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

1 files changed, 116 insertions, 116 deletions

diff --git a/library/cpp/http/fetch/httpparser_ut.cpp b/library/cpp/http/fetch/httpparser_ut.cpp
index 3b3b938e7a..6bb83f3971 100644
--- a/library/cpp/http/fetch/httpparser_ut.cpp
+++ b/library/cpp/http/fetch/httpparser_ut.cpp
@@ -1,41 +1,41 @@
-#include "httpparser.h"
-
+#include "httpparser.h" 
+ 
 #include <library/cpp/testing/unittest/registar.h>
-
+ 
 #define ENUM_OUT(arg)  \
     case type ::arg: { \
         out << #arg;   \
         return;        \
     }
-
+ 
 template <>
 void Out<THttpParserBase::States>(IOutputStream& out, THttpParserBase::States st) {
-    using type = THttpParserBase::States;
-    switch (st) {
-        ENUM_OUT(hp_error)
-        ENUM_OUT(hp_eof)
-        ENUM_OUT(hp_in_header)
-        ENUM_OUT(hp_read_alive)
-        ENUM_OUT(hp_read_closed)
-        ENUM_OUT(hp_begin_chunk_header)
-        ENUM_OUT(hp_chunk_header)
-        ENUM_OUT(hp_read_chunk)
-    }
-}
-
-namespace {
+    using type = THttpParserBase::States; 
+    switch (st) { 
+        ENUM_OUT(hp_error) 
+        ENUM_OUT(hp_eof) 
+        ENUM_OUT(hp_in_header) 
+        ENUM_OUT(hp_read_alive) 
+        ENUM_OUT(hp_read_closed) 
+        ENUM_OUT(hp_begin_chunk_header) 
+        ENUM_OUT(hp_chunk_header) 
+        ENUM_OUT(hp_read_chunk) 
+    } 
+} 
+ 
+namespace { 
     class TSomethingLikeFakeCheck;
-
+ 
     using TTestHttpParser = THttpParser<TSomethingLikeFakeCheck>;
-
+ 
     class TSomethingLikeFakeCheck {
         TString Body_;
-
+ 
     public:
         const TString& Body() const {
             return Body_;
         }
-
+ 
         // other functions are not really called by THttpParser
         void CheckDocPart(const void* buf, size_t len, THttpHeader* /* header */) {
             TString s(static_cast<const char*>(buf), len);
@@ -43,74 +43,74 @@ namespace {
             Body_ += s;
         }
     };
-
+ 
 }
-
+ 
 Y_UNIT_TEST_SUITE(TestHttpParser) {
     Y_UNIT_TEST(TestTrivialRequest) {
         const TString blob{
-            "GET /search?q=hi HTTP/1.1\r\n"
-            "Host:  www.google.ru:8080 \r\n"
-            "\r\n"};
-        THttpHeader hdr;
-        THttpParser<> parser;
-        parser.Init(&hdr);
+            "GET /search?q=hi HTTP/1.1\r\n" 
+            "Host:  www.google.ru:8080 \r\n" 
+            "\r\n"}; 
+        THttpHeader hdr; 
+        THttpParser<> parser; 
+        parser.Init(&hdr); 
         parser.Parse((void*)blob.data(), blob.size());
-        UNIT_ASSERT_EQUAL(parser.GetState(), parser.hp_error); // can't parse request as response
-    }
-
-    // XXX: `entity_size` is i32 and `content_length` is i64!
+        UNIT_ASSERT_EQUAL(parser.GetState(), parser.hp_error); // can't parse request as response 
+    } 
+ 
+    // XXX: `entity_size` is i32 and `content_length` is i64! 
     Y_UNIT_TEST(TestTrivialResponse) {
         const TString blob{
-            "HTTP/1.1 200 Ok\r\n"
-            "Content-Length: 2\r\n"
-            "\r\n"
-            "OK"};
-        THttpHeader hdr;
-        TTestHttpParser parser;
-        parser.Init(&hdr);
+            "HTTP/1.1 200 Ok\r\n" 
+            "Content-Length: 2\r\n" 
+            "\r\n" 
+            "OK"}; 
+        THttpHeader hdr; 
+        TTestHttpParser parser; 
+        parser.Init(&hdr); 
         parser.Parse((void*)blob.data(), blob.size());
-        UNIT_ASSERT_EQUAL(parser.GetState(), parser.hp_eof);
-        UNIT_ASSERT_EQUAL(parser.Body(), "OK");
-        UNIT_ASSERT_EQUAL(hdr.header_size, strlen(
+        UNIT_ASSERT_EQUAL(parser.GetState(), parser.hp_eof); 
+        UNIT_ASSERT_EQUAL(parser.Body(), "OK"); 
+        UNIT_ASSERT_EQUAL(hdr.header_size, strlen( 
                                                "HTTP/1.1 200 Ok\r\n"
                                                "Content-Length: 2\r\n"
                                                "\r\n"));
-        UNIT_ASSERT_EQUAL(hdr.entity_size, strlen("OK"));
-    }
-
-    // XXX: `entity_size` is off by one in TE:chunked case.
+        UNIT_ASSERT_EQUAL(hdr.entity_size, strlen("OK")); 
+    } 
+ 
+    // XXX: `entity_size` is off by one in TE:chunked case. 
     Y_UNIT_TEST(TestChunkedResponse) {
         const TString blob{
-            "HTTP/1.1 200 OK\r\n"
-            "Transfer-Encoding: chunked\r\n"
-            "\r\n"
-            "2\r\n"
-            "Ok\r\n"
-            "8\r\n"
-            "AllRight\r\n"
-            "0\r\n"
-            "\r\n"};
-        THttpHeader hdr;
-        TTestHttpParser parser;
-        parser.Init(&hdr);
+            "HTTP/1.1 200 OK\r\n" 
+            "Transfer-Encoding: chunked\r\n" 
+            "\r\n" 
+            "2\r\n" 
+            "Ok\r\n" 
+            "8\r\n" 
+            "AllRight\r\n" 
+            "0\r\n" 
+            "\r\n"}; 
+        THttpHeader hdr; 
+        TTestHttpParser parser; 
+        parser.Init(&hdr); 
         parser.Parse((void*)blob.data(), blob.size());
-        UNIT_ASSERT_EQUAL(parser.GetState(), parser.hp_eof);
-        UNIT_ASSERT_EQUAL(parser.Body(), "OkAllRight");
-        UNIT_ASSERT_EQUAL(hdr.header_size, strlen(
+        UNIT_ASSERT_EQUAL(parser.GetState(), parser.hp_eof); 
+        UNIT_ASSERT_EQUAL(parser.Body(), "OkAllRight"); 
+        UNIT_ASSERT_EQUAL(hdr.header_size, strlen( 
                                                "HTTP/1.1 200 OK\r\n"
                                                "Transfer-Encoding: chunked\r\n"
                                                "\r\n"));
-        const int off_by_one_err = -1; // XXX: it really looks so
-        UNIT_ASSERT_EQUAL(hdr.entity_size + off_by_one_err, strlen(
+        const int off_by_one_err = -1; // XXX: it really looks so 
+        UNIT_ASSERT_EQUAL(hdr.entity_size + off_by_one_err, strlen( 
                                                                 "2\r\n"
                                                                 "Ok\r\n"
                                                                 "8\r\n"
                                                                 "AllRight\r\n"
                                                                 "0\r\n"
                                                                 "\r\n"));
-    }
-
+    } 
+ 
     static const TString PipelineClenBlob_{
         "HTTP/1.1 200 Ok\r\n"
         "Content-Length: 4\r\n"
@@ -120,53 +120,53 @@ Y_UNIT_TEST_SUITE(TestHttpParser) {
         "Content-Length: 4\r\n"
         "\r\n"
         "ZZ\r\n"};
-
+ 
     void AssertPipelineClen(TTestHttpParser & parser, const THttpHeader& hdr) {
-        UNIT_ASSERT_EQUAL(parser.GetState(), parser.hp_eof);
-        UNIT_ASSERT_EQUAL(4, hdr.content_length);
-        UNIT_ASSERT_EQUAL(hdr.header_size, strlen(
+        UNIT_ASSERT_EQUAL(parser.GetState(), parser.hp_eof); 
+        UNIT_ASSERT_EQUAL(4, hdr.content_length); 
+        UNIT_ASSERT_EQUAL(hdr.header_size, strlen( 
                                                "HTTP/1.1 200 Ok\r\n"
                                                "Content-Length: 4\r\n"
                                                "\r\n"));
-    }
-
+    } 
+ 
     Y_UNIT_TEST(TestPipelineClenByteByByte) {
         const TString& blob = PipelineClenBlob_;
-        THttpHeader hdr;
-        TTestHttpParser parser;
-        parser.Init(&hdr);
+        THttpHeader hdr; 
+        TTestHttpParser parser; 
+        parser.Init(&hdr); 
         for (size_t i = 0; i < blob.size(); ++i) {
-            const TStringBuf d{blob, i, 1};
+            const TStringBuf d{blob, i, 1}; 
             parser.Parse((void*)d.data(), d.size());
             Cout << TString(d).Quote() << " -> " << parser.GetState() << Endl;
-        }
-        AssertPipelineClen(parser, hdr);
-        UNIT_ASSERT_EQUAL(parser.Body(), "OK\r\n");
-        UNIT_ASSERT_EQUAL(hdr.entity_size, hdr.content_length);
-    }
-
-    // XXX: Content-Length is ignored, Body() looks unexpected!
+        } 
+        AssertPipelineClen(parser, hdr); 
+        UNIT_ASSERT_EQUAL(parser.Body(), "OK\r\n"); 
+        UNIT_ASSERT_EQUAL(hdr.entity_size, hdr.content_length); 
+    } 
+ 
+    // XXX: Content-Length is ignored, Body() looks unexpected! 
     Y_UNIT_TEST(TestPipelineClenOneChunk) {
         const TString& blob = PipelineClenBlob_;
-        THttpHeader hdr;
-        TTestHttpParser parser;
-        parser.Init(&hdr);
+        THttpHeader hdr; 
+        TTestHttpParser parser; 
+        parser.Init(&hdr); 
         parser.Parse((void*)blob.data(), blob.size());
-        AssertPipelineClen(parser, hdr);
-        UNIT_ASSERT_EQUAL(parser.Body(),
+        AssertPipelineClen(parser, hdr); 
+        UNIT_ASSERT_EQUAL(parser.Body(), 
                           "OK\r\n"
                           "HTTP/1.1 200 Zz\r\n"
                           "Content-Length: 4\r\n"
                           "\r\n"
                           "ZZ\r\n");
-        UNIT_ASSERT_EQUAL(hdr.entity_size, strlen(
+        UNIT_ASSERT_EQUAL(hdr.entity_size, strlen( 
                                                "OK\r\n"
                                                "HTTP/1.1 200 Zz\r\n"
                                                "Content-Length: 4\r\n"
                                                "\r\n"
                                                "ZZ\r\n"));
-    }
-
+    } 
+ 
     static const TString PipelineChunkedBlob_{
         "HTTP/1.1 200 OK\r\n"
         "Transfer-Encoding: chunked\r\n"
@@ -186,46 +186,46 @@ Y_UNIT_TEST_SUITE(TestHttpParser) {
         "uWin!Iam\r\n"
         "0\r\n"
         "\r\n"};
-
+ 
     void AssertPipelineChunked(TTestHttpParser & parser, const THttpHeader& hdr) {
-        UNIT_ASSERT_EQUAL(parser.GetState(), parser.hp_eof);
-        UNIT_ASSERT_EQUAL(parser.Body(), "OkAllRight");
-        UNIT_ASSERT_EQUAL(-1, hdr.content_length);
-        UNIT_ASSERT_EQUAL(hdr.header_size, strlen(
+        UNIT_ASSERT_EQUAL(parser.GetState(), parser.hp_eof); 
+        UNIT_ASSERT_EQUAL(parser.Body(), "OkAllRight"); 
+        UNIT_ASSERT_EQUAL(-1, hdr.content_length); 
+        UNIT_ASSERT_EQUAL(hdr.header_size, strlen( 
                                                "HTTP/1.1 200 OK\r\n"
                                                "Transfer-Encoding: chunked\r\n"
                                                "\r\n"));
-        const int off_by_one_err = -1;
-        UNIT_ASSERT_EQUAL(hdr.entity_size + off_by_one_err, strlen(
+        const int off_by_one_err = -1; 
+        UNIT_ASSERT_EQUAL(hdr.entity_size + off_by_one_err, strlen( 
                                                                 "2\r\n"
                                                                 "Ok\r\n"
                                                                 "8\r\n"
                                                                 "AllRight\r\n"
                                                                 "0\r\n"
                                                                 "\r\n"));
-    }
-
+    } 
+ 
     Y_UNIT_TEST(TestPipelineChunkedByteByByte) {
         const TString& blob = PipelineChunkedBlob_;
-        THttpHeader hdr;
-        TTestHttpParser parser;
-        parser.Init(&hdr);
+        THttpHeader hdr; 
+        TTestHttpParser parser; 
+        parser.Init(&hdr); 
         for (size_t i = 0; i < blob.size(); ++i) {
-            const TStringBuf d{blob, i, 1};
+            const TStringBuf d{blob, i, 1}; 
             parser.Parse((void*)d.data(), d.size());
             Cout << TString(d).Quote() << " -> " << parser.GetState() << Endl;
             if (blob.size() / 2 - 1 <= i) // last \n sets EOF
-                UNIT_ASSERT_EQUAL(parser.GetState(), parser.hp_eof);
-        }
-        AssertPipelineChunked(parser, hdr);
-    }
-
+                UNIT_ASSERT_EQUAL(parser.GetState(), parser.hp_eof); 
+        } 
+        AssertPipelineChunked(parser, hdr); 
+    } 
+ 
     Y_UNIT_TEST(TestPipelineChunkedOneChunk) {
         const TString& blob = PipelineChunkedBlob_;
-        THttpHeader hdr;
-        TTestHttpParser parser;
-        parser.Init(&hdr);
+        THttpHeader hdr; 
+        TTestHttpParser parser; 
+        parser.Init(&hdr); 
         parser.Parse((void*)blob.data(), blob.size());
-        AssertPipelineChunked(parser, hdr);
-    }
-}
+        AssertPipelineChunked(parser, hdr); 
+    } 
+}