Remove Compute Vision CL support

Resolves COMPMID-4151

Change-Id: I46f541efe8c4087f27794d2e158b6c1547d459ba
Signed-off-by: Michalis Spyrou <michalis.spyrou@arm.com>
Reviewed-on: https://review.mlplatform.org/c/ml/ComputeLibrary/+/5160
Comments-Addressed: Arm Jenkins <bsgcomp@arm.com>
Tested-by: Arm Jenkins <bsgcomp@arm.com>
Reviewed-by: Michele Di Giorgio <michele.digiorgio@arm.com>

36 files changed, 0 insertions, 5089 deletions

diff --git a/tests/validation/fixtures/AbsoluteDifferenceFixture.h b/tests/validation/fixtures/AbsoluteDifferenceFixture.h
deleted file mode 100644
index 46118c9323..0000000000
--- a/tests/validation/fixtures/AbsoluteDifferenceFixture.h
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * Copyright (c) 2017 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_ABSOLUTE_DIFFERENCE_FIXTURE
-#define ARM_COMPUTE_TEST_ABSOLUTE_DIFFERENCE_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/Helpers.h"
-#include "tests/validation/reference/AbsoluteDifference.h"
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T>
-class AbsoluteDifferenceValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, DataType data_type0, DataType data_type1, DataType output_data_type)
-    {
-        _target    = compute_target(shape, data_type0, data_type1, output_data_type);
-        _reference = compute_reference(shape, data_type0, data_type1, output_data_type);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor, int i)
-    {
-        library->fill_tensor_uniform(tensor, i);
-    }
-
-    TensorType compute_target(const TensorShape &shape, DataType data_type0, DataType data_type1, DataType output_data_type)
-    {
-        // Create tensors
-        TensorType ref_src1 = create_tensor<TensorType>(shape, data_type0, 1);
-        TensorType ref_src2 = create_tensor<TensorType>(shape, data_type1, 1);
-        TensorType dst      = create_tensor<TensorType>(shape, output_data_type, 1);
-
-        // Create and configure function
-        FunctionType abs_diff;
-        abs_diff.configure(&ref_src1, &ref_src2, &dst);
-
-        ARM_COMPUTE_EXPECT(ref_src1.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(ref_src2.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        ref_src1.allocator()->allocate();
-        ref_src2.allocator()->allocate();
-        dst.allocator()->allocate();
-
-        ARM_COMPUTE_EXPECT(!ref_src1.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!ref_src2.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(ref_src1), 0);
-        fill(AccessorType(ref_src2), 1);
-
-        // Compute function
-        abs_diff.run();
-
-        return dst;
-    }
-
-    SimpleTensor<T> compute_reference(const TensorShape &shape, DataType data_type0, DataType data_type1, DataType output_data_type)
-    {
-        // Create reference
-        SimpleTensor<T> ref_src1{ shape, data_type0, 1 };
-        SimpleTensor<T> ref_src2{ shape, data_type1, 1 };
-
-        // Fill reference
-        fill(ref_src1, 0);
-        fill(ref_src2, 1);
-
-        return reference::absolute_difference<T>(ref_src1, ref_src2, output_data_type);
-    }
-
-    TensorType      _target{};
-    SimpleTensor<T> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_ABSOLUTE_DIFFERENCE_FIXTURE */
diff --git a/tests/validation/fixtures/AccumulateFixture.h b/tests/validation/fixtures/AccumulateFixture.h
deleted file mode 100644
index 7cea29c15d..0000000000
--- a/tests/validation/fixtures/AccumulateFixture.h
+++ /dev/null
@@ -1,193 +0,0 @@
-/*
- * Copyright (c) 2017-2020 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_ACCUMULATE_FIXTURE
-#define ARM_COMPUTE_TEST_ACCUMULATE_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/Helpers.h"
-#include "tests/validation/reference/Accumulate.h"
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T1, typename T2>
-class AccumulateBaseValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, DataType data_type, DataType output_data_type)
-    {
-        _target    = compute_target(shape, data_type, output_data_type);
-        _reference = compute_reference(shape, data_type, output_data_type);
-    }
-
-protected:
-    template <typename U, typename D>
-    void fill(U &&tensor, int i, D max)
-    {
-        library->fill_tensor_uniform(tensor, i, static_cast<D>(0), max);
-    }
-
-    TensorType compute_target(const TensorShape &shape, DataType data_type, DataType output_data_type)
-    {
-        // Create tensors
-        TensorType ref_src = create_tensor<TensorType>(shape, data_type);
-        TensorType dst     = create_tensor<TensorType>(shape, output_data_type);
-
-        // Create and configure function
-        FunctionType accum;
-        accum_conf(accum, ref_src, dst);
-
-        ARM_COMPUTE_EXPECT(ref_src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        ref_src.allocator()->allocate();
-        dst.allocator()->allocate();
-
-        ARM_COMPUTE_EXPECT(!ref_src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        const T1 max = std::numeric_limits<T1>::max();
-
-        // Fill tensors
-        fill(AccessorType(ref_src), 0, max);
-        fill(AccessorType(dst), 1, static_cast<T2>(max));
-
-        // Compute function
-        accum.run();
-
-        return dst;
-    }
-
-    SimpleTensor<T2> compute_reference(const TensorShape &shape, DataType data_type, DataType output_data_type)
-    {
-        // Create reference
-        SimpleTensor<T1> ref_src{ shape, data_type };
-
-        const T1 max = std::numeric_limits<T1>::max();
-
-        // Fill reference
-        fill(ref_src, 0, max);
-
-        return accum_ref(ref_src, output_data_type);
-    }
-
-    virtual void accum_conf(FunctionType &func, const TensorType &input, TensorType &accum) = 0;
-
-    virtual SimpleTensor<T2> accum_ref(const SimpleTensor<T1> &input, DataType output_data_type) = 0;
-
-    TensorType       _target{};
-    SimpleTensor<T2> _reference{};
-};
-
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T1, typename T2>
-class AccumulateValidationFixture : public AccumulateBaseValidationFixture<TensorType, AccessorType, FunctionType, T1, T2>
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, DataType data_type, DataType output_data_type)
-    {
-        AccumulateBaseValidationFixture<TensorType, AccessorType, FunctionType, T1, T2>::setup(shape, data_type, output_data_type);
-    }
-
-    virtual void accum_conf(FunctionType &func, const TensorType &input, TensorType &accum) override
-    {
-        func.configure(&input, &accum);
-    }
-
-    virtual SimpleTensor<T2> accum_ref(const SimpleTensor<T1> &input, DataType output_data_type) override
-    {
-        return reference::accumulate<T1, T2>(input, output_data_type);
-    }
-};
-
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T1, typename T2>
-class AccumulateWeightedValidationFixture : public AccumulateBaseValidationFixture<TensorType, AccessorType, FunctionType, T1, T2>
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, DataType data_type, DataType output_data_type)
-    {
-        std::mt19937                          gen(library->seed());
-        std::uniform_real_distribution<float> float_dist(0, 1);
-
-        _alpha = float_dist(gen);
-
-        AccumulateBaseValidationFixture<TensorType, AccessorType, FunctionType, T1, T2>::setup(shape, data_type, output_data_type);
-    }
-
-    virtual void accum_conf(FunctionType &func, const TensorType &input, TensorType &accum) override
-    {
-        func.configure(&input, _alpha, &accum);
-    }
-
-    virtual SimpleTensor<T2> accum_ref(const SimpleTensor<T1> &input, DataType output_data_type) override
-    {
-        return reference::accumulate_weighted<T1, T2>(input, _alpha, output_data_type);
-    }
-
-    float _alpha{ 0.f };
-};
-
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T1, typename T2>
-class AccumulateSquaredValidationFixture : public AccumulateBaseValidationFixture<TensorType, AccessorType, FunctionType, T1, T2>
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, DataType data_type, DataType output_data_type)
-    {
-        std::mt19937                            gen(library->seed());
-        std::uniform_int_distribution<uint32_t> int_dist(0, 15);
-
-        _shift = int_dist(gen);
-
-        AccumulateBaseValidationFixture<TensorType, AccessorType, FunctionType, T1, T2>::setup(shape, data_type, output_data_type);
-    }
-
-    virtual void accum_conf(FunctionType &func, const TensorType &input, TensorType &accum) override
-    {
-        func.configure(&input, _shift, &accum);
-    }
-
-    virtual SimpleTensor<T2> accum_ref(const SimpleTensor<T1> &input, DataType output_data_type) override
-    {
-        return reference::accumulate_squared<T1, T2>(input, _shift, output_data_type);
-    }
-
-    uint32_t _shift{ 0U };
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_ACCUMULATE_FIXTURE */
diff --git a/tests/validation/fixtures/Box3x3Fixture.h b/tests/validation/fixtures/Box3x3Fixture.h
deleted file mode 100644
index 8caeec8400..0000000000
--- a/tests/validation/fixtures/Box3x3Fixture.h
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * Copyright (c) 2017 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_BOX3X3_FIXTURE
-#define ARM_COMPUTE_TEST_BOX3X3_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/Box3x3.h"
-
-#include <random>
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T>
-class Box3x3ValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, DataType data_type, BorderMode border_mode)
-    {
-        std::mt19937                           gen(library->seed());
-        std::uniform_int_distribution<uint8_t> distribution(0, 255);
-        const uint8_t                          constant_border_value = distribution(gen);
-
-        _border_mode = border_mode;
-        _target      = compute_target(shape, data_type, border_mode, constant_border_value);
-        _reference   = compute_reference(shape, data_type, border_mode, constant_border_value);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor)
-    {
-        library->fill_tensor_uniform(tensor, 0);
-    }
-
-    TensorType compute_target(const TensorShape &shape, DataType data_type, BorderMode border_mode, uint8_t constant_border_value)
-    {
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(shape, data_type);
-        TensorType dst = create_tensor<TensorType>(shape, data_type);
-
-        // Create and configure function
-        FunctionType box3x3;
-        box3x3.configure(&src, &dst, border_mode, constant_border_value);
-
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        dst.allocator()->allocate();
-
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(src));
-
-        // Compute function
-        box3x3.run();
-
-        return dst;
-    }
-
-    SimpleTensor<T> compute_reference(const TensorShape &shape, DataType data_type, BorderMode border_mode, uint8_t constant_border_value)
-    {
-        ARM_COMPUTE_ERROR_ON(data_type != DataType::U8);
-
-        // Create reference
-        SimpleTensor<T> src{ shape, data_type };
-
-        // Fill reference
-        fill(src);
-
-        // Compute reference
-        return reference::box3x3<T>(src, border_mode, constant_border_value);
-    }
-
-    BorderMode      _border_mode{};
-    TensorType      _target{};
-    SimpleTensor<T> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_BOX3X3_FIXTURE */
diff --git a/tests/validation/fixtures/CannyEdgeFixture.h b/tests/validation/fixtures/CannyEdgeFixture.h
deleted file mode 100644
index 8e82e6d2f0..0000000000
--- a/tests/validation/fixtures/CannyEdgeFixture.h
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * Copyright (c) 2017-2018 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_CANNY_EDGE_FIXTURE
-#define ARM_COMPUTE_TEST_CANNY_EDGE_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/Helpers.h"
-#include "tests/validation/reference/CannyEdgeDetector.h"
-
-namespace arm_compute
-{
-class CLCannyEdge;
-class NECannyEdge;
-
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename ArrayType, typename FunctionType, typename T>
-class CannyEdgeValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    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, format, params);
-        _reference = compute_reference(image, gradient_size, norm_type, border_mode, format, params);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor, RawTensor raw)
-    {
-        library->fill(tensor, raw);
-    }
-
-    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);
-
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(raw.shape(), format);
-        TensorType dst = create_tensor<TensorType>(raw.shape(), format);
-        src.info()->set_format(format);
-        dst.info()->set_format(format);
-
-        // Create Canny edge configure function
-        FunctionType canny_edge;
-        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);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        dst.allocator()->allocate();
-
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(src), raw);
-
-        // Compute function
-        canny_edge.run();
-
-        return dst;
-    }
-
-    SimpleTensor<T> compute_reference(const std::string &image, int gradient_size, MagnitudeType norm_type, BorderMode border_mode, Format format, const CannyEdgeParameters &params)
-    {
-        ARM_COMPUTE_ERROR_ON(format != Format::U8);
-
-        // Load the image (cached by the library if loaded before)
-        const RawTensor &raw = library->get(image, format);
-
-        // Create reference
-        SimpleTensor<T> src{ raw.shape(), format };
-
-        // Fill reference
-        fill(src, raw);
-
-        return reference::canny_edge_detector<T>(src, params.upper_thresh, params.lower_thresh, gradient_size, norm_type, border_mode, params.constant_border_value);
-    }
-
-    TensorType      _target{};
-    SimpleTensor<T> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_CANNY_EDGE_FIXTURE */
diff --git a/tests/validation/fixtures/ChannelCombineFixture.h b/tests/validation/fixtures/ChannelCombineFixture.h
deleted file mode 100644
index f0d927a992..0000000000
--- a/tests/validation/fixtures/ChannelCombineFixture.h
+++ /dev/null
@@ -1,266 +0,0 @@
-/*
- * Copyright (c) 2017-2018 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_CHANNEL_COMBINE_FIXTURE
-#define ARM_COMPUTE_TEST_CHANNEL_COMBINE_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/Helpers.h"
-#include "tests/validation/reference/ChannelCombine.h"
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-namespace
-{
-template <typename TensorType>
-inline std::vector<TensorType> create_tensor_planes(const TensorShape &shape, Format format)
-{
-    TensorShape image_shape = adjust_odd_shape(shape, format);
-    TensorInfo  info(image_shape, Format::U8);
-
-    std::vector<TensorType> tensor_planes;
-
-    switch(format)
-    {
-        case Format::RGB888:
-        case Format::RGBA8888:
-        case Format::YUV444:
-        {
-            tensor_planes.resize(3);
-
-            if(format == Format::RGBA8888)
-            {
-                tensor_planes.resize(4);
-            }
-
-            for(unsigned int plane_idx = 0; plane_idx < tensor_planes.size(); ++plane_idx)
-            {
-                tensor_planes[plane_idx].allocator()->init(info);
-            }
-
-            break;
-        }
-        case Format::YUYV422:
-        case Format::UYVY422:
-        {
-            const TensorShape uv_shape = calculate_subsampled_shape(image_shape, format);
-            const TensorInfo  info_hor2(uv_shape, Format::U8);
-
-            tensor_planes.resize(3);
-
-            tensor_planes[0].allocator()->init(info);
-            tensor_planes[1].allocator()->init(info_hor2);
-            tensor_planes[2].allocator()->init(info_hor2);
-            break;
-        }
-        case Format::NV12:
-        case Format::NV21:
-        case Format::IYUV:
-        {
-            const TensorShape sub2_shape = calculate_subsampled_shape(image_shape, format);
-            const TensorInfo  info_sub2(sub2_shape, Format::U8);
-
-            tensor_planes.resize(3);
-
-            tensor_planes[0].allocator()->init(info);
-            tensor_planes[1].allocator()->init(info_sub2);
-            tensor_planes[2].allocator()->init(info_sub2);
-            break;
-        }
-        default:
-            ARM_COMPUTE_ERROR("Not supported");
-            break;
-    }
-
-    return tensor_planes;
-}
-} // namespace
-
-template <typename MultiImageType, typename TensorType, typename AccessorType, typename FunctionType, typename T>
-class ChannelCombineValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, Format format)
-    {
-        _num_planes = num_planes_from_format(format);
-        _target     = compute_target(shape, format);
-        _reference  = compute_reference(shape, format);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor, int i)
-    {
-        library->fill_tensor_uniform(tensor, i);
-    }
-
-    template <typename U>
-    std::vector<SimpleTensor<U>> create_tensor_planes_reference(const TensorShape &shape, Format format)
-    {
-        std::vector<SimpleTensor<U>> tensor_planes;
-
-        TensorShape image_shape = adjust_odd_shape(shape, format);
-
-        switch(format)
-        {
-            case Format::RGB888:
-            case Format::RGBA8888:
-            case Format::YUV444:
-            {
-                if(format == Format::RGBA8888)
-                {
-                    tensor_planes.emplace_back(image_shape, Format::U8);
-                }
-
-                tensor_planes.emplace_back(image_shape, Format::U8);
-                tensor_planes.emplace_back(image_shape, Format::U8);
-                tensor_planes.emplace_back(image_shape, Format::U8);
-                break;
-            }
-            case Format::YUYV422:
-            case Format::UYVY422:
-            {
-                const TensorShape hor2_shape = calculate_subsampled_shape(image_shape, format);
-
-                tensor_planes.emplace_back(image_shape, Format::U8);
-                tensor_planes.emplace_back(hor2_shape, Format::U8);
-                tensor_planes.emplace_back(hor2_shape, Format::U8);
-                break;
-            }
-            case Format::NV12:
-            case Format::NV21:
-            case Format::IYUV:
-            {
-                const TensorShape shape_sub2 = calculate_subsampled_shape(image_shape, format);
-
-                tensor_planes.emplace_back(image_shape, Format::U8);
-                tensor_planes.emplace_back(shape_sub2, Format::U8);
-                tensor_planes.emplace_back(shape_sub2, Format::U8);
-                break;
-            }
-            default:
-                ARM_COMPUTE_ERROR("Not supported");
-                break;
-        }
-
-        return tensor_planes;
-    }
-
-    MultiImageType compute_target(const TensorShape &shape, Format format)
-    {
-        // Create tensors
-        std::vector<TensorType> ref_src = create_tensor_planes<TensorType>(shape, format);
-        MultiImageType          dst     = create_multi_image<MultiImageType>(shape, format);
-
-        // Create and configure function
-        FunctionType channel_combine;
-
-        if(1 == _num_planes)
-        {
-            const TensorType *tensor_extra = ((Format::RGBA8888 == format) ? &ref_src[3] : nullptr);
-            TensorType       *tensor_dst   = dynamic_cast<TensorType *>(dst.plane(0));
-
-            channel_combine.configure(&ref_src[0], &ref_src[1], &ref_src[2], tensor_extra, tensor_dst);
-        }
-        else
-        {
-            channel_combine.configure(&ref_src[0], &ref_src[1], &ref_src[2], &dst);
-        }
-
-        for(unsigned int plane_idx = 0; plane_idx < _num_planes; ++plane_idx)
-        {
-            const TensorType *dst_plane = static_cast<const TensorType *>(dst.plane(plane_idx));
-
-            ARM_COMPUTE_EXPECT(dst_plane->info()->is_resizable(), framework::LogLevel::ERRORS);
-        }
-
-        for(unsigned int plane_idx = 0; plane_idx < ref_src.size(); ++plane_idx)
-        {
-            ARM_COMPUTE_EXPECT(ref_src[plane_idx].info()->is_resizable(), framework::LogLevel::ERRORS);
-        }
-
-        // Allocate tensors
-        dst.allocate();
-
-        for(unsigned int plane_idx = 0; plane_idx < ref_src.size(); ++plane_idx)
-        {
-            ref_src[plane_idx].allocator()->allocate();
-        }
-
-        for(unsigned int plane_idx = 0; plane_idx < _num_planes; ++plane_idx)
-        {
-            const TensorType *dst_plane = static_cast<const TensorType *>(dst.plane(plane_idx));
-
-            ARM_COMPUTE_EXPECT(!dst_plane->info()->is_resizable(), framework::LogLevel::ERRORS);
-        }
-
-        for(unsigned int plane_idx = 0; plane_idx < ref_src.size(); ++plane_idx)
-        {
-            ARM_COMPUTE_EXPECT(!ref_src[plane_idx].info()->is_resizable(), framework::LogLevel::ERRORS);
-        }
-
-        // Fill tensor planes
-        for(unsigned int plane_idx = 0; plane_idx < ref_src.size(); ++plane_idx)
-        {
-            fill(AccessorType(ref_src[plane_idx]), plane_idx);
-        }
-
-        // Compute function
-        channel_combine.run();
-
-        return dst;
-    }
-
-    std::vector<SimpleTensor<T>> compute_reference(const TensorShape &shape, Format format)
-    {
-        // Create reference
-        std::vector<SimpleTensor<T>> ref_src = create_tensor_planes_reference<T>(shape, format);
-
-        // Fill references
-        for(unsigned int plane_idx = 0; plane_idx < ref_src.size(); ++plane_idx)
-        {
-            fill(ref_src[plane_idx], plane_idx);
-        }
-
-        return reference::channel_combine<T>(shape, ref_src, format);
-    }
-
-    unsigned int                 _num_planes{};
-    MultiImageType               _target{};
-    std::vector<SimpleTensor<T>> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_CHANNEL_COMBINE_FIXTURE */
diff --git a/tests/validation/fixtures/ChannelExtractFixture.h b/tests/validation/fixtures/ChannelExtractFixture.h
deleted file mode 100644
index 2f5694fcb1..0000000000
--- a/tests/validation/fixtures/ChannelExtractFixture.h
+++ /dev/null
@@ -1,192 +0,0 @@
-/*
- * Copyright (c) 2017-2018 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_CHANNEL_EXTRACT_FIXTURE
-#define ARM_COMPUTE_TEST_CHANNEL_EXTRACT_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/Helpers.h"
-#include "tests/validation/reference/ChannelExtract.h"
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename MultiImageType, typename TensorType, typename AccessorType, typename FunctionType, typename T>
-class ChannelExtractValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, Format format, Channel channel)
-    {
-        shape = adjust_odd_shape(shape, format);
-
-        _target    = compute_target(shape, format, channel);
-        _reference = compute_reference(shape, format, channel);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor, int i)
-    {
-        library->fill_tensor_uniform(tensor, i);
-    }
-
-    std::vector<SimpleTensor<T>> create_tensor_planes_reference(const TensorShape &shape, Format format)
-    {
-        TensorShape input = adjust_odd_shape(shape, format);
-
-        std::vector<SimpleTensor<T>> tensor_planes;
-
-        switch(format)
-        {
-            case Format::RGB888:
-            case Format::RGBA8888:
-            case Format::YUYV422:
-            case Format::UYVY422:
-            {
-                tensor_planes.emplace_back(input, format);
-                break;
-            }
-            case Format::NV12:
-            case Format::NV21:
-            {
-                const TensorShape shape_uv88 = calculate_subsampled_shape(shape, Format::UV88);
-
-                tensor_planes.emplace_back(input, Format::U8);
-                tensor_planes.emplace_back(shape_uv88, Format::UV88);
-                break;
-            }
-            case Format::IYUV:
-            {
-                const TensorShape shape_sub2 = calculate_subsampled_shape(shape, Format::IYUV);
-
-                tensor_planes.emplace_back(input, Format::U8);
-                tensor_planes.emplace_back(shape_sub2, Format::U8);
-                tensor_planes.emplace_back(shape_sub2, Format::U8);
-                break;
-            }
-            case Format::YUV444:
-                tensor_planes.emplace_back(input, Format::U8);
-                tensor_planes.emplace_back(input, Format::U8);
-                tensor_planes.emplace_back(input, Format::U8);
-                break;
-            default:
-                ARM_COMPUTE_ERROR("Not supported");
-                break;
-        }
-
-        return tensor_planes;
-    }
-
-    TensorType compute_target(const TensorShape &shape, Format format, Channel channel)
-    {
-        const unsigned int num_planes = num_planes_from_format(format);
-
-        TensorShape dst_shape = calculate_subsampled_shape(shape, format, channel);
-
-        // Create tensors
-        MultiImageType ref_src = create_multi_image<MultiImageType>(shape, format);
-        TensorType     dst     = create_tensor<TensorType>(dst_shape, Format::U8);
-
-        // Create and configure function
-        FunctionType channel_extract;
-
-        if(1U == num_planes)
-        {
-            const TensorType *plane_src = static_cast<TensorType *>(ref_src.plane(0));
-
-            channel_extract.configure(plane_src, channel, &dst);
-        }
-        else
-        {
-            channel_extract.configure(&ref_src, channel, &dst);
-        }
-
-        for(unsigned int plane_idx = 0; plane_idx < num_planes; ++plane_idx)
-        {
-            const TensorType *src_plane = static_cast<const TensorType *>(ref_src.plane(plane_idx));
-
-            ARM_COMPUTE_EXPECT(src_plane->info()->is_resizable(), framework::LogLevel::ERRORS);
-        }
-
-        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        ref_src.allocate();
-        dst.allocator()->allocate();
-
-        for(unsigned int plane_idx = 0; plane_idx < num_planes; ++plane_idx)
-        {
-            const TensorType *src_plane = static_cast<const TensorType *>(ref_src.plane(plane_idx));
-
-            ARM_COMPUTE_EXPECT(!src_plane->info()->is_resizable(), framework::LogLevel::ERRORS);
-        }
-
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensor planes
-        for(unsigned int plane_idx = 0; plane_idx < num_planes; ++plane_idx)
-        {
-            TensorType *src_plane = static_cast<TensorType *>(ref_src.plane(plane_idx));
-
-            fill(AccessorType(*src_plane), plane_idx);
-        }
-
-        // Compute function
-        channel_extract.run();
-
-        return dst;
-    }
-
-    SimpleTensor<T> compute_reference(const TensorShape &shape, Format format, Channel channel)
-    {
-        const unsigned int num_planes = num_planes_from_format(format);
-
-        // Create reference
-        std::vector<SimpleTensor<T>> ref_src = create_tensor_planes_reference(shape, format);
-
-        // Fill references
-        for(unsigned int plane_idx = 0; plane_idx < num_planes; ++plane_idx)
-        {
-            fill(ref_src[plane_idx], plane_idx);
-        }
-
-        return reference::channel_extract<T>(shape, ref_src, format, channel);
-    }
-
-    TensorType      _target{};
-    SimpleTensor<T> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_CHANNEL_EXTRACT_FIXTURE */
diff --git a/tests/validation/fixtures/ColorConvertFixture.h b/tests/validation/fixtures/ColorConvertFixture.h
deleted file mode 100644
index a5ed5548d5..0000000000
--- a/tests/validation/fixtures/ColorConvertFixture.h
+++ /dev/null
@@ -1,218 +0,0 @@
-/*
- * Copyright (c) 2017-2018 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_COLOR_CONVERT_FIXTURE
-#define ARM_COMPUTE_TEST_COLOR_CONVERT_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/Helpers.h"
-#include "tests/validation/reference/ColorConvert.h"
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-namespace
-{
-}
-template <typename MultiImageType, typename TensorType, typename AccessorType, typename FunctionType, typename T>
-class ColorConvertValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, Format src_format, Format dst_format)
-    {
-        shape = adjust_odd_shape(shape, src_format);
-        shape = adjust_odd_shape(shape, dst_format);
-
-        _target    = compute_target(shape, src_format, dst_format);
-        _reference = compute_reference(shape, src_format, dst_format);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor, int i)
-    {
-        library->fill_tensor_uniform(tensor, i);
-    }
-
-    std::vector<SimpleTensor<T>> create_tensor_planes_reference(const TensorShape &shape, Format format)
-    {
-        std::vector<SimpleTensor<T>> tensor_planes;
-
-        switch(format)
-        {
-            case Format::RGB888:
-            case Format::RGBA8888:
-            case Format::YUYV422:
-            case Format::UYVY422:
-            {
-                tensor_planes.emplace_back(shape, format);
-                break;
-            }
-            case Format::NV12:
-            case Format::NV21:
-            {
-                const TensorShape shape_uv88 = calculate_subsampled_shape(shape, Format::UV88);
-
-                tensor_planes.emplace_back(shape, Format::U8);
-                tensor_planes.emplace_back(shape_uv88, Format::UV88);
-                break;
-            }
-            case Format::IYUV:
-            {
-                const TensorShape shape_sub2 = calculate_subsampled_shape(shape, Format::IYUV);
-
-                tensor_planes.emplace_back(shape, Format::U8);
-                tensor_planes.emplace_back(shape_sub2, Format::U8);
-                tensor_planes.emplace_back(shape_sub2, Format::U8);
-                break;
-            }
-            case Format::YUV444:
-            {
-                tensor_planes.emplace_back(shape, Format::U8);
-                tensor_planes.emplace_back(shape, Format::U8);
-                tensor_planes.emplace_back(shape, Format::U8);
-                break;
-            }
-            default:
-                ARM_COMPUTE_ERROR("Not supported");
-                break;
-        }
-
-        return tensor_planes;
-    }
-
-    MultiImageType compute_target(const TensorShape &shape, Format src_format, Format dst_format)
-    {
-        _src_num_planes = num_planes_from_format(src_format);
-        _dst_num_planes = num_planes_from_format(dst_format);
-
-        // Create tensors
-        MultiImageType ref_src = create_multi_image<MultiImageType>(shape, src_format);
-        MultiImageType ref_dst = create_multi_image<MultiImageType>(shape, dst_format);
-
-        // Create and configure function
-        FunctionType color_convert;
-
-        if(1U == _src_num_planes)
-        {
-            const TensorType *plane_src = static_cast<TensorType *>(ref_src.plane(0));
-
-            if(1U == _dst_num_planes)
-            {
-                TensorType *plane_dst = static_cast<TensorType *>(ref_dst.plane(0));
-                color_convert.configure(plane_src, plane_dst);
-            }
-            else
-            {
-                color_convert.configure(plane_src, &ref_dst);
-            }
-        }
-        else
-        {
-            if(1U == _dst_num_planes)
-            {
-                TensorType *plane_dst = static_cast<TensorType *>(ref_dst.plane(0));
-                color_convert.configure(&ref_src, plane_dst);
-            }
-            else
-            {
-                color_convert.configure(&ref_src, &ref_dst);
-            }
-        }
-
-        for(unsigned int plane_idx = 0; plane_idx < _src_num_planes; ++plane_idx)
-        {
-            const TensorType *src_plane = static_cast<const TensorType *>(ref_src.plane(plane_idx));
-
-            ARM_COMPUTE_EXPECT(src_plane->info()->is_resizable(), framework::LogLevel::ERRORS);
-        }
-        for(unsigned int plane_idx = 0; plane_idx < _dst_num_planes; ++plane_idx)
-        {
-            const TensorType *dst_plane = static_cast<const TensorType *>(ref_dst.plane(plane_idx));
-
-            ARM_COMPUTE_EXPECT(dst_plane->info()->is_resizable(), framework::LogLevel::ERRORS);
-        }
-
-        // Allocate tensors
-        ref_src.allocate();
-        ref_dst.allocate();
-
-        for(unsigned int plane_idx = 0; plane_idx < _src_num_planes; ++plane_idx)
-        {
-            const TensorType *src_plane = static_cast<const TensorType *>(ref_src.plane(plane_idx));
-            ARM_COMPUTE_EXPECT(!src_plane->info()->is_resizable(), framework::LogLevel::ERRORS);
-        }
-
-        for(unsigned int plane_idx = 0; plane_idx < _dst_num_planes; ++plane_idx)
-        {
-            const TensorType *dst_plane = static_cast<const TensorType *>(ref_dst.plane(plane_idx));
-            ARM_COMPUTE_EXPECT(!dst_plane->info()->is_resizable(), framework::LogLevel::ERRORS);
-        }
-
-        // Fill tensor planes
-        for(unsigned int plane_idx = 0; plane_idx < _src_num_planes; ++plane_idx)
-        {
-            TensorType *src_plane = static_cast<TensorType *>(ref_src.plane(plane_idx));
-
-            fill(AccessorType(*src_plane), plane_idx);
-        }
-
-        // Compute function
-        color_convert.run();
-
-        return ref_dst;
-    }
-
-    std::vector<SimpleTensor<T>> compute_reference(const TensorShape &shape, Format src_format, Format dst_format)
-    {
-        // Create reference
-        std::vector<SimpleTensor<T>> ref_src = create_tensor_planes_reference(shape, src_format);
-
-        // Fill references
-        for(unsigned int plane_idx = 0; plane_idx < ref_src.size(); ++plane_idx)
-        {
-            fill(ref_src[plane_idx], plane_idx);
-        }
-
-        return reference::color_convert<T>(shape, ref_src, src_format, dst_format);
-    }
-
-    unsigned int                 _src_num_planes{};
-    unsigned int                 _dst_num_planes{};
-    MultiImageType               _target{};
-    std::vector<SimpleTensor<T>> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_COLOR_CONVERT_FIXTURE */
diff --git a/tests/validation/fixtures/ConvolutionFixture.h b/tests/validation/fixtures/ConvolutionFixture.h
deleted file mode 100644
index 4692e2faf8..0000000000
--- a/tests/validation/fixtures/ConvolutionFixture.h
+++ /dev/null
@@ -1,235 +0,0 @@
-/*
- * Copyright (c) 2017-2020 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_CONVOLUTION_FIXTURE
-#define ARM_COMPUTE_TEST_CONVOLUTION_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/Convolution.h"
-
-#include <random>
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T>
-class ConvolutionValidationFixture : public framework::Fixture
-{
-protected:
-    template <typename...>
-    void setup(TensorShape shape, DataType output_data_type, BorderMode border_mode, const unsigned int width, const unsigned int height, const bool is_separable = false)
-    {
-        std::mt19937                           gen(library->seed());
-        std::uniform_int_distribution<uint8_t> distribution(0, 255);
-        std::uniform_int_distribution<uint8_t> scale_distribution(1, 255);
-        const uint8_t                          constant_border_value = distribution(gen);
-
-        // Generate random scale value between 1 and 255.
-        const uint32_t scale = scale_distribution(gen);
-
-        ARM_COMPUTE_ERROR_ON(3 != width && 5 != width && 7 != width && 9 != width);
-        ARM_COMPUTE_ERROR_ON(3 != height && 5 != height && 7 != height && 9 != height);
-
-        std::vector<int16_t> conv(width * height);
-
-        _width  = width;
-        _height = height;
-
-        if(is_separable)
-        {
-            init_separable_conv(conv.data(), width, height, library->seed());
-        }
-        else
-        {
-            init_conv(conv.data(), width, height, library->seed());
-        }
-
-        _target    = compute_target(shape, output_data_type, conv.data(), scale, border_mode, constant_border_value);
-        _reference = compute_reference(shape, output_data_type, conv.data(), scale, border_mode, constant_border_value);
-    }
-
-    template <typename U>
-    void fill(U &&tensor, int i)
-    {
-        library->fill_tensor_uniform(tensor, i);
-    }
-
-    SimpleTensor<T> compute_reference(const TensorShape &shape, DataType output_data_type, const int16_t *conv, uint32_t scale, BorderMode border_mode, uint8_t constant_border_value)
-    {
-        // Create reference
-        SimpleTensor<uint8_t> src{ shape, DataType::U8 };
-
-        // Fill reference
-        fill(src, 0);
-
-        // Compute reference
-        return reference::convolution<T>(src, output_data_type, conv, scale, border_mode, constant_border_value, _width, _height);
-    }
-
-    virtual TensorType compute_target(const TensorShape &shape, DataType output_data_type, const int16_t *conv, uint32_t scale, BorderMode border_mode, uint8_t constant_border_value) = 0;
-
-    BorderMode      _border_mode{};
-    TensorType      _target{};
-    SimpleTensor<T> _reference{};
-    unsigned int    _width{};
-    unsigned int    _height{};
-};
-
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T>
-class ConvolutionSquareValidationFixture : public ConvolutionValidationFixture<TensorType, AccessorType, FunctionType, T>
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, DataType output_data_type, BorderMode border_mode, const unsigned int width)
-    {
-        ConvolutionValidationFixture<TensorType, AccessorType, FunctionType, T>::setup(shape, output_data_type, border_mode, width, width);
-    }
-
-protected:
-    TensorType compute_target(const TensorShape &shape, DataType output_data_type, const int16_t *conv, uint32_t scale, BorderMode border_mode, uint8_t constant_border_value)
-    {
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(shape, DataType::U8);
-        TensorType dst = create_tensor<TensorType>(shape, output_data_type);
-
-        // Create and configure function
-        FunctionType convolution;
-        convolution.configure(&src, &dst, conv, scale, border_mode, constant_border_value);
-
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        dst.allocator()->allocate();
-
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        this->fill(AccessorType(src), 0);
-        this->fill(AccessorType(dst), 1);
-
-        // Compute function
-        convolution.run();
-
-        return dst;
-    }
-};
-
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T>
-class ConvolutionSeparableValidationFixture : public ConvolutionValidationFixture<TensorType, AccessorType, FunctionType, T>
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, DataType output_data_type, BorderMode border_mode, const unsigned int width)
-    {
-        ConvolutionValidationFixture<TensorType, AccessorType, FunctionType, T>::setup(shape, output_data_type, border_mode, width, width, true);
-    }
-
-protected:
-    TensorType compute_target(const TensorShape &shape, DataType output_data_type, const int16_t *conv, uint32_t scale, BorderMode border_mode, uint8_t constant_border_value)
-    {
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(shape, DataType::U8);
-        TensorType dst = create_tensor<TensorType>(shape, output_data_type);
-
-        // Create and configure function
-        FunctionType convolution;
-        convolution.configure(&src, &dst, conv, scale, border_mode, constant_border_value);
-
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        dst.allocator()->allocate();
-
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        this->fill(AccessorType(src), 0);
-        this->fill(AccessorType(dst), 1);
-
-        // Compute function
-        convolution.run();
-
-        return dst;
-    }
-};
-
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T>
-class ConvolutionRectangleValidationFixture : public ConvolutionValidationFixture<TensorType, AccessorType, FunctionType, T>
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, DataType output_data_type, BorderMode border_mode, const unsigned int width, const unsigned int height)
-    {
-        ConvolutionValidationFixture<TensorType, AccessorType, FunctionType, T>::setup(shape, output_data_type, border_mode, width, height);
-    }
-
-protected:
-    TensorType compute_target(const TensorShape &shape, DataType output_data_type, const int16_t *conv, uint32_t scale, BorderMode border_mode, uint8_t constant_border_value)
-    {
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(shape, DataType::U8);
-        TensorType dst = create_tensor<TensorType>(shape, output_data_type);
-
-        // Create and configure function
-        FunctionType convolution;
-        convolution.configure(&src, &dst, conv, this->_width, this->_height, scale, border_mode, constant_border_value);
-
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        dst.allocator()->allocate();
-
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        this->fill(AccessorType(src), 0);
-        this->fill(AccessorType(dst), 1);
-
-        // Compute function
-        convolution.run();
-
-        return dst;
-    }
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_CONVOLUTION_FIXTURE */
diff --git a/tests/validation/fixtures/DerivativeFixture.h b/tests/validation/fixtures/DerivativeFixture.h
deleted file mode 100644
index e520a9e14e..0000000000
--- a/tests/validation/fixtures/DerivativeFixture.h
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- * Copyright (c) 2017 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_DERIVATIVE_FIXTURE
-#define ARM_COMPUTE_TEST_DERIVATIVE_FIXTURE
-
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/Types.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/Derivative.h"
-
-#include <memory>
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T, typename U>
-class DerivativeValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, BorderMode border_mode, Format format, GradientDimension gradient_dimension)
-    {
-        // Generate a random constant value
-        std::mt19937                           gen(library->seed());
-        std::uniform_int_distribution<uint8_t> int_dist(0, 255);
-        const uint8_t                          constant_border_value = int_dist(gen);
-
-        _border_mode = border_mode;
-        _target      = compute_target(shape, border_mode, format, constant_border_value, gradient_dimension);
-        _reference   = compute_reference(shape, border_mode, format, constant_border_value, gradient_dimension);
-    }
-
-protected:
-    template <typename V>
-    void fill(V &&tensor)
-    {
-        library->fill_tensor_uniform(tensor, 0);
-    }
-
-    template <typename V>
-    void fill_zero(V &&tensor)
-    {
-        library->fill_tensor_uniform(tensor, 0, static_cast<U>(0), static_cast<U>(0));
-    }
-
-    std::pair<TensorType, TensorType> compute_target(const TensorShape &shape, BorderMode border_mode, Format format, uint8_t constant_border_value, GradientDimension gradient_dimension)
-    {
-        // Create tensors
-        TensorType src   = create_tensor<TensorType>(shape, data_type_from_format(format));
-        TensorType dst_x = create_tensor<TensorType>(shape, data_type_from_format(Format::S16));
-        TensorType dst_y = create_tensor<TensorType>(shape, data_type_from_format(Format::S16));
-
-        src.info()->set_format(format);
-        dst_x.info()->set_format(Format::S16);
-        dst_y.info()->set_format(Format::S16);
-
-        FunctionType derivative;
-
-        switch(gradient_dimension)
-        {
-            case GradientDimension::GRAD_X:
-                derivative.configure(&src, &dst_x, nullptr, border_mode, constant_border_value);
-                break;
-            case GradientDimension::GRAD_Y:
-                derivative.configure(&src, nullptr, &dst_y, border_mode, constant_border_value);
-                break;
-            case GradientDimension::GRAD_XY:
-                derivative.configure(&src, &dst_x, &dst_y, border_mode, constant_border_value);
-                break;
-            default:
-                ARM_COMPUTE_ERROR("Gradient dimension not supported");
-        }
-
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst_x.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst_y.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        dst_x.allocator()->allocate();
-        dst_y.allocator()->allocate();
-
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst_x.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst_y.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(src));
-        fill_zero(AccessorType(dst_x));
-        fill_zero(AccessorType(dst_y));
-
-        // Compute function
-        derivative.run();
-
-        return std::make_pair(std::move(dst_x), std::move(dst_y));
-    }
-
-    std::pair<SimpleTensor<U>, SimpleTensor<U>> compute_reference(const TensorShape &shape, BorderMode border_mode, Format format, uint8_t constant_border_value, GradientDimension gradient_dimension)
-    {
-        // Create reference
-        SimpleTensor<T> src{ shape, format };
-
-        // Fill reference
-        fill(src);
-
-        return reference::derivative<U>(src, border_mode, constant_border_value, gradient_dimension);
-    }
-
-    BorderMode _border_mode{ BorderMode::UNDEFINED };
-    std::pair<TensorType, TensorType>           _target{};
-    std::pair<SimpleTensor<U>, SimpleTensor<U>> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_DERIVATIVE_FIXTURE */
diff --git a/tests/validation/fixtures/DilateFixture.h b/tests/validation/fixtures/DilateFixture.h
deleted file mode 100644
index 51ed4df2d3..0000000000
--- a/tests/validation/fixtures/DilateFixture.h
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * Copyright (c) 2017 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_DILATE_FIXTURE
-#define ARM_COMPUTE_TEST_DILATE_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/Dilate.h"
-
-#include <random>
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T>
-class DilateValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, DataType data_type, BorderMode border_mode)
-    {
-        std::mt19937                           gen(library->seed());
-        std::uniform_int_distribution<uint8_t> distribution(0, 255);
-        const uint8_t                          constant_border_value = distribution(gen);
-
-        _border_mode = border_mode;
-        _target      = compute_target(shape, data_type, border_mode, constant_border_value);
-        _reference   = compute_reference(shape, data_type, border_mode, constant_border_value);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor)
-    {
-        library->fill_tensor_uniform(tensor, 0);
-    }
-
-    TensorType compute_target(const TensorShape &shape, DataType data_type, BorderMode border_mode, uint8_t constant_border_value)
-    {
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(shape, data_type);
-        TensorType dst = create_tensor<TensorType>(shape, data_type);
-
-        // Create and configure function
-        FunctionType dilate;
-        dilate.configure(&src, &dst, border_mode, constant_border_value);
-
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        dst.allocator()->allocate();
-
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(src));
-
-        // Compute function
-        dilate.run();
-
-        return dst;
-    }
-
-    SimpleTensor<T> compute_reference(const TensorShape &shape, DataType data_type, BorderMode border_mode, uint8_t constant_border_value)
-    {
-        ARM_COMPUTE_ERROR_ON(data_type != DataType::U8);
-
-        // Create reference
-        SimpleTensor<T> src{ shape, data_type };
-
-        // Fill reference
-        fill(src);
-
-        // Compute reference
-        return reference::dilate<T>(src, border_mode, constant_border_value);
-    }
-
-    BorderMode      _border_mode{};
-    TensorType      _target{};
-    SimpleTensor<T> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_DILATE_FIXTURE */
diff --git a/tests/validation/fixtures/EqualizeHistogramFixture.h b/tests/validation/fixtures/EqualizeHistogramFixture.h
deleted file mode 100644
index f7a0312747..0000000000
--- a/tests/validation/fixtures/EqualizeHistogramFixture.h
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- * Copyright (c) 2017-2018 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_EQUALIZE_HISTOGRAM_FIXTURE
-#define ARM_COMPUTE_TEST_EQUALIZE_HISTOGRAM_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/EqualizeHistogram.h"
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T>
-class EqualizeHistogramValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, DataType data_type)
-    {
-        _target    = compute_target(shape, data_type);
-        _reference = compute_reference(shape, data_type);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor)
-    {
-        library->fill_tensor_uniform(tensor, 0);
-    }
-
-    TensorType compute_target(const TensorShape &shape, DataType data_type)
-    {
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(shape, data_type);
-        TensorType dst = create_tensor<TensorType>(shape, data_type);
-
-        // Create and configure function
-        FunctionType equalize_histogram;
-
-        equalize_histogram.configure(&src, &dst);
-
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        dst.allocator()->allocate();
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(src));
-
-        // Compute function
-        equalize_histogram.run();
-
-        return dst;
-    }
-
-    SimpleTensor<T> compute_reference(const TensorShape &shape, DataType data_type)
-    {
-        // Create reference
-        SimpleTensor<T> src{ shape, data_type };
-
-        // Fill reference
-        fill(src);
-
-        return reference::equalize_histogram<T>(src);
-    }
-
-    TensorType      _target{};
-    SimpleTensor<T> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_EQUALIZE_HISTOGRAM_FIXTURE */
diff --git a/tests/validation/fixtures/ErodeFixture.h b/tests/validation/fixtures/ErodeFixture.h
deleted file mode 100644
index b9f17a266a..0000000000
--- a/tests/validation/fixtures/ErodeFixture.h
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * Copyright (c) 2017 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_ERODE_FIXTURE
-#define ARM_COMPUTE_TEST_ERODE_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/Erode.h"
-
-#include <random>
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T>
-class ErodeValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, DataType data_type, BorderMode border_mode)
-    {
-        std::mt19937                           gen(library->seed());
-        std::uniform_int_distribution<uint8_t> distribution(0, 255);
-        const uint8_t                          constant_border_value = distribution(gen);
-
-        _border_mode = border_mode;
-        _target      = compute_target(shape, data_type, border_mode, constant_border_value);
-        _reference   = compute_reference(shape, data_type, border_mode, constant_border_value);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor)
-    {
-        library->fill_tensor_uniform(tensor, 0);
-    }
-
-    TensorType compute_target(const TensorShape &shape, DataType data_type, BorderMode border_mode, uint8_t constant_border_value)
-    {
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(shape, data_type);
-        TensorType dst = create_tensor<TensorType>(shape, data_type);
-
-        // Create and configure function
-        FunctionType erode;
-        erode.configure(&src, &dst, border_mode, constant_border_value);
-
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        dst.allocator()->allocate();
-
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(src));
-
-        // Compute function
-        erode.run();
-
-        return dst;
-    }
-
-    SimpleTensor<T> compute_reference(const TensorShape &shape, DataType data_type, BorderMode border_mode, uint8_t constant_border_value)
-    {
-        ARM_COMPUTE_ERROR_ON(data_type != DataType::U8);
-
-        // Create reference
-        SimpleTensor<T> src{ shape, data_type };
-
-        // Fill reference
-        fill(src);
-
-        // Compute reference
-        return reference::erode<T>(src, border_mode, constant_border_value);
-    }
-
-    BorderMode      _border_mode{};
-    TensorType      _target{};
-    SimpleTensor<T> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_ERODE_FIXTURE */
diff --git a/tests/validation/fixtures/FastCornersFixture.h b/tests/validation/fixtures/FastCornersFixture.h
deleted file mode 100644
index ae66c375ef..0000000000
--- a/tests/validation/fixtures/FastCornersFixture.h
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- * Copyright (c) 2017-2018 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_FAST_CORNERS_FIXTURE
-#define ARM_COMPUTE_TEST_FAST_CORNERS_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/FastCorners.h"
-
-#include <random>
-
-namespace arm_compute
-{
-class CLFastCorners;
-class NEFastCorners;
-
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename ArrayType, typename FunctionType, typename T>
-class FastCornersValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(std::string image, Format format, bool suppress_nonmax, BorderMode border_mode)
-    {
-        std::mt19937                           gen(library->seed());
-        std::uniform_int_distribution<uint8_t> int_dist(0, 255);
-        std::uniform_real_distribution<float>  real_dist(0, 255);
-
-        const uint8_t constant_border_value = int_dist(gen);
-        const float   threshold             = real_dist(gen);
-
-        _target    = compute_target(image, format, threshold, suppress_nonmax, border_mode, constant_border_value);
-        _reference = compute_reference(image, format, threshold, suppress_nonmax, border_mode, constant_border_value);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor, RawTensor raw)
-    {
-        library->fill(tensor, raw);
-    }
-
-    template <typename F, typename std::enable_if<std::is_same<F, CLFastCorners>::value, int>::type = 0>
-    void configure_target(F &func, TensorType &src, ArrayType &corners, unsigned int *num_corners, float threshold, bool suppress_nonmax, BorderMode border_mode, uint8_t constant_border_value)
-    {
-        func.configure(&src, threshold, suppress_nonmax, &corners, num_corners, border_mode, constant_border_value);
-    }
-
-    template <typename F, typename std::enable_if<std::is_same<F, NEFastCorners>::value, int>::type = 0>
-    void configure_target(F &func, TensorType &src, ArrayType &corners, unsigned int *num_corners, float threshold, bool suppress_nonmax, BorderMode border_mode, uint8_t constant_border_value)
-    {
-        ARM_COMPUTE_UNUSED(num_corners);
-        func.configure(&src, threshold, suppress_nonmax, &corners, border_mode, constant_border_value);
-    }
-
-    ArrayType compute_target(const std::string &image, Format format, float threshold, bool suppress_nonmax, BorderMode border_mode, uint8_t constant_border_value)
-    {
-        // Load the image (cached by the library if loaded before)
-        const RawTensor &raw = library->get(image, format);
-
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(raw.shape(), format);
-
-        // Create array of keypoints
-        ArrayType    corners(raw.shape().total_size());
-        unsigned int num_corners = raw.shape().total_size();
-
-        // Create and configure function
-        FunctionType fast_corners;
-        configure_target<FunctionType>(fast_corners, src, corners, &num_corners, threshold, suppress_nonmax, border_mode, constant_border_value);
-
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(src), raw);
-
-        // Compute function
-        fast_corners.run();
-
-        return corners;
-    }
-
-    std::vector<KeyPoint> compute_reference(const std::string &image, Format format, float threshold, bool suppress_nonmax, BorderMode border_mode, uint8_t constant_border_value)
-    {
-        // Load the image (cached by the library if loaded before)
-        const RawTensor &raw = library->get(image, format);
-
-        // Create reference
-        SimpleTensor<T> src{ raw.shape(), format };
-
-        // Fill reference
-        fill(src, raw);
-
-        // Compute reference
-        return reference::fast_corners<T>(src, threshold, suppress_nonmax, border_mode, constant_border_value);
-    }
-
-    ArrayType             _target{};
-    std::vector<KeyPoint> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_FAST_CORNERS_FIXTURE */
diff --git a/tests/validation/fixtures/Gaussian3x3Fixture.h b/tests/validation/fixtures/Gaussian3x3Fixture.h
deleted file mode 100644
index 4a154ea0d1..0000000000
--- a/tests/validation/fixtures/Gaussian3x3Fixture.h
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * Copyright (c) 2017 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_GAUSSIAN3X3_FIXTURE
-#define ARM_COMPUTE_TEST_GAUSSIAN3X3_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/Gaussian3x3.h"
-
-#include <random>
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T>
-class Gaussian3x3ValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, DataType data_type, BorderMode border_mode)
-    {
-        std::mt19937                           gen(library->seed());
-        std::uniform_int_distribution<uint8_t> distribution(0, 255);
-        const uint8_t                          constant_border_value = distribution(gen);
-
-        _border_mode = border_mode;
-        _target      = compute_target(shape, data_type, border_mode, constant_border_value);
-        _reference   = compute_reference(shape, data_type, border_mode, constant_border_value);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor)
-    {
-        library->fill_tensor_uniform(tensor, 0);
-    }
-
-    TensorType compute_target(const TensorShape &shape, DataType data_type, BorderMode border_mode, uint8_t constant_border_value)
-    {
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(shape, data_type);
-        TensorType dst = create_tensor<TensorType>(shape, data_type);
-
-        // Create and configure function
-        FunctionType gaussian3x3;
-        gaussian3x3.configure(&src, &dst, border_mode, constant_border_value);
-
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        dst.allocator()->allocate();
-
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(src));
-
-        // Compute function
-        gaussian3x3.run();
-
-        return dst;
-    }
-
-    SimpleTensor<T> compute_reference(const TensorShape &shape, DataType data_type, BorderMode border_mode, uint8_t constant_border_value)
-    {
-        ARM_COMPUTE_ERROR_ON(data_type != DataType::U8);
-
-        // Create reference
-        SimpleTensor<T> src{ shape, data_type };
-
-        // Fill reference
-        fill(src);
-
-        // Compute reference
-        return reference::gaussian3x3<T>(src, border_mode, constant_border_value);
-    }
-
-    BorderMode      _border_mode{};
-    TensorType      _target{};
-    SimpleTensor<T> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_GAUSSIAN3X3_FIXTURE */
diff --git a/tests/validation/fixtures/Gaussian5x5Fixture.h b/tests/validation/fixtures/Gaussian5x5Fixture.h
deleted file mode 100644
index 68f91e1656..0000000000
--- a/tests/validation/fixtures/Gaussian5x5Fixture.h
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * Copyright (c) 2017 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_GAUSSIAN5X5_FIXTURE
-#define ARM_COMPUTE_TEST_GAUSSIAN5X5_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/Gaussian5x5.h"
-
-#include <random>
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T>
-class Gaussian5x5ValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, DataType data_type, BorderMode border_mode)
-    {
-        std::mt19937                           gen(library->seed());
-        std::uniform_int_distribution<uint8_t> distribution(0, 255);
-        const uint8_t                          constant_border_value = distribution(gen);
-
-        _border_mode = border_mode;
-        _target      = compute_target(shape, data_type, border_mode, constant_border_value);
-        _reference   = compute_reference(shape, data_type, border_mode, constant_border_value);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor)
-    {
-        library->fill_tensor_uniform(tensor, 0);
-    }
-
-    TensorType compute_target(const TensorShape &shape, DataType data_type, BorderMode border_mode, uint8_t constant_border_value)
-    {
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(shape, data_type);
-        TensorType dst = create_tensor<TensorType>(shape, data_type);
-
-        // Create and configure function
-        FunctionType gaussian5x5;
-        gaussian5x5.configure(&src, &dst, border_mode, constant_border_value);
-
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        dst.allocator()->allocate();
-
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(src));
-
-        // Compute function
-        gaussian5x5.run();
-
-        return dst;
-    }
-
-    SimpleTensor<T> compute_reference(const TensorShape &shape, DataType data_type, BorderMode border_mode, uint8_t constant_border_value)
-    {
-        ARM_COMPUTE_ERROR_ON(data_type != DataType::U8);
-
-        // Create reference
-        SimpleTensor<T> src{ shape, data_type };
-
-        // Fill reference
-        fill(src);
-
-        // Compute reference
-        return reference::gaussian5x5<T>(src, border_mode, constant_border_value);
-    }
-
-    BorderMode      _border_mode{};
-    TensorType      _target{};
-    SimpleTensor<T> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_GAUSSIAN5X5_FIXTURE */
diff --git a/tests/validation/fixtures/GaussianPyramidHalfFixture.h b/tests/validation/fixtures/GaussianPyramidHalfFixture.h
deleted file mode 100644
index f91b1d520d..0000000000
--- a/tests/validation/fixtures/GaussianPyramidHalfFixture.h
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
- * Copyright (c) 2017 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_GAUSSIAN_PYRAMID_HALF_FIXTURE
-#define ARM_COMPUTE_TEST_GAUSSIAN_PYRAMID_HALF_FIXTURE
-
-#include "arm_compute/core/IPyramid.h"
-#include "arm_compute/core/PyramidInfo.h"
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/GaussianPyramidHalf.h"
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T, typename PyramidType>
-class GaussianPyramidHalfValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, BorderMode border_mode, size_t num_levels)
-    {
-        std::mt19937                           gen(library->seed());
-        std::uniform_int_distribution<uint8_t> distribution(0, 255);
-        const uint8_t                          constant_border_value = distribution(gen);
-
-        _border_mode = border_mode;
-
-        // Compute target and reference
-        compute_target(shape, border_mode, constant_border_value, num_levels);
-        compute_reference(shape, border_mode, constant_border_value, num_levels);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor)
-    {
-        library->fill_tensor_uniform(tensor, 0);
-    }
-
-    void compute_target(const TensorShape &shape, BorderMode border_mode, uint8_t constant_border_value, size_t num_levels)
-    {
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(shape, DataType::U8);
-
-        PyramidInfo pyramid_info(num_levels, SCALE_PYRAMID_HALF, shape, Format::U8);
-        _target.init(pyramid_info);
-
-        // Create and configure function
-        FunctionType gaussian_pyramid;
-
-        gaussian_pyramid.configure(&src, &_target, border_mode, constant_border_value);
-
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        for(size_t i = 0; i < pyramid_info.num_levels(); ++i)
-        {
-            ARM_COMPUTE_EXPECT(_target.get_pyramid_level(i)->info()->is_resizable(), framework::LogLevel::ERRORS);
-        }
-
-        // Allocate input tensor
-        src.allocator()->allocate();
-
-        // Allocate pyramid
-        _target.allocate();
-
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        for(size_t i = 0; i < pyramid_info.num_levels(); ++i)
-        {
-            ARM_COMPUTE_EXPECT(!_target.get_pyramid_level(i)->info()->is_resizable(), framework::LogLevel::ERRORS);
-        }
-
-        // Fill tensors
-        fill(AccessorType(src));
-
-        // Compute function
-        gaussian_pyramid.run();
-    }
-
-    void compute_reference(const TensorShape &shape, BorderMode border_mode, uint8_t constant_border_value, size_t num_levels)
-    {
-        // Create reference
-        SimpleTensor<T> src{ shape, DataType::U8 };
-
-        // Fill reference
-        fill(src);
-
-        _reference = reference::gaussian_pyramid_half<T>(src, border_mode, constant_border_value, num_levels);
-    }
-
-    PyramidType                  _target{};
-    std::vector<SimpleTensor<T>> _reference{};
-    BorderMode                   _border_mode{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_GAUSSIAN_PYRAMID_HALF_FIXTURE */
\ No newline at end of file
diff --git a/tests/validation/fixtures/HOGDescriptorFixture.h b/tests/validation/fixtures/HOGDescriptorFixture.h
deleted file mode 100644
index 1021e12d72..0000000000
--- a/tests/validation/fixtures/HOGDescriptorFixture.h
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * Copyright (c) 2017-2018 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_HOG_DESCRIPTOR_FIXTURE
-#define ARM_COMPUTE_TEST_HOG_DESCRIPTOR_FIXTURE
-
-#include "arm_compute/core/HOGInfo.h"
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/HOGDescriptor.h"
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename HOGType, typename AccessorType, typename FunctionType, typename T, typename U>
-class HOGDescriptorValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(std::string image, HOGInfo hog_info, Format format, BorderMode border_mode)
-    {
-        // Only defined borders supported
-        ARM_COMPUTE_ERROR_ON(border_mode == BorderMode::UNDEFINED);
-
-        // Generate a random constant value
-        std::mt19937                     gen(library->seed());
-        std::uniform_int_distribution<T> int_dist(0, 255);
-        const T                          constant_border_value = int_dist(gen);
-
-        _target    = compute_target(image, format, border_mode, constant_border_value, hog_info);
-        _reference = compute_reference(image, format, border_mode, constant_border_value, hog_info);
-    }
-
-protected:
-    template <typename V>
-    void fill(V &&tensor, const std::string image, Format format)
-    {
-        library->fill(tensor, image, format);
-    }
-
-    template <typename V, typename D>
-    void fill(V &&tensor, int i, D max)
-    {
-        library->fill_tensor_uniform(tensor, i, static_cast<D>(0), max);
-    }
-
-    TensorType compute_target(const std::string image, Format &format, BorderMode &border_mode, T constant_border_value, const HOGInfo &hog_info)
-    {
-        // Get image shape for src tensor
-        TensorShape shape = library->get_image_shape(image);
-
-        // Create tensor info for HOG descriptor
-        TensorInfo tensor_info_hog_descriptor(hog_info, shape.x(), shape.y());
-
-        // Create HOG
-        HOGType hog = create_HOG<HOGType>(hog_info);
-
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(shape, data_type_from_format(format));
-        TensorType dst = create_tensor<TensorType>(tensor_info_hog_descriptor.tensor_shape(), DataType::F32, tensor_info_hog_descriptor.num_channels());
-
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Create and configure function
-        FunctionType hog_descriptor;
-        hog_descriptor.configure(&src, &dst, &hog, border_mode, constant_border_value);
-
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        dst.allocator()->allocate();
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        const T max = std::numeric_limits<T>::max();
-
-        // Fill tensors
-        fill(AccessorType(src), image, format);
-        fill(AccessorType(dst), 1, static_cast<U>(max));
-
-        // Compute function
-        hog_descriptor.run();
-
-        return dst;
-    }
-
-    SimpleTensor<U> compute_reference(const std::string image, Format format, BorderMode border_mode, T constant_border_value, const HOGInfo &hog_info)
-    {
-        // Create reference
-        SimpleTensor<T> src{ library->get_image_shape(image), data_type_from_format(format) };
-
-        // Fill reference
-        fill(src, image, format);
-
-        return reference::hog_descriptor<U>(src, border_mode, constant_border_value, hog_info);
-    }
-
-    TensorType      _target{};
-    SimpleTensor<U> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_HOG_DESCRIPTOR_FIXTURE */
diff --git a/tests/validation/fixtures/HOGDetectorFixture.h b/tests/validation/fixtures/HOGDetectorFixture.h
deleted file mode 100644
index f12e65b75c..0000000000
--- a/tests/validation/fixtures/HOGDetectorFixture.h
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- * Copyright (c) 2018 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_HOG_DETECTOR_FIXTURE
-#define ARM_COMPUTE_TEST_HOG_DETECTOR_FIXTURE
-
-#include "arm_compute/core/HOGInfo.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/IHOGAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/fixtures/HOGDescriptorFixture.h"
-#include "tests/validation/reference/HOGDetector.h"
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType,
-          typename HOGType,
-          typename DetectionWindowArrayType,
-          typename HOGDescriptorType,
-          typename AccessorType,
-          typename ArrayAccessorType,
-          typename HOGAccessorType,
-          typename HOGDetectorType,
-          typename T,
-          typename U>
-class HOGDetectorValidationFixture : public HOGDescriptorValidationFixture<TensorType, HOGType, AccessorType, HOGDescriptorType, T, U>
-{
-public:
-    template <typename...>
-    void setup(Size2D detection_window_stride, std::string image, HOGInfo hog_info, Format format, BorderMode border_mode)
-    {
-        using HDF = HOGDescriptorValidationFixture<TensorType, HOGType, AccessorType, HOGDescriptorType, T, U>;
-        HDF::setup(image, hog_info, format, border_mode);
-
-        const unsigned int max_num_detection_windows = 100000;
-
-        // Initialise descriptor (linear SVM coefficients).
-        // NOTE: Fixed values are used to keep the number of detection windows detected
-        // consistent in order to have meaningful validation tolerances.
-        // The values are "unbalanced" to reduce the number of detected objects
-        std::random_device::result_type seed       = 0;
-        std::vector<U>                  descriptor = generate_random_real(hog_info.descriptor_size(), -0.505f, 0.495f, seed);
-
-        // Compute target and reference values using feature vector from descriptor kernel
-        _target    = compute_target(HDF::_target, descriptor, max_num_detection_windows, hog_info, detection_window_stride);
-        _reference = compute_reference(HDF::_reference, descriptor, max_num_detection_windows, hog_info, detection_window_stride);
-    }
-
-protected:
-    std::vector<DetectionWindow> compute_target(const TensorType &src, const std::vector<U> &descriptor, unsigned int max_num_detection_windows,
-                                                const HOGInfo &hog_info, const Size2D &detection_window_stride)
-    {
-        // Create HOG
-        HOGType hog = create_HOG<HOGType>(hog_info);
-
-        // Create array of detection windows
-        DetectionWindowArrayType detection_windows(max_num_detection_windows);
-
-        // Copy HOG descriptor values to HOG memory
-        {
-            HOGAccessorType hog_accessor(hog);
-            std::memcpy(hog_accessor.descriptor(), descriptor.data(), descriptor.size() * sizeof(U));
-        }
-
-        // Create and configure function
-        HOGDetectorType hog_detector;
-        hog_detector.configure(&src, &hog, &detection_windows, detection_window_stride);
-
-        // Reset detection windows
-        detection_windows.clear();
-
-        // Compute function
-        hog_detector.run();
-
-        // Create array of detection windows
-        std::vector<DetectionWindow> windows;
-
-        // Copy detection windows
-        ArrayAccessorType accessor(detection_windows);
-
-        for(size_t i = 0; i < accessor.num_values(); i++)
-        {
-            DetectionWindow win;
-            win.x         = accessor.at(i).x;
-            win.y         = accessor.at(i).y;
-            win.width     = accessor.at(i).width;
-            win.height    = accessor.at(i).height;
-            win.idx_class = accessor.at(i).idx_class;
-            win.score     = accessor.at(i).score;
-
-            windows.push_back(win);
-        }
-
-        return windows;
-    }
-
-    std::vector<DetectionWindow> compute_reference(const SimpleTensor<U> &src, const std::vector<U> &descriptor, unsigned int max_num_detection_windows,
-                                                   const HOGInfo &hog_info, const Size2D &detection_window_stride)
-    {
-        // Assumes defaults value of zero for threshold and class_idx.
-        return reference::hog_detector(src, descriptor, max_num_detection_windows, hog_info, detection_window_stride);
-    }
-
-    std::vector<DetectionWindow> _target{};
-    std::vector<DetectionWindow> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_HOG_DETECTOR_FIXTURE */
diff --git a/tests/validation/fixtures/HOGMultiDetectionFixture.h b/tests/validation/fixtures/HOGMultiDetectionFixture.h
deleted file mode 100644
index c37bdb6df6..0000000000
--- a/tests/validation/fixtures/HOGMultiDetectionFixture.h
+++ /dev/null
@@ -1,193 +0,0 @@
-/*
- * Copyright (c) 2018 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_HOG_MULTI_DETECTION_FIXTURE
-#define ARM_COMPUTE_TEST_HOG_MULTI_DETECTION_FIXTURE
-
-#include "arm_compute/core/HOGInfo.h"
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/IHOGAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/HOGMultiDetection.h"
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType,
-          typename HOGType,
-          typename MultiHOGType,
-          typename DetectionWindowArrayType,
-          typename DetectionWindowStrideType,
-          typename AccessorType,
-          typename Size2DArrayAccessorType,
-          typename DetectionWindowArrayAccessorType,
-          typename HOGAccessorType,
-          typename FunctionType,
-          typename T,
-          typename U>
-class HOGMultiDetectionValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(std::string image, std::vector<HOGInfo> models, Format format, BorderMode border_mode, bool non_maxima_suppression)
-    {
-        // Only defined borders supported
-        ARM_COMPUTE_ERROR_ON(border_mode == BorderMode::UNDEFINED);
-
-        // Generate a random constant value
-        std::mt19937                     gen(library->seed());
-        std::uniform_int_distribution<T> int_dist(0, 255);
-        const T                          constant_border_value = int_dist(gen);
-
-        // Initialize descriptors vector
-        std::vector<std::vector<U>> descriptors(models.size());
-
-        // Use default values for threshold and min_distance
-        const float threshold    = 0.f;
-        const float min_distance = 1.f;
-
-        // Maximum number of detection windows per batch
-        const unsigned int max_num_detection_windows = 100000;
-
-        _target    = compute_target(image, format, border_mode, constant_border_value, models, descriptors, max_num_detection_windows, threshold, non_maxima_suppression, min_distance);
-        _reference = compute_reference(image, format, border_mode, constant_border_value, models, descriptors, max_num_detection_windows, threshold, non_maxima_suppression, min_distance);
-    }
-
-protected:
-    template <typename V>
-    void fill(V &&tensor, const std::string image, Format format)
-    {
-        library->fill(tensor, image, format);
-    }
-
-    void initialize_batch(const std::vector<HOGInfo> &models, MultiHOGType &multi_hog,
-                          std::vector<std::vector<U>> &descriptors, DetectionWindowStrideType &detection_window_strides)
-    {
-        for(unsigned i = 0; i < models.size(); ++i)
-        {
-            auto hog_model = reinterpret_cast<HOGType *>(multi_hog.model(i));
-            hog_model->init(models[i]);
-
-            // Initialise descriptor (linear SVM coefficients).
-            std::random_device::result_type seed = 0;
-            descriptors.at(i)                    = generate_random_real(models[i].descriptor_size(), -0.505f, 0.495f, seed);
-
-            // Copy HOG descriptor values to HOG memory
-            {
-                HOGAccessorType hog_accessor(*hog_model);
-                std::memcpy(hog_accessor.descriptor(), descriptors.at(i).data(), descriptors.at(i).size() * sizeof(U));
-            }
-
-            // Initialize detection window stride
-            Size2DArrayAccessorType accessor(detection_window_strides);
-            accessor.at(i) = models[i].block_stride();
-        }
-    }
-
-    std::vector<DetectionWindow> compute_target(const std::string image, Format &format, BorderMode &border_mode, T constant_border_value,
-                                                const std::vector<HOGInfo> &models, std::vector<std::vector<U>> &descriptors, unsigned int max_num_detection_windows,
-                                                float threshold, bool non_max_suppression, float min_distance)
-    {
-        MultiHOGType              multi_hog(models.size());
-        DetectionWindowArrayType  detection_windows(max_num_detection_windows);
-        DetectionWindowStrideType detection_window_strides(models.size());
-
-        // Resize detection window_strides for index access
-        detection_window_strides.resize(models.size());
-
-        // Initialiize MultiHOG and detection windows
-        initialize_batch(models, multi_hog, descriptors, detection_window_strides);
-
-        // Get image shape for src tensor
-        TensorShape shape = library->get_image_shape(image);
-
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(shape, data_type_from_format(format));
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Create and configure function
-        FunctionType hog_multi_detection;
-        hog_multi_detection.configure(&src, &multi_hog, &detection_windows, &detection_window_strides, border_mode, constant_border_value, threshold, non_max_suppression, min_distance);
-
-        // Reset detection windows
-        detection_windows.clear();
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(src), image, format);
-
-        // Compute function
-        hog_multi_detection.run();
-
-        // Copy detection windows
-        std::vector<DetectionWindow>     windows;
-        DetectionWindowArrayAccessorType accessor(detection_windows);
-
-        for(size_t i = 0; i < accessor.num_values(); i++)
-        {
-            DetectionWindow win;
-            win.x         = accessor.at(i).x;
-            win.y         = accessor.at(i).y;
-            win.width     = accessor.at(i).width;
-            win.height    = accessor.at(i).height;
-            win.idx_class = accessor.at(i).idx_class;
-            win.score     = accessor.at(i).score;
-
-            windows.push_back(win);
-        }
-
-        return windows;
-    }
-
-    std::vector<DetectionWindow> compute_reference(const std::string image, Format format, BorderMode border_mode, T constant_border_value,
-                                                   const std::vector<HOGInfo> &models, const std::vector<std::vector<U>> &descriptors, unsigned int max_num_detection_windows,
-                                                   float threshold, bool non_max_suppression, float min_distance)
-    {
-        // Create reference
-        SimpleTensor<T> src{ library->get_image_shape(image), data_type_from_format(format) };
-
-        // Fill reference
-        fill(src, image, format);
-
-        // NOTE: Detection window stride fixed to block stride
-        return reference::hog_multi_detection(src, border_mode, constant_border_value, models, descriptors, max_num_detection_windows, threshold, non_max_suppression, min_distance);
-    }
-
-    std::vector<DetectionWindow> _target{};
-    std::vector<DetectionWindow> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_HOG_MULTI_DETECTION_FIXTURE */
diff --git a/tests/validation/fixtures/HarrisCornersFixture.h b/tests/validation/fixtures/HarrisCornersFixture.h
deleted file mode 100644
index dbe77dde9c..0000000000
--- a/tests/validation/fixtures/HarrisCornersFixture.h
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
- * Copyright (c) 2017-2018 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_HARRIS_CORNERS_FIXTURE
-#define ARM_COMPUTE_TEST_HARRIS_CORNERS_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/Helpers.h"
-#include "tests/validation/reference/HarrisCornerDetector.h"
-
-namespace arm_compute
-{
-class CLHarrisCorners;
-class NEHarrisCorners;
-
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename ArrayType, typename FunctionType, typename T>
-class HarrisCornersValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    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, format, params);
-        _reference = compute_reference(image, gradient_size, block_size, border_mode, format, params);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor, RawTensor raw)
-    {
-        library->fill(tensor, raw);
-    }
-
-    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);
-
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(raw.shape(), format);
-
-        // Create array of keypoints
-        ArrayType corners(raw.shape().total_size());
-
-        // Create harris corners configure function
-        FunctionType harris_corners;
-        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);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(src), raw);
-
-        // Compute function
-        harris_corners.run();
-
-        return corners;
-    }
-
-    std::vector<KeyPoint> compute_reference(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);
-        // Create reference
-        SimpleTensor<T> src{ raw.shape(), format };
-
-        // Fill reference
-        fill(src, raw);
-
-        return reference::harris_corner_detector<T>(src, params.threshold, params.min_dist, params.sensitivity, gradient_size, block_size, border_mode, params.constant_border_value);
-    }
-
-    ArrayType             _target{};
-    std::vector<KeyPoint> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_HARRIS_CORNERS_FIXTURE */
diff --git a/tests/validation/fixtures/HistogramFixture.h b/tests/validation/fixtures/HistogramFixture.h
deleted file mode 100644
index dceb23b904..0000000000
--- a/tests/validation/fixtures/HistogramFixture.h
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * Copyright (c) 2017 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_HISTOGRAM_FIXTURE
-#define ARM_COMPUTE_TEST_HISTOGRAM_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/Histogram.h"
-#include "utils/Utils.h"
-
-#include <random>
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T, typename DistributionType>
-class HistogramValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, DataType data_type)
-    {
-        std::mt19937                            gen(library->seed());
-        std::uniform_int_distribution<size_t>   distribution_size_t(1, 30);
-        const size_t                            num_bins = distribution_size_t(gen);
-        std::uniform_int_distribution<int32_t>  distribution_int32_t(0, 125);
-        const size_t                            offset = distribution_int32_t(gen);
-        std::uniform_int_distribution<uint32_t> distribution_uint32_t(1, 255 - offset);
-        const size_t                            range = distribution_uint32_t(gen);
-
-        _target    = compute_target(shape, data_type, num_bins, offset, range);
-        _reference = compute_reference(shape, data_type, num_bins, offset, range);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor)
-    {
-        library->fill_tensor_uniform(tensor, 0);
-    }
-
-    TensorType compute_target(const TensorShape &shape, DataType data_type, size_t num_bins, int32_t offset, uint32_t range)
-    {
-        // Create tensors
-        TensorType       src = create_tensor<TensorType>(shape, data_type);
-        TensorType       dst = create_tensor<TensorType>(TensorShape(num_bins), DataType::U32);
-        DistributionType distribution_dst(num_bins, offset, range);
-
-        // Create and configure function
-        FunctionType histogram;
-        histogram.configure(&src, &distribution_dst);
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        dst.allocator()->allocate();
-
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(src));
-
-        // Compute function
-        histogram.run();
-
-        // Copy the distribution in a tensor
-        arm_compute::utils::map(distribution_dst, true);
-        AccessorType accessor_dst = AccessorType(dst);
-        uint32_t    *dst_data     = static_cast<uint32_t *>(accessor_dst.data());
-
-        ARM_COMPUTE_EXPECT(accessor_dst.size() <= dst.info()->total_size(), framework::LogLevel::ERRORS);
-
-        std::copy_n(distribution_dst.buffer(), num_bins, dst_data);
-        arm_compute::utils::unmap(distribution_dst);
-        return dst;
-    }
-
-    SimpleTensor<uint32_t> compute_reference(const TensorShape &shape, DataType data_type, size_t num_bins, int32_t offset, uint32_t range)
-    {
-        ARM_COMPUTE_ERROR_ON(data_type != DataType::U8);
-
-        // Create reference
-        SimpleTensor<T> src{ shape, data_type };
-
-        // Fill reference
-        fill(src);
-
-        // Compute reference
-        return reference::histogram<T>(src, num_bins, offset, range);
-    }
-
-    TensorType             _target{};
-    SimpleTensor<uint32_t> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_HISTOGRAM_FIXTURE */
diff --git a/tests/validation/fixtures/IntegralImageFixture.h b/tests/validation/fixtures/IntegralImageFixture.h
deleted file mode 100644
index abc99730a9..0000000000
--- a/tests/validation/fixtures/IntegralImageFixture.h
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- * Copyright (c) 2017 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_INTEGRAL_IMAGE_FIXTURE
-#define ARM_COMPUTE_TEST_INTEGRAL_IMAGE_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/IntegralImage.h"
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T>
-class IntegralImageValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, DataType data_type)
-    {
-        _target    = compute_target(shape);
-        _reference = compute_reference(shape, data_type);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor)
-    {
-        library->fill_tensor_uniform(tensor, 0);
-    }
-
-    TensorType compute_target(const TensorShape &shape)
-    {
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(shape, DataType::U8);
-        TensorType dst = create_tensor<TensorType>(shape, DataType::U32);
-
-        // Create and configure function
-        FunctionType integral_image;
-        integral_image.configure(&src, &dst);
-
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        dst.allocator()->allocate();
-
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(src));
-
-        // Compute function
-        integral_image.run();
-
-        return dst;
-    }
-
-    SimpleTensor<uint32_t> compute_reference(const TensorShape &shape, DataType data_type)
-    {
-        // Create reference
-        SimpleTensor<T> src{ shape, data_type };
-
-        // Fill reference
-        fill(src);
-
-        return reference::integral_image<T>(src);
-    }
-
-    TensorType             _target{};
-    SimpleTensor<uint32_t> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_INTEGRAL_IMAGE_FIXTURE */
diff --git a/tests/validation/fixtures/LaplacianPyramidFixture.h b/tests/validation/fixtures/LaplacianPyramidFixture.h
deleted file mode 100644
index 71319965b2..0000000000
--- a/tests/validation/fixtures/LaplacianPyramidFixture.h
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- * Copyright (c) 2018 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_LAPLACIAN_PYRAMID_FIXTURE
-#define ARM_COMPUTE_TEST_LAPLACIAN_PYRAMID_FIXTURE
-
-#include "arm_compute/core/IPyramid.h"
-#include "arm_compute/core/PyramidInfo.h"
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/LaplacianPyramid.h"
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T, typename U, typename PyramidType>
-class LaplacianPyramidValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape input_shape, BorderMode border_mode, size_t num_levels, Format format_in, Format format_out)
-    {
-        std::mt19937                     generator(library->seed());
-        std::uniform_int_distribution<T> distribution_u8(0, 255);
-        const T                          constant_border_value = distribution_u8(generator);
-
-        _pyramid_levels = num_levels;
-        _border_mode    = border_mode;
-
-        _target    = compute_target(input_shape, border_mode, constant_border_value, format_in, format_out);
-        _reference = compute_reference(input_shape, border_mode, constant_border_value, format_in, format_out);
-    }
-
-protected:
-    template <typename V>
-    void fill(V &&tensor)
-    {
-        library->fill_tensor_uniform(tensor, 0);
-    }
-
-    PyramidType compute_target(const TensorShape &input_shape, BorderMode border_mode, T constant_border_value,
-                               Format format_in, Format format_out)
-    {
-        // Create pyramid
-        PyramidType pyramid{};
-
-        // Create Pyramid Info
-        PyramidInfo pyramid_info(_pyramid_levels, SCALE_PYRAMID_HALF, input_shape, format_out);
-
-        // Use conservative padding strategy to fit all subsequent kernels
-        pyramid.init_auto_padding(pyramid_info);
-
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(input_shape, format_in);
-
-        // The first two dimensions of the output tensor must match the first
-        // two dimensions of the tensor in the last level of the pyramid
-        TensorShape dst_shape(input_shape);
-        dst_shape.set(0, pyramid.get_pyramid_level(_pyramid_levels - 1)->info()->dimension(0));
-        dst_shape.set(1, pyramid.get_pyramid_level(_pyramid_levels - 1)->info()->dimension(1));
-
-        // The lowest resolution tensor necessary to reconstruct the input
-        // tensor from the pyramid.
-        _dst_target = create_tensor<TensorType>(dst_shape, format_out);
-
-        // Create and configure function
-        FunctionType laplacian_pyramid;
-        laplacian_pyramid.configure(&src, &pyramid, &_dst_target, border_mode, constant_border_value);
-
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(_dst_target.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        _dst_target.allocator()->allocate();
-
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!_dst_target.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        pyramid.allocate();
-
-        for(size_t i = 0; i < pyramid_info.num_levels(); ++i)
-        {
-            ARM_COMPUTE_EXPECT(!pyramid.get_pyramid_level(i)->info()->is_resizable(), framework::LogLevel::ERRORS);
-        }
-
-        // Fill tensors
-        fill(AccessorType(src));
-
-        // Compute function
-        laplacian_pyramid.run();
-
-        return pyramid;
-    }
-
-    std::vector<SimpleTensor<U>> compute_reference(const TensorShape &shape, BorderMode border_mode, T constant_border_value,
-                                                   Format format_in, Format format_out)
-    {
-        // Create reference
-        SimpleTensor<T> src{ shape, format_in };
-
-        // The first two dimensions of the output tensor must match the first
-        // two dimensions of the tensor in the last level of the pyramid
-        TensorShape dst_shape(shape);
-        dst_shape.set(0, static_cast<float>(shape[0] + 1) / static_cast<float>(std::pow(2, _pyramid_levels - 1)));
-        dst_shape.set(1, static_cast<float>(shape[1] + 1) / static_cast<float>(std::pow(2, _pyramid_levels - 1)));
-
-        _dst_reference = SimpleTensor<U>(dst_shape, format_out);
-
-        // Fill reference
-        fill(src);
-
-        return reference::laplacian_pyramid<T, U>(src, _dst_reference, _pyramid_levels, border_mode, constant_border_value);
-    }
-
-    size_t                       _pyramid_levels{};
-    BorderMode                   _border_mode{};
-    SimpleTensor<U>              _dst_reference{};
-    TensorType                   _dst_target{};
-    PyramidType                  _target{};
-    std::vector<SimpleTensor<U>> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_LAPLACIAN_PYRAMID_FIXTURE */
diff --git a/tests/validation/fixtures/LaplacianReconstructFixture.h b/tests/validation/fixtures/LaplacianReconstructFixture.h
deleted file mode 100644
index 35432ee2cb..0000000000
--- a/tests/validation/fixtures/LaplacianReconstructFixture.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * Copyright (c) 2018 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_LAPLACIAN_RECONSTRUCT_FIXTURE
-#define ARM_COMPUTE_TEST_LAPLACIAN_RECONSTRUCT_FIXTURE
-
-#include "arm_compute/core/IPyramid.h"
-#include "arm_compute/core/PyramidInfo.h"
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/fixtures/LaplacianPyramidFixture.h"
-#include "tests/validation/reference/LaplacianPyramid.h"
-#include "tests/validation/reference/LaplacianReconstruct.h"
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename FunctionType, typename LaplacianPyramidType, typename T, typename U, typename PyramidType>
-class LaplacianReconstructValidationFixture : public LaplacianPyramidValidationFixture<TensorType, AccessorType, LaplacianPyramidType, U, T, PyramidType>
-{
-public:
-    template <typename...>
-    void setup(TensorShape input_shape, BorderMode border_mode, size_t num_levels, Format format_in, Format format_out)
-    {
-        std::mt19937                     generator(library->seed());
-        std::uniform_int_distribution<U> distribution_u8(0, 255);
-        const U                          constant_border_value = distribution_u8(generator);
-
-        using LPF = LaplacianPyramidValidationFixture<TensorType, AccessorType, LaplacianPyramidType, U, T, PyramidType>;
-        LPF::setup(input_shape, border_mode, num_levels, format_out, format_in);
-
-        // Compute target and reference values using the pyramid and lowest
-        // resolution tensor output from Laplacian Pyramid kernel
-        _target    = compute_target(input_shape, LPF::_target, LPF::_dst_target, border_mode, constant_border_value);
-        _reference = compute_reference(LPF::_reference, LPF::_dst_reference, border_mode, constant_border_value);
-    }
-
-protected:
-    template <typename V>
-    void fill(V &&tensor)
-    {
-        library->fill_tensor_uniform(tensor, 0);
-    }
-
-    TensorType compute_target(const TensorShape &input_shape, PyramidType &pyramid, TensorType &low_res, BorderMode border_mode, U constant_border_value)
-    {
-        // Create tensors
-        TensorType dst = create_tensor<TensorType>(input_shape, DataType::U8);
-
-        // Create and configure function
-        FunctionType laplacian_reconstruct;
-        laplacian_reconstruct.configure(&pyramid, &low_res, &dst, border_mode, constant_border_value);
-
-        // Allocate tensors
-        dst.allocator()->allocate();
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Compute function
-        laplacian_reconstruct.run();
-
-        return dst;
-    }
-
-    SimpleTensor<U> compute_reference(const std::vector<SimpleTensor<T>> &pyramid,
-                                      const SimpleTensor<T> &low_res, BorderMode border_mode, U constant_border_value)
-    {
-        return reference::laplacian_reconstruct<T, U>(pyramid, low_res, border_mode, constant_border_value);
-    }
-
-    TensorType      _target{};
-    SimpleTensor<U> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_LAPLACIAN_RECONSTRUCT_FIXTURE */
diff --git a/tests/validation/fixtures/MagnitudeFixture.h b/tests/validation/fixtures/MagnitudeFixture.h
deleted file mode 100644
index 81f4970b41..0000000000
--- a/tests/validation/fixtures/MagnitudeFixture.h
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * Copyright (c) 2017-2018 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_MAGNITUDE_FIXTURE
-#define ARM_COMPUTE_TEST_MAGNITUDE_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/Magnitude.h"
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T>
-class MagnitudeValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, Format format, MagnitudeType magnitude_type)
-    {
-        _target         = compute_target(shape, format, magnitude_type);
-        _reference      = compute_reference(shape, format, magnitude_type);
-        _magnitude_type = magnitude_type;
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor, std::random_device::result_type seed_offset)
-    {
-        library->fill_tensor_uniform(tensor, seed_offset);
-    }
-
-    TensorType compute_target(const TensorShape &shape, Format format, MagnitudeType magnitude_type)
-    {
-        DataType data_type = data_type_from_format(format);
-
-        // Create tensors
-        TensorType src1 = create_tensor<TensorType>(shape, data_type);
-        src1.info()->set_format(format);
-
-        TensorType src2 = create_tensor<TensorType>(shape, data_type);
-        src2.info()->set_format(format);
-
-        TensorType dst = create_tensor<TensorType>(shape, data_type);
-        dst.info()->set_format(format);
-
-        // Create and configure function
-        FunctionType magnitude;
-        magnitude.configure(&src1, &src2, &dst, magnitude_type);
-
-        ARM_COMPUTE_EXPECT(src1.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(src2.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src1.allocator()->allocate();
-        src2.allocator()->allocate();
-        dst.allocator()->allocate();
-
-        ARM_COMPUTE_EXPECT(!src1.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!src2.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(src1), 0);
-        fill(AccessorType(src2), 1);
-
-        // Compute function
-        magnitude.run();
-
-        return dst;
-    }
-
-    SimpleTensor<T> compute_reference(const TensorShape &shape, Format format, MagnitudeType magnitude_type)
-    {
-        DataType data_type = data_type_from_format(format);
-
-        // Create reference
-        SimpleTensor<T> src1{ shape, data_type };
-        SimpleTensor<T> src2{ shape, data_type };
-
-        // Fill reference
-        fill(src1, 0);
-        fill(src2, 1);
-
-        return reference::magnitude<T>(src1, src2, magnitude_type);
-    }
-
-    TensorType      _target{};
-    SimpleTensor<T> _reference{};
-    MagnitudeType   _magnitude_type{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_MAGNITUDE_FIXTURE */
diff --git a/tests/validation/fixtures/MeanStdDevFixture.h b/tests/validation/fixtures/MeanStdDevFixture.h
deleted file mode 100644
index f3facc50de..0000000000
--- a/tests/validation/fixtures/MeanStdDevFixture.h
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
- * Copyright (c) 2017-2021 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_MEAN_STD_DEV_FIXTURE
-#define ARM_COMPUTE_TEST_MEAN_STD_DEV_FIXTURE
-
-#include "tests/Globals.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/MeanStdDev.h"
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T>
-class MeanStdDevValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, DataType data_type)
-    {
-        _target    = compute_target(shape, data_type);
-        _reference = compute_reference(shape, data_type);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor)
-    {
-        if(tensor.data_type() == DataType::F32)
-        {
-            std::uniform_real_distribution<float> distribution(-1.0f, 1.0f);
-            library->fill(tensor, distribution, 0);
-        }
-        else if(tensor.data_type() == DataType::F16)
-        {
-            arm_compute::utils::uniform_real_distribution_16bit<half> distribution{ -1.0f, 1.0f };
-            library->fill(tensor, distribution, 0);
-        }
-        else
-        {
-            library->fill_tensor_uniform(tensor, 0);
-        }
-    }
-
-    std::pair<float, float> compute_target(const TensorShape &shape, DataType data_type)
-    {
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(shape, data_type);
-
-        // Create output variables
-        float mean    = 0.0f;
-        float std_dev = 0.0f;
-
-        // Create and configure function
-        FunctionType mean_std_dev;
-        mean_std_dev.configure(&src, &mean, &std_dev);
-
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(src));
-
-        // Compute function
-        mean_std_dev.run();
-
-        return std::make_pair(mean, std_dev);
-    }
-
-    std::pair<float, float> compute_reference(const TensorShape &shape, DataType data_type)
-    {
-        // Create reference
-        SimpleTensor<T> src{ shape, data_type };
-
-        // Fill reference
-        fill(src);
-
-        // Compute reference
-        return reference::mean_and_standard_deviation<T>(src);
-    }
-
-    std::pair<float, float> _target{};
-    std::pair<float, float> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_MEAN_STD_DEV_FIXTURE */
diff --git a/tests/validation/fixtures/Median3x3Fixture.h b/tests/validation/fixtures/Median3x3Fixture.h
deleted file mode 100644
index 2b978005b2..0000000000
--- a/tests/validation/fixtures/Median3x3Fixture.h
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * Copyright (c) 2017 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_MEDIAN3X3_FIXTURE
-#define ARM_COMPUTE_TEST_MEDIAN3X3_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/Median3x3.h"
-
-#include <random>
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T>
-class Median3x3ValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, DataType data_type, BorderMode border_mode)
-    {
-        std::mt19937                           gen(library->seed());
-        std::uniform_int_distribution<uint8_t> distribution(0, 255);
-        const uint8_t                          constant_border_value = distribution(gen);
-
-        _border_mode = border_mode;
-        _target      = compute_target(shape, data_type, border_mode, constant_border_value);
-        _reference   = compute_reference(shape, data_type, border_mode, constant_border_value);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor)
-    {
-        library->fill_tensor_uniform(tensor, 0);
-    }
-
-    TensorType compute_target(const TensorShape &shape, DataType data_type, BorderMode border_mode, uint8_t constant_border_value)
-    {
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(shape, data_type);
-        TensorType dst = create_tensor<TensorType>(shape, data_type);
-
-        // Create and configure function
-        FunctionType median3x3;
-        median3x3.configure(&src, &dst, border_mode, constant_border_value);
-
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        dst.allocator()->allocate();
-
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(src));
-
-        // Compute function
-        median3x3.run();
-
-        return dst;
-    }
-
-    SimpleTensor<T> compute_reference(const TensorShape &shape, DataType data_type, BorderMode border_mode, uint8_t constant_border_value)
-    {
-        ARM_COMPUTE_ERROR_ON(data_type != DataType::U8);
-
-        // Create reference
-        SimpleTensor<T> src{ shape, data_type };
-
-        // Fill reference
-        fill(src);
-
-        // Compute reference
-        return reference::median3x3<T>(src, border_mode, constant_border_value);
-    }
-
-    BorderMode      _border_mode{};
-    TensorType      _target{};
-    SimpleTensor<T> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_MEDIAN3X3_FIXTURE */
diff --git a/tests/validation/fixtures/MinMaxLocationFixture.h b/tests/validation/fixtures/MinMaxLocationFixture.h
deleted file mode 100644
index 73466cce54..0000000000
--- a/tests/validation/fixtures/MinMaxLocationFixture.h
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * Copyright (c) 2017 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_MIN_MAX_LOCATION_FIXTURE
-#define ARM_COMPUTE_TEST_MIN_MAX_LOCATION_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/Types.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/MinMaxLocation.h"
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename ArrayType, typename ArrayAccessorType, typename FunctionType, typename T>
-class MinMaxLocationValidationFixture : public framework::Fixture
-{
-public:
-    using target_type = typename std::conditional<std::is_integral<T>::value, int32_t, float>::type;
-
-    template <typename...>
-    void setup(TensorShape shape, DataType data_type)
-    {
-        _target    = compute_target(shape, data_type);
-        _reference = compute_reference(shape, data_type);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor)
-    {
-        library->fill_tensor_uniform(tensor, 0);
-    }
-
-    MinMaxLocationValues<target_type> compute_target(const TensorShape &shape, DataType data_type)
-    {
-        MinMaxLocationValues<target_type> target;
-
-        ArrayType min_loc(shape.total_size());
-        ArrayType max_loc(shape.total_size());
-
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(shape, data_type);
-
-        // Create and configure function
-        FunctionType min_max_loc;
-        min_max_loc.configure(&src, &target.min, &target.max, &min_loc, &max_loc);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(src));
-
-        // Compute function
-        min_max_loc.run();
-
-        // Create accessor objects for mapping operations
-        ArrayAccessorType min_loc_accessor(min_loc);
-        ArrayAccessorType max_loc_accessor(max_loc);
-
-        // Move min Coordinates2D values from ArrayType to vector
-        for(size_t i = 0; i < min_loc.num_values(); ++i)
-        {
-            target.min_loc.push_back(std::move(min_loc_accessor.at(i)));
-        }
-
-        // Move max Coordinates2D values from ArrayType to vector
-        for(size_t i = 0; i < max_loc.num_values(); ++i)
-        {
-            target.max_loc.push_back(std::move(max_loc_accessor.at(i)));
-        }
-
-        return target;
-    }
-
-    MinMaxLocationValues<T> compute_reference(const TensorShape &shape, DataType data_type)
-    {
-        // Create reference
-        SimpleTensor<T> src{ shape, data_type };
-
-        // Fill reference
-        fill(src);
-
-        return reference::min_max_location<T>(src);
-    }
-
-    MinMaxLocationValues<target_type> _target{};
-    MinMaxLocationValues<T>           _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_MIN_MAX_LOCATION_FIXTURE */
diff --git a/tests/validation/fixtures/NonLinearFilterFixture.h b/tests/validation/fixtures/NonLinearFilterFixture.h
deleted file mode 100644
index 03d2bcd962..0000000000
--- a/tests/validation/fixtures/NonLinearFilterFixture.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- * Copyright (c) 2017 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_NONLINEAR_FILTER_FIXTURE
-#define ARM_COMPUTE_TEST_NONLINEAR_FILTER_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/Helpers.h"
-#include "tests/validation/reference/NonLinearFilter.h"
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T>
-class NonLinearFilterValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, NonLinearFilterFunction function, unsigned int mask_size, MatrixPattern pattern, BorderMode border_mode, DataType data_type)
-    {
-        std::mt19937                           generator(library->seed());
-        std::uniform_int_distribution<uint8_t> distribution_u8(0, 255);
-        const uint8_t                          constant_border_value = distribution_u8(generator);
-
-        // Create the mask
-        std::vector<uint8_t> mask(mask_size * mask_size);
-        fill_mask_from_pattern(mask.data(), mask_size, mask_size, pattern);
-
-        _border_size = BorderSize(static_cast<int>(mask_size / 2));
-        _target      = compute_target(shape, data_type, function, mask_size, pattern, mask.data(), border_mode, constant_border_value);
-        _reference   = compute_reference(shape, data_type, function, mask_size, pattern, mask.data(), border_mode, constant_border_value);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor)
-    {
-        library->fill_tensor_uniform(tensor, 0);
-    }
-
-    TensorType compute_target(const TensorShape &shape, DataType data_type, NonLinearFilterFunction function, unsigned int mask_size, MatrixPattern pattern, const uint8_t *mask, BorderMode border_mode,
-                              uint8_t constant_border_value)
-    {
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(shape, data_type);
-        TensorType dst = create_tensor<TensorType>(shape, data_type);
-
-        // Create and configure function
-        FunctionType non_linear_filter;
-        non_linear_filter.configure(&src, &dst, function, mask_size, pattern, mask, border_mode, constant_border_value);
-
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        dst.allocator()->allocate();
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(src));
-
-        // Compute function
-        non_linear_filter.run();
-
-        return dst;
-    }
-
-    SimpleTensor<T> compute_reference(const TensorShape &shape, DataType data_type, NonLinearFilterFunction function, unsigned int mask_size, MatrixPattern pattern, const uint8_t *mask,
-                                      BorderMode border_mode, uint8_t constant_border_value)
-    {
-        // Create reference
-        SimpleTensor<T> src{ shape, data_type };
-
-        // Fill reference
-        fill(src);
-
-        return reference::non_linear_filter<T>(src, function, mask_size, pattern, mask, border_mode, constant_border_value);
-    }
-
-    BorderMode      _border_mode{};
-    BorderSize      _border_size{};
-    TensorType      _target{};
-    SimpleTensor<T> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_NONLINEAR_FILTER_FIXTURE */
diff --git a/tests/validation/fixtures/OpticalFlowFixture.h b/tests/validation/fixtures/OpticalFlowFixture.h
deleted file mode 100644
index 5c3285a601..0000000000
--- a/tests/validation/fixtures/OpticalFlowFixture.h
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
- * Copyright (c) 2018 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_OPTICAL_FLOW
-#define ARM_COMPUTE_TEST_OPTICAL_FLOW
-
-#include "arm_compute/core/PyramidInfo.h"
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/Types.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/OpticalFlow.h"
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType,
-          typename AccessorType,
-          typename ArrayType,
-          typename ArrayAccessorType,
-          typename FunctionType,
-          typename PyramidType,
-          typename PyramidFunctionType,
-          typename T>
-
-class OpticalFlowValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(std::string old_image_name, std::string new_image_name, OpticalFlowParameters params,
-               size_t num_levels, size_t num_keypoints, Format format, BorderMode border_mode)
-    {
-        std::mt19937                           gen(library->seed());
-        std::uniform_int_distribution<uint8_t> int_dist(0, 255);
-        const uint8_t                          constant_border_value = int_dist(gen);
-
-        // Create keypoints
-        std::vector<KeyPoint> old_keypoints           = generate_random_keypoints(library->get_image_shape(old_image_name), num_keypoints, library->seed(), num_levels);
-        std::vector<KeyPoint> new_keypoints_estimates = old_keypoints;
-
-        _target    = compute_target(old_image_name, new_image_name, params, num_levels, old_keypoints, new_keypoints_estimates, format, border_mode, constant_border_value);
-        _reference = compute_reference(old_image_name, new_image_name, params, num_levels, old_keypoints, new_keypoints_estimates, format, border_mode, constant_border_value);
-    }
-
-protected:
-    template <typename V>
-    void fill(V &&tensor, const std::string image, Format format)
-    {
-        library->fill(tensor, image, format);
-    }
-
-    ArrayType compute_target(std::string old_image_name, std::string new_image_name, OpticalFlowParameters params, size_t num_levels,
-                             std::vector<KeyPoint> &old_keypoints, std::vector<KeyPoint> &new_keypoints_estimates,
-                             Format format, BorderMode border_mode, uint8_t constant_border_value)
-    {
-        // Get image shapes
-        TensorShape old_shape = library->get_image_shape(old_image_name);
-        TensorShape new_shape = library->get_image_shape(new_image_name);
-
-        // Create tensors
-        auto old_image = create_tensor<TensorType>(old_shape, format);
-        auto new_image = create_tensor<TensorType>(new_shape, format);
-
-        // Load keypoints
-        ArrayType old_points(old_keypoints.size());
-        ArrayType new_points_estimates(new_keypoints_estimates.size());
-        ArrayType new_points(old_keypoints.size());
-
-        fill_array(ArrayAccessorType(old_points), old_keypoints);
-        fill_array(ArrayAccessorType(new_points_estimates), new_keypoints_estimates);
-
-        // Create pyramid images
-        PyramidInfo pyramid_info(num_levels, SCALE_PYRAMID_HALF, old_image.info()->tensor_shape(), format);
-        PyramidType old_pyramid = create_pyramid<PyramidType>(pyramid_info);
-        PyramidType new_pyramid = create_pyramid<PyramidType>(pyramid_info);
-
-        // Create and configure pyramid functions
-        PyramidFunctionType old_gp;
-        old_gp.configure(&old_image, &old_pyramid, border_mode, constant_border_value);
-
-        PyramidFunctionType new_gp;
-        new_gp.configure(&new_image, &new_pyramid, border_mode, constant_border_value);
-
-        for(size_t i = 0; i < pyramid_info.num_levels(); ++i)
-        {
-            ARM_COMPUTE_EXPECT(old_pyramid.get_pyramid_level(i)->info()->is_resizable(), framework::LogLevel::ERRORS);
-            ARM_COMPUTE_EXPECT(new_pyramid.get_pyramid_level(i)->info()->is_resizable(), framework::LogLevel::ERRORS);
-        }
-
-        // Create and configure optical flow function
-        FunctionType optical_flow;
-
-        optical_flow.configure(&old_pyramid,
-                               &new_pyramid,
-                               &old_points,
-                               &new_points_estimates,
-                               &new_points,
-                               params.termination,
-                               params.epsilon,
-                               params.num_iterations,
-                               params.window_dimension,
-                               params.use_initial_estimate,
-                               border_mode,
-                               constant_border_value);
-
-        ARM_COMPUTE_EXPECT(old_image.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(new_image.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate input tensors
-        old_image.allocator()->allocate();
-        new_image.allocator()->allocate();
-
-        // Allocate pyramids
-        old_pyramid.allocate();
-        new_pyramid.allocate();
-
-        ARM_COMPUTE_EXPECT(!old_image.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!new_image.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        for(size_t i = 0; i < pyramid_info.num_levels(); ++i)
-        {
-            ARM_COMPUTE_EXPECT(!old_pyramid.get_pyramid_level(i)->info()->is_resizable(), framework::LogLevel::ERRORS);
-            ARM_COMPUTE_EXPECT(!new_pyramid.get_pyramid_level(i)->info()->is_resizable(), framework::LogLevel::ERRORS);
-        }
-
-        // Fill tensors
-        fill(AccessorType(old_image), old_image_name, format);
-        fill(AccessorType(new_image), new_image_name, format);
-
-        // Compute functions
-        old_gp.run();
-        new_gp.run();
-        optical_flow.run();
-
-        return new_points;
-    }
-
-    std::vector<KeyPoint> compute_reference(std::string old_image_name, std::string new_image_name,
-                                            OpticalFlowParameters params, size_t num_levels,
-                                            std::vector<KeyPoint> &old_keypoints, std::vector<KeyPoint> &new_keypoints_estimates,
-                                            Format format, BorderMode border_mode, uint8_t constant_border_value)
-    {
-        SimpleTensor<T> old_image{ library->get_image_shape(old_image_name), data_type_from_format(format) };
-        SimpleTensor<T> new_image{ library->get_image_shape(new_image_name), data_type_from_format(format) };
-
-        fill(old_image, old_image_name, format);
-        fill(new_image, new_image_name, format);
-
-        return reference::optical_flow<T>(old_image, new_image, params, num_levels, old_keypoints, new_keypoints_estimates,
-                                          border_mode, constant_border_value);
-    }
-
-    ArrayType             _target{};
-    std::vector<KeyPoint> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_OPTICAL_FLOW */
diff --git a/tests/validation/fixtures/PhaseFixture.h b/tests/validation/fixtures/PhaseFixture.h
deleted file mode 100644
index b80d1ae00e..0000000000
--- a/tests/validation/fixtures/PhaseFixture.h
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * Copyright (c) 2017 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_PHASE_FIXTURE
-#define ARM_COMPUTE_TEST_PHASE_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/Phase.h"
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T>
-class PhaseValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, Format format, PhaseType phase_type)
-    {
-        _target    = compute_target(shape, format, phase_type);
-        _reference = compute_reference(shape, format, phase_type);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor, std::random_device::result_type seed_offset)
-    {
-        library->fill_tensor_uniform(tensor, seed_offset);
-    }
-
-    TensorType compute_target(const TensorShape &shape, Format format, PhaseType phase_type)
-    {
-        DataType data_type = data_type_from_format(format);
-
-        // Create tensors
-        TensorType src1 = create_tensor<TensorType>(shape, data_type);
-        src1.info()->set_format(format);
-
-        TensorType src2 = create_tensor<TensorType>(shape, data_type);
-        src2.info()->set_format(format);
-
-        TensorType dst = create_tensor<TensorType>(shape, DataType::U8);
-        dst.info()->set_format(Format::U8);
-
-        // Create and configure function
-        FunctionType phase;
-
-        phase.configure(&src1, &src2, &dst, phase_type);
-
-        ARM_COMPUTE_EXPECT(src1.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(src2.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src1.allocator()->allocate();
-        src2.allocator()->allocate();
-        dst.allocator()->allocate();
-
-        ARM_COMPUTE_EXPECT(!src1.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!src2.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(src1), 0);
-        fill(AccessorType(src2), 1);
-
-        // Compute function
-        phase.run();
-
-        return dst;
-    }
-
-    SimpleTensor<uint8_t> compute_reference(const TensorShape &shape, Format format, PhaseType phase_type)
-    {
-        DataType data_type = data_type_from_format(format);
-
-        // Create reference
-        SimpleTensor<T> src1{ shape, data_type };
-        SimpleTensor<T> src2{ shape, data_type };
-
-        // Fill reference
-        fill(src1, 0);
-        fill(src2, 1);
-
-        return reference::phase<T>(src1, src2, phase_type);
-    }
-
-    TensorType            _target{};
-    SimpleTensor<uint8_t> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_PHASE_FIXTURE */
diff --git a/tests/validation/fixtures/SobelFixture.h b/tests/validation/fixtures/SobelFixture.h
deleted file mode 100644
index 61a6a80d70..0000000000
--- a/tests/validation/fixtures/SobelFixture.h
+++ /dev/null
@@ -1,192 +0,0 @@
-/*
- * Copyright (c) 2017-2020 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_SOBEL_FIXTURE
-#define ARM_COMPUTE_TEST_SOBEL_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/Sobel.h"
-
-#include <memory>
-
-namespace arm_compute
-{
-class CLSobel3x3;
-class CLSobel5x5;
-class CLSobel7x7;
-class NESobel3x3;
-class NESobel5x5;
-class NESobel7x7;
-
-namespace test
-{
-namespace validation
-{
-namespace
-{
-template <typename Function>
-struct info;
-
-template <>
-struct info<NESobel3x3>
-{
-    static const Format dst_format  = Format::S16;
-    static const int    filter_size = 3;
-};
-
-template <>
-struct info<CLSobel3x3>
-{
-    static const Format dst_format  = Format::S16;
-    static const int    filter_size = 3;
-};
-
-template <>
-struct info<NESobel5x5>
-{
-    static const Format dst_format  = Format::S16;
-    static const int    filter_size = 5;
-};
-
-template <>
-struct info<CLSobel5x5>
-{
-    static const Format dst_format  = Format::S16;
-    static const int    filter_size = 5;
-};
-
-template <>
-struct info<NESobel7x7>
-{
-    static const Format dst_format  = Format::S32;
-    static const int    filter_size = 7;
-};
-
-template <>
-struct info<CLSobel7x7>
-{
-    static const Format dst_format  = Format::S32;
-    static const int    filter_size = 7;
-};
-} // namespace
-
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T, typename U>
-class SobelValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, BorderMode border_mode, Format format, GradientDimension gradient_dimension)
-    {
-        // Generate a random constant value
-        std::mt19937                           gen(library->seed());
-        std::uniform_int_distribution<uint8_t> int_dist(0, 255);
-        const uint8_t                          constant_border_value = int_dist(gen);
-
-        _border_mode = border_mode;
-        _target      = compute_target(shape, border_mode, format, constant_border_value, gradient_dimension);
-        _reference   = compute_reference(shape, info<FunctionType>::filter_size, border_mode, format, constant_border_value, gradient_dimension);
-    }
-
-protected:
-    template <typename V>
-    void fill(V &&tensor)
-    {
-        library->fill_tensor_uniform(tensor, 0);
-    }
-
-    std::pair<TensorType, TensorType> compute_target(const TensorShape &shape, BorderMode border_mode, Format format, uint8_t constant_border_value, GradientDimension gradient_dimension)
-    {
-        // Create tensors
-        TensorType src   = create_tensor<TensorType>(shape, data_type_from_format(format));
-        TensorType dst_x = create_tensor<TensorType>(shape, data_type_from_format(info<FunctionType>::dst_format));
-        TensorType dst_y = create_tensor<TensorType>(shape, data_type_from_format(info<FunctionType>::dst_format));
-
-        src.info()->set_format(format);
-        dst_x.info()->set_format(info<FunctionType>::dst_format);
-        dst_y.info()->set_format(info<FunctionType>::dst_format);
-
-        FunctionType sobel;
-
-        switch(gradient_dimension)
-        {
-            case GradientDimension::GRAD_X:
-                sobel.configure(&src, &dst_x, nullptr, border_mode, constant_border_value);
-                break;
-            case GradientDimension::GRAD_Y:
-                sobel.configure(&src, nullptr, &dst_y, border_mode, constant_border_value);
-                break;
-            case GradientDimension::GRAD_XY:
-                sobel.configure(&src, &dst_x, &dst_y, border_mode, constant_border_value);
-                break;
-            default:
-                ARM_COMPUTE_ERROR("Gradient dimension not supported");
-        }
-
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst_x.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst_y.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        dst_x.allocator()->allocate();
-        dst_y.allocator()->allocate();
-
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst_x.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst_y.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(src));
-
-        // Compute function
-        sobel.run();
-
-        return std::make_pair(std::move(dst_x), std::move(dst_y));
-    }
-
-    std::pair<SimpleTensor<U>, SimpleTensor<U>> compute_reference(const TensorShape &shape, int filter_size, BorderMode border_mode, Format format, uint8_t constant_border_value,
-                                                                  GradientDimension gradient_dimension)
-    {
-        // Create reference
-        SimpleTensor<T> src{ shape, format };
-
-        // Fill reference
-        fill(src);
-
-        return reference::sobel<U>(src, filter_size, border_mode, constant_border_value, gradient_dimension);
-    }
-
-    BorderMode _border_mode{ BorderMode::UNDEFINED };
-    std::pair<TensorType, TensorType>           _target{};
-    std::pair<SimpleTensor<U>, SimpleTensor<U>> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_SOBEL_FIXTURE */
diff --git a/tests/validation/fixtures/TableLookupFixture.h b/tests/validation/fixtures/TableLookupFixture.h
deleted file mode 100644
index a50c9fb2fe..0000000000
--- a/tests/validation/fixtures/TableLookupFixture.h
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * Copyright (c) 2017 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_TABLE_LOOKUP_FIXTURE
-#define ARM_COMPUTE_TEST_TABLE_LOOKUP_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/RawLutAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/Helpers.h"
-#include "tests/validation/reference/TableLookup.h"
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename FunctionType, typename LutAccessorType, typename LutType, typename T>
-class TableLookupValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, DataType data_type)
-    {
-        _target    = compute_target(shape, data_type);
-        _reference = compute_reference(shape, data_type);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor, int i)
-    {
-        library->fill_tensor_uniform(tensor, i);
-    }
-
-    TensorType compute_target(const TensorShape &shape, DataType data_type)
-    {
-        // Create Lut
-        const int num_elem = (data_type == DataType::U8) ? std::numeric_limits<uint8_t>::max() + 1 : std::numeric_limits<int16_t>::max() - std::numeric_limits<int16_t>::lowest() + 1;
-        LutType   lut(num_elem, data_type);
-
-        //Fill the Lut
-        fill_lookuptable(LutAccessorType(lut));
-
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(shape, data_type);
-        TensorType dst = create_tensor<TensorType>(shape, data_type);
-
-        // Create and configure function
-        FunctionType table_lookup;
-        table_lookup.configure(&src, &lut, &dst);
-
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        dst.allocator()->allocate();
-
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(src), 0);
-        fill(AccessorType(dst), 1);
-
-        // Compute function
-        table_lookup.run();
-
-        return dst;
-    }
-
-    SimpleTensor<T> compute_reference(const TensorShape &shape, DataType data_type)
-    {
-        // Create rawLut
-        std::map<T, T> rawlut;
-
-        // Fill the Lut
-        fill_lookuptable(RawLutAccessor<T>(rawlut));
-
-        // Create reference
-        SimpleTensor<T> src{ shape, data_type };
-
-        // Fill reference
-        fill(src, 0);
-
-        return reference::table_lookup(src, rawlut);
-    }
-
-    TensorType      _target{};
-    SimpleTensor<T> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_TABLE_LOOKUP_FIXTURE */
diff --git a/tests/validation/fixtures/ThresholdFixture.h b/tests/validation/fixtures/ThresholdFixture.h
deleted file mode 100644
index 038c296178..0000000000
--- a/tests/validation/fixtures/ThresholdFixture.h
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Copyright (c) 2017-2020 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_THRESHOLD_FIXTURE
-#define ARM_COMPUTE_TEST_THRESHOLD_FIXTURE
-
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/Threshold.h"
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T>
-class ThresholdValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, uint8_t threshold, uint8_t false_value, uint8_t true_value, ThresholdType type, uint8_t upper, DataType data_type)
-    {
-        _target    = compute_target(shape, data_type, threshold, false_value, true_value, type, upper);
-        _reference = compute_reference(shape, data_type, threshold, false_value, true_value, type, upper);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor)
-    {
-        library->fill_tensor_uniform(tensor, 0);
-    }
-
-    TensorType compute_target(const TensorShape &shape, DataType data_type,
-                              uint8_t threshold, uint8_t false_value, uint8_t true_value,
-                              ThresholdType type, uint8_t upper)
-    {
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(shape, data_type);
-        TensorType dst = create_tensor<TensorType>(shape, data_type);
-
-        // Create and configure function
-        FunctionType thrsh;
-        thrsh.configure(&src, &dst, ThresholdKernelInfo(threshold, false_value, true_value, type, upper));
-
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        dst.allocator()->allocate();
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(src));
-
-        // Compute function
-        thrsh.run();
-
-        return dst;
-    }
-
-    SimpleTensor<T> compute_reference(const TensorShape &shape, DataType data_type,
-                                      uint8_t threshold, uint8_t false_value, uint8_t true_value,
-                                      ThresholdType type, uint8_t upper)
-    {
-        // Create reference
-        SimpleTensor<T> src{ shape, data_type };
-
-        // Fill reference
-        fill(src);
-
-        return reference::threshold<T>(src, threshold, false_value, true_value, type, upper);
-    }
-
-    TensorType      _target{};
-    SimpleTensor<T> _reference{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_THRESHOLD_FIXTURE */
diff --git a/tests/validation/fixtures/WarpAffineFixture.h b/tests/validation/fixtures/WarpAffineFixture.h
deleted file mode 100644
index 014d6628b1..0000000000
--- a/tests/validation/fixtures/WarpAffineFixture.h
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * Copyright (c) 2017-2018 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_WARP_AFFINE_FIXTURE
-#define ARM_COMPUTE_TEST_WARP_AFFINE_FIXTURE
-
-#include <memory>
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/Utils.h"
-#include "tests/validation/reference/WarpAffine.h"
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T>
-class WarpAffineValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape shape, DataType data_type, InterpolationPolicy policy, BorderMode border_mode)
-    {
-        // Generate a random constant value if border_mode is constant
-        std::mt19937                           gen(library->seed());
-        std::uniform_int_distribution<uint8_t> distribution_u8(0, 255);
-        uint8_t                                constant_border_value = distribution_u8(gen);
-
-        // Create the matrix
-        std::array<float, 9> matrix{ {} };
-        fill_warp_matrix<9>(matrix);
-
-        _target    = compute_target(shape, data_type, matrix, policy, border_mode, constant_border_value);
-        _reference = compute_reference(shape, data_type, matrix, policy, border_mode, constant_border_value);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor)
-    {
-        library->fill_tensor_uniform(tensor, 0);
-    }
-
-    TensorType compute_target(const TensorShape &shape, DataType data_type, const std::array<float, 9> &matrix, InterpolationPolicy policy, BorderMode border_mode, uint8_t constant_border_value)
-    {
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(shape, data_type);
-        TensorType dst = create_tensor<TensorType>(shape, data_type);
-
-        // Create and configure function
-        FunctionType warp_affine;
-        warp_affine.configure(&src, &dst, matrix, policy, border_mode, constant_border_value);
-
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        dst.allocator()->allocate();
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(src));
-
-        // Compute function
-        warp_affine.run();
-
-        return dst;
-    }
-
-    SimpleTensor<T> compute_reference(const TensorShape &shape, DataType data_type, const std::array<float, 9> &matrix, InterpolationPolicy policy, BorderMode border_mode, uint8_t constant_border_value)
-    {
-        // Create reference
-        SimpleTensor<T> src{ shape, data_type };
-
-        // Create the valid mask Tensor
-        _valid_mask = SimpleTensor<T>(shape, data_type);
-
-        // Fill reference
-        fill(src);
-
-        return reference::warp_affine<T>(src, _valid_mask, matrix.data(), policy, border_mode, constant_border_value);
-    }
-
-    TensorType      _target{};
-    SimpleTensor<T> _reference{};
-    SimpleTensor<T> _valid_mask{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_WARP_AFFINE_FIXTURE */
diff --git a/tests/validation/fixtures/WarpPerspectiveFixture.h b/tests/validation/fixtures/WarpPerspectiveFixture.h
deleted file mode 100644
index 40ae3b956c..0000000000
--- a/tests/validation/fixtures/WarpPerspectiveFixture.h
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
- * Copyright (c) 2017-2019 Arm Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef ARM_COMPUTE_TEST_WARP_PERSPECTIVE_FIXTURE
-#define ARM_COMPUTE_TEST_WARP_PERSPECTIVE_FIXTURE
-
-#include "arm_compute/core/TensorShape.h"
-#include "arm_compute/core/Types.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/IAccessor.h"
-#include "tests/framework/Asserts.h"
-#include "tests/framework/Fixture.h"
-#include "tests/validation/reference/Utils.h"
-#include "tests/validation/reference/WarpPerspective.h"
-
-#include <random>
-
-namespace arm_compute
-{
-namespace test
-{
-namespace validation
-{
-template <typename TensorType, typename AccessorType, typename FunctionType, typename T>
-class WarpPerspectiveValidationFixture : public framework::Fixture
-{
-public:
-    template <typename...>
-    void setup(TensorShape input_shape, DataType data_type, InterpolationPolicy policy, BorderMode border_mode)
-    {
-        uint8_t constant_border_value = 0;
-        // Generate a random constant value if border_mode is constant
-        if(border_mode == BorderMode::CONSTANT)
-        {
-            std::mt19937                           gen(library->seed());
-            std::uniform_int_distribution<uint8_t> distribution_u8(0, 255);
-            constant_border_value = distribution_u8(gen);
-        }
-
-        // Create the matrix
-        std::array<float, 9> matrix = { { 0 } };
-        fill_warp_matrix<9>(matrix);
-
-        _target    = compute_target(input_shape, matrix, policy, border_mode, constant_border_value, data_type);
-        _reference = compute_reference(input_shape, matrix, policy, border_mode, constant_border_value, data_type);
-    }
-
-protected:
-    template <typename U>
-    void fill(U &&tensor)
-    {
-        library->fill_tensor_uniform(tensor, 0);
-    }
-
-    TensorType compute_target(const TensorShape &shape, const std::array<float, 9> &matrix, InterpolationPolicy policy, BorderMode border_mode,
-                              uint8_t  constant_border_value,
-                              DataType data_type)
-    {
-        // Create tensors
-        TensorType src = create_tensor<TensorType>(shape, data_type);
-        TensorType dst = create_tensor<TensorType>(shape, data_type);
-
-        // Create and configure function
-        FunctionType warp_perspective;
-        warp_perspective.configure(&src, &dst, matrix, policy, border_mode, constant_border_value);
-
-        ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Allocate tensors
-        src.allocator()->allocate();
-        dst.allocator()->allocate();
-
-        ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS);
-        ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
-        // Fill tensors
-        fill(AccessorType(src));
-
-        // Compute function
-        warp_perspective.run();
-
-        return dst;
-    }
-
-    SimpleTensor<T> compute_reference(const TensorShape &shape, const std::array<float, 9> &matrix, InterpolationPolicy policy, BorderMode border_mode,
-                                      uint8_t  constant_border_value,
-                                      DataType data_type)
-    {
-        ARM_COMPUTE_ERROR_ON(data_type != DataType::U8);
-
-        // Create reference
-        SimpleTensor<T> src{ shape, data_type };
-
-        // Create the valid mask Tensor
-        _valid_mask = SimpleTensor<T>(shape, data_type);
-
-        // Fill reference
-        fill(src);
-
-        // Compute reference
-        return reference::warp_perspective<T>(src, _valid_mask, matrix.data(), policy, border_mode, constant_border_value);
-    }
-
-    TensorType      _target{};
-    SimpleTensor<T> _reference{};
-    BorderMode      _border_mode{};
-    SimpleTensor<T> _valid_mask{};
-};
-} // namespace validation
-} // namespace test
-} // namespace arm_compute
-#endif /* ARM_COMPUTE_TEST_WARP_PERSPECTIVE_FIXTURE */