tests/nnfw_api/src/ValidationTestAddModelLoaded.cc

   1 /*
   2  * Copyright (c) 2020 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 "fixtures.h"
  18 #include "NNPackages.h"
  19
  20 #include "nnfw_internal.h"
  21
  22 using ValidationTestAddModelLoaded = ValidationTestModelLoaded<NNPackages::ADD>;
  23
  24 TEST_F(ValidationTestAddModelLoaded, prepare_001)
  25 {
  26   NNFW_ENSURE_SUCCESS(nnfw_prepare(_session));
  27
  28   SUCCEED();
  29 }
  30
  31 TEST_F(ValidationTestAddModelLoaded, set_available_backends_001)
  32 {
  33   NNFW_ENSURE_SUCCESS(nnfw_set_available_backends(_session, "cpu"));
  34
  35   SUCCEED();
  36 }
  37
  38 TEST_F(ValidationTestAddModelLoaded, get_input_size)
  39 {
  40   uint32_t size = 0;
  41   NNFW_ENSURE_SUCCESS(nnfw_input_size(_session, &size));
  42   ASSERT_EQ(size, 1);
  43 }
  44
  45 TEST_F(ValidationTestAddModelLoaded, get_output_size)
  46 {
  47   uint32_t size = 0;
  48   NNFW_ENSURE_SUCCESS(nnfw_output_size(_session, &size));
  49   ASSERT_EQ(size, 1);
  50 }
  51
  52 TEST_F(ValidationTestAddModelLoaded, output_tensorinfo)
  53 {
  54   nnfw_tensorinfo tensor_info;
  55   NNFW_ENSURE_SUCCESS(nnfw_output_tensorinfo(_session, 0, &tensor_info));
  56   ASSERT_EQ(tensor_info.rank, 1);
  57   ASSERT_EQ(tensor_info.dims[0], 1);
  58 }
  59
  60 TEST_F(ValidationTestAddModelLoaded, input_output_tensorindex)
  61 {
  62   uint32_t in_ind = 100;
  63   NNFW_ENSURE_SUCCESS(nnfw_input_tensorindex(_session, "X_input", &in_ind));
  64   ASSERT_EQ(in_ind, 0);
  65
  66   uint32_t out_ind = 100;
  67   NNFW_ENSURE_SUCCESS(nnfw_output_tensorindex(_session, "ADD_TOP", &out_ind));
  68   ASSERT_EQ(out_ind, 0);
  69 }
  70
  71 TEST_F(ValidationTestAddModelLoaded, neg_run)
  72 {
  73   // nnfw_prepare is not called
  74   ASSERT_EQ(nnfw_run(_session), NNFW_STATUS_INVALID_STATE);
  75 }
  76
  77 TEST_F(ValidationTestAddModelLoaded, neg_set_input)
  78 {
  79   // nnfw_prepare is not called
  80   ASSERT_EQ(nnfw_set_input(_session, 0, NNFW_TYPE_TENSOR_FLOAT32, nullptr, 0),
  81             NNFW_STATUS_INVALID_STATE);
  82 }
  83
  84 TEST_F(ValidationTestAddModelLoaded, neg_set_output)
  85 {
  86   // nnfw_prepare is not called
  87   ASSERT_EQ(nnfw_set_output(_session, 0, NNFW_TYPE_TENSOR_FLOAT32, nullptr, 0),
  88             NNFW_STATUS_INVALID_STATE);
  89 }
  90
  91 TEST_F(ValidationTestAddModelLoaded, neg_get_input_size)
  92 {
  93   ASSERT_EQ(nnfw_input_size(_session, nullptr), NNFW_STATUS_UNEXPECTED_NULL);
  94 }
  95
  96 TEST_F(ValidationTestAddModelLoaded, neg_get_output_size)
  97 {
  98   ASSERT_EQ(nnfw_output_size(_session, nullptr), NNFW_STATUS_UNEXPECTED_NULL);
  99 }
 100
 101 TEST_F(ValidationTestAddModelLoaded, neg_load_model)
 102 {
 103   // load model twice
 104   ASSERT_EQ(nnfw_load_model_from_file(
 105               _session, NNPackages::get().getModelAbsolutePath(NNPackages::ADD).c_str()),
 106             NNFW_STATUS_INVALID_STATE);
 107 }
 108
 109 TEST_F(ValidationTestAddModelLoaded, neg_output_tensorinfo)
 110 {
 111   // tensor_info is null
 112   ASSERT_EQ(nnfw_output_tensorinfo(_session, 0, nullptr), NNFW_STATUS_UNEXPECTED_NULL);
 113 }
 114
 115 TEST_F(ValidationTestAddModelLoaded, neg_input_output_tensorindex)
 116 {
 117   uint32_t in_ind = 100;
 118   ASSERT_EQ(nnfw_input_tensorindex(_session, "ADD_TOP", &in_ind), NNFW_STATUS_ERROR);
 119   ASSERT_EQ(in_ind, 100);
 120   ASSERT_EQ(nnfw_input_tensorindex(_session, "y_var", &in_ind), NNFW_STATUS_ERROR);
 121   ASSERT_EQ(in_ind, 100);
 122
 123   uint32_t out_ind = 100;
 124   ASSERT_EQ(nnfw_output_tensorindex(_session, "X_input", &out_ind), NNFW_STATUS_ERROR);
 125   ASSERT_EQ(out_ind, 100);
 126 }
 127
 128 TEST_F(ValidationTestAddModelLoaded, experimental_input_tensorindex)
 129 {
 130   uint32_t ind = 999;
 131   NNFW_ENSURE_SUCCESS(nnfw_input_tensorindex(_session, "X_input", &ind));
 132   ASSERT_EQ(ind, 0);
 133 }
 134
 135 TEST_F(ValidationTestAddModelLoaded, neg_experimental_input_tensorindex_name_null)
 136 {
 137   uint32_t ind = 999;
 138   ASSERT_EQ(nnfw_input_tensorindex(_session, nullptr, &ind), NNFW_STATUS_UNEXPECTED_NULL);
 139   ASSERT_EQ(ind, 999);
 140 }
 141
 142 TEST_F(ValidationTestAddModelLoaded, neg_experimental_input_tensorindex_index_null)
 143 {
 144   ASSERT_EQ(nnfw_input_tensorindex(_session, "X_input", nullptr), NNFW_STATUS_UNEXPECTED_NULL);
 145 }
 146
 147 TEST_F(ValidationTestAddModelLoaded, neg_experimental_input_name_too_long)
 148 {
 149   std::string long_name(1024, 'x'); // Too long
 150   uint32_t ind = 999;
 151   ASSERT_EQ(nnfw_output_tensorindex(_session, long_name.c_str(), &ind), NNFW_STATUS_ERROR);
 152   ASSERT_EQ(ind, 999);
 153 }
 154
 155 TEST_F(ValidationTestAddModelLoaded, neg_experimental_input_no_such_name)
 156 {
 157   uint32_t ind = 999;
 158   ASSERT_EQ(nnfw_output_tensorindex(_session, "NO_SUCH_TENSOR_NAME", &ind), NNFW_STATUS_ERROR);
 159   ASSERT_EQ(ind, 999);
 160 }
 161
 162 TEST_F(ValidationTestAddModelLoaded, experimental_output_tensorindex)
 163 {
 164   uint32_t ind = 999;
 165   NNFW_ENSURE_SUCCESS(nnfw_output_tensorindex(_session, "ADD_TOP", &ind));
 166   ASSERT_EQ(ind, 0);
 167 }
 168
 169 TEST_F(ValidationTestAddModelLoaded, neg_experimental_output_tensorindex_name_null)
 170 {
 171   uint32_t ind = 999;
 172   ASSERT_EQ(nnfw_output_tensorindex(_session, nullptr, &ind), NNFW_STATUS_UNEXPECTED_NULL);
 173   ASSERT_EQ(ind, 999);
 174 }
 175
 176 TEST_F(ValidationTestAddModelLoaded, neg_experimental_output_tensorindex_index_null)
 177 {
 178   ASSERT_EQ(nnfw_output_tensorindex(_session, "ADD_TOP", nullptr), NNFW_STATUS_UNEXPECTED_NULL);
 179 }
 180
 181 TEST_F(ValidationTestAddModelLoaded, neg_experimental_output_name_too_long)
 182 {
 183   std::string long_name(1024, 'x'); // Too long
 184   uint32_t ind = 999;
 185   ASSERT_EQ(nnfw_output_tensorindex(_session, long_name.c_str(), &ind), NNFW_STATUS_ERROR);
 186   ASSERT_EQ(ind, 999);
 187 }
 188
 189 TEST_F(ValidationTestAddModelLoaded, neg_experimental_output_no_such_name)
 190 {
 191   uint32_t ind = 999;
 192   ASSERT_EQ(nnfw_output_tensorindex(_session, "NO_SUCH_TENSOR_NAME", &ind), NNFW_STATUS_ERROR);
 193   ASSERT_EQ(ind, 999);
 194 }
 195
 196 TEST_F(ValidationTestAddModelLoaded, debug_set_config)
 197 {
 198   // At least one test for all valid keys
 199   NNFW_ENSURE_SUCCESS(nnfw_set_config(_session, "TRACE_FILEPATH", ""));
 200   NNFW_ENSURE_SUCCESS(nnfw_set_config(_session, "GRAPH_DOT_DUMP", "0"));
 201   NNFW_ENSURE_SUCCESS(nnfw_set_config(_session, "GRAPH_DOT_DUMP", "1"));
 202   NNFW_ENSURE_SUCCESS(nnfw_set_config(_session, "GRAPH_DOT_DUMP", "2"));
 203   NNFW_ENSURE_SUCCESS(nnfw_set_config(_session, "EXECUTOR", "Linear"));
 204   NNFW_ENSURE_SUCCESS(nnfw_set_config(_session, "OP_BACKEND_ALLOPS", "cpu"));
 205   NNFW_ENSURE_SUCCESS(nnfw_set_config(_session, "USE_SCHEDULER", "0"));
 206   NNFW_ENSURE_SUCCESS(nnfw_set_config(_session, "USE_SCHEDULER", "1"));
 207   NNFW_ENSURE_SUCCESS(nnfw_set_config(_session, "PROFILING_MODE", "0"));
 208   NNFW_ENSURE_SUCCESS(nnfw_set_config(_session, "PROFILING_MODE", "1"));
 209   NNFW_ENSURE_SUCCESS(nnfw_set_config(_session, "DISABLE_COMPILE", "0"));
 210   NNFW_ENSURE_SUCCESS(nnfw_set_config(_session, "DISABLE_COMPILE", "1"));
 211   SUCCEED();
 212 }
 213
 214 TEST_F(ValidationTestAddModelLoaded, neg_debug_set_config)
 215 {
 216   // unexpected null args
 217   ASSERT_EQ(nnfw_set_config(_session, nullptr, "1"), NNFW_STATUS_UNEXPECTED_NULL);
 218   ASSERT_EQ(nnfw_set_config(_session, "EXECUTOR", nullptr), NNFW_STATUS_UNEXPECTED_NULL);
 219
 220   // wrong keys
 221   ASSERT_EQ(nnfw_set_config(_session, "", "1"), NNFW_STATUS_ERROR);
 222   ASSERT_EQ(nnfw_set_config(_session, "BAD_KEY", "1"), NNFW_STATUS_ERROR);
 223 }
 224
 225 TEST_F(ValidationTestAddModelLoaded, debug_get_config)
 226 {
 227   // At least one test for all valid keys
 228   char buf[1024];
 229   NNFW_ENSURE_SUCCESS(nnfw_get_config(_session, "EXECUTOR", buf, sizeof(buf)));
 230   NNFW_ENSURE_SUCCESS(nnfw_get_config(_session, "BACKENDS", buf, sizeof(buf)));
 231   SUCCEED();
 232 }
 233
 234 TEST_F(ValidationTestAddModelLoaded, neg_debug_get_config)
 235 {
 236   // unexpected null args
 237   char buf[1024];
 238   ASSERT_EQ(nnfw_get_config(_session, nullptr, buf, sizeof(buf)), NNFW_STATUS_UNEXPECTED_NULL);
 239   ASSERT_EQ(nnfw_get_config(_session, "EXECUTOR", nullptr, 0), NNFW_STATUS_UNEXPECTED_NULL);
 240
 241   // buffer is too small
 242   ASSERT_EQ(nnfw_get_config(_session, "EXECUTOR", buf, 1), NNFW_STATUS_ERROR);
 243   ASSERT_EQ(nnfw_get_config(_session, "BACKENDS", buf, 1), NNFW_STATUS_ERROR);
 244
 245   // wrong keys
 246   ASSERT_EQ(nnfw_get_config(_session, "", buf, sizeof(buf)), NNFW_STATUS_ERROR);
 247   ASSERT_EQ(nnfw_get_config(_session, "BAD_KEY", buf, sizeof(buf)), NNFW_STATUS_ERROR);
 248 }