1  /*
2   * Copyright (C) 2022 The Android Open Source Project
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 <gtest/gtest.h>
18  #include <nnapi/TypeUtils.h>
19  #include <nnapi/Types.h>
20  
21  #include "ServerFlag.h"
22  
23  using android::nn::GetServerConfigurableFlagFunc;
24  using android::nn::getServerFeatureLevelFlag;
25  using android::nn::getServerTelemetryEnableFlag;
26  using android::nn::kDefaultFeatureLevelNum;
27  using android::nn::kDefaultTelemetryEnableValue;
28  using android::nn::kMaxFeatureLevelNum;
29  using android::nn::kMinFeatureLevelNum;
30  using android::nn::kVersionFeatureLevel5;
31  using android::nn::kVersionFeatureLevel6;
32  using android::nn::kVersionFeatureLevel7;
33  using android::nn::kVersionFeatureLevel8;
34  using android::nn::serverFeatureLevelToVersion;
35  
fakeServerFuncDefault(const std::string &,const std::string &,const std::string &)36  static std::string fakeServerFuncDefault(const std::string& /*categoryName*/,
37                                           const std::string& /*flagName*/,
38                                           const std::string& /*defaultValue*/) {
39      return std::to_string(kDefaultFeatureLevelNum);
40  }
41  
fakeServerFuncMax(const std::string &,const std::string &,const std::string &)42  static std::string fakeServerFuncMax(const std::string& /*categoryName*/,
43                                       const std::string& /*flagName*/,
44                                       const std::string& /*defaultValue*/) {
45      return std::to_string(kMaxFeatureLevelNum);
46  }
47  
fakeServerFuncMin(const std::string &,const std::string &,const std::string &)48  static std::string fakeServerFuncMin(const std::string& /*categoryName*/,
49                                       const std::string& /*flagName*/,
50                                       const std::string& /*defaultValue*/) {
51      return std::to_string(kMinFeatureLevelNum);
52  }
53  
fakeServerFuncLarge(const std::string &,const std::string &,const std::string &)54  static std::string fakeServerFuncLarge(const std::string& /*categoryName*/,
55                                         const std::string& /*flagName*/,
56                                         const std::string& /*defaultValue*/) {
57      return std::to_string(kMaxFeatureLevelNum + 1);
58  }
59  
fakeServerFuncSmall(const std::string &,const std::string &,const std::string &)60  static std::string fakeServerFuncSmall(const std::string& /*categoryName*/,
61                                         const std::string& /*flagName*/,
62                                         const std::string& /*defaultValue*/) {
63      return std::to_string(kMinFeatureLevelNum - 1);
64  }
65  
fakeServerFuncNull(const std::string &,const std::string &,const std::string &)66  static std::string fakeServerFuncNull(const std::string& /*categoryName*/,
67                                        const std::string& /*flagName*/,
68                                        const std::string& /*defaultValue*/) {
69      return "null";
70  }
71  
fakeServerTelemetryFuncDefault(const std::string &,const std::string &,const std::string &)72  static std::string fakeServerTelemetryFuncDefault(const std::string& /*categoryName*/,
73                                                    const std::string& /*flagName*/,
74                                                    const std::string& /*defaultValue*/) {
75      return std::to_string(kDefaultTelemetryEnableValue);
76  }
77  
fakeServerTelemetryFuncInvalid(const std::string &,const std::string &,const std::string &)78  static std::string fakeServerTelemetryFuncInvalid(const std::string& /*categoryName*/,
79                                                    const std::string& /*flagName*/,
80                                                    const std::string& /*defaultValue*/) {
81      return "not_a_bool";
82  }
83  
fakeServerTelemetryFuncNull(const std::string &,const std::string &,const std::string &)84  static std::string fakeServerTelemetryFuncNull(const std::string& /*categoryName*/,
85                                                 const std::string& /*flagName*/,
86                                                 const std::string& /*defaultValue*/) {
87      return "null";
88  }
89  
TEST(ServerFlagTest,ServerFeatureLevelFlag)90  TEST(ServerFlagTest, ServerFeatureLevelFlag) {
91      // Tests android::nn::getServerFeatureLevelFlag directly because
92      // feature level is stored as static variable in runtime so that the value does not change if
93      // uses client APIs.
94  
95      // Tests correct value is returned if the flag is set legally.
96      EXPECT_EQ(getServerFeatureLevelFlag(fakeServerFuncDefault), kDefaultFeatureLevelNum);
97      EXPECT_EQ(getServerFeatureLevelFlag(fakeServerFuncMax), kMaxFeatureLevelNum);
98      EXPECT_EQ(getServerFeatureLevelFlag(fakeServerFuncMin), kMinFeatureLevelNum);
99  
100      // Tests default value is returned if the flag is unset or illegal.
101      EXPECT_EQ(getServerFeatureLevelFlag(fakeServerFuncLarge), kDefaultFeatureLevelNum);
102      EXPECT_EQ(getServerFeatureLevelFlag(fakeServerFuncSmall), kDefaultFeatureLevelNum);
103      EXPECT_EQ(getServerFeatureLevelFlag(fakeServerFuncNull), kDefaultFeatureLevelNum);
104  }
105  
TEST(ServerFlagTest,ServerFeatureLevelToVersion)106  TEST(ServerFlagTest, ServerFeatureLevelToVersion) {
107      EXPECT_EQ(serverFeatureLevelToVersion(5), kVersionFeatureLevel5);
108      EXPECT_EQ(serverFeatureLevelToVersion(6), kVersionFeatureLevel6);
109      EXPECT_EQ(serverFeatureLevelToVersion(7), kVersionFeatureLevel7);
110      EXPECT_EQ(serverFeatureLevelToVersion(8), kVersionFeatureLevel8);
111  
112      EXPECT_EQ(serverFeatureLevelToVersion(kMinFeatureLevelNum), kVersionFeatureLevel8);
113      EXPECT_EQ(serverFeatureLevelToVersion(kDefaultFeatureLevelNum), kVersionFeatureLevel8);
114      EXPECT_EQ(serverFeatureLevelToVersion(kMaxFeatureLevelNum), kVersionFeatureLevel8);
115  }
116  
makeFuncWithReturn(std::string ret)117  static GetServerConfigurableFlagFunc makeFuncWithReturn(std::string ret) {
118      return [ret = std::move(ret)](const std::string&, const std::string&,
119                                    const std::string&) -> std::string { return ret; };
120  }
121  
TEST(ServerFlagTest,ServerTelemetryEnableFlag)122  TEST(ServerFlagTest, ServerTelemetryEnableFlag) {
123      // Tests android::nn::getServerTelemetryEnableFlag directly because whether or not telemetry is
124      // enabled is stored as static variable in runtime so that the value does not change if uses
125      // client APIs.
126  
127      // Tests correct value is returned if the flag is set legally.
128      EXPECT_EQ(getServerTelemetryEnableFlag(fakeServerTelemetryFuncDefault),
129                kDefaultTelemetryEnableValue);
130  
131      const std::vector<std::string> kPossibleTrueStrings = {"1", "on", "true", "y", "yes"};
132      for (const auto& trueString : kPossibleTrueStrings) {
133          GetServerConfigurableFlagFunc fn = makeFuncWithReturn(trueString);
134          EXPECT_EQ(getServerTelemetryEnableFlag(fn), true);
135      }
136  
137      const std::vector<std::string> kPossibleFalseStrings = {"0", "false", "n", "no", "off"};
138      for (const auto& falseString : kPossibleFalseStrings) {
139          GetServerConfigurableFlagFunc fn = makeFuncWithReturn(falseString);
140          EXPECT_EQ(getServerTelemetryEnableFlag(fn), false);
141      }
142  
143      // Tests default value is returned if the flag is unset or illegal.
144      EXPECT_EQ(getServerTelemetryEnableFlag(fakeServerTelemetryFuncInvalid),
145                kDefaultTelemetryEnableValue);
146      EXPECT_EQ(getServerTelemetryEnableFlag(fakeServerTelemetryFuncNull),
147                kDefaultTelemetryEnableValue);
148  }
149