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

void TestCuStringNew(CuTest* tc){	CuString* str = CuStringNew();	CuAssertTrue(tc, 0 == str->length);	CuAssertTrue(tc, 0 != str->size);	CuAssertStrEquals(tc, "", str->buffer);}

void TestCuSuiteDetails_MultiplePasses(CuTest* tc){	CuSuite ts;	CuTest tc1, tc2;	CuString details;	const char* expected;	CuSuiteInit(&ts);	CuTestInit(&tc1, "TestPasses", TestPasses);	CuTestInit(&tc2, "TestPasses", TestPasses);	CuStringInit(&details);	CuSuiteAdd(&ts, &tc1);	CuSuiteAdd(&ts, &tc2);	CuSuiteRun(&ts);	CuSuiteDetails(&ts, &details);	CuAssertTrue(tc, ts.count == 2);	CuAssertTrue(tc, ts.failCount == 0);	expected =		"OK (2 tests)/n";	CuAssertStrEquals(tc, expected, details.buffer);}

static void test_move_illegal(CuTest * tc) {  void (*event_cb)(const char *, ...);  unit * u;  region * r, ** path;  svc.reset();  event_cb = svc.add_event;  svc.add_event = record_events;  num_events = 0;  r = svc.regions->create(0, 0);  u = svc.units->create();  svc.regions->add_unit(r, u);  kv_seti(&u->stats, "speed", 1);  path = malloc(sizeof(region *)*2);  path[0] = svc.regions->create(2, 0);  path[1] = 0;  u_set_moves(u, path);  svc.units->set_region(u, r);  do_movement();  CuAssertPtrEquals(tc, r, svc.units->get_region(u));  CuAssertIntEquals(tc, 1, num_events);  CuAssertStrEquals(tc, "illegal_move", events[0]);  svc.add_event = event_cb;}

void TestReverseWithShortString(CuTest *tc) {  DHString *string = dhstring_new("Hello world!");  dhstring_reverse_in_place(string);  const char *actual = dhstring_to_array(string);  const char *expected = "!dlrow olleH";  CuAssertStrEquals(tc, expected, actual);}

void TestCuStringAppendNULL(CuTest* tc){	CuString* str = CuStringNew();	CuStringAppend(str, NULL);	CuAssertIntEquals(tc, 4, str->length);	CuAssertStrEquals(tc, "NULL", str->buffer);}

void TestReverseWithEmptyString(CuTest *tc) {  DHString *string = dhstring_new("");  dhstring_reverse_in_place(string);  const char *actual = dhstring_to_array(string);  const char *expected = "";  CuAssertStrEquals(tc, expected, actual);}

void testSetNormalise(CuTest *tc) {	char* input;	char* expected;	setStatus ss;	// TODO: Boundary Case - Max number of chars	// TODO: Boundary Case - Max number of members	// Boundary Case - 29 chars - Should be OK	input = strdup("a i a i a i a e a i a a i a i");   expected = "a e i"; 	ss = setNormalise(input); CuAssertStrEquals(tc, expected, input); CuAssertIntEquals(tc, setOK, ss);	// Boundary Case - 30 chars - ON THE LIMIT - Should return setBadSet	input = strdup("a i a i a i a e a i a a i a ii");   expected = "a i a i a i a e a i a a i a ii";  // "a e i ii"; 	ss = setNormalise(input); CuAssertStrEquals(tc, expected, input); CuAssertIntEquals(tc, setBadSet, ss);	// Boundary Case - 9 members - Should be OK	input = strdup("j i h g e d c b a");   expected = "a b c d e g h i j"; 	ss = setNormalise(input); CuAssertStrEquals(tc, expected, input); CuAssertIntEquals(tc, setOK, ss);	// Boundary Case - 10 members - Should return setBadSet	input = strdup("j i h g e d c b a z");   expected = "a b c d e g h i j z"; 	ss = setNormalise(input); CuAssertStrEquals(tc, expected, input); CuAssertIntEquals(tc, setBadSet, ss);	input = strdup("a i a i h g f e d c b a i a i");   expected = "a b c d e f g h i"; ss = setNormalise(input);	CuAssertStrEquals(tc, expected, input); CuAssertIntEquals(tc, setOK, ss);	// General Case - duplicates and ordering	input = strdup("i h g f e d c b a");               expected ="a b c d e f g h i";ss = setNormalise(input);	CuAssertStrEquals(tc, expected, input); CuAssertIntEquals(tc, setOK, ss);	// General Case - duplicates and ordering	input = strdup("c c c c c c d a");                 expected = "a c d";           ss = setNormalise(input);	CuAssertStrEquals(tc, expected, input); CuAssertIntEquals(tc, setOK, ss);	// General Case - duplicates and ordering	input = strdup("beta alpha beta gamma alpha");     expected = "alpha beta gamma"; ss = setNormalise(input);	CuAssertStrEquals(tc, expected, input); CuAssertIntEquals(tc, setOK, ss);	// Boundary Case - empty set supplied	input = strdup("");                                expected = "";                 ss = setNormalise(input);	CuAssertStrEquals(tc, expected, input); CuAssertIntEquals(tc, setOK, ss);	// Exceptional Case - NULL supplied	input = NULL;                                      expected = NULL;               ss = setNormalise(input);	CuAssertStrEquals(tc, expected, input); CuAssertIntEquals(tc, setBadSet, ss);} //testSetNormalise

test_uri_norm_scheme_2(CuTest *tc){	char *seed = strdup("hTTp://www.example.com/test/func.cgi?x=y&z=j");	uriobj_t uri;	uri_parse(&uri, re, seed);	uri_norm_scheme(&uri);	CuAssertStrEquals(tc, *uri.uri_scheme, "http" );}

static void snprintf_underflow(CuTest *tc){    char buf[20];    int rv;    rv = apr_snprintf(buf, sizeof buf, "%.2f", (double)0.0001);    CuAssertIntEquals(tc, 4, rv);    CuAssertStrEquals(tc, "0.00", buf);        rv = apr_snprintf(buf, sizeof buf, "%.2f", (double)0.001);    CuAssertIntEquals(tc, 4, rv);    CuAssertStrEquals(tc, "0.00", buf);        rv = apr_snprintf(buf, sizeof buf, "%.2f", (double)0.01);    CuAssertIntEquals(tc, 4, rv);    CuAssertStrEquals(tc, "0.01", buf);}

static void test_json_write(CuTest * tc) {    char buf[256];    cJSON * json = cJSON_CreateObject();    stream strm;    mstream_init(&strm);    cJSON_AddNumberToObject(json, "turn", 1);    json_write(json, &strm);    strm.api->rewind(strm.handle);    strm.api->readln(strm.handle, buf, sizeof(buf));    CuAssertStrEquals(tc, "{", buf);    strm.api->readln(strm.handle, buf, sizeof(buf));    CuAssertStrEquals(tc, "/t/"turn/":/t1", buf);    strm.api->readln(strm.handle, buf, sizeof(buf));    CuAssertStrEquals(tc, "}", buf);    cJSON_Delete(json);    mstream_done(&strm);}

static void test_spellref(CuTest *tc){    spellref *ref;    spell *sp;    test_setup();    ref = spellref_create(NULL, "hodor");    CuAssertPtrNotNull(tc, ref);    CuAssertPtrEquals(tc, NULL, ref->sp);    CuAssertStrEquals(tc, "hodor", ref->_name);    CuAssertPtrEquals(tc, NULL, spellref_get(ref));    CuAssertStrEquals(tc, "hodor", spellref_name(ref));    sp = create_spell("hodor");    CuAssertPtrNotNull(tc, sp);    CuAssertPtrEquals(tc, sp, spellref_get(ref));    spellref_free(ref);    test_teardown();}

// -----------------------------------------------------------------------------// Test: codeblock_execute() -- simple codeblock// -----------------------------------------------------------------------------void test_codeblock_execute(CuTest *tc){    Codeblock* cb = codeblock_create();    cb->ast       = cb_conststr_create("test");        codeblock_execute(cb); // execute codeblock once        CuAssertIntEquals(tc, CB_VT_STRING, cb_value_get_type(cb->result));    CuAssertStrEquals(tc, "test",       cb_string_get(cb->result));        codeblock_execute(cb); // execute a second time        CuAssertIntEquals(tc, CB_VT_STRING, cb_value_get_type(cb->result));    CuAssertStrEquals(tc, "test",       cb_string_get(cb->result));        codeblock_free(cb);}

void Test_d_string_insert_printf(CuTest* tc) {	char * test = "foo";	DString * result = d_string_new(test);	d_string_insert_printf(result, 2, "%dbar%d", 5, 7);	CuAssertStrEquals(tc, "fo5bar7o", result->str);	CuAssertIntEquals(tc, 8, result->currentStringLength);	d_string_insert_printf(result, -1, "z", 5, 7);	CuAssertStrEquals(tc, "fo5bar7oz", result->str);	CuAssertIntEquals(tc, 9, result->currentStringLength);	d_string_insert_printf(NULL, 0, NULL);	d_string_free(result, true);}

void Test_d_string_prepend(CuTest* tc) {	char * test = "foo";	DString * result = d_string_new(test);	d_string_prepend(result, "bar");	CuAssertStrEquals(tc, "barfoo", result->str);	CuAssertIntEquals(tc, 6, result->currentStringLength);	d_string_prepend(result, NULL);	CuAssertStrEquals(tc, "barfoo", result->str);	CuAssertIntEquals(tc, 6, result->currentStringLength);	d_string_prepend(NULL, "bar");	d_string_free(result, true);}

test_uri_normalize_2(CuTest *tc){	char *expect = strdup("http://www.example.com/test/func.cgi?x=y&z=j");	uriobj_t uri;	uri_parse(&uri, re, expect);	int err = uri_normalize(&uri);	CuAssertStrEquals(tc,*uri.uri_host,"www.example.com");}

test_uri_norm_auth_4(CuTest *tc){	char *expect = strdup("http://www.example.com:8080/test/func.cgi?x=y&z=j");	uriobj_t uri;	uri_parse(&uri, re, expect);	int err = uri_norm_auth(&uri);	CuAssertStrEquals(tc,*uri.uri_port,"8080");}

void test_create_a_finite_automata(CuTest *tc){    setup();    CuAssertStrEquals(tc, "test", m->subject);    CuAssertIntEquals(tc, -1, m->initial_state);    CuAssertIntEquals(tc, NUMBER_STATES, m->nstates);    teardown();}

test_uri_normalize_1(CuTest *tc){	char *expect = strdup("http://192.168.1.100:8080/test/func.cgi?x=y&z=j");	uriobj_t uri;	uri_parse(&uri, re, expect);	int err = uri_normalize(&uri);	CuAssertStrEquals(tc,*uri.uri_ip,"192.168.1.100");}

void Test_d_string_append_c(CuTest* tc) {	char * test = "foo";	DString * result = d_string_new(test);	d_string_append_c(result, 'z');	CuAssertStrEquals(tc, "fooz", result->str);	CuAssertIntEquals(tc, 4, result->currentStringLength);	d_string_append_c(result, 0);	CuAssertStrEquals(tc, "fooz", result->str);	CuAssertIntEquals(tc, 4, result->currentStringLength);	d_string_append_c(NULL, 'f');	d_string_free(result, true);}

voidtest_grid_viewport_tree(CuTest *tc) {    grid_context_t *gr = new_grid_context(100, 100);    grid_viewport_t *apple = new_grid_default_viewport();    grid_push_named_viewport(gr, "apple", apple);    CuAssertTrue(tc, gr->root_node != gr->current_node);    CuAssertStrEquals(tc, gr->current_node->name, "apple");    CuAssertPtrEquals(tc, gr->root_node->child, gr->current_node);    CuAssertPtrEquals(tc, gr->current_node->parent, gr->root_node);    grid_viewport_t *banana = new_grid_default_viewport();    grid_viewport_t *carrot = new_grid_default_viewport();    grid_push_named_viewport(gr, "banana", banana);    grid_up_viewport_1(gr);    grid_push_named_viewport(gr, "carrot", carrot);    CuAssertStrEquals(tc, "carrot", gr->current_node->name);    CuAssertStrEquals(tc, "banana", gr->current_node->gege->name);    CuAssertStrEquals(tc, "carrot", gr->current_node->gege->didi->name);    CuAssertStrEquals(tc, "apple", gr->current_node->parent->name);    bool result = grid_pop_viewport_1(gr);    CuAssertTrue(tc, result);    CuAssertStrEquals(tc, "apple", gr->current_node->name);    CuAssertStrEquals(tc, "banana", gr->current_node->child->name);    CuAssertPtrEquals(tc, NULL, gr->current_node->child->didi);    int n = grid_down_viewport(gr, "durian");    CuAssertIntEquals(tc, -1, n);    CuAssertStrEquals(tc, "apple", gr->current_node->name);    n = grid_down_viewport(gr, "banana");    CuAssertIntEquals(tc, 1, n);    CuAssertStrEquals(tc, "banana", gr->current_node->name);    grid_push_named_viewport(gr, "carrot", carrot);    n = grid_down_viewport(gr, "banana");    CuAssertIntEquals(tc, -1, n);    n = grid_seek_viewport(gr, "banana");    CuAssertIntEquals(tc, 2, n);    CuAssertStrEquals(tc, "banana", gr->current_node->name);    free_grid_context(gr);}

void Test_sh_tools_safe_name_04(CuTest *tc) {  /* invalid and valid octal code */  char* input = strdup("hello///n");  char* actual = sh_tools_safe_name(input, 0);  char* expected = "hello";  CuAssertStrEquals(tc, expected, actual);  input = strdup("hello//100");  actual = sh_tools_safe_name(input, 0);  expected = "hello=40";  CuAssertStrEquals(tc, expected, actual);  input = strdup("h///"ello//100a");  actual = sh_tools_safe_name(input, 0);  expected = "h=22ello=40a";  CuAssertStrEquals(tc, expected, actual);}

void test_user_groups_retrieves_users_groups(CuTest *tc){    char **groups;    setup();    groups = user_get_groups("bob", "first");    CuAssertPtrNotNull(tc, groups);    CuAssertStrEquals(tc, "admin", groups[0]);    CuAssertStrEquals(tc, "user", groups[1]);    /* This assertion ensures that groups come from a single     * animal.     */    CuAssertPtrEquals(tc, NULL, groups[2]);    teardown();}

void testSetUnion(CuTest *tc) {	char* input1;	char* input2;	char* expected;	set setU;	input1 = strdup("");  input2=strdup("a c b");  expected = "a b c"; 	setU = setUnion(input1, input2); CuAssertStrEquals(tc, expected, setU); 	input1 = strdup("a b c");  input2=strdup("");  expected = "a b c"; 	setU = setUnion(input1, input2); CuAssertStrEquals(tc, expected, setU); 	input1 = strdup("a b c");  input2=NULL;  expected = NULL; 	setU = setUnion(input1, input2); CuAssertStrEquals(tc, expected, setU); 	input1 = NULL;  input2=strdup("c b a");  expected = NULL; 	setU = setUnion(input1, input2); CuAssertStrEquals(tc, expected, setU); 	// Boundary case - 9 members in result - should be OK	input1 = strdup("i h g f p a z");  input2=strdup("i h g f e d");  expected = "a d e f g h i p z"; 	setU = setUnion(input1, input2); CuAssertStrEquals(tc, expected, setU); 	// Boundary case - 10 members in result which is ON THE LIMIT, and therefore should return NULL	input1 = strdup("i h g f p a z x");  input2=strdup("i h g f e d");  expected = NULL;	setU = setUnion(input1, input2); CuAssertStrEquals(tc, expected, setU); 	// Boundary case - 12 members in result which is OVER THE LIMIT, and therefore should return NULL	input1 = strdup("i h g f p a z x");  input2=strdup("i h g f e d w y");  expected = NULL; //"a d e f g h i p w x y z"; 	setU = setUnion(input1, input2); CuAssertStrEquals(tc, expected, setU); } //testSetUnion

void check_tokens(CuTest *tc, token_t *head, char *expected[], int expected_len) {	int i = 0;	while (head) {		CuAssertStrEquals(tc, expected[i], head->token);		head = head->next;		i++;	}	CuAssertIntEquals(tc, expected_len, i);}

static void testLookupByName(CuTest *tc) {    struct netcf_if *nif;    nif = ncf_lookup_by_name(ncf, "br0");    CuAssertPtrNotNull(tc, nif);    CuAssertStrEquals(tc, "br0", nif->name);    ncf_if_free(nif);    CuAssertIntEquals(tc, 1, ncf->ref);}

static void test_parse_maketemp(CuTest *tc) {    char cmd[32];    order *ord;    struct locale * lang = get_or_create_locale("en");    locale_setstring(lang, keyword(K_MAKE), "MAKE");    locale_setstring(lang, keyword(K_MAKETEMP), "MAKETEMP");    locale_setstring(lang, "TEMP", "TEMP");    init_locale(lang);    ord = parse_order("MAKET herp", lang);    CuAssertPtrNotNull(tc, ord);    CuAssertStrEquals(tc, "MAKETEMP herp", get_command(ord, cmd, sizeof(cmd)));    CuAssertIntEquals(tc, K_MAKETEMP, getkeyword(ord));    CuAssertIntEquals(tc, K_MAKETEMP, init_order(ord));    CuAssertStrEquals(tc, "herp", getstrtoken());    free_order(ord);}

void Test_d_string_append(CuTest* tc) {	char * test = "foo";	DString * result = d_string_new(test);	d_string_append(result, "bar");	CuAssertStrEquals(tc, "foobar", result->str);	d_string_append(result, "");	CuAssertStrEquals(tc, "foobar", result->str);	d_string_append(result, NULL);	CuAssertStrEquals(tc, "foobar", result->str);	d_string_append(NULL, "foo");	d_string_free(result, true);}

 void check(CuTest* tc, const TCHAR* input, const TCHAR* expected) {   StandardTokenizer* tokenStream = new StandardTokenizer(new StringReader(input));   GermanStemFilter filter(tokenStream, true);   Token t;   if (filter.next(&t) == NULL)     CuFail(tc, _T("Token expected!"));   CuAssertStrEquals(tc, _T(""), expected, t.termBuffer());   filter.close(); }

void test_reverse1_to_reverse_the_string_itself(CuTest *tc){    /*     * The string block "str" is readonly on  C, so we must     * create an "array" of chars with null char at end     */    char text1[] = { 'b', 'u', 't', '/0' };    char text2[] = { 'd', 'o', '/0' };        CuAssertStrEquals(tc, "but", text1);    CuAssertStrEquals(tc, "do", text2);        reverse1(text1);    reverse1(text2);        CuAssertStrEquals(tc, "tub", text1);    CuAssertStrEquals(tc, "od", text2);}