COMPMID-503: Move MinMaxLocation to new validation

Change-Id: I2d518b3a3f15e2c4786488593dac244c1d74a0f9
Reviewed-on: http://mpd-gerrit.cambridge.arm.com/86533
Tested-by: Kaizen <jeremy.johnson+kaizengerrit@arm.com>
Reviewed-by: Moritz Pflanzer <moritz.pflanzer@arm.com>

9 files changed, 0 insertions, 796 deletions

diff --git a/tests/validation_old/CL/MinMaxLocation.cpp b/tests/validation_old/CL/MinMaxLocation.cpp
deleted file mode 100644
index 06e9388abc..0000000000
--- a/tests/validation_old/CL/MinMaxLocation.cpp
+++ /dev/null
@@ -1,397 +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 "Utils.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/validation_old/Datasets.h"
-#include "tests/validation_old/Reference.h"
-#include "tests/validation_old/Validation.h"
-#include "utils/TypePrinter.h"
-
-#include "arm_compute/core/Helpers.h"
-#include "arm_compute/core/Types.h"
-#include "arm_compute/runtime/CL/functions/CLMinMaxLocation.h"
-#include "arm_compute/runtime/Tensor.h"
-#include "arm_compute/runtime/TensorAllocator.h"
-
-#include "PaddingCalculator.h"
-#include "tests/validation_old/boost_wrapper.h"
-
-#include <random>
-#include <string>
-
-using namespace arm_compute;
-using namespace arm_compute::test;
-using namespace arm_compute::test::validation;
-
-namespace
-{
-/** Compute CL MinMaxLocation function.
- *
- * @param[in]  shape     Shape of the input and output tensors.
- * @param[in]  dt_in     Data type of first input tensor.
- * @param[out] min       Minimum value of tensor
- * @param[out] max       Maximum value of tensor
- * @param[out] min_loc   Array with locations of minimum values
- * @param[out] max_loc   Array with locations of maximum values
- * @param[out] min_count Number of minimum values found
- * @param[out] max_count Number of maximum values found
- *
- * @return Computed output tensor.
- */
-void compute_min_max_location(const TensorShape &shape, DataType dt_in, void *min, void *max,
-                              CLCoordinates2DArray &min_loc, CLCoordinates2DArray &max_loc, uint32_t &min_count, uint32_t &max_count)
-{
-    // Create tensor
-    CLTensor src = create_tensor<CLTensor>(shape, dt_in);
-
-    // Create and configure min_max_location configure function
-    CLMinMaxLocation min_max_loc;
-    min_max_loc.configure(&src, min, max, &min_loc, &max_loc, &min_count, &max_count);
-
-    // Allocate tensors
-    src.allocator()->allocate();
-
-    BOOST_TEST(!src.info()->is_resizable());
-
-    // Fill tensors
-    library->fill_tensor_uniform(CLAccessor(src), 0);
-
-    // Compute function
-    min_max_loc.run();
-}
-
-void validate_configuration(const CLTensor &src, TensorShape shape)
-{
-    BOOST_TEST(src.info()->is_resizable());
-
-    // Create output storage
-    int32_t              min;
-    int32_t              max;
-    CLCoordinates2DArray min_loc(shape.total_size());
-    CLCoordinates2DArray max_loc(shape.total_size());
-    uint32_t             min_count;
-    uint32_t             max_count;
-
-    // Create and configure function
-    CLMinMaxLocation min_max_loc;
-    min_max_loc.configure(&src, &min, &max, &min_loc, &max_loc, &min_count, &max_count);
-
-    // Validate valid region
-    const ValidRegion valid_region = shape_to_valid_region(shape);
-    validate(src.info()->valid_region(), valid_region);
-
-    // Validate padding
-    const PaddingSize padding = PaddingCalculator(shape.x(), src.info()->dimension(0)).required_padding();
-    validate(src.info()->padding(), padding);
-}
-} // namespace
-
-#ifndef DOXYGEN_SKIP_THIS
-BOOST_AUTO_TEST_SUITE(CL)
-BOOST_AUTO_TEST_SUITE(MinMaxLocation)
-BOOST_AUTO_TEST_SUITE(U8)
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit") * boost::unit_test::label("nightly"))
-BOOST_DATA_TEST_CASE(Configuration, (Small2DShapes() + Large2DShapes()),
-                     shape)
-{
-    // Create tensor
-    CLTensor src = create_tensor<CLTensor>(shape, DataType::U8);
-    src.info()->set_format(Format::U8);
-
-    validate_configuration(src, shape);
-}
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
-BOOST_DATA_TEST_CASE(RunSmall, Small2DShapes(),
-                     shape)
-{
-    // Create output storage
-    int32_t              min;
-    int32_t              max;
-    CLCoordinates2DArray min_loc(shape.total_size());
-    CLCoordinates2DArray max_loc(shape.total_size());
-    uint32_t             min_count;
-    uint32_t             max_count;
-
-    int32_t              ref_min;
-    int32_t              ref_max;
-    CLCoordinates2DArray ref_min_loc(shape.total_size());
-    CLCoordinates2DArray ref_max_loc(shape.total_size());
-    uint32_t             ref_min_count;
-    uint32_t             ref_max_count;
-
-    // Compute function
-    compute_min_max_location(shape, DataType::U8, &min, &max, min_loc, max_loc, min_count, max_count);
-
-    // Compute reference
-    ref_min_loc.map();
-    ref_max_loc.map();
-
-    Reference::compute_reference_min_max_location(shape, DataType::U8, &ref_min, &ref_max, ref_min_loc, ref_max_loc, ref_min_count, ref_max_count);
-
-    min_loc.map();
-    max_loc.map();
-
-    // Validate output
-    validate_min_max_loc(min, ref_min, max, ref_max, min_loc, ref_min_loc, max_loc, ref_max_loc, min_count, ref_min_count, max_count, ref_max_count);
-
-    ref_min_loc.unmap();
-    ref_max_loc.unmap();
-    min_loc.unmap();
-    max_loc.unmap();
-}
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("nightly"))
-BOOST_DATA_TEST_CASE(RunLarge, Large2DShapes(),
-                     shape)
-{
-    // Create output storage
-    int32_t              min;
-    int32_t              max;
-    CLCoordinates2DArray min_loc(shape.total_size());
-    CLCoordinates2DArray max_loc(shape.total_size());
-    uint32_t             min_count;
-    uint32_t             max_count;
-
-    int32_t              ref_min;
-    int32_t              ref_max;
-    CLCoordinates2DArray ref_min_loc(shape.total_size());
-    CLCoordinates2DArray ref_max_loc(shape.total_size());
-    uint32_t             ref_min_count;
-    uint32_t             ref_max_count;
-
-    // Compute function
-    compute_min_max_location(shape, DataType::U8, &min, &max, min_loc, max_loc, min_count, max_count);
-
-    // Compute reference
-    ref_min_loc.map();
-    ref_max_loc.map();
-
-    Reference::compute_reference_min_max_location(shape, DataType::U8, &ref_min, &ref_max, ref_min_loc, ref_max_loc, ref_min_count, ref_max_count);
-
-    min_loc.map();
-    max_loc.map();
-
-    // Validate output
-    validate_min_max_loc(min, ref_min, max, ref_max, min_loc, ref_min_loc, max_loc, ref_max_loc, min_count, ref_min_count, max_count, ref_max_count);
-
-    ref_min_loc.unmap();
-    ref_max_loc.unmap();
-    min_loc.unmap();
-    max_loc.unmap();
-}
-BOOST_AUTO_TEST_SUITE_END()
-
-BOOST_AUTO_TEST_SUITE(S16)
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit") * boost::unit_test::label("nightly"))
-BOOST_DATA_TEST_CASE(Configuration, (Small2DShapes() + Large2DShapes()),
-                     shape)
-{
-    // Create tensor
-    CLTensor src = create_tensor<CLTensor>(shape, DataType::S16);
-    src.info()->set_format(Format::S16);
-
-    validate_configuration(src, shape);
-}
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
-BOOST_DATA_TEST_CASE(RunSmall, Small2DShapes(),
-                     shape)
-{
-    // Create output storage
-    int32_t              min;
-    int32_t              max;
-    CLCoordinates2DArray min_loc(shape.total_size());
-    CLCoordinates2DArray max_loc(shape.total_size());
-    uint32_t             min_count;
-    uint32_t             max_count;
-
-    int32_t              ref_min;
-    int32_t              ref_max;
-    CLCoordinates2DArray ref_min_loc(shape.total_size());
-    CLCoordinates2DArray ref_max_loc(shape.total_size());
-    uint32_t             ref_min_count;
-    uint32_t             ref_max_count;
-
-    // Compute function
-    compute_min_max_location(shape, DataType::S16, &min, &max, min_loc, max_loc, min_count, max_count);
-
-    // Compute reference
-    ref_min_loc.map();
-    ref_max_loc.map();
-
-    Reference::compute_reference_min_max_location(shape, DataType::S16, &ref_min, &ref_max, ref_min_loc, ref_max_loc, ref_min_count, ref_max_count);
-
-    min_loc.map();
-    max_loc.map();
-
-    // Validate output
-    validate_min_max_loc(min, ref_min, max, ref_max, min_loc, ref_min_loc, max_loc, ref_max_loc, min_count, ref_min_count, max_count, ref_max_count);
-
-    ref_min_loc.unmap();
-    ref_max_loc.unmap();
-    min_loc.unmap();
-    max_loc.unmap();
-}
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("nightly"))
-BOOST_DATA_TEST_CASE(RunLarge, Large2DShapes(),
-                     shape)
-{
-    // Create output storage
-    int32_t              min;
-    int32_t              max;
-    CLCoordinates2DArray min_loc(shape.total_size());
-    CLCoordinates2DArray max_loc(shape.total_size());
-    uint32_t             min_count;
-    uint32_t             max_count;
-
-    int32_t              ref_min;
-    int32_t              ref_max;
-    CLCoordinates2DArray ref_min_loc(shape.total_size());
-    CLCoordinates2DArray ref_max_loc(shape.total_size());
-    uint32_t             ref_min_count;
-    uint32_t             ref_max_count;
-
-    // Compute function
-    compute_min_max_location(shape, DataType::S16, &min, &max, min_loc, max_loc, min_count, max_count);
-
-    // Compute reference
-    ref_min_loc.map();
-    ref_max_loc.map();
-
-    Reference::compute_reference_min_max_location(shape, DataType::S16, &ref_min, &ref_max, ref_min_loc, ref_max_loc, ref_min_count, ref_max_count);
-
-    min_loc.map();
-    max_loc.map();
-
-    // Validate output
-    validate_min_max_loc(min, ref_min, max, ref_max, min_loc, ref_min_loc, max_loc, ref_max_loc, min_count, ref_min_count, max_count, ref_max_count);
-
-    ref_min_loc.unmap();
-    ref_max_loc.unmap();
-    min_loc.unmap();
-    max_loc.unmap();
-}
-BOOST_AUTO_TEST_SUITE_END()
-
-BOOST_AUTO_TEST_SUITE(Float)
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit") * boost::unit_test::label("nightly"))
-BOOST_DATA_TEST_CASE(Configuration, (Small2DShapes() + Large2DShapes()),
-                     shape)
-{
-    // Create tensor
-    CLTensor src = create_tensor<CLTensor>(shape, DataType::F32);
-
-    validate_configuration(src, shape);
-}
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
-BOOST_DATA_TEST_CASE(RunSmall, Small2DShapes(),
-                     shape)
-{
-    // Create output storage
-    float                min;
-    float                max;
-    CLCoordinates2DArray min_loc(shape.total_size());
-    CLCoordinates2DArray max_loc(shape.total_size());
-    uint32_t             min_count;
-    uint32_t             max_count;
-
-    float                ref_min;
-    float                ref_max;
-    CLCoordinates2DArray ref_min_loc(shape.total_size());
-    CLCoordinates2DArray ref_max_loc(shape.total_size());
-    uint32_t             ref_min_count;
-    uint32_t             ref_max_count;
-
-    // Compute function
-    compute_min_max_location(shape, DataType::F32, &min, &max, min_loc, max_loc, min_count, max_count);
-
-    // Compute reference
-    ref_min_loc.map();
-    ref_max_loc.map();
-
-    Reference::compute_reference_min_max_location(shape, DataType::F32, &ref_min, &ref_max, ref_min_loc, ref_max_loc, ref_min_count, ref_max_count);
-
-    min_loc.map();
-    max_loc.map();
-
-    // Validate output
-    validate_min_max_loc(min, ref_min, max, ref_max, min_loc, ref_min_loc, max_loc, ref_max_loc, min_count, ref_min_count, max_count, ref_max_count);
-
-    ref_min_loc.unmap();
-    ref_max_loc.unmap();
-    min_loc.unmap();
-    max_loc.unmap();
-}
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("nightly"))
-BOOST_DATA_TEST_CASE(RunLarge, Large2DShapes(),
-                     shape)
-{
-    // Create output storage
-    float                min;
-    float                max;
-    CLCoordinates2DArray min_loc(shape.total_size());
-    CLCoordinates2DArray max_loc(shape.total_size());
-    uint32_t             min_count;
-    uint32_t             max_count;
-
-    float                ref_min;
-    float                ref_max;
-    CLCoordinates2DArray ref_min_loc(shape.total_size());
-    CLCoordinates2DArray ref_max_loc(shape.total_size());
-    uint32_t             ref_min_count;
-    uint32_t             ref_max_count;
-
-    // Compute function
-    compute_min_max_location(shape, DataType::F32, &min, &max, min_loc, max_loc, min_count, max_count);
-
-    // Compute reference
-    ref_min_loc.map();
-    ref_max_loc.map();
-
-    Reference::compute_reference_min_max_location(shape, DataType::F32, &ref_min, &ref_max, ref_min_loc, ref_max_loc, ref_min_count, ref_max_count);
-
-    min_loc.map();
-    max_loc.map();
-
-    // Validate output
-    validate_min_max_loc(min, ref_min, max, ref_max, min_loc, ref_min_loc, max_loc, ref_max_loc, min_count, ref_min_count, max_count, ref_max_count);
-
-    ref_min_loc.unmap();
-    ref_max_loc.unmap();
-    min_loc.unmap();
-    max_loc.unmap();
-}
-BOOST_AUTO_TEST_SUITE_END()
-
-BOOST_AUTO_TEST_SUITE_END()
-BOOST_AUTO_TEST_SUITE_END()
-#endif /* DOXYGEN_SKIP_THIS */
diff --git a/tests/validation_old/NEON/MinMaxLocation.cpp b/tests/validation_old/NEON/MinMaxLocation.cpp
deleted file mode 100644
index 1b258d19d6..0000000000
--- a/tests/validation_old/NEON/MinMaxLocation.cpp
+++ /dev/null
@@ -1,224 +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 "NEON/Helper.h"
-#include "PaddingCalculator.h"
-#include "Utils.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/validation_old/Datasets.h"
-#include "tests/validation_old/Reference.h"
-#include "tests/validation_old/Validation.h"
-#include "utils/TypePrinter.h"
-
-#include "arm_compute/core/Helpers.h"
-#include "arm_compute/core/Types.h"
-#include "arm_compute/runtime/NEON/functions/NEMinMaxLocation.h"
-#include "arm_compute/runtime/Tensor.h"
-#include "arm_compute/runtime/TensorAllocator.h"
-
-#include "tests/validation_old/boost_wrapper.h"
-
-#include <random>
-#include <string>
-
-using namespace arm_compute;
-using namespace arm_compute::test;
-using namespace arm_compute::test::validation;
-
-namespace
-{
-/** Compute Neon MinMaxLocation function.
- *
- * @param[in]  shape     Shape of the input and output tensors.
- * @param[in]  dt_in     Data type of first input tensor.
- * @param[out] min       Minimum value of tensor
- * @param[out] max       Maximum value of tensor
- * @param[out] min_loc   Array with locations of minimum values
- * @param[out] max_loc   Array with locations of maximum values
- * @param[out] min_count Number of minimum values found
- * @param[out] max_count Number of maximum values found
- *
- * @return Computed output tensor.
- */
-
-void compute_min_max_location(const TensorShape &shape, DataType dt_in, void *min, void *max,
-                              Coordinates2DArray &min_loc, Coordinates2DArray &max_loc, uint32_t &min_count, uint32_t &max_count)
-{
-    // Create tensor
-    Tensor src = create_tensor<Tensor>(shape, dt_in);
-
-    // Create and configure min_max_location configure function
-    NEMinMaxLocation min_max_loc;
-    min_max_loc.configure(&src, min, max, &min_loc, &max_loc, &min_count, &max_count);
-
-    // Allocate tensors
-    src.allocator()->allocate();
-
-    BOOST_TEST(!src.info()->is_resizable());
-
-    // Fill tensors
-    library->fill_tensor_uniform(Accessor(src), 0);
-
-    // Compute function
-    min_max_loc.run();
-}
-
-void validate_configuration(const Tensor &src, TensorShape shape)
-{
-    BOOST_TEST(src.info()->is_resizable());
-
-    // Create output storage
-    int32_t            min;
-    int32_t            max;
-    Coordinates2DArray min_loc;
-    Coordinates2DArray max_loc;
-    uint32_t           min_count;
-    uint32_t           max_count;
-
-    // Create and configure function
-    NEMinMaxLocation min_max_loc;
-    min_max_loc.configure(&src, &min, &max, &min_loc, &max_loc, &min_count, &max_count);
-
-    // Validate valid region
-    const ValidRegion valid_region = shape_to_valid_region(shape);
-    validate(src.info()->valid_region(), valid_region);
-
-    // Validate padding
-    const PaddingSize padding = PaddingCalculator(shape.x(), 1).required_padding();
-    validate(src.info()->padding(), padding);
-}
-} // namespace
-
-#ifndef DOXYGEN_SKIP_THIS
-BOOST_AUTO_TEST_SUITE(NEON)
-BOOST_AUTO_TEST_SUITE(MinMaxLocation)
-
-BOOST_AUTO_TEST_SUITE(Integer)
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit") * boost::unit_test::label("nightly"))
-BOOST_DATA_TEST_CASE(Configuration, (Small2DShapes() + Large2DShapes()) * boost::unit_test::data::make({ DataType::U8, DataType::S16 }),
-                     shape, dt)
-{
-    // Create tensor
-    Tensor src = create_tensor<Tensor>(shape, dt);
-    src.info()->set_format(dt == DataType::U8 ? Format::U8 : Format::S16);
-
-    validate_configuration(src, shape);
-}
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
-BOOST_DATA_TEST_CASE(RunSmall, Small2DShapes() * boost::unit_test::data::make({ DataType::U8, DataType::S16 }),
-                     shape, dt)
-{
-    // Create output storage
-    int32_t            min;
-    int32_t            max;
-    Coordinates2DArray min_loc(shape.total_size());
-    Coordinates2DArray max_loc(shape.total_size());
-    uint32_t           min_count;
-    uint32_t           max_count;
-
-    int32_t            ref_min;
-    int32_t            ref_max;
-    Coordinates2DArray ref_min_loc(shape.total_size());
-    Coordinates2DArray ref_max_loc(shape.total_size());
-    uint32_t           ref_min_count;
-    uint32_t           ref_max_count;
-
-    // Compute function
-    compute_min_max_location(shape, dt, &min, &max, min_loc, max_loc, min_count, max_count);
-
-    // Compute reference
-    Reference::compute_reference_min_max_location(shape, dt, &ref_min, &ref_max, ref_min_loc, ref_max_loc, ref_min_count, ref_max_count);
-
-    // Validate output
-    validate_min_max_loc(min, ref_min, max, ref_max, min_loc, ref_min_loc, max_loc, ref_max_loc, min_count, ref_min_count, max_count, ref_max_count);
-}
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("nightly"))
-BOOST_DATA_TEST_CASE(RunLarge, Large2DShapes() * boost::unit_test::data::make({ DataType::U8, DataType::S16 }),
-                     shape, dt)
-{
-    // Create output storage
-    int32_t            min;
-    int32_t            max;
-    Coordinates2DArray min_loc(shape.total_size());
-    Coordinates2DArray max_loc(shape.total_size());
-    uint32_t           min_count;
-    uint32_t           max_count;
-
-    int32_t            ref_min;
-    int32_t            ref_max;
-    Coordinates2DArray ref_min_loc(shape.total_size());
-    Coordinates2DArray ref_max_loc(shape.total_size());
-    uint32_t           ref_min_count;
-    uint32_t           ref_max_count;
-
-    // Compute function
-    compute_min_max_location(shape, dt, &min, &max, min_loc, max_loc, min_count, max_count);
-
-    // Compute reference
-    Reference::compute_reference_min_max_location(shape, dt, &ref_min, &ref_max, ref_min_loc, ref_max_loc, ref_min_count, ref_max_count);
-
-    // Validate output
-    validate_min_max_loc(min, ref_min, max, ref_max, min_loc, ref_min_loc, max_loc, ref_max_loc, min_count, ref_min_count, max_count, ref_max_count);
-}
-BOOST_AUTO_TEST_SUITE_END()
-
-BOOST_AUTO_TEST_SUITE(Float)
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
-BOOST_DATA_TEST_CASE(RunSmall, Small2DShapes() * DataType::F32,
-                     shape, dt)
-{
-    // Create output storage
-    float              min;
-    float              max;
-    Coordinates2DArray min_loc(shape.total_size());
-    Coordinates2DArray max_loc(shape.total_size());
-    uint32_t           min_count;
-    uint32_t           max_count;
-
-    float              ref_min;
-    float              ref_max;
-    Coordinates2DArray ref_min_loc(shape.total_size());
-    Coordinates2DArray ref_max_loc(shape.total_size());
-    uint32_t           ref_min_count;
-    uint32_t           ref_max_count;
-
-    // Compute function
-    compute_min_max_location(shape, dt, &min, &max, min_loc, max_loc, min_count, max_count);
-
-    // Compute reference
-    Reference::compute_reference_min_max_location(shape, dt, &ref_min, &ref_max, ref_min_loc, ref_max_loc, ref_min_count, ref_max_count);
-
-    // Validate output
-    validate_min_max_loc(min, ref_min, max, ref_max, min_loc, ref_min_loc, max_loc, ref_max_loc, min_count, ref_min_count, max_count, ref_max_count);
-}
-
-BOOST_AUTO_TEST_SUITE_END()
-
-BOOST_AUTO_TEST_SUITE_END()
-BOOST_AUTO_TEST_SUITE_END()
-#endif /* DOXYGEN_SKIP_THIS */
diff --git a/tests/validation_old/Reference.cpp b/tests/validation_old/Reference.cpp
index fc5484606e..b5fe1d2baf 100644
--- a/tests/validation_old/Reference.cpp
+++ b/tests/validation_old/Reference.cpp
@@ -72,18 +72,6 @@ std::pair<RawTensor, RawTensor> Reference::compute_reference_sobel_5x5(const Ten
 
     return std::make_pair(ref_dst_x, ref_dst_y);
 }
-void Reference::compute_reference_min_max_location(const TensorShape &shape, DataType dt_in, void *min, void *max, IArray<Coordinates2D> &min_loc, IArray<Coordinates2D> &max_loc,
-                                                   uint32_t &min_count, uint32_t &max_count)
-{
-    // Create reference
-    RawTensor ref_src(shape, dt_in);
-
-    // Fill reference
-    library->fill_tensor_uniform(ref_src, 0);
-
-    // Compute reference
-    ReferenceCPP::min_max_location(ref_src, min, max, min_loc, max_loc, min_count, max_count);
-}
 
 KeyPointArray Reference::compute_reference_harris_corners(const TensorShape &shape, float threshold, float min_dist, float sensitivity,
                                                           int32_t gradient_size, int32_t block_size, BorderMode border_mode, uint8_t constant_border_value)
diff --git a/tests/validation_old/Reference.h b/tests/validation_old/Reference.h
index e363bb2ecd..153986d82a 100644
--- a/tests/validation_old/Reference.h
+++ b/tests/validation_old/Reference.h
@@ -74,22 +74,6 @@ public:
      */
     static KeyPointArray compute_reference_harris_corners(const TensorShape &shape, float threshold, float min_dist, float sensitivity,
                                                           int32_t gradient_size, int32_t block_size, BorderMode border_mode, uint8_t constant_border_value);
-    /** Compute min max location.
-     *
-     * @param[in]  shape     Shape of the input tensors.
-     * @param[in]  dt_in     Data type of input tensor.
-     * @param[out] min       Minimum value of tensor
-     * @param[out] max       Maximum value of tensor
-     * @param[out] min_loc   Array with locations of minimum values
-     * @param[out] max_loc   Array with locations of maximum values
-     * @param[out] min_count Number of minimum values found
-     * @param[out] max_count Number of maximum values found
-     *
-     * @return Computed minimum, maximum values and their locations.
-     */
-    static void compute_reference_min_max_location(const TensorShape &shape, DataType dt_in, void *min, void *max, IArray<Coordinates2D> &min_loc, IArray<Coordinates2D> &max_loc,
-                                                   uint32_t &min_count,
-                                                   uint32_t &max_count);
     /** Compute reference integral image.
      *
      * @param[in] shape Shape of the input and output tensors.
diff --git a/tests/validation_old/ReferenceCPP.cpp b/tests/validation_old/ReferenceCPP.cpp
index cca8997485..55aac59211 100644
--- a/tests/validation_old/ReferenceCPP.cpp
+++ b/tests/validation_old/ReferenceCPP.cpp
@@ -95,13 +95,6 @@ void ReferenceCPP::harris_corners(RawTensor &src, RawTensor &Gx, RawTensor &Gy,
     }
 }
 
-// Minimum maximum location
-void ReferenceCPP::min_max_location(const RawTensor &src, void *min, void *max, IArray<Coordinates2D> &min_loc, IArray<Coordinates2D> &max_loc, uint32_t &min_count, uint32_t &max_count)
-{
-    const TensorVariant s = TensorFactory::get_tensor(src);
-    boost::apply_visitor(tensor_visitors::min_max_location_visitor(min, max, min_loc, max_loc, min_count, max_count), s);
-}
-
 // Absolute difference
 void ReferenceCPP::absolute_difference(const RawTensor &src1, const RawTensor &src2, RawTensor &dst)
 {
diff --git a/tests/validation_old/ReferenceCPP.h b/tests/validation_old/ReferenceCPP.h
index 2f02afc30e..b04d5e331f 100644
--- a/tests/validation_old/ReferenceCPP.h
+++ b/tests/validation_old/ReferenceCPP.h
@@ -83,17 +83,6 @@ public:
      */
     static void harris_corners(RawTensor &src, RawTensor &Gx, RawTensor &Gy, const RawTensor &candidates, const RawTensor &non_maxima, float threshold, float min_dist, float sensitivity,
                                int32_t gradient_size, int32_t block_size, KeyPointArray &corners, BorderMode border_mode, uint8_t constant_border_value);
-    /** Function to compute the min max values and their location in a tensor.
-     *
-     * @param[in]  src       Input tensor.
-     * @param[out] min       Minimum value of the tensor.
-     * @param[out] max       Maximum value of the tensor
-     * @param[out] min_loc   Array with locations of minimum values
-     * @param[out] max_loc   Array with locations of maximum values
-     * @param[out] min_count Number of minimum values found
-     * @param[out] max_count Number of maximum values found
-     */
-    static void min_max_location(const RawTensor &src, void *min, void *max, IArray<Coordinates2D> &min_loc, IArray<Coordinates2D> &max_loc, uint32_t &min_count, uint32_t &max_count);
     /** Function to compute the integral image of a tensor.
      *
      * @param[in]  src Input tensor.
diff --git a/tests/validation_old/TensorOperations.h b/tests/validation_old/TensorOperations.h
index 04a79f0de3..af17ea8dfd 100644
--- a/tests/validation_old/TensorOperations.h
+++ b/tests/validation_old/TensorOperations.h
@@ -406,72 +406,6 @@ void harris_corners(Tensor<T1> &in, Tensor<T2> &Gx, Tensor<T2> &Gy, Tensor<T3> &
     }
 }
 
-template <typename T>
-void compute_min_max(const Tensor<T> &in, void *min, void *max)
-{
-    using type = typename std::conditional<std::is_same<T, float>::value, float, int32_t>::type;
-
-    // Set min and max to first pixel
-    type tmp_min = static_cast<type>(in[0]);
-    type tmp_max = static_cast<type>(in[0]);
-
-    // Look for min and max values
-    for(int i = 1; i < in.num_elements(); ++i)
-    {
-        if(static_cast<type>(in[i]) < tmp_min)
-        {
-            tmp_min = static_cast<type>(in[i]);
-        }
-        if(static_cast<type>(in[i]) > tmp_max)
-        {
-            tmp_max = static_cast<type>(in[i]);
-        }
-    }
-
-    *static_cast<type *>(min) = tmp_min;
-    *static_cast<type *>(max) = tmp_max;
-}
-
-// Min max location
-template <typename T1>
-void min_max_location(const Tensor<T1> &in, void *min, void *max, IArray<Coordinates2D> &min_loc, IArray<Coordinates2D> &max_loc, uint32_t &min_count, uint32_t &max_count)
-{
-    const size_t width = in.shape().x();
-
-    compute_min_max(in, min, max);
-
-    using type = typename std::conditional<std::is_same<T1, float>::value, float, int32_t>::type;
-
-    type min_value = *static_cast<type *>(min);
-    type max_value = *static_cast<type *>(max);
-
-    min_count = 0;
-    max_count = 0;
-    for(int i = 0; i < in.num_elements(); ++i)
-    {
-        if(static_cast<type>(in[i]) == min_value)
-        {
-            Coordinates2D min_coord;
-            min_coord.x = static_cast<int32_t>(i % width);
-            min_coord.y = static_cast<int32_t>(i / width);
-
-            min_loc.push_back(min_coord);
-
-            min_count++;
-        }
-        if(static_cast<type>(in[i]) == max_value)
-        {
-            Coordinates2D max_coord;
-            max_coord.x = static_cast<int32_t>(i % width);
-            max_coord.y = static_cast<int32_t>(i / width);
-
-            max_loc.push_back(max_coord);
-
-            max_count++;
-        }
-    }
-}
-
 // Integral Image
 void integral_image(const Tensor<uint8_t> &in, Tensor<uint32_t> &out)
 {
diff --git a/tests/validation_old/TensorVisitors.h b/tests/validation_old/TensorVisitors.h
index 8af035be08..30b552ae3c 100644
--- a/tests/validation_old/TensorVisitors.h
+++ b/tests/validation_old/TensorVisitors.h
@@ -46,28 +46,6 @@ namespace validation
 {
 namespace tensor_visitors
 {
-// Min max location visitor
-struct min_max_location_visitor : public boost::static_visitor<>
-{
-public:
-    explicit min_max_location_visitor(void *min, void *max, IArray<Coordinates2D> &min_loc, IArray<Coordinates2D> &max_loc, uint32_t &min_count, uint32_t &max_count)
-        : _min(min), _max(max), _min_loc(min_loc), _max_loc(max_loc), _min_count(min_count), _max_count(max_count)
-    {
-    }
-    template <typename T1>
-    void operator()(const Tensor<T1> &in) const
-    {
-        tensor_operations::min_max_location(in, _min, _max, _min_loc, _max_loc, _min_count, _max_count);
-    }
-
-private:
-    void                  *_min;
-    void                  *_max;
-    IArray<Coordinates2D> &_min_loc;
-    IArray<Coordinates2D> &_max_loc;
-    uint32_t              &_min_count;
-    uint32_t              &_max_count;
-};
 // Absolute Difference visitor
 struct absolute_difference_visitor : public boost::static_visitor<>
 {
diff --git a/tests/validation_old/Validation.h b/tests/validation_old/Validation.h
index 4c8752b937..f0630c1d3e 100644
--- a/tests/validation_old/Validation.h
+++ b/tests/validation_old/Validation.h
@@ -141,47 +141,6 @@ void validate(std::vector<unsigned int> classified_labels, std::vector<unsigned
  */
 void validate(float target, float ref, float tolerance_abs_error = std::numeric_limits<float>::epsilon(), float tolerance_relative_error = 0.0001f);
 
-/** Validate min max location.
- *
- * - All values should match
- */
-template <typename T>
-void validate_min_max_loc(T min, T ref_min, T max, T ref_max,
-                          IArray<Coordinates2D> &min_loc, IArray<Coordinates2D> &ref_min_loc, IArray<Coordinates2D> &max_loc, IArray<Coordinates2D> &ref_max_loc,
-                          uint32_t min_count, uint32_t ref_min_count, uint32_t max_count, uint32_t ref_max_count)
-{
-    BOOST_TEST(min == ref_min);
-    BOOST_TEST(max == ref_max);
-
-    BOOST_TEST(min_count == min_loc.num_values());
-    BOOST_TEST(max_count == max_loc.num_values());
-    BOOST_TEST(ref_min_count == ref_min_loc.num_values());
-    BOOST_TEST(ref_max_count == ref_max_loc.num_values());
-
-    BOOST_TEST(min_count == ref_min_count);
-    BOOST_TEST(max_count == ref_max_count);
-
-    for(uint32_t i = 0; i < min_count; i++)
-    {
-        Coordinates2D *same_coords = std::find_if(ref_min_loc.buffer(), ref_min_loc.buffer() + min_count, [&min_loc, i](Coordinates2D coord)
-        {
-            return coord.x == min_loc.at(i).x && coord.y == min_loc.at(i).y;
-        });
-
-        BOOST_TEST(same_coords != ref_min_loc.buffer() + min_count);
-    }
-
-    for(uint32_t i = 0; i < max_count; i++)
-    {
-        Coordinates2D *same_coords = std::find_if(ref_max_loc.buffer(), ref_max_loc.buffer() + max_count, [&max_loc, i](Coordinates2D coord)
-        {
-            return coord.x == max_loc.at(i).x && coord.y == max_loc.at(i).y;
-        });
-
-        BOOST_TEST(same_coords != ref_max_loc.buffer() + max_count);
-    }
-}
-
 /** Validate KeyPoint arrays.
  *
  * - All values should match