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

14 files changed, 189 insertions, 189 deletions

diff --git a/util/network/address.cpp b/util/network/address.cpp
index a81a9e6994..267c2f9092 100644
--- a/util/network/address.cpp
+++ b/util/network/address.cpp
@@ -139,7 +139,7 @@ IRemoteAddrPtr NAddr::GetSockAddr(SOCKET s) {
 
     return addr;
 }
-
+ 
 IRemoteAddrPtr NAddr::GetPeerAddr(SOCKET s) {
     auto addr = MakeHolder<TOpaqueAddr>();
 
@@ -150,41 +150,41 @@ IRemoteAddrPtr NAddr::GetPeerAddr(SOCKET s) {
     return addr;
 }
 
-static const in_addr& InAddr(const IRemoteAddr& addr) {
-    return ((const sockaddr_in*)addr.Addr())->sin_addr;
-}
-
-static const in6_addr& In6Addr(const IRemoteAddr& addr) {
-    return ((const sockaddr_in6*)addr.Addr())->sin6_addr;
-}
-
-bool NAddr::IsLoopback(const IRemoteAddr& addr) {
-    if (addr.Addr()->sa_family == AF_INET) {
+static const in_addr& InAddr(const IRemoteAddr& addr) { 
+    return ((const sockaddr_in*)addr.Addr())->sin_addr; 
+} 
+ 
+static const in6_addr& In6Addr(const IRemoteAddr& addr) { 
+    return ((const sockaddr_in6*)addr.Addr())->sin6_addr; 
+} 
+ 
+bool NAddr::IsLoopback(const IRemoteAddr& addr) { 
+    if (addr.Addr()->sa_family == AF_INET) { 
         return ((ntohl(InAddr(addr).s_addr) >> 24) & 0xff) == 127;
     }
 
     if (addr.Addr()->sa_family == AF_INET6) {
-        return 0 == memcmp(&In6Addr(addr), &in6addr_loopback, sizeof(in6_addr));
-    }
+        return 0 == memcmp(&In6Addr(addr), &in6addr_loopback, sizeof(in6_addr)); 
+    } 
 
     return false;
-}
-
-bool NAddr::IsSame(const IRemoteAddr& lhs, const IRemoteAddr& rhs) {
-    if (lhs.Addr()->sa_family != rhs.Addr()->sa_family) {
-        return false;
+} 
+ 
+bool NAddr::IsSame(const IRemoteAddr& lhs, const IRemoteAddr& rhs) { 
+    if (lhs.Addr()->sa_family != rhs.Addr()->sa_family) { 
+        return false; 
     }
 
     if (lhs.Addr()->sa_family == AF_INET) {
-        return InAddr(lhs).s_addr == InAddr(rhs).s_addr;
+        return InAddr(lhs).s_addr == InAddr(rhs).s_addr; 
     }
 
     if (lhs.Addr()->sa_family == AF_INET6) {
-        return 0 == memcmp(&In6Addr(lhs), &In6Addr(rhs), sizeof(in6_addr));
-    }
-
-    ythrow yexception() << "unsupported addr family: " << lhs.Addr()->sa_family;
-}
+        return 0 == memcmp(&In6Addr(lhs), &In6Addr(rhs), sizeof(in6_addr)); 
+    } 
+ 
+    ythrow yexception() << "unsupported addr family: " << lhs.Addr()->sa_family; 
+} 
 
 socklen_t NAddr::SockAddrLength(const sockaddr* addr) {
     switch (addr->sa_family) {
diff --git a/util/network/address.h b/util/network/address.h
index 448fcac0c9..b88c3558fc 100644
--- a/util/network/address.h
+++ b/util/network/address.h
@@ -25,9 +25,9 @@ namespace NAddr {
     TString PrintHost(const IRemoteAddr& addr);
     TString PrintHostAndPort(const IRemoteAddr& addr);
 
-    bool IsLoopback(const IRemoteAddr& addr);
-    bool IsSame(const IRemoteAddr& lhs, const IRemoteAddr& rhs);
-
+    bool IsLoopback(const IRemoteAddr& addr); 
+    bool IsSame(const IRemoteAddr& lhs, const IRemoteAddr& rhs); 
+ 
     socklen_t SockAddrLength(const sockaddr* addr);
 
     //for accept, recvfrom - see LenPtr()
diff --git a/util/network/endpoint.h b/util/network/endpoint.h
index a3e59b4925..959b14d394 100644
--- a/util/network/endpoint.h
+++ b/util/network/endpoint.h
@@ -54,7 +54,7 @@ struct THash<TEndpoint> {
 
 inline bool operator==(const TEndpoint& l, const TEndpoint& r) {
     try {
-        return NAddr::IsSame(*l.Addr(), *r.Addr()) && l.Port() == r.Port();
+        return NAddr::IsSame(*l.Addr(), *r.Addr()) && l.Port() == r.Port(); 
     } catch (...) {
         return false;
     }
diff --git a/util/network/endpoint_ut.cpp b/util/network/endpoint_ut.cpp
index d5e40dd6e1..ed26b111cf 100644
--- a/util/network/endpoint_ut.cpp
+++ b/util/network/endpoint_ut.cpp
@@ -85,27 +85,27 @@ Y_UNIT_TEST_SUITE(TEndpointTest) {
 
         UNIT_ASSERT_VALUES_EQUAL(5u, he.size());
     }
-
+ 
     Y_UNIT_TEST(TestEqual) {
         const TString ip1 = "2a02:6b8:0:1410::5f6c:f3c2";
         const TString ip2 = "2a02:6b8:0:1410::5f6c:f3c3";
 
         TNetworkAddress na1(ip1, 24242);
-        TEndpoint ep1(new NAddr::TAddrInfo(&*na1.Begin()));
-
+        TEndpoint ep1(new NAddr::TAddrInfo(&*na1.Begin())); 
+ 
         TNetworkAddress na2(ip1, 24242);
-        TEndpoint ep2(new NAddr::TAddrInfo(&*na2.Begin()));
-
+        TEndpoint ep2(new NAddr::TAddrInfo(&*na2.Begin())); 
+ 
         TNetworkAddress na3(ip2, 24242);
-        TEndpoint ep3(new NAddr::TAddrInfo(&*na3.Begin()));
-
+        TEndpoint ep3(new NAddr::TAddrInfo(&*na3.Begin())); 
+ 
         TNetworkAddress na4(ip2, 24243);
-        TEndpoint ep4(new NAddr::TAddrInfo(&*na4.Begin()));
-
-        UNIT_ASSERT(ep1 == ep2);
-        UNIT_ASSERT(!(ep1 == ep3));
-        UNIT_ASSERT(!(ep1 == ep4));
-    }
+        TEndpoint ep4(new NAddr::TAddrInfo(&*na4.Begin())); 
+ 
+        UNIT_ASSERT(ep1 == ep2); 
+        UNIT_ASSERT(!(ep1 == ep3)); 
+        UNIT_ASSERT(!(ep1 == ep4)); 
+    } 
 
     Y_UNIT_TEST(TestIsUnixSocket) {
         TNetworkAddress na1(TUnixSocketPath("/tmp/unixsocket"));
diff --git a/util/stream/buffered.cpp b/util/stream/buffered.cpp
index a00e592e1c..6c8519bdfe 100644
--- a/util/stream/buffered.cpp
+++ b/util/stream/buffered.cpp
@@ -71,13 +71,13 @@ public:
 
         while (true) {
             if (MemInput_.Exhausted()) {
-                const size_t bytesRead = Slave_->Read(Buf(), BufLen());
+                const size_t bytesRead = Slave_->Read(Buf(), BufLen()); 
 
-                if (!bytesRead) {
+                if (!bytesRead) { 
                     break;
                 }
 
-                MemInput_.Reset(Buf(), bytesRead);
+                MemInput_.Reset(Buf(), bytesRead); 
             }
 
             const size_t a_len(MemInput_.Avail());
diff --git a/util/stream/ios_ut.cpp b/util/stream/ios_ut.cpp
index 139f4296e5..9db05b9fba 100644
--- a/util/stream/ios_ut.cpp
+++ b/util/stream/ios_ut.cpp
@@ -261,21 +261,21 @@ void TStreamsTest::TestBufferStream() {
 
     stream.Write(s.data(), s.size());
     char buf[5];
-    size_t bytesRead = stream.Read(buf, 4);
-    UNIT_ASSERT_EQUAL(4, bytesRead);
+    size_t bytesRead = stream.Read(buf, 4); 
+    UNIT_ASSERT_EQUAL(4, bytesRead); 
     UNIT_ASSERT_EQUAL(0, strncmp(s.data(), buf, 4));
 
     stream.Write(s.data(), s.size());
-    bytesRead = stream.Read(buf, 2);
-    UNIT_ASSERT_EQUAL(2, bytesRead);
+    bytesRead = stream.Read(buf, 2); 
+    UNIT_ASSERT_EQUAL(2, bytesRead); 
     UNIT_ASSERT_EQUAL(0, strncmp("te", buf, 2));
 
-    bytesRead = stream.Read(buf, 2);
-    UNIT_ASSERT_EQUAL(2, bytesRead);
+    bytesRead = stream.Read(buf, 2); 
+    UNIT_ASSERT_EQUAL(2, bytesRead); 
     UNIT_ASSERT_EQUAL(0, strncmp("st", buf, 2));
 
-    bytesRead = stream.Read(buf, 2);
-    UNIT_ASSERT_EQUAL(0, bytesRead);
+    bytesRead = stream.Read(buf, 2); 
+    UNIT_ASSERT_EQUAL(0, bytesRead); 
 }
 
 namespace {
diff --git a/util/stream/tokenizer.h b/util/stream/tokenizer.h
index b2398efdd1..41f5f2a76d 100644
--- a/util/stream/tokenizer.h
+++ b/util/stream/tokenizer.h
@@ -173,11 +173,11 @@ public:
 private:
     inline size_t Fill() {
         const size_t avail = BufEnd() - End_;
-        const size_t bytesRead = Input_->Read(End_, avail);
+        const size_t bytesRead = Input_->Read(End_, avail); 
 
-        End_ += bytesRead;
+        End_ += bytesRead; 
 
-        return bytesRead;
+        return bytesRead; 
     }
 
     inline char* BufBegin() noexcept {
diff --git a/util/stream/zerocopy.cpp b/util/stream/zerocopy.cpp
index dc2982ad55..be27642733 100644
--- a/util/stream/zerocopy.cpp
+++ b/util/stream/zerocopy.cpp
@@ -44,12 +44,12 @@ size_t IZeroCopyInputFastReadTo::DoReadTo(TString& st, char ch) {
     st.clear();
     do {
         if (const char* pos = (const char*)memchr(ptr, ch, len)) {
-            size_t bytesRead = (pos - ptr) + 1;
-            if (bytesRead > 1) {
+            size_t bytesRead = (pos - ptr) + 1; 
+            if (bytesRead > 1) { 
                 st.append(ptr, pos);
             }
-            Undo(len - bytesRead);
-            result += bytesRead;
+            Undo(len - bytesRead); 
+            result += bytesRead; 
             return result;
         } else {
             result += len;
diff --git a/util/system/direct_io.cpp b/util/system/direct_io.cpp
index f59c54b0cb..ea4dc39382 100644
--- a/util/system/direct_io.cpp
+++ b/util/system/direct_io.cpp
@@ -110,7 +110,7 @@ void TDirectIOBufferedFile::Finish() {
     File.Close();
 }
 
-void TDirectIOBufferedFile::Write(const void* buffer, size_t byteCount) {
+void TDirectIOBufferedFile::Write(const void* buffer, size_t byteCount) { 
     WriteToBuffer(buffer, byteCount, DataLen);
     WritePosition += byteCount;
 }
@@ -146,51 +146,51 @@ void TDirectIOBufferedFile::WriteToFile(const void* buf, size_t len, ui64 positi
     }
 }
 
-size_t TDirectIOBufferedFile::PreadSafe(void* buffer, size_t byteCount, ui64 offset) {
+size_t TDirectIOBufferedFile::PreadSafe(void* buffer, size_t byteCount, ui64 offset) { 
     if (FlushedToDisk < offset + byteCount) {
         File.FlushData();
         FlushedToDisk = FlushedBytes;
     }
 
-#ifdef _linux_
-    ssize_t bytesRead = 0;
-    do {
-        bytesRead = pread(File.GetHandle(), buffer, byteCount, offset);
-    } while (bytesRead == -1 && errno == EINTR);
+#ifdef _linux_ 
+    ssize_t bytesRead = 0; 
+    do { 
+        bytesRead = pread(File.GetHandle(), buffer, byteCount, offset); 
+    } while (bytesRead == -1 && errno == EINTR); 
 
-    if (bytesRead < 0) {
+    if (bytesRead < 0) { 
         ythrow yexception() << "error while pread file: " << LastSystemError() << "(" << LastSystemErrorText() << ")";
     }
 
-    return bytesRead;
-#else
-    return File.Pread(buffer, byteCount, offset);
-#endif
+    return bytesRead; 
+#else 
+    return File.Pread(buffer, byteCount, offset); 
+#endif 
 }
 
-size_t TDirectIOBufferedFile::ReadFromFile(void* buffer, size_t byteCount, ui64 offset) {
-    SetDirectIO(true);
-
-    ui64 bytesRead = 0;
-
-    while (byteCount) {
-        if (!Alignment || IsAligned(buffer) && IsAligned(byteCount) && IsAligned(offset)) {
-            if (const ui64 fromFile = PreadSafe(buffer, byteCount, offset)) {
-                buffer = (char*)buffer + fromFile;
-                byteCount -= fromFile;
-                offset += fromFile;
-                bytesRead += fromFile;
-            } else {
-                return bytesRead;
-            }
-        } else {
-            break;
-        }
+size_t TDirectIOBufferedFile::ReadFromFile(void* buffer, size_t byteCount, ui64 offset) { 
+    SetDirectIO(true); 
+ 
+    ui64 bytesRead = 0; 
+ 
+    while (byteCount) { 
+        if (!Alignment || IsAligned(buffer) && IsAligned(byteCount) && IsAligned(offset)) { 
+            if (const ui64 fromFile = PreadSafe(buffer, byteCount, offset)) { 
+                buffer = (char*)buffer + fromFile; 
+                byteCount -= fromFile; 
+                offset += fromFile; 
+                bytesRead += fromFile; 
+            } else { 
+                return bytesRead; 
+            } 
+        } else { 
+            break; 
+        } 
     }
 
-    if (!byteCount) {
-        return bytesRead;
-    }
+    if (!byteCount) { 
+        return bytesRead; 
+    } 
 
     ui64 bufSize = AlignUp(Min<size_t>(BufferStorage.Size(), byteCount + (Alignment << 1)), Alignment);
     TBuffer readBufferStorage(bufSize + Alignment);
@@ -199,59 +199,59 @@ size_t TDirectIOBufferedFile::ReadFromFile(void* buffer, size_t byteCount, ui64
     while (byteCount) {
         ui64 begin = AlignDown(offset, (ui64)Alignment);
         ui64 end = AlignUp(offset + byteCount, (ui64)Alignment);
-        ui64 toRead = Min(end - begin, bufSize);
-        ui64 fromFile = PreadSafe(readBuffer, toRead, begin);
+        ui64 toRead = Min(end - begin, bufSize); 
+        ui64 fromFile = PreadSafe(readBuffer, toRead, begin); 
 
         if (!fromFile) {
             break;
         }
 
-        ui64 delta = offset - begin;
-        ui64 count = Min<ui64>(fromFile - delta, byteCount);
+        ui64 delta = offset - begin; 
+        ui64 count = Min<ui64>(fromFile - delta, byteCount); 
 
         memcpy(buffer, readBuffer + delta, count);
         buffer = (char*)buffer + count;
         byteCount -= count;
         offset += count;
-        bytesRead += count;
+        bytesRead += count; 
     }
-    return bytesRead;
+    return bytesRead; 
 }
 
-size_t TDirectIOBufferedFile::Read(void* buffer, size_t byteCount) {
-    size_t bytesRead = Pread(buffer, byteCount, ReadPosition);
-    ReadPosition += bytesRead;
-    return bytesRead;
+size_t TDirectIOBufferedFile::Read(void* buffer, size_t byteCount) { 
+    size_t bytesRead = Pread(buffer, byteCount, ReadPosition); 
+    ReadPosition += bytesRead; 
+    return bytesRead; 
 }
 
-size_t TDirectIOBufferedFile::Pread(void* buffer, size_t byteCount, ui64 offset) {
+size_t TDirectIOBufferedFile::Pread(void* buffer, size_t byteCount, ui64 offset) { 
     if (!byteCount) {
         return 0;
     }
 
-    size_t readFromFile = 0;
+    size_t readFromFile = 0; 
     if (offset < FlushedBytes) {
         readFromFile = Min<ui64>(byteCount, FlushedBytes - offset);
-        size_t bytesRead = ReadFromFile(buffer, readFromFile, offset);
-        if (bytesRead != readFromFile || readFromFile == byteCount) {
-            return bytesRead;
+        size_t bytesRead = ReadFromFile(buffer, readFromFile, offset); 
+        if (bytesRead != readFromFile || readFromFile == byteCount) { 
+            return bytesRead; 
         }
     }
     ui64 start = offset > FlushedBytes ? offset - FlushedBytes : 0;
-    ui64 count = Min<ui64>(DataLen - start, byteCount - readFromFile);
+    ui64 count = Min<ui64>(DataLen - start, byteCount - readFromFile); 
     if (count) {
         memcpy((char*)buffer + readFromFile, (const char*)Buffer + start, count);
     }
     return count + readFromFile;
 }
 
-void TDirectIOBufferedFile::Pwrite(const void* buffer, size_t byteCount, ui64 offset) {
+void TDirectIOBufferedFile::Pwrite(const void* buffer, size_t byteCount, ui64 offset) { 
     if (offset > WritePosition) {
         ythrow yexception() << "cannot frite to position" << offset;
     }
 
-    size_t writeToBufer = byteCount;
-    size_t writeToFile = 0;
+    size_t writeToBufer = byteCount; 
+    size_t writeToFile = 0; 
 
     if (FlushedBytes > offset) {
         writeToFile = Min<ui64>(byteCount, FlushedBytes - offset);
diff --git a/util/system/direct_io.h b/util/system/direct_io.h
index 6a3325a960..ec1ff84356 100644
--- a/util/system/direct_io.h
+++ b/util/system/direct_io.h
@@ -16,10 +16,10 @@ public:
 
     void FlushData();
     void Finish();
-    size_t Read(void* buffer, size_t byteCount);
-    void Write(const void* buffer, size_t byteCount);
-    size_t Pread(void* buffer, size_t byteCount, ui64 offset);
-    void Pwrite(const void* buffer, size_t byteCount, ui64 offset);
+    size_t Read(void* buffer, size_t byteCount); 
+    void Write(const void* buffer, size_t byteCount); 
+    size_t Pread(void* buffer, size_t byteCount, ui64 offset); 
+    void Pwrite(const void* buffer, size_t byteCount, ui64 offset); 
 
     inline bool IsOpen() const {
         return true;
@@ -54,8 +54,8 @@ private:
         return Alignment ? value == AlignDown(value, Alignment) : true;
     }
 
-    size_t PreadSafe(void* buffer, size_t byteCount, ui64 offset);
-    size_t ReadFromFile(void* buffer, size_t byteCount, ui64 offset);
+    size_t PreadSafe(void* buffer, size_t byteCount, ui64 offset); 
+    size_t ReadFromFile(void* buffer, size_t byteCount, ui64 offset); 
     void WriteToFile(const void* buf, size_t len, ui64 position);
     void WriteToBuffer(const void* buf, size_t len, ui64 position);
     void SetDirectIO(bool value);
diff --git a/util/system/direct_io_ut.cpp b/util/system/direct_io_ut.cpp
index 839c3de7ca..36c1a20d63 100644
--- a/util/system/direct_io_ut.cpp
+++ b/util/system/direct_io_ut.cpp
@@ -2,7 +2,7 @@
 
 #include <util/generic/yexception.h>
 #include <util/system/fs.h>
-#include <util/system/tempfile.h>
+#include <util/system/tempfile.h> 
 #include <util/random/random.h>
 
 #include "direct_io.h"
@@ -13,7 +13,7 @@ Y_UNIT_TEST_SUITE(TDirectIoTestSuite) {
     Y_UNIT_TEST(TestDirectFile) {
         TDirectIOBufferedFile file(FileName_, RdWr | Direct | Seq | CreateAlways, 1 << 15);
         TVector<ui64> data((1 << 15) + 1);
-        TVector<ui64> readResult(data.size());
+        TVector<ui64> readResult(data.size()); 
         for (auto& i : data) {
             i = RandomNumber<ui64>();
         }
@@ -24,10 +24,10 @@ Y_UNIT_TEST_SUITE(TDirectIoTestSuite) {
             size_t readPos = RandomNumber(writePos);
             size_t readCount = RandomNumber(writePos - readPos);
             UNIT_ASSERT_VALUES_EQUAL(
-                file.Pread(&readResult[0], readCount * sizeof(ui64), readPos * sizeof(ui64)),
+                file.Pread(&readResult[0], readCount * sizeof(ui64), readPos * sizeof(ui64)), 
                 readCount * sizeof(ui64));
             for (size_t i = 0; i < readCount; ++i) {
-                UNIT_ASSERT_VALUES_EQUAL(readResult[i], data[i + readPos]);
+                UNIT_ASSERT_VALUES_EQUAL(readResult[i], data[i + readPos]); 
             }
         }
         file.Finish();
@@ -36,56 +36,56 @@ Y_UNIT_TEST_SUITE(TDirectIoTestSuite) {
             size_t readPos = RandomNumber(data.size());
             size_t readCount = RandomNumber(data.size() - readPos);
             UNIT_ASSERT_VALUES_EQUAL(
-                fileNew.Pread(&readResult[0], readCount * sizeof(ui64), readPos * sizeof(ui64)),
+                fileNew.Pread(&readResult[0], readCount * sizeof(ui64), readPos * sizeof(ui64)), 
                 readCount * sizeof(ui64));
             for (size_t j = 0; j < readCount; ++j) {
-                UNIT_ASSERT_VALUES_EQUAL(readResult[j], data[j + readPos]);
+                UNIT_ASSERT_VALUES_EQUAL(readResult[j], data[j + readPos]); 
             }
         }
         size_t readCount = data.size();
         UNIT_ASSERT_VALUES_EQUAL(
-            fileNew.Pread(&readResult[0], readCount * sizeof(ui64), 0),
+            fileNew.Pread(&readResult[0], readCount * sizeof(ui64), 0), 
             readCount * sizeof(ui64));
         for (size_t i = 0; i < readCount; ++i) {
-            UNIT_ASSERT_VALUES_EQUAL(readResult[i], data[i]);
+            UNIT_ASSERT_VALUES_EQUAL(readResult[i], data[i]); 
         }
         NFs::Remove(FileName_);
     }
 
-    void TestHugeFile(size_t size) {
-        TTempFile tmpFile("test.file");
-
-        {
-            TDirectIOBufferedFile directIOFile(tmpFile.Name(), WrOnly | CreateAlways | Direct);
-            TVector<ui8> data(size, 'x');
-            directIOFile.Write(&data[0], data.size());
-        }
-
-        {
-            TDirectIOBufferedFile directIOFile(tmpFile.Name(), RdOnly | Direct);
-            TVector<ui8> data(size + 1, 'y');
-
-            const size_t readResult = directIOFile.Read(&data[0], data.size());
-
-            UNIT_ASSERT_VALUES_EQUAL(readResult, size);
-
-            UNIT_ASSERT_VALUES_EQUAL(data[0], 'x');
-            UNIT_ASSERT_VALUES_EQUAL(data[size / 2], 'x');
-            UNIT_ASSERT_VALUES_EQUAL(data[size - 1], 'x');
-            UNIT_ASSERT_VALUES_EQUAL(data[size], 'y');
-        }
-    }
-
-    Y_UNIT_TEST(TestHugeFile1) {
+    void TestHugeFile(size_t size) { 
+        TTempFile tmpFile("test.file"); 
+ 
+        { 
+            TDirectIOBufferedFile directIOFile(tmpFile.Name(), WrOnly | CreateAlways | Direct); 
+            TVector<ui8> data(size, 'x'); 
+            directIOFile.Write(&data[0], data.size()); 
+        } 
+ 
+        { 
+            TDirectIOBufferedFile directIOFile(tmpFile.Name(), RdOnly | Direct); 
+            TVector<ui8> data(size + 1, 'y'); 
+ 
+            const size_t readResult = directIOFile.Read(&data[0], data.size()); 
+ 
+            UNIT_ASSERT_VALUES_EQUAL(readResult, size); 
+ 
+            UNIT_ASSERT_VALUES_EQUAL(data[0], 'x'); 
+            UNIT_ASSERT_VALUES_EQUAL(data[size / 2], 'x'); 
+            UNIT_ASSERT_VALUES_EQUAL(data[size - 1], 'x'); 
+            UNIT_ASSERT_VALUES_EQUAL(data[size], 'y'); 
+        } 
+    } 
+ 
+    Y_UNIT_TEST(TestHugeFile1) { 
         if constexpr (sizeof(size_t) > 4) {
-            TestHugeFile(5 * 1024 * 1024 * 1024ULL);
-        }
-    }
-    Y_UNIT_TEST(TestHugeFile2) {
+            TestHugeFile(5 * 1024 * 1024 * 1024ULL); 
+        } 
+    } 
+    Y_UNIT_TEST(TestHugeFile2) { 
         if constexpr (sizeof(size_t) > 4) {
-            TestHugeFile(5 * 1024 * 1024 * 1024ULL + 1111);
-        }
-    }
+            TestHugeFile(5 * 1024 * 1024 * 1024ULL + 1111); 
+        } 
+    } 
 }
 
 Y_UNIT_TEST_SUITE(TDirectIoErrorHandling) {
diff --git a/util/system/file.cpp b/util/system/file.cpp
index 4a261d020c..6115799e8d 100644
--- a/util/system/file.cpp
+++ b/util/system/file.cpp
@@ -1191,10 +1191,10 @@ size_t TFile::Pread(void* buf, size_t len, i64 offset) const {
     return Impl_->Pread(buf, len, offset);
 }
 
-i32 TFile::RawPread(void* buf, ui32 len, i64 offset) const {
-    return Impl_->RawPread(buf, len, offset);
-}
-
+i32 TFile::RawPread(void* buf, ui32 len, i64 offset) const { 
+    return Impl_->RawPread(buf, len, offset); 
+} 
+ 
 void TFile::Pload(void* buf, size_t len, i64 offset) const {
     Impl_->Pload(buf, len, offset);
 }
diff --git a/util/system/file.h b/util/system/file.h
index 9502e159b6..3b18ae07ce 100644
--- a/util/system/file.h
+++ b/util/system/file.h
@@ -186,8 +186,8 @@ public:
 
     // Retries incomplete reads until EOF, throws on error
     size_t Pread(void* buf, size_t len, i64 offset) const;
-    // Single pread call
-    i32 RawPread(void* buf, ui32 len, i64 offset) const;
+    // Single pread call 
+    i32 RawPread(void* buf, ui32 len, i64 offset) const; 
     // Reads exactly len bytes, throws on premature EOF or error
     void Pload(void* buf, size_t len, i64 offset) const;
 
diff --git a/util/system/file_ut.cpp b/util/system/file_ut.cpp
index 941e6a50f3..2d5343c94d 100644
--- a/util/system/file_ut.cpp
+++ b/util/system/file_ut.cpp
@@ -21,7 +21,7 @@ class TFileTest: public TTestBase {
     UNIT_TEST(TestFlushSpecialFile);
     UNIT_TEST(TestRawRead);
     UNIT_TEST(TestRead);
-    UNIT_TEST(TestRawPread);
+    UNIT_TEST(TestRawPread); 
     UNIT_TEST(TestPread);
     UNIT_TEST(TestCache);
     UNIT_TEST_SUITE_END();
@@ -35,7 +35,7 @@ public:
     void TestFlushSpecialFile();
     void TestRawRead();
     void TestRead();
-    void TestRawPread();
+    void TestRawPread(); 
     void TestPread();
     void TestCache();
 
@@ -281,30 +281,30 @@ void TFileTest::TestRead() {
     }
 }
 
-void TFileTest::TestRawPread() {
-    TTempFile tmp("tmp");
-
-    {
-        TFile file(tmp.Name(), OpenAlways | WrOnly);
-        file.Write("1234567", 7);
-        file.Flush();
-        file.Close();
-    }
-
-    {
-        TFile file(tmp.Name(), OpenExisting | RdOnly);
-        char buf[7];
-        i32 reallyRead = file.RawPread(buf, 3, 1);
-        Y_ENSURE(0 <= reallyRead && reallyRead <= 3);
-        Y_ENSURE(TStringBuf(buf, reallyRead) == TStringBuf("234").Head(reallyRead));
-
-        memset(buf, 0, sizeof(buf));
-        reallyRead = file.RawPread(buf, 2, 5);
-        Y_ENSURE(0 <= reallyRead && reallyRead <= 2);
-        Y_ENSURE(TStringBuf(buf, reallyRead) == TStringBuf("67").Head(reallyRead));
-    }
-}
-
+void TFileTest::TestRawPread() { 
+    TTempFile tmp("tmp"); 
+ 
+    { 
+        TFile file(tmp.Name(), OpenAlways | WrOnly); 
+        file.Write("1234567", 7); 
+        file.Flush(); 
+        file.Close(); 
+    } 
+ 
+    { 
+        TFile file(tmp.Name(), OpenExisting | RdOnly); 
+        char buf[7]; 
+        i32 reallyRead = file.RawPread(buf, 3, 1); 
+        Y_ENSURE(0 <= reallyRead && reallyRead <= 3); 
+        Y_ENSURE(TStringBuf(buf, reallyRead) == TStringBuf("234").Head(reallyRead)); 
+ 
+        memset(buf, 0, sizeof(buf)); 
+        reallyRead = file.RawPread(buf, 2, 5); 
+        Y_ENSURE(0 <= reallyRead && reallyRead <= 2); 
+        Y_ENSURE(TStringBuf(buf, reallyRead) == TStringBuf("67").Head(reallyRead)); 
+    } 
+} 
+ 
 void TFileTest::TestPread() {
     TTempFile tmp("tmp");