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")); }
TEST_F(ExoticaTaskTest, IXT) //!< Incomplete XML Test (or reordering) { boost::shared_ptr<tinyxml2::XMLHandle> xml_handle; tinyxml2::XMLDocument doc; 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(1, task1_p_->getParameters().optimisation_window) << " : Incorrect initialisation"; //!< Incorrect Number of entries: 1 more: should not fail 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"; EXPECT_TRUE(task1_p_->initBase(*xml_handle)); EXPECT_TRUE(task1_p_->derived_called); task1_p_->clearFlags(); EXPECT_EQ(Eigen::MatrixXd::Identity(3, 3), task1_p_->getGoalWeights(0)); //!< Goal Weights not Specified 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(1, task1_p_->getParameters().optimisation_window) << " : Incorrect initialisation"; ASSERT_EQ(tinyxml2::XML_NO_ERROR, doc.LoadFile((resource_path_ + std::string("ex_task_5.xml")).c_str())); xml_handle.reset(new tinyxml2::XMLHandle(*(doc.RootElement()))); ASSERT_NE(nullptr, xml_handle)<< " : Aborting: could not initialise"; EXPECT_TRUE(task1_p_->initBase(*xml_handle)); EXPECT_TRUE(task1_p_->derived_called); task1_p_->clearFlags(); EXPECT_EQ(0, task1_p_->getGoalWeights().size()); //!< Task Weight not specified 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(1, task1_p_->getParameters().optimisation_window) << " : Incorrect initialisation"; ASSERT_EQ(tinyxml2::XML_NO_ERROR, doc.LoadFile((resource_path_ + std::string("ex_task_6.xml")).c_str())); xml_handle.reset(new tinyxml2::XMLHandle(*(doc.RootElement()))); ASSERT_NE(nullptr, xml_handle)<< " : Aborting: could not initialise"; EXPECT_TRUE(task1_p_->initBase(*xml_handle)); EXPECT_TRUE(task1_p_->derived_called); task1_p_->clearFlags(); EXPECT_EQ(0, task1_p_->getTaskWeight()); //!< Goal Not specified 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(1, task1_p_->getParameters().optimisation_window) << " : Incorrect initialisation"; ASSERT_EQ(tinyxml2::XML_NO_ERROR, doc.LoadFile((resource_path_ + std::string("ex_task_7.xml")).c_str())); xml_handle.reset(new tinyxml2::XMLHandle(*(doc.RootElement()))); ASSERT_NE(nullptr, xml_handle)<< " : Aborting: could not initialise"; EXPECT_TRUE(task1_p_->initBase(*xml_handle)); EXPECT_TRUE(task1_p_->derived_called); task1_p_->clearFlags(); EXPECT_EQ(0, task1_p_->getGoal().size()); }
/** * 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(SlotMap, ReplaceNodesAllMasters) { cerb::SlotMap slot_map; std::set<cerb::Server*> replaced = slot_map.replace_map(cerb::parse_slot_map( "21952b372055dfdb5fa25b2761857831040472e1 127.0.0.1:7001 master - 0 1428573582310 1 connected 0-3883\n" "29fa34bf473c742c91cee391a908a30eb4139292 127.0.0.1:7000 myself,master - 0 0 0 connected 3884-16383", "127.0.0.1"), nullptr); ASSERT_TRUE(replaced.empty()); for (cerb::slot s = 0; s < 3883; ++s) { cerb::Server* svr = slot_map.get_by_slot(s); ASSERT_NE(nullptr, svr) << " slot #" << s; ASSERT_EQ("127.0.0.1", svr->addr.host) << " slot #" << s; ASSERT_EQ(7001, svr->addr.port) << " slot #" << s; } for (cerb::slot s = 3884; s < 16384; ++s) { cerb::Server* svr = slot_map.get_by_slot(s); ASSERT_NE(nullptr, svr) << " slot #" << s; ASSERT_EQ("127.0.0.1", 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)); to_be_replaced.insert(slot_map.get_by_slot(3884)); 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_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(7002, 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; } to_be_replaced.clear(); 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.102:7000 master - 0 0 2 connected 0-3839\n" "933970b4fd2d1ad06166ab1d893e8cac7b129ebd 192.168.1.101:7001 master - 0 0 4 connected 3840-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 < 3840; ++s) { cerb::Server* svr = slot_map.get_by_slot(s); ASSERT_NE(nullptr, svr) << " slot #" << s; ASSERT_EQ("192.168.1.102", svr->addr.host) << " slot #" << s; ASSERT_EQ(7000, svr->addr.port) << " slot #" << s; } for (cerb::slot s = 3840; 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(7002, 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; } }
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 ANGLE TEST(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(ExoticaTaskTest, BXT) //!< Broken XML file Test { boost::shared_ptr<tinyxml2::XMLHandle> xml_handle; tinyxml2::XMLDocument doc; 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(1, task1_p_->getParameters().optimisation_window) << " : Incorrect initialisation"; //!< Wrong Entries -- GoalWeights of incorrect size ASSERT_EQ(tinyxml2::XML_NO_ERROR, doc.LoadFile((resource_path_ + std::string("ex_task_2.xml")).c_str())); xml_handle.reset(new tinyxml2::XMLHandle(*(doc.RootElement()))); ASSERT_NE(nullptr, xml_handle)<< " : Aborting: could not initialise"; EXPECT_FALSE(task1_p_->initBase(*xml_handle)); EXPECT_FALSE(task1_p_->derived_called); task1_p_->clearFlags(); //!< Wrong Entries -- GoalWeights with incorrect dimension (x) ASSERT_EQ(tinyxml2::XML_NO_ERROR, doc.LoadFile((resource_path_ + std::string("ex_task_10.xml")).c_str())); xml_handle.reset(new tinyxml2::XMLHandle(*(doc.RootElement()))); ASSERT_NE(nullptr, xml_handle)<< " : Aborting: could not initialise"; EXPECT_FALSE(task1_p_->initBase(*xml_handle)); EXPECT_FALSE(task1_p_->derived_called); task1_p_->clearFlags(); //!< Wrong Entries -- GoalWeights with no dimension ASSERT_EQ(tinyxml2::XML_NO_ERROR, doc.LoadFile((resource_path_ + std::string("ex_task_11.xml")).c_str())); xml_handle.reset(new tinyxml2::XMLHandle(*(doc.RootElement()))); ASSERT_NE(nullptr, xml_handle)<< " : Aborting: could not initialise"; EXPECT_FALSE(task1_p_->initBase(*xml_handle)); EXPECT_FALSE(task1_p_->derived_called); task1_p_->clearFlags(); //!< Wrong Entries -- Task Weight specified as string... ASSERT_EQ(tinyxml2::XML_NO_ERROR, doc.LoadFile((resource_path_ + std::string("ex_task_3.xml")).c_str())); xml_handle.reset(new tinyxml2::XMLHandle(*(doc.RootElement()))); ASSERT_NE(nullptr, xml_handle)<< " : Aborting: could not initialise"; EXPECT_FALSE(task1_p_->initBase(*xml_handle)); EXPECT_FALSE(task1_p_->derived_called); task1_p_->clearFlags(); //!< Wrong Entries -- Goal Tolerance specified with invalid character ASSERT_EQ(tinyxml2::XML_NO_ERROR, doc.LoadFile((resource_path_ + std::string("ex_task_12.xml")).c_str())); xml_handle.reset(new tinyxml2::XMLHandle(*(doc.RootElement()))); ASSERT_NE(nullptr, xml_handle)<< " : Aborting: could not initialise"; EXPECT_FALSE(task1_p_->initBase(*xml_handle)); EXPECT_FALSE(task1_p_->derived_called); task1_p_->clearFlags(); //!< Wrong Entries -- Goal specified with invalid character: will not fail since we do not know how much to read /*ASSERT_EQ(tinyxml2::XML_NO_ERROR, doc.LoadFile(resource_path_ + std::string("ex_task_13.xml").c_str())); xml_handle.reset(new tinyxml2::XMLHandle(*(doc.RootElement()))); ASSERT_NE(nullptr, xml_handle) << " : Aborting: could not initialise"; EXPECT_FALSE(task1_p_->initBase(*xml_handle)); EXPECT_FALSE(task1_p_->derived_called); task1_p_->clearFlags();*/ //!< Wrong Entries -- No Goal Tolerance specified ASSERT_EQ(tinyxml2::XML_NO_ERROR, doc.LoadFile((resource_path_ + std::string("ex_task_14.xml")).c_str())); xml_handle.reset(new tinyxml2::XMLHandle(*(doc.RootElement()))); ASSERT_NE(nullptr, xml_handle)<< " : Aborting: could not initialise"; EXPECT_FALSE(task1_p_->initBase(*xml_handle)); EXPECT_FALSE(task1_p_->derived_called); task1_p_->clearFlags(); //!< Incorrect Number of entries: 1 less ASSERT_EQ(tinyxml2::XML_NO_ERROR, doc.LoadFile((resource_path_ + std::string("ex_task_4.xml")).c_str())); xml_handle.reset(new tinyxml2::XMLHandle(*(doc.RootElement()))); params_.optimisation_window = 2; task1_p_ = boost::dynamic_pointer_cast<ExoticaTaskTest_1>( exotica::TaskCreator::Instance()->createObject("ExoticaTask_1", params_)); ASSERT_NE(nullptr, xml_handle)<< " : Aborting: could not initialise"; EXPECT_FALSE(task1_p_->initBase(*xml_handle)); EXPECT_FALSE(task1_p_->derived_called); task1_p_->clearFlags(); //!< No Time Element 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"; ASSERT_EQ(tinyxml2::XML_NO_ERROR, doc.LoadFile((resource_path_ + std::string("ex_task_8.xml")).c_str())); xml_handle.reset(new tinyxml2::XMLHandle(*(doc.RootElement()))); ASSERT_NE(nullptr, xml_handle)<< " : Aborting: could not initialise"; EXPECT_FALSE(task1_p_->initBase(*xml_handle)); EXPECT_FALSE(task1_p_->derived_called); task1_p_->clearFlags(); //!< No Task Paramaters 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"; ASSERT_EQ(tinyxml2::XML_NO_ERROR, doc.LoadFile((resource_path_ + std::string("ex_task_9.xml")).c_str())); xml_handle.reset(new tinyxml2::XMLHandle(*(doc.RootElement()))); ASSERT_NE(nullptr, xml_handle)<< " : Aborting: could not initialise"; EXPECT_FALSE(task1_p_->initBase(*xml_handle)); EXPECT_FALSE(task1_p_->derived_called); task1_p_->clearFlags(); }
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); }
TEST(uri_comparison_test, equality_empty_lhs) { network::uri lhs; network::uri rhs("http://www.example.com/"); ASSERT_NE(lhs, rhs); }
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, ']'); } if(*c == '\\'){ backslash_preceded = true; } break; case SD_PARAM_VALUE_END: TestUTF8Compliance(paramValue.c_str()); if(*c == ' '){ current_state = SD_PARAM_NAME; break; } if(*c == ']'){ current_state = SD_ELEMENT_BEGIN; break; } FAIL() << "invalid ending of PARAM-VALUE"; break; default: FAIL() << "invalid state reached during SD-ELEMENT parsing"; } } }
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(sys_mman, mmap64_std) { void* map = mmap64(NULL, 4096, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0); ASSERT_NE(MAP_FAILED, map); ASSERT_EQ(0, munmap(map, 4096)); }
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()); // and non-const Find() TestList::Iterator it = list.Find(sValues[2]); ASSERT_NE(it, list.End()); ASSERT_EQ(it, list.ReverseBegin()); // try to find something that's not in the list TestStruct notInList = { 17, 7.4 }; ASSERT_EQ(constList.Find(notInList), constList.End()); ASSERT_EQ(list.Find(notInList), list.End()); // try to remove something that's not in the list ASSERT_EQ(list.Remove(notInList), XN_STATUS_NO_MATCH); // try to remove end ASSERT_EQ(list.Remove(list.End()), XN_STATUS_ILLEGAL_POSITION); }
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; default: FAIL() << "invalid state reached during string parsing"; } } }
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()); }