src/armnnDeserializer/test/DeserializeResizeBilinear.cpp

   1 //
   2 // Copyright © 2017 Arm Ltd. All rights reserved.
   3 // SPDX-License-Identifier: MIT
   4 //
   5
   6 #include <boost/test/unit_test.hpp>
   7 #include "ParserFlatbuffersSerializeFixture.hpp"
   8 #include <armnnDeserializer/IDeserializer.hpp>
   9
  10 #include <string>
  11
  12 BOOST_AUTO_TEST_SUITE(Deserializer)
  13
  14 struct ResizeBilinearFixture : public ParserFlatbuffersSerializeFixture
  15 {
  16     explicit ResizeBilinearFixture(const std::string& inputShape,
  17                                    const std::string& targetWidth,
  18                                    const std::string& targetHeight,
  19                                    const std::string& dataLayout,
  20                                    const std::string& outputShape,
  21                                    const std::string& dataType)
  22     {
  23         m_JsonString = R"(
  24             {
  25                 inputIds: [0],
  26                 outputIds: [2],
  27                 layers: [
  28                     {
  29                         layer_type: "InputLayer",
  30                         layer: {
  31                             base: {
  32                                 layerBindingId: 0,
  33                                 base: {
  34                                     index: 0,
  35                                     layerName: "InputLayer",
  36                                     layerType: "Input",
  37                                     inputSlots: [{
  38                                         index: 0,
  39                                         connection: {sourceLayerIndex:0, outputSlotIndex:0 },
  40                                     }],
  41                                     outputSlots: [{
  42                                         index: 0,
  43                                         tensorInfo: {
  44                                             dimensions: )" + inputShape + R"(,
  45                                             dataType: )" + dataType + R"(
  46                                         }
  47                                     }]
  48                                 }
  49                             }
  50                         }
  51                     },
  52                     {
  53                         layer_type: "ResizeBilinearLayer",
  54                         layer: {
  55                             base: {
  56                                 index: 1,
  57                                 layerName: "ResizeBilinearLayer",
  58                                 layerType: "ResizeBilinear",
  59                                 inputSlots: [{
  60                                     index: 0,
  61                                     connection: {sourceLayerIndex:0, outputSlotIndex:0 },
  62                                 }],
  63                                 outputSlots: [{
  64                                     index: 0,
  65                                     tensorInfo: {
  66                                         dimensions: )" + outputShape + R"(,
  67                                         dataType: )" + dataType + R"(
  68                                     }
  69                                 }]
  70                             },
  71                             descriptor: {
  72                                 targetWidth: )" + targetWidth + R"(,
  73                                 targetHeight: )" + targetHeight + R"(,
  74                                 dataLayout: )" + dataLayout + R"(,
  75                             }
  76                         }
  77                     },
  78                     {
  79                         layer_type: "OutputLayer",
  80                         layer: {
  81                             base:{
  82                                 layerBindingId: 2,
  83                                 base: {
  84                                     index: 2,
  85                                     layerName: "OutputLayer",
  86                                     layerType: "Output",
  87                                     inputSlots: [{
  88                                         index: 0,
  89                                         connection: {sourceLayerIndex:1, outputSlotIndex:0 },
  90                                     }],
  91                                     outputSlots: [{
  92                                         index: 0,
  93                                         tensorInfo: {
  94                                             dimensions: )" + outputShape + R"(,
  95                                             dataType: )" + dataType + R"(
  96                                         },
  97                                     }],
  98                                 }
  99                             }
 100                         },
 101                     }
 102                 ]
 103             }
 104         )";
 105         SetupSingleInputSingleOutput("InputLayer", "OutputLayer");
 106     }
 107 };
 108
 109 struct SimpleResizeBilinearFixture : ResizeBilinearFixture
 110 {
 111     SimpleResizeBilinearFixture() : ResizeBilinearFixture("[1, 2, 2, 2]",
 112                                                           "1",
 113                                                           "1",
 114                                                           "NCHW",
 115                                                           "[1, 2, 1, 1]",
 116                                                           "Float32") {}
 117 };
 118
 119 BOOST_FIXTURE_TEST_CASE(SimpleResizeBilinearFloat32, SimpleResizeBilinearFixture)
 120 {
 121     RunTest<4, armnn::DataType::Float32>(0,
 122                                          {
 123                                               1.0f, 255.0f, 200.0f, 250.0f,
 124                                             250.0f, 200.0f, 250.0f,   1.0f
 125                                          },
 126                                          {
 127                                               1.0f, 250.0f
 128                                          });
 129 }
 130
 131 BOOST_AUTO_TEST_SUITE_END()