src/armnnDeserializer/test/DeserializeShape.cpp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//

#include "ParserFlatbuffersSerializeFixture.hpp"
#include <armnnDeserializer/IDeserializer.hpp>

#include <doctest/doctest.h>

#include <string>

TEST_SUITE("Deserializer_Shape")
{
struct ShapeFixture : public ParserFlatbuffersSerializeFixture
{
    explicit ShapeFixture()
    {
        m_JsonString = R"(
            {
              layers: [
                {
                  layer_type: "InputLayer",
                  layer: {
                    base: {
                      base: {
                        layerName: "InputLayer",
                        layerType: "Input",
                        inputSlots: [

                        ],
                        outputSlots: [
                          {
                            tensorInfo: {
                              dimensions: [
                                1,
                                3,
                                3,
                                1
                              ],
                              dataType: "Signed32",
                              quantizationScale: 0.0
                            }
                          }
                        ]
                      }
                    }
                  }
                },
                {
                  layer_type: "ShapeLayer",
                  layer: {
                    base: {
                      index: 1,
                      layerName: "shape",
                      layerType: "Shape",
                      inputSlots: [
                        {
                          connection: {
                            sourceLayerIndex: 0,
                            outputSlotIndex: 0
                          }
                        }
                      ],
                      outputSlots: [
                        {
                          tensorInfo: {
                            dimensions: [
                              4
                            ],
                            dataType: "Signed32",
                            quantizationScale: 0.0
                          }
                        }
                      ]
                    }
                  }
                },
                {
                  layer_type: "OutputLayer",
                  layer: {
                    base: {
                      base: {
                        index: 2,
                        layerName: "OutputLayer",
                        layerType: "Output",
                        inputSlots: [
                          {
                            connection: {
                              sourceLayerIndex: 1,
                              outputSlotIndex: 0
                            }
                          }
                        ],
                        outputSlots: [

                        ]
                      }
                    }
                  }
                }
              ],
              inputIds: [
                0
              ],
              outputIds: [
                0
              ],
              featureVersions: {
                bindingIdsScheme: 1
              }
            }
    )";
        Setup();
    }
};

struct SimpleShapeFixture : ShapeFixture
{
    SimpleShapeFixture() : ShapeFixture() {}
};

TEST_CASE_FIXTURE(SimpleShapeFixture, "DeserializeShape")
{
    RunTest<1, armnn::DataType::Signed32>(
            0,
            {{"InputLayer", { 1, 1, 1, 1, 1, 1, 1, 1, 1 }}},
            {{"OutputLayer",{ 1, 3, 3, 1 }}});
}

}