libucore/test/test_bcd.c

#include <check.h>
#include "ucore/string.h"


START_TEST (test_2bcd_1234567890)
{
    char ascii[] = "1234567890";
    unsigned char bcd[5];
    size_t len = uc_ascii2bcd(ascii, bcd, 0);

    ck_assert_int_eq(len, 5);
    ck_assert_int_eq(bcd[0], 0x21);
    ck_assert_int_eq(bcd[1], 0x43);
    ck_assert_int_eq(bcd[2], 0x65);
    ck_assert_int_eq(bcd[3], 0x87);
    ck_assert_int_eq(bcd[4], 0x09);
}
END_TEST

START_TEST (test_2bcd_empty)
{
    char ascii[] = "";
    unsigned char bcd[1];
    size_t len = uc_ascii2bcd(ascii, bcd, 3);

    ck_assert_int_eq(len, 0);
}
END_TEST

START_TEST (test_2bcd_1_filler)
{
    char ascii[] = "1";
    unsigned char bcd[1];
    size_t len = uc_ascii2bcd(ascii, bcd, 0xa);

    ck_assert_int_eq(len, 1);
    ck_assert_int_ne(bcd[0], 0);
}
END_TEST

START_TEST (test_2bcd_2_filler)
{
    char ascii[] = "123";
    unsigned char bcd[2];
    size_t len = uc_ascii2bcd(ascii, bcd, 0xf);

    ck_assert_int_eq(len , 2);
    ck_assert_int_eq(bcd[0] , 0x21);
    ck_assert_int_eq(bcd[1] , 0xf3);
    ck_assert_int_eq(UC_BCD_LEN(strlen(ascii)) , len);
}
END_TEST

START_TEST (test_2bcd_3_filler)
{

    char ascii[] = "123";
    unsigned char bcd[2];
    size_t len = uc_ascii2bcd(ascii, bcd, 0x0);

    ck_assert_int_eq(len , 2);
    ck_assert_int_eq(bcd[0] , 0x21);
    ck_assert_int_eq(bcd[1] , 0x03);
}
END_TEST

START_TEST (test_2bcd_non_digits)
{

    char ascii[] = "a,b{  }=";
    unsigned char bcd[10];
    size_t len = uc_ascii2bcd(ascii, bcd, 0x0);

    ck_assert_int_eq(len , 0);
}
END_TEST

START_TEST (test_2bcd_phoneno)
{

    char ascii[] = "0047-3233-4";
    unsigned char bcd[24];
    size_t len = uc_ascii2bcd(ascii, bcd, 0xf);

    ck_assert_int_eq(len , 5);
    ck_assert_int_eq(bcd[0] , 0x00);
    ck_assert_int_eq(bcd[1] , 0x74);
    ck_assert_int_eq(bcd[2] , 0x23);
    ck_assert_int_eq(bcd[3] , 0x33);
    ck_assert_int_eq(bcd[4] , 0xf4);
}
END_TEST

START_TEST (test_2bcd_binary)
{

    char ascii[] = {0x32,0x01,0xAF,0xFF,0x00};
    unsigned char bcd[24];
    size_t len = uc_ascii2bcd(ascii, bcd, 0xf);

    ck_assert_int_eq(len , 1);
    ck_assert_int_eq(bcd[0], 0xf2);
}
END_TEST

START_TEST (test_2hex_1)
{

    unsigned char bcd[] = {0x21, 0x43 };
    char ascii[sizeof bcd * 2 + 1];
    size_t len = uc_bcd2ascii(bcd, sizeof bcd, ascii);

    ck_assert_int_eq(len, 4);
    ck_assert_int_eq(ascii[0], '1');
    ck_assert_int_eq(ascii[1], '2');
    ck_assert_int_eq(ascii[2], '3');
    ck_assert_int_eq(ascii[3], '4');
    ck_assert_int_eq(ascii[4],  0);
    ck_assert_int_eq(UC_ASCII_LEN(sizeof bcd) , len);
}
END_TEST

START_TEST (test_2hex_2)
{

    unsigned char bcd[] = {0xF0, 0xFF, 0x00};
    char ascii[sizeof bcd * 2 + 1];
    size_t len = uc_bcd2ascii(bcd, sizeof bcd, ascii);

    ck_assert_int_eq(len , 6);
    ck_assert_int_eq(ascii[0] , '0');
    ck_assert_int_eq(ascii[1] , 'F');
    ck_assert_int_eq(ascii[2] , 'F');
    ck_assert_int_eq(ascii[3] , 'F');
    ck_assert_int_eq(ascii[4] , '0');
    ck_assert_int_eq(ascii[5] , '0');
    ck_assert_int_eq(ascii[6] ,  0);
}
END_TEST

START_TEST (test_2hex_empty)
{

    unsigned char bcd[] = {0xF0, 0xFF, 0x00};
    char ascii[sizeof bcd * 2 + 1];
    ascii[0] = 0xFF;
    size_t len = uc_bcd2ascii(bcd, 0, ascii);

    ck_assert_int_eq(len, 0);
    ck_assert_int_eq(ascii[0],  0);
}
END_TEST

Suite *bcd_suite(void)
{
    Suite *s = suite_create("bcd");
    TCase *tc = tcase_create("bcd tests");
    tcase_add_test(tc, test_2bcd_1234567890);
    tcase_add_test(tc, test_2bcd_empty);
    tcase_add_test(tc, test_2bcd_1_filler);
    tcase_add_test(tc, test_2bcd_2_filler);
    tcase_add_test(tc, test_2bcd_3_filler);
    tcase_add_test(tc, test_2bcd_non_digits);
    tcase_add_test(tc, test_2bcd_phoneno);
    tcase_add_test(tc, test_2bcd_binary);

    tcase_add_test(tc, test_2hex_1);
    tcase_add_test(tc, test_2hex_2);
    tcase_add_test(tc, test_2hex_empty);

    suite_add_tcase(s, tc);

    return s;
}