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

void ManualPoller::poll_write(int, int evtfd, void* data){    EXPECT_TRUE(this->has_pollee(evtfd)) << evtfd << " in " << data;    pollees[evtfd] = EV_HUP | EV_READ | EV_WRITE;}

	static void Exec(void * params) {		OrderParams* order_params = static_cast<OrderParams*>(params);		g_exec_order++;		EXPECT_TRUE(g_exec_order == order_params->total_ - order_params->put_order_);	}

TEST(String, Informational) {  EXPECT_TRUE(String().isNull());  EXPECT_TRUE(!String("").isNull());  EXPECT_TRUE(String().empty());  EXPECT_TRUE(String("").empty());  EXPECT_TRUE(!String("test").empty());  EXPECT_TRUE(String().size() == 0);  EXPECT_TRUE(String().length() == 0);  EXPECT_TRUE(String("").size() == 0);  EXPECT_TRUE(String("").length() == 0);  EXPECT_TRUE(String("test").size() == 4);  EXPECT_TRUE(String("test").length() == 4);  EXPECT_TRUE(!String("2test").isNumeric());  EXPECT_TRUE(!String("2test").isInteger());  EXPECT_TRUE(!String("test").isNumeric());  EXPECT_TRUE(!String("test").isInteger());  EXPECT_TRUE(String("23").isNumeric());  EXPECT_TRUE(String("23").isInteger());  EXPECT_TRUE(String("23.3").isNumeric());  EXPECT_TRUE(!String("23.3").isInteger());}

inline void invoke_recoding(recoding_parameters param){    // Common setting    typename Encoder::factory encoder_factory(        param.m_max_symbols, param.m_max_symbol_size);    encoder_factory.set_symbols(param.m_symbols);    encoder_factory.set_symbol_size(param.m_symbol_size);    auto encoder = encoder_factory.build();    typename Decoder::factory decoder_factory(        param.m_max_symbols, param.m_max_symbol_size);    decoder_factory.set_symbols(param.m_symbols);    decoder_factory.set_symbol_size(param.m_symbol_size);    auto decoder_one = decoder_factory.build();    auto decoder_two = decoder_factory.build();    // If tested with a shallow decoder we have to remember to set the    // buffers to use for the decoding    std::vector<uint8_t> buffer_decoder_one(decoder_one->block_size(), '/0');    std::vector<uint8_t> buffer_decoder_two(decoder_two->block_size(), '/0');    if(kodo::has_shallow_symbol_storage<Decoder>::value)    {        decoder_one->set_symbols(sak::storage(buffer_decoder_one));        decoder_two->set_symbols(sak::storage(buffer_decoder_two));    }    EXPECT_EQ(encoder->payload_size(), decoder_one->payload_size());    EXPECT_EQ(encoder->payload_size(), decoder_two->payload_size());    std::vector<uint8_t> payload(encoder->payload_size());    std::vector<uint8_t> data_in = random_vector(encoder->block_size());    encoder->set_symbols(sak::storage(data_in));    // Set the encoder non-systematic    if(kodo::has_systematic_encoder<Encoder>::value)        kodo::set_systematic_off(encoder);    while( !decoder_two->is_complete() )    {        uint32_t encode_size = encoder->encode( &payload[0] );        EXPECT_TRUE(encode_size <= payload.size());        EXPECT_TRUE(encode_size > 0);        decoder_one->decode( &payload[0] );        uint32_t recode_size = decoder_one->recode( &payload[0] );        EXPECT_TRUE(recode_size <= payload.size());        EXPECT_TRUE(recode_size > 0);        decoder_two->decode( &payload[0] );    }    std::vector<uint8_t> data_out_one(decoder_one->block_size(), '/0');    std::vector<uint8_t> data_out_two(decoder_two->block_size(), '/0');    decoder_one->copy_symbols(sak::storage(data_out_one));    decoder_two->copy_symbols(sak::storage(data_out_two));    EXPECT_TRUE(std::equal(data_out_one.begin(),                           data_out_one.end(),                           data_in.begin()));    EXPECT_TRUE(std::equal(data_out_two.begin(),                           data_out_two.end(),                           data_in.begin()));}

  void IntegerBasicTest()  {    Dissent::Crypto::Integer int0(5);    Dissent::Crypto::Integer int1(6);    EXPECT_NE(int0, int1);    EXPECT_EQ(int0, int1 - 1);    EXPECT_EQ(int0 + 1, int1);    EXPECT_TRUE(int0 < int1);    EXPECT_TRUE(int1 > int0);    EXPECT_TRUE(int0 <= int1);    EXPECT_TRUE(int1 >= int0);    EXPECT_TRUE(int0 + 1 <= int1);    EXPECT_TRUE(int1 - 1 >= int0);    std::swap(int0, int1);    EXPECT_NE(int0, int1);    EXPECT_EQ(int0, int1 + 1);    EXPECT_EQ(int0 - 1, int1);    EXPECT_TRUE(int0 > int1);    EXPECT_TRUE(int1 < int0);    EXPECT_TRUE(int0 >= int1);    EXPECT_TRUE(int1 <= int0);    EXPECT_TRUE(int0 - 1 >= int1);    EXPECT_TRUE(int1 + 1 <= int0);    EXPECT_EQ(int0 * int1, Integer(30));    EXPECT_EQ(Integer(30) / int0, int1);    EXPECT_EQ(Integer(30) / int1, int0);  }

TEST(stanMcmcDiagEStaticHmc,headerParses) {  EXPECT_TRUE(true);}

TEST_F(TimeSmokeTest, simpleAbsoluteTime){    timeHandle = xme_hal_time_handleFromAbsoluteTime(&someTime);    EXPECT_TRUE(xme_hal_time_isValidTimeHandle(timeHandle));}

TEST_F(SQLiteUtilTests, test_simple_query_execution) {  // Access to the internal SQL implementation is only available in core.  auto sql = SQL("SELECT * FROM time");  EXPECT_TRUE(sql.ok());  EXPECT_EQ(sql.rows().size(), 1U);}

 void resultTypeMustBe() {   EXPECT_TRUE(_result.is<T>()); }

TEST_F(NodeSmokeTest, initIteratorOnNonInitedNodeTableWithValidInterface){    xme_core_directory_nodeRegistryController_nodeInterfaceIterator_t *iterator=NULL;    EXPECT_EQ(XME_STATUS_NOT_FOUND, xme_core_directory_nodeRegistryController_initNodeInterfaceIterator((xme_core_node_nodeId_t)1, XME_COM_INTERFACE_ADDRESS_TYPE_IPV4, &iterator));    EXPECT_TRUE(NULL==iterator);}

TEST(hash_trie, trivial) {  HashTrie t;  read_t a = str_to_read("A");  read_t ab = str_to_read("AB");  read_t abc = str_to_read("ABC");  read_t abd = str_to_read("ABD");  id_t i_a = 0;  id_t i_abc = 2;  id_t i_abd = 3;  t.insert(abc, i_abc, 1);  // [abc]  t.print(cout);  read_t r;  id_t w;  t.get_ith(abc, 0, w, r);  EXPECT_EQ(i_abc, w);  EXPECT_EQ(abc, r);  t.insert(abc, i_abc, 1);  // [abc, abc]  t.get_ith(ab, 0, w, r);  EXPECT_EQ(i_abc, w);  EXPECT_EQ(abc, r);  t.get_ith(ab, 1, w, r);  EXPECT_EQ(i_abc, w);  EXPECT_EQ(abc, r);  t.insert(abd, i_abd, 1);  // [abc, abc, abd]  // Order for C and D is not defined  read_t r1, r2, r3;  id_t w1, w2, w3;  t.get_ith(ab, 0, w1, r1);  t.get_ith(ab, 1, w2, r2);  t.get_ith(ab, 2, w3, r3);  EXPECT_TRUE(      (w1 == i_abc && w2 == i_abc && w3 == i_abd &&       r1 == abc && r2 == abc && r3 == abd) ||      (w1 == i_abd && w2 == i_abc && w3 == i_abc &&       r1 == abd && r2 == abc && r3 == abc));  t.print(cout);  EXPECT_EQ(3u, t.count_total(ab));  EXPECT_EQ(3u, t.count_total(a));  EXPECT_EQ(1u, t.count_total(abd));  t.insert(a, i_a, 1);  // [a, abc, abc, abd]  t.print(cout);  t.get_ith(a, 0, w, r);  EXPECT_EQ(i_a, w);  EXPECT_EQ(a, r);  t.get_ith(a, 1, w1, r1);  t.get_ith(a, 2, w2, r2);  t.get_ith(a, 3, w3, r3);  EXPECT_TRUE(      (w1 == i_abc && w2 == i_abc && w3 == i_abd &&       r1 == abc && r2 == abc && r3 == abd) ||      (w1 == i_abd && w2 == i_abc && w3 == i_abc &&       r1 == abd && r2 == abc && r3 == abc));}

TEST_F(XmlFasadeTest, hello){	EXPECT_TRUE(true);}

TEST(KeyboardmasterUT, Test){	EXPECT_TRUE(true);}

TEST(MruCache, InitialEmpty) {  TestCache c(kCacheCapacity);  EXPECT_TRUE(c.GetMostRecentlyUsed() == NULL);}

TEST(is_hdd, linux_os_root){  std::string path = "/";  EXPECT_TRUE(tools::is_hdd(path.c_str()) != boost::none);}

void CheckFixedNullableResultType(const Type &cast_type) {  const UnaryOperation &op = NumericCastOperation::Instance(cast_type);  const Type *fixed_result_type = op.fixedNullableResultType();  ASSERT_NE(fixed_result_type, nullptr);  EXPECT_TRUE(cast_type.getNullableVersion().equals(*fixed_result_type));}

TEST_F(UsesAnalysisTests,AnalysisHasNonEmptyID) {	EXPECT_TRUE(!usesAnalysis.getName().empty()) <<		"the analyzer should have a non-empty ID";}

TEST_F(EventsDatabaseTests, test_event_add) {  auto sub = std::make_shared<FakeEventSubscriber>();  auto status = sub->testAdd(1);  EXPECT_TRUE(status.ok());}

TEST_F(PerfTest, Parse){  // uint64 and floats should be parsed.  Try<hashmap<string, mesos::PerfStatistics> > parse =    perf::parse("123,cycles/n0.123,task-clock");  CHECK_SOME(parse);  ASSERT_TRUE(parse.get().contains(""));  mesos::PerfStatistics statistics = parse.get().get("").get();  ASSERT_TRUE(statistics.has_cycles());  EXPECT_EQ(123u, statistics.cycles());  ASSERT_TRUE(statistics.has_task_clock());  EXPECT_EQ(0.123, statistics.task_clock());  // Parse multiple cgroups.  parse = perf::parse("123,cycles,cgroup1/n"                      "456,cycles,cgroup2/n"                      "0.456,task-clock,cgroup2/n"                      "0.123,task-clock,cgroup1");  CHECK_SOME(parse);  EXPECT_FALSE(parse.get().contains(""));  ASSERT_TRUE(parse.get().contains("cgroup1"));  statistics = parse.get().get("cgroup1").get();  ASSERT_TRUE(statistics.has_cycles());  EXPECT_EQ(123u, statistics.cycles());  ASSERT_TRUE(statistics.has_task_clock());  EXPECT_EQ(0.123, statistics.task_clock());  ASSERT_TRUE(parse.get().contains("cgroup2"));  statistics = parse.get().get("cgroup2").get();  ASSERT_TRUE(statistics.has_cycles());  EXPECT_EQ(456u, statistics.cycles());  EXPECT_TRUE(statistics.has_task_clock());  EXPECT_EQ(0.456, statistics.task_clock());  // Statistics reporting <not supported> should not appear.  parse = perf::parse("<not supported>,cycles");  CHECK_SOME(parse);  ASSERT_TRUE(parse.get().contains(""));  statistics = parse.get().get("").get();  EXPECT_FALSE(statistics.has_cycles());  // Statistics reporting <not counted> should be zero.  parse = perf::parse("<not counted>,cycles/n<not counted>,task-clock");  CHECK_SOME(parse);  ASSERT_TRUE(parse.get().contains(""));  statistics = parse.get().get("").get();  EXPECT_TRUE(statistics.has_cycles());  EXPECT_EQ(0u, statistics.cycles());  EXPECT_TRUE(statistics.has_task_clock());  EXPECT_EQ(0.0, statistics.task_clock());  // Check parsing fails.  parse = perf::parse("1,cycles/ngarbage");  EXPECT_ERROR(parse);  parse = perf::parse("1,unknown-field");  EXPECT_ERROR(parse);}