diff --git a/core/src/mock/mock_processor.cpp b/core/src/mock/mock_processor.cpp index 570553264d..7114f89c86 100644 --- a/core/src/mock/mock_processor.cpp +++ b/core/src/mock/mock_processor.cpp @@ -75,11 +75,11 @@ namespace km { mock_processor::mock_processor(core::path const & path) : abstract_processor( keyboard_attributes(path.stem(), u"3.145", { - option{KM_CORE_OPT_KEYBOARD, u"__test_point", u"not tiggered"}, + option{KM_CORE_OPT_KEYBOARD, u"test_keyboard_option", u"default_value"}, })), _options({ - {u"\x01__test_point", u"not tiggered"}, - {u"\x02hello", u"-"} + {u"\x01test_keyboard_option", u"default_value"}, + {u"\x02test_env_option", u"-"} }) { } diff --git a/core/tests/unit/kmnkbd/keyboard_api.tests.cpp b/core/tests/unit/kmnkbd/keyboard_api.tests.cpp index 07dfb3e4cf..f1e96f5e30 100644 --- a/core/tests/unit/kmnkbd/keyboard_api.tests.cpp +++ b/core/tests/unit/kmnkbd/keyboard_api.tests.cpp @@ -1,38 +1,42 @@ /* - Copyright: © 2018 SIL International. - Description: Tests for the Keyboard API family of functions. - Create Date: 30 Oct 2018 - Authors: Tim Eves (TSE) -*/ + * Keyman is copyright (C) SIL Global. MIT License. + * + * Created by Tim Eves on 2018-10-30 + * + * Tests for the Keyboard API family of functions. + */ + #include #include "keyman_core.h" #include "path.hpp" #include "mock/mock_processor.hpp" +#include "../../../src/kmx/kmx_xstring.h" //u16cmp +#include -namespace -{ - km::core::path const test_kb_path = "/a/dummy/keyboard.mock"; -} +km::core::path const test_kb_path = "/a/dummy/keyboard.mock"; -#define try_status(expr) \ -{auto __s = (expr); if (__s != KM_CORE_STATUS_OK) return 100*__LINE__+__s;} - -int main(int, char *[]) -{ +TEST(km_core_keyboard, simple_sniff_test) { km_core_keyboard * test_kb = nullptr; km_core_keyboard_attrs const * kb_attrs = nullptr; km_core_keyboard_key * kb_key_list = nullptr; km_core_keyboard_imx * kb_imx_list = nullptr; test_kb = (km_core_keyboard *)new km::core::mock_processor(test_kb_path); - try_status(km_core_keyboard_get_attrs(test_kb, &kb_attrs)); - try_status(km_core_keyboard_get_key_list(test_kb,&kb_key_list)); - try_status(km_core_keyboard_get_imx_list(test_kb,&kb_imx_list)); + EXPECT_EQ(km_core_keyboard_get_attrs(test_kb, &kb_attrs), KM_CORE_STATUS_OK); + EXPECT_EQ(km_core_keyboard_get_key_list(test_kb,&kb_key_list), KM_CORE_STATUS_OK); + EXPECT_EQ(km_core_keyboard_get_imx_list(test_kb,&kb_imx_list), KM_CORE_STATUS_OK); + EXPECT_EQ(km::core::kmx::u16cmp(kb_attrs->version_string, u"3.145"), 0); + + // cleanup km_core_keyboard_dispose(test_kb); km_core_keyboard_key_list_dispose(kb_key_list); km_core_keyboard_imx_list_dispose(kb_imx_list); - - return 0; +} + +GTEST_API_ int +main(int argc, char **argv) { + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } diff --git a/core/tests/unit/kmnkbd/meson.build b/core/tests/unit/kmnkbd/meson.build index c108ae5b83..f0d618db84 100644 --- a/core/tests/unit/kmnkbd/meson.build +++ b/core/tests/unit/kmnkbd/meson.build @@ -42,7 +42,7 @@ foreach t : tests cpp_args: local_defns + defns + warns, include_directories: [inc, libsrc], link_args: links + tests_flags, - dependencies: [icu_uc, icu_i18n], + dependencies: [icu_uc, icu_i18n, gtest_dep], objects: lib.extract_all_objects(recursive: false)) test(t[0], bin, args: ['--color', test_path]) diff --git a/core/tests/unit/kmnkbd/options_api.tests.cpp b/core/tests/unit/kmnkbd/options_api.tests.cpp index 6a745d21bd..04fae29524 100644 --- a/core/tests/unit/kmnkbd/options_api.tests.cpp +++ b/core/tests/unit/kmnkbd/options_api.tests.cpp @@ -1,9 +1,10 @@ /* - Copyright: © 2018 SIL International. - Description: Tests for the context API family of functions. - Create Date: 30 Oct 2018 - Authors: Tim Eves (TSE) -*/ + * Keyman is copyright (C) SIL Global. MIT License. + * + * Created by Tim Eves on 2018-10-30 + * + * Tests for the context API family of functions. + */ #include #include @@ -11,83 +12,21 @@ #include "option.hpp" #include "state.hpp" - -#define try_status(expr) \ -{auto __s = (expr); if (__s != KM_CORE_STATUS_OK) std::exit(100*__LINE__+__s);} - -namespace -{ -#if 0 - km_core_option_item const test_env[] = - { - {u"isdummy", u"yes", 0}, - {u"testing", u"maybe", 0}, - KM_CORE_OPTIONS_END - }; - - km_core_option_item const test_kb[] = - { - {u"hello", u"world", 0}, - KM_CORE_OPTIONS_END - }; - - km_core_option_item test_opts[] = - { - {u"isdummy", u"no", KM_CORE_OPT_ENVIRONMENT}, - {u"hello", u"globe", KM_CORE_OPT_KEYBOARD}, - KM_CORE_OPTIONS_END - }; - - km_core_option_item bad_key_opts[] = - { - {u"isdumber", u"yes!", KM_CORE_OPT_ENVIRONMENT}, - KM_CORE_OPTIONS_END - }; - - km_core_option_item bad_scope_opts[] = - { - {u"hello", u"!", KM_CORE_OPT_UNKNOWN}, - KM_CORE_OPTIONS_END - }; -#endif - km_core_option_item const empty_options_list[] = {KM_CORE_OPTIONS_END}; - - km_core_option_item const api_mock_options[] = - { - {u"hello", u"world", KM_CORE_OPT_KEYBOARD}, - {u"isdummy", u"yes", KM_CORE_OPT_ENVIRONMENT}, - {u"testing", u"maybe", KM_CORE_OPT_ENVIRONMENT}, - KM_CORE_OPTIONS_END - }; - -#if 0 - km::core::state mock_state(test_kb, test_env); - km::core::state empty_state(empty_options_list, empty_options_list); +#include "../../../src/kmx/kmx_xstring.h" //u16cmp +#include "mock/mock_processor.hpp" +#include - std::string get_json_doc(km_core_state * const state) - { - size_t sz = 0; - try_status(km_core_state_options_to_json(state, nullptr, &sz)); - std::string buf(sz-1, 0); - try_status(km_core_state_options_to_json(state, &buf[0], &sz)); +// km_core_option_item const test_kb[] = +// { +// {u"hello", u"world", 0}, +// KM_CORE_OPTIONS_END +// }; - return buf; - } +km::core::path const test_kb_path = "/a/dummy/keyboard.mock"; +km::core::mock_processor mock_processor(test_kb_path); - #define assert_lookup_equals(k,v,s) {if (!_assert_lookup_equals(k,v,s)) return __LINE__; } - bool _assert_lookup_equals(std::u16string const key, std::u16string value, km_core_option_scope scope) - { - - km_core_cu const * ret = nullptr; - auto s = km_core_state_option_lookup(api_mock_options, scope, - key.c_str(), - &ret); - bool v = s == KM_CORE_STATUS_OK && ret == value; - return v; - } - -constexpr char const *empty_json = "\ +const std::string empty_json = "\ {\n\ \"keyboard\" : {},\n\ \"environment\" : {},\n\ @@ -97,67 +36,106 @@ constexpr char const *empty_json = "\ }\n\ }\n"; -constexpr char const *mock_json = "\ +TEST(km_core_options, verify_list_size) { + km_core_option_item const api_mock_options[] = { + {u"hello", u"world", KM_CORE_OPT_KEYBOARD}, + {u"isdummy", u"yes", KM_CORE_OPT_ENVIRONMENT}, + {u"testing", u"maybe", KM_CORE_OPT_ENVIRONMENT}, + KM_CORE_OPTIONS_END + }; + + EXPECT_EQ(km_core_options_list_size(api_mock_options), 3); +} + +GTEST_API_ int +main(int argc, char **argv) { + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} + +TEST(km_core_options, test_empty_list) { + km_core_option_item const empty_options_list[] = {KM_CORE_OPTIONS_END}; + + // Simple sanity tests on an empty options and mock options with 3 items. + EXPECT_EQ(km_core_options_list_size(empty_options_list), 0); + + km_core_state empty_state(mock_processor, empty_options_list); + km_core_cu const *value; + EXPECT_EQ(km_core_state_option_lookup(&empty_state, KM_CORE_OPT_ENVIRONMENT, u"isdummy", &value), KM_CORE_STATUS_KEY_ERROR); +} + +TEST(km_core_options, test_json) { + GTEST_SKIP(); + + + km_core_option_item const empty_options_list[] = {KM_CORE_OPTIONS_END}; + km_core_state empty_state(mock_processor, empty_options_list); + + size_t sz = 0; + ASSERT_EQ(km_core_state_options_to_json(&empty_state, nullptr, &sz), KM_CORE_STATUS_OK); + std::string buf(sz-1, 0); + ASSERT_EQ(km_core_state_options_to_json(&empty_state, &buf[0], &sz), KM_CORE_STATUS_OK); + EXPECT_EQ(buf, empty_json); +} + +#define expect_opt_matches(state, scope, key, expected) {\ + km_core_cu const * actual = nullptr; \ + auto s = km_core_state_option_lookup(state, scope, key, &actual); \ + ASSERT_EQ(s, KM_CORE_STATUS_OK); \ + EXPECT_EQ(std::u16string(actual), std::u16string(expected)); \ +} + +TEST(km_core_options, test_setting_state) { + km_core_option_item const test_env[] = { + {u"test_env_option", u"yes", 0}, + {u"testing", u"maybe", 0}, + KM_CORE_OPTIONS_END + }; + + km_core_option_item const new_opts[] = { + {u"test_env_option", u"no", KM_CORE_OPT_ENVIRONMENT}, + {u"test_keyboard_option", u"globe", KM_CORE_OPT_KEYBOARD}, + KM_CORE_OPTIONS_END + }; + + km_core_state test_state(mock_processor, test_env); + + expect_opt_matches(&test_state, KM_CORE_OPT_ENVIRONMENT, u"test_env_option", u"yes"); + expect_opt_matches(&test_state, KM_CORE_OPT_KEYBOARD, u"test_keyboard_option", u"default_value"); + ASSERT_EQ(km_core_state_options_update(&test_state, new_opts), KM_CORE_STATUS_OK); + expect_opt_matches(&test_state, KM_CORE_OPT_ENVIRONMENT, u"test_env_option", u"no"); + expect_opt_matches(&test_state, KM_CORE_OPT_KEYBOARD, u"test_keyboard_option", u"globe"); + + km_core_option_item bad_scope_opts[] = { + {u"hello", u"!", KM_CORE_OPT_UNKNOWN}, + KM_CORE_OPTIONS_END + }; + EXPECT_EQ(km_core_state_options_update(&test_state, bad_scope_opts), KM_CORE_STATUS_INVALID_ARGUMENT); + + /*size_t sz = 0; + ASSERT_EQ(km_core_state_options_to_json(&test_state, nullptr, &sz), KM_CORE_STATUS_OK); + std::string buf(sz-1, 0); + std::cout << sz << std::endl; + ASSERT_EQ(km_core_state_options_to_json(&test_state, &buf[0], &sz), KM_CORE_STATUS_OK); + + + const std::string mock_json = "\ {\n\ \"keyboard\" : {\n\ - \"hello\" : \"world\"\n\ + \"test_keyboard_option\" : \"default_value\"\n\ },\n\ \"environment\" : {\n\ - \"isdummy\" : \"yes\",\n\ - \"testing\" : \"maybe\"\n\ + \"test_env_option\" : \"yes\"\n\ },\n\ \"saved\" : {\n\ \"keyboard\" : {\n\ - \"hello\" : \"globe\"\n\ + \"test_keyboard_option\" : \"globe\"\n\ },\n\ \"environment\" : {\n\ - \"isdummy\" : \"no\"\n\ + \"test_env_option\" : \"no\"\n\ }\n\ }\n\ }\n"; -#endif -} - -int main(int, char * []) -{ - - // Simple sanity tests on an empty options and mock options with 3 items. - if (km_core_options_list_size(empty_options_list) != 0) - return __LINE__; - - if (km_core_options_list_size(api_mock_options) != 3) - return __LINE__; - -#if 0 - km_core_cu const *value; - auto s = km_core_options_lookup(api_empty_options, - KM_CORE_OPT_ENVIRONMENT, - u"isdummy", &value); - if (s != KM_CORE_STATUS_KEY_ERROR) return __LINE__; - if (get_json_doc(api_empty_options) != empty_json) return __LINE__; - - // Lets update data. - assert_lookup_equals(u"isdummy", u"yes", KM_CORE_OPT_ENVIRONMENT); - assert_lookup_equals(u"hello", u"world", KM_CORE_OPT_KEYBOARD); - try_status(km_core_options_update(api_mock_options, test_opts)); - assert_lookup_equals(u"isdummy", u"no", KM_CORE_OPT_ENVIRONMENT); - assert_lookup_equals(u"hello", u"globe", KM_CORE_OPT_KEYBOARD); - - // Test writing of non-exitent keys - if (km_core_options_update(api_mock_options, bad_key_opts) - != KM_CORE_STATUS_KEY_ERROR) - return __LINE__; - - if (km_core_options_update(api_mock_options, bad_scope_opts) - != KM_CORE_STATUS_INVALID_ARGUMENT) - return __LINE__; - - // Create a single entry options set for testing fuller json output. - // Because the underlying data structure is unordered there is no way define - // a static json test document that will be consistently sorted across - // runtimes or platforms. - if (get_json_doc(api_mock_options) != mock_json) return __LINE__; -#endif - - return 0; + + EXPECT_EQ(buf, mock_json);*/ }