Exemple #1
0
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));
}
Exemple #3
0
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);
    }
}
Exemple #4
0
TEST(stat_test, get_config) {
    stat_client cli(host(), port(), cluster_name(), timeout());
    ASSERT_NE("", cli.get_config());
}
Exemple #5
0
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());
}
Exemple #8
0
 /** 
  * 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];
 }
Exemple #9
0
 /**
  * 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;
    }
}
Exemple #11
0
 /** 
  * 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;
    }
}
Exemple #13
0
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);
}
Exemple #16
0
 /**
  * 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;
 }
Exemple #17
0
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();
}
Exemple #18
0
 /** 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);
}
Exemple #23
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);
}
Exemple #25
0
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";
    }
  }
}
Exemple #26
0
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));
}
Exemple #28
0
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);
}
Exemple #29
0
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";
    }
  }
}
Exemple #30
0
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());
}