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 2012/10/13 02:55:10 UTC
svn commit: r1397754 - in /incubator/mesos/trunk/src/tests:
cgroups_tests.cpp utils.hpp
Author: benh
Date: Sat Oct 13 00:55:09 2012
New Revision: 1397754
URL: http://svn.apache.org/viewvc?rev=1397754&view=rev
Log:
Added some ASSERT_/EXPECT_ macros for Option, Try, and Result.
Review: https://reviews.apache.org/r/7545
Modified:
incubator/mesos/trunk/src/tests/cgroups_tests.cpp
incubator/mesos/trunk/src/tests/utils.hpp
Modified: incubator/mesos/trunk/src/tests/cgroups_tests.cpp
URL: http://svn.apache.org/viewvc/incubator/mesos/trunk/src/tests/cgroups_tests.cpp?rev=1397754&r1=1397753&r2=1397754&view=diff
==============================================================================
--- incubator/mesos/trunk/src/tests/cgroups_tests.cpp (original)
+++ incubator/mesos/trunk/src/tests/cgroups_tests.cpp Sat Oct 13 00:55:09 2012
@@ -36,6 +36,8 @@
#include "linux/cgroups.hpp"
+#include "tests/utils.hpp"
+
using namespace process;
@@ -59,14 +61,14 @@ protected:
{
// Create a hierarchy for test.
std::string subsystems = "cpu,memory,freezer";
- ASSERT_TRUE(cgroups::createHierarchy(hierarchy, subsystems).isSome());
+ ASSERT_SOME(cgroups::createHierarchy(hierarchy, subsystems));
// Create cgroups for test.
- ASSERT_TRUE(cgroups::createCgroup(hierarchy, "prof").isSome());
- ASSERT_TRUE(cgroups::createCgroup(hierarchy, "stu").isSome());
- ASSERT_TRUE(cgroups::createCgroup(hierarchy, "stu/grad").isSome());
- ASSERT_TRUE(cgroups::createCgroup(hierarchy, "stu/under").isSome());
- ASSERT_TRUE(cgroups::createCgroup(hierarchy, "stu/under/senior").isSome());
+ ASSERT_SOME(cgroups::createCgroup(hierarchy, "prof"));
+ ASSERT_SOME(cgroups::createCgroup(hierarchy, "stu"));
+ ASSERT_SOME(cgroups::createCgroup(hierarchy, "stu/grad"));
+ ASSERT_SOME(cgroups::createCgroup(hierarchy, "stu/under"));
+ ASSERT_SOME(cgroups::createCgroup(hierarchy, "stu/under/senior"));
}
void cleanup()
@@ -74,13 +76,13 @@ protected:
if (cgroups::checkHierarchy(hierarchy).isSome()) {
// Remove all cgroups.
Try<std::vector<std::string> > cgroups = cgroups::getCgroups(hierarchy);
- ASSERT_TRUE(cgroups.isSome());
+ ASSERT_SOME(cgroups);
foreach (const std::string& cgroup, cgroups.get()) {
- ASSERT_TRUE(cgroups::removeCgroup(hierarchy, cgroup).isSome());
+ ASSERT_SOME(cgroups::removeCgroup(hierarchy, cgroup));
}
// Remove the hierarchy.
- ASSERT_TRUE(cgroups::removeHierarchy(hierarchy).isSome());
+ ASSERT_SOME(cgroups::removeHierarchy(hierarchy));
}
// Remove the directory if still exists.
@@ -111,76 +113,34 @@ const std::string CgroupsTest::hierarchy
TEST_F(CgroupsSimpleTest, ROOT_CGROUPS_Enabled)
{
- Try<bool> result = false;
-
- result = cgroups::enabled("cpu");
- ASSERT_TRUE(result.isSome());
- EXPECT_TRUE(result.get());
-
- result = cgroups::enabled(",cpu");
- ASSERT_TRUE(result.isSome());
- EXPECT_TRUE(result.get());
-
- result = cgroups::enabled("cpu,memory");
- ASSERT_TRUE(result.isSome());
- EXPECT_TRUE(result.get());
-
- result = cgroups::enabled("cpu,memory,");
- ASSERT_TRUE(result.isSome());
- EXPECT_TRUE(result.get());
-
- result = cgroups::enabled("invalid");
- EXPECT_TRUE(result.isError());
-
- result = cgroups::enabled("cpu,invalid");
- EXPECT_TRUE(result.isError());
-
- result = cgroups::enabled(",");
- EXPECT_TRUE(result.isError());
-
- result = cgroups::enabled("");
- EXPECT_TRUE(result.isError());
+ EXPECT_SOME_TRUE(cgroups::enabled("cpu"));
+ EXPECT_SOME_TRUE(cgroups::enabled(",cpu"));
+ EXPECT_SOME_TRUE(cgroups::enabled("cpu,memory"));
+ EXPECT_SOME_TRUE(cgroups::enabled("cpu,memory,"));
+ EXPECT_ERROR(cgroups::enabled("invalid"));
+ EXPECT_ERROR(cgroups::enabled("cpu,invalid"));
+ EXPECT_ERROR(cgroups::enabled(","));
+ EXPECT_ERROR(cgroups::enabled(""));
}
TEST_F(CgroupsTest, ROOT_CGROUPS_Busy)
{
- Try<bool> result = false;
-
- result = cgroups::busy("invalid");
- EXPECT_TRUE(result.isError());
-
- result = cgroups::busy("cpu,invalid");
- EXPECT_TRUE(result.isError());
-
- result = cgroups::busy(",");
- EXPECT_TRUE(result.isError());
-
- result = cgroups::busy("");
- EXPECT_TRUE(result.isError());
-
- result = cgroups::busy("cpu");
- ASSERT_TRUE(result.isSome());
- EXPECT_TRUE(result.get());
-
- result = cgroups::busy(",cpu");
- ASSERT_TRUE(result.isSome());
- EXPECT_TRUE(result.get());
-
- result = cgroups::busy("cpu,memory");
- ASSERT_TRUE(result.isSome());
- EXPECT_TRUE(result.get());
-
- result = cgroups::busy("cpu,memory,");
- ASSERT_TRUE(result.isSome());
- EXPECT_TRUE(result.get());
+ EXPECT_ERROR(cgroups::busy("invalid"));
+ EXPECT_ERROR(cgroups::busy("cpu,invalid"));
+ EXPECT_ERROR(cgroups::busy(","));
+ EXPECT_ERROR(cgroups::busy(""));
+ EXPECT_SOME_TRUE(cgroups::busy("cpu"));
+ EXPECT_SOME_TRUE(cgroups::busy(",cpu"));
+ EXPECT_SOME_TRUE(cgroups::busy("cpu,memory"));
+ EXPECT_SOME_TRUE(cgroups::busy("cpu,memory,"));
}
TEST_F(CgroupsSimpleTest, ROOT_CGROUPS_Subsystems)
{
Try<std::set<std::string> > names = cgroups::subsystems();
- ASSERT_TRUE(names.isSome());
+ ASSERT_SOME(names);
Option<std::string> cpu;
Option<std::string> memory;
@@ -192,15 +152,15 @@ TEST_F(CgroupsSimpleTest, ROOT_CGROUPS_S
}
}
- EXPECT_TRUE(cpu.isSome());
- EXPECT_TRUE(memory.isSome());
+ EXPECT_SOME(cpu);
+ EXPECT_SOME(memory);
}
TEST_F(CgroupsTest, ROOT_CGROUPS_SubsystemsHierarchy)
{
Try<std::set<std::string> > names = cgroups::subsystems(hierarchy);
- ASSERT_TRUE(names.isSome());
+ ASSERT_SOME(names);
Option<std::string> cpu;
Option<std::string> memory;
@@ -212,118 +172,116 @@ TEST_F(CgroupsTest, ROOT_CGROUPS_Subsyst
}
}
- EXPECT_TRUE(cpu.isSome());
- EXPECT_TRUE(memory.isSome());
+ EXPECT_SOME(cpu);
+ EXPECT_SOME(memory);
}
TEST_F(CgroupsSimpleTest, ROOT_CGROUPS_CreateRemoveHierarchy)
{
- EXPECT_TRUE(cgroups::createHierarchy("/tmp", "cpu").isError());
+ EXPECT_ERROR(cgroups::createHierarchy("/tmp", "cpu"));
- EXPECT_TRUE(cgroups::createHierarchy(hierarchy, "invalid").isError());
+ EXPECT_ERROR(cgroups::createHierarchy(hierarchy, "invalid"));
- ASSERT_TRUE(cgroups::createHierarchy(hierarchy, "cpu,memory").isSome());
+ ASSERT_SOME(cgroups::createHierarchy(hierarchy, "cpu,memory"));
- EXPECT_TRUE(cgroups::createHierarchy(hierarchy, "cpuset").isError());
+ EXPECT_ERROR(cgroups::createHierarchy(hierarchy, "cpuset"));
- EXPECT_TRUE(cgroups::removeHierarchy("/tmp").isError());
+ EXPECT_ERROR(cgroups::removeHierarchy("/tmp"));
- ASSERT_TRUE(cgroups::removeHierarchy(hierarchy).isSome());
+ ASSERT_SOME(cgroups::removeHierarchy(hierarchy));
}
TEST_F(CgroupsTest, ROOT_CGROUPS_CheckHierarchy)
{
- EXPECT_TRUE(cgroups::checkHierarchy("/tmp-nonexist").isError());
+ EXPECT_ERROR(cgroups::checkHierarchy("/tmp-nonexist"));
- EXPECT_TRUE(cgroups::checkHierarchy("/tmp").isError());
+ EXPECT_ERROR(cgroups::checkHierarchy("/tmp"));
- EXPECT_TRUE(cgroups::checkHierarchy(hierarchy).isSome());
+ EXPECT_SOME(cgroups::checkHierarchy(hierarchy));
- EXPECT_TRUE(cgroups::checkHierarchy(hierarchy + "/").isSome());
+ EXPECT_SOME(cgroups::checkHierarchy(hierarchy + "/"));
- EXPECT_TRUE(cgroups::checkHierarchy(hierarchy + "/stu").isError());
+ EXPECT_ERROR(cgroups::checkHierarchy(hierarchy + "/stu"));
}
TEST_F(CgroupsTest, ROOT_CGROUPS_CheckHierarchySubsystems)
{
- EXPECT_TRUE(cgroups::checkHierarchy("/tmp-nonexist", "cpu").isError());
+ EXPECT_ERROR(cgroups::checkHierarchy("/tmp-nonexist", "cpu"));
- EXPECT_TRUE(cgroups::checkHierarchy("/tmp", "cpu,memory").isError());
+ EXPECT_ERROR(cgroups::checkHierarchy("/tmp", "cpu,memory"));
- EXPECT_TRUE(cgroups::checkHierarchy("/tmp", "cpu").isError());
+ EXPECT_ERROR(cgroups::checkHierarchy("/tmp", "cpu"));
- EXPECT_TRUE(cgroups::checkHierarchy("/tmp", "invalid").isError());
+ EXPECT_ERROR(cgroups::checkHierarchy("/tmp", "invalid"));
- EXPECT_TRUE(cgroups::checkHierarchy(hierarchy, "cpu,memory").isSome());
+ EXPECT_SOME(cgroups::checkHierarchy(hierarchy, "cpu,memory"));
- EXPECT_TRUE(cgroups::checkHierarchy(hierarchy, "memory").isSome());
+ EXPECT_SOME(cgroups::checkHierarchy(hierarchy, "memory"));
- EXPECT_TRUE(cgroups::checkHierarchy(hierarchy, "invalid").isError());
+ EXPECT_ERROR(cgroups::checkHierarchy(hierarchy, "invalid"));
- EXPECT_TRUE(cgroups::checkHierarchy(hierarchy + "/stu", "cpu").isError());
+ EXPECT_ERROR(cgroups::checkHierarchy(hierarchy + "/stu", "cpu"));
}
TEST_F(CgroupsSimpleTest, ROOT_CGROUPS_CreateRemoveCgroup)
{
- EXPECT_TRUE(cgroups::createCgroup("/tmp", "test").isError());
+ EXPECT_ERROR(cgroups::createCgroup("/tmp", "test"));
- ASSERT_TRUE(cgroups::createHierarchy(hierarchy, "cpu,memory").isSome());
+ ASSERT_SOME(cgroups::createHierarchy(hierarchy, "cpu,memory"));
- EXPECT_TRUE(cgroups::createCgroup(hierarchy, "test/1").isError());
+ EXPECT_ERROR(cgroups::createCgroup(hierarchy, "test/1"));
- ASSERT_TRUE(cgroups::createCgroup(hierarchy, "test").isSome());
+ ASSERT_SOME(cgroups::createCgroup(hierarchy, "test"));
- EXPECT_TRUE(cgroups::removeCgroup(hierarchy, "invalid").isError());
+ EXPECT_ERROR(cgroups::removeCgroup(hierarchy, "invalid"));
- ASSERT_TRUE(cgroups::removeCgroup(hierarchy, "test").isSome());
+ ASSERT_SOME(cgroups::removeCgroup(hierarchy, "test"));
- ASSERT_TRUE(cgroups::removeHierarchy(hierarchy).isSome());
+ ASSERT_SOME(cgroups::removeHierarchy(hierarchy));
}
TEST_F(CgroupsTest, ROOT_CGROUPS_ReadControl)
{
- Try<std::string> result = std::string();
- std::string pid = stringify(::getpid());
+ EXPECT_ERROR(cgroups::readControl(hierarchy, "/stu", "invalid"));
- result = cgroups::readControl(hierarchy, "/stu", "invalid");
- EXPECT_TRUE(result.isError());
+ std::string pid = stringify(::getpid());
- result = cgroups::readControl(hierarchy, "/", "tasks");
- ASSERT_TRUE(result.isSome());
+ Try<std::string> result = cgroups::readControl(hierarchy, "/", "tasks");
+ ASSERT_SOME(result);
EXPECT_TRUE(strings::contains(result.get(), pid));
}
TEST_F(CgroupsTest, ROOT_CGROUPS_WriteControl)
{
- std::string pid = stringify(::getpid());
-
- EXPECT_TRUE(cgroups::writeControl(hierarchy,
+ EXPECT_ERROR(cgroups::writeControl(hierarchy,
"/prof",
"invalid",
- "invalid").isError());
+ "invalid"));
+
+ std::string pid = stringify(::getpid());
- ASSERT_TRUE(cgroups::writeControl(hierarchy, "/prof", "tasks", pid).isSome());
+ ASSERT_SOME(cgroups::writeControl(hierarchy, "/prof", "tasks", pid));
Try<std::set<pid_t> > tasks = cgroups::getTasks(hierarchy, "/prof");
- ASSERT_TRUE(tasks.isSome());
+ ASSERT_SOME(tasks);
std::set<pid_t> pids = tasks.get();
EXPECT_NE(pids.find(::getpid()), pids.end());
- ASSERT_TRUE(cgroups::writeControl(hierarchy, "/", "tasks", pid).isSome());
+ ASSERT_SOME(cgroups::writeControl(hierarchy, "/", "tasks", pid));
}
TEST_F(CgroupsTest, ROOT_CGROUPS_GetCgroups)
{
Try<std::vector<std::string> > cgroups = cgroups::getCgroups(hierarchy);
- ASSERT_TRUE(cgroups.isSome());
+ ASSERT_SOME(cgroups);
EXPECT_EQ(cgroups.get()[0], "/stu/under/senior");
EXPECT_EQ(cgroups.get()[1], "/stu/under");
@@ -332,14 +290,14 @@ TEST_F(CgroupsTest, ROOT_CGROUPS_GetCgro
EXPECT_EQ(cgroups.get()[4], "/prof");
cgroups = cgroups::getCgroups(hierarchy, "/stu");
- ASSERT_TRUE(cgroups.isSome());
+ ASSERT_SOME(cgroups);
EXPECT_EQ(cgroups.get()[0], "/stu/under/senior");
EXPECT_EQ(cgroups.get()[1], "/stu/under");
EXPECT_EQ(cgroups.get()[2], "/stu/grad");
cgroups = cgroups::getCgroups(hierarchy, "/prof");
- ASSERT_TRUE(cgroups.isSome());
+ ASSERT_SOME(cgroups);
EXPECT_TRUE(cgroups.get().empty());
}
@@ -348,7 +306,7 @@ TEST_F(CgroupsTest, ROOT_CGROUPS_GetCgro
TEST_F(CgroupsTest, ROOT_CGROUPS_GetTasks)
{
Try<std::set<pid_t> > tasks = cgroups::getTasks(hierarchy, "/");
- ASSERT_TRUE(tasks.isSome());
+ ASSERT_SOME(tasks);
std::set<pid_t> pids = tasks.get();
EXPECT_NE(pids.find(1), pids.end());
@@ -359,17 +317,17 @@ TEST_F(CgroupsTest, ROOT_CGROUPS_GetTask
TEST_F(CgroupsTest, ROOT_CGROUPS_ListenEvent)
{
// Disable oom killer.
- ASSERT_TRUE(cgroups::writeControl(hierarchy,
+ ASSERT_SOME(cgroups::writeControl(hierarchy,
"/prof",
"memory.oom_control",
- "1").isSome());
+ "1"));
// Limit the memory usage of "/prof" to 64MB.
size_t limit = 1024 * 1024 * 64;
- ASSERT_TRUE(cgroups::writeControl(hierarchy,
+ ASSERT_SOME(cgroups::writeControl(hierarchy,
"/prof",
"memory.limit_in_bytes",
- stringify(limit)).isSome());
+ stringify(limit)));
// Listen on oom events for "/prof" cgroup.
Future<uint64_t> future =
Modified: incubator/mesos/trunk/src/tests/utils.hpp
URL: http://svn.apache.org/viewvc/incubator/mesos/trunk/src/tests/utils.hpp?rev=1397754&r1=1397753&r2=1397754&view=diff
==============================================================================
--- incubator/mesos/trunk/src/tests/utils.hpp (original)
+++ incubator/mesos/trunk/src/tests/utils.hpp Sat Oct 13 00:55:09 2012
@@ -120,83 +120,6 @@ void enterTestDirectory(const char* test
DEFAULT_EXECUTOR_INFO.executor_id()
-template <typename T>
-void ASSERT_FUTURE_WILL_SUCCEED(const process::Future<T>& future)
-{
- ASSERT_TRUE(future.await());
- ASSERT_FALSE(future.isDiscarded());
- ASSERT_FALSE(future.isFailed()) << future.failure();
-}
-
-
-template <typename T>
-void EXPECT_FUTURE_WILL_SUCCEED(const process::Future<T>& future)
-{
- ASSERT_TRUE(future.await());
- EXPECT_FALSE(future.isDiscarded());
- EXPECT_FALSE(future.isFailed()) << future.failure();
-}
-
-
-template <typename T>
-void ASSERT_FUTURE_WILL_FAIL(const process::Future<T>& future)
-{
- ASSERT_TRUE(future.await());
- ASSERT_TRUE(future.isFailed());
-}
-
-
-template <typename T>
-void EXPECT_FUTURE_WILL_FAIL(const process::Future<T>& future)
-{
- ASSERT_TRUE(future.await());
- EXPECT_TRUE(future.isFailed());
-}
-
-
-template <typename T1, typename T2>
-void ASSERT_FUTURE_WILL_EQ(const T1& t1, const process::Future<T2>& future)
-{
- ASSERT_FUTURE_WILL_SUCCEED(future);
- ASSERT_EQ(t1, future.get());
-}
-
-
-template <typename T1, typename T2>
-void EXPECT_FUTURE_WILL_EQ(const T1& t1, const process::Future<T2>& future)
-{
- ASSERT_FUTURE_WILL_SUCCEED(future);
- EXPECT_EQ(t1, future.get());
-}
-
-
-inline void EXPECT_RESPONSE_STATUS_WILL_EQ(
- const std::string& expected,
- const process::Future<process::http::Response>& future)
-{
- ASSERT_FUTURE_WILL_SUCCEED(future);
- EXPECT_EQ(expected, future.get().status);
-}
-
-
-inline void EXPECT_RESPONSE_BODY_WILL_EQ(
- const std::string& expected,
- const process::Future<process::http::Response>& future)
-{
- ASSERT_FUTURE_WILL_SUCCEED(future);
- EXPECT_EQ(expected, future.get().body);
-}
-
-
-#define EXPECT_RESPONSE_HEADER_WILL_EQ(expected, headerKey, future) \
- do { \
- typeof(future) _future = future; \
- ASSERT_FUTURE_WILL_SUCCEED(future); \
- EXPECT_TRUE(_future.get().headers.contains(headerKey)); \
- EXPECT_EQ(expected, _future.get().headers.find(headerKey)->second); \
- } while (false);
-
-
/**
* Definition of a mock Scheduler to be used in tests with gmock.
*/
@@ -742,4 +665,162 @@ private:
} // namespace internal {
} // namespace mesos {
+
+template <typename T>
+std::string assertSomeError(const Option<T>& o)
+{
+ CHECK(!o.isSome());
+ return "Option is NONE";
+}
+
+
+template <typename T>
+std::string assertSomeError(const Try<T>& t)
+{
+ CHECK(!t.isSome());
+ return t.error();
+}
+
+
+template <typename T>
+std::string assertSomeError(const Result<T>& r)
+{
+ CHECK(!r.isSome());
+ if (r.isNone()) {
+ return "Result is NONE";
+ }
+ return r.error();
+}
+
+
+#define ASSERT_SOME(s) \
+ do { \
+ typeof(s) __s = (s); \
+ ASSERT_TRUE(__s.isSome()) << assertSomeError(__s); \
+ } while (false)
+
+
+#define EXPECT_SOME(s) \
+ do { \
+ typeof(s) __s = (s); \
+ EXPECT_TRUE(__s.isSome()) << assertSomeError(__s); \
+ } while (false)
+
+
+#define ASSERT_SOME_EQ(expected, s) \
+ do { \
+ typeof(s) _s = (s); \
+ ASSERT_SOME(_s); \
+ ASSERT_EQ(expected, _s.get()); \
+ } while (false)
+
+
+#define EXPECT_SOME_EQ(expected, s) \
+ do { \
+ typeof(s) _s = (s); \
+ ASSERT_SOME(_s); \
+ EXPECT_EQ(expected, _s.get()); \
+ } while (false)
+
+
+#define ASSERT_SOME_TRUE(s) \
+ do { \
+ typeof(s) _s = (s); \
+ ASSERT_SOME(_s); \
+ ASSERT_TRUE(_s.get()); \
+ } while (false)
+
+
+#define EXPECT_SOME_TRUE(s) \
+ do { \
+ typeof(s) _s = (s); \
+ ASSERT_SOME(_s); \
+ EXPECT_TRUE(_s.get()); \
+ } while (false)
+
+
+#define ASSERT_ERROR(s) \
+ ASSERT_TRUE(s.isError())
+
+
+#define EXPECT_ERROR(s) \
+ EXPECT_TRUE(s.isError())
+
+
+#define ASSERT_FUTURE_WILL_SUCCEED(future) \
+ do { \
+ typeof(future) __future = (future); \
+ ASSERT_TRUE(__future.await()); \
+ ASSERT_FALSE(__future.isDiscarded()); \
+ ASSERT_FALSE(__future.isFailed()) << __future.failure(); \
+ } while (false)
+
+
+#define EXPECT_FUTURE_WILL_SUCCEED(future) \
+ do { \
+ typeof(future) __future = (future); \
+ ASSERT_TRUE(__future.await()); \
+ EXPECT_FALSE(__future.isDiscarded()); \
+ EXPECT_FALSE(__future.isFailed()) << __future.failure(); \
+ } while (false)
+
+
+#define ASSERT_FUTURE_WILL_FAIL(future) \
+ do { \
+ typeof(future) __future = (future); \
+ ASSERT_TRUE(__future.await()); \
+ ASSERT_TRUE(__future.isFailed()); \
+ } while (false)
+
+
+#define EXPECT_FUTURE_WILL_FAIL(future) \
+ do { \
+ typeof(future) __future = (future); \
+ ASSERT_TRUE(__future.await()); \
+ EXPECT_TRUE(__future.isFailed()); \
+ } while (false)
+
+
+#define ASSERT_FUTURE_WILL_EQ(expected, future) \
+ do { \
+ typeof(future) _future = (future); \
+ ASSERT_FUTURE_WILL_SUCCEED(_future); \
+ ASSERT_EQ(expected, _future.get()); \
+ } while (false)
+
+
+#define EXPECT_FUTURE_WILL_EQ(expected, future) \
+ do { \
+ typeof(future) _future = (future); \
+ ASSERT_FUTURE_WILL_SUCCEED(_future); \
+ EXPECT_EQ(expected, _future.get()); \
+ } while (false)
+
+
+#define EXPECT_RESPONSE_STATUS_WILL_EQ(expected, future) \
+ do { \
+ typeof(future) _future = (future); \
+ ASSERT_FUTURE_WILL_SUCCEED(_future); \
+ const process::http::Response& response = _future.get(); \
+ EXPECT_EQ(expected, response.status); \
+ } while (false)
+
+
+#define EXPECT_RESPONSE_BODY_WILL_EQ(expected, future) \
+ do { \
+ typeof(future) _future = (future); \
+ ASSERT_FUTURE_WILL_SUCCEED(_future); \
+ const process::http::Response& response = _future.get(); \
+ EXPECT_EQ(expected, response.body); \
+ } while (false);
+
+
+#define EXPECT_RESPONSE_HEADER_WILL_EQ(expected, header, future) \
+ do { \
+ typeof(future) _future = future; \
+ ASSERT_FUTURE_WILL_SUCCEED(future); \
+ EXPECT_TRUE(_future.get().headers.contains(header)); \
+ EXPECT_EQ(expected, _future.get().headers.find(header)->second); \
+ } while (false);
+
#endif // __TESTING_UTILS_HPP__