Restoring authorship annotation for <yazevnul@yandex-team.ru>. Commit 2 of 2.

1 files changed, 267 insertions, 267 deletions

diff --git a/library/cpp/protobuf/util/pb_io_ut.cpp b/library/cpp/protobuf/util/pb_io_ut.cpp
index 32bba7bc40..875d6dc602 100644
--- a/library/cpp/protobuf/util/pb_io_ut.cpp
+++ b/library/cpp/protobuf/util/pb_io_ut.cpp
@@ -1,22 +1,22 @@
-#include "pb_io.h" 
- 
-#include "is_equal.h" 
- 
+#include "pb_io.h"
+
+#include "is_equal.h"
+
 #include <library/cpp/protobuf/util/ut/common_ut.pb.h>
- 
+
 #include <library/cpp/testing/unittest/registar.h>
- 
-#include <util/folder/path.h> 
-#include <util/folder/tempdir.h> 
-#include <util/stream/file.h> 
-#include <util/stream/str.h> 
- 
-static NProtobufUtilUt::TTextTest GetCorrectMessage() { 
-    NProtobufUtilUt::TTextTest m; 
-    m.SetFoo(42); 
-    return m; 
-} 
- 
+
+#include <util/folder/path.h>
+#include <util/folder/tempdir.h>
+#include <util/stream/file.h>
+#include <util/stream/str.h>
+
+static NProtobufUtilUt::TTextTest GetCorrectMessage() {
+    NProtobufUtilUt::TTextTest m;
+    m.SetFoo(42);
+    return m;
+}
+
 static NProtobufUtilUt::TTextEnumTest GetCorrectEnumMessage() {
     NProtobufUtilUt::TTextEnumTest m;
     m.SetSlot(NProtobufUtilUt::TTextEnumTest::EET_SLOT_1);
@@ -25,41 +25,41 @@ static NProtobufUtilUt::TTextEnumTest GetCorrectEnumMessage() {
 
 static const TString CORRECT_MESSAGE =
     R"(Foo: 42
-)"; 
+)";
 static const TString CORRECT_ENUM_NAME_MESSAGE =
     R"(Slot: EET_SLOT_1
 )";
 static const TString CORRECT_ENUM_ID_MESSAGE =
     R"(Slot: 1
 )";
- 
+
 static const TString INCORRECT_MESSAGE =
     R"(Bar: 1
-)"; 
+)";
 static const TString INCORRECT_ENUM_NAME_MESSAGE =
     R"(Slot: EET_SLOT_3
 )";
 static const TString INCORRECT_ENUM_ID_MESSAGE =
     R"(Slot: 3
 )";
- 
+
 static const TString CORRECT_BASE64_MESSAGE = "CCo,";
 
 static const TString CORRECT_UNEVEN_BASE64_MESSAGE = "CCo";
 
 static const TString INCORRECT_BASE64_MESSAGE = "CC";
 
-Y_UNIT_TEST_SUITE(TTestProtoBufIO) { 
-    Y_UNIT_TEST(TestBase64) { 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            UNIT_ASSERT(NProtoBuf::TryParseFromBase64String(CORRECT_BASE64_MESSAGE, message)); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            UNIT_ASSERT(!NProtoBuf::TryParseFromBase64String(INCORRECT_BASE64_MESSAGE, message)); 
-        } 
-        { 
+Y_UNIT_TEST_SUITE(TTestProtoBufIO) {
+    Y_UNIT_TEST(TestBase64) {
+        {
+            NProtobufUtilUt::TTextTest message;
+            UNIT_ASSERT(NProtoBuf::TryParseFromBase64String(CORRECT_BASE64_MESSAGE, message));
+        }
+        {
+            NProtobufUtilUt::TTextTest message;
+            UNIT_ASSERT(!NProtoBuf::TryParseFromBase64String(INCORRECT_BASE64_MESSAGE, message));
+        }
+        {
             NProtobufUtilUt::TTextTest message;
             UNIT_ASSERT(NProtoBuf::TryParseFromBase64String(CORRECT_UNEVEN_BASE64_MESSAGE , message, true));
         }
@@ -68,134 +68,134 @@ Y_UNIT_TEST_SUITE(TTestProtoBufIO) {
             UNIT_ASSERT(!NProtoBuf::TryParseFromBase64String(CORRECT_UNEVEN_BASE64_MESSAGE , message, false));
         }
         {
-            UNIT_ASSERT_VALUES_EQUAL(CORRECT_BASE64_MESSAGE, NProtoBuf::SerializeToBase64String(GetCorrectMessage())); 
-        } 
-        { 
-            const auto m = NProtoBuf::ParseFromBase64String<NProtobufUtilUt::TTextTest>(CORRECT_BASE64_MESSAGE); 
-            UNIT_ASSERT(NProtoBuf::IsEqual(GetCorrectMessage(), m)); 
-        } 
-    } 
- 
-    Y_UNIT_TEST(TestParseFromTextFormat) { 
-        TTempDir tempDir; 
-        const TFsPath correctFileName = TFsPath{tempDir()} / "correct.pb.txt"; 
-        const TFsPath incorrectFileName = TFsPath{tempDir()} / "incorrect.pb.txt"; 
- 
+            UNIT_ASSERT_VALUES_EQUAL(CORRECT_BASE64_MESSAGE, NProtoBuf::SerializeToBase64String(GetCorrectMessage()));
+        }
+        {
+            const auto m = NProtoBuf::ParseFromBase64String<NProtobufUtilUt::TTextTest>(CORRECT_BASE64_MESSAGE);
+            UNIT_ASSERT(NProtoBuf::IsEqual(GetCorrectMessage(), m));
+        }
+    }
+
+    Y_UNIT_TEST(TestParseFromTextFormat) {
+        TTempDir tempDir;
+        const TFsPath correctFileName = TFsPath{tempDir()} / "correct.pb.txt";
+        const TFsPath incorrectFileName = TFsPath{tempDir()} / "incorrect.pb.txt";
+
         TFileOutput{correctFileName}.Write(CORRECT_MESSAGE);
         TFileOutput{incorrectFileName}.Write(INCORRECT_MESSAGE);
- 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            UNIT_ASSERT(TryParseFromTextFormat(correctFileName, message)); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            UNIT_ASSERT(!TryParseFromTextFormat(incorrectFileName, message)); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            TStringInput in{CORRECT_MESSAGE}; 
-            UNIT_ASSERT(TryParseFromTextFormat(in, message)); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            TStringInput in{INCORRECT_MESSAGE}; 
-            UNIT_ASSERT(!TryParseFromTextFormat(in, message)); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            UNIT_ASSERT_NO_EXCEPTION(TryParseFromTextFormat(incorrectFileName, message)); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            UNIT_ASSERT(!TryParseFromTextFormat("this_file_doesnt_exists", message)); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            UNIT_ASSERT_NO_EXCEPTION(TryParseFromTextFormat("this_file_doesnt_exists", message)); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest message; 
+
+        {
+            NProtobufUtilUt::TTextTest message;
+            UNIT_ASSERT(TryParseFromTextFormat(correctFileName, message));
+        }
+        {
+            NProtobufUtilUt::TTextTest message;
+            UNIT_ASSERT(!TryParseFromTextFormat(incorrectFileName, message));
+        }
+        {
+            NProtobufUtilUt::TTextTest message;
+            TStringInput in{CORRECT_MESSAGE};
+            UNIT_ASSERT(TryParseFromTextFormat(in, message));
+        }
+        {
+            NProtobufUtilUt::TTextTest message;
+            TStringInput in{INCORRECT_MESSAGE};
+            UNIT_ASSERT(!TryParseFromTextFormat(in, message));
+        }
+        {
+            NProtobufUtilUt::TTextTest message;
+            UNIT_ASSERT_NO_EXCEPTION(TryParseFromTextFormat(incorrectFileName, message));
+        }
+        {
+            NProtobufUtilUt::TTextTest message;
+            UNIT_ASSERT(!TryParseFromTextFormat("this_file_doesnt_exists", message));
+        }
+        {
+            NProtobufUtilUt::TTextTest message;
+            UNIT_ASSERT_NO_EXCEPTION(TryParseFromTextFormat("this_file_doesnt_exists", message));
+        }
+        {
+            NProtobufUtilUt::TTextTest message;
             UNIT_ASSERT_EXCEPTION(ParseFromTextFormat("this_file_doesnt_exists", message), TFileError);
         }
         {
-            NProtobufUtilUt::TTextTest message; 
-            UNIT_ASSERT_NO_EXCEPTION(ParseFromTextFormat(correctFileName, message)); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            UNIT_ASSERT_EXCEPTION(ParseFromTextFormat(incorrectFileName, message), yexception); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            TStringInput in{CORRECT_MESSAGE}; 
-            UNIT_ASSERT_NO_EXCEPTION(ParseFromTextFormat(in, message)); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            TStringInput in{INCORRECT_MESSAGE}; 
-            UNIT_ASSERT_EXCEPTION(ParseFromTextFormat(in, message), yexception); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest m; 
+            NProtobufUtilUt::TTextTest message;
+            UNIT_ASSERT_NO_EXCEPTION(ParseFromTextFormat(correctFileName, message));
+        }
+        {
+            NProtobufUtilUt::TTextTest message;
+            UNIT_ASSERT_EXCEPTION(ParseFromTextFormat(incorrectFileName, message), yexception);
+        }
+        {
+            NProtobufUtilUt::TTextTest message;
+            TStringInput in{CORRECT_MESSAGE};
+            UNIT_ASSERT_NO_EXCEPTION(ParseFromTextFormat(in, message));
+        }
+        {
+            NProtobufUtilUt::TTextTest message;
+            TStringInput in{INCORRECT_MESSAGE};
+            UNIT_ASSERT_EXCEPTION(ParseFromTextFormat(in, message), yexception);
+        }
+        {
+            NProtobufUtilUt::TTextTest m;
             const auto f = [&correctFileName](NProtobufUtilUt::TTextTest& mm) {
                 mm = ParseFromTextFormat<NProtobufUtilUt::TTextTest>(correctFileName);
-            }; 
-            UNIT_ASSERT_NO_EXCEPTION(f(m)); 
-            UNIT_ASSERT(NProtoBuf::IsEqual(GetCorrectMessage(), m)); 
-        } 
-        { 
-            UNIT_ASSERT_EXCEPTION(ParseFromTextFormat<NProtobufUtilUt::TTextTest>(incorrectFileName), yexception); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest m; 
-            TStringInput in{CORRECT_MESSAGE}; 
+            };
+            UNIT_ASSERT_NO_EXCEPTION(f(m));
+            UNIT_ASSERT(NProtoBuf::IsEqual(GetCorrectMessage(), m));
+        }
+        {
+            UNIT_ASSERT_EXCEPTION(ParseFromTextFormat<NProtobufUtilUt::TTextTest>(incorrectFileName), yexception);
+        }
+        {
+            NProtobufUtilUt::TTextTest m;
+            TStringInput in{CORRECT_MESSAGE};
             const auto f = [&in](NProtobufUtilUt::TTextTest& mm) {
                 mm = ParseFromTextFormat<NProtobufUtilUt::TTextTest>(in);
-            }; 
-            UNIT_ASSERT_NO_EXCEPTION(f(m)); 
-            UNIT_ASSERT(NProtoBuf::IsEqual(GetCorrectMessage(), m)); 
-        } 
-        { 
-            TStringInput in{INCORRECT_MESSAGE}; 
-            UNIT_ASSERT_EXCEPTION(ParseFromTextFormat<NProtobufUtilUt::TTextTest>(in), yexception); 
-        } 
-        { 
+            };
+            UNIT_ASSERT_NO_EXCEPTION(f(m));
+            UNIT_ASSERT(NProtoBuf::IsEqual(GetCorrectMessage(), m));
+        }
+        {
+            TStringInput in{INCORRECT_MESSAGE};
+            UNIT_ASSERT_EXCEPTION(ParseFromTextFormat<NProtobufUtilUt::TTextTest>(in), yexception);
+        }
+        {
             const TFsPath correctFileName2 = TFsPath{tempDir()} / "serialized.pb.txt";
-            const auto original = GetCorrectMessage(); 
+            const auto original = GetCorrectMessage();
             UNIT_ASSERT_NO_EXCEPTION(SerializeToTextFormat(original, correctFileName2));
             const auto serializedStr = TUnbufferedFileInput{correctFileName2}.ReadAll();
-            UNIT_ASSERT_VALUES_EQUAL(serializedStr, CORRECT_MESSAGE); 
-        } 
-        { 
-            const auto original = GetCorrectMessage(); 
-            TStringStream out; 
-            UNIT_ASSERT_NO_EXCEPTION(SerializeToTextFormat(original, out)); 
-            UNIT_ASSERT_VALUES_EQUAL(out.Str(), CORRECT_MESSAGE); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest m; 
+            UNIT_ASSERT_VALUES_EQUAL(serializedStr, CORRECT_MESSAGE);
+        }
+        {
+            const auto original = GetCorrectMessage();
+            TStringStream out;
+            UNIT_ASSERT_NO_EXCEPTION(SerializeToTextFormat(original, out));
+            UNIT_ASSERT_VALUES_EQUAL(out.Str(), CORRECT_MESSAGE);
+        }
+        {
+            NProtobufUtilUt::TTextTest m;
             const auto f = [&correctFileName](NProtobufUtilUt::TTextTest& mm) {
                 mm = ParseFromTextFormat<NProtobufUtilUt::TTextTest>(
                     correctFileName,
                     EParseFromTextFormatOption::AllowUnknownField);
-            }; 
-            UNIT_ASSERT_NO_EXCEPTION(f(m)); 
-            UNIT_ASSERT(NProtoBuf::IsEqual(GetCorrectMessage(), m)); 
-        } 
-        { 
-            const NProtobufUtilUt::TTextTest empty; 
-            NProtobufUtilUt::TTextTest m; 
+            };
+            UNIT_ASSERT_NO_EXCEPTION(f(m));
+            UNIT_ASSERT(NProtoBuf::IsEqual(GetCorrectMessage(), m));
+        }
+        {
+            const NProtobufUtilUt::TTextTest empty;
+            NProtobufUtilUt::TTextTest m;
             const auto f = [&incorrectFileName](NProtobufUtilUt::TTextTest& mm) {
                 mm = ParseFromTextFormat<NProtobufUtilUt::TTextTest>(
                     incorrectFileName,
                     EParseFromTextFormatOption::AllowUnknownField);
-            }; 
-            UNIT_ASSERT_NO_EXCEPTION(f(m)); 
-            UNIT_ASSERT(NProtoBuf::IsEqual(empty, m)); 
-        } 
-    } 
- 
+            };
+            UNIT_ASSERT_NO_EXCEPTION(f(m));
+            UNIT_ASSERT(NProtoBuf::IsEqual(empty, m));
+        }
+    }
+
     Y_UNIT_TEST(TestSerializeToTextFormatWithEnumId) {
         TTempDir tempDir;
         const TFsPath correctNameFileName = TFsPath{tempDir()} / "correct_name.pb.txt";
@@ -250,139 +250,139 @@ Y_UNIT_TEST_SUITE(TTestProtoBufIO) {
         }
     }
 
-    Y_UNIT_TEST(TestMergeFromTextFormat) { 
-        // 
-        // Tests cases below are identical to `Parse` tests 
-        // 
-        TTempDir tempDir; 
-        const TFsPath correctFileName = TFsPath{tempDir()} / "correct.pb.txt"; 
-        const TFsPath incorrectFileName = TFsPath{tempDir()} / "incorrect.pb.txt"; 
- 
+    Y_UNIT_TEST(TestMergeFromTextFormat) {
+        //
+        // Tests cases below are identical to `Parse` tests
+        //
+        TTempDir tempDir;
+        const TFsPath correctFileName = TFsPath{tempDir()} / "correct.pb.txt";
+        const TFsPath incorrectFileName = TFsPath{tempDir()} / "incorrect.pb.txt";
+
         TFileOutput{correctFileName}.Write(CORRECT_MESSAGE);
         TFileOutput{incorrectFileName}.Write(INCORRECT_MESSAGE);
- 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            UNIT_ASSERT(TryMergeFromTextFormat(correctFileName, message)); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            UNIT_ASSERT(!TryMergeFromTextFormat(incorrectFileName, message)); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            TStringInput in{CORRECT_MESSAGE}; 
-            UNIT_ASSERT(TryMergeFromTextFormat(in, message)); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            TStringInput in{INCORRECT_MESSAGE}; 
-            UNIT_ASSERT(!TryMergeFromTextFormat(in, message)); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            UNIT_ASSERT_NO_EXCEPTION(TryMergeFromTextFormat(incorrectFileName, message)); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            UNIT_ASSERT(!TryMergeFromTextFormat("this_file_doesnt_exists", message)); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            UNIT_ASSERT_NO_EXCEPTION(TryMergeFromTextFormat("this_file_doesnt_exists", message)); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            UNIT_ASSERT_EXCEPTION(MergeFromTextFormat("this_file_doesnt_exists", message), TFileError); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            UNIT_ASSERT_NO_EXCEPTION(MergeFromTextFormat(correctFileName, message)); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            UNIT_ASSERT_EXCEPTION(MergeFromTextFormat(incorrectFileName, message), yexception); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            TStringInput in{CORRECT_MESSAGE}; 
-            UNIT_ASSERT_NO_EXCEPTION(MergeFromTextFormat(in, message)); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            TStringInput in{INCORRECT_MESSAGE}; 
-            UNIT_ASSERT_EXCEPTION(MergeFromTextFormat(in, message), yexception); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest m; 
-            const auto f = [&correctFileName](NProtobufUtilUt::TTextTest& mm) { 
-                mm = MergeFromTextFormat<NProtobufUtilUt::TTextTest>(correctFileName); 
-            }; 
-            UNIT_ASSERT_NO_EXCEPTION(f(m)); 
-            UNIT_ASSERT(NProtoBuf::IsEqual(GetCorrectMessage(), m)); 
-        } 
-        { 
-            UNIT_ASSERT_EXCEPTION(MergeFromTextFormat<NProtobufUtilUt::TTextTest>(incorrectFileName), yexception); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest m; 
-            TStringInput in{CORRECT_MESSAGE}; 
-            const auto f = [&in](NProtobufUtilUt::TTextTest& mm) { 
-                mm = MergeFromTextFormat<NProtobufUtilUt::TTextTest>(in); 
-            }; 
-            UNIT_ASSERT_NO_EXCEPTION(f(m)); 
-            UNIT_ASSERT(NProtoBuf::IsEqual(GetCorrectMessage(), m)); 
-        } 
-        { 
-            TStringInput in{INCORRECT_MESSAGE}; 
-            UNIT_ASSERT_EXCEPTION(MergeFromTextFormat<NProtobufUtilUt::TTextTest>(in), yexception); 
-        } 
-        { 
-            const TFsPath correctFileName2 = TFsPath{tempDir()} / "serialized.pb.txt"; 
-            const auto original = GetCorrectMessage(); 
-            UNIT_ASSERT_NO_EXCEPTION(SerializeToTextFormat(original, correctFileName2)); 
+
+        {
+            NProtobufUtilUt::TTextTest message;
+            UNIT_ASSERT(TryMergeFromTextFormat(correctFileName, message));
+        }
+        {
+            NProtobufUtilUt::TTextTest message;
+            UNIT_ASSERT(!TryMergeFromTextFormat(incorrectFileName, message));
+        }
+        {
+            NProtobufUtilUt::TTextTest message;
+            TStringInput in{CORRECT_MESSAGE};
+            UNIT_ASSERT(TryMergeFromTextFormat(in, message));
+        }
+        {
+            NProtobufUtilUt::TTextTest message;
+            TStringInput in{INCORRECT_MESSAGE};
+            UNIT_ASSERT(!TryMergeFromTextFormat(in, message));
+        }
+        {
+            NProtobufUtilUt::TTextTest message;
+            UNIT_ASSERT_NO_EXCEPTION(TryMergeFromTextFormat(incorrectFileName, message));
+        }
+        {
+            NProtobufUtilUt::TTextTest message;
+            UNIT_ASSERT(!TryMergeFromTextFormat("this_file_doesnt_exists", message));
+        }
+        {
+            NProtobufUtilUt::TTextTest message;
+            UNIT_ASSERT_NO_EXCEPTION(TryMergeFromTextFormat("this_file_doesnt_exists", message));
+        }
+        {
+            NProtobufUtilUt::TTextTest message;
+            UNIT_ASSERT_EXCEPTION(MergeFromTextFormat("this_file_doesnt_exists", message), TFileError);
+        }
+        {
+            NProtobufUtilUt::TTextTest message;
+            UNIT_ASSERT_NO_EXCEPTION(MergeFromTextFormat(correctFileName, message));
+        }
+        {
+            NProtobufUtilUt::TTextTest message;
+            UNIT_ASSERT_EXCEPTION(MergeFromTextFormat(incorrectFileName, message), yexception);
+        }
+        {
+            NProtobufUtilUt::TTextTest message;
+            TStringInput in{CORRECT_MESSAGE};
+            UNIT_ASSERT_NO_EXCEPTION(MergeFromTextFormat(in, message));
+        }
+        {
+            NProtobufUtilUt::TTextTest message;
+            TStringInput in{INCORRECT_MESSAGE};
+            UNIT_ASSERT_EXCEPTION(MergeFromTextFormat(in, message), yexception);
+        }
+        {
+            NProtobufUtilUt::TTextTest m;
+            const auto f = [&correctFileName](NProtobufUtilUt::TTextTest& mm) {
+                mm = MergeFromTextFormat<NProtobufUtilUt::TTextTest>(correctFileName);
+            };
+            UNIT_ASSERT_NO_EXCEPTION(f(m));
+            UNIT_ASSERT(NProtoBuf::IsEqual(GetCorrectMessage(), m));
+        }
+        {
+            UNIT_ASSERT_EXCEPTION(MergeFromTextFormat<NProtobufUtilUt::TTextTest>(incorrectFileName), yexception);
+        }
+        {
+            NProtobufUtilUt::TTextTest m;
+            TStringInput in{CORRECT_MESSAGE};
+            const auto f = [&in](NProtobufUtilUt::TTextTest& mm) {
+                mm = MergeFromTextFormat<NProtobufUtilUt::TTextTest>(in);
+            };
+            UNIT_ASSERT_NO_EXCEPTION(f(m));
+            UNIT_ASSERT(NProtoBuf::IsEqual(GetCorrectMessage(), m));
+        }
+        {
+            TStringInput in{INCORRECT_MESSAGE};
+            UNIT_ASSERT_EXCEPTION(MergeFromTextFormat<NProtobufUtilUt::TTextTest>(in), yexception);
+        }
+        {
+            const TFsPath correctFileName2 = TFsPath{tempDir()} / "serialized.pb.txt";
+            const auto original = GetCorrectMessage();
+            UNIT_ASSERT_NO_EXCEPTION(SerializeToTextFormat(original, correctFileName2));
             const auto serializedStr = TUnbufferedFileInput{correctFileName2}.ReadAll();
-            UNIT_ASSERT_VALUES_EQUAL(serializedStr, CORRECT_MESSAGE); 
-        } 
-        { 
-            const auto original = GetCorrectMessage(); 
-            TStringStream out; 
-            UNIT_ASSERT_NO_EXCEPTION(SerializeToTextFormat(original, out)); 
-            UNIT_ASSERT_VALUES_EQUAL(out.Str(), CORRECT_MESSAGE); 
-        } 
-        { 
-            NProtobufUtilUt::TTextTest m; 
-            const auto f = [&correctFileName](NProtobufUtilUt::TTextTest& mm) { 
-                mm = MergeFromTextFormat<NProtobufUtilUt::TTextTest>( 
+            UNIT_ASSERT_VALUES_EQUAL(serializedStr, CORRECT_MESSAGE);
+        }
+        {
+            const auto original = GetCorrectMessage();
+            TStringStream out;
+            UNIT_ASSERT_NO_EXCEPTION(SerializeToTextFormat(original, out));
+            UNIT_ASSERT_VALUES_EQUAL(out.Str(), CORRECT_MESSAGE);
+        }
+        {
+            NProtobufUtilUt::TTextTest m;
+            const auto f = [&correctFileName](NProtobufUtilUt::TTextTest& mm) {
+                mm = MergeFromTextFormat<NProtobufUtilUt::TTextTest>(
                     correctFileName,
                     EParseFromTextFormatOption::AllowUnknownField);
-            }; 
-            UNIT_ASSERT_NO_EXCEPTION(f(m)); 
-            UNIT_ASSERT(NProtoBuf::IsEqual(GetCorrectMessage(), m)); 
-        } 
-        { 
-            const NProtobufUtilUt::TTextTest empty; 
-            NProtobufUtilUt::TTextTest m; 
-            const auto f = [&incorrectFileName](NProtobufUtilUt::TTextTest& mm) { 
-                mm = MergeFromTextFormat<NProtobufUtilUt::TTextTest>( 
+            };
+            UNIT_ASSERT_NO_EXCEPTION(f(m));
+            UNIT_ASSERT(NProtoBuf::IsEqual(GetCorrectMessage(), m));
+        }
+        {
+            const NProtobufUtilUt::TTextTest empty;
+            NProtobufUtilUt::TTextTest m;
+            const auto f = [&incorrectFileName](NProtobufUtilUt::TTextTest& mm) {
+                mm = MergeFromTextFormat<NProtobufUtilUt::TTextTest>(
                     incorrectFileName,
                     EParseFromTextFormatOption::AllowUnknownField);
-            }; 
-            UNIT_ASSERT_NO_EXCEPTION(f(m)); 
-            UNIT_ASSERT(NProtoBuf::IsEqual(empty, m)); 
-        } 
- 
-        // 
-        // Test cases for `Merge` 
-        // 
-        { 
-            NProtobufUtilUt::TTextTest message; 
-            message.SetFoo(100500); 
-            TStringInput in{CORRECT_MESSAGE}; 
-            UNIT_ASSERT(TryMergeFromTextFormat(in, message)); 
-            UNIT_ASSERT(NProtoBuf::IsEqual(message, GetCorrectMessage())); 
-        } 
-    } 
+            };
+            UNIT_ASSERT_NO_EXCEPTION(f(m));
+            UNIT_ASSERT(NProtoBuf::IsEqual(empty, m));
+        }
+
+        //
+        // Test cases for `Merge`
+        //
+        {
+            NProtobufUtilUt::TTextTest message;
+            message.SetFoo(100500);
+            TStringInput in{CORRECT_MESSAGE};
+            UNIT_ASSERT(TryMergeFromTextFormat(in, message));
+            UNIT_ASSERT(NProtoBuf::IsEqual(message, GetCorrectMessage()));
+        }
+    }
 
     Y_UNIT_TEST(TestMergeFromString) {
         NProtobufUtilUt::TMergeTest message;
@@ -415,4 +415,4 @@ Y_UNIT_TEST_SUITE(TTestProtoBufIO) {
             UNIT_ASSERT(NProtoBuf::IsEqual(message, m3));
         }
     }
-} 
+}