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

7 files changed, 1102 insertions, 1102 deletions

diff --git a/util/datetime/base.h b/util/datetime/base.h
index 5e902b8f63..7ea581de40 100644
--- a/util/datetime/base.h
+++ b/util/datetime/base.h
@@ -60,15 +60,15 @@ inline void sprint_date8601(char* buf, time_t when) {
     buf[FormatDate8601(buf, 64, when)] = 0;
 }
 
-bool ParseISO8601DateTimeDeprecated(const char* date, time_t& utcTime);
-bool ParseISO8601DateTimeDeprecated(const char* date, size_t dateLen, time_t& utcTime);
-bool ParseRFC822DateTimeDeprecated(const char* date, time_t& utcTime);
-bool ParseRFC822DateTimeDeprecated(const char* date, size_t dateLen, time_t& utcTime);
-bool ParseHTTPDateTimeDeprecated(const char* date, time_t& utcTime);
-bool ParseHTTPDateTimeDeprecated(const char* date, size_t dateLen, time_t& utcTime);
-bool ParseX509ValidityDateTimeDeprecated(const char* date, time_t& utcTime);
-bool ParseX509ValidityDateTimeDeprecated(const char* date, size_t dateLen, time_t& utcTime);
-
+bool ParseISO8601DateTimeDeprecated(const char* date, time_t& utcTime); 
+bool ParseISO8601DateTimeDeprecated(const char* date, size_t dateLen, time_t& utcTime); 
+bool ParseRFC822DateTimeDeprecated(const char* date, time_t& utcTime); 
+bool ParseRFC822DateTimeDeprecated(const char* date, size_t dateLen, time_t& utcTime); 
+bool ParseHTTPDateTimeDeprecated(const char* date, time_t& utcTime); 
+bool ParseHTTPDateTimeDeprecated(const char* date, size_t dateLen, time_t& utcTime); 
+bool ParseX509ValidityDateTimeDeprecated(const char* date, time_t& utcTime); 
+bool ParseX509ValidityDateTimeDeprecated(const char* date, size_t dateLen, time_t& utcTime); 
+ 
 bool ParseISO8601DateTime(const char* date, time_t& utcTime);
 bool ParseISO8601DateTime(const char* date, size_t dateLen, time_t& utcTime);
 bool ParseRFC822DateTime(const char* date, time_t& utcTime);
@@ -525,12 +525,12 @@ public:
     ///
     /// @link https://tools.ietf.org/html/rfc822#section-5 Description of format.
     static bool TryParseRfc822(TStringBuf input, TInstant& instant);
-
+ 
     /// RFC 2616 3.3.1 Full Date
     ///
     /// @link https://tools.ietf.org/html/rfc2616#section-3.3.1 Description of format.
     static bool TryParseHttp(TStringBuf input, TInstant& instant);
-
+ 
     /// X.509 certificate validity time (see rfc5280 4.1.2.5.*)
     ///
     /// @link https://tools.ietf.org/html/rfc5280#section-4.1.2.5 Description of format.
diff --git a/util/datetime/base.pxd b/util/datetime/base.pxd
index 1d863b1bd8..e450f1c7f4 100644
--- a/util/datetime/base.pxd
+++ b/util/datetime/base.pxd
@@ -76,25 +76,25 @@ cdef extern from "<util/datetime/base.h>" nogil:
         @staticmethod
         bool_t TryParseX509(const TStringBuf, TInstant&) except +
 
-        @staticmethod
-        TInstant ParseIso8601Deprecated(const TStringBuf) except +
-        @staticmethod
-        TInstant ParseRfc822Deprecated(const TStringBuf) except +
-        @staticmethod
-        TInstant ParseHttpDeprecated(const TStringBuf) except +
-        @staticmethod
-        TInstant ParseX509ValidityDeprecated(const TStringBuf) except +
-
-        @staticmethod
-        bool_t TryParseIso8601Deprecated(const TStringBuf, TInstant&) except +
-        @staticmethod
-        bool_t TryParseRfc822Deprecated(const TStringBuf, TInstant&) except +
-        @staticmethod
-        bool_t TryParseHttpDeprecated(const TStringBuf, TInstant&) except +
-        @staticmethod
-        bool_t TryParseX509Deprecated(const TStringBuf, TInstant&) except +
-
-
+        @staticmethod 
+        TInstant ParseIso8601Deprecated(const TStringBuf) except + 
+        @staticmethod 
+        TInstant ParseRfc822Deprecated(const TStringBuf) except + 
+        @staticmethod 
+        TInstant ParseHttpDeprecated(const TStringBuf) except + 
+        @staticmethod 
+        TInstant ParseX509ValidityDeprecated(const TStringBuf) except + 
+
+        @staticmethod 
+        bool_t TryParseIso8601Deprecated(const TStringBuf, TInstant&) except + 
+        @staticmethod 
+        bool_t TryParseRfc822Deprecated(const TStringBuf, TInstant&) except + 
+        @staticmethod 
+        bool_t TryParseHttpDeprecated(const TStringBuf, TInstant&) except + 
+        @staticmethod 
+        bool_t TryParseX509Deprecated(const TStringBuf, TInstant&) except + 
+ 
+ 
     cdef cppclass TDuration(TTimeBase):
         TDuration()
         TDuration(uint64_t)
diff --git a/util/datetime/parser.h b/util/datetime/parser.h
index f0c1b4a0c7..386ec84822 100644
--- a/util/datetime/parser.h
+++ b/util/datetime/parser.h
@@ -7,7 +7,7 @@
 struct TDateTimeFields {
     TDateTimeFields() {
         Zero(*this);
-        ZoneOffsetMinutes = 0;
+        ZoneOffsetMinutes = 0; 
         Hour = 0;
     }
 
@@ -155,140 +155,140 @@ struct TDurationParser {
     bool ParsePart(const char* input, size_t len);
     TDuration GetResult(TDuration defaultValue) const;
 };
-
-/**
-Depcrecated cause of default hour offset (+4 hours)
-@see IGNIETFERRO-823
-*/
-struct TDateTimeFieldsDeprecated {
-    TDateTimeFieldsDeprecated() {
-        Zero(*this);
-        ZoneOffsetMinutes = (i32)TDuration::Hours(4).Minutes(); // legacy code
-        Hour = 11;
-    }
-
-    ui32 Year;
-    ui32 Month;       // 1..12
-    ui32 Day;         // 1 .. 31
-    ui32 Hour;        // 0 .. 23
-    ui32 Minute;      // 0 .. 59
-    ui32 Second;      // 0 .. 60
-    ui32 MicroSecond; // 0 .. 999999
-    i32 ZoneOffsetMinutes;
-
-    void SetLooseYear(ui32 year) {
-        if (year < 60)
-            year += 100;
-        if (year < 160)
-            year += 1900;
-        Year = year;
-    }
-
-    bool IsOk() const noexcept {
-        if (Year < 1970)
-            return false;
-        if (Month < 1 || Month > 12)
-            return false;
-
-        unsigned int maxMonthDay = 31;
-        if (Month == 4 || Month == 6 || Month == 9 || Month == 11) {
-            maxMonthDay = 30;
-        } else if (Month == 2) {
-            if (Year % 4 == 0 && (Year % 100 != 0 || Year % 400 == 0))
-                // leap year
-                maxMonthDay = 29;
-            else
-                maxMonthDay = 28;
-        }
-        if (Day > maxMonthDay)
-            return false;
-
-        if (Hour > 23)
-            return false;
-
-        if (Minute > 59)
-            return false;
-
-        if (Second > 60)
-            return false;
-
-        if (MicroSecond > 999999)
-            return false;
-
-        if (Year == 1970 && Month == 1 && Day == 1) {
-            if ((i64)(3600 * Hour + 60 * Minute + Second) < (60 * ZoneOffsetMinutes))
-                return false;
-        }
-
-        return true;
-    }
-
-    TInstant ToInstant(TInstant defaultValue) const {
-        time_t tt = ToTimeT(-1);
-        if (tt == -1)
-            return defaultValue;
-        return TInstant::Seconds(tt) + TDuration::MicroSeconds(MicroSecond);
-    }
-
-    time_t ToTimeT(time_t defaultValue) const {
-        if (!IsOk())
-            return defaultValue;
-        struct tm tm;
-        Zero(tm);
-        tm.tm_year = Year - 1900;
-        tm.tm_mon = Month - 1;
-        tm.tm_mday = Day;
-        tm.tm_hour = Hour;
-        tm.tm_min = Minute;
-        tm.tm_sec = Second;
-        time_t tt = TimeGM(&tm);
-        if (tt == -1)
-            return defaultValue;
-        return tt - ZoneOffsetMinutes * 60;
-    }
-};
-
-class TDateTimeParserBaseDeprecated {
-public:
-    const TDateTimeFieldsDeprecated& GetDateTimeFields() const {
-        return DateTimeFields;
-    }
-
-protected:
-    TDateTimeFieldsDeprecated DateTimeFields;
-    int cs; //for ragel
-    int Sign;
-    int I;
-    int Dc;
-
-protected:
-    TDateTimeParserBaseDeprecated()
-        : DateTimeFields()
-        , cs(0)
-        , Sign(0)
-        , I(0xDEADBEEF) // to guarantee unittest break if ragel code is incorrect
-        , Dc(0xDEADBEEF)
-    {
-    }
-
-    inline TInstant GetResult(int firstFinalState, TInstant defaultValue) const {
-        if (cs < firstFinalState)
-            return defaultValue;
-        return DateTimeFields.ToInstant(defaultValue);
-    }
-};
-
+ 
+/** 
+Depcrecated cause of default hour offset (+4 hours) 
+@see IGNIETFERRO-823 
+*/ 
+struct TDateTimeFieldsDeprecated { 
+    TDateTimeFieldsDeprecated() { 
+        Zero(*this); 
+        ZoneOffsetMinutes = (i32)TDuration::Hours(4).Minutes(); // legacy code 
+        Hour = 11; 
+    } 
+ 
+    ui32 Year; 
+    ui32 Month;       // 1..12 
+    ui32 Day;         // 1 .. 31 
+    ui32 Hour;        // 0 .. 23 
+    ui32 Minute;      // 0 .. 59 
+    ui32 Second;      // 0 .. 60 
+    ui32 MicroSecond; // 0 .. 999999 
+    i32 ZoneOffsetMinutes; 
+ 
+    void SetLooseYear(ui32 year) { 
+        if (year < 60) 
+            year += 100; 
+        if (year < 160) 
+            year += 1900; 
+        Year = year; 
+    } 
+ 
+    bool IsOk() const noexcept { 
+        if (Year < 1970) 
+            return false; 
+        if (Month < 1 || Month > 12) 
+            return false; 
+ 
+        unsigned int maxMonthDay = 31; 
+        if (Month == 4 || Month == 6 || Month == 9 || Month == 11) { 
+            maxMonthDay = 30; 
+        } else if (Month == 2) { 
+            if (Year % 4 == 0 && (Year % 100 != 0 || Year % 400 == 0)) 
+                // leap year 
+                maxMonthDay = 29; 
+            else 
+                maxMonthDay = 28; 
+        } 
+        if (Day > maxMonthDay) 
+            return false; 
+ 
+        if (Hour > 23) 
+            return false; 
+ 
+        if (Minute > 59) 
+            return false; 
+ 
+        if (Second > 60) 
+            return false; 
+ 
+        if (MicroSecond > 999999) 
+            return false; 
+ 
+        if (Year == 1970 && Month == 1 && Day == 1) { 
+            if ((i64)(3600 * Hour + 60 * Minute + Second) < (60 * ZoneOffsetMinutes)) 
+                return false; 
+        } 
+ 
+        return true; 
+    } 
+ 
+    TInstant ToInstant(TInstant defaultValue) const { 
+        time_t tt = ToTimeT(-1); 
+        if (tt == -1) 
+            return defaultValue; 
+        return TInstant::Seconds(tt) + TDuration::MicroSeconds(MicroSecond); 
+    } 
+ 
+    time_t ToTimeT(time_t defaultValue) const { 
+        if (!IsOk()) 
+            return defaultValue; 
+        struct tm tm; 
+        Zero(tm); 
+        tm.tm_year = Year - 1900; 
+        tm.tm_mon = Month - 1; 
+        tm.tm_mday = Day; 
+        tm.tm_hour = Hour; 
+        tm.tm_min = Minute; 
+        tm.tm_sec = Second; 
+        time_t tt = TimeGM(&tm); 
+        if (tt == -1) 
+            return defaultValue; 
+        return tt - ZoneOffsetMinutes * 60; 
+    } 
+}; 
+ 
+class TDateTimeParserBaseDeprecated { 
+public: 
+    const TDateTimeFieldsDeprecated& GetDateTimeFields() const { 
+        return DateTimeFields; 
+    } 
+ 
+protected: 
+    TDateTimeFieldsDeprecated DateTimeFields; 
+    int cs; //for ragel 
+    int Sign; 
+    int I; 
+    int Dc; 
+ 
+protected: 
+    TDateTimeParserBaseDeprecated() 
+        : DateTimeFields() 
+        , cs(0) 
+        , Sign(0) 
+        , I(0xDEADBEEF) // to guarantee unittest break if ragel code is incorrect 
+        , Dc(0xDEADBEEF) 
+    { 
+    } 
+ 
+    inline TInstant GetResult(int firstFinalState, TInstant defaultValue) const { 
+        if (cs < firstFinalState) 
+            return defaultValue; 
+        return DateTimeFields.ToInstant(defaultValue); 
+    } 
+}; 
+ 
 #define DECLARE_PARSER(CLASS)                            \
     struct CLASS: public TDateTimeParserBaseDeprecated { \
         CLASS();                                         \
         bool ParsePart(const char* input, size_t len);   \
         TInstant GetResult(TInstant defaultValue) const; \
-    };
-
-DECLARE_PARSER(TIso8601DateTimeParserDeprecated)
-DECLARE_PARSER(TRfc822DateTimeParserDeprecated)
-DECLARE_PARSER(THttpDateTimeParserDeprecated)
-DECLARE_PARSER(TX509ValidityDateTimeParserDeprecated)
-DECLARE_PARSER(TX509Validity4yDateTimeParserDeprecated)
-
-#undef DECLARE_PARSER
+    }; 
+ 
+DECLARE_PARSER(TIso8601DateTimeParserDeprecated) 
+DECLARE_PARSER(TRfc822DateTimeParserDeprecated) 
+DECLARE_PARSER(THttpDateTimeParserDeprecated) 
+DECLARE_PARSER(TX509ValidityDateTimeParserDeprecated) 
+DECLARE_PARSER(TX509Validity4yDateTimeParserDeprecated) 
+ 
+#undef DECLARE_PARSER 
diff --git a/util/datetime/parser.rl6 b/util/datetime/parser.rl6
index 931f09eae1..86e714ab59 100644
--- a/util/datetime/parser.rl6
+++ b/util/datetime/parser.rl6
@@ -163,23 +163,11 @@ write data noerror;
 
 }%%
 
-TRfc822DateTimeParserDeprecated::TRfc822DateTimeParserDeprecated() {
+TRfc822DateTimeParserDeprecated::TRfc822DateTimeParserDeprecated() { 
     %% write init;
 }
 
-bool TRfc822DateTimeParserDeprecated::ParsePart(const char* input, size_t len) {
-    const char* p = input;
-    const char* pe = input + len;
-
-    %% write exec;
-    return cs != %%{ write error; }%%;
-}
-
-TRfc822DateTimeParser::TRfc822DateTimeParser() {
-    %% write init;
-}
-
-bool TRfc822DateTimeParser::ParsePart(const char* input, size_t len) {
+bool TRfc822DateTimeParserDeprecated::ParsePart(const char* input, size_t len) { 
     const char* p = input;
     const char* pe = input + len;
 
@@ -187,6 +175,18 @@ bool TRfc822DateTimeParser::ParsePart(const char* input, size_t len) {
     return cs != %%{ write error; }%%;
 }
 
+TRfc822DateTimeParser::TRfc822DateTimeParser() { 
+    %% write init; 
+} 
+ 
+bool TRfc822DateTimeParser::ParsePart(const char* input, size_t len) { 
+    const char* p = input; 
+    const char* pe = input + len; 
+ 
+    %% write exec; 
+    return cs != %%{ write error; }%%; 
+} 
+ 
 %%{
 
 machine ISO8601DateTimeParser;
@@ -223,23 +223,11 @@ write data noerror;
 
 }%%
 
-TIso8601DateTimeParserDeprecated::TIso8601DateTimeParserDeprecated() {
-    %% write init;
-}
-
-bool TIso8601DateTimeParserDeprecated::ParsePart(const char* input, size_t len) {
-    const char* p = input;
-    const char* pe = input + len;
-
-    %% write exec;
-    return cs != %%{ write error; }%%;
-}
-
-TIso8601DateTimeParser::TIso8601DateTimeParser() {
+TIso8601DateTimeParserDeprecated::TIso8601DateTimeParserDeprecated() { 
     %% write init;
 }
 
-bool TIso8601DateTimeParser::ParsePart(const char* input, size_t len) {
+bool TIso8601DateTimeParserDeprecated::ParsePart(const char* input, size_t len) { 
     const char* p = input;
     const char* pe = input + len;
 
@@ -247,6 +235,18 @@ bool TIso8601DateTimeParser::ParsePart(const char* input, size_t len) {
     return cs != %%{ write error; }%%;
 }
 
+TIso8601DateTimeParser::TIso8601DateTimeParser() { 
+    %% write init; 
+} 
+ 
+bool TIso8601DateTimeParser::ParsePart(const char* input, size_t len) { 
+    const char* p = input; 
+    const char* pe = input + len; 
+ 
+    %% write exec; 
+    return cs != %%{ write error; }%%; 
+} 
+ 
 %%{
 
 machine HttpDateTimeParser;
@@ -279,23 +279,11 @@ write data noerror;
 
 }%%
 
-THttpDateTimeParserDeprecated::THttpDateTimeParserDeprecated() {
+THttpDateTimeParserDeprecated::THttpDateTimeParserDeprecated() { 
     %% write init;
 }
 
-bool THttpDateTimeParserDeprecated::ParsePart(const char* input, size_t len) {
-    const char* p = input;
-    const char* pe = input + len;
-
-    %% write exec;
-    return cs != %%{ write error; }%%;
-}
-
-THttpDateTimeParser::THttpDateTimeParser() {
-    %% write init;
-}
-
-bool THttpDateTimeParser::ParsePart(const char* input, size_t len) {
+bool THttpDateTimeParserDeprecated::ParsePart(const char* input, size_t len) { 
     const char* p = input;
     const char* pe = input + len;
 
@@ -303,6 +291,18 @@ bool THttpDateTimeParser::ParsePart(const char* input, size_t len) {
     return cs != %%{ write error; }%%;
 }
 
+THttpDateTimeParser::THttpDateTimeParser() { 
+    %% write init; 
+} 
+ 
+bool THttpDateTimeParser::ParsePart(const char* input, size_t len) { 
+    const char* p = input; 
+    const char* pe = input + len; 
+ 
+    %% write exec; 
+    return cs != %%{ write error; }%%; 
+} 
+ 
 %%{
 
 machine X509ValidityDateTimeParser;
@@ -325,23 +325,11 @@ write data noerror;
 
 }%%
 
-TX509ValidityDateTimeParserDeprecated::TX509ValidityDateTimeParserDeprecated() {
-    %% write init;
-}
-
-bool TX509ValidityDateTimeParserDeprecated::ParsePart(const char *input, size_t len) {
-    const char *p = input;
-    const char *pe = input + len;
-
-    %% write exec;
-    return cs != %%{ write error; }%%;
-}
-
-TX509ValidityDateTimeParser::TX509ValidityDateTimeParser() {
+TX509ValidityDateTimeParserDeprecated::TX509ValidityDateTimeParserDeprecated() { 
     %% write init;
 }
 
-bool TX509ValidityDateTimeParser::ParsePart(const char *input, size_t len) {
+bool TX509ValidityDateTimeParserDeprecated::ParsePart(const char *input, size_t len) { 
     const char *p = input;
     const char *pe = input + len;
 
@@ -349,6 +337,18 @@ bool TX509ValidityDateTimeParser::ParsePart(const char *input, size_t len) {
     return cs != %%{ write error; }%%;
 }
 
+TX509ValidityDateTimeParser::TX509ValidityDateTimeParser() { 
+    %% write init; 
+} 
+ 
+bool TX509ValidityDateTimeParser::ParsePart(const char *input, size_t len) { 
+    const char *p = input; 
+    const char *pe = input + len; 
+ 
+    %% write exec; 
+    return cs != %%{ write error; }%%; 
+} 
+ 
 %%{
 
 machine X509Validity4yDateTimeParser;
@@ -370,11 +370,11 @@ write data noerror;
 
 }%%
 
-TX509Validity4yDateTimeParserDeprecated::TX509Validity4yDateTimeParserDeprecated() {
+TX509Validity4yDateTimeParserDeprecated::TX509Validity4yDateTimeParserDeprecated() { 
     %% write init;
 }
 
-bool TX509Validity4yDateTimeParserDeprecated::ParsePart(const char *input, size_t len) {
+bool TX509Validity4yDateTimeParserDeprecated::ParsePart(const char *input, size_t len) { 
     const char *p = input;
     const char *pe = input + len;
 
@@ -382,68 +382,68 @@ bool TX509Validity4yDateTimeParserDeprecated::ParsePart(const char *input, size_
     return cs != %%{ write error; }%%;
 }
 
-TX509Validity4yDateTimeParser::TX509Validity4yDateTimeParser() {
-    %% write init;
-}
-
-bool TX509Validity4yDateTimeParser::ParsePart(const char *input, size_t len) {
-    const char *p = input;
-    const char *pe = input + len;
-
-    %% write exec;
-    return cs != %%{ write error; }%%;
-}
-
-TInstant TIso8601DateTimeParserDeprecated::GetResult(TInstant defaultValue) const {
-    Y_UNUSED(ISO8601DateTimeParser_en_main);
-    return TDateTimeParserBaseDeprecated::GetResult(ISO8601DateTimeParser_first_final, defaultValue);
-}
-
-TInstant TRfc822DateTimeParserDeprecated::GetResult(TInstant defaultValue) const {
-    Y_UNUSED(RFC822DateParser_en_main);
-    return TDateTimeParserBaseDeprecated::GetResult(RFC822DateParser_first_final, defaultValue);
-}
-
-TInstant THttpDateTimeParserDeprecated::GetResult(TInstant defaultValue) const {
-    Y_UNUSED(HttpDateTimeParserStandalone_en_main);
-    return TDateTimeParserBaseDeprecated::GetResult(HttpDateTimeParserStandalone_first_final, defaultValue);
-}
-
-TInstant TX509ValidityDateTimeParserDeprecated::GetResult(TInstant defaultValue) const {
-    Y_UNUSED(X509ValidityDateTimeParser_en_main);
-    return TDateTimeParserBaseDeprecated::GetResult(X509ValidityDateTimeParser_first_final, defaultValue);
-}
-
-TInstant TX509Validity4yDateTimeParserDeprecated::GetResult(TInstant defaultValue) const {
-    Y_UNUSED(X509Validity4yDateTimeParser_en_main);
-    return TDateTimeParserBaseDeprecated::GetResult(X509Validity4yDateTimeParser_first_final, defaultValue);
-}
-
-TInstant TIso8601DateTimeParser::GetResult(TInstant defaultValue) const {
+TX509Validity4yDateTimeParser::TX509Validity4yDateTimeParser() { 
+    %% write init; 
+} 
+ 
+bool TX509Validity4yDateTimeParser::ParsePart(const char *input, size_t len) { 
+    const char *p = input; 
+    const char *pe = input + len; 
+ 
+    %% write exec; 
+    return cs != %%{ write error; }%%; 
+} 
+ 
+TInstant TIso8601DateTimeParserDeprecated::GetResult(TInstant defaultValue) const { 
     Y_UNUSED(ISO8601DateTimeParser_en_main);
-    return TDateTimeParserBase::GetResult(ISO8601DateTimeParser_first_final, defaultValue);
+    return TDateTimeParserBaseDeprecated::GetResult(ISO8601DateTimeParser_first_final, defaultValue); 
 }
 
-TInstant TRfc822DateTimeParser::GetResult(TInstant defaultValue) const {
+TInstant TRfc822DateTimeParserDeprecated::GetResult(TInstant defaultValue) const { 
     Y_UNUSED(RFC822DateParser_en_main);
-    return TDateTimeParserBase::GetResult(RFC822DateParser_first_final, defaultValue);
+    return TDateTimeParserBaseDeprecated::GetResult(RFC822DateParser_first_final, defaultValue); 
 }
 
-TInstant THttpDateTimeParser::GetResult(TInstant defaultValue) const {
+TInstant THttpDateTimeParserDeprecated::GetResult(TInstant defaultValue) const { 
     Y_UNUSED(HttpDateTimeParserStandalone_en_main);
-    return TDateTimeParserBase::GetResult(HttpDateTimeParserStandalone_first_final, defaultValue);
+    return TDateTimeParserBaseDeprecated::GetResult(HttpDateTimeParserStandalone_first_final, defaultValue); 
 }
 
-TInstant TX509ValidityDateTimeParser::GetResult(TInstant defaultValue) const {
+TInstant TX509ValidityDateTimeParserDeprecated::GetResult(TInstant defaultValue) const { 
     Y_UNUSED(X509ValidityDateTimeParser_en_main);
-    return TDateTimeParserBase::GetResult(X509ValidityDateTimeParser_first_final, defaultValue);
+    return TDateTimeParserBaseDeprecated::GetResult(X509ValidityDateTimeParser_first_final, defaultValue); 
 }
 
-TInstant TX509Validity4yDateTimeParser::GetResult(TInstant defaultValue) const {
+TInstant TX509Validity4yDateTimeParserDeprecated::GetResult(TInstant defaultValue) const { 
     Y_UNUSED(X509Validity4yDateTimeParser_en_main);
-    return TDateTimeParserBase::GetResult(X509Validity4yDateTimeParser_first_final, defaultValue);
-}
-
+    return TDateTimeParserBaseDeprecated::GetResult(X509Validity4yDateTimeParser_first_final, defaultValue); 
+}
+
+TInstant TIso8601DateTimeParser::GetResult(TInstant defaultValue) const { 
+    Y_UNUSED(ISO8601DateTimeParser_en_main); 
+    return TDateTimeParserBase::GetResult(ISO8601DateTimeParser_first_final, defaultValue); 
+} 
+ 
+TInstant TRfc822DateTimeParser::GetResult(TInstant defaultValue) const { 
+    Y_UNUSED(RFC822DateParser_en_main); 
+    return TDateTimeParserBase::GetResult(RFC822DateParser_first_final, defaultValue); 
+} 
+ 
+TInstant THttpDateTimeParser::GetResult(TInstant defaultValue) const { 
+    Y_UNUSED(HttpDateTimeParserStandalone_en_main); 
+    return TDateTimeParserBase::GetResult(HttpDateTimeParserStandalone_first_final, defaultValue); 
+} 
+ 
+TInstant TX509ValidityDateTimeParser::GetResult(TInstant defaultValue) const { 
+    Y_UNUSED(X509ValidityDateTimeParser_en_main); 
+    return TDateTimeParserBase::GetResult(X509ValidityDateTimeParser_first_final, defaultValue); 
+} 
+ 
+TInstant TX509Validity4yDateTimeParser::GetResult(TInstant defaultValue) const { 
+    Y_UNUSED(X509Validity4yDateTimeParser_en_main); 
+    return TDateTimeParserBase::GetResult(X509Validity4yDateTimeParser_first_final, defaultValue); 
+} 
+ 
 template<class TParser, class TResult>
 static inline TResult Parse(const char* input, size_t len, TResult defaultValue) {
     TParser parser;
@@ -460,19 +460,19 @@ static inline TResult ParseUnsafe(const char* input, size_t len) {
     return r;
 }
 
-TInstant TInstant::ParseIso8601Deprecated(const TStringBuf input) {
+TInstant TInstant::ParseIso8601Deprecated(const TStringBuf input) { 
     return ParseUnsafe<TIso8601DateTimeParserDeprecated, TInstant>(input.data(), input.size());
 }
 
-TInstant TInstant::ParseRfc822Deprecated(const TStringBuf input) {
+TInstant TInstant::ParseRfc822Deprecated(const TStringBuf input) { 
     return ParseUnsafe<TRfc822DateTimeParserDeprecated, TInstant>(input.data(), input.size());
 }
 
-TInstant TInstant::ParseHttpDeprecated(const TStringBuf input) {
+TInstant TInstant::ParseHttpDeprecated(const TStringBuf input) { 
     return ParseUnsafe<THttpDateTimeParserDeprecated, TInstant>(input.data(), input.size());
 }
 
-TInstant TInstant::ParseX509ValidityDeprecated(const TStringBuf input) {
+TInstant TInstant::ParseX509ValidityDeprecated(const TStringBuf input) { 
     switch (input.size()) {
     case 13:
         return ParseUnsafe<TX509ValidityDateTimeParserDeprecated, TInstant>(input.data(), 13);
@@ -483,7 +483,7 @@ TInstant TInstant::ParseX509ValidityDeprecated(const TStringBuf input) {
     }
 }
 
-bool TInstant::TryParseIso8601Deprecated(const TStringBuf input, TInstant& instant) {
+bool TInstant::TryParseIso8601Deprecated(const TStringBuf input, TInstant& instant) { 
     const auto parsed = ParseUnsafe<TIso8601DateTimeParserDeprecated, TInstant, false>(input.data(), input.size());
     if (TInstant::Max() == parsed) {
         return false;
@@ -492,7 +492,7 @@ bool TInstant::TryParseIso8601Deprecated(const TStringBuf input, TInstant& insta
     return true;
 }
 
-bool TInstant::TryParseRfc822Deprecated(const TStringBuf input, TInstant& instant) {
+bool TInstant::TryParseRfc822Deprecated(const TStringBuf input, TInstant& instant) { 
     const auto parsed = ParseUnsafe<TRfc822DateTimeParserDeprecated, TInstant, false>(input.data(), input.size());
     if (TInstant::Max() == parsed) {
         return false;
@@ -501,7 +501,7 @@ bool TInstant::TryParseRfc822Deprecated(const TStringBuf input, TInstant& instan
     return true;
 }
 
-bool TInstant::TryParseHttpDeprecated(const TStringBuf input, TInstant& instant) {
+bool TInstant::TryParseHttpDeprecated(const TStringBuf input, TInstant& instant) { 
     const auto parsed = ParseUnsafe<THttpDateTimeParserDeprecated, TInstant, false>(input.data(), input.size());
     if (TInstant::Max() == parsed) {
         return false;
@@ -510,7 +510,7 @@ bool TInstant::TryParseHttpDeprecated(const TStringBuf input, TInstant& instant)
     return true;
 }
 
-bool TInstant::TryParseX509Deprecated(const TStringBuf input, TInstant& instant) {
+bool TInstant::TryParseX509Deprecated(const TStringBuf input, TInstant& instant) { 
     TInstant parsed;
     switch (input.size()) {
         case 13:
@@ -529,136 +529,136 @@ bool TInstant::TryParseX509Deprecated(const TStringBuf input, TInstant& instant)
     return true;
 }
 
-TInstant TInstant::ParseIso8601(const TStringBuf input) {
+TInstant TInstant::ParseIso8601(const TStringBuf input) { 
     return ParseUnsafe<TIso8601DateTimeParser, TInstant>(input.data(), input.size());
-}
-
-TInstant TInstant::ParseRfc822(const TStringBuf input) {
+} 
+ 
+TInstant TInstant::ParseRfc822(const TStringBuf input) { 
     return ParseUnsafe<TRfc822DateTimeParser, TInstant>(input.data(), input.size());
-}
-
-TInstant TInstant::ParseHttp(const TStringBuf input) {
+} 
+ 
+TInstant TInstant::ParseHttp(const TStringBuf input) { 
     return ParseUnsafe<THttpDateTimeParser, TInstant>(input.data(), input.size());
-}
-
-TInstant TInstant::ParseX509Validity(const TStringBuf input) {
+} 
+ 
+TInstant TInstant::ParseX509Validity(const TStringBuf input) { 
     switch (input.size()) {
-    case 13:
+    case 13: 
         return ParseUnsafe<TX509ValidityDateTimeParser, TInstant>(input.data(), 13);
-    case 15:
+    case 15: 
         return ParseUnsafe<TX509Validity4yDateTimeParser, TInstant>(input.data(), 15);
-    default:
-        ythrow TDateTimeParseException();
-    }
-}
-
-bool TInstant::TryParseIso8601(const TStringBuf input, TInstant& instant) {
+    default: 
+        ythrow TDateTimeParseException(); 
+    } 
+} 
+ 
+bool TInstant::TryParseIso8601(const TStringBuf input, TInstant& instant) { 
     const auto parsed = ParseUnsafe<TIso8601DateTimeParser, TInstant, false>(input.data(), input.size());
-    if (TInstant::Max() == parsed) {
-        return false;
-    }
-    instant = parsed;
-    return true;
-}
-
-bool TInstant::TryParseRfc822(const TStringBuf input, TInstant& instant) {
+    if (TInstant::Max() == parsed) { 
+        return false; 
+    } 
+    instant = parsed; 
+    return true; 
+} 
+ 
+bool TInstant::TryParseRfc822(const TStringBuf input, TInstant& instant) { 
     const auto parsed = ParseUnsafe<TRfc822DateTimeParser, TInstant, false>(input.data(), input.size());
-    if (TInstant::Max() == parsed) {
-        return false;
-    }
-    instant = parsed;
-    return true;
-}
-
-bool TInstant::TryParseHttp(const TStringBuf input, TInstant& instant) {
+    if (TInstant::Max() == parsed) { 
+        return false; 
+    } 
+    instant = parsed; 
+    return true; 
+} 
+ 
+bool TInstant::TryParseHttp(const TStringBuf input, TInstant& instant) { 
     const auto parsed = ParseUnsafe<THttpDateTimeParser, TInstant, false>(input.data(), input.size());
-    if (TInstant::Max() == parsed) {
-        return false;
-    }
-    instant = parsed;
-    return true;
-}
-
-bool TInstant::TryParseX509(const TStringBuf input, TInstant& instant) {
-    TInstant parsed;
+    if (TInstant::Max() == parsed) { 
+        return false; 
+    } 
+    instant = parsed; 
+    return true; 
+} 
+ 
+bool TInstant::TryParseX509(const TStringBuf input, TInstant& instant) { 
+    TInstant parsed; 
     switch (input.size()) {
-        case 13:
+        case 13: 
             parsed = ParseUnsafe<TX509ValidityDateTimeParser, TInstant, false>(input.data(), 13);
-            break;
-        case 15:
+            break; 
+        case 15: 
             parsed = ParseUnsafe<TX509Validity4yDateTimeParser, TInstant, false>(input.data(), 15);
-            break;
-        default:
-            return false;
-    }
-    if (TInstant::Max() == parsed) {
-        return false;
-    }
-    instant = parsed;
-    return true;
-}
-
-bool ParseRFC822DateTimeDeprecated(const char* input, time_t& utcTime) {
-    return ParseRFC822DateTimeDeprecated(input, strlen(input), utcTime);
-}
-
-bool ParseISO8601DateTimeDeprecated(const char* input, time_t& utcTime) {
-    return ParseISO8601DateTimeDeprecated(input, strlen(input), utcTime);
-}
-
-bool ParseHTTPDateTimeDeprecated(const char* input, time_t& utcTime) {
-    return ParseHTTPDateTimeDeprecated(input, strlen(input), utcTime);
-}
-
-bool ParseX509ValidityDateTimeDeprecated(const char* input, time_t& utcTime) {
-    return ParseX509ValidityDateTimeDeprecated(input, strlen(input), utcTime);
-}
-
-bool ParseRFC822DateTimeDeprecated(const char* input, size_t inputLen, time_t& utcTime) {
-    try {
-        utcTime = ParseUnsafe<TRfc822DateTimeParserDeprecated, TInstant>(input, inputLen).TimeT();
-        return true;
-    } catch (const TDateTimeParseException&) {
-        return false;
-    }
-}
-
-bool ParseISO8601DateTimeDeprecated(const char* input, size_t inputLen, time_t& utcTime) {
-    try {
-        utcTime = ParseUnsafe<TIso8601DateTimeParserDeprecated, TInstant>(input, inputLen).TimeT();
-        return true;
-    } catch (const TDateTimeParseException&) {
-        return false;
-    }
-}
-
-bool ParseHTTPDateTimeDeprecated(const char* input, size_t inputLen, time_t& utcTime) {
-    try {
-        utcTime = ParseUnsafe<THttpDateTimeParserDeprecated, TInstant>(input, inputLen).TimeT();
-        return true;
-    } catch (const TDateTimeParseException&) {
-        return false;
-    }
-}
-
-bool ParseX509ValidityDateTimeDeprecated(const char* input, size_t inputLen, time_t& utcTime) {
-    TInstant r;
-    switch (inputLen) {
-    case 13:
-        r = Parse<TX509ValidityDateTimeParserDeprecated, TInstant>(input, 13, TInstant::Max());
-        break;
-    case 15:
-        r = Parse<TX509Validity4yDateTimeParserDeprecated, TInstant>(input, 15, TInstant::Max());
-        break;
-    default:
-        return false;
-    }
-    if (r == TInstant::Max())
-        return false;
-    utcTime = r.TimeT();
-    return true;
-}
-
+            break; 
+        default: 
+            return false; 
+    } 
+    if (TInstant::Max() == parsed) { 
+        return false; 
+    } 
+    instant = parsed; 
+    return true; 
+} 
+ 
+bool ParseRFC822DateTimeDeprecated(const char* input, time_t& utcTime) { 
+    return ParseRFC822DateTimeDeprecated(input, strlen(input), utcTime); 
+} 
+ 
+bool ParseISO8601DateTimeDeprecated(const char* input, time_t& utcTime) { 
+    return ParseISO8601DateTimeDeprecated(input, strlen(input), utcTime); 
+} 
+ 
+bool ParseHTTPDateTimeDeprecated(const char* input, time_t& utcTime) { 
+    return ParseHTTPDateTimeDeprecated(input, strlen(input), utcTime); 
+} 
+ 
+bool ParseX509ValidityDateTimeDeprecated(const char* input, time_t& utcTime) { 
+    return ParseX509ValidityDateTimeDeprecated(input, strlen(input), utcTime); 
+} 
+ 
+bool ParseRFC822DateTimeDeprecated(const char* input, size_t inputLen, time_t& utcTime) { 
+    try { 
+        utcTime = ParseUnsafe<TRfc822DateTimeParserDeprecated, TInstant>(input, inputLen).TimeT(); 
+        return true; 
+    } catch (const TDateTimeParseException&) { 
+        return false; 
+    } 
+} 
+ 
+bool ParseISO8601DateTimeDeprecated(const char* input, size_t inputLen, time_t& utcTime) { 
+    try { 
+        utcTime = ParseUnsafe<TIso8601DateTimeParserDeprecated, TInstant>(input, inputLen).TimeT(); 
+        return true; 
+    } catch (const TDateTimeParseException&) { 
+        return false; 
+    } 
+} 
+ 
+bool ParseHTTPDateTimeDeprecated(const char* input, size_t inputLen, time_t& utcTime) { 
+    try { 
+        utcTime = ParseUnsafe<THttpDateTimeParserDeprecated, TInstant>(input, inputLen).TimeT(); 
+        return true; 
+    } catch (const TDateTimeParseException&) { 
+        return false; 
+    } 
+} 
+ 
+bool ParseX509ValidityDateTimeDeprecated(const char* input, size_t inputLen, time_t& utcTime) { 
+    TInstant r; 
+    switch (inputLen) { 
+    case 13: 
+        r = Parse<TX509ValidityDateTimeParserDeprecated, TInstant>(input, 13, TInstant::Max()); 
+        break; 
+    case 15: 
+        r = Parse<TX509Validity4yDateTimeParserDeprecated, TInstant>(input, 15, TInstant::Max()); 
+        break; 
+    default: 
+        return false; 
+    } 
+    if (r == TInstant::Max()) 
+        return false; 
+    utcTime = r.TimeT(); 
+    return true; 
+} 
+ 
 bool ParseRFC822DateTime(const char* input, time_t& utcTime) {
     return ParseRFC822DateTime(input, strlen(input), utcTime);
 }
@@ -677,7 +677,7 @@ bool ParseX509ValidityDateTime(const char* input, time_t& utcTime) {
 
 bool ParseRFC822DateTime(const char* input, size_t inputLen, time_t& utcTime) {
     try {
-        utcTime = ParseUnsafe<TRfc822DateTimeParser, TInstant>(input, inputLen).TimeT();
+        utcTime = ParseUnsafe<TRfc822DateTimeParser, TInstant>(input, inputLen).TimeT(); 
         return true;
     } catch (const TDateTimeParseException&) {
         return false;
@@ -686,7 +686,7 @@ bool ParseRFC822DateTime(const char* input, size_t inputLen, time_t& utcTime) {
 
 bool ParseISO8601DateTime(const char* input, size_t inputLen, time_t& utcTime) {
     try {
-        utcTime = ParseUnsafe<TIso8601DateTimeParser, TInstant>(input, inputLen).TimeT();
+        utcTime = ParseUnsafe<TIso8601DateTimeParser, TInstant>(input, inputLen).TimeT(); 
         return true;
     } catch (const TDateTimeParseException&) {
         return false;
@@ -695,7 +695,7 @@ bool ParseISO8601DateTime(const char* input, size_t inputLen, time_t& utcTime) {
 
 bool ParseHTTPDateTime(const char* input, size_t inputLen, time_t& utcTime) {
     try {
-        utcTime = ParseUnsafe<THttpDateTimeParser, TInstant>(input, inputLen).TimeT();
+        utcTime = ParseUnsafe<THttpDateTimeParser, TInstant>(input, inputLen).TimeT(); 
         return true;
     } catch (const TDateTimeParseException&) {
         return false;
@@ -706,10 +706,10 @@ bool ParseX509ValidityDateTime(const char* input, size_t inputLen, time_t& utcTi
     TInstant r;
     switch (inputLen) {
     case 13:
-        r = Parse<TX509ValidityDateTimeParser, TInstant>(input, 13, TInstant::Max());
+        r = Parse<TX509ValidityDateTimeParser, TInstant>(input, 13, TInstant::Max()); 
         break;
     case 15:
-        r = Parse<TX509Validity4yDateTimeParser, TInstant>(input, 15, TInstant::Max());
+        r = Parse<TX509Validity4yDateTimeParser, TInstant>(input, 15, TInstant::Max()); 
         break;
     default:
         return false;
diff --git a/util/datetime/parser_deprecated_ut.cpp b/util/datetime/parser_deprecated_ut.cpp
index 6ad9f885b1..2ef11ee95f 100644
--- a/util/datetime/parser_deprecated_ut.cpp
+++ b/util/datetime/parser_deprecated_ut.cpp
@@ -1,576 +1,576 @@
-#include "parser.h"
-
+#include "parser.h" 
+ 
 #include <library/cpp/testing/unittest/registar.h>
-
-static const time_t SECONDS_PER_HOUR = 3600;
-static const time_t SECONDS_PER_MINUTE = 60;
-
-Y_UNIT_TEST_SUITE(TDateTimeParseTestDeprecated) {
-    Y_UNIT_TEST(TestRfc822CorrectDeprecated) {
-        bool r = false;
-        time_t t = 0;
-
-        // predefined time zones
-
-        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 UT", t);
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885);
-
-        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 GMT", t);
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885);
-
-        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 EST", t);
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_VALUES_EQUAL(t, (time_t)1109964885 + 5 * SECONDS_PER_HOUR);
-        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 EDT", t);
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 4 * SECONDS_PER_HOUR);
-
-        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 CST", t);
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 6 * SECONDS_PER_HOUR);
-        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 CDT", t);
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 5 * SECONDS_PER_HOUR);
-
-        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 MST", t);
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 7 * SECONDS_PER_HOUR);
-        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 MDT", t);
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 6 * SECONDS_PER_HOUR);
-
-        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 PST", t);
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 8 * SECONDS_PER_HOUR);
-        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 PDT", t);
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 7 * SECONDS_PER_HOUR);
-
-        // optinal century
-        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 05 19:34:45 UT", t);
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885);
-
-        // + optional day of week
-        r = ParseRFC822DateTimeDeprecated("4 Mar 05 19:34:45 UT", t);
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885);
-
-        // + optional seconds
-        r = ParseRFC822DateTimeDeprecated("4 Mar 05 19:34 UT", t);
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964840);
-
-        // local differential hour+min
-
-        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 +0300", t);
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)1109954085);
-
-        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 05 19:34:45 +0300", t);
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)1109954085);
-
-        r = ParseRFC822DateTimeDeprecated("21 Apr 1999 23:40:00 +0400", t);
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)924723600);
-
-        r = ParseRFC822DateTimeDeprecated("21 Apr 99 23:40 +0400", t);
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)924723600);
-
-        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 -0300", t);
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 3 * SECONDS_PER_HOUR);
-
-        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34 -0300", t);
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964840 + 3 * SECONDS_PER_HOUR);
-
-        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 05 19:34:45 -0330", t);
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 3 * SECONDS_PER_HOUR + 30 * SECONDS_PER_MINUTE);
-
-        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 05 19:34 -0330", t);
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964840 + 3 * SECONDS_PER_HOUR + 30 * SECONDS_PER_MINUTE);
-
-        r = ParseRFC822DateTimeDeprecated("4 Mar 2005 19:34:45 -1030", t);
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 10 * SECONDS_PER_HOUR + 30 * SECONDS_PER_MINUTE);
-
-        r = ParseRFC822DateTimeDeprecated("4 Mar 2005 19:34 -1030", t);
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964840 + 10 * SECONDS_PER_HOUR + 30 * SECONDS_PER_MINUTE);
-
-        // white spaces
-
-        r = ParseRFC822DateTimeDeprecated("Fri,4 Mar 2005 19:34:45 UT", t); // no space after comma
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885);
-
-        r = ParseRFC822DateTimeDeprecated("   Fri,   4   Mar   2005   19:34:45   UT   ", t); // several spaces, leading and trailing
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885);
-
-        r = ParseRFC822DateTimeDeprecated(" \t Fri, \t 4 \t Mar \t 2005 \t 19:34:45 \t UT \t ", t); // spaces with tabs
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)1109964885);
-
-        r = ParseRFC822DateTimeDeprecated("Thu, 01 Jan 1970 03:00:00 +0300", t); // spaces with tabs
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)0);
-
-        r = ParseRFC822DateTimeDeprecated("Sat, 14 Feb 2009 02:31:30 +0300", t); // spaces with tabs
-        UNIT_ASSERT(r);
-        UNIT_ASSERT_EQUAL(t, (time_t)1234567890);
-    }
-
-    time_t GetOffset(char militaryZone) {
-        char ch = (char)toupper(militaryZone);
-        if (ch == 'Z') {
-            return 0;
-        } else if (ch >= 'A' && ch < 'J') {
-            return (ch - 'A' + 1) * SECONDS_PER_HOUR;
-        } else if (ch > 'J' && ch <= 'M') {
-            return (ch - 'A') * SECONDS_PER_HOUR;
-        } else if (ch >= 'N' && ch <= 'Y') {
-            return -(ch - 'N' + 1) * SECONDS_PER_HOUR;
-        } else {
-            ythrow yexception() << "Invalid military zone.";
-        }
-    }
-
-    void DoTestMilitaryZones(char firstChar, char lastChar) {
-        const time_t utcTime = 1109964885; // Fri, 4 Mar 2005 19:34:45 UT
-        char text[] = "Fri, 4 Mar 2005 19:34:45 A";
-        const size_t zoneCharIndex = strlen(text) - 1;
-
-        for (char militaryZone = firstChar; militaryZone <= lastChar; ++militaryZone) {
-            time_t t = 0;
-            const time_t offset = GetOffset(militaryZone);
-            // the last character is replaced with next zone symbol
-            text[zoneCharIndex] = militaryZone;
-
-            UNIT_ASSERT(ParseRFC822DateTimeDeprecated(text, t));
-            UNIT_ASSERT_EQUAL(t, utcTime - offset);
-        }
-    }
-
-    Y_UNIT_TEST(TestRfc822MilitaryZonesDeprecated) {
-        DoTestMilitaryZones('A', 'I');
-        DoTestMilitaryZones('K', 'Z');
-        DoTestMilitaryZones('a', 'i');
-        DoTestMilitaryZones('k', 'z');
-    }
-
-    Y_UNIT_TEST(TestRfc822IncorrectDatesDeprecated) {
-        bool r = true;
-        time_t t = 0;
-
-        t = 12345;
-        r = ParseRFC822DateTimeDeprecated("", t);
-        UNIT_ASSERT(!r);
-        UNIT_ASSERT_EQUAL(t, (time_t)12345);
-
-        t = 223344;
-        r = ParseRFC822DateTimeDeprecated("Fri, some junk", t);
-        UNIT_ASSERT(!r);
-        UNIT_ASSERT_EQUAL(t, (time_t)223344);
-
-        t = 54321;
-        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 UTC", t);
-        UNIT_ASSERT(!r);
-        UNIT_ASSERT_EQUAL(t, (time_t)54321);
-
-        // TODO: check semantic validity of parsed date (30 Feb, 88:90 etc.).
-        // The following tests MUST fail (they don't now)
-        // r = ParseRFC822DateTimeDeprecated("45 Mar 2005 19:34:45 UT", t);
-        // UNIT_ASSERT_EQUAL(r, false);
-
-        // r = ParseRFC822DateTimeDeprecated("29 Feb 2005 19:34:45 +0300", t);
-        // UNIT_ASSERT_EQUAL(r, false);
-
-        // r = ParseRFC822DateTimeDeprecated("31 Apr 2004 19:34:45 +0300", t);
-        // UNIT_ASSERT_EQUAL(r, false);
-
-        r = ParseRFC822DateTimeDeprecated("17 Nov 2008 19:34:45", t); // no specified time zone
-        UNIT_ASSERT(!r);
-
-        r = ParseRFC822DateTimeDeprecated("17 Nov 200 19:34:45 UT", t);
-        UNIT_ASSERT(!r);
-        r = ParseRFC822DateTimeDeprecated("17 Nov 8 19:34:45 UT", t);
-        UNIT_ASSERT(!r);
-        r = ParseRFC822DateTimeDeprecated("17 Nov 20008 19:34:45 UT", t);
-        UNIT_ASSERT(!r);
-
-        r = ParseRFC822DateTimeDeprecated("17 Nov 2008 1:34:45 UT", t);
-        UNIT_ASSERT(!r);
-        r = ParseRFC822DateTimeDeprecated("17 Nov 2008 123:34:45 UT", t);
-        UNIT_ASSERT(!r);
-        r = ParseRFC822DateTimeDeprecated("17 Nov 2008 19:1:45 UT", t);
-        UNIT_ASSERT(!r);
-        r = ParseRFC822DateTimeDeprecated("17 Nov 2008 19:123:45 UT", t);
-        UNIT_ASSERT(!r);
-        r = ParseRFC822DateTimeDeprecated("17 Nov 2008 19:34:1 UT", t);
-        UNIT_ASSERT(!r);
-        r = ParseRFC822DateTimeDeprecated("17 Nov 2008 19:34:123 UT", t);
-        UNIT_ASSERT(!r);
-        r = ParseRFC822DateTimeDeprecated("17 Nov 2008 19:34:12.12 UT", t); // fractions of second are now allowed
-        UNIT_ASSERT(!r);
-
-        r = ParseRFC822DateTimeDeprecated("Mon , 17 Nov 2005 19:34:45 UT", t); // space after day before the comma
-        UNIT_ASSERT(!r);
-        r = ParseRFC822DateTimeDeprecated("Mon, 17 Nov 2005 19 :34:45 UT", t);
-        UNIT_ASSERT(!r);
-        r = ParseRFC822DateTimeDeprecated("Mon, 17 Nov 2005 19: 34:45 UT", t);
-        UNIT_ASSERT(!r);
-        r = ParseRFC822DateTimeDeprecated("Mon, 17 Nov 2005 19:34 :45 UT", t);
-        UNIT_ASSERT(!r);
-        r = ParseRFC822DateTimeDeprecated("Mon, 17 Nov 2005 19:34: 45 UT", t);
-        UNIT_ASSERT(!r);
-
-        r = ParseRFC822DateTimeDeprecated("Monday, 17 Nov 2005 19:34:45 UT", t);
-        UNIT_ASSERT(!r);
-        r = ParseRFC822DateTimeDeprecated("Mon, 17 November 2008 19:34:45 UT", t);
-        UNIT_ASSERT(!r);
-
-        r = ParseRFC822DateTimeDeprecated("Mon, 17 Nov 2008 19:34:45 +3", t);
-        UNIT_ASSERT(!r);
-        r = ParseRFC822DateTimeDeprecated("Mon, 17 Nov 2008 19:34:45 +03", t);
-        UNIT_ASSERT(!r);
-        r = ParseRFC822DateTimeDeprecated("Mon, 17 Nov 2008 19:34:45 +030", t);
-        UNIT_ASSERT(!r);
-        r = ParseRFC822DateTimeDeprecated("Mon, 17 Nov 2008 19:34:45 +03030", t);
-        UNIT_ASSERT(!r);
-        r = ParseRFC822DateTimeDeprecated("Mon, 17 Nov 2008 19:34:45 -3", t);
-        UNIT_ASSERT(!r);
-        r = ParseRFC822DateTimeDeprecated("Mon, 17 Nov 2008 19:34:45 -03", t);
-        UNIT_ASSERT(!r);
-        r = ParseRFC822DateTimeDeprecated("Mon, 17 Nov 2008 19:34:45 -030", t);
-        UNIT_ASSERT(!r);
-        r = ParseRFC822DateTimeDeprecated("Mon, 17 Nov 2008 19:34:45 -03030", t);
-        UNIT_ASSERT(!r);
-    }
-
-    Y_UNIT_TEST(TestRfc822PartialDeprecated) {
-        TRfc822DateTimeParserDeprecated p;
-        const char* part1 = "Fri, 4 Mar 05 1";
-        const char* part2 = "9:34:45 +0300";
-        UNIT_ASSERT(p.ParsePart(part1, strlen(part1)));
-        UNIT_ASSERT(p.ParsePart(part2, strlen(part2)));
-        UNIT_ASSERT_VALUES_EQUAL(TInstant::Seconds(1109954085), p.GetResult(TInstant::Max()));
-        p = TRfc822DateTimeParserDeprecated();
-        const char* part3 = "Fri, 4 Mar 05 19:34:46 +0300";
-        UNIT_ASSERT(p.ParsePart(part3, strlen(part3)));
-        UNIT_ASSERT_VALUES_EQUAL(TInstant::Seconds(1109954086), p.GetResult(TInstant::Zero()));
-    }
-
-    Y_UNIT_TEST(TestIso8601PartialDeprecated) {
-        TIso8601DateTimeParserDeprecated p;
-        const char* part1 = "1990-03-15T15:1";
-        const char* part2 = "6:17+0732";
-        UNIT_ASSERT(p.ParsePart(part1, strlen(part1)));
-        UNIT_ASSERT(p.ParsePart(part2, strlen(part2)));
-        UNIT_ASSERT_VALUES_EQUAL(TInstant::Seconds(637487057), p.GetResult(TInstant::Max()));
-        p = TIso8601DateTimeParserDeprecated();
-        const char* part3 = "1990-03-15T15:16:18+0732";
-        UNIT_ASSERT(p.ParsePart(part3, strlen(part3)));
-        UNIT_ASSERT_VALUES_EQUAL(TInstant::Seconds(637487058), p.GetResult(TInstant::Zero()));
-    }
-
-    Y_UNIT_TEST(TestIso8601CorrectDeprecatedDeprecated) {
-        bool ret;
-        time_t t;
-
-        // ISO 8601 actually does not allow time without time zone
-        ret = ParseISO8601DateTimeDeprecated("1990-03-15", t);
-        UNIT_ASSERT(ret);
-        UNIT_ASSERT_VALUES_EQUAL(t, 637484400);
-
-        // some normal dates
-        ret = ParseISO8601DateTimeDeprecated("1990-03-15T15:16:17Z", t);
-        UNIT_ASSERT(ret);
-        UNIT_ASSERT_VALUES_EQUAL(t, 637514177);
-
-        ret = ParseISO8601DateTimeDeprecated("1990-03-15t15:16:17z", t); // lower-case must be allowed too
-        UNIT_ASSERT(ret);
-        UNIT_ASSERT_VALUES_EQUAL(t, 637514177);
-
-        ret = ParseISO8601DateTimeDeprecated("1990-03-15 15:16:17Z", t); // space as separator should be allowed
-        UNIT_ASSERT(ret);
-        UNIT_ASSERT_VALUES_EQUAL(t, 637514177);
-
-        ret = ParseISO8601DateTimeDeprecated("1990-03-15T15:16:17.18Z", t);
-        UNIT_ASSERT(ret);
-        UNIT_ASSERT_VALUES_EQUAL(t, 637514177);
-
-        ret = ParseISO8601DateTimeDeprecated("1990-03-15T15:16:17.18+07:32", t);
-        UNIT_ASSERT(ret);
-        UNIT_ASSERT_VALUES_EQUAL(t, 637487057);
-
-        ret = ParseISO8601DateTimeDeprecated("1990-03-15T15:16:17.18+0732", t);
-        UNIT_ASSERT(ret);
-        UNIT_ASSERT_VALUES_EQUAL(t, 637487057);
-
-        ret = ParseISO8601DateTimeDeprecated("1970-01-01T00:00:00Z", t);
-        UNIT_ASSERT(ret);
-        UNIT_ASSERT_VALUES_EQUAL(t, 0);
-
-        ret = ParseISO8601DateTimeDeprecated("1970-01-01T00:01:02Z", t);
-        UNIT_ASSERT(ret);
-        UNIT_ASSERT_VALUES_EQUAL(t, 62);
-
-#if 0
-        // these tests are disabled, because time zones are handled differently
-        // in old util/ parser and agalakhov@ parser
-        ret = ParseISO8601DateTimeDeprecated("1970-01-01", t);
-        UNIT_ASSERT(ret);
-        UNIT_ASSERT_VALUES_EQUAL(t, -4 * 3600);
-
-        ret = ParseISO8601DateTimeDeprecated("1970-01-02", t);
-        UNIT_ASSERT(ret);
-        UNIT_ASSERT_VALUES_EQUAL(t, 86400 - 3 * 3600);
-#endif
-
-        // this is wrong because of timezone
-        ret = ParseISO8601DateTimeDeprecated("2009-02-14T03:31:30", t);
-        UNIT_ASSERT(ret);
-        UNIT_ASSERT_VALUES_EQUAL(t, 1234567890);
-
-        ret = ParseISO8601DateTimeDeprecated("2009-02-14t03:31:30", t);
-        UNIT_ASSERT(ret);
-        UNIT_ASSERT_VALUES_EQUAL(t, 1234567890);
-
-        ret = ParseISO8601DateTimeDeprecated("2009-02-14T02:31:30+0300", t);
-        UNIT_ASSERT(ret);
-        UNIT_ASSERT_VALUES_EQUAL(t, 1234567890);
-
-        ret = ParseISO8601DateTimeDeprecated("2009-02-14T02:31:30+03:00", t);
-        UNIT_ASSERT(ret);
-        UNIT_ASSERT_VALUES_EQUAL(t, 1234567890);
-
-        ret = ParseISO8601DateTimeDeprecated("2009-02-14 02:31:30+03:00", t);
-        UNIT_ASSERT(ret);
-        UNIT_ASSERT_VALUES_EQUAL(t, 1234567890);
-
-        ret = ParseISO8601DateTimeDeprecated("2010-03-28T04:27:00.000-07:00", t);
-        UNIT_ASSERT(ret);
-        UNIT_ASSERT_VALUES_EQUAL(t, 1269775620);
-    }
-
-    Y_UNIT_TEST(TestIso8601TimeZoneDeprecated) {
-        time_t t1, t2, t3, t4;
-        UNIT_ASSERT(ParseISO8601DateTimeDeprecated("2010-03-28T04:27:00.000+07:00", t1));
-        UNIT_ASSERT(ParseISO8601DateTimeDeprecated("2010-03-27T21:27:00.000Z", t2));
-        UNIT_ASSERT(ParseISO8601DateTimeDeprecated("2010-03-27T22:27:00.000+0100", t3));
-        UNIT_ASSERT(ParseISO8601DateTimeDeprecated("2010-03-27T20:27:00.000-01:00", t4));
-        UNIT_ASSERT_VALUES_EQUAL(t1, t2);
-        UNIT_ASSERT_VALUES_EQUAL(t2, t3);
-        UNIT_ASSERT_VALUES_EQUAL(t3, t4);
-    }
-
-    Y_UNIT_TEST(TestIso8601IncorrectDeprecated) {
-        bool ret;
-        time_t t;
-
-        t = 12345;
-        ret = ParseISO8601DateTimeDeprecated("", t);
-        UNIT_ASSERT(!ret);
-        UNIT_ASSERT_EQUAL(t, (time_t)12345);
-
-        // some bad dates
-        t = 54321;
-        ret = ParseISO8601DateTimeDeprecated("a990-01-15", t);
-        UNIT_ASSERT(!ret);
-        UNIT_ASSERT_EQUAL(t, (time_t)54321);
-
-        ret = ParseISO8601DateTimeDeprecated("1970-01-01T03:00:00+04:00", t); // this is 1969 GMT
-        UNIT_ASSERT(!ret);
-
-        ret = ParseISO8601DateTimeDeprecated("1987-13-16", t);
-        UNIT_ASSERT(!ret);
-
-        ret = ParseISO8601DateTimeDeprecated("1987-02-29", t);
-        UNIT_ASSERT(!ret);
-
-        ret = ParseISO8601DateTimeDeprecated("1990-03-151Y15:16:17.18", t);
-        UNIT_ASSERT(!ret);
-
-        ret = ParseISO8601DateTimeDeprecated("1990-03-151T15:16:17:43.18", t);
-        UNIT_ASSERT(!ret);
-
-        ret = ParseISO8601DateTimeDeprecated("1990-03-151T15:16:17.18Z+21:32", t);
-        UNIT_ASSERT(!ret);
-    }
-
-    Y_UNIT_TEST(TestIso8601FractionsDeprecated) {
-        UNIT_ASSERT_VALUES_EQUAL(
-            TInstant::ParseIso8601Deprecated("2009-09-19 03:37:08.1+04:00"),
-            TInstant::Seconds(1253317028) + TDuration::MilliSeconds(100));
-        UNIT_ASSERT_VALUES_EQUAL(
-            TInstant::ParseIso8601Deprecated("2009-09-19 03:37:03.926+04:00"),
-            TInstant::Seconds(1253317023) + TDuration::MilliSeconds(926));
-        UNIT_ASSERT_VALUES_EQUAL(
-            TInstant::ParseIso8601Deprecated("2009-09-19 03:37:03.92622+04:00"),
-            TInstant::Seconds(1253317023) + TDuration::MicroSeconds(926220));
-        UNIT_ASSERT_VALUES_EQUAL(
-            TInstant::ParseIso8601Deprecated("2009-09-19 03:37:03.012331+04:00"),
-            TInstant::Seconds(1253317023) + TDuration::MicroSeconds(12331));
-    }
-
-    Y_UNIT_TEST(TestHttpDateDeprecated) {
-        UNIT_ASSERT_VALUES_EQUAL(
-            TInstant::ParseHttpDeprecated("Sun, 06 Nov 1994 08:49:37 GMT"),
-            TInstant::ParseIso8601Deprecated("1994-11-06T08:49:37Z"));
-        UNIT_ASSERT_VALUES_EQUAL(
-            TInstant::ParseHttpDeprecated("Sunday, 06-Nov-94 08:49:37 GMT"),
-            TInstant::ParseIso8601Deprecated("1994-11-06T08:49:37Z"));
-        UNIT_ASSERT_VALUES_EQUAL(
-            TInstant::ParseHttpDeprecated("Sun Nov  6 08:49:37 1994"),
-            TInstant::ParseIso8601Deprecated("1994-11-06T08:49:37Z"));
-        UNIT_ASSERT_VALUES_EQUAL(
-            TInstant::ParseHttpDeprecated("Mon, 19 Jan 2037 08:49:37 GMT"),
-            TInstant::ParseIso8601Deprecated("2037-01-19T08:49:37Z"));
-    }
-
-    Y_UNIT_TEST(TestHttpDateIncorrectDeprecated) {
-        bool ret;
-        time_t t = 0;
-        ret = ParseHTTPDateTimeDeprecated("1990-03-15T15:16:17Z", t);
-        UNIT_ASSERT(!ret);
-    }
-
-    Y_UNIT_TEST(TestX509ValidityTimeDeprecated) {
-        UNIT_ASSERT_VALUES_EQUAL(
-            TInstant::ParseX509ValidityDeprecated("20091014165533Z"),
-            TInstant::ParseRfc822Deprecated("Wed, 14 Oct 2009 16:55:33 GMT"));
-        UNIT_ASSERT_VALUES_EQUAL(
-            TInstant::ParseX509ValidityDeprecated("990104074212Z"),
-            TInstant::ParseRfc822Deprecated("4 Jan 1999 07:42:12 GMT"));
-        UNIT_ASSERT_VALUES_EQUAL(
-            TInstant::ParseX509ValidityDeprecated("191231235959Z"),
-            TInstant::ParseRfc822Deprecated("31 Dec 2019 23:59:59 GMT"));
-    }
-
-    Y_UNIT_TEST(TestX509ValidityTimeIncorrectDeprecated) {
-        bool ret;
-        time_t t = 0;
-        ret = ParseX509ValidityDateTimeDeprecated("500101000000Z", t);
-        UNIT_ASSERT(!ret);
-        ret = ParseX509ValidityDateTimeDeprecated("091014165533+0300", t);
-        UNIT_ASSERT(!ret);
-    }
-
-    Y_UNIT_TEST(TestTInstantTryParseDeprecated) {
-        {
+ 
+static const time_t SECONDS_PER_HOUR = 3600; 
+static const time_t SECONDS_PER_MINUTE = 60; 
+ 
+Y_UNIT_TEST_SUITE(TDateTimeParseTestDeprecated) { 
+    Y_UNIT_TEST(TestRfc822CorrectDeprecated) { 
+        bool r = false; 
+        time_t t = 0; 
+ 
+        // predefined time zones 
+ 
+        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 UT", t); 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885); 
+ 
+        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 GMT", t); 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885); 
+ 
+        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 EST", t); 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_VALUES_EQUAL(t, (time_t)1109964885 + 5 * SECONDS_PER_HOUR); 
+        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 EDT", t); 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 4 * SECONDS_PER_HOUR); 
+ 
+        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 CST", t); 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 6 * SECONDS_PER_HOUR); 
+        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 CDT", t); 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 5 * SECONDS_PER_HOUR); 
+ 
+        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 MST", t); 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 7 * SECONDS_PER_HOUR); 
+        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 MDT", t); 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 6 * SECONDS_PER_HOUR); 
+ 
+        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 PST", t); 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 8 * SECONDS_PER_HOUR); 
+        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 PDT", t); 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 7 * SECONDS_PER_HOUR); 
+ 
+        // optinal century 
+        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 05 19:34:45 UT", t); 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885); 
+ 
+        // + optional day of week 
+        r = ParseRFC822DateTimeDeprecated("4 Mar 05 19:34:45 UT", t); 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885); 
+ 
+        // + optional seconds 
+        r = ParseRFC822DateTimeDeprecated("4 Mar 05 19:34 UT", t); 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964840); 
+ 
+        // local differential hour+min 
+ 
+        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 +0300", t); 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)1109954085); 
+ 
+        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 05 19:34:45 +0300", t); 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)1109954085); 
+ 
+        r = ParseRFC822DateTimeDeprecated("21 Apr 1999 23:40:00 +0400", t); 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)924723600); 
+ 
+        r = ParseRFC822DateTimeDeprecated("21 Apr 99 23:40 +0400", t); 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)924723600); 
+ 
+        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 -0300", t); 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 3 * SECONDS_PER_HOUR); 
+ 
+        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34 -0300", t); 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964840 + 3 * SECONDS_PER_HOUR); 
+ 
+        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 05 19:34:45 -0330", t); 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 3 * SECONDS_PER_HOUR + 30 * SECONDS_PER_MINUTE); 
+ 
+        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 05 19:34 -0330", t); 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964840 + 3 * SECONDS_PER_HOUR + 30 * SECONDS_PER_MINUTE); 
+ 
+        r = ParseRFC822DateTimeDeprecated("4 Mar 2005 19:34:45 -1030", t); 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 10 * SECONDS_PER_HOUR + 30 * SECONDS_PER_MINUTE); 
+ 
+        r = ParseRFC822DateTimeDeprecated("4 Mar 2005 19:34 -1030", t); 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964840 + 10 * SECONDS_PER_HOUR + 30 * SECONDS_PER_MINUTE); 
+ 
+        // white spaces 
+ 
+        r = ParseRFC822DateTimeDeprecated("Fri,4 Mar 2005 19:34:45 UT", t); // no space after comma 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885); 
+ 
+        r = ParseRFC822DateTimeDeprecated("   Fri,   4   Mar   2005   19:34:45   UT   ", t); // several spaces, leading and trailing 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885); 
+ 
+        r = ParseRFC822DateTimeDeprecated(" \t Fri, \t 4 \t Mar \t 2005 \t 19:34:45 \t UT \t ", t); // spaces with tabs 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)1109964885); 
+ 
+        r = ParseRFC822DateTimeDeprecated("Thu, 01 Jan 1970 03:00:00 +0300", t); // spaces with tabs 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)0); 
+ 
+        r = ParseRFC822DateTimeDeprecated("Sat, 14 Feb 2009 02:31:30 +0300", t); // spaces with tabs 
+        UNIT_ASSERT(r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)1234567890); 
+    } 
+ 
+    time_t GetOffset(char militaryZone) { 
+        char ch = (char)toupper(militaryZone); 
+        if (ch == 'Z') { 
+            return 0; 
+        } else if (ch >= 'A' && ch < 'J') { 
+            return (ch - 'A' + 1) * SECONDS_PER_HOUR; 
+        } else if (ch > 'J' && ch <= 'M') { 
+            return (ch - 'A') * SECONDS_PER_HOUR; 
+        } else if (ch >= 'N' && ch <= 'Y') { 
+            return -(ch - 'N' + 1) * SECONDS_PER_HOUR; 
+        } else { 
+            ythrow yexception() << "Invalid military zone."; 
+        } 
+    } 
+ 
+    void DoTestMilitaryZones(char firstChar, char lastChar) { 
+        const time_t utcTime = 1109964885; // Fri, 4 Mar 2005 19:34:45 UT 
+        char text[] = "Fri, 4 Mar 2005 19:34:45 A"; 
+        const size_t zoneCharIndex = strlen(text) - 1; 
+ 
+        for (char militaryZone = firstChar; militaryZone <= lastChar; ++militaryZone) { 
+            time_t t = 0; 
+            const time_t offset = GetOffset(militaryZone); 
+            // the last character is replaced with next zone symbol 
+            text[zoneCharIndex] = militaryZone; 
+ 
+            UNIT_ASSERT(ParseRFC822DateTimeDeprecated(text, t)); 
+            UNIT_ASSERT_EQUAL(t, utcTime - offset); 
+        } 
+    } 
+ 
+    Y_UNIT_TEST(TestRfc822MilitaryZonesDeprecated) { 
+        DoTestMilitaryZones('A', 'I'); 
+        DoTestMilitaryZones('K', 'Z'); 
+        DoTestMilitaryZones('a', 'i'); 
+        DoTestMilitaryZones('k', 'z'); 
+    } 
+ 
+    Y_UNIT_TEST(TestRfc822IncorrectDatesDeprecated) { 
+        bool r = true; 
+        time_t t = 0; 
+ 
+        t = 12345; 
+        r = ParseRFC822DateTimeDeprecated("", t); 
+        UNIT_ASSERT(!r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)12345); 
+ 
+        t = 223344; 
+        r = ParseRFC822DateTimeDeprecated("Fri, some junk", t); 
+        UNIT_ASSERT(!r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)223344); 
+ 
+        t = 54321; 
+        r = ParseRFC822DateTimeDeprecated("Fri, 4 Mar 2005 19:34:45 UTC", t); 
+        UNIT_ASSERT(!r); 
+        UNIT_ASSERT_EQUAL(t, (time_t)54321); 
+ 
+        // TODO: check semantic validity of parsed date (30 Feb, 88:90 etc.). 
+        // The following tests MUST fail (they don't now) 
+        // r = ParseRFC822DateTimeDeprecated("45 Mar 2005 19:34:45 UT", t); 
+        // UNIT_ASSERT_EQUAL(r, false); 
+ 
+        // r = ParseRFC822DateTimeDeprecated("29 Feb 2005 19:34:45 +0300", t); 
+        // UNIT_ASSERT_EQUAL(r, false); 
+ 
+        // r = ParseRFC822DateTimeDeprecated("31 Apr 2004 19:34:45 +0300", t); 
+        // UNIT_ASSERT_EQUAL(r, false); 
+ 
+        r = ParseRFC822DateTimeDeprecated("17 Nov 2008 19:34:45", t); // no specified time zone 
+        UNIT_ASSERT(!r); 
+ 
+        r = ParseRFC822DateTimeDeprecated("17 Nov 200 19:34:45 UT", t); 
+        UNIT_ASSERT(!r); 
+        r = ParseRFC822DateTimeDeprecated("17 Nov 8 19:34:45 UT", t); 
+        UNIT_ASSERT(!r); 
+        r = ParseRFC822DateTimeDeprecated("17 Nov 20008 19:34:45 UT", t); 
+        UNIT_ASSERT(!r); 
+ 
+        r = ParseRFC822DateTimeDeprecated("17 Nov 2008 1:34:45 UT", t); 
+        UNIT_ASSERT(!r); 
+        r = ParseRFC822DateTimeDeprecated("17 Nov 2008 123:34:45 UT", t); 
+        UNIT_ASSERT(!r); 
+        r = ParseRFC822DateTimeDeprecated("17 Nov 2008 19:1:45 UT", t); 
+        UNIT_ASSERT(!r); 
+        r = ParseRFC822DateTimeDeprecated("17 Nov 2008 19:123:45 UT", t); 
+        UNIT_ASSERT(!r); 
+        r = ParseRFC822DateTimeDeprecated("17 Nov 2008 19:34:1 UT", t); 
+        UNIT_ASSERT(!r); 
+        r = ParseRFC822DateTimeDeprecated("17 Nov 2008 19:34:123 UT", t); 
+        UNIT_ASSERT(!r); 
+        r = ParseRFC822DateTimeDeprecated("17 Nov 2008 19:34:12.12 UT", t); // fractions of second are now allowed 
+        UNIT_ASSERT(!r); 
+ 
+        r = ParseRFC822DateTimeDeprecated("Mon , 17 Nov 2005 19:34:45 UT", t); // space after day before the comma 
+        UNIT_ASSERT(!r); 
+        r = ParseRFC822DateTimeDeprecated("Mon, 17 Nov 2005 19 :34:45 UT", t); 
+        UNIT_ASSERT(!r); 
+        r = ParseRFC822DateTimeDeprecated("Mon, 17 Nov 2005 19: 34:45 UT", t); 
+        UNIT_ASSERT(!r); 
+        r = ParseRFC822DateTimeDeprecated("Mon, 17 Nov 2005 19:34 :45 UT", t); 
+        UNIT_ASSERT(!r); 
+        r = ParseRFC822DateTimeDeprecated("Mon, 17 Nov 2005 19:34: 45 UT", t); 
+        UNIT_ASSERT(!r); 
+ 
+        r = ParseRFC822DateTimeDeprecated("Monday, 17 Nov 2005 19:34:45 UT", t); 
+        UNIT_ASSERT(!r); 
+        r = ParseRFC822DateTimeDeprecated("Mon, 17 November 2008 19:34:45 UT", t); 
+        UNIT_ASSERT(!r); 
+ 
+        r = ParseRFC822DateTimeDeprecated("Mon, 17 Nov 2008 19:34:45 +3", t); 
+        UNIT_ASSERT(!r); 
+        r = ParseRFC822DateTimeDeprecated("Mon, 17 Nov 2008 19:34:45 +03", t); 
+        UNIT_ASSERT(!r); 
+        r = ParseRFC822DateTimeDeprecated("Mon, 17 Nov 2008 19:34:45 +030", t); 
+        UNIT_ASSERT(!r); 
+        r = ParseRFC822DateTimeDeprecated("Mon, 17 Nov 2008 19:34:45 +03030", t); 
+        UNIT_ASSERT(!r); 
+        r = ParseRFC822DateTimeDeprecated("Mon, 17 Nov 2008 19:34:45 -3", t); 
+        UNIT_ASSERT(!r); 
+        r = ParseRFC822DateTimeDeprecated("Mon, 17 Nov 2008 19:34:45 -03", t); 
+        UNIT_ASSERT(!r); 
+        r = ParseRFC822DateTimeDeprecated("Mon, 17 Nov 2008 19:34:45 -030", t); 
+        UNIT_ASSERT(!r); 
+        r = ParseRFC822DateTimeDeprecated("Mon, 17 Nov 2008 19:34:45 -03030", t); 
+        UNIT_ASSERT(!r); 
+    } 
+ 
+    Y_UNIT_TEST(TestRfc822PartialDeprecated) { 
+        TRfc822DateTimeParserDeprecated p; 
+        const char* part1 = "Fri, 4 Mar 05 1"; 
+        const char* part2 = "9:34:45 +0300"; 
+        UNIT_ASSERT(p.ParsePart(part1, strlen(part1))); 
+        UNIT_ASSERT(p.ParsePart(part2, strlen(part2))); 
+        UNIT_ASSERT_VALUES_EQUAL(TInstant::Seconds(1109954085), p.GetResult(TInstant::Max())); 
+        p = TRfc822DateTimeParserDeprecated(); 
+        const char* part3 = "Fri, 4 Mar 05 19:34:46 +0300"; 
+        UNIT_ASSERT(p.ParsePart(part3, strlen(part3))); 
+        UNIT_ASSERT_VALUES_EQUAL(TInstant::Seconds(1109954086), p.GetResult(TInstant::Zero())); 
+    } 
+ 
+    Y_UNIT_TEST(TestIso8601PartialDeprecated) { 
+        TIso8601DateTimeParserDeprecated p; 
+        const char* part1 = "1990-03-15T15:1"; 
+        const char* part2 = "6:17+0732"; 
+        UNIT_ASSERT(p.ParsePart(part1, strlen(part1))); 
+        UNIT_ASSERT(p.ParsePart(part2, strlen(part2))); 
+        UNIT_ASSERT_VALUES_EQUAL(TInstant::Seconds(637487057), p.GetResult(TInstant::Max())); 
+        p = TIso8601DateTimeParserDeprecated(); 
+        const char* part3 = "1990-03-15T15:16:18+0732"; 
+        UNIT_ASSERT(p.ParsePart(part3, strlen(part3))); 
+        UNIT_ASSERT_VALUES_EQUAL(TInstant::Seconds(637487058), p.GetResult(TInstant::Zero())); 
+    } 
+ 
+    Y_UNIT_TEST(TestIso8601CorrectDeprecatedDeprecated) { 
+        bool ret; 
+        time_t t; 
+ 
+        // ISO 8601 actually does not allow time without time zone 
+        ret = ParseISO8601DateTimeDeprecated("1990-03-15", t); 
+        UNIT_ASSERT(ret); 
+        UNIT_ASSERT_VALUES_EQUAL(t, 637484400); 
+ 
+        // some normal dates 
+        ret = ParseISO8601DateTimeDeprecated("1990-03-15T15:16:17Z", t); 
+        UNIT_ASSERT(ret); 
+        UNIT_ASSERT_VALUES_EQUAL(t, 637514177); 
+ 
+        ret = ParseISO8601DateTimeDeprecated("1990-03-15t15:16:17z", t); // lower-case must be allowed too 
+        UNIT_ASSERT(ret); 
+        UNIT_ASSERT_VALUES_EQUAL(t, 637514177); 
+ 
+        ret = ParseISO8601DateTimeDeprecated("1990-03-15 15:16:17Z", t); // space as separator should be allowed 
+        UNIT_ASSERT(ret); 
+        UNIT_ASSERT_VALUES_EQUAL(t, 637514177); 
+ 
+        ret = ParseISO8601DateTimeDeprecated("1990-03-15T15:16:17.18Z", t); 
+        UNIT_ASSERT(ret); 
+        UNIT_ASSERT_VALUES_EQUAL(t, 637514177); 
+ 
+        ret = ParseISO8601DateTimeDeprecated("1990-03-15T15:16:17.18+07:32", t); 
+        UNIT_ASSERT(ret); 
+        UNIT_ASSERT_VALUES_EQUAL(t, 637487057); 
+ 
+        ret = ParseISO8601DateTimeDeprecated("1990-03-15T15:16:17.18+0732", t); 
+        UNIT_ASSERT(ret); 
+        UNIT_ASSERT_VALUES_EQUAL(t, 637487057); 
+ 
+        ret = ParseISO8601DateTimeDeprecated("1970-01-01T00:00:00Z", t); 
+        UNIT_ASSERT(ret); 
+        UNIT_ASSERT_VALUES_EQUAL(t, 0); 
+ 
+        ret = ParseISO8601DateTimeDeprecated("1970-01-01T00:01:02Z", t); 
+        UNIT_ASSERT(ret); 
+        UNIT_ASSERT_VALUES_EQUAL(t, 62); 
+ 
+#if 0 
+        // these tests are disabled, because time zones are handled differently 
+        // in old util/ parser and agalakhov@ parser 
+        ret = ParseISO8601DateTimeDeprecated("1970-01-01", t); 
+        UNIT_ASSERT(ret); 
+        UNIT_ASSERT_VALUES_EQUAL(t, -4 * 3600); 
+ 
+        ret = ParseISO8601DateTimeDeprecated("1970-01-02", t); 
+        UNIT_ASSERT(ret); 
+        UNIT_ASSERT_VALUES_EQUAL(t, 86400 - 3 * 3600); 
+#endif 
+ 
+        // this is wrong because of timezone 
+        ret = ParseISO8601DateTimeDeprecated("2009-02-14T03:31:30", t); 
+        UNIT_ASSERT(ret); 
+        UNIT_ASSERT_VALUES_EQUAL(t, 1234567890); 
+ 
+        ret = ParseISO8601DateTimeDeprecated("2009-02-14t03:31:30", t); 
+        UNIT_ASSERT(ret); 
+        UNIT_ASSERT_VALUES_EQUAL(t, 1234567890); 
+ 
+        ret = ParseISO8601DateTimeDeprecated("2009-02-14T02:31:30+0300", t); 
+        UNIT_ASSERT(ret); 
+        UNIT_ASSERT_VALUES_EQUAL(t, 1234567890); 
+ 
+        ret = ParseISO8601DateTimeDeprecated("2009-02-14T02:31:30+03:00", t); 
+        UNIT_ASSERT(ret); 
+        UNIT_ASSERT_VALUES_EQUAL(t, 1234567890); 
+ 
+        ret = ParseISO8601DateTimeDeprecated("2009-02-14 02:31:30+03:00", t); 
+        UNIT_ASSERT(ret); 
+        UNIT_ASSERT_VALUES_EQUAL(t, 1234567890); 
+ 
+        ret = ParseISO8601DateTimeDeprecated("2010-03-28T04:27:00.000-07:00", t); 
+        UNIT_ASSERT(ret); 
+        UNIT_ASSERT_VALUES_EQUAL(t, 1269775620); 
+    } 
+ 
+    Y_UNIT_TEST(TestIso8601TimeZoneDeprecated) { 
+        time_t t1, t2, t3, t4; 
+        UNIT_ASSERT(ParseISO8601DateTimeDeprecated("2010-03-28T04:27:00.000+07:00", t1)); 
+        UNIT_ASSERT(ParseISO8601DateTimeDeprecated("2010-03-27T21:27:00.000Z", t2)); 
+        UNIT_ASSERT(ParseISO8601DateTimeDeprecated("2010-03-27T22:27:00.000+0100", t3)); 
+        UNIT_ASSERT(ParseISO8601DateTimeDeprecated("2010-03-27T20:27:00.000-01:00", t4)); 
+        UNIT_ASSERT_VALUES_EQUAL(t1, t2); 
+        UNIT_ASSERT_VALUES_EQUAL(t2, t3); 
+        UNIT_ASSERT_VALUES_EQUAL(t3, t4); 
+    } 
+ 
+    Y_UNIT_TEST(TestIso8601IncorrectDeprecated) { 
+        bool ret; 
+        time_t t; 
+ 
+        t = 12345; 
+        ret = ParseISO8601DateTimeDeprecated("", t); 
+        UNIT_ASSERT(!ret); 
+        UNIT_ASSERT_EQUAL(t, (time_t)12345); 
+ 
+        // some bad dates 
+        t = 54321; 
+        ret = ParseISO8601DateTimeDeprecated("a990-01-15", t); 
+        UNIT_ASSERT(!ret); 
+        UNIT_ASSERT_EQUAL(t, (time_t)54321); 
+ 
+        ret = ParseISO8601DateTimeDeprecated("1970-01-01T03:00:00+04:00", t); // this is 1969 GMT 
+        UNIT_ASSERT(!ret); 
+ 
+        ret = ParseISO8601DateTimeDeprecated("1987-13-16", t); 
+        UNIT_ASSERT(!ret); 
+ 
+        ret = ParseISO8601DateTimeDeprecated("1987-02-29", t); 
+        UNIT_ASSERT(!ret); 
+ 
+        ret = ParseISO8601DateTimeDeprecated("1990-03-151Y15:16:17.18", t); 
+        UNIT_ASSERT(!ret); 
+ 
+        ret = ParseISO8601DateTimeDeprecated("1990-03-151T15:16:17:43.18", t); 
+        UNIT_ASSERT(!ret); 
+ 
+        ret = ParseISO8601DateTimeDeprecated("1990-03-151T15:16:17.18Z+21:32", t); 
+        UNIT_ASSERT(!ret); 
+    } 
+ 
+    Y_UNIT_TEST(TestIso8601FractionsDeprecated) { 
+        UNIT_ASSERT_VALUES_EQUAL( 
+            TInstant::ParseIso8601Deprecated("2009-09-19 03:37:08.1+04:00"), 
+            TInstant::Seconds(1253317028) + TDuration::MilliSeconds(100)); 
+        UNIT_ASSERT_VALUES_EQUAL( 
+            TInstant::ParseIso8601Deprecated("2009-09-19 03:37:03.926+04:00"), 
+            TInstant::Seconds(1253317023) + TDuration::MilliSeconds(926)); 
+        UNIT_ASSERT_VALUES_EQUAL( 
+            TInstant::ParseIso8601Deprecated("2009-09-19 03:37:03.92622+04:00"), 
+            TInstant::Seconds(1253317023) + TDuration::MicroSeconds(926220)); 
+        UNIT_ASSERT_VALUES_EQUAL( 
+            TInstant::ParseIso8601Deprecated("2009-09-19 03:37:03.012331+04:00"), 
+            TInstant::Seconds(1253317023) + TDuration::MicroSeconds(12331)); 
+    } 
+ 
+    Y_UNIT_TEST(TestHttpDateDeprecated) { 
+        UNIT_ASSERT_VALUES_EQUAL( 
+            TInstant::ParseHttpDeprecated("Sun, 06 Nov 1994 08:49:37 GMT"), 
+            TInstant::ParseIso8601Deprecated("1994-11-06T08:49:37Z")); 
+        UNIT_ASSERT_VALUES_EQUAL( 
+            TInstant::ParseHttpDeprecated("Sunday, 06-Nov-94 08:49:37 GMT"), 
+            TInstant::ParseIso8601Deprecated("1994-11-06T08:49:37Z")); 
+        UNIT_ASSERT_VALUES_EQUAL( 
+            TInstant::ParseHttpDeprecated("Sun Nov  6 08:49:37 1994"), 
+            TInstant::ParseIso8601Deprecated("1994-11-06T08:49:37Z")); 
+        UNIT_ASSERT_VALUES_EQUAL( 
+            TInstant::ParseHttpDeprecated("Mon, 19 Jan 2037 08:49:37 GMT"), 
+            TInstant::ParseIso8601Deprecated("2037-01-19T08:49:37Z")); 
+    } 
+ 
+    Y_UNIT_TEST(TestHttpDateIncorrectDeprecated) { 
+        bool ret; 
+        time_t t = 0; 
+        ret = ParseHTTPDateTimeDeprecated("1990-03-15T15:16:17Z", t); 
+        UNIT_ASSERT(!ret); 
+    } 
+ 
+    Y_UNIT_TEST(TestX509ValidityTimeDeprecated) { 
+        UNIT_ASSERT_VALUES_EQUAL( 
+            TInstant::ParseX509ValidityDeprecated("20091014165533Z"), 
+            TInstant::ParseRfc822Deprecated("Wed, 14 Oct 2009 16:55:33 GMT")); 
+        UNIT_ASSERT_VALUES_EQUAL( 
+            TInstant::ParseX509ValidityDeprecated("990104074212Z"), 
+            TInstant::ParseRfc822Deprecated("4 Jan 1999 07:42:12 GMT")); 
+        UNIT_ASSERT_VALUES_EQUAL( 
+            TInstant::ParseX509ValidityDeprecated("191231235959Z"), 
+            TInstant::ParseRfc822Deprecated("31 Dec 2019 23:59:59 GMT")); 
+    } 
+ 
+    Y_UNIT_TEST(TestX509ValidityTimeIncorrectDeprecated) { 
+        bool ret; 
+        time_t t = 0; 
+        ret = ParseX509ValidityDateTimeDeprecated("500101000000Z", t); 
+        UNIT_ASSERT(!ret); 
+        ret = ParseX509ValidityDateTimeDeprecated("091014165533+0300", t); 
+        UNIT_ASSERT(!ret); 
+    } 
+ 
+    Y_UNIT_TEST(TestTInstantTryParseDeprecated) { 
+        { 
             const TStringBuf s = "2009-09-19 03:37:08.1+04:00";
-            const auto i = TInstant::ParseIso8601Deprecated(s);
-            TInstant iTry;
-            UNIT_ASSERT(TInstant::TryParseIso8601Deprecated(s, iTry));
-            UNIT_ASSERT_VALUES_EQUAL(i, iTry);
-        }
-        {
+            const auto i = TInstant::ParseIso8601Deprecated(s); 
+            TInstant iTry; 
+            UNIT_ASSERT(TInstant::TryParseIso8601Deprecated(s, iTry)); 
+            UNIT_ASSERT_VALUES_EQUAL(i, iTry); 
+        } 
+        { 
             const TStringBuf s = "2009-09aslkdjfkljasdjfl4:00";
-            TInstant iTry;
-            UNIT_ASSERT_EXCEPTION(TInstant::ParseIso8601Deprecated(s), TDateTimeParseException);
-            UNIT_ASSERT(!TInstant::TryParseIso8601Deprecated(s, iTry));
-        }
-        {
+            TInstant iTry; 
+            UNIT_ASSERT_EXCEPTION(TInstant::ParseIso8601Deprecated(s), TDateTimeParseException); 
+            UNIT_ASSERT(!TInstant::TryParseIso8601Deprecated(s, iTry)); 
+        } 
+        { 
             const TStringBuf s = "Wed, 14 Oct 2009 16:55:33 GMT";
-            const auto i = TInstant::ParseRfc822Deprecated(s);
-            TInstant iTry;
-            UNIT_ASSERT(TInstant::TryParseRfc822Deprecated(s, iTry));
-            UNIT_ASSERT_VALUES_EQUAL(i, iTry);
-        }
-        {
+            const auto i = TInstant::ParseRfc822Deprecated(s); 
+            TInstant iTry; 
+            UNIT_ASSERT(TInstant::TryParseRfc822Deprecated(s, iTry)); 
+            UNIT_ASSERT_VALUES_EQUAL(i, iTry); 
+        } 
+        { 
             const TStringBuf s = "Wed, alsdjflkasjdfl:55:33 GMT";
-            TInstant iTry;
-            UNIT_ASSERT_EXCEPTION(TInstant::ParseRfc822Deprecated(s), TDateTimeParseException);
-            UNIT_ASSERT(!TInstant::TryParseRfc822Deprecated(s, iTry));
-        }
-        {
+            TInstant iTry; 
+            UNIT_ASSERT_EXCEPTION(TInstant::ParseRfc822Deprecated(s), TDateTimeParseException); 
+            UNIT_ASSERT(!TInstant::TryParseRfc822Deprecated(s, iTry)); 
+        } 
+        { 
             const TStringBuf s = "20091014165533Z";
-            const auto i = TInstant::ParseX509ValidityDeprecated(s);
-            TInstant iTry;
-            UNIT_ASSERT(TInstant::TryParseX509Deprecated(s, iTry));
-            UNIT_ASSERT_VALUES_EQUAL(i, iTry);
-        }
-        {
+            const auto i = TInstant::ParseX509ValidityDeprecated(s); 
+            TInstant iTry; 
+            UNIT_ASSERT(TInstant::TryParseX509Deprecated(s, iTry)); 
+            UNIT_ASSERT_VALUES_EQUAL(i, iTry); 
+        } 
+        { 
             const TStringBuf s = "200asdfasdf533Z";
-            TInstant iTry;
-            UNIT_ASSERT_EXCEPTION(TInstant::ParseX509ValidityDeprecated(s), TDateTimeParseException);
-            UNIT_ASSERT(!TInstant::TryParseX509Deprecated(s, iTry));
-        }
-        {
+            TInstant iTry; 
+            UNIT_ASSERT_EXCEPTION(TInstant::ParseX509ValidityDeprecated(s), TDateTimeParseException); 
+            UNIT_ASSERT(!TInstant::TryParseX509Deprecated(s, iTry)); 
+        } 
+        { 
             const TStringBuf s = "990104074212Z";
-            const auto i = TInstant::ParseX509ValidityDeprecated(s);
-            TInstant iTry;
-            UNIT_ASSERT(TInstant::TryParseX509Deprecated(s, iTry));
-            UNIT_ASSERT_VALUES_EQUAL(i, iTry);
-        }
-        {
+            const auto i = TInstant::ParseX509ValidityDeprecated(s); 
+            TInstant iTry; 
+            UNIT_ASSERT(TInstant::TryParseX509Deprecated(s, iTry)); 
+            UNIT_ASSERT_VALUES_EQUAL(i, iTry); 
+        } 
+        { 
             const TStringBuf s = "9901asdf4212Z";
-            TInstant iTry;
-            UNIT_ASSERT_EXCEPTION(TInstant::ParseX509ValidityDeprecated(s), TDateTimeParseException);
-            UNIT_ASSERT(!TInstant::TryParseX509Deprecated(s, iTry));
-        }
-    }
-}
-
-Y_UNIT_TEST_SUITE(TDurationParseTestDeprecated) {
-    Y_UNIT_TEST(TestParseDeprecated) {
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::Seconds(60), TDuration::Parse("1m"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::Seconds(90), TDuration::Parse("1.5m"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::Seconds(102), TDuration::Parse("1.7m"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(119400), TDuration::Parse("1.99m"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(119940), TDuration::Parse("1.999m"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(119994), TDuration::Parse("1.9999m"));
-
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::Minutes(60), TDuration::Parse("1h"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::Minutes(90), TDuration::Parse("1.5h"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::Minutes(102), TDuration::Parse("1.7h"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::Seconds(7164), TDuration::Parse("1.99h"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(7196400), TDuration::Parse("1.999h"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(7199640), TDuration::Parse("1.9999h"));
-
-        UNIT_ASSERT_EQUAL(TDuration::Minutes(15), TDuration::Parse("15m"));
-        UNIT_ASSERT_EQUAL(TDuration::Hours(10), TDuration::Parse("10h"));
-        UNIT_ASSERT_EQUAL(TDuration::Days(365), TDuration::Parse("365d"));
-        UNIT_ASSERT_EQUAL(TDuration::Hours(36), TDuration::Parse("1.5d"));
-
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::Hours(24), TDuration::Parse("1d"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::Hours(36), TDuration::Parse("1.5d"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::Minutes(2448), TDuration::Parse("1.7d"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::Seconds(171936), TDuration::Parse("1.99d"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(172713600), TDuration::Parse("1.999d"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(172791360), TDuration::Parse("1.9999d"));
-
-#if 0 // not implemented
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::Seconds(90), TDuration::Parse("1m30s"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::Minutes(90), TDuration::Parse("1h30m"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::Hours(36), TDuration::Parse("1d12h"));
-#endif
-
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::Seconds(10), TDuration::Parse("10s"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::Seconds(10), TDuration::Parse("10.000s"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::MicroSeconds(4), TDuration::Parse("0.000004s"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(3456), TDuration::Parse("3.456s"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(3450), TDuration::Parse("3.450s"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(3450), TDuration::Parse("3.45000000s"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(3450), TDuration::Parse("3.45s"));
-
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(1), TDuration::Parse("1ms"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::MicroSeconds(1100), TDuration::Parse("1.1ms"));
-
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::Seconds(112), TDuration::Parse("112"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::MicroSeconds(14456), TDuration::Parse("14456us"));
-
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::MicroSeconds(1), TDuration::Parse("1000ns"));
-        UNIT_ASSERT_VALUES_EQUAL(TDuration::MicroSeconds(1), TDuration::Parse("0.000001s"));
-
-        UNIT_ASSERT_EQUAL(TDuration(), TDuration::Parse("10ns")); // TDuration has 1us precision.
-    }
-}
+            TInstant iTry; 
+            UNIT_ASSERT_EXCEPTION(TInstant::ParseX509ValidityDeprecated(s), TDateTimeParseException); 
+            UNIT_ASSERT(!TInstant::TryParseX509Deprecated(s, iTry)); 
+        } 
+    } 
+} 
+ 
+Y_UNIT_TEST_SUITE(TDurationParseTestDeprecated) { 
+    Y_UNIT_TEST(TestParseDeprecated) { 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::Seconds(60), TDuration::Parse("1m")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::Seconds(90), TDuration::Parse("1.5m")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::Seconds(102), TDuration::Parse("1.7m")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(119400), TDuration::Parse("1.99m")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(119940), TDuration::Parse("1.999m")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(119994), TDuration::Parse("1.9999m")); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::Minutes(60), TDuration::Parse("1h")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::Minutes(90), TDuration::Parse("1.5h")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::Minutes(102), TDuration::Parse("1.7h")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::Seconds(7164), TDuration::Parse("1.99h")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(7196400), TDuration::Parse("1.999h")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(7199640), TDuration::Parse("1.9999h")); 
+ 
+        UNIT_ASSERT_EQUAL(TDuration::Minutes(15), TDuration::Parse("15m")); 
+        UNIT_ASSERT_EQUAL(TDuration::Hours(10), TDuration::Parse("10h")); 
+        UNIT_ASSERT_EQUAL(TDuration::Days(365), TDuration::Parse("365d")); 
+        UNIT_ASSERT_EQUAL(TDuration::Hours(36), TDuration::Parse("1.5d")); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::Hours(24), TDuration::Parse("1d")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::Hours(36), TDuration::Parse("1.5d")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::Minutes(2448), TDuration::Parse("1.7d")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::Seconds(171936), TDuration::Parse("1.99d")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(172713600), TDuration::Parse("1.999d")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(172791360), TDuration::Parse("1.9999d")); 
+ 
+#if 0 // not implemented 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::Seconds(90), TDuration::Parse("1m30s")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::Minutes(90), TDuration::Parse("1h30m")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::Hours(36), TDuration::Parse("1d12h")); 
+#endif 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::Seconds(10), TDuration::Parse("10s")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::Seconds(10), TDuration::Parse("10.000s")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::MicroSeconds(4), TDuration::Parse("0.000004s")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(3456), TDuration::Parse("3.456s")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(3450), TDuration::Parse("3.450s")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(3450), TDuration::Parse("3.45000000s")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(3450), TDuration::Parse("3.45s")); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(1), TDuration::Parse("1ms")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::MicroSeconds(1100), TDuration::Parse("1.1ms")); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::Seconds(112), TDuration::Parse("112")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::MicroSeconds(14456), TDuration::Parse("14456us")); 
+ 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::MicroSeconds(1), TDuration::Parse("1000ns")); 
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::MicroSeconds(1), TDuration::Parse("0.000001s")); 
+ 
+        UNIT_ASSERT_EQUAL(TDuration(), TDuration::Parse("10ns")); // TDuration has 1us precision. 
+    } 
+} 
diff --git a/util/datetime/parser_ut.cpp b/util/datetime/parser_ut.cpp
index 61364af997..1556d24877 100644
--- a/util/datetime/parser_ut.cpp
+++ b/util/datetime/parser_ut.cpp
@@ -12,118 +12,118 @@ Y_UNIT_TEST_SUITE(TDateTimeParseTest) {
 
         // predefined time zones
 
-        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 UT", t);
+        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 UT", t); 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885);
 
-        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 GMT", t);
+        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 GMT", t); 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885);
 
-        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 EST", t);
+        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 EST", t); 
         UNIT_ASSERT(r);
         UNIT_ASSERT_VALUES_EQUAL(t, (time_t)1109964885 + 5 * SECONDS_PER_HOUR);
-        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 EDT", t);
+        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 EDT", t); 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 4 * SECONDS_PER_HOUR);
 
-        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 CST", t);
+        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 CST", t); 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 6 * SECONDS_PER_HOUR);
-        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 CDT", t);
+        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 CDT", t); 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 5 * SECONDS_PER_HOUR);
 
-        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 MST", t);
+        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 MST", t); 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 7 * SECONDS_PER_HOUR);
-        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 MDT", t);
+        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 MDT", t); 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 6 * SECONDS_PER_HOUR);
 
-        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 PST", t);
+        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 PST", t); 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 8 * SECONDS_PER_HOUR);
-        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 PDT", t);
+        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 PDT", t); 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 7 * SECONDS_PER_HOUR);
 
         // optinal century
-        r = ParseRFC822DateTime("Fri, 4 Mar 05 19:34:45 UT", t);
+        r = ParseRFC822DateTime("Fri, 4 Mar 05 19:34:45 UT", t); 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885);
 
         // + optional day of week
-        r = ParseRFC822DateTime("4 Mar 05 19:34:45 UT", t);
+        r = ParseRFC822DateTime("4 Mar 05 19:34:45 UT", t); 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885);
 
         // + optional seconds
-        r = ParseRFC822DateTime("4 Mar 05 19:34 UT", t);
+        r = ParseRFC822DateTime("4 Mar 05 19:34 UT", t); 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964840);
 
         // local differential hour+min
 
-        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 +0300", t);
+        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 +0300", t); 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109954085);
 
-        r = ParseRFC822DateTime("Fri, 4 Mar 05 19:34:45 +0300", t);
+        r = ParseRFC822DateTime("Fri, 4 Mar 05 19:34:45 +0300", t); 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109954085);
 
-        r = ParseRFC822DateTime("21 Apr 1999 23:40:00 +0400", t);
+        r = ParseRFC822DateTime("21 Apr 1999 23:40:00 +0400", t); 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)924723600);
 
-        r = ParseRFC822DateTime("21 Apr 99 23:40 +0400", t);
+        r = ParseRFC822DateTime("21 Apr 99 23:40 +0400", t); 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)924723600);
 
-        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 -0300", t);
+        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 -0300", t); 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 3 * SECONDS_PER_HOUR);
 
-        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34 -0300", t);
+        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34 -0300", t); 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964840 + 3 * SECONDS_PER_HOUR);
 
-        r = ParseRFC822DateTime("Fri, 4 Mar 05 19:34:45 -0330", t);
+        r = ParseRFC822DateTime("Fri, 4 Mar 05 19:34:45 -0330", t); 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 3 * SECONDS_PER_HOUR + 30 * SECONDS_PER_MINUTE);
 
-        r = ParseRFC822DateTime("Fri, 4 Mar 05 19:34 -0330", t);
+        r = ParseRFC822DateTime("Fri, 4 Mar 05 19:34 -0330", t); 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964840 + 3 * SECONDS_PER_HOUR + 30 * SECONDS_PER_MINUTE);
 
-        r = ParseRFC822DateTime("4 Mar 2005 19:34:45 -1030", t);
+        r = ParseRFC822DateTime("4 Mar 2005 19:34:45 -1030", t); 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885 + 10 * SECONDS_PER_HOUR + 30 * SECONDS_PER_MINUTE);
 
-        r = ParseRFC822DateTime("4 Mar 2005 19:34 -1030", t);
+        r = ParseRFC822DateTime("4 Mar 2005 19:34 -1030", t); 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964840 + 10 * SECONDS_PER_HOUR + 30 * SECONDS_PER_MINUTE);
 
         // white spaces
 
-        r = ParseRFC822DateTime("Fri,4 Mar 2005 19:34:45 UT", t); // no space after comma
+        r = ParseRFC822DateTime("Fri,4 Mar 2005 19:34:45 UT", t); // no space after comma 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885);
 
-        r = ParseRFC822DateTime("   Fri,   4   Mar   2005   19:34:45   UT   ", t); // several spaces, leading and trailing
+        r = ParseRFC822DateTime("   Fri,   4   Mar   2005   19:34:45   UT   ", t); // several spaces, leading and trailing 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885);
 
-        r = ParseRFC822DateTime(" \t Fri, \t 4 \t Mar \t 2005 \t 19:34:45 \t UT \t ", t); // spaces with tabs
+        r = ParseRFC822DateTime(" \t Fri, \t 4 \t Mar \t 2005 \t 19:34:45 \t UT \t ", t); // spaces with tabs 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1109964885);
 
-        r = ParseRFC822DateTime("Thu, 01 Jan 1970 03:00:00 +0300", t); // spaces with tabs
+        r = ParseRFC822DateTime("Thu, 01 Jan 1970 03:00:00 +0300", t); // spaces with tabs 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)0);
 
-        r = ParseRFC822DateTime("Sat, 14 Feb 2009 02:31:30 +0300", t); // spaces with tabs
+        r = ParseRFC822DateTime("Sat, 14 Feb 2009 02:31:30 +0300", t); // spaces with tabs 
         UNIT_ASSERT(r);
         UNIT_ASSERT_EQUAL(t, (time_t)1234567890);
     }
@@ -154,7 +154,7 @@ Y_UNIT_TEST_SUITE(TDateTimeParseTest) {
             // the last character is replaced with next zone symbol
             text[zoneCharIndex] = militaryZone;
 
-            UNIT_ASSERT(ParseRFC822DateTime(text, t));
+            UNIT_ASSERT(ParseRFC822DateTime(text, t)); 
             UNIT_ASSERT_EQUAL(t, utcTime - offset);
         }
     }
@@ -171,111 +171,111 @@ Y_UNIT_TEST_SUITE(TDateTimeParseTest) {
         time_t t = 0;
 
         t = 12345;
-        r = ParseRFC822DateTime("", t);
+        r = ParseRFC822DateTime("", t); 
         UNIT_ASSERT(!r);
         UNIT_ASSERT_EQUAL(t, (time_t)12345);
 
         t = 223344;
-        r = ParseRFC822DateTime("Fri, some junk", t);
+        r = ParseRFC822DateTime("Fri, some junk", t); 
         UNIT_ASSERT(!r);
         UNIT_ASSERT_EQUAL(t, (time_t)223344);
 
         t = 54321;
-        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 UTC", t);
+        r = ParseRFC822DateTime("Fri, 4 Mar 2005 19:34:45 UTC", t); 
         UNIT_ASSERT(!r);
         UNIT_ASSERT_EQUAL(t, (time_t)54321);
 
         // TODO: check semantic validity of parsed date (30 Feb, 88:90 etc.).
         // The following tests MUST fail (they don't now)
-        // r = ParseRFC822DateTime("45 Mar 2005 19:34:45 UT", t);
+        // r = ParseRFC822DateTime("45 Mar 2005 19:34:45 UT", t); 
         // UNIT_ASSERT_EQUAL(r, false);
 
-        // r = ParseRFC822DateTime("29 Feb 2005 19:34:45 +0300", t);
+        // r = ParseRFC822DateTime("29 Feb 2005 19:34:45 +0300", t); 
         // UNIT_ASSERT_EQUAL(r, false);
 
-        // r = ParseRFC822DateTime("31 Apr 2004 19:34:45 +0300", t);
+        // r = ParseRFC822DateTime("31 Apr 2004 19:34:45 +0300", t); 
         // UNIT_ASSERT_EQUAL(r, false);
 
-        r = ParseRFC822DateTime("17 Nov 2008 19:34:45", t); // no specified time zone
+        r = ParseRFC822DateTime("17 Nov 2008 19:34:45", t); // no specified time zone 
         UNIT_ASSERT(!r);
 
-        r = ParseRFC822DateTime("17 Nov 200 19:34:45 UT", t);
+        r = ParseRFC822DateTime("17 Nov 200 19:34:45 UT", t); 
         UNIT_ASSERT(!r);
-        r = ParseRFC822DateTime("17 Nov 8 19:34:45 UT", t);
+        r = ParseRFC822DateTime("17 Nov 8 19:34:45 UT", t); 
         UNIT_ASSERT(!r);
-        r = ParseRFC822DateTime("17 Nov 20008 19:34:45 UT", t);
+        r = ParseRFC822DateTime("17 Nov 20008 19:34:45 UT", t); 
         UNIT_ASSERT(!r);
 
-        r = ParseRFC822DateTime("17 Nov 2008 1:34:45 UT", t);
+        r = ParseRFC822DateTime("17 Nov 2008 1:34:45 UT", t); 
         UNIT_ASSERT(!r);
-        r = ParseRFC822DateTime("17 Nov 2008 123:34:45 UT", t);
+        r = ParseRFC822DateTime("17 Nov 2008 123:34:45 UT", t); 
         UNIT_ASSERT(!r);
-        r = ParseRFC822DateTime("17 Nov 2008 19:1:45 UT", t);
+        r = ParseRFC822DateTime("17 Nov 2008 19:1:45 UT", t); 
         UNIT_ASSERT(!r);
-        r = ParseRFC822DateTime("17 Nov 2008 19:123:45 UT", t);
+        r = ParseRFC822DateTime("17 Nov 2008 19:123:45 UT", t); 
         UNIT_ASSERT(!r);
-        r = ParseRFC822DateTime("17 Nov 2008 19:34:1 UT", t);
+        r = ParseRFC822DateTime("17 Nov 2008 19:34:1 UT", t); 
         UNIT_ASSERT(!r);
-        r = ParseRFC822DateTime("17 Nov 2008 19:34:123 UT", t);
+        r = ParseRFC822DateTime("17 Nov 2008 19:34:123 UT", t); 
         UNIT_ASSERT(!r);
-        r = ParseRFC822DateTime("17 Nov 2008 19:34:12.12 UT", t); // fractions of second are now allowed
+        r = ParseRFC822DateTime("17 Nov 2008 19:34:12.12 UT", t); // fractions of second are now allowed 
         UNIT_ASSERT(!r);
 
-        r = ParseRFC822DateTime("Mon , 17 Nov 2005 19:34:45 UT", t); // space after day before the comma
+        r = ParseRFC822DateTime("Mon , 17 Nov 2005 19:34:45 UT", t); // space after day before the comma 
         UNIT_ASSERT(!r);
-        r = ParseRFC822DateTime("Mon, 17 Nov 2005 19 :34:45 UT", t);
+        r = ParseRFC822DateTime("Mon, 17 Nov 2005 19 :34:45 UT", t); 
         UNIT_ASSERT(!r);
-        r = ParseRFC822DateTime("Mon, 17 Nov 2005 19: 34:45 UT", t);
+        r = ParseRFC822DateTime("Mon, 17 Nov 2005 19: 34:45 UT", t); 
         UNIT_ASSERT(!r);
-        r = ParseRFC822DateTime("Mon, 17 Nov 2005 19:34 :45 UT", t);
+        r = ParseRFC822DateTime("Mon, 17 Nov 2005 19:34 :45 UT", t); 
         UNIT_ASSERT(!r);
-        r = ParseRFC822DateTime("Mon, 17 Nov 2005 19:34: 45 UT", t);
+        r = ParseRFC822DateTime("Mon, 17 Nov 2005 19:34: 45 UT", t); 
         UNIT_ASSERT(!r);
 
-        r = ParseRFC822DateTime("Monday, 17 Nov 2005 19:34:45 UT", t);
+        r = ParseRFC822DateTime("Monday, 17 Nov 2005 19:34:45 UT", t); 
         UNIT_ASSERT(!r);
-        r = ParseRFC822DateTime("Mon, 17 November 2008 19:34:45 UT", t);
+        r = ParseRFC822DateTime("Mon, 17 November 2008 19:34:45 UT", t); 
         UNIT_ASSERT(!r);
 
-        r = ParseRFC822DateTime("Mon, 17 Nov 2008 19:34:45 +3", t);
+        r = ParseRFC822DateTime("Mon, 17 Nov 2008 19:34:45 +3", t); 
         UNIT_ASSERT(!r);
-        r = ParseRFC822DateTime("Mon, 17 Nov 2008 19:34:45 +03", t);
+        r = ParseRFC822DateTime("Mon, 17 Nov 2008 19:34:45 +03", t); 
         UNIT_ASSERT(!r);
-        r = ParseRFC822DateTime("Mon, 17 Nov 2008 19:34:45 +030", t);
+        r = ParseRFC822DateTime("Mon, 17 Nov 2008 19:34:45 +030", t); 
         UNIT_ASSERT(!r);
-        r = ParseRFC822DateTime("Mon, 17 Nov 2008 19:34:45 +03030", t);
+        r = ParseRFC822DateTime("Mon, 17 Nov 2008 19:34:45 +03030", t); 
         UNIT_ASSERT(!r);
-        r = ParseRFC822DateTime("Mon, 17 Nov 2008 19:34:45 -3", t);
+        r = ParseRFC822DateTime("Mon, 17 Nov 2008 19:34:45 -3", t); 
         UNIT_ASSERT(!r);
-        r = ParseRFC822DateTime("Mon, 17 Nov 2008 19:34:45 -03", t);
+        r = ParseRFC822DateTime("Mon, 17 Nov 2008 19:34:45 -03", t); 
         UNIT_ASSERT(!r);
-        r = ParseRFC822DateTime("Mon, 17 Nov 2008 19:34:45 -030", t);
+        r = ParseRFC822DateTime("Mon, 17 Nov 2008 19:34:45 -030", t); 
         UNIT_ASSERT(!r);
-        r = ParseRFC822DateTime("Mon, 17 Nov 2008 19:34:45 -03030", t);
+        r = ParseRFC822DateTime("Mon, 17 Nov 2008 19:34:45 -03030", t); 
         UNIT_ASSERT(!r);
     }
 
     Y_UNIT_TEST(TestRfc822Partial) {
-        TRfc822DateTimeParser p;
+        TRfc822DateTimeParser p; 
         const char* part1 = "Fri, 4 Mar 05 1";
         const char* part2 = "9:34:45 +0300";
         UNIT_ASSERT(p.ParsePart(part1, strlen(part1)));
         UNIT_ASSERT(p.ParsePart(part2, strlen(part2)));
         UNIT_ASSERT_VALUES_EQUAL(TInstant::Seconds(1109954085), p.GetResult(TInstant::Max()));
-        p = TRfc822DateTimeParser();
+        p = TRfc822DateTimeParser(); 
         const char* part3 = "Fri, 4 Mar 05 19:34:46 +0300";
         UNIT_ASSERT(p.ParsePart(part3, strlen(part3)));
         UNIT_ASSERT_VALUES_EQUAL(TInstant::Seconds(1109954086), p.GetResult(TInstant::Zero()));
     }
 
     Y_UNIT_TEST(TestIso8601Partial) {
-        TIso8601DateTimeParser p;
+        TIso8601DateTimeParser p; 
         const char* part1 = "1990-03-15T15:1";
         const char* part2 = "6:17+0732";
         UNIT_ASSERT(p.ParsePart(part1, strlen(part1)));
         UNIT_ASSERT(p.ParsePart(part2, strlen(part2)));
         UNIT_ASSERT_VALUES_EQUAL(TInstant::Seconds(637487057), p.GetResult(TInstant::Max()));
-        p = TIso8601DateTimeParser();
+        p = TIso8601DateTimeParser(); 
         const char* part3 = "1990-03-15T15:16:18+0732";
         UNIT_ASSERT(p.ParsePart(part3, strlen(part3)));
         UNIT_ASSERT_VALUES_EQUAL(TInstant::Seconds(637487058), p.GetResult(TInstant::Zero()));
@@ -286,87 +286,87 @@ Y_UNIT_TEST_SUITE(TDateTimeParseTest) {
         time_t t;
 
         // ISO 8601 actually does not allow time without time zone
-        ret = ParseISO8601DateTime("1990-03-15", t);
+        ret = ParseISO8601DateTime("1990-03-15", t); 
         UNIT_ASSERT(ret);
         UNIT_ASSERT_VALUES_EQUAL(t, 637459200);
 
         // some normal dates
-        ret = ParseISO8601DateTime("1990-03-15T15:16:17Z", t);
+        ret = ParseISO8601DateTime("1990-03-15T15:16:17Z", t); 
         UNIT_ASSERT(ret);
         UNIT_ASSERT_VALUES_EQUAL(t, 637514177);
 
-        ret = ParseISO8601DateTime("1990-03-15t15:16:17z", t); // lower-case must be allowed too
+        ret = ParseISO8601DateTime("1990-03-15t15:16:17z", t); // lower-case must be allowed too 
         UNIT_ASSERT(ret);
         UNIT_ASSERT_VALUES_EQUAL(t, 637514177);
 
-        ret = ParseISO8601DateTime("1990-03-15 15:16:17Z", t); // space as separator should be allowed
+        ret = ParseISO8601DateTime("1990-03-15 15:16:17Z", t); // space as separator should be allowed 
         UNIT_ASSERT(ret);
         UNIT_ASSERT_VALUES_EQUAL(t, 637514177);
 
-        ret = ParseISO8601DateTime("1990-03-15T15:16:17.18Z", t);
+        ret = ParseISO8601DateTime("1990-03-15T15:16:17.18Z", t); 
         UNIT_ASSERT(ret);
         UNIT_ASSERT_VALUES_EQUAL(t, 637514177);
 
-        ret = ParseISO8601DateTime("1990-03-15T15:16:17.18+07:32", t);
+        ret = ParseISO8601DateTime("1990-03-15T15:16:17.18+07:32", t); 
         UNIT_ASSERT(ret);
         UNIT_ASSERT_VALUES_EQUAL(t, 637487057);
 
-        ret = ParseISO8601DateTime("1990-03-15T15:16:17.18+0732", t);
+        ret = ParseISO8601DateTime("1990-03-15T15:16:17.18+0732", t); 
         UNIT_ASSERT(ret);
         UNIT_ASSERT_VALUES_EQUAL(t, 637487057);
 
-        ret = ParseISO8601DateTime("1970-01-01T00:00:00Z", t);
+        ret = ParseISO8601DateTime("1970-01-01T00:00:00Z", t); 
         UNIT_ASSERT(ret);
         UNIT_ASSERT_VALUES_EQUAL(t, 0);
 
-        ret = ParseISO8601DateTime("1970-01-01T00:01:02Z", t);
+        ret = ParseISO8601DateTime("1970-01-01T00:01:02Z", t); 
         UNIT_ASSERT(ret);
         UNIT_ASSERT_VALUES_EQUAL(t, 62);
 
 #if 0
         // these tests are disabled, because time zones are handled differently
         // in old util/ parser and agalakhov@ parser
-        ret = ParseISO8601DateTime("1970-01-01", t);
+        ret = ParseISO8601DateTime("1970-01-01", t); 
         UNIT_ASSERT(ret);
         UNIT_ASSERT_VALUES_EQUAL(t, -4 * 3600);
 
-        ret = ParseISO8601DateTime("1970-01-02", t);
+        ret = ParseISO8601DateTime("1970-01-02", t); 
         UNIT_ASSERT(ret);
         UNIT_ASSERT_VALUES_EQUAL(t, 86400 - 3 * 3600);
 #endif
 
         // this is wrong because of timezone
-        ret = ParseISO8601DateTime("2009-02-14T03:31:30", t);
+        ret = ParseISO8601DateTime("2009-02-14T03:31:30", t); 
         UNIT_ASSERT(ret);
-        UNIT_ASSERT_VALUES_EQUAL(t, 1234582290);
+        UNIT_ASSERT_VALUES_EQUAL(t, 1234582290); 
 
-        ret = ParseISO8601DateTime("2009-02-14t03:31:30", t);
+        ret = ParseISO8601DateTime("2009-02-14t03:31:30", t); 
         UNIT_ASSERT(ret);
-        UNIT_ASSERT_VALUES_EQUAL(t, 1234582290);
+        UNIT_ASSERT_VALUES_EQUAL(t, 1234582290); 
 
-        ret = ParseISO8601DateTime("2009-02-14T02:31:30+0300", t);
+        ret = ParseISO8601DateTime("2009-02-14T02:31:30+0300", t); 
         UNIT_ASSERT(ret);
         UNIT_ASSERT_VALUES_EQUAL(t, 1234567890);
 
-        ret = ParseISO8601DateTime("2009-02-14T02:31:30+03:00", t);
+        ret = ParseISO8601DateTime("2009-02-14T02:31:30+03:00", t); 
         UNIT_ASSERT(ret);
         UNIT_ASSERT_VALUES_EQUAL(t, 1234567890);
 
-        ret = ParseISO8601DateTime("2009-02-14 02:31:30+03:00", t);
+        ret = ParseISO8601DateTime("2009-02-14 02:31:30+03:00", t); 
         UNIT_ASSERT(ret);
         UNIT_ASSERT_VALUES_EQUAL(t, 1234567890);
 
-        ret = ParseISO8601DateTime("2010-03-28T04:27:00.000-07:00", t);
+        ret = ParseISO8601DateTime("2010-03-28T04:27:00.000-07:00", t); 
         UNIT_ASSERT(ret);
         UNIT_ASSERT_VALUES_EQUAL(t, 1269775620);
     }
 
     Y_UNIT_TEST(TestIso8601TimeZone) {
         time_t t1, t2, t3, t4;
-        UNIT_ASSERT(ParseISO8601DateTime("2010-03-28T04:27:00.000+07:00", t1));
-        UNIT_ASSERT(ParseISO8601DateTime("2010-03-27T21:27:00.000Z", t2));
-        UNIT_ASSERT(ParseISO8601DateTime("2010-03-27T22:27:00.000+0100", t3));
-        UNIT_ASSERT(ParseISO8601DateTime("2010-03-27T20:27:00.000-01:00", t4));
+        UNIT_ASSERT(ParseISO8601DateTime("2010-03-28T04:27:00.000+07:00", t1)); 
+        UNIT_ASSERT(ParseISO8601DateTime("2010-03-27T21:27:00.000Z", t2)); 
+        UNIT_ASSERT(ParseISO8601DateTime("2010-03-27T22:27:00.000+0100", t3)); 
+        UNIT_ASSERT(ParseISO8601DateTime("2010-03-27T20:27:00.000-01:00", t4)); 
         UNIT_ASSERT_VALUES_EQUAL(t1, t2);
         UNIT_ASSERT_VALUES_EQUAL(t2, t3);
         UNIT_ASSERT_VALUES_EQUAL(t3, t4);
@@ -377,47 +377,47 @@ Y_UNIT_TEST_SUITE(TDateTimeParseTest) {
         time_t t;
 
         t = 12345;
-        ret = ParseISO8601DateTime("", t);
+        ret = ParseISO8601DateTime("", t); 
         UNIT_ASSERT(!ret);
         UNIT_ASSERT_EQUAL(t, (time_t)12345);
 
         // some bad dates
         t = 54321;
-        ret = ParseISO8601DateTime("a990-01-15", t);
+        ret = ParseISO8601DateTime("a990-01-15", t); 
         UNIT_ASSERT(!ret);
         UNIT_ASSERT_EQUAL(t, (time_t)54321);
 
-        ret = ParseISO8601DateTime("1970-01-01T03:00:00+04:00", t); // this is 1969 GMT
+        ret = ParseISO8601DateTime("1970-01-01T03:00:00+04:00", t); // this is 1969 GMT 
         UNIT_ASSERT(!ret);
 
-        ret = ParseISO8601DateTime("1987-13-16", t);
+        ret = ParseISO8601DateTime("1987-13-16", t); 
         UNIT_ASSERT(!ret);
 
-        ret = ParseISO8601DateTime("1987-02-29", t);
+        ret = ParseISO8601DateTime("1987-02-29", t); 
         UNIT_ASSERT(!ret);
 
-        ret = ParseISO8601DateTime("1990-03-151Y15:16:17.18", t);
+        ret = ParseISO8601DateTime("1990-03-151Y15:16:17.18", t); 
         UNIT_ASSERT(!ret);
 
-        ret = ParseISO8601DateTime("1990-03-151T15:16:17:43.18", t);
+        ret = ParseISO8601DateTime("1990-03-151T15:16:17:43.18", t); 
         UNIT_ASSERT(!ret);
 
-        ret = ParseISO8601DateTime("1990-03-151T15:16:17.18Z+21:32", t);
+        ret = ParseISO8601DateTime("1990-03-151T15:16:17.18Z+21:32", t); 
         UNIT_ASSERT(!ret);
     }
 
     Y_UNIT_TEST(TestIso8601Fractions) {
         UNIT_ASSERT_VALUES_EQUAL(
-            TInstant::ParseIso8601("2009-09-19 03:37:08.1+04:00"),
+            TInstant::ParseIso8601("2009-09-19 03:37:08.1+04:00"), 
             TInstant::Seconds(1253317028) + TDuration::MilliSeconds(100));
         UNIT_ASSERT_VALUES_EQUAL(
-            TInstant::ParseIso8601("2009-09-19 03:37:03.926+04:00"),
+            TInstant::ParseIso8601("2009-09-19 03:37:03.926+04:00"), 
             TInstant::Seconds(1253317023) + TDuration::MilliSeconds(926));
         UNIT_ASSERT_VALUES_EQUAL(
-            TInstant::ParseIso8601("2009-09-19 03:37:03.92622+04:00"),
+            TInstant::ParseIso8601("2009-09-19 03:37:03.92622+04:00"), 
             TInstant::Seconds(1253317023) + TDuration::MicroSeconds(926220));
         UNIT_ASSERT_VALUES_EQUAL(
-            TInstant::ParseIso8601("2009-09-19 03:37:03.012331+04:00"),
+            TInstant::ParseIso8601("2009-09-19 03:37:03.012331+04:00"), 
             TInstant::Seconds(1253317023) + TDuration::MicroSeconds(12331));
     }
 
@@ -473,99 +473,99 @@ Y_UNIT_TEST_SUITE(TDateTimeParseTest) {
 
     Y_UNIT_TEST(TestHttpDate) {
         UNIT_ASSERT_VALUES_EQUAL(
-            TInstant::ParseHttp("Sun, 06 Nov 1994 08:49:37 GMT"),
-            TInstant::ParseIso8601("1994-11-06T08:49:37Z"));
+            TInstant::ParseHttp("Sun, 06 Nov 1994 08:49:37 GMT"), 
+            TInstant::ParseIso8601("1994-11-06T08:49:37Z")); 
         UNIT_ASSERT_VALUES_EQUAL(
-            TInstant::ParseHttp("Sunday, 06-Nov-94 08:49:37 GMT"),
-            TInstant::ParseIso8601("1994-11-06T08:49:37Z"));
+            TInstant::ParseHttp("Sunday, 06-Nov-94 08:49:37 GMT"), 
+            TInstant::ParseIso8601("1994-11-06T08:49:37Z")); 
         UNIT_ASSERT_VALUES_EQUAL(
-            TInstant::ParseHttp("Sun Nov  6 08:49:37 1994"),
-            TInstant::ParseIso8601("1994-11-06T08:49:37Z"));
+            TInstant::ParseHttp("Sun Nov  6 08:49:37 1994"), 
+            TInstant::ParseIso8601("1994-11-06T08:49:37Z")); 
         UNIT_ASSERT_VALUES_EQUAL(
-            TInstant::ParseHttp("Mon, 19 Jan 2037 08:49:37 GMT"),
-            TInstant::ParseIso8601("2037-01-19T08:49:37Z"));
+            TInstant::ParseHttp("Mon, 19 Jan 2037 08:49:37 GMT"), 
+            TInstant::ParseIso8601("2037-01-19T08:49:37Z")); 
     }
 
     Y_UNIT_TEST(TestHttpDateIncorrect) {
         bool ret;
         time_t t = 0;
-        ret = ParseHTTPDateTime("1990-03-15T15:16:17Z", t);
+        ret = ParseHTTPDateTime("1990-03-15T15:16:17Z", t); 
         UNIT_ASSERT(!ret);
     }
 
     Y_UNIT_TEST(TestX509ValidityTime) {
         UNIT_ASSERT_VALUES_EQUAL(
-            TInstant::ParseX509Validity("20091014165533Z"),
-            TInstant::ParseRfc822("Wed, 14 Oct 2009 16:55:33 GMT"));
+            TInstant::ParseX509Validity("20091014165533Z"), 
+            TInstant::ParseRfc822("Wed, 14 Oct 2009 16:55:33 GMT")); 
         UNIT_ASSERT_VALUES_EQUAL(
-            TInstant::ParseX509Validity("990104074212Z"),
-            TInstant::ParseRfc822("4 Jan 1999 07:42:12 GMT"));
+            TInstant::ParseX509Validity("990104074212Z"), 
+            TInstant::ParseRfc822("4 Jan 1999 07:42:12 GMT")); 
         UNIT_ASSERT_VALUES_EQUAL(
-            TInstant::ParseX509Validity("191231235959Z"),
-            TInstant::ParseRfc822("31 Dec 2019 23:59:59 GMT"));
+            TInstant::ParseX509Validity("191231235959Z"), 
+            TInstant::ParseRfc822("31 Dec 2019 23:59:59 GMT")); 
     }
 
     Y_UNIT_TEST(TestX509ValidityTimeIncorrect) {
         bool ret;
         time_t t = 0;
-        ret = ParseX509ValidityDateTime("500101000000Z", t);
+        ret = ParseX509ValidityDateTime("500101000000Z", t); 
         UNIT_ASSERT(!ret);
-        ret = ParseX509ValidityDateTime("091014165533+0300", t);
+        ret = ParseX509ValidityDateTime("091014165533+0300", t); 
         UNIT_ASSERT(!ret);
     }
 
     Y_UNIT_TEST(TestTInstantTryParse) {
         {
             const TStringBuf s = "2009-09-19 03:37:08.1+04:00";
-            const auto i = TInstant::ParseIso8601(s);
+            const auto i = TInstant::ParseIso8601(s); 
             TInstant iTry;
-            UNIT_ASSERT(TInstant::TryParseIso8601(s, iTry));
+            UNIT_ASSERT(TInstant::TryParseIso8601(s, iTry)); 
             UNIT_ASSERT_VALUES_EQUAL(i, iTry);
         }
         {
             const TStringBuf s = "2009-09aslkdjfkljasdjfl4:00";
             TInstant iTry;
-            UNIT_ASSERT_EXCEPTION(TInstant::ParseIso8601(s), TDateTimeParseException);
-            UNIT_ASSERT(!TInstant::TryParseIso8601(s, iTry));
+            UNIT_ASSERT_EXCEPTION(TInstant::ParseIso8601(s), TDateTimeParseException); 
+            UNIT_ASSERT(!TInstant::TryParseIso8601(s, iTry)); 
         }
         {
             const TStringBuf s = "Wed, 14 Oct 2009 16:55:33 GMT";
-            const auto i = TInstant::ParseRfc822(s);
+            const auto i = TInstant::ParseRfc822(s); 
             TInstant iTry;
-            UNIT_ASSERT(TInstant::TryParseRfc822(s, iTry));
+            UNIT_ASSERT(TInstant::TryParseRfc822(s, iTry)); 
             UNIT_ASSERT_VALUES_EQUAL(i, iTry);
         }
         {
             const TStringBuf s = "Wed, alsdjflkasjdfl:55:33 GMT";
             TInstant iTry;
-            UNIT_ASSERT_EXCEPTION(TInstant::ParseRfc822(s), TDateTimeParseException);
-            UNIT_ASSERT(!TInstant::TryParseRfc822(s, iTry));
+            UNIT_ASSERT_EXCEPTION(TInstant::ParseRfc822(s), TDateTimeParseException); 
+            UNIT_ASSERT(!TInstant::TryParseRfc822(s, iTry)); 
         }
         {
             const TStringBuf s = "20091014165533Z";
-            const auto i = TInstant::ParseX509Validity(s);
+            const auto i = TInstant::ParseX509Validity(s); 
             TInstant iTry;
-            UNIT_ASSERT(TInstant::TryParseX509(s, iTry));
+            UNIT_ASSERT(TInstant::TryParseX509(s, iTry)); 
             UNIT_ASSERT_VALUES_EQUAL(i, iTry);
         }
         {
             const TStringBuf s = "200asdfasdf533Z";
             TInstant iTry;
-            UNIT_ASSERT_EXCEPTION(TInstant::ParseX509Validity(s), TDateTimeParseException);
-            UNIT_ASSERT(!TInstant::TryParseX509(s, iTry));
+            UNIT_ASSERT_EXCEPTION(TInstant::ParseX509Validity(s), TDateTimeParseException); 
+            UNIT_ASSERT(!TInstant::TryParseX509(s, iTry)); 
         }
         {
             const TStringBuf s = "990104074212Z";
-            const auto i = TInstant::ParseX509Validity(s);
+            const auto i = TInstant::ParseX509Validity(s); 
             TInstant iTry;
-            UNIT_ASSERT(TInstant::TryParseX509(s, iTry));
+            UNIT_ASSERT(TInstant::TryParseX509(s, iTry)); 
             UNIT_ASSERT_VALUES_EQUAL(i, iTry);
         }
         {
             const TStringBuf s = "9901asdf4212Z";
             TInstant iTry;
-            UNIT_ASSERT_EXCEPTION(TInstant::ParseX509Validity(s), TDateTimeParseException);
-            UNIT_ASSERT(!TInstant::TryParseX509(s, iTry));
+            UNIT_ASSERT_EXCEPTION(TInstant::ParseX509Validity(s), TDateTimeParseException); 
+            UNIT_ASSERT(!TInstant::TryParseX509(s, iTry)); 
         }
     }
 }
diff --git a/util/datetime/ut/ya.make b/util/datetime/ut/ya.make
index c2bc714059..64fac0cb5d 100644
--- a/util/datetime/ut/ya.make
+++ b/util/datetime/ut/ya.make
@@ -5,7 +5,7 @@ SUBSCRIBER(g:util-subscribers)
 
 SRCS(
     datetime/base_ut.cpp
-    datetime/parser_deprecated_ut.cpp
+    datetime/parser_deprecated_ut.cpp 
     datetime/parser_ut.cpp
     datetime/uptime_ut.cpp
 )