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(); }
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()); }
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); } }
//----------------------------------------------------------------------------- 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); }
//----------------------------------------------------------------------------- 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(); }
//----------------------------------------------------------------------------- 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); }
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(); }
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; }
// 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(); }
// 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(); }
// 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(); }
// 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(); }
// 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(); }
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(); }
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()); }
//----------------------------------------------------------------------------- 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); }
TEST(QiOs, get_host_name) { std::string temp = qi::os::gethostname(); EXPECT_NE(std::string(), temp); }
//----------------------------------------------------------------------------- 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); }
TEST_F( utVersion, aiGetCompileFlagsTest ) { EXPECT_NE( aiGetCompileFlags(), 0U ); }
//----------------------------------------------------------------------------- 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); }
TEST_F( utVersion, aiGetVersionRevisionTest ) { EXPECT_NE( aiGetVersionRevision(), 0U ); }
// 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); }
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); }
// 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); }
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()); }