COMP: Fix unused-lambda-capture statement

lambda capture 'n' is not required to be captured for this use [-Wunused-lambda-capture]

Author: hjmjohnson

Modules/Core/Common/test/itkImageBufferRangeGTest.cxx

@@ -664,10 +664,10 @@ TEST(ImageBufferRange, IteratorsSupportRandomAccess)
 
   {
     // Expression to be tested: 'r += n'
-    difference_type const n = 3;
+    constexpr difference_type n = 3;
 
     r = initialIterator;
-    const auto expectedResult = [&r, n] {
+    const auto expectedResult = [&r](const difference_type n) {
       // Operational semantics, as specified by the C++11 Standard:
       difference_type m = n;
       if (m >= 0)
@@ -677,53 +677,53 @@ TEST(ImageBufferRange, IteratorsSupportRandomAccess)
         while (m++)
           --r;
       return r;
-    }();
+    }(n);
     r = initialIterator;
     auto && actualResult = r += n;
     EXPECT_EQ(actualResult, expectedResult);
     static_assert(std::is_same_v<decltype(actualResult), X &>, "Type of result 'r += n' tested");
   }
   {
     // Expressions to be tested: 'a + n' and 'n + a'
-    difference_type const n = 3;
+    constexpr difference_type n = 3;
 
     static_assert(std::is_same_v<decltype(a + n), X>, "Return type tested");
     static_assert(std::is_same_v<decltype(n + a), X>, "Return type tested");
 
-    const auto expectedResult = [a, n] {
+    const auto expectedResult = [a](const difference_type n) {
       // Operational semantics, as specified by the C++11 Standard:
       X tmp = a;
       return tmp += n;
-    }();
+    }(n);
 
     EXPECT_EQ(a + n, expectedResult);
     EXPECT_TRUE(a + n == n + a);
   }
   {
     // Expression to be tested: 'r -= n'
-    difference_type const n = 3;
+    constexpr difference_type n = 3;
 
     r = initialIterator;
-    const auto expectedResult = [&r, n] {
+    const auto expectedResult = [&r](const difference_type n) {
       // Operational semantics, as specified by the C++11 Standard:
       return r += -n;
-    }();
+    }(n);
     r = initialIterator;
     auto && actualResult = r -= n;
     EXPECT_EQ(actualResult, expectedResult);
     static_assert(std::is_same_v<decltype(actualResult), X &>, "Type of result 'r -= n' tested");
   }
   {
     // Expression to be tested: 'a - n'
-    difference_type const n = -3;
+    constexpr difference_type n = -3;
 
     static_assert(std::is_same_v<decltype(a - n), X>, "Return type tested");
 
-    const auto expectedResult = [a, n] {
+    const auto expectedResult = [a](const difference_type n) {
       // Operational semantics, as specified by the C++11 Standard:
       X tmp = a;
       return tmp -= n;
-    }();
+    }(n);
 
     EXPECT_EQ(a - n, expectedResult);
   }
@@ -737,7 +737,7 @@ TEST(ImageBufferRange, IteratorsSupportRandomAccess)
   }
   {
     // Expression to be tested: 'a[n]'
-    difference_type const n = 3;
+    constexpr difference_type n = 3;
     static_assert(std::is_convertible_v<decltype(a[n]), reference>, "Return type tested");
     EXPECT_EQ(a[n], *(a + n));
   }

Modules/Core/Common/test/itkShapedImageNeighborhoodRangeGTest.cxx

@@ -770,12 +770,12 @@ TEST(ShapedImageNeighborhoodRange, IteratorsSupportRandomAccess)
 
   {
     // Expression to be tested: 'r += n'
-    const difference_type n = 3;
+    constexpr difference_type n = 3;
 
     static_assert(std::is_same_v<decltype(r += n), X &>, "Return type tested");
 
     r = initialIterator;
-    const auto expectedResult = [&r, n] {
+    const auto expectedResult = [&r](const difference_type n) {
       // Operational semantics, as specified by the C++11 Standard:
       difference_type m = n;
       if (m >= 0)
@@ -785,67 +785,67 @@ TEST(ShapedImageNeighborhoodRange, IteratorsSupportRandomAccess)
         while (m++)
           --r;
       return r;
-    }();
+    }(n);
     r = initialIterator;
     const auto actualResult = r += n;
     EXPECT_EQ(actualResult, expectedResult);
   }
   {
     // Expressions to be tested: 'a + n' and 'n + a'
-    difference_type const n = 3;
+    constexpr difference_type n = 3;
 
     static_assert(std::is_same_v<decltype(a + n), X>, "Return type tested");
     static_assert(std::is_same_v<decltype(n + a), X>, "Return type tested");
 
-    const auto expectedResult = [a, n] {
+    const auto expectedResult = [a](const difference_type n) {
       // Operational semantics, as specified by the C++11 Standard:
       X tmp = a;
       return tmp += n;
-    }();
+    }(n);
 
     EXPECT_EQ(a + n, expectedResult);
     EXPECT_TRUE(a + n == n + a);
   }
   {
     // Expression to be tested: 'r -= n'
-    difference_type const n = 3;
+    constexpr difference_type n = 3;
 
     static_assert(std::is_same_v<decltype(r -= n), X &>, "Return type tested");
 
     r = initialIterator;
-    const auto expectedResult = [&r, n] {
+    const auto expectedResult = [&r](const difference_type n) {
       // Operational semantics, as specified by the C++11 Standard:
       return r += -n;
-    }();
+    }(n);
     r = initialIterator;
     const auto actualResult = r -= n;
     EXPECT_EQ(actualResult, expectedResult);
   }
   {
     // Expression to be tested: 'a - n'
-    difference_type const n = -3;
+    constexpr difference_type n = -3;
 
     static_assert(std::is_same_v<decltype(a - n), X>, "Return type tested");
 
-    const auto expectedResult = [a, n] {
+    const auto expectedResult = [a](const difference_type n) {
       // Operational semantics, as specified by the C++11 Standard:
       X tmp = a;
       return tmp -= n;
-    }();
+    }(n);
 
     EXPECT_EQ(a - n, expectedResult);
   }
   {
     // Expression to be tested: 'b - a'
     static_assert(std::is_same_v<decltype(b - a), difference_type>, "Return type tested");
 
-    difference_type const n = b - a;
+    const difference_type n = b - a;
     EXPECT_TRUE(a + n == b);
     EXPECT_TRUE(b == a + (b - a));
   }
   {
     // Expression to be tested: 'a[n]'
-    const difference_type n = 3;
+    constexpr difference_type n = 3;
     static_assert(std::is_convertible_v<decltype(a[n]), reference>, "Return type tested");
     EXPECT_EQ(a[n], *(a + n));
   }