Restoring authorship annotation for <[email protected]>. Commit 2 of 2.

9 files changed, 514 insertions, 514 deletions

diff --git a/library/cpp/json/json_reader.cpp b/library/cpp/json/json_reader.cpp
index 03233f90d01..072c8deafee 100644
--- a/library/cpp/json/json_reader.cpp
+++ b/library/cpp/json/json_reader.cpp
@@ -1,5 +1,5 @@
-#include "json_reader.h" 
- 
+#include "json_reader.h"
+
 #include "rapidjson_helpers.h"
 
 #include <contrib/libs/rapidjson/include/rapidjson/error/en.h>
@@ -8,7 +8,7 @@
 
 #include <util/generic/stack.h>
 #include <util/string/cast.h>
-#include <util/system/yassert.h> 
+#include <util/system/yassert.h>
 #include <util/string/builder.h>
 
 namespace NJson {
@@ -94,7 +94,7 @@ namespace NJson {
     bool TParserCallbacks::OnString(const TStringBuf& val) {
         return SetValue(val);
     }
- 
+
     bool TParserCallbacks::OnDouble(double val) {
         return SetValue(val);
     }
@@ -148,7 +148,7 @@ namespace NJson {
     void TJsonReaderConfig::SetBufferSize(size_t bufferSize) {
         BufferSize = Max((size_t)1, Min(bufferSize, DEFAULT_BUFFER_LEN));
     }
- 
+
     size_t TJsonReaderConfig::GetBufferSize() const {
         return BufferSize;
     }
@@ -437,7 +437,7 @@ namespace NJson {
                 : Impl(impl)
             {
             }
- 
+
             bool Null() {
                 return Impl.OnNull();
             }
@@ -445,7 +445,7 @@ namespace NJson {
             bool Bool(bool b) {
                 return Impl.OnBoolean(b);
             }
- 
+
             template <class U>
             bool ProcessUint(U u) {
                 if (Y_LIKELY(u <= ui64(Max<i64>()))) {
diff --git a/library/cpp/json/json_reader.h b/library/cpp/json/json_reader.h
index 54b9ea2c60f..b6737883306 100644
--- a/library/cpp/json/json_reader.h
+++ b/library/cpp/json/json_reader.h
@@ -19,7 +19,7 @@ namespace NJson {
         bool AllowComments = false;
         bool DontValidateUtf8 = false;
         bool AllowEscapedApostrophe = false;
- 
+
         void SetBufferSize(size_t bufferSize);
         size_t GetBufferSize() const;
 
@@ -30,7 +30,7 @@ namespace NJson {
     bool ReadJsonTree(TStringBuf in, TJsonValue* out, bool throwOnError = false);
     bool ReadJsonTree(TStringBuf in, bool allowComments, TJsonValue* out, bool throwOnError = false);
     bool ReadJsonTree(TStringBuf in, const TJsonReaderConfig* config, TJsonValue* out, bool throwOnError = false);
- 
+
     bool ReadJsonTree(IInputStream* in, TJsonValue* out, bool throwOnError = false);
     bool ReadJsonTree(IInputStream* in, bool allowComments, TJsonValue* out, bool throwOnError = false);
     bool ReadJsonTree(IInputStream* in, const TJsonReaderConfig* config, TJsonValue* out, bool throwOnError = false);
@@ -38,7 +38,7 @@ namespace NJson {
     TJsonValue ReadJsonTree(IInputStream* in, bool throwOnError = false);
     TJsonValue ReadJsonTree(IInputStream* in, bool allowComments, bool throwOnError);
     TJsonValue ReadJsonTree(IInputStream* in, const TJsonReaderConfig* config, bool throwOnError = false);
- 
+
     bool ReadJson(IInputStream* in, TJsonCallbacks* callbacks);
     bool ReadJson(IInputStream* in, bool allowComments, TJsonCallbacks* callbacks);
     bool ReadJson(IInputStream* in, bool allowComments, bool allowEscapedApostrophe, TJsonCallbacks* callbacks);
diff --git a/library/cpp/json/json_writer.cpp b/library/cpp/json/json_writer.cpp
index 925e97dbb74..3d058bae360 100644
--- a/library/cpp/json/json_writer.cpp
+++ b/library/cpp/json/json_writer.cpp
@@ -45,7 +45,7 @@ namespace NJson {
             }
         }
     }
- 
+
     void TJsonWriter::Flush() {
         if (Out) {
             Buf.FlushTo(Out);
@@ -101,7 +101,7 @@ namespace NJson {
     void TJsonWriter::Write(unsigned long long value) {
         Buf.WriteULongLong(value);
     }
- 
+
     void TJsonWriter::Write(bool value) {
         Buf.WriteBool(value);
     }
@@ -145,5 +145,5 @@ namespace NJson {
         w.Write(val);
         w.Flush();
     }
- 
-} 
+
+}
diff --git a/library/cpp/json/json_writer.h b/library/cpp/json/json_writer.h
index 9d4c2c2741b..c7f5c9499a4 100644
--- a/library/cpp/json/json_writer.h
+++ b/library/cpp/json/json_writer.h
@@ -56,7 +56,7 @@ namespace NJson {
         const bool ValidateUtf8;
         const bool DontEscapeStrings;
         const bool DontFlushInDestructor;
- 
+
     public:
         TJsonWriter(IOutputStream* out, bool formatOutput, bool sortkeys = false, bool validateUtf8 = true);
         TJsonWriter(IOutputStream* out, const TJsonWriterConfig& config, bool DontFlushInDestructor = false);
diff --git a/library/cpp/json/ut/json_reader_ut.cpp b/library/cpp/json/ut/json_reader_ut.cpp
index c853ec3d567..cd31afa0b8b 100644
--- a/library/cpp/json/ut/json_reader_ut.cpp
+++ b/library/cpp/json/ut/json_reader_ut.cpp
@@ -26,10 +26,10 @@ public:
     }
 
     bool OnUInteger(unsigned long long val) override {
-        Writer.Write(val); 
-        return true; 
-    } 
- 
+        Writer.Write(val);
+        return true;
+    }
+
     bool OnString(const TStringBuf& val) override {
         Writer.Write(val);
         return true;
@@ -135,7 +135,7 @@ Y_UNIT_TEST_SUITE(TJsonReaderTest) {
         UNIT_ASSERT_VALUES_EQUAL(value["array"][1].GetInteger(), 2);
         UNIT_ASSERT_VALUES_EQUAL(value["array"][2].GetInteger(), 3);
         UNIT_ASSERT_VALUES_EQUAL(value["array"][3].GetString(), TString("TString"));
-        UNIT_ASSERT(value["null value"].IsNull()); 
+        UNIT_ASSERT(value["null value"].IsNull());
 
         // AsString
         UNIT_ASSERT_VALUES_EQUAL(value["intkey"].GetStringRobust(), "10");
@@ -146,12 +146,12 @@ Y_UNIT_TEST_SUITE(TJsonReaderTest) {
         UNIT_ASSERT_VALUES_EQUAL(value["null value"].GetStringRobust(), "null");
 
         const TJsonValue::TArray* array;
-        UNIT_ASSERT(GetArrayPointer(value, "array", &array)); 
-        UNIT_ASSERT_VALUES_EQUAL(value["array"].GetArray().size(), array->size()); 
-        UNIT_ASSERT_VALUES_EQUAL(value["array"][0].GetInteger(), (*array)[0].GetInteger()); 
+        UNIT_ASSERT(GetArrayPointer(value, "array", &array));
+        UNIT_ASSERT_VALUES_EQUAL(value["array"].GetArray().size(), array->size());
+        UNIT_ASSERT_VALUES_EQUAL(value["array"][0].GetInteger(), (*array)[0].GetInteger());
         UNIT_ASSERT_VALUES_EQUAL(value["array"][1].GetInteger(), (*array)[1].GetInteger());
         UNIT_ASSERT_VALUES_EQUAL(value["array"][2].GetInteger(), (*array)[2].GetInteger());
-        UNIT_ASSERT_VALUES_EQUAL(value["array"][3].GetString(), (*array)[3].GetString()); 
+        UNIT_ASSERT_VALUES_EQUAL(value["array"][3].GetString(), (*array)[3].GetString());
     }
 
     Y_UNIT_TEST(TJsonRomaTest) {
@@ -166,193 +166,193 @@ Y_UNIT_TEST_SUITE(TJsonReaderTest) {
     }
 
     Y_UNIT_TEST(TJsonReadTreeWithComments) {
-        { 
+        {
             TString leadingCommentData = "{ // \"test\" : 1 \n}";
-            { 
-                // No comments allowed 
-                TStringStream in; 
-                in << leadingCommentData; 
-                TJsonValue value; 
-                UNIT_ASSERT(!ReadJsonTree(&in, false, &value)); 
-            } 
- 
-            { 
-                // Comments allowed 
-                TStringStream in; 
-                in << leadingCommentData; 
-                TJsonValue value; 
-                UNIT_ASSERT(ReadJsonTree(&in, true, &value)); 
-                UNIT_ASSERT(!value.Has("test")); 
-            } 
-        } 
- 
-        { 
+            {
+                // No comments allowed
+                TStringStream in;
+                in << leadingCommentData;
+                TJsonValue value;
+                UNIT_ASSERT(!ReadJsonTree(&in, false, &value));
+            }
+
+            {
+                // Comments allowed
+                TStringStream in;
+                in << leadingCommentData;
+                TJsonValue value;
+                UNIT_ASSERT(ReadJsonTree(&in, true, &value));
+                UNIT_ASSERT(!value.Has("test"));
+            }
+        }
+
+        {
             TString trailingCommentData = "{ \"test1\" : 1 // \"test2\" : 2 \n }";
-            { 
-                // No comments allowed 
-                TStringStream in; 
-                in << trailingCommentData; 
-                TJsonValue value; 
-                UNIT_ASSERT(!ReadJsonTree(&in, false, &value)); 
-            } 
- 
-            { 
-                // Comments allowed 
-                TStringStream in; 
-                in << trailingCommentData; 
-                TJsonValue value; 
-                UNIT_ASSERT(ReadJsonTree(&in, true, &value)); 
-                UNIT_ASSERT(value.Has("test1")); 
-                UNIT_ASSERT_EQUAL(value["test1"].GetInteger(), 1); 
-                UNIT_ASSERT(!value.Has("test2")); 
-            } 
-        } 
-    } 
- 
+            {
+                // No comments allowed
+                TStringStream in;
+                in << trailingCommentData;
+                TJsonValue value;
+                UNIT_ASSERT(!ReadJsonTree(&in, false, &value));
+            }
+
+            {
+                // Comments allowed
+                TStringStream in;
+                in << trailingCommentData;
+                TJsonValue value;
+                UNIT_ASSERT(ReadJsonTree(&in, true, &value));
+                UNIT_ASSERT(value.Has("test1"));
+                UNIT_ASSERT_EQUAL(value["test1"].GetInteger(), 1);
+                UNIT_ASSERT(!value.Has("test2"));
+            }
+        }
+    }
+
     Y_UNIT_TEST(TJsonSignedIntegerTest) {
-        { 
-            TStringStream in; 
-            in << "{ \"test\" : " << Min<i64>() << " }"; 
-            TJsonValue value; 
-            UNIT_ASSERT(ReadJsonTree(&in, &value)); 
-            UNIT_ASSERT(value.Has("test")); 
-            UNIT_ASSERT(value["test"].IsInteger()); 
-            UNIT_ASSERT(!value["test"].IsUInteger()); 
-            UNIT_ASSERT_EQUAL(value["test"].GetInteger(), Min<i64>()); 
-            UNIT_ASSERT_EQUAL(value["test"].GetIntegerRobust(), Min<i64>()); 
-        } // Min<i64>() 
- 
-        { 
-            TStringStream in; 
-            in << "{ \"test\" : " << Max<i64>() + 1ull << " }"; 
-            TJsonValue value; 
-            UNIT_ASSERT(ReadJsonTree(&in, &value)); 
-            UNIT_ASSERT(value.Has("test")); 
-            UNIT_ASSERT(!value["test"].IsInteger()); 
-            UNIT_ASSERT(value["test"].IsUInteger()); 
+        {
+            TStringStream in;
+            in << "{ \"test\" : " << Min<i64>() << " }";
+            TJsonValue value;
+            UNIT_ASSERT(ReadJsonTree(&in, &value));
+            UNIT_ASSERT(value.Has("test"));
+            UNIT_ASSERT(value["test"].IsInteger());
+            UNIT_ASSERT(!value["test"].IsUInteger());
+            UNIT_ASSERT_EQUAL(value["test"].GetInteger(), Min<i64>());
+            UNIT_ASSERT_EQUAL(value["test"].GetIntegerRobust(), Min<i64>());
+        } // Min<i64>()
+
+        {
+            TStringStream in;
+            in << "{ \"test\" : " << Max<i64>() + 1ull << " }";
+            TJsonValue value;
+            UNIT_ASSERT(ReadJsonTree(&in, &value));
+            UNIT_ASSERT(value.Has("test"));
+            UNIT_ASSERT(!value["test"].IsInteger());
+            UNIT_ASSERT(value["test"].IsUInteger());
             UNIT_ASSERT_EQUAL(value["test"].GetIntegerRobust(), (i64)(Max<i64>() + 1ull));
-        } // Max<i64>() + 1 
-    } 
- 
+        } // Max<i64>() + 1
+    }
+
     Y_UNIT_TEST(TJsonUnsignedIntegerTest) {
-        { 
-            TStringStream in; 
-            in << "{ \"test\" : 1 }"; 
-            TJsonValue value; 
-            UNIT_ASSERT(ReadJsonTree(&in, &value)); 
-            UNIT_ASSERT(value.Has("test")); 
-            UNIT_ASSERT(value["test"].IsInteger()); 
-            UNIT_ASSERT(value["test"].IsUInteger()); 
-            UNIT_ASSERT_EQUAL(value["test"].GetInteger(), 1); 
-            UNIT_ASSERT_EQUAL(value["test"].GetIntegerRobust(), 1); 
-            UNIT_ASSERT_EQUAL(value["test"].GetUInteger(), 1); 
-            UNIT_ASSERT_EQUAL(value["test"].GetUIntegerRobust(), 1); 
-        } // 1 
- 
-        { 
-            TStringStream in; 
-            in << "{ \"test\" : -1 }"; 
-            TJsonValue value; 
-            UNIT_ASSERT(ReadJsonTree(&in, &value)); 
-            UNIT_ASSERT(value.Has("test")); 
-            UNIT_ASSERT(value["test"].IsInteger()); 
-            UNIT_ASSERT(!value["test"].IsUInteger()); 
-            UNIT_ASSERT_EQUAL(value["test"].GetInteger(), -1); 
-            UNIT_ASSERT_EQUAL(value["test"].GetIntegerRobust(), -1); 
-            UNIT_ASSERT_EQUAL(value["test"].GetUInteger(), 0); 
-            UNIT_ASSERT_EQUAL(value["test"].GetUIntegerRobust(), static_cast<unsigned long long>(-1)); 
-        } // -1 
- 
-        { 
-            TStringStream in; 
-            in << "{ \"test\" : 18446744073709551615 }"; 
-            TJsonValue value; 
-            UNIT_ASSERT(ReadJsonTree(&in, &value)); 
-            UNIT_ASSERT(value.Has("test")); 
-            UNIT_ASSERT(!value["test"].IsInteger()); 
-            UNIT_ASSERT(value["test"].IsUInteger()); 
-            UNIT_ASSERT_EQUAL(value["test"].GetInteger(), 0); 
-            UNIT_ASSERT_EQUAL(value["test"].GetIntegerRobust(), static_cast<long long>(18446744073709551615ull)); 
-            UNIT_ASSERT_EQUAL(value["test"].GetUInteger(), 18446744073709551615ull); 
-            UNIT_ASSERT_EQUAL(value["test"].GetUIntegerRobust(), 18446744073709551615ull); 
-        } // 18446744073709551615 
- 
-        { 
-            TStringStream in; 
-            in << "{ \"test\" : 1.1 }"; 
-            TJsonValue value; 
-            UNIT_ASSERT(ReadJsonTree(&in, &value)); 
-            UNIT_ASSERT(value.Has("test")); 
-            UNIT_ASSERT(!value["test"].IsInteger()); 
-            UNIT_ASSERT(!value["test"].IsUInteger()); 
-            UNIT_ASSERT_EQUAL(value["test"].GetInteger(), 0); 
-            UNIT_ASSERT_EQUAL(value["test"].GetIntegerRobust(), static_cast<long long>(1.1)); 
-            UNIT_ASSERT_EQUAL(value["test"].GetUInteger(), 0); 
-            UNIT_ASSERT_EQUAL(value["test"].GetUIntegerRobust(), static_cast<unsigned long long>(1.1)); 
-        } // 1.1 
- 
-        { 
-            TStringStream in; 
-            in << "{ \"test\" : [1, 18446744073709551615] }"; 
-            TJsonValue value; 
-            UNIT_ASSERT(ReadJsonTree(&in, &value)); 
-            UNIT_ASSERT(value.Has("test")); 
-            UNIT_ASSERT(value["test"].IsArray()); 
-            UNIT_ASSERT_EQUAL(value["test"].GetArray().size(), 2); 
-            UNIT_ASSERT(value["test"][0].IsInteger()); 
-            UNIT_ASSERT(value["test"][0].IsUInteger()); 
-            UNIT_ASSERT_EQUAL(value["test"][0].GetInteger(), 1); 
-            UNIT_ASSERT_EQUAL(value["test"][0].GetUInteger(), 1); 
-            UNIT_ASSERT(!value["test"][1].IsInteger()); 
-            UNIT_ASSERT(value["test"][1].IsUInteger()); 
-            UNIT_ASSERT_EQUAL(value["test"][1].GetUInteger(), 18446744073709551615ull); 
-        } 
-    } // TJsonUnsignedIntegerTest 
- 
+        {
+            TStringStream in;
+            in << "{ \"test\" : 1 }";
+            TJsonValue value;
+            UNIT_ASSERT(ReadJsonTree(&in, &value));
+            UNIT_ASSERT(value.Has("test"));
+            UNIT_ASSERT(value["test"].IsInteger());
+            UNIT_ASSERT(value["test"].IsUInteger());
+            UNIT_ASSERT_EQUAL(value["test"].GetInteger(), 1);
+            UNIT_ASSERT_EQUAL(value["test"].GetIntegerRobust(), 1);
+            UNIT_ASSERT_EQUAL(value["test"].GetUInteger(), 1);
+            UNIT_ASSERT_EQUAL(value["test"].GetUIntegerRobust(), 1);
+        } // 1
+
+        {
+            TStringStream in;
+            in << "{ \"test\" : -1 }";
+            TJsonValue value;
+            UNIT_ASSERT(ReadJsonTree(&in, &value));
+            UNIT_ASSERT(value.Has("test"));
+            UNIT_ASSERT(value["test"].IsInteger());
+            UNIT_ASSERT(!value["test"].IsUInteger());
+            UNIT_ASSERT_EQUAL(value["test"].GetInteger(), -1);
+            UNIT_ASSERT_EQUAL(value["test"].GetIntegerRobust(), -1);
+            UNIT_ASSERT_EQUAL(value["test"].GetUInteger(), 0);
+            UNIT_ASSERT_EQUAL(value["test"].GetUIntegerRobust(), static_cast<unsigned long long>(-1));
+        } // -1
+
+        {
+            TStringStream in;
+            in << "{ \"test\" : 18446744073709551615 }";
+            TJsonValue value;
+            UNIT_ASSERT(ReadJsonTree(&in, &value));
+            UNIT_ASSERT(value.Has("test"));
+            UNIT_ASSERT(!value["test"].IsInteger());
+            UNIT_ASSERT(value["test"].IsUInteger());
+            UNIT_ASSERT_EQUAL(value["test"].GetInteger(), 0);
+            UNIT_ASSERT_EQUAL(value["test"].GetIntegerRobust(), static_cast<long long>(18446744073709551615ull));
+            UNIT_ASSERT_EQUAL(value["test"].GetUInteger(), 18446744073709551615ull);
+            UNIT_ASSERT_EQUAL(value["test"].GetUIntegerRobust(), 18446744073709551615ull);
+        } // 18446744073709551615
+
+        {
+            TStringStream in;
+            in << "{ \"test\" : 1.1 }";
+            TJsonValue value;
+            UNIT_ASSERT(ReadJsonTree(&in, &value));
+            UNIT_ASSERT(value.Has("test"));
+            UNIT_ASSERT(!value["test"].IsInteger());
+            UNIT_ASSERT(!value["test"].IsUInteger());
+            UNIT_ASSERT_EQUAL(value["test"].GetInteger(), 0);
+            UNIT_ASSERT_EQUAL(value["test"].GetIntegerRobust(), static_cast<long long>(1.1));
+            UNIT_ASSERT_EQUAL(value["test"].GetUInteger(), 0);
+            UNIT_ASSERT_EQUAL(value["test"].GetUIntegerRobust(), static_cast<unsigned long long>(1.1));
+        } // 1.1
+
+        {
+            TStringStream in;
+            in << "{ \"test\" : [1, 18446744073709551615] }";
+            TJsonValue value;
+            UNIT_ASSERT(ReadJsonTree(&in, &value));
+            UNIT_ASSERT(value.Has("test"));
+            UNIT_ASSERT(value["test"].IsArray());
+            UNIT_ASSERT_EQUAL(value["test"].GetArray().size(), 2);
+            UNIT_ASSERT(value["test"][0].IsInteger());
+            UNIT_ASSERT(value["test"][0].IsUInteger());
+            UNIT_ASSERT_EQUAL(value["test"][0].GetInteger(), 1);
+            UNIT_ASSERT_EQUAL(value["test"][0].GetUInteger(), 1);
+            UNIT_ASSERT(!value["test"][1].IsInteger());
+            UNIT_ASSERT(value["test"][1].IsUInteger());
+            UNIT_ASSERT_EQUAL(value["test"][1].GetUInteger(), 18446744073709551615ull);
+        }
+    } // TJsonUnsignedIntegerTest
+
     Y_UNIT_TEST(TJsonDoubleTest) {
-        { 
-            TStringStream in; 
-            in << "{ \"test\" : 1.0 }"; 
-            TJsonValue value; 
-            UNIT_ASSERT(ReadJsonTree(&in, &value)); 
-            UNIT_ASSERT(value.Has("test")); 
-            UNIT_ASSERT(value["test"].IsDouble()); 
-            UNIT_ASSERT_EQUAL(value["test"].GetDouble(), 1.0); 
-            UNIT_ASSERT_EQUAL(value["test"].GetDoubleRobust(), 1.0); 
-        } // 1.0 
- 
-        { 
-            TStringStream in; 
-            in << "{ \"test\" : 1 }"; 
-            TJsonValue value; 
-            UNIT_ASSERT(ReadJsonTree(&in, &value)); 
-            UNIT_ASSERT(value.Has("test")); 
-            UNIT_ASSERT(value["test"].IsDouble()); 
-            UNIT_ASSERT_EQUAL(value["test"].GetDouble(), 1.0); 
-            UNIT_ASSERT_EQUAL(value["test"].GetDoubleRobust(), 1.0); 
-        } // 1 
- 
-        { 
-            TStringStream in; 
-            in << "{ \"test\" : -1 }"; 
-            TJsonValue value; 
-            UNIT_ASSERT(ReadJsonTree(&in, &value)); 
-            UNIT_ASSERT(value.Has("test")); 
-            UNIT_ASSERT(value["test"].IsDouble()); 
-            UNIT_ASSERT_EQUAL(value["test"].GetDouble(), -1.0); 
-            UNIT_ASSERT_EQUAL(value["test"].GetDoubleRobust(), -1.0); 
-        } // -1 
- 
-        { 
-            TStringStream in; 
-            in << "{ \"test\" : " << Max<ui64>() << " }"; 
-            TJsonValue value; 
-            UNIT_ASSERT(ReadJsonTree(&in, &value)); 
-            UNIT_ASSERT(value.Has("test")); 
-            UNIT_ASSERT(!value["test"].IsDouble()); 
-            UNIT_ASSERT_EQUAL(value["test"].GetDouble(), 0.0); 
-            UNIT_ASSERT_EQUAL(value["test"].GetDoubleRobust(), static_cast<double>(Max<ui64>())); 
-        } // Max<ui64>() 
+        {
+            TStringStream in;
+            in << "{ \"test\" : 1.0 }";
+            TJsonValue value;
+            UNIT_ASSERT(ReadJsonTree(&in, &value));
+            UNIT_ASSERT(value.Has("test"));
+            UNIT_ASSERT(value["test"].IsDouble());
+            UNIT_ASSERT_EQUAL(value["test"].GetDouble(), 1.0);
+            UNIT_ASSERT_EQUAL(value["test"].GetDoubleRobust(), 1.0);
+        } // 1.0
+
+        {
+            TStringStream in;
+            in << "{ \"test\" : 1 }";
+            TJsonValue value;
+            UNIT_ASSERT(ReadJsonTree(&in, &value));
+            UNIT_ASSERT(value.Has("test"));
+            UNIT_ASSERT(value["test"].IsDouble());
+            UNIT_ASSERT_EQUAL(value["test"].GetDouble(), 1.0);
+            UNIT_ASSERT_EQUAL(value["test"].GetDoubleRobust(), 1.0);
+        } // 1
+
+        {
+            TStringStream in;
+            in << "{ \"test\" : -1 }";
+            TJsonValue value;
+            UNIT_ASSERT(ReadJsonTree(&in, &value));
+            UNIT_ASSERT(value.Has("test"));
+            UNIT_ASSERT(value["test"].IsDouble());
+            UNIT_ASSERT_EQUAL(value["test"].GetDouble(), -1.0);
+            UNIT_ASSERT_EQUAL(value["test"].GetDoubleRobust(), -1.0);
+        } // -1
+
+        {
+            TStringStream in;
+            in << "{ \"test\" : " << Max<ui64>() << " }";
+            TJsonValue value;
+            UNIT_ASSERT(ReadJsonTree(&in, &value));
+            UNIT_ASSERT(value.Has("test"));
+            UNIT_ASSERT(!value["test"].IsDouble());
+            UNIT_ASSERT_EQUAL(value["test"].GetDouble(), 0.0);
+            UNIT_ASSERT_EQUAL(value["test"].GetDoubleRobust(), static_cast<double>(Max<ui64>()));
+        } // Max<ui64>()
     }     // TJsonDoubleTest
 
     Y_UNIT_TEST(TJsonInvalidTest) {
diff --git a/library/cpp/json/ut/json_writer_ut.cpp b/library/cpp/json/ut/json_writer_ut.cpp
index f9f44ed34e2..ca11d34dad9 100644
--- a/library/cpp/json/ut/json_writer_ut.cpp
+++ b/library/cpp/json/ut/json_writer_ut.cpp
@@ -54,7 +54,7 @@ Y_UNIT_TEST_SUITE(TJsonWriterTest) {
         WriteJson(&out, &v);
         UNIT_ASSERT_VALUES_EQUAL(out.Str(), expected);
     }
- 
+
     Y_UNIT_TEST(FormatOutput) {
         TString expected = "{\n  \"key1\":null,\n  \"key2\":\n    {\n      \"subkey1\":\n        [\n          1,\n          {\n            \"subsubkey\":\"test2\"\n          },\n          null,\n          true\n        ],\n      \"subkey2\":\"test\"\n    }\n}";
         TJsonValue v;
@@ -83,45 +83,45 @@ Y_UNIT_TEST_SUITE(TJsonWriterTest) {
     }
 
     Y_UNIT_TEST(SimpleUnsignedIntegerWriteTest) {
-        { 
+        {
             TString expected = "{\"test\":1}";
-            TJsonValue v; 
-            v.InsertValue("test", 1ull); 
-            TStringStream out; 
-            WriteJson(&out, &v); 
-            UNIT_ASSERT_VALUES_EQUAL(out.Str(), expected); 
-        } // 1 
- 
-        { 
+            TJsonValue v;
+            v.InsertValue("test", 1ull);
+            TStringStream out;
+            WriteJson(&out, &v);
+            UNIT_ASSERT_VALUES_EQUAL(out.Str(), expected);
+        } // 1
+
+        {
             TString expected = "{\"test\":-1}";
-            TJsonValue v; 
-            v.InsertValue("test", -1); 
-            TStringStream out; 
-            WriteJson(&out, &v); 
-            UNIT_ASSERT_VALUES_EQUAL(out.Str(), expected); 
-        } // -1 
- 
-        { 
+            TJsonValue v;
+            v.InsertValue("test", -1);
+            TStringStream out;
+            WriteJson(&out, &v);
+            UNIT_ASSERT_VALUES_EQUAL(out.Str(), expected);
+        } // -1
+
+        {
             TString expected = "{\"test\":18446744073709551615}";
-            TJsonValue v; 
-            v.InsertValue("test", 18446744073709551615ull); 
-            TStringStream out; 
-            WriteJson(&out, &v); 
-            UNIT_ASSERT_VALUES_EQUAL(out.Str(), expected); 
-        } // 18446744073709551615 
- 
-        { 
+            TJsonValue v;
+            v.InsertValue("test", 18446744073709551615ull);
+            TStringStream out;
+            WriteJson(&out, &v);
+            UNIT_ASSERT_VALUES_EQUAL(out.Str(), expected);
+        } // 18446744073709551615
+
+        {
             TString expected = "{\"test\":[1,18446744073709551615]}";
-            TJsonValue v; 
-            v.InsertValue("test", TJsonValue()); 
-            v["test"].AppendValue(1); 
-            v["test"].AppendValue(18446744073709551615ull); 
-            TStringStream out; 
-            WriteJson(&out, &v); 
-            UNIT_ASSERT_VALUES_EQUAL(out.Str(), expected); 
-        } // 18446744073709551615 
+            TJsonValue v;
+            v.InsertValue("test", TJsonValue());
+            v["test"].AppendValue(1);
+            v["test"].AppendValue(18446744073709551615ull);
+            TStringStream out;
+            WriteJson(&out, &v);
+            UNIT_ASSERT_VALUES_EQUAL(out.Str(), expected);
+        } // 18446744073709551615
     }     // SimpleUnsignedIntegerWriteTest
- 
+
     Y_UNIT_TEST(WriteOptionalTest) {
         {
             TString expected = "{\"test\":1}";
diff --git a/library/cpp/json/writer/json_value.cpp b/library/cpp/json/writer/json_value.cpp
index 3e7ab2915e6..c61e8d1dc43 100644
--- a/library/cpp/json/writer/json_value.cpp
+++ b/library/cpp/json/writer/json_value.cpp
@@ -2,7 +2,7 @@
 #include "json.h"
 
 #include <util/generic/ymath.h>
-#include <util/generic/ylimits.h> 
+#include <util/generic/ylimits.h>
 #include <util/generic/utility.h>
 #include <util/generic/singleton.h>
 #include <util/stream/str.h>
@@ -10,63 +10,63 @@
 #include <util/string/cast.h>
 #include <util/string/type.h>
 #include <util/string/vector.h>
-#include <util/system/yassert.h> 
+#include <util/system/yassert.h>
 #include <util/ysaveload.h>
 #include <util/generic/bt_exception.h>
 
-static bool 
-AreJsonMapsEqual(const NJson::TJsonValue& lhs, const NJson::TJsonValue& rhs) { 
-    using namespace NJson; 
- 
+static bool
+AreJsonMapsEqual(const NJson::TJsonValue& lhs, const NJson::TJsonValue& rhs) {
+    using namespace NJson;
+
     Y_VERIFY(lhs.GetType() == JSON_MAP, "lhs has not a JSON_MAP type.");
- 
-    if (rhs.GetType() != JSON_MAP) 
-        return false; 
- 
+
+    if (rhs.GetType() != JSON_MAP)
+        return false;
+
     typedef TJsonValue::TMapType TMapType;
     const TMapType& lhsMap = lhs.GetMap();
     const TMapType& rhsMap = rhs.GetMap();
- 
-    if (lhsMap.size() != rhsMap.size()) 
-        return false; 
- 
+
+    if (lhsMap.size() != rhsMap.size())
+        return false;
+
     for (const auto& lhsIt : lhsMap) {
         TMapType::const_iterator rhsIt = rhsMap.find(lhsIt.first);
-        if (rhsIt == rhsMap.end()) 
-            return false; 
- 
+        if (rhsIt == rhsMap.end())
+            return false;
+
         if (lhsIt.second != rhsIt->second)
-            return false; 
-    } 
- 
-    return true; 
-} 
- 
-static bool 
-AreJsonArraysEqual(const NJson::TJsonValue& lhs, const NJson::TJsonValue& rhs) { 
-    using namespace NJson; 
- 
+            return false;
+    }
+
+    return true;
+}
+
+static bool
+AreJsonArraysEqual(const NJson::TJsonValue& lhs, const NJson::TJsonValue& rhs) {
+    using namespace NJson;
+
     Y_VERIFY(lhs.GetType() == JSON_ARRAY, "lhs has not a JSON_ARRAY type.");
- 
-    if (rhs.GetType() != JSON_ARRAY) 
-        return false; 
- 
-    typedef TJsonValue::TArray TArray; 
-    const TArray& lhsArray = lhs.GetArray(); 
-    const TArray& rhsArray = rhs.GetArray(); 
- 
-    if (lhsArray.size() != rhsArray.size()) 
-        return false; 
- 
-    for (TArray::const_iterator lhsIt = lhsArray.begin(), rhsIt = rhsArray.begin(); 
+
+    if (rhs.GetType() != JSON_ARRAY)
+        return false;
+
+    typedef TJsonValue::TArray TArray;
+    const TArray& lhsArray = lhs.GetArray();
+    const TArray& rhsArray = rhs.GetArray();
+
+    if (lhsArray.size() != rhsArray.size())
+        return false;
+
+    for (TArray::const_iterator lhsIt = lhsArray.begin(), rhsIt = rhsArray.begin();
          lhsIt != lhsArray.end(); ++lhsIt, ++rhsIt) {
-        if (*lhsIt != *rhsIt) 
-            return false; 
-    } 
- 
-    return true; 
-} 
- 
+        if (*lhsIt != *rhsIt)
+            return false;
+    }
+
+    return true;
+}
+
 namespace NJson {
     const TJsonValue TJsonValue::UNDEFINED{};
 
@@ -135,7 +135,7 @@ namespace NJson {
         SetType(JSON_UINTEGER);
         Value.UInteger = value;
     }
- 
+
     TJsonValue::TJsonValue(const int value) noexcept {
         SetType(JSON_INTEGER);
         Value.Integer = value;
@@ -145,7 +145,7 @@ namespace NJson {
         SetType(JSON_UINTEGER);
         Value.UInteger = value;
     }
- 
+
     TJsonValue::TJsonValue(const long value) noexcept {
         SetType(JSON_INTEGER);
         Value.Integer = value;
@@ -155,7 +155,7 @@ namespace NJson {
         SetType(JSON_UINTEGER);
         Value.UInteger = value;
     }
- 
+
     TJsonValue::TJsonValue(const double value) noexcept {
         SetType(JSON_DOUBLE);
         Value.Double = value;
@@ -362,55 +362,55 @@ namespace NJson {
 
             case JSON_UINTEGER:
                 return Value.UInteger;
- 
+
             case JSON_DOUBLE:
                 return Value.Double;
- 
+
             default:
                 Y_ASSERT(false && "Unexpected type.");
                 return 0;
         }
-    } 
+    }
 
     unsigned long long TJsonValue::GetUInteger() const {
         if (!IsUInteger())
             return 0;
- 
+
         switch (Type) {
             case JSON_UINTEGER:
                 return Value.UInteger;
- 
+
             case JSON_INTEGER:
                 return Value.Integer;
- 
+
             case JSON_DOUBLE:
                 return Value.Double;
- 
+
             default:
                 Y_ASSERT(false && "Unexpected type.");
                 return 0;
         }
-    } 
- 
+    }
+
     double TJsonValue::GetDouble() const {
         if (!IsDouble())
             return 0.0;
- 
+
         switch (Type) {
             case JSON_DOUBLE:
                 return Value.Double;
- 
+
             case JSON_INTEGER:
                 return Value.Integer;
- 
+
             case JSON_UINTEGER:
                 return Value.UInteger;
- 
+
             default:
                 Y_ASSERT(false && "Unexpected type.");
                 return 0.0;
         }
-    } 
+    }
 
     const TString& TJsonValue::GetString() const {
         return Type != JSON_STRING ? Singleton<TDefaultsHolder>()->String : Value.String;
@@ -593,8 +593,8 @@ namespace NJson {
             case JSON_UINTEGER:
                 return Value.UInteger;
         }
-    } 
- 
+    }
+
     double TJsonValue::GetDoubleRobust() const noexcept {
         switch (Type) {
             case JSON_ARRAY:
@@ -664,11 +664,11 @@ namespace NJson {
     bool TJsonValue::GetUInteger(unsigned long long* value) const noexcept {
         if (!IsUInteger())
             return false;
- 
+
         *value = GetUInteger();
         return true;
     }
- 
+
     bool TJsonValue::GetDouble(double* value) const noexcept {
         if (!IsDouble())
             return false;
@@ -765,56 +765,56 @@ namespace NJson {
     bool TJsonValue::IsBoolean() const noexcept {
         return Type == JSON_BOOLEAN;
     }
- 
+
     bool TJsonValue::IsInteger() const noexcept {
         switch (Type) {
             case JSON_INTEGER:
                 return true;
- 
+
             case JSON_UINTEGER:
                 return (Value.UInteger <= static_cast<unsigned long long>(Max<long long>()));
- 
+
             case JSON_DOUBLE:
                 return ((long long)Value.Double == Value.Double);
 
             default:
                 return false;
         }
-    } 
+    }
 
     bool TJsonValue::IsUInteger() const noexcept {
         switch (Type) {
             case JSON_UINTEGER:
                 return true;
- 
+
             case JSON_INTEGER:
                 return (Value.Integer >= 0);
- 
+
             case JSON_DOUBLE:
                 return ((unsigned long long)Value.Double == Value.Double);
- 
+
             default:
                 return false;
         }
-    } 
- 
+    }
+
     bool TJsonValue::IsDouble() const noexcept {
         // Check whether we can convert integer to floating-point
         // without precision loss.
         switch (Type) {
             case JSON_DOUBLE:
                 return true;
- 
+
             case JSON_INTEGER:
                 return (1ll << std::numeric_limits<double>::digits) >= Abs(Value.Integer);
- 
+
             case JSON_UINTEGER:
                 return (1ull << std::numeric_limits<double>::digits) >= Value.UInteger;
- 
+
             default:
                 return false;
         }
-    } 
+    }
 
     namespace {
         template <class TPtr, class T>
@@ -906,42 +906,42 @@ namespace NJson {
 
     void TJsonValue::Scan(IScanCallback& callback) {
         DoScan("", nullptr, callback);
-    } 
- 
+    }
+
     bool TJsonValue::IsString() const noexcept {
         return Type == JSON_STRING;
-    } 
- 
+    }
+
     bool TJsonValue::IsMap() const noexcept {
         return Type == JSON_MAP;
-    } 
- 
+    }
+
     bool TJsonValue::IsArray() const noexcept {
         return Type == JSON_ARRAY;
-    } 
- 
+    }
+
     bool TJsonValue::Has(const TStringBuf& key) const noexcept {
         return Type == JSON_MAP && Value.Map->contains(key);
-    } 
- 
+    }
+
     bool TJsonValue::Has(size_t key) const noexcept {
         return Type == JSON_ARRAY && Value.Array->size() > key;
-    } 
- 
+    }
+
     bool TJsonValue::operator==(const TJsonValue& rhs) const {
         switch (Type) {
             case JSON_UNDEFINED: {
                 return (rhs.GetType() == JSON_UNDEFINED);
             }
- 
+
             case JSON_NULL: {
                 return rhs.IsNull();
             }
- 
+
             case JSON_BOOLEAN: {
                 return (rhs.IsBoolean() && Value.Boolean == rhs.Value.Boolean);
             }
- 
+
             case JSON_INTEGER: {
                 return (rhs.IsInteger() && GetInteger() == rhs.GetInteger());
             }
diff --git a/library/cpp/json/writer/json_value.h b/library/cpp/json/writer/json_value.h
index d777d070625..3f0f50bc4c8 100644
--- a/library/cpp/json/writer/json_value.h
+++ b/library/cpp/json/writer/json_value.h
@@ -170,10 +170,10 @@ namespace NJson {
 
         /// @return true if JSON_UINTEGER or (JSON_INTEGER and Value >= 0)
         bool IsUInteger() const noexcept;
- 
+
         bool Has(const TStringBuf& key) const noexcept;
         bool Has(size_t key) const noexcept;
- 
+
         void Scan(IScanCallback& callback);
 
         /// Non-robust comparison.
@@ -182,9 +182,9 @@ namespace NJson {
         bool operator!=(const TJsonValue& rhs) const {
             return !(*this == rhs);
         }
- 
+
         void Swap(TJsonValue& rhs) noexcept;
- 
+
         // save using util/ysaveload.h serialization (not to JSON stream)
         void Save(IOutputStream* s) const;
 
diff --git a/library/cpp/json/writer/json_value_ut.cpp b/library/cpp/json/writer/json_value_ut.cpp
index 7cb1003a755..dc7f6affdff 100644
--- a/library/cpp/json/writer/json_value_ut.cpp
+++ b/library/cpp/json/writer/json_value_ut.cpp
@@ -1,11 +1,11 @@
-#include "json_value.h" 
- 
+#include "json_value.h"
+
 #include <library/cpp/testing/unittest/registar.h>
- 
-#include <util/stream/input.h> 
- 
-using namespace NJson; 
- 
+
+#include <util/stream/input.h>
+
+using namespace NJson;
+
 Y_UNIT_TEST_SUITE(TJsonValueTest) {
     Y_UNIT_TEST(UndefTest) {
         TJsonValue undef;
@@ -37,177 +37,177 @@ Y_UNIT_TEST_SUITE(TJsonValueTest) {
     }
 
     Y_UNIT_TEST(DefaultCompareTest) {
-        { 
-            TJsonValue lhs; 
-            TJsonValue rhs; 
-            UNIT_ASSERT(lhs == rhs); 
-            UNIT_ASSERT(rhs == lhs); 
-        } 
- 
-        { 
-            TJsonValue lhs; 
-            TJsonValue rhs(JSON_NULL); 
-            UNIT_ASSERT(lhs != rhs); 
-            UNIT_ASSERT(rhs != lhs); 
-        } 
-    } 
- 
+        {
+            TJsonValue lhs;
+            TJsonValue rhs;
+            UNIT_ASSERT(lhs == rhs);
+            UNIT_ASSERT(rhs == lhs);
+        }
+
+        {
+            TJsonValue lhs;
+            TJsonValue rhs(JSON_NULL);
+            UNIT_ASSERT(lhs != rhs);
+            UNIT_ASSERT(rhs != lhs);
+        }
+    }
+
     Y_UNIT_TEST(NullCompareTest) {
-        TJsonValue lhs(JSON_NULL); 
-        TJsonValue rhs(JSON_NULL); 
-        UNIT_ASSERT(lhs == rhs); 
-        UNIT_ASSERT(rhs == lhs); 
-    } 
- 
+        TJsonValue lhs(JSON_NULL);
+        TJsonValue rhs(JSON_NULL);
+        UNIT_ASSERT(lhs == rhs);
+        UNIT_ASSERT(rhs == lhs);
+    }
+
     Y_UNIT_TEST(StringCompareTest) {
-        { 
-            TJsonValue lhs(JSON_STRING); 
-            TJsonValue rhs(JSON_STRING); 
-            UNIT_ASSERT(lhs == rhs); 
-            UNIT_ASSERT(rhs == lhs); 
-        } 
- 
-        { 
-            TJsonValue lhs(""); 
-            TJsonValue rhs(""); 
-            UNIT_ASSERT(lhs == rhs); 
-            UNIT_ASSERT(rhs == lhs); 
-        } 
- 
-        { 
-            TJsonValue lhs("abc"); 
-            TJsonValue rhs("abc"); 
-            UNIT_ASSERT(lhs == rhs); 
-            UNIT_ASSERT(rhs == lhs); 
-        } 
- 
-        { 
-            TJsonValue lhs("1"); 
-            TJsonValue rhs(1); 
-            UNIT_ASSERT(lhs != rhs); 
-            UNIT_ASSERT(rhs != lhs); 
-        } 
-    } 
- 
+        {
+            TJsonValue lhs(JSON_STRING);
+            TJsonValue rhs(JSON_STRING);
+            UNIT_ASSERT(lhs == rhs);
+            UNIT_ASSERT(rhs == lhs);
+        }
+
+        {
+            TJsonValue lhs("");
+            TJsonValue rhs("");
+            UNIT_ASSERT(lhs == rhs);
+            UNIT_ASSERT(rhs == lhs);
+        }
+
+        {
+            TJsonValue lhs("abc");
+            TJsonValue rhs("abc");
+            UNIT_ASSERT(lhs == rhs);
+            UNIT_ASSERT(rhs == lhs);
+        }
+
+        {
+            TJsonValue lhs("1");
+            TJsonValue rhs(1);
+            UNIT_ASSERT(lhs != rhs);
+            UNIT_ASSERT(rhs != lhs);
+        }
+    }
+
     Y_UNIT_TEST(ArrayCompareTest) {
-        { 
-            TJsonValue lhs(JSON_ARRAY); 
-            TJsonValue rhs(JSON_ARRAY); 
-            UNIT_ASSERT(lhs == rhs); 
-            UNIT_ASSERT(rhs == lhs); 
-        } 
- 
-        { 
-            TJsonValue lhs; 
-            TJsonValue rhs; 
- 
-            lhs.AppendValue(TJsonValue()); 
- 
-            UNIT_ASSERT(lhs != rhs); 
-            UNIT_ASSERT(rhs != lhs); 
-        } 
- 
-        { 
-            TJsonValue lhs; 
-            TJsonValue rhs; 
- 
-            lhs.AppendValue(1); 
-            lhs.AppendValue("2"); 
-            lhs.AppendValue(3.0); 
-            lhs.AppendValue(TJsonValue()); 
-            lhs.AppendValue(TJsonValue(JSON_NULL)); 
- 
-            rhs.AppendValue(1); 
-            rhs.AppendValue("2"); 
-            rhs.AppendValue(3.0); 
-            rhs.AppendValue(TJsonValue()); 
-            rhs.AppendValue(TJsonValue(JSON_NULL)); 
- 
-            UNIT_ASSERT(lhs == rhs); 
-            UNIT_ASSERT(rhs == lhs); 
-        } 
- 
-        { 
-            TJsonValue lhs; 
-            TJsonValue rhs; 
- 
-            lhs.AppendValue(1); 
-            rhs.AppendValue("1"); 
- 
-            UNIT_ASSERT(lhs != rhs); 
-            UNIT_ASSERT(rhs != lhs); 
-        } 
-    } 
- 
+        {
+            TJsonValue lhs(JSON_ARRAY);
+            TJsonValue rhs(JSON_ARRAY);
+            UNIT_ASSERT(lhs == rhs);
+            UNIT_ASSERT(rhs == lhs);
+        }
+
+        {
+            TJsonValue lhs;
+            TJsonValue rhs;
+
+            lhs.AppendValue(TJsonValue());
+
+            UNIT_ASSERT(lhs != rhs);
+            UNIT_ASSERT(rhs != lhs);
+        }
+
+        {
+            TJsonValue lhs;
+            TJsonValue rhs;
+
+            lhs.AppendValue(1);
+            lhs.AppendValue("2");
+            lhs.AppendValue(3.0);
+            lhs.AppendValue(TJsonValue());
+            lhs.AppendValue(TJsonValue(JSON_NULL));
+
+            rhs.AppendValue(1);
+            rhs.AppendValue("2");
+            rhs.AppendValue(3.0);
+            rhs.AppendValue(TJsonValue());
+            rhs.AppendValue(TJsonValue(JSON_NULL));
+
+            UNIT_ASSERT(lhs == rhs);
+            UNIT_ASSERT(rhs == lhs);
+        }
+
+        {
+            TJsonValue lhs;
+            TJsonValue rhs;
+
+            lhs.AppendValue(1);
+            rhs.AppendValue("1");
+
+            UNIT_ASSERT(lhs != rhs);
+            UNIT_ASSERT(rhs != lhs);
+        }
+    }
+
     Y_UNIT_TEST(CompareTest) {
-        { 
-            TJsonValue lhs; 
-            lhs.InsertValue("null value", TJsonValue(JSON_NULL)); 
-            lhs.InsertValue("int key", TJsonValue(10)); 
-            lhs.InsertValue("double key", TJsonValue(11.11)); 
-            lhs.InsertValue("string key", TJsonValue("string")); 
- 
-            TJsonValue array; 
-            array.AppendValue(1); 
-            array.AppendValue(2); 
-            array.AppendValue(3); 
-            array.AppendValue("string"); 
-            lhs.InsertValue("array", array); 
- 
-            lhs.InsertValue("bool key", TJsonValue(true)); 
- 
-            TJsonValue rhs; 
-            rhs = lhs; 
- 
-            UNIT_ASSERT(lhs == rhs); 
-            UNIT_ASSERT(rhs == lhs); 
-        } 
- 
-        { 
-            // Insert keys in different orders 
-            const int NUM_KEYS = 1000; 
- 
-            TJsonValue lhs; 
-            for (int i = 0; i < NUM_KEYS; ++i) 
-                lhs.InsertValue(ToString(i), i); 
- 
-            TJsonValue rhs; 
-            for (int i = 0; i < NUM_KEYS; i += 2) 
-                rhs.InsertValue(ToString(i), i); 
-            for (int i = 1; i < NUM_KEYS; i += 2) 
-                rhs.InsertValue(ToString(i), i); 
- 
-            UNIT_ASSERT(lhs == rhs); 
-            UNIT_ASSERT(rhs == lhs); 
-        } 
- 
-        { 
-            TJsonValue lhs; 
-            lhs.InsertValue("null value", TJsonValue(JSON_NULL)); 
-            lhs.InsertValue("int key", TJsonValue(10)); 
-            lhs.InsertValue("double key", TJsonValue(11.11)); 
-            lhs.InsertValue("string key", TJsonValue("string")); 
- 
-            TJsonValue array; 
-            array.AppendValue(1); 
-            array.AppendValue(2); 
-            array.AppendValue(3); 
-            array.AppendValue("string"); 
-            lhs.InsertValue("array", array); 
- 
-            lhs.InsertValue("bool key", TJsonValue(true)); 
- 
-            TJsonValue rhs; 
-            rhs.InsertValue("null value", TJsonValue(JSON_NULL)); 
-            rhs.InsertValue("int key", TJsonValue(10)); 
-            rhs.InsertValue("double key", TJsonValue(11.11)); 
-            rhs.InsertValue("string key", TJsonValue("string")); 
-            rhs.InsertValue("bool key", TJsonValue(true)); 
- 
-            UNIT_ASSERT(lhs != rhs); 
-            UNIT_ASSERT(rhs != lhs); 
-        } 
-    } 
+        {
+            TJsonValue lhs;
+            lhs.InsertValue("null value", TJsonValue(JSON_NULL));
+            lhs.InsertValue("int key", TJsonValue(10));
+            lhs.InsertValue("double key", TJsonValue(11.11));
+            lhs.InsertValue("string key", TJsonValue("string"));
+
+            TJsonValue array;
+            array.AppendValue(1);
+            array.AppendValue(2);
+            array.AppendValue(3);
+            array.AppendValue("string");
+            lhs.InsertValue("array", array);
+
+            lhs.InsertValue("bool key", TJsonValue(true));
+
+            TJsonValue rhs;
+            rhs = lhs;
+
+            UNIT_ASSERT(lhs == rhs);
+            UNIT_ASSERT(rhs == lhs);
+        }
+
+        {
+            // Insert keys in different orders
+            const int NUM_KEYS = 1000;
+
+            TJsonValue lhs;
+            for (int i = 0; i < NUM_KEYS; ++i)
+                lhs.InsertValue(ToString(i), i);
+
+            TJsonValue rhs;
+            for (int i = 0; i < NUM_KEYS; i += 2)
+                rhs.InsertValue(ToString(i), i);
+            for (int i = 1; i < NUM_KEYS; i += 2)
+                rhs.InsertValue(ToString(i), i);
+
+            UNIT_ASSERT(lhs == rhs);
+            UNIT_ASSERT(rhs == lhs);
+        }
+
+        {
+            TJsonValue lhs;
+            lhs.InsertValue("null value", TJsonValue(JSON_NULL));
+            lhs.InsertValue("int key", TJsonValue(10));
+            lhs.InsertValue("double key", TJsonValue(11.11));
+            lhs.InsertValue("string key", TJsonValue("string"));
+
+            TJsonValue array;
+            array.AppendValue(1);
+            array.AppendValue(2);
+            array.AppendValue(3);
+            array.AppendValue("string");
+            lhs.InsertValue("array", array);
+
+            lhs.InsertValue("bool key", TJsonValue(true));
+
+            TJsonValue rhs;
+            rhs.InsertValue("null value", TJsonValue(JSON_NULL));
+            rhs.InsertValue("int key", TJsonValue(10));
+            rhs.InsertValue("double key", TJsonValue(11.11));
+            rhs.InsertValue("string key", TJsonValue("string"));
+            rhs.InsertValue("bool key", TJsonValue(true));
+
+            UNIT_ASSERT(lhs != rhs);
+            UNIT_ASSERT(rhs != lhs);
+        }
+    }
 
     Y_UNIT_TEST(SwapTest) {
         {
@@ -647,4 +647,4 @@ Y_UNIT_TEST_SUITE(TJsonValueTest) {
         UNIT_ASSERT_VALUES_EQUAL(filled["4"].GetMapSafe().size(), 1);
         UNIT_ASSERT_VALUES_EQUAL(filled["4"]["5"], TJsonValue{5});
     }
-} // TJsonValueTest 
+} // TJsonValueTest