const-qualify more collections in MOP tests

Morwenn · Morwenn · commit 16077c9a0f23 · 2025-07-21T23:35:09.000+02:00
diff --git a/tests/probes/block.cpp b/tests/probes/block.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2022 Morwenn
+ * Copyright (c) 2021-2025 Morwenn
  * SPDX-License-Identifier: MIT
  */
 #include <forward_list>
@@ -17,7 +17,7 @@ TEST_CASE( "presortedness measure: block", "[probe][block]" )
 
     SECTION( "simple test" )
     {
-        std::forward_list<int> li = { 74, 59, 62, 23, 86, 69, 18, 52, 77, 68 };
+        const std::forward_list<int> li = { 74, 59, 62, 23, 86, 69, 18, 52, 77, 68 };
         CHECK( block(li) == 8 );
         CHECK( block(li.begin(), li.end()) == 8 );
 
@@ -30,7 +30,7 @@ TEST_CASE( "presortedness measure: block", "[probe][block]" )
         // The upper bound should correspond to the size of
         // the input sequence minus one
 
-        std::forward_list<int> li = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
+        const std::forward_list<int> li = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
         auto max_n = block.max_for_size(cppsort::utility::size(li));
         CHECK( max_n == 10 );
         CHECK( block(li) == max_n );
diff --git a/tests/probes/dis.cpp b/tests/probes/dis.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2022 Morwenn
+ * Copyright (c) 2016-2025 Morwenn
  * SPDX-License-Identifier: MIT
  */
 #include <forward_list>
@@ -16,19 +16,19 @@ TEST_CASE( "presortedness measure: dis", "[probe][dis]" )
     SECTION( "simple tests" )
     {
         {
-            std::forward_list<int> li = { 47, 53, 46, 41, 59, 81, 74, 97, 100, 45 };
+            const std::forward_list<int> li = { 47, 53, 46, 41, 59, 81, 74, 97, 100, 45 };
             CHECK( dis(li) == 9 );
             CHECK( dis(li.begin(), li.end()) == 9 );
 
-            std::vector<internal_compare<int>> tricky(li.begin(), li.end());
+            const std::vector<internal_compare<int>> tricky(li.begin(), li.end());
             CHECK( dis(tricky, &internal_compare<int>::compare_to) == 9 );
         }
         {
             const std::forward_list<int> li = { 48, 43, 96, 44, 42, 34, 42, 57, 68, 69 };
             CHECK( dis(li) == 7 );
             CHECK( dis(li.begin(), li.end()) == 7 );
 
-            std::vector<internal_compare<int>> tricky(li.begin(), li.end());
+            const std::vector<internal_compare<int>> tricky(li.begin(), li.end());
             CHECK( dis(tricky, &internal_compare<int>::compare_to) == 7 );
         }
     }
@@ -52,7 +52,7 @@ TEST_CASE( "presortedness measure: dis", "[probe][dis]" )
         // The upper bound should correspond to the size of
         // the input sequence minus one
 
-        std::forward_list<int> li = { 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
+        const std::forward_list<int> li = { 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
         auto max_n = dis.max_for_size(cppsort::utility::size(li));
         CHECK( max_n == 10 );
         CHECK( dis(li) == max_n );
diff --git a/tests/probes/enc.cpp b/tests/probes/enc.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2022 Morwenn
+ * Copyright (c) 2016-2025 Morwenn
  * SPDX-License-Identifier: MIT
  */
 #include <forward_list>
@@ -15,7 +15,7 @@ TEST_CASE( "presortedness measure: enc", "[probe][enc]" )
 
     SECTION( "simple test" )
     {
-        std::forward_list<int> li = { 4, 6, 5, 2, 9, 1, 3, 8, 0, 7 };
+        const std::forward_list<int> li = { 4, 6, 5, 2, 9, 1, 3, 8, 0, 7 };
         CHECK( enc(li) == 2 );
         CHECK( enc(li.begin(), li.end()) == 2 );
 
@@ -28,7 +28,7 @@ TEST_CASE( "presortedness measure: enc", "[probe][enc]" )
         // The upper bound should correspond to half the size
         // of the input sequence minus one
 
-        std::forward_list<int> li = { 10, 0, 9, 1, 8, 2, 7, 3, 6, 4, 5 };
+        const std::forward_list<int> li = { 10, 0, 9, 1, 8, 2, 7, 3, 6, 4, 5 };
         auto max_n = enc.max_for_size(cppsort::utility::size(li));
         CHECK( max_n == 5 );
         CHECK( enc(li) == max_n );
diff --git a/tests/probes/every_probe_common.cpp b/tests/probes/every_probe_common.cpp
@@ -33,7 +33,7 @@ TEMPLATE_TEST_CASE( "test every probe with all_equal distribution", "[probe]",
     // Ensure that all measures of presortedness return 0 when
     // given a collection where all elements are equal
 
-    std::vector<int> collection(50, 5);
+    const std::vector<int> collection(50, 5);
     std::decay_t<TestType> mop;
     auto presortedness = mop(collection);
     CHECK( presortedness == 0 );
@@ -88,14 +88,14 @@ TEMPLATE_TEST_CASE( "test every probe with a 0 or 1 element", "[probe]",
 
     SECTION( "empty collection" )
     {
-        std::vector<int> collection;
+        const std::vector<int> collection;
         auto presortedness = mop(collection);
         CHECK( presortedness == 0 );
     }
 
     SECTION( "one-element collection" )
     {
-        std::vector<int> collection = { 42 };
+        const std::vector<int> collection = { 42 };
         auto presortedness = mop(collection);
         CHECK( presortedness == 0 );
     }
diff --git a/tests/probes/exc.cpp b/tests/probes/exc.cpp
@@ -17,15 +17,15 @@ TEST_CASE( "presortedness measure: exc", "[probe][exc]" )
 
     SECTION( "simple test" )
     {
-        std::forward_list<int> li = { 74, 59, 62, 23, 86, 69, 18, 52, 77, 68 };
+        const std::forward_list<int> li = { 74, 59, 62, 23, 86, 69, 18, 52, 77, 68 };
         CHECK( exc(li) == 7 );
         CHECK( exc(li.begin(), li.end()) == 7 );
 
-        std::forward_list<int> li2 = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
+        const std::forward_list<int> li2 = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
         CHECK( exc(li2) == 5 );
         CHECK( exc(li2.begin(), li2.end()) == 5 );
 
-        std::vector<internal_compare<int>> tricky(li.begin(), li.end());
+        const std::vector<internal_compare<int>> tricky(li.begin(), li.end());
         CHECK( exc(tricky, &internal_compare<int>::compare_to) == 7 );
     }
 
@@ -34,7 +34,7 @@ TEST_CASE( "presortedness measure: exc", "[probe][exc]" )
         // The upper bound should correspond to the size of
         // the input sequence minus one
 
-        std::forward_list<int> li = { 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+        const std::forward_list<int> li = { 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
         auto max_n = exc.max_for_size(cppsort::utility::size(li));
         CHECK( max_n == 10 );
         CHECK( exc(li) == max_n );
@@ -53,7 +53,7 @@ TEST_CASE( "presortedness measure: exc", "[probe][exc]" )
 
     SECTION( "regression: first and last elements of a cycle compare equal" )
     {
-        std::vector<int> collection = { 0, 0, -1 };
+        const std::vector<int> collection = { 0, 0, -1 };
         CHECK( exc(collection) == 1 );
     }
 }
diff --git a/tests/probes/ham.cpp b/tests/probes/ham.cpp
@@ -19,7 +19,7 @@ TEST_CASE( "presortedness measure: ham", "[probe][ham]" )
 
     SECTION( "simple test" )
     {
-        std::forward_list<int> li = { 34, 43, 96, 42, 44, 48, 57, 42, 68, 69 };
+        const std::forward_list<int> li = { 34, 43, 96, 42, 44, 48, 57, 42, 68, 69 };
         CHECK( ham(li) == 6 );
         CHECK( ham(li.begin(), li.end()) == 6 );
 
@@ -32,7 +32,7 @@ TEST_CASE( "presortedness measure: ham", "[probe][ham]" )
         // The upper bound should correspond to the size of
         // the input sequence
 
-        std::forward_list<int> li = { 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+        const std::forward_list<int> li = { 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
         auto max_n = ham.max_for_size(cppsort::utility::size(li));
         CHECK( max_n == 11 );
         CHECK( ham(li) == max_n );
diff --git a/tests/probes/max.cpp b/tests/probes/max.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2022 Morwenn
+ * Copyright (c) 2016-2025 Morwenn
  * SPDX-License-Identifier: MIT
  */
 #include <forward_list>
@@ -17,11 +17,11 @@ TEST_CASE( "presortedness measure: max", "[probe][max]" )
 
     SECTION( "simple test" )
     {
-        std::forward_list<int> li = { 12, 28, 17, 59, 13, 10, 39, 21, 31, 30 };
+        const std::forward_list<int> li = { 12, 28, 17, 59, 13, 10, 39, 21, 31, 30 };
         CHECK( (max)(li) == 6 );
         CHECK( (max)(li.begin(), li.end()) == 6 );
 
-        std::vector<internal_compare<int>> tricky(li.begin(), li.end());
+        const std::vector<internal_compare<int>> tricky(li.begin(), li.end());
         CHECK( (max)(tricky, &internal_compare<int>::compare_to) == 6 );
     }
 
@@ -30,7 +30,7 @@ TEST_CASE( "presortedness measure: max", "[probe][max]" )
         // The upper bound should correspond to the size of
         // the input sequence minus one
 
-        std::forward_list<int> li = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
+        const std::forward_list<int> li = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
         auto max_n = (max).max_for_size(cppsort::utility::size(li));
         CHECK( max_n == 10 );
         CHECK( (max)(li) == max_n );
diff --git a/tests/probes/osc.cpp b/tests/probes/osc.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2022 Morwenn
+ * Copyright (c) 2016-2025 Morwenn
  * SPDX-License-Identifier: MIT
  */
 #include <forward_list>
@@ -19,7 +19,7 @@ TEST_CASE( "presortedness measure: osc", "[probe][osc]" )
         // Example from the paper Adaptive Heapsort
         // by Levcopoulos and Petersson
 
-        std::forward_list<int> li = { 6, 3, 9, 8, 4, 7, 1, 11 };
+        const std::forward_list<int> li = { 6, 3, 9, 8, 4, 7, 1, 11 };
         CHECK( osc(li) == 17 );
         CHECK( osc(li.begin(), li.end()) == 17 );
 
@@ -33,7 +33,7 @@ TEST_CASE( "presortedness measure: osc", "[probe][osc]" )
         // by Levcopoulos and Petersson, the upper bound
         // should be (size * (size - 2) - 1) / 2
 
-        std::forward_list<int> li = { 8, 5, 10, 3, 12, 1, 13, 2, 11, 4, 9, 6, 7 };
+        const std::forward_list<int> li = { 8, 5, 10, 3, 12, 1, 13, 2, 11, 4, 9, 6, 7 };
         auto max_n = osc.max_for_size(cppsort::utility::size(li));
         CHECK( max_n == 71 );
         CHECK( osc(li) == max_n );
@@ -43,7 +43,7 @@ TEST_CASE( "presortedness measure: osc", "[probe][osc]" )
     SECTION( "regressions" )
     {
         using wrapper = generic_wrapper<generic_wrapper<int>>;
-        std::vector<wrapper> vec = { {{6}}, {{3}}, {{9}}, {{8}}, {{4}}, {{7}}, {{1}}, {{11}} };
+        const std::vector<wrapper> vec = { {{6}}, {{3}}, {{9}}, {{8}}, {{4}}, {{7}}, {{1}}, {{11}} };
         auto comp = [](generic_wrapper<int> const& lhs, generic_wrapper<int> const& rhs) {
             return lhs.value < rhs.value;
         };
diff --git a/tests/probes/rem.cpp b/tests/probes/rem.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2022 Morwenn
+ * Copyright (c) 2016-2025 Morwenn
  * SPDX-License-Identifier: MIT
  */
 #include <forward_list>
@@ -16,16 +16,16 @@ TEST_CASE( "presortedness measure: rem", "[probe][rem]" )
     SECTION( "simple test" )
     {
         // Forward iterators
-        std::forward_list<int> li = { 6, 9, 79, 41, 44, 49, 11, 16, 69, 15 };
+        const std::forward_list<int> li = { 6, 9, 79, 41, 44, 49, 11, 16, 69, 15 };
         CHECK( rem(li) == 4 );
         CHECK( rem(li.begin(), li.end()) == 4 );
 
         // Random-access iterators
-        std::vector<int> vec(li.begin(), li.end());
+        const std::vector<int> vec(li.begin(), li.end());
         CHECK( rem(vec) == 4 );
         CHECK( rem(vec.begin(), vec.end()) == 4 );
 
-        std::vector<internal_compare<int>> tricky(li.begin(), li.end());
+        const std::vector<internal_compare<int>> tricky(li.begin(), li.end());
         CHECK( rem(tricky, &internal_compare<int>::compare_to) == 4 );
     }
 
@@ -34,7 +34,7 @@ TEST_CASE( "presortedness measure: rem", "[probe][rem]" )
         // The upper bound should correspond to the size of
         // the input sequence minus one
 
-        std::forward_list<int> li = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
+        const std::forward_list<int> li = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
         auto max_n = rem.max_for_size(cppsort::utility::size(li));
         CHECK( max_n == 10 );
         CHECK( rem(li) == max_n );
diff --git a/tests/probes/runs.cpp b/tests/probes/runs.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2022 Morwenn
+ * Copyright (c) 2016-2025 Morwenn
  * SPDX-License-Identifier: MIT
  */
 #include <forward_list>
@@ -15,17 +15,17 @@ TEST_CASE( "presortedness measure: runs", "[probe][runs]" )
 
     SECTION( "simple tests" )
     {
-        std::forward_list<int> li = { 40, 49, 58, 99, 60, 70, 12, 87, 9, 8, 82, 91, 99, 67, 82, 92 };
+        const std::forward_list<int> li = { 40, 49, 58, 99, 60, 70, 12, 87, 9, 8, 82, 91, 99, 67, 82, 92 };
         CHECK( runs(li) == 5 );
         CHECK( runs(li.begin(), li.end()) == 5 );
 
         // From Right invariant metrics and measures of
         // presortedness by Estivill-Castro, Mannila and Wood
-        std::forward_list<int> li2 = { 4, 2, 6, 5, 3, 1, 9, 7, 10, 8 };
+        const std::forward_list<int> li2 = { 4, 2, 6, 5, 3, 1, 9, 7, 10, 8 };
         CHECK( runs(li2) == 6 );
         CHECK( runs(li2.begin(), li2.end()) == 6 );
 
-        std::vector<internal_compare<int>> tricky(li.begin(), li.end());
+        const std::vector<internal_compare<int>> tricky(li.begin(), li.end());
         CHECK( runs(tricky, &internal_compare<int>::compare_to) == 5 );
     }
 
@@ -34,7 +34,7 @@ TEST_CASE( "presortedness measure: runs", "[probe][runs]" )
         // The upper bound should correspond to the size of
         // the input sequence minus one
 
-        std::forward_list<int> li = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
+        const std::forward_list<int> li = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
         auto max_n = runs.max_for_size(cppsort::utility::size(li));
         CHECK( max_n == 10 );
         CHECK( runs(li) == max_n );
diff --git a/tests/probes/spear.cpp b/tests/probes/spear.cpp
@@ -18,11 +18,11 @@ TEST_CASE( "presortedness measure: spear", "[probe][max]" )
 
     SECTION( "simple test" )
     {
-        std::forward_list<int> li = { 12, 28, 17, 59, 13, 10, 39, 21, 31, 30 };
+        const std::forward_list<int> li = { 12, 28, 17, 59, 13, 10, 39, 21, 31, 30 };
         CHECK( spear(li) == 28 );
         CHECK( spear(li.begin(), li.end()) == 28 );
 
-        std::vector<internal_compare<int>> tricky(li.begin(), li.end());
+        const std::vector<internal_compare<int>> tricky(li.begin(), li.end());
         CHECK( spear(tricky, &internal_compare<int>::compare_to) == 28 );
     }
 
@@ -31,7 +31,7 @@ TEST_CASE( "presortedness measure: spear", "[probe][max]" )
         // The upper bound should be n²/2 when the collection
         // is sorted in reverse order
 
-        std::forward_list<int> li = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
+        const std::forward_list<int> li = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
         auto max_n = spear.max_for_size(cppsort::utility::size(li));
         CHECK( max_n == 60 );
         CHECK( spear(li) == max_n );
@@ -75,7 +75,7 @@ TEST_CASE( "presortedness measure: spear", "[probe][max]" )
 
     SECTION( "regression test: some equal values" )
     {
-        int arr[] = {2, 2, 0, -1};
+        const int arr[] = {2, 2, 0, -1};
         CHECK( spear(arr) == 8 );
     }
 }
diff --git a/tests/probes/sus.cpp b/tests/probes/sus.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2022 Morwenn
+ * Copyright (c) 2021-2025 Morwenn
  * SPDX-License-Identifier: MIT
  */
 #include <forward_list>
@@ -15,11 +15,11 @@ TEST_CASE( "presortedness measure: sus", "[probe][sus]" )
 
     SECTION( "simple test" )
     {
-        std::forward_list<int> li = { 6, 9, 79, 41, 44, 49, 11, 16, 69, 15 };
+        const std::forward_list<int> li = { 6, 9, 79, 41, 44, 49, 11, 16, 69, 15 };
         CHECK( sus(li) == 3 );
         CHECK( sus(li.begin(), li.end()) == 3 );
 
-        std::vector<internal_compare<int>> tricky(li.begin(), li.end());
+        const std::vector<internal_compare<int>> tricky(li.begin(), li.end());
         CHECK( sus(tricky, &internal_compare<int>::compare_to) == 3 );
     }
 
@@ -28,7 +28,7 @@ TEST_CASE( "presortedness measure: sus", "[probe][sus]" )
         // The upper bound should correspond to the size of
         // the input sequence minus one
 
-        std::forward_list<int> li = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
+        const std::forward_list<int> li = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
         auto max_n = sus.max_for_size(cppsort::utility::size(li));
         CHECK( max_n == 10 );
         CHECK( sus(li) == max_n );

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (c) 2016-2022 Morwenn`
	`2`	`+ * Copyright (c) 2016-2025 Morwenn`
`3`	`3`	`* SPDX-License-Identifier: MIT`
`4`	`4`	`*/`
`5`	`5`	`#include <forward_list>`
`@@ -16,19 +16,19 @@ TEST_CASE( "presortedness measure: dis", "[probe][dis]" )`
`16`	`16`	`SECTION( "simple tests" )`
`17`	`17`	`{`
`18`	`18`	`{`
`19`		`- std::forward_list<int> li = { 47, 53, 46, 41, 59, 81, 74, 97, 100, 45 };`
	`19`	`+ const std::forward_list<int> li = { 47, 53, 46, 41, 59, 81, 74, 97, 100, 45 };`
`20`	`20`	`CHECK( dis(li) == 9 );`
`21`	`21`	`CHECK( dis(li.begin(), li.end()) == 9 );`
`22`	`22`
`23`		`- std::vector<internal_compare<int>> tricky(li.begin(), li.end());`
	`23`	`+ const std::vector<internal_compare<int>> tricky(li.begin(), li.end());`
`24`	`24`	`CHECK( dis(tricky, &internal_compare<int>::compare_to) == 9 );`
`25`	`25`	`}`
`26`	`26`	`{`
`27`	`27`	`const std::forward_list<int> li = { 48, 43, 96, 44, 42, 34, 42, 57, 68, 69 };`
`28`	`28`	`CHECK( dis(li) == 7 );`
`29`	`29`	`CHECK( dis(li.begin(), li.end()) == 7 );`
`30`	`30`
`31`		`- std::vector<internal_compare<int>> tricky(li.begin(), li.end());`
	`31`	`+ const std::vector<internal_compare<int>> tricky(li.begin(), li.end());`
`32`	`32`	`CHECK( dis(tricky, &internal_compare<int>::compare_to) == 7 );`
`33`	`33`	`}`
`34`	`34`	`}`
`@@ -52,7 +52,7 @@ TEST_CASE( "presortedness measure: dis", "[probe][dis]" )`
`52`	`52`	`// The upper bound should correspond to the size of`
`53`	`53`	`// the input sequence minus one`
`54`	`54`
`55`		`- std::forward_list<int> li = { 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };`
	`55`	`+ const std::forward_list<int> li = { 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };`
`56`	`56`	`auto max_n = dis.max_for_size(cppsort::utility::size(li));`
`57`	`57`	`CHECK( max_n == 10 );`
`58`	`58`	`CHECK( dis(li) == max_n );`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ TEMPLATE_TEST_CASE( "test every probe with all_equal distribution", "[probe]",`
`33`	`33`	`// Ensure that all measures of presortedness return 0 when`
`34`	`34`	`// given a collection where all elements are equal`
`35`	`35`
`36`		`- std::vector<int> collection(50, 5);`
	`36`	`+ const std::vector<int> collection(50, 5);`
`37`	`37`	`std::decay_t<TestType> mop;`
`38`	`38`	`auto presortedness = mop(collection);`
`39`	`39`	`CHECK( presortedness == 0 );`
`@@ -88,14 +88,14 @@ TEMPLATE_TEST_CASE( "test every probe with a 0 or 1 element", "[probe]",`
`88`	`88`
`89`	`89`	`SECTION( "empty collection" )`
`90`	`90`	`{`
`91`		`- std::vector<int> collection;`
	`91`	`+ const std::vector<int> collection;`
`92`	`92`	`auto presortedness = mop(collection);`
`93`	`93`	`CHECK( presortedness == 0 );`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`SECTION( "one-element collection" )`
`97`	`97`	`{`
`98`		`- std::vector<int> collection = { 42 };`
	`98`	`+ const std::vector<int> collection = { 42 };`
`99`	`99`	`auto presortedness = mop(collection);`
`100`	`100`	`CHECK( presortedness == 0 );`
`101`	`101`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,15 +17,15 @@ TEST_CASE( "presortedness measure: exc", "[probe][exc]" )`
`17`	`17`
`18`	`18`	`SECTION( "simple test" )`
`19`	`19`	`{`
`20`		`- std::forward_list<int> li = { 74, 59, 62, 23, 86, 69, 18, 52, 77, 68 };`
	`20`	`+ const std::forward_list<int> li = { 74, 59, 62, 23, 86, 69, 18, 52, 77, 68 };`
`21`	`21`	`CHECK( exc(li) == 7 );`
`22`	`22`	`CHECK( exc(li.begin(), li.end()) == 7 );`
`23`	`23`
`24`		`- std::forward_list<int> li2 = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };`
	`24`	`+ const std::forward_list<int> li2 = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };`
`25`	`25`	`CHECK( exc(li2) == 5 );`
`26`	`26`	`CHECK( exc(li2.begin(), li2.end()) == 5 );`
`27`	`27`
`28`		`- std::vector<internal_compare<int>> tricky(li.begin(), li.end());`
	`28`	`+ const std::vector<internal_compare<int>> tricky(li.begin(), li.end());`
`29`	`29`	`CHECK( exc(tricky, &internal_compare<int>::compare_to) == 7 );`
`30`	`30`	`}`
`31`	`31`
`@@ -34,7 +34,7 @@ TEST_CASE( "presortedness measure: exc", "[probe][exc]" )`
`34`	`34`	`// The upper bound should correspond to the size of`
`35`	`35`	`// the input sequence minus one`
`36`	`36`
`37`		`- std::forward_list<int> li = { 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };`
	`37`	`+ const std::forward_list<int> li = { 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };`
`38`	`38`	`auto max_n = exc.max_for_size(cppsort::utility::size(li));`
`39`	`39`	`CHECK( max_n == 10 );`
`40`	`40`	`CHECK( exc(li) == max_n );`
`@@ -53,7 +53,7 @@ TEST_CASE( "presortedness measure: exc", "[probe][exc]" )`
`53`	`53`
`54`	`54`	`SECTION( "regression: first and last elements of a cycle compare equal" )`
`55`	`55`	`{`
`56`		`- std::vector<int> collection = { 0, 0, -1 };`
	`56`	`+ const std::vector<int> collection = { 0, 0, -1 };`
`57`	`57`	`CHECK( exc(collection) == 1 );`
`58`	`58`	`}`
`59`	`59`	`}`