Ejemplo n.º 1
0
TEST_F(StatusUpdateManagerTest, RetryStatusUpdate)
{
  Try<PID<Master> > master = StartMaster();
  ASSERT_SOME(master);

  MockExecutor exec(DEFAULT_EXECUTOR_ID);

  slave::Flags flags = CreateSlaveFlags();

  Try<PID<Slave> > slave = StartSlave(&exec, flags);
  ASSERT_SOME(slave);

  FrameworkInfo frameworkInfo = DEFAULT_FRAMEWORK_INFO;
  frameworkInfo.set_checkpoint(true); // Enable checkpointing.

  MockScheduler sched;
  MesosSchedulerDriver driver(
      &sched, frameworkInfo, master.get(), DEFAULT_CREDENTIAL);

  EXPECT_CALL(sched, registered(_, _, _))
    .Times(1);

  Future<vector<Offer> > offers;
  EXPECT_CALL(sched, resourceOffers(_, _))
    .WillOnce(FutureArg<1>(&offers))
    .WillRepeatedly(Return()); // Ignore subsequent offers.

  driver.start();

  AWAIT_READY(offers);
  EXPECT_NE(0u, offers.get().size());

  EXPECT_CALL(exec, registered(_, _, _, _))
    .Times(1);

  EXPECT_CALL(exec, launchTask(_, _))
    .WillOnce(SendStatusUpdateFromTask(TASK_RUNNING));

  Future<StatusUpdateMessage> statusUpdateMessage =
    DROP_PROTOBUF(StatusUpdateMessage(), master.get(), _);

  Clock::pause();

  driver.launchTasks(offers.get()[0].id(), createTasks(offers.get()[0]));

  AWAIT_READY(statusUpdateMessage);

  Future<TaskStatus> status;
  EXPECT_CALL(sched, statusUpdate(_, _))
    .WillOnce(FutureArg<1>(&status));

  Clock::advance(slave::STATUS_UPDATE_RETRY_INTERVAL_MIN);

  AWAIT_READY(status);

  EXPECT_EQ(TASK_RUNNING, status.get().state());

  Clock::resume();

  EXPECT_CALL(exec, shutdown(_))
    .Times(AtMost(1));

  driver.stop();
  driver.join();

  Shutdown();
}
Ejemplo n.º 2
0
TEST_F(APZHitTestingTester, ComplexMultiLayerTree) {
    CreateComplexMultiLayerTree();
    ScopedLayerTreeRegistration registration(manager, 0, root, mcc);
    manager->UpdateHitTestingTree(0, root, false, 0, 0);

    /* The layer tree looks like this:

                  0
          |----|--+--|----|
          1    2     4    5
               |         /|\
               3        6 8 9
                        |
                        7

       Layers 1,2 have the same APZC
       Layers 4,6,8 have the same APZC
       Layer 7 has an APZC
       Layer 9 has an APZC
    */

    TestAsyncPanZoomController* nullAPZC = nullptr;
    // Ensure all the scrollable layers have an APZC
    EXPECT_FALSE(layers[0]->HasScrollableFrameMetrics());
    EXPECT_NE(nullAPZC, ApzcOf(layers[1]));
    EXPECT_NE(nullAPZC, ApzcOf(layers[2]));
    EXPECT_FALSE(layers[3]->HasScrollableFrameMetrics());
    EXPECT_NE(nullAPZC, ApzcOf(layers[4]));
    EXPECT_FALSE(layers[5]->HasScrollableFrameMetrics());
    EXPECT_NE(nullAPZC, ApzcOf(layers[6]));
    EXPECT_NE(nullAPZC, ApzcOf(layers[7]));
    EXPECT_NE(nullAPZC, ApzcOf(layers[8]));
    EXPECT_NE(nullAPZC, ApzcOf(layers[9]));
    // Ensure those that scroll together have the same APZCs
    EXPECT_EQ(ApzcOf(layers[1]), ApzcOf(layers[2]));
    EXPECT_EQ(ApzcOf(layers[4]), ApzcOf(layers[6]));
    EXPECT_EQ(ApzcOf(layers[8]), ApzcOf(layers[6]));
    // Ensure those that don't scroll together have different APZCs
    EXPECT_NE(ApzcOf(layers[1]), ApzcOf(layers[4]));
    EXPECT_NE(ApzcOf(layers[1]), ApzcOf(layers[7]));
    EXPECT_NE(ApzcOf(layers[1]), ApzcOf(layers[9]));
    EXPECT_NE(ApzcOf(layers[4]), ApzcOf(layers[7]));
    EXPECT_NE(ApzcOf(layers[4]), ApzcOf(layers[9]));
    EXPECT_NE(ApzcOf(layers[7]), ApzcOf(layers[9]));
    // Ensure the APZC parent chains are set up correctly
    TestAsyncPanZoomController* layers1_2 = ApzcOf(layers[1]);
    TestAsyncPanZoomController* layers4_6_8 = ApzcOf(layers[4]);
    TestAsyncPanZoomController* layer7 = ApzcOf(layers[7]);
    TestAsyncPanZoomController* layer9 = ApzcOf(layers[9]);
    EXPECT_EQ(nullptr, layers1_2->GetParent());
    EXPECT_EQ(nullptr, layers4_6_8->GetParent());
    EXPECT_EQ(layers4_6_8, layer7->GetParent());
    EXPECT_EQ(nullptr, layer9->GetParent());
    // Ensure the hit-testing tree looks like the layer tree
    RefPtr<HitTestingTreeNode> root = manager->GetRootNode();
    RefPtr<HitTestingTreeNode> node5 = root->GetLastChild();
    RefPtr<HitTestingTreeNode> node4 = node5->GetPrevSibling();
    RefPtr<HitTestingTreeNode> node2 = node4->GetPrevSibling();
    RefPtr<HitTestingTreeNode> node1 = node2->GetPrevSibling();
    RefPtr<HitTestingTreeNode> node3 = node2->GetLastChild();
    RefPtr<HitTestingTreeNode> node9 = node5->GetLastChild();
    RefPtr<HitTestingTreeNode> node8 = node9->GetPrevSibling();
    RefPtr<HitTestingTreeNode> node6 = node8->GetPrevSibling();
    RefPtr<HitTestingTreeNode> node7 = node6->GetLastChild();
    EXPECT_EQ(nullptr, node1->GetPrevSibling());
    EXPECT_EQ(nullptr, node3->GetPrevSibling());
    EXPECT_EQ(nullptr, node6->GetPrevSibling());
    EXPECT_EQ(nullptr, node7->GetPrevSibling());
    EXPECT_EQ(nullptr, node1->GetLastChild());
    EXPECT_EQ(nullptr, node3->GetLastChild());
    EXPECT_EQ(nullptr, node4->GetLastChild());
    EXPECT_EQ(nullptr, node7->GetLastChild());
    EXPECT_EQ(nullptr, node8->GetLastChild());
    EXPECT_EQ(nullptr, node9->GetLastChild());

    RefPtr<AsyncPanZoomController> hit = GetTargetAPZC(ScreenPoint(25, 25));
    EXPECT_EQ(ApzcOf(layers[1]), hit.get());
    hit = GetTargetAPZC(ScreenPoint(275, 375));
    EXPECT_EQ(ApzcOf(layers[9]), hit.get());
    hit = GetTargetAPZC(ScreenPoint(250, 100));
    EXPECT_EQ(ApzcOf(layers[7]), hit.get());
}
Ejemplo n.º 3
0
TEST_F (test_StringPiece, All)
{
    std::string str = "abcdefg";
    {
        swift::StringPiece sp (str);
        ASSERT_TRUE (sp.size () == str.size ());
        ASSERT_EQ (sp.data (), sp.c_str ());
        ASSERT_EQ (sp.data (), str.c_str ());
        ASSERT_TRUE (0 == memcmp (sp.data (), str.data (), str.size ()));
        ASSERT_EQ (sp.length (), sp.size ());
        ASSERT_EQ (sp.size (), str.size ());
        ASSERT_EQ (sp.empty (), false);

        sp.Set (str.c_str ());
        ASSERT_EQ (sp.size (), str.size ());
        ASSERT_TRUE (0 == memcmp (sp.data (), str.data (), str.size ()));

        sp.Set (str.data (), str.size ());
        ASSERT_EQ (sp.size (), str.size ());
        ASSERT_TRUE (0 == memcmp (sp.data (), str.data (), str.size ()));
        for (size_t i = 0; i < str.size (); ++i) {
            ASSERT_EQ (sp[i], str[i]);
        }

        ASSERT_EQ (sp.ToString (), str);
        sp.RemovePrefix (1);
        ASSERT_EQ (sp.ToString (), "bcdefg");
        ASSERT_EQ (sp.size (), str.size () - 1);
        sp.RemoveSuffix (1);
        ASSERT_EQ (sp.ToString (), "bcdef");
        ASSERT_EQ (sp.size (), str.size () - 2);

        sp.Set (nullptr);
        ASSERT_EQ (sp.data (), nullptr);
        ASSERT_TRUE (sp.size () == 0);
        ASSERT_TRUE (sp.ToString ().empty () == true);
        ASSERT_EQ (sp.compare (sp), 0);

        sp.Set (str.c_str ());
        swift::StringPiece s1 ("abcdefg");
        ASSERT_EQ (sp.compare (s1), 0);
        s1.RemovePrefix (2);
        ASSERT_TRUE (sp.compare (s1) < 0);
        s1.Set ("abcdefghi");
        ASSERT_TRUE (sp.compare (s1) < 0);
        s1.Set (nullptr);
        ASSERT_TRUE (sp.compare (s1) > 0);

        s1.Set ("abcdefghi");
        swift::StringPiece s2 = s1;
        ASSERT_EQ (s2.capacity (), s1.size ());
        ASSERT_EQ (s2.max_size (), s1.max_size ());

        ASSERT_EQ (s2.StartWith ("abc"), true);
        ASSERT_EQ (s2.StartWith ("cb"), false);
        ASSERT_EQ (s2.EndWith ("ghi"), true);
        ASSERT_EQ (s2.EndWith ("ohg"), false);

        std::string tmp;
        s2.CopyToString (&tmp);
        ASSERT_EQ (s2.ToString (), tmp);
        tmp.clear ();
        s2.AppendToString (&tmp);
        ASSERT_EQ (s2.ToString (), tmp);
        std::string tmp2 = tmp;
        s2.clear ();
        s2.AppendToString (&tmp);
        ASSERT_EQ (tmp2, tmp);

        s2.CopyToString (&tmp);
        ASSERT_EQ (s2.empty (), true);
        ASSERT_EQ (tmp.empty (), true);
    }

    {
        swift::StringPiece sp (str.c_str (), str.size ());
        swift::StringPiece sp1 (str.c_str ());
        ASSERT_EQ (sp, sp1);
    }

    {
        swift::StringPiece sp;
        swift::StringPiece sp1 (str.begin (), str.end ());
        sp = sp1;
        ASSERT_EQ (sp, sp1);
        ASSERT_EQ (sp.size (), str.size ());
        ASSERT_EQ (sp.ToString (), str);

        std::unique_ptr<std::string::value_type> ptr (new std::string::value_type[str.size () + 1]);
        memset (ptr.get (), '\0', str.size () + 1);
        sp.copy (ptr.get (), str.size ());
        ASSERT_EQ (sp.ToString (), std::string (ptr.get ()));
        ptr.reset ();

        {
            swift::StringPiece::const_iterator spit = sp.begin ();
            std::string::const_iterator sit = str.begin ();
            for (; spit != sp.end () && sit != str.end (); ++spit, ++sit) {
                ASSERT_EQ (*spit, *sit);
            }
        }

        {
            swift::StringPiece::const_reverse_iterator spit = sp.rbegin ();
            std::string::const_reverse_iterator sit = str.rbegin ();
            for (; spit != sp.rend () && sit != str.rend (); ++spit, ++sit) {
                ASSERT_EQ (*spit, *sit);
            }
        }

        ASSERT_EQ (sp.find ('c'), str.find ('c'));
        ASSERT_EQ (sp.find ('x'), swift::StringPiece::npos);
        ASSERT_EQ (sp.find ('c', sp.size ()), swift::StringPiece::npos);
        ASSERT_EQ (sp.find ('a', sp.size () + 10), swift::StringPiece::npos);
        ASSERT_EQ (sp.find (swift::StringPiece ("xx")), swift::StringPiece::npos);
        ASSERT_EQ (sp.find (swift::StringPiece ("def")), str.find ("def"));

        ASSERT_EQ (sp.rfind ('c'), sp.find ('c'));
        ASSERT_EQ (sp.rfind (swift::StringPiece ("def")), str.find ("def"));
    }

    {
        std::string s = "abcdabcdeabcdefghijklmnop123123321";
        swift::StringPiece sp (s);
        ASSERT_EQ (sp.find_first_of ('a'), 0);
        ASSERT_EQ (sp.find_first_of ('a', 4), 4);
        ASSERT_EQ (sp.find_first_of (swift::StringPiece ()), swift::StringPiece::npos);
        ASSERT_EQ (sp.find_first_of (swift::StringPiece ("123")), s.find_first_of ("123"));

        ASSERT_EQ (sp.find_first_not_of ("abcd", 4), 8);
        ASSERT_EQ (sp.find_first_not_of ('a', 4), 5);
        ASSERT_EQ (sp.find_first_not_of ("a", 4), 5);
        ASSERT_EQ (sp.find_first_not_of (swift::StringPiece ()), 0);
        ASSERT_EQ (sp.find_first_not_of ("abcd"), s.find_first_not_of ("abcd"));

        swift::StringPiece substr = sp.substr (3, 4);
        ASSERT_EQ (substr, "dabc");

        ASSERT_EQ (sp.find_last_of ('1'), s.size () - 1);
        ASSERT_EQ (sp.find_last_of ('x'), swift::StringPiece::npos);
        ASSERT_EQ (sp.find_last_of (swift::StringPiece ()), swift::StringPiece::npos);
        ASSERT_EQ (sp.find_last_of ("123"), s.find_last_of ("123"));
        ASSERT_EQ (sp.find_last_not_of ('1'), sp.size () - 2);
        ASSERT_EQ (sp.find_last_not_of ("1"), sp.size () - 2);
        ASSERT_EQ (sp.find_last_not_of (swift::StringPiece ()), sp.size () - 1);
        ASSERT_EQ (sp.find_last_not_of ("321"), s.find_last_not_of ("321"));
        std::cout << sp << std::endl;
        ASSERT_TRUE (sp == sp);
        ASSERT_FALSE (sp != sp);
        ASSERT_FALSE (sp > sp);
        ASSERT_TRUE (sp >= sp);
        ASSERT_FALSE (sp < sp);
        ASSERT_TRUE (sp <= sp);
    }

    {
        swift::StringPiece s;
        EXPECT_EQ (5381, s.Hash ());
        const char *buf = "abdcdefg";
        s.Set (buf);
        EXPECT_NE (0, s.Hash ());

        std::unordered_map<swift::StringPiece, int> m;
        m[s] = 1;
        std::unordered_map<swift::StringPiece, int>::iterator it = m.find (s);
        EXPECT_EQ (it->second, 1);
        EXPECT_EQ (it->first, s);
    }

}
Ejemplo n.º 4
0
//-----------------------------------------------------------------------------
TEST(c_conduit_node_set, set_native_int_ptr)
{
    char  icav[6] = {-2,-4,-8,-16,-32,-64};
    short isav[6] = {-2,-4,-8,-16,-32,-64};
    int   iiav[6] = {-2,-4,-8,-16,-32,-64};
    long  ilav[6] = {-2,-4,-8,-16,-32,-64};
        
    conduit_node *n = conduit_node_create();
    
    // using char* interface
    conduit_node_set_char_ptr(n,icav,6);
    conduit_node_print(n);

    char *icav_ptr = conduit_node_as_char_ptr(n);
    for(conduit_index_t i=0;i<6;i++)
    {
        EXPECT_EQ(icav_ptr[i],icav[i]);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&icav_ptr[i],&icav[i]);
    }
    EXPECT_EQ(icav_ptr[5],-64);
    
    // using short* interface
    conduit_node_set_short_ptr(n,isav,6);
    conduit_node_print(n);
    
    short *isav_ptr = conduit_node_as_short_ptr(n);
    for(conduit_index_t i=0;i<6;i++)
    {
        EXPECT_EQ(isav_ptr[i],isav[i]);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&isav_ptr[i],&isav[i]);
    }
    EXPECT_EQ(isav_ptr[5],-64);
    
    // using int* interface
    conduit_node_set_int_ptr(n,iiav,6);
    conduit_node_print(n);

    int *iiav_ptr = conduit_node_as_int_ptr(n);
    for(conduit_index_t i=0;i<6;i++)
    {
        EXPECT_EQ(iiav_ptr[i],iiav[i]);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&iiav_ptr[i],&iiav[i]);
    }
    EXPECT_EQ(iiav_ptr[5],-64);
    
    // using long * interface
    conduit_node_set_long_ptr(n,ilav,6);
    conduit_node_print(n);
    
    long *ilav_ptr = conduit_node_as_long_ptr(n);
    for(conduit_index_t i=0;i<6;i++)
    {
        EXPECT_EQ(ilav_ptr[i],ilav[i]);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&ilav_ptr[i],&ilav[i]);
    }
    EXPECT_EQ(ilav_ptr[5],-64);
    
    conduit_node_destroy(n);
}
Ejemplo n.º 5
0
//-----------------------------------------------------------------------------
TEST(conduit_node_set, set_native_float_ptr)
{
    float   fav[4] = {-0.8, -1.6, -3.2, -6.4};
    double  dav[4] = {-0.8, -1.6, -3.2, -6.4};

    conduit_node *n = conduit_node_create();
    
    // float*
    conduit_node_set_float_ptr(n,fav,4);
    conduit_node_print(n);

    float *fav_ptr = conduit_node_as_float_ptr(n);
    for(conduit_index_t i=0;i<4;i++)
    {
        EXPECT_NEAR(fav_ptr[i],fav[i],0.001);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&fav_ptr[i],&fav[i]); 
    }
    EXPECT_NEAR(fav_ptr[3],-6.4,0.001);
    
    
    // float32 detailed
    conduit_node_set_float_ptr_detailed(n,
                                        fav,
                                        4,
                                        0,
                                        sizeof(float),
                                        sizeof(float),
                                        CONDUIT_ENDIANNESS_DEFAULT_ID);
    conduit_node_print(n);

    fav_ptr = conduit_node_as_float_ptr(n);
    for(conduit_index_t i=0;i<4;i++)
    {
        EXPECT_NEAR(fav_ptr[i],fav[i],0.001);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&fav_ptr[i],&fav[i]); 
    }
    EXPECT_NEAR(fav_ptr[3],-6.4,0.001);
    
    
    // double
    conduit_node_set_double_ptr(n,dav,4);
    conduit_node_print(n);

    double *dav_ptr = conduit_node_as_double_ptr(n);
    for(conduit_index_t i=0;i<4;i++)
    {
        EXPECT_NEAR(dav_ptr[i],dav[i],0.001);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&dav_ptr[i],&dav[i]);
    }
    EXPECT_NEAR(dav_ptr[3],-6.4,0.001);

    // float64 detailed
    conduit_node_set_double_ptr_detailed(n,
                                         dav,
                                         4,
                                         0,
                                         sizeof(double),
                                         sizeof(double),
                                         CONDUIT_ENDIANNESS_DEFAULT_ID);
    conduit_node_print(n);

    dav_ptr = conduit_node_as_double_ptr(n);
    for(conduit_index_t i=0;i<4;i++)
    {
        EXPECT_NEAR(dav_ptr[i],dav[i],0.001);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&dav_ptr[i],&dav[i]);
    }
    EXPECT_NEAR(dav_ptr[3],-6.4,0.001);


    conduit_node_destroy(n);
}
// This test verifies that when the slave re-registers, the master
// does not send TASK_LOST update for a task that has reached terminal
// state but is waiting for an acknowledgement.
TEST_F(MasterSlaveReconciliationTest, SlaveReregisterTerminalTask)
{
  Try<PID<Master> > master = StartMaster();
  ASSERT_SOME(master);

  MockExecutor exec(DEFAULT_EXECUTOR_ID);

  StandaloneMasterDetector detector(master.get());

  Try<PID<Slave> > slave = StartSlave(&exec, &detector);
  ASSERT_SOME(slave);

  MockScheduler sched;
  MesosSchedulerDriver driver(
      &sched, DEFAULT_FRAMEWORK_INFO, master.get(), DEFAULT_CREDENTIAL);

  EXPECT_CALL(sched, registered(&driver, _, _));

  Future<vector<Offer> > offers;
  EXPECT_CALL(sched, resourceOffers(&driver, _))
    .WillOnce(FutureArg<1>(&offers))
    .WillRepeatedly(Return()); // Ignore subsequent offers.

  driver.start();

  AWAIT_READY(offers);
  EXPECT_NE(0u, offers.get().size());

  TaskInfo task;
  task.set_name("test task");
  task.mutable_task_id()->set_value("1");
  task.mutable_slave_id()->MergeFrom(offers.get()[0].slave_id());
  task.mutable_resources()->MergeFrom(offers.get()[0].resources());
  task.mutable_executor()->MergeFrom(DEFAULT_EXECUTOR_INFO);

  EXPECT_CALL(exec, registered(_, _, _, _));

  // Send a terminal update right away.
  EXPECT_CALL(exec, launchTask(_, _))
    .WillOnce(SendStatusUpdateFromTask(TASK_FINISHED));

  // Drop the status update from slave to the master, so that
  // the slave has a pending terminal update when it re-registers.
  DROP_PROTOBUF(StatusUpdateMessage(), _, master.get());

  Future<Nothing> _statusUpdate = FUTURE_DISPATCH(_, &Slave::_statusUpdate);

  Future<TaskStatus> status;
  EXPECT_CALL(sched, statusUpdate(&driver, _))
    .WillOnce(FutureArg<1>(&status))
    .WillRepeatedly(Return()); // Ignore retried update due to update framework.

  driver.launchTasks(offers.get()[0].id(), {task});

  AWAIT_READY(_statusUpdate);

  Future<SlaveReregisteredMessage> slaveReregisteredMessage =
    FUTURE_PROTOBUF(SlaveReregisteredMessage(), _, _);

  // Simulate a spurious master change event (e.g., due to ZooKeeper
  // expiration) at the slave to force re-registration.
  detector.appoint(master.get());

  AWAIT_READY(slaveReregisteredMessage);

  // The master should not send a TASK_LOST after the slave
  // re-registers. We check this by calling Clock::settle() so that
  // the only update the scheduler receives is the retried
  // TASK_FINISHED update.
  // NOTE: The status update manager resends the status update when
  // it detects a new master.
  Clock::pause();
  Clock::settle();

  AWAIT_READY(status);
  ASSERT_EQ(TASK_FINISHED, status.get().state());

  EXPECT_CALL(exec, shutdown(_))
    .Times(AtMost(1));

  driver.stop();
  driver.join();

  Shutdown();
}
Ejemplo n.º 7
0
//-----------------------------------------------------------------------------
TEST(c_conduit_node_set, set_bitwidth_uint_ptr)
{
    conduit_uint8    u8av[6] = {2,4,8,16,32,64};
    conduit_uint16  u16av[6] = {2,4,8,16,32,64};
    conduit_uint32  u32av[6] = {2,4,8,16,32,64};
    conduit_uint64  u64av[6] = {2,4,8,16,32,64};
        
    conduit_node *n = conduit_node_create();
    
    // using uint8* interface
    conduit_node_set_uint8_ptr(n,u8av,6);
    conduit_node_print(n);

    conduit_uint8 *u8av_ptr = conduit_node_as_uint8_ptr(n);
    for(conduit_index_t i=0;i<6;i++)
    {
        EXPECT_EQ(u8av_ptr[i],u8av[i]);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&u8av_ptr[i],&u8av[i]);
    }
    EXPECT_EQ(u8av_ptr[5],64);
    
    // using uint16* interface
    conduit_node_set_uint16_ptr(n,u16av,6);
    conduit_node_print(n);
    
    conduit_uint16 *u16av_ptr = conduit_node_as_uint16_ptr(n);
    for(conduit_index_t i=0;i<6;i++)
    {
        EXPECT_EQ(u16av_ptr[i],u16av[i]);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&u16av_ptr[i],&u16av[i]);
    }
    EXPECT_EQ(u16av_ptr[5],64);
    
    // using uint32 * interface
    conduit_node_set_uint32_ptr(n,u32av,6);
    conduit_node_print(n);

    conduit_uint32 *u32av_ptr = conduit_node_as_uint32_ptr(n);
    for(conduit_index_t i=0;i<6;i++)
    {
        EXPECT_EQ(u32av_ptr[i],u32av[i]);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&u32av_ptr[i],&u32av[i]);
    }
    EXPECT_EQ(u32av_ptr[5],64);
    
    // using uint64 * interface
    conduit_node_set_uint64_ptr(n,u64av,6);
    conduit_node_print(n);
    
    conduit_uint64 *u64av_ptr = conduit_node_as_uint64_ptr(n);
    for(conduit_index_t i=0;i<6;i++)
    {
        EXPECT_EQ(u64av_ptr[i],u64av[i]);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&u64av_ptr[i],&u64av[i]);
    }
    EXPECT_EQ(u64av_ptr[5],64);

    conduit_node_destroy(n);
}
Ejemplo n.º 8
0
TEST_F(StatusUpdateManagerTest, CheckpointStatusUpdate)
{
  Try<PID<Master> > master = StartMaster();
  ASSERT_SOME(master);

  MockExecutor exec(DEFAULT_EXECUTOR_ID);

  // Require flags to retrieve work_dir when recovering
  // the checkpointed data.
  slave::Flags flags = CreateSlaveFlags();

  Try<PID<Slave> > slave = StartSlave(&exec, flags);
  ASSERT_SOME(slave);

  FrameworkInfo frameworkInfo = DEFAULT_FRAMEWORK_INFO;
  frameworkInfo.set_checkpoint(true); // Enable checkpointing.

  MockScheduler sched;
  MesosSchedulerDriver driver(
      &sched, frameworkInfo, master.get(), DEFAULT_CREDENTIAL);

  Future<FrameworkID> frameworkId;
  EXPECT_CALL(sched, registered(_, _, _))
    .WillOnce(FutureArg<1>(&frameworkId));

  Future<vector<Offer> > offers;
  EXPECT_CALL(sched, resourceOffers(_, _))
    .WillOnce(FutureArg<1>(&offers))
    .WillRepeatedly(Return()); // Ignore subsequent offers.

  driver.start();

  AWAIT_READY(frameworkId);
  AWAIT_READY(offers);
  EXPECT_NE(0u, offers.get().size());

  EXPECT_CALL(exec, registered(_, _, _, _))
    .Times(1);

  EXPECT_CALL(exec, launchTask(_, _))
    .WillOnce(SendStatusUpdateFromTask(TASK_RUNNING));

  Future<TaskStatus> status;
  EXPECT_CALL(sched, statusUpdate(_, _))
    .WillOnce(FutureArg<1>(&status));

  Future<Nothing> _statusUpdateAcknowledgement =
    FUTURE_DISPATCH(slave.get(), &Slave::_statusUpdateAcknowledgement);

  driver.launchTasks(offers.get()[0].id(), createTasks(offers.get()[0]));

  AWAIT_READY(status);
  EXPECT_EQ(TASK_RUNNING, status.get().state());

  AWAIT_READY(_statusUpdateAcknowledgement);

  // Ensure that both the status update and its acknowledgement are
  // correctly checkpointed.
  Result<slave::state::State> state =
    slave::state::recover(slave::paths::getMetaRootDir(flags.work_dir), true);

  ASSERT_SOME(state);
  ASSERT_SOME(state.get().slave);
  ASSERT_TRUE(state.get().slave.get().frameworks.contains(frameworkId.get()));

  slave::state::FrameworkState frameworkState =
    state.get().slave.get().frameworks.get(frameworkId.get()).get();

  ASSERT_EQ(1u, frameworkState.executors.size());

  slave::state::ExecutorState executorState =
    frameworkState.executors.begin()->second;

  ASSERT_EQ(1u, executorState.runs.size());

  slave::state::RunState runState = executorState.runs.begin()->second;

  ASSERT_EQ(1u, runState.tasks.size());

  slave::state::TaskState taskState = runState.tasks.begin()->second;

  EXPECT_EQ(1u, taskState.updates.size());
  EXPECT_EQ(1u, taskState.acks.size());

  EXPECT_CALL(exec, shutdown(_))
    .Times(AtMost(1));

  driver.stop();
  driver.join();

  Shutdown();
}
Ejemplo n.º 9
0
static void*
error_test_thread(void) {
	error_context_t* context = 0;

	EXPECT_EQ(error(), ERROR_NONE);
	EXPECT_EQ(error(), ERROR_NONE);

	error_report(ERRORLEVEL_WARNING, ERROR_ACCESS_DENIED);
	EXPECT_EQ(error(), ERROR_ACCESS_DENIED);
	EXPECT_EQ(error(), ERROR_NONE);

	error_report(ERRORLEVEL_ERROR, ERROR_INVALID_VALUE);
	EXPECT_EQ(error(), ERROR_INVALID_VALUE);
	EXPECT_EQ(error(), ERROR_NONE);

	context = error_context();
	if (context)
		EXPECT_EQ(context->depth, 0);

	error_context_push(STRING_CONST("error test"), STRING_CONST("data"));
	context = error_context();

#if BUILD_ENABLE_ERROR_CONTEXT
	EXPECT_NE(context, 0);
	EXPECT_EQ(context->depth, 1);
	EXPECT_CONSTSTRINGEQ(context->frame[0].name, string_const(STRING_CONST("error test")));
	EXPECT_CONSTSTRINGEQ(context->frame[0].data, string_const(STRING_CONST("data")));
#else
	EXPECT_EQ(context, 0);
#endif

	error_context_pop();
	context = error_context();

#if BUILD_ENABLE_ERROR_CONTEXT
	EXPECT_NE(context, 0);
	EXPECT_EQ(context->depth, 0);
#else
	EXPECT_EQ(context, 0);
#endif

	error_context_push(STRING_CONST("error test"), STRING_CONST("data"));
	error_context_push(STRING_CONST("another test"), STRING_CONST("more data"));
	context = error_context();

#if BUILD_ENABLE_ERROR_CONTEXT
	EXPECT_NE(context, 0);
	EXPECT_EQ(context->depth, 2);
	EXPECT_CONSTSTRINGEQ(context->frame[0].name, string_const(STRING_CONST("error test")));
	EXPECT_CONSTSTRINGEQ(context->frame[0].data, string_const(STRING_CONST("data")));
	EXPECT_CONSTSTRINGEQ(context->frame[1].name, string_const(STRING_CONST("another test")));
	EXPECT_CONSTSTRINGEQ(context->frame[1].data, string_const(STRING_CONST("more data")));
#else
	EXPECT_EQ(context, 0);
#endif

	error_context_pop();
	context = error_context();

#if BUILD_ENABLE_ERROR_CONTEXT
	EXPECT_NE(context, 0);
	EXPECT_EQ(context->depth, 1);
	EXPECT_CONSTSTRINGEQ(context->frame[0].name, string_const(STRING_CONST("error test")));
	EXPECT_CONSTSTRINGEQ(context->frame[0].data, string_const(STRING_CONST("data")));
#else
	EXPECT_EQ(context, 0);
#endif

	error_context_pop();

	return 0;
}
Ejemplo n.º 10
0
// This test verifies that the slave and status update manager
// properly handle duplicate status updates, when the second
// update with the same UUID is received before the ACK for the
// first update. The proper behavior here is for the status update
// manager to drop the duplicate update.
TEST_F(StatusUpdateManagerTest, DuplicateUpdateBeforeAck)
{
  Try<PID<Master> > master = StartMaster();
  ASSERT_SOME(master);

  MockExecutor exec(DEFAULT_EXECUTOR_ID);

  Try<PID<Slave> > slave = StartSlave(&exec);
  ASSERT_SOME(slave);

  FrameworkInfo frameworkInfo = DEFAULT_FRAMEWORK_INFO;
  frameworkInfo.set_checkpoint(true); // Enable checkpointing.

  MockScheduler sched;
  MesosSchedulerDriver driver(
      &sched, frameworkInfo, master.get(), DEFAULT_CREDENTIAL);

  FrameworkID frameworkId;
  EXPECT_CALL(sched, registered(_, _, _))
    .WillOnce(SaveArg<1>(&frameworkId));

  Future<vector<Offer> > offers;
  EXPECT_CALL(sched, resourceOffers(_, _))
    .WillOnce(FutureArg<1>(&offers))
    .WillRepeatedly(Return()); // Ignore subsequent offers.

  driver.start();

  AWAIT_READY(offers);
  EXPECT_NE(0u, offers.get().size());

  ExecutorDriver* execDriver;
  EXPECT_CALL(exec, registered(_, _, _, _))
    .WillOnce(SaveArg<0>(&execDriver));

  EXPECT_CALL(exec, launchTask(_, _))
    .WillOnce(SendStatusUpdateFromTask(TASK_RUNNING));

  // Capture the first status update message.
  Future<StatusUpdateMessage> statusUpdateMessage =
    FUTURE_PROTOBUF(StatusUpdateMessage(), _, _);

  Future<TaskStatus> status;
  EXPECT_CALL(sched, statusUpdate(_, _))
    .WillOnce(FutureArg<1>(&status));

  // Drop the first ACK from the scheduler to the slave.
  Future<StatusUpdateAcknowledgementMessage> statusUpdateAckMessage =
    DROP_PROTOBUF(StatusUpdateAcknowledgementMessage(), _, slave.get());

  Clock::pause();

  driver.launchTasks(offers.get()[0].id(), createTasks(offers.get()[0]));

  AWAIT_READY(statusUpdateMessage);

  AWAIT_READY(status);

  EXPECT_EQ(TASK_RUNNING, status.get().state());

  AWAIT_READY(statusUpdateAckMessage);

  Future<Nothing> __statusUpdate =
    FUTURE_DISPATCH(slave.get(), &Slave::__statusUpdate);

  // Now resend the TASK_RUNNING update.
  process::post(slave.get(), statusUpdateMessage.get());

  // At this point the status update manager has handled
  // the duplicate status update.
  AWAIT_READY(__statusUpdate);

  // After we advance the clock, the status update manager should
  // retry the TASK_RUNNING update and the scheduler should receive
  // and acknowledge it.
  Future<TaskStatus> update;
  EXPECT_CALL(sched, statusUpdate(_, _))
    .WillOnce(FutureArg<1>(&update));

  Clock::advance(slave::STATUS_UPDATE_RETRY_INTERVAL_MIN);
  Clock::settle();

  // Ensure the scheduler receives TASK_FINISHED.
  AWAIT_READY(update);
  EXPECT_EQ(TASK_RUNNING, update.get().state());

  EXPECT_CALL(exec, shutdown(_))
    .Times(AtMost(1));

  Clock::resume();

  driver.stop();
  driver.join();

  Shutdown();
}
Ejemplo n.º 11
0
// This test verifies that if master receives a status update
// for an already terminated task it forwards it without
// changing the state of the task.
TEST_F(StatusUpdateManagerTest, DuplicatedTerminalStatusUpdate)
{
  Try<PID<Master> > master = StartMaster();
  ASSERT_SOME(master);

  MockExecutor exec(DEFAULT_EXECUTOR_ID);

  Try<PID<Slave>> slave = StartSlave(&exec);
  ASSERT_SOME(slave);

  FrameworkInfo frameworkInfo = DEFAULT_FRAMEWORK_INFO;
  frameworkInfo.set_checkpoint(true); // Enable checkpointing.

  MockScheduler sched;
  MesosSchedulerDriver driver(
      &sched, frameworkInfo, master.get(), DEFAULT_CREDENTIAL);

  FrameworkID frameworkId;
  EXPECT_CALL(sched, registered(_, _, _))
    .WillOnce(SaveArg<1>(&frameworkId));

  Future<vector<Offer> > offers;
  EXPECT_CALL(sched, resourceOffers(_, _))
    .WillOnce(FutureArg<1>(&offers))
    .WillRepeatedly(Return()); // Ignore subsequent offers.

  driver.start();

  AWAIT_READY(offers);
  EXPECT_NE(0u, offers.get().size());

  ExecutorDriver* execDriver;
  EXPECT_CALL(exec, registered(_, _, _, _))
    .WillOnce(SaveArg<0>(&execDriver));

  // Send a terminal update right away.
  EXPECT_CALL(exec, launchTask(_, _))
    .WillOnce(SendStatusUpdateFromTask(TASK_FINISHED));

  Future<TaskStatus> status;
  EXPECT_CALL(sched, statusUpdate(_, _))
    .WillOnce(FutureArg<1>(&status));

  Future<Nothing> _statusUpdateAcknowledgement =
    FUTURE_DISPATCH(slave.get(), &Slave::_statusUpdateAcknowledgement);

  driver.launchTasks(offers.get()[0].id(), createTasks(offers.get()[0]));

  AWAIT_READY(status);

  EXPECT_EQ(TASK_FINISHED, status.get().state());

  AWAIT_READY(_statusUpdateAcknowledgement);

  Future<TaskStatus> update;
  EXPECT_CALL(sched, statusUpdate(_, _))
    .WillOnce(FutureArg<1>(&update));

  Future<Nothing> _statusUpdateAcknowledgement2 =
    FUTURE_DISPATCH(slave.get(), &Slave::_statusUpdateAcknowledgement);

  Clock::pause();

  // Now send a TASK_KILLED update for the same task.
  TaskStatus status2 = status.get();
  status2.set_state(TASK_KILLED);
  execDriver->sendStatusUpdate(status2);

  // Ensure the scheduler receives TASK_KILLED.
  AWAIT_READY(update);
  EXPECT_EQ(TASK_KILLED, update.get().state());

  // Ensure the slave properly handles the ACK.
  // Clock::settle() ensures that the slave successfully
  // executes Slave::_statusUpdateAcknowledgement().
  AWAIT_READY(_statusUpdateAcknowledgement2);

  // Verify the latest task status.
  Future<process::http::Response> tasks =
    process::http::get(master.get(), "tasks");

  AWAIT_EXPECT_RESPONSE_STATUS_EQ(process::http::OK().status, tasks);
  AWAIT_EXPECT_RESPONSE_HEADER_EQ(APPLICATION_JSON, "Content-Type", tasks);

  Try<JSON::Object> parse = JSON::parse<JSON::Object>(tasks.get().body);
  ASSERT_SOME(parse);

  Result<JSON::String> state = parse.get().find<JSON::String>("tasks[0].state");

  ASSERT_SOME_EQ(JSON::String("TASK_FINISHED"), state);

  Clock::resume();

  EXPECT_CALL(exec, shutdown(_))
    .Times(AtMost(1));

  driver.stop();
  driver.join();

  Shutdown();
}
Ejemplo n.º 12
0
// This test verifies that the slave and status update manager
// properly handle duplicate terminal status updates, when the
// second update is received after the ACK for the first update.
// The proper behavior here is for the status update manager to
// forward the duplicate update to the scheduler.
TEST_F(StatusUpdateManagerTest, DuplicateTerminalUpdateAfterAck)
{
  Try<PID<Master> > master = StartMaster();
  ASSERT_SOME(master);

  MockExecutor exec(DEFAULT_EXECUTOR_ID);

  slave::Flags flags = CreateSlaveFlags();

  Try<PID<Slave> > slave = StartSlave(&exec, flags);
  ASSERT_SOME(slave);

  FrameworkInfo frameworkInfo = DEFAULT_FRAMEWORK_INFO;
  frameworkInfo.set_checkpoint(true); // Enable checkpointing.

  MockScheduler sched;
  MesosSchedulerDriver driver(
      &sched, frameworkInfo, master.get(), DEFAULT_CREDENTIAL);

  FrameworkID frameworkId;
  EXPECT_CALL(sched, registered(_, _, _))
    .WillOnce(SaveArg<1>(&frameworkId));

  Future<vector<Offer> > offers;
  EXPECT_CALL(sched, resourceOffers(_, _))
    .WillOnce(FutureArg<1>(&offers))
    .WillRepeatedly(Return()); // Ignore subsequent offers.

  driver.start();

  AWAIT_READY(offers);
  EXPECT_NE(0u, offers.get().size());

  ExecutorDriver* execDriver;
  EXPECT_CALL(exec, registered(_, _, _, _))
    .WillOnce(SaveArg<0>(&execDriver));

  // Send a terminal update right away.
  EXPECT_CALL(exec, launchTask(_, _))
    .WillOnce(SendStatusUpdateFromTask(TASK_FINISHED));

  Future<TaskStatus> status;
  EXPECT_CALL(sched, statusUpdate(_, _))
    .WillOnce(FutureArg<1>(&status));

  Future<Nothing> _statusUpdateAcknowledgement =
    FUTURE_DISPATCH(slave.get(), &Slave::_statusUpdateAcknowledgement);

  driver.launchTasks(offers.get()[0].id(), createTasks(offers.get()[0]));

  AWAIT_READY(status);

  EXPECT_EQ(TASK_FINISHED, status.get().state());

  AWAIT_READY(_statusUpdateAcknowledgement);

  Future<TaskStatus> update;
  EXPECT_CALL(sched, statusUpdate(_, _))
    .WillOnce(FutureArg<1>(&update));

  Future<Nothing> _statusUpdateAcknowledgement2 =
    FUTURE_DISPATCH(slave.get(), &Slave::_statusUpdateAcknowledgement);

  Clock::pause();

  // Now send a TASK_KILLED update for the same task.
  TaskStatus status2 = status.get();
  status2.set_state(TASK_KILLED);
  execDriver->sendStatusUpdate(status2);

  // Ensure the scheduler receives TASK_KILLED.
  AWAIT_READY(update);
  EXPECT_EQ(TASK_KILLED, update.get().state());

  // Ensure the slave properly handles the ACK.
  // Clock::settle() ensures that the slave successfully
  // executes Slave::_statusUpdateAcknowledgement().
  AWAIT_READY(_statusUpdateAcknowledgement2);
  Clock::settle();

  Clock::resume();

  EXPECT_CALL(exec, shutdown(_))
    .Times(AtMost(1));

  driver.stop();
  driver.join();

  Shutdown();
}
Ejemplo n.º 13
0
// This test verifies that status update manager ignores
// unexpected ACK for an earlier update when it is waiting
// for an ACK for another update. We do this by dropping ACKs
// for the original update and sending a random ACK to the slave.
TEST_F(StatusUpdateManagerTest, IgnoreUnexpectedStatusUpdateAck)
{
  Try<PID<Master> > master = StartMaster();
  ASSERT_SOME(master);

  MockExecutor exec(DEFAULT_EXECUTOR_ID);

  Try<PID<Slave> > slave = StartSlave(&exec);
  ASSERT_SOME(slave);

  FrameworkInfo frameworkInfo = DEFAULT_FRAMEWORK_INFO;
  frameworkInfo.set_checkpoint(true); // Enable checkpointing.

  MockScheduler sched;
  MesosSchedulerDriver driver(
      &sched, frameworkInfo, master.get(), DEFAULT_CREDENTIAL);

  FrameworkID frameworkId;
  EXPECT_CALL(sched, registered(_, _, _))
    .WillOnce(SaveArg<1>(&frameworkId));

  Future<vector<Offer> > offers;
  EXPECT_CALL(sched, resourceOffers(_, _))
    .WillOnce(FutureArg<1>(&offers))
    .WillRepeatedly(Return()); // Ignore subsequent offers.

  Future<TaskStatus> status;
  EXPECT_CALL(sched, statusUpdate(_, _))
    .WillOnce(FutureArg<1>(&status));

  driver.start();

  AWAIT_READY(offers);
  EXPECT_NE(0u, offers.get().size());

  ExecutorDriver* execDriver;
  EXPECT_CALL(exec, registered(_, _, _, _))
      .WillOnce(SaveArg<0>(&execDriver));

  EXPECT_CALL(exec, launchTask(_, _))
    .WillOnce(SendStatusUpdateFromTask(TASK_RUNNING));

  Future<StatusUpdateMessage> statusUpdateMessage =
    FUTURE_PROTOBUF(StatusUpdateMessage(), master.get(), _);

  // Drop the ACKs, so that status update manager
  // retries the update.
  DROP_CALLS(mesos::scheduler::Call(),
             mesos::scheduler::Call::ACKNOWLEDGE,
             _,
             master.get());

  driver.launchTasks(offers.get()[0].id(), createTasks(offers.get()[0]));

  AWAIT_READY(statusUpdateMessage);
  StatusUpdate update = statusUpdateMessage.get().update();

  AWAIT_READY(status);

  EXPECT_EQ(TASK_RUNNING, status.get().state());

  Future<Nothing> unexpectedAck =
      FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);

  // Now send an ACK with a random UUID.
  process::dispatch(
      slave.get(),
      &Slave::statusUpdateAcknowledgement,
      master.get(),
      update.slave_id(),
      frameworkId,
      update.status().task_id(),
      UUID::random().toBytes());

  AWAIT_READY(unexpectedAck);

  EXPECT_CALL(exec, shutdown(_))
    .Times(AtMost(1));

  driver.stop();
  driver.join();

  Shutdown();
}
Ejemplo n.º 14
0
// This test verifies that status update manager ignores
// duplicate ACK for an earlier update when it is waiting
// for an ACK for a later update. This could happen when the
// duplicate ACK is for a retried update.
TEST_F(StatusUpdateManagerTest, IgnoreDuplicateStatusUpdateAck)
{
  Try<PID<Master> > master = StartMaster();
  ASSERT_SOME(master);

  MockExecutor exec(DEFAULT_EXECUTOR_ID);

  Try<PID<Slave> > slave = StartSlave(&exec);
  ASSERT_SOME(slave);

  FrameworkInfo frameworkInfo = DEFAULT_FRAMEWORK_INFO;
  frameworkInfo.set_checkpoint(true); // Enable checkpointing.

  MockScheduler sched;
  MesosSchedulerDriver driver(
      &sched, frameworkInfo, master.get(), DEFAULT_CREDENTIAL);

  FrameworkID frameworkId;
  EXPECT_CALL(sched, registered(_, _, _))
    .WillOnce(SaveArg<1>(&frameworkId));

  Future<vector<Offer> > offers;
  EXPECT_CALL(sched, resourceOffers(_, _))
    .WillOnce(FutureArg<1>(&offers))
    .WillRepeatedly(Return()); // Ignore subsequent offers.

  driver.start();

  AWAIT_READY(offers);
  EXPECT_NE(0u, offers.get().size());

  ExecutorDriver* execDriver;
  EXPECT_CALL(exec, registered(_, _, _, _))
      .WillOnce(SaveArg<0>(&execDriver));

  EXPECT_CALL(exec, launchTask(_, _))
    .WillOnce(SendStatusUpdateFromTask(TASK_RUNNING));

  // Drop the first update, so that status update manager
  // resends the update.
  Future<StatusUpdateMessage> statusUpdateMessage =
    DROP_PROTOBUF(StatusUpdateMessage(), master.get(), _);

  Clock::pause();

  driver.launchTasks(offers.get()[0].id(), createTasks(offers.get()[0]));

  AWAIT_READY(statusUpdateMessage);
  StatusUpdate update = statusUpdateMessage.get().update();

  Future<TaskStatus> status;
  EXPECT_CALL(sched, statusUpdate(_, _))
    .WillOnce(FutureArg<1>(&status));

  // This is the ACK for the retried update.
  Future<Nothing> ack =
    FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);

  Clock::advance(slave::STATUS_UPDATE_RETRY_INTERVAL_MIN);

  AWAIT_READY(status);

  EXPECT_EQ(TASK_RUNNING, status.get().state());

  AWAIT_READY(ack);

  // Now send TASK_FINISHED update so that the status update manager
  // is waiting for its ACK, which it never gets because we drop the
  // update.
  DROP_PROTOBUFS(StatusUpdateMessage(), master.get(), _);

  Future<Nothing> update2 = FUTURE_DISPATCH(_, &Slave::_statusUpdate);

  TaskStatus status2 = status.get();
  status2.set_state(TASK_FINISHED);

  execDriver->sendStatusUpdate(status2);

  AWAIT_READY(update2);

  // This is to catch the duplicate ack for TASK_RUNNING.
  Future<Nothing> duplicateAck =
      FUTURE_DISPATCH(_, &Slave::_statusUpdateAcknowledgement);

  // Now send a duplicate ACK for the TASK_RUNNING update.
  process::dispatch(
      slave.get(),
      &Slave::statusUpdateAcknowledgement,
      master.get(),
      update.slave_id(),
      frameworkId,
      update.status().task_id(),
      update.uuid());

  AWAIT_READY(duplicateAck);

  Clock::resume();

  EXPECT_CALL(exec, shutdown(_))
    .Times(AtMost(1));

  driver.stop();
  driver.join();

  Shutdown();
}
// This test verifies that the master reconciles tasks that are
// missing from a re-registering slave. In this case, we trigger
// a race between the slave re-registration message and the launch
// message. There should be no TASK_LOST.
// This was motivated by MESOS-1696.
TEST_F(MasterSlaveReconciliationTest, ReconcileRace)
{
  Try<PID<Master> > master = StartMaster();
  ASSERT_SOME(master);

  MockExecutor exec(DEFAULT_EXECUTOR_ID);

  StandaloneMasterDetector detector(master.get());

  Future<SlaveRegisteredMessage> slaveRegisteredMessage =
    FUTURE_PROTOBUF(SlaveRegisteredMessage(), master.get(), _);

  Try<PID<Slave> > slave = StartSlave(&exec, &detector);
  ASSERT_SOME(slave);

  AWAIT_READY(slaveRegisteredMessage);

  MockScheduler sched;
  MesosSchedulerDriver driver(
      &sched, DEFAULT_FRAMEWORK_INFO, master.get(), DEFAULT_CREDENTIAL);

  EXPECT_CALL(sched, registered(&driver, _, _));

  Future<vector<Offer> > offers;
  EXPECT_CALL(sched, resourceOffers(&driver, _))
    .WillOnce(FutureArg<1>(&offers))
    .WillRepeatedly(Return()); // Ignore subsequent offers.

  driver.start();

  // Trigger a re-registration of the slave and capture the message
  // so that we can spoof a race with a launch task message.
  DROP_PROTOBUFS(ReregisterSlaveMessage(), slave.get(), master.get());

  Future<ReregisterSlaveMessage> reregisterSlaveMessage =
    DROP_PROTOBUF(ReregisterSlaveMessage(), slave.get(), master.get());

  detector.appoint(master.get());

  AWAIT_READY(reregisterSlaveMessage);

  AWAIT_READY(offers);
  EXPECT_NE(0u, offers.get().size());

  TaskInfo task;
  task.set_name("test task");
  task.mutable_task_id()->set_value("1");
  task.mutable_slave_id()->MergeFrom(offers.get()[0].slave_id());
  task.mutable_resources()->MergeFrom(offers.get()[0].resources());
  task.mutable_executor()->MergeFrom(DEFAULT_EXECUTOR_INFO);

  ExecutorDriver* executorDriver;
  EXPECT_CALL(exec, registered(_, _, _, _))
    .WillOnce(SaveArg<0>(&executorDriver));

  // Leave the task in TASK_STAGING.
  Future<Nothing> launchTask;
  EXPECT_CALL(exec, launchTask(_, _))
    .WillOnce(FutureSatisfy(&launchTask));

  EXPECT_CALL(sched, statusUpdate(&driver, _))
    .Times(0);

  driver.launchTasks(offers.get()[0].id(), {task});

  AWAIT_READY(launchTask);

  // Send the stale re-registration message, which does not contain
  // the task we just launched. This will trigger a reconciliation
  // by the master.
  Future<SlaveReregisteredMessage> slaveReregisteredMessage =
    FUTURE_PROTOBUF(SlaveReregisteredMessage(), _, _);

  // Prevent this from being dropped per the DROP_PROTOBUFS above.
  FUTURE_PROTOBUF(ReregisterSlaveMessage(), slave.get(), master.get());

  process::post(slave.get(), master.get(), reregisterSlaveMessage.get());

  AWAIT_READY(slaveReregisteredMessage);

  // Neither the master nor the slave should not send a TASK_LOST
  // as part of the reconciliation. We check this by calling
  // Clock::settle() to flush all pending events.
  Clock::pause();
  Clock::settle();
  Clock::resume();

  // Now send TASK_FINISHED and make sure it's the only message
  // received by the scheduler.
  Future<TaskStatus> status;
  EXPECT_CALL(sched, statusUpdate(&driver, _))
    .WillOnce(FutureArg<1>(&status));

  TaskStatus taskStatus;
  taskStatus.mutable_task_id()->CopyFrom(task.task_id());
  taskStatus.set_state(TASK_FINISHED);
  executorDriver->sendStatusUpdate(taskStatus);

  AWAIT_READY(status);
  ASSERT_EQ(TASK_FINISHED, status.get().state());

  EXPECT_CALL(exec, shutdown(_))
    .Times(AtMost(1));

  driver.stop();
  driver.join();

  Shutdown();
}
Ejemplo n.º 16
0
DECLARE_TEST(error, output) {
#if BUILD_ENABLE_LOG
	error_callback_fn callback_error = error_callback();
	log_callback_fn callback_log = log_callback();
	string_const_t shortmsg = string_const(STRING_CONST("Short message with prefix"));
    string_const_t longmsg = string_const(STRING_CONST("Longer message which should be output without a prefix"));

	error_set_callback(ignore_error_handler);
	log_set_callback(log_verify_callback);

    log_enable_stdout(false);
    log_warn(HASH_TEST, WARNING_SUSPICIOUS, STRING_ARGS(shortmsg));
    log_enable_stdout(true);
	EXPECT_EQ(_last_log_context, HASH_TEST);
	EXPECT_EQ(_last_log_severity, ERRORLEVEL_WARNING);
	EXPECT_GE(_last_log_length, shortmsg.length);
	EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(shortmsg), 0), STRING_NPOS);
	EXPECT_GT(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(shortmsg), 0), 0);
	EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_CONST("WARNING [suspicious]"), 0), STRING_NPOS);

	_last_log_context = 0;
	_last_log_severity = ERRORLEVEL_NONE;
	_last_log_msg = nullptr;
	_last_log_length = 0;

    log_enable_stdout(false);
	log_warn(HASH_TEST, (warning_t)0x1000, STRING_ARGS(shortmsg));
    log_enable_stdout(true);
	EXPECT_EQ(_last_log_context, HASH_TEST);
	EXPECT_EQ(_last_log_severity, ERRORLEVEL_WARNING);
	EXPECT_GE(_last_log_length, shortmsg.length);
	EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(shortmsg), 0), STRING_NPOS);
	EXPECT_GT(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(shortmsg), 0), 0);
	EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_CONST("WARNING [4096]"), 0), STRING_NPOS);

	_last_log_context = 0;
	_last_log_severity = ERRORLEVEL_NONE;
	_last_log_msg = nullptr;
	_last_log_length = 0;

    log_enable_prefix(false);
    log_enable_stdout(false);
	log_warn(HASH_TEST, WARNING_SYSTEM_CALL_FAIL, STRING_ARGS(longmsg));
    log_enable_stdout(true);
    log_enable_prefix(true);
	EXPECT_EQ(_last_log_context, HASH_TEST);
	EXPECT_EQ(_last_log_severity, ERRORLEVEL_WARNING);
	EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(longmsg), 0), STRING_NPOS);
	EXPECT_GT(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(longmsg), 0), 0);

	_last_log_context = 0;
	_last_log_severity = ERRORLEVEL_NONE;
	_last_log_msg = nullptr;
	_last_log_length = 0;

    log_enable_stdout(false);
	log_error(HASH_TEST, ERROR_DEPRECATED, STRING_ARGS(shortmsg));
    log_enable_stdout(true);
	EXPECT_EQ(_last_log_context, HASH_TEST);
	EXPECT_EQ(_last_log_severity, ERRORLEVEL_ERROR);
	EXPECT_GE(_last_log_length, shortmsg.length);
	EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(shortmsg), 0), STRING_NPOS);
	EXPECT_GT(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(shortmsg), 0), 0);
	EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_CONST("ERROR [deprecated]"), 0), STRING_NPOS);

	_last_log_context = 0;
	_last_log_severity = ERRORLEVEL_NONE;
	_last_log_msg = nullptr;
	_last_log_length = 0;

    log_enable_stdout(false);
	log_error(HASH_TEST, (error_t)0x1000, STRING_ARGS(shortmsg));
    log_enable_stdout(true);
	EXPECT_EQ(_last_log_context, HASH_TEST);
	EXPECT_EQ(_last_log_severity, ERRORLEVEL_ERROR);
	EXPECT_GE(_last_log_length, shortmsg.length);
	EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(shortmsg), 0), STRING_NPOS);
	EXPECT_GT(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(shortmsg), 0), 0);
	EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_CONST("ERROR [4096]"), 0), STRING_NPOS);

	_last_log_context = 0;
	_last_log_severity = ERRORLEVEL_NONE;
	_last_log_msg = nullptr;
	_last_log_length = 0;

	log_enable_prefix(false);
    log_enable_stdout(false);
	log_error(HASH_TEST, ERROR_INVALID_VALUE, STRING_ARGS(longmsg));
    log_enable_stdout(true);
    log_enable_prefix(true);
	EXPECT_EQ(_last_log_context, HASH_TEST);
	EXPECT_EQ(_last_log_severity, ERRORLEVEL_ERROR);
	EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(longmsg), 0), STRING_NPOS);
	EXPECT_GT(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(longmsg), 0), 0);

	_last_log_context = 0;
	_last_log_severity = ERRORLEVEL_NONE;
	_last_log_msg = nullptr;
	_last_log_length = 0;

    log_enable_stdout(false);
	log_panic(HASH_TEST, ERROR_DEPRECATED, STRING_ARGS(shortmsg));
    log_enable_stdout(true);
	EXPECT_EQ(_last_log_context, HASH_TEST);
	EXPECT_EQ(_last_log_severity, ERRORLEVEL_PANIC);
	EXPECT_GE(_last_log_length, shortmsg.length);
	EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(shortmsg), 0), STRING_NPOS);
	EXPECT_GT(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(shortmsg), 0), 0);
	EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_CONST("PANIC [deprecated]"), 0), STRING_NPOS);

	_last_log_context = 0;
	_last_log_severity = ERRORLEVEL_NONE;
	_last_log_msg = nullptr;
	_last_log_length = 0;

    log_enable_stdout(false);
	log_panic(HASH_TEST, (error_t)0x1000, STRING_ARGS(shortmsg));
    log_enable_stdout(true);
	EXPECT_EQ(_last_log_context, HASH_TEST);
	EXPECT_EQ(_last_log_severity, ERRORLEVEL_PANIC);
	EXPECT_GE(_last_log_length, shortmsg.length);
	EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(shortmsg), 0), STRING_NPOS);
	EXPECT_GT(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(shortmsg), 0), 0);
	EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_CONST("PANIC [4096]"), 0), STRING_NPOS);

	_last_log_context = 0;
	_last_log_severity = ERRORLEVEL_NONE;
	_last_log_msg = nullptr;
	_last_log_length = 0;

	log_enable_prefix(false);
    log_enable_stdout(false);
	log_panic(HASH_TEST, ERROR_INVALID_VALUE, STRING_ARGS(longmsg));
    log_enable_stdout(true);
    log_enable_prefix(true);
	EXPECT_EQ(_last_log_context, HASH_TEST);
	EXPECT_EQ(_last_log_severity, ERRORLEVEL_PANIC);
	EXPECT_NE(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(longmsg), 0), STRING_NPOS);
	EXPECT_GT(string_find_string(_last_log_msg, _last_log_length, STRING_ARGS(longmsg), 0), 0);
    
	error_context_push(STRING_CONST("one"), STRING_CONST("dataone"));
	error_context_push(STRING_CONST("two"), STRING_CONST("datatwo"));
	error_context_push(STRING_CONST("three"), STRING_CONST("datathree"));

	_last_log_context = 0;
	_last_log_severity = ERRORLEVEL_NONE;
	_last_log_msg = nullptr;
	_last_log_length = 0;

    log_enable_stdout(false);
	log_error_context(HASH_TEST, ERRORLEVEL_INFO);
    log_enable_stdout(true);

    error_context_pop();
    error_context_pop();
    error_context_pop();

	EXPECT_SIZEEQ(string_find_string(_last_log_msg, _last_log_length, STRING_CONST("When one: dataone"), 0), STRING_NPOS);
	EXPECT_SIZEEQ(string_find_string(_last_log_msg, _last_log_length, STRING_CONST("When two: datatwo"), 0), STRING_NPOS);
	EXPECT_SIZENE(string_find_string(_last_log_msg, _last_log_length, STRING_CONST("When three: datathree"), 0), STRING_NPOS);

	log_set_callback(callback_log);
	error_set_callback(callback_error);
#endif
	return 0;
}
// This test verifies that the slave reports pending tasks when
// re-registering, otherwise the master will report them as being
// lost.
TEST_F(MasterSlaveReconciliationTest, SlaveReregisterPendingTask)
{
  Try<PID<Master> > master = StartMaster();
  ASSERT_SOME(master);

  StandaloneMasterDetector detector(master.get());

  Try<PID<Slave> > slave = StartSlave(&detector);
  ASSERT_SOME(slave);

  MockScheduler sched;
  MesosSchedulerDriver driver(
      &sched, DEFAULT_FRAMEWORK_INFO, master.get(), DEFAULT_CREDENTIAL);

  EXPECT_CALL(sched, registered(&driver, _, _));

  Future<vector<Offer> > offers;
  EXPECT_CALL(sched, resourceOffers(&driver, _))
    .WillOnce(FutureArg<1>(&offers))
    .WillRepeatedly(Return()); // Ignore subsequent offers.

  driver.start();

  AWAIT_READY(offers);
  EXPECT_NE(0u, offers.get().size());

  // No TASK_LOST updates should occur!
  EXPECT_CALL(sched, statusUpdate(&driver, _))
    .Times(0);

  // We drop the _runTask dispatch to ensure the task remains
  // pending in the slave.
  Future<Nothing> _runTask = DROP_DISPATCH(slave.get(), &Slave::_runTask);

  TaskInfo task1;
  task1.set_name("test task");
  task1.mutable_task_id()->set_value("1");
  task1.mutable_slave_id()->MergeFrom(offers.get()[0].slave_id());
  task1.mutable_resources()->MergeFrom(offers.get()[0].resources());
  task1.mutable_executor()->MergeFrom(DEFAULT_EXECUTOR_INFO);

  driver.launchTasks(offers.get()[0].id(), {task1});

  AWAIT_READY(_runTask);

  Future<SlaveReregisteredMessage> slaveReregisteredMessage =
    FUTURE_PROTOBUF(SlaveReregisteredMessage(), _, _);

  // Simulate a spurious master change event (e.g., due to ZooKeeper
  // expiration) at the slave to force re-registration.
  detector.appoint(master.get());

  AWAIT_READY(slaveReregisteredMessage);

  Clock::pause();
  Clock::settle();
  Clock::resume();

  driver.stop();
  driver.join();

  Shutdown();
}
Ejemplo n.º 18
0
TEST(Tag6, clone) {
    OpenPGP::Packet::Tag6 tag6;
    OpenPGP::Packet::Tag::Ptr clone = tag6.clone();
    EXPECT_NE(&tag6, clone.get());
    EXPECT_EQ(tag6.raw(), clone -> raw());
}
Ejemplo n.º 19
0
//-----------------------------------------------------------------------------
TEST(c_conduit_node_set, set_bitwidth_int_ptr)
{
    conduit_int8    i8av[6] = {-2,-4,-8,-16,-32,-64};
    conduit_int16  i16av[6] = {-2,-4,-8,-16,-32,-64};
    conduit_int32  i32av[6] = {-2,-4,-8,-16,-32,-64};
    conduit_int64  i64av[6] = {-2,-4,-8,-16,-32,-64};
        
    conduit_node *n = conduit_node_create();
    
    // using uint8* interface
    conduit_node_set_int8_ptr(n,i8av,6);
    conduit_node_print(n);

    conduit_int8 *i8av_ptr = conduit_node_as_int8_ptr(n);
    for(conduit_index_t i=0;i<6;i++)
    {
        EXPECT_EQ(i8av_ptr[i],i8av[i]);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&i8av_ptr[i],&i8av[i]);
    }
    EXPECT_EQ(i8av_ptr[5],-64);
    
    // using uint16* interface
    conduit_node_set_int16_ptr(n,i16av,6);
    conduit_node_print(n);
    
    conduit_int16 *i16av_ptr = conduit_node_as_int16_ptr(n);
    for(conduit_index_t i=0;i<6;i++)
    {
        EXPECT_EQ(i16av_ptr[i],i16av[i]);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&i16av_ptr[i],&i16av[i]);
    }
    EXPECT_EQ(i16av_ptr[5],-64);
    
    // using uint32 * interface
    conduit_node_set_int32_ptr(n,i32av,6);
    conduit_node_print(n);

    conduit_int32 *i32av_ptr = conduit_node_as_int32_ptr(n);
    for(conduit_index_t i=0;i<6;i++)
    {
        EXPECT_EQ(i32av_ptr[i],i32av[i]);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&i32av_ptr[i],&i32av[i]);
    }
    EXPECT_EQ(i32av_ptr[5],-64);
    
    // using uint64 * interface
    conduit_node_set_int64_ptr(n,i64av,6);
    conduit_node_print(n);
    
    conduit_int64 *i64av_ptr = conduit_node_as_int64_ptr(n);
    for(conduit_index_t i=0;i<6;i++)
    {
        EXPECT_EQ(i64av_ptr[i],i64av[i]);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&i64av_ptr[i],&i64av[i]);
    }
    EXPECT_EQ(i64av_ptr[5],-64);
    
    conduit_node_destroy(n);
}
Ejemplo n.º 20
0
TEST(QiOs, get_host_name)
{
  std::string temp = qi::os::gethostname();
  EXPECT_NE(std::string(), temp);
}
Ejemplo n.º 21
0
//-----------------------------------------------------------------------------
TEST(conduit_node_set, set_bitwidth_float_ptr)
{
    conduit_float32  f32av[4] = {-0.8, -1.6, -3.2, -6.4};
    conduit_float64  f64av[4] = {-0.8, -1.6, -3.2, -6.4};


        
    conduit_node *n = conduit_node_create();
    
    // float32
    conduit_node_set_float32_ptr(n,f32av,4);
    conduit_node_print(n);

    conduit_float32 *f32av_ptr = conduit_node_as_float32_ptr(n);
    for(conduit_index_t i=0;i<4;i++)
    {
        EXPECT_NEAR(f32av_ptr[i],f32av[i],0.001);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&f32av_ptr[i],&f32av[i]); 
    }
    EXPECT_NEAR(f32av_ptr[3],-6.4,0.001);
    
    
    // float32 detailed
    conduit_node_set_float32_ptr_detailed(n,
                                          f32av,
                                          4,
                                          0,
                                          sizeof(conduit_float32),
                                          sizeof(conduit_float32),
                                          CONDUIT_ENDIANNESS_DEFAULT_ID);
    conduit_node_print(n);

    f32av_ptr = conduit_node_as_float32_ptr(n);
    for(conduit_index_t i=0;i<4;i++)
    {
        EXPECT_NEAR(f32av_ptr[i],f32av[i],0.001);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&f32av_ptr[i],&f32av[i]); 
    }
    EXPECT_NEAR(f32av_ptr[3],-6.4,0.001);
    
    // float64
    conduit_node_set_float64_ptr(n,f64av,4);
    conduit_node_print(n);

    conduit_float64 *f64av_ptr = conduit_node_as_float64_ptr(n);
    for(conduit_index_t i=0;i<4;i++)
    {
        EXPECT_NEAR(f64av_ptr[i],f64av[i],0.001);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&f64av_ptr[i],&f64av[i]);
    }
    EXPECT_NEAR(f64av_ptr[3],-6.4,0.001);

    // float64 detailed
    conduit_node_set_float64_ptr_detailed(n,
                                          f64av,
                                          4,
                                          0,
                                          sizeof(conduit_float64),
                                          sizeof(conduit_float64),
                                          CONDUIT_ENDIANNESS_DEFAULT_ID);
    conduit_node_print(n);

    f64av_ptr = conduit_node_as_float64_ptr(n);
    for(conduit_index_t i=0;i<4;i++)
    {
        EXPECT_NEAR(f64av_ptr[i],f64av[i],0.001);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&f64av_ptr[i],&f64av[i]);
    }
    EXPECT_NEAR(f64av_ptr[3],-6.4,0.001);


    conduit_node_destroy(n);
}
Ejemplo n.º 22
0
TEST_F( utVersion, aiGetCompileFlagsTest ) {
    EXPECT_NE( aiGetCompileFlags(), 0U );
}
Ejemplo n.º 23
0
//-----------------------------------------------------------------------------
TEST(c_conduit_node_set, set_native_uint_ptr)
{
    unsigned char   ucav[6] = {2,4,8,16,32,64};
    unsigned short  usav[6] = {2,4,8,16,32,64};
    unsigned int    uiav[6] = {2,4,8,16,32,64};
    unsigned long   ulav[6] = {2,4,8,16,32,64};
        
    conduit_node *n = conduit_node_create();
    
    // using unsigned char* interface
    conduit_node_set_unsigned_char_ptr(n,ucav,6);
    conduit_node_print(n);

    unsigned char *ucav_ptr = conduit_node_as_unsigned_char_ptr(n);
    for(conduit_index_t i=0;i<6;i++)
    {
        EXPECT_EQ(ucav_ptr[i],ucav[i]);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&ucav_ptr[i],&ucav[i]);
    }
    EXPECT_EQ(ucav_ptr[5],64);
    
    // using unsigned short* interface
    conduit_node_set_unsigned_short_ptr(n,usav,6);
    conduit_node_print(n);
    
    unsigned short *usav_ptr = conduit_node_as_unsigned_short_ptr(n);
    for(conduit_index_t i=0;i<6;i++)
    {
        EXPECT_EQ(usav_ptr[i],usav[i]);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&usav_ptr[i],&usav[i]);
    }
    EXPECT_EQ(usav_ptr[5],64);
    
    // using unsigned int * interface
    conduit_node_set_unsigned_int_ptr(n,uiav,6);
    conduit_node_print(n);

    unsigned int *uiav_ptr = conduit_node_as_unsigned_int_ptr(n);
    for(conduit_index_t i=0;i<6;i++)
    {
        EXPECT_EQ(uiav_ptr[i],uiav[i]);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&uiav_ptr[i],&uiav[i]);
    }
    EXPECT_EQ(uiav_ptr[5],64);
    
    // using unsigned long * interface
    conduit_node_set_unsigned_long_ptr(n,ulav,6);
    conduit_node_print(n);
    
    unsigned long *ulav_ptr = conduit_node_as_unsigned_long_ptr(n);
    for(conduit_index_t i=0;i<6;i++)
    {
        EXPECT_EQ(ulav_ptr[i],ulav[i]);
        // set(...) semantics imply a copy -- mem addys should differ
        EXPECT_NE(&ulav_ptr[i],&ulav[i]);
    }
    EXPECT_EQ(ulav_ptr[5],64);

    conduit_node_destroy(n);
}
Ejemplo n.º 24
0
TEST_F( utVersion, aiGetVersionRevisionTest ) {
    EXPECT_NE( aiGetVersionRevision(), 0U );
}
Ejemplo n.º 25
0
// A simple hit testing test that doesn't involve any transforms on layers.
TEST_F(APZHitTestingTester, HitTesting1) {
    CreateHitTesting1LayerTree();
    ScopedLayerTreeRegistration registration(manager, 0, root, mcc);

    // No APZC attached so hit testing will return no APZC at (20,20)
    RefPtr<AsyncPanZoomController> hit = GetTargetAPZC(ScreenPoint(20, 20));
    TestAsyncPanZoomController* nullAPZC = nullptr;
    EXPECT_EQ(nullAPZC, hit.get());
    EXPECT_EQ(ScreenToParentLayerMatrix4x4(), transformToApzc);
    EXPECT_EQ(ParentLayerToScreenMatrix4x4(), transformToGecko);

    uint32_t paintSequenceNumber = 0;

    // Now we have a root APZC that will match the page
    SetScrollableFrameMetrics(root, FrameMetrics::START_SCROLL_ID);
    manager->UpdateHitTestingTree(0, root, false, 0, paintSequenceNumber++);
    hit = GetTargetAPZC(ScreenPoint(15, 15));
    EXPECT_EQ(ApzcOf(root), hit.get());
    // expect hit point at LayerIntPoint(15, 15)
    EXPECT_EQ(ParentLayerPoint(15, 15), transformToApzc.TransformPoint(ScreenPoint(15, 15)));
    EXPECT_EQ(ScreenPoint(15, 15), transformToGecko.TransformPoint(ParentLayerPoint(15, 15)));

    // Now we have a sub APZC with a better fit
    SetScrollableFrameMetrics(layers[3], FrameMetrics::START_SCROLL_ID + 1);
    manager->UpdateHitTestingTree(0, root, false, 0, paintSequenceNumber++);
    EXPECT_NE(ApzcOf(root), ApzcOf(layers[3]));
    hit = GetTargetAPZC(ScreenPoint(25, 25));
    EXPECT_EQ(ApzcOf(layers[3]), hit.get());
    // expect hit point at LayerIntPoint(25, 25)
    EXPECT_EQ(ParentLayerPoint(25, 25), transformToApzc.TransformPoint(ScreenPoint(25, 25)));
    EXPECT_EQ(ScreenPoint(25, 25), transformToGecko.TransformPoint(ParentLayerPoint(25, 25)));

    // At this point, layers[4] obscures layers[3] at the point (15, 15) so
    // hitting there should hit the root APZC
    hit = GetTargetAPZC(ScreenPoint(15, 15));
    EXPECT_EQ(ApzcOf(root), hit.get());

    // Now test hit testing when we have two scrollable layers
    SetScrollableFrameMetrics(layers[4], FrameMetrics::START_SCROLL_ID + 2);
    manager->UpdateHitTestingTree(0, root, false, 0, paintSequenceNumber++);
    hit = GetTargetAPZC(ScreenPoint(15, 15));
    EXPECT_EQ(ApzcOf(layers[4]), hit.get());
    // expect hit point at LayerIntPoint(15, 15)
    EXPECT_EQ(ParentLayerPoint(15, 15), transformToApzc.TransformPoint(ScreenPoint(15, 15)));
    EXPECT_EQ(ScreenPoint(15, 15), transformToGecko.TransformPoint(ParentLayerPoint(15, 15)));

    // Hit test ouside the reach of layer[3,4] but inside root
    hit = GetTargetAPZC(ScreenPoint(90, 90));
    EXPECT_EQ(ApzcOf(root), hit.get());
    // expect hit point at LayerIntPoint(90, 90)
    EXPECT_EQ(ParentLayerPoint(90, 90), transformToApzc.TransformPoint(ScreenPoint(90, 90)));
    EXPECT_EQ(ScreenPoint(90, 90), transformToGecko.TransformPoint(ParentLayerPoint(90, 90)));

    // Hit test ouside the reach of any layer
    hit = GetTargetAPZC(ScreenPoint(1000, 10));
    EXPECT_EQ(nullAPZC, hit.get());
    EXPECT_EQ(ScreenToParentLayerMatrix4x4(), transformToApzc);
    EXPECT_EQ(ParentLayerToScreenMatrix4x4(), transformToGecko);
    hit = GetTargetAPZC(ScreenPoint(-1000, 10));
    EXPECT_EQ(nullAPZC, hit.get());
    EXPECT_EQ(ScreenToParentLayerMatrix4x4(), transformToApzc);
    EXPECT_EQ(ParentLayerToScreenMatrix4x4(), transformToGecko);
}
Ejemplo n.º 26
0
TEST_F(CoverArtUtilTest, searchImage) {
    // creating a temp track directory
    QString trackdir(QDir::tempPath() % "/TrackDir");
    ASSERT_FALSE(QDir().exists(trackdir)); // it must start empty
    ASSERT_TRUE(QDir().mkpath(trackdir));

    const QString kTrackLocationTest(kTestDir.absoluteFilePath("cover-test-png.mp3"));

    TrackPointer pTrack(Track::newTemporary(kTrackLocationTest));
    QLinkedList<QFileInfo> covers;
    CoverInfo res;
    // looking for cover in an empty directory
    res = CoverArtUtils::selectCoverArtForTrack(*pTrack, covers);
    CoverInfo expected1;
    expected1.source = CoverInfo::GUESSED;
    expected1.trackLocation = pTrack->getLocation();
    EXPECT_EQ(expected1, res);

    // Looking for a track with embedded cover.
    pTrack = Track::newTemporary(kTrackLocationTest);
    SoundSourceProxy(pTrack).updateTrackFromSource();
    CoverInfo result = pTrack->getCoverInfoWithLocation();
    EXPECT_EQ(result.type, CoverInfo::METADATA);
    EXPECT_EQ(result.source, CoverInfo::GUESSED);
    EXPECT_EQ(result.coverLocation, QString());
    EXPECT_NE(result.hash, CoverInfoRelative().hash);

    const char* format("jpg");
    const QString qFormat(format);

    // Since we already parsed this image from the metadata in
    // kTrackLocationTest, hang on to it since we use it as a template for
    // stuff below.

    result.trackLocation = kTrackLocationTest;
    const QImage img = CoverArtUtils::loadCover(result);
    EXPECT_EQ(img.isNull(), false);

    QString trackBaseName = "cover-test";
    QString trackAlbum = "album_name";

    // Search Strategy
    // 0. If we have just one file, we will get it.
    // 1. %track-file-base%.jpg in the track directory for %track-file-base%.mp3
    // 2. %album%.jpg
    // 3. cover.jpg
    // 4. front.jpg
    // 5. album.jpg
    // 6. folder.jpg
    // 7. if just one file exists take that otherwise none.

    // All the following expect the same image/hash to be selected.
    CoverInfoRelative expected2;
    expected2.hash = CoverInfoRelative().hash;

    // All the following expect FILE and GUESSED.
    expected2.type = CoverInfo::FILE;
    expected2.source = CoverInfo::GUESSED;

    // 0. saving just one cover in our temp track dir
    QString cLoc_foo = QString(trackdir % "/" % "foo." % qFormat);
    EXPECT_TRUE(img.save(cLoc_foo, format));

    // looking for cover in an directory with one image will select that one.
    expected2.coverLocation = "foo.jpg";
    expected2.hash = CoverArtUtils::calculateHash(QImage(cLoc_foo));
    covers << QFileInfo(cLoc_foo);
    CoverInfoRelative res2 = CoverArtUtils::selectCoverArtForTrack(
            trackBaseName, trackAlbum, covers);
    EXPECT_EQ(expected2, res2);
    QFile::remove(cLoc_foo);

    QStringList extraCovers;
    // adding some extra images (bigger) just to populate the track dir.
    QString cLoc_big1 = QString(trackdir % "/" % "big1." % qFormat);
    EXPECT_TRUE(img.scaled(1000,1000).save(cLoc_big1, format));
    extraCovers << cLoc_big1;
    QString cLoc_big2 = QString(trackdir % "/" % "big2." % qFormat);
    EXPECT_TRUE(img.scaled(900,900).save(cLoc_big2, format));
    extraCovers << cLoc_big2;
    QString cLoc_big3 = QString(trackdir % "/" % "big3." % qFormat);
    EXPECT_TRUE(img.scaled(800,800).save(cLoc_big3, format));
    extraCovers << cLoc_big3;

    // saving more covers using the preferred names in the right order
    QLinkedList<QFileInfo> prefCovers;
    // 1. track_filename.jpg
    QString cLoc_filename = QString(trackdir % "/cover-test." % qFormat);
    EXPECT_TRUE(img.scaled(500,500).save(cLoc_filename, format));
    prefCovers << QFileInfo(cLoc_filename);
    // 2. album_name.jpg
    QString cLoc_albumName = QString(trackdir % "/album_name." % qFormat);
    EXPECT_TRUE(img.scaled(500,500).save(cLoc_albumName, format));
    prefCovers << QFileInfo(cLoc_albumName);
    // 3. cover.jpg
    QString cLoc_cover = QString(trackdir % "/" % "cover." % qFormat);
    EXPECT_TRUE(img.scaled(400,400).save(cLoc_cover, format));
    prefCovers << QFileInfo(cLoc_cover);
    // 4. front.jpg
    QString cLoc_front = QString(trackdir % "/" % "front." % qFormat);
    EXPECT_TRUE(img.scaled(300,300).save(cLoc_front, format));
    prefCovers << QFileInfo(cLoc_front);
    // 5. album.jpg
    QString cLoc_album = QString(trackdir % "/" % "album." % qFormat);
    EXPECT_TRUE(img.scaled(100,100).save(cLoc_album, format));
    prefCovers << QFileInfo(cLoc_album);
    // 6. folder.jpg
    QString cLoc_folder = QString(trackdir % "/" % "folder." % qFormat);
    EXPECT_TRUE(img.scaled(100,100).save(cLoc_folder, format));
    prefCovers << QFileInfo(cLoc_folder);
    // 8. other1.jpg
    QString cLoc_other1 = QString(trackdir % "/" % "other1." % qFormat);
    EXPECT_TRUE(img.scaled(10,10).save(cLoc_other1, format));
    prefCovers << QFileInfo(cLoc_other1);
    // 7. other2.jpg
    QString cLoc_other2 = QString(trackdir % "/" % "other2." % qFormat);
    EXPECT_TRUE(img.scaled(10,10).save(cLoc_other2, format));
    prefCovers << QFileInfo(cLoc_other2);

    // we must find covers in the right order
    EXPECT_EQ(8, prefCovers.size());

    // Remove the covers one by one from the front, checking that each one is
    // selected as we remove the previously-most-preferable cover.
    while (!prefCovers.isEmpty()) {
        QFileInfo cover = prefCovers.first();

        // We expect no cover selected for other1 since there are 2 covers,
        // neither of which match our preferred cover names. other2 will be
        // selected once we get to it since it is the only cover available.
        if (cover.baseName() == "other1") {
            expected2.type = CoverInfo::NONE;
            expected2.coverLocation = QString();
            expected2.hash = CoverInfoRelative().hash;
        } else {
            expected2.type = CoverInfo::FILE;
            expected2.coverLocation = cover.fileName();
            expected2.hash = CoverArtUtils::calculateHash(QImage(cover.filePath()));
        }
        res2 = CoverArtUtils::selectCoverArtForTrack(trackBaseName, trackAlbum,
                                                    prefCovers);
        EXPECT_QSTRING_EQ(expected2.coverLocation, res2.coverLocation);
        EXPECT_EQ(expected2.hash, res2.hash);
        EXPECT_EQ(expected2, res2);

        QFile::remove(cover.filePath());
        prefCovers.pop_front();
    }

    //
    // Additional tests
    //

    // what is chosen when cover.jpg and cover.JPG exists?
    // (it must always prefer the lighter cover)
    QString cLoc_coverJPG = trackdir % "/" % "cover." % "JPG";
    EXPECT_TRUE(img.scaled(200,200).save(cLoc_coverJPG, "JPG"));
    prefCovers.append(QFileInfo(cLoc_coverJPG));
    QString cLoc_coverjpg = trackdir % "/" % "cover." % "jpg";
    EXPECT_TRUE(img.scaled(400,400).save(cLoc_coverjpg, "jpg"));
    prefCovers.append(QFileInfo(cLoc_coverjpg));
    extraCovers << cLoc_coverJPG << cLoc_coverjpg;

    res2 = CoverArtUtils::selectCoverArtForTrack(trackBaseName, trackAlbum,
                                                prefCovers);
    expected2.hash = CoverArtUtils::calculateHash(QImage(cLoc_coverJPG));
    expected2.coverLocation = "cover.JPG";
    EXPECT_EQ(expected2, res2);

    // As we are looking for %album%.jpg and %base_track.jpg%,
    // we need to check if everything works with UTF8 chars.
    trackBaseName = QString::fromUtf8("track_ðÑöæäî");
    trackAlbum = QString::fromUtf8("öæäîðÑ_album");

    prefCovers.clear();

    // 2. album_name.jpg
    cLoc_albumName = QString(trackdir % "/" % trackAlbum % "." % qFormat);
    EXPECT_TRUE(img.save(cLoc_albumName, format));
    prefCovers.append(QFileInfo(cLoc_albumName));
    res2 = CoverArtUtils::selectCoverArtForTrack(trackBaseName, trackAlbum,
                                                prefCovers);
    expected2.hash = CoverArtUtils::calculateHash(QImage(cLoc_albumName));
    expected2.coverLocation = trackAlbum % ".jpg";
    EXPECT_EQ(expected2, res2);

    // 1. track_filename.jpg
    cLoc_filename = QString(trackdir % "/" % trackBaseName % "." % qFormat);
    EXPECT_TRUE(img.save(cLoc_filename, format));
    prefCovers.append(QFileInfo(cLoc_filename));
    res2 = CoverArtUtils::selectCoverArtForTrack(trackBaseName, trackAlbum,
                                                prefCovers);

    expected2.hash = CoverArtUtils::calculateHash(QImage(cLoc_filename));
    expected2.coverLocation = trackBaseName % ".jpg";
    EXPECT_EQ(expected2, res2);

    QFile::remove(cLoc_filename);
    QFile::remove(cLoc_albumName);

    // cleaning temp dir
    foreach (QString loc, extraCovers) {
        QFile::remove(loc);
    }
Ejemplo n.º 27
0
// This test ensures that when explicit acknowledgements are enabled,
// acknowledgements for master-generated updates are dropped by the
// driver. We test this by creating an invalid task that uses no
// resources.
TEST_F(MesosSchedulerDriverTest, ExplicitAcknowledgementsMasterGeneratedUpdate)
{
  Try<Owned<cluster::Master>> master = StartMaster();
  ASSERT_SOME(master);

  Owned<MasterDetector> detector = master.get()->createDetector();
  Try<Owned<cluster::Slave>> slave = StartSlave(detector.get());
  ASSERT_SOME(slave);

  MockScheduler sched;
  MesosSchedulerDriver driver(
      &sched,
      DEFAULT_FRAMEWORK_INFO,
      master.get()->pid,
      false,
      DEFAULT_CREDENTIAL);

  EXPECT_CALL(sched, registered(&driver, _, _));

  Future<vector<Offer>> offers;
  EXPECT_CALL(sched, resourceOffers(&driver, _))
    .WillOnce(FutureArg<1>(&offers))
    .WillRepeatedly(Return()); // Ignore subsequent offers.

  // Ensure no status update acknowledgements are sent to the master.
  EXPECT_NO_FUTURE_CALLS(
      mesos::scheduler::Call(),
      mesos::scheduler::Call::ACKNOWLEDGE,
      _ ,
      master.get()->pid);

  driver.start();

  AWAIT_READY(offers);
  EXPECT_NE(0u, offers->size());

  // Launch a task using no resources.
  TaskInfo task;
  task.set_name("");
  task.mutable_task_id()->set_value("1");
  task.mutable_slave_id()->MergeFrom(offers.get()[0].slave_id());
  task.mutable_executor()->MergeFrom(DEFAULT_EXECUTOR_INFO);

  vector<TaskInfo> tasks;
  tasks.push_back(task);

  Future<TaskStatus> status;
  EXPECT_CALL(sched, statusUpdate(&driver, _))
    .WillOnce(FutureArg<1>(&status));

  driver.launchTasks(offers.get()[0].id(), tasks);

  AWAIT_READY(status);
  ASSERT_EQ(TASK_ERROR, status->state());
  ASSERT_EQ(TaskStatus::SOURCE_MASTER, status->source());
  ASSERT_EQ(TaskStatus::REASON_TASK_INVALID, status->reason());

  // Now send the acknowledgement.
  driver.acknowledgeStatusUpdate(status.get());

  // Settle the clock to ensure driver processes the acknowledgement,
  // which should get dropped due to having come from the master.
  Clock::pause();
  Clock::settle();

  driver.stop();
  driver.join();
}
// This test verifies that the master reconciles tasks that are
// missing from a re-registering slave. In this case, we drop the
// RunTaskMessage so the slave should send TASK_LOST.
TEST_F(MasterSlaveReconciliationTest, ReconcileLostTask)
{
  Try<PID<Master> > master = StartMaster();
  ASSERT_SOME(master);

  StandaloneMasterDetector detector(master.get());

  Try<PID<Slave> > slave = StartSlave(&detector);
  ASSERT_SOME(slave);

  MockScheduler sched;
  MesosSchedulerDriver driver(
      &sched, DEFAULT_FRAMEWORK_INFO, master.get(), DEFAULT_CREDENTIAL);

  EXPECT_CALL(sched, registered(&driver, _, _));

  Future<vector<Offer> > offers;
  EXPECT_CALL(sched, resourceOffers(&driver, _))
    .WillOnce(FutureArg<1>(&offers))
    .WillRepeatedly(Return()); // Ignore subsequent offers.

  driver.start();

  AWAIT_READY(offers);

  EXPECT_NE(0u, offers.get().size());

  TaskInfo task;
  task.set_name("test task");
  task.mutable_task_id()->set_value("1");
  task.mutable_slave_id()->MergeFrom(offers.get()[0].slave_id());
  task.mutable_resources()->MergeFrom(offers.get()[0].resources());
  task.mutable_executor()->MergeFrom(DEFAULT_EXECUTOR_INFO);

  // We now launch a task and drop the corresponding RunTaskMessage on
  // the slave, to ensure that only the master knows about this task.
  Future<RunTaskMessage> runTaskMessage =
    DROP_PROTOBUF(RunTaskMessage(), _, _);

  driver.launchTasks(offers.get()[0].id(), {task});

  AWAIT_READY(runTaskMessage);

  Future<SlaveReregisteredMessage> slaveReregisteredMessage =
    FUTURE_PROTOBUF(SlaveReregisteredMessage(), _, _);

  Future<StatusUpdateMessage> statusUpdateMessage =
    FUTURE_PROTOBUF(StatusUpdateMessage(), _, master.get());

  Future<TaskStatus> status;
  EXPECT_CALL(sched, statusUpdate(&driver, _))
    .WillOnce(FutureArg<1>(&status));

  // Simulate a spurious master change event (e.g., due to ZooKeeper
  // expiration) at the slave to force re-registration.
  detector.appoint(master.get());

  AWAIT_READY(slaveReregisteredMessage);

  // Make sure the slave generated the TASK_LOST.
  AWAIT_READY(statusUpdateMessage);

  AWAIT_READY(status);

  ASSERT_EQ(task.task_id(), status.get().task_id());
  ASSERT_EQ(TASK_LOST, status.get().state());

  // Before we obtain the metrics, ensure that the master has finished
  // processing the status update so metrics have been updated.
  Clock::pause();
  Clock::settle();
  Clock::resume();

  // Check metrics.
  JSON::Object stats = Metrics();
  EXPECT_EQ(1u, stats.values.count("master/tasks_lost"));
  EXPECT_EQ(1u, stats.values["master/tasks_lost"]);
  EXPECT_EQ(
      1u,
      stats.values.count(
          "master/task_lost/source_slave/reason_reconciliation"));
  EXPECT_EQ(
      1u,
      stats.values["master/task_lost/source_slave/reason_reconciliation"]);

  driver.stop();
  driver.join();

  Shutdown();
}
TEST(nequali_op, matnequal_op2x4) {
    tmat2x4i a = {
            1, 1, 1, 1,
            1, 1, 1, 1
    };

    tmat2x4i b = {
            -1, 1, 1, 1,
            1, 1, 1, 1
    };

    EXPECT_NE(a, b);
    EXPECT_NE(b, a);


    b = {
            1, -1, 1, 1,
            1, 1, 1, 1
    };

    EXPECT_NE(a, b);
    EXPECT_NE(b, a);


    b = {
            1, 1, -1, 1,
            1, 1, 1, 1
    };

    EXPECT_NE(a, b);
    EXPECT_NE(b, a);


    b = {
            1, 1, 1, -1,
            1, 1, 1, 1
    };

    EXPECT_NE(a, b);
    EXPECT_NE(b, a);


    b = {
            1, 1, 1, 1,
            -1, 1, 1, 1
    };

    EXPECT_NE(a, b);
    EXPECT_NE(b, a);

    b = {
            1, 1, 1, 1,
            1, -1, 1, 1
    };

    EXPECT_NE(a, b);
    EXPECT_NE(b, a);


    b = {
            1, 1, 1, 1,
            1, 1,-1, 1
    };

    EXPECT_NE(a, b);
    EXPECT_NE(b, a);


    b = {
            1, 1, 1, 1,
            1, 1, 1,-1
    };

    EXPECT_NE(a, b);
    EXPECT_NE(b, a);

}
Ejemplo n.º 30
0
TEST_F(SQLiteUtilTests, test_sqlite_instance_manager) {
  auto dbc1 = SQLiteDBManager::get();
  auto dbc2 = SQLiteDBManager::get();
  EXPECT_NE(dbc1->db(), dbc2->db());
  EXPECT_EQ(dbc1->db(), dbc1->db());
}