Merge test folder of test branch
[iotivity.git] / test / src / tc / pm / gtest / cpp / src / helper / PMCppUtilityHelper.cpp
1 /******************************************************************
2  *
3  * Copyright 2016 Samsung Electronics All Rights Reserved.
4  *
5  *
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  *      LICENSE-2.0" target="_blank">http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  *
19  *
20  ******************************************************************/
21
22 #include "PMCppHelper.h"
23 #include "PMCppUtilityHelper.h"
24
25 bool PMCppUtilityHelper::readFile(const char *name, OCByteString *out)
26 {
27     FILE *file = NULL;
28     int length = 0;
29     uint8_t *buffer = NULL;
30     bool result = false;
31     size_t count, realCount;
32     //Open file
33     file = fopen(name, "rb");
34     if (!file)
35     {
36         OIC_LOG_V(ERROR, TAG, "Unable to open file %s", name);
37         return result;
38     }
39
40     //Get file length
41     if (fseek(file, 0, SEEK_END))
42     {
43         OIC_LOG(ERROR, TAG, "Failed to SEEK_END");
44         goto exit;
45     }
46
47     length = ftell(file);
48     if (length < 0)
49     {
50         OIC_LOG(ERROR, TAG, "Failed to ftell");
51         goto exit;
52     }
53
54     if (fseek(file, 0, SEEK_SET))
55     {
56         OIC_LOG(ERROR, TAG, "Failed to SEEK_SET");
57         goto exit;
58     }
59
60     //Allocate memory
61     buffer = (uint8_t *) malloc(length);
62     if (!buffer)
63     {
64         OIC_LOG(ERROR, TAG, "Failed to allocate buffer");
65         goto exit;
66     }
67
68     //Read file contents into buffer
69     count = 1;
70     realCount = fread(buffer, length, count, file);
71     if (realCount != count)
72     {
73         OIC_LOG_V(ERROR, TAG, "Read %d bytes %zu times instead of %zu", length, realCount, count);
74         goto exit;
75     }
76
77     out->bytes = buffer;
78     out->len = length;
79
80     result = true;
81     exit: fclose(file);
82     return result;
83 }
84
85 void PMCppUtilityHelper::printDevices(DeviceList_t &list)
86 {
87     for (unsigned int i = 0; i < list.size(); i++)
88     {
89         std::cout << "Device " << i + 1 << " ID: ";
90         std::cout << list[i]->getDeviceID() << " From IP: ";
91         std::cout << list[i]->getDevAddr() << " Device Status(On/ Off) ";
92         std::cout << list[i]->getDeviceStatus() << " Owned Status: ";
93         std::cout << list[i]->getOwnedStatus() << std::endl;
94     }
95 }
96
97 char* PMCppUtilityHelper::getOxmType(OicSecOxm_t oxmType)
98 {
99
100     char* resultString = NULL;
101
102     switch (oxmType)
103     {
104         case OIC_JUST_WORKS:
105             resultString = (char*) "OIC_JUST_WORKS";
106             break;
107         case OIC_RANDOM_DEVICE_PIN:
108             resultString = (char*) "OIC_RANDOM_DEVICE_PIN";
109             break;
110         case OIC_MANUFACTURER_CERTIFICATE:
111             resultString = (char*) "OIC_MANUFACTURER_CERTIFICATE";
112             break;
113         case OIC_DECENTRALIZED_PUBLIC_KEY:
114             resultString = (char*) "OIC_DECENTRALIZED_PUBLIC_KEY";
115             break;
116         case OIC_OXM_COUNT:
117             resultString = (char*) "OIC_OXM_COUNT";
118             break;
119         case OIC_PRECONFIG_PIN:
120             resultString = (char*) "OIC_PRECONFIG_PIN";
121             break;
122         case OIC_MV_JUST_WORKS:
123             resultString = (char*) "OC_STACK_RESOURCE_CREATED";
124             break;
125         case OIC_CON_MFG_CERT:
126             resultString = (char*) "OIC_CON_MFG_CERT";
127             break;
128         default:
129             resultString = (char*) "UNKNOWN_OXM_TYPE";
130     }
131
132     return resultString;
133 }
134
135 void PMCppUtilityHelper::printUuid(OicUuid_t uuid)
136 {
137     for (int i = 0; i < UUID_LENGTH; i++)
138     {
139         std::cout << std::hex << uuid.id[i] << " ";
140     }
141     std::cout << std::endl;
142 }
143
144 void PMCppUtilityHelper::removeAllResFile()
145 {
146     CommonUtil::rmFile(JUSTWORKS_SERVER1_CBOR);
147     CommonUtil::rmFile(JUSTWORKS_SERVER2_CBOR);
148     CommonUtil::rmFile(RANDOMPIN_SERVER_CBOR);
149     CommonUtil::rmFile(PRECONFIG_SERVER1_CBOR);
150     CommonUtil::rmFile(PRECONFIG_SERVER2_CBOR);
151     CommonUtil::rmFile(JUSTWORKS_SERVER7_CBOR);
152     CommonUtil::rmFile(MV_JUSTWORKS_SERVER_CBOR);
153
154     CommonUtil::rmFile(CLIENT_DATABASE);
155     CommonUtil::rmFile(CLIENT_CBOR);
156
157     CommonUtil::rmFile(MOT_CLIENT_DATABASE);
158     CommonUtil::rmFile(MOT_CLIENT_CBOR);
159
160     CommonUtil::rmFile(DEVICE_PROPERTIES);
161
162     CommonUtil::rmFile(ROOT_CERT_FILE_TMP);
163 }
164
165 OCProvisionDev_t* PMCppUtilityHelper::getDevInst(OCProvisionDev_t* dev_lst, const int dev_num)
166 {
167     IOTIVITYTEST_LOG(DEBUG, "[PMHelper] getDevInst IN");
168
169     if (!dev_lst || 0 >= dev_num)
170     {
171         IOTIVITYTEST_LOG(ERROR, "[PMHelper] Device List is Empty");
172         return NULL;
173     }
174
175     OCProvisionDev_t* lst = (OCProvisionDev_t*) dev_lst;
176
177     for (int i = 0; lst;)
178     {
179         if (dev_num == ++i)
180         {
181             IOTIVITYTEST_LOG(DEBUG, "[PMHelper] getDevInst OUT");
182             return lst;
183         }
184         lst = lst->next;
185     }
186
187     IOTIVITYTEST_LOG(DEBUG, "[PMHelper] getDevInst OUT");
188     return NULL; // in here |lst| is always |NULL|
189 }
190
191 int PMCppUtilityHelper::printDevList(OCProvisionDev_t* dev_lst)
192 {
193     IOTIVITYTEST_LOG(DEBUG, "[PMHelper] printDevList IN");
194
195     if (!dev_lst)
196     {
197         IOTIVITYTEST_LOG(INFO, "[PMHelper] Device List is Empty...");
198         return 0;
199     }
200
201     OCProvisionDev_t* lst = (OCProvisionDev_t*) dev_lst;
202     int lst_cnt = 0;
203
204     for (; lst;)
205     {
206         printf("     [%d] ", ++lst_cnt);
207         printUuid((const OicUuid_t*) &lst->doxm->deviceID);
208         printf("\n");
209         lst = lst->next;
210     }
211     printf("\n");
212
213     IOTIVITYTEST_LOG(DEBUG, "[PMHelper] printDevList OUT");
214     return lst_cnt;
215 }
216
217 size_t PMCppUtilityHelper::printUuidList(const OCUuidList_t* uid_lst)
218 {
219     IOTIVITYTEST_LOG(DEBUG, "[PMHelper] printUuidList IN");
220
221     if (!uid_lst)
222     {
223         IOTIVITYTEST_LOG(INFO, "[PMHelper] Device List is Empty...");
224         return 0;
225     }
226
227     OCUuidList_t* lst = (OCUuidList_t*) uid_lst;
228     size_t lst_cnt = 0;
229
230     for (; lst;)
231     {
232         printf("     [%zu] ", ++lst_cnt);
233         printUuid((const OicUuid_t*) &lst->dev);
234         printf("\n");
235         lst = lst->next;
236     }
237     printf("\n");
238
239     IOTIVITYTEST_LOG(DEBUG, "[PMHelper] printUuidList OUT");
240     return lst_cnt;
241 }
242
243 int PMCppUtilityHelper::printResultList(const OCProvisionResult_t* rslt_lst, const int rslt_cnt)
244 {
245     IOTIVITYTEST_LOG(DEBUG, "[PMHelper] printResultList IN");
246
247     if (!rslt_lst || 0 >= rslt_cnt)
248     {
249         IOTIVITYTEST_LOG(INFO, "[PMHelper] Device List is Empty...");
250         return 0;
251     }
252
253     int lst_cnt = 0;
254     for (; rslt_cnt > lst_cnt; ++lst_cnt)
255     {
256         printf("     [%d] ", lst_cnt + 1);
257         printUuid((const OicUuid_t*) &rslt_lst[lst_cnt].deviceId);
258         printf(" - result: %s\n", CommonUtil::getOCStackResult(rslt_lst[lst_cnt].res));
259     }
260     printf("\n");
261
262     IOTIVITYTEST_LOG(INFO, "[PMHelper] printResultList IN");
263     return lst_cnt;
264 }
265
266 void PMCppUtilityHelper::printUuid(const OicUuid_t* uid)
267 {
268     IOTIVITYTEST_LOG(DEBUG, "[PMHelper] printUuid IN");
269
270     for (int i = 0; i < UUID_LENGTH;)
271     {
272         printf("%02X", (*uid).id[i++]);
273         if (i == 4 || i == 6 || i == 8 || i == 10) // canonical format for UUID has '8-4-4-4-12'
274         {
275             printf("%c", DASH);
276         }
277     }
278     printf("\n");
279
280     IOTIVITYTEST_LOG(DEBUG, "[PMHelper] printUuid OUT");
281 }
282
283 /**
284  * Function to set failure message
285  */
286 std::string PMCppUtilityHelper::setFailureMessage(OCStackResult expectedResult,
287         OCStackResult actualResult)
288 {
289     std::string errorMessage("\033[1;31m[Error] Expected : ");
290     errorMessage.append(CommonUtil::getOCStackResult(expectedResult));
291     errorMessage.append("\033[0m  \033[1;31mActual : ");
292     errorMessage.append(CommonUtil::getOCStackResult(actualResult));
293     errorMessage.append("\033[0m");
294     return errorMessage;
295 }
296
297 /**
298  * Function to set failure message
299  */
300 std::string PMCppUtilityHelper::setFailureMessage(OicSecOxm_t expectedResult,
301         OicSecOxm_t actualResult)
302 {
303     std::string errorMessage("\033[1;31m[Error] Expected : ");
304     errorMessage.append(PMCppUtilityHelper::getOxmType(expectedResult));
305     errorMessage.append("\033[0m  \033[1;31mActual : ");
306     errorMessage.append(PMCppUtilityHelper::getOxmType(actualResult));
307     errorMessage.append("\033[0m");
308     return errorMessage;
309 }
310
311 /**
312  * Function to set failure message
313  */
314 std::string PMCppUtilityHelper::setFailureMessage(std::string errorMessage)
315 {
316     std::string retErrorMessage("\033[1;31m[Error] Expected : ");
317     retErrorMessage.append(errorMessage);
318     retErrorMessage.append("\033[0m");
319
320     return retErrorMessage;
321 }
322