1 /* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
2
3 Licensed under the Apache License, Version 2.0 (the "License");
4 you may not use this file except in compliance with the License.
5 You may obtain a copy of the License at
6
7 http://www.apache.org/licenses/LICENSE-2.0
8
9 Unless required by applicable law or agreed to in writing, software
10 distributed under the License is distributed on an "AS IS" BASIS,
11 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 See the License for the specific language governing permissions and
13 limitations under the License.
14 ==============================================================================*/
15 #include <cstdint>
16
17 #include "tensorflow/lite/c/builtin_op_data.h"
18 #include "tensorflow/lite/c/common.h"
19 #include "tensorflow/lite/micro/all_ops_resolver.h"
20 #include "tensorflow/lite/micro/kernels/kernel_runner.h"
21 #include "tensorflow/lite/micro/test_helpers.h"
22 #include "tensorflow/lite/micro/testing/micro_test.h"
23
24 namespace tflite {
25 namespace testing {
26 namespace {
27
28 template <typename T>
ValidateStridedSliceGoldens(TfLiteTensor * tensors,int tensors_size,const T * golden,T * output,int output_len,TfLiteStridedSliceParams * params,const bool expect_prepare_err,int num_invoke,float tolerance=1e-5)29 void ValidateStridedSliceGoldens(TfLiteTensor* tensors, int tensors_size,
30 const T* golden, T* output, int output_len,
31 TfLiteStridedSliceParams* params,
32 const bool expect_prepare_err, int num_invoke,
33 float tolerance = 1e-5) {
34 int inputs_array_data[] = {4, 0, 1, 2, 3};
35 TfLiteIntArray* inputs_array = IntArrayFromInts(inputs_array_data);
36 int outputs_array_data[] = {1, 4};
37 TfLiteIntArray* outputs_array = IntArrayFromInts(outputs_array_data);
38
39 const TfLiteRegistration registration =
40 tflite::ops::micro::Register_STRIDED_SLICE();
41 micro::KernelRunner runner(registration, tensors, tensors_size, inputs_array,
42 outputs_array, reinterpret_cast<void*>(params));
43 if (expect_prepare_err) {
44 TF_LITE_MICRO_EXPECT_EQ(kTfLiteError, runner.InitAndPrepare());
45 return;
46 } else {
47 TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
48 }
49
50 for (int i = 0; i < num_invoke; i++) {
51 TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
52 }
53
54 for (int i = 0; i < output_len; ++i) {
55 TF_LITE_MICRO_EXPECT_NEAR(golden[i], output[i], 1e-5f);
56 }
57 }
58
TestStridedSliceFloat(const int * input_shape,const int * begin_shape,const int * end_shape,const int * strides_shape,TfLiteStridedSliceParams * builtin_data,float * input_data,const int32_t * begin_data,const int32_t * end_data,const int32_t * strides_data,const int * output_shape,float * output_data,const float * expected_output,bool expect_prepare_err,int num_invoke=1)59 void TestStridedSliceFloat(const int* input_shape, const int* begin_shape,
60 const int* end_shape, const int* strides_shape,
61 TfLiteStridedSliceParams* builtin_data,
62 float* input_data, const int32_t* begin_data,
63 const int32_t* end_data, const int32_t* strides_data,
64 const int* output_shape, float* output_data,
65 const float* expected_output,
66 bool expect_prepare_err, int num_invoke = 1) {
67 TfLiteIntArray* input_dims = IntArrayFromInts(input_shape);
68 TfLiteIntArray* begin_dims = IntArrayFromInts(begin_shape);
69 TfLiteIntArray* end_dims = IntArrayFromInts(end_shape);
70 TfLiteIntArray* strides_dims = IntArrayFromInts(strides_shape);
71 TfLiteIntArray* output_dims = IntArrayFromInts(output_shape);
72 constexpr int inputs_size = 4;
73 constexpr int outputs_size = 1;
74 constexpr int tensors_size = inputs_size + outputs_size;
75 TfLiteTensor tensors[tensors_size] = {
76 CreateTensor(input_data, input_dims),
77 CreateTensor(begin_data, begin_dims),
78 CreateTensor(end_data, end_dims),
79 CreateTensor(strides_data, strides_dims),
80 CreateTensor(output_data, output_dims),
81 };
82
83 ValidateStridedSliceGoldens(tensors, tensors_size, expected_output,
84 output_data, ElementCount(*output_dims),
85 builtin_data, expect_prepare_err, num_invoke,
86 1.0);
87 }
88
89 template <typename T>
TestStridedSliceQuantized(const int * input_shape,const int * begin_shape,const int * end_shape,const int * strides_shape,TfLiteStridedSliceParams * builtin_data,const T * input_data,const int32_t * begin_data,const int32_t * end_data,const int32_t * strides_data,const int * output_shape,T * output_data,const T * expected_output,bool expect_prepare_err,int num_invoke=1)90 void TestStridedSliceQuantized(
91 const int* input_shape, const int* begin_shape, const int* end_shape,
92 const int* strides_shape, TfLiteStridedSliceParams* builtin_data,
93 const T* input_data, const int32_t* begin_data, const int32_t* end_data,
94 const int32_t* strides_data, const int* output_shape, T* output_data,
95 const T* expected_output, bool expect_prepare_err, int num_invoke = 1) {
96 TfLiteIntArray* input_dims = IntArrayFromInts(input_shape);
97 TfLiteIntArray* begin_dims = IntArrayFromInts(begin_shape);
98 TfLiteIntArray* end_dims = IntArrayFromInts(end_shape);
99 TfLiteIntArray* strides_dims = IntArrayFromInts(strides_shape);
100 TfLiteIntArray* output_dims = IntArrayFromInts(output_shape);
101 constexpr int inputs_size = 4;
102 constexpr int outputs_size = 1;
103 constexpr int tensors_size = inputs_size + outputs_size;
104 int zero_point =
105 std::numeric_limits<T>::max() + std::numeric_limits<T>::min() / 2;
106 TfLiteTensor tensors[tensors_size] = {
107 CreateQuantizedTensor(input_data, input_dims, 1.0, zero_point),
108 CreateTensor(begin_data, begin_dims),
109 CreateTensor(end_data, end_dims),
110 CreateTensor(strides_data, strides_dims),
111 CreateQuantizedTensor(output_data, output_dims, 1.0, zero_point),
112 };
113
114 ValidateStridedSliceGoldens(tensors, tensors_size, expected_output,
115 output_data, ElementCount(*output_dims),
116 builtin_data, expect_prepare_err, num_invoke,
117 1.0);
118 }
119
120 } // namespace
121 } // namespace testing
122 } // namespace tflite
123
124 TF_LITE_MICRO_TESTS_BEGIN
125
TF_LITE_MICRO_TEST(UnsupportedInputSize)126 TF_LITE_MICRO_TEST(UnsupportedInputSize) {
127 const int input_shape[] = {5, 2, 2, 2, 2, 2};
128 const int begin_shape[] = {1, 5};
129 const int end_shape[] = {1, 5};
130 const int strides_shape[] = {1, 5};
131 const int output_shape[] = {0};
132 float input_data[] = {};
133 int32_t begin_data[] = {};
134 int32_t end_data[] = {};
135 int32_t strides_data[] = {};
136 float golden[] = {};
137 float output_data[4];
138
139 TfLiteStridedSliceParams builtin_data = {};
140
141 tflite::testing::TestStridedSliceFloat(
142 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
143 input_data, begin_data, end_data, strides_data, output_shape, output_data,
144 golden, true);
145 }
146
TF_LITE_MICRO_TEST(In1D)147 TF_LITE_MICRO_TEST(In1D) {
148 const int input_shape[] = {1, 4};
149 const int begin_shape[] = {1, 1};
150 const int end_shape[] = {1, 1};
151 const int strides_shape[] = {1, 1};
152 const int output_shape[] = {1, 2};
153 float input_data[] = {1, 2, 3, 4};
154 int32_t begin_data[] = {1};
155 int32_t end_data[] = {3};
156 int32_t strides_data[] = {1};
157 float golden[] = {2, 3};
158 float output_data[4];
159
160 TfLiteStridedSliceParams builtin_data = {};
161
162 tflite::testing::TestStridedSliceFloat(
163 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
164 input_data, begin_data, end_data, strides_data, output_shape, output_data,
165 golden, false);
166 }
167
TF_LITE_MICRO_TEST(In1D_EmptyOutput)168 TF_LITE_MICRO_TEST(In1D_EmptyOutput) {
169 const int input_shape[] = {1, 4};
170 const int begin_shape[] = {1, 1};
171 const int end_shape[] = {1, 1};
172 const int strides_shape[] = {1, 1};
173 const int output_shape[] = {1, 0};
174 float input_data[] = {1, 2, 3, 4};
175 int32_t begin_data[] = {10};
176 int32_t end_data[] = {3};
177 int32_t strides_data[] = {1};
178 float golden[] = {};
179 float output_data[4];
180
181 TfLiteStridedSliceParams builtin_data = {};
182
183 tflite::testing::TestStridedSliceFloat(
184 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
185 input_data, begin_data, end_data, strides_data, output_shape, output_data,
186 golden, false);
187 }
188
TF_LITE_MICRO_TEST(In1D_NegativeBegin)189 TF_LITE_MICRO_TEST(In1D_NegativeBegin) {
190 const int input_shape[] = {1, 4};
191 const int begin_shape[] = {1, 1};
192 const int end_shape[] = {1, 1};
193 const int strides_shape[] = {1, 1};
194 const int output_shape[] = {1, 2};
195 float input_data[] = {1, 2, 3, 4};
196 int32_t begin_data[] = {-3};
197 int32_t end_data[] = {3};
198 int32_t strides_data[] = {1};
199 float golden[] = {2, 3};
200 float output_data[4];
201
202 TfLiteStridedSliceParams builtin_data = {};
203
204 tflite::testing::TestStridedSliceFloat(
205 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
206 input_data, begin_data, end_data, strides_data, output_shape, output_data,
207 golden, false);
208 }
209
TF_LITE_MICRO_TEST(In1D_OutOfRangeBegin)210 TF_LITE_MICRO_TEST(In1D_OutOfRangeBegin) {
211 const int input_shape[] = {1, 4};
212 const int begin_shape[] = {1, 1};
213 const int end_shape[] = {1, 1};
214 const int strides_shape[] = {1, 1};
215 const int output_shape[] = {1, 3};
216 float input_data[] = {1, 2, 3, 4};
217 int32_t begin_data[] = {-5};
218 int32_t end_data[] = {3};
219 int32_t strides_data[] = {1};
220 float golden[] = {1, 2, 3};
221 float output_data[4];
222
223 TfLiteStridedSliceParams builtin_data = {};
224
225 tflite::testing::TestStridedSliceFloat(
226 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
227 input_data, begin_data, end_data, strides_data, output_shape, output_data,
228 golden, false);
229 }
230
TF_LITE_MICRO_TEST(In1D_NegativeEnd)231 TF_LITE_MICRO_TEST(In1D_NegativeEnd) {
232 const int input_shape[] = {1, 4};
233 const int begin_shape[] = {1, 1};
234 const int end_shape[] = {1, 1};
235 const int strides_shape[] = {1, 1};
236 const int output_shape[] = {1, 1};
237 float input_data[] = {1, 2, 3, 4};
238 int32_t begin_data[] = {1};
239 int32_t end_data[] = {-2};
240 int32_t strides_data[] = {1};
241 float golden[] = {2};
242 float output_data[4];
243
244 TfLiteStridedSliceParams builtin_data = {};
245
246 tflite::testing::TestStridedSliceFloat(
247 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
248 input_data, begin_data, end_data, strides_data, output_shape, output_data,
249 golden, false);
250 }
251
TF_LITE_MICRO_TEST(In1D_OutOfRangeEnd)252 TF_LITE_MICRO_TEST(In1D_OutOfRangeEnd) {
253 const int input_shape[] = {1, 4};
254 const int begin_shape[] = {1, 1};
255 const int end_shape[] = {1, 1};
256 const int strides_shape[] = {1, 1};
257 const int output_shape[] = {1, 3};
258 float input_data[] = {1, 2, 3, 4};
259 int32_t begin_data[] = {-3};
260 int32_t end_data[] = {5};
261 int32_t strides_data[] = {1};
262 float golden[] = {2, 3, 4};
263 float output_data[4];
264
265 TfLiteStridedSliceParams builtin_data = {};
266
267 tflite::testing::TestStridedSliceFloat(
268 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
269 input_data, begin_data, end_data, strides_data, output_shape, output_data,
270 golden, false);
271 }
272
TF_LITE_MICRO_TEST(In1D_BeginMask)273 TF_LITE_MICRO_TEST(In1D_BeginMask) {
274 const int input_shape[] = {1, 4};
275 const int begin_shape[] = {1, 1};
276 const int end_shape[] = {1, 1};
277 const int strides_shape[] = {1, 1};
278 const int output_shape[] = {1, 3};
279 float input_data[] = {1, 2, 3, 4};
280 int32_t begin_data[] = {1};
281 int32_t end_data[] = {3};
282 int32_t strides_data[] = {1};
283 float golden[] = {1, 2, 3};
284 float output_data[4];
285
286 TfLiteStridedSliceParams builtin_data = {1, 0, 0, 0, 0};
287
288 tflite::testing::TestStridedSliceFloat(
289 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
290 input_data, begin_data, end_data, strides_data, output_shape, output_data,
291 golden, false);
292 }
293
TF_LITE_MICRO_TEST(In1D_NegativeBeginNegativeStride)294 TF_LITE_MICRO_TEST(In1D_NegativeBeginNegativeStride) {
295 const int input_shape[] = {1, 4};
296 const int begin_shape[] = {1, 1};
297 const int end_shape[] = {1, 1};
298 const int strides_shape[] = {1, 1};
299 const int output_shape[] = {1, 1};
300 float input_data[] = {1, 2, 3, 4};
301 int32_t begin_data[] = {-2};
302 int32_t end_data[] = {-3};
303 int32_t strides_data[] = {-1};
304 float golden[] = {3};
305 float output_data[4];
306
307 TfLiteStridedSliceParams builtin_data = {};
308
309 tflite::testing::TestStridedSliceFloat(
310 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
311 input_data, begin_data, end_data, strides_data, output_shape, output_data,
312 golden, false);
313 }
314
TF_LITE_MICRO_TEST(In1D_OutOfRangeBeginNegativeStride)315 TF_LITE_MICRO_TEST(In1D_OutOfRangeBeginNegativeStride) {
316 const int input_shape[] = {1, 4};
317 const int begin_shape[] = {1, 1};
318 const int end_shape[] = {1, 1};
319 const int strides_shape[] = {1, 1};
320 const int output_shape[] = {1, 1};
321 float input_data[] = {1, 2, 3, 4};
322 int32_t begin_data[] = {5};
323 int32_t end_data[] = {2};
324 int32_t strides_data[] = {-1};
325 float golden[] = {4};
326 float output_data[4];
327
328 TfLiteStridedSliceParams builtin_data = {};
329
330 tflite::testing::TestStridedSliceFloat(
331 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
332 input_data, begin_data, end_data, strides_data, output_shape, output_data,
333 golden, false);
334 }
335
TF_LITE_MICRO_TEST(In1D_NegativeEndNegativeStride)336 TF_LITE_MICRO_TEST(In1D_NegativeEndNegativeStride) {
337 const int input_shape[] = {1, 4};
338 const int begin_shape[] = {1, 1};
339 const int end_shape[] = {1, 1};
340 const int strides_shape[] = {1, 1};
341 const int output_shape[] = {1, 2};
342 float input_data[] = {1, 2, 3, 4};
343 int32_t begin_data[] = {2};
344 int32_t end_data[] = {-4};
345 int32_t strides_data[] = {-1};
346 float golden[] = {3, 2};
347 float output_data[4];
348
349 TfLiteStridedSliceParams builtin_data = {};
350
351 tflite::testing::TestStridedSliceFloat(
352 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
353 input_data, begin_data, end_data, strides_data, output_shape, output_data,
354 golden, false);
355 }
356
TF_LITE_MICRO_TEST(In1D_OutOfRangeEndNegativeStride)357 TF_LITE_MICRO_TEST(In1D_OutOfRangeEndNegativeStride) {
358 const int input_shape[] = {1, 4};
359 const int begin_shape[] = {1, 1};
360 const int end_shape[] = {1, 1};
361 const int strides_shape[] = {1, 1};
362 const int output_shape[] = {1, 2};
363 float input_data[] = {1, 2, 3, 4};
364 int32_t begin_data[] = {-3};
365 int32_t end_data[] = {-5};
366 int32_t strides_data[] = {-1};
367 float golden[] = {2, 1};
368 float output_data[4];
369
370 TfLiteStridedSliceParams builtin_data = {};
371
372 tflite::testing::TestStridedSliceFloat(
373 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
374 input_data, begin_data, end_data, strides_data, output_shape, output_data,
375 golden, false);
376 }
377
TF_LITE_MICRO_TEST(In1D_EndMask)378 TF_LITE_MICRO_TEST(In1D_EndMask) {
379 const int input_shape[] = {1, 4};
380 const int begin_shape[] = {1, 1};
381 const int end_shape[] = {1, 1};
382 const int strides_shape[] = {1, 1};
383 const int output_shape[] = {1, 3};
384 float input_data[] = {1, 2, 3, 4};
385 int32_t begin_data[] = {1};
386 int32_t end_data[] = {3};
387 int32_t strides_data[] = {1};
388 float golden[] = {2, 3, 4};
389 float output_data[4];
390
391 TfLiteStridedSliceParams builtin_data = {0, 1, 0, 0, 0};
392
393 tflite::testing::TestStridedSliceFloat(
394 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
395 input_data, begin_data, end_data, strides_data, output_shape, output_data,
396 golden, false);
397 }
398
TF_LITE_MICRO_TEST(In1D_NegStride)399 TF_LITE_MICRO_TEST(In1D_NegStride) {
400 const int input_shape[] = {1, 3};
401 const int begin_shape[] = {1, 1};
402 const int end_shape[] = {1, 1};
403 const int strides_shape[] = {1, 1};
404 const int output_shape[] = {1, 3};
405 float input_data[] = {1, 2, 3};
406 int32_t begin_data[] = {-1};
407 int32_t end_data[] = {-4};
408 int32_t strides_data[] = {-1};
409 float golden[] = {3, 2, 1};
410 float output_data[4];
411
412 TfLiteStridedSliceParams builtin_data = {};
413
414 tflite::testing::TestStridedSliceFloat(
415 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
416 input_data, begin_data, end_data, strides_data, output_shape, output_data,
417 golden, false);
418 }
419
TF_LITE_MICRO_TEST(In1D_EvenLenStride2)420 TF_LITE_MICRO_TEST(In1D_EvenLenStride2) {
421 const int input_shape[] = {1, 2};
422 const int begin_shape[] = {1, 1};
423 const int end_shape[] = {1, 1};
424 const int strides_shape[] = {1, 1};
425 const int output_shape[] = {1, 1};
426 float input_data[] = {1, 2, 3, 4};
427 int32_t begin_data[] = {0};
428 int32_t end_data[] = {4};
429 int32_t strides_data[] = {2};
430 float golden[] = {1};
431 float output_data[4];
432
433 TfLiteStridedSliceParams builtin_data = {};
434
435 tflite::testing::TestStridedSliceFloat(
436 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
437 input_data, begin_data, end_data, strides_data, output_shape, output_data,
438 golden, false);
439 }
440
TF_LITE_MICRO_TEST(In1D_OddLenStride2)441 TF_LITE_MICRO_TEST(In1D_OddLenStride2) {
442 const int input_shape[] = {1, 3};
443 const int begin_shape[] = {1, 1};
444 const int end_shape[] = {1, 1};
445 const int strides_shape[] = {1, 1};
446 const int output_shape[] = {1, 2};
447 float input_data[] = {1, 2, 3, 4};
448 int32_t begin_data[] = {0};
449 int32_t end_data[] = {3};
450 int32_t strides_data[] = {2};
451 float golden[] = {1, 3};
452 float output_data[4];
453
454 TfLiteStridedSliceParams builtin_data = {};
455
456 tflite::testing::TestStridedSliceFloat(
457 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
458 input_data, begin_data, end_data, strides_data, output_shape, output_data,
459 golden, false);
460 }
461
TF_LITE_MICRO_TEST(In2D_Identity)462 TF_LITE_MICRO_TEST(In2D_Identity) {
463 const int input_shape[] = {2, 2, 3};
464 const int begin_shape[] = {1, 2};
465 const int end_shape[] = {1, 2};
466 const int strides_shape[] = {1, 2};
467 const int output_shape[] = {2, 2, 3};
468 float input_data[] = {1, 2, 3, 4, 5, 6};
469 int32_t begin_data[] = {0, 0};
470 int32_t end_data[] = {2, 3};
471 int32_t strides_data[] = {1, 1};
472 float golden[] = {1, 2, 3, 4, 5, 6};
473 float output_data[8];
474
475 TfLiteStridedSliceParams builtin_data = {};
476
477 tflite::testing::TestStridedSliceFloat(
478 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
479 input_data, begin_data, end_data, strides_data, output_shape, output_data,
480 golden, false);
481 }
482
TF_LITE_MICRO_TEST(In2D)483 TF_LITE_MICRO_TEST(In2D) {
484 const int input_shape[] = {2, 2, 3};
485 const int begin_shape[] = {1, 2};
486 const int end_shape[] = {1, 2};
487 const int strides_shape[] = {1, 2};
488 const int output_shape[] = {2, 1, 2};
489 float input_data[] = {1, 2, 3, 4, 5, 6};
490 int32_t begin_data[] = {1, 0};
491 int32_t end_data[] = {2, 2};
492 int32_t strides_data[] = {1, 1};
493 float golden[] = {4, 5};
494 float output_data[8];
495
496 TfLiteStridedSliceParams builtin_data = {};
497
498 tflite::testing::TestStridedSliceFloat(
499 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
500 input_data, begin_data, end_data, strides_data, output_shape, output_data,
501 golden, false);
502 }
503
TF_LITE_MICRO_TEST(In2D_Stride2)504 TF_LITE_MICRO_TEST(In2D_Stride2) {
505 const int input_shape[] = {2, 2, 3};
506 const int begin_shape[] = {1, 2};
507 const int end_shape[] = {1, 2};
508 const int strides_shape[] = {1, 2};
509 const int output_shape[] = {2, 1, 2};
510 float input_data[] = {1, 2, 3, 4, 5, 6};
511 int32_t begin_data[] = {0, 0};
512 int32_t end_data[] = {2, 3};
513 int32_t strides_data[] = {2, 2};
514 float golden[] = {1, 3};
515 float output_data[8];
516
517 TfLiteStridedSliceParams builtin_data = {};
518
519 tflite::testing::TestStridedSliceFloat(
520 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
521 input_data, begin_data, end_data, strides_data, output_shape, output_data,
522 golden, false);
523 }
524
TF_LITE_MICRO_TEST(In2D_NegStride)525 TF_LITE_MICRO_TEST(In2D_NegStride) {
526 const int input_shape[] = {2, 2, 3};
527 const int begin_shape[] = {1, 2};
528 const int end_shape[] = {1, 2};
529 const int strides_shape[] = {1, 2};
530 const int output_shape[] = {2, 1, 3};
531 float input_data[] = {1, 2, 3, 4, 5, 6};
532 int32_t begin_data[] = {1, -1};
533 int32_t end_data[] = {2, -4};
534 int32_t strides_data[] = {2, -1};
535 float golden[] = {6, 5, 4};
536 float output_data[8];
537
538 TfLiteStridedSliceParams builtin_data = {};
539
540 tflite::testing::TestStridedSliceFloat(
541 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
542 input_data, begin_data, end_data, strides_data, output_shape, output_data,
543 golden, false);
544 }
545
TF_LITE_MICRO_TEST(In2D_BeginMask)546 TF_LITE_MICRO_TEST(In2D_BeginMask) {
547 const int input_shape[] = {2, 2, 3};
548 const int begin_shape[] = {1, 2};
549 const int end_shape[] = {1, 2};
550 const int strides_shape[] = {1, 2};
551 const int output_shape[] = {2, 2, 2};
552 float input_data[] = {1, 2, 3, 4, 5, 6};
553 int32_t begin_data[] = {1, 0};
554 int32_t end_data[] = {2, 2};
555 int32_t strides_data[] = {1, 1};
556 float golden[] = {1, 2, 4, 5};
557 float output_data[8];
558
559 TfLiteStridedSliceParams builtin_data = {1, 0, 0, 0, 0};
560
561 tflite::testing::TestStridedSliceFloat(
562 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
563 input_data, begin_data, end_data, strides_data, output_shape, output_data,
564 golden, false);
565 }
566
TF_LITE_MICRO_TEST(In2D_EndMask)567 TF_LITE_MICRO_TEST(In2D_EndMask) {
568 const int input_shape[] = {2, 2, 3};
569 const int begin_shape[] = {1, 2};
570 const int end_shape[] = {1, 2};
571 const int strides_shape[] = {1, 2};
572 const int output_shape[] = {2, 1, 3};
573 float input_data[] = {1, 2, 3, 4, 5, 6};
574 int32_t begin_data[] = {1, 0};
575 int32_t end_data[] = {2, 2};
576 int32_t strides_data[] = {1, 1};
577 float golden[] = {4, 5, 6};
578 float output_data[8];
579
580 TfLiteStridedSliceParams builtin_data = {0, 2, 0, 0, 0};
581
582 tflite::testing::TestStridedSliceFloat(
583 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
584 input_data, begin_data, end_data, strides_data, output_shape, output_data,
585 golden, false);
586 }
587
TF_LITE_MICRO_TEST(In2D_NegStrideBeginMask)588 TF_LITE_MICRO_TEST(In2D_NegStrideBeginMask) {
589 const int input_shape[] = {2, 2, 3};
590 const int begin_shape[] = {1, 2};
591 const int end_shape[] = {1, 2};
592 const int strides_shape[] = {1, 2};
593 const int output_shape[] = {2, 1, 3};
594 float input_data[] = {1, 2, 3, 4, 5, 6};
595 int32_t begin_data[] = {1, -2};
596 int32_t end_data[] = {2, -4};
597 int32_t strides_data[] = {1, -1};
598 float golden[] = {6, 5, 4};
599 float output_data[8];
600
601 TfLiteStridedSliceParams builtin_data = {2, 0, 0, 0, 0};
602
603 tflite::testing::TestStridedSliceFloat(
604 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
605 input_data, begin_data, end_data, strides_data, output_shape, output_data,
606 golden, false);
607 }
608
TF_LITE_MICRO_TEST(In2D_NegStrideEndMask)609 TF_LITE_MICRO_TEST(In2D_NegStrideEndMask) {
610 const int input_shape[] = {2, 2, 3};
611 const int begin_shape[] = {1, 2};
612 const int end_shape[] = {1, 2};
613 const int strides_shape[] = {1, 2};
614 const int output_shape[] = {2, 1, 2};
615 float input_data[] = {1, 2, 3, 4, 5, 6};
616 int32_t begin_data[] = {1, -2};
617 int32_t end_data[] = {2, -3};
618 int32_t strides_data[] = {1, -1};
619 float golden[] = {5, 4};
620 float output_data[8];
621
622 TfLiteStridedSliceParams builtin_data = {0, 2, 0, 0, 0};
623
624 tflite::testing::TestStridedSliceFloat(
625 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
626 input_data, begin_data, end_data, strides_data, output_shape, output_data,
627 golden, false);
628 }
629
TF_LITE_MICRO_TEST(In3D_Identity)630 TF_LITE_MICRO_TEST(In3D_Identity) {
631 const int input_shape[] = {3, 2, 3, 2};
632 const int begin_shape[] = {1, 3};
633 const int end_shape[] = {1, 3};
634 const int strides_shape[] = {1, 3};
635 const int output_shape[] = {3, 2, 3, 2};
636 float input_data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
637 int32_t begin_data[] = {0, 0, 0};
638 int32_t end_data[] = {2, 3, 2};
639 int32_t strides_data[] = {1, 1, 1};
640 float golden[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
641 float output_data[16];
642
643 TfLiteStridedSliceParams builtin_data = {};
644
645 tflite::testing::TestStridedSliceFloat(
646 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
647 input_data, begin_data, end_data, strides_data, output_shape, output_data,
648 golden, false);
649 }
650
TF_LITE_MICRO_TEST(In3D_NegStride)651 TF_LITE_MICRO_TEST(In3D_NegStride) {
652 const int input_shape[] = {3, 2, 3, 2};
653 const int begin_shape[] = {1, 3};
654 const int end_shape[] = {1, 3};
655 const int strides_shape[] = {1, 3};
656 const int output_shape[] = {3, 2, 3, 2};
657 float input_data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
658 int32_t begin_data[] = {0, 0, 0};
659 int32_t end_data[] = {2, 3, 2};
660 int32_t strides_data[] = {1, 1, 1};
661 float golden[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
662 float output_data[16];
663
664 TfLiteStridedSliceParams builtin_data = {};
665
666 tflite::testing::TestStridedSliceFloat(
667 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
668 input_data, begin_data, end_data, strides_data, output_shape, output_data,
669 golden, false);
670 }
671
TF_LITE_MICRO_TEST(In3D_Strided2)672 TF_LITE_MICRO_TEST(In3D_Strided2) {
673 const int input_shape[] = {3, 2, 3, 2};
674 const int begin_shape[] = {1, 3};
675 const int end_shape[] = {1, 3};
676 const int strides_shape[] = {1, 3};
677 const int output_shape[] = {3, 1, 2, 1};
678 float input_data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
679 int32_t begin_data[] = {0, 0, 0};
680 int32_t end_data[] = {2, 3, 2};
681 int32_t strides_data[] = {2, 2, 2};
682 float golden[] = {1, 5};
683 float output_data[16];
684
685 TfLiteStridedSliceParams builtin_data = {};
686
687 tflite::testing::TestStridedSliceFloat(
688 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
689 input_data, begin_data, end_data, strides_data, output_shape, output_data,
690 golden, false);
691 }
692
TF_LITE_MICRO_TEST(In1D_ShrinkAxisMask1)693 TF_LITE_MICRO_TEST(In1D_ShrinkAxisMask1) {
694 const int input_shape[] = {3, 2, 3, 2};
695 const int begin_shape[] = {1, 3};
696 const int end_shape[] = {1, 3};
697 const int strides_shape[] = {1, 3};
698 const int output_shape[] = {3, 2, 3, 2};
699 float input_data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
700 int32_t begin_data[] = {0, 0, 0};
701 int32_t end_data[] = {2, 3, 2};
702 int32_t strides_data[] = {1, 1, 1};
703 float golden[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
704 float output_data[16];
705
706 TfLiteStridedSliceParams builtin_data = {};
707
708 tflite::testing::TestStridedSliceFloat(
709 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
710 input_data, begin_data, end_data, strides_data, output_shape, output_data,
711 golden, false);
712 }
713
TF_LITE_MICRO_TEST(In1D_ShrinkAxisMask1_NegativeSlice)714 TF_LITE_MICRO_TEST(In1D_ShrinkAxisMask1_NegativeSlice) {
715 const int input_shape[] = {1, 4};
716 const int begin_shape[] = {1, 1};
717 const int end_shape[] = {1, 1};
718 const int strides_shape[] = {1, 1};
719 const int output_shape[] = {0};
720 float input_data[] = {0, 1, 2, 3};
721 int32_t begin_data[] = {-1};
722 int32_t end_data[] = {0};
723 int32_t strides_data[] = {1};
724 float golden[] = {3};
725 float output_data[4];
726
727 TfLiteStridedSliceParams builtin_data = {0, 0, 0, 0, 1};
728
729 tflite::testing::TestStridedSliceFloat(
730 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
731 input_data, begin_data, end_data, strides_data, output_shape, output_data,
732 golden, false);
733 }
734
TF_LITE_MICRO_TEST(In2D_ShrinkAxis3_NegativeSlice)735 TF_LITE_MICRO_TEST(In2D_ShrinkAxis3_NegativeSlice) {
736 const int input_shape[] = {2, 4, 1};
737 const int begin_shape[] = {1, 2};
738 const int end_shape[] = {1, 2};
739 const int strides_shape[] = {1, 2};
740 const int output_shape[] = {0};
741 float input_data[] = {0, 1, 2, 3};
742 int32_t begin_data[] = {-2, -1};
743 int32_t end_data[] = {-1, 0};
744 int32_t strides_data[] = {1, 1};
745 float golden[] = {2};
746 float output_data[4];
747
748 TfLiteStridedSliceParams builtin_data = {0, 0, 0, 0, 3};
749
750 tflite::testing::TestStridedSliceFloat(
751 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
752 input_data, begin_data, end_data, strides_data, output_shape, output_data,
753 golden, false);
754 }
755
TF_LITE_MICRO_TEST(In2D_ShrinkAxis2_BeginEndAxis1_NegativeSlice)756 TF_LITE_MICRO_TEST(In2D_ShrinkAxis2_BeginEndAxis1_NegativeSlice) {
757 const int input_shape[] = {2, 4, 1};
758 const int begin_shape[] = {1, 2};
759 const int end_shape[] = {1, 2};
760 const int strides_shape[] = {1, 2};
761 const int output_shape[] = {1, 4};
762 float input_data[] = {0, 1, 2, 3};
763 int32_t begin_data[] = {0, -1};
764 int32_t end_data[] = {0, 0};
765 int32_t strides_data[] = {1, 1};
766 float golden[] = {0, 1, 2, 3};
767 float output_data[4];
768
769 TfLiteStridedSliceParams builtin_data = {1, 1, 0, 0, 2};
770
771 tflite::testing::TestStridedSliceFloat(
772 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
773 input_data, begin_data, end_data, strides_data, output_shape, output_data,
774 golden, false);
775 }
776
TF_LITE_MICRO_TEST(In1D_BeginMaskShrinkAxisMask1)777 TF_LITE_MICRO_TEST(In1D_BeginMaskShrinkAxisMask1) {
778 const int input_shape[] = {1, 4};
779 const int begin_shape[] = {1, 1};
780 const int end_shape[] = {1, 1};
781 const int strides_shape[] = {1, 1};
782 const int output_shape[] = {0};
783 float input_data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
784 int32_t begin_data[] = {1};
785 int32_t end_data[] = {1};
786 int32_t strides_data[] = {1};
787 float golden[] = {1};
788 float output_data[4];
789
790 TfLiteStridedSliceParams builtin_data = {1, 0, 0, 0, 1};
791
792 tflite::testing::TestStridedSliceFloat(
793 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
794 input_data, begin_data, end_data, strides_data, output_shape, output_data,
795 golden, false);
796 }
797
TF_LITE_MICRO_TEST(In2D_ShrinkAxisMask1)798 TF_LITE_MICRO_TEST(In2D_ShrinkAxisMask1) {
799 const int input_shape[] = {2, 2, 3};
800 const int begin_shape[] = {1, 2};
801 const int end_shape[] = {1, 2};
802 const int strides_shape[] = {1, 2};
803 const int output_shape[] = {1, 3};
804 float input_data[] = {1, 2, 3, 4, 5, 6};
805 int32_t begin_data[] = {0, 0};
806 int32_t end_data[] = {1, 3};
807 int32_t strides_data[] = {1, 1};
808 float golden[] = {1, 2, 3};
809 float output_data[6];
810
811 TfLiteStridedSliceParams builtin_data = {0, 0, 0, 0, 1};
812
813 tflite::testing::TestStridedSliceFloat(
814 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
815 input_data, begin_data, end_data, strides_data, output_shape, output_data,
816 golden, false);
817 }
818
TF_LITE_MICRO_TEST(In2D_ShrinkAxisMask2)819 TF_LITE_MICRO_TEST(In2D_ShrinkAxisMask2) {
820 const int input_shape[] = {2, 2, 3};
821 const int begin_shape[] = {1, 2};
822 const int end_shape[] = {1, 2};
823 const int strides_shape[] = {1, 2};
824 const int output_shape[] = {1, 2};
825 float input_data[] = {1, 2, 3, 4, 5, 6};
826 int32_t begin_data[] = {0, 0};
827 int32_t end_data[] = {2, 1};
828 int32_t strides_data[] = {1, 1};
829 float golden[] = {1, 4};
830 float output_data[6];
831
832 TfLiteStridedSliceParams builtin_data = {0, 0, 0, 0, 2};
833
834 tflite::testing::TestStridedSliceFloat(
835 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
836 input_data, begin_data, end_data, strides_data, output_shape, output_data,
837 golden, false);
838 }
839
TF_LITE_MICRO_TEST(In2D_ShrinkAxisMask3)840 TF_LITE_MICRO_TEST(In2D_ShrinkAxisMask3) {
841 const int input_shape[] = {2, 2, 3};
842 const int begin_shape[] = {1, 2};
843 const int end_shape[] = {1, 2};
844 const int strides_shape[] = {1, 2};
845 const int output_shape[] = {0};
846 float input_data[] = {1, 2, 3, 4, 5, 6};
847 int32_t begin_data[] = {0, 0};
848 int32_t end_data[] = {1, 1};
849 int32_t strides_data[] = {1, 1};
850 float golden[] = {1};
851 float output_data[6];
852
853 TfLiteStridedSliceParams builtin_data = {0, 0, 0, 0, 3};
854
855 tflite::testing::TestStridedSliceFloat(
856 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
857 input_data, begin_data, end_data, strides_data, output_shape, output_data,
858 golden, false);
859 }
860
TF_LITE_MICRO_TEST(In3D_IdentityShrinkAxis1)861 TF_LITE_MICRO_TEST(In3D_IdentityShrinkAxis1) {
862 const int input_shape[] = {3, 2, 3, 2};
863 const int begin_shape[] = {1, 3};
864 const int end_shape[] = {1, 3};
865 const int strides_shape[] = {1, 3};
866 const int output_shape[] = {2, 3, 2};
867 float input_data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
868 int32_t begin_data[] = {0, 0, 0};
869 int32_t end_data[] = {1, 3, 2};
870 int32_t strides_data[] = {1, 1, 1};
871 float golden[] = {1, 2, 3, 4, 5, 6};
872 float output_data[16];
873
874 TfLiteStridedSliceParams builtin_data = {0, 0, 0, 0, 1};
875
876 tflite::testing::TestStridedSliceFloat(
877 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
878 input_data, begin_data, end_data, strides_data, output_shape, output_data,
879 golden, false);
880 }
881
TF_LITE_MICRO_TEST(In3D_IdentityShrinkAxis2)882 TF_LITE_MICRO_TEST(In3D_IdentityShrinkAxis2) {
883 const int input_shape[] = {3, 2, 3, 2};
884 const int begin_shape[] = {1, 3};
885 const int end_shape[] = {1, 3};
886 const int strides_shape[] = {1, 3};
887 const int output_shape[] = {2, 2, 2};
888 float input_data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
889 int32_t begin_data[] = {0, 0, 0};
890 int32_t end_data[] = {2, 1, 2};
891 int32_t strides_data[] = {1, 1, 1};
892 float golden[] = {1, 2, 7, 8};
893 float output_data[16];
894
895 TfLiteStridedSliceParams builtin_data = {0, 0, 0, 0, 2};
896
897 tflite::testing::TestStridedSliceFloat(
898 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
899 input_data, begin_data, end_data, strides_data, output_shape, output_data,
900 golden, false);
901 }
902
TF_LITE_MICRO_TEST(In3D_IdentityShrinkAxis3)903 TF_LITE_MICRO_TEST(In3D_IdentityShrinkAxis3) {
904 const int input_shape[] = {3, 2, 3, 2};
905 const int begin_shape[] = {1, 3};
906 const int end_shape[] = {1, 3};
907 const int strides_shape[] = {1, 3};
908 const int output_shape[] = {1, 2};
909 float input_data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
910 int32_t begin_data[] = {0, 0, 0};
911 int32_t end_data[] = {1, 1, 2};
912 int32_t strides_data[] = {1, 1, 1};
913 float golden[] = {1, 2};
914 float output_data[16];
915
916 TfLiteStridedSliceParams builtin_data = {0, 0, 0, 0, 3};
917
918 tflite::testing::TestStridedSliceFloat(
919 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
920 input_data, begin_data, end_data, strides_data, output_shape, output_data,
921 golden, false);
922 }
923
TF_LITE_MICRO_TEST(In3D_IdentityShrinkAxis4)924 TF_LITE_MICRO_TEST(In3D_IdentityShrinkAxis4) {
925 const int input_shape[] = {3, 2, 3, 2};
926 const int begin_shape[] = {1, 3};
927 const int end_shape[] = {1, 3};
928 const int strides_shape[] = {1, 3};
929 const int output_shape[] = {2, 2, 3};
930 float input_data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
931 int32_t begin_data[] = {0, 0, 0};
932 int32_t end_data[] = {2, 3, 2};
933 int32_t strides_data[] = {1, 1, 1};
934 float golden[] = {1, 3, 5, 7, 9, 11};
935 float output_data[16];
936
937 TfLiteStridedSliceParams builtin_data = {0, 0, 0, 0, 4};
938
939 tflite::testing::TestStridedSliceFloat(
940 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
941 input_data, begin_data, end_data, strides_data, output_shape, output_data,
942 golden, false);
943 }
944
TF_LITE_MICRO_TEST(In3D_IdentityShrinkAxis5)945 TF_LITE_MICRO_TEST(In3D_IdentityShrinkAxis5) {
946 const int input_shape[] = {3, 2, 3, 2};
947 const int begin_shape[] = {1, 3};
948 const int end_shape[] = {1, 3};
949 const int strides_shape[] = {1, 3};
950 const int output_shape[] = {1, 3};
951 float input_data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
952 int32_t begin_data[] = {0, 0, 0};
953 int32_t end_data[] = {1, 3, 1};
954 int32_t strides_data[] = {1, 1, 1};
955 float golden[] = {1, 3, 5};
956 float output_data[16];
957
958 TfLiteStridedSliceParams builtin_data = {0, 0, 0, 0, 5};
959
960 tflite::testing::TestStridedSliceFloat(
961 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
962 input_data, begin_data, end_data, strides_data, output_shape, output_data,
963 golden, false);
964 }
965
TF_LITE_MICRO_TEST(In3D_IdentityShrinkAxis6)966 TF_LITE_MICRO_TEST(In3D_IdentityShrinkAxis6) {
967 const int input_shape[] = {3, 2, 3, 2};
968 const int begin_shape[] = {1, 3};
969 const int end_shape[] = {1, 3};
970 const int strides_shape[] = {1, 3};
971 const int output_shape[] = {1, 2};
972 float input_data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
973 int32_t begin_data[] = {0, 0, 0};
974 int32_t end_data[] = {2, 1, 1};
975 int32_t strides_data[] = {1, 1, 1};
976 float golden[] = {1, 7};
977 float output_data[16];
978
979 TfLiteStridedSliceParams builtin_data = {0, 0, 0, 0, 6};
980
981 tflite::testing::TestStridedSliceFloat(
982 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
983 input_data, begin_data, end_data, strides_data, output_shape, output_data,
984 golden, false);
985 }
986
TF_LITE_MICRO_TEST(In3D_IdentityShrinkAxis7)987 TF_LITE_MICRO_TEST(In3D_IdentityShrinkAxis7) {
988 const int input_shape[] = {3, 2, 3, 2};
989 const int begin_shape[] = {1, 3};
990 const int end_shape[] = {1, 3};
991 const int strides_shape[] = {1, 3};
992 const int output_shape[] = {0};
993 float input_data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
994 int32_t begin_data[] = {0, 0, 0};
995 int32_t end_data[] = {1, 1, 1};
996 int32_t strides_data[] = {1, 1, 1};
997 float golden[] = {1};
998 float output_data[16];
999
1000 TfLiteStridedSliceParams builtin_data = {0, 0, 0, 0, 7};
1001
1002 tflite::testing::TestStridedSliceFloat(
1003 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
1004 input_data, begin_data, end_data, strides_data, output_shape, output_data,
1005 golden, false);
1006 }
1007
1008 // This tests catches a very subtle bug that was fixed by cl/188403234.
TF_LITE_MICRO_TEST(RunTwice)1009 TF_LITE_MICRO_TEST(RunTwice) {
1010 const int input_shape[] = {2, 2, 3};
1011 const int begin_shape[] = {1, 2};
1012 const int end_shape[] = {1, 2};
1013 const int strides_shape[] = {1, 2};
1014 const int output_shape[] = {2, 2, 2};
1015 float input_data[] = {1, 2, 3, 4, 5, 6};
1016 int32_t begin_data[] = {1, 0};
1017 int32_t end_data[] = {2, 2};
1018 int32_t strides_data[] = {1, 1};
1019 float golden[] = {1, 2, 4, 5};
1020 float output_data[16];
1021
1022 TfLiteStridedSliceParams builtin_data = {1, 0, 0, 0, 0};
1023
1024 tflite::testing::TestStridedSliceFloat(
1025 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
1026 input_data, begin_data, end_data, strides_data, output_shape, output_data,
1027 golden, false, 2);
1028 }
1029
TF_LITE_MICRO_TEST(In3D_IdentityShrinkAxis1Uint8)1030 TF_LITE_MICRO_TEST(In3D_IdentityShrinkAxis1Uint8) {
1031 const int input_shape[] = {3, 2, 3, 2};
1032 const int begin_shape[] = {1, 3};
1033 const int end_shape[] = {1, 3};
1034 const int strides_shape[] = {1, 3};
1035 const int output_shape[] = {2, 3, 2};
1036 uint8_t input_data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
1037 int32_t begin_data[] = {0, 0, 0};
1038 int32_t end_data[] = {1, 3, 2};
1039 int32_t strides_data[] = {1, 1, 1};
1040 uint8_t golden[] = {1, 2, 3, 4, 5, 6};
1041 uint8_t output_data[12];
1042
1043 TfLiteStridedSliceParams builtin_data = {0, 0, 0, 0, 1};
1044
1045 tflite::testing::TestStridedSliceQuantized(
1046 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
1047 input_data, begin_data, end_data, strides_data, output_shape, output_data,
1048 golden, false);
1049 }
1050
TF_LITE_MICRO_TEST(In3D_IdentityShrinkAxis1int8)1051 TF_LITE_MICRO_TEST(In3D_IdentityShrinkAxis1int8) {
1052 const int input_shape[] = {3, 2, 3, 2};
1053 const int begin_shape[] = {1, 3};
1054 const int end_shape[] = {1, 3};
1055 const int strides_shape[] = {1, 3};
1056 const int output_shape[] = {2, 3, 2};
1057 int8_t input_data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
1058 int32_t begin_data[] = {0, 0, 0};
1059 int32_t end_data[] = {1, 3, 2};
1060 int32_t strides_data[] = {1, 1, 1};
1061 int8_t golden[] = {1, 2, 3, 4, 5, 6};
1062 int8_t output_data[12];
1063
1064 TfLiteStridedSliceParams builtin_data = {0, 0, 0, 0, 1};
1065
1066 tflite::testing::TestStridedSliceQuantized(
1067 input_shape, begin_shape, end_shape, strides_shape, &builtin_data,
1068 input_data, begin_data, end_data, strides_data, output_shape, output_data,
1069 golden, false);
1070 }
1071
1072 TF_LITE_MICRO_TESTS_END
1073