Merge test folder of test branch
[iotivity.git] / test / src / tc / re / gtest / src / btc / REResourceBrokerTest.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 //      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 #include <string>
22 #include "gtest/gtest.h"
23 #include "REHelper.h"
24
25 class REResourceBrokerTest_btc: public ::testing::Test
26 {
27 protected:
28
29     REHelper* m_pREHelper;
30     std::string m_errorMsg;
31     shared_ptr< OIC::Service::RCSRemoteResourceObject > m_resource;
32
33     virtual void SetUp()
34     {
35         CommonTestUtil::runCommonTCSetUpPart();
36
37         CommonUtil::launchApp(RE_SERVER_APP);
38         CommonUtil::waitInSecond(CALLBACK_WAIT_MAX);
39
40         m_pREHelper = REHelper::getInstance();
41         bool isResourceAvailable = m_pREHelper->findPrimitiveResources(RESOURCE_TYPE_LIGHT);
42
43         if (isResourceAvailable)
44         {
45             m_resource = m_pREHelper->getFoundResourceList().at(0);
46         }
47         else
48         {
49             SET_FAILURE("Precondition Failed, No Resource Found!!");
50         }
51         m_errorMsg = "";
52     }
53
54     virtual void TearDown()
55     {
56         CommonUtil::killApp(RE_SERVER_APP);
57         CommonUtil::waitInSecond(CALLBACK_WAIT_MAX);
58         CommonTestUtil::runCommonTCTearDownPart();
59     }
60
61 public:
62     void onStateChangeReceived(ResourceState resourceState)
63     {
64
65     }
66
67 };
68
69 /**
70  * @since 2015-06-30
71  * @see None
72  * @objective Test 'startMonitoring' function with positive basic way
73  * @target void startMonitoring(StateChangedCallback cb);
74  * @test_data callback function for receiving changed state
75  * @pre_condition Remote Resource Object should be instantialized
76  * @procedure Perform startMonitoring() API
77  * @post_condition None
78  * @expected The API should not generate any exception
79  **/
80 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
81 TEST_F(REResourceBrokerTest_btc, startMonitoring_SRC_P)
82 {
83     try
84     {
85         m_resource->startMonitoring(
86                 std::bind(&REResourceBrokerTest_btc::onStateChangeReceived, this, PH::_1));
87     }
88     catch (exception& e)
89     {
90         SET_FAILURE("Exception occurred inside StartMonitoring_SRC_P" + std::string(e.what()));
91     }
92 }
93 #endif
94
95 /**
96  * @since 2016-02-22
97  * @see None
98  * @objective Test 'startMonitoring' function with negative basic way
99  * @target void startMonitoring(ResourceStateChangedCallback callback)
100  * @test_data NULL
101  * @pre_condition Remote Resource Object should be instantialized
102  * @procedure Perform startMonitoring() API with NULL Cb
103  * @post_condition None
104  * @expected The API should not generate any exception
105  **/
106 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
107 TEST_F(REResourceBrokerTest_btc, startMonitoring_NV_N)
108 {
109     try
110     {
111         m_resource->startMonitoring(NULL);
112     }
113     catch (exception& e)
114     {
115         string exceptionMsg = string(e.what());
116
117         if (exceptionMsg != "startMonitoring : Callback is NULL")
118         {
119             SET_FAILURE("Exception occurred while startMonitoring, exception is: " + exceptionMsg);
120         }
121
122     }
123 }
124 #endif
125
126 /**
127  * @since 2015-06-30
128  * @see void startMonitoring(StateChangedCallback cb);
129  * @objective Test 'StopMonitoring' function with positive basic way
130  * @target void stopMonitoring();
131  * @test_data callback function for receiving changed state
132  * @pre_condition Remote Resource Object should be instantialized
133  * @procedure 1. Perform startMonitoring() API
134  *            2. Perform stopMonitoring() API
135  * @post_condition None
136  * @expected The API should not generate any exception
137  **/
138 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
139 TEST_F(REResourceBrokerTest_btc, stopMonitoring_SRC_P)
140 {
141     try
142     {
143         m_resource->startMonitoring(
144                 std::bind(&REResourceBrokerTest_btc::onStateChangeReceived, this, PH::_1));
145
146         CommonUtil::waitInSecond(CALLBACK_WAIT_MIN);
147         m_resource->stopMonitoring();
148     }
149     catch (exception& e)
150     {
151         SET_FAILURE("Exception occurred inside stopMonitoring_SRC_P" + std::string(e.what()));
152     }
153 }
154 #endif
155
156 /**
157  * @since 2015-06-30
158  * @see None
159  * @objective Test 'stopMonitoring' function with negative basic way
160  * @target void stopMonitoring()
161  * @test_data callback function for receiving changed state
162  * @pre_condition Remote Resource Object should be instantialized
163  * @procedure Perform stopMonitoring() API without startMonitoring() API
164  * @post_condition None
165  * @expected No crash should occur
166  **/
167 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
168 TEST_F(REResourceBrokerTest_btc, stopMonitoring_ECRC_N)
169 {
170     try
171     {
172         m_resource->stopMonitoring();
173     }
174     catch (exception& e)
175     {
176         SET_FAILURE("Exception occurred inside StopWatching_ECRC_N" + std::string(e.what()));
177     }
178 }
179 #endif
180
181 /**
182  * @since 2016-02-22
183  * @see None
184  * @objective Test 'startCaching' function with positive basic way
185  * @target void startCaching()
186  * @test_data None
187  * @pre_condition Remote Resource Object should be instantialized
188  * @procedure Perform startCaching() API
189  * @post_condition None
190  * @expected No crash should occur
191  **/
192 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
193 TEST_F(REResourceBrokerTest_btc, StartCaching_SRC_P)
194 {
195     try
196     {
197         m_resource->startCaching();
198     }
199     catch (exception& e)
200     {
201         SET_FAILURE("Exception occurred inside StartCatching_SRC_P" + std::string(e.what()));
202     }
203 }
204 #endif
205
206 /**
207  * @since 2016-02-22
208  * @see None
209  * @objective Test 'stopCaching' function with positive basic way
210  * @target void stopCaching()
211  * @test_data None
212  * @pre_condition Remote Resource Object should be instantialized
213  * @procedure Perform stopCaching() API
214  * @post_condition None
215  * @expected No crash should occur
216  **/
217 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
218 TEST_F(REResourceBrokerTest_btc, StopCaching_SRC_P)
219 {
220     try
221     {
222         m_resource->stopCaching();
223     }
224     catch (exception& e)
225     {
226         SET_FAILURE("Exception occurred inside StopCatching_SRC_P" + std::string(e.what()));
227     }
228 }
229 #endif
230
231 /**
232  * @since 2016-02-22
233  * @see startCaching()
234  * @objective Test 'isCaching' function with positive basic way
235  * @target bool isCaching() const;
236  * @test_data None
237  * @pre_condition Remote Resource Object should be instantialized
238  * @procedure Perform isCaching() API
239  * @post_condition None
240  * @expected No crash occurs
241  **/
242 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
243 TEST_F(REResourceBrokerTest_btc, IsCaching_SRC_P)
244 {
245     m_resource->startCaching();
246
247     bool isC = m_resource->isCaching();
248
249     if (isC == false)
250     {
251         SET_FAILURE("Fail to get cache state !");
252     }
253 }
254 #endif 
255
256 /**
257  * @since 2016-02-22
258  * @see startCaching()
259  * @objective Test 'isCaching' function with positive basic way
260  * @target bool isCaching() const;
261  * @test_data None
262  * @pre_condition Remote Resource Object should be instantialized
263  * @procedure Perform isCaching() API
264  * @post_condition None
265  * @expected No crash occurs
266  **/
267 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
268 TEST_F(REResourceBrokerTest_btc, IsCaching_SRCC_P)
269 {
270
271     bool isC = m_resource->isCaching();
272
273     if (isC == true)
274     {
275         SET_FAILURE("Fail to get cache state!");
276     }
277 }
278 #endif 
279
280 /**
281  * @since 2015-07-01
282  * @see startMonitoring
283  * @objective Test 'GetState' function with positive basic way
284  * @target ResourceState getState() const;
285  * @test_data None
286  * @pre_condition Remote Resource Object should be instantialized
287  * @procedure Perform GetState() API
288  * @post_condition None
289  * @expected No crash should occur
290  **/
291 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
292 TEST_F(REResourceBrokerTest_btc, GetState_SRC_P)
293 {
294     ResourceState resourceState = m_resource->getState();
295
296     if ((int) resourceState < 0 || (int) resourceState > 3)
297     {
298         SET_FAILURE("Failed to get state");
299     }
300
301 }
302 #endif
303
304 /**
305  * @since 2016-02-19
306  * @see startMonitoring
307  * @objective Test 'GetState' function with positive basic way
308  * @target ResourceState getState() const;
309  * @test_data None
310  * @pre_condition Remote Resource Object should be instantialized
311  * @procedure Perform GetState() API
312  * @post_condition None
313  * @expected No crash should occur
314  **/
315 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
316 TEST_F(REResourceBrokerTest_btc, GetState_SRCC_P)
317 {
318     ResourceState resourceState = m_resource->getState();
319
320     if (int(resourceState) != 0)
321     {
322         SET_FAILURE("Failed to get state");
323     }
324
325 }
326 #endif
327
328 /**
329  * @since 2016-02-19
330  * @see startMonitoring()
331  * @objective Test 'isMonitoring' function with positive basic way
332  * @target bool isMonitoring()
333  * @test_data callback function for receiving changed state
334  * @pre_condition Remote Resource Object should be instantialized
335  * @procedure 1. Perform startMonitoring() API
336  *            2. Perform isMonitoring() API
337  * @post_condition Perform stopMonitoring() API
338  * @expected The API should not throw any exception
339  **/
340 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
341 TEST_F(REResourceBrokerTest_btc, IsMonitoring_SRC_P)
342 {
343     m_resource->startMonitoring(
344             std::bind(&REResourceBrokerTest_btc::onStateChangeReceived, this, PH::_1));
345
346     CommonUtil::waitInSecond(CALLBACK_WAIT_MIN);
347
348     bool monitorState = m_resource->isMonitoring();
349
350     if (!monitorState)
351     {
352         SET_FAILURE("Failed to start monitoring");
353     }
354
355     m_resource->stopMonitoring();
356 }
357 #endif
358
359 /**
360  * @since 2016-02-19
361  * @see startMonitoring()
362  * @objective Test 'isMonitoring' function without calling startMonitoring()
363  * @target bool isMonitoring()
364  * @test_data None
365  * @pre_condition Remote Resource Object should be instantialized
366  * @procedure Perform isMonitoring() API
367  * @post_condition Perform stopMonitoring() API
368  * @expected The API should not throw any exception
369  **/
370 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
371 TEST_F(REResourceBrokerTest_btc, IsMonitoring_SRCC_P)
372 {
373
374     bool monitorState = m_resource->isMonitoring();
375
376     if (monitorState)
377     {
378         SET_FAILURE("Start monitoring successful, but isMonitoring failed!");
379     }
380
381     m_resource->stopMonitoring();
382 }
383 #endif
384
385 /**
386  * @since 2016-02-22
387  * @see startObservable()
388  * @objective Test 'isObservable' function with positive basic way
389  * @target bool isObservable_P()
390  * @test_data None
391  * @pre_condition 1. Remote Resource Object should be instantialized
392  *                2. Perform startMonitoring() API
393  * @procedure Perform isObservable() API
394  * @post_condition Perform stopMonitoring() API
395  * @expected The API should not throw any exception
396  **/
397 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
398 TEST_F(REResourceBrokerTest_btc, IsObservable_SRC_P)
399 {
400     m_resource->startMonitoring(
401             std::bind(&REResourceBrokerTest_btc::onStateChangeReceived, this, PH::_1));
402
403     CommonUtil::waitInSecond(CALLBACK_WAIT_MIN);
404
405     bool Observable = m_resource->isObservable();
406
407     if (!Observable)
408     {
409         SET_FAILURE("Failed to start Observable");
410     }
411
412     m_resource->stopMonitoring();
413 }
414 #endif
415
416 /**
417  * @since 2016-02-22
418  * @see startObservable()
419  * @objective Test 'isObservable' function without calling startObservable()
420  * @target bool isObservable()
421  * @test_data None
422  * @pre_condition Remote Resource Object should be instantialized
423  * @procedure Perform isObservable() API
424  * @post_condition Perform stopMonitoring() API
425  * @expected The API should not throw any exception
426  **/
427 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
428 TEST_F(REResourceBrokerTest_btc, IsObservable_SRCC_P)
429 {
430
431     bool Observable = m_resource->isObservable();
432     if (Observable == 0)
433     {
434         SET_FAILURE("Failed to start Observable");
435     }
436
437     m_resource->stopMonitoring();
438 }
439 #endif