1 //
2 // Copyright (C) 2016 Google, Inc.
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 <base.h>
18 #include <base/logging.h>
19 #include <rapidjson/document.h>
20 #include <rapidjson/writer.h>
21 #include <rapidjson/stringbuffer.h>
22 #include "test_facade.h"
23 #include <tuple>
24 #include <utils/command_receiver.h>
25 #include <utils/common_utils.h>
26
TestBoolTrueReturn()27 std::tuple<bool, int> TestFacade::TestBoolTrueReturn() {
28 return std::make_tuple(true, sl4n_error_codes::kPassInt);
29 }
30
TestBoolFalseReturn()31 std::tuple<bool, int> TestFacade::TestBoolFalseReturn() {
32 return std::make_tuple(false, sl4n_error_codes::kPassInt);
33 }
34
TestErrorCodeFail()35 std::tuple<bool, int> TestFacade::TestErrorCodeFail() {
36 return std::make_tuple(true, sl4n_error_codes::kFailInt);
37 }
38
TestNullReturn()39 std::tuple<int, int> TestFacade::TestNullReturn() {
40 return std::make_tuple(NULL, sl4n_error_codes::kPassInt);
41 }
42
TestStringEmptyReturn()43 std::tuple<std::string, int> TestFacade::TestStringEmptyReturn() {
44 return std::make_tuple("", sl4n_error_codes::kPassInt);
45 }
46
TestStringMaxReturn(std::string max_string)47 std::tuple<std::string, int> TestFacade::TestStringMaxReturn(
48 std::string max_string) {
49
50 return std::make_tuple(max_string, sl4n_error_codes::kPassInt);
51 }
52
TestSpecificParamNaming(std::string test_string,int test_int)53 std::tuple<bool, int> TestFacade::TestSpecificParamNaming(
54 std::string test_string, int test_int) {
55
56 return std::make_tuple(true, sl4n_error_codes::kPassInt);
57 }
58
59 //////////////////
60 // wrappers
61 //////////////////
62
63 static TestFacade facade; // triggers registration with CommandReceiver
64
test_bool_true_return_wrapper(rapidjson::Document & doc)65 void test_bool_true_return_wrapper(rapidjson::Document &doc) {
66 int expected_param_size = 0;
67 if (!CommonUtils::IsParamLengthMatching(doc, expected_param_size)) {
68 return;
69 }
70 bool result;
71 int error_code;
72 std::tie(result, error_code) = facade.TestBoolTrueReturn();
73 if (error_code == sl4n_error_codes::kFailInt) {
74 doc.AddMember(sl4n::kResultStr, false, doc.GetAllocator());
75 doc.AddMember(sl4n::kErrorStr, sl4n::kFailStr, doc.GetAllocator());
76 } else {
77 doc.AddMember(sl4n::kResultStr, result, doc.GetAllocator());
78 doc.AddMember(sl4n::kErrorStr, NULL, doc.GetAllocator());
79 }
80 }
81
test_bool_false_return_wrapper(rapidjson::Document & doc)82 void test_bool_false_return_wrapper(rapidjson::Document &doc) {
83 int expected_param_size = 0;
84 if (!CommonUtils::IsParamLengthMatching(doc, expected_param_size)) {
85 return;
86 }
87 int result;
88 int error_code;
89 std::tie(result, error_code) = facade.TestBoolFalseReturn();
90 if (error_code == sl4n_error_codes::kFailInt) {
91 doc.AddMember(sl4n::kResultStr, false, doc.GetAllocator());
92 doc.AddMember(sl4n::kErrorStr, sl4n::kFailStr, doc.GetAllocator());
93 } else {
94 doc.AddMember(sl4n::kResultStr, result, doc.GetAllocator());
95 doc.AddMember(sl4n::kErrorStr, NULL, doc.GetAllocator());
96 }
97 }
98
test_null_return_wrapper(rapidjson::Document & doc)99 void test_null_return_wrapper(rapidjson::Document &doc) {
100 int expected_param_size = 0;
101 if (!CommonUtils::IsParamLengthMatching(doc, expected_param_size)) {
102 return;
103 }
104 int result;
105 int error_code;
106 std::tie(result, error_code) = facade.TestNullReturn();
107 if (error_code == sl4n_error_codes::kFailInt) {
108 doc.AddMember(sl4n::kResultStr, false, doc.GetAllocator());
109 doc.AddMember(sl4n::kErrorStr, sl4n::kFailStr, doc.GetAllocator());
110 } else {
111 doc.AddMember(sl4n::kResultStr, result, doc.GetAllocator());
112 doc.AddMember(sl4n::kErrorStr, NULL, doc.GetAllocator());
113 }
114 }
115
test_string_empty_return_wrapper(rapidjson::Document & doc)116 void test_string_empty_return_wrapper(rapidjson::Document &doc) {
117 int expected_param_size = 0;
118 if (!CommonUtils::IsParamLengthMatching(doc, expected_param_size)) {
119 return;
120 }
121 std::string result;
122 int error_code;
123 std::tie(result, error_code) = facade.TestStringEmptyReturn();
124 if (error_code == sl4n_error_codes::kFailInt) {
125 doc.AddMember(sl4n::kResultStr, false, doc.GetAllocator());
126 doc.AddMember(sl4n::kErrorStr, sl4n::kFailStr, doc.GetAllocator());
127 } else {
128 rapidjson::Value tmp;
129 tmp.SetString(result.c_str(), doc.GetAllocator());
130 doc.AddMember(sl4n::kResultStr, tmp, doc.GetAllocator());
131 doc.AddMember(sl4n::kErrorStr, NULL, doc.GetAllocator());
132 }
133 }
134
test_string_max_return_wrapper(rapidjson::Document & doc)135 void test_string_max_return_wrapper(rapidjson::Document &doc) {
136 int expected_param_size = 1;
137 if (!CommonUtils::IsParamLengthMatching(doc, expected_param_size)) {
138 return;
139 }
140 std::string max_string;
141 if (!doc[sl4n::kParamsStr][0].IsString()) {
142 LOG(ERROR) << sl4n::kTagStr << ": Expected String input for name";
143 doc.AddMember(sl4n::kResultStr, false, doc.GetAllocator());
144 doc.AddMember(sl4n::kErrorStr, sl4n::kFailStr, doc.GetAllocator());
145 return;
146 } else {
147 max_string = doc[sl4n::kParamsStr][0].GetString();
148 }
149 std::string result;
150 int error_code;
151 std::tie(result, error_code) = facade.TestStringMaxReturn(max_string);
152 if (error_code == sl4n_error_codes::kFailInt) {
153 doc.AddMember(sl4n::kResultStr, false, doc.GetAllocator());
154 doc.AddMember(sl4n::kErrorStr, sl4n::kFailStr, doc.GetAllocator());
155 } else {
156 rapidjson::Value tmp;
157 tmp.SetString(result.c_str(), doc.GetAllocator());
158 doc.AddMember(sl4n::kResultStr, tmp, doc.GetAllocator());
159 doc.AddMember(sl4n::kErrorStr, NULL, doc.GetAllocator());
160 }
161 }
162
test_specific_param_naming_wrapper(rapidjson::Document & doc)163 void test_specific_param_naming_wrapper(rapidjson::Document &doc) {
164 int expected_param_size = 1;
165 if (!CommonUtils::IsParamLengthMatching(doc, expected_param_size)) {
166 return;
167 }
168 std::string string_test;
169 int int_test;
170 std::string string_member = "string_test";
171 std::string int_member = "int_test";
172 if (!doc[sl4n::kParamsStr][0][0].HasMember(string_member.c_str())) {
173 LOG(ERROR) << sl4n::kTagStr << ": Expected member " << string_member;
174 doc.AddMember(sl4n::kResultStr, false, doc.GetAllocator());
175 doc.AddMember(sl4n::kErrorStr, sl4n::kFailStr, doc.GetAllocator());
176 return;
177 } else {
178 if (!doc[sl4n::kParamsStr][0][0][string_member.c_str()].IsString()) {
179 LOG(ERROR) << sl4n::kTagStr << ": Expected String input for "
180 << string_member;
181 doc.AddMember(sl4n::kResultStr, false, doc.GetAllocator());
182 doc.AddMember(sl4n::kErrorStr, sl4n::kFailStr, doc.GetAllocator());
183 return;
184 }
185 string_test = doc[sl4n::kParamsStr][0][0][string_member.c_str()].GetString();
186 }
187 if (!doc[sl4n::kParamsStr][0][0].HasMember(int_member.c_str())) {
188 LOG(ERROR) << sl4n::kTagStr << ": Expected member " << int_member;
189 doc.AddMember(sl4n::kResultStr, false, doc.GetAllocator());
190 doc.AddMember(sl4n::kErrorStr, sl4n::kFailStr, doc.GetAllocator());
191 return;
192 } else {
193 if (!doc[sl4n::kParamsStr][0][0][int_member.c_str()].IsInt()) {
194 LOG(ERROR) << sl4n::kTagStr << ": Expected Int input for "
195 << int_member;
196 doc.AddMember(sl4n::kResultStr, false, doc.GetAllocator());
197 doc.AddMember(sl4n::kErrorStr, sl4n::kFailStr, doc.GetAllocator());
198 return;
199 }
200 int_test = doc[sl4n::kParamsStr][0][0][int_member.c_str()].GetInt();
201 }
202 bool result;
203 int error_code;
204 std::tie(result, error_code) = facade.TestSpecificParamNaming(
205 string_test, int_test);
206 if (error_code == sl4n_error_codes::kFailInt) {
207 doc.AddMember(sl4n::kResultStr, false, doc.GetAllocator());
208 doc.AddMember(sl4n::kErrorStr, sl4n::kFailStr, doc.GetAllocator());
209 } else {
210 doc.AddMember(sl4n::kResultStr, result, doc.GetAllocator());
211 doc.AddMember(sl4n::kErrorStr, NULL, doc.GetAllocator());
212 }
213 }
214
215 ////////////////
216 // constructor
217 ////////////////
218
TestFacade()219 TestFacade::TestFacade() {
220
221 CommandReceiver::RegisterCommand("TestBoolTrueReturn",
222 &test_bool_true_return_wrapper);
223 CommandReceiver::RegisterCommand("TestBoolFalseReturn",
224 &test_bool_false_return_wrapper);
225 CommandReceiver::RegisterCommand("TestNullReturn",
226 &test_null_return_wrapper);
227 CommandReceiver::RegisterCommand("TestStringEmptyReturn",
228 &test_string_empty_return_wrapper);
229 CommandReceiver::RegisterCommand("TestStringMaxReturn",
230 &test_string_max_return_wrapper);
231 CommandReceiver::RegisterCommand("TestSpecificParamNaming",
232 &test_specific_param_naming_wrapper);
233 }
234
235