removed release builds

jkalias · jkalias · commit b2a87b92c14d · 2021-08-28T22:05:57.000+02:00
diff --git a/.github/workflows/cmake.yml b/.github/workflows/cmake.yml
@@ -21,7 +21,7 @@ jobs:
       matrix:
         config: 
         - {
-            name: "Windows Latest MSVC (Debug)",
+            name: "Windows Latest MSVC",
             os: windows-latest,
             build_type: "Debug",
             cc: "cl",
@@ -30,46 +30,21 @@ jobs:
             generators: "Visual Studio 16 2019"
           }
         - {
-            name: "Windows Latest MSVC (Release)",
-            os: windows-latest,
-            build_type: "Release",
-            cc: "cl",
-            cxx: "cl",
-            environment_script: "C:/Program Files (x86)/Microsoft Visual Studio/2019/Enterprise/VC/Auxiliary/Build/vcvars64.bat",
-            generators: "Visual Studio 16 2019"
-          }
-        - {
-            name: "Ubuntu Latest GCC (Debug)",
+            name: "Ubuntu Latest GCC",
             os: ubuntu-latest,
             build_type: "Debug",
             cc: "gcc",
             cxx: "g++",
             generators: "Ninja"
           }
         - {
-            name: "Ubuntu Latest GCC (Release)",
-            os: ubuntu-latest,
-            build_type: "Release",
-            cc: "gcc",
-            cxx: "g++",
-            generators: "Ninja"
-          }
-        - {
-            name: "macOS Latest Clang (Debug)",
+            name: "macOS Latest Clang",
             os: macos-latest,
             build_type: "Debug",
             cc: "clang",
             cxx: "clang++",
             generators: "Xcode"
           }
-        - {
-            name: "macOS Latest Clang (Release)",
-            os: macos-latest,
-            build_type: "Release",
-            cc: "clang",
-            cxx: "clang++",
-            generators: "Xcode"
-          }
 
     steps:
       # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
diff --git a/include/functional_vector.h b/include/functional_vector.h
@@ -515,7 +515,7 @@ class functional_vector
     
     // Returns the last index in which the given element is found in the vector.
     // In case of multiple occurrences, only the last index is returned
-    // (see find_all_indices for multiple occurences).
+    // (see find_all_indices for multiple occurrences).
     //
     // example:
     //      const functional_vector numbers({1, 4, 2, 5, -6, 3, 1, 7, 1});
@@ -1115,7 +1115,7 @@ class functional_vector
         return *this;
     }
     
-    // Returns the size of the vector (how many elements it contains)
+    // Returns the size of the vector (how many elements it contains, it may be different from its capacity)
     size_t size() const
     {
         return backing_vector_.size();
diff --git a/tests/functional_vector_test.cc b/tests/functional_vector_test.cc
@@ -256,7 +256,6 @@ TEST(FunctionalVectorTest, ReversedTest)
     EXPECT_EQ(9, vector_under_test[2].age);
 }
 
-#ifndef NDEBUG
 TEST(FunctionalVectorTest, ZipWithStdVectorUnequalSizesThrowsTest)
 {
     const functional_vector ages_vector({32, 25, 53, 62});
@@ -269,7 +268,6 @@ TEST(FunctionalVectorTest, ZipWithFunctionalVectorUnequalSizesThrowsTest)
     const auto names_vector = functional_vector<std::string>({"Jake", "Mary"});
     EXPECT_DEATH({ const auto zipped_vector = ages_vector.zip(names_vector); }, "");
 }
-#endif
 
 TEST(FunctionalVectorTest, ZipWithFunctionalVectorTest)
 {
@@ -430,7 +428,6 @@ TEST(FunctionalVectorTest, SortedDescendingTest)
     EXPECT_EQ(-4, sorted_vector[3]);
 }
 
-#ifndef NDEBUG
 TEST(FunctionalVectorTest, SubscriptOperatorNegativeDeathTest)
 {
     const functional_vector vector_under_test({3, 1, 9, -4});
@@ -466,7 +463,6 @@ TEST(FunctionalVectorTest, SubscriptOperatorAssignIndexLargerThanSizeDeathTest)
     functional_vector vector_under_test({3, 1, 9, -4});
     EXPECT_DEATH(vector_under_test[5] = -3, "");
 }
-#endif
 
 TEST(FunctionalVectorTest, SubscriptOperatorAssignTest)
 {
@@ -540,7 +536,6 @@ TEST(FunctionalVectorTest, FindAllIndicesFilledVectorTest)
     EXPECT_EQ(std::vector<size_t>({ 7 }), seven_indices);
 }
 
-#ifndef NDEBUG
 TEST(FunctionalVectorTest, RemoveAtEmptyVectorTest)
 {
     functional_vector<int> vector_under_test;
@@ -554,7 +549,6 @@ TEST(FunctionalVectorTest, RemoveAtFilledVectorAboveSizeTest)
     auto vector_under_test = functional_vector({1, 4, 2, 5, 8, 3, 1, 7, 1});
     EXPECT_DEATH(vector_under_test.remove_at(15), "");
 }
-#endif
 
 TEST(FunctionalVectorTest, RemoveAtFilledVectorTest)
 {
@@ -567,7 +561,6 @@ TEST(FunctionalVectorTest, RemoveAtFilledVectorTest)
     EXPECT_EQ(functional_vector<int>({ 1, 5, 8, 3, 7, 1 }), vector_under_test);
 }
 
-#ifndef NDEBUG
 TEST(FunctionalVectorTest, RemovingAtEmptyVectorTest)
 {
     const functional_vector<int> vector_under_test;
@@ -581,7 +574,6 @@ TEST(FunctionalVectorTest, RemovingAtFilledVectorAboveSizeTest)
     const functional_vector vector_under_test({1, 4, 2, 5, 8, 3, 1, 7, 1});
     EXPECT_DEATH(vector_under_test.removing_at(15), "");
 }
-#endif
 
 TEST(FunctionalVectorTest, RemovingAtFilledVectorTest)
 {
@@ -633,9 +625,7 @@ TEST(FunctionalVectorTest, RemovingFrontTest)
 TEST(FunctionalVectorTest, InsertAtEmptyVectorTest)
 {
     functional_vector<int> vector_under_test;
-#ifndef NDEBUG
     EXPECT_DEATH(vector_under_test.insert_at(15, -1), "");
-#endif
     vector_under_test.insert_at(0, -1);
     EXPECT_EQ(1, vector_under_test.size());
     EXPECT_EQ(-1, vector_under_test[0]);
@@ -644,19 +634,15 @@ TEST(FunctionalVectorTest, InsertAtEmptyVectorTest)
 TEST(FunctionalVectorTest, InsertAtFilledVectorTest)
 {
     functional_vector<int> vector_under_test({1, 4, 2, 5, 8, 3, 1, 7, 1});
-#ifndef NDEBUG
     EXPECT_DEATH(vector_under_test.insert_at(15, -1), "");
-#endif
     vector_under_test.insert_at(3, 18);
     EXPECT_EQ(functional_vector<int>({ 1, 4, 2, 18, 5, 8, 3, 1, 7, 1 }), vector_under_test);
 }
 
 TEST(FunctionalVectorTest, InsertingAtEmptyVectorTest)
 {
     const functional_vector<int> vector_under_test;
-#ifndef NDEBUG
     EXPECT_DEATH(vector_under_test.inserting_at(15, -1), "");
-#endif
     const auto augmented_vector = vector_under_test.inserting_at(0, -1);
     EXPECT_EQ(1, augmented_vector.size());
     EXPECT_EQ(-1, augmented_vector[0]);
@@ -666,9 +652,7 @@ TEST(FunctionalVectorTest, InsertingAtEmptyVectorTest)
 TEST(FunctionalVectorTest, InsertingAtFilledVectorTest)
 {
     const functional_vector<int> vector_under_test({1, 4, 2, 5, 8, 3, 1, 7, 1});
-#ifndef NDEBUG
     EXPECT_DEATH(vector_under_test.inserting_at(15, -1), "");
-#endif
     const auto augmented_vector = vector_under_test.inserting_at(3, 18);
     EXPECT_EQ(functional_vector<int>({ 1, 4, 2, 18, 5, 8, 3, 1, 7, 1 }), augmented_vector);
     EXPECT_EQ(functional_vector<int>({ 1, 4, 2, 5, 8, 3, 1, 7, 1 }), vector_under_test);
@@ -682,15 +666,13 @@ TEST(FunctionalVectorTest, InsertRangeEmptyFunctionalVectorTest)
     EXPECT_EQ(functional_vector({ 4, 7, 3, -5 }), vector_under_test);
 }
 
-#ifndef NDEBUG
 TEST(FunctionalVectorTest, InsertRangeExistingWrongInsertionIndexFunctionalVectorTest)
 {
     functional_vector<int> vector_under_test({1, 4, 2, 5, 8, 3, 1, 7, 1});
     const functional_vector vector_to_insert({9, -5, 6});
     EXPECT_DEATH(vector_under_test.insert_at(-1, vector_to_insert), "");
     EXPECT_DEATH(vector_under_test.insert_at(10, vector_to_insert), "");
 }
-#endif
 
 TEST(FunctionalVectorTest, InsertRangeExistingFunctionalVectorTest)
 {
@@ -708,15 +690,13 @@ TEST(FunctionalVectorTest, InsertRangeEmptyStdVectorTest)
     EXPECT_EQ(functional_vector({ 4, 7, 3, -5 }), vector_under_test);
 }
 
-#ifndef NDEBUG
 TEST(FunctionalVectorTest, InsertRangeExistingWrongInsertionIndexStdVectorTest)
 {
     functional_vector<int> vector_under_test({1, 4, 2, 5, 8, 3, 1, 7, 1});
     const std::vector<int> vector_to_insert({9, -5, 6});
     EXPECT_DEATH(vector_under_test.insert_at(-1, vector_to_insert), "");
     EXPECT_DEATH(vector_under_test.insert_at(10, vector_to_insert), "");
 }
-#endif
 
 TEST(FunctionalVectorTest, InsertRangeExistingStdVectorTest)
 {
@@ -733,14 +713,12 @@ TEST(FunctionalVectorTest, InsertRangeEmptyInitializerListTest)
     EXPECT_EQ(functional_vector({ 4, 7, 3, -5 }), vector_under_test);
 }
 
-#ifndef NDEBUG
 TEST(FunctionalVectorTest, InsertRangeExistingWrongInsertionIndexInitializerListTest)
 {
     functional_vector<int> vector_under_test({1, 4, 2, 5, 8, 3, 1, 7, 1});
     EXPECT_DEATH(vector_under_test.insert_at(-1, { 9, -5, 6 }), "");
     EXPECT_DEATH(vector_under_test.insert_at(10, { 9, -5, 6 }), "");
 }
-#endif
 
 TEST(FunctionalVectorTest, InsertRangeExistingInitializerListTest)
 {
@@ -757,15 +735,13 @@ TEST(FunctionalVectorTest, InsertingRangeEmptyFunctionalVectorTest)
     EXPECT_EQ(functional_vector({ 4, 7, 3, -5 }), result_vector);
 }
 
-#ifndef NDEBUG
 TEST(FunctionalVectorTest, InsertingRangeExistingWrongInsertionIndexFunctionalVectorTest)
 {
     const functional_vector<int> vector_under_test({1, 4, 2, 5, 8, 3, 1, 7, 1});
     const functional_vector vector_to_insert({9, -5, 6});
     EXPECT_DEATH(vector_under_test.inserting_at(-1, vector_to_insert), "");
     EXPECT_DEATH(vector_under_test.inserting_at(10, vector_to_insert), "");
 }
-#endif
 
 TEST(FunctionalVectorTest, InsertingRangeExistingFunctionalVectorTest)
 {
@@ -783,15 +759,13 @@ TEST(FunctionalVectorTest, InsertingRangeEmptyStdVectorTest)
     EXPECT_EQ(functional_vector({ 4, 7, 3, -5 }), result_vector);
 }
 
-#ifndef NDEBUG
 TEST(FunctionalVectorTest, InsertingRangeExistingWrongInsertionIndexStdVectorTest)
 {
     const functional_vector<int> vector_under_test({1, 4, 2, 5, 8, 3, 1, 7, 1});
     const std::vector vector_to_insert({9, -5, 6});
     EXPECT_DEATH(vector_under_test.inserting_at(-1, vector_to_insert), "");
     EXPECT_DEATH(vector_under_test.inserting_at(10, vector_to_insert), "");
 }
-#endif
 
 TEST(FunctionalVectorTest, InsertingRangeExistingStdVectorTest)
 {
@@ -808,14 +782,12 @@ TEST(FunctionalVectorTest, InsertingRangeEmptyInitializerListTest)
     EXPECT_EQ(functional_vector({ 4, 7, 3, -5 }), result_vector);
 }
 
-#ifndef NDEBUG
 TEST(FunctionalVectorTest, InsertingRangeExistingWrongInsertionIndexInitializerListTest)
 {
     const functional_vector<int> vector_under_test({1, 4, 2, 5, 8, 3, 1, 7, 1});
     EXPECT_DEATH(vector_under_test.inserting_at(-1, { 9, -5, 6 }), "");
     EXPECT_DEATH(vector_under_test.inserting_at(10, { 9, -5, 6 }), "");
 }
-#endif
 
 TEST(FunctionalVectorTest, InsertingRangeExistingInitializerListTest)
 {
@@ -887,7 +859,6 @@ TEST(FunctionalVectorTest, ReplaceRangeAtWithEmptySource)
     EXPECT_EQ(functional_vector({ 5, -3 , 4, -9 }), vector_under_test);
 }
 
-#ifndef NDEBUG
 TEST(FunctionalVectorTest, ReplaceRangeAtWrongIndex)
 {
     functional_vector vector_under_test({5, -3, 4, -9});
@@ -901,7 +872,6 @@ TEST(FunctionalVectorTest, ReplaceRangeAtMoreElementsInSourceThanCapacityTest)
     functional_vector vector_under_test({5, -3, 4, -9});
     EXPECT_DEATH(vector_under_test.replace_range_at(2, { 1, 2, 6, 4, 8, 9, -10 }), "");
 }
-#endif
 
 TEST(FunctionalVectorTest, ReplaceRangeAtWithFunctionalVectorTest)
 {
@@ -931,7 +901,6 @@ TEST(FunctionalVectorTest, ReplacingRangeAtWithEmptySource)
     EXPECT_EQ(functional_vector({ 5, -3 , 4, -9 }), replaced_vector);
 }
 
-#ifndef NDEBUG
 TEST(FunctionalVectorTest, ReplacingRangeAtWrongIndex)
 {
     const functional_vector vector_under_test({5, -3, 4, -9});
@@ -945,7 +914,6 @@ TEST(FunctionalVectorTest, ReplacingRangeAtMoreElementsInSourceThanCapacityTest)
     const functional_vector vector_under_test({5, -3, 4, -9});
     EXPECT_DEATH(vector_under_test.replacing_range_at(2, { 1, 2, 6, 4, 8, 9, -10 }), "");
 }
-#endif
 
 TEST(FunctionalVectorTest, ReplacingRangeAtWithFunctionalVectorTest)
 {

Original file line number	Diff line number	Diff line change
`@@ -256,7 +256,6 @@ TEST(FunctionalVectorTest, ReversedTest)`
`256`	`256`	`EXPECT_EQ(9, vector_under_test[2].age);`
`257`	`257`	`}`
`258`	`258`
`259`		`-#ifndef NDEBUG`
`260`	`259`	`TEST(FunctionalVectorTest, ZipWithStdVectorUnequalSizesThrowsTest)`
`261`	`260`	`{`
`262`	`261`	`const functional_vector ages_vector({32, 25, 53, 62});`
`@@ -269,7 +268,6 @@ TEST(FunctionalVectorTest, ZipWithFunctionalVectorUnequalSizesThrowsTest)`
`269`	`268`	`const auto names_vector = functional_vector<std::string>({"Jake", "Mary"});`
`270`	`269`	`EXPECT_DEATH({ const auto zipped_vector = ages_vector.zip(names_vector); }, "");`
`271`	`270`	`}`
`272`		`-#endif`
`273`	`271`
`274`	`272`	`TEST(FunctionalVectorTest, ZipWithFunctionalVectorTest)`
`275`	`273`	`{`
`@@ -430,7 +428,6 @@ TEST(FunctionalVectorTest, SortedDescendingTest)`
`430`	`428`	`EXPECT_EQ(-4, sorted_vector[3]);`
`431`	`429`	`}`
`432`	`430`
`433`		`-#ifndef NDEBUG`
`434`	`431`	`TEST(FunctionalVectorTest, SubscriptOperatorNegativeDeathTest)`
`435`	`432`	`{`
`436`	`433`	`const functional_vector vector_under_test({3, 1, 9, -4});`
`@@ -466,7 +463,6 @@ TEST(FunctionalVectorTest, SubscriptOperatorAssignIndexLargerThanSizeDeathTest)`
`466`	`463`	`functional_vector vector_under_test({3, 1, 9, -4});`
`467`	`464`	`EXPECT_DEATH(vector_under_test[5] = -3, "");`
`468`	`465`	`}`
`469`		`-#endif`
`470`	`466`
`471`	`467`	`TEST(FunctionalVectorTest, SubscriptOperatorAssignTest)`
`472`	`468`	`{`
`@@ -540,7 +536,6 @@ TEST(FunctionalVectorTest, FindAllIndicesFilledVectorTest)`
`540`	`536`	`EXPECT_EQ(std::vector<size_t>({ 7 }), seven_indices);`
`541`	`537`	`}`
`542`	`538`
`543`		`-#ifndef NDEBUG`
`544`	`539`	`TEST(FunctionalVectorTest, RemoveAtEmptyVectorTest)`
`545`	`540`	`{`
`546`	`541`	`functional_vector<int> vector_under_test;`
`@@ -554,7 +549,6 @@ TEST(FunctionalVectorTest, RemoveAtFilledVectorAboveSizeTest)`
`554`	`549`	`auto vector_under_test = functional_vector({1, 4, 2, 5, 8, 3, 1, 7, 1});`
`555`	`550`	`EXPECT_DEATH(vector_under_test.remove_at(15), "");`
`556`	`551`	`}`
`557`		`-#endif`
`558`	`552`
`559`	`553`	`TEST(FunctionalVectorTest, RemoveAtFilledVectorTest)`
`560`	`554`	`{`
`@@ -567,7 +561,6 @@ TEST(FunctionalVectorTest, RemoveAtFilledVectorTest)`
`567`	`561`	`EXPECT_EQ(functional_vector<int>({ 1, 5, 8, 3, 7, 1 }), vector_under_test);`
`568`	`562`	`}`
`569`	`563`
`570`		`-#ifndef NDEBUG`
`571`	`564`	`TEST(FunctionalVectorTest, RemovingAtEmptyVectorTest)`
`572`	`565`	`{`
`573`	`566`	`const functional_vector<int> vector_under_test;`
`@@ -581,7 +574,6 @@ TEST(FunctionalVectorTest, RemovingAtFilledVectorAboveSizeTest)`
`581`	`574`	`const functional_vector vector_under_test({1, 4, 2, 5, 8, 3, 1, 7, 1});`
`582`	`575`	`EXPECT_DEATH(vector_under_test.removing_at(15), "");`
`583`	`576`	`}`
`584`		`-#endif`
`585`	`577`
`586`	`578`	`TEST(FunctionalVectorTest, RemovingAtFilledVectorTest)`
`587`	`579`	`{`
`@@ -633,9 +625,7 @@ TEST(FunctionalVectorTest, RemovingFrontTest)`
`633`	`625`	`TEST(FunctionalVectorTest, InsertAtEmptyVectorTest)`
`634`	`626`	`{`
`635`	`627`	`functional_vector<int> vector_under_test;`
`636`		`-#ifndef NDEBUG`
`637`	`628`	`EXPECT_DEATH(vector_under_test.insert_at(15, -1), "");`
`638`		`-#endif`
`639`	`629`	`vector_under_test.insert_at(0, -1);`
`640`	`630`	`EXPECT_EQ(1, vector_under_test.size());`
`641`	`631`	`EXPECT_EQ(-1, vector_under_test[0]);`
`@@ -644,19 +634,15 @@ TEST(FunctionalVectorTest, InsertAtEmptyVectorTest)`
`644`	`634`	`TEST(FunctionalVectorTest, InsertAtFilledVectorTest)`
`645`	`635`	`{`
`646`	`636`	`functional_vector<int> vector_under_test({1, 4, 2, 5, 8, 3, 1, 7, 1});`
`647`		`-#ifndef NDEBUG`
`648`	`637`	`EXPECT_DEATH(vector_under_test.insert_at(15, -1), "");`
`649`		`-#endif`
`650`	`638`	`vector_under_test.insert_at(3, 18);`
`651`	`639`	`EXPECT_EQ(functional_vector<int>({ 1, 4, 2, 18, 5, 8, 3, 1, 7, 1 }), vector_under_test);`
`652`	`640`	`}`
`653`	`641`
`654`	`642`	`TEST(FunctionalVectorTest, InsertingAtEmptyVectorTest)`
`655`	`643`	`{`
`656`	`644`	`const functional_vector<int> vector_under_test;`
`657`		`-#ifndef NDEBUG`
`658`	`645`	`EXPECT_DEATH(vector_under_test.inserting_at(15, -1), "");`
`659`		`-#endif`
`660`	`646`	`const auto augmented_vector = vector_under_test.inserting_at(0, -1);`
`661`	`647`	`EXPECT_EQ(1, augmented_vector.size());`
`662`	`648`	`EXPECT_EQ(-1, augmented_vector[0]);`
`@@ -666,9 +652,7 @@ TEST(FunctionalVectorTest, InsertingAtEmptyVectorTest)`
`666`	`652`	`TEST(FunctionalVectorTest, InsertingAtFilledVectorTest)`
`667`	`653`	`{`
`668`	`654`	`const functional_vector<int> vector_under_test({1, 4, 2, 5, 8, 3, 1, 7, 1});`
`669`		`-#ifndef NDEBUG`
`670`	`655`	`EXPECT_DEATH(vector_under_test.inserting_at(15, -1), "");`
`671`		`-#endif`
`672`	`656`	`const auto augmented_vector = vector_under_test.inserting_at(3, 18);`
`673`	`657`	`EXPECT_EQ(functional_vector<int>({ 1, 4, 2, 18, 5, 8, 3, 1, 7, 1 }), augmented_vector);`
`674`	`658`	`EXPECT_EQ(functional_vector<int>({ 1, 4, 2, 5, 8, 3, 1, 7, 1 }), vector_under_test);`
`@@ -682,15 +666,13 @@ TEST(FunctionalVectorTest, InsertRangeEmptyFunctionalVectorTest)`
`682`	`666`	`EXPECT_EQ(functional_vector({ 4, 7, 3, -5 }), vector_under_test);`
`683`	`667`	`}`
`684`	`668`
`685`		`-#ifndef NDEBUG`
`686`	`669`	`TEST(FunctionalVectorTest, InsertRangeExistingWrongInsertionIndexFunctionalVectorTest)`
`687`	`670`	`{`
`688`	`671`	`functional_vector<int> vector_under_test({1, 4, 2, 5, 8, 3, 1, 7, 1});`
`689`	`672`	`const functional_vector vector_to_insert({9, -5, 6});`
`690`	`673`	`EXPECT_DEATH(vector_under_test.insert_at(-1, vector_to_insert), "");`
`691`	`674`	`EXPECT_DEATH(vector_under_test.insert_at(10, vector_to_insert), "");`
`692`	`675`	`}`
`693`		`-#endif`
`694`	`676`
`695`	`677`	`TEST(FunctionalVectorTest, InsertRangeExistingFunctionalVectorTest)`
`696`	`678`	`{`
`@@ -708,15 +690,13 @@ TEST(FunctionalVectorTest, InsertRangeEmptyStdVectorTest)`
`708`	`690`	`EXPECT_EQ(functional_vector({ 4, 7, 3, -5 }), vector_under_test);`
`709`	`691`	`}`
`710`	`692`
`711`		`-#ifndef NDEBUG`
`712`	`693`	`TEST(FunctionalVectorTest, InsertRangeExistingWrongInsertionIndexStdVectorTest)`
`713`	`694`	`{`
`714`	`695`	`functional_vector<int> vector_under_test({1, 4, 2, 5, 8, 3, 1, 7, 1});`
`715`	`696`	`const std::vector<int> vector_to_insert({9, -5, 6});`
`716`	`697`	`EXPECT_DEATH(vector_under_test.insert_at(-1, vector_to_insert), "");`
`717`	`698`	`EXPECT_DEATH(vector_under_test.insert_at(10, vector_to_insert), "");`
`718`	`699`	`}`
`719`		`-#endif`
`720`	`700`
`721`	`701`	`TEST(FunctionalVectorTest, InsertRangeExistingStdVectorTest)`
`722`	`702`	`{`
`@@ -733,14 +713,12 @@ TEST(FunctionalVectorTest, InsertRangeEmptyInitializerListTest)`
`733`	`713`	`EXPECT_EQ(functional_vector({ 4, 7, 3, -5 }), vector_under_test);`
`734`	`714`	`}`
`735`	`715`
`736`		`-#ifndef NDEBUG`
`737`	`716`	`TEST(FunctionalVectorTest, InsertRangeExistingWrongInsertionIndexInitializerListTest)`
`738`	`717`	`{`
`739`	`718`	`functional_vector<int> vector_under_test({1, 4, 2, 5, 8, 3, 1, 7, 1});`
`740`	`719`	`EXPECT_DEATH(vector_under_test.insert_at(-1, { 9, -5, 6 }), "");`
`741`	`720`	`EXPECT_DEATH(vector_under_test.insert_at(10, { 9, -5, 6 }), "");`
`742`	`721`	`}`
`743`		`-#endif`
`744`	`722`
`745`	`723`	`TEST(FunctionalVectorTest, InsertRangeExistingInitializerListTest)`
`746`	`724`	`{`
`@@ -757,15 +735,13 @@ TEST(FunctionalVectorTest, InsertingRangeEmptyFunctionalVectorTest)`
`757`	`735`	`EXPECT_EQ(functional_vector({ 4, 7, 3, -5 }), result_vector);`
`758`	`736`	`}`
`759`	`737`
`760`		`-#ifndef NDEBUG`
`761`	`738`	`TEST(FunctionalVectorTest, InsertingRangeExistingWrongInsertionIndexFunctionalVectorTest)`
`762`	`739`	`{`
`763`	`740`	`const functional_vector<int> vector_under_test({1, 4, 2, 5, 8, 3, 1, 7, 1});`
`764`	`741`	`const functional_vector vector_to_insert({9, -5, 6});`
`765`	`742`	`EXPECT_DEATH(vector_under_test.inserting_at(-1, vector_to_insert), "");`
`766`	`743`	`EXPECT_DEATH(vector_under_test.inserting_at(10, vector_to_insert), "");`
`767`	`744`	`}`
`768`		`-#endif`
`769`	`745`
`770`	`746`	`TEST(FunctionalVectorTest, InsertingRangeExistingFunctionalVectorTest)`
`771`	`747`	`{`
`@@ -783,15 +759,13 @@ TEST(FunctionalVectorTest, InsertingRangeEmptyStdVectorTest)`
`783`	`759`	`EXPECT_EQ(functional_vector({ 4, 7, 3, -5 }), result_vector);`
`784`	`760`	`}`
`785`	`761`
`786`		`-#ifndef NDEBUG`
`787`	`762`	`TEST(FunctionalVectorTest, InsertingRangeExistingWrongInsertionIndexStdVectorTest)`
`788`	`763`	`{`
`789`	`764`	`const functional_vector<int> vector_under_test({1, 4, 2, 5, 8, 3, 1, 7, 1});`
`790`	`765`	`const std::vector vector_to_insert({9, -5, 6});`
`791`	`766`	`EXPECT_DEATH(vector_under_test.inserting_at(-1, vector_to_insert), "");`
`792`	`767`	`EXPECT_DEATH(vector_under_test.inserting_at(10, vector_to_insert), "");`
`793`	`768`	`}`
`794`		`-#endif`
`795`	`769`
`796`	`770`	`TEST(FunctionalVectorTest, InsertingRangeExistingStdVectorTest)`
`797`	`771`	`{`
`@@ -808,14 +782,12 @@ TEST(FunctionalVectorTest, InsertingRangeEmptyInitializerListTest)`
`808`	`782`	`EXPECT_EQ(functional_vector({ 4, 7, 3, -5 }), result_vector);`
`809`	`783`	`}`
`810`	`784`
`811`		`-#ifndef NDEBUG`
`812`	`785`	`TEST(FunctionalVectorTest, InsertingRangeExistingWrongInsertionIndexInitializerListTest)`
`813`	`786`	`{`
`814`	`787`	`const functional_vector<int> vector_under_test({1, 4, 2, 5, 8, 3, 1, 7, 1});`
`815`	`788`	`EXPECT_DEATH(vector_under_test.inserting_at(-1, { 9, -5, 6 }), "");`
`816`	`789`	`EXPECT_DEATH(vector_under_test.inserting_at(10, { 9, -5, 6 }), "");`
`817`	`790`	`}`
`818`		`-#endif`
`819`	`791`
`820`	`792`	`TEST(FunctionalVectorTest, InsertingRangeExistingInitializerListTest)`
`821`	`793`	`{`
`@@ -887,7 +859,6 @@ TEST(FunctionalVectorTest, ReplaceRangeAtWithEmptySource)`
`887`	`859`	`EXPECT_EQ(functional_vector({ 5, -3 , 4, -9 }), vector_under_test);`
`888`	`860`	`}`
`889`	`861`
`890`		`-#ifndef NDEBUG`
`891`	`862`	`TEST(FunctionalVectorTest, ReplaceRangeAtWrongIndex)`
`892`	`863`	`{`
`893`	`864`	`functional_vector vector_under_test({5, -3, 4, -9});`
`@@ -901,7 +872,6 @@ TEST(FunctionalVectorTest, ReplaceRangeAtMoreElementsInSourceThanCapacityTest)`
`901`	`872`	`functional_vector vector_under_test({5, -3, 4, -9});`
`902`	`873`	`EXPECT_DEATH(vector_under_test.replace_range_at(2, { 1, 2, 6, 4, 8, 9, -10 }), "");`
`903`	`874`	`}`
`904`		`-#endif`
`905`	`875`
`906`	`876`	`TEST(FunctionalVectorTest, ReplaceRangeAtWithFunctionalVectorTest)`
`907`	`877`	`{`
`@@ -931,7 +901,6 @@ TEST(FunctionalVectorTest, ReplacingRangeAtWithEmptySource)`
`931`	`901`	`EXPECT_EQ(functional_vector({ 5, -3 , 4, -9 }), replaced_vector);`
`932`	`902`	`}`
`933`	`903`
`934`		`-#ifndef NDEBUG`
`935`	`904`	`TEST(FunctionalVectorTest, ReplacingRangeAtWrongIndex)`
`936`	`905`	`{`
`937`	`906`	`const functional_vector vector_under_test({5, -3, 4, -9});`
`@@ -945,7 +914,6 @@ TEST(FunctionalVectorTest, ReplacingRangeAtMoreElementsInSourceThanCapacityTest)`
`945`	`914`	`const functional_vector vector_under_test({5, -3, 4, -9});`
`946`	`915`	`EXPECT_DEATH(vector_under_test.replacing_range_at(2, { 1, 2, 6, 4, 8, 9, -10 }), "");`
`947`	`916`	`}`
`948`		`-#endif`
`949`	`917`
`950`	`918`	`TEST(FunctionalVectorTest, ReplacingRangeAtWithFunctionalVectorTest)`
`951`	`919`	`{`