aboutsummaryrefslogtreecommitdiffstats
path: root/native/dicttoolkit/tests/utils
diff options
context:
space:
mode:
Diffstat (limited to 'native/dicttoolkit/tests/utils')
-rw-r--r--native/dicttoolkit/tests/utils/arguments_parser_test.cpp147
-rw-r--r--native/dicttoolkit/tests/utils/command_utils_test.cpp37
-rw-r--r--native/dicttoolkit/tests/utils/utf8_utils_test.cpp85
3 files changed, 269 insertions, 0 deletions
diff --git a/native/dicttoolkit/tests/utils/arguments_parser_test.cpp b/native/dicttoolkit/tests/utils/arguments_parser_test.cpp
new file mode 100644
index 000000000..58b499823
--- /dev/null
+++ b/native/dicttoolkit/tests/utils/arguments_parser_test.cpp
@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * 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 "utils/arguments_parser.h"
+
+#include <gtest/gtest.h>
+
+namespace latinime {
+namespace dicttoolkit {
+namespace {
+
+TEST(ArgumentsParserTests, TestValitadeSpecs) {
+ {
+ std::unordered_map<std::string, OptionSpec> optionSpecs;
+ std::vector<ArgumentSpec> argumentSpecs;
+ EXPECT_TRUE(
+ ArgumentsParser(std::move(optionSpecs), std::move(argumentSpecs)).validateSpecs());
+ }
+ {
+ std::unordered_map<std::string, OptionSpec> optionSpecs;
+ optionSpecs["a"] = OptionSpec::keyValueOption("valueName", "default", "description");
+ const std::vector<ArgumentSpec> argumentSpecs = {
+ ArgumentSpec::singleArgument("name", "description"),
+ ArgumentSpec::variableLengthArguments("name2", 0 /* minCount */, 1 /* maxCount */,
+ "description2")
+ };
+ EXPECT_TRUE(
+ ArgumentsParser(std::move(optionSpecs), std::move(argumentSpecs)).validateSpecs());
+ }
+ {
+ const std::vector<ArgumentSpec> argumentSpecs = {
+ ArgumentSpec::variableLengthArguments("name", 0 /* minCount */, 0 /* maxCount */,
+ "description")
+ };
+ EXPECT_FALSE(ArgumentsParser(std::unordered_map<std::string, OptionSpec>(),
+ std::move(argumentSpecs)).validateSpecs());
+ }
+ {
+ const std::vector<ArgumentSpec> argumentSpecs = {
+ ArgumentSpec::singleArgument("name", "description"),
+ ArgumentSpec::variableLengthArguments("name", 0 /* minCount */, 1 /* maxCount */,
+ "description")
+ };
+ EXPECT_FALSE(ArgumentsParser(std::unordered_map<std::string, OptionSpec>(),
+ std::move(argumentSpecs)).validateSpecs());
+ }
+ {
+ const std::vector<ArgumentSpec> argumentSpecs = {
+ ArgumentSpec::variableLengthArguments("name", 0 /* minCount */, 1 /* maxCount */,
+ "description"),
+ ArgumentSpec::singleArgument("name2", "description2")
+ };
+ EXPECT_FALSE(ArgumentsParser(std::unordered_map<std::string, OptionSpec>(),
+ std::move(argumentSpecs)).validateSpecs());
+ }
+}
+
+int initArgv(char *mutableCommandLine, char **argv) {
+ bool readingSeparator = false;
+ int argc = 1;
+ argv[0] = mutableCommandLine;
+ const size_t length = strlen(mutableCommandLine);
+ for (size_t i = 0; i < length; ++i) {
+ if (mutableCommandLine[i] != ' ' && readingSeparator) {
+ readingSeparator = false;
+ argv[argc] = mutableCommandLine + i;
+ ++argc;
+ } else if (mutableCommandLine[i] == ' ' && !readingSeparator) {
+ readingSeparator = true;
+ mutableCommandLine[i] = '\0';
+ }
+ }
+ argv[argc] = nullptr;
+ return argc;
+}
+
+TEST(ArgumentsParserTests, TestParseArguments) {
+ std::unordered_map<std::string, OptionSpec> optionSpecs;
+ optionSpecs["a"] = OptionSpec::switchOption("description");
+ optionSpecs["b"] = OptionSpec::keyValueOption("valueName", "default", "description");
+ const std::vector<ArgumentSpec> argumentSpecs = {
+ ArgumentSpec::singleArgument("arg0", "description"),
+ ArgumentSpec::variableLengthArguments("arg1", 0 /* minCount */, 2 /* maxCount */,
+ "description"),
+ };
+ const ArgumentsParser parser =
+ ArgumentsParser(std::move(optionSpecs), std::move(argumentSpecs));
+
+ {
+ char kMutableCommandLine[1024] = "command arg";
+ char *argv[128] = {};
+ const int argc = initArgv(kMutableCommandLine, argv);
+ ASSERT_EQ(2, argc);
+ const ArgumentsAndOptions argumentsAndOptions = parser.parseArguments(
+ argc, argv, false /* printErrorMessages */);
+ EXPECT_FALSE(argumentsAndOptions.hasOption("a"));
+ EXPECT_EQ("default", argumentsAndOptions.getOptionValue("b"));
+ EXPECT_EQ("arg", argumentsAndOptions.getSingleArgument("arg0"));
+ EXPECT_FALSE(argumentsAndOptions.hasArgument("arg1"));
+ }
+ {
+ char kArgumentBuffer[1024] = "command -a arg arg";
+ char *argv[128] = {};
+ const int argc = initArgv(kArgumentBuffer, argv);
+ ASSERT_EQ(4, argc);
+ const ArgumentsAndOptions argumentsAndOptions = parser.parseArguments(
+ argc, argv, false /* printErrorMessages */);
+ EXPECT_TRUE(argumentsAndOptions.hasOption("a"));
+ EXPECT_EQ("default", argumentsAndOptions.getOptionValue("b"));
+ EXPECT_EQ("arg", argumentsAndOptions.getSingleArgument("arg0"));
+ EXPECT_TRUE(argumentsAndOptions.hasArgument("arg1"));
+ EXPECT_EQ(1u, argumentsAndOptions.getVariableLengthArguments("arg1").size());
+ }
+ {
+ char kArgumentBuffer[1024] = "command -b value arg arg1 arg2";
+ char *argv[128] = {};
+ const int argc = initArgv(kArgumentBuffer, argv);
+ ASSERT_EQ(6, argc);
+ const ArgumentsAndOptions argumentsAndOptions = parser.parseArguments(
+ argc, argv, false /* printErrorMessages */);
+ EXPECT_FALSE(argumentsAndOptions.hasOption("a"));
+ EXPECT_EQ("value", argumentsAndOptions.getOptionValue("b"));
+ EXPECT_EQ("arg", argumentsAndOptions.getSingleArgument("arg0"));
+ const std::vector<std::string> &arg1 =
+ argumentsAndOptions.getVariableLengthArguments("arg1");
+ EXPECT_EQ(2u, arg1.size());
+ EXPECT_EQ("arg1", arg1[0]);
+ EXPECT_EQ("arg2", arg1[1]);
+ }
+}
+
+} // namespace
+} // namespace dicttoolkit
+} // namespace latinime
diff --git a/native/dicttoolkit/tests/utils/command_utils_test.cpp b/native/dicttoolkit/tests/utils/command_utils_test.cpp
new file mode 100644
index 000000000..9d79c9dd9
--- /dev/null
+++ b/native/dicttoolkit/tests/utils/command_utils_test.cpp
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * 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 "utils/command_utils.h"
+
+#include <gtest/gtest.h>
+
+namespace latinime {
+namespace dicttoolkit {
+namespace {
+
+TEST(CommandUtilsTests, TestGetCommandType) {
+ EXPECT_EQ(CommandUtils::getCommandType(""), CommandType::Unknown);
+ EXPECT_EQ(CommandUtils::getCommandType("abc"), CommandType::Unknown);
+ EXPECT_EQ(CommandUtils::getCommandType("info"), CommandType::Info);
+ EXPECT_EQ(CommandUtils::getCommandType("diff"), CommandType::Diff);
+ EXPECT_EQ(CommandUtils::getCommandType("makedict"), CommandType::Makedict);
+ EXPECT_EQ(CommandUtils::getCommandType("header"), CommandType::Header);
+ EXPECT_EQ(CommandUtils::getCommandType("help"), CommandType::Help);
+}
+
+} // namespace
+} // namespace dicttoolkit
+} // namespace latinime
diff --git a/native/dicttoolkit/tests/utils/utf8_utils_test.cpp b/native/dicttoolkit/tests/utils/utf8_utils_test.cpp
new file mode 100644
index 000000000..9c59a8b05
--- /dev/null
+++ b/native/dicttoolkit/tests/utils/utf8_utils_test.cpp
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * 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 "utils/utf8_utils.h"
+
+#include <gtest/gtest.h>
+
+#include <vector>
+
+#include "utils/int_array_view.h"
+
+namespace latinime {
+namespace dicttoolkit {
+namespace {
+
+TEST(Utf8UtilsTests, TestGetCodePoints) {
+ {
+ const std::vector<int> codePoints = Utf8Utils::getCodePoints("");
+ EXPECT_EQ(0u, codePoints.size());
+ }
+ {
+ const std::vector<int> codePoints = Utf8Utils::getCodePoints("test");
+ EXPECT_EQ(4u, codePoints.size());
+ EXPECT_EQ('t', codePoints[0]);
+ EXPECT_EQ('e', codePoints[1]);
+ EXPECT_EQ('s', codePoints[2]);
+ EXPECT_EQ('t', codePoints[3]);
+ }
+ {
+ const std::vector<int> codePoints = Utf8Utils::getCodePoints(u8"\u3042a\u03C2\u0410");
+ EXPECT_EQ(4u, codePoints.size());
+ EXPECT_EQ(0x3042, codePoints[0]); // HIRAGANA LETTER A
+ EXPECT_EQ('a', codePoints[1]);
+ EXPECT_EQ(0x03C2, codePoints[2]); // CYRILLIC CAPITAL LETTER A
+ EXPECT_EQ(0x0410, codePoints[3]); // GREEK SMALL LETTER FINAL SIGMA
+ }
+ {
+ const std::vector<int> codePoints = Utf8Utils::getCodePoints(u8"\U0001F36A?\U0001F752");
+ EXPECT_EQ(3u, codePoints.size());
+ EXPECT_EQ(0x1F36A, codePoints[0]); // COOKIE
+ EXPECT_EQ('?', codePoints[1]);
+ EXPECT_EQ(0x1F752, codePoints[2]); // ALCHEMICAL SYMBOL FOR STARRED TRIDENT
+ }
+
+ // Redundant UTF-8 sequences must be rejected.
+ EXPECT_TRUE(Utf8Utils::getCodePoints("\xC0\xAF").empty());
+ EXPECT_TRUE(Utf8Utils::getCodePoints("\xE0\x80\xAF").empty());
+ EXPECT_TRUE(Utf8Utils::getCodePoints("\xF0\x80\x80\xAF").empty());
+}
+
+TEST(Utf8UtilsTests, TestGetUtf8String) {
+ {
+ const std::vector<int> codePoints = {'t', 'e', 's', 't'};
+ EXPECT_EQ("test", Utf8Utils::getUtf8String(CodePointArrayView(codePoints)));
+ }
+ {
+ const std::vector<int> codePoints = {
+ 0x00E0 /* LATIN SMALL LETTER A WITH GRAVE */,
+ 0x03C2 /* GREEK SMALL LETTER FINAL SIGMA */,
+ 0x0430 /* CYRILLIC SMALL LETTER A */,
+ 0x3042 /* HIRAGANA LETTER A */,
+ 0x1F36A /* COOKIE */,
+ 0x1F752 /* ALCHEMICAL SYMBOL FOR STARRED TRIDENT */
+ };
+ EXPECT_EQ(u8"\u00E0\u03C2\u0430\u3042\U0001F36A\U0001F752",
+ Utf8Utils::getUtf8String(CodePointArrayView(codePoints)));
+ }
+}
+
+} // namespace
+} // namespace dicttoolkit
+} // namespace latinime
generated by cgit v1.2.3-83-g751a (git 2.47.1) at 2025-05-05 09:38:12 +0000