Use the UnitTest instead of GTest

7 files changed, 267 insertions, 200 deletions

diff --git a/ydb/core/kafka_proxy/ut/CMakeLists.darwin-x86_64.txt b/ydb/core/kafka_proxy/ut/CMakeLists.darwin-x86_64.txt
index b20b2c0a03..27753bb665 100644
--- a/ydb/core/kafka_proxy/ut/CMakeLists.darwin-x86_64.txt
+++ b/ydb/core/kafka_proxy/ut/CMakeLists.darwin-x86_64.txt
@@ -8,12 +8,14 @@
 
 
 add_executable(ydb-core-kafka_proxy-ut)
+target_include_directories(ydb-core-kafka_proxy-ut PRIVATE
+  ${CMAKE_SOURCE_DIR}/ydb/core/kafka_proxy
+)
 target_link_libraries(ydb-core-kafka_proxy-ut PUBLIC
   contrib-libs-cxxsupp
   yutil
   library-cpp-cpuid_check
-  cpp-testing-gtest
-  cpp-testing-gtest_main
+  cpp-testing-unittest_main
   ydb-core-kafka_proxy
 )
 target_link_options(ydb-core-kafka_proxy-ut PRIVATE
@@ -27,20 +29,33 @@ target_sources(ydb-core-kafka_proxy-ut PRIVATE
   ${CMAKE_SOURCE_DIR}/ydb/core/kafka_proxy/ut/ut_kafka_functions.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/kafka_proxy/ut/ut_serialization.cpp
 )
-add_test(
+set_property(
+  TARGET
+  ydb-core-kafka_proxy-ut
+  PROPERTY
+  SPLIT_FACTOR
+  1
+)
+add_yunittest(
   NAME
   ydb-core-kafka_proxy-ut
-  COMMAND
+  TEST_TARGET
   ydb-core-kafka_proxy-ut
+  TEST_ARG
+  --print-before-suite
+  --print-before-test
+  --fork-tests
+  --print-times
+  --show-fails
 )
-set_property(
+set_yunittest_property(
   TEST
   ydb-core-kafka_proxy-ut
   PROPERTY
   LABELS
   SMALL
 )
-set_property(
+set_yunittest_property(
   TEST
   ydb-core-kafka_proxy-ut
   PROPERTY
diff --git a/ydb/core/kafka_proxy/ut/CMakeLists.linux-aarch64.txt b/ydb/core/kafka_proxy/ut/CMakeLists.linux-aarch64.txt
index 38872fb558..2211b83d4d 100644
--- a/ydb/core/kafka_proxy/ut/CMakeLists.linux-aarch64.txt
+++ b/ydb/core/kafka_proxy/ut/CMakeLists.linux-aarch64.txt
@@ -8,12 +8,14 @@
 
 
 add_executable(ydb-core-kafka_proxy-ut)
+target_include_directories(ydb-core-kafka_proxy-ut PRIVATE
+  ${CMAKE_SOURCE_DIR}/ydb/core/kafka_proxy
+)
 target_link_libraries(ydb-core-kafka_proxy-ut PUBLIC
   contrib-libs-linux-headers
   contrib-libs-cxxsupp
   yutil
-  cpp-testing-gtest
-  cpp-testing-gtest_main
+  cpp-testing-unittest_main
   ydb-core-kafka_proxy
 )
 target_link_options(ydb-core-kafka_proxy-ut PRIVATE
@@ -30,20 +32,33 @@ target_sources(ydb-core-kafka_proxy-ut PRIVATE
   ${CMAKE_SOURCE_DIR}/ydb/core/kafka_proxy/ut/ut_kafka_functions.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/kafka_proxy/ut/ut_serialization.cpp
 )
-add_test(
+set_property(
+  TARGET
+  ydb-core-kafka_proxy-ut
+  PROPERTY
+  SPLIT_FACTOR
+  1
+)
+add_yunittest(
   NAME
   ydb-core-kafka_proxy-ut
-  COMMAND
+  TEST_TARGET
   ydb-core-kafka_proxy-ut
+  TEST_ARG
+  --print-before-suite
+  --print-before-test
+  --fork-tests
+  --print-times
+  --show-fails
 )
-set_property(
+set_yunittest_property(
   TEST
   ydb-core-kafka_proxy-ut
   PROPERTY
   LABELS
   SMALL
 )
-set_property(
+set_yunittest_property(
   TEST
   ydb-core-kafka_proxy-ut
   PROPERTY
diff --git a/ydb/core/kafka_proxy/ut/CMakeLists.linux-x86_64.txt b/ydb/core/kafka_proxy/ut/CMakeLists.linux-x86_64.txt
index a75ef634f8..564249b298 100644
--- a/ydb/core/kafka_proxy/ut/CMakeLists.linux-x86_64.txt
+++ b/ydb/core/kafka_proxy/ut/CMakeLists.linux-x86_64.txt
@@ -8,13 +8,15 @@
 
 
 add_executable(ydb-core-kafka_proxy-ut)
+target_include_directories(ydb-core-kafka_proxy-ut PRIVATE
+  ${CMAKE_SOURCE_DIR}/ydb/core/kafka_proxy
+)
 target_link_libraries(ydb-core-kafka_proxy-ut PUBLIC
   contrib-libs-linux-headers
   contrib-libs-cxxsupp
   yutil
   library-cpp-cpuid_check
-  cpp-testing-gtest
-  cpp-testing-gtest_main
+  cpp-testing-unittest_main
   ydb-core-kafka_proxy
 )
 target_link_options(ydb-core-kafka_proxy-ut PRIVATE
@@ -31,20 +33,33 @@ target_sources(ydb-core-kafka_proxy-ut PRIVATE
   ${CMAKE_SOURCE_DIR}/ydb/core/kafka_proxy/ut/ut_kafka_functions.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/kafka_proxy/ut/ut_serialization.cpp
 )
-add_test(
+set_property(
+  TARGET
+  ydb-core-kafka_proxy-ut
+  PROPERTY
+  SPLIT_FACTOR
+  1
+)
+add_yunittest(
   NAME
   ydb-core-kafka_proxy-ut
-  COMMAND
+  TEST_TARGET
   ydb-core-kafka_proxy-ut
+  TEST_ARG
+  --print-before-suite
+  --print-before-test
+  --fork-tests
+  --print-times
+  --show-fails
 )
-set_property(
+set_yunittest_property(
   TEST
   ydb-core-kafka_proxy-ut
   PROPERTY
   LABELS
   SMALL
 )
-set_property(
+set_yunittest_property(
   TEST
   ydb-core-kafka_proxy-ut
   PROPERTY
diff --git a/ydb/core/kafka_proxy/ut/CMakeLists.windows-x86_64.txt b/ydb/core/kafka_proxy/ut/CMakeLists.windows-x86_64.txt
index 5bb08d1134..4f256a5faf 100644
--- a/ydb/core/kafka_proxy/ut/CMakeLists.windows-x86_64.txt
+++ b/ydb/core/kafka_proxy/ut/CMakeLists.windows-x86_64.txt
@@ -8,32 +8,47 @@
 
 
 add_executable(ydb-core-kafka_proxy-ut)
+target_include_directories(ydb-core-kafka_proxy-ut PRIVATE
+  ${CMAKE_SOURCE_DIR}/ydb/core/kafka_proxy
+)
 target_link_libraries(ydb-core-kafka_proxy-ut PUBLIC
   contrib-libs-cxxsupp
   yutil
   library-cpp-cpuid_check
-  cpp-testing-gtest
-  cpp-testing-gtest_main
+  cpp-testing-unittest_main
   ydb-core-kafka_proxy
 )
 target_sources(ydb-core-kafka_proxy-ut PRIVATE
   ${CMAKE_SOURCE_DIR}/ydb/core/kafka_proxy/ut/ut_kafka_functions.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/kafka_proxy/ut/ut_serialization.cpp
 )
-add_test(
+set_property(
+  TARGET
+  ydb-core-kafka_proxy-ut
+  PROPERTY
+  SPLIT_FACTOR
+  1
+)
+add_yunittest(
   NAME
   ydb-core-kafka_proxy-ut
-  COMMAND
+  TEST_TARGET
   ydb-core-kafka_proxy-ut
+  TEST_ARG
+  --print-before-suite
+  --print-before-test
+  --fork-tests
+  --print-times
+  --show-fails
 )
-set_property(
+set_yunittest_property(
   TEST
   ydb-core-kafka_proxy-ut
   PROPERTY
   LABELS
   SMALL
 )
-set_property(
+set_yunittest_property(
   TEST
   ydb-core-kafka_proxy-ut
   PROPERTY
diff --git a/ydb/core/kafka_proxy/ut/ut_kafka_functions.cpp b/ydb/core/kafka_proxy/ut/ut_kafka_functions.cpp
index c66ba20a03..6dbe39200f 100644
--- a/ydb/core/kafka_proxy/ut/ut_kafka_functions.cpp
+++ b/ydb/core/kafka_proxy/ut/ut_kafka_functions.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/testing/gtest/gtest.h>
+#include <library/cpp/testing/unittest/registar.h>
 
 #include <strstream>
 
@@ -14,16 +14,20 @@ const std::vector<i16> apiKeys {
      INIT_PRODUCER_ID
 };
 
-TEST(Functions, CreateRequest) {
+Y_UNIT_TEST_SUITE(Functions) {
+
+Y_UNIT_TEST(CreateRequest) {
     for(i16 apiKey : apiKeys) {
         auto result = CreateRequest(apiKey);
-        EXPECT_EQ(result->ApiKey(), apiKey);
+        UNIT_ASSERT_EQUAL(result->ApiKey(), apiKey);
     }
 }
 
-TEST(Functions, CreateResponse) {
+Y_UNIT_TEST(CreateResponse) {
     for(i16 apiKey : apiKeys) {
         auto result = CreateResponse(apiKey);
-        EXPECT_EQ(result->ApiKey(), apiKey);
+        UNIT_ASSERT_EQUAL(result->ApiKey(), apiKey);
     }
 }
+
+}
diff --git a/ydb/core/kafka_proxy/ut/ut_serialization.cpp b/ydb/core/kafka_proxy/ut/ut_serialization.cpp
index b23c713831..5d492d5740 100644
--- a/ydb/core/kafka_proxy/ut/ut_serialization.cpp
+++ b/ydb/core/kafka_proxy/ut/ut_serialization.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/testing/gtest/gtest.h>
+#include <library/cpp/testing/unittest/registar.h>
 
 #include <strstream>
 
@@ -10,8 +10,9 @@ void Print(std::string& sb);
 
 static constexpr size_t BUFFER_SIZE = 1 << 16;
 
+Y_UNIT_TEST_SUITE(Serialization) {
 
-TEST(Serialization, RequestHeader) {
+Y_UNIT_TEST(RequestHeader) {
     TWritableBuf sb(nullptr, BUFFER_SIZE);
 
     TRequestHeaderData value;
@@ -28,13 +29,13 @@ TEST(Serialization, RequestHeader) {
     TKafkaReadable readable(sb.GetBuffer());
     result.Read(readable, 1);
 
-    EXPECT_EQ(result.RequestApiKey, 3);
-    EXPECT_EQ(result.RequestApiVersion, 7);
-    EXPECT_EQ(result.CorrelationId, 11);
-    EXPECT_EQ(*result.ClientId, "clientId-value");
+    UNIT_ASSERT_EQUAL(result.RequestApiKey, 3);
+    UNIT_ASSERT_EQUAL(result.RequestApiVersion, 7);
+    UNIT_ASSERT_EQUAL(result.CorrelationId, 11);
+    UNIT_ASSERT_EQUAL(*result.ClientId, "clientId-value");
 }
 
-TEST(Serialization, ResponseHeader) {
+Y_UNIT_TEST(ResponseHeader) {
     TWritableBuf sb(nullptr, BUFFER_SIZE);
 
     TResponseHeaderData value;
@@ -48,10 +49,10 @@ TEST(Serialization, ResponseHeader) {
     TResponseHeaderData result;
     result.Read(readable, 0);
 
-    EXPECT_EQ(result.CorrelationId, 13);
+    UNIT_ASSERT_EQUAL(result.CorrelationId, 13);
 }
 
-TEST(Serialization, ApiVersionsRequest) {
+Y_UNIT_TEST(ApiVersionsRequest) {
     TWritableBuf sb(nullptr, BUFFER_SIZE);
 
     TApiVersionsRequestData value;
@@ -66,11 +67,11 @@ TEST(Serialization, ApiVersionsRequest) {
     TApiVersionsRequestData result;
     result.Read(readable, 3);
 
-    EXPECT_EQ(*result.ClientSoftwareName, "apache-kafka-java");
-    EXPECT_EQ(*result.ClientSoftwareVersion, "3.4.0");
+    UNIT_ASSERT_EQUAL(*result.ClientSoftwareName, "apache-kafka-java");
+    UNIT_ASSERT_EQUAL(*result.ClientSoftwareVersion, "3.4.0");
 }
 
-TEST(Serialization, ApiVersionsResponse) {
+Y_UNIT_TEST(ApiVersionsResponse) {
     TString longString = "long-string-value-0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"; 
 
     TWritableBuf sb(nullptr, BUFFER_SIZE);
@@ -114,24 +115,24 @@ TEST(Serialization, ApiVersionsResponse) {
     TApiVersionsResponseData result;
     result.Read(readable, 3);
 
-    EXPECT_EQ(result.ErrorCode, 7);
-    EXPECT_EQ(result.ApiKeys.size(), 2ul);
-    EXPECT_EQ(result.ApiKeys[0].ApiKey, 11);
-    EXPECT_EQ(result.ApiKeys[0].MinVersion, 13);
-    EXPECT_EQ(result.ApiKeys[0].MaxVersion, 17);
-    EXPECT_EQ(result.ApiKeys[1].ApiKey, 33);
-    EXPECT_EQ(result.ApiKeys[1].MinVersion, 37);
-    EXPECT_EQ(result.ApiKeys[1].MaxVersion, 41);
-    EXPECT_EQ(result.FinalizedFeatures.size(), 1ul);
-    EXPECT_EQ(*result.FinalizedFeatures[0].Name, longString);
-    EXPECT_EQ(result.FinalizedFeatures[0].MaxVersionLevel, 19);
-    EXPECT_EQ(result.FinalizedFeatures[0].MinVersionLevel, 23);
-    EXPECT_EQ(result.FinalizedFeaturesEpoch, 29l);
-    EXPECT_EQ(result.ThrottleTimeMs, 31);
-    EXPECT_EQ(result.ZkMigrationReady, true);
+    UNIT_ASSERT_EQUAL(result.ErrorCode, 7);
+    UNIT_ASSERT_EQUAL(result.ApiKeys.size(), 2ul);
+    UNIT_ASSERT_EQUAL(result.ApiKeys[0].ApiKey, 11);
+    UNIT_ASSERT_EQUAL(result.ApiKeys[0].MinVersion, 13);
+    UNIT_ASSERT_EQUAL(result.ApiKeys[0].MaxVersion, 17);
+    UNIT_ASSERT_EQUAL(result.ApiKeys[1].ApiKey, 33);
+    UNIT_ASSERT_EQUAL(result.ApiKeys[1].MinVersion, 37);
+    UNIT_ASSERT_EQUAL(result.ApiKeys[1].MaxVersion, 41);
+    UNIT_ASSERT_EQUAL(result.FinalizedFeatures.size(), 1ul);
+    UNIT_ASSERT_EQUAL(*result.FinalizedFeatures[0].Name, longString);
+    UNIT_ASSERT_EQUAL(result.FinalizedFeatures[0].MaxVersionLevel, 19);
+    UNIT_ASSERT_EQUAL(result.FinalizedFeatures[0].MinVersionLevel, 23);
+    UNIT_ASSERT_EQUAL(result.FinalizedFeaturesEpoch, 29l);
+    UNIT_ASSERT_EQUAL(result.ThrottleTimeMs, 31);
+    UNIT_ASSERT_EQUAL(result.ZkMigrationReady, true);
 }
 
-TEST(Serialization, ProduceRequest) {
+Y_UNIT_TEST(ProduceRequest) {
     TWritableBuf sb(nullptr, BUFFER_SIZE);
 
     TProduceRequestData value;
@@ -156,26 +157,26 @@ TEST(Serialization, ProduceRequest) {
     TProduceRequestData result;
     result.Read(readable, 3);
 
-    EXPECT_TRUE(result.TransactionalId);
-    EXPECT_EQ(*result.TransactionalId, "transactional-id-value-123456" );
-    EXPECT_EQ(result.Acks, 3);
-    EXPECT_EQ(result.TimeoutMs, 5);
-    EXPECT_EQ(result.TopicData.size(), 2ul);
-    EXPECT_TRUE(result.TopicData[0].Name);
-    EXPECT_EQ(*result.TopicData[0].Name, "/it/is/some/topic/name");
-    EXPECT_EQ(result.TopicData[0].PartitionData.size(), 2ul);
-    EXPECT_EQ(result.TopicData[0].PartitionData[0].Index, 0);
-    EXPECT_EQ(result.TopicData[0].PartitionData[0].Records, std::nullopt);
-    EXPECT_EQ(result.TopicData[0].PartitionData[1].Index, 1);
-    EXPECT_EQ(result.TopicData[0].PartitionData[1].Records, std::nullopt);
-    EXPECT_TRUE(result.TopicData[1].Name);
-    EXPECT_EQ(*result.TopicData[1].Name, "/it/is/other/topic/name");
-    EXPECT_EQ(result.TopicData[1].PartitionData.size(), 1ul);
-    EXPECT_EQ(result.TopicData[1].PartitionData[0].Index, 0);
-    EXPECT_EQ(result.TopicData[1].PartitionData[0].Records, std::nullopt);
+    UNIT_ASSERT(result.TransactionalId);
+    UNIT_ASSERT_EQUAL(*result.TransactionalId, "transactional-id-value-123456" );
+    UNIT_ASSERT_EQUAL(result.Acks, 3);
+    UNIT_ASSERT_EQUAL(result.TimeoutMs, 5);
+    UNIT_ASSERT_EQUAL(result.TopicData.size(), 2ul);
+    UNIT_ASSERT(result.TopicData[0].Name);
+    UNIT_ASSERT_EQUAL(*result.TopicData[0].Name, "/it/is/some/topic/name");
+    UNIT_ASSERT_EQUAL(result.TopicData[0].PartitionData.size(), 2ul);
+    UNIT_ASSERT_EQUAL(result.TopicData[0].PartitionData[0].Index, 0);
+    UNIT_ASSERT_EQUAL(result.TopicData[0].PartitionData[0].Records, std::nullopt);
+    UNIT_ASSERT_EQUAL(result.TopicData[0].PartitionData[1].Index, 1);
+    UNIT_ASSERT_EQUAL(result.TopicData[0].PartitionData[1].Records, std::nullopt);
+    UNIT_ASSERT(result.TopicData[1].Name);
+    UNIT_ASSERT_EQUAL(*result.TopicData[1].Name, "/it/is/other/topic/name");
+    UNIT_ASSERT_EQUAL(result.TopicData[1].PartitionData.size(), 1ul);
+    UNIT_ASSERT_EQUAL(result.TopicData[1].PartitionData[0].Index, 0);
+    UNIT_ASSERT_EQUAL(result.TopicData[1].PartitionData[0].Records, std::nullopt);
 }
 
-TEST(Serialization, UnsignedVarint) {
+Y_UNIT_TEST(UnsignedVarint) {
     std::vector<ui32> values = {0, 1, 127, 128, 32191};
 
     for(ui32 v : values) {
@@ -185,7 +186,7 @@ TEST(Serialization, UnsignedVarint) {
 
         writable.writeUnsignedVarint(v);
         ui32 r = readable.readUnsignedVarint();
-        EXPECT_EQ(r, v);
+        UNIT_ASSERT_EQUAL(r, v);
     }
 }
 
@@ -193,9 +194,9 @@ TEST(Serialization, UnsignedVarint) {
     Meta_##Type_::Type value = Value;               \
     Meta_##Type_::Type result;                      \
                                                     \
-    TWritableBuf sb(nullptr, BUFFER_SIZE);                                \
+    TWritableBuf sb(nullptr, BUFFER_SIZE);          \
     TKafkaWritable writable(sb);                    \
-    TKafkaReadable readable(sb.GetBuffer());                    \
+    TKafkaReadable readable(sb.GetBuffer());        \
                                                     \
     Y_UNUSED(readable);                             \
     Y_UNUSED(result);                               \
@@ -221,50 +222,50 @@ struct Meta_TKafkaInt8 {
 
 const Meta_TKafkaInt8::Type Meta_TKafkaInt8::Default = 7;
 
-TEST(Serialization, TKafkaInt8_NotPresentVersion) {
+Y_UNIT_TEST(TKafkaInt8_NotPresentVersion) {
     SIMPLE_HEAD(TKafkaInt8, 37);
 
     NKafka::NPrivate::Write<Meta_TKafkaInt8>(collector, writable, 0, value);
-    EXPECT_EQ(sb.Size(), (size_t)0); // For version 0 value is not serializable. Stream must be empty
-    EXPECT_EQ(collector.NumTaggedFields, 0u);
+    UNIT_ASSERT_EQUAL(sb.Size(), (size_t)0); // For version 0 value is not serializable. Stream must be empty
+    UNIT_ASSERT_EQUAL(collector.NumTaggedFields, 0u);
 
     NKafka::NPrivate::Read<Meta_TKafkaInt8>(readable, 0, result);
-    EXPECT_EQ(result, Meta_TKafkaInt8::Default); // For version 0 value is not serializable
+    UNIT_ASSERT_EQUAL(result, Meta_TKafkaInt8::Default); // For version 0 value is not serializable
 }
 
-TEST(Serialization, TKafkaInt8_PresentVersion_NotTaggedVersion) {
+Y_UNIT_TEST(TKafkaInt8_PresentVersion_NotTaggedVersion) {
     SIMPLE_HEAD(TKafkaInt8, 37);
 
     NKafka::NPrivate::Write<Meta_TKafkaInt8>(collector, writable, 3, value);
     NKafka::NPrivate::Read<Meta_TKafkaInt8>(readable, 3, result);
 
-    EXPECT_EQ(collector.NumTaggedFields, 0u);
-    EXPECT_EQ(result, value); // Must read same that write
+    UNIT_ASSERT_EQUAL(collector.NumTaggedFields, 0u);
+    UNIT_ASSERT_EQUAL(result, value); // Must read same that write
 }
 
-TEST(Serialization, TKafkaInt8_PresentVersion_TaggedVersion) {
+Y_UNIT_TEST(TKafkaInt8_PresentVersion_TaggedVersion) {
     SIMPLE_HEAD(TKafkaInt8, 37);
 
     NKafka::NPrivate::Write<Meta_TKafkaInt8>(collector, writable, 11, value);
-    EXPECT_EQ(collector.NumTaggedFields, 1u);
+    UNIT_ASSERT_EQUAL(collector.NumTaggedFields, 1u);
 
     NKafka::NPrivate::WriteTag<Meta_TKafkaInt8>(writable, 11, value);
 
     i32 tag = readable.readUnsignedVarint();
-    EXPECT_EQ(tag, Meta_TKafkaInt8::Tag);
+    UNIT_ASSERT_EQUAL(tag, Meta_TKafkaInt8::Tag);
 
     ui32 size = readable.readUnsignedVarint();
-    EXPECT_EQ(size, sizeof(TKafkaInt8));
+    UNIT_ASSERT_EQUAL(size, sizeof(TKafkaInt8));
 
     NKafka::NPrivate::ReadTag<Meta_TKafkaInt8>(readable, 11, result);
-    EXPECT_EQ(result, value); // Must read same that write
+    UNIT_ASSERT_EQUAL(result, value); // Must read same that write
 }
 
-TEST(Serialization, TKafkaInt8_PresentVersion_TaggedVersion_Default) {
+Y_UNIT_TEST(TKafkaInt8_PresentVersion_TaggedVersion_Default) {
     SIMPLE_HEAD(TKafkaInt8, Meta_TKafkaInt8::Default);
 
     NKafka::NPrivate::Write<Meta_TKafkaInt8>(collector, writable, 11, value);
-    EXPECT_EQ(collector.NumTaggedFields, 0u); // not serialize default value for tagged version
+    UNIT_ASSERT_EQUAL(collector.NumTaggedFields, 0u); // not serialize default value for tagged version
 }
 
 struct Meta_TKafkaStruct {
@@ -282,12 +283,12 @@ struct Meta_TKafkaStruct {
     static constexpr TKafkaVersions FlexibleVersions{7, Max<TKafkaVersion>()};
 };
 
-TEST(Serialization, Struct_IsDefault) {
+Y_UNIT_TEST(Struct_IsDefault) {
     TRequestHeaderData value;
-    EXPECT_TRUE(NKafka::NPrivate::IsDefaultValue<Meta_TKafkaStruct>(value)); // all fields have default values
+    UNIT_ASSERT(NKafka::NPrivate::IsDefaultValue<Meta_TKafkaStruct>(value)); // all fields have default values
 
     value.RequestApiKey = 123;
-    EXPECT_FALSE(NKafka::NPrivate::IsDefaultValue<Meta_TKafkaStruct>(value)); // field changed
+    UNIT_ASSERT(!NKafka::NPrivate::IsDefaultValue<Meta_TKafkaStruct>(value)); // field changed
 }
 
 struct Meta_TKafkaString {
@@ -307,50 +308,50 @@ struct Meta_TKafkaString {
 
 const Meta_TKafkaString::Type Meta_TKafkaString::Default = "default_value";
 
-TEST(Serialization, TKafkaString_IsDefault) {
+Y_UNIT_TEST(TKafkaString_IsDefault) {
     TKafkaString value;
-    EXPECT_FALSE(NKafka::NPrivate::IsDefaultValue<Meta_TKafkaString>(value)); // std::nullopt != "default_value"
+    UNIT_ASSERT(!NKafka::NPrivate::IsDefaultValue<Meta_TKafkaString>(value)); // std::nullopt != "default_value"
 
     value = "random_string";
-    EXPECT_FALSE(NKafka::NPrivate::IsDefaultValue<Meta_TKafkaString>(value)); // "random_string" != "default_value"
+    UNIT_ASSERT(!NKafka::NPrivate::IsDefaultValue<Meta_TKafkaString>(value)); // "random_string" != "default_value"
 
     value = "default_value";
-    EXPECT_TRUE(NKafka::NPrivate::IsDefaultValue<Meta_TKafkaString>(value));
+    UNIT_ASSERT(NKafka::NPrivate::IsDefaultValue<Meta_TKafkaString>(value));
 }
 
-TEST(Serialization, TKafkaString_PresentVersion_NotTaggedVersion) {
+Y_UNIT_TEST(TKafkaString_PresentVersion_NotTaggedVersion) {
     SIMPLE_HEAD(TKafkaString, { "some value" });
 
     NKafka::NPrivate::Write<Meta_TKafkaString>(collector, writable, 3, value);
     NKafka::NPrivate::Read<Meta_TKafkaString>(readable, 3, result);
 
-    EXPECT_EQ(collector.NumTaggedFields, 0u);
-    EXPECT_EQ(result, value); // Must read same that write
+    UNIT_ASSERT_EQUAL(collector.NumTaggedFields, 0u);
+    UNIT_ASSERT_EQUAL(result, value); // Must read same that write
 }
 
-TEST(Serialization, TKafkaString_PresentVersion_TaggedVersion) {
+Y_UNIT_TEST(TKafkaString_PresentVersion_TaggedVersion) {
     SIMPLE_HEAD(TKafkaString, { "some value" });
 
     NKafka::NPrivate::Write<Meta_TKafkaString>(collector, writable, 11, value);
-    EXPECT_EQ(collector.NumTaggedFields, 1u);
+    UNIT_ASSERT_EQUAL(collector.NumTaggedFields, 1u);
 
     NKafka::NPrivate::WriteTag<Meta_TKafkaString>(writable, 11, value);
 
     i32 tag = readable.readUnsignedVarint();
-    EXPECT_EQ(tag, Meta_TKafkaString::Tag);
+    UNIT_ASSERT_EQUAL(tag, Meta_TKafkaString::Tag);
 
     ui32 size = readable.readUnsignedVarint();
-    EXPECT_EQ(size, value->size() + NKafka::NPrivate::SizeOfUnsignedVarint(value->size() + 1)); // "+1" because serialized as unsigned int, and null serialized with size equals 0
+    UNIT_ASSERT_EQUAL(size, value->size() + NKafka::NPrivate::SizeOfUnsignedVarint(value->size() + 1)); // "+1" because serialized as unsigned int, and null serialized with size equals 0
 
     NKafka::NPrivate::ReadTag<Meta_TKafkaString>(readable, 11, result);
-    EXPECT_EQ(result, value); // Must read same that write
+    UNIT_ASSERT_EQUAL(result, value); // Must read same that write
 }
 
-TEST(Serialization, TKafkaString_PresentVersion_TaggedVersion_Default) {
+Y_UNIT_TEST(TKafkaString_PresentVersion_TaggedVersion_Default) {
     SIMPLE_HEAD(TKafkaInt8, Meta_TKafkaInt8::Default);
 
     NKafka::NPrivate::Write<Meta_TKafkaInt8>(collector, writable, 11, value);
-    EXPECT_EQ(collector.NumTaggedFields, 0u); // not serialize default value for tagged version
+    UNIT_ASSERT_EQUAL(collector.NumTaggedFields, 0u); // not serialize default value for tagged version
 }
 
 
@@ -370,51 +371,51 @@ struct Meta_TKafkaArray {
     static constexpr TKafkaVersions FlexibleVersions{7, Max<TKafkaVersion>()};
 };
 
-TEST(Serialization, TKafkaArray_IsDefault) {
+Y_UNIT_TEST(TKafkaArray_IsDefault) {
     Meta_TKafkaArray::Type value;
-    EXPECT_TRUE(NKafka::NPrivate::IsDefaultValue<Meta_TKafkaArray>(value)); // array is empty
+    UNIT_ASSERT(NKafka::NPrivate::IsDefaultValue<Meta_TKafkaArray>(value)); // array is empty
 
     value.push_back("random_string");
-    EXPECT_FALSE(NKafka::NPrivate::IsDefaultValue<Meta_TKafkaArray>(value)); // array contains elements
+    UNIT_ASSERT(!NKafka::NPrivate::IsDefaultValue<Meta_TKafkaArray>(value)); // array contains elements
 }
 
-TEST(Serialization, TKafkaArray_PresentVersion_NotTaggedVersion) {
+Y_UNIT_TEST(TKafkaArray_PresentVersion_NotTaggedVersion) {
     SIMPLE_HEAD(TKafkaArray, { "some value" });
 
     NKafka::NPrivate::Write<Meta_TKafkaArray>(collector, writable, 3, value);
     NKafka::NPrivate::Read<Meta_TKafkaArray>(readable, 3, result);
 
-    EXPECT_EQ(collector.NumTaggedFields, 0u);
-    EXPECT_EQ(result, value); // Must read same that write
+    UNIT_ASSERT_EQUAL(collector.NumTaggedFields, 0u);
+    UNIT_ASSERT_EQUAL(result, value); // Must read same that write
 }
 
-TEST(Serialization, TKafkaArray_PresentVersion_TaggedVersion) {
+Y_UNIT_TEST(TKafkaArray_PresentVersion_TaggedVersion) {
     TString v = "some value";
     SIMPLE_HEAD(TKafkaArray, { v });
 
     NKafka::NPrivate::Write<Meta_TKafkaArray>(collector, writable, 11, value);
-    EXPECT_EQ(collector.NumTaggedFields, 1u);
+    UNIT_ASSERT_EQUAL(collector.NumTaggedFields, 1u);
 
     NKafka::NPrivate::WriteTag<Meta_TKafkaArray>(writable, 11, value);
 
     i32 tag = readable.readUnsignedVarint();
-    EXPECT_EQ(tag, Meta_TKafkaArray::Tag);
+    UNIT_ASSERT_EQUAL(tag, Meta_TKafkaArray::Tag);
 
     ui32 size = readable.readUnsignedVarint();
-    EXPECT_EQ(size, v.length() // array element data
+    UNIT_ASSERT_EQUAL(size, v.length() // array element data
         + NKafka::NPrivate::SizeOfUnsignedVarint(value.size()) // array size
         + NKafka::NPrivate::SizeOfUnsignedVarint(v.length() + 1) // string size. +1 because null string serialize as 0-length
     );
 
     NKafka::NPrivate::ReadTag<Meta_TKafkaArray>(readable, 11, result);
-    EXPECT_EQ(result, value); // Must read same that write
+    UNIT_ASSERT_EQUAL(result, value); // Must read same that write
 }
 
-TEST(Serialization, TKafkaArray_PresentVersion_TaggedVersion_Default) {
+Y_UNIT_TEST(TKafkaArray_PresentVersion_TaggedVersion_Default) {
     SIMPLE_HEAD(TKafkaArray, {});
 
     NKafka::NPrivate::Write<Meta_TKafkaArray>(collector, writable, 11, value);
-    EXPECT_EQ(collector.NumTaggedFields, 0u); // not serialize default value for tagged version
+    UNIT_ASSERT_EQUAL(collector.NumTaggedFields, 0u); // not serialize default value for tagged version
 }
 
 
@@ -433,58 +434,58 @@ struct Meta_TKafkaBytes {
     static constexpr TKafkaVersions FlexibleVersions{7, Max<TKafkaVersion>()};
 };
 
-TEST(Serialization, TKafkaBytes_IsDefault) {
+Y_UNIT_TEST(TKafkaBytes_IsDefault) {
     Meta_TKafkaBytes::Type value;
-    EXPECT_TRUE(NKafka::NPrivate::IsDefaultValue<Meta_TKafkaBytes>(value)); // value is std::nullopt
+    UNIT_ASSERT(NKafka::NPrivate::IsDefaultValue<Meta_TKafkaBytes>(value)); // value is std::nullopt
 
     char v[] = "value";
     value = TArrayRef<char>(v);
-    EXPECT_FALSE(NKafka::NPrivate::IsDefaultValue<Meta_TKafkaBytes>(value)); // value is not null
+    UNIT_ASSERT(!NKafka::NPrivate::IsDefaultValue<Meta_TKafkaBytes>(value)); // value is not null
 }
 
-TEST(Serialization, TKafkaBytes_PresentVersion_NotTaggedVersion) {
+Y_UNIT_TEST(TKafkaBytes_PresentVersion_NotTaggedVersion) {
     char v[] = "0123456789";
     SIMPLE_HEAD(TKafkaBytes, TArrayRef(v));
 
     NKafka::NPrivate::Write<Meta_TKafkaBytes>(collector, writable, 3, value);
     NKafka::NPrivate::Read<Meta_TKafkaBytes>(readable, 3, result);
 
-    EXPECT_EQ(collector.NumTaggedFields, 0u);
-    EXPECT_EQ(result->size(), value->size());
-    EXPECT_STREQ(result->begin(), value->begin()); // Must read same that write
+    UNIT_ASSERT_EQUAL(collector.NumTaggedFields, 0u);
+    UNIT_ASSERT_EQUAL(result->size(), value->size());
+    UNIT_ASSERT_EQUAL(TString(result->begin(), result->size()), TString(value->begin(), value->size())); // Must read same that write
 }
 
-TEST(Serialization, TKafkaBytes_PresentVersion_TaggedVersion) {
+Y_UNIT_TEST(TKafkaBytes_PresentVersion_TaggedVersion) {
     char v[] = "0123456789";
     SIMPLE_HEAD(TKafkaBytes, TArrayRef(v));
 
     NKafka::NPrivate::Write<Meta_TKafkaBytes>(collector, writable, 11, value);
-    EXPECT_EQ(collector.NumTaggedFields, 1u);
+    UNIT_ASSERT_EQUAL(collector.NumTaggedFields, 1u);
 
     NKafka::NPrivate::WriteTag<Meta_TKafkaBytes>(writable, 11, value);
 
     i32 tag = readable.readUnsignedVarint();
-    EXPECT_EQ(tag, Meta_TKafkaArray::Tag);
+    UNIT_ASSERT_EQUAL(tag, Meta_TKafkaArray::Tag);
 
     ui32 size = readable.readUnsignedVarint();
-    EXPECT_EQ(size, value->size() // byffer data
+    UNIT_ASSERT_EQUAL(size, value->size() // byffer data
         + NKafka::NPrivate::SizeOfUnsignedVarint(value->size() + 1) // buffer size. +1 because null value stored as size 0
     );
 
     NKafka::NPrivate::ReadTag<Meta_TKafkaBytes>(readable, 11, result);
-    EXPECT_EQ(result->size(), value->size());
-    EXPECT_STREQ(result->begin(), value->begin()); // Must read same that write
+    UNIT_ASSERT_EQUAL(result->size(), value->size());
+    UNIT_ASSERT_EQUAL(TString(result->begin(), result->size()), TString(value->begin(), value->size())); // Must read same that write
 }
 
-TEST(Serialization, TKafkaBytes_PresentVersion_TaggedVersion_Default) {
+Y_UNIT_TEST(TKafkaBytes_PresentVersion_TaggedVersion_Default) {
     SIMPLE_HEAD(TKafkaBytes, std::nullopt);
 
     NKafka::NPrivate::Write<Meta_TKafkaBytes>(collector, writable, 11, value);
-    EXPECT_EQ(collector.NumTaggedFields, 0u); // not serialize default value for tagged version
+    UNIT_ASSERT_EQUAL(collector.NumTaggedFields, 0u); // not serialize default value for tagged version
 }
 
 
-TEST(Serialization, TRequestHeaderData_reference) {
+Y_UNIT_TEST(TRequestHeaderData_reference) {
     // original kafka serialized value (java implementation)
     ui8 reference[] = {0x00, 0x03, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x10, 0x63, 0x6C, 0x69, 0x65, 0x6E, 0x74,
                        0x2D, 0x69, 0x64, 0x2D, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x00};
@@ -501,19 +502,19 @@ TEST(Serialization, TRequestHeaderData_reference) {
 
     value.Write(writable, 2);
 
-    EXPECT_EQ(sb.Size(), sizeof(reference));
+    UNIT_ASSERT_EQUAL(sb.Size(), sizeof(reference));
     for(size_t i = 0; i < sizeof(reference); ++i) {
-        EXPECT_EQ(*(sb.Data() + i), reference[i]);
+        UNIT_ASSERT_EQUAL(*(sb.Data() + i), reference[i]);
     }
 
 
     TRequestHeaderData result;
     result.Read(readable, 2);
 
-    EXPECT_EQ(result.RequestApiKey, 3);
-    EXPECT_EQ(result.RequestApiVersion, 7);
-    EXPECT_EQ(result.CorrelationId, 13);
-    EXPECT_EQ(result.ClientId, "client-id-string");
+    UNIT_ASSERT_EQUAL(result.RequestApiKey, 3);
+    UNIT_ASSERT_EQUAL(result.RequestApiVersion, 7);
+    UNIT_ASSERT_EQUAL(result.CorrelationId, 13);
+    UNIT_ASSERT_EQUAL(result.ClientId, "client-id-string");
 }
 
 struct Meta_TKafkaFloat64 {
@@ -533,7 +534,7 @@ struct Meta_TKafkaFloat64 {
 
 const Meta_TKafkaFloat64::Type Meta_TKafkaFloat64::Default = 7.875;
 
-TEST(Serialization, TKafkaFloat64_PresentVersion_NotTaggedVersion) {
+Y_UNIT_TEST(TKafkaFloat64_PresentVersion_NotTaggedVersion) {
     // original kafka serialized value (java implementation)
     ui8 reference[] = {0x40, 0x09, 0x21, 0xCA, 0xC0, 0x83, 0x12, 0x6F};
 
@@ -542,16 +543,16 @@ TEST(Serialization, TKafkaFloat64_PresentVersion_NotTaggedVersion) {
     NKafka::NPrivate::Write<Meta_TKafkaFloat64>(collector, writable, 3, value);
     NKafka::NPrivate::Read<Meta_TKafkaFloat64>(readable, 3, result);
 
-    EXPECT_EQ(collector.NumTaggedFields, 0u);
-    EXPECT_EQ(result, value); // Must read same that write
+    UNIT_ASSERT_EQUAL(collector.NumTaggedFields, 0u);
+    UNIT_ASSERT_EQUAL(result, value); // Must read same that write
 
-    EXPECT_EQ(sb.Size(), sizeof(reference));
+    UNIT_ASSERT_EQUAL(sb.Size(), sizeof(reference));
     for(size_t i = 0; i < sizeof(reference); ++i) {
-        EXPECT_EQ(*(sb.Data() + i), (char)reference[i]);
+        UNIT_ASSERT_EQUAL(*(sb.Data() + i), (char)reference[i]);
     }
 }
 
-TEST(Serialization, RequestHeader_reference) {
+Y_UNIT_TEST(RequestHeader_reference) {
     ui8 reference[] = {0x00, 0x12, 0x00, 0x00, 0x7F, 0x6F, 0x6F, 0x68, 0x00, 0x0A, 0x70, 0x72, 0x6F, 0x64, 0x75, 0x63, 
                      0x65, 0x72, 0x2D, 0x31};
 
@@ -562,12 +563,12 @@ TEST(Serialization, RequestHeader_reference) {
     TRequestHeaderData result;
     result.Read(readable, 1);
 
-    EXPECT_EQ(result.RequestApiKey, 0x12);
-    EXPECT_EQ(result.RequestApiVersion, 0x00);
-    EXPECT_EQ(result.ClientId, "producer-1");
+    UNIT_ASSERT_EQUAL(result.RequestApiKey, 0x12);
+    UNIT_ASSERT_EQUAL(result.RequestApiVersion, 0x00);
+    UNIT_ASSERT_EQUAL(result.ClientId, "producer-1");
 }
 
-TEST(Serialization, ProduceRequestData) {
+Y_UNIT_TEST(ProduceRequestData) {
     ui8 reference[] = {0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x04, 0x00, 0x0A, 0x70, 0x72, 0x6F, 0x64, 0x75, 0x63,
                        0x65, 0x72, 0x2D, 0x31, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x75, 0x30, 0x02, 0x08, 0x74, 0x6F,
                        0x70, 0x69, 0x63, 0x2D, 0x31, 0x02, 0x00, 0x00, 0x00, 0x00, 0xCD, 0x01, 0x00, 0x00, 0x00, 0x00,
@@ -596,54 +597,54 @@ TEST(Serialization, ProduceRequestData) {
     TProduceRequestData result;
     result.Read(readable, 9);
 
-    EXPECT_EQ(result.Acks, -1);
-    EXPECT_EQ(result.TimeoutMs, 30000);
+    UNIT_ASSERT_EQUAL(result.Acks, -1);
+    UNIT_ASSERT_EQUAL(result.TimeoutMs, 30000);
 
     auto& r0 = *result.TopicData[0].PartitionData[0].Records;
-    EXPECT_EQ(r0.BaseOffset, 0);
-    EXPECT_EQ(r0.BatchLength, 192);
-    EXPECT_EQ(r0.PartitionLeaderEpoch, -1);
-    EXPECT_EQ(r0.Magic, 2);
-    EXPECT_EQ(r0.Crc, 920453412);
-    EXPECT_EQ(r0.Attributes, 0);
-    EXPECT_EQ(r0.LastOffsetDelta, 2);
-    EXPECT_EQ(r0.BaseTimestamp, 1688133283621);
-    EXPECT_EQ(r0.MaxTimestamp, 1688133284377);
-    EXPECT_EQ(r0.ProducerId, 1);
-    EXPECT_EQ(r0.ProducerEpoch, 1);
-    EXPECT_EQ(r0.BaseSequence, 0);
-
-    EXPECT_EQ(r0.Records.size(), (size_t)3);
+    UNIT_ASSERT_EQUAL(r0.BaseOffset, 0);
+    UNIT_ASSERT_EQUAL(r0.BatchLength, 192);
+    UNIT_ASSERT_EQUAL(r0.PartitionLeaderEpoch, -1);
+    UNIT_ASSERT_EQUAL(r0.Magic, 2);
+    UNIT_ASSERT_EQUAL(r0.Crc, 920453412);
+    UNIT_ASSERT_EQUAL(r0.Attributes, 0);
+    UNIT_ASSERT_EQUAL(r0.LastOffsetDelta, 2);
+    UNIT_ASSERT_EQUAL(r0.BaseTimestamp, 1688133283621);
+    UNIT_ASSERT_EQUAL(r0.MaxTimestamp, 1688133284377);
+    UNIT_ASSERT_EQUAL(r0.ProducerId, 1);
+    UNIT_ASSERT_EQUAL(r0.ProducerEpoch, 1);
+    UNIT_ASSERT_EQUAL(r0.BaseSequence, 0);
+
+    UNIT_ASSERT_EQUAL(r0.Records.size(), (size_t)3);
     
-    EXPECT_EQ(r0.Records[0].Key, TKafkaRawBytes("key", 3));
-    EXPECT_EQ(r0.Records[0].Value, TKafkaRawBytes("msg-1-1", 7));
-    EXPECT_EQ(r0.Records[0].Headers.size(), (size_t)3);
-    EXPECT_EQ(r0.Records[0].Headers[0].Key, TKafkaRawBytes("h-1", 3));
-    EXPECT_EQ(r0.Records[0].Headers[0].Value, TKafkaRawBytes("v-1-1", 5));
-    EXPECT_EQ(r0.Records[0].Headers[1].Key, TKafkaRawBytes("h-2", 3));
-    EXPECT_EQ(r0.Records[0].Headers[1].Value, TKafkaRawBytes("v-2-1", 5));
-    EXPECT_EQ(r0.Records[0].Headers[2].Key, TKafkaRawBytes("h-3", 3));
-    EXPECT_EQ(r0.Records[0].Headers[2].Value, TKafkaRawBytes("v-3-1", 5));
+    UNIT_ASSERT_EQUAL(r0.Records[0].Key, TKafkaRawBytes("key", 3));
+    UNIT_ASSERT_EQUAL(r0.Records[0].Value, TKafkaRawBytes("msg-1-1", 7));
+    UNIT_ASSERT_EQUAL(r0.Records[0].Headers.size(), (size_t)3);
+    UNIT_ASSERT_EQUAL(r0.Records[0].Headers[0].Key, TKafkaRawBytes("h-1", 3));
+    UNIT_ASSERT_EQUAL(r0.Records[0].Headers[0].Value, TKafkaRawBytes("v-1-1", 5));
+    UNIT_ASSERT_EQUAL(r0.Records[0].Headers[1].Key, TKafkaRawBytes("h-2", 3));
+    UNIT_ASSERT_EQUAL(r0.Records[0].Headers[1].Value, TKafkaRawBytes("v-2-1", 5));
+    UNIT_ASSERT_EQUAL(r0.Records[0].Headers[2].Key, TKafkaRawBytes("h-3", 3));
+    UNIT_ASSERT_EQUAL(r0.Records[0].Headers[2].Value, TKafkaRawBytes("v-3-1", 5));
     
-    EXPECT_EQ(r0.Records[1].Key, TKafkaRawBytes("key", 3));
-    EXPECT_EQ(r0.Records[1].Value, TKafkaRawBytes("msg-1-2", 7));
-    EXPECT_EQ(r0.Records[1].Headers.size(), (size_t)3);
-    EXPECT_EQ(r0.Records[1].Headers[0].Key, TKafkaRawBytes("h-1", 3));
-    EXPECT_EQ(r0.Records[1].Headers[0].Value, TKafkaRawBytes("v-1-2", 5));
-    EXPECT_EQ(r0.Records[1].Headers[1].Key, TKafkaRawBytes("h-2", 3));
-    EXPECT_EQ(r0.Records[1].Headers[1].Value, TKafkaRawBytes("v-2-2", 5));
-    EXPECT_EQ(r0.Records[1].Headers[2].Key, TKafkaRawBytes("h-3", 3));
-    EXPECT_EQ(r0.Records[1].Headers[2].Value, TKafkaRawBytes("v-3-2", 5));
+    UNIT_ASSERT_EQUAL(r0.Records[1].Key, TKafkaRawBytes("key", 3));
+    UNIT_ASSERT_EQUAL(r0.Records[1].Value, TKafkaRawBytes("msg-1-2", 7));
+    UNIT_ASSERT_EQUAL(r0.Records[1].Headers.size(), (size_t)3);
+    UNIT_ASSERT_EQUAL(r0.Records[1].Headers[0].Key, TKafkaRawBytes("h-1", 3));
+    UNIT_ASSERT_EQUAL(r0.Records[1].Headers[0].Value, TKafkaRawBytes("v-1-2", 5));
+    UNIT_ASSERT_EQUAL(r0.Records[1].Headers[1].Key, TKafkaRawBytes("h-2", 3));
+    UNIT_ASSERT_EQUAL(r0.Records[1].Headers[1].Value, TKafkaRawBytes("v-2-2", 5));
+    UNIT_ASSERT_EQUAL(r0.Records[1].Headers[2].Key, TKafkaRawBytes("h-3", 3));
+    UNIT_ASSERT_EQUAL(r0.Records[1].Headers[2].Value, TKafkaRawBytes("v-3-2", 5));
     
-    EXPECT_EQ(r0.Records[2].Key, TKafkaRawBytes("key", 3));
-    EXPECT_EQ(r0.Records[2].Value, TKafkaRawBytes("msg-1-3", 7));
-    EXPECT_EQ(r0.Records[2].Headers.size(), (size_t)3);
-    EXPECT_EQ(r0.Records[2].Headers[0].Key, TKafkaRawBytes("h-1", 3));
-    EXPECT_EQ(r0.Records[2].Headers[0].Value, TKafkaRawBytes("v-1-3", 5));
-    EXPECT_EQ(r0.Records[2].Headers[1].Key, TKafkaRawBytes("h-2", 3));
-    EXPECT_EQ(r0.Records[2].Headers[1].Value, TKafkaRawBytes("v-2-3", 5));
-    EXPECT_EQ(r0.Records[2].Headers[2].Key, TKafkaRawBytes("h-3", 3));
-    EXPECT_EQ(r0.Records[2].Headers[2].Value, TKafkaRawBytes("v-3-3", 5));
+    UNIT_ASSERT_EQUAL(r0.Records[2].Key, TKafkaRawBytes("key", 3));
+    UNIT_ASSERT_EQUAL(r0.Records[2].Value, TKafkaRawBytes("msg-1-3", 7));
+    UNIT_ASSERT_EQUAL(r0.Records[2].Headers.size(), (size_t)3);
+    UNIT_ASSERT_EQUAL(r0.Records[2].Headers[0].Key, TKafkaRawBytes("h-1", 3));
+    UNIT_ASSERT_EQUAL(r0.Records[2].Headers[0].Value, TKafkaRawBytes("v-1-3", 5));
+    UNIT_ASSERT_EQUAL(r0.Records[2].Headers[1].Key, TKafkaRawBytes("h-2", 3));
+    UNIT_ASSERT_EQUAL(r0.Records[2].Headers[1].Value, TKafkaRawBytes("v-2-3", 5));
+    UNIT_ASSERT_EQUAL(r0.Records[2].Headers[2].Key, TKafkaRawBytes("h-3", 3));
+    UNIT_ASSERT_EQUAL(r0.Records[2].Headers[2].Value, TKafkaRawBytes("v-3-3", 5));
 
     TWritableBuf sb(nullptr, sizeof(reference));
     TKafkaWritable writable(sb);
@@ -651,9 +652,9 @@ TEST(Serialization, ProduceRequestData) {
     header.Write(writable, 2);
     result.Write(writable, 9);
 
-    EXPECT_EQ(sb.Size(), sizeof(reference));
+    UNIT_ASSERT_EQUAL(sb.Size(), sizeof(reference));
     for(size_t i = 0; i < sizeof(reference); ++i) {
-        EXPECT_EQ(*(sb.Data() + i), (char)reference[i]);
+        UNIT_ASSERT_EQUAL(*(sb.Data() + i), (char)reference[i]);
     }
 }
 
@@ -671,3 +672,5 @@ void Print(std::string& sb) {
     }
     Cerr << Endl;
 }
+
+}
diff --git a/ydb/core/kafka_proxy/ut/ya.make b/ydb/core/kafka_proxy/ut/ya.make
index 4626bbd0dc..cf7a7cf6db 100644
--- a/ydb/core/kafka_proxy/ut/ya.make
+++ b/ydb/core/kafka_proxy/ut/ya.make
@@ -1,4 +1,4 @@
-GTEST()
+UNITTEST_FOR(ydb/core/kafka_proxy)
 
 SRCS(
     ut_kafka_functions.cpp