自学教程：C++ ASSERT_STR_EQ函数代码示例

static voidtest_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_ENDTEST_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 voidtest_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}

static voidtest_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 voidtest_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 voidtest_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 voidtest_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 voidtest_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 voidtest_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--;    }}

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_ENDTEST_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();}

static voidtest_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;}