Speed tests were rewritten as benchmarks (instead of unit tests). Submodule…

Speed tests were rewritten as benchmarks (instead of unit tests). Submodule google benchmark was added.

.gitmodules

-[submodule "gmock"]
-	path = gmock
-	url = https://github.com/mgoral/googlemock
+[submodule "benchmark"]
+	path = benchmark
+	url = https://github.com/google/benchmark.git

benchmark @ be84ed03

+Subproject commit be84ed037323d5d7fe1a4d22975b615b9414f93f

boolinq/Makefile.benchmark

+OPTIMIZATION       ?= O0
+
+CXX                 = g++
+INCLUDES            = -I. -I../benchmark/include
+CXXFLAGS            = -c \
+                      -MD \
+                      -std=c++11 -march=native -mtune=native \
+                      -Wall -Wextra \
+                      -$(OPTIMIZATION)
+LDPATH              = -L../benchmark/lib
+LDADD               = -lbenchmark -lpthread -lgtest -lgtest_main
+SRC                 = SpeedTest.cpp
+
+OBJ                 = $(SRC:.cpp=.o)
+BENCHMARK           = boolinqbenchmakr
+
+TMP_DATA            = $(shell find . -type f -name '*~')
+
+
+all: $(BENCHMARK)
+
+
+$(BENCHMARK): $(OBJ)
+	$(CXX) $(OBJ) $(LDPATH) $(LDADD) -o $@
+
+
+.cpp.o:
+	$(CXX) $(CXXFLAGS) $(INCLUDES) $< -o $@
+
+
+clean:
+	rm -rf $(OBJ) $(BENCHMARK) $(TMP_DATA) $(COV_DATA) $(PRO_DATA)

boolinq/Makefile → boolinq/Makefile.test

@@ -41,7 +41,6 @@ SRC                 = AllTest.cpp \
                       SelectRangeTest.cpp \
                       SkipRangeTest.cpp \
                       SkipWhileRangeTest.cpp \
-                      SpeedTest.cpp \
                       SumTest.cpp \
                       TakeRangeTest.cpp \
                       TakeWhileRangeTest.cpp \

boolinq/SpeedTest.cpp

+#include <benchmark/benchmark.h>
 #include <gtest/gtest.h>
 
-#include <iostream>
-
+#include <stdlib.h>
 #include "boolinq.h"
 
+
 using namespace boolinq;
 
-std::vector<int> vec(1000000, 0);
-   
-TEST(SpeedTest1, Init)
+
+constexpr std::size_t benchmarkVectorSize {1000000};
+std::vector<int> vecBoolinq (benchmarkVectorSize, 0);
+std::vector<int> vecCpp     (benchmarkVectorSize, 0);
+std::vector<int> vecCppIter (benchmarkVectorSize, 0);
+
+
+
+int main (int argc, const char ** argv)
 {
+    // Preparing input benchmark data (the same data sets for all tests).
     srand(0xDEADBEEF);
-    for (unsigned i = 0; i < vec.size(); i++)
-        vec[i] = rand();
+    for (unsigned i = 0; i < benchmarkVectorSize; i++) {
+        const auto x = rand();
+        vecBoolinq[i] = x;
+        vecCpp[i]     = x;
+        vecCppIter[i] = x;
+    }
+
+    // Launch benchmark.
+    benchmark::Initialize (&argc, argv);
+    benchmark::RunSpecifiedBenchmarks ();
+
+    return EXIT_SUCCESS;
 }
 
-TEST(SpeedTest1, BoolinqCode)
-{
-    double avgValue = from(vec).where( [](int a){return a%2 == 1;})
-                               .avg<double>();
 
-    double disper = from(vec).where(  [](int a){return a%2 == 1;})
-                             .select([=](int a){return (double)((a-avgValue)*(a-avgValue));})
-                             .avg<double>();
 
-    EXPECT_EQ(164004, (int)(avgValue*10));
-    EXPECT_EQ(89512454, (int)disper);
+static void BM_BoolinqCode (benchmark::State& state)
+{
+    while (state.KeepRunning () ) {
+        double avgValue = from(vecBoolinq).where( [](int a){return a%2 == 1;})
+                                   .avg<double>();
+
+        double disper = from(vecBoolinq).where(  [](int a){return a%2 == 1;})
+                                 .select([=](int a){return (double)((a-avgValue)*(a-avgValue));})
+                                 .avg<double>();
+        // It's no test, instead it's avoiding skip of calculation throgh optimization.
+        state.PauseTiming ();
+        EXPECT_TRUE(avgValue);
+        EXPECT_TRUE(disper);
+        state.ResumeTiming ();
+    }
 }
+BENCHMARK(BM_BoolinqCode);
+
 
-TEST(SpeedTest1, CppCode)
+
+static void BM_CppCode (benchmark::State& state)
 {
-    double sum = 0;
-    int count = 0;
-    for (unsigned i = 0; i < vec.size(); i++)
-    {
-        if (vec[i] % 2 == 1)
+    while (state.KeepRunning () ) {
+        double sum = 0;
+        int count = 0;
+        for (unsigned i = 0; i < vecCpp.size(); i++)
         {
-            sum += vec[i];
-            count++;
+            if (vecCpp[i] % 2 == 1)
+            {
+                sum += vecCpp[i];
+                count++;
+            }
         }
+        double avgValue = sum / count;
+
+        double disperSum = 0;
+        for (unsigned i = 0; i < vecCpp.size(); i++)
+            if (vecCpp[i] % 2 == 1)
+                disperSum += (vecCpp[i] - avgValue)*(vecCpp[i] - avgValue);
+        double disper = disperSum / count;
+
+        // It's no test, instead it's avoiding skip of calculation throgh optimization.
+        state.PauseTiming ();
+        EXPECT_TRUE(avgValue);
+        EXPECT_TRUE(disper);
+        state.ResumeTiming ();
     }
-    double avgValue = sum / count;
-
-    double disperSum = 0;
-    for (unsigned i = 0; i < vec.size(); i++)
-        if (vec[i] % 2 == 1)
-            disperSum += (vec[i] - avgValue)*(vec[i] - avgValue);
-    double disper = disperSum / count;
-    
-    EXPECT_EQ(164004, (int)(avgValue*10));
-    EXPECT_EQ(89512454, (int)disper);
 }
+BENCHMARK(BM_CppCode);
+
+
 
-TEST(SpeedTest1, CppIterCode)
+static void BM_CppIterCode (benchmark::State& state)
 {
-    double sum = 0;
-    int count = 0;
-    for (auto it = vec.begin(); it != vec.end(); ++it)
-    {
-        if (*it % 2 == 1)
+    while (state.KeepRunning () ) {
+        double sum = 0;
+        int count = 0;
+        for (auto it = vecCppIter.begin(); it != vecCppIter.end(); ++it)
         {
-            sum += *it;
-            count++;
+            if (*it % 2 == 1)
+            {
+                sum += *it;
+                count++;
+            }
         }
-    }
-    double avgValue = sum / count;
+        double avgValue = sum / count;
 
-    double disperSum = 0;
-    for (auto it = vec.begin(); it != vec.end(); ++it)
-        if (*it % 2 == 1)
-            disperSum += (*it - avgValue)*(*it - avgValue);
-    double disper = disperSum / count;
+        double disperSum = 0;
+        for (auto it = vecCppIter.begin(); it != vecCppIter.end(); ++it)
+            if (*it % 2 == 1)
+                disperSum += (*it - avgValue)*(*it - avgValue);
+        double disper = disperSum / count;
 
-    EXPECT_EQ(164004, (int)(avgValue*10));
-    EXPECT_EQ(89512454, (int)disper);
+        // It's no test, instead it's avoiding skip of calculation throgh optimization.
+        state.PauseTiming ();
+        EXPECT_TRUE(avgValue);
+        EXPECT_TRUE(disper);
+        state.ResumeTiming ();
+    }
 }
+BENCHMARK(BM_CppIterCode);