implement TC language code short format.

git-svn-id: http://svn.sourceforge.jp/svnroot/bchan/bchanf/trunk@593 20a0b8eb-f62a-4a12-8fe1-b598822500fb

diff --git a/src/tad/tadlangcode.c b/src/tad/tadlangcode.c
new file mode 100644 (file)
index 0000000..71fa6a0
--- /dev/null
+++ b/src/tad/tadlangcode.c
@@ -0,0 +1,161 @@
+/*
+ * tadlangcode.c
+ *
+ * Copyright (c) 2013 project bchan
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source
+ *    distribution.
+ *
+ */
+
+#include       "tadlangcode.h"
+
+#include       <bstdio.h>
+
+#ifdef BCHAN_CONFIG_DEBUG
+# define DP(arg) printf arg
+# define DP_ER(msg, err) printf("%s (%d/%x)\n", msg, err>>16, err)
+#else
+# define DP(arg) /**/
+# define DP_ER(msg, err) /**/
+#endif
+
+EXPORT TADLANGCODE_PARSER_RESULT tadlangcode_parser_inputchar(tadlangcode_parser_t *parser, TC ch)
+{
+       switch (parser->state) {
+       case TADLANGCODE_PARSER_STATE_START:
+               if ((ch & 0xFF00) != 0xFE00) {
+                       return TADLANGCODE_PARSER_RESULT_INVALID;
+               }
+               if (ch == 0xFEFE) {
+                       parser->state = TADLANGCODE_PARSER_STATE_LANGCODE;
+                       parser->iter = 1;
+                       return TADLANGCODE_PARSER_RESULT_CONTINUE;
+               }
+               parser->state = TADLANGCODE_PARSER_STATE_DETERMINED;
+               parser->iter = 0;
+               parser->code = ch & 0xFF;
+               return TADLANGCODE_PARSER_RESULT_DETERMINED;
+       case TADLANGCODE_PARSER_STATE_LANGCODE:
+               if (ch == 0xFEFE) {
+                       parser->iter += 2;
+                       return TADLANGCODE_PARSER_RESULT_CONTINUE;
+               }
+               if ((ch & 0xFF00) == 0x0000) {
+                       parser->state = TADLANGCODE_PARSER_STATE_DETERMINED;
+                       parser->code = ch & 0xFF;
+                       return TADLANGCODE_PARSER_RESULT_DETERMINED;
+               }
+               if ((ch & 0xFF00) == 0xFE00) {
+                       parser->state = TADLANGCODE_PARSER_STATE_DETERMINED;
+                       parser->iter += 1;
+                       parser->code = ch & 0xFF;
+                       return TADLANGCODE_PARSER_RESULT_DETERMINED;
+               }
+               return TADLANGCODE_PARSER_RESULT_INVALID;
+       case TADLANGCODE_PARSER_STATE_DETERMINED:
+               return TADLANGCODE_PARSER_RESULT_INVALID;
+       }
+       return TADLANGCODE_PARSER_RESULT_INVALID;
+}
+
+EXPORT W tadlangcode_parser_getlangcode(tadlangcode_parser_t *parser, tadlangcode *langcode)
+{
+       if (parser->state != TADLANGCODE_PARSER_STATE_DETERMINED) {
+               return -1; /* TODO */
+       }
+       langcode->iter = parser->iter;
+       langcode->code = parser->code;
+       return 0;
+}
+
+EXPORT VOID tadlangcode_parser_initialize(tadlangcode_parser_t *parser)
+{
+       parser->state = TADLANGCODE_PARSER_STATE_START;
+       parser->iter = 0;
+       parser->code = 0;
+}
+
+EXPORT VOID tadlangcode_parser_finalize(tadlangcode_parser_t *parser)
+{
+}
+
+EXPORT W tadlangcodetoTC(tadlangcode *src, TC *dest, W dest_len)
+{
+       W i, req_len;
+
+       req_len = 2 + (src->iter+1)/2*2;
+
+       if (dest == NULL || dest_len < 0) {
+               return req_len / sizeof(TC);
+       }
+
+       for (i = 0; i < (src->iter + 1) / 2; i++) {
+               dest[i] = 0xFEFE;
+       }
+       if (src->iter % 2 == 1) {
+               dest[i] = src->code;
+       } else {
+               dest[i] = 0xFE00 | src->code;
+       }
+
+       return req_len / sizeof(TC);
+}
+
+EXPORT W TCtotadlangcode(TC *src, W src_len, tadlangcode *dest)
+{
+       tadlangcode_parser_t parser;
+       W i, err;
+       TADLANGCODE_PARSER_RESULT result;
+
+       tadlangcode_parser_initialize(&parser);
+
+       for (i = 0; i < src_len; i++) {
+               result = tadlangcode_parser_inputchar(&parser, src[i]);
+               if (result == TADLANGCODE_PARSER_RESULT_DETERMINED) {
+                       break;
+               }
+       }
+
+       err = tadlangcode_parser_getlangcode(&parser, dest);
+
+       tadlangcode_parser_finalize(&parser);
+
+       return err;
+}
+
+EXPORT Bool tadlangcodecmpTC(TC *str, W len, tadlangcode *langcode)
+{
+       W err;
+       tadlangcode lang;
+
+       err = TCtotadlangcode(str, len, &lang);
+       if (err < 0) {
+               return False;
+       }
+       return tadlangcodecmp(&lang, langcode);
+}
+
+EXPORT Bool tadlangcodecmp(tadlangcode *langcode1, tadlangcode *langcode2)
+{
+       if ((langcode1->iter == langcode2->iter)&&(langcode1->code == langcode2->code)) {
+               return True;
+       }
+       return False;
+}

diff --git a/src/tad/tadlangcode.h b/src/tad/tadlangcode.h
new file mode 100644 (file)
index 0000000..5c1902e
--- /dev/null
+++ b/src/tad/tadlangcode.h
@@ -0,0 +1,75 @@
+/*
+ * tadlangcode.h
+ *
+ * Copyright (c) 2013 project bchan
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source
+ *    distribution.
+ *
+ */
+
+/* Vendor name: */
+/* Functionality name: tadlangcode */
+/* Detail name: */
+
+#include    <basic.h>
+
+#ifndef __TADLANGCODE_H__
+#define __TADLANGCODE_H__
+
+struct tadlangcode_ {
+       UW iter;
+       UB code;
+};
+typedef struct tadlangcode_ tadlangcode;
+
+IMPORT W tadlangcodetoTC(tadlangcode *src, TC *dest, W dest_len);
+IMPORT W TCtotadlangcode(TC *src, W src_len, tadlangcode *dest);
+IMPORT Bool tadlangcodecmpTC(TC *str, W len, tadlangcode *langcode);
+IMPORT Bool tadlangcodecmp(tadlangcode *langcode1, tadlangcode *langcode2);
+
+/* Functionality name: tadlangcode */
+/* Detail name: parser */
+struct tadlangcode_parser_t_ {
+       enum {
+               TADLANGCODE_PARSER_STATE_START,
+               TADLANGCODE_PARSER_STATE_LANGCODE,
+               TADLANGCODE_PARSER_STATE_DETERMINED,
+       } state;
+       UW iter;
+       UB code;
+};
+typedef struct tadlangcode_parser_t_ tadlangcode_parser_t;
+
+/* Functionality name: tadlangcode */
+/* Detail name: parser */
+/* Data structure identifier: result */
+enum TADLANGCODE_PARSER_RESULT_ {
+       TADLANGCODE_PARSER_RESULT_CONTINUE,
+       TADLANGCODE_PARSER_RESULT_INVALID,
+       TADLANGCODE_PARSER_RESULT_DETERMINED,
+};
+typedef enum TADLANGCODE_PARSER_RESULT_ TADLANGCODE_PARSER_RESULT;
+
+IMPORT VOID tadlangcode_parser_initialize(tadlangcode_parser_t *parser);
+IMPORT VOID tadlangcode_parser_finalize(tadlangcode_parser_t *parser);
+IMPORT TADLANGCODE_PARSER_RESULT tadlangcode_parser_inputchar(tadlangcode_parser_t *parser, TC ch);
+IMPORT W tadlangcode_parser_getlangcode(tadlangcode_parser_t *parser, tadlangcode *langcode);
+
+#endif

diff --git a/src/tad/test_tadlangcode.c b/src/tad/test_tadlangcode.c
new file mode 100644 (file)
index 0000000..89e90d2
--- /dev/null
+++ b/src/tad/test_tadlangcode.c
@@ -0,0 +1,389 @@
+/*
+ * test_tadlangcode.c
+ *
+ * Copyright (c) 2013 project bchan
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source
+ *    distribution.
+ *
+ */
+
+#include "test_tad.h"
+
+#include "tadlangcode.h"
+
+#include       <basic.h>
+#include       <bstdio.h>
+#include       <bstdlib.h>
+#include       <bstring.h>
+#include       <tstring.h>
+
+#include    <unittest_driver.h>
+
+LOCAL UNITTEST_RESULT test_TCtotadlangcode_common(TC *testdata, W testdata_len, tadlangcode *expected)
+{
+       W err;
+       Bool cmp;
+       tadlangcode result;
+
+       err = TCtotadlangcode(testdata, testdata_len, &result);
+       if (err < 0) {
+               return UNITTEST_RESULT_FAIL;
+       }
+       cmp = tadlangcodecmp(&result, expected);
+       if (cmp == False) {
+               return UNITTEST_RESULT_FAIL;
+       }
+       return UNITTEST_RESULT_PASS;
+}
+
+LOCAL UNITTEST_RESULT test_TCtotadlangcode_1()
+{
+       TC testdata[] = {0xFE21};
+       W testdata_len = 1;
+       tadlangcode expected = {0, 0x21};
+       return test_TCtotadlangcode_common(testdata, testdata_len, &expected);
+}
+
+LOCAL UNITTEST_RESULT test_TCtotadlangcode_2()
+{
+       TC testdata[] = {0xFE22};
+       W testdata_len = 1;
+       tadlangcode expected = {0, 0x22};
+       return test_TCtotadlangcode_common(testdata, testdata_len, &expected);
+}
+
+LOCAL UNITTEST_RESULT test_TCtotadlangcode_3()
+{
+       TC testdata[] = {0xFEFE, 0xFE21};
+       W testdata_len = 2;
+       tadlangcode expected = {2, 0x21};
+       return test_TCtotadlangcode_common(testdata, testdata_len, &expected);
+}
+
+LOCAL UNITTEST_RESULT test_TCtotadlangcode_4()
+{
+       TC testdata[] = {0xFEFE, 0x0021};
+       W testdata_len = 2;
+       tadlangcode expected = {1, 0x21};
+       return test_TCtotadlangcode_common(testdata, testdata_len, &expected);
+}
+
+LOCAL UNITTEST_RESULT test_TCtotadlangcode_5()
+{
+       TC testdata[] = {0xFEFE, 0xFEFE, 0xFE21};
+       W testdata_len = 3;
+       tadlangcode expected = {4, 0x21};
+       return test_TCtotadlangcode_common(testdata, testdata_len, &expected);
+}
+
+LOCAL UNITTEST_RESULT test_TCtotadlangcode_6()
+{
+       TC testdata[] = {0xFEFE, 0xFEFE, 0x0021};
+       W testdata_len = 3;
+       tadlangcode expected = {3, 0x21};
+       return test_TCtotadlangcode_common(testdata, testdata_len, &expected);
+}
+
+LOCAL UNITTEST_RESULT test_tadlangcodetoTC_common(tadlangcode *testdata, TC *expected, W expected_len)
+{
+       W len;
+       TC *str;
+
+       len = tadlangcodetoTC(testdata, NULL, 1);
+       if (len != expected_len) {
+               printf("tadlangcodetoTC length check 1 error\n");
+               return UNITTEST_RESULT_FAIL;
+       }
+
+       str = malloc(sizeof(TC)*len);
+       if (str == NULL) {
+               return UNITTEST_RESULT_FAIL;
+       }
+
+       len = tadlangcodetoTC(testdata, str, -1);
+       if (len != expected_len) {
+               free(str);
+               printf("tadlangcodetoTC length check 2 error\n");
+               return UNITTEST_RESULT_FAIL;
+       }
+
+       len = tadlangcodetoTC(testdata, str, len);
+       if (len != expected_len) {
+               free(str);
+               printf("tadlangcodetoTC converted length error\n");
+               return UNITTEST_RESULT_FAIL;
+       }
+       if (tc_strncmp(str, expected, len) != 0) {
+               free(str);
+               printf("tadlangcodetoTC convarted string error\n");
+               return UNITTEST_RESULT_FAIL;
+       }
+
+       free(str);
+
+       return UNITTEST_RESULT_PASS;
+}
+
+LOCAL UNITTEST_RESULT test_tadlangcodetoTC_1()
+{
+       tadlangcode testdata = {0, 0x21};
+       TC expected[] = {0xFE21};
+       W expected_len = 1;
+       return test_tadlangcodetoTC_common(&testdata, expected, expected_len);
+}
+
+LOCAL UNITTEST_RESULT test_tadlangcodetoTC_2()
+{
+       tadlangcode testdata = {0, 0x22};
+       TC expected[] = {0xFE22};
+       W expected_len = 1;
+       return test_tadlangcodetoTC_common(&testdata, expected, expected_len);
+}
+
+LOCAL UNITTEST_RESULT test_tadlangcodetoTC_3()
+{
+       tadlangcode testdata = {2, 0x21};
+       TC expected[] = {0xFEFE, 0xFE21};
+       W expected_len = 2;
+       return test_tadlangcodetoTC_common(&testdata, expected, expected_len);
+}
+
+LOCAL UNITTEST_RESULT test_tadlangcodetoTC_4()
+{
+       tadlangcode testdata = {1, 0x21};
+       TC expected[] = {0xFEFE, 0x0021};
+       W expected_len = 2;
+       return test_tadlangcodetoTC_common(&testdata, expected, expected_len);
+}
+
+LOCAL UNITTEST_RESULT test_tadlangcodetoTC_5()
+{
+       tadlangcode testdata = {4, 0x21};
+       TC expected[] = {0xFEFE, 0xFEFE, 0xFE21};
+       W expected_len = 3;
+       return test_tadlangcodetoTC_common(&testdata, expected, expected_len);
+}
+
+LOCAL UNITTEST_RESULT test_tadlangcodetoTC_6()
+{
+       tadlangcode testdata = {3, 0x21};
+       TC expected[] = {0xFEFE, 0xFEFE, 0x0021};
+       W expected_len = 3;
+       return test_tadlangcodetoTC_common(&testdata, expected, expected_len);
+}
+
+LOCAL UNITTEST_RESULT test_tadlangcodecmpTC_common(tadlangcode *testdata1, TC *testdata2, W testdata2_len, Bool expected)
+{
+       Bool ret;
+       UNITTEST_RESULT result = UNITTEST_RESULT_PASS;
+
+       ret = tadlangcodecmpTC(testdata2, testdata2_len, testdata1);
+       if (ret == False) {
+               if (expected != False) {
+                       result = UNITTEST_RESULT_FAIL;
+               }
+       } else {
+               if (expected == False) {
+                       result = UNITTEST_RESULT_FAIL;
+               }
+       }
+
+       return result;
+}
+
+LOCAL UNITTEST_RESULT test_tadlangcodecmpTC_1()
+{
+       tadlangcode testdata1 = {0, 0x21};
+       TC testdata2[] = {0xFE21};
+       W testdata2_len = 1;
+       Bool expected = True;
+       return test_tadlangcodecmpTC_common(&testdata1, testdata2, testdata2_len, expected);
+}
+
+LOCAL UNITTEST_RESULT test_tadlangcodecmpTC_2()
+{
+       tadlangcode testdata1 = {0, 0x22};
+       TC testdata2[] = {0xFE22};
+       W testdata2_len = 1;
+       Bool expected = True;
+       return test_tadlangcodecmpTC_common(&testdata1, testdata2, testdata2_len, expected);
+}
+
+LOCAL UNITTEST_RESULT test_tadlangcodecmpTC_3()
+{
+       tadlangcode testdata1 = {2, 0x21};
+       TC testdata2[] = {0xFEFE, 0xFE21};
+       W testdata2_len = 2;
+       Bool expected = True;
+       return test_tadlangcodecmpTC_common(&testdata1, testdata2, testdata2_len, expected);
+}
+
+LOCAL UNITTEST_RESULT test_tadlangcodecmpTC_4()
+{
+       tadlangcode testdata1 = {1, 0x21};
+       TC testdata2[] = {0xFEFE, 0x0021};
+       W testdata2_len = 2;
+       Bool expected = True;
+       return test_tadlangcodecmpTC_common(&testdata1, testdata2, testdata2_len, expected);
+}
+
+LOCAL UNITTEST_RESULT test_tadlangcodecmpTC_5()
+{
+       tadlangcode testdata1 = {4, 0x21};
+       TC testdata2[] = {0xFEFE, 0xFEFE, 0xFE21};
+       W testdata2_len = 3;
+       Bool expected = True;
+       return test_tadlangcodecmpTC_common(&testdata1, testdata2, testdata2_len, expected);
+}
+
+LOCAL UNITTEST_RESULT test_tadlangcodecmpTC_6()
+{
+       tadlangcode testdata1 = {3, 0x21};
+       TC testdata2[] = {0xFEFE, 0xFEFE, 0x0021};
+       W testdata2_len = 3;
+       Bool expected = True;
+       return test_tadlangcodecmpTC_common(&testdata1, testdata2, testdata2_len, expected);
+}
+
+LOCAL UNITTEST_RESULT test_tadlangcodecmpTC_7()
+{
+       tadlangcode testdata1 = {0, 0x21};
+       TC testdata2[] = {0xFE22};
+       W testdata2_len = 1;
+       Bool expected = False;
+       return test_tadlangcodecmpTC_common(&testdata1, testdata2, testdata2_len, expected);
+}
+
+LOCAL UNITTEST_RESULT test_tadlangcodecmpTC_8()
+{
+       tadlangcode testdata1 = {2, 0x21};
+       TC testdata2[] = {0xFEFE, 0xFE22};
+       W testdata2_len = 2;
+       Bool expected = False;
+       return test_tadlangcodecmpTC_common(&testdata1, testdata2, testdata2_len, expected);
+}
+
+LOCAL UNITTEST_RESULT test_tadlangcodecmpTC_9()
+{
+       tadlangcode testdata1 = {4, 0x21};
+       TC testdata2[] = {0xFEFE, 0xFEFE, 0xFE22};
+       W testdata2_len = 3;
+       Bool expected = False;
+       return test_tadlangcodecmpTC_common(&testdata1, testdata2, testdata2_len, expected);
+}
+
+LOCAL UNITTEST_RESULT test_tadlangcodecmp_common(tadlangcode *testdata1, tadlangcode *testdata2, Bool expected)
+{
+       Bool ret;
+       UNITTEST_RESULT result = UNITTEST_RESULT_PASS;
+
+       ret = tadlangcodecmp(testdata1, testdata2);
+       if (ret == False) {
+               if (expected != False) {
+                       result = UNITTEST_RESULT_FAIL;
+               }
+       } else {
+               if (expected == False) {
+                       result = UNITTEST_RESULT_FAIL;
+               }
+       }
+
+       return result;
+}
+
+LOCAL UNITTEST_RESULT test_tadlangcodecmp_1()
+{
+       tadlangcode testdata1 = {0, 0x21};
+       tadlangcode testdata2 = {0, 0x21};
+       Bool expected = True;
+       return test_tadlangcodecmp_common(&testdata1, &testdata2, expected);
+}
+
+
+LOCAL UNITTEST_RESULT test_tadlangcodecmp_2()
+{
+       tadlangcode testdata1 = {0, 0x21};
+       tadlangcode testdata2 = {0, 0x22};
+       Bool expected = False;
+       return test_tadlangcodecmp_common(&testdata1, &testdata2, expected);
+}
+
+LOCAL UNITTEST_RESULT test_tadlangcodecmp_3()
+{
+       tadlangcode testdata1 = {0, 0x21};
+       tadlangcode testdata2 = {1, 0x21};
+       Bool expected = False;
+       return test_tadlangcodecmp_common(&testdata1, &testdata2, expected);
+}
+
+LOCAL UNITTEST_RESULT test_tadlangcodecmp_4()
+{
+       tadlangcode testdata1 = {1, 0x21};
+       tadlangcode testdata2 = {1, 0x21};
+       Bool expected = True;
+       return test_tadlangcodecmp_common(&testdata1, &testdata2, expected);
+}
+
+LOCAL UNITTEST_RESULT test_tadlangcodecmp_5()
+{
+       tadlangcode testdata1 = {1, 0x21};
+       tadlangcode testdata2 = {1, 0x22};
+       Bool expected = False;
+       return test_tadlangcodecmp_common(&testdata1, &testdata2, expected);
+}
+
+LOCAL UNITTEST_RESULT test_tadlangcodecmp_6()
+{
+       tadlangcode testdata1 = {1, 0x21};
+       tadlangcode testdata2 = {2, 0x21};
+       Bool expected = False;
+       return test_tadlangcodecmp_common(&testdata1, &testdata2, expected);
+}
+
+EXPORT VOID test_tadlangcode_main(unittest_driver_t *driver)
+{
+       UNITTEST_DRIVER_REGIST(driver, test_TCtotadlangcode_1);
+       UNITTEST_DRIVER_REGIST(driver, test_TCtotadlangcode_2);
+       UNITTEST_DRIVER_REGIST(driver, test_TCtotadlangcode_3);
+       UNITTEST_DRIVER_REGIST(driver, test_TCtotadlangcode_4);
+       UNITTEST_DRIVER_REGIST(driver, test_TCtotadlangcode_5);
+       UNITTEST_DRIVER_REGIST(driver, test_TCtotadlangcode_6);
+       UNITTEST_DRIVER_REGIST(driver, test_tadlangcodetoTC_1);
+       UNITTEST_DRIVER_REGIST(driver, test_tadlangcodetoTC_2);
+       UNITTEST_DRIVER_REGIST(driver, test_tadlangcodetoTC_3);
+       UNITTEST_DRIVER_REGIST(driver, test_tadlangcodetoTC_4);
+       UNITTEST_DRIVER_REGIST(driver, test_tadlangcodetoTC_5);
+       UNITTEST_DRIVER_REGIST(driver, test_tadlangcodetoTC_6);
+       UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmpTC_1);
+       UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmpTC_2);
+       UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmpTC_3);
+       UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmpTC_4);
+       UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmpTC_5);
+       UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmpTC_6);
+       UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmpTC_7);
+       UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmpTC_8);
+       UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmpTC_9);
+       UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmp_1);
+       UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmp_2);
+       UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmp_3);
+       UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmp_4);
+       UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmp_5);
+       UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmp_6);
+}