static void test_append_from_base16(void) { struct sol_buffer buf; struct sol_str_slice slice; const char to_decode[] = "546573742001090a0f2048656c6c6f"; int err; #define B16_DECODED "Test \x01\x09\x0a\x0f Hello" sol_buffer_init(&buf); slice = sol_str_slice_from_str("XYZ"); err = sol_buffer_append_slice(&buf, slice); ASSERT_INT_EQ(err, 0); ASSERT_INT_EQ(buf.used, strlen("XYZ")); ASSERT_STR_EQ(buf.data, "XYZ"); slice = sol_str_slice_from_str(to_decode); err = sol_buffer_append_from_base16(&buf, slice, SOL_DECODE_LOWERCASE); ASSERT_INT_EQ(err, 0); ASSERT_INT_EQ(buf.used, strlen("XYZ" B16_DECODED)); ASSERT_STR_EQ(buf.data, "XYZ" B16_DECODED); sol_buffer_fini(&buf); #undef B16_DECODED }
static void test_getset_parameter_node_value (abts_case *tc, void *data) { cwmp_t * c = (cwmp_t*)data; parameter_node_t * param; char * name = "InternetGatewayDevice.DeviceInfo.SoftwareVersion"; char * retval; char * value ; pool_t * pool = pool_create(POOL_DEFAULT_SIZE); FUNCTION_TRACE(); param = cwmp_get_parameter_path_node(c->root, name); ASSERT_NOTNULL(param); value = "V1.3.x"; cwmp_set_parameter_node_value(c, param, name, value, strlen(value)); retval = cwmp_data_get_parameter_value(c, param, name, pool); printf("retval ------------------is %s\n", retval); ASSERT_STR_EQ(value, retval); value = "V1.4.x"; cwmp_set_parameter_node_value(c, param, name, value, strlen(value)); retval = cwmp_data_get_parameter_value(c, param, name, pool); ASSERT_STR_EQ(value, retval); pool_destroy(pool); }
TEST_END TEST_START(pushes_buf_kv) { clax_kv_list_t list; clax_kv_list_init(&list); clax_kv_list_pushn(&list, "foo", 3, "bar", 3); ASSERT_EQ(list.size, 1); ASSERT_STR_EQ(clax_kv_list_find(&list, "foo"), "bar"); clax_kv_list_pushn(&list, "", 0, "bar", 3); ASSERT_EQ(list.size, 2); ASSERT_STR_EQ(clax_kv_list_find(&list, ""), "bar"); clax_kv_list_pushn(&list, "baz", 3, "", 0); ASSERT_EQ(list.size, 3); ASSERT_STR_EQ(clax_kv_list_find(&list, "baz"), ""); clax_kv_list_pushn(&list, "", 0, "", 0); ASSERT_EQ(list.size, 4); size_t start = 3; ASSERT_STR_EQ(clax_kv_list_find_all(&list, "", &start), ""); clax_kv_list_free(&list); }
static void test_insert_as_base16(void) { struct sol_buffer buf; struct sol_str_slice slice; const char to_encode[] = "Test \x01\x09\x0a\x0f Hello"; int err; #define B16_ENCODED "546573742001090a0f2048656c6c6f" sol_buffer_init(&buf); slice = sol_str_slice_from_str("World"); err = sol_buffer_insert_slice(&buf, 0, slice); ASSERT_INT_EQ(err, 0); ASSERT_INT_EQ(buf.used, strlen("World")); ASSERT_STR_EQ(buf.data, "World"); slice = sol_str_slice_from_str("Hello"); err = sol_buffer_insert_slice(&buf, 0, slice); ASSERT_INT_EQ(err, 0); ASSERT_INT_EQ(buf.used, strlen("HelloWorld")); ASSERT_STR_EQ(buf.data, "HelloWorld"); slice = sol_str_slice_from_str(to_encode); err = sol_buffer_insert_as_base16(&buf, strlen("Hello"), slice, false); ASSERT_INT_EQ(err, 0); ASSERT_INT_EQ(buf.used, strlen("Hello" B16_ENCODED "World")); ASSERT_STR_EQ(buf.data, "Hello" B16_ENCODED "World"); sol_buffer_fini(&buf); #undef B16_ENCODED }
TEST_END TEST_START(finds_all_kv) { size_t start = 0; clax_kv_list_t list; clax_kv_list_init(&list); ASSERT(clax_kv_list_find_all(&list, "foo", &start) == NULL); ASSERT_EQ(start, 0); start = 100; ASSERT(clax_kv_list_find_all(&list, "foo", &start) == NULL); ASSERT_EQ(start, 100); clax_kv_list_push(&list, "foo", "bar"); clax_kv_list_push(&list, "bar", "baz"); clax_kv_list_push(&list, "bar", "zab"); start = 0; ASSERT_STR_EQ(clax_kv_list_find_all(&list, "foo", &start), "bar"); ASSERT_EQ(start, 1); ASSERT(clax_kv_list_find_all(&list, "foo", &start) == NULL); ASSERT(clax_kv_list_find_all(&list, "foo", &start) == NULL); start = 0; ASSERT_STR_EQ(clax_kv_list_find_all(&list, "bar", &start), "baz"); ASSERT_STR_EQ(clax_kv_list_find_all(&list, "bar", &start), "zab"); ASSERT(clax_kv_list_find_all(&list, "bar", &start) == NULL); ASSERT(clax_kv_list_find_all(&list, "bar", &start) == NULL); clax_kv_list_free(&list); }
static void test_insert_as_base64(void) { struct sol_buffer buf; struct sol_str_slice slice; const char to_encode[] = "This is a message that is multiple of 3 chars"; int err; #define B64_ENCODED "VGhpcyBpcyBhIG1lc3NhZ2UgdGhhdCBpcyBtdWx0aXBsZSBvZiAzIGNoYXJz" sol_buffer_init(&buf); slice = sol_str_slice_from_str("World"); err = sol_buffer_insert_slice(&buf, 0, slice); ASSERT_INT_EQ(err, 0); ASSERT_INT_EQ(buf.used, strlen("World")); ASSERT_STR_EQ(buf.data, "World"); slice = sol_str_slice_from_str("Hello"); err = sol_buffer_insert_slice(&buf, 0, slice); ASSERT_INT_EQ(err, 0); ASSERT_INT_EQ(buf.used, strlen("HelloWorld")); ASSERT_STR_EQ(buf.data, "HelloWorld"); slice = sol_str_slice_from_str(to_encode); err = sol_buffer_insert_as_base64(&buf, strlen("Hello"), slice, SOL_BASE64_MAP); ASSERT_INT_EQ(err, 0); ASSERT_INT_EQ(buf.used, strlen("Hello" B64_ENCODED "World")); ASSERT_STR_EQ(buf.data, "Hello" B64_ENCODED "World"); sol_buffer_fini(&buf); #undef B64_ENCODED }
static void test_append_from_base64(void) { struct sol_buffer buf; struct sol_str_slice slice; const char to_decode[] = "VGhpcyBpcyBhIG1lc3NhZ2UgdGhhdCBpcyBtdWx0aXBsZSBvZiAzIGNoYXJz"; int err; #define B64_DECODED "This is a message that is multiple of 3 chars" sol_buffer_init(&buf); slice = sol_str_slice_from_str("XYZ"); err = sol_buffer_append_slice(&buf, slice); ASSERT_INT_EQ(err, 0); ASSERT_INT_EQ(buf.used, strlen("XYZ")); ASSERT_STR_EQ(buf.data, "XYZ"); slice = sol_str_slice_from_str(to_decode); err = sol_buffer_append_from_base64(&buf, slice, SOL_BASE64_MAP); ASSERT_INT_EQ(err, 0); ASSERT_INT_EQ(buf.used, strlen("XYZ" B64_DECODED)); ASSERT_STR_EQ(buf.data, "XYZ" B64_DECODED); sol_buffer_fini(&buf); #undef B64_DECODED }
static void test_insert_slice(void) { struct sol_buffer buf; struct sol_str_slice slice; int err; sol_buffer_init(&buf); slice = sol_str_slice_from_str("World"); err = sol_buffer_insert_slice(&buf, 0, slice); ASSERT_INT_EQ(err, 0); ASSERT_INT_EQ(buf.used, strlen("World")); ASSERT_STR_EQ(buf.data, "World"); slice = sol_str_slice_from_str("Hello"); err = sol_buffer_insert_slice(&buf, 0, slice); ASSERT_INT_EQ(err, 0); ASSERT_INT_EQ(buf.used, strlen("HelloWorld")); ASSERT_STR_EQ(buf.data, "HelloWorld"); slice = sol_str_slice_from_str(" -*- "); err = sol_buffer_insert_slice(&buf, strlen("Hello"), slice); ASSERT_INT_EQ(err, 0); ASSERT_INT_EQ(buf.used, strlen("Hello -*- World")); ASSERT_STR_EQ(buf.data, "Hello -*- World"); sol_buffer_fini(&buf); }
static void test_set_slice(void) { struct sol_buffer buf; struct sol_str_slice slice; const char *str = "Hello"; char *backend; int err; backend = strdup(str); slice = sol_str_slice_from_str(backend); sol_buffer_init(&buf); err = sol_buffer_set_slice(&buf, slice); ASSERT(err >= 0); ASSERT_INT_EQ(buf.used, strlen(backend)); ASSERT_STR_EQ(buf.data, backend); backend[1] = 'a'; ASSERT_STR_NE(buf.data, backend); ASSERT_STR_EQ(buf.data, str); sol_buffer_fini(&buf); free(backend); }
TEST test_large_map(void) { struct mushroom_map *map = mushroom_map_new(); ASSERT_EQ_FMT((size_t)0, mushroom_map_get_count(map), "%zu"); int key_number = 300; for (int i = 0; i < key_number; i++) { char key[10]; sprintf(key, "key-%d", i); mushroom_map_put(map, key, key); } char *value = mushroom_map_get(map, "key-9"); ASSERT(value != NULL); ASSERT_STR_EQ("key-9", value); for (int i = 0; i < key_number; i++) { char key[10]; sprintf(key, "key-%d", i); mushroom_map_put(map, key, key); value = mushroom_map_get(map, key); ASSERT(value != NULL); ASSERT_STR_EQ(key, value); } value = mushroom_map_get(map, "key-9"); ASSERT(value != NULL); ASSERT_STR_EQ("key-9", value); ASSERT_EQ_FMT((size_t)300, mushroom_map_get_count(map), "%zu"); mushroom_map_free(map); PASS(); }
TEST(ZXTestCAssertionTest, AssertStrEq) { const char* str1 = "a"; const char* str2 = "a"; EXPECT_STR_EQ(str1, str2, "ASSERT_STR_EQ failed to identify equal strings."); EXPECT_STR_EQ(str1, str1, "ASSERT_STR_EQ failed to identify equal strings."); ASSERT_STR_EQ(str1, str2, "ASSERT_STR_EQ failed to identify equal strings."); ASSERT_STR_EQ(str1, str1, "ASSERT_STR_EQ failed to identify equal strings."); // No failures ZX_ASSERT_MSG(!_ZXTEST_ABORT_IF_ERROR, "Assert was did not abort test."); }
TEST write_flushes_multiple_times(void) { enum status s; s = NORM_INIT(h); ASSERT_EQ(status_ok, s); char b[] = "hello$me$how$are$you?"; s = buf_write(&h, b, sizeof(b)); ASSERT_STR_EQ("hello$me$how$are$", (char *)flush_buffer); ASSERT_STR_EQ("you?", (char *)buffer); PASS(); }
TEST write_flushes_on_terminator(void) { enum status s; s = NORM_INIT(h); ASSERT_EQ(status_ok, s); char b[] = "hello$ me"; s = buf_write(&h, b, sizeof(b)); ASSERT_STR_EQ("hello$", (char *)flush_buffer); ASSERT_STR_EQ(" me", (char *)buffer); PASS(); }
TEST close_works(void) { char b[] = "hello"; ASSERT_EQ(status_ok, NORM_INIT(h)); ASSERT_EQ(status_ok, buf_write(&h, b, sizeof(b))); ASSERT_STR_EQ("", (char *)flush_buffer); ASSERT_STR_EQ("hello", (char *)buffer); ASSERT_EQ(status_ok, buf_close(&h)); ASSERT_STR_EQ("hello", (char *)flush_buffer); PASS(); };
TEST write_flushes_on_multi_char_term(void) { enum status s; s = MULT_INIT(h); ASSERT_EQ(status_ok, s); char b[] = "hello^me^@how are you?"; s = buf_write(&h, b, sizeof(b)); ASSERT_STR_EQ("hello^me^@", (char *)flush_buffer); ASSERT_STR_EQ("how are you?", (char *)buffer); PASS(); }
TEST write_flushes_when_out_of_space(void) { enum status s; s = CUST_BLEN_INIT(h, 5); ASSERT_EQ(status_ok, s); char b[] = "hello me"; s = buf_write(&h, b, sizeof(b)); ASSERT_EQ(status_ok, s); ASSERT_STR_EQ("hello", (char *)flush_buffer); ASSERT_STR_EQ(" me", (char *)buffer); PASS(); }
TEST serialize(void) { sl2_t a, b; unsigned char bufa[256] = {0}; char bufb[256], bufc[256]; int i; for (i = 0; i < 1024; i++) { sl2_rand(a); sl2_serialize(a, bufa); sl2_unserialize(b, bufa); ASSERT_STR_EQ(gf2p127_hex(bufb, a[0][0]), gf2p127_hex(bufc, b[0][0])); ASSERT_STR_EQ(gf2p127_hex(bufb, a[0][1]), gf2p127_hex(bufc, b[0][1])); ASSERT_STR_EQ(gf2p127_hex(bufb, a[1][0]), gf2p127_hex(bufc, b[1][0])); ASSERT_STR_EQ(gf2p127_hex(bufb, a[1][1]), gf2p127_hex(bufc, b[1][1])); } PASS(); }
TEST multiplication_special_bit_right(void) { sl2_t a, b, m[2]; char bufa[1024], bufb[1024]; int i; sl2_init(m); for (i = 0; i < 1024; i++) { sl2_rand(a); sl2_mul(b, a, m[i % 2]); sl2_mul_bit_right(&a[0][0], &a[0][1], &a[1][0], &a[1][1], _mm_load_si128(&minmax[i % 2])); ASSERT_STR_EQ(gf2p127_hex(bufa, a[0][0]), gf2p127_hex(bufb, b[0][0])); ASSERT_STR_EQ(gf2p127_hex(bufa, a[0][1]), gf2p127_hex(bufb, b[0][1])); ASSERT_STR_EQ(gf2p127_hex(bufa, a[1][0]), gf2p127_hex(bufb, b[1][0])); ASSERT_STR_EQ(gf2p127_hex(bufa, a[1][1]), gf2p127_hex(bufb, b[1][1])); } PASS(); }
/* tests all conditions which should hold when reading to the end of the file. */ int test_dbfr_getline_2() { dbfr_t *reader = dbfr_open(TEST_FILENAME); ssize_t retval; int i = 0; char expected[80]; unittest_has_error = 0; ASSERT_TRUE(reader != NULL, "dbfr_open: return non-null"); if (! reader) { return 1; } while (i < LINES_IN_TEST_FILE) { i++; dbfr_getline(reader); ASSERT_LONG_EQ(i, reader->line_no, "dbfr_getline: line_no incremented"); } ASSERT_TRUE(reader->current_line != NULL, "current_line not NULL at EOF"); ASSERT_TRUE(reader->next_line == NULL, "next_line NULL at EOF"); sprintf(expected, "this is line %d\n", LINES_IN_TEST_FILE); ASSERT_STR_EQ(expected, reader->current_line, "current_line intact at EOF"); retval = dbfr_getline(reader); ASSERT_LONG_GT(0, retval, "dbfr_getline() returns < 0 at EOF"); ASSERT_TRUE(reader->eof, "dbfr_t.eof set at EOF"); dbfr_close(reader); return 0; }
static void test_remove_data(void) { struct sol_buffer buf; struct sol_str_slice slice; int err; sol_buffer_init(&buf); slice = sol_str_slice_from_str("ABCDEFGHI"); err = sol_buffer_append_slice(&buf, slice); ASSERT_INT_EQ(err, 0); ASSERT_INT_EQ(buf.used, strlen("ABCDEFGHI")); ASSERT_STR_EQ(buf.data, "ABCDEFGHI"); err = sol_buffer_remove_data(&buf, strlen("ABC"), 0); ASSERT_INT_EQ(err, 0); ASSERT_INT_EQ(buf.used, strlen("DEFGHI")); err = sol_buffer_remove_data(&buf, strlen("GHI"), 3); ASSERT_INT_EQ(err, 0); ASSERT_INT_EQ(buf.used, strlen("DEF")); err = sol_buffer_remove_data(&buf, strlen("DEF"), 0); ASSERT_INT_EQ(err, 0); ASSERT_INT_EQ(buf.used, 0); err = sol_buffer_remove_data(&buf, 100, 0); ASSERT_INT_EQ(err, 0); ASSERT_INT_EQ(buf.used, 0); err = sol_buffer_remove_data(&buf, 0, 100); ASSERT_INT_EQ(err, -EINVAL); sol_buffer_fini(&buf); }
static bool basic_test(void) { BEGIN_TEST; zx::socket client, server; ASSERT_EQ(ZX_OK, zx::socket::create(ZX_SOCKET_HAS_CONTROL, &client, &server)); async_loop_t* loop = nullptr; ASSERT_EQ(ZX_OK, async_loop_create(&kAsyncLoopConfigNoAttachToThread, &loop), ""); ASSERT_EQ(ZX_OK, async_loop_start_thread(loop, "spaceship-dispatcher", nullptr), ""); async_dispatcher_t* dispatcher = async_loop_get_dispatcher(loop); ASSERT_EQ(ZX_OK, fidl_bind_socket(dispatcher, server.release(), reinterpret_cast<fidl_dispatch_t*>(fidl_test_fakesocket_Control_dispatch), nullptr, &kOps)); ASSERT_EQ(ZX_OK, fidl_test_fakesocket_ControlBind(client.get(), "xy", 2u)); char buffer[64]; memset(buffer, 0, sizeof(buffer)); size_t actual = 0u; ASSERT_EQ(ZX_OK, fidl_test_fakesocket_ControlGetPeerAddr(client.get(), 5, buffer, sizeof(buffer), &actual)); ASSERT_EQ(3u, actual); buffer[3] = '\0'; ASSERT_STR_EQ("abc", buffer); client.reset(); async_loop_destroy(loop); END_TEST; }
static void test_base64_encode(void) { const char base64_map[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; const char instr[] = "This is a message that is multiple of 3 chars"; const char *expectstrs[] = { "VGhpcyBpcyBhIG1lc3NhZ2UgdGhhdCBpcyBtdWx0aXBsZSBvZiAzIGNoYXJz", "VGhpcyBpcyBhIG1lc3NhZ2UgdGhhdCBpcyBtdWx0aXBsZSBvZiAzIGNoYXI=", "VGhpcyBpcyBhIG1lc3NhZ2UgdGhhdCBpcyBtdWx0aXBsZSBvZiAzIGNoYQ==", "VGhpcyBpcyBhIG1lc3NhZ2UgdGhhdCBpcyBtdWx0aXBsZSBvZiAzIGNo" }; struct sol_str_slice slice; char outstr[(sizeof(instr) / 3 + 1) * 4 + 1]; size_t r, i; slice = sol_str_slice_from_str(instr); for (i = 0; i < SOL_UTIL_ARRAY_SIZE(expectstrs); i++) { struct sol_str_slice exp = sol_str_slice_from_str(expectstrs[i]); memset(outstr, 0xff, sizeof(outstr)); r = sol_util_base64_encode(outstr, sizeof(outstr), slice, base64_map); ASSERT_INT_EQ(r, exp.len); ASSERT_INT_EQ(outstr[r], (char)0xff); outstr[r] = '\0'; ASSERT_STR_EQ(outstr, exp.data); slice.len--; } }
TEST_END TEST_START(sets_new_val) { clax_kv_list_t list; clax_kv_list_init(&list); clax_kv_list_set(&list, "foo", "bar"); ASSERT_STR_EQ(clax_kv_list_find(&list, "foo"), "bar"); clax_kv_list_set(&list, "foo", "baz"); ASSERT_STR_EQ(clax_kv_list_find(&list, "foo"), "baz"); clax_kv_list_free(&list); }
void assert_parse_package(const char* package_name, const char* java_text) { JavaDocStructure* java_doc = parse_text(java_text, TRUE, FALSE); ASSERT_NOT_NULL(java_doc); ASSERT_NOT_NULL(java_doc->package_declaration); ASSERT_STR_EQ(package_name, java_doc->package_declaration->package_name); java_doc_free(java_doc); }
TEST_END TEST_START(parses_basic_auth) { opt options; clax_options_init(&options); char *argv[] = {"clax", "-n", "-r", ".", "-a", "foo:bar"}; int ret = clax_parse_options(&options, sizeof_array(argv), argv); ASSERT_EQ(ret, 0); ASSERT_STR_EQ(options.basic_auth_username, "foo"); ASSERT_STR_EQ(options.basic_auth_password, "bar"); clax_options_free(&options); }
TEST ibwt_bacabba() { char *input = "bcbbaaa"; char output[8]; ibwt(input, output, 4, 7); output[7] = '\0'; ASSERT_STR_EQ("bacabba", output); PASS(); }
TEST ibwt_abracadabra() { char *input = "rdarcaaaabb"; char output[12]; ibwt(input, output, 2, 11); output[11] = '\0'; ASSERT_STR_EQ("abracadabra", output); PASS(); }
TEST_END TEST_START(parses_ssl_options) { opt options; clax_options_init(&options); char *argv[] = {"clax", "-r", ".", "-t", "ssl/server.crt", "-p", "ssl/server.key"}; int ret = clax_parse_options(&options, sizeof_array(argv), argv); ASSERT_EQ(ret, 0) ASSERT_EQ(options.no_ssl, 0) ASSERT_EQ(options.no_ssl_verify, 0) ASSERT_STR_EQ(options.cert_file, "ssl/server.crt") ASSERT_STR_EQ(options.key_file, "ssl/server.key") clax_options_free(&options); }
static void test_simple_SOL_MEMDESC_TYPE_STRING(void) { const struct sol_memdesc desc = { SOL_SET_API_VERSION(.api_version = SOL_MEMDESC_API_VERSION, ) .type = SOL_MEMDESC_TYPE_STRING, .defcontent.s = "hello world" }; char *a, *b; const char *c; int r; r = sol_memdesc_init_defaults(&desc, &a); ASSERT_INT_EQ(r, 0); ASSERT(a != desc.defcontent.s); ASSERT_STR_EQ(a, "hello world"); r = sol_memdesc_init_defaults(&desc, &b); ASSERT_INT_EQ(r, 0); ASSERT(b != desc.defcontent.s); ASSERT_STR_EQ(b, "hello world"); r = sol_memdesc_compare(&desc, &a, &b); ASSERT_INT_EQ(r, 0); ASSERT_INT_EQ(errno, 0); c = "other string"; r = sol_memdesc_set_content(&desc, &a, &c); ASSERT_INT_EQ(r, 0); ASSERT(a != c); ASSERT_STR_EQ(a, "other string"); r = sol_memdesc_compare(&desc, &a, &c); ASSERT_INT_EQ(r, 0); ASSERT_INT_EQ(errno, 0); r = sol_memdesc_compare(&desc, &a, &b); ASSERT(r > 0); sol_memdesc_free_content(&desc, &a); sol_memdesc_free_content(&desc, &b); }
/* tests all conditions which should hold after reading the first line of the file. */ int test_dbfr_getline_1() { dbfr_t *reader = dbfr_open(TEST_FILENAME); ssize_t retval; unittest_has_error = 0; ASSERT_TRUE(reader != NULL, "dbfr_open: return non-null"); if (! reader) { return 1; } retval = dbfr_getline(reader); ASSERT_LONG_EQ(strlen("this is line 1\n"), retval, "dbfr_getline: return string length"); ASSERT_LONG_EQ(1, reader->line_no, "dbfr_getline: increment line_no"); ASSERT_STR_EQ("this is line 1\n", reader->current_line, "dbfr_getline: initialize current_line"); ASSERT_STR_EQ("this is line 2\n", reader->next_line, "dbfr_getline: initialize next_line"); dbfr_close(reader); return unittest_has_error; }