COMPMID-508: Port TableLookup to new validation

Change-Id: I9e1a683afd64c351252617ba52131ca1ee829933
Reviewed-on: http://mpd-gerrit.cambridge.arm.com/87698
Reviewed-by: Moritz Pflanzer <moritz.pflanzer@arm.com>
Reviewed-by: Pablo Tello <pablo.tello@arm.com>
Tested-by: Kaizen <jeremy.johnson+kaizengerrit@arm.com>

8 files changed, 0 insertions, 539 deletions

diff --git a/tests/validation_old/CL/TableLookup.cpp b/tests/validation_old/CL/TableLookup.cpp
deleted file mode 100644
index 26c38689f0..0000000000
--- a/tests/validation_old/CL/TableLookup.cpp
+++ /dev/null
@@ -1,229 +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 "CL/CLLutAccessor.h"
-#include "PaddingCalculator.h"
-#include "RawLutAccessor.h"
-#include "TypePrinter.h"
-#include "Utils.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/validation_old/Datasets.h"
-#include "tests/validation_old/Helpers.h"
-#include "tests/validation_old/Reference.h"
-#include "tests/validation_old/Validation.h"
-
-#include "arm_compute/core/Helpers.h"
-#include "arm_compute/core/Types.h"
-#include "arm_compute/runtime/CL/CLTensor.h"
-#include "arm_compute/runtime/CL/CLTensorAllocator.h"
-#include "arm_compute/runtime/CL/functions/CLTableLookup.h"
-
-#include "tests/validation_old/boost_wrapper.h"
-
-#include <map>
-#include <random>
-#include <string>
-
-using namespace arm_compute;
-using namespace arm_compute::test;
-using namespace arm_compute::test::validation;
-
-namespace
-{
-/** Compute Table Lookup function.
- *
- * @param[in] shape     Shape of the input tensors
- * @param[in] data_type Type of the input/output tensor
- * @param[in] lut       The input LUT.
- *
- * @return Computed output cl tensor.
- */
-CLTensor compute_table_lookup(const TensorShape &shape, DataType data_type, CLLut &lut)
-{
-    // Create tensors
-    CLTensor src = create_tensor<CLTensor>(shape, data_type);
-    CLTensor dst = create_tensor<CLTensor>(shape, data_type);
-
-    // Create and configure function
-    CLTableLookup table_lookup;
-    table_lookup.configure(&src, &lut, &dst);
-
-    // Allocate tensors
-    src.allocator()->allocate();
-    dst.allocator()->allocate();
-
-    BOOST_TEST(!src.info()->is_resizable());
-    BOOST_TEST(!dst.info()->is_resizable());
-
-    // Fill tensors
-    library->fill_tensor_uniform(CLAccessor(src), 0);
-
-    // Compute function
-    table_lookup.run();
-
-    return dst;
-}
-} // namespace
-
-#ifndef DOXYGEN_SKIP_THIS
-BOOST_AUTO_TEST_SUITE(CL)
-BOOST_AUTO_TEST_SUITE(TableLookup)
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit") * boost::unit_test::label("nightly"))
-BOOST_DATA_TEST_CASE(Configuration, (SmallShapes() + LargeShapes()) * boost::unit_test::data::make({ DataType::U8, DataType::S16 }),
-                     shape, 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;
-    CLLut     cllut(num_elem, data_type);
-
-    if(data_type == DataType::U8)
-    {
-        fill_lookuptable(CLLutAccessor<uint8_t>(cllut));
-    }
-    else
-    {
-        fill_lookuptable(CLLutAccessor<int16_t>(cllut));
-    }
-
-    // Create tensors
-    CLTensor src = create_tensor<CLTensor>(shape, data_type);
-    CLTensor dst = create_tensor<CLTensor>(shape, data_type);
-
-    BOOST_TEST(src.info()->is_resizable());
-    BOOST_TEST(dst.info()->is_resizable());
-
-    // Create and configure function
-    CLTableLookup table_lookup;
-    table_lookup.configure(&src, &cllut, &dst);
-
-    // Validate valid region
-    const ValidRegion valid_region = shape_to_valid_region(shape);
-    validate(src.info()->valid_region(), valid_region);
-    validate(dst.info()->valid_region(), valid_region);
-
-    // Validate padding
-    const PaddingSize padding = PaddingCalculator(shape.x(), 8).required_padding();
-    validate(src.info()->padding(), padding);
-    validate(dst.info()->padding(), padding);
-}
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
-BOOST_DATA_TEST_CASE(RunSmall,
-                     SmallShapes() * boost::unit_test::data::make({ DataType::U8, DataType::S16 }),
-                     shape, 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;
-    CLLut     cllut(num_elem, data_type);
-
-    if(data_type == DataType::U8)
-    {
-        //Create rawLut
-        std::map<uint8_t, uint8_t> rawlut;
-
-        //Fill the Lut
-        fill_lookuptable(CLLutAccessor<uint8_t>(cllut));
-        fill_lookuptable(RawLutAccessor<uint8_t>(rawlut));
-
-        // Compute function
-        CLTensor dst = compute_table_lookup(shape, data_type, cllut);
-
-        // Compute reference
-        RawTensor ref_dst = Reference::compute_reference_table_lookup(shape, data_type, rawlut);
-
-        // Validate output
-        validate(CLAccessor(dst), ref_dst);
-    }
-    else
-    {
-        //Create rawLut
-        std::map<int16_t, int16_t> rawlut;
-
-        //Fill the Lut
-        fill_lookuptable(CLLutAccessor<int16_t>(cllut));
-        fill_lookuptable(RawLutAccessor<int16_t>(rawlut));
-
-        // Compute function
-        CLTensor dst = compute_table_lookup(shape, data_type, cllut);
-
-        // Compute reference
-        RawTensor ref_dst = Reference::compute_reference_table_lookup(shape, data_type, rawlut);
-
-        // Validate output
-        validate(CLAccessor(dst), ref_dst);
-    }
-}
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("nightly"))
-BOOST_DATA_TEST_CASE(RunLarge,
-                     LargeShapes() * boost::unit_test::data::make({ DataType::U8, DataType::S16 }),
-                     shape, 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;
-    CLLut     cllut(num_elem, data_type);
-
-    if(data_type == DataType::U8)
-    {
-        //Create rawLut
-        std::map<uint8_t, uint8_t> rawlut;
-
-        //Fill the Lut
-        fill_lookuptable(CLLutAccessor<uint8_t>(cllut));
-        fill_lookuptable(RawLutAccessor<uint8_t>(rawlut));
-
-        // Compute function
-        CLTensor dst = compute_table_lookup(shape, data_type, cllut);
-
-        // Compute reference
-        RawTensor ref_dst = Reference::compute_reference_table_lookup(shape, data_type, rawlut);
-
-        // Validate output
-        validate(CLAccessor(dst), ref_dst);
-    }
-    else
-    {
-        //Create rawLut
-        std::map<int16_t, int16_t> rawlut;
-
-        //Fill the Lut
-        fill_lookuptable(CLLutAccessor<int16_t>(cllut));
-        fill_lookuptable(RawLutAccessor<int16_t>(rawlut));
-
-        // Compute function
-        CLTensor dst = compute_table_lookup(shape, data_type, cllut);
-
-        // Compute reference
-        RawTensor ref_dst = Reference::compute_reference_table_lookup(shape, data_type, rawlut);
-
-        // Validate output
-        validate(CLAccessor(dst), ref_dst);
-    }
-}
-
-BOOST_AUTO_TEST_SUITE_END()
-BOOST_AUTO_TEST_SUITE_END()
-#endif /* DOXYGEN_SKIP_THIS */
diff --git a/tests/validation_old/NEON/TableLookup.cpp b/tests/validation_old/NEON/TableLookup.cpp
deleted file mode 100644
index f134e5d417..0000000000
--- a/tests/validation_old/NEON/TableLookup.cpp
+++ /dev/null
@@ -1,229 +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 "NEON/LutAccessor.h"
-#include "PaddingCalculator.h"
-#include "RawLutAccessor.h"
-#include "TypePrinter.h"
-#include "Utils.h"
-#include "tests/AssetsLibrary.h"
-#include "tests/Globals.h"
-#include "tests/validation_old/Datasets.h"
-#include "tests/validation_old/Helpers.h"
-#include "tests/validation_old/Reference.h"
-#include "tests/validation_old/Validation.h"
-
-#include "arm_compute/core/Helpers.h"
-#include "arm_compute/core/Types.h"
-#include "arm_compute/runtime/NEON/functions/NETableLookup.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 Table Lookup function.
- *
- * @param[in] shape     Shape of the input tensors
- * @param[in] data_type Datatype of the input/output tensors
- * @param[in] lut       The input LUT.
- *
- * @return Computed output tensor.
- */
-Tensor compute_table_lookup(const TensorShape &shape, DataType data_type, Lut &lut)
-{
-    // Create tensors
-    Tensor src = create_tensor<Tensor>(shape, data_type);
-    Tensor dst = create_tensor<Tensor>(shape, data_type);
-
-    // Create and configure function
-    NETableLookup table_lookup;
-    table_lookup.configure(&src, &lut, &dst);
-
-    // Allocate tensors
-    src.allocator()->allocate();
-    dst.allocator()->allocate();
-
-    BOOST_TEST(!src.info()->is_resizable());
-    BOOST_TEST(!dst.info()->is_resizable());
-
-    // Fill tensors
-    library->fill_tensor_uniform(Accessor(src), 0);
-
-    // Compute function
-    table_lookup.run();
-
-    return dst;
-}
-} // namespace
-
-#ifndef DOXYGEN_SKIP_THIS
-BOOST_AUTO_TEST_SUITE(NEON)
-BOOST_AUTO_TEST_SUITE(TableLookup)
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit") * boost::unit_test::label("nightly"))
-BOOST_DATA_TEST_CASE(Configuration, (SmallShapes() + LargeShapes()) * boost::unit_test::data::make({ DataType::U8, DataType::S16 }),
-                     shape, 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;
-    Lut       lut(num_elem, data_type);
-
-    if(data_type == DataType::U8)
-    {
-        fill_lookuptable(LutAccessor<uint8_t>(lut));
-    }
-    else
-    {
-        fill_lookuptable(LutAccessor<int16_t>(lut));
-    }
-
-    // Create tensors
-    Tensor src = create_tensor<Tensor>(shape, data_type);
-    Tensor dst = create_tensor<Tensor>(shape, data_type);
-
-    BOOST_TEST(src.info()->is_resizable());
-    BOOST_TEST(dst.info()->is_resizable());
-
-    // Create and configure function
-    NETableLookup table_lookup;
-    table_lookup.configure(&src, &lut, &dst);
-
-    // Validate valid region
-    const ValidRegion valid_region = shape_to_valid_region(shape);
-    validate(src.info()->valid_region(), valid_region);
-    validate(dst.info()->valid_region(), valid_region);
-
-    // Validate padding
-    const PaddingSize padding = PaddingCalculator(shape.x(), 16).required_padding();
-    validate(src.info()->padding(), padding);
-    validate(dst.info()->padding(), padding);
-}
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
-BOOST_DATA_TEST_CASE(RunSmall,
-                     SmallShapes() * boost::unit_test::data::make({ DataType::U8, DataType::S16 }),
-                     shape, 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;
-    Lut       lut(num_elem, data_type);
-
-    if(data_type == DataType::U8)
-    {
-        //Create rawLut
-        std::map<uint8_t, uint8_t> rawlut;
-
-        //Fill the Lut
-        fill_lookuptable(LutAccessor<uint8_t>(lut));
-        fill_lookuptable(RawLutAccessor<uint8_t>(rawlut));
-
-        // Compute function
-        Tensor dst = compute_table_lookup(shape, data_type, lut);
-
-        // Compute reference
-        RawTensor ref_dst = Reference::compute_reference_table_lookup(shape, data_type, rawlut);
-
-        // Validate output
-        validate(Accessor(dst), ref_dst);
-    }
-    else
-    {
-        //Create rawLut
-        std::map<int16_t, int16_t> rawlut;
-
-        //Fill the Lut
-        fill_lookuptable(LutAccessor<int16_t>(lut));
-        fill_lookuptable(RawLutAccessor<int16_t>(rawlut));
-
-        // Compute function
-        Tensor dst = compute_table_lookup(shape, data_type, lut);
-
-        // Compute reference
-        RawTensor ref_dst = Reference::compute_reference_table_lookup(shape, data_type, rawlut);
-
-        // Validate output
-        validate(Accessor(dst), ref_dst);
-    }
-}
-
-BOOST_TEST_DECORATOR(*boost::unit_test::label("nightly"))
-BOOST_DATA_TEST_CASE(RunLarge,
-                     LargeShapes() * boost::unit_test::data::make({ DataType::U8, DataType::S16 }),
-                     shape, 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;
-    Lut       lut(num_elem, data_type);
-
-    if(data_type == DataType::U8)
-    {
-        //Create rawLut
-        std::map<uint8_t, uint8_t> rawlut;
-
-        //Fill the Lut
-        fill_lookuptable(LutAccessor<uint8_t>(lut));
-        fill_lookuptable(RawLutAccessor<uint8_t>(rawlut));
-
-        // Compute function
-        Tensor dst = compute_table_lookup(shape, data_type, lut);
-
-        // Compute reference
-        RawTensor ref_dst = Reference::compute_reference_table_lookup(shape, data_type, rawlut);
-
-        // Validate output
-        validate(Accessor(dst), ref_dst);
-    }
-    else
-    {
-        //Create rawLut
-        std::map<int16_t, int16_t> rawlut;
-
-        //Fill the Lut
-        fill_lookuptable(LutAccessor<int16_t>(lut));
-        fill_lookuptable(RawLutAccessor<int16_t>(rawlut));
-
-        // Compute function
-        Tensor dst = compute_table_lookup(shape, data_type, lut);
-
-        // Compute reference
-        RawTensor ref_dst = Reference::compute_reference_table_lookup(shape, data_type, rawlut);
-
-        // Validate output
-        validate(Accessor(dst), ref_dst);
-    }
-}
-
-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 b8564dbb03..6a52cd016f 100644
--- a/tests/validation_old/Reference.cpp
+++ b/tests/validation_old/Reference.cpp
@@ -253,23 +253,6 @@ RawTensor Reference::compute_reference_fixed_point_pixel_wise_multiplication(con
     return ref_dst;
 }
 
-template <typename T>
-RawTensor Reference::compute_reference_table_lookup(const TensorShape &shape, DataType dt_inout, std::map<T, T> &lut)
-{
-    // Create reference
-    RawTensor ref_src(shape, dt_inout);
-    RawTensor ref_dst(shape, dt_inout);
-    // Fill reference
-    library->fill_tensor_uniform(ref_src, 0);
-
-    // Compute reference
-    ReferenceCPP::table_lookup(ref_src, ref_dst, lut);
-
-    return ref_dst;
-}
-template RawTensor arm_compute::test::validation::Reference::compute_reference_table_lookup<uint8_t>(const TensorShape &shape, DataType dt_inout, std::map<uint8_t, uint8_t> &lut);
-template RawTensor arm_compute::test::validation::Reference::compute_reference_table_lookup<int16_t>(const TensorShape &shape, DataType dt_inout, std::map<int16_t, int16_t> &lut);
-
 RawTensor Reference::compute_reference_threshold(const TensorShape &shape, uint8_t threshold, uint8_t false_value, uint8_t true_value, ThresholdType type, uint8_t upper)
 {
     // Create reference
diff --git a/tests/validation_old/Reference.h b/tests/validation_old/Reference.h
index b3f35ce43a..9c7baacbf6 100644
--- a/tests/validation_old/Reference.h
+++ b/tests/validation_old/Reference.h
@@ -177,16 +177,6 @@ public:
      */
     static RawTensor compute_reference_fixed_point_pixel_wise_multiplication(const TensorShape &shape, DataType dt_in0, DataType dt_in1, DataType dt_out, float scale, int fixed_point_position,
                                                                              ConvertPolicy convert_policy, RoundingPolicy rounding_policy);
-    /** Compute reference Table Lookup.
-     *
-     * @param[in] shape    Shape of the input and output tensors.
-     * @param[in] dt_inout Data type of input/output tensor.
-     * @param[in] lut      Input lookup table.
-     *
-     * @return Computed raw tensor.
-     */
-    template <typename T>
-    static RawTensor compute_reference_table_lookup(const TensorShape &shape, DataType dt_inout, std::map<T, T> &lut);
     /** Compute reference threshold.
      *
      * @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 2f59103f95..86dc589bb1 100644
--- a/tests/validation_old/ReferenceCPP.cpp
+++ b/tests/validation_old/ReferenceCPP.cpp
@@ -193,19 +193,6 @@ void ReferenceCPP::fixed_point_pixel_wise_multiplication(const RawTensor &src1,
     boost::apply_visitor(tensor_visitors::fixed_point_pixel_wise_multiplication_visitor(s1, s2, scale, convert_policy, rounding_policy), d);
 }
 
-// Table lookup
-template <typename T>
-void ReferenceCPP::table_lookup(const RawTensor &src, RawTensor &dst, std::map<T, T> &lut)
-{
-    const TensorVariant s = TensorFactory::get_tensor(src);
-    TensorVariant       d = TensorFactory::get_tensor(dst);
-    boost::apply_visitor(tensor_visitors::table_lookup<T>(s, lut), d);
-}
-#ifndef DOXYGEN_SKIP_THIS
-template void arm_compute::test::validation::ReferenceCPP::table_lookup<uint8_t>(const RawTensor &src, RawTensor &dst, std::map<uint8_t, uint8_t> &lut);
-template void arm_compute::test::validation::ReferenceCPP::table_lookup<int16_t>(const RawTensor &src, RawTensor &dst, std::map<int16_t, int16_t> &lut);
-#endif /* DOXYGEN_SKIP_THIS */
-
 // Threshold
 void ReferenceCPP::threshold(const RawTensor &src, RawTensor &dst, uint8_t threshold, uint8_t false_value, uint8_t true_value, ThresholdType type, uint8_t upper)
 {
diff --git a/tests/validation_old/ReferenceCPP.h b/tests/validation_old/ReferenceCPP.h
index 851f34b236..5bc10a512f 100644
--- a/tests/validation_old/ReferenceCPP.h
+++ b/tests/validation_old/ReferenceCPP.h
@@ -176,14 +176,6 @@ public:
      * @param[in]  rounding_policy Rounding policy.
      */
     static void fixed_point_pixel_wise_multiplication(const RawTensor &src1, const RawTensor &src2, RawTensor &dst, float scale, ConvertPolicy convert_policy, RoundingPolicy rounding_policy);
-    /** Table Lookup f@p src to @p dst
-     *
-     * @param[in]  src Input tensor.
-     * @param[out] dst Result tensor.
-     * @param[in]  lut Input lookup table.
-     */
-    template <typename T>
-    static void table_lookup(const RawTensor &src, RawTensor &dst, std::map<T, T> &lut);
     /** Threshold of@p src to @p dst
      *
      * @param[in]  src         Input tensor.
diff --git a/tests/validation_old/TensorOperations.h b/tests/validation_old/TensorOperations.h
index 73e7661a1c..0c1ab4134e 100644
--- a/tests/validation_old/TensorOperations.h
+++ b/tests/validation_old/TensorOperations.h
@@ -740,16 +740,6 @@ void fixed_point_pixel_wise_multiplication(const Tensor<T> &in1, const Tensor<T>
     }
 }
 
-//Table Lookup
-template <typename T, typename T1>
-void table_lookup(const Tensor<T> &in, Tensor<T> &out, std::map<T1, T1> &lut)
-{
-    for(int i = 0; i < in.num_elements(); ++i)
-    {
-        out[i] = static_cast<T>(lut[in[i]]);
-    }
-}
-
 // Threshold
 template <typename T>
 void threshold(const Tensor<T> &in, Tensor<T> &out, uint8_t threshold, uint8_t false_value, uint8_t true_value, ThresholdType type, uint8_t upper)
diff --git a/tests/validation_old/TensorVisitors.h b/tests/validation_old/TensorVisitors.h
index 7d67dca5a5..dafbfe0235 100644
--- a/tests/validation_old/TensorVisitors.h
+++ b/tests/validation_old/TensorVisitors.h
@@ -127,29 +127,6 @@ private:
     ConvertPolicy        _convert_policy;
     RoundingPolicy       _rounding_policy;
 };
-// Table lookup operation
-template <typename T1>
-struct table_lookup : public boost::static_visitor<>
-{
-public:
-    explicit table_lookup(const TensorVariant &in, std::map<T1, T1> &lut)
-        : _in(in), _lut(lut)
-    {
-    }
-
-    template <typename T>
-    void operator()(Tensor<T> &out) const
-    {
-        const auto &in = boost::get<Tensor<T>>(_in);
-        tensor_operations::table_lookup(in, out, _lut);
-    }
-
-private:
-    const TensorVariant &_in;
-    std::map<T1, T1> &_lut;
-};
-template struct arm_compute::test::validation::tensor_visitors::table_lookup<uint8_t>;
-template struct arm_compute::test::validation::tensor_visitors::table_lookup<int16_t>;
 
 // Batch Normalization Layer visitor
 struct batch_normalization_layer_visitor : public boost::static_visitor<>