revert rXXXXXX (see discusstion in pr), will commit again more pci-dss friendly way

1 files changed, 20 insertions, 59 deletions

diff --git a/library/cpp/threading/equeue/equeue_ut.cpp b/library/cpp/threading/equeue/equeue_ut.cpp
index 2c7d2c7b1e..8557f63ac0 100644
--- a/library/cpp/threading/equeue/equeue_ut.cpp
+++ b/library/cpp/threading/equeue/equeue_ut.cpp
@@ -1,5 +1,4 @@
 #include "equeue.h"
-#include "fast.h"
 
 #include <library/cpp/testing/unittest/registar.h>
 
@@ -10,33 +9,18 @@
 Y_UNIT_TEST_SUITE(TElasticQueueTest) {
     const size_t MaxQueueSize = 20;
     const size_t ThreadCount = 10;
+    const size_t N = 100000;
 
-    template <typename T>
-    THolder<T> MakeQueue();
-
-    template <>
-    THolder<TElasticQueue> MakeQueue() {
-        return MakeHolder<TElasticQueue>(MakeHolder<TSimpleThreadPool>());
-    }
-
-    template <>
-    THolder<TFastElasticQueue> MakeQueue() {
-        return MakeHolder<TFastElasticQueue>();
-    }
-
-    template <typename T>
-    struct TEnv {
-        static inline THolder<T> Queue;
+    static THolder<TElasticQueue> Queue;
 
-        struct TQueueSetup {
-            TQueueSetup() {
-                Queue.Reset(MakeQueue<T>());
-                Queue->Start(ThreadCount, MaxQueueSize);
-            }
-            ~TQueueSetup() {
-                Queue->Stop();
-            }
-        };
+    struct TQueueSetup {
+        TQueueSetup() {
+            Queue.Reset(new TElasticQueue(MakeHolder<TSimpleThreadPool>()));
+            Queue->Start(ThreadCount, MaxQueueSize);
+        }
+        ~TQueueSetup() {
+            Queue->Stop();
+        }
     };
 
     struct TCounters {
@@ -53,9 +37,7 @@ Y_UNIT_TEST_SUITE(TElasticQueueTest) {
 
 //fill test -- fill queue with "endless" jobs
     TSystemEvent WaitEvent;
-
-    template <typename T>
-    void FillTest() {
+    Y_UNIT_TEST(FillTest) {
         Counters.Reset();
 
         struct TWaitJob: public IObjectInQueue {
@@ -65,10 +47,7 @@ Y_UNIT_TEST_SUITE(TElasticQueueTest) {
             }
         } job;
 
-        struct TLocalSetup: TEnv<T>::TQueueSetup {
-            TLocalSetup() {
-                WaitEvent.Reset();
-            }
+        struct TLocalSetup: TQueueSetup {
             ~TLocalSetup() {
                 WaitEvent.Signal();
             }
@@ -77,26 +56,19 @@ Y_UNIT_TEST_SUITE(TElasticQueueTest) {
         size_t enqueued = 0;
         {
             TLocalSetup setup;
-            while (TEnv<T>::Queue->Add(&job) && enqueued < MaxQueueSize + 100) {
+            while (Queue->Add(&job) && enqueued < MaxQueueSize + 100) {
                 ++enqueued;
             }
 
             UNIT_ASSERT_VALUES_EQUAL(enqueued, MaxQueueSize);
-            UNIT_ASSERT_VALUES_EQUAL(enqueued, TEnv<T>::Queue->ObjectCount());
+            UNIT_ASSERT_VALUES_EQUAL(enqueued, Queue->ObjectCount());
         }
 
-        UNIT_ASSERT_VALUES_EQUAL(0u, TEnv<T>::Queue->ObjectCount());
-        UNIT_ASSERT_VALUES_EQUAL(0u, TEnv<T>::Queue->Size());
+        UNIT_ASSERT_VALUES_EQUAL(0u, Queue->ObjectCount());
+        UNIT_ASSERT_VALUES_EQUAL(0u, Queue->Size());
         UNIT_ASSERT_VALUES_EQUAL((size_t)Counters.Processed, enqueued);
     }
 
-    Y_UNIT_TEST(FillTest) {
-        FillTest<TElasticQueue>();
-    }
-
-    Y_UNIT_TEST(FillTestFast) {
-        FillTest<TFastElasticQueue>();
-    }
 
 //concurrent test -- send many jobs from different threads
     struct TJob: public IObjectInQueue {
@@ -106,10 +78,9 @@ Y_UNIT_TEST_SUITE(TElasticQueueTest) {
     };
     static TJob Job;
 
-    template <typename T>
     static bool TryAdd() {
         AtomicIncrement(Counters.Total);
-        if (TEnv<T>::Queue->Add(&Job)) {
+        if (Queue->Add(&Job)) {
             AtomicIncrement(Counters.Scheduled);
             return true;
         } else {
@@ -118,18 +89,16 @@ Y_UNIT_TEST_SUITE(TElasticQueueTest) {
         }
     }
 
-    const size_t N = 100000;
     static size_t TryCounter;
 
-    template <typename T>
-    void ConcurrentTest() {
+    Y_UNIT_TEST(ConcurrentTest) {
         Counters.Reset();
         TryCounter = 0;
 
         struct TSender: public IThreadFactory::IThreadAble {
             void DoExecute() override {
                 while ((size_t)AtomicIncrement(TryCounter) <= N) {
-                    if (!TryAdd<T>()) {
+                    if (!TryAdd()) {
                         Sleep(TDuration::MicroSeconds(50));
                     }
                 }
@@ -137,7 +106,7 @@ Y_UNIT_TEST_SUITE(TElasticQueueTest) {
         } sender;
 
         {
-            typename TEnv<T>::TQueueSetup setup;
+            TQueueSetup setup;
 
             TVector< TAutoPtr<IThreadFactory::IThread> > senders;
             for (size_t i = 0; i < ThreadCount; ++i) {
@@ -153,12 +122,4 @@ Y_UNIT_TEST_SUITE(TElasticQueueTest) {
         UNIT_ASSERT_VALUES_EQUAL(Counters.Processed, Counters.Scheduled);
         UNIT_ASSERT_VALUES_EQUAL(Counters.Total, Counters.Scheduled + Counters.Discarded);
     }
-
-    Y_UNIT_TEST(ConcurrentTest) {
-        ConcurrentTest<TElasticQueue>();
-    }
-
-    Y_UNIT_TEST(ConcurrentTestFast) {
-        ConcurrentTest<TFastElasticQueue>();
-    }
 }