diff --git a/tests/benchmark/CL/CannyEdge.cpp b/tests/benchmark/CL/CannyEdge.cpp
index 7e327f3..8cc918f 100644
--- a/tests/benchmark/CL/CannyEdge.cpp
+++ b/tests/benchmark/CL/CannyEdge.cpp
@@ -42,10 +42,9 @@
 {
 // *INDENT-OFF*
 // clang-format off
-const auto use_fp16           = framework::dataset::make("UseFP16", { false });
 const auto canny_edge_dataset = combine(framework::dataset::make("GradientSize", { 3, 5, 7 }),
                                 combine(framework::dataset::make("Normalization", { MagnitudeType::L1NORM, MagnitudeType::L2NORM }),
-                                combine(datasets::BorderModes(), use_fp16)));
+                                        datasets::BorderModes()));
 } // namespace
 
 using CLCannyEdgeFixture = CannyEdgeFixture<CLTensor, CLCannyEdge, CLAccessor>;
diff --git a/tests/benchmark/CL/HarrisCorners.cpp b/tests/benchmark/CL/HarrisCorners.cpp
index 990ac24..dbaf95c 100644
--- a/tests/benchmark/CL/HarrisCorners.cpp
+++ b/tests/benchmark/CL/HarrisCorners.cpp
@@ -54,25 +54,23 @@
 TEST_SUITE(CL)
 TEST_SUITE(HarrisCorners)
 
-REGISTER_FIXTURE_DATA_TEST_CASE(RunSmall, CLHarrisCornersFixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(combine(combine(combine(datasets::SmallImageFiles(),
+REGISTER_FIXTURE_DATA_TEST_CASE(RunSmall, CLHarrisCornersFixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(combine(combine(datasets::SmallImageFiles(),
                                                                                                                      framework::dataset::make("Format", { Format::U8 })),
                                                                                                                      threshold),
                                                                                                                      min_dist),
                                                                                                                      sensitivity),
                                                                                                                      gradient_size),
                                                                                                                      block_size),
-                                                                                                                     border_mode),
-                                                                                                             framework::dataset::make("UseFP16", { false })));
+                                                                                                             border_mode));
 
-REGISTER_FIXTURE_DATA_TEST_CASE(RunLarge, CLHarrisCornersFixture, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(combine(combine(datasets::LargeImageFiles(),
+REGISTER_FIXTURE_DATA_TEST_CASE(RunLarge, CLHarrisCornersFixture, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(combine(datasets::LargeImageFiles(),
                                                                                                                    framework::dataset::make("Format", { Format::U8 })),
                                                                                                                    threshold),
                                                                                                                    min_dist),
                                                                                                                    sensitivity),
                                                                                                                    gradient_size),
                                                                                                                    block_size),
-                                                                                                                   border_mode),
-                                                                                                           framework::dataset::make("UseFP16", { false })));
+                                                                                                           border_mode));
 
 TEST_SUITE_END() // HarrisCorners
 TEST_SUITE_END() // CL
diff --git a/tests/benchmark/NEON/CannyEdge.cpp b/tests/benchmark/NEON/CannyEdge.cpp
index 50fd832..c441450 100644
--- a/tests/benchmark/NEON/CannyEdge.cpp
+++ b/tests/benchmark/NEON/CannyEdge.cpp
@@ -42,10 +42,9 @@
 {
 // *INDENT-OFF*
 // clang-format off
-const auto use_fp16           = framework::dataset::make("UseFP16", { false });
 const auto canny_edge_dataset = combine(framework::dataset::make("GradientSize", { 3, 5, 7 }),
                                 combine(framework::dataset::make("Normalization", { MagnitudeType::L1NORM, MagnitudeType::L2NORM }),
-                                combine(datasets::BorderModes(), use_fp16)));
+                                        datasets::BorderModes()));
 } // namespace
 
 using NECannyEdgeFixture = CannyEdgeFixture<Tensor, NECannyEdge, Accessor>;
diff --git a/tests/benchmark/NEON/HarrisCorners.cpp b/tests/benchmark/NEON/HarrisCorners.cpp
index 33315ff..75a6794 100644
--- a/tests/benchmark/NEON/HarrisCorners.cpp
+++ b/tests/benchmark/NEON/HarrisCorners.cpp
@@ -53,49 +53,23 @@
 TEST_SUITE(NEON)
 TEST_SUITE(HarrisCorners)
 
-#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
-TEST_SUITE(FP16)
-
-REGISTER_FIXTURE_DATA_TEST_CASE(RunSmall, NEHarrisCornersFixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(combine(combine(combine(datasets::SmallImageFiles(),
-                                                                                                                     framework::dataset::make("Format", { Format::U8 })),
-                                                                                                                     threshold),
-                                                                                                                     min_dist),
-                                                                                                                     sensitivity),
-                                                                                                                     gradient_size),
-                                                                                                                     block_size),
-                                                                                                                     border_mode),
-                                                                                                             framework::dataset::make("UseFP16", { true })));
-REGISTER_FIXTURE_DATA_TEST_CASE(RunLarge, NEHarrisCornersFixture, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(combine(combine(datasets::LargeImageFiles(),
-                                                                                                                   framework::dataset::make("Format", { Format::U8 })),
-                                                                                                                   threshold),
-                                                                                                                   min_dist),
-                                                                                                                   sensitivity),
-                                                                                                                   gradient_size),
-                                                                                                                   block_size),
-                                                                                                                   border_mode),
-                                                                                                           framework::dataset::make("UseFP16", { true })));
-TEST_SUITE_END() // FP16
-#endif           // __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
-
 TEST_SUITE(S16)
-REGISTER_FIXTURE_DATA_TEST_CASE(RunSmall, NEHarrisCornersFixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(combine(combine(combine(datasets::SmallImageFiles(),
+REGISTER_FIXTURE_DATA_TEST_CASE(RunSmall, NEHarrisCornersFixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(combine(combine(datasets::SmallImageFiles(),
                                                                                                                      framework::dataset::make("Format", { Format::U8 })),
                                                                                                                      threshold),
                                                                                                                      min_dist),
                                                                                                                      sensitivity),
                                                                                                                      gradient_size),
                                                                                                                      block_size),
-                                                                                                                     border_mode),
-                                                                                                             framework::dataset::make("UseFP16", { false })));
-REGISTER_FIXTURE_DATA_TEST_CASE(RunLarge, NEHarrisCornersFixture, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(combine(combine(datasets::LargeImageFiles(),
+                                                                                                             border_mode));
+REGISTER_FIXTURE_DATA_TEST_CASE(RunLarge, NEHarrisCornersFixture, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(combine(datasets::LargeImageFiles(),
                                                                                                                    framework::dataset::make("Format", { Format::U8 })),
                                                                                                                    threshold),
                                                                                                                    min_dist),
                                                                                                                    sensitivity),
                                                                                                                    gradient_size),
                                                                                                                    block_size),
-                                                                                                                   border_mode),
-                                                                                                           framework::dataset::make("UseFP16", { false })));
+                                                                                                           border_mode));
 TEST_SUITE_END() // S16
 TEST_SUITE_END() // HarrisCorners
 TEST_SUITE_END() // NEON
diff --git a/tests/benchmark/fixtures/CannyEdgeFixture.h b/tests/benchmark/fixtures/CannyEdgeFixture.h
index 099daba..e2aec24 100644
--- a/tests/benchmark/fixtures/CannyEdgeFixture.h
+++ b/tests/benchmark/fixtures/CannyEdgeFixture.h
@@ -44,7 +44,7 @@
 {
 public:
     template <typename...>
-    void setup(std::string image, int gradient_size, MagnitudeType norm_type, BorderMode border_mode, bool use_fp16, Format format)
+    void setup(std::string image, int gradient_size, MagnitudeType norm_type, BorderMode border_mode, Format format)
     {
         // Load the image (cached by the library if loaded before)
         const RawTensor &raw = library->get(image, format);
@@ -52,7 +52,7 @@
         src = create_tensor<TensorType>(raw.shape(), format);
         dst = create_tensor<TensorType>(raw.shape(), format);
 
-        configure_target<Function>(canny_edge_func, src, dst, gradient_size, static_cast<int>(norm_type) + 1, border_mode, use_fp16);
+        canny_edge_func.configure(&src, &dst, upper_thresh, lower_thresh, gradient_size, static_cast<int>(norm_type) + 1, border_mode, constant_border_value);
 
         // Allocate tensors
         src.allocator()->allocate();
@@ -72,22 +72,6 @@
         sync_tensor_if_necessary<TensorType>(dst);
     }
 
-protected:
-    template <typename F, typename std::enable_if<std::is_same<F, NECannyEdge>::value, int>::type = 0>
-    void configure_target(F &func, TensorType &src, TensorType &dst, int gradient_size, int norm_type, BorderMode border_mode, bool use_fp16)
-    {
-        func.configure(&src, &dst, upper_thresh, lower_thresh, gradient_size, norm_type, border_mode, constant_border_value, use_fp16);
-    }
-
-    template <typename F, typename std::enable_if<std::is_same<F, CLCannyEdge>::value, int>::type = 0>
-    void configure_target(F &func, TensorType &src, TensorType &dst, int gradient_size, int norm_type, BorderMode border_mode, bool use_fp16)
-    {
-        ARM_COMPUTE_UNUSED(use_fp16);
-        ARM_COMPUTE_ERROR_ON(use_fp16);
-
-        func.configure(&src, &dst, upper_thresh, lower_thresh, gradient_size, norm_type, border_mode, constant_border_value);
-    }
-
 private:
     static const int32_t lower_thresh          = 0;
     static const int32_t upper_thresh          = 255;
diff --git a/tests/benchmark/fixtures/HarrisCornersFixture.h b/tests/benchmark/fixtures/HarrisCornersFixture.h
index c7ce683..29d1741 100644
--- a/tests/benchmark/fixtures/HarrisCornersFixture.h
+++ b/tests/benchmark/fixtures/HarrisCornersFixture.h
@@ -42,8 +42,7 @@
 public:
     template <typename...>
     void setup(std::string image, Format format, float threshold, float min_dist, float sensitivity,
-               int32_t gradient_size, int32_t block_size,
-               BorderMode border_mode, bool use_fp16)
+               int32_t gradient_size, int32_t block_size, BorderMode border_mode)
     {
         // Load the image (cached by the library if loaded before)
         const RawTensor &raw = library->get(image, format);
@@ -52,7 +51,7 @@
         src = create_tensor<TensorType>(raw.shape(), format);
 
         // Create and configure function
-        harris_corners_func.configure(&src, threshold, min_dist, sensitivity, gradient_size, block_size, &out, border_mode, 0, use_fp16);
+        harris_corners_func.configure(&src, threshold, min_dist, sensitivity, gradient_size, block_size, &out, border_mode, 0);
 
         // Allocate tensor
         src.allocator()->allocate();
diff --git a/tests/validation/CL/CannyEdge.cpp b/tests/validation/CL/CannyEdge.cpp
index 7aa178a..d130aa4 100644
--- a/tests/validation/CL/CannyEdge.cpp
+++ b/tests/validation/CL/CannyEdge.cpp
@@ -48,21 +48,16 @@
 /* Allowed ratio of mismatches between target and reference (1.0 = 100%) */
 const float allowed_mismatch_ratio = 0.1f;
 
-const auto use_fp16 = framework::dataset::make("UseFP16", { false });
-
 const auto data = combine(framework::dataset::make("GradientSize", { 3, 5, 7 }),
-                          combine(framework::dataset::make("Normalization", { MagnitudeType::L1NORM, MagnitudeType::L2NORM }), combine(datasets::BorderModes(), use_fp16)));
+                          combine(framework::dataset::make("Normalization", { MagnitudeType::L1NORM, MagnitudeType::L2NORM }), datasets::BorderModes()));
 } // namespace
 
 TEST_SUITE(CL)
 TEST_SUITE(CannyEdge)
 
 DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(concat(datasets::Small2DShapes(), datasets::Large2DShapes()), data), framework::dataset::make("Format", Format::U8)),
-               shape, gradient_size, normalization, border_mode, use_fp16, format)
+               shape, gradient_size, normalization, border_mode, format)
 {
-    ARM_COMPUTE_UNUSED(use_fp16);
-    ARM_COMPUTE_ERROR_ON(use_fp16);
-
     CannyEdgeParameters params = canny_edge_parameters();
     // Convert normalisation type to integer
     const auto norm_type = static_cast<int>(normalization) + 1;
diff --git a/tests/validation/CL/HarrisCorners.cpp b/tests/validation/CL/HarrisCorners.cpp
index 890367c..ccc9293 100644
--- a/tests/validation/CL/HarrisCorners.cpp
+++ b/tests/validation/CL/HarrisCorners.cpp
@@ -46,21 +46,15 @@
 {
 namespace
 {
-const auto use_fp16 = framework::dataset::make("UseFP16",
-{ false });
-
-const auto data = combine(framework::dataset::make("GradientSize", { 3, 5, 7 }), combine(framework::dataset::make("BlockSize", { 3, 5, 7 }), combine(datasets::BorderModes(), use_fp16)));
+const auto data = combine(framework::dataset::make("GradientSize", { 3, 5, 7 }), combine(framework::dataset::make("BlockSize", { 3, 5, 7 }), datasets::BorderModes()));
 } // namespace
 
 TEST_SUITE(CL)
 TEST_SUITE(HarrisCorners)
 
 DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(concat(datasets::Small2DShapes(), datasets::Large2DShapes()), data), framework::dataset::make("Format", Format::U8)), shape,
-               gradient_size, block_size, border_mode, use_fp16, format)
+               gradient_size, block_size, border_mode, format)
 {
-    ARM_COMPUTE_UNUSED(use_fp16);
-    ARM_COMPUTE_ERROR_ON(use_fp16);
-
     std::mt19937                          gen(library->seed());
     std::uniform_real_distribution<float> real_dist(0.f, 0.01f);
 
diff --git a/tests/validation/NEON/CannyEdge.cpp b/tests/validation/NEON/CannyEdge.cpp
index 5697b62..7c4cd80 100644
--- a/tests/validation/NEON/CannyEdge.cpp
+++ b/tests/validation/NEON/CannyEdge.cpp
@@ -48,23 +48,15 @@
 /* Allowed ratio of mismatches between target and reference (1.0 = 100%) */
 const float allowed_mismatch_ratio = 0.1f;
 
-const auto use_fp16 = framework::dataset::make("UseFP16",
-{
-#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
-    true,
-#endif /* __ARM_FEATURE_FP16_VECTOR_ARITHMETIC */
-    false
-});
-
 const auto data = combine(framework::dataset::make("GradientSize", { 3, 5, 7 }),
-                          combine(framework::dataset::make("Normalization", { MagnitudeType::L1NORM, MagnitudeType::L2NORM }), combine(datasets::BorderModes(), use_fp16)));
+                          combine(framework::dataset::make("Normalization", { MagnitudeType::L1NORM, MagnitudeType::L2NORM }), datasets::BorderModes()));
 } // namespace
 
 TEST_SUITE(NEON)
 TEST_SUITE(CannyEdge)
 
 DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(concat(datasets::Small2DShapes(), datasets::Large2DShapes()), data), framework::dataset::make("Format", Format::U8)),
-               shape, gradient_size, normalization, border_mode, use_fp16, format)
+               shape, gradient_size, normalization, border_mode, format)
 {
     CannyEdgeParameters params = canny_edge_parameters();
     // Convert normalisation type to integer
@@ -81,7 +73,7 @@
 
     // Create Canny edge configure function
     NECannyEdge canny_edge;
-    canny_edge.configure(&src, &dst, params.upper_thresh, params.lower_thresh, gradient_size, norm_type, border_mode, params.constant_border_value, use_fp16);
+    canny_edge.configure(&src, &dst, params.upper_thresh, params.lower_thresh, gradient_size, norm_type, border_mode, params.constant_border_value);
 
     // Validate valid region
     validate(src.info()->valid_region(), shape_to_valid_region(shape, (BorderMode::UNDEFINED == border_mode)));
diff --git a/tests/validation/NEON/HarrisCorners.cpp b/tests/validation/NEON/HarrisCorners.cpp
index 3474a96..e0bbd92 100644
--- a/tests/validation/NEON/HarrisCorners.cpp
+++ b/tests/validation/NEON/HarrisCorners.cpp
@@ -50,22 +50,14 @@
 /* Allowed percentage of keypoints mismatching between target and reference */
 const float allowed_mismatch_percentage = 10.f;
 
-const auto use_fp16 = framework::dataset::make("UseFP16",
-{
-#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
-    true,
-#endif /* __ARM_FEATURE_FP16_VECTOR_ARITHMETIC */
-    false
-});
-
-const auto data = combine(framework::dataset::make("GradientSize", { 3, 5, 7 }), combine(framework::dataset::make("BlockSize", { 3, 5, 7 }), combine(datasets::BorderModes(), use_fp16)));
+const auto data = combine(framework::dataset::make("GradientSize", { 3, 5, 7 }), combine(framework::dataset::make("BlockSize", { 3, 5, 7 }), datasets::BorderModes()));
 } // namespace
 
 TEST_SUITE(NEON)
 TEST_SUITE(HarrisCorners)
 
 DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(concat(datasets::Small2DShapes(), datasets::Large2DShapes()), data), framework::dataset::make("Format", Format::U8)), shape,
-               gradient_size, block_size, border_mode, use_fp16, format)
+               gradient_size, block_size, border_mode, format)
 {
     std::mt19937                          gen(library->seed());
     std::uniform_real_distribution<float> real_dist(0.f, 0.01f);
@@ -90,7 +82,7 @@
 
     // Create harris corners configure function
     NEHarrisCorners harris_corners;
-    harris_corners.configure(&src, threshold, min_dist, sensitivity, gradient_size, block_size, &corners, border_mode, constant_border_value, use_fp16);
+    harris_corners.configure(&src, threshold, min_dist, sensitivity, gradient_size, block_size, &corners, border_mode, constant_border_value);
 
     // Validate padding
     PaddingCalculator calculator(shape.x(), 8);
diff --git a/tests/validation/fixtures/CannyEdgeFixture.h b/tests/validation/fixtures/CannyEdgeFixture.h
index 0f37c46..d52b17e 100644
--- a/tests/validation/fixtures/CannyEdgeFixture.h
+++ b/tests/validation/fixtures/CannyEdgeFixture.h
@@ -47,12 +47,11 @@
 {
 public:
     template <typename...>
-    void setup(std::string image, int gradient_size, MagnitudeType norm_type, BorderMode border_mode, bool use_fp16, Format format)
+    void setup(std::string image, int gradient_size, MagnitudeType norm_type, BorderMode border_mode, Format format)
     {
         CannyEdgeParameters params = canny_edge_parameters();
 
-        _target = compute_target(image, gradient_size, norm_type, border_mode, use_fp16, format, params);
-        //TODO(COMPMID-543): Add use_fp16 to reference
+        _target    = compute_target(image, gradient_size, norm_type, border_mode, format, params);
         _reference = compute_reference(image, gradient_size, norm_type, border_mode, format, params);
     }
 
@@ -63,21 +62,7 @@
         library->fill(tensor, raw);
     }
 
-    template <typename F, typename std::enable_if<std::is_same<F, NECannyEdge>::value, int>::type = 0>
-    void configure_target(F &func, TensorType &src, TensorType &dst, int gradient_size, int norm_type, BorderMode border_mode, bool use_fp16, const CannyEdgeParameters &params)
-    {
-        func.configure(&src, &dst, params.upper_thresh, params.lower_thresh, gradient_size, norm_type, border_mode, params.constant_border_value, use_fp16);
-    }
-
-    template <typename F, typename std::enable_if<std::is_same<F, CLCannyEdge>::value, int>::type = 0>
-    void configure_target(F &func, TensorType &src, TensorType &dst, int gradient_size, int norm_type, BorderMode border_mode, bool use_fp16, const CannyEdgeParameters &params)
-    {
-        ARM_COMPUTE_UNUSED(use_fp16);
-        ARM_COMPUTE_ERROR_ON(use_fp16);
-        func.configure(&src, &dst, params.upper_thresh, params.lower_thresh, gradient_size, norm_type, border_mode, params.constant_border_value);
-    }
-
-    TensorType compute_target(const std::string &image, int gradient_size, MagnitudeType norm_type, BorderMode border_mode, bool use_fp16, Format format, const CannyEdgeParameters &params)
+    TensorType compute_target(const std::string &image, int gradient_size, MagnitudeType norm_type, BorderMode border_mode, Format format, const CannyEdgeParameters &params)
     {
         // Load the image (cached by the library if loaded before)
         const RawTensor &raw = library->get(image, format);
@@ -90,7 +75,7 @@
 
         // Create Canny edge configure function
         FunctionType canny_edge;
-        configure_target<FunctionType>(canny_edge, src, dst, gradient_size, static_cast<int>(norm_type) + 1, border_mode, use_fp16, params);
+        canny_edge.configure(&src, &dst, params.upper_thresh, params.lower_thresh, gradient_size, static_cast<int>(norm_type) + 1, border_mode, params.constant_border_value);
 
         ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
         ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
diff --git a/tests/validation/fixtures/HarrisCornersFixture.h b/tests/validation/fixtures/HarrisCornersFixture.h
index 1c30157..f1d1f2d 100644
--- a/tests/validation/fixtures/HarrisCornersFixture.h
+++ b/tests/validation/fixtures/HarrisCornersFixture.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 ARM Limited.
+ * Copyright (c) 2017-2018 ARM Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -47,12 +47,11 @@
 {
 public:
     template <typename...>
-    void setup(std::string image, int gradient_size, int block_size, BorderMode border_mode, bool use_fp16, Format format)
+    void setup(std::string image, int gradient_size, int block_size, BorderMode border_mode, Format format)
     {
         HarrisCornersParameters params = harris_corners_parameters();
 
-        _target = compute_target(image, gradient_size, block_size, border_mode, use_fp16, format, params);
-        //TODO(COMPMID-543): Add use_fp16 to reference
+        _target    = compute_target(image, gradient_size, block_size, border_mode, format, params);
         _reference = compute_reference(image, gradient_size, block_size, border_mode, format, params);
     }
 
@@ -63,21 +62,7 @@
         library->fill(tensor, raw);
     }
 
-    template <typename F, typename std::enable_if<std::is_same<F, NEHarrisCorners>::value, int>::type = 0>
-    void configure_target(F &func, TensorType &src, ArrayType &corners, int gradient_size, int block_size, BorderMode border_mode, bool use_fp16, const HarrisCornersParameters &params)
-    {
-        func.configure(&src, params.threshold, params.min_dist, params.sensitivity, gradient_size, block_size, &corners, border_mode, params.constant_border_value, use_fp16);
-    }
-
-    template <typename F, typename std::enable_if<std::is_same<F, CLHarrisCorners>::value, int>::type = 0>
-    void configure_target(F &func, TensorType &src, ArrayType &corners, int gradient_size, int block_size, BorderMode border_mode, bool use_fp16, const HarrisCornersParameters &params)
-    {
-        ARM_COMPUTE_UNUSED(use_fp16);
-        ARM_COMPUTE_ERROR_ON(use_fp16);
-        func.configure(&src, params.threshold, params.min_dist, params.sensitivity, gradient_size, block_size, &corners, border_mode, params.constant_border_value);
-    }
-
-    ArrayType compute_target(std::string image, int gradient_size, int block_size, BorderMode border_mode, bool use_fp16, Format format, const HarrisCornersParameters &params)
+    ArrayType compute_target(std::string image, int gradient_size, int block_size, BorderMode border_mode, Format format, const HarrisCornersParameters &params)
     {
         // Load the image (cached by the library if loaded before)
         const RawTensor &raw = library->get(image, format);
@@ -90,7 +75,7 @@
 
         // Create harris corners configure function
         FunctionType harris_corners;
-        configure_target<FunctionType>(harris_corners, src, corners, gradient_size, block_size, border_mode, use_fp16, params);
+        harris_corners.configure(&src, params.threshold, params.min_dist, params.sensitivity, gradient_size, block_size, &corners, border_mode, params.constant_border_value);
 
         ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
 
diff --git a/tests/validation/reference/CannyEdgeDetector.cpp b/tests/validation/reference/CannyEdgeDetector.cpp
index cfe8ae8..d50452b 100644
--- a/tests/validation/reference/CannyEdgeDetector.cpp
+++ b/tests/validation/reference/CannyEdgeDetector.cpp
@@ -231,7 +231,8 @@
 } // namespace
 
 template <typename T>
-SimpleTensor<T> canny_edge_detector(const SimpleTensor<T> &src, int32_t upper_thresh, int32_t lower_thresh, int gradient_size, MagnitudeType norm_type,
+SimpleTensor<T> canny_edge_detector(const SimpleTensor<T> &src,
+                                    int32_t upper_thresh, int32_t lower_thresh, int gradient_size, MagnitudeType norm_type,
                                     BorderMode border_mode, T constant_border_value)
 {
     if(gradient_size < 7)
@@ -244,7 +245,8 @@
     }
 }
 
-template SimpleTensor<uint8_t> canny_edge_detector(const SimpleTensor<uint8_t> &src, int32_t upper_thresh, int32_t lower_thresh, int gradient_size, MagnitudeType norm_type,
+template SimpleTensor<uint8_t> canny_edge_detector(const SimpleTensor<uint8_t> &src,
+                                                   int32_t upper_thresh, int32_t lower_thresh, int gradient_size, MagnitudeType norm_type,
                                                    BorderMode border_mode, uint8_t constant_border_value);
 } // namespace reference
 } // namespace validation
diff --git a/tests/validation/reference/CannyEdgeDetector.h b/tests/validation/reference/CannyEdgeDetector.h
index a46c145..ee6199d 100644
--- a/tests/validation/reference/CannyEdgeDetector.h
+++ b/tests/validation/reference/CannyEdgeDetector.h
@@ -36,7 +36,8 @@
 namespace reference
 {
 template <typename T>
-SimpleTensor<T> canny_edge_detector(const SimpleTensor<T> &src, int32_t upper_thresh, int32_t lower_thresh, int gradient_size, MagnitudeType norm_type,
+SimpleTensor<T> canny_edge_detector(const SimpleTensor<T> &src,
+                                    int32_t upper_thresh, int32_t lower_thresh, int gradient_size, MagnitudeType norm_type,
                                     BorderMode border_mode, T constant_border_value = 0);
 } // namespace reference
 } // namespace validation
diff --git a/tests/validation/reference/HarrisCornerDetector.h b/tests/validation/reference/HarrisCornerDetector.h
index 042e857..f208eaa 100644
--- a/tests/validation/reference/HarrisCornerDetector.h
+++ b/tests/validation/reference/HarrisCornerDetector.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 ARM Limited.
+ * Copyright (c) 2017-2018 ARM Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -38,8 +38,9 @@
 namespace reference
 {
 template <typename T>
-std::vector<KeyPoint> harris_corner_detector(const SimpleTensor<T> &src, float threshold, float min_dist, float sensitivity, int gradient_size, int block_size, BorderMode border_mode,
-                                             T constant_border_value = 0);
+std::vector<KeyPoint> harris_corner_detector(const SimpleTensor<T> &src,
+                                             float threshold, float min_dist, float sensitivity, int gradient_size, int block_size,
+                                             BorderMode border_mode, T constant_border_value = 0);
 } // namespace reference
 } // namespace validation
 } // namespace test