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

BOOST_FIXTURE_TEST_CASE(readFilePath, JsonFilePaserTestInit){  std::string filename;  TEST_ASSERT(jsonFile.readFilePath("filename",filename,false));  ASSERT_NE(filename,std::string("f.txt"));  ASSERT_EQ(filename,jsonFile.getFileDir()+std::string("f.txt"));}

TEST(sys_mman, mremap_PTRDIFF_MAX) {  void* map = mmap(nullptr, PAGE_SIZE, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);  ASSERT_NE(MAP_FAILED, map);  ASSERT_EQ(MAP_FAILED, mremap(map, PAGE_SIZE, kHuge, MREMAP_MAYMOVE));}

TEST(SocketTests, ClientServer) {    int fd_socket, fd_connect;    int port, res;    pid_t child;    socklen_t size;    struct sockaddr_in saddr = {};    char buf[512];    saddr.sin_family = AF_INET;    saddr.sin_addr.s_addr = INADDR_ANY;    /* use 0 so the kernel assigns us an open port # */    saddr.sin_port = htons(0);    fd_socket = socket(AF_INET, SOCK_STREAM, 0);    ASSERT_NE(fd_socket, -1);    res = bind(fd_socket, (struct sockaddr *) &saddr, sizeof(saddr));    ASSERT_NE(res, -1);    res = listen(fd_socket, 16/*max queue length*/);    ASSERT_NE(res, -1);    /* get the port # we were assigned */    size = sizeof(saddr);    res = getsockname(fd_socket, (struct sockaddr *) &saddr, &size);    ASSERT_NE(res, -1);    port = ntohs(saddr.sin_port);    child = fork();    ASSERT_TRUE(child >= 0);    if (child == 0) {        struct sockaddr from_addr;        socklen_t from_len = sizeof(from_addr);        int fd_client;        struct hostent *hp = gethostbyname("localhost");        ASSERT_NE(hp, (struct hostent *)NULL);        memset(&saddr, 0, sizeof(saddr));        saddr.sin_family = AF_INET;        saddr.sin_addr.s_addr = ((struct in_addr *)(hp->h_addr))->s_addr;        saddr.sin_port = htons(port);        /* connect and exchange greetings */        fd_client = socket(AF_INET, SOCK_STREAM, 0);        ASSERT_NE(fd_client, -1);        res = connect(fd_client, (struct sockaddr *) &saddr, sizeof(saddr));        ASSERT_NE(res, -1);        res = send(fd_client, "hello", strlen("hello")+1, 0);        ASSERT_NE(res, -1);        res = recvfrom(fd_client, buf, sizeof(buf), 0, &from_addr, &from_len);        ASSERT_NE(res, -1);        EXPECT_EQ(0, (int)from_len);  /* no from addr with SOCK_STREAM */        ASSERT_STREQ(buf, "goodbye");        close(fd_client);        exit(0);    } else {        /* wait for child to connect */        size = sizeof(saddr);         fd_connect = accept(fd_socket, (struct sockaddr *) &saddr, &size);        ASSERT_NE(fd_connect, -1);        /* exchange greetings */        res = recv(fd_connect, buf, sizeof(buf), 0);        ASSERT_NE(res, -1);        ASSERT_STREQ(buf, "hello");        res = send(fd_connect, "goodbye", strlen("goodbye")+1, 0);        ASSERT_NE(res, -1);        int status;        do {            res = waitpid(child, &status, 0);        } while (res == -1 && errno == EINTR);        ASSERT_EQ(res, child);        ASSERT_EQ(0, status);        close(fd_connect);        close(fd_socket);    }}

TEST(stat_test, get_config) {    stat_client cli(host(), port(), cluster_name(), timeout());    ASSERT_NE("", cli.get_config());}

char *locate_file (const char *name){  ASSERT_NE (NULL, path_to_selftest_files);  return concat (path_to_selftest_files, "/", name, NULL);}

TEST_F(ExoticaTaskTest, XIT) //!< XML Initialisation Test{    boost::shared_ptr<tinyxml2::XMLHandle> xml_handle;    tinyxml2::XMLDocument doc;    ASSERT_EQ(tinyxml2::XML_NO_ERROR,              doc.LoadFile((resource_path_ + std::string("ex_task_1.xml")).c_str()));    xml_handle.reset(new tinyxml2::XMLHandle(*(doc.RootElement())));    ASSERT_NE(nullptr, xml_handle)<< " : Aborting: could  not initialise";    params_.optimisation_window = 2;  //!< Test with 2 instances    task1_p_ = boost::dynamic_pointer_cast<ExoticaTaskTest_1>(                   exotica::TaskCreator::Instance()->createObject("ExoticaTask_1", params_));    ASSERT_TRUE(task1_p_ != nullptr)<<" : Could not initialise object";    EXPECT_EQ(2, task1_p_->getParameters().optimisation_window)            << " : Incorrect initialisation";    EXPECT_TRUE(task1_p_->initBase(*xml_handle));    EXPECT_TRUE(task1_p_->derived_called);    task1_p_->clearFlags();    //!< Goal Weights    EXPECT_EQ(Eigen::MatrixXd::Identity(3, 3), task1_p_->getGoalWeights(0));    EXPECT_EQ(Eigen::MatrixXd::Ones(3, 3), task1_p_->getGoalWeights(1));    EXPECT_EQ(Eigen::MatrixXd::Zero(1, 1), task1_p_->getGoalWeights(2));    //!< Task Weight    EXPECT_FLOAT_EQ(0.5, task1_p_->getTaskWeight(0));    EXPECT_FLOAT_EQ(0.2, task1_p_->getTaskWeight(1));    EXPECT_GT(0, task1_p_->getTaskWeight(2));    //!< Goal    Eigen::VectorXd goal_0(3);    Eigen::VectorXd goal_1(3);    goal_0 << 0.2, 0.4, 0.6;    goal_1 << 0.5, 0.5, 0.5;    ASSERT_EQ(goal_0.size(), task1_p_->getGoal(0).size());    EXPECT_EQ(goal_0, task1_p_->getGoal(0));    EXPECT_FLOAT_EQ(0.2, task1_p_->getTolerance()); //!< Should give the zeroth one..    ASSERT_EQ(goal_1.size(), task1_p_->getGoal(1).size());    EXPECT_EQ(goal_1, task1_p_->getGoal(1));    EXPECT_FLOAT_EQ(0.01, task1_p_->getTolerance(1));    EXPECT_EQ(Eigen::VectorXd::Zero(1), task1_p_->getGoal(2));    EXPECT_GT(0, task1_p_->getTolerance(2));    //!< Private members (check that they are passed ok from base) (task of type 2)    ASSERT_EQ(tinyxml2::XML_NO_ERROR,              doc.LoadFile(                  (resource_path_ + std::string("ExoticaTask2_default.xml")).c_str()));    xml_handle.reset(new tinyxml2::XMLHandle(*(doc.RootElement())));    ASSERT_NE(nullptr, xml_handle)<< " : Aborting: could  not initialise";    params_.optimisation_window = 1;  //!< Test with 1 instances    task2_p_ = boost::dynamic_pointer_cast<ExoticaTaskTest_2>(                   exotica::TaskCreator::Instance()->createObject("ExoticaTask_2", params_));    ASSERT_TRUE(task2_p_ != nullptr)<<" : Could not initialise object";    EXPECT_EQ(1, task2_p_->getParameters().optimisation_window)            << " : Incorrect initialisation";    EXPECT_TRUE(task2_p_->initBase(*xml_handle));    EXPECT_TRUE(task2_p_->derived_called);    task2_p_->clearFlags();    EXPECT_EQ(6, task2_p_->int_element);    EXPECT_EQ(0, task2_p_->string_element.compare("blabla"));}

 /**   * Return the number of rows in the segment.  * Will throw an exception if the sarray is invalid (there is an error  * reading files)  */ size_t segment_length(size_t segment) const {   ASSERT_NE(reader, NULL);   return m_segment_lengths[segment]; }

 /**  * Return the file prefix of the sarray (paramter on construction)  */ std::string get_index_file() const {   ASSERT_NE(reader, NULL);   return reader->get_index_file(); }

TEST(SlotMap, ReplaceNodesAlsoSlave){    cerb::SlotMap::select_slave_if_possible();    cerb::SlotMap slot_map;    std::set<cerb::Server*> replaced = slot_map.replace_map(cerb::parse_slot_map(                                           "69853562969c74ff387f9e491d025b2a86ac478f 192.168.1.100:7002 master - 0 0 3 connected 8192-12287/n"                                           "2f53d0fb4a59274e83e47b1dca02697384822ca5 192.168.1.100:7006 slave 69853562969c74ff387f9e491d025b2a86ac478f 0 0 3 connected/n"                                           "2560c867f9ca2ef4cc872eb85ce985373ad9e815 192.168.1.101:7003 master - 0 0 2 connected 0-4095/n"                                           "933970b4fd2d1ad06166ab1d893e8cac7b129ebd 192.168.1.101:7001 master - 0 0 4 connected 4096-8191/n"                                           "d3adf40539ad749d214609987563bf9903a57ffc 192.168.1.101:7007 slave 2560c867f9ca2ef4cc872eb85ce985373ad9e815 0 0 2 connected/n"                                           "6c001456aff0ae537ba242d4e86fb325c5babbea 192.168.1.100:7000 myself,master - 0 0 1 connected 12288-16383/n",                                           "127.0.0.1"), nullptr);    ASSERT_TRUE(replaced.empty());    for (cerb::slot s = 0; s < 4096; ++s) {        cerb::Server* svr = slot_map.get_by_slot(s);        ASSERT_NE(nullptr, svr) << " slot #" << s;        ASSERT_EQ("192.168.1.101", svr->addr.host) << " slot #" << s;        ASSERT_EQ(7007, svr->addr.port) << " slot #" << s;    }    for (cerb::slot s = 4096; s < 8192; ++s) {        cerb::Server* svr = slot_map.get_by_slot(s);        ASSERT_NE(nullptr, svr) << " slot #" << s;        ASSERT_EQ("192.168.1.101", svr->addr.host) << " slot #" << s;        ASSERT_EQ(7001, svr->addr.port) << " slot #" << s;    }    for (cerb::slot s = 8192; s < 12288; ++s) {        cerb::Server* svr = slot_map.get_by_slot(s);        ASSERT_NE(nullptr, svr) << " slot #" << s;        ASSERT_EQ("192.168.1.100", svr->addr.host) << " slot #" << s;        ASSERT_EQ(7006, svr->addr.port) << " slot #" << s;    }    for (cerb::slot s = 12288; s < 16384; ++s) {        cerb::Server* svr = slot_map.get_by_slot(s);        ASSERT_NE(nullptr, svr) << " slot #" << s;        ASSERT_EQ("192.168.1.100", svr->addr.host) << " slot #" << s;        ASSERT_EQ(7000, svr->addr.port) << " slot #" << s;    }    std::set<cerb::Server*> to_be_replaced;    to_be_replaced.insert(slot_map.get_by_slot(0));    replaced = slot_map.replace_map(cerb::parse_slot_map(                                        "69853562969c74ff387f9e491d025b2a86ac478f 192.168.1.100:7002 master - 0 0 3 connected 8192-12287/n"                                        "2f53d0fb4a59274e83e47b1dca02697384822ca5 192.168.1.100:7006 slave 69853562969c74ff387f9e491d025b2a86ac478f 0 0 3 connected/n"                                        "2560c867f9ca2ef4cc872eb85ce985373ad9e815 192.168.1.101:7003 master - 0 0 2 connected 0-4095/n"                                        "933970b4fd2d1ad06166ab1d893e8cac7b129ebd 192.168.1.101:7001 master - 0 0 4 connected 4096-8191/n"                                        "6c001456aff0ae537ba242d4e86fb325c5babbea 192.168.1.100:7000 myself,master - 0 0 1 connected 12288-16383/n",                                        "127.0.0.1"), nullptr);    ASSERT_EQ(to_be_replaced, replaced);    for (cerb::slot s = 0; s < 4096; ++s) {        cerb::Server* svr = slot_map.get_by_slot(s);        ASSERT_NE(nullptr, svr) << " slot #" << s;        ASSERT_EQ("192.168.1.101", svr->addr.host) << " slot #" << s;        ASSERT_EQ(7003, svr->addr.port) << " slot #" << s;    }    for (cerb::slot s = 4096; s < 8192; ++s) {        cerb::Server* svr = slot_map.get_by_slot(s);        ASSERT_NE(nullptr, svr) << " slot #" << s;        ASSERT_EQ("192.168.1.101", svr->addr.host) << " slot #" << s;        ASSERT_EQ(7001, svr->addr.port) << " slot #" << s;    }    for (cerb::slot s = 8192; s < 12288; ++s) {        cerb::Server* svr = slot_map.get_by_slot(s);        ASSERT_NE(nullptr, svr) << " slot #" << s;        ASSERT_EQ("192.168.1.100", svr->addr.host) << " slot #" << s;        ASSERT_EQ(7006, svr->addr.port) << " slot #" << s;    }    for (cerb::slot s = 12288; s < 16384; ++s) {        cerb::Server* svr = slot_map.get_by_slot(s);        ASSERT_NE(nullptr, svr) << " slot #" << s;        ASSERT_EQ("192.168.1.100", svr->addr.host) << " slot #" << s;        ASSERT_EQ(7000, svr->addr.port) << " slot #" << s;    }}

 /**   * Return the number of segments in the collection.   * Will throw an exception if the sarray is invalid (there is an error  * reading files)  */ size_t num_segments() const {   ASSERT_NE(reader, NULL);   return m_num_segments; }

TEST_F(HostTest, IsSingleton) {	ASSERT_NE(h, NULL);	ASSERT_NE(*h, NULL);}

TEST(MallocTests, HeapCompact) {    HANDLE heap = GetProcessHeap();    ASSERT_NE(heap, (HANDLE)NULL);    SIZE_T largest = HeapCompact(heap, 0);    ASSERT_GT(largest, 1024);}

// Checks the tests are running against ANGLETEST(EGLSanityCheckTest, IsRunningOnANGLE){    const char *extensionString =        static_cast<const char *>(eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS));    ASSERT_NE(strstr(extensionString, "EGL_ANGLE_platform_angle"), nullptr);}

 /**  * Returns the collection of files storing the sarray.  * For instance: [file_prefix].sidx, [file_prefix].0001, etc.  */ std::vector<std::string> get_file_names() const {   ASSERT_NE(reader, NULL);   return reader->get_index_info().segment_files; }

int main(int argc, char** argv) {//   cppipc::comm_client client({"localhost:2181"}, "test");  cppipc::comm_client client({}, "tcp://127.0.0.1:19000");  /*  cppipc::comm_client client({},                              "ipc:///tmp/cppipc_server_test");                             */  if (argc >= 2) {    client.add_auth_method(std::make_shared<cppipc::authentication_token_method>(argv[1]));  }  client.start();  client.add_status_watch(WATCH_COMM_SERVER_INFO,                           [](std::string message) {                          std::cout << message << "/n";                          });  for (size_t i = 0;i < 100; ++i) {  try {     test_object_proxy test_object(client);    std::cout << test_object.ping("hello world") << "/n";    std::cout << "5 + 1 = " << test_object.add_one(5, "hello") << "/n";    std::cout << "5 + 5 = " << test_object.add(5, 5) << "/n";    std::cout << "5 - 5 = " << test_object.subtract(5, 5) << "/n";    std::cout << "return_one = " << test_object.return_one() << "/n";    ASSERT_EQ(test_object.add(5, 5), 10);    ASSERT_EQ(test_object.subtract(5, 5), 0);  } catch (cppipc::reply_status status) {    std::cout << "Exception: " << cppipc::reply_status_to_string(status) << "/n";  } catch (const char* s) {    std::cout << "Exception: " << s << "/n";  }  }  std::shared_ptr<test_object_proxy> pika(std::make_shared<test_object_proxy>(client));  std::shared_ptr<test_object_proxy> chu(std::make_shared<test_object_proxy>(client));  pika->set_value(10);  chu->set_value(5);  ASSERT_EQ(pika->get_value(), 10);  ASSERT_EQ(chu->get_value(), 5);  pika->subtract_from(std::static_pointer_cast<test_object_base>(chu));  ASSERT_EQ(pika->get_value(), 5);  ASSERT_EQ(chu->get_value(), 5);  chu->subtract_from(std::static_pointer_cast<test_object_base>(pika));  ASSERT_EQ(pika->get_value(), 5);  ASSERT_EQ(chu->get_value(), 0);  pika->swap(std::static_pointer_cast<test_object_base>(chu));  ASSERT_EQ(pika->get_value(), 0);  ASSERT_EQ(chu->get_value(), 5);  chu->swap(std::static_pointer_cast<test_object_base>(pika));  ASSERT_EQ(pika->get_value(), 5);  ASSERT_EQ(chu->get_value(), 0);  chu->set_value(2);  std::shared_ptr<test_object_proxy> p = std::dynamic_pointer_cast<test_object_proxy>(*pika - chu);  ASSERT_NE(p.get(), NULL);  ASSERT_EQ(p->get_value(), 3);  // Test objects with reference count greater than 1  std::shared_ptr<test_object_proxy> q = std::dynamic_pointer_cast<test_object_proxy>(*pika + chu);  ASSERT_EQ(q->get_value(), 7);  ASSERT_EQ(chu->get_value(), 7);  ASSERT_EQ(pika->get_value(), 5);  bool exception_caught = false;  try {    chu->an_exception();  } catch (cppipc::ipcexception& except) {    std::cout << except.what() << "/n";    exception_caught = true;  }  ASSERT_TRUE(exception_caught);  // ping test with increasing lengths  test_object_proxy test_object(client);  for (size_t i = 0;i <= 25; ++i) {    size_t j = ((size_t)1 << i) - 1;    graphlab::timer ti;    std::cout << "Sending ping of length " << j << std::endl;    std::string ret = test_object.return_big_object(j);    std::cout << "Ping of length " << j << " RTT = " << ti.current_time() << "s" << std::endl;    ASSERT_EQ(ret.length(), j);  }  p.reset();}

 /** Return the end iterator of the segment.  * The iterator (/ref sarray_iterator) is of the input iterator type and   * has value_type T. See /ref end() to get the end iterator of the segment.  *  * The iterator is invalid once the originating sarray is destroyed.  * Accessing the iterator after the sarray is destroyed is undefined behavior.  *  * /code  * // example to print segment 1 to screen  * auto iter = sarr.begin(1);  * auto enditer =sarr.end(1);  * while(iter != enditer) {  *   std::cout << *iter << "/n";  *   ++iter;  * }  * /endcode  *  * Will throw an exception if the sarray is invalid (there is an error  * reading files) Also segmentid must be a valid segment ID. Will throw an  * exception otherwise.  */ iterator end(size_t segmentid) const {   ASSERT_NE(reader, NULL);   ASSERT_LT(segmentid, num_segments());   return iterator(&(m_read_buffers[segmentid]), segmentid, false); }

TEST_F(TestObject, multipleConnect){  int additional_timeout = 5;//time to wait after having received the correct number of callbacks  i = 0;  qi::SignalLink link1 = oclient2.connect(se2, oserver1, callbackId).value(2000);  qi::SignalLink link2 = oclient2.connect(se2, oserver1, callbackId).value(2000);  qi::SignalLink link3 = oclient2.connect(se2, oserver1, callbackId).value(2000);  qi::SignalLink link4 = oclient2.connect(se2, oserver1, callbackId).value(2000);  ASSERT_NE(link1, link2);  ASSERT_NE(link2, link3);  ASSERT_NE(link3, link4);  oclient2.post("fire2", 42);  oclient2.post("fire2", 42);  int waiting_time = 0;  while(i._value != 8 && waiting_time < 10000)//waiting 10 seconds max  {    qi::os::msleep(additional_timeout); //additional timeout to wait for unwanted callback    waiting_time += additional_timeout;  }  qi::os::msleep(additional_timeout);  ASSERT_EQ(i._value, 8);  //disconnect 3/4 callbacks  oclient2.disconnect(link2);  oclient2.disconnect(link3);  oclient2.disconnect(link4);  oclient2.post("fire2", 42);//post signal twice  oclient2.post("fire2", 42);  while(i._value != 10 && waiting_time < 10000)//waiting 10 seconds max  {    qi::os::msleep(additional_timeout); //additional timeout to wait for unwanted callback    waiting_time += additional_timeout;  }  qi::os::msleep(additional_timeout); //additional timeout to wait for unwanted callback  ASSERT_EQ(i._value, 10);  //i = 0;  //reconnect callbacks  link2 = oclient2.connect(se2, oserver1, callbackId).value(2000);  link3 = oclient2.connect(se2, oserver1, callbackId).value(2000);  link4 = oclient2.connect(se2, oserver1, callbackId).value(2000);  oclient2.post("fire2", 42);//post signal twice  oclient2.post("fire2", 42);  while((*i) != 18 && waiting_time < 10000)//waiting 10 seconds max  {    qi::os::msleep(additional_timeout); //additional timeout to wait for unwanted callback    waiting_time += additional_timeout;  }  qi::os::msleep(additional_timeout); //additional timeout to wait for unwanted callback  ASSERT_EQ(*i, 18);  oclient2.disconnect(link1);  oclient2.disconnect(link2);  oclient2.disconnect(link3);  oclient2.disconnect(link4);  oclient2.post("fire2", 42);  qi::os::msleep(additional_timeout); //additional timeout to wait for unwanted callback  ASSERT_EQ(*i, 18);}

TEST(ConstantPropagationTest1, constantpropagation) {  g_redex = new RedexContext();	const char* dexfile =    "gen/native/redex/test/integ/constant-propagation-test-dex/constant-propagation.dex";  if (access(dexfile, R_OK) != 0) {    dexfile = std::getenv("dexfile");    ASSERT_NE(nullptr, dexfile);  }  std::vector<DexClasses> dexen;  dexen.emplace_back(load_classes_from_dex(dexfile));  DexClasses& classes = dexen.back();  std::cout << "Loaded classes: " << classes.size() << std::endl;	TRACE(CONSTP, 2, "Code before:/n");  for(const auto& cls : classes) {    TRACE(CONSTP, 2, "Class %s/n", SHOW(cls));    if (filter_test_classes(cls->get_name()) < 2) {      TRACE(CONSTP, 2, "Class %s/n", SHOW(cls));      for (const auto& dm : cls->get_dmethods()) {        TRACE(CONSTP, 2, "dmethod: %s/n",  dm->get_name()->c_str());        if (strcmp(dm->get_name()->c_str(), "propagation_1") == 0 ||            strcmp(dm->get_name()->c_str(), "propagation_2") == 0 ||            strcmp(dm->get_name()->c_str(), "propagation_3") == 0) {          TRACE(CONSTP, 2, "dmethod: %s/n",  SHOW(dm->get_code()));        }      }    }  }  std::vector<Pass*> passes = {    new ConstantPropagationPass(),    new LocalDcePass()  };  std::vector<KeepRule> null_rules;  PassManager manager(passes, null_rules);  Json::Value conf_obj = Json::nullValue;  ConfigFiles dummy_cfg(conf_obj);  dummy_cfg.using_seeds = true;  manager.run_passes(dexen, dummy_cfg);  TRACE(CONSTP, 2, "Code after:/n");  for(const auto& cls : classes) {    TRACE(CONSTP, 2, "Class %s/n", SHOW(cls));    //ASSERT_NE(filter_test_classes(cls->get_name()), REMOVEDCLASS);    if (filter_test_classes(cls->get_name()) == MAINCLASS) {      for (const auto& dm : cls->get_dmethods()) {        TRACE(CONSTP, 2, "dmethod: %s/n",  dm->get_name()->c_str());        if (strcmp(dm->get_name()->c_str(), "propagation_1") == 0) {          TRACE(CONSTP, 2, "dmethod: %s/n",  SHOW(dm->get_code()));          for (auto const instruction : dm->get_code()->get_instructions()) {            ASSERT_NE(instruction->opcode(), OPCODE_IF_EQZ);            ASSERT_NE(instruction->opcode(), OPCODE_NEW_INSTANCE);          }        } else if (strcmp(dm->get_name()->c_str(), "propagation_2") == 0) {          TRACE(CONSTP, 2, "dmethod: %s/n",  SHOW(dm->get_code()));          for (auto const instruction : dm->get_code()->get_instructions()) {            ASSERT_NE(instruction->opcode(), OPCODE_IF_EQZ);            ASSERT_NE(instruction->opcode(), OPCODE_INVOKE_STATIC);          }        } else if(strcmp(dm->get_name()->c_str(), "propagation_3") == 0) {          TRACE(CONSTP, 2, "dmethod: %s/n",  SHOW(dm->get_code()));          for (auto const instruction : dm->get_code()->get_instructions()) {            //ASSERT_NE(instruction->opcode(), OPCODE_IF_EQZ);            //ASSERT_NE(instruction->opcode(), OPCODE_INVOKE_STATIC);          }        }      }    }  }}

TEST(uri_comparison_test, equality_test_capitalized_scheme) {  network::uri lhs("http://www.example.com/");  network::uri rhs("HTTP://www.example.com/");  ASSERT_NE(lhs.compare(rhs, network::uri_comparison_level::string_comparison), 0);}

named_temp_file::named_temp_file (const char *suffix){  m_filename = make_temp_file (suffix);  ASSERT_NE (m_filename, NULL);}

void TestRFC5424StructuredData(const char *structured_data){  enum sd_state {    INIT_STATE,    SD_ELEMENT_EMPTY,    SD_ELEMENT_BEGIN,    SD_ID_NAME,    SD_ID_ENTERPRISE_NUMBER,    SD_PARAM_NAME,    SD_PARAM_VALUE_BEGIN,    SD_PARAM_VALUE,    SD_PARAM_VALUE_END  };  enum sd_state current_state = INIT_STATE;  bool backslash_preceded = false;  std::string paramValue;  for(const char *c=structured_data; *c != '/0'; c++){    switch(current_state){      case INIT_STATE:        if(*c == '-'){          current_state = SD_ELEMENT_EMPTY;        } else if( *c == '['){          current_state = SD_ID_NAME;        }        break;      case SD_ELEMENT_EMPTY:        FAIL() << "an empty STRUCTURED-DATA had more than a '-' character";        break;      case SD_ELEMENT_BEGIN:        ASSERT_EQ(*c, '[');        current_state = SD_ID_NAME;        break;      // todo validate with RFC      case SD_ID_NAME:        if(*c == '@'){          current_state = SD_ID_ENTERPRISE_NUMBER;          break;        }        if(*c == ']'){          current_state = SD_ELEMENT_BEGIN;          break;        }        if(*c == ' '){          current_state = SD_PARAM_NAME;          break;        }        ASSERT_GT(*c, 32);        ASSERT_LT(*c, 127);        ASSERT_NE(*c, '=');        ASSERT_NE(*c, '"');        break;      // todo validate with registry      case SD_ID_ENTERPRISE_NUMBER:        if(*c == ']'){          current_state = SD_ELEMENT_BEGIN;          break;        }        if(*c == ' '){          current_state = SD_PARAM_NAME;          break;        }        ASSERT_GE(*c, '0');        ASSERT_LE(*c, '9');        break;      case SD_PARAM_NAME:        if(*c == '='){          current_state = SD_PARAM_VALUE_BEGIN;          break;        }        ASSERT_GT(*c, 32);        ASSERT_LT(*c, 127);        ASSERT_NE(*c, ' ');        ASSERT_NE(*c, ']');        ASSERT_NE(*c, '"');        break;      case SD_PARAM_VALUE_BEGIN:        ASSERT_EQ(*c, '"');        current_state = SD_PARAM_VALUE;        paramValue = std::string();        break;      case SD_PARAM_VALUE:        paramValue.push_back(*c);        if(backslash_preceded){          backslash_preceded = false;          break;        } else {          if(*c == '"'){            current_state = SD_PARAM_VALUE_END;            break;          }          ASSERT_NE(*c, '=');          ASSERT_NE(*c, ']');        }//.........这里部分代码省略.........

static bool ZbiTestNoOverflow(void) {    BEGIN_TEST;    constexpr size_t kBufferSize = 1024;    constexpr size_t kUsableBufferSize = kBufferSize / 2;    constexpr uint8_t kSentinel = 0xab;    static_assert(kBufferSize % ZBI_ALIGNMENT == 0);    static_assert(kUsableBufferSize % ZBI_ALIGNMENT == 0);    uint8_t* dst_buffer = new uint8_t[kBufferSize];    std::unique_ptr<uint8_t[]> dst_deleter;    dst_deleter.reset(dst_buffer);    memset(dst_buffer, kSentinel, kBufferSize);    uint8_t* src_buffer = new uint8_t[kBufferSize];    std::unique_ptr<uint8_t[]> src_deleter;    src_deleter.reset(src_buffer);    memset(src_buffer, kSentinel, kBufferSize);    uint8_t* test_data = new uint8_t[kUsableBufferSize];    std::unique_ptr<uint8_t[]> test_data_deleter;    test_data_deleter.reset(test_data);    memset(test_data, 0x12, kUsableBufferSize);    ASSERT_EQ(zbi_init(dst_buffer, kUsableBufferSize), ZBI_RESULT_OK);    ASSERT_EQ(zbi_init(src_buffer, kUsableBufferSize), ZBI_RESULT_OK);    ASSERT_EQ(zbi_append_section(                  src_buffer,                  kUsableBufferSize,                  kUsableBufferSize - (sizeof(zbi_header_t) * 2), // Leave room for ZBI header _and_ section header                  ZBI_TYPE_CMDLINE,                  0, // Extra                  0, // Flags                  test_data),              ZBI_RESULT_OK);    ASSERT_EQ(zbi_extend(dst_buffer, kUsableBufferSize, src_buffer), ZBI_RESULT_OK);    // Make sure we haven't trampled any bytes that we shouldn't have.    for (size_t i = kUsableBufferSize; i < kUsableBufferSize; i++) {        ASSERT_EQ(dst_buffer[i], kSentinel);    }    ASSERT_EQ(zbi_init(dst_buffer, kUsableBufferSize), ZBI_RESULT_OK);    ASSERT_EQ(zbi_init(src_buffer, kUsableBufferSize + 1), ZBI_RESULT_OK);    ASSERT_EQ(zbi_append_section(                  src_buffer,                  ZBI_ALIGN(kUsableBufferSize + 1),                  (kUsableBufferSize + 1) - (sizeof(zbi_header_t) * 2), // This payload is too big.                  ZBI_TYPE_CMDLINE,                  0, // Extra                  0, // Flags                  test_data),              ZBI_RESULT_OK);    ASSERT_NE(zbi_extend(dst_buffer, kUsableBufferSize, src_buffer), ZBI_RESULT_OK);    END_TEST;}

TEST(ListTests, TestAll) {	static TestStruct sValues[] = 	{		{ 1, 1.1 },		{ 2, 2.2 },		{ 3, 3.3 },		{ 4, 4.4 },	};	// test empty	TestList list;	TestCurrentListState(list, 0, NULL);	// test Clear() when empty	ASSERT_EQ(list.Clear(), XN_STATUS_OK);	TestCurrentListState(list, 0, NULL);	// make sure AddBefore and AddAfter fail when receiving End()	ASSERT_EQ(list.AddBefore(list.End(), sValues[0]), XN_STATUS_ILLEGAL_POSITION);	ASSERT_EQ(list.AddAfter(list.End(), sValues[0]), XN_STATUS_ILLEGAL_POSITION);	// test AddLast when empty	ASSERT_EQ(list.AddLast(sValues[0]), XN_STATUS_OK);	TestCurrentListState(list, 1, sValues);	// test Clear when only one	ASSERT_EQ(list.Clear(), XN_STATUS_OK);	TestCurrentListState(list, 0, NULL);	// test AddFirst when empty	ASSERT_EQ(list.AddFirst(sValues[2]), XN_STATUS_OK);	TestCurrentListState(list, 1, sValues + 2);	// test AddFirst when having one	ASSERT_EQ(list.AddFirst(sValues[1]), XN_STATUS_OK);	TestCurrentListState(list, 2, sValues + 1);	// test AddBefore in the beginning	ASSERT_EQ(list.AddBefore(list.Begin(), sValues[0]), XN_STATUS_OK);	TestCurrentListState(list, 3, sValues);	// test Remove by value	ASSERT_EQ(list.Remove(sValues[1]), XN_STATUS_OK);	TestStruct aTemp[] = 	{		sValues[0],		sValues[2]	};	TestCurrentListState(list, 2, aTemp);	// and Remove by iterator	ASSERT_EQ(list.Remove(++list.Begin()), XN_STATUS_OK);	TestCurrentListState(list, 1, sValues);	// test AddLast when having one	ASSERT_EQ(list.AddLast(sValues[1]), XN_STATUS_OK);	TestCurrentListState(list, 2, sValues);	// test AddAfter in the end	ASSERT_EQ(list.AddAfter(list.ReverseBegin(), sValues[2]), XN_STATUS_OK);	TestCurrentListState(list, 3, sValues);	// test AddBefore in the middle	ASSERT_EQ(list.AddBefore(++list.Begin(), sValues[3]), XN_STATUS_OK);	TestStruct aTemp2[] = 	{		sValues[0],		sValues[3],		sValues[1],		sValues[2]	};	TestCurrentListState(list, 4, aTemp2);	// remove one (needed for next test)	ASSERT_EQ(list.Remove(++list.Begin()), XN_STATUS_OK);	TestStruct aTemp3[] = 	{		sValues[0],		sValues[1],		sValues[2]	};	TestCurrentListState(list, 3, aTemp3);	// test AddAfter in the middle	ASSERT_EQ(list.AddAfter(--list.ReverseBegin(), sValues[3]), XN_STATUS_OK);	TestStruct aTemp4[] = 	{		sValues[0],		sValues[1],		sValues[3],		sValues[2]	};	TestCurrentListState(list, 4, aTemp4);	// test const Find()	const TestList& constList = list;	TestList::ConstIterator constIt = constList.Find(sValues[3]);	ASSERT_NE(constIt, constList.End());	ASSERT_EQ(constIt, --constList.ReverseBegin());//.........这里部分代码省略.........

void TestUTF8Compliance(const char *str){  // strip off the BOM if it exists  if(*str == '/xef' && *(str+1) == '/xbb' && *(str+2) == '/xbf'){    str += 3;  }  enum utf8_state {    LEAD_CHAR,    TWO_CHAR,    THREE_CHAR,    FOUR_CHAR,    FIVE_CHAR,    SIX_CHAR  };  enum utf8_state current_state = LEAD_CHAR;  size_t char_count;  char bytes[6];  for(const char *c=str; *c != '/0'; c++){    switch(current_state){      case LEAD_CHAR:        if((*c & '/xe0') == '/xc0'){          current_state = TWO_CHAR;          bytes[0] = *c & '/x1f';          break;        }        if((*c & '/xf0') == '/xe0'){          current_state = THREE_CHAR;          bytes[0] = *c & '/x0f';          char_count = 1;          break;        }        if((*c & '/xf8') == '/xf0'){          current_state = FOUR_CHAR;          bytes[0] = *c & '/x07';          char_count = 1;          break;        }        if((*c & '/xfc') == '/xf8'){          current_state = FIVE_CHAR;          bytes[0] = *c & '/x03';          char_count = 1;          break;        }        if((*c & '/xfe') == '/xfc'){          current_state = SIX_CHAR;          bytes[0] = *c & '/x01';          char_count = 1;          break;        }        ASSERT_EQ(*c & '/x80', 0) << "invalid lead byte";        break;      case TWO_CHAR:        ASSERT_EQ(*c & '/xc0', '/x80') << "invalid continuation byte";        ASSERT_NE(bytes[0] & '/x1e', 0) << "non-shortest form not allowed";        current_state = LEAD_CHAR;        break;      case THREE_CHAR:        ASSERT_EQ(*c & '/xc0', '/x80') << "invalid continuation byte";        bytes[char_count] = *c & '/x3f';        char_count++;        if(char_count == 3){          ASSERT_NE(bytes[0] | (bytes[1] & '/x20'), 0) << "non-shortest form not allowed";          current_state = LEAD_CHAR;        }        break;      case FOUR_CHAR:        ASSERT_EQ(*c & '/xc0', '/x80') << "invalid continuation byte";        bytes[char_count] = *c & '/x3f';        char_count++;        if(char_count == 4){          ASSERT_NE(bytes[0] | (bytes[1] & '/x30'), 0) << "non-shortest form not allowed";          current_state = LEAD_CHAR;        }        break;      case FIVE_CHAR:        ASSERT_EQ(*c & '/xc0', '/x80') << "invalid continuation byte";        bytes[char_count] = *c & '/x3f';        char_count++;        if(char_count == 5){          ASSERT_NE(bytes[0] | (bytes[1] & '/x38'), 0) << "non-shortest form not allowed";          current_state = LEAD_CHAR;        }        break;      case SIX_CHAR:        ASSERT_EQ(*c & '/xc0', '/x80') << "invalid continuation byte";        bytes[char_count] = *c & '/x3f';        char_count++;        if(char_count == 6){          ASSERT_NE(bytes[0] | (bytes[1] & '/x3c'), 0) << "non-shortest form not allowed";          current_state = LEAD_CHAR;        }        break;//.........这里部分代码省略.........

TEST(GapBuffer, test_constructor_a_01) {    GapBuffer<int> gb;    ASSERT_EQ(0, gb.size());    ASSERT_NE(0, gb.capacity());    ASSERT_LT(gb.size(), gb.capacity());}