/*
 * Copyright (c) 2019 ARM Limited.
 *
 * SPDX-License-Identifier: MIT
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
 * deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
#include "arm_compute/runtime/CL/functions/CLLSTMLayerQuantized.h"

#include "tests/CL/CLAccessor.h"
#include "tests/PaddingCalculator.h"
#include "tests/Utils.h"
#include "tests/datasets/LSTMLayerDataset.h"
#include "tests/framework/Asserts.h"
#include "tests/framework/Macros.h"
#include "tests/framework/datasets/Datasets.h"
#include "tests/validation/Validation.h"

#include <vector>

namespace arm_compute
{
namespace test
{
namespace validation
{
namespace
{
template <typename T>
inline void fill_tensor(CLTensor &tensor, const std::vector<T> &v)
{
    tensor.map(true);
    // Import memory accounting for padding
    TensorShape t_shape = tensor.info()->tensor_shape();
    Window      window;
    window.use_tensor_dimensions(t_shape);
    Iterator out(&tensor, window);
    execute_window_loop(window, [&](const Coordinates & id)
    {
        *reinterpret_cast<T *>(out.ptr()) = v[coord2index(t_shape, id)];
    },
    out);
    tensor.unmap();
}

template <typename T>
inline void fill_tensor(SimpleTensor<T> &tensor, const std::vector<T> &v)
{
    std::memcpy(tensor.data(), v.data(), sizeof(T) * v.size());
}

} // namespace

TEST_SUITE(CL)
TEST_SUITE(LSTMLayerQuantized)

// *INDENT-OFF*
// clang-format off
TEST_CASE(IntegrationTestCaseSmall, framework::DatasetMode::PRECOMMIT)
{
    const int batch_size  = 2;
    const int input_size  = 2;
    const int output_size = 4;


    QuantizationInfo qasymm(1.f / 128.f, 128);
    QuantizationInfo qweights(1.f / 128.f, 128);
    QuantizationInfo qsymm_3(8.f / 32768.f, 0);
    QuantizationInfo qsymm_4(16.f / 32768.f, 0);

    TensorShape input_shape{ input_size, batch_size };
    TensorShape input_weights_shape{ input_size, output_size };
    TensorShape recurrent_weights_shape{ output_size, output_size };
    TensorShape output_shape{ output_size, batch_size};
    TensorShape bias_shape{ output_size };

    auto input_to_input_weights      = create_tensor<CLTensor>(input_weights_shape, DataType::QASYMM8, 1, qweights);
    auto input_to_forget_weights     = create_tensor<CLTensor>(input_weights_shape, DataType::QASYMM8, 1, qweights);
    auto input_to_cell_weights       = create_tensor<CLTensor>(input_weights_shape, DataType::QASYMM8, 1, qweights);
    auto input_to_output_weights     = create_tensor<CLTensor>(input_weights_shape, DataType::QASYMM8, 1, qweights);
    auto recurrent_to_input_weights  = create_tensor<CLTensor>(recurrent_weights_shape, DataType::QASYMM8, 1, qweights);
    auto recurrent_to_forget_weights = create_tensor<CLTensor>(recurrent_weights_shape, DataType::QASYMM8, 1, qweights);
    auto recurrent_to_cell_weights   = create_tensor<CLTensor>(recurrent_weights_shape, DataType::QASYMM8, 1, qweights);
    auto recurrent_to_output_weights = create_tensor<CLTensor>(recurrent_weights_shape, DataType::QASYMM8, 1, qweights);
    auto input_gate_bias             = create_tensor<CLTensor>(bias_shape, DataType::S32);
    auto forget_gate_bias            = create_tensor<CLTensor>(bias_shape, DataType::S32);
    auto cell_gate_bias              = create_tensor<CLTensor>(bias_shape, DataType::S32);
    auto output_gate_bias            = create_tensor<CLTensor>(bias_shape, DataType::S32);

    // LSTM input
    auto input = create_tensor<CLTensor>(input_shape, DataType::QASYMM8, 1, qasymm);

    // LSTM output state
    auto output_state = create_tensor<CLTensor>(output_shape, DataType::QASYMM8, 1, qasymm);

    // LSTM cell state
    auto cell_state = create_tensor<CLTensor>(output_shape, DataType::QSYMM16, 1, qsymm_4);

    CLLSTMLayerQuantized lstmq;

    lstmq.configure(&input, &input_to_input_weights, &input_to_forget_weights, &input_to_cell_weights, &input_to_output_weights,
                    &recurrent_to_input_weights, &recurrent_to_forget_weights, &recurrent_to_cell_weights, &recurrent_to_output_weights,
                    &input_gate_bias, &forget_gate_bias, &cell_gate_bias, &output_gate_bias, &cell_state, &output_state, &cell_state, &output_state);

    input.allocator()->allocate();
    input_to_input_weights.allocator()->allocate();
    input_to_forget_weights.allocator()->allocate();
    input_to_cell_weights.allocator()->allocate();
    input_to_output_weights.allocator()->allocate();
    recurrent_to_input_weights.allocator()->allocate();
    recurrent_to_forget_weights.allocator()->allocate();
    recurrent_to_cell_weights.allocator()->allocate();
    recurrent_to_output_weights.allocator()->allocate();
    input_gate_bias.allocator()->allocate();
    forget_gate_bias.allocator()->allocate();
    cell_gate_bias.allocator()->allocate();
    output_gate_bias.allocator()->allocate();
    cell_state.allocator()->allocate();
    output_state.allocator()->allocate();

    // Fill weights and biases
    fill_tensor(input_to_input_weights, std::vector<uint8_t>{ 47,  168,
                                                              66,  239,
                                                               6,   42,
                                                             237,  236 });

    fill_tensor(input_to_forget_weights, std::vector<uint8_t> { 204,  193,
                                                                148,  59,
                                                                113,  17,
                                                                 66, 197 });

    fill_tensor(input_to_cell_weights, std::vector<uint8_t> { 172,  101,
                                                              184, 209,
                                                              165,  82,
                                                              108, 209 });

    fill_tensor(input_to_output_weights, std::vector<uint8_t> { 203, 244,
                                                                219, 114,
                                                                130,  16,
                                                                163, 222 });

    fill_tensor(recurrent_to_input_weights, std::vector<uint8_t> { 162, 168,  7,  95,
                                                                    91, 155, 108, 216,
                                                                   255, 100,  48, 188,
                                                                    58,  37, 186, 147 });

    fill_tensor(recurrent_to_forget_weights, std::vector<uint8_t> {  46,  58,  47, 170,
                                                                    246,  96,  12,  99,
                                                                     68,  23, 186, 161,
                                                                    237, 164,  89,   6 });

    fill_tensor(recurrent_to_cell_weights, std::vector<uint8_t> { 234,  99,   71, 206,
                                                                  205, 159,   64, 253,
                                                                  191, 148,  116,   8,
                                                                  209, 136,   59, 138 });

    fill_tensor(recurrent_to_output_weights, std::vector<uint8_t> {  23, 241, 137, 36,
                                                                    206,   5, 227, 56,
                                                                    254, 176, 231, 47,
                                                                     18, 201, 161, 11 });

    fill_tensor(input_gate_bias, std::vector<int>  {-103038,   30525,  115255, -38154 });
    fill_tensor(forget_gate_bias, std::vector<int> { -23428,  126970,  116806,  46307 });
    fill_tensor(cell_gate_bias, std::vector<int>   { 128006,   69949,  -42808,  42568 });
    fill_tensor(output_gate_bias, std::vector<int> { -67066,  -53607,   47233,  7300  });

    SimpleTensor<uint8_t> expected_output(output_shape, DataType::QASYMM8, 1, qasymm);

    // Initialize state
    fill_tensor(output_state, std::vector<uint8_t> { 128, 128, 128, 128,
                                                     128, 128, 128, 128 });
    fill_tensor(cell_state, std::vector<int16_t> { 0, 0, 0, 0,
                                                   0, 0, 0, 0 });

    // First input
    fill_tensor(input, std::vector<uint8_t> { 106,  193,
                                              155,  150 });

    fill_tensor(expected_output, std::vector<uint8_t> { 128, 130,  36, 134,
                                                        128, 131,  35, 133 });

    lstmq.run();
    validate(CLAccessor(output_state), expected_output);

    // Second input
    fill_tensor(expected_output, std::vector<uint8_t> { 128, 129, 12, 137,
                                                        128, 131, 10, 136 });
    lstmq.run();
    validate(CLAccessor(output_state), expected_output);

    // Third input
    fill_tensor(expected_output, std::vector<uint8_t> { 128, 129, 8, 140,
                                                        128, 130, 6, 138 });
    lstmq.run();
    validate(CLAccessor(output_state), expected_output);
}

TEST_CASE(IntegrationTestCaseLarge, framework::DatasetMode::PRECOMMIT)
{
    const int batch_size  = 16;
    const int input_size  = 8;
    const int output_size = 8;


    QuantizationInfo qasymm(1.f / 128.f, 128);
    QuantizationInfo qweights(1.f / 128.f, 128);
    QuantizationInfo qsymm_3(8.f / 32768.f, 0);
    QuantizationInfo qsymm_4(16.f / 32768.f, 0);

    TensorShape input_shape{ input_size, batch_size };
    TensorShape input_weights_shape{ input_size, output_size };
    TensorShape recurrent_weights_shape{ output_size, output_size };
    TensorShape output_shape{ output_size, batch_size};
    TensorShape bias_shape{ output_size };

    auto input_to_input_weights      = create_tensor<CLTensor>(input_weights_shape, DataType::QASYMM8, 1, qweights);
    auto input_to_forget_weights     = create_tensor<CLTensor>(input_weights_shape, DataType::QASYMM8, 1, qweights);
    auto input_to_cell_weights       = create_tensor<CLTensor>(input_weights_shape, DataType::QASYMM8, 1, qweights);
    auto input_to_output_weights     = create_tensor<CLTensor>(input_weights_shape, DataType::QASYMM8, 1, qweights);
    auto recurrent_to_input_weights  = create_tensor<CLTensor>(recurrent_weights_shape, DataType::QASYMM8, 1, qweights);
    auto recurrent_to_forget_weights = create_tensor<CLTensor>(recurrent_weights_shape, DataType::QASYMM8, 1, qweights);
    auto recurrent_to_cell_weights   = create_tensor<CLTensor>(recurrent_weights_shape, DataType::QASYMM8, 1, qweights);
    auto recurrent_to_output_weights = create_tensor<CLTensor>(recurrent_weights_shape, DataType::QASYMM8, 1, qweights);
    auto input_gate_bias             = create_tensor<CLTensor>(bias_shape, DataType::S32);
    auto forget_gate_bias            = create_tensor<CLTensor>(bias_shape, DataType::S32);
    auto cell_gate_bias              = create_tensor<CLTensor>(bias_shape, DataType::S32);
    auto output_gate_bias            = create_tensor<CLTensor>(bias_shape, DataType::S32);

    // LSTM input
    auto input = create_tensor<CLTensor>(input_shape, DataType::QASYMM8, 1, qasymm);

    // LSTM output state
    auto output_state = create_tensor<CLTensor>(output_shape, DataType::QASYMM8, 1, qasymm);

    // LSTM cell state
    auto cell_state = create_tensor<CLTensor>(output_shape, DataType::QSYMM16, 1, qsymm_4);

    CLLSTMLayerQuantized lstmq;

    lstmq.configure(&input, &input_to_input_weights, &input_to_forget_weights, &input_to_cell_weights, &input_to_output_weights,
                    &recurrent_to_input_weights, &recurrent_to_forget_weights, &recurrent_to_cell_weights, &recurrent_to_output_weights,
                    &input_gate_bias, &forget_gate_bias, &cell_gate_bias, &output_gate_bias, &cell_state, &output_state, &cell_state, &output_state);

    input.allocator()->allocate();
    input_to_input_weights.allocator()->allocate();
    input_to_forget_weights.allocator()->allocate();
    input_to_cell_weights.allocator()->allocate();
    input_to_output_weights.allocator()->allocate();
    recurrent_to_input_weights.allocator()->allocate();
    recurrent_to_forget_weights.allocator()->allocate();
    recurrent_to_cell_weights.allocator()->allocate();
    recurrent_to_output_weights.allocator()->allocate();
    input_gate_bias.allocator()->allocate();
    forget_gate_bias.allocator()->allocate();
    cell_gate_bias.allocator()->allocate();
    output_gate_bias.allocator()->allocate();
    cell_state.allocator()->allocate();
    output_state.allocator()->allocate();

    // Fill weights and biases
    fill_tensor(input_to_input_weights, std::vector<uint8_t>{ 141,  89, 200, 180,  46,  50,  87, 128,
                                                              149, 227, 177, 187, 212, 229,  54, 111,
                                                              131, 116,   3,  58, 196,  26, 131, 255,
                                                               22, 106, 216,  69, 239,  12, 232, 207,
                                                              184,  56, 236, 172,  28, 143, 161, 124,
                                                              255,  33, 197, 122,  47, 197,  26, 229,
                                                               91,  79,  11, 160,  26,  80, 100,  36,
                                                              248, 186,  97,  61, 125,  46,  14, 100, });

    fill_tensor(input_to_forget_weights, std::vector<uint8_t> { 237, 165, 141, 249,  72, 116, 36 , 115,
                                                                234, 213,  85,  84,  59,  62, 150, 246,
                                                                182, 102, 158, 214, 182, 183,  94,  11,
                                                                158, 192,  92, 189, 160, 219, 206, 249,
                                                                 88, 213, 193, 244, 151,  72, 129,  49,
                                                                239,  83, 106,   9, 169, 187, 125, 171,
                                                                 32, 141, 126,  92,  13,  36, 224, 150,
                                                                187, 250, 178, 169,  89, 214,  91, 173 });

    fill_tensor(input_to_cell_weights, std::vector<uint8_t> {  93, 103, 226, 139, 185, 252, 129, 171,
                                                              159,  32,  25, 175, 224, 183, 165,  35,
                                                              207,  69, 238, 228, 149, 214,  79,   6,
                                                                5,  66, 102,  14,  19, 111,  36, 143,
                                                               22,  85,  13,  78, 236, 121, 122,  77,
                                                              249,  39,  88,  12, 205, 143,  93, 240,
                                                              167,  89, 188,  50,  73,  69, 201, 251,
                                                               59,  32, 203, 184, 139, 191, 199,  74});

    fill_tensor(input_to_output_weights, std::vector<uint8_t> { 205,   7,  95, 104, 252, 143, 226,  73,
                                                                229, 114, 152, 171, 221, 153,  73, 229,
                                                                153, 165, 223, 239, 100,  38, 172, 211,
                                                                226, 133, 239, 207, 116, 230, 170, 100,
                                                                241,  95, 171, 124,  63, 115,  32, 127,
                                                                141, 239,  53, 193, 201,  53, 104, 178,
                                                                186, 212, 167, 107, 226, 230,  71, 213,
                                                                148, 217,  19, 248, 233, 195, 183, 156 });

    fill_tensor(recurrent_to_input_weights, std::vector<uint8_t> { 147, 112, 140, 103,   3, 255,  17,  49,
                                                                    84, 112, 144, 213, 138, 142, 112,  66,
                                                                   117,  30, 101,  35,  25, 132, 211, 229,
                                                                   183, 208, 102,  16,  38,  85, 101, 152,
                                                                   226,  83, 132,  22, 161, 110, 157, 129,
                                                                   184,  63, 168,  42, 220, 126, 209, 157,
                                                                     5,  88, 243,  83, 249,  19, 226, 209,
                                                                   173,  96, 185,  77, 146, 227, 238, 136 });


    fill_tensor(recurrent_to_forget_weights, std::vector<uint8_t> {  52, 132,  92, 200, 213,  32, 213,  37,
                                                                    116, 142, 116, 180,   4, 172, 158, 143,
                                                                    110,  40,  99,  28, 221, 153, 133,   2,
                                                                    247, 144, 198, 100,  20,  15, 221, 196,
                                                                    159, 178, 188, 151, 171,  15,  25, 217,
                                                                    178, 109, 110, 118, 128,  39, 232, 234,
                                                                    184, 214, 177,  13,  56,   6,  28, 252,
                                                                     89, 187, 242,  59, 146, 111, 132, 129});

    fill_tensor(recurrent_to_cell_weights, std::vector<uint8_t> {  70,  44, 137,  29,  36, 127,   1, 241,
                                                                   26, 241, 142, 114,  67, 181,  49,  57,
                                                                  131, 152, 175,  77,  23,  63,  37, 124,
                                                                  150, 113,  95, 103, 110, 201,  69,  97,
                                                                  196, 242,  62, 214,  66,  19,  45, 135,
                                                                   22, 168, 149, 104,  77, 101,  36,  68,
                                                                  170, 116, 222, 100, 109,   1, 154,  18,
                                                                  133, 215, 105,  93,  31,  57, 231, 112 });


    fill_tensor(recurrent_to_output_weights, std::vector<uint8_t> { 45 ,  181 ,  220 ,  219 ,   49  ,  63 ,   49  , 129,
                                                                     7 ,  166 ,  104 ,  114 ,   83  ,  40 ,    1  , 195,
                                                                   245 ,  142 ,   82 ,  232 ,  104  , 245 ,   82  , 196,
                                                                   111 ,   56 ,  156 ,    9 ,  141  , 240 ,  180  , 148,
                                                                   247 ,  198 ,  234 ,  137 ,   13  , 210 ,  161  , 192,
                                                                   196 ,   59 ,  233 ,  184 ,  142  , 187 ,  140  , 166,
                                                                     2 ,   95 ,  152 ,   46 ,   71  ,  46 ,  113  ,  32,
                                                                   175 ,  229 ,   86 ,   87 ,   62  ,  93 ,   74  , 130});

    fill_tensor(input_gate_bias, std::vector<int>  {  -40040, -106916,  -92315,  -79123,   45160, -17954,   50962, -63758 });
    fill_tensor(forget_gate_bias, std::vector<int> { -128514,    8463,  -57831,  116977,  106547, -28132, -124557,  44941 });
    fill_tensor(cell_gate_bias, std::vector<int>   { 88388  ,  123601, -116148,  -13022,   21619,  48926,   57523,  39332 });
    fill_tensor(output_gate_bias, std::vector<int> {  59485 ,  -33070,   21386, -100633, -115959, 125768,  -56407,  24897 });

    SimpleTensor<uint8_t> expected_output(output_shape, DataType::QASYMM8, 1, qasymm);

    // Initialize state
    fill_tensor(output_state, std::vector<uint8_t> { 128, 128, 128, 128, 128, 128, 128, 128,
                                                     128, 128, 128, 128, 128, 128, 128, 128,
                                                     128, 128, 128, 128, 128, 128, 128, 128,
                                                     128, 128, 128, 128, 128, 128, 128, 128,
                                                     128, 128, 128, 128, 128, 128, 128, 128,
                                                     128, 128, 128, 128, 128, 128, 128, 128,
                                                     128, 128, 128, 128, 128, 128, 128, 128,
                                                     128, 128, 128, 128, 128, 128, 128, 128,
                                                     128, 128, 128, 128, 128, 128, 128, 128,
                                                     128, 128, 128, 128, 128, 128, 128, 128,
                                                     128, 128, 128, 128, 128, 128, 128, 128,
                                                     128, 128, 128, 128, 128, 128, 128, 128,
                                                     128, 128, 128, 128, 128, 128, 128, 128,
                                                     128, 128, 128, 128, 128, 128, 128, 128,
                                                     128, 128, 128, 128, 128, 128, 128, 128,
                                                     128, 128, 128, 128, 128, 128, 128, 128 });

    fill_tensor(cell_state, std::vector<int16_t> { 0, 0, 0, 0, 0, 0, 0, 0,
                                                   0, 0, 0, 0, 0, 0, 0, 0,
                                                   0, 0, 0, 0, 0, 0, 0, 0,
                                                   0, 0, 0, 0, 0, 0, 0, 0,
                                                   0, 0, 0, 0, 0, 0, 0, 0,
                                                   0, 0, 0, 0, 0, 0, 0, 0,
                                                   0, 0, 0, 0, 0, 0, 0, 0,
                                                   0, 0, 0, 0, 0, 0, 0, 0,
                                                   0, 0, 0, 0, 0, 0, 0, 0,
                                                   0, 0, 0, 0, 0, 0, 0, 0,
                                                   0, 0, 0, 0, 0, 0, 0, 0,
                                                   0, 0, 0, 0, 0, 0, 0, 0,
                                                   0, 0, 0, 0, 0, 0, 0, 0,
                                                   0, 0, 0, 0, 0, 0, 0, 0,
                                                   0, 0, 0, 0, 0, 0, 0, 0,
                                                   0, 0, 0, 0, 0, 0, 0, 0});

    // First input
    fill_tensor(input, std::vector<uint8_t> { 247,  203, 159, 131, 182, 114, 207, 195,
                                              48 ,  61 , 154,  16,  80, 101, 116, 255,
                                              50 , 115 ,  45, 186,  75, 212,  98,  48,
                                              88 , 146 ,  24, 143, 218, 174, 203, 200,
                                             239 ,  16 ,  66, 136, 234,  54,  94,  51,
                                             101 , 128 , 220, 213, 164,  82, 137, 255,
                                              70 , 165 , 234, 220,  66,  35, 183, 206,
                                              39 ,  57 , 180, 202,  23, 172, 224, 109,
                                             102 , 215 , 186,  82, 215, 147,  85, 187,
                                              96 , 249 ,  59, 116, 150,  44, 167, 128,
                                              34 , 217 , 148, 193, 243,  38, 250, 208,
                                             112 , 130 , 208,  29,  16, 122,  20,  92,
                                              24 ,  72 , 104,  29, 150, 233, 151,  19,
                                             158 , 192 , 254,  70,  73, 142, 106, 152,
                                               3 ,  61 ,  24, 135, 212,   9,  80, 234,
                                             147 , 246 ,  83, 249,  49,  14,  68,  50});

    fill_tensor(expected_output, std::vector<uint8_t> {131, 128,  128,  128,  128,  180,  129,  133,
                                                       136, 128,  126,  128,  128,  173,  135,  130,
                                                       160, 128,  128,  128,  128,  138,  132,  129,
                                                       131, 128,  127,  128,  128,  169,  129,  131,
                                                       133, 128,  128,  128,  128,  182,  130,  129,
                                                       131, 128,  128,  128,  128,  163,  129,  130,
                                                       131, 128,  128,  128,  128,  149,  132,  129,
                                                       143, 128,  127,  128,  128,  150,  134,  131,
                                                       134, 128,  128,  128,  128,  167,  130,  130,
                                                       131, 128,  128,  128,  128,  152,  132,  129,
                                                       128, 128,  128,  128,  128,  169,  130,  130,
                                                       173, 128,  128,  128,  128,  148,  139,  130,
                                                       152, 128,  128,  128,  128,  168,  139,  132,
                                                       147, 128,  128,  128,  128,  161,  131,  132,
                                                       130, 128,  128,  128,  128,  159,  134,  128,
                                                       140, 128,  128,  128,  128,  133,  132,  128 });

    lstmq.run();
    validate(CLAccessor(output_state), expected_output);

    // Second input
    fill_tensor(expected_output, std::vector<uint8_t> { 130,   128,   128,   128,   128,   205,   129,   137,
                                                        135,   128,   127,   128,   128,   190,   137,   132,
                                                        160,   128,   128,   128,   128,   142,   133,   131,
                                                        130,   128,   128,   128,   128,   185,   129,   133,
                                                        132,   128,   128,   128,   128,   198,   131,   130,
                                                        130,   128,   128,   128,   128,   178,   130,   131,
                                                        131,   128,   128,   128,   128,   158,   132,   131,
                                                        142,   128,   127,   128,   128,   158,   135,   134,
                                                        133,   128,   128,   128,   128,   178,   131,   132,
                                                        131,   128,   128,   128,   128,   160,   132,   130,
                                                        128,   128,   128,   128,   128,   190,   131,   131,
                                                        170,   128,   128,   128,   128,   157,   142,   131,
                                                        149,   128,   128,   128,   128,   178,   142,   135,
                                                        145,   128,   128,   128,   129,   173,   132,   135,
                                                        129,   128,   128,   128,   128,   171,   134,   129,
                                                        140,   128,   128,   128,   128,   135,   132,   129});
    lstmq.run();
    validate(CLAccessor(output_state), expected_output);
}
// clang-format on
// *INDENT-ON*

TEST_SUITE_END() // LSTMLayerQuantized
TEST_SUITE_END() // NEON
} // namespace validation
} // namespace test
} // namespace arm_compute