Scale Stack 0.3 Developer Documentation

scalestack/kernel/test/core.cc

Go to the documentation of this file.

/*
 * Scale Stack
 *
 * Copyright 2010 Eric Day
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "config.h"

#include <cstdlib>
#include <cstring>

#include <scalestack/kernel/service.h>
#include <scalestack/kernel/test.h>

using namespace std;
using namespace scalestack;

class test_suite: public scalestack::kernel::test_suite<test_suite>
{
public:

  void test_constructor(void)
  {
  }

  void test_parse_arguments(void)
  {
    const char* argv[] =
    {
      "v",
      "-h",
      "--help",
      "test_child"
      "test_child=value1",
      "test_parent.option1",
      "test_parent.option2=value2"
    };
    core->parse_arguments(sizeof(argv) / sizeof(const char*), argv);
  }

  void test_parse_paths(void)
  {
    const char* argv[] =
    {
      "p=/path/to/modules",
      "path=/another/path/to/modules"
    };
    core->parse_arguments(2, argv);
  }

  void test_parse_bad_paths(void)
  {
    const char* argv[] =
    {
      "path"
    };
    assert_exception(core->parse_arguments(1, argv));
    argv[0] = "path.a";
    assert_exception(core->parse_arguments(1, argv));
  }

  void test_parse_files(void)
  {
    const char* argv[] =
    {
      "f=" SCALESTACK_SOURCE_PATH "/scalestack/kernel/test/config_file1",
      "file=" SCALESTACK_SOURCE_PATH "/scalestack/kernel/test/config_file2"
    };
    core->parse_arguments(2, argv);
  }

  void test_parse_bad_files(void)
  {
    const char* argv[] =
    {
      "file"
    };
    assert_exception(core->parse_arguments(1, argv));
    argv[0] = "file.a";
    assert_exception(core->parse_arguments(1, argv));
    argv[0] = "file=bad_file";
    assert_exception(core->parse_arguments(1, argv));
    argv[0] = "file=" SCALESTACK_SOURCE_PATH
      "/scalestack/kernel/test/config_file4";
    assert_exception(core->parse_arguments(1, argv));
  }

  void test_bad_option(void)
  {
    const char* argv[] =
    {
      ""
    };
    assert_exception(core->parse_arguments(1, argv));
    argv[0] = ".option=value";
    assert_exception(core->parse_arguments(1, argv));
    argv[0] = "=value";
    assert_exception(core->parse_arguments(1, argv));
  }

  void test_long_option(void)
  {
    const size_t long_option_size = 1024 * 128;
    char* long_option = static_cast<char*>(malloc(long_option_size));
    assert(long_option != NULL);
    const char* argv[] =
    {
      long_option
    };

    memset(long_option, 'A', long_option_size - 1);
    long_option[long_option_size - 1] = '\0';
    long_option[long_option_size / 3] = '.';
    long_option[(long_option_size / 3) * 2] = '=';

    core->parse_arguments(1, argv);
    free(long_option);
  }

  void test_long_option_list(void)
  {
    /* Use a new core object so debug mode doesn't flood the test output. */
    kernel::core new_core;
    const size_t argc = 1024 * 128;
    const char** argv = static_cast<const char**>(malloc(sizeof(char*) * argc));

    for (size_t x = 0; x < argc; x++)
      argv[x] = const_cast<char*>("module.option=value");

    new_core.parse_arguments(argc, argv);
    free(argv);
  }

  void test_add_module_option_value(void)
  {
    core->add_module_option_value("module", "option", "value");
    core->get_module("module");
    assert_exception(core->add_module_option_value("", "option", "value"));
    core->add_module_option_value("module", "", "value");
    core->add_module_option_value("module", "option", "");
    assert_exception(core->add_module_option_value("", "", "value"));
    assert_exception(core->add_module_option_value("", "option", ""));
    core->add_module_option_value("module", "", "");
    assert_exception(core->add_module_option_value("", "", ""));
  }

  void test_set_signal_handlers(void)
  {
    core->set_signal_handlers();
    assert_exception(core->set_signal_handlers());
  }

  void test_handle_signal(void)
  {
    core->handle_signal(0);
  }

  void test_get_or_add_module(void)
  {
    kernel::module& module = core->get_or_add_module("module");
    assert(&core->get_or_add_module("module") == &module);

    kernel::module& module2 = core->get_or_add_module("module2");
    assert(&core->get_or_add_module("module2") == &module2);
    assert(&core->get_or_add_module("module2") != &module);
  }

  void test_get_module(void)
  {
    kernel::module& module = core->get_or_add_module("module");
    assert(&core->get_module("module") == &module);
    assert_exception(core->get_module("bad_module"));
  }

  void test_get_module_count(void)
  {
    assert(core->get_module_count() == 0);
    core->get_or_add_module("module");
    assert(core->get_module_count() == 1);
    core->get_or_add_module("module2");
    assert(core->get_module_count() == 2);
    core->get_or_add_module("module2");
    assert(core->get_module_count() == 2);
  }

  void test_get_or_add_module_normalize(void)
  {
    assert(core->get_module_count() == 0);
    core->get_or_add_module("module_test");
    assert(core->get_module_count() == 1);
    core->get_or_add_module("MODULE_TEST");
    assert(core->get_module_count() == 1);
    core->get_or_add_module("module::test");
    assert(core->get_module_count() == 1);
  }

  void test_module_scan(void)
  {
    assert(core->begin_module() == NULL);
    assert(core->next_module() == NULL);

    kernel::module& module = core->get_or_add_module("module");
    assert(core->begin_module() == &module);
    assert(core->next_module() == NULL);

    kernel::module& module2 = core->get_or_add_module("module2");
    assert(core->begin_module() == &module);
    assert(core->next_module() == &module2);
    assert(core->next_module() == NULL);
  }

  void test_add_service(void)
  {
    kernel::module& module = core->get_or_add_module("module");
    kernel::service service(module);;
    core->add_service("service1", &service);
    core->add_service("service2", &service);
    assert_exception(core->add_service("service2", &service));
    assert(&service.get_module() == &module);
  }

  void test_remove_service(void)
  {
    kernel::module& module = core->get_or_add_module("module");
    kernel::service service(module);
    kernel::service service2(module);
    core->add_service("service1", &service);
    core->add_service("service2", &service2);
    assert(core->remove_service("service1") == &service);
    assert(core->remove_service("service2") == &service2);
    assert_exception(core->remove_service("service2"));
  }

  void test_get_service(void)
  {
    kernel::module& module = core->get_or_add_module("module");
    kernel::service service(module);
    kernel::service service2(module);
    core->add_service("service1", &service);
    core->add_service("service2", &service2);
    assert(&core->get_service("service1") == &service);
    assert(&core->get_service("service1") == &service);
    assert(&core->get_service("service2") == &service2);
    assert_exception(core->get_service("service3"));
  }

  class log_test: public kernel::log
  {
  public:
    size_t errors;
    log_test(void): errors() {}
    void write_log(kernel::log::level log_level, const char*, const char*)
    {
      if (log_level == kernel::log::LEVEL_ERROR)
        errors++;
    }
  };

  void test_add_log(void)
  {
    log_test log;
    core->add_log("log1", &log);
    core->add_log("log2", &log);
    assert_exception(core->add_log("log2", &log));
    core->remove_log("log1");
    core->remove_log("log2");
  }

  void test_remove_log(void)
  {
    log_test log;
    log_test log2;
    core->add_log("log1", &log);
    core->add_log("log2", &log2);
    assert(core->remove_log("log1") == &log);
    assert(core->remove_log("log2") == &log2);
    assert_exception(core->remove_log("log2"));
  }

  void test_get_log(void)
  {
    log_test log;
    log_test log2;
    core->add_log("log1", &log);
    core->add_log("log2", &log2);
    assert(&core->get_log("log1") == &log);
    assert(&core->get_log("log1") == &log);
    assert(&core->get_log("log2") == &log2);
    assert_exception(core->get_log("log3"));
    core->remove_log("log1");
    core->remove_log("log2");
  }

  void test_unremoved_log(void)
  {
    cout << _("Testing unremoved logs, ignore the following output:") << endl;
    log_test log1;
    log_test log2;
    /* Put this in a nested scope so it can destruct before end of test. */
    {
      kernel::core new_core;

      /* Turn on verbose logging so we can catch errors. */
      const char* argv[] =
      {
        "v"
      };
      new_core.parse_arguments(1, argv);

      /* The core destructor sends errors when there is more than one unremoved
         log (one for the built-in console log). Add two logs so more than one
         still exists. */
      new_core.add_log("log1", &log1);
      new_core.add_log("log2", &log2);

      /* Core goes out of scope here and destructs. */
    }

    /* There should be three errors, one for each existing log plus console. */
    assert(log1.errors == 3);
  }

  void test_run(void)
  {
    cout << _("Testing exception message, ignore the following output:") <<
      endl;
    bool run_failed = false;
    try
    {
      core->run();
    }
    catch (exception& e)
    {
      cout << e.what() << endl;
      run_failed = true;
    }
    assert(run_failed);
  }

  void test_threshold(void)
  {
    const char* argv[] =
    {
      "v",
    };
    size_t old_threshold = core->get_threshold();
    core->parse_arguments(1, argv);
    assert(core->get_threshold() == (old_threshold + 1));
    argv[0] = "v=3";
    core->parse_arguments(1, argv);
    assert(core->get_threshold() == 3);
    core->set_threshold(4);
    assert(core->get_threshold() == 4);
  }

  void test_run_verbose(void)
  {
    const char* argv[] =
    {
      "vvvv",
    };
    core->parse_arguments(1, argv);
    cout << _("Testing verbose messages, ignore the following output:") << endl;
    assert_exception(core->run());
  }

  void test_shutdown(void)
  {
    core->shutdown();
  }

  void test_print_help(void)
  {
    const char* argv[] =
    {
      "help",
    };
    core->parse_arguments(1, argv);
    cout << _("Testing help messages, ignore the following output:") << endl;
    core->run();
  }

  void test_print_config(void)
  {
    const char* argv[] =
    {
      "config",
      "a=b",
    };
    core->parse_arguments(2, argv);
    cout << _("Testing config messages, ignore the following output:") << endl;
    core->run();
  }

  void test_alias(void)
  {
    kernel::module& module = core->get_or_add_module("module");
    kernel::module& module2 = core->get_or_add_module("module2");
    core->add_module_option_value("module_a", "", "module");
    assert(&core->get_module("module_a") == &module);
    core->add_module_option_value("module_a", "", "module2");
    assert(&core->get_module("module_a") == &module2);
  }

  test_suite(int argc, const char** argv):
    scalestack::kernel::test_suite<test_suite>(argc, argv)
  {
    test_case(test_suite::test_constructor);
    test_case(test_suite::test_parse_arguments);
    test_case(test_suite::test_parse_paths);
    test_case(test_suite::test_parse_bad_paths);
    test_case(test_suite::test_parse_files);
    test_case(test_suite::test_parse_bad_files);
    test_case(test_suite::test_bad_option);
    test_case(test_suite::test_long_option);
    test_case(test_suite::test_long_option_list);
    test_case(test_suite::test_add_module_option_value);
    test_case(test_suite::test_set_signal_handlers);
    test_case(test_suite::test_handle_signal);
    test_case(test_suite::test_get_or_add_module);
    test_case(test_suite::test_get_module);
    test_case(test_suite::test_get_module_count);
    test_case(test_suite::test_get_or_add_module_normalize);
    test_case(test_suite::test_module_scan);
    test_case(test_suite::test_add_service);
    test_case(test_suite::test_remove_service);
    test_case(test_suite::test_get_service);
    test_case(test_suite::test_add_log);
    test_case(test_suite::test_remove_log);
    test_case(test_suite::test_get_log);
    test_case(test_suite::test_unremoved_log);
    test_case(test_suite::test_run);
    test_case(test_suite::test_threshold);
    test_case(test_suite::test_run_verbose);
    test_case(test_suite::test_shutdown);
    test_case(test_suite::test_print_help);
    test_case(test_suite::test_print_config);
    test_case(test_suite::test_alias);
  }
};

int main(int argc, const char* argv[])
{
  test_suite test_suite(argc - 1, argv + 1);
  test_suite.run();
  return 0;
}

---