//*****************************************************************************
// Copyright 2017-2020 Intel Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//*****************************************************************************

// !!!!!!!!!!!!!! THIS FILE IS AUTOGENERATED OUTSIDE OF THE BUILD PROCESS !!!!!!!!!!!!!!
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! DO NOT EDIT THIS FILE !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//
// DO NOT EDIT THIS FILE. If you want to add new tests, you should edit
//  test/ref_generators/generate_dyn_slice_ref.py and regenerate this file.
//
// To regenerate:
//
//   $ cd <ngraph source dir>/test
//   $ ./update_dyn_slice_reference.sh
//
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! DO NOT EDIT THIS FILE !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// !!!!!!!!!!!!!! THIS FILE IS AUTOGENERATED OUTSIDE OF THE BUILD PROCESS !!!!!!!!!!!!!!
//
// clang-format off

#include <algorithm>
#include <cmath>

#include "gtest/gtest.h"

#include "ngraph/ngraph.hpp"
#include "util/test_tools.hpp"
#include "util/autodiff/numeric_compare.hpp"
#include "util/all_close_f.hpp"
#include "util/test_control.hpp"

using namespace std;
using namespace ngraph;

static string s_manifest = "${MANIFEST}";

template <typename T>
void check_failure(const element::Type& input_element_type,
                   const Shape& input_shape,
                   const std::vector<int64_t>& lb_values,
                   const std::vector<int64_t>& ub_values,
                   const std::vector<int64_t>& strides_values,
                   const AxisSet& lb_mask,
                   const AxisSet& ub_mask,
                   const AxisSet& new_mask,
                   const AxisSet& shrink_mask,
                   const AxisSet& ellipsis_mask)
{
    auto arg = std::make_shared<op::Parameter>(input_element_type, input_shape);
    auto lb = std::make_shared<op::Parameter>(element::i64, Shape{lb_values.size()});
    auto ub = std::make_shared<op::Parameter>(element::i64, Shape{ub_values.size()});
    auto strides = std::make_shared<op::Parameter>(element::i64, Shape{strides_values.size()});

    std::vector<T> input_values(shape_size(input_shape));
    std::iota(input_values.begin(), input_values.end(), static_cast<T>(0));

    EXPECT_ANY_THROW({
        auto slice = std::make_shared<op::DynSlice>(arg, lb, ub, strides, lb_mask, ub_mask, new_mask, shrink_mask, ellipsis_mask);

        auto f = std::make_shared<Function>(NodeVector{slice}, ParameterVector{arg, lb, ub, strides});

        auto backend = runtime::Backend::create("${BACKEND_NAME}",true);
        auto ex = backend->compile(f);

        auto input_arg = backend->create_tensor(input_element_type, input_shape);
        auto input_lb = backend->create_tensor(element::i64, Shape{lb_values.size()});
        auto input_ub = backend->create_tensor(element::i64, Shape{ub_values.size()});
        auto input_strides = backend->create_tensor(element::i64, Shape{strides_values.size()});
        copy_data(input_arg, input_values);
        copy_data(input_lb, lb_values);
        copy_data(input_ub, ub_values);
        copy_data(input_strides, strides_values);

        auto output = backend->create_dynamic_tensor(input_element_type, PartialShape::dynamic());

        ex->call_with_validate({output}, {input_arg, input_lb, input_ub, input_strides});
    });
}

template <typename T>
void check_success(const element::Type& input_element_type,
                   const Shape& input_shape,
                   const std::vector<int64_t>& lb_values,
                   const std::vector<int64_t>& ub_values,
                   const std::vector<int64_t>& strides_values,
                   const AxisSet& lb_mask,
                   const AxisSet& ub_mask,
                   const AxisSet& new_mask,
                   const AxisSet& shrink_mask,
                   const AxisSet& ellipsis_mask,
                   const Shape& expected_output_shape,
                   const std::vector<T>& expected_values)
{
    auto arg = std::make_shared<op::Parameter>(input_element_type, input_shape);
    auto lb = std::make_shared<op::Parameter>(element::i64, Shape{lb_values.size()});
    auto ub = std::make_shared<op::Parameter>(element::i64, Shape{ub_values.size()});
    auto strides = std::make_shared<op::Parameter>(element::i64, Shape{strides_values.size()});

    std::vector<T> input_values(shape_size(input_shape));
    std::iota(input_values.begin(), input_values.end(), static_cast<T>(0));

    auto slice = std::make_shared<op::DynSlice>(arg, lb, ub, strides, lb_mask, ub_mask, new_mask, shrink_mask, ellipsis_mask);

    auto f = std::make_shared<Function>(NodeVector{slice}, ParameterVector{arg, lb, ub, strides});

    auto backend = runtime::Backend::create("${BACKEND_NAME}",true);
    auto ex = backend->compile(f);

    auto input_arg = backend->create_tensor(input_element_type, input_shape);
    auto input_lb = backend->create_tensor(element::i64, Shape{lb_values.size()});
    auto input_ub = backend->create_tensor(element::i64, Shape{ub_values.size()});
    auto input_strides = backend->create_tensor(element::i64, Shape{strides_values.size()});
    copy_data(input_arg, input_values);
    copy_data(input_lb, lb_values);
    copy_data(input_ub, ub_values);
    copy_data(input_strides, strides_values);

    auto output = backend->create_dynamic_tensor(input_element_type, PartialShape::dynamic());

    ex->call_with_validate({output}, {input_arg, input_lb, input_ub, input_strides});

    EXPECT_EQ(output->get_element_type(), input_element_type);
    EXPECT_EQ(output->get_shape(), expected_output_shape);

    auto output_values = read_vector<T>(output);

    EXPECT_EQ(output_values, expected_values);
}

// slices are: [newaxis,3:0:-1]
// dtype is: int32
// input shape is: Shape{4}
// expected output shape is Shape{1,3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_0)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{4},
                  std::vector<int64_t>{0,3},
                  std::vector<int64_t>{0,0},
                  std::vector<int64_t>{1,-1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  Shape{1,3},
                  std::vector<int32_t>{3,2,1});
}

// slices are: [...]
// dtype is: int32
// input shape is: Shape{4}
// expected output shape is Shape{4}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_1)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{4},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0},
                  Shape{4},
                  std::vector<int32_t>{0,1,2,3});
}

// slices are: [1:3]
// dtype is: int32
// input shape is: Shape{4}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_2)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{4},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int32_t>{1,2});
}

// slices are: [2]
// dtype is: int32
// input shape is: Shape{4}
// expected output shape is Shape{}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_3)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{4},
                  std::vector<int64_t>{2},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  Shape{},
                  std::vector<int32_t>{2});
}

// slices are: [3:0:-2]
// dtype is: int32
// input shape is: Shape{4}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_4)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{4},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int32_t>{3,1});
}

// slices are: [3::-2]
// dtype is: int32
// input shape is: Shape{4}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_5)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{4},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int32_t>{3,1});
}

// slices are: [4::-2]
// dtype is: int32
// input shape is: Shape{4}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_6)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{4},
                  std::vector<int64_t>{4},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int32_t>{3,1});
}

// slices are: [5::-2]
// dtype is: int32
// input shape is: Shape{4}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_7)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{4},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int32_t>{3,1});
}

// slices are: [-9000:-8000:2]
// dtype is: int32
// input shape is: Shape{4}
// expected output shape is Shape{0}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_8)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{4},
                  std::vector<int64_t>{-9000},
                  std::vector<int64_t>{-8000},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{0},
                  std::vector<int32_t>{});
}

// slices are: [-9000:8000:2]
// dtype is: int32
// input shape is: Shape{4}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_9)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{4},
                  std::vector<int64_t>{-9000},
                  std::vector<int64_t>{8000},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int32_t>{0,2});
}

// slices are: [-5:5:2]
// dtype is: int32
// input shape is: Shape{4}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_10)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{4},
                  std::vector<int64_t>{-5},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int32_t>{0,2});
}

// slices are: [newaxis]
// dtype is: int32
// input shape is: Shape{4}
// expected output shape is Shape{1,4}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_11)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{4},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  Shape{1,4},
                  std::vector<int32_t>{0,1,2,3});
}

// slices are: [newaxis,newaxis]
// dtype is: int32
// input shape is: Shape{4}
// expected output shape is Shape{1,1,4}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_12)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{4},
                  std::vector<int64_t>{0,0},
                  std::vector<int64_t>{0,0},
                  std::vector<int64_t>{1,1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0,1},
                  AxisSet{},
                  AxisSet{},
                  Shape{1,1,4},
                  std::vector<int32_t>{0,1,2,3});
}

// slices are: [newaxis,newaxis,...,newaxis]
// dtype is: int32
// input shape is: Shape{4}
// expected output shape is Shape{1,1,4,1}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_13)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{4},
                  std::vector<int64_t>{0,0,0,0},
                  std::vector<int64_t>{0,0,0,0},
                  std::vector<int64_t>{1,1,1,1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0,1,3},
                  AxisSet{},
                  AxisSet{2},
                  Shape{1,1,4,1},
                  std::vector<int32_t>{0,1,2,3});
}

// slices are: [3:0:-2]
// dtype is: int32
// input shape is: Shape{5}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_14)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{5},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int32_t>{3,1});
}

// slices are: [0:3:2]
// dtype is: int32
// input shape is: Shape{5}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_15)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int32_t>{0,2});
}

// slices are: [0:4:2]
// dtype is: int32
// input shape is: Shape{5}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_16)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{4},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int32_t>{0,2});
}

// slices are: [0:5:2]
// dtype is: int32
// input shape is: Shape{5}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_17)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<int32_t>{0,2,4});
}

// slices are: [0:6:2]
// dtype is: int32
// input shape is: Shape{5}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_18)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{6},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<int32_t>{0,2,4});
}

// slices are: [0:100:2]
// dtype is: int32
// input shape is: Shape{5}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_19)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{100},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<int32_t>{0,2,4});
}

// slices are: [4:0:-2]
// dtype is: int32
// input shape is: Shape{5}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_20)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{5},
                  std::vector<int64_t>{4},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int32_t>{4,2});
}

// slices are: [4:0:-3]
// dtype is: int32
// input shape is: Shape{5}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_21)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{5},
                  std::vector<int64_t>{4},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int32_t>{4,1});
}

// slices are: [3:2:1]
// dtype is: int32
// input shape is: Shape{5}
// expected output shape is Shape{0}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_22)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{5},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{2},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{0},
                  std::vector<int32_t>{});
}

// slices are: [4::-2]
// dtype is: int32
// input shape is: Shape{5}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_23)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{5},
                  std::vector<int64_t>{4},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<int32_t>{4,2,0});
}

// slices are: [1:-5:-1]
// dtype is: int32
// input shape is: Shape{5}
// expected output shape is Shape{1}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_24)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{5},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{-5},
                  std::vector<int64_t>{-1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{1},
                  std::vector<int32_t>{1});
}

// slices are: [1:-1:-1]
// dtype is: int32
// input shape is: Shape{5}
// expected output shape is Shape{0}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_25)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{5},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{-1},
                  std::vector<int64_t>{-1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{0},
                  std::vector<int32_t>{});
}

// slices are: [1:]
// dtype is: int32
// input shape is: Shape{5}
// expected output shape is Shape{4}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_26)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{5},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{4},
                  std::vector<int32_t>{1,2,3,4});
}

// slices are: [1::-1]
// dtype is: int32
// input shape is: Shape{5}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_27)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{5},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-1},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int32_t>{1,0});
}

// slices are: [-5:5:2]
// dtype is: int32
// input shape is: Shape{5}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_28)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{5},
                  std::vector<int64_t>{-5},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<int32_t>{0,2,4});
}

// slices are: [-1:5:1]
// dtype is: int32
// input shape is: Shape{5}
// expected output shape is Shape{1}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_29)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{5},
                  std::vector<int64_t>{-1},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{1},
                  std::vector<int32_t>{4});
}

// slices are: [-1:1:1]
// dtype is: int32
// input shape is: Shape{5}
// expected output shape is Shape{0}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_30)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{5},
                  std::vector<int64_t>{-1},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{0},
                  std::vector<int32_t>{});
}

// slices are: [5:2:-3]
// dtype is: int32
// input shape is: Shape{8}
// expected output shape is Shape{1}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_31)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{8},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{2},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{1},
                  std::vector<int32_t>{5});
}

// slices are: [5:1:-3]
// dtype is: int32
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_32)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{8},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int32_t>{5,2});
}

// slices are: [5:0:-3]
// dtype is: int32
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_33)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{8},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int32_t>{5,2});
}

// slices are: [5::-3]
// dtype is: int32
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_34)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{8},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int32_t>{5,2});
}

// slices are: [6:3:-3]
// dtype is: int32
// input shape is: Shape{8}
// expected output shape is Shape{1}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_35)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{8},
                  std::vector<int64_t>{6},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{1},
                  std::vector<int32_t>{6});
}

// slices are: [6:2:-3]
// dtype is: int32
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_36)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{8},
                  std::vector<int64_t>{6},
                  std::vector<int64_t>{2},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int32_t>{6,3});
}

// slices are: [6:1:-3]
// dtype is: int32
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_37)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{8},
                  std::vector<int64_t>{6},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int32_t>{6,3});
}

// slices are: [6::-3]
// dtype is: int32
// input shape is: Shape{8}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_38)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{8},
                  std::vector<int64_t>{6},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<int32_t>{6,3,0});
}

// slices are: [7:1:-3]
// dtype is: int32
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_39)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{8},
                  std::vector<int64_t>{7},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int32_t>{7,4});
}

// slices are: [7:0:-3]
// dtype is: int32
// input shape is: Shape{8}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_40)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{8},
                  std::vector<int64_t>{7},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<int32_t>{7,4,1});
}

// slices are: [7::-3]
// dtype is: int32
// input shape is: Shape{8}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_41)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{8},
                  std::vector<int64_t>{7},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<int32_t>{7,4,1});
}

// slices are: [newaxis,3:0:-1]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{1,3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_42)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{0,3},
                  std::vector<int64_t>{0,0},
                  std::vector<int64_t>{1,-1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  Shape{1,3},
                  std::vector<int64_t>{3,2,1});
}

// slices are: [...]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{8}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_43)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0},
                  Shape{8},
                  std::vector<int64_t>{0,1,2,3,4,5,6,7});
}

// slices are: [1:3]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_44)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int64_t>{1,2});
}

// slices are: [2]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_45)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{2},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  Shape{},
                  std::vector<int64_t>{2});
}

// slices are: [3:0:-2]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_46)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int64_t>{3,1});
}

// slices are: [3::-2]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_47)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int64_t>{3,1});
}

// slices are: [4::-2]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_48)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{4},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<int64_t>{4,2,0});
}

// slices are: [5::-2]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_49)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<int64_t>{5,3,1});
}

// slices are: [-9000:-8000:2]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{0}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_50)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{-9000},
                  std::vector<int64_t>{-8000},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{0},
                  std::vector<int64_t>{});
}

// slices are: [-9000:8000:2]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{4}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_51)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{-9000},
                  std::vector<int64_t>{8000},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{4},
                  std::vector<int64_t>{0,2,4,6});
}

// slices are: [-5:5:2]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{1}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_52)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{-5},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{1},
                  std::vector<int64_t>{3});
}

// slices are: [newaxis]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{1,8}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_53)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  Shape{1,8},
                  std::vector<int64_t>{0,1,2,3,4,5,6,7});
}

// slices are: [newaxis,newaxis]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{1,1,8}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_54)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{0,0},
                  std::vector<int64_t>{0,0},
                  std::vector<int64_t>{1,1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0,1},
                  AxisSet{},
                  AxisSet{},
                  Shape{1,1,8},
                  std::vector<int64_t>{0,1,2,3,4,5,6,7});
}

// slices are: [newaxis,newaxis,...,newaxis]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{1,1,8,1}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_55)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{0,0,0,0},
                  std::vector<int64_t>{0,0,0,0},
                  std::vector<int64_t>{1,1,1,1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0,1,3},
                  AxisSet{},
                  AxisSet{2},
                  Shape{1,1,8,1},
                  std::vector<int64_t>{0,1,2,3,4,5,6,7});
}

// slices are: [3:0:-2]
// dtype is: int64
// input shape is: Shape{5}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_56)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{5},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int64_t>{3,1});
}

// slices are: [0:3:2]
// dtype is: int64
// input shape is: Shape{5}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_57)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int64_t>{0,2});
}

// slices are: [0:4:2]
// dtype is: int64
// input shape is: Shape{5}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_58)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{4},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int64_t>{0,2});
}

// slices are: [0:5:2]
// dtype is: int64
// input shape is: Shape{5}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_59)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<int64_t>{0,2,4});
}

// slices are: [0:6:2]
// dtype is: int64
// input shape is: Shape{5}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_60)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{6},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<int64_t>{0,2,4});
}

// slices are: [0:100:2]
// dtype is: int64
// input shape is: Shape{5}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_61)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{100},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<int64_t>{0,2,4});
}

// slices are: [4:0:-2]
// dtype is: int64
// input shape is: Shape{5}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_62)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{5},
                  std::vector<int64_t>{4},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int64_t>{4,2});
}

// slices are: [4:0:-3]
// dtype is: int64
// input shape is: Shape{5}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_63)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{5},
                  std::vector<int64_t>{4},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int64_t>{4,1});
}

// slices are: [3:2:1]
// dtype is: int64
// input shape is: Shape{5}
// expected output shape is Shape{0}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_64)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{5},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{2},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{0},
                  std::vector<int64_t>{});
}

// slices are: [4::-2]
// dtype is: int64
// input shape is: Shape{5}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_65)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{5},
                  std::vector<int64_t>{4},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<int64_t>{4,2,0});
}

// slices are: [1:-5:-1]
// dtype is: int64
// input shape is: Shape{5}
// expected output shape is Shape{1}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_66)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{5},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{-5},
                  std::vector<int64_t>{-1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{1},
                  std::vector<int64_t>{1});
}

// slices are: [1:-1:-1]
// dtype is: int64
// input shape is: Shape{5}
// expected output shape is Shape{0}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_67)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{5},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{-1},
                  std::vector<int64_t>{-1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{0},
                  std::vector<int64_t>{});
}

// slices are: [1:]
// dtype is: int64
// input shape is: Shape{5}
// expected output shape is Shape{4}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_68)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{5},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{4},
                  std::vector<int64_t>{1,2,3,4});
}

// slices are: [1::-1]
// dtype is: int64
// input shape is: Shape{5}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_69)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{5},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-1},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int64_t>{1,0});
}

// slices are: [-5:5:2]
// dtype is: int64
// input shape is: Shape{5}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_70)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{5},
                  std::vector<int64_t>{-5},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<int64_t>{0,2,4});
}

// slices are: [-1:5:1]
// dtype is: int64
// input shape is: Shape{5}
// expected output shape is Shape{1}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_71)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{5},
                  std::vector<int64_t>{-1},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{1},
                  std::vector<int64_t>{4});
}

// slices are: [-1:1:1]
// dtype is: int64
// input shape is: Shape{5}
// expected output shape is Shape{0}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_72)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{5},
                  std::vector<int64_t>{-1},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{0},
                  std::vector<int64_t>{});
}

// slices are: [5:2:-3]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{1}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_73)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{2},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{1},
                  std::vector<int64_t>{5});
}

// slices are: [5:1:-3]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_74)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int64_t>{5,2});
}

// slices are: [5:0:-3]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_75)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int64_t>{5,2});
}

// slices are: [5::-3]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_76)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int64_t>{5,2});
}

// slices are: [6:3:-3]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{1}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_77)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{6},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{1},
                  std::vector<int64_t>{6});
}

// slices are: [6:2:-3]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_78)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{6},
                  std::vector<int64_t>{2},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int64_t>{6,3});
}

// slices are: [6:1:-3]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_79)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{6},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int64_t>{6,3});
}

// slices are: [6::-3]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_80)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{6},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<int64_t>{6,3,0});
}

// slices are: [7:1:-3]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_81)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{7},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<int64_t>{7,4});
}

// slices are: [7:0:-3]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_82)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{7},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<int64_t>{7,4,1});
}

// slices are: [7::-3]
// dtype is: int64
// input shape is: Shape{8}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_83)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{8},
                  std::vector<int64_t>{7},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<int64_t>{7,4,1});
}

// slices are: [newaxis,3:0:-1]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{1,3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_84)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{0,3},
                  std::vector<int64_t>{0,0},
                  std::vector<int64_t>{1,-1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  Shape{1,3},
                  std::vector<float>{3.0,2.0,1.0});
}

// slices are: [...]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{8}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_85)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0},
                  Shape{8},
                  std::vector<float>{0.0,1.0,2.0,3.0,4.0,5.0,6.0,7.0});
}

// slices are: [1:3]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_86)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<float>{1.0,2.0});
}

// slices are: [2]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_87)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{2},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  Shape{},
                  std::vector<float>{2.0});
}

// slices are: [3:0:-2]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_88)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<float>{3.0,1.0});
}

// slices are: [3::-2]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_89)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<float>{3.0,1.0});
}

// slices are: [4::-2]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_90)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{4},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<float>{4.0,2.0,0.0});
}

// slices are: [5::-2]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_91)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<float>{5.0,3.0,1.0});
}

// slices are: [-9000:-8000:2]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{0}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_92)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{-9000},
                  std::vector<int64_t>{-8000},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{0},
                  std::vector<float>{});
}

// slices are: [-9000:8000:2]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{4}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_93)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{-9000},
                  std::vector<int64_t>{8000},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{4},
                  std::vector<float>{0.0,2.0,4.0,6.0});
}

// slices are: [-5:5:2]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{1}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_94)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{-5},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{1},
                  std::vector<float>{3.0});
}

// slices are: [newaxis]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{1,8}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_95)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  Shape{1,8},
                  std::vector<float>{0.0,1.0,2.0,3.0,4.0,5.0,6.0,7.0});
}

// slices are: [newaxis,newaxis]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{1,1,8}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_96)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{0,0},
                  std::vector<int64_t>{0,0},
                  std::vector<int64_t>{1,1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0,1},
                  AxisSet{},
                  AxisSet{},
                  Shape{1,1,8},
                  std::vector<float>{0.0,1.0,2.0,3.0,4.0,5.0,6.0,7.0});
}

// slices are: [newaxis,newaxis,...,newaxis]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{1,1,8,1}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_97)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{0,0,0,0},
                  std::vector<int64_t>{0,0,0,0},
                  std::vector<int64_t>{1,1,1,1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0,1,3},
                  AxisSet{},
                  AxisSet{2},
                  Shape{1,1,8,1},
                  std::vector<float>{0.0,1.0,2.0,3.0,4.0,5.0,6.0,7.0});
}

// slices are: [3:0:-2]
// dtype is: float32
// input shape is: Shape{5}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_98)
{
    check_success<float>
                 (element::f32,
                  Shape{5},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<float>{3.0,1.0});
}

// slices are: [0:3:2]
// dtype is: float32
// input shape is: Shape{5}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_99)
{
    check_success<float>
                 (element::f32,
                  Shape{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<float>{0.0,2.0});
}

// slices are: [0:4:2]
// dtype is: float32
// input shape is: Shape{5}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_100)
{
    check_success<float>
                 (element::f32,
                  Shape{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{4},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<float>{0.0,2.0});
}

// slices are: [0:5:2]
// dtype is: float32
// input shape is: Shape{5}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_101)
{
    check_success<float>
                 (element::f32,
                  Shape{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<float>{0.0,2.0,4.0});
}

// slices are: [0:6:2]
// dtype is: float32
// input shape is: Shape{5}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_102)
{
    check_success<float>
                 (element::f32,
                  Shape{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{6},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<float>{0.0,2.0,4.0});
}

// slices are: [0:100:2]
// dtype is: float32
// input shape is: Shape{5}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_103)
{
    check_success<float>
                 (element::f32,
                  Shape{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{100},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<float>{0.0,2.0,4.0});
}

// slices are: [4:0:-2]
// dtype is: float32
// input shape is: Shape{5}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_104)
{
    check_success<float>
                 (element::f32,
                  Shape{5},
                  std::vector<int64_t>{4},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<float>{4.0,2.0});
}

// slices are: [4:0:-3]
// dtype is: float32
// input shape is: Shape{5}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_105)
{
    check_success<float>
                 (element::f32,
                  Shape{5},
                  std::vector<int64_t>{4},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<float>{4.0,1.0});
}

// slices are: [3:2:1]
// dtype is: float32
// input shape is: Shape{5}
// expected output shape is Shape{0}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_106)
{
    check_success<float>
                 (element::f32,
                  Shape{5},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{2},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{0},
                  std::vector<float>{});
}

// slices are: [4::-2]
// dtype is: float32
// input shape is: Shape{5}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_107)
{
    check_success<float>
                 (element::f32,
                  Shape{5},
                  std::vector<int64_t>{4},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<float>{4.0,2.0,0.0});
}

// slices are: [1:-5:-1]
// dtype is: float32
// input shape is: Shape{5}
// expected output shape is Shape{1}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_108)
{
    check_success<float>
                 (element::f32,
                  Shape{5},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{-5},
                  std::vector<int64_t>{-1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{1},
                  std::vector<float>{1.0});
}

// slices are: [1:-1:-1]
// dtype is: float32
// input shape is: Shape{5}
// expected output shape is Shape{0}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_109)
{
    check_success<float>
                 (element::f32,
                  Shape{5},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{-1},
                  std::vector<int64_t>{-1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{0},
                  std::vector<float>{});
}

// slices are: [1:]
// dtype is: float32
// input shape is: Shape{5}
// expected output shape is Shape{4}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_110)
{
    check_success<float>
                 (element::f32,
                  Shape{5},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{4},
                  std::vector<float>{1.0,2.0,3.0,4.0});
}

// slices are: [1::-1]
// dtype is: float32
// input shape is: Shape{5}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_111)
{
    check_success<float>
                 (element::f32,
                  Shape{5},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-1},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<float>{1.0,0.0});
}

// slices are: [-5:5:2]
// dtype is: float32
// input shape is: Shape{5}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_112)
{
    check_success<float>
                 (element::f32,
                  Shape{5},
                  std::vector<int64_t>{-5},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<float>{0.0,2.0,4.0});
}

// slices are: [-1:5:1]
// dtype is: float32
// input shape is: Shape{5}
// expected output shape is Shape{1}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_113)
{
    check_success<float>
                 (element::f32,
                  Shape{5},
                  std::vector<int64_t>{-1},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{1},
                  std::vector<float>{4.0});
}

// slices are: [-1:1:1]
// dtype is: float32
// input shape is: Shape{5}
// expected output shape is Shape{0}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_114)
{
    check_success<float>
                 (element::f32,
                  Shape{5},
                  std::vector<int64_t>{-1},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{0},
                  std::vector<float>{});
}

// slices are: [5:2:-3]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{1}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_115)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{2},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{1},
                  std::vector<float>{5.0});
}

// slices are: [5:1:-3]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_116)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<float>{5.0,2.0});
}

// slices are: [5:0:-3]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_117)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<float>{5.0,2.0});
}

// slices are: [5::-3]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_118)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<float>{5.0,2.0});
}

// slices are: [6:3:-3]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{1}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_119)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{6},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{1},
                  std::vector<float>{6.0});
}

// slices are: [6:2:-3]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_120)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{6},
                  std::vector<int64_t>{2},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<float>{6.0,3.0});
}

// slices are: [6:1:-3]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_121)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{6},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<float>{6.0,3.0});
}

// slices are: [6::-3]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_122)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{6},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<float>{6.0,3.0,0.0});
}

// slices are: [7:1:-3]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_123)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{7},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<float>{7.0,4.0});
}

// slices are: [7:0:-3]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_124)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{7},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<float>{7.0,4.0,1.0});
}

// slices are: [7::-3]
// dtype is: float32
// input shape is: Shape{8}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_125)
{
    check_success<float>
                 (element::f32,
                  Shape{8},
                  std::vector<int64_t>{7},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<float>{7.0,4.0,1.0});
}

// slices are: [newaxis,3:0:-1]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{1,3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_126)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{0,3},
                  std::vector<int64_t>{0,0},
                  std::vector<int64_t>{1,-1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  Shape{1,3},
                  std::vector<uint32_t>{3,2,1});
}

// slices are: [...]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{8}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_127)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0},
                  Shape{8},
                  std::vector<uint32_t>{0,1,2,3,4,5,6,7});
}

// slices are: [1:3]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_128)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<uint32_t>{1,2});
}

// slices are: [2]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_129)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{2},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  Shape{},
                  std::vector<uint32_t>{2});
}

// slices are: [3:0:-2]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_130)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<uint32_t>{3,1});
}

// slices are: [3::-2]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_131)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<uint32_t>{3,1});
}

// slices are: [4::-2]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_132)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{4},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<uint32_t>{4,2,0});
}

// slices are: [5::-2]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_133)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<uint32_t>{5,3,1});
}

// slices are: [-9000:-8000:2]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{0}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_134)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{-9000},
                  std::vector<int64_t>{-8000},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{0},
                  std::vector<uint32_t>{});
}

// slices are: [-9000:8000:2]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{4}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_135)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{-9000},
                  std::vector<int64_t>{8000},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{4},
                  std::vector<uint32_t>{0,2,4,6});
}

// slices are: [-5:5:2]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{1}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_136)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{-5},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{1},
                  std::vector<uint32_t>{3});
}

// slices are: [newaxis]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{1,8}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_137)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  Shape{1,8},
                  std::vector<uint32_t>{0,1,2,3,4,5,6,7});
}

// slices are: [newaxis,newaxis]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{1,1,8}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_138)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{0,0},
                  std::vector<int64_t>{0,0},
                  std::vector<int64_t>{1,1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0,1},
                  AxisSet{},
                  AxisSet{},
                  Shape{1,1,8},
                  std::vector<uint32_t>{0,1,2,3,4,5,6,7});
}

// slices are: [newaxis,newaxis,...,newaxis]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{1,1,8,1}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_139)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{0,0,0,0},
                  std::vector<int64_t>{0,0,0,0},
                  std::vector<int64_t>{1,1,1,1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0,1,3},
                  AxisSet{},
                  AxisSet{2},
                  Shape{1,1,8,1},
                  std::vector<uint32_t>{0,1,2,3,4,5,6,7});
}

// slices are: [3:0:-2]
// dtype is: uint32
// input shape is: Shape{5}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_140)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{5},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<uint32_t>{3,1});
}

// slices are: [0:3:2]
// dtype is: uint32
// input shape is: Shape{5}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_141)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<uint32_t>{0,2});
}

// slices are: [0:4:2]
// dtype is: uint32
// input shape is: Shape{5}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_142)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{4},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<uint32_t>{0,2});
}

// slices are: [0:5:2]
// dtype is: uint32
// input shape is: Shape{5}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_143)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<uint32_t>{0,2,4});
}

// slices are: [0:6:2]
// dtype is: uint32
// input shape is: Shape{5}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_144)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{6},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<uint32_t>{0,2,4});
}

// slices are: [0:100:2]
// dtype is: uint32
// input shape is: Shape{5}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_145)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{100},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<uint32_t>{0,2,4});
}

// slices are: [4:0:-2]
// dtype is: uint32
// input shape is: Shape{5}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_146)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{5},
                  std::vector<int64_t>{4},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<uint32_t>{4,2});
}

// slices are: [4:0:-3]
// dtype is: uint32
// input shape is: Shape{5}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_147)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{5},
                  std::vector<int64_t>{4},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<uint32_t>{4,1});
}

// slices are: [3:2:1]
// dtype is: uint32
// input shape is: Shape{5}
// expected output shape is Shape{0}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_148)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{5},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{2},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{0},
                  std::vector<uint32_t>{});
}

// slices are: [4::-2]
// dtype is: uint32
// input shape is: Shape{5}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_149)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{5},
                  std::vector<int64_t>{4},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-2},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<uint32_t>{4,2,0});
}

// slices are: [1:-5:-1]
// dtype is: uint32
// input shape is: Shape{5}
// expected output shape is Shape{1}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_150)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{5},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{-5},
                  std::vector<int64_t>{-1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{1},
                  std::vector<uint32_t>{1});
}

// slices are: [1:-1:-1]
// dtype is: uint32
// input shape is: Shape{5}
// expected output shape is Shape{0}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_151)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{5},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{-1},
                  std::vector<int64_t>{-1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{0},
                  std::vector<uint32_t>{});
}

// slices are: [1:]
// dtype is: uint32
// input shape is: Shape{5}
// expected output shape is Shape{4}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_152)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{5},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{4},
                  std::vector<uint32_t>{1,2,3,4});
}

// slices are: [1::-1]
// dtype is: uint32
// input shape is: Shape{5}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_153)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{5},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-1},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<uint32_t>{1,0});
}

// slices are: [-5:5:2]
// dtype is: uint32
// input shape is: Shape{5}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_154)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{5},
                  std::vector<int64_t>{-5},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{2},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<uint32_t>{0,2,4});
}

// slices are: [-1:5:1]
// dtype is: uint32
// input shape is: Shape{5}
// expected output shape is Shape{1}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_155)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{5},
                  std::vector<int64_t>{-1},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{1},
                  std::vector<uint32_t>{4});
}

// slices are: [-1:1:1]
// dtype is: uint32
// input shape is: Shape{5}
// expected output shape is Shape{0}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_156)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{5},
                  std::vector<int64_t>{-1},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{0},
                  std::vector<uint32_t>{});
}

// slices are: [5:2:-3]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{1}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_157)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{2},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{1},
                  std::vector<uint32_t>{5});
}

// slices are: [5:1:-3]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_158)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<uint32_t>{5,2});
}

// slices are: [5:0:-3]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_159)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<uint32_t>{5,2});
}

// slices are: [5::-3]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_160)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{5},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<uint32_t>{5,2});
}

// slices are: [6:3:-3]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{1}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_161)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{6},
                  std::vector<int64_t>{3},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{1},
                  std::vector<uint32_t>{6});
}

// slices are: [6:2:-3]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_162)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{6},
                  std::vector<int64_t>{2},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<uint32_t>{6,3});
}

// slices are: [6:1:-3]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_163)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{6},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<uint32_t>{6,3});
}

// slices are: [6::-3]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_164)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{6},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<uint32_t>{6,3,0});
}

// slices are: [7:1:-3]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_165)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{7},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{2},
                  std::vector<uint32_t>{7,4});
}

// slices are: [7:0:-3]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_166)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{7},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<uint32_t>{7,4,1});
}

// slices are: [7::-3]
// dtype is: uint32
// input shape is: Shape{8}
// expected output shape is Shape{3}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_167)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{8},
                  std::vector<int64_t>{7},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{-3},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  Shape{3},
                  std::vector<uint32_t>{7,4,1});
}

// slices are: [80000]
// dtype is: int32
// input shape is: Shape{8}
// failure is expected
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_168)
{
    check_failure<int32_t>
                 (element::i32,
                  Shape{8},
                  std::vector<int64_t>{80000},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{});
}

// slices are: [-80000]
// dtype is: int32
// input shape is: Shape{8}
// failure is expected
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_169)
{
    check_failure<int32_t>
                 (element::i32,
                  Shape{8},
                  std::vector<int64_t>{-80000},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0},
                  AxisSet{});
}

// slices are: [:,:]
// dtype is: int32
// input shape is: Shape{8}
// failure is expected
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_170)
{
    check_failure<int32_t>
                 (element::i32,
                  Shape{8},
                  std::vector<int64_t>{0,0},
                  std::vector<int64_t>{0,0},
                  std::vector<int64_t>{1,1},
                  AxisSet{0,1},
                  AxisSet{0,1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{});
}

// slices are: [0:0:0]
// dtype is: int32
// input shape is: Shape{8}
// failure is expected
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_171)
{
    check_failure<int32_t>
                 (element::i32,
                  Shape{8},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{});
}

// slices are: [0:1:0]
// dtype is: int32
// input shape is: Shape{8}
// failure is expected
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_172)
{
    check_failure<int32_t>
                 (element::i32,
                  Shape{8},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{1},
                  std::vector<int64_t>{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{});
}

// slices are: [0:2:0]
// dtype is: int32
// input shape is: Shape{8}
// failure is expected
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_173)
{
    check_failure<int32_t>
                 (element::i32,
                  Shape{8},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{2},
                  std::vector<int64_t>{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{});
}

// slices are: [::0]
// dtype is: int32
// input shape is: Shape{8}
// failure is expected
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_174)
{
    check_failure<int32_t>
                 (element::i32,
                  Shape{8},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{0},
                  std::vector<int64_t>{0},
                  AxisSet{0},
                  AxisSet{0},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{});
}

// slices are: [1,newaxis]
// dtype is: int32
// input shape is: Shape{2,3,4}
// expected output shape is Shape{1,3,4}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_175)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{2,3,4},
                  std::vector<int64_t>{1,0},
                  std::vector<int64_t>{0,0},
                  std::vector<int64_t>{1,1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{1},
                  AxisSet{0},
                  AxisSet{},
                  Shape{1,3,4},
                  std::vector<int32_t>{12,13,14,15,16,17,18,19,20,21,22,23});
}

// slices are: [-1,-1,newaxis]
// dtype is: int32
// input shape is: Shape{2,3,4}
// expected output shape is Shape{1,4}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_176)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{2,3,4},
                  std::vector<int64_t>{-1,-1,0},
                  std::vector<int64_t>{0,0,0},
                  std::vector<int64_t>{1,1,1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{2},
                  AxisSet{0,1},
                  AxisSet{},
                  Shape{1,4},
                  std::vector<int32_t>{20,21,22,23});
}

// slices are: [1,newaxis]
// dtype is: int64
// input shape is: Shape{2,3,4}
// expected output shape is Shape{1,3,4}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_177)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{2,3,4},
                  std::vector<int64_t>{1,0},
                  std::vector<int64_t>{0,0},
                  std::vector<int64_t>{1,1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{1},
                  AxisSet{0},
                  AxisSet{},
                  Shape{1,3,4},
                  std::vector<int64_t>{12,13,14,15,16,17,18,19,20,21,22,23});
}

// slices are: [-1,-1,newaxis]
// dtype is: int64
// input shape is: Shape{2,3,4}
// expected output shape is Shape{1,4}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_178)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{2,3,4},
                  std::vector<int64_t>{-1,-1,0},
                  std::vector<int64_t>{0,0,0},
                  std::vector<int64_t>{1,1,1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{2},
                  AxisSet{0,1},
                  AxisSet{},
                  Shape{1,4},
                  std::vector<int64_t>{20,21,22,23});
}

// slices are: [1,newaxis]
// dtype is: float32
// input shape is: Shape{2,3,4}
// expected output shape is Shape{1,3,4}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_179)
{
    check_success<float>
                 (element::f32,
                  Shape{2,3,4},
                  std::vector<int64_t>{1,0},
                  std::vector<int64_t>{0,0},
                  std::vector<int64_t>{1,1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{1},
                  AxisSet{0},
                  AxisSet{},
                  Shape{1,3,4},
                  std::vector<float>{12.0,13.0,14.0,15.0,16.0,17.0,18.0,19.0,20.0,21.0,22.0,23.0});
}

// slices are: [-1,-1,newaxis]
// dtype is: float32
// input shape is: Shape{2,3,4}
// expected output shape is Shape{1,4}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_180)
{
    check_success<float>
                 (element::f32,
                  Shape{2,3,4},
                  std::vector<int64_t>{-1,-1,0},
                  std::vector<int64_t>{0,0,0},
                  std::vector<int64_t>{1,1,1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{2},
                  AxisSet{0,1},
                  AxisSet{},
                  Shape{1,4},
                  std::vector<float>{20.0,21.0,22.0,23.0});
}

// slices are: [1,newaxis]
// dtype is: uint32
// input shape is: Shape{2,3,4}
// expected output shape is Shape{1,3,4}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_181)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{2,3,4},
                  std::vector<int64_t>{1,0},
                  std::vector<int64_t>{0,0},
                  std::vector<int64_t>{1,1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{1},
                  AxisSet{0},
                  AxisSet{},
                  Shape{1,3,4},
                  std::vector<uint32_t>{12,13,14,15,16,17,18,19,20,21,22,23});
}

// slices are: [-1,-1,newaxis]
// dtype is: uint32
// input shape is: Shape{2,3,4}
// expected output shape is Shape{1,4}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_182)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{2,3,4},
                  std::vector<int64_t>{-1,-1,0},
                  std::vector<int64_t>{0,0,0},
                  std::vector<int64_t>{1,1,1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{2},
                  AxisSet{0,1},
                  AxisSet{},
                  Shape{1,4},
                  std::vector<uint32_t>{20,21,22,23});
}

// slices are: [0:,:4,2:6:2,7:3:-2,newaxis,...,1]
// dtype is: int32
// input shape is: Shape{2,4,6,8,2,2,2}
// expected output shape is Shape{2,4,2,2,1,2,2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_183)
{
    check_success<int32_t>
                 (element::i32,
                  Shape{2,4,6,8,2,2,2},
                  std::vector<int64_t>{0,0,2,7,0,0,1},
                  std::vector<int64_t>{0,4,6,3,0,0,0},
                  std::vector<int64_t>{1,1,2,-2,1,1,1},
                  AxisSet{1},
                  AxisSet{0},
                  AxisSet{4},
                  AxisSet{6},
                  AxisSet{5},
                  Shape{2,4,2,2,1,2,2},
                  std::vector<int32_t>{185,187,189,191,169,171,173,175,313,315,317,319,297,299,301,303,569,571,573,575,553,555,557,559,697,699,701,703,681,683,685,687,953,955,957,959,937,939,941,943,1081,1083,1085,1087,1065,1067,1069,1071,1337,1339,1341,1343,1321,1323,1325,1327,1465,1467,1469,1471,1449,1451,1453,1455,1721,1723,1725,1727,1705,1707,1709,1711,1849,1851,1853,1855,1833,1835,1837,1839,2105,2107,2109,2111,2089,2091,2093,2095,2233,2235,2237,2239,2217,2219,2221,2223,2489,2491,2493,2495,2473,2475,2477,2479,2617,2619,2621,2623,2601,2603,2605,2607,2873,2875,2877,2879,2857,2859,2861,2863,3001,3003,3005,3007,2985,2987,2989,2991});
}

// slices are: [0:,:4,2:6:2,7:3:-2,newaxis,...,1]
// dtype is: int64
// input shape is: Shape{2,4,6,8,2,2,2}
// expected output shape is Shape{2,4,2,2,1,2,2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_184)
{
    check_success<int64_t>
                 (element::i64,
                  Shape{2,4,6,8,2,2,2},
                  std::vector<int64_t>{0,0,2,7,0,0,1},
                  std::vector<int64_t>{0,4,6,3,0,0,0},
                  std::vector<int64_t>{1,1,2,-2,1,1,1},
                  AxisSet{1},
                  AxisSet{0},
                  AxisSet{4},
                  AxisSet{6},
                  AxisSet{5},
                  Shape{2,4,2,2,1,2,2},
                  std::vector<int64_t>{185,187,189,191,169,171,173,175,313,315,317,319,297,299,301,303,569,571,573,575,553,555,557,559,697,699,701,703,681,683,685,687,953,955,957,959,937,939,941,943,1081,1083,1085,1087,1065,1067,1069,1071,1337,1339,1341,1343,1321,1323,1325,1327,1465,1467,1469,1471,1449,1451,1453,1455,1721,1723,1725,1727,1705,1707,1709,1711,1849,1851,1853,1855,1833,1835,1837,1839,2105,2107,2109,2111,2089,2091,2093,2095,2233,2235,2237,2239,2217,2219,2221,2223,2489,2491,2493,2495,2473,2475,2477,2479,2617,2619,2621,2623,2601,2603,2605,2607,2873,2875,2877,2879,2857,2859,2861,2863,3001,3003,3005,3007,2985,2987,2989,2991});
}

// slices are: [0:,:4,2:6:2,7:3:-2,newaxis,...,1]
// dtype is: float32
// input shape is: Shape{2,4,6,8,2,2,2}
// expected output shape is Shape{2,4,2,2,1,2,2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_185)
{
    check_success<float>
                 (element::f32,
                  Shape{2,4,6,8,2,2,2},
                  std::vector<int64_t>{0,0,2,7,0,0,1},
                  std::vector<int64_t>{0,4,6,3,0,0,0},
                  std::vector<int64_t>{1,1,2,-2,1,1,1},
                  AxisSet{1},
                  AxisSet{0},
                  AxisSet{4},
                  AxisSet{6},
                  AxisSet{5},
                  Shape{2,4,2,2,1,2,2},
                  std::vector<float>{185.0,187.0,189.0,191.0,169.0,171.0,173.0,175.0,313.0,315.0,317.0,319.0,297.0,299.0,301.0,303.0,569.0,571.0,573.0,575.0,553.0,555.0,557.0,559.0,697.0,699.0,701.0,703.0,681.0,683.0,685.0,687.0,953.0,955.0,957.0,959.0,937.0,939.0,941.0,943.0,1081.0,1083.0,1085.0,1087.0,1065.0,1067.0,1069.0,1071.0,1337.0,1339.0,1341.0,1343.0,1321.0,1323.0,1325.0,1327.0,1465.0,1467.0,1469.0,1471.0,1449.0,1451.0,1453.0,1455.0,1721.0,1723.0,1725.0,1727.0,1705.0,1707.0,1709.0,1711.0,1849.0,1851.0,1853.0,1855.0,1833.0,1835.0,1837.0,1839.0,2105.0,2107.0,2109.0,2111.0,2089.0,2091.0,2093.0,2095.0,2233.0,2235.0,2237.0,2239.0,2217.0,2219.0,2221.0,2223.0,2489.0,2491.0,2493.0,2495.0,2473.0,2475.0,2477.0,2479.0,2617.0,2619.0,2621.0,2623.0,2601.0,2603.0,2605.0,2607.0,2873.0,2875.0,2877.0,2879.0,2857.0,2859.0,2861.0,2863.0,3001.0,3003.0,3005.0,3007.0,2985.0,2987.0,2989.0,2991.0});
}

// slices are: [0:,:4,2:6:2,7:3:-2,newaxis,...,1]
// dtype is: uint32
// input shape is: Shape{2,4,6,8,2,2,2}
// expected output shape is Shape{2,4,2,2,1,2,2}
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_186)
{
    check_success<uint32_t>
                 (element::u32,
                  Shape{2,4,6,8,2,2,2},
                  std::vector<int64_t>{0,0,2,7,0,0,1},
                  std::vector<int64_t>{0,4,6,3,0,0,0},
                  std::vector<int64_t>{1,1,2,-2,1,1,1},
                  AxisSet{1},
                  AxisSet{0},
                  AxisSet{4},
                  AxisSet{6},
                  AxisSet{5},
                  Shape{2,4,2,2,1,2,2},
                  std::vector<uint32_t>{185,187,189,191,169,171,173,175,313,315,317,319,297,299,301,303,569,571,573,575,553,555,557,559,697,699,701,703,681,683,685,687,953,955,957,959,937,939,941,943,1081,1083,1085,1087,1065,1067,1069,1071,1337,1339,1341,1343,1321,1323,1325,1327,1465,1467,1469,1471,1449,1451,1453,1455,1721,1723,1725,1727,1705,1707,1709,1711,1849,1851,1853,1855,1833,1835,1837,1839,2105,2107,2109,2111,2089,2091,2093,2095,2233,2235,2237,2239,2217,2219,2221,2223,2489,2491,2493,2495,2473,2475,2477,2479,2617,2619,2621,2623,2601,2603,2605,2607,2873,2875,2877,2879,2857,2859,2861,2863,3001,3003,3005,3007,2985,2987,2989,2991});
}

// slices are: [...,...]
// dtype is: int32
// input shape is: Shape{2,4,6,8,2,2,2}
// failure is expected
NGRAPH_TEST(${BACKEND_NAME}, dyn_slice_187)
{
    check_failure<int32_t>
                 (element::i32,
                  Shape{2,4,6,8,2,2,2},
                  std::vector<int64_t>{0,0},
                  std::vector<int64_t>{0,0},
                  std::vector<int64_t>{1,1},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{},
                  AxisSet{0,1});
}
// clang-format on
