summaryrefslogtreecommitdiffstats
path: root/tests/src
diff options
context:
space:
mode:
Diffstat (limited to 'tests/src')
-rw-r--r--tests/src/baseline-tests.cpp115
-rw-r--r--tests/src/compare-files.cpp126
-rw-r--r--tests/src/exception-tests.cpp331
-rw-r--r--tests/src/g10-compat-tests.cpp51
-rw-r--r--tests/src/g23-compat-tests.cpp139
-rw-r--r--tests/src/g23-exception-tests.cpp108
-rw-r--r--tests/src/primitives-tests.cpp394
7 files changed, 1264 insertions, 0 deletions
diff --git a/tests/src/baseline-tests.cpp b/tests/src/baseline-tests.cpp
new file mode 100644
index 0000000..bbd59a4
--- /dev/null
+++ b/tests/src/baseline-tests.cpp
@@ -0,0 +1,115 @@
+/**
+ *
+ * Copyright 2021-2023 Ribose Inc. (https://www.ribose.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include "sexp-tests.h"
+
+using namespace sexp;
+using ::testing::UnitTest;
+
+namespace {
+class BaselineTests : public testing::Test {
+ protected:
+ static const uint32_t base_sample_advanced = 0;
+ static const uint32_t base_sample_base64 = 1;
+ static const uint32_t base_sample_canonical = 2;
+ static const uint32_t n_base_samples = base_sample_canonical + 1;
+
+ static std::string base_samples[n_base_samples];
+
+ BaselineTests()
+ {
+ base_samples[base_sample_advanced] = sexp_samples_folder + "/baseline/sexp-sample-a";
+ base_samples[base_sample_base64] = sexp_samples_folder + "/baseline/sexp-sample-b";
+ base_samples[base_sample_canonical] = sexp_samples_folder + "/baseline/sexp-sample-c";
+ };
+};
+
+const uint32_t BaselineTests::n_base_samples;
+const uint32_t BaselineTests::base_sample_advanced;
+const uint32_t BaselineTests::base_sample_base64;
+const uint32_t BaselineTests::base_sample_canonical;
+std::string BaselineTests::base_samples[n_base_samples];
+
+TEST_F(BaselineTests, Scan2Canonical)
+{
+ for (uint32_t i = 0; i < n_base_samples; i++) {
+ std::ifstream ifs(base_samples[i], std::ifstream::binary);
+ bool r = ifs.fail();
+ EXPECT_FALSE(r);
+
+ if (!ifs.fail()) {
+ sexp_input_stream_t is(&ifs);
+ const auto obj = is.set_byte_size(8)->get_char()->scan_object();
+
+ std::ostringstream oss(std::ios_base::binary);
+ sexp_output_stream_t os(&oss);
+ os.print_canonical(obj);
+
+ std::istringstream iss(oss.str(), std::ios_base::binary);
+ EXPECT_TRUE(compare_binary_files(base_samples[base_sample_canonical], iss));
+ }
+ }
+}
+
+TEST_F(BaselineTests, Scan2Base64)
+{
+ for (uint32_t i = 0; i < n_base_samples; i++) {
+ std::ifstream ifs(base_samples[i], std::ifstream::binary);
+ EXPECT_FALSE(ifs.fail());
+
+ if (!ifs.fail()) {
+ sexp_input_stream_t is(&ifs);
+ const auto obj = is.set_byte_size(8)->get_char()->scan_object();
+
+ std::ostringstream oss(std::ios_base::binary);
+ sexp_output_stream_t os(&oss);
+
+ os.set_max_column(0)->print_base64(obj);
+ oss << std::endl;
+
+ std::istringstream iss(oss.str(), std::ios_base::binary);
+ EXPECT_TRUE(compare_text_files(base_samples[base_sample_base64], iss));
+ }
+ }
+}
+
+TEST_F(BaselineTests, Scan2Advanced)
+{
+ for (uint32_t i = 0; i < n_base_samples; i++) {
+ std::ifstream ifs(base_samples[i], std::ifstream::binary);
+ EXPECT_FALSE(ifs.fail());
+
+ if (!ifs.fail()) {
+ sexp_input_stream_t is(&ifs);
+ const auto obj = is.set_byte_size(8)->get_char()->scan_object();
+
+ std::ostringstream oss(std::ios_base::binary);
+ sexp_output_stream_t os(&oss);
+ os.print_advanced(obj);
+
+ std::istringstream iss(oss.str(), std::ios_base::binary);
+ EXPECT_TRUE(compare_text_files(base_samples[base_sample_advanced], iss));
+ }
+ }
+}
+} // namespace
diff --git a/tests/src/compare-files.cpp b/tests/src/compare-files.cpp
new file mode 100644
index 0000000..49caec5
--- /dev/null
+++ b/tests/src/compare-files.cpp
@@ -0,0 +1,126 @@
+/**
+ *
+ * Copyright 2021-2023 Ribose Inc. (https://www.ribose.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include <algorithm>
+#include <fstream>
+
+#include "sexp-tests.h"
+
+bool compare_binary_files(const std::string &filename1, const std::string &filename2)
+{
+ bool res = false;
+ std::ifstream file1(filename1, std::ifstream::ate | std::ifstream::binary);
+ std::ifstream file2(filename2, std::ifstream::ate | std::ifstream::binary);
+
+ if (file1.tellg() == file2.tellg()) { // otherwise different file size
+ file1.seekg(0);
+ file2.seekg(0);
+
+ std::istreambuf_iterator<char> begin1(file1);
+ std::istreambuf_iterator<char> begin2(file2);
+
+ res = std::equal(begin1, std::istreambuf_iterator<char>(), begin2);
+ }
+
+ return res;
+}
+
+bool compare_binary_files(const std::string &filename1, std::istream &file2)
+{
+ std::ifstream file1(filename1, std::ifstream::binary);
+
+ std::istreambuf_iterator<char> begin1(file1);
+ std::istreambuf_iterator<char> begin2(file2);
+ return std::equal(begin1, std::istreambuf_iterator<char>(), begin2);
+}
+
+std::istream &safe_get_line(std::istream &is, std::string &t)
+{
+ t.clear();
+
+ // The characters in the stream are read one-by-one using a std::streambuf.
+ // That is faster than reading them one-by-one using the std::istream.
+ // Code that uses streambuf this way must be guarded by a sentry object.
+ // The sentry object performs various tasks,
+ // such as thread synchronization and updating the stream state.
+
+ std::istream::sentry se(is, true);
+ std::streambuf * sb = is.rdbuf();
+
+ for (;;) {
+ int c = sb->sbumpc();
+ switch (c) {
+ case '\n':
+ return is;
+ case '\r':
+ if (sb->sgetc() == '\n')
+ sb->sbumpc();
+ return is;
+ case std::streambuf::traits_type::eof():
+ // Also handle the case when the last line has no line ending
+ if (t.empty())
+ is.setstate(std::ios::eofbit);
+ return is;
+ default:
+ t += (char) c;
+ }
+ }
+}
+
+bool compare_text_files(const std::string &filename1, const std::string &filename2)
+{
+ bool res = true;
+ std::ifstream file1(filename1, std::ifstream::binary);
+ std::ifstream file2(filename2, std::ifstream::binary);
+ std::string s1, s2;
+
+ while (res) {
+ if (file1.eof() && file2.eof())
+ break;
+ safe_get_line(file1, s1);
+ safe_get_line(file2, s2);
+ if (s1 != s2)
+ res = false;
+ }
+
+ return res;
+}
+
+bool compare_text_files(const std::string &filename1, std::istream &file2)
+{
+ bool res = true;
+ std::ifstream file1(filename1, std::ifstream::binary);
+ std::string s1, s2;
+ file2.seekg(0);
+
+ while (res) {
+ if (file1.eof() && file2.eof())
+ break;
+ safe_get_line(file1, s1);
+ safe_get_line(file2, s2);
+ if (s1 != s2)
+ res = false;
+ }
+
+ return res;
+}
diff --git a/tests/src/exception-tests.cpp b/tests/src/exception-tests.cpp
new file mode 100644
index 0000000..318b2b8
--- /dev/null
+++ b/tests/src/exception-tests.cpp
@@ -0,0 +1,331 @@
+/**
+ *
+ * Copyright 2021-2023 Ribose Inc. (https://www.ribose.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include "sexp-tests.h"
+
+using namespace sexp;
+
+namespace {
+class ExceptionTests : public testing::Test {
+ protected:
+ static void do_scan_with_exception(const char *str_in, const char *msg)
+ {
+ try {
+ std::istringstream iss(str_in);
+ sexp_input_stream_t is(&iss);
+ is.set_byte_size(8)->get_char()->scan_object();
+ FAIL() << "sexp::sexp_exception_t expected but has not been thrown";
+ } catch (sexp::sexp_exception_t &e) {
+ EXPECT_STREQ(e.what(), msg);
+ }
+ }
+};
+
+TEST_F(ExceptionTests, UnexpectedEof)
+{
+ do_scan_with_exception("(4:This2:is1:a4:test",
+ "SEXP ERROR: unexpected end of file at position 20");
+}
+
+TEST_F(ExceptionTests, UnexpectedCharacter4bit)
+{
+ do_scan_with_exception(
+ "(4:This2:is1:a4:test #)",
+ "SEXP ERROR: character ')' found in 4-bit coding region at position 22");
+}
+
+TEST_F(ExceptionTests, IllegalCharacter)
+{
+ do_scan_with_exception("(This is a test ?)",
+ "SEXP ERROR: illegal character '?' (0x3f) at position 16");
+}
+
+TEST_F(ExceptionTests, UnexpectedEofAfterQoute)
+{
+ do_scan_with_exception("(\")\n", "SEXP ERROR: unexpected end of file at position 4");
+}
+
+TEST_F(ExceptionTests, IllegalCharacterBase64)
+{
+ do_scan_with_exception("(Test {KDQ6VGhpczI6aXMxOmE0OnRlc3Qq})",
+ "SEXP ERROR: illegal character '}' (0x7d) at position 35");
+}
+
+TEST_F(ExceptionTests, InvalidHex)
+{
+ do_scan_with_exception("(\"\\x1U\")",
+ "SEXP ERROR: Hex character \\x1... too short at position 5");
+}
+
+TEST_F(ExceptionTests, InvalidOctal)
+{
+ do_scan_with_exception("(\"\\12U\")",
+ "SEXP ERROR: Octal character \\12... too short at position 5");
+}
+
+TEST_F(ExceptionTests, TooBigOctal)
+{
+ do_scan_with_exception("(\"\\666U\")",
+ "SEXP ERROR: Octal character \\666... too big at position 5");
+}
+
+TEST_F(ExceptionTests, InvalidEscape)
+{
+ do_scan_with_exception("(\"\\?\")",
+ "SEXP ERROR: Unknown escape sequence \\? at position 3");
+}
+
+TEST_F(ExceptionTests, StringTooShortQuoted)
+{
+ do_scan_with_exception(
+ "(4\"ABC\")",
+ "SEXP ERROR: Declared length was 4, but quoted string ended too early at position 6");
+}
+
+TEST_F(ExceptionTests, StringTooShortBase64)
+{
+ sexp::sexp_exception_t::set_verbosity(sexp::sexp_exception_t::warning);
+ do_scan_with_exception("(8|NDpBQkNE|)",
+ "SEXP WARNING: Base64 string has length 6 different than declared "
+ "length 8 at position 12");
+ sexp::sexp_exception_t::set_verbosity(sexp::sexp_exception_t::error);
+}
+
+TEST_F(ExceptionTests, StringTooShortHex)
+{
+ sexp::sexp_exception_t::set_verbosity(sexp::sexp_exception_t::warning);
+ do_scan_with_exception(
+ "(8#AAABFCAD#)",
+ "SEXP WARNING: Hex string has length 4 different than declared length 8 at position 12");
+ sexp::sexp_exception_t::set_verbosity(sexp::sexp_exception_t::error);
+}
+
+TEST_F(ExceptionTests, StringBadLength)
+{
+ do_scan_with_exception("(1A:AAABFCAD)",
+ "SEXP ERROR: illegal character 'A' (0x41) at position 2");
+}
+
+TEST_F(ExceptionTests, DecimalTooLong)
+{
+ do_scan_with_exception("(1234567890:AAABFCAD)",
+ "SEXP ERROR: Decimal number is too long at position 11");
+}
+
+TEST_F(ExceptionTests, Base64CurlyBracket)
+{
+ // "ey..." in base64 encoding translates to "{..."
+ do_scan_with_exception("({ey})", "SEXP ERROR: illegal character '{' (0x7b) at position 3");
+}
+
+TEST_F(ExceptionTests, UnusedBits)
+{
+ sexp::sexp_exception_t::set_verbosity(sexp::sexp_exception_t::warning);
+ do_scan_with_exception(
+ "(Test |AABBCCDD11|)",
+ "SEXP WARNING: 6-bit region ended with 4 unused bits left-over at position 17");
+ sexp::sexp_exception_t::set_verbosity(sexp::sexp_exception_t::error);
+}
+
+TEST_F(ExceptionTests, NotAListWhenExpected)
+{
+ try {
+ std::istringstream iss(
+ "|d738/4ghP9rFZ0gAIYZ5q9y6iskDJwASi5rEQpEQq8ZyMZeIZzIAR2I5iGE=|");
+ sexp_input_stream_t is(&iss);
+
+ sexp_list_t a_list;
+ a_list.parse(is.set_byte_size(8)->get_char());
+ FAIL() << "sexp::sexp_exception_t expected but has not been thrown";
+ } catch (sexp::sexp_exception_t &e) {
+ EXPECT_STREQ(e.what(),
+ "SEXP ERROR: character '|' found where '(' was expected at position 0");
+ }
+}
+
+TEST_F(ExceptionTests, InvalidByteSizeAndMode)
+{
+ try {
+ std::istringstream iss("(3:a\011c)");
+ sexp_input_stream_t is(&iss);
+ std::shared_ptr<sexp_object_t> obj = is.set_byte_size(8)->get_char()->scan_object();
+
+ std::ostringstream oss(std::ios_base::binary);
+ sexp_output_stream_t os(&oss);
+ os.change_output_byte_size(4, sexp_output_stream_t::advanced)->print_advanced(obj);
+ FAIL() << "sexp::sexp_exception_t expected but has not been thrown";
+ } catch (sexp::sexp_exception_t &e) {
+ EXPECT_STREQ(
+ e.what(),
+ "SEXP ERROR: Can't print in advanced mode with restricted output character set");
+ }
+}
+
+TEST_F(ExceptionTests, SexpWarning)
+{
+ testing::internal::CaptureStdout();
+ sexp::sexp_exception_t::set_interactive(true);
+ sexp_error(sexp_exception_t::warning, "Test warning", 0, 0, 200);
+ std::string output = testing::internal::GetCapturedStdout();
+ EXPECT_EQ(output, "\n*** SEXP WARNING: Test warning at position 200 ***\n");
+ sexp::sexp_exception_t::set_interactive(false);
+}
+
+static void do_parse_list_from_string(const char *str)
+{
+ std::istringstream iss(str);
+ sexp_input_stream_t is(&iss);
+ sexp_list_t lst;
+ lst.parse(is.set_byte_size(8)->get_char());
+}
+
+static void do_parse_list_from_string_with_limit(const char *str, size_t m_depth)
+{
+ std::istringstream iss(str);
+ sexp_input_stream_t is(&iss, m_depth);
+ sexp_list_t lst;
+ lst.parse(is.set_byte_size(8)->get_char());
+}
+
+TEST_F(ExceptionTests, MaxDepthParse)
+{
+ const char *depth_1 = "(sexp_list_1)";
+ const char *depth_4 = "(sexp_list_1 (sexp_list_2 (sexp_list_3 (sexp_list_4))))";
+ const char *depth_4e = "(sexp_list_1 (sexp_list_2 (sexp_list_3 ())))";
+ const char *depth_5 =
+ "(sexp_list_1 (sexp_list_2 (sexp_list_3 (sexp_list_4 (sexp_list_5)))))";
+ const char *depth_5e = "(sexp_list_1 (sexp_list_2 (sexp_list_3 (sexp_list_4 ()))))";
+
+ do_parse_list_from_string(depth_1);
+ do_parse_list_from_string(depth_4);
+ do_parse_list_from_string(depth_4e);
+ do_parse_list_from_string(depth_5);
+ do_parse_list_from_string(depth_5e);
+
+ do_parse_list_from_string_with_limit(depth_1, 4);
+ do_parse_list_from_string_with_limit(depth_4, 4);
+ do_parse_list_from_string_with_limit(depth_4e, 4);
+
+ try {
+ do_parse_list_from_string_with_limit(depth_5, 4);
+ FAIL() << "sexp::sexp_exception_t expected but has not been thrown";
+ } catch (sexp::sexp_exception_t &e) {
+ EXPECT_STREQ(
+ e.what(),
+ "SEXP ERROR: Maximum allowed SEXP list depth (4) is exceeded at position 53");
+ }
+
+ try {
+ do_parse_list_from_string_with_limit(depth_5e, 4);
+ FAIL() << "sexp::sexp_exception_t expected but has not been thrown";
+ } catch (sexp::sexp_exception_t &e) {
+ EXPECT_STREQ(
+ e.what(),
+ "SEXP ERROR: Maximum allowed SEXP list depth (4) is exceeded at position 53");
+ }
+}
+
+static void do_print_list_from_string(const char *str, bool advanced, size_t m_depth = 0)
+{
+ std::istringstream iss(str);
+ sexp_input_stream_t is(&iss);
+ sexp_list_t lst;
+ lst.parse(is.set_byte_size(8)->get_char());
+
+ std::ostringstream oss(str);
+ sexp_output_stream_t os(&oss, m_depth);
+ if (advanced)
+ lst.print_advanced(&os);
+ else
+ lst.print_canonical(&os);
+}
+
+TEST_F(ExceptionTests, MaxDepthPrintAdvanced)
+{
+ const char *depth_1 = "(sexp_list_1)";
+ const char *depth_4 = "(sexp_list_1 (sexp_list_2 (sexp_list_3 (sexp_list_4))))";
+ const char *depth_4e = "(sexp_list_1 (sexp_list_2 (sexp_list_3 ())))";
+ const char *depth_5 =
+ "(sexp_list_1 (sexp_list_2 (sexp_list_3 (sexp_list_4 (sexp_list_5)))))";
+ const char *depth_5e = "(sexp_list_1 (sexp_list_2 (sexp_list_3 (sexp_list_4 ()))))";
+
+ do_print_list_from_string(depth_1, true);
+ do_print_list_from_string(depth_4, true);
+ do_print_list_from_string(depth_4e, true);
+ do_print_list_from_string(depth_5, true);
+ do_print_list_from_string(depth_5e, true);
+
+ do_print_list_from_string(depth_1, true, 4);
+ do_print_list_from_string(depth_4, true, 4);
+ do_print_list_from_string(depth_4e, true, 4);
+
+ try {
+ do_print_list_from_string(depth_5, true, 4);
+ FAIL() << "sexp::sexp_exception_t expected but has not been thrown";
+ } catch (sexp::sexp_exception_t &e) {
+ EXPECT_STREQ(e.what(), "SEXP ERROR: Maximum allowed SEXP list depth (4) is exceeded");
+ }
+
+ try {
+ do_print_list_from_string(depth_5e, true, 4);
+ FAIL() << "sexp::sexp_exception_t expected but has not been thrown";
+ } catch (sexp::sexp_exception_t &e) {
+ EXPECT_STREQ(e.what(), "SEXP ERROR: Maximum allowed SEXP list depth (4) is exceeded");
+ }
+}
+
+TEST_F(ExceptionTests, MaxDepthPrintCanonical)
+{
+ const char *depth_1 = "(sexp_list_1)";
+ const char *depth_4 = "(sexp_list_1 (sexp_list_2 (sexp_list_3 (sexp_list_4))))";
+ const char *depth_4e = "(sexp_list_1 (sexp_list_2 (sexp_list_3 ())))";
+ const char *depth_5 =
+ "(sexp_list_1 (sexp_list_2 (sexp_list_3 (sexp_list_4 (sexp_list_5)))))";
+ const char *depth_5e = "(sexp_list_1 (sexp_list_2 (sexp_list_3 (sexp_list_4 ()))))";
+
+ do_print_list_from_string(depth_1, false);
+ do_print_list_from_string(depth_4, false);
+ do_print_list_from_string(depth_4e, false);
+ do_print_list_from_string(depth_5, false);
+ do_print_list_from_string(depth_5e, false);
+
+ do_print_list_from_string(depth_1, false, 4);
+ do_print_list_from_string(depth_4, false, 4);
+ do_print_list_from_string(depth_4e, false, 4);
+
+ try {
+ do_print_list_from_string(depth_5, false, 4);
+ FAIL() << "sexp::sexp_exception_t expected but has not been thrown";
+ } catch (sexp::sexp_exception_t &e) {
+ EXPECT_STREQ(e.what(), "SEXP ERROR: Maximum allowed SEXP list depth (4) is exceeded");
+ }
+
+ try {
+ do_print_list_from_string(depth_5e, false, 4);
+ FAIL() << "sexp::sexp_exception_t expected but has not been thrown";
+ } catch (sexp::sexp_exception_t &e) {
+ EXPECT_STREQ(e.what(), "SEXP ERROR: Maximum allowed SEXP list depth (4) is exceeded");
+ }
+}
+
+} // namespace
diff --git a/tests/src/g10-compat-tests.cpp b/tests/src/g10-compat-tests.cpp
new file mode 100644
index 0000000..62f1180
--- /dev/null
+++ b/tests/src/g10-compat-tests.cpp
@@ -0,0 +1,51 @@
+/**
+ *
+ * Copyright 2021-2023 Ribose Inc. (https://www.ribose.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include "sexp-tests.h"
+
+using namespace sexp;
+
+namespace {
+class G10CompatTests : public testing::Test {
+};
+
+TEST_F(G10CompatTests, Canonical)
+{
+ std::string keyfile(sexp_samples_folder + "/compat/g10/canonical.key");
+ std::ifstream ifs(keyfile, std::ifstream::binary);
+ EXPECT_FALSE(ifs.fail());
+
+ if (!ifs.fail()) {
+ sexp_input_stream_t is(&ifs);
+ const auto obj = is.set_byte_size(8)->get_char()->scan_object();
+
+ std::ostringstream oss(std::ios_base::binary);
+ sexp_output_stream_t os(&oss);
+ os.print_canonical(obj);
+
+ std::istringstream iss(oss.str(), std::ios_base::binary);
+ EXPECT_TRUE(compare_binary_files(keyfile, iss));
+ }
+}
+
+} // namespace
diff --git a/tests/src/g23-compat-tests.cpp b/tests/src/g23-compat-tests.cpp
new file mode 100644
index 0000000..3a2e756
--- /dev/null
+++ b/tests/src/g23-compat-tests.cpp
@@ -0,0 +1,139 @@
+/**
+ *
+ * Copyright 2021-2023 Ribose Inc. (https://www.ribose.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include "sexp-tests.h"
+#include "sexpp/ext-key-format.h"
+
+using namespace sexp;
+using namespace ext_key_format;
+
+using ::testing::UnitTest;
+
+namespace {
+class G23CompatTests : public testing::Test {
+ protected:
+ static void scan_and_check_correct(const char *fn)
+ {
+ std::ifstream ifs(sexp_samples_folder + "/compat/g23/" + fn, std::ifstream::binary);
+ bool r = ifs.fail();
+ EXPECT_FALSE(r);
+
+ if (!ifs.fail()) {
+ ext_key_input_stream_t is(&ifs);
+ extended_private_key_t extended_key;
+ is.scan(extended_key);
+ EXPECT_EQ(extended_key.fields.size(), 2);
+ EXPECT_EQ(extended_key.fields.count("Created"), 1);
+ EXPECT_EQ(extended_key.fields.count("creaTed"), 1);
+ EXPECT_EQ(extended_key.fields.count("something"), 0);
+
+ auto search = extended_key.fields.find("Created");
+ if (search != extended_key.fields.end()) {
+ EXPECT_EQ(search->second, "20221130T160847");
+ }
+ }
+ }
+};
+
+TEST_F(G23CompatTests, G10Test)
+{
+ std::ifstream ifs(sexp_samples_folder + "/compat/g10/canonical.key",
+ std::ifstream::binary);
+ bool r = ifs.fail();
+ EXPECT_FALSE(r);
+
+ if (!ifs.fail()) {
+ ext_key_input_stream_t is(&ifs);
+ extended_private_key_t extended_key;
+ is.scan(extended_key);
+ EXPECT_EQ(extended_key.fields.size(), 0);
+ }
+}
+
+// Correct extended key format
+TEST_F(G23CompatTests, G23Correct)
+{
+ scan_and_check_correct("correct.key");
+}
+
+// Correct extended key format, no terminating end of line
+TEST_F(G23CompatTests, G23CorrectNoEol)
+{
+ scan_and_check_correct("correct_no_eol.key");
+}
+
+// Correct extended key format, with a comment
+TEST_F(G23CompatTests, G23CorrectWithComment)
+{
+ scan_and_check_correct("correct_with_comment.key");
+}
+
+// Correct extended key format, with an empty line (which is comment a well)
+TEST_F(G23CompatTests, G23CorrectWithTwoEmptyLines)
+{
+ scan_and_check_correct("correct_with_two_empty_lines.key");
+}
+
+// Correct extended key format, with two empty linea
+TEST_F(G23CompatTests, G23CorrectWithEmptyLine)
+{
+ scan_and_check_correct("correct_with_empty_line.key");
+}
+
+// Correct extended key format, witg windows line endings
+TEST_F(G23CompatTests, G23CorrectWithWindowsEol)
+{
+ scan_and_check_correct("correct_with_windows_eol.key");
+}
+
+// Correct extended key format, with a comment at the end of file
+TEST_F(G23CompatTests, G23CorrectWithCommentAtEof)
+{
+ scan_and_check_correct("correct_with_comment_at_eof.key");
+}
+
+// Correct extended key format, with multiple fields of the same name
+TEST_F(G23CompatTests, G23CorrectWithMultFields)
+{
+ std::ifstream ifs(sexp_samples_folder + "/compat/g23/correct_mult_fields.key",
+ std::ifstream::binary);
+ bool r = ifs.fail();
+ EXPECT_FALSE(r);
+
+ if (!ifs.fail()) {
+ ext_key_input_stream_t is(&ifs);
+ extended_private_key_t extended_key;
+ extended_key.parse(is);
+ EXPECT_EQ(extended_key.fields.size(), 4);
+ EXPECT_EQ(extended_key.fields.count("Created"), 1);
+ EXPECT_EQ(extended_key.fields.count("Description"), 3);
+ EXPECT_EQ(extended_key.fields.count("something"), 0);
+
+ auto search = extended_key.fields.find("Description");
+ if (search != extended_key.fields.end()) {
+ EXPECT_EQ(search->second, "RSA/RSA");
+ }
+ }
+}
+
+} // namespace
diff --git a/tests/src/g23-exception-tests.cpp b/tests/src/g23-exception-tests.cpp
new file mode 100644
index 0000000..4f4413d
--- /dev/null
+++ b/tests/src/g23-exception-tests.cpp
@@ -0,0 +1,108 @@
+/**
+ *
+ * Copyright 2021-2023 Ribose Inc. (https://www.ribose.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include "sexp-tests.h"
+#include "sexpp/ext-key-format.h"
+
+using namespace sexp;
+using namespace ext_key_format;
+
+using ::testing::UnitTest;
+
+namespace {
+class G23ExceptionTests : public testing::Test {
+ protected:
+ static void do_scan_ex(const char *fn, const char *msg)
+ {
+ std::ifstream ifs(sexp_samples_folder + "/compat/g23/" + fn, std::ifstream::binary);
+ EXPECT_FALSE(ifs.fail());
+ if (!ifs.fail()) {
+ try {
+ ext_key_input_stream_t is(&ifs);
+ extended_private_key_t extended_key;
+ is.scan(extended_key);
+ FAIL() << "sexp::sexp_exception_t expected but has not been thrown";
+ } catch (sexp::sexp_exception_t &e) {
+ EXPECT_STREQ(e.what(), msg);
+ }
+ }
+ }
+};
+
+// Malformed extended key format, line break inside name
+TEST_F(G23ExceptionTests, G23MalformedNameBreak)
+{
+ do_scan_ex("malformed_name_break.key",
+ "EXTENDED KEY FORMAT ERROR: unexpected end of line at position 5");
+}
+
+// Malformed extended key format, eof break inside name
+TEST_F(G23ExceptionTests, G23MalformedNameEof)
+{
+ do_scan_ex("malformed_name_eof.key",
+ "EXTENDED KEY FORMAT ERROR: unexpected end of file at position 2800");
+}
+
+// Malformed extended key format, invalid character name
+TEST_F(G23ExceptionTests, G23MalformedInvalidNameChar)
+{
+ do_scan_ex(
+ "malformed_invalid_name_char.key",
+ "EXTENDED KEY FORMAT ERROR: unexpected character '@' (0x40) found in a name field "
+ "at position 28");
+}
+
+// Malformed extended key format, invalid character name
+TEST_F(G23ExceptionTests, G23MalformedInvalidNameFirstChar)
+{
+ do_scan_ex(
+ "malformed_invalid_name_first_char.key",
+ "EXTENDED KEY FORMAT ERROR: unexpected character '1' (0x31) found starting a name field "
+ "at position 21");
+}
+
+// Malformed extended key format, no key field
+TEST_F(G23ExceptionTests, G23MalformedNoKey)
+{
+ do_scan_ex("malformed_no_key.key",
+ "EXTENDED KEY FORMAT ERROR: missing mandatory 'key' field at position 2819");
+}
+
+// Malformed extended key format, two key fields
+TEST_F(G23ExceptionTests, G23MalformedTwoKeys)
+{
+ do_scan_ex("malformed_two_keys.key",
+ "EXTENDED KEY FORMAT ERROR: 'key' field must occur only once at position 2822");
+}
+
+TEST_F(G23ExceptionTests, G23Warning)
+{
+ testing::internal::CaptureStdout();
+ sexp::sexp_exception_t::set_interactive(true);
+ ext_key_error(sexp_exception_t::warning, "Test warning", 0, 0, 200);
+ std::string output = testing::internal::GetCapturedStdout();
+ EXPECT_EQ(output, "\n*** EXTENDED KEY FORMAT WARNING: Test warning at position 200 ***\n");
+ sexp::sexp_exception_t::set_interactive(false);
+}
+
+} // namespace
diff --git a/tests/src/primitives-tests.cpp b/tests/src/primitives-tests.cpp
new file mode 100644
index 0000000..0689d27
--- /dev/null
+++ b/tests/src/primitives-tests.cpp
@@ -0,0 +1,394 @@
+/**
+ *
+ * Copyright 2021-2023 Ribose Inc. (https://www.ribose.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include "sexp-tests.h"
+
+using namespace sexp;
+
+namespace {
+class PrimitivesTests : public testing::Test {
+ protected:
+ static void do_test_advanced(const char *str_in, const char *str_out = nullptr)
+ {
+ std::istringstream iss(str_in);
+ sexp_input_stream_t is(&iss);
+ const auto obj = is.set_byte_size(8)->get_char()->scan_object();
+
+ std::ostringstream oss(std::ios_base::binary);
+ sexp_output_stream_t os(&oss);
+ os.print_advanced(obj);
+ const char *sample = str_out == nullptr ? str_in : str_out;
+ EXPECT_EQ(oss.str(), sample);
+ }
+
+ static void do_test_canonical(const char *str_in, const char *str_out = nullptr)
+ {
+ std::istringstream iss(str_in);
+ sexp_input_stream_t is(&iss);
+ const auto obj = is.set_byte_size(8)->get_char()->scan_object();
+
+ std::ostringstream oss(std::ios_base::binary);
+ sexp_output_stream_t os(&oss);
+ os.print_canonical(obj);
+ const char *sample = str_out == nullptr ? str_in : str_out;
+ EXPECT_EQ(oss.str(), sample);
+ }
+};
+
+TEST_F(PrimitivesTests, EmptyList)
+{
+ do_test_canonical("( )", "()");
+ do_test_advanced("( )", "()");
+}
+
+TEST_F(PrimitivesTests, EmptyString)
+{
+ sexp::sexp_exception_t::set_verbosity(sexp::sexp_exception_t::error);
+ do_test_canonical("(\"\")", "(0:)");
+ do_test_advanced("(\"\")", "(\"\")");
+}
+
+TEST_F(PrimitivesTests, String)
+{
+ sexp::sexp_exception_t::set_verbosity(sexp::sexp_exception_t::error);
+ do_test_canonical("(ab)", "(2:ab)");
+ do_test_advanced("(ab)", "(ab)");
+}
+
+TEST_F(PrimitivesTests, QuotedStringWithOctal)
+{
+ sexp::sexp_exception_t::set_verbosity(sexp::sexp_exception_t::error);
+ do_test_canonical("\"ab\\015\"", "3:ab\r");
+ do_test_advanced("\"ab\\015\"", "#61620D#");
+}
+
+TEST_F(PrimitivesTests, QuotedStringWithEscape)
+{
+ sexp::sexp_exception_t::set_verbosity(sexp::sexp_exception_t::error);
+ do_test_canonical("\"ab\\tc\"", "4:ab\tc");
+ do_test_advanced("4:ab\tc", "#61620963#");
+}
+
+TEST_F(PrimitivesTests, HexString)
+{
+ sexp::sexp_exception_t::set_verbosity(sexp::sexp_exception_t::error);
+ do_test_canonical("#616263#", "3:abc");
+ do_test_advanced("#616263#", "abc");
+}
+
+TEST_F(PrimitivesTests, ListList)
+{
+ do_test_canonical("(string-level-1 (string-level-2) )",
+ "(14:string-level-1(14:string-level-2))");
+ do_test_advanced("(string-level-1 (string-level-2) )",
+ "(string-level-1 (string-level-2))");
+}
+
+TEST_F(PrimitivesTests, Base64Ofoctet_t)
+{
+ do_test_canonical("|YWJj|", "3:abc");
+ do_test_advanced("|YWJj|", "abc");
+}
+
+TEST_F(PrimitivesTests, Base64OfVerbatium)
+{
+ do_test_canonical("{MzphYmM=}", "3:abc");
+ do_test_advanced("{MzphYmM=}", "abc");
+}
+
+TEST_F(PrimitivesTests, MultilineLinux)
+{
+ do_test_canonical("\"abcd\\\nef\"", "6:abcdef");
+ do_test_advanced("\"abcd\\\nef\"", "abcdef");
+}
+
+TEST_F(PrimitivesTests, MultilineMac)
+{
+ do_test_canonical("\"abcd\\\ref\"", "6:abcdef");
+ do_test_advanced("\"abcd\\\ref\"", "abcdef");
+}
+
+TEST_F(PrimitivesTests, MultilineWin)
+{
+ do_test_canonical("\"abcd\\\r\nef\"", "6:abcdef");
+ do_test_advanced("\"abcd\\\r\nef\"", "abcdef");
+}
+
+TEST_F(PrimitivesTests, MultilineBsd)
+{
+ do_test_canonical("\"abcd\\\n\ref\"", "6:abcdef");
+ do_test_advanced("\"abcd\\\n\ref\"", "abcdef");
+}
+
+TEST_F(PrimitivesTests, Wrap)
+{
+ const char *reallyLong = "(a (b (c ddddddddddddddd"
+ "ddddddddddddddddddddddddddddddddddddddddddddddddd"
+ "ddddddddddddddddddddddddddddddddddddddddddddddddd"
+ "ddddddddddddddddddddddddddddddddddddddddddddddddd"
+ "ddddddd)))";
+ const char *stillLong = "(1:a(1:b(1:c169:ddddddddd"
+ "ddddddddddddddddddddddddddddddddddddddddddddddddd"
+ "ddddddddddddddddddddddddddddddddddddddddddddddddd"
+ "ddddddddddddddddddddddddddddddddddddddddddddddddd"
+ "ddddddddddddd)))";
+ const char *broken = "(a\n"
+ " (b\n"
+ " (c\n"
+ " "
+ "\"ddddddddddddddddddddddddddddddddddddddddddddddddddddd"
+ "dddddddddddddddd\\\n"
+ "ddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
+ "dddddddddddddddddd\\\n"
+ "ddddddddddddddddddddddddddd\")))";
+ do_test_canonical(reallyLong, stillLong);
+ do_test_advanced(reallyLong, broken);
+}
+
+TEST_F(PrimitivesTests, Escapes)
+{
+ do_test_canonical("(\"\\b\\t\\v\\n\\f\\r\\\"\\'\\\\\")", "(9:\b\t\v\n\f\r\"'\\)");
+ do_test_advanced("(\"\\b\\t\\v\\n\\f\\r\\\"\\'\\\\\")", "(|CAkLCgwNIidc|)");
+
+ do_test_canonical("(\"\\040\\041\\042\\043\\044\")", "(5: !\"#$)");
+ do_test_advanced("(\"\\065\\061\\062\\063\\064\")", "(\"51234\")");
+
+ do_test_canonical("(\"\\x40\\x41\\x42\\x43\\x44\")", "(5:@ABCD)");
+ do_test_advanced("(\"\\x65\\x61\\x62\\x63\\x64\")", "(eabcd)");
+}
+
+TEST_F(PrimitivesTests, at4rnp)
+{
+ const char *str_in = "(rnp_block (rnp_list1 rnp_list2))";
+
+ std::istringstream iss(str_in);
+ sexp_input_stream_t is(&iss);
+
+ sexp_list_t lst;
+ lst.parse(is.set_byte_size(8)->get_char());
+
+ EXPECT_EQ(lst.sexp_list_at(0), nullptr);
+ EXPECT_NE(lst.sexp_list_at(1), nullptr);
+
+ EXPECT_NE(lst.sexp_string_at(0), nullptr);
+ EXPECT_EQ(lst.sexp_string_at(1), nullptr);
+
+ const sexp_object_t *obj = lst.sexp_list_at(1);
+
+ if (obj != nullptr) {
+ EXPECT_EQ(obj->sexp_list_at(0), nullptr);
+ EXPECT_EQ(obj->sexp_list_at(1), nullptr);
+ }
+
+ const sexp_string_t *sstr = lst.sexp_string_at(0);
+ EXPECT_STREQ(reinterpret_cast<const char *>(sstr->get_string().c_str()), "rnp_block");
+}
+
+TEST_F(PrimitivesTests, eq4rnp)
+{
+ const char *str_in = "(rnp_block (rnp_list1 rnp_list2))";
+
+ std::istringstream iss(str_in);
+ sexp_input_stream_t is(&iss);
+
+ sexp_list_t lst;
+ lst.parse(is.set_byte_size(8)->get_char());
+
+ EXPECT_TRUE(*lst.at(0) == "rnp_block");
+ EXPECT_FALSE(*lst.at(0) == "not_rnp_block");
+ EXPECT_FALSE(*lst.at(1) == "rnp_block");
+ EXPECT_FALSE(*lst.at(1) == "not_rnp_block");
+
+ EXPECT_TRUE(*lst.sexp_string_at(0) == "rnp_block");
+ EXPECT_FALSE(*lst.sexp_string_at(0) == "not_rnp_block");
+ EXPECT_TRUE(*lst.sexp_simple_string_at(0) == "rnp_block");
+ EXPECT_FALSE(*lst.sexp_simple_string_at(0) == "not_rnp_block");
+
+ EXPECT_TRUE(*lst.sexp_list_at(1)->at(0) == "rnp_list1");
+ EXPECT_TRUE(*lst.sexp_list_at(1)->sexp_string_at(1) == "rnp_list2");
+
+ EXPECT_TRUE(lst.sexp_string_at(0) == std::string("rnp_block"));
+ EXPECT_FALSE(lst.sexp_string_at(0) == std::string("not_rnp_block"));
+ EXPECT_TRUE(lst.sexp_simple_string_at(0) == std::string("rnp_block"));
+ EXPECT_FALSE(lst.sexp_simple_string_at(0) == std::string("not_rnp_block"));
+}
+
+TEST_F(PrimitivesTests, ne4rnp)
+{
+ const char *str_in = "(rnp_block (rnp_list1 rnp_list2))";
+
+ std::istringstream iss(str_in);
+ sexp_input_stream_t is(&iss);
+
+ sexp_list_t lst;
+ lst.parse(is.set_byte_size(8)->get_char());
+
+ EXPECT_FALSE(*lst.at(0) != "rnp_block");
+ EXPECT_TRUE(*lst.at(0) != "not_rnp_block");
+ EXPECT_TRUE(*lst.at(1) != "rnp_block");
+ EXPECT_TRUE(*lst.at(1) != "not_rnp_block");
+
+ EXPECT_FALSE(*lst.sexp_string_at(0) != "rnp_block");
+ EXPECT_TRUE(*lst.sexp_string_at(0) != "not_rnp_block");
+ EXPECT_FALSE(*lst.sexp_simple_string_at(0) != "rnp_block");
+ EXPECT_TRUE(*lst.sexp_simple_string_at(0) != "not_rnp_block");
+
+ EXPECT_FALSE(*lst.sexp_list_at(1)->at(0) != "rnp_list1");
+ EXPECT_FALSE(*lst.sexp_list_at(1)->sexp_string_at(1) != "rnp_list2");
+
+ EXPECT_FALSE(lst.sexp_string_at(0) != std::string("rnp_block"));
+ EXPECT_TRUE(lst.sexp_string_at(0) != std::string("not_rnp_block"));
+ EXPECT_FALSE(lst.sexp_simple_string_at(0) != std::string("rnp_block"));
+ EXPECT_TRUE(lst.sexp_simple_string_at(0) != std::string("not_rnp_block"));
+}
+
+TEST_F(PrimitivesTests, u4rnp)
+{
+ const char *str_in1 = "(unsigned_value \"12345\")";
+ const char *str_in2 = "(14:unsigned_value5:54321)";
+
+ std::istringstream iss1(str_in1);
+ std::istringstream iss2(str_in2);
+
+ sexp_input_stream_t is(&iss1);
+ sexp_list_t lst;
+ lst.parse(is.set_byte_size(8)->get_char());
+ EXPECT_EQ(lst.sexp_string_at(1)->as_unsigned(), 12345);
+
+ lst.clear();
+ lst.parse(is.set_input(&iss2)->set_byte_size(8)->get_char());
+ EXPECT_EQ(lst.sexp_string_at(1)->as_unsigned(), 54321);
+}
+
+TEST_F(PrimitivesTests, proInheritance)
+{
+ sexp_list_t lst;
+ EXPECT_FALSE(lst.is_sexp_string());
+ EXPECT_TRUE(lst.is_sexp_list());
+ EXPECT_EQ(lst.sexp_string_view(), nullptr);
+ EXPECT_EQ(lst.sexp_list_view(), &lst);
+ EXPECT_EQ(lst.as_unsigned(), std::numeric_limits<uint32_t>::max());
+ EXPECT_EQ(lst.sexp_list_at(0), nullptr);
+ EXPECT_EQ(lst.sexp_string_at(0), nullptr);
+ EXPECT_EQ(lst.sexp_simple_string_at(0), nullptr);
+
+ sexp_string_t str;
+ EXPECT_FALSE(str.is_sexp_list());
+ EXPECT_TRUE(str.is_sexp_string());
+ EXPECT_EQ(str.sexp_string_view(), &str);
+ EXPECT_EQ(str.sexp_list_view(), nullptr);
+ EXPECT_EQ(str.sexp_list_at(0), nullptr);
+ EXPECT_EQ(str.sexp_string_at(0), nullptr);
+ EXPECT_EQ(str.sexp_simple_string_at(0), nullptr);
+}
+
+TEST_F(PrimitivesTests, DisplayHint)
+{
+ do_test_canonical("(URL [URI]www.ribose.com)", "(3:URL[3:URI]14:www.ribose.com)");
+ do_test_advanced("(3:URL[3:URI]14:www.ribose.com)", "(URL [URI]www.ribose.com)");
+}
+
+TEST_F(PrimitivesTests, scanToEof)
+{
+ const char *str_in = "ABCD";
+
+ std::istringstream iss(str_in);
+ sexp_input_stream_t is(&iss);
+
+ auto object = is.scan_to_eof();
+ EXPECT_TRUE(object->is_sexp_string());
+
+ is.set_byte_size(4);
+ EXPECT_EQ(is.get_byte_size(), 4);
+
+ EXPECT_EQ(is.get_char(), &is);
+ EXPECT_EQ(is.get_byte_size(), 8);
+}
+
+TEST_F(PrimitivesTests, ChangeOutputByteSizeTest)
+{
+ std::ostringstream oss(std::ios_base::binary);
+ sexp_output_stream_t os(&oss);
+
+ EXPECT_EQ(os.change_output_byte_size(8, sexp_output_stream_t::advanced), &os);
+
+ try {
+ os.change_output_byte_size(7, sexp_output_stream_t::advanced);
+ FAIL() << "sexp::sexp_exception_t expected but has not been thrown";
+ } catch (sexp::sexp_exception_t &e) {
+ EXPECT_STREQ(e.what(), "SEXP ERROR: Illegal output base 7");
+ }
+
+ EXPECT_EQ(os.change_output_byte_size(4, sexp_output_stream_t::advanced), &os);
+
+ try {
+ os.change_output_byte_size(6, sexp_output_stream_t::advanced);
+ FAIL() << "sexp::sexp_exception_t expected but has not been thrown";
+ } catch (sexp::sexp_exception_t &e) {
+ EXPECT_STREQ(e.what(), "SEXP ERROR: Illegal change of output byte size from 4 to 6");
+ }
+}
+
+TEST_F(PrimitivesTests, FlushTest)
+{
+ std::ostringstream oss1(std::ios_base::binary);
+ std::ostringstream oss2(std::ios_base::binary);
+ sexp_output_stream_t os(&oss1);
+
+ EXPECT_EQ(
+ os.change_output_byte_size(6, sexp_output_stream_t::advanced)->print_decimal(1)->flush(),
+ &os);
+ EXPECT_EQ(oss1.str(), "MQ==");
+ os.set_output(&oss2)
+ ->change_output_byte_size(6, sexp_output_stream_t::advanced)
+ ->set_max_column(2)
+ ->print_decimal(2)
+ ->flush();
+ EXPECT_EQ(oss2.str(), "Mg\n==");
+}
+
+TEST_F(PrimitivesTests, ListWrapTest)
+{
+ std::istringstream iss("(abc)");
+ sexp_input_stream_t is(&iss);
+ const auto obj = is.set_byte_size(8)->get_char()->scan_object();
+
+ std::ostringstream oss(std::ios_base::binary);
+ sexp_output_stream_t os(&oss);
+ os.set_max_column(5)->print_advanced(obj);
+ EXPECT_EQ(oss.str(), "(abc\n )");
+}
+
+TEST_F(PrimitivesTests, EnsureHexTest)
+{
+ std::istringstream iss("(3:a\011c)");
+ sexp_input_stream_t is(&iss);
+ const auto obj = is.set_byte_size(8)->get_char()->scan_object();
+
+ std::ostringstream oss(std::ios_base::binary);
+ sexp_output_stream_t os(&oss);
+ os.print_advanced(obj);
+ EXPECT_EQ(oss.str(), "(#610963#)");
+}
+
+} // namespace
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-03 14:22:50 +0000