test/test_commandline_sdbd.c

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "commandline_sdbd.h"
  18 #include "sdb.h"
  19
  20 #include <assert.h>
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23
  24 #include <check.h>
  25
  26 /*!
  27  * @define print_nullable(s)
  28  * Takes string (<tt>const char *</tt>) and returns it or "(null)" literal
  29  * in case \c s is NULL.
  30  */
  31 #define print_nullable(s) \
  32         (((s) == NULL) ? "(null)" : (s))
  33
  34
  35 /*!
  36  * @define ck_hostport(hp, h, p)
  37  * Check if HostPort contains given host and port
  38  *
  39  * Host strings are equal if both point to the same address (including NULL)
  40  * or, provided none of them is NULL, if strcmp() == 0.
  41  *
  42  * @param hp \ref HostPort to be checked (<tt>const HostPort *</tt>)
  43  * @param h hostname (<tt>const char *</tt>) to be checked against
  44  * @param p port (\c int) to be checked against
  45  */
  46 #define _ck_hostport(hp, h, p) \
  47         ( (((hp)->host == (h)) \
  48                         || (((hp)->host) && (h) && (strcmp((hp)->host, (h)) == 0))) \
  49                 && (hp)->port == (p) )
  50
  51
  52 /*!
  53  * @define ck_assert_hostport_eq(hp,h,p)
  54  * Makes assertion against HostPort containing given host and port
  55  *
  56  * @param hp \ref HostPort to be checked (<tt>const HostPort *</tt>)
  57  * @param h hostname (<tt>const char *</tt>) to be checked against
  58  * @param p port (\c int) to be checked against
  59  *
  60  * @see ck_hostport
  61  */
  62 #define ck_assert_hostport_eq(hp,h,p) \
  63         (fail_unless(_ck_hostport(hp,h,p), "Assertion failed (%s,%d) != (%s, %d)", \
  64                         print_nullable((hp)->host), (hp)->port, print_nullable(h), (p)))
  65
  66
  67 #define array_size(a) \
  68     (sizeof(a) / sizeof((a)[0]))
  69
  70
  71 void setup(void) {
  72
  73 }
  74
  75 void teardown(void) {
  76
  77 }
  78
  79
  80 START_TEST(test_all_opts) {
  81         char *test_argv[] = {
  82                         "./test",
  83                         "--emulator=tizen:101",
  84                         "--listen-port=101",
  85                         "--sensors=localhost:103",
  86                         "--connect-to=localhost:99"
  87         };
  88
  89         SdbdCommandlineArgs sdbd_args = {0};
  90
  91         apply_sdbd_commandline_defaults(&sdbd_args);
  92         int parse_res = parse_sdbd_commandline(&sdbd_args, array_size(test_argv), test_argv);
  93
  94         if (parse_res != SDBD_COMMANDLINE_SUCCESS) {
  95                 ck_abort_msg("parsing commandline failed");
  96                 return;
  97         }
  98
  99         ck_assert_hostport_eq(&sdbd_args.emulator, "tizen", 101);
 100         ck_assert_hostport_eq(&sdbd_args.sensors, "localhost", 103);
 101         ck_assert_hostport_eq(&sdbd_args.sdb, "localhost", 99);
 102         ck_assert_int_eq(sdbd_args.sdbd_port, 101);
 103
 104 } END_TEST
 105
 106 START_TEST(test_emul_default_tcp_port) {
 107         char *test_argv[] = {
 108                         "./test",
 109                         "--emulator=tizen:101",
 110         };
 111
 112         SdbdCommandlineArgs sdbd_args = {0};
 113
 114         apply_sdbd_commandline_defaults(&sdbd_args);
 115         int parse_res = parse_sdbd_commandline(&sdbd_args, array_size(test_argv), test_argv);
 116
 117         if (parse_res != SDBD_COMMANDLINE_SUCCESS) {
 118                 ck_abort_msg("parsing commandline failed");
 119                 return;
 120         }
 121
 122         ck_assert_hostport_eq(&sdbd_args.emulator, "tizen", 101);
 123         ck_assert_int_eq(sdbd_args.sdbd_port, DEFAULT_SDB_LOCAL_TRANSPORT_PORT);
 124 } END_TEST
 125
 126 START_TEST(test_tcp_port) {
 127         char *test_argv[] = {
 128                         "./test",
 129                         "--listen-port=101",
 130         };
 131
 132         SdbdCommandlineArgs sdbd_args = {0};
 133
 134         apply_sdbd_commandline_defaults(&sdbd_args);
 135         int parse_res = parse_sdbd_commandline(&sdbd_args, array_size(test_argv), test_argv);
 136
 137         if (parse_res != SDBD_COMMANDLINE_SUCCESS) {
 138                 ck_abort_msg("parsing commandline failed");
 139                 return;
 140         }
 141
 142         ck_assert_int_eq(sdbd_args.sdbd_port, 101);
 143 } END_TEST
 144
 145 START_TEST(test_empty) {
 146         char *test_argv[] = {
 147                         "./test"
 148         };
 149
 150         SdbdCommandlineArgs sdbd_args = {0};
 151
 152         int parse_res = parse_sdbd_commandline(&sdbd_args, array_size(test_argv), test_argv);
 153
 154         if (parse_res != SDBD_COMMANDLINE_SUCCESS) {
 155                 ck_abort_msg("parsing commandline failed");
 156                 return;
 157         }
 158
 159         /* Now check if sdbd_commandline_args was not tainted */
 160         SdbdCommandlineArgs zero_args;
 161         memset(&zero_args, 0, sizeof(SdbdCommandlineArgs));
 162         if (memcmp(&sdbd_args, &zero_args, sizeof(SdbdCommandlineArgs)) != 0) {
 163                 ck_abort_msg("SdbdCommandlineArgs is tainted");
 164         }
 165
 166 } END_TEST
 167
 168
 169 START_TEST(test_unknown) {
 170         char *test_argv[] = {
 171                         "./test",
 172                         "--emulator=tizen:26101",
 173                         "--unknown=true"
 174         };
 175
 176         SdbdCommandlineArgs sdbd_args = {0};
 177
 178         int parse_res = parse_sdbd_commandline(&sdbd_args, array_size(test_argv), test_argv);
 179
 180         if (parse_res != SDBD_COMMANDLINE_FAILURE_UNKNOWN_OPT) {
 181                 ck_abort_msg("parsing commandline failed");
 182                 return;
 183         }
 184
 185 } END_TEST
 186
 187
 188 START_TEST(test_clear_args) {
 189         SdbdCommandlineArgs sdbd_args = {0};
 190
 191         sdbd_args.emulator.host = strdup("emul_host");
 192         sdbd_args.emulator.port = 123456;
 193         sdbd_args.sdb.host = strdup("sdb_host");
 194         sdbd_args.sdb.port = 623451;
 195         sdbd_args.sensors.host = strdup("sdb_host");
 196         sdbd_args.sensors.port = 634512;
 197         sdbd_args.sdbd_port = 543216;
 198
 199         clear_sdbd_commandline_args(&sdbd_args);
 200
 201         ck_assert_hostport_eq(&sdbd_args.emulator, NULL, 0);
 202         ck_assert_hostport_eq(&sdbd_args.sensors, NULL, 0);
 203         ck_assert_hostport_eq(&sdbd_args.sdb, NULL, 0);
 204         ck_assert_int_eq(sdbd_args.sdbd_port, 0);
 205 } END_TEST
 206
 207
 208 START_TEST(test_double_clear) {
 209     SdbdCommandlineArgs sdbd_args = {0};
 210     clear_sdbd_commandline_args(&sdbd_args);
 211 } END_TEST
 212
 213
 214 START_TEST(test_default_args) {
 215         SdbdCommandlineArgs sdbd_args = {0};
 216
 217         apply_sdbd_commandline_defaults(&sdbd_args);
 218
 219         ck_assert_hostport_eq(&sdbd_args.emulator, NULL, 0);
 220         ck_assert_hostport_eq(&sdbd_args.sensors, QEMU_FORWARD_IP, DEFAULT_SENSORS_LOCAL_TRANSPORT_PORT);
 221         ck_assert_hostport_eq(&sdbd_args.sdb, QEMU_FORWARD_IP, DEFAULT_SDB_PORT);
 222         ck_assert_int_eq(sdbd_args.sdbd_port, -1);
 223 } END_TEST
 224
 225
 226 START_TEST(test_usage_message) {
 227     FILE *stream;
 228     char *buffer = NULL;
 229     size_t buf_len = 0;
 230
 231     stream = open_memstream(&buffer, &buf_len);
 232     print_sdbd_usage_message(stream);
 233     fclose(stream);
 234
 235     // Just check if all options are mentioned in usage message
 236     ck_assert(strstr(buffer, "--"ARG_EMULATOR_VM_NAME) != NULL);
 237     ck_assert(strstr(buffer, "--"ARG_SDBD_LISTEN_PORT) != NULL);
 238     ck_assert(strstr(buffer, "--"ARG_SDB) != NULL);
 239     ck_assert(strstr(buffer, "--"ARG_SENSORS) != NULL);
 240     ck_assert(strstr(buffer, "--"ARG_HELP) != NULL);
 241     ck_assert(strstr(buffer, "--"ARG_USAGE) != NULL);
 242
 243     free(buffer);
 244 } END_TEST
 245
 246 START_TEST(test_usage) {
 247     char *test_argv[] = {
 248             "./test",
 249             "--usage"
 250     };
 251
 252     SdbdCommandlineArgs sdbd_args = {0};
 253
 254     int parse_res = parse_sdbd_commandline(&sdbd_args, array_size(test_argv), test_argv);
 255     ck_assert_int_eq(parse_res, SDBD_COMMANDLINE_USAGE);
 256
 257 } END_TEST
 258
 259
 260 START_TEST(test_help) {
 261     char *test_argv[] = {
 262             "./test",
 263             "--help"
 264     };
 265
 266     SdbdCommandlineArgs sdbd_args = {0};
 267
 268     int parse_res = parse_sdbd_commandline(&sdbd_args, array_size(test_argv), test_argv);
 269     ck_assert_int_eq(parse_res, SDBD_COMMANDLINE_HELP);
 270
 271 } END_TEST
 272
 273
 274 START_TEST(test_help_other_opt) {
 275     char *test_argv[] = {
 276             "./test",
 277             "--listen-port=1234",
 278             "--help"
 279     };
 280
 281     SdbdCommandlineArgs sdbd_args = {0};
 282
 283     int parse_res = parse_sdbd_commandline(&sdbd_args, array_size(test_argv), test_argv);
 284     ck_assert_int_eq(parse_res, SDBD_COMMANDLINE_HELP);
 285
 286 } END_TEST
 287
 288
 289 Suite *sdbd_commandline_suite (void) {
 290         Suite *s = suite_create ("sdbd commandline");
 291
 292         TCase *tc_core = tcase_create ("Core");
 293         tcase_add_checked_fixture(tc_core, setup, teardown);
 294         tcase_add_test (tc_core, test_all_opts);
 295         tcase_add_test (tc_core, test_empty);
 296         tcase_add_test (tc_core, test_unknown);
 297         tcase_add_test (tc_core, test_clear_args);
 298         tcase_add_test (tc_core, test_double_clear);
 299         tcase_add_test (tc_core, test_default_args);
 300         tcase_add_test (tc_core, test_usage_message);
 301         tcase_add_test (tc_core, test_usage);
 302         tcase_add_test (tc_core, test_help);
 303         tcase_add_test (tc_core, test_help_other_opt);
 304         suite_add_tcase (s, tc_core);
 305
 306         return s;
 307 }
 308
 309
 310 int run_tests(int print_output) {
 311         int number_failed;
 312         Suite *s = sdbd_commandline_suite();
 313         SRunner *sr = srunner_create (s);
 314         srunner_run_all (sr, print_output);
 315         number_failed = srunner_ntests_failed (sr);
 316         srunner_free (sr);
 317         return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
 318 }
 319
 320
 321 #ifndef COMMANDLINE_SDBD_TESTS_NO_MAIN
 322 int main(int argc, char *argv[]) {
 323         return run_tests(CK_NORMAL);
 324 }
 325 #endif /* COMMANDLINE_SDBD_TESTS_NO_MAIN */