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

void test_create_request(void **state){    (void)state;    kaa_user_log_record_t *test_log_record = kaa_test_log_record_create();    test_log_record->data = kaa_string_copy_create(TEST_LOG_BUFFER);    size_t test_log_record_size = test_log_record->get_size(test_log_record);    kaa_log_collector_t *log_collector = NULL;    kaa_error_t error_code = kaa_log_collector_create(&log_collector, status,            channel_manager, logger);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    mock_strategy_context_t strategy;    memset(&strategy, 0, sizeof(mock_strategy_context_t));    strategy.decision = NOOP;    strategy.max_parallel_uploads = UINT32_MAX;    kaa_log_bucket_constraints_t constraints = {        .max_bucket_size = 2 * test_log_record_size,        .max_bucket_log_count = UINT32_MAX,    };    error_code = kaa_logging_init(log_collector, create_mock_storage(), &strategy, &constraints);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    error_code = kaa_logging_add_record(log_collector, test_log_record, NULL);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    size_t expected_size = 0;    error_code = kaa_logging_request_get_size(log_collector, &expected_size);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    uint8_t buffer[expected_size];    kaa_platform_message_writer_t *writer = NULL;    error_code = kaa_platform_message_writer_create(&writer, buffer, expected_size);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    ASSERT_NOT_NULL(writer);    error_code = kaa_logging_request_serialize(log_collector, writer);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    kaa_platform_message_writer_destroy(writer);    uint8_t *buf_cursor = buffer;    ASSERT_EQUAL(KAA_EXTENSION_LOGGING, KAA_HTONS(*(uint16_t *)buf_cursor));    buf_cursor += sizeof(uint16_t);    uint8_t options[] = { 0x00, 0x01 };    ASSERT_EQUAL(memcmp(buf_cursor, options, 2), 0);    buf_cursor += 2;    ASSERT_EQUAL(*(uint32_t *) buf_cursor, KAA_HTONL(20));    buf_cursor += sizeof(uint32_t);    uint8_t request_id_records_count[]  = { 0x00, 0x01, 0x00, 0x01 };    ASSERT_EQUAL(memcmp(buf_cursor, request_id_records_count, 4), 0);    buf_cursor += 4;    uint8_t record_buf[test_log_record_size];    avro_writer_t avro_writer = avro_writer_memory((char *)record_buf, test_log_record_size);    test_log_record->serialize(avro_writer, test_log_record);    avro_writer_free(avro_writer);    ASSERT_EQUAL(*(uint32_t *) buf_cursor, KAA_HTONL(test_log_record_size));    buf_cursor += sizeof(uint32_t);    ASSERT_EQUAL(memcmp(buf_cursor, record_buf, test_log_record_size), 0);    kaa_log_collector_destroy(log_collector);    test_log_record->destroy(test_log_record);}void test_response(void **state){    (void)state;    srand(time(NULL));    kaa_log_collector_t *log_collector = NULL;    kaa_error_t error_code = kaa_log_collector_create(&log_collector, status, channel_manager, logger);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    mock_strategy_context_t strategy;    memset(&strategy, 0, sizeof(mock_strategy_context_t));    mock_storage_context_t *storage = create_mock_storage();    kaa_log_bucket_constraints_t constraints = {        .max_bucket_size = 1024,        .max_bucket_log_count = UINT32_MAX,    };    error_code = kaa_logging_init(log_collector, storage, &strategy, &constraints);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    uint32_t response_count = 2;    size_t response_buffer_size = sizeof(uint32_t) + sizeof(uint32_t) * response_count;    uint8_t response_buffer[response_buffer_size];//.........这里部分代码省略.........

void testSetAtWithInt() {	IndexableSet<int> indexSet{1,2,3,4};	int i = indexSet.at(1);	ASSERT_EQUAL(2, i);}

void testBracketOperatorBackWithInt() {	IndexableSet<int> indexSet{1,2,3,4};	int i = indexSet[3];	ASSERT_EQUAL(4, i);}

void testCaselessCompare() {	IndexableSet<std::string, CaselessComparator> indexSet {"hallo","Hallo","Test","taste"};	ASSERT_EQUAL(3, indexSet.size());}

void testIndexSetBackWithInt() {	IndexableSet<int> indexSet{1,2,3,4};	int i = indexSet.back();	ASSERT_EQUAL(4, i);}

void testDefaultConstructor() {	IndexableSet<int> indexSet{};	indexSet.insert(1);	ASSERT_EQUAL(1, indexSet[0] );}

void testCopyConstructor() {	IndexableSet<int> indexSet {1, 2, 3, 4, 5};	IndexableSet<int> copiedIndexSet(indexSet);	ASSERT_EQUAL(3, indexSet[2]);}

void testSubtraction(){	Ring5 two{2};	ASSERT_EQUAL(Ring5{0}, two-two);	ASSERT_EQUAL(Ring5{0}, Ring5{4}-Ring5{4});}

void testMultiplication(){    Ring5 four{4};    Ring5 three{3};    Ring5 two = four * three;    ASSERT_EQUAL(Ring5{2},two);}

void testAddition() {    Ring5 two{2};    Ring5 four = two+two;    ASSERT_EQUAL(4,four.value());}

void testAdditionWrap(){    Ring5 four{4};    Ring5 three = four + four;    ASSERT_EQUAL(3,three.value());}

// define operator<< formatvoid testOutputOperator(){    std::ostringstream out;    out << Ring5{4};    ASSERT_EQUAL("Ring5{4}",out.str());}

// operator==, operator<< for failuresvoid testValueCtorWithLargeInput(){    Ring5 four{19};    ASSERT_EQUAL(Ring5{4},four);}

void test_meta_extension_serialize(void){    KAA_TRACE_IN(logger);    size_t meta_extension_size;    kaa_error_t error_code = kaa_meta_data_request_get_size(&meta_extension_size);    char buffer[meta_extension_size];    kaa_platform_message_writer_t *writer;    error_code = kaa_platform_message_writer_create(&writer, buffer, meta_extension_size);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    uint32_t expected_timeout = KAA_SYNC_TIMEOUT;    kaa_digest expected_public_key_hash = {0x74, 0xc7, 0x51, 0x43, 0x00, 0xf7, 0xb8, 0x21, 0x2c, 0xc3, 0x6b, 0xa5, 0x9c, 0xb4, 0x03, 0xef, 0xc2, 0x5c, 0x65, 0x6c};    kaa_digest expected_profile_hash = {0xfa, 0x71, 0xb5, 0x02, 0xe7, 0xdf, 0x96, 0x86, 0x6c, 0xdc, 0xe1, 0x4a, 0x17, 0x35, 0x7f, 0xd9, 0xa8, 0xfb, 0x71, 0x09};    error_code = ext_copy_sha_hash(status->endpoint_public_key_hash, expected_public_key_hash);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    error_code = ext_copy_sha_hash(status->profile_hash, expected_profile_hash);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    kaa_context_t *context = NULL;    kaa_init(&context);    kaa_platform_protocol_t *protocol = NULL;    kaa_platform_protocol_create(&protocol, context, status);    error_code = kaa_meta_data_request_serialize(protocol, writer, 1);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    kaa_deinit(context);    kaa_platform_message_reader_t *reader;    error_code = kaa_platform_message_reader_create(&reader, buffer, meta_extension_size);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    uint16_t extension_type;    uint16_t extension_options;    uint32_t extension_payload;    error_code = kaa_platform_message_read_extension_header(                    reader, &extension_type, &extension_options, &extension_payload);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    ASSERT_EQUAL(extension_type, KAA_META_DATA_EXTENSION_TYPE);    ASSERT_EQUAL(extension_options, (TIMEOUT_VALUE | PUBLIC_KEY_HASH_VALUE | PROFILE_HASH_VALUE | APP_TOKEN_VALUE));    ASSERT_EQUAL(extension_payload, meta_extension_size - KAA_EXTENSION_HEADER_SIZE);    uint32_t request_id;    uint32_t timeout;    kaa_digest public_key_hash;    kaa_digest profile_hash;    char sdk_token[KAA_SDK_TOKEN_LENGTH];    error_code = kaa_platform_message_read(reader, &request_id, sizeof(uint32_t));    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    ASSERT_EQUAL(KAA_NTOHL(request_id), 1);    error_code = kaa_platform_message_read(reader, &timeout, sizeof(uint32_t));    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    timeout = KAA_NTOHL(timeout);    ASSERT_EQUAL(expected_timeout, timeout);    error_code = kaa_platform_message_read_aligned(reader, public_key_hash, SHA_1_DIGEST_LENGTH);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    error_code = (memcmp(public_key_hash, expected_public_key_hash, SHA_1_DIGEST_LENGTH) == 0 ? KAA_ERR_NONE : KAA_ERR_READ_FAILED);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    error_code = kaa_platform_message_read_aligned(reader, profile_hash, SHA_1_DIGEST_LENGTH);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    error_code = (memcmp(profile_hash, expected_profile_hash, SHA_1_DIGEST_LENGTH) == 0 ? KAA_ERR_NONE : KAA_ERR_READ_FAILED);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    error_code = kaa_platform_message_read_aligned(reader, sdk_token, KAA_SDK_TOKEN_LENGTH);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    error_code = (memcmp(sdk_token, KAA_SDK_TOKEN, KAA_SDK_TOKEN_LENGTH) == 0 ? KAA_ERR_NONE : KAA_ERR_READ_FAILED);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    kaa_platform_message_reader_destroy(reader);    kaa_platform_message_writer_destroy(writer);}

void testBracketOperatorBackWithString() {	IndexableSet<std::string> indexSet{"Hallo","Hoi","Test","Tester"};	std::string compareString = indexSet[3];	ASSERT_EQUAL("Tester", compareString);}

void testDefaultCtor() {    Ring5 v{};    ASSERT_EQUAL(0,v.value());}

void testNegativeBracketToPositiveIndexString() {	IndexableSet<std::string> indexSet{"Hallo","Hoi","Test","Tester"};	std::string compareString = indexSet[-1];	ASSERT_EQUAL("Tester", compareString);}

void testValueCtor(){    Ring5 four{4};    ASSERT_EQUAL(4,four.value());}

void testRangeConstructor() {	std::vector<int> myInts = {1, 2, 3, 4, 5};	IndexableSet<int> indexSet(myInts.begin() , myInts.end());	ASSERT_EQUAL(3, indexSet[2]);}

// Test _xl_get_row().CTEST(utility, _xl_get_row) {    ASSERT_EQUAL(0,       lxw_get_row("A1"));    ASSERT_EQUAL(1,       lxw_get_row("B2"));    ASSERT_EQUAL(2,       lxw_get_row("C3"));    ASSERT_EQUAL(9,       lxw_get_row("J10"));    ASSERT_EQUAL(24,      lxw_get_row("Y25"));    ASSERT_EQUAL(25,      lxw_get_row("Z26"));    ASSERT_EQUAL(26,      lxw_get_row("AA27"));    ASSERT_EQUAL(254,     lxw_get_row("IU255"));    ASSERT_EQUAL(255,     lxw_get_row("IV256"));    ASSERT_EQUAL(256,     lxw_get_row("IW257"));    ASSERT_EQUAL(16383,   lxw_get_row("XFD16384"));    ASSERT_EQUAL(16384,   lxw_get_row("XFE16385"));    ASSERT_EQUAL(1048576, lxw_get_row("XFE1048577"));}

void testMoveConstructor() {	IndexableSet<int> indexSet {1, 2, 3, 4, 5};	IndexableSet<int> moveIndexSet(std::move(indexSet));	ASSERT_EQUAL(3, moveIndexSet[2]);}

void SequencerChannelsTest::testSequencerChannels(void) {	// 1st test	{		const std::string TEST_FILE_IN = "TestData/sequences_3x2x1.xml";		SequencerChannels sg;		state::PatternChannelMap  in_chans;		state::PatternChannelMap out_chans;		sg.readSequences(TEST_FILE_IN, in_chans, out_chans);		//std::cout<<"SequencerChannelsTest: "<<" "<<std::endl;		//std::cout<<sg<<std::endl;		// simple tests		{			int in_sz = in_chans.getSize();			int out_sz = out_chans.getSize();			ASSERT_EQUAL(1, in_sz);			ASSERT_EQUAL(1, out_sz);		}		// check input channel and size		{			//for all in in_chans			{				std::map<boost::uuids::uuid, boost::shared_ptr<PatternChannel> >::const_iterator it_in_chans =						in_chans.begin();				const std::map<boost::uuids::uuid, boost::shared_ptr<PatternChannel> >::const_iterator it_in_chans_end =						in_chans.end();				while (it_in_chans != it_in_chans_end) {					int width = it_in_chans->second->getWidth();					int length = it_in_chans->second->getLength();					ASSERT_EQUAL(3, width);					ASSERT_EQUAL(2, length);					++it_in_chans;				}			}		}		//check output channel and size		{			//for all in out_chans			{				std::map<boost::uuids::uuid, boost::shared_ptr<PatternChannel> >::const_iterator it_out_chans =						out_chans.begin();				const std::map<boost::uuids::uuid, boost::shared_ptr<PatternChannel> >::const_iterator						it_out_chans_end = out_chans.end();				while (it_out_chans != it_out_chans_end) {					int width = it_out_chans->second->getWidth();					int length = it_out_chans->second->getLength();					ASSERT_EQUAL(3, width);					ASSERT_EQUAL(2, length);					++it_out_chans;				}			}		}	}	// 1st test	{		const std::string TEST_FILE_IN = "TestData/sequences_3x2x3-2x3x1.xml";		SequencerChannels sg;		state::PatternChannelMap  in_chans;				state::PatternChannelMap out_chans;				sg.readSequences(TEST_FILE_IN, in_chans, out_chans);		//std::cout<<"SequencerChannelsTest: "<<" "<<std::endl;		//std::cout<<sg<<std::endl;		// simple tests		{			int in_sz = in_chans.getSize();			int out_sz = out_chans.getSize();			ASSERT_EQUAL(3, in_sz);			ASSERT_EQUAL(1, out_sz);		}	}}

void testIndexSetFrontWithInt() {	IndexableSet<int> indexSet{1,2,3,4};	int i = indexSet.front();	ASSERT_EQUAL(1, i);}

/* * Test IO error during operation. * 1. Set access point, check connect and authorize sending CONNECT and receiving CONNACK * 2. Imitate IO error on read * 3. Close socket, check bootstrap manager access point failure notification */void test_set_access_point_io_error(){    KAA_TRACE_IN(logger);    kaa_error_t error_code;    kaa_transport_channel_interface_t *channel = NULL;    channel = KAA_CALLOC(1,sizeof(kaa_transport_channel_interface_t));    kaa_service_t bootstrap_services[] = {KAA_SERVICE_BOOTSTRAP};    error_code = kaa_tcp_channel_create(channel,logger,bootstrap_services,1);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    //Set access point and imitate start of connection to destination    test_set_access_point(channel);    //Imitate WR event, and wait socket connect call, channel should start authorization, prepare    //CONNECT message    error_code = kaa_tcp_channel_process_event(channel,FD_WRITE);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    ASSERT_EQUAL(access_point_test_info.socket_connected, true);    ASSERT_EQUAL(access_point_test_info.socket_connected_callback, true);    ASSERT_EQUAL(access_point_test_info.fill_connect_message, true);    ASSERT_EQUAL(access_point_test_info.request_connect, true);    //Check correct RD,WR operation, in this point we waiting for RD,WR operations true    CHECK_SOCKET_RW(channel,true,true);    //Imitate socket ready for writing, and writing CONNECT message    error_code = kaa_tcp_channel_process_event(channel,FD_WRITE);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    ASSERT_EQUAL(access_point_test_info.auth_packet_written, true);    //Check correct RD,WR operation, in this point we waiting for RD operations true    //and WR false, no pending services and empty buffer.    CHECK_SOCKET_RW(channel,true,false);    //Imitate socket ready for reading, and got IO error during read    access_point_test_info.socket_connecting_error_scenario = true;    error_code = kaa_tcp_channel_process_event(channel,FD_READ);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    ASSERT_EQUAL(access_point_test_info.connack_read, false);    ASSERT_EQUAL(access_point_test_info.socket_disconnected_callback, true);    ASSERT_EQUAL(access_point_test_info.socket_disconnected_closed, true);    ASSERT_EQUAL(access_point_test_info.bootstrap_manager_on_access_point_failed, true);    channel->destroy(channel->context);    KAA_TRACE_OUT(logger);    KAA_FREE(channel);}

void testIndexSetSizeAfterCreation() {	IndexableSet<std::string> indexSet{};	ASSERT_EQUAL(indexSet.size(), 0);}

void test_check_bootstrap_sync(kaa_transport_channel_interface_t *channel){    ASSERT_NOT_NULL(channel);    //Reset test bools    access_point_test_info.socket_connected                         = false;    access_point_test_info.socket_connected_callback                = false;    access_point_test_info.fill_connect_message                     = false;    access_point_test_info.request_connect                          = false;    access_point_test_info.auth_packet_written                      = false;    access_point_test_info.connack_read                             = false;    access_point_test_info.kaasync_read                             = false;    access_point_test_info.kaasync_processed                        = false;    access_point_test_info.socket_disconnected_write                = false;    access_point_test_info.socket_disconnected_callback             = false;    access_point_test_info.socket_disconnected_closed               = false;    access_point_test_info.bootstrap_manager_on_access_point_failed = false;    //Imitate WR event, and wait socket connect call, channel should start authorization, prepare    //CONNECT message    kaa_error_t error_code = kaa_tcp_channel_process_event(channel,FD_WRITE);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    ASSERT_EQUAL(access_point_test_info.socket_connected, true);    ASSERT_EQUAL(access_point_test_info.socket_connected_callback, true);    ASSERT_EQUAL(access_point_test_info.fill_connect_message, true);    ASSERT_EQUAL(access_point_test_info.request_connect, true);    //Check correct RD,WR operation, in this point we waiting for RD,WR operations true    CHECK_SOCKET_RW(channel,true,true);    //Imitate socket ready for writing, and writing CONNECT message    error_code = kaa_tcp_channel_process_event(channel,FD_WRITE);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    ASSERT_EQUAL(access_point_test_info.auth_packet_written, true);    //Check correct RD,WR operation, in this point we waiting for RD operations true    //and WR false, no pending services and empty buffer.    CHECK_SOCKET_RW(channel,true,false);    //Imitate socket ready for reading, and read CONNACK message    error_code = kaa_tcp_channel_process_event(channel,FD_READ);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    ASSERT_EQUAL(access_point_test_info.connack_read, true);    //Check correct RD,WR operation, in this point we waiting for RD operations true    //and WR false, no pending services and empty buffer.    //Checking receiving KAA_SYNC message    CHECK_SOCKET_RW(channel,true,false);    //Imitate socket ready for reading, and read KAA_SYNC Bootstrap message    error_code = kaa_tcp_channel_process_event(channel,FD_READ);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    ASSERT_EQUAL(access_point_test_info.kaasync_read, true);    ASSERT_EQUAL(access_point_test_info.kaasync_processed, true);    //Check correct RD,WR operation, in this point we waiting for WR operations true    //and RD true, no pending services and buffer with Disconnect message.    //Checking receiving KAA_SYNC message    CHECK_SOCKET_RW(channel,true,true);    //Imitate socket ready for writing, and write Disconnect message    error_code = kaa_tcp_channel_process_event(channel,FD_WRITE);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    ASSERT_EQUAL(access_point_test_info.socket_disconnected_write, true);    ASSERT_EQUAL(access_point_test_info.socket_disconnected_callback, true);    ASSERT_EQUAL(access_point_test_info.socket_disconnected_closed, true);    ASSERT_EQUAL(access_point_test_info.bootstrap_manager_on_access_point_failed, false);}

void testBracketOperatorFrontWithInt() {	IndexableSet<int> indexSet{1,2,3,4};	int i = indexSet[0];	ASSERT_EQUAL(1, i);}

void test_hashes(redis::client & c){  test("hset");  {    c.hset("hash1", "key1", "hval1");    c.hset("hash1", "key2", "hval2");    c.hset("hash1", "key3", "hval3");        ASSERT_EQUAL(c.exists("hash1"), true);    ASSERT_EQUAL(c.type("hash1"), redis::client::datatype_hash);    ASSERT_EQUAL(c.hlen("hash1"), 3L);  }    test("hget");  {    ASSERT_EQUAL(c.hget("hash1", "key1"), string("hval1"));    ASSERT_EQUAL(c.hget("hash1", "key2"), string("hval2"));    ASSERT_EQUAL(c.hget("hash1", "key3"), string("hval3"));  }    test("hsetnx");  {    ASSERT_EQUAL(c.hsetnx("hash1", "key1", "hvalINVALID"), false);    ASSERT_EQUAL(c.hget("hash1", "key1"), string("hval1"));    ASSERT_EQUAL(c.hsetnx("hash1", "key4", "hval4"), true);    ASSERT_EQUAL(c.hget("hash1", "key4"), string("hval4"));  }    redis::client::string_pair_vector content;  test("hmset");  {    content.push_back( make_pair("key1", "hval1") );    content.push_back( make_pair("key2", "hval2") );    content.push_back( make_pair("key3", "hval3") );        c.hmset("hash2", content);  }    test("hmget");  {    redis::client::string_vector fields;    fields.push_back("key1");    fields.push_back("key2");    fields.push_back("key3");    fields.push_back("key4");        redis::client::string_vector content2;    c.hmget("hash2", fields, content2);    ASSERT_EQUAL(content2.size(), (size_t) 4);        for(size_t i=0; i<content2.size(); i++)    {      if(content.size() > i)        ASSERT_EQUAL( content2[i], content[i].second );      else        ASSERT_EQUAL( content2[i], redis::client::missing_value() );    }  }    test("hincrby");  {    c.hset("hash3", "key1", "1");    long l;    l = c.hincrby("hash3", "key1", 1);    ASSERT_EQUAL( l, 2L );    l = c.hincrby("hash3", "key2", 1);    ASSERT_EQUAL( l, 1L );    l = c.hincrby("hash3", "key3", -3);    ASSERT_EQUAL( l, -3L );    string s;    s = c.hget("hash3", "key1");    ASSERT_EQUAL( s, string("2") );    s = c.hget("hash3", "key2" );    ASSERT_EQUAL( s, string("1") );    s = c.hget("hash3", "key3" );    ASSERT_EQUAL( s, string("-3") );  }    test("hexists");  {    ASSERT_EQUAL( c.hexists("hash3", "key1"), true );    ASSERT_EQUAL( c.hexists("hash3", "key4"), false );  }    test("hdel");  {    ASSERT_EQUAL( c.hdel("hash3", "key1"), true );    ASSERT_EQUAL( c.hexists("hash3", "key1"), false );        ASSERT_EQUAL( c.hdel("hash3", "key4"), false );    ASSERT_EQUAL( c.hexists("hash3", "key4"), false );        c.hset("hash3", "key1", "hval1");  }    test("hlen");  {    ASSERT_EQUAL( c.hlen("hash3"), 3L );    ASSERT_EQUAL( c.hlen("hash4"), 0L );//.........这里部分代码省略.........

void testNegativeBracketToPositiveIndex() {	IndexableSet<int> indexSet{1,2,3,4};	int i = indexSet[-1];	ASSERT_EQUAL(4, i);}

void test_unmark_by_bucket_id(void){    KAA_TRACE_IN(logger);    kaa_error_t error_code;    void *storage;    error_code = ext_unlimited_log_storage_create(&storage, logger);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    size_t record_len = 0;    size_t TEST_RECORD_COUNT = 10;    size_t record_count = 0;    const char *data = "DATA";    size_t data_size = strlen("DATA");    while (record_count < TEST_RECORD_COUNT) {        error_code = add_log_record(storage, data, data_size);        ASSERT_EQUAL(error_code, KAA_ERR_NONE);        ++record_count;    }    size_t buffer_size = data_size;    char buffer[buffer_size];    size_t bucket_id_1 = 1;    size_t i;    for (i = 0; i < record_count / 2; ++i) {        error_code = ext_log_storage_write_next_record(storage, buffer, buffer_size, bucket_id_1, &record_len);        ASSERT_EQUAL(error_code, KAA_ERR_NONE);    }    size_t bucket_id_2 = 2;    for (i = 0; i < record_count / 2; ++i) {        error_code = ext_log_storage_write_next_record(storage, buffer, buffer_size, bucket_id_2, &record_len);        ASSERT_EQUAL(error_code, KAA_ERR_NONE);    }    size_t bucket_id_3 = 3;    error_code = ext_log_storage_write_next_record(storage, buffer, buffer_size, bucket_id_3, &record_len);    ASSERT_EQUAL(error_code, KAA_ERR_NOT_FOUND);    error_code = ext_log_storage_remove_by_bucket_id(storage, bucket_id_2);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    error_code = ext_log_storage_write_next_record(storage, buffer, buffer_size, bucket_id_3, &record_len);    ASSERT_EQUAL(error_code, KAA_ERR_NOT_FOUND);    error_code = ext_log_storage_unmark_by_bucket_id(storage, bucket_id_1);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    size_t bucket_id_4 = 4;    for (i = 0; i < record_count / 2; ++i) {        error_code = ext_log_storage_write_next_record(storage, buffer, buffer_size, bucket_id_4, &record_len);        ASSERT_EQUAL(error_code, KAA_ERR_NONE);    }    error_code = ext_log_storage_write_next_record(storage, buffer, buffer_size, bucket_id_3, &record_len);    ASSERT_EQUAL(error_code, KAA_ERR_NOT_FOUND);    error_code = ext_log_storage_remove_by_bucket_id(storage, bucket_id_4);    ASSERT_EQUAL(error_code, KAA_ERR_NONE);    ASSERT_EQUAL(ext_log_storage_get_records_count(storage), 0);    ASSERT_EQUAL(ext_log_storage_get_total_size(storage), 0);    ext_log_storage_destroy(storage);    KAA_TRACE_OUT(logger);}