intermediate changes

ref:cde9a383711a11544ce7e107a78147fb96cc4029

1 files changed, 256 insertions, 0 deletions

diff --git a/library/cpp/yson_pull/ut/writer_ut.cpp b/library/cpp/yson_pull/ut/writer_ut.cpp
new file mode 100644
index 0000000000..5c304bad0f
--- /dev/null
+++ b/library/cpp/yson_pull/ut/writer_ut.cpp
@@ -0,0 +1,256 @@
+#include <library/cpp/yson_pull/scalar.h>
+#include <library/cpp/yson_pull/detail/writer.h>
+
+#include <library/cpp/testing/unittest/registar.h>
+
+#include <util/generic/string.h>
+
+#include <climits>
+#include <limits>
+
+using namespace std::string_view_literals;
+
+namespace {
+    template <typename Writer, typename Function>
+    TString with_writer(Function&& function) {
+        TString result;
+        auto writer = NYsonPull::NDetail::make_writer<Writer>(
+            NYsonPull::NOutput::FromString(&result),
+            NYsonPull::EStreamType::Node);
+
+        function(writer);
+
+        return result;
+    }
+
+    template <typename Writer>
+    TString to_yson_string(const NYsonPull::TScalar& value) {
+        return with_writer<Writer>([&](NYsonPull::TWriter& writer) {
+            writer.BeginStream().Scalar(value).EndStream();
+        });
+    }
+
+    template <typename T>
+    TString to_yson_binary_string(T&& value) {
+        return to_yson_string<NYsonPull::NDetail::TBinaryWriterImpl>(std::forward<T>(value));
+    }
+
+    template <typename T>
+    TString to_yson_text_string(T&& value) {
+        return to_yson_string<NYsonPull::NDetail::TTextWriterImpl>(std::forward<T>(value));
+    }
+
+} // anonymous namespace
+
+// =================== Text format =====================
+
+Y_UNIT_TEST_SUITE(Writer) {
+    Y_UNIT_TEST(TextEntity) {
+        UNIT_ASSERT_VALUES_EQUAL(
+            "#",
+            to_yson_text_string(NYsonPull::TScalar{}));
+    }
+
+    Y_UNIT_TEST(TextBoolean) {
+        UNIT_ASSERT_VALUES_EQUAL(
+            "%false",
+            to_yson_text_string(NYsonPull::TScalar{false}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            "%true",
+            to_yson_text_string(NYsonPull::TScalar{true}));
+    }
+
+    Y_UNIT_TEST(TextInt64) {
+        UNIT_ASSERT_VALUES_EQUAL(
+            "0",
+            to_yson_text_string(NYsonPull::TScalar{i64{0}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            "200",
+            to_yson_text_string(NYsonPull::TScalar{i64{200}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            "20000",
+            to_yson_text_string(NYsonPull::TScalar{i64{20000}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            "200000000",
+            to_yson_text_string(NYsonPull::TScalar{i64{200000000}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            "20000000000000000",
+            to_yson_text_string(NYsonPull::TScalar{i64{20000000000000000}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            "9223372036854775807",
+            to_yson_text_string(NYsonPull::TScalar{i64{INT64_MAX}}));
+
+        UNIT_ASSERT_VALUES_EQUAL(
+            "-200",
+            to_yson_text_string(NYsonPull::TScalar{i64{-200}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            "-20000",
+            to_yson_text_string(NYsonPull::TScalar{i64{-20000}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            "-200000000",
+            to_yson_text_string(NYsonPull::TScalar{i64{-200000000}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            "-20000000000000000",
+            to_yson_text_string(NYsonPull::TScalar{i64{-20000000000000000}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            "-9223372036854775808",
+            to_yson_text_string(NYsonPull::TScalar{i64{INT64_MIN}}));
+    }
+
+    Y_UNIT_TEST(TextUInt64) {
+        UNIT_ASSERT_VALUES_EQUAL(
+            "0u",
+            to_yson_text_string(NYsonPull::TScalar{ui64{0}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            "200u",
+            to_yson_text_string(NYsonPull::TScalar{ui64{200}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            "20000u",
+            to_yson_text_string(NYsonPull::TScalar{ui64{20000}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            "200000000u",
+            to_yson_text_string(NYsonPull::TScalar{ui64{200000000}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            "20000000000000000u",
+            to_yson_text_string(NYsonPull::TScalar{ui64{20000000000000000}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            "9223372036854775807u",
+            to_yson_text_string(NYsonPull::TScalar{ui64{INT64_MAX}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            "18446744073709551615u",
+            to_yson_text_string(NYsonPull::TScalar{ui64{UINT64_MAX}}));
+    }
+
+    Y_UNIT_TEST(TextFloat64) {
+        UNIT_ASSERT_VALUES_EQUAL(
+            "%inf",
+            to_yson_text_string(NYsonPull::TScalar{std::numeric_limits<double>::infinity()}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            "%-inf",
+            to_yson_text_string(NYsonPull::TScalar{-std::numeric_limits<double>::infinity()}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            "%nan",
+            to_yson_text_string(NYsonPull::TScalar{std::numeric_limits<double>::quiet_NaN()}));
+    }
+
+    Y_UNIT_TEST(TextString) {
+        UNIT_ASSERT_VALUES_EQUAL(
+            R"("")",
+            to_yson_text_string(NYsonPull::TScalar{""}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            R"("hello")",
+            to_yson_text_string(NYsonPull::TScalar{"hello"}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            R"("hello\nworld")",
+            to_yson_text_string(NYsonPull::TScalar{"hello\nworld"}));
+    }
+
+    // =================== Binary format =====================
+
+    Y_UNIT_TEST(BinaryEntity) {
+        UNIT_ASSERT_VALUES_EQUAL(
+            "#",
+            to_yson_binary_string(NYsonPull::TScalar{}));
+    }
+
+    Y_UNIT_TEST(BinaryBoolean) {
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x4"),
+            to_yson_binary_string(NYsonPull::TScalar{false}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x5"),
+            to_yson_binary_string(NYsonPull::TScalar{true}));
+    }
+
+    Y_UNIT_TEST(BinaryInt64) {
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x2\0"sv),
+            to_yson_binary_string(NYsonPull::TScalar{i64{0}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x2\x90\x3"),
+            to_yson_binary_string(NYsonPull::TScalar{i64{200}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x2\xC0\xB8\x2"),
+            to_yson_binary_string(NYsonPull::TScalar{i64{20000}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x2\x80\x88\xDE\xBE\x1"),
+            to_yson_binary_string(NYsonPull::TScalar{i64{200000000}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x2\x80\x80\x90\xF8\x9B\xF9\x86G"),
+            to_yson_binary_string(NYsonPull::TScalar{i64{20000000000000000}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x2\xFE\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x1"),
+            to_yson_binary_string(NYsonPull::TScalar{i64{INT64_MAX}}));
+
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x2\x8F\x3"),
+            to_yson_binary_string(NYsonPull::TScalar{i64{-200}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x2\xBF\xB8\x2"),
+            to_yson_binary_string(NYsonPull::TScalar{i64{-20000}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x2\xFF\x87\xDE\xBE\x1"),
+            to_yson_binary_string(NYsonPull::TScalar{i64{-200000000}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x2\xFF\xFF\x8F\xF8\x9B\xF9\x86G"),
+            to_yson_binary_string(NYsonPull::TScalar{i64{-20000000000000000}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x2\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x1"),
+            to_yson_binary_string(NYsonPull::TScalar{i64{INT64_MIN}}));
+    }
+
+    Y_UNIT_TEST(BinaryUInt64) {
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x6\0"sv),
+            to_yson_binary_string(NYsonPull::TScalar{ui64{0}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x6\xC8\x1"),
+            to_yson_binary_string(NYsonPull::TScalar{ui64{200}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x6\xA0\x9C\x1"),
+            to_yson_binary_string(NYsonPull::TScalar{ui64{20000}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x6\x80\x84\xAF_"),
+            to_yson_binary_string(NYsonPull::TScalar{ui64{200000000}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x6\x80\x80\x88\xFC\xCD\xBC\xC3#"),
+            to_yson_binary_string(NYsonPull::TScalar{ui64{20000000000000000}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x6\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F"),
+            to_yson_binary_string(NYsonPull::TScalar{ui64{INT64_MAX}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x6\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x1"),
+            to_yson_binary_string(NYsonPull::TScalar{ui64{UINT64_MAX}}));
+    }
+
+    Y_UNIT_TEST(BinaryFloat64) {
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x03\x00\x00\x00\x00\x00\x00\xf0\x7f"sv),
+            to_yson_binary_string(NYsonPull::TScalar{std::numeric_limits<double>::infinity()}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x03\x00\x00\x00\x00\x00\x00\xf0\xff"sv),
+            to_yson_binary_string(NYsonPull::TScalar{-std::numeric_limits<double>::infinity()}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x03\x00\x00\x00\x00\x00\x00\xf8\x7f"sv),
+            to_yson_binary_string(NYsonPull::TScalar{std::numeric_limits<double>::quiet_NaN()}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x03\x9a\x99\x99\x99\x99\x99\xf1\x3f"),
+            to_yson_binary_string(NYsonPull::TScalar{double{1.1}}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x03\x9a\x99\x99\x99\x99\x99\xf1\xbf"),
+            to_yson_binary_string(NYsonPull::TScalar{double{-1.1}}));
+    }
+
+    Y_UNIT_TEST(BinaryString) {
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x1\0"sv),
+            to_yson_binary_string(NYsonPull::TScalar{""}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x1\nhello"),
+            to_yson_binary_string(NYsonPull::TScalar{"hello"}));
+        UNIT_ASSERT_VALUES_EQUAL(
+            TStringBuf("\x1\x16hello\nworld"),
+            to_yson_binary_string(NYsonPull::TScalar{"hello\nworld"}));
+    }
+
+} // Y_UNIT_TEST_SUITE(Writer)