You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mesos.apache.org by be...@apache.org on 2011/06/05 11:27:16 UTC
svn commit: r1132335 [4/4] - in /incubator/mesos/trunk: include/
include/mesos/ src/ src/common/ src/detector/ src/examples/ src/exec/
src/java/jni/ src/launcher/ src/local/ src/master/ src/messaging/
src/python/native/ src/sched/ src/slave/ src/tests/
Modified: incubator/mesos/trunk/src/tests/master_test.cpp
URL: http://svn.apache.org/viewvc/incubator/mesos/trunk/src/tests/master_test.cpp?rev=1132335&r1=1132334&r2=1132335&view=diff
==============================================================================
--- incubator/mesos/trunk/src/tests/master_test.cpp (original)
+++ incubator/mesos/trunk/src/tests/master_test.cpp Sun Jun 5 09:27:14 2011
@@ -1,19 +1,21 @@
#include <gmock/gmock.h>
-#include <mesos_exec.hpp>
-#include <mesos_sched.hpp>
-
#include <boost/lexical_cast.hpp>
-#include <local/local.hpp>
+#include <mesos/executor.hpp>
+#include <mesos/scheduler.hpp>
+
+#include "detector/detector.hpp"
+
+#include "local/local.hpp"
-#include <master/master.hpp>
+#include "master/master.hpp"
-#include <slave/isolation_module.hpp>
-#include <slave/process_based_isolation_module.hpp>
-#include <slave/slave.hpp>
+#include "slave/isolation_module.hpp"
+#include "slave/process_based_isolation_module.hpp"
+#include "slave/slave.hpp"
-#include <tests/utils.hpp>
+#include "tests/utils.hpp"
using namespace mesos;
using namespace mesos::internal;
@@ -22,10 +24,12 @@ using namespace mesos::internal::test;
using boost::lexical_cast;
using mesos::internal::master::Master;
+
using mesos::internal::slave::Slave;
-using mesos::internal::slave::Framework;
-using mesos::internal::slave::IsolationModule;
using mesos::internal::slave::ProcessBasedIsolationModule;
+using mesos::internal::slave::STATUS_UPDATE_RETRY_TIMEOUT;
+
+using process::PID;
using std::string;
using std::map;
@@ -45,42 +49,59 @@ using testing::Sequence;
using testing::StrEq;
-class LocalIsolationModule : public IsolationModule
+class TestingIsolationModule : public slave::IsolationModule
{
public:
- Executor *executor;
- MesosExecutorDriver *driver;
- string pid;
-
- LocalIsolationModule(Executor *_executor)
- : executor(_executor), driver(NULL) {}
+ TestingIsolationModule(const map<ExecutorID, Executor*>& _executors)
+ : executors(_executors) {}
- virtual ~LocalIsolationModule() {}
+ virtual ~TestingIsolationModule() {}
- virtual void initialize(Slave *slave) {
- pid = slave->self();
+ virtual void initialize(Slave* _slave)
+ {
+ slave = _slave;
}
- virtual void startExecutor(Framework *framework) {
- // TODO(benh): Cleanup the way we launch local drivers!
- setenv("MESOS_LOCAL", "1", 1);
- setenv("MESOS_SLAVE_PID", pid.c_str(), 1);
- setenv("MESOS_FRAMEWORK_ID", framework->id.c_str(), 1);
-
- driver = new MesosExecutorDriver(executor);
- driver->start();
+ virtual void launchExecutor(slave::Framework* f, slave::Executor* e)
+ {
+ if (executors.count(e->info.executor_id()) > 0) {
+ Executor* executor = executors[e->info.executor_id()];
+ MesosExecutorDriver* driver = new MesosExecutorDriver(executor);
+ drivers[e->info.executor_id()] = driver;
+
+ setenv("MESOS_LOCAL", "1", 1);
+ setenv("MESOS_SLAVE_PID", string(slave->self()).c_str(), 1);
+ setenv("MESOS_FRAMEWORK_ID", f->frameworkId.value().c_str(), 1);
+ setenv("MESOS_EXECUTOR_ID", e->info.executor_id().value().c_str(), 1);
+
+ driver->start();
+
+ unsetenv("MESOS_LOCAL");
+ unsetenv("MESOS_SLAVE_PID");
+ unsetenv("MESOS_FRAMEWORK_ID");
+ unsetenv("MESOS_EXECUTOR_ID");
+ } else {
+ FAIL() << "Cannot launch executor";
+ }
}
- virtual void killExecutor(Framework* framework) {
- driver->stop();
- driver->join();
- delete driver;
-
- // TODO(benh): Cleanup the way we launch local drivers!
- unsetenv("MESOS_LOCAL");
- unsetenv("MESOS_SLAVE_PID");
- unsetenv("MESOS_FRAMEWORK_ID");
+ virtual void killExecutor(slave::Framework* f, slave::Executor* e)
+ {
+ if (drivers.count(e->info.executor_id()) > 0) {
+ MesosExecutorDriver* driver = drivers[e->info.executor_id()];
+ driver->stop();
+ driver->join();
+ delete driver;
+ drivers.erase(e->info.executor_id());
+ } else {
+ FAIL() << "Cannot kill executor";
+ }
}
+
+private:
+ map<ExecutorID, Executor*> executors;
+ map<ExecutorID, MesosExecutorDriver*> drivers;
+ Slave* slave;
};
@@ -88,7 +109,7 @@ TEST(MasterTest, ResourceOfferWithMultip
{
ASSERT_TRUE(GTEST_IS_THREADSAFE);
- PID master = local::launch(10, 2, 1 * Gigabyte, false, false);
+ PID<Master> master = local::launch(10, 2, 1 * Gigabyte, false, false);
MockScheduler sched;
MesosSchedulerDriver driver(&sched, master);
@@ -101,13 +122,14 @@ TEST(MasterTest, ResourceOfferWithMultip
.WillOnce(Return(""));
EXPECT_CALL(sched, getExecutorInfo(&driver))
- .WillOnce(Return(ExecutorInfo("noexecutor", "")));
+ .WillOnce(Return(DEFAULT_EXECUTOR_INFO));
EXPECT_CALL(sched, registered(&driver, _))
.Times(1);
EXPECT_CALL(sched, resourceOffer(&driver, _, _))
- .WillOnce(DoAll(SaveArg<2>(&offers), Trigger(&resourceOfferCall)));
+ .WillOnce(DoAll(SaveArg<2>(&offers), Trigger(&resourceOfferCall)))
+ .WillRepeatedly(Return());
EXPECT_CALL(sched, offerRescinded(&driver, _))
.Times(AtMost(1));
@@ -119,8 +141,9 @@ TEST(MasterTest, ResourceOfferWithMultip
EXPECT_NE(0, offers.size());
EXPECT_GE(10, offers.size());
- EXPECT_EQ("2", offers[0].params["cpus"]);
- EXPECT_EQ("1024", offers[0].params["mem"]);
+ Resources resources(offers[0].resources());
+ EXPECT_EQ(2, resources.getScalar("cpus", Resource::Scalar()).value());
+ EXPECT_EQ(1024, resources.getScalar("mem", Resource::Scalar()).value());
driver.stop();
driver.join();
@@ -133,7 +156,7 @@ TEST(MasterTest, ResourcesReofferedAfter
{
ASSERT_TRUE(GTEST_IS_THREADSAFE);
- PID master = local::launch(10, 2, 1 * Gigabyte, false, false);
+ PID<Master> master = local::launch(1, 2, 1 * Gigabyte, false, false);
MockScheduler sched1;
MesosSchedulerDriver driver1(&sched1, master);
@@ -146,19 +169,20 @@ TEST(MasterTest, ResourcesReofferedAfter
.WillOnce(Return(""));
EXPECT_CALL(sched1, getExecutorInfo(&driver1))
- .WillOnce(Return(ExecutorInfo("noexecutor", "")));
+ .WillOnce(Return(DEFAULT_EXECUTOR_INFO));
EXPECT_CALL(sched1, registered(&driver1, _))
.Times(1);
EXPECT_CALL(sched1, resourceOffer(&driver1, _, _))
- .WillOnce(DoAll(SaveArg<1>(&offerId), Trigger(&sched1ResourceOfferCall)));
+ .WillOnce(DoAll(SaveArg<1>(&offerId), Trigger(&sched1ResourceOfferCall)))
+ .WillRepeatedly(Return());
driver1.start();
WAIT_UNTIL(sched1ResourceOfferCall);
- driver1.replyToOffer(offerId, vector<TaskDescription>(), map<string, string>());
+ driver1.replyToOffer(offerId, vector<TaskDescription>());
driver1.stop();
driver1.join();
@@ -172,13 +196,14 @@ TEST(MasterTest, ResourcesReofferedAfter
.WillOnce(Return(""));
EXPECT_CALL(sched2, getExecutorInfo(&driver2))
- .WillOnce(Return(ExecutorInfo("noexecutor", "")));
+ .WillOnce(Return(DEFAULT_EXECUTOR_INFO));
EXPECT_CALL(sched2, registered(&driver2, _))
.Times(1);
EXPECT_CALL(sched2, resourceOffer(&driver2, _, _))
- .WillOnce(Trigger(&sched2ResourceOfferCall));
+ .WillOnce(Trigger(&sched2ResourceOfferCall))
+ .WillRepeatedly(Return());
EXPECT_CALL(sched2, offerRescinded(&driver2, _))
.Times(AtMost(1));
@@ -198,7 +223,7 @@ TEST(MasterTest, ResourcesReofferedAfter
{
ASSERT_TRUE(GTEST_IS_THREADSAFE);
- PID master = local::launch(1, 2, 1 * Gigabyte, false, false);
+ PID<Master> master = local::launch(1, 2, 1 * Gigabyte, false, false);
MockScheduler sched1;
MesosSchedulerDriver driver1(&sched1, master);
@@ -212,14 +237,15 @@ TEST(MasterTest, ResourcesReofferedAfter
.WillOnce(Return(""));
EXPECT_CALL(sched1, getExecutorInfo(&driver1))
- .WillOnce(Return(ExecutorInfo("noexecutor", "")));
+ .WillOnce(Return(DEFAULT_EXECUTOR_INFO));
EXPECT_CALL(sched1, registered(&driver1, _))
.Times(1);
EXPECT_CALL(sched1, resourceOffer(&driver1, _, ElementsAre(_)))
.WillOnce(DoAll(SaveArg<1>(&offerId), SaveArg<2>(&offers),
- Trigger(&sched1ResourceOfferCall)));
+ Trigger(&sched1ResourceOfferCall)))
+ .WillRepeatedly(Return());
driver1.start();
@@ -227,22 +253,34 @@ TEST(MasterTest, ResourcesReofferedAfter
EXPECT_NE(0, offers.size());
- map<string, string> params;
- params["cpus"] = "0";
- params["mem"] = lexical_cast<string>(1 * Gigabyte);
+ TaskDescription task;
+ task.set_name("");
+ task.mutable_task_id()->set_value("1");
+ task.mutable_slave_id()->MergeFrom(offers[0].slave_id());
+
+ Resource* cpus = task.add_resources();
+ cpus->set_name("cpus");
+ cpus->set_type(Resource::SCALAR);
+ cpus->mutable_scalar()->set_value(0);
+
+ Resource* mem = task.add_resources();
+ mem->set_name("mem");
+ mem->set_type(Resource::SCALAR);
+ mem->mutable_scalar()->set_value(1 * Gigabyte);
vector<TaskDescription> tasks;
- tasks.push_back(TaskDescription(1, offers[0].slaveId, "", params, bytes()));
+ tasks.push_back(task);
trigger sched1ErrorCall;
- EXPECT_CALL(sched1, error(&driver1, _, "Invalid task size: <0 CPUs, 1024 MEM>"))
+ EXPECT_CALL(sched1,
+ error(&driver1, _, "Invalid resources for task"))
.WillOnce(Trigger(&sched1ErrorCall));
EXPECT_CALL(sched1, offerRescinded(&driver1, offerId))
.Times(AtMost(1));
- driver1.replyToOffer(offerId, tasks, map<string, string>());
+ driver1.replyToOffer(offerId, tasks);
WAIT_UNTIL(sched1ErrorCall);
@@ -258,13 +296,14 @@ TEST(MasterTest, ResourcesReofferedAfter
.WillOnce(Return(""));
EXPECT_CALL(sched2, getExecutorInfo(&driver2))
- .WillOnce(Return(ExecutorInfo("noexecutor", "")));
+ .WillOnce(Return(DEFAULT_EXECUTOR_INFO));
EXPECT_CALL(sched2, registered(&driver2, _))
.Times(1);
EXPECT_CALL(sched2, resourceOffer(&driver2, _, _))
- .WillOnce(Trigger(&sched2ResourceOfferCall));
+ .WillOnce(Trigger(&sched2ResourceOfferCall))
+ .WillRepeatedly(Return());
EXPECT_CALL(sched2, offerRescinded(&driver2, _))
.Times(AtMost(1));
@@ -285,11 +324,14 @@ TEST(MasterTest, SlaveLost)
ASSERT_TRUE(GTEST_IS_THREADSAFE);
Master m;
- PID master = Process::spawn(&m);
+ PID<Master> master = process::spawn(&m);
+
+ Resources resources = Resources::parse("cpus:2;mem:1024");
ProcessBasedIsolationModule isolationModule;
- Slave s(Resources(2, 1 * Gigabyte), true, &isolationModule);
- PID slave = Process::spawn(&s);
+
+ Slave s(resources, true, &isolationModule);
+ PID<Slave> slave = process::spawn(&s);
BasicMasterDetector detector(master, slave, true);
@@ -305,14 +347,15 @@ TEST(MasterTest, SlaveLost)
.WillOnce(Return(""));
EXPECT_CALL(sched, getExecutorInfo(&driver))
- .WillOnce(Return(ExecutorInfo("noexecutor", "")));
+ .WillOnce(Return(DEFAULT_EXECUTOR_INFO));
EXPECT_CALL(sched, registered(&driver, _))
.Times(1);
EXPECT_CALL(sched, resourceOffer(&driver, _, _))
.WillOnce(DoAll(SaveArg<1>(&offerId), SaveArg<2>(&offers),
- Trigger(&resourceOfferCall)));
+ Trigger(&resourceOfferCall)))
+ .WillRepeatedly(Return());
driver.start();
@@ -325,10 +368,10 @@ TEST(MasterTest, SlaveLost)
EXPECT_CALL(sched, offerRescinded(&driver, offerId))
.WillOnce(Trigger(&offerRescindedCall));
- EXPECT_CALL(sched, slaveLost(&driver, offers[0].slaveId))
+ EXPECT_CALL(sched, slaveLost(&driver, offers[0].slave_id()))
.WillOnce(Trigger(&slaveLostCall));
- MesosProcess::post(slave, pack<S2S_SHUTDOWN>());
+ process::post(slave, process::TERMINATE);
WAIT_UNTIL(offerRescindedCall);
WAIT_UNTIL(slaveLostCall);
@@ -336,10 +379,10 @@ TEST(MasterTest, SlaveLost)
driver.stop();
driver.join();
- Process::wait(slave);
+ process::wait(slave);
- MesosProcess::post(master, pack<M2M_SHUTDOWN>());
- Process::wait(master);
+ process::post(master, process::TERMINATE);
+ process::wait(master);
}
@@ -347,7 +390,7 @@ TEST(MasterTest, SchedulerFailover)
{
ASSERT_TRUE(GTEST_IS_THREADSAFE);
- PID master = local::launch(1, 2, 1 * Gigabyte, false, false);
+ PID<Master> master = local::launch(1, 2, 1 * Gigabyte, false, false);
// Launch the first (i.e., failing) scheduler and wait until
// registered gets called to launch the second (i.e., failover)
@@ -364,13 +407,13 @@ TEST(MasterTest, SchedulerFailover)
.WillOnce(Return(""));
EXPECT_CALL(sched1, getExecutorInfo(&driver1))
- .WillOnce(Return(ExecutorInfo("noexecutor", "")));
+ .WillOnce(Return(DEFAULT_EXECUTOR_INFO));
EXPECT_CALL(sched1, registered(&driver1, _))
.WillOnce(DoAll(SaveArg<1>(&frameworkId), Trigger(&sched1RegisteredCall)));
EXPECT_CALL(sched1, resourceOffer(&driver1, _, _))
- .Times(AtMost(1));
+ .WillRepeatedly(Return());
EXPECT_CALL(sched1, offerRescinded(&driver1, _))
.Times(AtMost(1));
@@ -395,13 +438,13 @@ TEST(MasterTest, SchedulerFailover)
.WillOnce(Return(""));
EXPECT_CALL(sched2, getExecutorInfo(&driver2))
- .WillOnce(Return(ExecutorInfo("noexecutor", "")));
+ .WillOnce(Return(DEFAULT_EXECUTOR_INFO));
EXPECT_CALL(sched2, registered(&driver2, frameworkId))
.WillOnce(Trigger(&sched2RegisteredCall));
EXPECT_CALL(sched2, resourceOffer(&driver2, _, _))
- .Times(AtMost(1));
+ .WillRepeatedly(Return());
EXPECT_CALL(sched2, offerRescinded(&driver2, _))
.Times(AtMost(1));
@@ -424,15 +467,15 @@ TEST(MasterTest, SlavePartitioned)
{
ASSERT_TRUE(GTEST_IS_THREADSAFE);
- Clock::pause();
+ process::Clock::pause();
MockFilter filter;
- Process::filter(&filter);
+ process::filter(&filter);
EXPECT_MSG(filter, _, _, _)
.WillRepeatedly(Return(false));
- PID master = local::launch(1, 2, 1 * Gigabyte, false, false);
+ PID<Master> master = local::launch(1, 2, 1 * Gigabyte, false, false);
MockScheduler sched;
MesosSchedulerDriver driver(&sched, master);
@@ -443,13 +486,13 @@ TEST(MasterTest, SlavePartitioned)
.WillOnce(Return(""));
EXPECT_CALL(sched, getExecutorInfo(&driver))
- .WillOnce(Return(ExecutorInfo("noexecutor", "")));
+ .WillOnce(Return(DEFAULT_EXECUTOR_INFO));
EXPECT_CALL(sched, registered(&driver, _))
.Times(1);
EXPECT_CALL(sched, resourceOffer(&driver, _, _))
- .Times(AtMost(1));
+ .WillRepeatedly(Return());
EXPECT_CALL(sched, offerRescinded(&driver, _))
.Times(AtMost(1));
@@ -457,12 +500,14 @@ TEST(MasterTest, SlavePartitioned)
EXPECT_CALL(sched, slaveLost(&driver, _))
.WillOnce(Trigger(&slaveLostCall));
- EXPECT_MSG(filter, Eq(SH2M_HEARTBEAT), _, _)
+ EXPECT_MSG(filter, Eq(PONG), _, _)
.WillRepeatedly(Return(true));
driver.start();
- Clock::advance(master::HEARTBEAT_TIMEOUT);
+ double secs = master::SLAVE_PONG_TIMEOUT * master::MAX_SLAVE_TIMEOUTS;
+
+ process::Clock::advance(secs);
WAIT_UNTIL(slaveLostCall);
@@ -471,9 +516,9 @@ TEST(MasterTest, SlavePartitioned)
local::shutdown();
- Process::filter(NULL);
+ process::filter(NULL);
- Clock::resume();
+ process::Clock::resume();
}
@@ -482,23 +527,121 @@ TEST(MasterTest, TaskRunning)
ASSERT_TRUE(GTEST_IS_THREADSAFE);
Master m;
- PID master = Process::spawn(&m);
+ PID<Master> master = process::spawn(&m);
+
+ Resources resources = Resources::parse("cpus:2;mem:1024");
+
+ MockExecutor exec;
+
+ EXPECT_CALL(exec, init(_, _))
+ .Times(1);
+
+ EXPECT_CALL(exec, launchTask(_, _))
+ .Times(1);
+
+ EXPECT_CALL(exec, shutdown(_))
+ .Times(1);
+
+ map<ExecutorID, Executor*> execs;
+ execs[DEFAULT_EXECUTOR_ID] = &exec;
+
+ TestingIsolationModule isolationModule(execs);
+
+ Slave s(resources, true, &isolationModule);
+ PID<Slave> slave = process::spawn(&s);
+
+ BasicMasterDetector detector(master, slave, true);
+
+ MockScheduler sched;
+ MesosSchedulerDriver driver(&sched, master);
+
+ OfferID offerId;
+ vector<SlaveOffer> offers;
+ TaskStatus status;
+
+ trigger resourceOfferCall, statusUpdateCall;
+
+ EXPECT_CALL(sched, getFrameworkName(&driver))
+ .WillOnce(Return(""));
+
+ EXPECT_CALL(sched, getExecutorInfo(&driver))
+ .WillOnce(Return(DEFAULT_EXECUTOR_INFO));
+
+ EXPECT_CALL(sched, registered(&driver, _))
+ .Times(1);
+
+ EXPECT_CALL(sched, resourceOffer(&driver, _, _))
+ .WillOnce(DoAll(SaveArg<1>(&offerId), SaveArg<2>(&offers),
+ Trigger(&resourceOfferCall)))
+ .WillRepeatedly(Return());
+
+ EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(DoAll(SaveArg<1>(&status), Trigger(&statusUpdateCall)));
+
+ driver.start();
+
+ WAIT_UNTIL(resourceOfferCall);
+
+ EXPECT_NE(0, offers.size());
+
+ TaskDescription task;
+ task.set_name("");
+ task.mutable_task_id()->set_value("1");
+ task.mutable_slave_id()->MergeFrom(offers[0].slave_id());
+ task.mutable_resources()->MergeFrom(offers[0].resources());
+
+ vector<TaskDescription> tasks;
+ tasks.push_back(task);
+
+ driver.replyToOffer(offerId, tasks);
+
+ WAIT_UNTIL(statusUpdateCall);
+
+ EXPECT_EQ(TASK_RUNNING, status.state());
+
+ driver.stop();
+ driver.join();
+
+ process::post(slave, process::TERMINATE);
+ process::wait(slave);
+
+ process::post(master, process::TERMINATE);
+ process::wait(master);
+}
+
+
+TEST(MasterTest, KillTask)
+{
+ ASSERT_TRUE(GTEST_IS_THREADSAFE);
+
+ Master m;
+ PID<Master> master = process::spawn(&m);
+
+ Resources resources = Resources::parse("cpus:2;mem:1024");
MockExecutor exec;
+ trigger killTaskCall;
+
EXPECT_CALL(exec, init(_, _))
.Times(1);
EXPECT_CALL(exec, launchTask(_, _))
.Times(1);
+ EXPECT_CALL(exec, killTask(_, _))
+ .WillOnce(Trigger(&killTaskCall));
+
EXPECT_CALL(exec, shutdown(_))
.Times(1);
- LocalIsolationModule isolationModule(&exec);
+ map<ExecutorID, Executor*> execs;
+ execs[DEFAULT_EXECUTOR_ID] = &exec;
- Slave s(Resources(2, 1 * Gigabyte), true, &isolationModule);
- PID slave = Process::spawn(&s);
+ TestingIsolationModule isolationModule(execs);
+
+ Slave s(resources, true, &isolationModule);
+ PID<Slave> slave = process::spawn(&s);
BasicMasterDetector detector(master, slave, true);
@@ -515,14 +658,15 @@ TEST(MasterTest, TaskRunning)
.WillOnce(Return(""));
EXPECT_CALL(sched, getExecutorInfo(&driver))
- .WillOnce(Return(ExecutorInfo("noexecutor", "")));
+ .WillOnce(Return(DEFAULT_EXECUTOR_INFO));
EXPECT_CALL(sched, registered(&driver, _))
.Times(1);
EXPECT_CALL(sched, resourceOffer(&driver, _, _))
.WillOnce(DoAll(SaveArg<1>(&offerId), SaveArg<2>(&offers),
- Trigger(&resourceOfferCall)));
+ Trigger(&resourceOfferCall)))
+ .WillRepeatedly(Return());
EXPECT_CALL(sched, statusUpdate(&driver, _))
.WillOnce(DoAll(SaveArg<1>(&status), Trigger(&statusUpdateCall)));
@@ -533,23 +677,36 @@ TEST(MasterTest, TaskRunning)
EXPECT_NE(0, offers.size());
+ TaskID taskId;
+ taskId.set_value("1");
+
+ TaskDescription task;
+ task.set_name("");
+ task.mutable_task_id()->MergeFrom(taskId);
+ task.mutable_slave_id()->MergeFrom(offers[0].slave_id());
+ task.mutable_resources()->MergeFrom(offers[0].resources());
+
vector<TaskDescription> tasks;
- tasks.push_back(TaskDescription(1, offers[0].slaveId, "", offers[0].params, ""));
+ tasks.push_back(task);
- driver.replyToOffer(offerId, tasks, map<string, string>());
+ driver.replyToOffer(offerId, tasks);
WAIT_UNTIL(statusUpdateCall);
- EXPECT_EQ(TASK_RUNNING, status.state);
+ EXPECT_EQ(TASK_RUNNING, status.state());
+
+ driver.killTask(taskId);
+
+ WAIT_UNTIL(killTaskCall);
driver.stop();
driver.join();
- MesosProcess::post(slave, pack<S2S_SHUTDOWN>());
- Process::wait(slave);
+ process::post(slave, process::TERMINATE);
+ process::wait(slave);
- MesosProcess::post(master, pack<M2M_SHUTDOWN>());
- Process::wait(master);
+ process::post(master, process::TERMINATE);
+ process::wait(master);
}
@@ -557,14 +714,19 @@ TEST(MasterTest, SchedulerFailoverStatus
{
ASSERT_TRUE(GTEST_IS_THREADSAFE);
- Clock::pause();
+ process::Clock::pause();
MockFilter filter;
- Process::filter(&filter);
+ process::filter(&filter);
EXPECT_MSG(filter, _, _, _)
.WillRepeatedly(Return(false));
+ Master m;
+ PID<Master> master = process::spawn(&m);
+
+ Resources resources = Resources::parse("cpus:2;mem:1024");
+
MockExecutor exec;
EXPECT_CALL(exec, init(_, _))
@@ -576,13 +738,13 @@ TEST(MasterTest, SchedulerFailoverStatus
EXPECT_CALL(exec, shutdown(_))
.Times(1);
- LocalIsolationModule isolationModule(&exec);
+ map<ExecutorID, Executor*> execs;
+ execs[DEFAULT_EXECUTOR_ID] = &exec;
- Master m;
- PID master = Process::spawn(&m);
+ TestingIsolationModule isolationModule(execs);
- Slave s(Resources(2, 1 * Gigabyte), true, &isolationModule);
- PID slave = Process::spawn(&s);
+ Slave s(resources, true, &isolationModule);
+ PID<Slave> slave = process::spawn(&s);
BasicMasterDetector detector(master, slave, true);
@@ -602,14 +764,15 @@ TEST(MasterTest, SchedulerFailoverStatus
.WillOnce(Return(""));
EXPECT_CALL(sched1, getExecutorInfo(&driver1))
- .WillOnce(Return(ExecutorInfo("noexecutor", "")));
+ .WillOnce(Return(DEFAULT_EXECUTOR_INFO));
EXPECT_CALL(sched1, registered(&driver1, _))
.WillOnce(SaveArg<1>(&frameworkId));
EXPECT_CALL(sched1, resourceOffer(&driver1, _, _))
.WillOnce(DoAll(SaveArg<1>(&offerId), SaveArg<2>(&offers),
- Trigger(&resourceOfferCall)));
+ Trigger(&resourceOfferCall)))
+ .WillRepeatedly(Return());
EXPECT_CALL(sched1, statusUpdate(&driver1, _))
.Times(0);
@@ -627,10 +790,16 @@ TEST(MasterTest, SchedulerFailoverStatus
EXPECT_NE(0, offers.size());
+ TaskDescription task;
+ task.set_name("");
+ task.mutable_task_id()->set_value("1");
+ task.mutable_slave_id()->MergeFrom(offers[0].slave_id());
+ task.mutable_resources()->MergeFrom(offers[0].resources());
+
vector<TaskDescription> tasks;
- tasks.push_back(TaskDescription(1, offers[0].slaveId, "", offers[0].params, ""));
+ tasks.push_back(task);
- driver1.replyToOffer(offerId, tasks, map<string, string>());
+ driver1.replyToOffer(offerId, tasks);
WAIT_UNTIL(statusUpdateMsg);
@@ -648,7 +817,7 @@ TEST(MasterTest, SchedulerFailoverStatus
.WillOnce(Return(""));
EXPECT_CALL(sched2, getExecutorInfo(&driver2))
- .WillOnce(Return(ExecutorInfo("noexecutor", "")));
+ .WillOnce(Return(DEFAULT_EXECUTOR_INFO));
EXPECT_CALL(sched2, registered(&driver2, frameworkId))
.WillOnce(Trigger(®isteredCall));
@@ -660,7 +829,7 @@ TEST(MasterTest, SchedulerFailoverStatus
WAIT_UNTIL(registeredCall);
- Clock::advance(RELIABLE_TIMEOUT);
+ process::Clock::advance(STATUS_UPDATE_RETRY_TIMEOUT);
WAIT_UNTIL(statusUpdateCall);
@@ -670,15 +839,15 @@ TEST(MasterTest, SchedulerFailoverStatus
driver1.join();
driver2.join();
- MesosProcess::post(slave, pack<S2S_SHUTDOWN>());
- Process::wait(slave);
+ process::post(slave, process::TERMINATE);
+ process::wait(slave);
- MesosProcess::post(master, pack<M2M_SHUTDOWN>());
- Process::wait(master);
+ process::post(master, process::TERMINATE);
+ process::wait(master);
- Process::filter(NULL);
+ process::filter(NULL);
- Clock::resume();
+ process::Clock::resume();
}
@@ -686,11 +855,16 @@ TEST(MasterTest, FrameworkMessage)
{
ASSERT_TRUE(GTEST_IS_THREADSAFE);
+ Master m;
+ PID<Master> master = process::spawn(&m);
+
+ Resources resources = Resources::parse("cpus:2;mem:1024");
+
MockExecutor exec;
- ExecutorDriver *execDriver;
+ ExecutorDriver* execDriver;
ExecutorArgs args;
- FrameworkMessage execMessage;
+ string execData;
trigger execFrameworkMessageCall;
@@ -701,19 +875,19 @@ TEST(MasterTest, FrameworkMessage)
.Times(1);
EXPECT_CALL(exec, frameworkMessage(_, _))
- .WillOnce(DoAll(SaveArg<1>(&execMessage),
+ .WillOnce(DoAll(SaveArg<1>(&execData),
Trigger(&execFrameworkMessageCall)));
EXPECT_CALL(exec, shutdown(_))
.Times(1);
- LocalIsolationModule isolationModule(&exec);
+ map<ExecutorID, Executor*> execs;
+ execs[DEFAULT_EXECUTOR_ID] = &exec;
- Master m;
- PID master = Process::spawn(&m);
+ TestingIsolationModule isolationModule(execs);
- Slave s(Resources(2, 1 * Gigabyte), true, &isolationModule);
- PID slave = Process::spawn(&s);
+ Slave s(resources, true, &isolationModule);
+ PID<Slave> slave = process::spawn(&s);
BasicMasterDetector detector(master, slave, true);
@@ -726,7 +900,7 @@ TEST(MasterTest, FrameworkMessage)
OfferID offerId;
vector<SlaveOffer> offers;
TaskStatus status;
- FrameworkMessage schedMessage;
+ string schedData;
trigger resourceOfferCall, statusUpdateCall, schedFrameworkMessageCall;
@@ -734,20 +908,21 @@ TEST(MasterTest, FrameworkMessage)
.WillOnce(Return(""));
EXPECT_CALL(sched, getExecutorInfo(&schedDriver))
- .WillOnce(Return(ExecutorInfo("noexecutor", "")));
+ .WillOnce(Return(DEFAULT_EXECUTOR_INFO));
EXPECT_CALL(sched, registered(&schedDriver, _))
.Times(1);
EXPECT_CALL(sched, resourceOffer(&schedDriver, _, _))
.WillOnce(DoAll(SaveArg<1>(&offerId), SaveArg<2>(&offers),
- Trigger(&resourceOfferCall)));
+ Trigger(&resourceOfferCall)))
+ .WillRepeatedly(Return());
EXPECT_CALL(sched, statusUpdate(&schedDriver, _))
.WillOnce(DoAll(SaveArg<1>(&status), Trigger(&statusUpdateCall)));
- EXPECT_CALL(sched, frameworkMessage(&schedDriver, _))
- .WillOnce(DoAll(SaveArg<1>(&schedMessage),
+ EXPECT_CALL(sched, frameworkMessage(&schedDriver, _, _, _))
+ .WillOnce(DoAll(SaveArg<3>(&schedData),
Trigger(&schedFrameworkMessageCall)));
schedDriver.start();
@@ -756,37 +931,47 @@ TEST(MasterTest, FrameworkMessage)
EXPECT_NE(0, offers.size());
+ TaskDescription task;
+ task.set_name("");
+ task.mutable_task_id()->set_value("1");
+ task.mutable_slave_id()->MergeFrom(offers[0].slave_id());
+ task.mutable_resources()->MergeFrom(offers[0].resources());
+
vector<TaskDescription> tasks;
- tasks.push_back(TaskDescription(1, offers[0].slaveId, "", offers[0].params, ""));
+ tasks.push_back(task);
- schedDriver.replyToOffer(offerId, tasks, map<string, string>());
+ schedDriver.replyToOffer(offerId, tasks);
WAIT_UNTIL(statusUpdateCall);
- EXPECT_EQ(TASK_RUNNING, status.state);
+ EXPECT_EQ(TASK_RUNNING, status.state());
+
+ string hello = "hello";
- FrameworkMessage hello(offers[0].slaveId, 1, "hello");
- schedDriver.sendFrameworkMessage(hello);
+ schedDriver.sendFrameworkMessage(offers[0].slave_id(),
+ DEFAULT_EXECUTOR_ID,
+ hello);
WAIT_UNTIL(execFrameworkMessageCall);
- EXPECT_EQ("hello", execMessage.data);
+ EXPECT_EQ(hello, execData);
+
+ string reply = "reply";
- FrameworkMessage reply(args.slaveId, 1, "reply");
execDriver->sendFrameworkMessage(reply);
WAIT_UNTIL(schedFrameworkMessageCall);
- EXPECT_EQ("reply", schedMessage.data);
+ EXPECT_EQ(reply, schedData);
schedDriver.stop();
schedDriver.join();
- MesosProcess::post(slave, pack<S2S_SHUTDOWN>());
- Process::wait(slave);
+ process::post(slave, process::TERMINATE);
+ process::wait(slave);
- MesosProcess::post(master, pack<M2M_SHUTDOWN>());
- Process::wait(master);
+ process::post(master, process::TERMINATE);
+ process::wait(master);
}
@@ -794,9 +979,14 @@ TEST(MasterTest, SchedulerFailoverFramew
{
ASSERT_TRUE(GTEST_IS_THREADSAFE);
+ Master m;
+ PID<Master> master = process::spawn(&m);
+
+ Resources resources = Resources::parse("cpus:2;mem:1024");
+
MockExecutor exec;
- ExecutorDriver *execDriver;
+ ExecutorDriver* execDriver;
EXPECT_CALL(exec, init(_, _))
.WillOnce(SaveArg<0>(&execDriver));
@@ -807,13 +997,13 @@ TEST(MasterTest, SchedulerFailoverFramew
EXPECT_CALL(exec, shutdown(_))
.Times(1);
- LocalIsolationModule isolationModule(&exec);
+ map<ExecutorID, Executor*> execs;
+ execs[DEFAULT_EXECUTOR_ID] = &exec;
- Master m;
- PID master = Process::spawn(&m);
+ TestingIsolationModule isolationModule(execs);
- Slave s(Resources(2, 1 * Gigabyte), true, &isolationModule);
- PID slave = Process::spawn(&s);
+ Slave s(resources, true, &isolationModule);
+ PID<Slave> slave = process::spawn(&s);
BasicMasterDetector detector(master, slave, true);
@@ -831,7 +1021,7 @@ TEST(MasterTest, SchedulerFailoverFramew
.WillOnce(Return(""));
EXPECT_CALL(sched1, getExecutorInfo(&driver1))
- .WillOnce(Return(ExecutorInfo("noexecutor", "")));
+ .WillOnce(Return(DEFAULT_EXECUTOR_INFO));
EXPECT_CALL(sched1, registered(&driver1, _))
.WillOnce(SaveArg<1>(&frameworkId));
@@ -841,7 +1031,8 @@ TEST(MasterTest, SchedulerFailoverFramew
EXPECT_CALL(sched1, resourceOffer(&driver1, _, ElementsAre(_)))
.WillOnce(DoAll(SaveArg<1>(&offerId), SaveArg<2>(&offers),
- Trigger(&sched1ResourceOfferCall)));
+ Trigger(&sched1ResourceOfferCall)))
+ .WillRepeatedly(Return());
EXPECT_CALL(sched1, error(&driver1, _, "Framework failover"))
.Times(1);
@@ -852,14 +1043,20 @@ TEST(MasterTest, SchedulerFailoverFramew
EXPECT_NE(0, offers.size());
+ TaskDescription task;
+ task.set_name("");
+ task.mutable_task_id()->set_value("1");
+ task.mutable_slave_id()->MergeFrom(offers[0].slave_id());
+ task.mutable_resources()->MergeFrom(offers[0].resources());
+
vector<TaskDescription> tasks;
- tasks.push_back(TaskDescription(1, offers[0].slaveId, "", offers[0].params, ""));
+ tasks.push_back(task);
- driver1.replyToOffer(offerId, tasks, map<string, string>());
+ driver1.replyToOffer(offerId, tasks);
WAIT_UNTIL(sched1StatusUpdateCall);
- EXPECT_EQ(TASK_RUNNING, status.state);
+ EXPECT_EQ(TASK_RUNNING, status.state());
MockScheduler sched2;
MesosSchedulerDriver driver2(&sched2, master, frameworkId);
@@ -870,19 +1067,19 @@ TEST(MasterTest, SchedulerFailoverFramew
.WillOnce(Return(""));
EXPECT_CALL(sched2, getExecutorInfo(&driver2))
- .WillOnce(Return(ExecutorInfo("noexecutor", "")));
+ .WillOnce(Return(DEFAULT_EXECUTOR_INFO));
EXPECT_CALL(sched2, registered(&driver2, frameworkId))
.WillOnce(Trigger(&sched2RegisteredCall));
- EXPECT_CALL(sched2, frameworkMessage(&driver2, _))
+ EXPECT_CALL(sched2, frameworkMessage(&driver2, _, _, _))
.WillOnce(Trigger(&sched2FrameworkMessageCall));
driver2.start();
WAIT_UNTIL(sched2RegisteredCall);
- execDriver->sendFrameworkMessage(FrameworkMessage());
+ execDriver->sendFrameworkMessage("");
WAIT_UNTIL(sched2FrameworkMessageCall);
@@ -892,9 +1089,145 @@ TEST(MasterTest, SchedulerFailoverFramew
driver1.join();
driver2.join();
- MesosProcess::post(slave, pack<S2S_SHUTDOWN>());
- Process::wait(slave);
+ process::post(slave, process::TERMINATE);
+ process::wait(slave);
+
+ process::post(master, process::TERMINATE);
+ process::wait(master);
+}
+
+
+TEST(MasterTest, MultipleExecutors)
+{
+ ASSERT_TRUE(GTEST_IS_THREADSAFE);
+
+ Master m;
+ PID<Master> master = process::spawn(&m);
+
+ Resources resources = Resources::parse("cpus:2;mem:1024");
+
+ MockExecutor exec1;
+ TaskDescription exec1Task;
+ trigger exec1LaunchTaskCall;
+
+ EXPECT_CALL(exec1, init(_, _))
+ .Times(1);
+
+ EXPECT_CALL(exec1, launchTask(_, _))
+ .WillOnce(DoAll(SaveArg<1>(&exec1Task),
+ Trigger(&exec1LaunchTaskCall)));
+
+ EXPECT_CALL(exec1, shutdown(_))
+ .Times(1);
+
+ MockExecutor exec2;
+ TaskDescription exec2Task;
+ trigger exec2LaunchTaskCall;
+
+ EXPECT_CALL(exec2, init(_, _))
+ .Times(1);
+
+ EXPECT_CALL(exec2, launchTask(_, _))
+ .WillOnce(DoAll(SaveArg<1>(&exec2Task),
+ Trigger(&exec2LaunchTaskCall)));
+
+ EXPECT_CALL(exec2, shutdown(_))
+ .Times(1);
+
+ ExecutorID executorId1;
+ executorId1.set_value("executor-1");
+
+ ExecutorID executorId2;
+ executorId2.set_value("executor-2");
+
+ map<ExecutorID, Executor*> execs;
+ execs[executorId1] = &exec1;
+ execs[executorId2] = &exec2;
+
+ TestingIsolationModule isolationModule(execs);
+
+ Slave s(resources, true, &isolationModule);
+ PID<Slave> slave = process::spawn(&s);
+
+ BasicMasterDetector detector(master, slave, true);
+
+ MockScheduler sched;
+ MesosSchedulerDriver driver(&sched, master);
+
+ OfferID offerId;
+ vector<SlaveOffer> offers;
+ TaskStatus status1, status2;
+
+ trigger resourceOfferCall, statusUpdateCall1, statusUpdateCall2;
+
+ EXPECT_CALL(sched, getFrameworkName(&driver))
+ .WillOnce(Return(""));
+
+ EXPECT_CALL(sched, getExecutorInfo(&driver))
+ .WillOnce(Return(DEFAULT_EXECUTOR_INFO));
+
+ EXPECT_CALL(sched, registered(&driver, _))
+ .Times(1);
+
+ EXPECT_CALL(sched, resourceOffer(&driver, _, _))
+ .WillOnce(DoAll(SaveArg<1>(&offerId), SaveArg<2>(&offers),
+ Trigger(&resourceOfferCall)))
+ .WillRepeatedly(Return());
+
+ EXPECT_CALL(sched, statusUpdate(&driver, _))
+ .WillOnce(DoAll(SaveArg<1>(&status1), Trigger(&statusUpdateCall1)))
+ .WillOnce(DoAll(SaveArg<1>(&status2), Trigger(&statusUpdateCall2)));
+
+ driver.start();
+
+ WAIT_UNTIL(resourceOfferCall);
+
+ ASSERT_NE(0, offers.size());
+
+ TaskDescription task1;
+ task1.set_name("");
+ task1.mutable_task_id()->set_value("1");
+ task1.mutable_slave_id()->MergeFrom(offers[0].slave_id());
+ task1.mutable_resources()->MergeFrom(Resources::parse("cpus:1;mem:512"));
+ task1.mutable_executor()->mutable_executor_id()->MergeFrom(executorId1);
+ task1.mutable_executor()->set_uri("noexecutor");
+
+ TaskDescription task2;
+ task2.set_name("");
+ task2.mutable_task_id()->set_value("2");
+ task2.mutable_slave_id()->MergeFrom(offers[0].slave_id());
+ task2.mutable_resources()->MergeFrom(Resources::parse("cpus:1;mem:512"));
+ task2.mutable_executor()->mutable_executor_id()->MergeFrom(executorId2);
+ task2.mutable_executor()->set_uri("noexecutor");
+
+ vector<TaskDescription> tasks;
+ tasks.push_back(task1);
+ tasks.push_back(task2);
+
+ driver.replyToOffer(offerId, tasks);
+
+ WAIT_UNTIL(statusUpdateCall1);
+
+ EXPECT_EQ(TASK_RUNNING, status1.state());
+
+ WAIT_UNTIL(statusUpdateCall2);
+
+ EXPECT_EQ(TASK_RUNNING, status2.state());
+
+ WAIT_UNTIL(exec1LaunchTaskCall);
+
+ EXPECT_EQ(task1.task_id(), exec1Task.task_id());
+
+ WAIT_UNTIL(exec2LaunchTaskCall);
+
+ EXPECT_EQ(task2.task_id(), exec2Task.task_id());
+
+ driver.stop();
+ driver.join();
+
+ process::post(slave, process::TERMINATE);
+ process::wait(slave);
- MesosProcess::post(master, pack<M2M_SHUTDOWN>());
- Process::wait(master);
+ process::post(master, process::TERMINATE);
+ process::wait(master);
}
Modified: incubator/mesos/trunk/src/tests/multimap_test.cpp
URL: http://svn.apache.org/viewvc/incubator/mesos/trunk/src/tests/multimap_test.cpp?rev=1132335&r1=1132334&r2=1132335&view=diff
==============================================================================
--- incubator/mesos/trunk/src/tests/multimap_test.cpp (original)
+++ incubator/mesos/trunk/src/tests/multimap_test.cpp Sun Jun 5 09:27:14 2011
@@ -2,14 +2,14 @@
#include <string>
-#include <common/foreach.hpp>
-#include <common/multimap.hpp>
-
-using std::string;
+#include "common/foreach.hpp"
+#include "common/multimap.hpp"
using namespace mesos;
using namespace mesos::internal;
+using std::string;
+
TEST(Multimap, Insert)
{
Modified: incubator/mesos/trunk/src/tests/offer_reply_errors_test.cpp
URL: http://svn.apache.org/viewvc/incubator/mesos/trunk/src/tests/offer_reply_errors_test.cpp?rev=1132335&r1=1132334&r2=1132335&view=diff
==============================================================================
--- incubator/mesos/trunk/src/tests/offer_reply_errors_test.cpp (original)
+++ incubator/mesos/trunk/src/tests/offer_reply_errors_test.cpp Sun Jun 5 09:27:14 2011
@@ -1,21 +1,21 @@
#include <gmock/gmock.h>
-#include <mesos_exec.hpp>
-#include <mesos_sched.hpp>
-
#include <boost/lexical_cast.hpp>
-#include <common/date_utils.hpp>
+#include <mesos/executor.hpp>
+#include <mesos/scheduler.hpp>
+
+#include "common/date_utils.hpp"
-#include <local/local.hpp>
+#include "local/local.hpp"
-#include <master/master.hpp>
+#include "master/master.hpp"
-#include <slave/isolation_module.hpp>
-#include <slave/process_based_isolation_module.hpp>
-#include <slave/slave.hpp>
+#include "slave/isolation_module.hpp"
+#include "slave/process_based_isolation_module.hpp"
+#include "slave/slave.hpp"
-#include <tests/utils.hpp>
+#include "tests/utils.hpp"
using namespace mesos;
using namespace mesos::internal;
Modified: incubator/mesos/trunk/src/tests/resources_test.cpp
URL: http://svn.apache.org/viewvc/incubator/mesos/trunk/src/tests/resources_test.cpp?rev=1132335&r1=1132334&r2=1132335&view=diff
==============================================================================
--- incubator/mesos/trunk/src/tests/resources_test.cpp (original)
+++ incubator/mesos/trunk/src/tests/resources_test.cpp Sun Jun 5 09:27:14 2011
@@ -3,7 +3,7 @@
#include <gtest/gtest.h>
-#include <master/master.hpp>
+#include "master/master.hpp"
using namespace mesos;
using namespace mesos::internal;
Modified: incubator/mesos/trunk/src/tests/sample_frameworks_test.cpp
URL: http://svn.apache.org/viewvc/incubator/mesos/trunk/src/tests/sample_frameworks_test.cpp?rev=1132335&r1=1132334&r2=1132335&view=diff
==============================================================================
--- incubator/mesos/trunk/src/tests/sample_frameworks_test.cpp (original)
+++ incubator/mesos/trunk/src/tests/sample_frameworks_test.cpp Sun Jun 5 09:27:14 2011
@@ -1,8 +1,8 @@
#include <gtest/gtest.h>
-#include <config/config.hpp>
+#include "config/config.hpp"
-#include <tests/external_test.hpp>
+#include "tests/external_test.hpp"
// Run each of the sample frameworks in local mode
Modified: incubator/mesos/trunk/src/tests/string_utils_test.cpp
URL: http://svn.apache.org/viewvc/incubator/mesos/trunk/src/tests/string_utils_test.cpp?rev=1132335&r1=1132334&r2=1132335&view=diff
==============================================================================
--- incubator/mesos/trunk/src/tests/string_utils_test.cpp (original)
+++ incubator/mesos/trunk/src/tests/string_utils_test.cpp Sun Jun 5 09:27:14 2011
@@ -3,14 +3,14 @@
#include <string>
#include <vector>
-#include <common/string_utils.hpp>
-
-using std::string;
-using std::vector;
+#include "common/string_utils.hpp"
using namespace mesos;
using namespace mesos::internal;
+using std::string;
+using std::vector;
+
TEST(StringUtilsTest, SplitEmptyString)
{
Modified: incubator/mesos/trunk/src/tests/utils.cpp
URL: http://svn.apache.org/viewvc/incubator/mesos/trunk/src/tests/utils.cpp?rev=1132335&r1=1132334&r2=1132335&view=diff
==============================================================================
--- incubator/mesos/trunk/src/tests/utils.cpp (original)
+++ incubator/mesos/trunk/src/tests/utils.cpp Sun Jun 5 09:27:14 2011
@@ -4,12 +4,12 @@
#include <gtest/gtest.h>
-#include <tests/utils.hpp>
-
-using std::string;
+#include "tests/utils.hpp"
using namespace mesos::internal;
+using std::string;
+
string test::mesosHome;
Modified: incubator/mesos/trunk/src/tests/utils.hpp
URL: http://svn.apache.org/viewvc/incubator/mesos/trunk/src/tests/utils.hpp?rev=1132335&r1=1132334&r2=1132335&view=diff
==============================================================================
--- incubator/mesos/trunk/src/tests/utils.hpp (original)
+++ incubator/mesos/trunk/src/tests/utils.hpp Sun Jun 5 09:27:14 2011
@@ -1,16 +1,16 @@
#ifndef __TESTING_UTILS_HPP__
#define __TESTING_UTILS_HPP__
-#include <string>
+#include <gmock/gmock.h>
-#include <mesos_exec.hpp>
-#include <mesos_sched.hpp>
+#include <string>
-#include <process.hpp>
+#include <mesos/executor.hpp>
+#include <mesos/scheduler.hpp>
-#include <gmock/gmock.h>
+#include <process/process.hpp>
-#include <messaging/messages.hpp>
+#include "messaging/messages.hpp"
namespace mesos { namespace internal { namespace test {