COMPMID-415: Move ConvolutionLayer to new validation

Change-Id: I1f40dff43142c4e2c096122bfa1ca08241ff80ff
Reviewed-on: http://mpd-gerrit.cambridge.arm.com/81952
Tested-by: Kaizen <jeremy.johnson+kaizengerrit@arm.com>
Reviewed-by: Anthony Barbier <anthony.barbier@arm.com>

10 files changed, 0 insertions, 1166 deletions

diff --git a/tests/validation/CL/ConvolutionLayer.cpp b/tests/validation/CL/ConvolutionLayer.cpp
deleted file mode 100644
index 570077120e..0000000000
--- a/tests/validation/CL/ConvolutionLayer.cpp
+++ /dev/null
@@ -1,222 +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.
- */
-#include "CL/CLAccessor.h"
-
-#include "TypePrinter.h"
-#include "dataset/ConvolutionLayerDataset.h"
-#include "tests/Globals.h"
-#include "tests/Utils.h"
-#include "validation/Datasets.h"
-#include "validation/Reference.h"
-#include "validation/Validation.h"
-
-#include "arm_compute/core/Helpers.h"
-#include "arm_compute/core/Types.h"
-#include "arm_compute/runtime/CL/functions/CLConvolutionLayer.h"
-#include "arm_compute/runtime/Tensor.h"
-#include "arm_compute/runtime/TensorAllocator.h"
-
-#include <random>
-
-using namespace arm_compute;
-using namespace arm_compute::test;
-using namespace arm_compute::test::validation;
-
-namespace
-{
-const float tolerance_f16 = 0.1f;   /**< Tolerance value for comparing reference's output against implementation's output for DataType::F16 */
-const float tolerance_f32 = 1e-03f; /**< Tolerance value for comparing reference's output against implementation's output for DataType::F32 */
-const float tolerance_q   = 1.0f;   /**< Tolerance value for comparing reference's output against implementation's output for fixed point data types */
-
-CLTensor compute_convolution_layer(const TensorShape &input_shape, const TensorShape &weights_shape, const TensorShape &bias_shape, const TensorShape &output_shape, DataType dt,
-                                   const PadStrideInfo &conv_info, int fixed_point_position)
-{
-    // Create tensors
-    CLTensor src     = create_tensor<CLTensor>(input_shape, dt, 1, fixed_point_position);
-    CLTensor weights = create_tensor<CLTensor>(weights_shape, dt, 1, fixed_point_position);
-    CLTensor bias    = create_tensor<CLTensor>(bias_shape, dt, 1, fixed_point_position);
-    CLTensor dst     = create_tensor<CLTensor>(output_shape, dt, 1, fixed_point_position);
-
-    // Create and configure function
-    CLConvolutionLayer conv;
-    conv.configure(&src, &weights, &bias, &dst, conv_info);
-
-    // Allocate tensors
-    src.allocator()->allocate();
-    weights.allocator()->allocate();
-    bias.allocator()->allocate();
-    dst.allocator()->allocate();
-
-    BOOST_TEST(!src.info()->is_resizable());
-    BOOST_TEST(!weights.info()->is_resizable());
-    BOOST_TEST(!bias.info()->is_resizable());
-    BOOST_TEST(!dst.info()->is_resizable());
-
-    // Fill tensors
-    if(dt == DataType::F32 || dt == DataType::F16)
-    {
-        std::uniform_real_distribution<> distribution(-1.0f, 1.0f);
-        library->fill(CLAccessor(src), distribution, 0);
-        library->fill(CLAccessor(weights), distribution, 1);
-        library->fill(CLAccessor(bias), distribution, 2);
-    }
-    else
-    {
-        library->fill_tensor_uniform(CLAccessor(src), 0);
-        library->fill_tensor_uniform(CLAccessor(weights), 1);
-        library->fill_tensor_uniform(CLAccessor(bias), 2);
-    }
-
-    // Compute CLConvolutionLayer function
-    conv.run();
-
-    return dst;
-}
-} // namespace
-
-#ifndef DOXYGEN_SKIP_THIS
-BOOST_AUTO_TEST_SUITE(CL)
-BOOST_AUTO_TEST_SUITE(ConvolutionLayer)
-BOOST_AUTO_TEST_SUITE(GEMM)
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit") * boost::unit_test::label("nightly"))
-BOOST_DATA_TEST_CASE(Configuration,
-                     AlexNetConvolutionLayerDataset() * boost::unit_test::data::make({ DataType::F32, DataType::QS8, DataType::QS16 }),
-                     conv_set, dt)
-{
-    // Set fixed point position data type allowed
-    int fixed_point_position = (dt == DataType::F32) ? 0 : 3;
-
-    // Create tensors
-    CLTensor src     = create_tensor<CLTensor>(conv_set.src_shape, dt, 1, fixed_point_position);
-    CLTensor weights = create_tensor<CLTensor>(conv_set.weights_shape, dt, 1, fixed_point_position);
-    CLTensor bias    = create_tensor<CLTensor>(conv_set.bias_shape, dt, 1, fixed_point_position);
-    CLTensor dst     = create_tensor<CLTensor>(conv_set.dst_shape, dt, 1, fixed_point_position);
-
-    BOOST_TEST(src.info()->is_resizable());
-    BOOST_TEST(weights.info()->is_resizable());
-    BOOST_TEST(bias.info()->is_resizable());
-    BOOST_TEST(dst.info()->is_resizable());
-
-    // Create and configure function
-    CLConvolutionLayer conv;
-    conv.configure(&src, &weights, &bias, &dst, conv_set.info);
-
-    // Validate valid region
-    const ValidRegion src_valid_region     = shape_to_valid_region(conv_set.src_shape);
-    const ValidRegion weights_valid_region = shape_to_valid_region(conv_set.weights_shape);
-    const ValidRegion bias_valid_region    = shape_to_valid_region(conv_set.bias_shape);
-    const ValidRegion dst_valid_region     = shape_to_valid_region(conv_set.dst_shape);
-
-    validate(src.info()->valid_region(), src_valid_region);
-    validate(weights.info()->valid_region(), weights_valid_region);
-    validate(bias.info()->valid_region(), bias_valid_region);
-    validate(dst.info()->valid_region(), dst_valid_region);
-}
-
-BOOST_AUTO_TEST_SUITE(Float16)
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
-BOOST_DATA_TEST_CASE(SmallConvolutionLayer,
-                     SmallConvolutionLayerDataset() * boost::unit_test::data::make(DataType::F16),
-                     conv_set, dt)
-{
-    // Compute function
-    CLTensor dst = compute_convolution_layer(conv_set.src_shape, conv_set.weights_shape, conv_set.bias_shape, conv_set.dst_shape, dt, conv_set.info, 0);
-
-    // Compute reference
-    RawTensor ref_dst = Reference::compute_reference_convolution_layer(conv_set.src_shape, conv_set.weights_shape, conv_set.bias_shape, conv_set.dst_shape, dt, conv_set.info, 0);
-
-    // Validate output
-    validate(CLAccessor(dst), ref_dst, tolerance_f16);
-}
-BOOST_AUTO_TEST_SUITE_END()
-
-BOOST_AUTO_TEST_SUITE(Float)
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
-BOOST_DATA_TEST_CASE(SmallConvolutionLayer,
-                     SmallConvolutionLayerDataset() * boost::unit_test::data::make(DataType::F32),
-                     conv_set, dt)
-{
-    // Compute function
-    CLTensor dst = compute_convolution_layer(conv_set.src_shape, conv_set.weights_shape, conv_set.bias_shape, conv_set.dst_shape, dt, conv_set.info, 0);
-
-    // Compute reference
-    RawTensor ref_dst = Reference::compute_reference_convolution_layer(conv_set.src_shape, conv_set.weights_shape, conv_set.bias_shape, conv_set.dst_shape, dt, conv_set.info, 0);
-
-    // Validate output
-    validate(CLAccessor(dst), ref_dst, tolerance_f32);
-}
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("nightly"))
-BOOST_DATA_TEST_CASE(LargeConvolutionLayer,
-                     AlexNetConvolutionLayerDataset() * boost::unit_test::data::make(DataType::F32),
-                     conv_set, dt)
-{
-    // Compute function
-    CLTensor dst = compute_convolution_layer(conv_set.src_shape, conv_set.weights_shape, conv_set.bias_shape, conv_set.dst_shape, dt, conv_set.info, 0);
-
-    // Compute reference
-    RawTensor ref_dst = Reference::compute_reference_convolution_layer(conv_set.src_shape, conv_set.weights_shape, conv_set.bias_shape, conv_set.dst_shape, dt, conv_set.info, 0);
-
-    // Validate output
-    validate(CLAccessor(dst), ref_dst, tolerance_f32);
-}
-BOOST_AUTO_TEST_SUITE_END()
-
-BOOST_AUTO_TEST_SUITE(Quantized)
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
-BOOST_DATA_TEST_CASE(SmallConvolutionLayer,
-                     SmallConvolutionLayerDataset() * boost::unit_test::data::make({ DataType::QS8, DataType::QS16 }) * boost::unit_test::data::xrange(4, 7),
-                     conv_set, dt, fixed_point_position)
-{
-    // Compute function
-    CLTensor dst = compute_convolution_layer(conv_set.src_shape, conv_set.weights_shape, conv_set.bias_shape, conv_set.dst_shape, dt, conv_set.info, fixed_point_position);
-
-    // Compute reference
-    RawTensor ref_dst = Reference::compute_reference_convolution_layer(conv_set.src_shape, conv_set.weights_shape, conv_set.bias_shape, conv_set.dst_shape, dt, conv_set.info, fixed_point_position);
-
-    // Validate output
-    validate(CLAccessor(dst), ref_dst, tolerance_q);
-}
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("nightly"))
-BOOST_DATA_TEST_CASE(LargeConvolutionLayer,
-                     AlexNetConvolutionLayerDataset() * boost::unit_test::data::make({ DataType::QS8, DataType::QS16 }) * boost::unit_test::data::xrange(4, 7),
-                     conv_set, dt, fixed_point_position)
-{
-    // Compute function
-    CLTensor dst = compute_convolution_layer(conv_set.src_shape, conv_set.weights_shape, conv_set.bias_shape, conv_set.dst_shape, dt, conv_set.info, fixed_point_position);
-
-    // Compute reference
-    RawTensor ref_dst = Reference::compute_reference_convolution_layer(conv_set.src_shape, conv_set.weights_shape, conv_set.bias_shape, conv_set.dst_shape, dt, conv_set.info, fixed_point_position);
-
-    // Validate output
-    validate(CLAccessor(dst), ref_dst, tolerance_q);
-}
-BOOST_AUTO_TEST_SUITE_END()
-
-BOOST_AUTO_TEST_SUITE_END()
-BOOST_AUTO_TEST_SUITE_END()
-BOOST_AUTO_TEST_SUITE_END()
-#endif /* DOXYGEN_SKIP_THIS */
diff --git a/tests/validation/CL/DirectConvolutionLayer.cpp b/tests/validation/CL/DirectConvolutionLayer.cpp
deleted file mode 100644
index d9dd34b9ec..0000000000
--- a/tests/validation/CL/DirectConvolutionLayer.cpp
+++ /dev/null
@@ -1,197 +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.
- */
-#include "AssetsLibrary.h"
-#include "CL/CLAccessor.h"
-#include "Globals.h"
-#include "TypePrinter.h"
-#include "Utils.h"
-#include "validation/Datasets.h"
-#include "validation/Reference.h"
-#include "validation/Validation.h"
-
-#include "arm_compute/core/Helpers.h"
-#include "arm_compute/core/Types.h"
-#include "arm_compute/runtime/CL/functions/CLDirectConvolutionLayer.h"
-#include "arm_compute/runtime/Tensor.h"
-#include "arm_compute/runtime/TensorAllocator.h"
-
-#include "boost_wrapper.h"
-
-#include <random>
-#include <string>
-#include <tuple>
-
-using namespace arm_compute;
-using namespace arm_compute::test;
-using namespace arm_compute::test::validation;
-
-namespace
-{
-/** Define tolerance of the direct convolution layer
- *
- * @param[in] dt DataType of the tensor.
- *
- * @return Tolerance depending on the data type.
- */
-float direct_convolution_layer_tolerance(DataType dt)
-{
-    switch(dt)
-    {
-        case DataType::F16:
-            return 0.1f;
-        case DataType::F32:
-            return 1e-3f;
-        default:
-            return 0.f;
-    }
-}
-
-/** Compute CL direct convolution layer function.
- *
- * @param[in] src_shape            Shape of the input tensor.
- * @param[in] weights_shape        Shape of the weights.
- * @param[in] bias_shape           Shape of the bias tensor.
- * @param[in] dst_shape            Shape of the output tensor.
- * @param[in] dt                   Data type of input, convolution matrix and output tensors.
- * @param[in] conv_info            Padding and stride information.
- * @param[in] fixed_point_position (Optional) Number of bits for the fractional part of the fixed point numbers
- *
- * @return Computed output tensor.
-*/
-CLTensor compute_convolution_layer(const TensorShape &src_shape, const TensorShape &weights_shape, const TensorShape &bias_shape, const TensorShape &dst_shape,
-                                   DataType dt, PadStrideInfo conv_info, int fixed_point_position = 0)
-{
-    // Create tensors
-    CLTensor src     = create_tensor<CLTensor>(src_shape, dt, 1, fixed_point_position);
-    CLTensor weights = create_tensor<CLTensor>(weights_shape, dt, 1, fixed_point_position);
-
-    CLTensor bias = create_tensor<CLTensor>(bias_shape, dt, 1, fixed_point_position);
-    CLTensor dst  = create_tensor<CLTensor>(dst_shape, dt, 1, fixed_point_position);
-
-    // Create and configure function
-    CLDirectConvolutionLayer conv_layer;
-    conv_layer.configure(&src, &weights, &bias, &dst, conv_info);
-
-    // Allocate tensors
-    src.allocator()->allocate();
-    weights.allocator()->allocate();
-    dst.allocator()->allocate();
-    bias.allocator()->allocate();
-
-    BOOST_TEST(!src.info()->is_resizable());
-    BOOST_TEST(!weights.info()->is_resizable());
-    BOOST_TEST(!dst.info()->is_resizable());
-    BOOST_TEST(!bias.info()->is_resizable());
-
-    // Fill tensors
-    switch(dt)
-    {
-        case DataType::F16:
-        case DataType::F32:
-        {
-            std::uniform_real_distribution<> distribution(-1.f, 1.f);
-            library->fill(CLAccessor(src), distribution, 0);
-            library->fill(CLAccessor(weights), distribution, 1);
-            library->fill(CLAccessor(bias), distribution, 2);
-            break;
-        }
-        default:
-        {
-            ARM_COMPUTE_ERROR("Not supported");
-        }
-    }
-
-    // Compute function
-    conv_layer.run();
-
-    return dst;
-}
-
-TensorShape get_output_shape(TensorShape in_shape, TensorShape kernel_shape, const PadStrideInfo &conv_info)
-{
-    TensorShape out_shape(in_shape);
-    const std::pair<unsigned int, unsigned int> scaled_dims = arm_compute::scaled_dimensions(in_shape.x(),
-                                                                                             in_shape.y(),
-                                                                                             kernel_shape.x(),
-                                                                                             kernel_shape.y(),
-                                                                                             conv_info);
-    out_shape.set(0, scaled_dims.first);
-    out_shape.set(1, scaled_dims.second);
-    out_shape.set(2, kernel_shape[3]);
-    return out_shape;
-}
-
-} // namespace
-
-#ifndef DOXYGEN_SKIP_THIS
-BOOST_AUTO_TEST_SUITE(CL)
-BOOST_AUTO_TEST_SUITE(DirectConvolutionLayer)
-
-BOOST_AUTO_TEST_SUITE(Float)
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
-BOOST_DATA_TEST_CASE(W1x1, DirectConvolutionShapes() * boost::unit_test::data::make({ DataType::F16, DataType::F32 }) * boost::unit_test::data::xrange(1, 4, 1) * boost::unit_test::data::xrange(1, 4,
-                     1)
-                     * boost::unit_test::data::make({ 1, 4, 8, 16 }),
-                     input_shape, dt, sx, sy, num_kernels)
-{
-    const unsigned int  kernel_size = 1;
-    const PadStrideInfo conv_info(sx, sy, 0, 0, DimensionRoundingType::FLOOR);
-    const TensorShape   w_shape(kernel_size, kernel_size, input_shape.z(), static_cast<unsigned int>(num_kernels));
-    const TensorShape   b_shape(static_cast<unsigned int>(num_kernels));
-    const TensorShape   d_shape(get_output_shape(input_shape, w_shape, conv_info));
-
-    CLTensor dst = compute_convolution_layer(input_shape, w_shape, b_shape, d_shape, dt, conv_info);
-
-    RawTensor ref = Reference::compute_reference_convolution_layer(input_shape, w_shape, b_shape, d_shape, dt, conv_info, 0);
-
-    // Validate output
-    validate(CLAccessor(dst), ref, direct_convolution_layer_tolerance(dt));
-}
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
-BOOST_DATA_TEST_CASE(W3x3, DirectConvolutionShapes() * boost::unit_test::data::make({ DataType::F16, DataType::F32 }) * boost::unit_test::data::xrange(1, 3, 1) * boost::unit_test::data::xrange(1, 3,
-                     1)
-                     * boost::unit_test::data::xrange(0, 2, 1)
-                     * boost::unit_test::data::xrange(0, 2, 1) * boost::unit_test::data::make({ 1, 4, 8, 16 }),
-                     input_shape, dt, sx, sy, px, py, num_kernels)
-{
-    const unsigned int  kernel_size = 3;
-    const PadStrideInfo conv_info(sx, sy, px, py, DimensionRoundingType::FLOOR);
-    const TensorShape   w_shape(kernel_size, kernel_size, input_shape.z(), static_cast<unsigned int>(num_kernels));
-    const TensorShape   b_shape(static_cast<unsigned int>(num_kernels));
-    const TensorShape   d_shape(get_output_shape(input_shape, w_shape, conv_info));
-
-    CLTensor dst = compute_convolution_layer(input_shape, w_shape, b_shape, d_shape, dt, conv_info);
-
-    RawTensor ref = Reference::compute_reference_convolution_layer(input_shape, w_shape, b_shape, d_shape, dt, conv_info, 0);
-
-    // Validate output
-    validate(CLAccessor(dst), ref, direct_convolution_layer_tolerance(dt));
-}
-BOOST_AUTO_TEST_SUITE_END()
-
-BOOST_AUTO_TEST_SUITE_END()
-BOOST_AUTO_TEST_SUITE_END()
-#endif /* DOXYGEN_SKIP_THIS */
diff --git a/tests/validation/NEON/ConvolutionLayer.cpp b/tests/validation/NEON/ConvolutionLayer.cpp
deleted file mode 100644
index ce96a6b321..0000000000
--- a/tests/validation/NEON/ConvolutionLayer.cpp
+++ /dev/null
@@ -1,222 +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.
- */
-#include "NEON/Accessor.h"
-#include "TypePrinter.h"
-#include "dataset/ConvolutionLayerDataset.h"
-#include "tests/Globals.h"
-#include "tests/Utils.h"
-#include "validation/Datasets.h"
-#include "validation/Reference.h"
-#include "validation/Validation.h"
-
-#include "arm_compute/core/Error.h"
-#include "arm_compute/runtime/NEON/functions/NEConvolutionLayer.h"
-
-#include <random>
-
-using namespace arm_compute;
-using namespace arm_compute::test;
-using namespace arm_compute::test::validation;
-
-namespace
-{
-const float tolerance_f32 = 1e-03f; /**< Tolerance value for comparing reference's output against implementation's output for DataType::F32 */
-#ifdef ARM_COMPUTE_ENABLE_FP16
-const float tolerance_f16 = 0.01f; /**< Tolerance value for comparing reference's output against implementation's output for DataType::F16 */
-#endif                             /* ARM_COMPUTE_ENABLE_FP16 */
-const float tolerance_q = 1.0f;    /**< Tolerance value for comparing reference's output against implementation's output for fixed point data types */
-
-Tensor compute_convolution_layer(const TensorShape &input_shape, const TensorShape &weights_shape, const TensorShape &bias_shape, const TensorShape &output_shape, DataType dt,
-                                 const PadStrideInfo &conv_info, int fixed_point_position)
-{
-    // Create tensors
-    Tensor src     = create_tensor<Tensor>(input_shape, dt, 1, fixed_point_position);
-    Tensor weights = create_tensor<Tensor>(weights_shape, dt, 1, fixed_point_position);
-    Tensor bias    = create_tensor<Tensor>(bias_shape, dt, 1, fixed_point_position);
-    Tensor dst     = create_tensor<Tensor>(output_shape, dt, 1, fixed_point_position);
-
-    // Create and configure function
-    NEConvolutionLayer conv;
-    conv.configure(&src, &weights, &bias, &dst, conv_info);
-
-    // Allocate tensors
-    src.allocator()->allocate();
-    weights.allocator()->allocate();
-    bias.allocator()->allocate();
-    dst.allocator()->allocate();
-
-    BOOST_TEST(!src.info()->is_resizable());
-    BOOST_TEST(!weights.info()->is_resizable());
-    BOOST_TEST(!bias.info()->is_resizable());
-    BOOST_TEST(!dst.info()->is_resizable());
-
-    // Fill tensors
-    if(dt == DataType::F16 || dt == DataType::F32)
-    {
-        std::uniform_real_distribution<> distribution(-1.0f, 1.0f);
-        library->fill(Accessor(src), distribution, 0);
-        library->fill(Accessor(weights), distribution, 1);
-        library->fill(Accessor(bias), distribution, 2);
-    }
-    else
-    {
-        library->fill_tensor_uniform(Accessor(src), 0);
-        library->fill_tensor_uniform(Accessor(weights), 1);
-        library->fill_tensor_uniform(Accessor(bias), 2);
-    }
-
-    // Compute NEConvolutionLayer function
-    conv.run();
-
-    return dst;
-}
-} // namespace
-
-#ifndef DOXYGEN_SKIP_THIS
-BOOST_AUTO_TEST_SUITE(NEON)
-BOOST_AUTO_TEST_SUITE(ConvolutionLayer)
-BOOST_AUTO_TEST_SUITE(GEMM)
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit") * boost::unit_test::label("nightly"))
-BOOST_DATA_TEST_CASE(Configuration,
-                     AlexNetConvolutionLayerDataset() * boost::unit_test::data::make({ DataType::F32, DataType::QS8, DataType::QS16 }),
-                     conv_set, dt)
-{
-    // Set fixed point position data type allowed
-    int fixed_point_position = (dt == DataType::F32) ? 0 : 3;
-
-    // Create tensors
-    Tensor src     = create_tensor<Tensor>(conv_set.src_shape, dt, 1, fixed_point_position);
-    Tensor weights = create_tensor<Tensor>(conv_set.weights_shape, dt, 1, fixed_point_position);
-    Tensor bias    = create_tensor<Tensor>(conv_set.bias_shape, dt, 1, fixed_point_position);
-    Tensor dst     = create_tensor<Tensor>(conv_set.dst_shape, dt, 1, fixed_point_position);
-
-    BOOST_TEST(src.info()->is_resizable());
-    BOOST_TEST(weights.info()->is_resizable());
-    BOOST_TEST(bias.info()->is_resizable());
-    BOOST_TEST(dst.info()->is_resizable());
-
-    // Create and configure function
-    NEConvolutionLayer conv;
-    conv.configure(&src, &weights, &bias, &dst, conv_set.info);
-
-    // Validate valid region
-    const ValidRegion src_valid_region     = shape_to_valid_region(conv_set.src_shape);
-    const ValidRegion weights_valid_region = shape_to_valid_region(conv_set.weights_shape);
-    const ValidRegion bias_valid_region    = shape_to_valid_region(conv_set.bias_shape);
-    const ValidRegion dst_valid_region     = shape_to_valid_region(conv_set.dst_shape);
-
-    validate(src.info()->valid_region(), src_valid_region);
-    validate(weights.info()->valid_region(), weights_valid_region);
-    validate(bias.info()->valid_region(), bias_valid_region);
-    validate(dst.info()->valid_region(), dst_valid_region);
-}
-
-#ifdef ARM_COMPUTE_ENABLE_FP16
-BOOST_AUTO_TEST_SUITE(Float16)
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
-BOOST_DATA_TEST_CASE(SmallConvolutionLayer,
-                     SmallConvolutionLayerDataset() * boost::unit_test::data::make(DataType::F16),
-                     conv_set, dt)
-{
-    // Compute function
-    Tensor dst = compute_convolution_layer(conv_set.src_shape, conv_set.weights_shape, conv_set.bias_shape, conv_set.dst_shape, dt, conv_set.info, 0);
-
-    // Compute reference
-    RawTensor ref_dst = Reference::compute_reference_convolution_layer(conv_set.src_shape, conv_set.weights_shape, conv_set.bias_shape, conv_set.dst_shape, dt, conv_set.info, 0);
-
-    // Validate output
-    validate(Accessor(dst), ref_dst, tolerance_f16);
-}
-BOOST_AUTO_TEST_SUITE_END()
-#endif /* ARM_COMPUTE_ENABLE_FP16 */
-
-BOOST_AUTO_TEST_SUITE(Float)
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
-BOOST_DATA_TEST_CASE(SmallConvolutionLayer,
-                     SmallConvolutionLayerDataset() * boost::unit_test::data::make(DataType::F32),
-                     conv_set, dt)
-{
-    // Compute function
-    Tensor dst = compute_convolution_layer(conv_set.src_shape, conv_set.weights_shape, conv_set.bias_shape, conv_set.dst_shape, dt, conv_set.info, 0);
-
-    // Compute reference
-    RawTensor ref_dst = Reference::compute_reference_convolution_layer(conv_set.src_shape, conv_set.weights_shape, conv_set.bias_shape, conv_set.dst_shape, dt, conv_set.info, 0);
-
-    // Validate output
-    validate(Accessor(dst), ref_dst, tolerance_f32);
-}
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("nightly"))
-BOOST_DATA_TEST_CASE(LargeConvolutionLayer,
-                     AlexNetConvolutionLayerDataset() * boost::unit_test::data::make(DataType::F32),
-                     conv_set, dt)
-{
-    // Compute function
-    Tensor dst = compute_convolution_layer(conv_set.src_shape, conv_set.weights_shape, conv_set.bias_shape, conv_set.dst_shape, dt, conv_set.info, 0);
-
-    // Compute reference
-    RawTensor ref_dst = Reference::compute_reference_convolution_layer(conv_set.src_shape, conv_set.weights_shape, conv_set.bias_shape, conv_set.dst_shape, dt, conv_set.info, 0);
-
-    // Validate output
-    validate(Accessor(dst), ref_dst, tolerance_f32);
-}
-BOOST_AUTO_TEST_SUITE_END()
-
-BOOST_AUTO_TEST_SUITE(Quantized)
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
-BOOST_DATA_TEST_CASE(SmallConvolutionLayer,
-                     SmallConvolutionLayerDataset() * boost::unit_test::data::make({ DataType::QS8, DataType::QS16 }) * boost::unit_test::data::xrange(4, 7),
-                     conv_set, dt, fixed_point_position)
-{
-    // Compute function
-    Tensor dst = compute_convolution_layer(conv_set.src_shape, conv_set.weights_shape, conv_set.bias_shape, conv_set.dst_shape, dt, conv_set.info, fixed_point_position);
-
-    // Compute reference
-    RawTensor ref_dst = Reference::compute_reference_convolution_layer(conv_set.src_shape, conv_set.weights_shape, conv_set.bias_shape, conv_set.dst_shape, dt, conv_set.info, fixed_point_position);
-
-    // Validate output
-    validate(Accessor(dst), ref_dst, tolerance_q);
-}
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("nightly"))
-BOOST_DATA_TEST_CASE(LargeConvolutionLayer,
-                     AlexNetConvolutionLayerDataset() * boost::unit_test::data::make({ DataType::QS8, DataType::QS16 }) * boost::unit_test::data::xrange(4, 7),
-                     conv_set, dt, fixed_point_position)
-{
-    // Compute function
-    Tensor dst = compute_convolution_layer(conv_set.src_shape, conv_set.weights_shape, conv_set.bias_shape, conv_set.dst_shape, dt, conv_set.info, fixed_point_position);
-
-    // Compute reference
-    RawTensor ref_dst = Reference::compute_reference_convolution_layer(conv_set.src_shape, conv_set.weights_shape, conv_set.bias_shape, conv_set.dst_shape, dt, conv_set.info, fixed_point_position);
-
-    // Validate output
-    validate(Accessor(dst), ref_dst, tolerance_q);
-}
-BOOST_AUTO_TEST_SUITE_END()
-
-BOOST_AUTO_TEST_SUITE_END()
-BOOST_AUTO_TEST_SUITE_END()
-BOOST_AUTO_TEST_SUITE_END()
-#endif /* DOXYGEN_SKIP_THIS */
diff --git a/tests/validation/NEON/DirectConvolutionLayer.cpp b/tests/validation/NEON/DirectConvolutionLayer.cpp
deleted file mode 100644
index 7022d656e9..0000000000
--- a/tests/validation/NEON/DirectConvolutionLayer.cpp
+++ /dev/null
@@ -1,280 +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.
- */
-#include "AssetsLibrary.h"
-#include "Globals.h"
-#include "NEON/Accessor.h"
-#include "TypePrinter.h"
-#include "Utils.h"
-#include "validation/Datasets.h"
-#include "validation/Reference.h"
-#include "validation/Validation.h"
-
-#include "arm_compute/core/Helpers.h"
-#include "arm_compute/core/Types.h"
-#include "arm_compute/runtime/NEON/functions/NEDirectConvolutionLayer.h"
-#include "arm_compute/runtime/Tensor.h"
-#include "arm_compute/runtime/TensorAllocator.h"
-
-#include "boost_wrapper.h"
-
-#include <random>
-#include <string>
-#include <tuple>
-
-using namespace arm_compute;
-using namespace arm_compute::test;
-using namespace arm_compute::test::validation;
-
-namespace
-{
-const float tolerance_qs = 1.f; /**< Tolerance for 8 bit fixed point tests */
-#ifdef ARM_COMPUTE_ENABLE_FP16
-const float tolerance_fp16 = 0.01f; /**< Tolerance for half precision floating point tests */
-#endif                              /* ARM_COMPUTE_ENABLE_FP16 */
-const float tolerance_fp32 = 1e-3f; /**< Tolerance for floating point tests */
-
-/** Compute NEON direct convolution layer function.
- *
- * @param[in] src_shape            Shape of the input tensor.
- * @param[in] weights_shape        Shape of the weights.
- * @param[in] bias_shape           Shape of the bias tensor.
- * @param[in] dst_shape            Shape of the output tensor.
- * @param[in] dt                   Data type of input, convolution matrix and output tensors.
- * @param[in] conv_info            Padding and stride information.
- * @param[in] fixed_point_position (Optional) Number of bits for the fractional part of the fixed point numbers
- *
- * @return Computed output tensor.
-*/
-Tensor compute_convolution_layer(const TensorShape &src_shape, const TensorShape &weights_shape, const TensorShape &bias_shape, const TensorShape &dst_shape,
-                                 DataType dt, PadStrideInfo conv_info, int fixed_point_position = 0)
-{
-    // Create tensors
-    Tensor src     = create_tensor<Tensor>(src_shape, dt, 1, fixed_point_position);
-    Tensor weights = create_tensor<Tensor>(weights_shape, dt, 1, fixed_point_position);
-    Tensor bias    = create_tensor<Tensor>(bias_shape, dt, 1, fixed_point_position);
-    Tensor dst     = create_tensor<Tensor>(dst_shape, dt, 1, fixed_point_position);
-
-    // Create and configure function
-    NEDirectConvolutionLayer conv_layer;
-    conv_layer.configure(&src, &weights, &bias, &dst, conv_info);
-
-    // Allocate tensors
-    src.allocator()->allocate();
-    weights.allocator()->allocate();
-    bias.allocator()->allocate();
-    dst.allocator()->allocate();
-
-    BOOST_TEST(!src.info()->is_resizable());
-    BOOST_TEST(!weights.info()->is_resizable());
-    BOOST_TEST(!bias.info()->is_resizable());
-    BOOST_TEST(!dst.info()->is_resizable());
-
-    // Fill tensors
-    switch(dt)
-    {
-        case DataType::F16:
-        case DataType::F32:
-        {
-            std::uniform_real_distribution<> distribution(-1.f, 1.f);
-            library->fill(Accessor(src), distribution, 0);
-            library->fill(Accessor(weights), distribution, 1);
-            library->fill(Accessor(bias), distribution, 2);
-            break;
-        }
-        case DataType::QS8:
-        case DataType::QS16:
-        {
-            library->fill_tensor_uniform(Accessor(src), 0);
-            library->fill_tensor_uniform(Accessor(weights), 1);
-            library->fill_tensor_uniform(Accessor(bias), 2);
-            break;
-        }
-        default:
-        {
-            ARM_COMPUTE_ERROR("Data type not supported.");
-            break;
-        }
-    }
-
-    // Compute function
-    conv_layer.run();
-
-    return dst;
-}
-
-TensorShape get_output_shape(TensorShape in_shape, TensorShape kernel_shape, const PadStrideInfo &conv_info)
-{
-    TensorShape out_shape(in_shape);
-    const std::pair<unsigned int, unsigned int> scaled_dims = arm_compute::scaled_dimensions(in_shape.x(),
-                                                                                             in_shape.y(),
-                                                                                             kernel_shape.x(),
-                                                                                             kernel_shape.y(),
-                                                                                             conv_info);
-    out_shape.set(0, scaled_dims.first);
-    out_shape.set(1, scaled_dims.second);
-    out_shape.set(2, kernel_shape[3]);
-    return out_shape;
-}
-
-} // namespace
-
-#ifndef DOXYGEN_SKIP_THIS
-BOOST_AUTO_TEST_SUITE(NEON)
-BOOST_AUTO_TEST_SUITE(ConvolutionLayer)
-BOOST_AUTO_TEST_SUITE(Direct)
-
-#ifdef ARM_COMPUTE_ENABLE_FP16
-BOOST_AUTO_TEST_SUITE(Float16)
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
-BOOST_DATA_TEST_CASE(W1x1,
-                     DirectConvolutionShapes() * boost::unit_test::data::make(DataType::F16) * boost::unit_test::data::xrange(1, 3, 1) * boost::unit_test::data::xrange(1, 3, 1) * boost::unit_test::data::make({ 1, 4, 8, 16 }),
-                     input_shape, dt, sx, sy, num_kernels)
-{
-    const unsigned int  kernel_size = 1;
-    const PadStrideInfo conv_info(sx, sy, 0, 0, DimensionRoundingType::FLOOR);
-    const TensorShape   w_shape(kernel_size, kernel_size, input_shape.z(), static_cast<unsigned int>(num_kernels));
-    const TensorShape   b_shape(static_cast<unsigned int>(num_kernels));
-    const TensorShape   d_shape(get_output_shape(input_shape, w_shape, conv_info));
-
-    Tensor dst = compute_convolution_layer(input_shape, w_shape, b_shape, d_shape, dt, conv_info);
-
-    RawTensor ref = Reference::compute_reference_convolution_layer(input_shape, w_shape, b_shape, d_shape, dt, conv_info, 0);
-
-    // Validate output
-    validate(Accessor(dst), ref);
-}
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
-BOOST_DATA_TEST_CASE(W3x3, DirectConvolutionShapes() * boost::unit_test::data::make(DataType::F16) * boost::unit_test::data::xrange(1, 3, 1) * boost::unit_test::data::xrange(1, 3,
-                     1)
-                     * boost::unit_test::data::xrange(0, 2,
-                                                      1)
-                     * boost::unit_test::data::xrange(0, 2, 1) * boost::unit_test::data::make({ 1, 4, 8, 16 }),
-                     input_shape, dt, sx, sy, px, py, num_kernels)
-{
-    const unsigned int  kernel_size = 3;
-    const PadStrideInfo conv_info(sx, sy, px, py, DimensionRoundingType::FLOOR);
-    const TensorShape   w_shape(kernel_size, kernel_size, input_shape.z(), static_cast<unsigned int>(num_kernels));
-    const TensorShape   b_shape(static_cast<unsigned int>(num_kernels));
-    const TensorShape   d_shape(get_output_shape(input_shape, w_shape, conv_info));
-
-    Tensor dst = compute_convolution_layer(input_shape, w_shape, b_shape, d_shape, dt, conv_info);
-
-    RawTensor ref = Reference::compute_reference_convolution_layer(input_shape, w_shape, b_shape, d_shape, dt, conv_info, 0);
-
-    // Validate output
-    validate(Accessor(dst), ref, tolerance_fp16);
-}
-BOOST_AUTO_TEST_SUITE_END()
-#endif /* ARM_COMPUTE_ENABLE_FP16 */
-
-BOOST_AUTO_TEST_SUITE(Float)
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
-BOOST_DATA_TEST_CASE(W1x1,
-                     DirectConvolutionShapes() * CNNFloatDataTypes() * boost::unit_test::data::xrange(1, 3, 1) * boost::unit_test::data::xrange(1, 3, 1) * boost::unit_test::data::make({ 1, 4, 8, 16 }),
-                     input_shape, dt, sx, sy, num_kernels)
-{
-    const unsigned int  kernel_size = 1;
-    const PadStrideInfo conv_info(sx, sy, 0, 0, DimensionRoundingType::FLOOR);
-    const TensorShape   w_shape(kernel_size, kernel_size, input_shape.z(), static_cast<unsigned int>(num_kernels));
-    const TensorShape   b_shape(static_cast<unsigned int>(num_kernels));
-    const TensorShape   d_shape(get_output_shape(input_shape, w_shape, conv_info));
-
-    Tensor dst = compute_convolution_layer(input_shape, w_shape, b_shape, d_shape, dt, conv_info);
-
-    RawTensor ref = Reference::compute_reference_convolution_layer(input_shape, w_shape, b_shape, d_shape, dt, conv_info, 0);
-
-    // Validate output
-    validate(Accessor(dst), ref);
-}
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
-BOOST_DATA_TEST_CASE(W3x3, DirectConvolutionShapes() * CNNFloatDataTypes() * boost::unit_test::data::xrange(1, 3, 1) * boost::unit_test::data::xrange(1, 3, 1) * boost::unit_test::data::xrange(0, 2,
-                     1)
-                     * boost::unit_test::data::xrange(0, 2, 1) * boost::unit_test::data::make({ 1, 4, 8, 16 }),
-                     input_shape, dt, sx, sy, px, py, num_kernels)
-{
-    const unsigned int  kernel_size = 3;
-    const PadStrideInfo conv_info(sx, sy, px, py, DimensionRoundingType::FLOOR);
-    const TensorShape   w_shape(kernel_size, kernel_size, input_shape.z(), static_cast<unsigned int>(num_kernels));
-    const TensorShape   b_shape(static_cast<unsigned int>(num_kernels));
-    const TensorShape   d_shape(get_output_shape(input_shape, w_shape, conv_info));
-
-    Tensor dst = compute_convolution_layer(input_shape, w_shape, b_shape, d_shape, dt, conv_info);
-
-    RawTensor ref = Reference::compute_reference_convolution_layer(input_shape, w_shape, b_shape, d_shape, dt, conv_info, 0);
-
-    // Validate output
-    validate(Accessor(dst), ref, tolerance_fp32);
-}
-BOOST_AUTO_TEST_SUITE_END()
-
-BOOST_AUTO_TEST_SUITE(Quantized)
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
-BOOST_DATA_TEST_CASE(W1x1,
-                     DirectConvolutionShapes() * boost::unit_test::data::make({ DataType::QS8, DataType::QS16 }) * boost::unit_test::data::xrange(1, 3, 1) * boost::unit_test::data::xrange(1, 3,
-                             1)
-                     * boost::unit_test::data::make({ 1, 4, 8, 16 }) * boost::unit_test::data::make({ 4, 5 }),
-                     input_shape, dt, sx, sy, num_kernels, fixed_point_position)
-{
-    const unsigned int  kernel_size = 1;
-    const PadStrideInfo conv_info(sx, sy, 0, 0, DimensionRoundingType::FLOOR);
-    const TensorShape   w_shape(kernel_size, kernel_size, input_shape.z(), static_cast<unsigned int>(num_kernels));
-    const TensorShape   b_shape(static_cast<unsigned int>(num_kernels));
-    const TensorShape   d_shape(get_output_shape(input_shape, w_shape, conv_info));
-
-    Tensor dst = compute_convolution_layer(input_shape, w_shape, b_shape, d_shape, dt, conv_info, fixed_point_position);
-
-    RawTensor ref = Reference::compute_reference_convolution_layer(input_shape, w_shape, b_shape, d_shape, dt, conv_info, fixed_point_position);
-
-    // Validate output
-    validate(Accessor(dst), ref, tolerance_qs);
-}
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
-BOOST_DATA_TEST_CASE(W3x3, DirectConvolutionShapes() * boost::unit_test::data::make(DataType::QS8) * boost::unit_test::data::xrange(1, 3, 1) * boost::unit_test::data::xrange(1, 3,
-                     1)
-                     * boost::unit_test::data::xrange(0, 2, 1)
-                     * boost::unit_test::data::xrange(0, 2, 1) * boost::unit_test::data::make({ 1, 4, 8, 16 }) * boost::unit_test::data::make({ 4, 5 }),
-                     input_shape, dt, sx, sy, px, py, num_kernels, fixed_point_position)
-{
-    const unsigned int  kernel_size = 3;
-    const PadStrideInfo conv_info(sx, sy, px, py, DimensionRoundingType::FLOOR);
-    const TensorShape   w_shape(kernel_size, kernel_size, input_shape.z(), static_cast<unsigned int>(num_kernels));
-    const TensorShape   b_shape(static_cast<unsigned int>(num_kernels));
-    const TensorShape   d_shape(get_output_shape(input_shape, w_shape, conv_info));
-
-    Tensor dst = compute_convolution_layer(input_shape, w_shape, b_shape, d_shape, dt, conv_info, fixed_point_position);
-
-    RawTensor ref = Reference::compute_reference_convolution_layer(input_shape, w_shape, b_shape, d_shape, dt, conv_info, fixed_point_position);
-
-    // Validate output
-    validate(Accessor(dst), ref, tolerance_qs);
-}
-BOOST_AUTO_TEST_SUITE_END()
-
-BOOST_AUTO_TEST_SUITE_END()
-BOOST_AUTO_TEST_SUITE_END()
-BOOST_AUTO_TEST_SUITE_END()
-#endif /* DOXYGEN_SKIP_THIS */
diff --git a/tests/validation/Reference.cpp b/tests/validation/Reference.cpp
index 145f308c50..99e3095007 100644
--- a/tests/validation/Reference.cpp
+++ b/tests/validation/Reference.cpp
@@ -515,48 +515,6 @@ RawTensor Reference::compute_reference_batch_normalization_layer(const TensorSha
     return ref_dst;
 }
 
-RawTensor Reference::compute_reference_convolution_layer(const TensorShape &input_shape, const TensorShape &weights_shape, const TensorShape &bias_shape, const TensorShape &output_shape, DataType dt,
-                                                         const PadStrideInfo &conv_info, int fixed_point_position)
-{
-    // Create reference
-    RawTensor ref_src(input_shape, dt, 1, fixed_point_position);
-    RawTensor ref_weights(weights_shape, dt, 1, fixed_point_position);
-    RawTensor ref_bias(bias_shape, dt, 1, fixed_point_position);
-    RawTensor ref_dst(output_shape, dt, 1, fixed_point_position);
-
-    // Fill reference
-    switch(dt)
-    {
-        case DataType::F32:
-        case DataType::F16:
-        {
-            std::uniform_real_distribution<> distribution(-1.0f, 1.0f);
-            library->fill(ref_src, distribution, 0);
-            library->fill(ref_weights, distribution, 1);
-            library->fill(ref_bias, distribution, 2);
-            break;
-        }
-        case DataType::QS16:
-        case DataType::QS8:
-        {
-            library->fill_tensor_uniform(ref_src, 0);
-            library->fill_tensor_uniform(ref_weights, 1);
-            library->fill_tensor_uniform(ref_bias, 2);
-            break;
-        }
-        default:
-        {
-            ARM_COMPUTE_ERROR("Not supported");
-            break;
-        }
-    }
-
-    // Compute reference
-    ReferenceCPP::convolution_layer(ref_src, ref_weights, ref_bias, ref_dst, conv_info);
-
-    return ref_dst;
-}
-
 RawTensor Reference::compute_reference_fully_connected_layer(const TensorShape &input_shape, const TensorShape &weights_shape, const TensorShape &bias_shape, const TensorShape &output_shape,
                                                              DataType dt, bool transpose_weights, int fixed_point_position)
 {
diff --git a/tests/validation/Reference.h b/tests/validation/Reference.h
index 8c22545cb1..f3216fbaf9 100644
--- a/tests/validation/Reference.h
+++ b/tests/validation/Reference.h
@@ -306,20 +306,6 @@ public:
      * @return Computed raw tensor.
      */
     static RawTensor compute_reference_batch_normalization_layer(const TensorShape &shape0, const TensorShape &shape1, DataType dt, float epsilon, int fixed_point_position = 0);
-    /** Compute reference convolution layer
-     *
-     * @param[in] input_shape          Shape for the input tensor
-     * @param[in] weights_shape        Shape for the weights tensor
-     * @param[in] bias_shape           Shape for the bias tensor
-     * @param[in] output_shape         Shape for the output tensor
-     * @param[in] dt                   Data type to use
-     * @param[in] conv_info            Pads and strides information for the convolution layer
-     * @param[in] fixed_point_position Number of bits for the fractional part of the fixed point numbers
-     *
-     * @return Computed raw tensor.
-     */
-    static RawTensor compute_reference_convolution_layer(const TensorShape &input_shape, const TensorShape &weights_shape, const TensorShape &bias_shape, const TensorShape &output_shape, DataType dt,
-                                                         const PadStrideInfo &conv_info, int fixed_point_position);
     /** Compute reference for fully connected layer function
      *
      * @param[in] input_shape          Shape for the input tensor
diff --git a/tests/validation/ReferenceCPP.cpp b/tests/validation/ReferenceCPP.cpp
index 5f3fa1fcbc..6b902ae3f2 100644
--- a/tests/validation/ReferenceCPP.cpp
+++ b/tests/validation/ReferenceCPP.cpp
@@ -296,16 +296,6 @@ void ReferenceCPP::batch_normalization_layer(const RawTensor &src, RawTensor &ds
     boost::apply_visitor(tensor_visitors::batch_normalization_layer_visitor(s, m, v, b, g, epsilon, fixed_point_position), d);
 }
 
-// Convolution Layer
-void ReferenceCPP::convolution_layer(const RawTensor &src, const RawTensor &weights, const RawTensor &bias, RawTensor &dst, const PadStrideInfo &conv_info)
-{
-    const TensorVariant s = TensorFactory::get_tensor(src);
-    const TensorVariant w = TensorFactory::get_tensor(weights);
-    const TensorVariant b = TensorFactory::get_tensor(bias);
-    TensorVariant       d = TensorFactory::get_tensor(dst);
-    boost::apply_visitor(tensor_visitors::convolution_layer_visitor(s, w, b, conv_info), d);
-}
-
 // Fully connected layer
 void ReferenceCPP::fully_connected_layer(const RawTensor &src, const RawTensor &weights, const RawTensor &bias, RawTensor &dst)
 {
diff --git a/tests/validation/ReferenceCPP.h b/tests/validation/ReferenceCPP.h
index ab77d783b6..d289e8e57e 100644
--- a/tests/validation/ReferenceCPP.h
+++ b/tests/validation/ReferenceCPP.h
@@ -266,15 +266,6 @@ public:
      */
     static void batch_normalization_layer(const RawTensor &src, RawTensor &dst, const RawTensor &mean, const RawTensor &var, const RawTensor &beta, const RawTensor &gamma, float epsilon,
                                           int fixed_point_position = 0);
-    /** Convolution layer function
-     *
-     * @param[in]  src       Input tensor.
-     * @param[in]  weights   Weights tensor.
-     * @param[in]  bias      Bias tensor.
-     * @param[out] dst       Result tensor.
-     * @param[in]  conv_info Pads and strides information for the convolution layer.
-     */
-    static void convolution_layer(const RawTensor &src, const RawTensor &weights, const RawTensor &bias, RawTensor &dst, const PadStrideInfo &conv_info);
     /** Fully connected layer function
      *
      * @param[in]  src     Input tensor
diff --git a/tests/validation/TensorOperations.h b/tests/validation/TensorOperations.h
index 84aa965a9f..f4d2110387 100644
--- a/tests/validation/TensorOperations.h
+++ b/tests/validation/TensorOperations.h
@@ -59,100 +59,6 @@ struct is_floating_point
 {
 };
 
-bool is_valid_pixel(int i, int min, int max)
-{
-    return (i >= min && i < max);
-}
-
-// 3D convolution for floating point type
-template <typename T, typename std::enable_if<is_floating_point<T>::value, int>::type * = nullptr>
-void convolution3d(const T *in, const T *weights, const T *bias, T *out, int xi, int yi, int width_in, int height_in, int depth_in, int width_weights, int height_weights, int8_t fixed_point_position)
-{
-    const int half_width_weights  = width_weights / 2;
-    const int half_height_weights = height_weights / 2;
-
-    // Reset accumulator
-    T acc = static_cast<T>(0);
-
-    // Compute a 2D convolution for each IFM and accumulate the result
-    for(int ifm = 0; ifm < depth_in; ++ifm)
-    {
-        // Compute the offset for the input slice
-        const int offset_slice_in = xi + yi * width_in + ifm * width_in * height_in;
-
-        // Compute 2D convolution
-        for(int yk = -half_height_weights; yk <= half_height_weights; ++yk)
-        {
-            for(int xk = -half_width_weights; xk <= half_width_weights; ++xk)
-            {
-                // Check if the pixel is out-of-bound
-                if(is_valid_pixel(xi + xk, 0, width_in) && is_valid_pixel(yi + yk, 0, height_in))
-                {
-                    const int idx = xk + half_width_weights;
-                    const int idy = yk + half_height_weights;
-
-                    const T i_value = in[offset_slice_in + xk + yk * width_in];
-                    const T w_value = weights[idx + idy * width_weights + ifm * width_weights * height_weights];
-
-                    acc += i_value * w_value;
-                }
-            }
-        }
-    }
-
-    // Accumulate the bias and store the result
-    *out = acc + (*bias);
-}
-
-// 3D convolution for fixed point type
-template <typename T, typename std::enable_if<std::is_integral<T>::value, int>::type * = nullptr>
-void convolution3d(const T *in, const T *weights, const T *bias, T *out, int xi, int yi, int width_in, int height_in, int depth_in, int width_weights, int height_weights,
-                   int8_t fixed_point_position)
-{
-    const int half_width_weights  = width_weights / 2;
-    const int half_height_weights = height_weights / 2;
-
-    using namespace fixed_point_arithmetic;
-    using promoted_type = typename fixed_point_arithmetic::traits::promote<T>::type;
-
-    // Reset accumulator
-    fixed_point<promoted_type> acc(0, fixed_point_position);
-
-    // Compute a 2D convolution for each IFM and accumulate the result
-    for(int ifm = 0; ifm < depth_in; ++ifm)
-    {
-        // Compute the offset for the input slice
-        const int offset_slice_in = xi + yi * width_in + ifm * width_in * height_in;
-
-        // Compute 2D convolution
-        for(int yk = -half_height_weights; yk <= half_height_weights; ++yk)
-        {
-            for(int xk = -half_width_weights; xk <= half_width_weights; ++xk)
-            {
-                // Check if the pixel is out-of-bound
-                if(is_valid_pixel(xi + xk, 0, width_in) && is_valid_pixel(yi + yk, 0, height_in))
-                {
-                    const int idx = xk + half_width_weights;
-                    const int idy = yk + half_height_weights;
-
-                    const fixed_point<promoted_type> i_value(in[offset_slice_in + xk + yk * width_in], fixed_point_position, true);
-                    const fixed_point<promoted_type> w_value(weights[idx + idy * width_weights + ifm * width_weights * height_weights], fixed_point_position, true);
-                    const fixed_point<promoted_type> iw = i_value * w_value;
-                    acc                                 = iw + acc;
-                }
-            }
-        }
-    }
-
-    // Get the bias
-    const fixed_point<promoted_type> b(*bias, fixed_point_position, true);
-
-    // Accumulate the bias and covert back
-    acc = acc + b;
-    fixed_point<T> res(acc);
-    *out = res.raw();
-}
-
 template <typename T, typename std::enable_if<is_floating_point<T>::value, int>::type * = nullptr>
 void vector_matrix_multiply(const T *in, const T *weights, const T *bias, T *out, int cols_weights, int rows_weights, uint8_t fixed_point_position)
 {
@@ -999,58 +905,6 @@ void batch_normalization_layer(const Tensor<T> &in, Tensor<T> &out, const Tensor
     }
 }
 
-// Convolution layer
-template <typename T>
-void convolution_layer(const Tensor<T> &in, const Tensor<T> &weights, const Tensor<T> &bias, Tensor<T> &out, const PadStrideInfo &conv_info)
-{
-    const int width_in       = in.shape().x();
-    const int height_in      = in.shape().y();
-    const int depth_in       = in.shape().z();
-    const int width_out      = out.shape().x();
-    const int height_out     = out.shape().y();
-    const int depth_out      = out.shape().z();
-    const int width_weights  = weights.shape().x();
-    const int height_weights = weights.shape().y();
-    const int depth_weights  = weights.shape().z();
-    const int pad_xi         = std::min(static_cast<int>(conv_info.pad().first), width_weights / 2);
-    const int pad_yi         = std::min(static_cast<int>(conv_info.pad().second), height_weights / 2);
-    const int start_xi       = width_weights / 2 - pad_xi;
-    const int start_yi       = height_weights / 2 - pad_yi;
-    const int end_xi         = width_in - start_xi;
-    const int end_yi         = height_in - start_yi;
-    const int stride_xi      = conv_info.stride().first;
-    const int stride_yi      = conv_info.stride().second;
-    const int num_batches    = in.shape().total_size() / (width_in * height_in * depth_in);
-
-    for(int r = 0; r < num_batches; ++r)
-    {
-        for(int yi = start_yi; yi < end_yi; yi += stride_yi)
-        {
-            for(int xi = start_xi; xi < end_xi; xi += stride_xi)
-            {
-                for(int ofm = 0; ofm < depth_out; ++ofm)
-                {
-                    // Compute input and output offsets
-                    const int offset_in  = r * width_in * height_in * depth_in;
-                    const int xo         = (xi - start_xi) / stride_xi;
-                    const int yo         = (yi - start_yi) / stride_yi;
-                    const int offset_out = xo + yo * width_out + ofm * width_out * height_out + r * width_out * height_out * depth_out;
-
-                    // Compute 3D convolution
-                    convolution3d(in.data() + offset_in,
-                                  weights.data() + ofm * width_weights * height_weights * depth_weights,
-                                  bias.data() + ofm,
-                                  out.data() + offset_out,
-                                  xi, yi,
-                                  width_in, height_in, depth_in,
-                                  width_weights, height_weights,
-                                  static_cast<int8_t>(in.fixed_point_position()));
-                }
-            }
-        }
-    }
-}
-
 // Fully connected layer
 template <typename T>
 void fully_connected_layer(const Tensor<T> &in, const Tensor<T> &weights, const Tensor<T> &bias, Tensor<T> &out)
diff --git a/tests/validation/TensorVisitors.h b/tests/validation/TensorVisitors.h
index d72b437344..67f1d8a001 100644
--- a/tests/validation/TensorVisitors.h
+++ b/tests/validation/TensorVisitors.h
@@ -254,30 +254,6 @@ private:
     float                _epsilon;
     int                  _fixed_point_position;
 };
-// Convolution Layer visitor
-struct convolution_layer_visitor : public boost::static_visitor<>
-{
-public:
-    explicit convolution_layer_visitor(const TensorVariant &in, const TensorVariant &weights, const TensorVariant &bias, PadStrideInfo conv_info)
-        : _in(in), _weights(weights), _bias(bias), _conv_info(conv_info)
-    {
-    }
-
-    template <typename T>
-    void operator()(Tensor<T> &out) const
-    {
-        const Tensor<T> &in      = boost::get<Tensor<T>>(_in);
-        const Tensor<T> &weights = boost::get<Tensor<T>>(_weights);
-        const Tensor<T> &bias    = boost::get<Tensor<T>>(_bias);
-        tensor_operations::convolution_layer(in, weights, bias, out, _conv_info);
-    }
-
-private:
-    const TensorVariant &_in;
-    const TensorVariant &_weights;
-    const TensorVariant &_bias;
-    PadStrideInfo        _conv_info;
-};
 // Fully Connected Layer visitor
 struct fully_connected_layer_visitor : public boost::static_visitor<>
 {