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

ssize_t hncp_io_sendto(hncp o, void *buf, size_t len,                       const char *ifname,                       const struct in6_addr *dst){  if (check_send)    {      sput_fail_unless(o, "hncp");      sput_fail_unless(o && o->udp_socket == 1, "hncp_io ready");      smock_pull_string_is("sendto_ifname", ifname);      struct in6_addr *e_dst = smock_pull("sendto_dst");      sput_fail_unless(e_dst && memcmp(e_dst, dst, sizeof(*dst)) == 0, "dst match");      /* Two optional verification steps.. */      if (_smock_get_queue("sendto_len", false))        {          int r_len = smock_pull_int("sendto_len");          sput_fail_unless(r_len == (int) len, "len");        }      if (_smock_get_queue("sendto_buf", false))        {          unsigned char *r = smock_pull("sendto_buf");          sput_fail_unless(memcmp(r, buf, len), "buf");        }      return smock_pull_int("sendto_return");    }  else    {      want_send++;      return 1;    }}

static void test_intlist_removeall(void){    intlist_t list = intlist_construct(10);    /* Initialize list to [0, 2, 4, 6, 8] */    for (int i = 0; i < 5; i++) {        list = intlist_append(list, 2 * i);    }    list = intlist_removeall(list);    sput_fail_unless(intlist_size(list) == 0,                     "list = intlist_construct(10),/n"                     "Initialized list to [0 2 4 6 8],/n"                     "list = intlist_removeall(list)/n"                     "Verifying list size is now 0");    sput_fail_unless(intlist_capacity(list) == 10,                     "Verifying list capacity remains 10");    sput_fail_unless(list.elems != NULL,                     "Verifying list.elems != NULL");    intlist_destroy(list);}

static void test_increase_capacity(void){    /* Initialize a new list to [4, 7, 3, -2, 9] */    intlist_t list = intlist_construct(5);    list = intlist_append(list, 4);    list = intlist_append(list, 7);    list = intlist_append(list, 3);    list = intlist_append(list, -2);    list = intlist_append(list, 9);    int *old_array = list.elems;    /* Increase the list's capacity from 5 to 10. */    list = increase_capacity(list, 10);    sput_fail_unless(list.capacity == 10,                     "list = intlist_construct(10);/n"                     "Initialized list to [4 7 3 -2 9]/n"                     "list = increase_capacity(list, 10)/n"                     "Verifying list capacity increased from 5 to 10");    sput_fail_unless(list.elems != old_array,                     "Verifying that a new array was allocated");    int expected[] = {4, 7, 3, -2, 9};    sput_fail_unless(compare_arrays(list.elems, expected, 5),                     "Verifying that list still contains [4 7 3 -2 9]");    intlist_destroy(list);}

void test_histogram__capacity(void){	static const size_t HISTO_CAP = USHRT_MAX;	struct brubeck_histo h;	struct brubeck_histo_sample sample;	size_t j;	memset(&h, 0x0, sizeof(h));	for (j = 0; j < HISTO_CAP + 500; ++j)		brubeck_histo_push(&h, (double)(j + 1), 1.0);	sput_fail_unless(h.size == HISTO_CAP, "histogram size");	sput_fail_unless(h.count == (HISTO_CAP + 500), "histogram value count");	brubeck_histo_sample(&sample, &h);	sput_fail_unless(sample.min == 1.0, "sample.min");	sput_fail_unless(sample.max == (double)HISTO_CAP, "sample.max");	sput_fail_unless(sample.count == (HISTO_CAP + 500), "sample.count");	for (j = 0; j < HISTO_CAP + 500; ++j)		brubeck_histo_push(&h, (double)(j + 1), 10.0);	sput_fail_unless(h.size == HISTO_CAP, "histogram size");	sput_fail_unless(h.count == ((HISTO_CAP + 500) * 10), "histogram value count");	brubeck_histo_sample(&sample, &h);	sput_fail_unless(sample.min == 1.0, "sample.min");	sput_fail_unless(sample.max == (double)HISTO_CAP, "sample.max");	sput_fail_unless(sample.count == ((HISTO_CAP + 500) * 10), "sample.count");}

    void secure_comparator_test(){      std::string shared_secret_a("shared_secret");      std::string shared_secret_b("shared_secret");      themispp::secure_comparator_t a(STR_2_VEC(shared_secret_a));      themispp::secure_comparator_t b(STR_2_VEC(shared_secret_b));            std::vector<uint8_t> buf;            buf=a.init();      buf=b.proceed(buf);      buf=a.proceed(buf);      buf=b.proceed(buf);      buf=a.proceed(buf);            sput_fail_unless(a.get(), "a ready", __LINE__);          sput_fail_unless(b.get(), "b ready", __LINE__);      std::string shared_secret_c("shared_secret_c");      std::string shared_secret_d("shared_secret_d");      themispp::secure_comparator_t c(STR_2_VEC(shared_secret_c));      themispp::secure_comparator_t d(STR_2_VEC(shared_secret_d));      buf=c.init();      buf=d.proceed(buf);      buf=c.proceed(buf);      buf=d.proceed(buf);      buf=c.proceed(buf);            sput_fail_unless(!(c.get()), "c ready", __LINE__);          sput_fail_unless(!(d.get()), "d ready", __LINE__);    }

static void test_intlist_get(void){    intlist_t list = intlist_construct(10);    /* Initialize list to [0, 2, 4, 6, 8] */    for (int i = 0; i < 5; i++) {        list = intlist_append(list, 2 * i);    }    sput_fail_unless(intlist_get(list, 0) == 0,                     "list = intlist_construct(10),/n"                     "Initialized list to [0 2 4 6 8],/n"		             "Verifying intlist_get(list, 0) returns 0");    sput_fail_unless(intlist_get(list, 1) == 2,                     "Verifying intlist_get(list, 1) returns 2");    sput_fail_unless(intlist_get(list, 2) == 4,                     "Verifying intlist_get(list, 2) returns 4");    sput_fail_unless(intlist_get(list, 3) == 6,                     "Verifying intlist_get(list, 3) returns 6");    sput_fail_unless(intlist_get(list, 4) == 8,                     "Verifying intlist_get(list, 4) returns 8");    intlist_destroy(list);}

    void secure_session_test(){      std::string mes("the test message");      callback client_callbacks;      std::string client_id("client");      std::string server_id("server");            themispp::secure_session_t client(std::vector<uint8_t>(client_id.c_str(), client_id.c_str()+client_id.length()), std::vector<uint8_t>(client_priv, client_priv+sizeof(client_priv)), &client_callbacks);      callback server_callbacks;      themispp::secure_session_t server(std::vector<uint8_t>(server_id.c_str(), server_id.c_str()+server_id.length()), std::vector<uint8_t>(server_priv, server_priv+sizeof(server_priv)), &server_callbacks);      std::vector<uint8_t> control_msg1=client.init();      std::vector<uint8_t> control_msg2=server.unwrap(control_msg1);      std::vector<uint8_t> control_msg3=client.unwrap(control_msg2);      std::vector<uint8_t> control_msg4=server.unwrap(control_msg3);      std::vector<uint8_t> control_msg5=client.unwrap(control_msg4);      sput_fail_unless(server.is_established(), "server ready", __LINE__);      sput_fail_unless(client.is_established(), "client ready", __LINE__);      std::vector<uint8_t> msg1=client.wrap(std::vector<uint8_t>(mes.c_str(), mes.c_str()+mes.length()+1));      std::vector<uint8_t> msg2=server.unwrap(msg1);      sput_fail_unless(strcmp(mes.c_str(), (const char*)(&msg2[0]))==0, "server get message", __LINE__);      std::vector<uint8_t> msg3=server.wrap(std::vector<uint8_t>(mes.c_str(), mes.c_str()+mes.length()+1));      std::vector<uint8_t> msg4=client.unwrap(msg3);      sput_fail_unless(strcmp(mes.c_str(), (const char*)(&msg4[0]))==0, "client get message", __LINE__);    }

void dncp_ext_readable(dncp o){  char buf[1024];  size_t len = sizeof(buf);  int r;  struct sockaddr_in6 *src, *dst;  dncp_ep ep;  int flags;  r = o->ext->cb.recv(o->ext, &ep, &src, &dst, &flags, buf, len);  smock_pull_int_is("dncp_poll_io_recvfrom", r);  if (r >= 0)    {      void *b = smock_pull("dncp_poll_io_recvfrom_buf");      char *ifn = smock_pull("dncp_poll_io_recvfrom_ifname");      struct sockaddr_in6 *esrc = smock_pull("dncp_poll_io_recvfrom_src");      struct sockaddr_in6 *edst = smock_pull("dncp_poll_io_recvfrom_dst");      sput_fail_unless(memcmp(b, buf, r)==0, "buf mismatch");      sput_fail_unless(strcmp(ifn, ep->ifname) == 0, "ifname mismatch");      sput_fail_unless(memcmp(src, esrc, sizeof(*src))==0, "src mismatch");      sput_fail_unless(memcmp(&dst->sin6_addr,                              &edst->sin6_addr, sizeof(dst->sin6_addr))==0,                       "dst mismatch");      if (!--pending_packets)        uloop_end();    }}

static void test_modified_intlist_append(void){    int expected[] = {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20};    /* Construct a list with capacity 10 and fill it. */    intlist_t list = intlist_construct(10);    for (int i = 0; i < 10; i += 1) {        list = intlist_append(list, i * 2);    }    /* Now append an integer to the full list.*/    list = intlist_append(list, 20);    sput_fail_unless(compare_arrays(list.elems, expected, 11),                     "list = intlist_construct(10);/n"		             "Initialized list to [0 2 4 6 8 10 12 14 16 18]/n"                     "list = intlist_append(list, 20);/n"		             "Verifying list is now [0 2 4 6 8 10 12 14 16 18 20]");    sput_fail_unless(list.size == 11,                     "Verifying list size is now 11");    sput_fail_unless(list.capacity == 20,                     "Verifying list capacity is now 20");    intlist_destroy(list);}

bool hncp_io_set_ifname_enabled(hncp o, const char *ifname, bool enabled){  sput_fail_unless(o, "hncp");  sput_fail_unless(o && o->udp_socket == 1, "hncp_io ready");  smock_pull_string_is("set_enable_ifname", ifname);  smock_pull_bool_is("set_enable_enabled", enabled);  return smock_pull_bool("set_enable_result");}

static void dummy_node_cb(hncp_subscriber s, hncp_node n, bool add){  L_NOTICE("node callback %s %s",           HNCP_NODE_REPR(n), add ? "add" : "remove");  sput_fail_unless(s, "subscriber provided");  sput_fail_unless(s->node_change_callback == dummy_node_cb, "node cb set");  sput_fail_unless(n, "node set");  smock_pull_bool_is("node_callback", add);}

void TestAddMemory()	{    GameProperties testGame;    testGame = createGame();    addMemory(100);    sput_fail_unless(getAvailableMemory() == 100,"Adding MEmory");    sput_fail_unless(addMemory(-100) == 0,"Adding Negative Memory");    free(testGame);}

void CreateGameTest()	{    GameProperties testGame;    testGame = getGame(NULL);    sput_fail_unless(getAvailableMemory() == 1000,"Initializing Memory");    //sput_fail_unless(getWave(testGame) == 3,"Initializing WaveNo");    sput_fail_unless(getTotalWaveNo() == 3,"Total Wave Number set to 3 from level file");    sput_fail_unless(getHealth(testGame) == 100,"Initializing Health");}

void testlastAction()	{    GameProperties newGame = getGame(NULL);    delayGame(ACTIONCOOLDOWN);    sput_fail_unless(lastAction(newGame) == 1,"Checking delay more than Cooldown returns true");    delayGame(ACTIONCOOLDOWN-1);    sput_fail_unless(lastAction(newGame) == 0,"Checking delay less than Cooldown returns false");}

void testSetLastAction()	{    GameProperties newGame = getGame(NULL);    clock_t currTime = clock()/CLOCKS_PER_SEC;    delayGame(2);    sput_fail_unless(setlastAction(newGame) == (currTime + 2),"Setting Last Action to current time");    delayGame(2);    sput_fail_unless(setlastAction(newGame) == (currTime + 4),"Setting Last Action to current time");}

void testStartNextWave()	{    setCurrWaveNum(getGame(NULL)->currWaveNo+1);    increaseEnemyNumbersThisWave(10);    getGame(NULL)->deathCount = 0;    sput_fail_unless(startNextWave() == 0, "Invalid: 10 enemies have not registered as dead yet");    getGame(NULL)->deathCount = 10;    sput_fail_unless(startNextWave() == 1, "Valid: 10 enemies have registered as dead");}

static void try_parse(struct brubeck_statsd_msg *msg, const char *msg_text, int expect_parse, double expected){	char buffer[64];	strcpy(buffer, msg_text);	sput_fail_unless(brubeck_statsd_msg_parse(msg, buffer) == expect_parse, msg_text);	if(0 == expect_parse) {		sput_fail_unless(expected == msg->value.n, "msg.value.n == expected");	}}

void CreateGameTest()	{	GameProperties testGame;	testGame = createGame();	sput_fail_if((createGame()) == NULL,"Creating Game");	sput_fail_unless(getAvailableMemory(testGame) == 0,"Initializing Memory");	sput_fail_unless(getWave(testGame) == 0,"Initializing WaveNo");	sput_fail_unless(getHealth(testGame) == 0,"Initializing Health");	free(testGame);}

void TestUseMemory()	{    GameProperties testGame;    testGame = createGame();    testGame->totalMemory = 100;    useMemory(testGame,50);    sput_fail_unless(getAvailableMemory() == 50,"Subtracting Memory");    sput_fail_unless(useMemory(testGame,100) == 0,"Subtracting too much Memory");    free(testGame);}

static void try_parse_set(struct brubeck_statsd_msg *msg, const char *msg_text, int expect_parse, const char *expected){	char buffer[64];	strcpy(buffer, msg_text);	sput_fail_unless(brubeck_statsd_msg_parse(msg, buffer) == expect_parse, msg_text);	if(0 == expect_parse) {		sput_fail_unless(0 == strcmp(msg->value.s, expected), "msg.value.s == expected");	}}

void Test_CRC(){    const char *buffer = "123456789";    uint32_t crc = 0;    crc = crc32((uint32_t)0L, (unsigned char *)buffer, (size_t)9);    sput_fail_unless(crc == 0xCBF43926, "crc32 check");    crc = crc32(0L, (unsigned char *)NULL, (size_t)1);    sput_fail_unless(crc == 0, "crc32 check");}

void testlastAction()	{	GameProperties newGame = createGame();	delayGame(ACTIONCOOLDOWN);	sput_fail_unless(lastAction(newGame) == 1,"Checking delay more than Cooldown returns true");	delayGame(ACTIONCOOLDOWN-1);	sput_fail_unless(lastAction(newGame) == 0,"Checking delay less than Cooldown returns false");	free(newGame->clock);	free(newGame);}

static void dummy_local_tlv_cb(hncp_subscriber s,                               struct tlv_attr *tlv, bool add){  sput_fail_unless(s, "subscriber provided");  sput_fail_unless(s->local_tlv_change_callback == dummy_local_tlv_cb,                   "tlv cb set");  sput_fail_unless(tlv, "tlv set");  L_NOTICE("local tlv callback %s %s", TLV_REPR(tlv), add ? "add" : "remove");  if (tlv_id(tlv) == HNCP_T_VERSION) return;  int exp_v = (add ? 1 : -1) * tlv_id(tlv);  smock_pull_int_is("local_tlv_callback", exp_v);}

static void test_gettm_fail(){	Task task;	task.description = "(A) do hw START: bob";	sput_fail_unless(gettms(&task) == NULL, "gettm(): start fail test"); 	task.description = "(A) do hw END: bob";	sput_fail_unless(gettms(&task) == NULL, "gettm(): end fail test");	task.description = "(A) do hw START: bob END: larry";	sput_fail_unless(gettms(&task) == NULL, "gettm(): end fail test");}

void test_fls64(){    sput_fail_unless(bit_fls(0ull)==-1, "Edge case: arg=0");    sput_fail_unless(bit_fls(1ull)==0,  "arg=1");    sput_fail_unless(bit_fls(0xFFFFFFFFFFFFFFFFull)==63,  "arg=0xFFFFFFFF");    sput_fail_unless(bit_ffs(0x8000000000000000ull)==63,  "arg=0x8000000000000000");    for (uint64_t i=0; i<64; ++i)    {        sput_fail_unless(bit_fls(1ull<<i)==i, "General Test");        sput_fail_unless(bit_fls(0xFFFFFFFFFFFFFFFFull>>i)==63-i, "General test1");    }}

void test_fls32(){    sput_fail_unless(bit_fls(0u)==-1, "Edge case: arg=0");    sput_fail_unless(bit_fls(1u)==0,  "arg=1");    sput_fail_unless(bit_fls(0xFFFFFFFFu)==31,  "arg=0xFFFFFFFF");    sput_fail_unless(bit_fls(0x80000000u)==31,  "arg=0x80000000");    for (uint32_t i=0; i<32; ++i)    {        sput_fail_unless(bit_fls(1u<<i)==i, "General Test0");        sput_fail_unless(bit_fls(0xFFFFFFFFu>>i)==31-i, "General test1");    }}

void hncp_io_schedule(hncp o, int msecs){  if (check_timing)    {      sput_fail_unless(o, "hncp");      sput_fail_unless(o && o->udp_socket == 1, "hncp_io ready");      smock_pull_int_is("schedule", msecs);    }  else    {      want_schedule = msecs;    }}

void prefix_contains_t(void){	sput_fail_if(prefix_contains(&p1, &p2),			"p1 and p2 are disjoint");	sput_fail_if(prefix_contains(&p2, &p1),			"p1 and p2 are disjoint");	sput_fail_unless(prefix_contains(&p1, &p11),			"p1 contains p11");	sput_fail_unless(prefix_contains(&p1, &p1f),			"p1 contains p1f");	sput_fail_if(prefix_contains(&p2, &p11),			"p2 do not contain p11");}

static void test_intlist_construct(void){    intlist_t list = intlist_construct(10);    sput_fail_unless(list.capacity == 10,                     "list = intlist_construct(10),/n"                     "Verifying list.capacity == 10");    sput_fail_unless(list.size == 0,                     "Verifying list.size == 0");    sput_fail_unless(list.elems != NULL,                     "Verifying list.elems is not NULL");    intlist_destroy(list);}

/** creates two enemies and checks their defaut values*/void Test_createEnemy(){    freeAllEnemies();    createEnemy();    sput_fail_unless(getNumberOfEnemies() == 1, "Valid: Number of enemies held in group is one.");        sput_fail_unless(getEnemyHealth(getNumberOfEnemies()) == 100,"Valid: Enemy health is default." );    createEnemy();    sput_fail_unless(getNumberOfEnemies() == 2, "Valid: Number of enemies held in group is two.");    sput_fail_unless(getEnemyHealth(getNumberOfEnemies()) == 100,"Valid: Enemy 2  health is default." );}