SET(TEST_EXEC context-test)
# Source List
-FILE(GLOB_RECURSE TEST_SRCS src/*.cpp)
+FILE(GLOB TEST_SRCS src/*.cpp src/app-history/*.cpp)
INCLUDE_DIRECTORIES(
${CMAKE_SOURCE_DIR}/src
)
*/
#include <context_history.h>
-#include <ProviderTypes.h>
-
#include "../shared.h"
#include "history.h"
-using namespace ctx::test;
+#define KEY_RESULT_SIZE "ResultSize"
+#define KEY_TIME_SPAN "TimeSpan"
+#define KEY_START_TIME "StartTime"
+#define KEY_END_TIME "EndTime"
+#define KEY_DAY_OF_WEEK "DayOfWeek"
+#define KEY_APP_ID "AppId"
+#define KEY_AUDIO_JACK "AudioJack"
+#define KEY_BSSID "BSSID"
+#define KEY_COMMUNICATION_TYPE "CommunicationType"
+
+using namespace test;
static context_history_h history_h = NULL;
static context_history_list_h list_h = NULL;
filter_h = NULL;
}
-int test_history(int *argc, char ***argv)
+int testAppHistory(int *argc, char ***argv)
{
- err = context_history_create(&history_h);
- if (err != ERR_NONE) {
+ lastError = context_history_create(&history_h);
+ if (lastError != E_NONE) {
g_print(RED("Memory allocation failed\n"));
return 0;
}
- ctx::test::newline_after_tcname = true;
+ flag::newlineAfterTestCaseName = true;
while (true) {
g_print("\nSelect the target item...\n");
g_print(" 9. Common Setting for Video 10. Frequently Communicated Address\n");
g_print(" 11. Battery Usage 12. Recent Battery Usage\n");
- while (!get_input_int("(to exit, ctrl-c)? ")) {;}
+ while (!getInputInt("(to exit, ctrl-c)? ")) {;}
- switch (int_val) {
+ switch (value::int32) {
case 1:
- run_testcase("/history/recently_used_app", _history_app_recently);
+ runTestCase("/history/recently_used_app", _history_app_recently);
break;
case 2:
- run_testcase("/history/frequently_used_app", _history_app_frequently);
+ runTestCase("/history/frequently_used_app", _history_app_frequently);
break;
case 3:
- run_testcase("/history/rarely_used_app", _history_app_rarely);
+ runTestCase("/history/rarely_used_app", _history_app_rarely);
break;
case 4:
- run_testcase("/history/peak_time_for_app", _history_app_peak_time);
+ runTestCase("/history/peak_time_for_app", _history_app_peak_time);
break;
case 5:
- run_testcase("/history/peak_time_for_music", _history_music_peak_time);
+ runTestCase("/history/peak_time_for_music", _history_music_peak_time);
break;
case 6:
- run_testcase("/history/peak_time_for_video", _history_video_peak_time);
+ runTestCase("/history/peak_time_for_video", _history_video_peak_time);
break;
case 7:
- run_testcase("/history/common_setting_for_app", _history_app_setting);
+ runTestCase("/history/common_setting_for_app", _history_app_setting);
break;
case 8:
- run_testcase("/history/common_setting_for_music", _history_music_setting);
+ runTestCase("/history/common_setting_for_music", _history_music_setting);
break;
case 9:
- run_testcase("/history/common_setting_for_video", _history_video_setting);
+ runTestCase("/history/common_setting_for_video", _history_video_setting);
break;
case 10:
- run_testcase("/history/frequently_communicated_address", _history_comm_frequently);
+ runTestCase("/history/frequently_communicated_address", _history_comm_frequently);
break;
case 11:
- run_testcase("/history/battery_usage", _history_battery);
+ runTestCase("/history/battery_usage", _history_battery);
break;
case 12:
- run_testcase("/history/recent_battery_usage", _history_battery_recent);
+ runTestCase("/history/recent_battery_usage", _history_battery_recent);
break;
default:
g_print("Invalid number\n");
std::string msg = " ";
msg = msg + key + "? ";
- if (get_input_int(msg.c_str()))
- context_history_filter_set_int(filter_h, type, int_val);
+ if (getInputInt(msg.c_str()))
+ context_history_filter_set_int(filter_h, type, value::int32);
}
static void __filter_set_str(context_history_filter_e type, const char *key)
std::string msg = " ";
msg = msg + key + "? ";
- if (get_input_str(msg.c_str()))
- context_history_filter_set_string(filter_h, type, str_val.c_str());
+ if (getInputStr(msg.c_str()))
+ context_history_filter_set_string(filter_h, type, value::str.c_str());
}
static bool __get_list(context_history_data_e type)
{
- err = context_history_get_list(history_h, type, filter_h, &list_h);
+ lastError = context_history_get_list(history_h, type, filter_h, &list_h);
- if (err == ERR_NOT_SUPPORTED) {
+ if (lastError == E_SUPPORT) {
g_print(YELLOW("Not Supported") "\n");
return false;
}
- if (err == ERR_NO_DATA) {
+ if (lastError == E_NO_DATA) {
g_print(YELLOW("No Data") "\n");
return false;
}
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
return true;
}
static bool __iterate_list(const char *int_attr[], const char *double_attr[], const char *str_attr[])
{
int cnt = 0;
- err = context_history_list_get_count(list_h, &cnt);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = context_history_list_get_count(list_h, &cnt);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
for (int i = 0; i < cnt; ++i) {
- err = context_history_list_get_current(list_h, &record_h);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = context_history_list_get_current(list_h, &record_h);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
g_print("[%d] ", i);
/* Integer attributes */
for (int j = 0; int_attr[j] != NULL; ++j) {
- err = context_history_record_get_int(record_h, int_attr[j], &int_val);
- ASSERT_CMPINT(err, ==, ERR_NONE);
- g_print("%s(%d) ", int_attr[j], int_val);
+ lastError = context_history_record_get_int(record_h, int_attr[j], &value::int32);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
+ g_print("%s(%d) ", int_attr[j], value::int32);
}
/* Double attributes */
for (int j = 0; double_attr[j] != NULL; ++j) {
- err = context_history_record_get_double(record_h, double_attr[j], &double_val);
- ASSERT_CMPINT(err, ==, ERR_NONE);
- g_print("%s(%f) ", double_attr[j], double_val);
+ lastError = context_history_record_get_double(record_h, double_attr[j], &value::dbl);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
+ g_print("%s(%f) ", double_attr[j], value::dbl);
}
/* String attributes */
for (int j = 0; str_attr[j] != NULL; ++j) {
char *tmp = NULL;
- err = context_history_record_get_string(record_h, str_attr[j], &tmp);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = context_history_record_get_string(record_h, str_attr[j], &tmp);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
g_print("%s(%s) ", str_attr[j], tmp);
g_free(tmp);
}
if (i < cnt - 1) {
- err = context_history_list_move_next(list_h);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = context_history_list_move_next(list_h);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
}
context_history_record_destroy(record_h);
__filter_set_int(CONTEXT_HISTORY_FILTER_AUDIO_JACK, KEY_AUDIO_JACK);
__filter_set_str(CONTEXT_HISTORY_FILTER_WIFI_BSSID, KEY_BSSID);
- bool_val = __get_list(CONTEXT_HISTORY_RECENTLY_USED_APP);
- IF_FAIL_RETURN(bool_val, false);
+ value::boolean = __get_list(CONTEXT_HISTORY_RECENTLY_USED_APP);
+ IF_FAIL_RETURN(value::boolean, false);
- bool_val = __iterate_list(int_attr, double_attr, str_attr);
- IF_FAIL_RETURN(bool_val, false);
+ value::boolean = __iterate_list(int_attr, double_attr, str_attr);
+ IF_FAIL_RETURN(value::boolean, false);
return true;
}
__filter_set_int(CONTEXT_HISTORY_FILTER_AUDIO_JACK, KEY_AUDIO_JACK);
__filter_set_str(CONTEXT_HISTORY_FILTER_WIFI_BSSID, KEY_BSSID);
- bool_val = __get_list(CONTEXT_HISTORY_FREQUENTLY_USED_APP);
- IF_FAIL_RETURN(bool_val, false);
+ value::boolean = __get_list(CONTEXT_HISTORY_FREQUENTLY_USED_APP);
+ IF_FAIL_RETURN(value::boolean, false);
- bool_val = __iterate_list(int_attr, double_attr, str_attr);
- IF_FAIL_RETURN(bool_val, false);
+ value::boolean = __iterate_list(int_attr, double_attr, str_attr);
+ IF_FAIL_RETURN(value::boolean, false);
return true;
}
__filter_set_int(CONTEXT_HISTORY_FILTER_START_TIME, KEY_START_TIME);
__filter_set_int(CONTEXT_HISTORY_FILTER_END_TIME, KEY_END_TIME);
- bool_val = __get_list(CONTEXT_HISTORY_RARELY_USED_APP);
- IF_FAIL_RETURN(bool_val, false);
+ value::boolean = __get_list(CONTEXT_HISTORY_RARELY_USED_APP);
+ IF_FAIL_RETURN(value::boolean, false);
- bool_val = __iterate_list(int_attr, double_attr, str_attr);
- IF_FAIL_RETURN(bool_val, false);
+ value::boolean = __iterate_list(int_attr, double_attr, str_attr);
+ IF_FAIL_RETURN(value::boolean, false);
return true;
}
__filter_set_int(CONTEXT_HISTORY_FILTER_DAY_OF_WEEK, KEY_DAY_OF_WEEK);
__filter_set_str(CONTEXT_HISTORY_FILTER_APP_ID, KEY_APP_ID);
- bool_val = __get_list(CONTEXT_HISTORY_PEAK_TIME_FOR_APP);
- IF_FAIL_RETURN(bool_val, false);
+ value::boolean = __get_list(CONTEXT_HISTORY_PEAK_TIME_FOR_APP);
+ IF_FAIL_RETURN(value::boolean, false);
- bool_val = __iterate_list(int_attr, double_attr, str_attr);
- IF_FAIL_RETURN(bool_val, false);
+ value::boolean = __iterate_list(int_attr, double_attr, str_attr);
+ IF_FAIL_RETURN(value::boolean, false);
return true;
}
__filter_set_int(CONTEXT_HISTORY_FILTER_END_TIME, KEY_END_TIME);
__filter_set_str(CONTEXT_HISTORY_FILTER_APP_ID, KEY_APP_ID);
- bool_val = __get_list(CONTEXT_HISTORY_COMMON_SETTING_FOR_APP);
- IF_FAIL_RETURN(bool_val, false);
+ value::boolean = __get_list(CONTEXT_HISTORY_COMMON_SETTING_FOR_APP);
+ IF_FAIL_RETURN(value::boolean, false);
- bool_val = __iterate_list(int_attr, double_attr, str_attr);
- IF_FAIL_RETURN(bool_val, false);
+ value::boolean = __iterate_list(int_attr, double_attr, str_attr);
+ IF_FAIL_RETURN(value::boolean, false);
return true;
}
__filter_set_int(CONTEXT_HISTORY_FILTER_END_TIME, KEY_END_TIME);
__filter_set_int(CONTEXT_HISTORY_FILTER_DAY_OF_WEEK, KEY_DAY_OF_WEEK);
- bool_val = __get_list(CONTEXT_HISTORY_PEAK_TIME_FOR_MUSIC);
- IF_FAIL_RETURN(bool_val, false);
+ value::boolean = __get_list(CONTEXT_HISTORY_PEAK_TIME_FOR_MUSIC);
+ IF_FAIL_RETURN(value::boolean, false);
- bool_val = __iterate_list(int_attr, double_attr, str_attr);
- IF_FAIL_RETURN(bool_val, false);
+ value::boolean = __iterate_list(int_attr, double_attr, str_attr);
+ IF_FAIL_RETURN(value::boolean, false);
return true;
}
__filter_set_int(CONTEXT_HISTORY_FILTER_START_TIME, KEY_START_TIME);
__filter_set_int(CONTEXT_HISTORY_FILTER_END_TIME, KEY_END_TIME);
- bool_val = __get_list(CONTEXT_HISTORY_COMMON_SETTING_FOR_MUSIC);
- IF_FAIL_RETURN(bool_val, false);
+ value::boolean = __get_list(CONTEXT_HISTORY_COMMON_SETTING_FOR_MUSIC);
+ IF_FAIL_RETURN(value::boolean, false);
- bool_val = __iterate_list(int_attr, double_attr, str_attr);
- IF_FAIL_RETURN(bool_val, false);
+ value::boolean = __iterate_list(int_attr, double_attr, str_attr);
+ IF_FAIL_RETURN(value::boolean, false);
return true;
}
__filter_set_int(CONTEXT_HISTORY_FILTER_END_TIME, KEY_END_TIME);
__filter_set_int(CONTEXT_HISTORY_FILTER_DAY_OF_WEEK, KEY_DAY_OF_WEEK);
- bool_val = __get_list(CONTEXT_HISTORY_PEAK_TIME_FOR_VIDEO);
- IF_FAIL_RETURN(bool_val, false);
+ value::boolean = __get_list(CONTEXT_HISTORY_PEAK_TIME_FOR_VIDEO);
+ IF_FAIL_RETURN(value::boolean, false);
- bool_val = __iterate_list(int_attr, double_attr, str_attr);
- IF_FAIL_RETURN(bool_val, false);
+ value::boolean = __iterate_list(int_attr, double_attr, str_attr);
+ IF_FAIL_RETURN(value::boolean, false);
return true;
}
__filter_set_int(CONTEXT_HISTORY_FILTER_START_TIME, KEY_START_TIME);
__filter_set_int(CONTEXT_HISTORY_FILTER_END_TIME, KEY_END_TIME);
- bool_val = __get_list(CONTEXT_HISTORY_COMMON_SETTING_FOR_VIDEO);
- IF_FAIL_RETURN(bool_val, false);
+ value::boolean = __get_list(CONTEXT_HISTORY_COMMON_SETTING_FOR_VIDEO);
+ IF_FAIL_RETURN(value::boolean, false);
- bool_val = __iterate_list(int_attr, double_attr, str_attr);
- IF_FAIL_RETURN(bool_val, false);
+ value::boolean = __iterate_list(int_attr, double_attr, str_attr);
+ IF_FAIL_RETURN(value::boolean, false);
return true;
}
__filter_set_int(CONTEXT_HISTORY_FILTER_END_TIME, KEY_END_TIME);
__filter_set_int(CONTEXT_HISTORY_FILTER_COMMUNICATION_TYPE, KEY_COMMUNICATION_TYPE);
- bool_val = __get_list(CONTEXT_HISTORY_FREQUENTLY_COMMUNICATED_ADDRESS);
- IF_FAIL_RETURN(bool_val, false);
+ value::boolean = __get_list(CONTEXT_HISTORY_FREQUENTLY_COMMUNICATED_ADDRESS);
+ IF_FAIL_RETURN(value::boolean, false);
- bool_val = __iterate_list(int_attr, double_attr, str_attr);
- IF_FAIL_RETURN(bool_val, false);
+ value::boolean = __iterate_list(int_attr, double_attr, str_attr);
+ IF_FAIL_RETURN(value::boolean, false);
return true;
}
__filter_set_int(CONTEXT_HISTORY_FILTER_START_TIME, KEY_START_TIME);
__filter_set_int(CONTEXT_HISTORY_FILTER_END_TIME, KEY_END_TIME);
- bool_val = __get_list(CONTEXT_HISTORY_BATTERY_USAGE);
- IF_FAIL_RETURN(bool_val, false);
+ value::boolean = __get_list(CONTEXT_HISTORY_BATTERY_USAGE);
+ IF_FAIL_RETURN(value::boolean, false);
- bool_val = __iterate_list(int_attr, double_attr, str_attr);
- IF_FAIL_RETURN(bool_val, false);
+ value::boolean = __iterate_list(int_attr, double_attr, str_attr);
+ IF_FAIL_RETURN(value::boolean, false);
return true;
}
__filter_set_int(CONTEXT_HISTORY_FILTER_RESULT_SIZE, KEY_RESULT_SIZE);
__filter_set_int(CONTEXT_HISTORY_FILTER_END_TIME, KEY_END_TIME);
- bool_val = __get_list(CONTEXT_HISTORY_RECENT_BATTERY_USAGE);
- IF_FAIL_RETURN(bool_val, false);
+ value::boolean = __get_list(CONTEXT_HISTORY_RECENT_BATTERY_USAGE);
+ IF_FAIL_RETURN(value::boolean, false);
- bool_val = __iterate_list(int_attr, double_attr, str_attr);
- IF_FAIL_RETURN(bool_val, false);
+ value::boolean = __iterate_list(int_attr, double_attr, str_attr);
+ IF_FAIL_RETURN(value::boolean, false);
return true;
}
#ifndef __CONTEXT_TEST_HISTORY_H__
#define __CONTEXT_TEST_HISTORY_H__
-int test_history(int *argc, char ***argv);
+int testAppHistory(int *argc, char ***argv);
bool _history_app_recently();
bool _history_app_frequently();
*/
#include "shared.h"
-#include "trigger/condition.h"
-#include "trigger/event.h"
-#include "history/history.h"
+#include "app-history/history.h"
-static void signal_handler(int signo)
+using namespace test;
+
+static void __signalHandler(int signo)
{
- if (signo == SIGINT && ctx::test::is_mainloop_running()) {
+ if (signo == SIGINT && isMainloopRunning()) {
g_print(PURPLE("\nskipping the testcase..."));
- ctx::test::stop_mainloop();
+ stopMainloop();
} else {
g_print(PURPLE("\nterminating... (SIGNAL %d)\n"), signo);
exit(EXIT_SUCCESS);
}
}
-static void print_usage()
+static void __printUsage()
{
g_print("Usage: context-test TESTSUITE\n\n");
g_print("TESTSUITE can be one of the followings:\n");
- g_print(" h\t for testing all contextual history items\n");
- g_print(" c\t for testing all contextual trigger conditions\n");
- g_print(" e\t for testing all contextual trigger events\n");
+ g_print(" a\t to test app-history\n");
+ g_print(" j\t to test job-scheduler\n");
}
int main(int argc, char** argv)
{
- signal(SIGINT, signal_handler);
- signal(SIGHUP, signal_handler);
- signal(SIGTERM, signal_handler);
- signal(SIGQUIT, signal_handler);
- signal(SIGABRT, signal_handler);
+ signal(SIGINT, __signalHandler);
+ signal(SIGHUP, __signalHandler);
+ signal(SIGTERM, __signalHandler);
+ signal(SIGQUIT, __signalHandler);
+ signal(SIGABRT, __signalHandler);
if (argc < 2) {
- print_usage();
+ __printUsage();
return EXIT_SUCCESS;
}
switch (argv[1][0]) {
- case 'h':
- return test_history(&argc, &argv);
- case 'c':
- return test_trigger_condition(&argc, &argv);
- case 'e':
- return test_trigger_event(&argc, &argv);
+ case 'a':
+ return testAppHistory(&argc, &argv);
+ case 'j':
+ return EXIT_SUCCESS;
default:
- print_usage();
+ __printUsage();
return EXIT_SUCCESS;
}
}
#include "shared.h"
-static bool __is_mainloop_running = false;
+static GMainLoop* __mainloop = NULL;
-namespace ctx {
- namespace test {
- GMainLoop *mainloop = NULL;
- int callback_count = 0;
- int err = 0;
- int req_id = 0;
- int int_val = 0;
- double double_val = 0;
- bool bool_val = false;
- bool skip_tc = false;
- bool newline_after_tcname = false;
- ctx::CtxJson1 json_val = EMPTY_JSON_OBJECT;
- std::string str_val = "";
+namespace test {
+ namespace value {
+ int int32 = 0;
+ double dbl = 0;
+ bool boolean = false;
+ std::string str = "";
}
+ namespace flag {
+ bool skipTestCase = false;
+ bool newlineAfterTestCaseName = false;
+ }
+ int lastError = 0;
}
-void ctx::test::start_mainloop()
+void test::startMainloop()
{
- if (!__is_mainloop_running) {
- __is_mainloop_running = true;
- mainloop = g_main_loop_new(NULL, FALSE);
- g_main_loop_run(mainloop);
+ if (!__mainloop) {
+ __mainloop = g_main_loop_new(NULL, FALSE);
+ g_main_loop_run(__mainloop);
}
}
-void ctx::test::stop_mainloop()
+void test::stopMainloop()
{
- if (__is_mainloop_running) {
- g_main_loop_quit(mainloop);
- g_main_loop_unref(mainloop);
- ctx::test::skip_tc = true;
- __is_mainloop_running = false;
+ if (__mainloop) {
+ g_main_loop_quit(__mainloop);
+ g_main_loop_unref(__mainloop);
+ test::flag::skipTestCase = true;
+ __mainloop = NULL;
}
}
-bool ctx::test::is_mainloop_running()
+bool test::isMainloopRunning()
{
- return __is_mainloop_running;
+ return (__mainloop != NULL);
}
-void ctx::test::cleanup_vars()
+void test::cleanupVars()
{
- ctx::test::callback_count = 5;
- ctx::test::err = -1;
- ctx::test::req_id = -1;
- ctx::test::json_val = EMPTY_JSON_OBJECT;
- ctx::test::bool_val = false;
- ctx::test::int_val = 0;
- ctx::test::double_val = 0;
- ctx::test::str_val = "";
- ctx::test::skip_tc = false;
+ test::lastError = -1;
+ test::value::boolean = false;
+ test::value::int32 = 0;
+ test::value::dbl = 0;
+ test::value::str = "";
+ test::flag::skipTestCase = false;
}
-bool ctx::test::get_input_int(const char *msg)
+bool test::getInputInt(const char *msg)
{
std::cout << msg;
- std::getline(std::cin, str_val);
- IF_FAIL_RETURN(!str_val.empty(), false);
- int_val = atoi(str_val.c_str());
+ std::getline(std::cin, test::value::str);
+ IF_FAIL_RETURN(!test::value::str.empty(), false);
+ test::value::int32 = atoi(test::value::str.c_str());
return true;
}
-bool ctx::test::get_input_str(const char *msg)
+bool test::getInputStr(const char *msg)
{
std::cout << msg;
- std::getline(std::cin, str_val);
- IF_FAIL_RETURN(!str_val.empty(), false);
+ std::getline(std::cin, test::value::str);
+ IF_FAIL_RETURN(!test::value::str.empty(), false);
return true;
}
-void ctx::test::run_testcase(const char *tc_name, bool (*tc_func)(void))
+void test::runTestCase(const char *tcName, bool (*tcFunc)(void))
{
- IF_FAIL_VOID(tc_name && tc_func);
+ IF_FAIL_VOID(tcName && tcFunc);
- g_print(CYAN("%s") ": ", tc_name);
- if (newline_after_tcname)
+ g_print(CYAN("%s") ": ", tcName);
+ if (test::flag::newlineAfterTestCaseName)
g_print("\n");
- cleanup_vars();
- bool result = tc_func();
+ test::cleanupVars();
+ bool result = tcFunc();
if (result)
g_print(GREEN("PASS") "\n");
}
#include <iostream>
#include <string>
#include <glib.h>
-#include <Types.h>
-#include <CtxJson1.h>
-
-#define CALLBACK_COUNT 5
+#include <ContextTypes.h>
+#include <SharedUtil.h>
#define ASSERT(condition) \
do { \
if (!(condition)) { \
g_print("\n"); \
- if (!ctx::test::skip_tc) \
+ if (!test::flag::skipTestCase) \
g_print(RED("FAIL") ": %s(%d) > %s\n", __FUNCTION__, __LINE__, #condition); \
return false; \
} \
do { \
if (!((left) comp (right))) { \
g_print("\n"); \
- if (!ctx::test::skip_tc) \
+ if (!test::flag::skipTestCase) \
g_print(RED("FAIL") ": %s(%d) > %s(%d) %s %s(%d)\n", __FUNCTION__, __LINE__, #left, (left), #comp, #right, (right)); \
return false; \
} \
} while (0)
-#define ASSERT_CONTAIN_STR(JSONOBJ, VKEY) \
- do { \
- ctx::test::bool_val = (JSONOBJ).get(NULL, (VKEY), &ctx::test::str_val); \
- if (!ctx::test::bool_val) { \
- g_print("\n"); \
- if (!ctx::test::skip_tc) \
- g_print(RED("FAIL") ": %s(%d) > Getting the string '%s'\n", __FUNCTION__, __LINE__, (VKEY)); \
- return false; \
- } \
- g_print("%s(%s) ", (VKEY), ctx::test::str_val.c_str()); \
- } while (0)
-
-#define ASSERT_CONTAIN_INT(JSONOBJ, VKEY) \
- do { \
- ctx::test::bool_val = (JSONOBJ).get(NULL, (VKEY), &ctx::test::int_val); \
- if (!ctx::test::bool_val) { \
- g_print("\n"); \
- if (!ctx::test::skip_tc) \
- g_print(RED("FAIL") ": %s(%d) > Getting the integer '%s'\n", __FUNCTION__, __LINE__, (VKEY)); \
- return false; \
- } \
- g_print("%s(%d) ", (VKEY), ctx::test::int_val); \
- } while (0)
-
-namespace ctx {
- namespace test {
- extern GMainLoop *mainloop;
- extern int callback_count;
- extern int err;
- extern int req_id;
- extern int int_val;
- extern double double_val;
- extern bool bool_val;
- extern bool skip_tc;
- extern bool newline_after_tcname;
- extern ctx::CtxJson1 json_val;
- extern std::string str_val;
+namespace test {
+ namespace value {
+ extern int int32;
+ extern double dbl;
+ extern bool boolean;
+ extern std::string str;
+ }
+ namespace flag {
+ extern bool skipTestCase;
+ extern bool newlineAfterTestCaseName;
+ }
+ extern int lastError;
- void start_mainloop();
- void stop_mainloop();
- bool is_mainloop_running();
+ void startMainloop();
+ void stopMainloop();
+ bool isMainloopRunning();
- void cleanup_vars();
- bool get_input_int(const char *msg);
- bool get_input_str(const char *msg);
+ void cleanupVars();
+ bool getInputInt(const char *msg);
+ bool getInputStr(const char *msg);
- void run_testcase(const char *tc_name, bool (*tc_func)(void));
- }
+ void runTestCase(const char *tcName, bool (*tcFunc)(void));
}
#endif
int test_trigger_condition(int *argc, char ***argv)
{
- run_testcase("/trigger/cond/battery", _trigger_cond_battery);
- run_testcase("/trigger/cond/charger", _trigger_cond_charger);
- run_testcase("/trigger/cond/gps", _trigger_cond_gps);
- run_testcase("/trigger/cond/headphone", _trigger_cond_headphone);
- run_testcase("/trigger/cond/usb", _trigger_cond_usb);
- run_testcase("/trigger/cond/wifi", _trigger_cond_wifi);
- run_testcase("/trigger/cond/psmode", _trigger_cond_psmode);
- run_testcase("/trigger/cond/call", _trigger_cond_call);
- run_testcase("/trigger/cond/time", _trigger_cond_time);
-
- run_testcase("/trigger/cond/app_freq1", _trigger_cond_app_use_freq1);
- run_testcase("/trigger/cond/app_freq2", _trigger_cond_app_use_freq2);
- run_testcase("/trigger/cond/app_freq3", _trigger_cond_app_use_freq3);
- run_testcase("/trigger/cond/app_freq4", _trigger_cond_app_use_freq4);
-
- run_testcase("/trigger/cond/comm_freq1", _trigger_cond_comm_freq1);
- run_testcase("/trigger/cond/comm_freq2", _trigger_cond_comm_freq2);
- run_testcase("/trigger/cond/comm_freq3", _trigger_cond_comm_freq3);
- run_testcase("/trigger/cond/comm_freq4", _trigger_cond_comm_freq4);
-
- run_testcase("/trigger/cond/music_freq1", _trigger_cond_music_freq1);
- run_testcase("/trigger/cond/music_freq2", _trigger_cond_music_freq2);
- run_testcase("/trigger/cond/music_freq3", _trigger_cond_music_freq3);
- run_testcase("/trigger/cond/music_freq4", _trigger_cond_music_freq4);
-
- run_testcase("/trigger/cond/video_freq1", _trigger_cond_video_freq1);
- run_testcase("/trigger/cond/video_freq2", _trigger_cond_video_freq2);
- run_testcase("/trigger/cond/video_freq3", _trigger_cond_video_freq3);
- run_testcase("/trigger/cond/video_freq4", _trigger_cond_video_freq4);
+ runTestCase("/trigger/cond/battery", _trigger_cond_battery);
+ runTestCase("/trigger/cond/charger", _trigger_cond_charger);
+ runTestCase("/trigger/cond/gps", _trigger_cond_gps);
+ runTestCase("/trigger/cond/headphone", _trigger_cond_headphone);
+ runTestCase("/trigger/cond/usb", _trigger_cond_usb);
+ runTestCase("/trigger/cond/wifi", _trigger_cond_wifi);
+ runTestCase("/trigger/cond/psmode", _trigger_cond_psmode);
+ runTestCase("/trigger/cond/call", _trigger_cond_call);
+ runTestCase("/trigger/cond/time", _trigger_cond_time);
+
+ runTestCase("/trigger/cond/app_freq1", _trigger_cond_app_use_freq1);
+ runTestCase("/trigger/cond/app_freq2", _trigger_cond_app_use_freq2);
+ runTestCase("/trigger/cond/app_freq3", _trigger_cond_app_use_freq3);
+ runTestCase("/trigger/cond/app_freq4", _trigger_cond_app_use_freq4);
+
+ runTestCase("/trigger/cond/comm_freq1", _trigger_cond_comm_freq1);
+ runTestCase("/trigger/cond/comm_freq2", _trigger_cond_comm_freq2);
+ runTestCase("/trigger/cond/comm_freq3", _trigger_cond_comm_freq3);
+ runTestCase("/trigger/cond/comm_freq4", _trigger_cond_comm_freq4);
+
+ runTestCase("/trigger/cond/music_freq1", _trigger_cond_music_freq1);
+ runTestCase("/trigger/cond/music_freq2", _trigger_cond_music_freq2);
+ runTestCase("/trigger/cond/music_freq3", _trigger_cond_music_freq3);
+ runTestCase("/trigger/cond/music_freq4", _trigger_cond_music_freq4);
+
+ runTestCase("/trigger/cond/video_freq1", _trigger_cond_video_freq1);
+ runTestCase("/trigger/cond/video_freq2", _trigger_cond_video_freq2);
+ runTestCase("/trigger/cond/video_freq3", _trigger_cond_video_freq3);
+ runTestCase("/trigger/cond/video_freq4", _trigger_cond_video_freq4);
return 0;
}
static bool __support(context_trigger_condition_e cond)
{
- err = context_trigger_rule_condition_is_supported(cond, &bool_val);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = context_trigger_rule_condition_is_supported(cond, &value::boolean);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
- if (!bool_val) {
+ if (!value::boolean) {
g_print(YELLOW("Not Supported") "\n");
return false;
}
{
if (!__support(CONTEXT_TRIGGER_CONDITION_BATTERY)) return false;
- err = ctx::request_handler::read_sync(SUBJ_STATE_BATTERY, NULL, &req_id, &json_val);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::read_sync(SUBJ_STATE_BATTERY, NULL, &req_id, &json_val);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
ASSERT_CONTAIN_STR(json_val, CONTEXT_TRIGGER_LEVEL);
ASSERT_CONTAIN_INT(json_val, CONTEXT_TRIGGER_IS_CHARGING);
{
if (!__support(CONTEXT_TRIGGER_CONDITION_CHARGER)) return false;
- err = ctx::request_handler::read_sync(SUBJ_STATE_CHARGER, NULL, &req_id, &json_val);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::read_sync(SUBJ_STATE_CHARGER, NULL, &req_id, &json_val);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
ASSERT_CONTAIN_INT(json_val, CONTEXT_TRIGGER_IS_CONNECTED);
return true;
{
if (!__support(CONTEXT_TRIGGER_CONDITION_GPS)) return false;
- err = ctx::request_handler::read_sync(SUBJ_STATE_GPS, NULL, &req_id, &json_val);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::read_sync(SUBJ_STATE_GPS, NULL, &req_id, &json_val);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
ASSERT_CONTAIN_STR(json_val, CONTEXT_TRIGGER_STATE);
{
if (!__support(CONTEXT_TRIGGER_CONDITION_HEADPHONE)) return false;
- err = ctx::request_handler::read_sync(SUBJ_STATE_HEADPHONE, NULL, &req_id, &json_val);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::read_sync(SUBJ_STATE_HEADPHONE, NULL, &req_id, &json_val);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
ASSERT_CONTAIN_INT(json_val, CONTEXT_TRIGGER_IS_CONNECTED);
- if (int_val == CONTEXT_TRIGGER_FALSE) return true;
+ if (value::int32 == CONTEXT_TRIGGER_FALSE) return true;
ASSERT_CONTAIN_STR(json_val, CONTEXT_TRIGGER_TYPE);
{
if (!__support(CONTEXT_TRIGGER_CONDITION_USB)) return false;
- err = ctx::request_handler::read_sync(SUBJ_STATE_USB, NULL, &req_id, &json_val);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::read_sync(SUBJ_STATE_USB, NULL, &req_id, &json_val);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
ASSERT_CONTAIN_INT(json_val, CONTEXT_TRIGGER_IS_CONNECTED);
{
if (!__support(CONTEXT_TRIGGER_CONDITION_WIFI)) return false;
- err = ctx::request_handler::read_sync(SUBJ_STATE_WIFI, NULL, &req_id, &json_val);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::read_sync(SUBJ_STATE_WIFI, NULL, &req_id, &json_val);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
ASSERT_CONTAIN_STR(json_val, CONTEXT_TRIGGER_STATE);
- if (str_val == CONTEXT_TRIGGER_CONNECTED)
+ if (value::str == CONTEXT_TRIGGER_CONNECTED)
ASSERT_CONTAIN_STR(json_val, CONTEXT_TRIGGER_BSSID);
return true;
{
if (!__support(CONTEXT_TRIGGER_CONDITION_POWER_SAVING_MODE)) return false;
- err = ctx::request_handler::read_sync(SUBJ_STATE_PSMODE, NULL, &req_id, &json_val);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::read_sync(SUBJ_STATE_PSMODE, NULL, &req_id, &json_val);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
ASSERT_CONTAIN_INT(json_val, CONTEXT_TRIGGER_IS_ENABLED);
{
if (!__support(CONTEXT_TRIGGER_CONDITION_CALL)) return false;
- err = ctx::request_handler::read_sync(SUBJ_STATE_CALL, NULL, &req_id, &json_val);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::read_sync(SUBJ_STATE_CALL, NULL, &req_id, &json_val);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
ASSERT_CONTAIN_STR(json_val, CONTEXT_TRIGGER_STATE);
- if (str_val == CONTEXT_TRIGGER_IDLE) return true;
+ if (value::str == CONTEXT_TRIGGER_IDLE) return true;
ASSERT_CONTAIN_STR(json_val, CONTEXT_TRIGGER_MEDIUM);
ASSERT_CONTAIN_STR(json_val, CONTEXT_TRIGGER_ADDRESS);
{
if (!__support(CONTEXT_TRIGGER_CONDITION_TIME)) return false;
- err = ctx::request_handler::read_sync(SUBJ_STATE_TIME, NULL, &req_id, &json_val);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::read_sync(SUBJ_STATE_TIME, NULL, &req_id, &json_val);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
ASSERT_CONTAIN_INT(json_val, CONTEXT_TRIGGER_TIME_OF_DAY);
ASSERT_CONTAIN_INT(json_val, CONTEXT_TRIGGER_DAY_OF_MONTH);
{
if (!__support(CONTEXT_TRIGGER_CONDITION_APP_USE_FREQUENCY)) return false;
- err = ctx::request_handler::read_sync(SUBJ_APP_FREQUENCY, &option, &req_id, &json_val);
- if (err == ERR_NO_DATA) {
+ lastError = ctx::request_handler::read_sync(SUBJ_APP_FREQUENCY, &option, &req_id, &json_val);
+ if (lastError == E_NO_DATA) {
g_print(RED("No Data "));
return true;
}
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
ASSERT_CONTAIN_STR(json_val, CONTEXT_TRIGGER_APP_ID);
ASSERT_CONTAIN_INT(json_val, CONTEXT_TRIGGER_RANK);
{
if (!__support(CONTEXT_TRIGGER_CONDITION_COMMUNICATION_FREQUENCY)) return false;
- err = ctx::request_handler::read_sync(SUBJ_SOCIAL_FREQUENCY, &option, &req_id, &json_val);
- if (err == ERR_NO_DATA) {
+ lastError = ctx::request_handler::read_sync(SUBJ_SOCIAL_FREQUENCY, &option, &req_id, &json_val);
+ if (lastError == E_NO_DATA) {
g_print(RED("No Data "));
return true;
}
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
ASSERT_CONTAIN_STR(json_val, CONTEXT_TRIGGER_ADDRESS);
ASSERT_CONTAIN_INT(json_val, CONTEXT_TRIGGER_RANK);
{
if (!__support(item)) return false;
- err = ctx::request_handler::read_sync(item_str, &option, &req_id, &json_val);
- if (err == ERR_NO_DATA) {
+ lastError = ctx::request_handler::read_sync(item_str, &option, &req_id, &json_val);
+ if (lastError == E_NO_DATA) {
g_print(YELLOW("No Data "));
return true;
}
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
ASSERT_CONTAIN_INT(json_val, CONTEXT_TRIGGER_TOTAL_COUNT);
return true;
if (callback_count == 0) {
json_val = data;
- stop_mainloop();
+ stopMainloop();
}
}
ctx::request_handler::register_callback(SUBJ_ACTIVITY_IN_VEHICLE, __domain_cb);
ctx::request_handler::register_callback(SUBJ_PLACE_GEOFENCE, __domain_cb);
- run_testcase("/trigger/event/battery", _trigger_event_battery);
- run_testcase("/trigger/event/charger", _trigger_event_charger);
- run_testcase("/trigger/event/gps", _trigger_event_gps);
- run_testcase("/trigger/event/headphone", _trigger_event_headphone);
- run_testcase("/trigger/event/usb", _trigger_event_usb);
- run_testcase("/trigger/event/wifi", _trigger_event_wifi);
- run_testcase("/trigger/event/psmode", _trigger_event_psmode);
- run_testcase("/trigger/event/call", _trigger_event_call);
- run_testcase("/trigger/event/time", _trigger_event_time);
- run_testcase("/trigger/event/email", _trigger_event_email);
- run_testcase("/trigger/event/message", _trigger_event_message);
- run_testcase("/trigger/event/activity", _trigger_event_activity);
- run_testcase("/trigger/event/place", _trigger_event_place);
+ runTestCase("/trigger/event/battery", _trigger_event_battery);
+ runTestCase("/trigger/event/charger", _trigger_event_charger);
+ runTestCase("/trigger/event/gps", _trigger_event_gps);
+ runTestCase("/trigger/event/headphone", _trigger_event_headphone);
+ runTestCase("/trigger/event/usb", _trigger_event_usb);
+ runTestCase("/trigger/event/wifi", _trigger_event_wifi);
+ runTestCase("/trigger/event/psmode", _trigger_event_psmode);
+ runTestCase("/trigger/event/call", _trigger_event_call);
+ runTestCase("/trigger/event/time", _trigger_event_time);
+ runTestCase("/trigger/event/email", _trigger_event_email);
+ runTestCase("/trigger/event/message", _trigger_event_message);
+ runTestCase("/trigger/event/activity", _trigger_event_activity);
+ runTestCase("/trigger/event/place", _trigger_event_place);
return g_test_run();
}
static bool __support(context_trigger_event_e ev)
{
- err = context_trigger_rule_event_is_supported(ev, &bool_val);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = context_trigger_rule_event_is_supported(ev, &value::boolean);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
- if (!bool_val) {
+ if (!value::boolean) {
g_print(YELLOW("Not Supported") "\n");
return false;
}
{
if (!__support(CONTEXT_TRIGGER_EVENT_BATTERY)) return false;
- err = ctx::request_handler::subscribe(SUBJ_STATE_BATTERY, NULL, &req_id, NULL);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::subscribe(SUBJ_STATE_BATTERY, NULL, &req_id, NULL);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
g_print("\n> Change the battery lavel (or charging status) %d times.\n", CALLBACK_COUNT);
- start_mainloop();
+ startMainloop();
ctx::request_handler::unsubscribe(SUBJ_STATE_BATTERY, req_id);
{
if (!__support(CONTEXT_TRIGGER_EVENT_CHARGER)) return false;
- err = ctx::request_handler::subscribe(SUBJ_STATE_CHARGER, NULL, &req_id, NULL);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::subscribe(SUBJ_STATE_CHARGER, NULL, &req_id, NULL);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
g_print("\n> Change the charger connection state %d times.\n", CALLBACK_COUNT);
- start_mainloop();
+ startMainloop();
ctx::request_handler::unsubscribe(SUBJ_STATE_CHARGER, req_id);
{
if (!__support(CONTEXT_TRIGGER_EVENT_GPS)) return false;
- err = ctx::request_handler::subscribe(SUBJ_STATE_GPS, NULL, &req_id, NULL);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::subscribe(SUBJ_STATE_GPS, NULL, &req_id, NULL);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
g_print("\n> Change the GPS status %d times.\n", CALLBACK_COUNT);
- start_mainloop();
+ startMainloop();
ctx::request_handler::unsubscribe(SUBJ_STATE_GPS, req_id);
{
if (!__support(CONTEXT_TRIGGER_EVENT_HEADPHONE)) return false;
- err = ctx::request_handler::subscribe(SUBJ_STATE_HEADPHONE, NULL, &req_id, NULL);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::subscribe(SUBJ_STATE_HEADPHONE, NULL, &req_id, NULL);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
g_print("\n> Connect/disconnect a headphone %d times.\n", CALLBACK_COUNT);
- start_mainloop();
+ startMainloop();
ctx::request_handler::unsubscribe(SUBJ_STATE_HEADPHONE, req_id);
ASSERT_CONTAIN_INT(json_val, CONTEXT_TRIGGER_IS_CONNECTED);
- if (int_val == CONTEXT_TRIGGER_FALSE) return true;
+ if (value::int32 == CONTEXT_TRIGGER_FALSE) return true;
ASSERT_CONTAIN_STR(json_val, CONTEXT_TRIGGER_TYPE);
{
if (!__support(CONTEXT_TRIGGER_EVENT_USB)) return false;
- err = ctx::request_handler::subscribe(SUBJ_STATE_USB, NULL, &req_id, NULL);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::subscribe(SUBJ_STATE_USB, NULL, &req_id, NULL);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
g_print("\n> Connect/disconnect USB %d times.\n", CALLBACK_COUNT);
- start_mainloop();
+ startMainloop();
ctx::request_handler::unsubscribe(SUBJ_STATE_USB, req_id);
{
if (!__support(CONTEXT_TRIGGER_EVENT_WIFI)) return false;
- err = ctx::request_handler::subscribe(SUBJ_STATE_WIFI, NULL, &req_id, NULL);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::subscribe(SUBJ_STATE_WIFI, NULL, &req_id, NULL);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
g_print("\n> Change the WiFi state %d times.\n", CALLBACK_COUNT);
- start_mainloop();
+ startMainloop();
ctx::request_handler::unsubscribe(SUBJ_STATE_WIFI, req_id);
ASSERT_CONTAIN_STR(json_val, CONTEXT_TRIGGER_STATE);
- if (str_val == CONTEXT_TRIGGER_CONNECTED)
+ if (value::str == CONTEXT_TRIGGER_CONNECTED)
ASSERT_CONTAIN_STR(json_val, CONTEXT_TRIGGER_BSSID);
return true;
{
if (!__support(CONTEXT_TRIGGER_EVENT_POWER_SAVING_MODE)) return false;
- err = ctx::request_handler::subscribe(SUBJ_STATE_PSMODE, NULL, &req_id, NULL);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::subscribe(SUBJ_STATE_PSMODE, NULL, &req_id, NULL);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
g_print("\n> Turn on/off the power-saving mode %d times.\n", CALLBACK_COUNT);
- start_mainloop();
+ startMainloop();
ctx::request_handler::unsubscribe(SUBJ_STATE_PSMODE, req_id);
{
if (!__support(CONTEXT_TRIGGER_EVENT_CALL)) return false;
- err = ctx::request_handler::subscribe(SUBJ_STATE_CALL, NULL, &req_id, NULL);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::subscribe(SUBJ_STATE_CALL, NULL, &req_id, NULL);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
g_print("\n> Make a phone call to this device to change call state %d times.\n", CALLBACK_COUNT);
- start_mainloop();
+ startMainloop();
ctx::request_handler::unsubscribe(SUBJ_STATE_CALL, req_id);
ASSERT_CONTAIN_STR(json_val, CONTEXT_TRIGGER_STATE);
- if (str_val == CONTEXT_TRIGGER_IDLE) return true;
+ if (value::str == CONTEXT_TRIGGER_IDLE) return true;
ASSERT_CONTAIN_STR(json_val, CONTEXT_TRIGGER_MEDIUM);
ASSERT_CONTAIN_STR(json_val, CONTEXT_TRIGGER_ADDRESS);
option.append(NULL, CONTEXT_TRIGGER_DAY_OF_WEEK, dow_str);
option.append(NULL, CONTEXT_TRIGGER_TIME_OF_DAY, tod);
- err = ctx::request_handler::subscribe(SUBJ_STATE_ALARM, &option, &req_id, NULL);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::subscribe(SUBJ_STATE_ALARM, &option, &req_id, NULL);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
callback_count = 1;
g_print("\n> Wait until %02d:%02d %s.\n", tod / 60, tod % 60, dow_str.c_str());
- start_mainloop();
+ startMainloop();
ctx::request_handler::unsubscribe(SUBJ_STATE_CALL, req_id);
{
if (!__support(CONTEXT_TRIGGER_EVENT_EMAIL)) return false;
- err = ctx::request_handler::subscribe(SUBJ_STATE_EMAIL, NULL, &req_id, NULL);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::subscribe(SUBJ_STATE_EMAIL, NULL, &req_id, NULL);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
g_print("\n> Send/receive emails %d times.\n", CALLBACK_COUNT);
- start_mainloop();
+ startMainloop();
ctx::request_handler::unsubscribe(SUBJ_STATE_EMAIL, req_id);
{
if (!__support(CONTEXT_TRIGGER_EVENT_MESSAGE)) return false;
- err = ctx::request_handler::subscribe(SUBJ_STATE_MESSAGE, NULL, &req_id, NULL);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::subscribe(SUBJ_STATE_MESSAGE, NULL, &req_id, NULL);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
g_print("\n> Receive SMS/MMS %d times.\n", CALLBACK_COUNT);
- start_mainloop();
+ startMainloop();
ctx::request_handler::unsubscribe(SUBJ_STATE_MESSAGE, req_id);
int req_ids[4];
- err = ctx::request_handler::subscribe(SUBJ_ACTIVITY_STATIONARY, NULL, &req_ids[0], NULL);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::subscribe(SUBJ_ACTIVITY_STATIONARY, NULL, &req_ids[0], NULL);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
- err = ctx::request_handler::subscribe(SUBJ_ACTIVITY_WALKING, NULL, &req_ids[1], NULL);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::subscribe(SUBJ_ACTIVITY_WALKING, NULL, &req_ids[1], NULL);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
- err = ctx::request_handler::subscribe(SUBJ_ACTIVITY_RUNNING, NULL, &req_ids[2], NULL);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::subscribe(SUBJ_ACTIVITY_RUNNING, NULL, &req_ids[2], NULL);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
- err = ctx::request_handler::subscribe(SUBJ_ACTIVITY_IN_VEHICLE, NULL, &req_ids[3], NULL);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::subscribe(SUBJ_ACTIVITY_IN_VEHICLE, NULL, &req_ids[3], NULL);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
g_print("\n> Mimic any type of activity %d times.\n", CALLBACK_COUNT);
- start_mainloop();
+ startMainloop();
ctx::request_handler::unsubscribe(SUBJ_ACTIVITY_STATIONARY, req_ids[0]);
ctx::request_handler::unsubscribe(SUBJ_ACTIVITY_WALKING, req_ids[1]);
ctx::CtxJson1 option;
option.set(NULL, CONTEXT_TRIGGER_PLACE_ID, 2); /* 2 => office */
- err = ctx::request_handler::subscribe(SUBJ_PLACE_GEOFENCE, &option, &req_id, NULL);
- ASSERT_CMPINT(err, ==, ERR_NONE);
+ lastError = ctx::request_handler::subscribe(SUBJ_PLACE_GEOFENCE, &option, &req_id, NULL);
+ ASSERT_CMPINT(lastError, ==, E_NONE);
g_print("\n> Mimic fence in/out event to office %d times.\n", CALLBACK_COUNT);
- start_mainloop();
+ startMainloop();
ctx::request_handler::unsubscribe(SUBJ_PLACE_GEOFENCE, req_id);
projects / platform / core / api / context.git / commitdiff