erabo/spiegel-keyman
1
0
Fork 0
mirror of https://github.com/keymanapp/keyman.git synced 2026-10-28 00:37:53 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

chore(core): move keyboard_api and options_api tests to gtest

Browse source
This commit is contained in:
Marc Durdin 2026-04-10 11:39:01 +02:00
parent b40012de23
commit 596aae6e40
4 changed files with 134 additions and 152 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
core/src/mock/mock_processor.cpp
View file

@ -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"-"}
})
{
}

42
core/tests/unit/kmnkbd/keyboard_api.tests.cpp
View file

@ -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 <string>
#include "keyman_core.h"
#include "path.hpp"
#include "mock/mock_processor.hpp"
#include "../../../src/kmx/kmx_xstring.h" //u16cmp
#include <gtest/gtest.h>
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();
}

2
core/tests/unit/kmnkbd/meson.build
View file

@ -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])

236
core/tests/unit/kmnkbd/options_api.tests.cpp
View file

@ -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 <cstdlib>
#include <string>
@ -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 <gtest/gtest.h>
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);*/
}