compiler/luci/logex/src/CircleNodeSummaryBuilder.test.cpp

   1 /*
   2  * Copyright (c) 2022 Samsung Electronics Co., Ltd. All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *    http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "CircleNodeSummaryBuilder.h"
  18
  19 #include <luci/IR/CircleNodes.h>
  20 #include <locop/NodeSummary.h>
  21 #include <locop/SymbolTable.h>
  22
  23 #include <gtest/gtest.h>
  24
  25 namespace
  26 {
  27
  28 class MockSymbolTable : public locop::SymbolTable
  29 {
  30   std::string lookup(const loco::Node *) const override
  31   {
  32     return "Do nothing because it is mocking Symbol Table!";
  33   }
  34 };
  35
  36 class CircleNodeSummaryBuilderTest : public ::testing::Test
  37 {
  38 protected:
  39   bool mock_build(const loco::Node *node)
  40   {
  41     return luci::CircleNodeSummaryBuilder().build(node, &_tbl, _s);
  42   }
  43
  44 protected:
  45   MockSymbolTable _tbl;
  46   locop::NodeSummary _s;
  47 };
  48
  49 } // namespace
  50
  51 TEST_F(CircleNodeSummaryBuilderTest, Add_validate)
  52 {
  53   luci::CircleAdd node;
  54   node.fusedActivationFunction(luci::FusedActFunc::RELU);
  55   EXPECT_TRUE(mock_build(&node));
  56 }
  57
  58 TEST_F(CircleNodeSummaryBuilderTest, Add_validate_fused_NEG)
  59 {
  60   luci::CircleAdd node;
  61   node.fusedActivationFunction(luci::FusedActFunc::UNDEFINED);
  62   EXPECT_FALSE(mock_build(&node));
  63 }
  64
  65 TEST_F(CircleNodeSummaryBuilderTest, AveragePool2D_validate)
  66 {
  67   luci::CircleAveragePool2D node;
  68   node.fusedActivationFunction(luci::FusedActFunc::RELU);
  69   node.padding(luci::Padding::SAME);
  70   EXPECT_TRUE(mock_build(&node));
  71 }
  72
  73 TEST_F(CircleNodeSummaryBuilderTest, AveragePool2D_validate_fused_NEG)
  74 {
  75   luci::CircleAveragePool2D node;
  76   node.fusedActivationFunction(luci::FusedActFunc::UNDEFINED);
  77   node.padding(luci::Padding::SAME);
  78   EXPECT_FALSE(mock_build(&node));
  79 }
  80
  81 TEST_F(CircleNodeSummaryBuilderTest, AveragePool2D_validate_padding_NEG)
  82 {
  83   luci::CircleAveragePool2D node;
  84   node.fusedActivationFunction(luci::FusedActFunc::RELU);
  85   node.padding(luci::Padding::UNDEFINED);
  86   EXPECT_FALSE(mock_build(&node));
  87 }
  88
  89 TEST_F(CircleNodeSummaryBuilderTest, BCQFullyConnected_validate)
  90 {
  91   luci::CircleBCQFullyConnected node;
  92   node.fusedActivationFunction(luci::FusedActFunc::RELU);
  93   EXPECT_TRUE(mock_build(&node));
  94 }
  95
  96 TEST_F(CircleNodeSummaryBuilderTest, BCQFullyConnected_validate_fused_NEG)
  97 {
  98   luci::CircleBCQFullyConnected node;
  99   node.fusedActivationFunction(luci::FusedActFunc::UNDEFINED);
 100   EXPECT_FALSE(mock_build(&node));
 101 }
 102
 103 TEST_F(CircleNodeSummaryBuilderTest, Concatenation_validate)
 104 {
 105   luci::CircleConcatenation node(2);
 106   node.fusedActivationFunction(luci::FusedActFunc::RELU);
 107   EXPECT_TRUE(mock_build(&node));
 108 }
 109
 110 TEST_F(CircleNodeSummaryBuilderTest, Concatenation_validate_fused_NEG)
 111 {
 112   luci::CircleConcatenation node(2);
 113   node.fusedActivationFunction(luci::FusedActFunc::UNDEFINED);
 114   EXPECT_FALSE(mock_build(&node));
 115 }
 116
 117 TEST_F(CircleNodeSummaryBuilderTest, Conv2D_validate)
 118 {
 119   luci::CircleConv2D node;
 120   node.fusedActivationFunction(luci::FusedActFunc::RELU);
 121   node.padding(luci::Padding::SAME);
 122   EXPECT_TRUE(mock_build(&node));
 123 }
 124
 125 TEST_F(CircleNodeSummaryBuilderTest, Conv2D_validate_fused_NEG)
 126 {
 127   luci::CircleConv2D node;
 128   node.fusedActivationFunction(luci::FusedActFunc::UNDEFINED);
 129   node.padding(luci::Padding::SAME);
 130   EXPECT_FALSE(mock_build(&node));
 131 }
 132
 133 TEST_F(CircleNodeSummaryBuilderTest, Conv2D_validate_padding_NEG)
 134 {
 135   luci::CircleConv2D node;
 136   node.fusedActivationFunction(luci::FusedActFunc::RELU);
 137   node.padding(luci::Padding::UNDEFINED);
 138   EXPECT_FALSE(mock_build(&node));
 139 }
 140
 141 TEST_F(CircleNodeSummaryBuilderTest, DepthwiseConv2D_validate)
 142 {
 143   luci::CircleDepthwiseConv2D node;
 144   node.fusedActivationFunction(luci::FusedActFunc::RELU);
 145   node.padding(luci::Padding::SAME);
 146   EXPECT_TRUE(mock_build(&node));
 147 }
 148
 149 TEST_F(CircleNodeSummaryBuilderTest, DepthwiseConv2D_validate_fused_NEG)
 150 {
 151   luci::CircleDepthwiseConv2D node;
 152   node.fusedActivationFunction(luci::FusedActFunc::UNDEFINED);
 153   node.padding(luci::Padding::SAME);
 154   EXPECT_FALSE(mock_build(&node));
 155 }
 156
 157 TEST_F(CircleNodeSummaryBuilderTest, DepthwiseConv2D_validate_padding_NEG)
 158 {
 159   luci::CircleDepthwiseConv2D node;
 160   node.fusedActivationFunction(luci::FusedActFunc::RELU);
 161   node.padding(luci::Padding::UNDEFINED);
 162   EXPECT_FALSE(mock_build(&node));
 163 }
 164
 165 TEST_F(CircleNodeSummaryBuilderTest, FullyConnected_validate)
 166 {
 167   luci::CircleFullyConnected node;
 168   node.fusedActivationFunction(luci::FusedActFunc::RELU);
 169   EXPECT_TRUE(mock_build(&node));
 170 }
 171
 172 TEST_F(CircleNodeSummaryBuilderTest, FullyConnected_validate_fused_NEG)
 173 {
 174   luci::CircleFullyConnected node;
 175   node.fusedActivationFunction(luci::FusedActFunc::UNDEFINED);
 176   EXPECT_FALSE(mock_build(&node));
 177 }
 178
 179 TEST_F(CircleNodeSummaryBuilderTest, InstanceNorm_validate)
 180 {
 181   luci::CircleInstanceNorm node;
 182   node.fusedActivationFunction(luci::FusedActFunc::RELU);
 183   EXPECT_TRUE(mock_build(&node));
 184 }
 185
 186 TEST_F(CircleNodeSummaryBuilderTest, InstanceNorm_validate_fused_NEG)
 187 {
 188   luci::CircleInstanceNorm node;
 189   node.fusedActivationFunction(luci::FusedActFunc::UNDEFINED);
 190   EXPECT_FALSE(mock_build(&node));
 191 }
 192
 193 TEST_F(CircleNodeSummaryBuilderTest, L2Normalize_validate)
 194 {
 195   luci::CircleL2Normalize node;
 196   node.fusedActivationFunction(luci::FusedActFunc::RELU);
 197   EXPECT_TRUE(mock_build(&node));
 198 }
 199
 200 TEST_F(CircleNodeSummaryBuilderTest, L2Normalize_validate_fused_NEG)
 201 {
 202   luci::CircleL2Normalize node;
 203   node.fusedActivationFunction(luci::FusedActFunc::UNDEFINED);
 204   EXPECT_FALSE(mock_build(&node));
 205 }
 206
 207 TEST_F(CircleNodeSummaryBuilderTest, L2Pool2D_validate)
 208 {
 209   luci::CircleL2Pool2D node;
 210   node.fusedActivationFunction(luci::FusedActFunc::RELU);
 211   node.padding(luci::Padding::SAME);
 212   EXPECT_TRUE(mock_build(&node));
 213 }
 214
 215 TEST_F(CircleNodeSummaryBuilderTest, L2Pool2D_validate_fused_NEG)
 216 {
 217   luci::CircleL2Pool2D node;
 218   node.fusedActivationFunction(luci::FusedActFunc::UNDEFINED);
 219   node.padding(luci::Padding::SAME);
 220   EXPECT_FALSE(mock_build(&node));
 221 }
 222
 223 TEST_F(CircleNodeSummaryBuilderTest, L2Pool2D_validate_padding_NEG)
 224 {
 225   luci::CircleL2Pool2D node;
 226   node.fusedActivationFunction(luci::FusedActFunc::RELU);
 227   node.padding(luci::Padding::UNDEFINED);
 228   EXPECT_FALSE(mock_build(&node));
 229 }
 230
 231 TEST_F(CircleNodeSummaryBuilderTest, MaxPool2D_validate)
 232 {
 233   luci::CircleMaxPool2D node;
 234   node.fusedActivationFunction(luci::FusedActFunc::RELU);
 235   node.padding(luci::Padding::SAME);
 236   EXPECT_TRUE(mock_build(&node));
 237 }
 238
 239 TEST_F(CircleNodeSummaryBuilderTest, MaxPool2D_validate_fused_NEG)
 240 {
 241   luci::CircleMaxPool2D node;
 242   node.fusedActivationFunction(luci::FusedActFunc::UNDEFINED);
 243   node.padding(luci::Padding::SAME);
 244   EXPECT_FALSE(mock_build(&node));
 245 }
 246
 247 TEST_F(CircleNodeSummaryBuilderTest, MaxPool2D_validate_padding_NEG)
 248 {
 249   luci::CircleMaxPool2D node;
 250   node.fusedActivationFunction(luci::FusedActFunc::RELU);
 251   node.padding(luci::Padding::UNDEFINED);
 252   EXPECT_FALSE(mock_build(&node));
 253 }
 254
 255 TEST_F(CircleNodeSummaryBuilderTest, MirrorPad_validate)
 256 {
 257   luci::CircleMirrorPad node;
 258   node.mode(luci::MirrorPadMode::REFLECT);
 259   EXPECT_TRUE(mock_build(&node));
 260 }
 261
 262 TEST_F(CircleNodeSummaryBuilderTest, MirrorPad_validate_mirror_padding_NEG)
 263 {
 264   luci::CircleMirrorPad node;
 265   node.mode(luci::MirrorPadMode::UNDEFINED);
 266   EXPECT_FALSE(mock_build(&node));
 267 }
 268
 269 TEST_F(CircleNodeSummaryBuilderTest, Mul_validate)
 270 {
 271   luci::CircleMul node;
 272   node.fusedActivationFunction(luci::FusedActFunc::RELU);
 273   EXPECT_TRUE(mock_build(&node));
 274 }
 275
 276 TEST_F(CircleNodeSummaryBuilderTest, Mul_validate_fused_NEG)
 277 {
 278   luci::CircleMul node;
 279   node.fusedActivationFunction(luci::FusedActFunc::UNDEFINED);
 280   EXPECT_FALSE(mock_build(&node));
 281 }
 282
 283 TEST_F(CircleNodeSummaryBuilderTest, SVDF_validate)
 284 {
 285   luci::CircleSVDF node;
 286   node.fusedActivationFunction(luci::FusedActFunc::RELU);
 287   EXPECT_TRUE(mock_build(&node));
 288 }
 289
 290 TEST_F(CircleNodeSummaryBuilderTest, SVDF_validate_fused_NEG)
 291 {
 292   luci::CircleSVDF node;
 293   node.fusedActivationFunction(luci::FusedActFunc::UNDEFINED);
 294   EXPECT_FALSE(mock_build(&node));
 295 }
 296
 297 TEST_F(CircleNodeSummaryBuilderTest, TransposeConv_validate)
 298 {
 299   luci::CircleTransposeConv node;
 300   node.padding(luci::Padding::SAME);
 301   node.fusedActivationFunction(luci::FusedActFunc::RELU);
 302   EXPECT_TRUE(mock_build(&node));
 303 }
 304
 305 TEST_F(CircleNodeSummaryBuilderTest, TransposeConv_validate_padding_NEG)
 306 {
 307   luci::CircleTransposeConv node;
 308   node.padding(luci::Padding::UNDEFINED);
 309   EXPECT_FALSE(mock_build(&node));
 310 }
 311
 312 TEST_F(CircleNodeSummaryBuilderTest, TransposeConv_validate_fused_NEG)
 313 {
 314   luci::CircleTransposeConv node;
 315   node.fusedActivationFunction(luci::FusedActFunc::UNDEFINED);
 316   EXPECT_FALSE(mock_build(&node));
 317 }