resource/csdk/resource-directory/unittests/rdtests.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 extern "C"
  22 {
  23     #include "rd_client.h"
  24     #include "rd_server.h"
  25     #include "ocstack.h"
  26     #include "logger.h"
  27     #include "oic_malloc.h"
  28 }
  29
  30 #include "gtest/gtest.h"
  31 #include <sys/types.h>
  32 #include <sys/stat.h>
  33 #include <errno.h>
  34 #include <fcntl.h>
  35 #include <unistd.h>
  36 #include <stdlib.h>
  37
  38 //-----------------------------------------------------------------------------
  39 // Includes
  40 //-----------------------------------------------------------------------------
  41 #include <stdio.h>
  42 #include <string.h>
  43
  44 #include <iostream>
  45 #include <stdint.h>
  46
  47 #include "gtest_helper.h"
  48
  49 using namespace std;
  50
  51 namespace itst = iotivity::test;
  52
  53 #define DEFAULT_CONTEXT_VALUE 0x99
  54
  55 //-----------------------------------------------------------------------------
  56 // Private variables
  57 //-----------------------------------------------------------------------------
  58 static const char TAG[] = "RDTests";
  59
  60 std::chrono::seconds const SHORT_TEST_TIMEOUT = std::chrono::seconds(5);
  61
  62 //-----------------------------------------------------------------------------
  63 // Callback functions
  64 //-----------------------------------------------------------------------------
  65 #if (defined(RD_SERVER) && defined(RD_CLIENT))
  66 static OCStackApplicationResult handleDiscoveryCB(__attribute__((unused))void *ctx,
  67                                                   __attribute__((unused)) OCDoHandle handle,
  68                                                   __attribute__((unused))
  69                                                   OCClientResponse *clientResponse)
  70 {
  71     OIC_LOG(DEBUG, TAG, "Successfully found RD.");
  72
  73     return OC_STACK_DELETE_TRANSACTION;
  74 }
  75 #endif
  76
  77 #ifdef RD_CLIENT
  78 static OCStackApplicationResult handlePublishCB(__attribute__((unused))void *ctx,
  79                                                 __attribute__((unused)) OCDoHandle handle,
  80                                                 __attribute__((unused))
  81                                                 OCClientResponse *clientResponse)
  82 {
  83     OIC_LOG(DEBUG, TAG, "Successfully published resources.");
  84
  85     return OC_STACK_DELETE_TRANSACTION;
  86 }
  87
  88 static OCStackApplicationResult handleDeleteCB(__attribute__((unused))void *ctx,
  89                                                __attribute__((unused)) OCDoHandle handle,
  90                                                __attribute__((unused))
  91                                                OCClientResponse *clientResponse)
  92 {
  93     OIC_LOG(DEBUG, TAG, "Successfully delete resources.");
  94
  95     return OC_STACK_DELETE_TRANSACTION;
  96 }
  97 #endif
  98
  99 //-----------------------------------------------------------------------------
 100 // Entity handler
 101 //-----------------------------------------------------------------------------
 102 OCEntityHandlerResult rdEntityHandler(OCEntityHandlerFlag /*flag*/,
 103                                       OCEntityHandlerRequest * /*entityHandlerRequest*/,
 104                                       void* /*callbackParam*/)
 105 {
 106     OIC_LOG(INFO, TAG, "Entering entityHandler");
 107
 108     return OC_EH_OK;
 109 }
 110
 111 //-----------------------------------------------------------------------------
 112 //  Tests
 113 //-----------------------------------------------------------------------------
 114 class RDTests : public testing::Test {
 115     protected:
 116     virtual void SetUp()
 117     {
 118         OCInit("127.0.0.1", 5683, OC_CLIENT_SERVER);
 119     }
 120
 121     virtual void TearDown()
 122     {
 123         OCStop();
 124     }
 125 };
 126
 127 #if (defined(RD_SERVER) && defined(RD_CLIENT))
 128 TEST_F(RDTests, CreateRDResource)
 129 {
 130     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 131     EXPECT_EQ(OC_STACK_OK, OCRDStart());
 132
 133     OCCallbackData cbData;
 134     cbData.cb = &handleDiscoveryCB;;
 135     cbData.cd = NULL;
 136     cbData.context = (void*) DEFAULT_CONTEXT_VALUE;
 137     EXPECT_EQ(OC_STACK_OK, OCRDDiscover(NULL, CT_ADAPTER_IP, &cbData, OC_LOW_QOS));
 138
 139     EXPECT_EQ(OC_STACK_OK, OCRDStop());
 140 }
 141 #endif
 142
 143 #ifdef RD_CLIENT
 144 // TEST_F(RDTests, CreateRDPayload)
 145 // {
 146 //     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 147 //
 148 //     OCResourceHandle handle;
 149 //     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle, "core.light",
 150 //                                             "oic.if.baseline", "/a/light", rdEntityHandler,
 151 //                                             NULL, OC_DISCOVERABLE | OC_OBSERVABLE));
 152 //
 153 //     // Create RD Publish Payload.
 154 //     // OCRDPayload *rdPayload = (OCRDPayload *) OCRDPublishPayloadCreate(&handle, 1, 86400);
 155 //     // EXPECT_TRUE(rdPayload != NULL);
 156 //
 157 //     // Cleanup.
 158 //     // OCPayloadDestroy(rdPayload);
 159 // }
 160 //
 161 // TEST_F(RDTests, ConvertParseRDPayload)
 162 // {
 163 //     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 164 //
 165 //     OCResourceHandle handle;
 166 //     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle, "core.light",
 167 //                                             "oic.if.baseline", "/a/light", rdEntityHandler,
 168 //                                             NULL, OC_DISCOVERABLE | OC_OBSERVABLE));
 169 //
 170 //     // Create RD Publish Payload.
 171 //     OCRDPayload *rdPayload = (OCRDPayload *) OCRDPublishPayloadCreate(&handle, 1, 86400);
 172 //     EXPECT_TRUE(rdPayload != NULL);
 173 //
 174 //     if (rdPayload)
 175 //     {
 176 //         // Convert RD Publish Payload to CBOR.
 177 //         size_t curSize = 255;
 178 //         uint8_t *outPayload = (uint8_t *)OICCalloc(1, curSize);
 179 //         OCRDPayloadToCbor(rdPayload, outPayload, &curSize);
 180 //
 181 //         // Parse CBOR back to RD Publish Payload.
 182 //         CborParser parser;
 183 //         CborValue rootValue;
 184 //         cbor_parser_init(outPayload, curSize, 0, &parser, &rootValue);
 185 //
 186 //         OCRDPayload *rdPayload = NULL;
 187 //         EXPECT_EQ(OC_STACK_OK, OCRDCborToPayload(&rootValue, (OCPayload**) &rdPayload));
 188 //
 189 //         // Cleanup.
 190 //         OICFree(outPayload);
 191 //     }
 192 //     OCRDPayloadDestroy(rdPayload);
 193 // }
 194
 195 TEST_F(RDTests, RDPublishResourceNullAddr)
 196 {
 197     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 198     EXPECT_EQ(OC_STACK_INVALID_IP, OCRDPublish(NULL, 0, CT_ADAPTER_IP, nullptr, 0, 0, OC_LOW_QOS));
 199 }
 200
 201 TEST_F(RDTests, RDPublishResourceNullCB)
 202 {
 203     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 204     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, OCRDPublish(NULL, "127.0.0.1", CT_ADAPTER_IP, nullptr,
 205                                                      0, 0, OC_LOW_QOS));
 206 }
 207
 208 TEST_F(RDTests, RDPublishResource)
 209 {
 210     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 211
 212     OCCallbackData cbData;
 213     cbData.cb = &handlePublishCB;
 214     cbData.cd = NULL;
 215     cbData.context = (void*) DEFAULT_CONTEXT_VALUE;
 216
 217     OCResourceHandle handle;
 218
 219     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle, "core.light",
 220                                             "oic.if.baseline", "/a/light", rdEntityHandler,
 221                                             NULL, (OC_DISCOVERABLE | OC_OBSERVABLE)));
 222
 223     EXPECT_EQ(OC_STACK_OK, OCRDPublish(NULL, "127.0.0.1", CT_ADAPTER_IP, &handle,
 224                                        1, &cbData, OC_LOW_QOS));
 225 }
 226
 227 TEST_F(RDTests, RDPublishMultipleResources)
 228 {
 229     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 230
 231     OCCallbackData cbData;
 232     cbData.cb = &handlePublishCB;
 233     cbData.cd = NULL;
 234     cbData.context = (void*) DEFAULT_CONTEXT_VALUE;
 235
 236     OCResourceHandle handles[2];
 237     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles[0], "core.light",
 238                                             "oic.if.baseline", "/a/light", rdEntityHandler,
 239                                             NULL, (OC_DISCOVERABLE | OC_OBSERVABLE)));
 240
 241     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles[1], "core.light",
 242                                             "oic.if.baseline", "/a/light2", rdEntityHandler,
 243                                             NULL, (OC_DISCOVERABLE | OC_OBSERVABLE)));
 244
 245     EXPECT_EQ(OC_STACK_OK, OCRDPublish(NULL, "127.0.0.1", CT_ADAPTER_IP, handles,
 246                                        2, &cbData, OC_LOW_QOS));
 247 }
 248
 249 TEST_F(RDTests, RDDeleteResourceNullAddr)
 250 {
 251     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 252     EXPECT_EQ(OC_STACK_INVALID_IP, OCRDDelete(NULL, 0, CT_ADAPTER_IP, nullptr, 0, 0, OC_LOW_QOS));
 253 }
 254
 255 TEST_F(RDTests, RDDeleteResourceNullCB)
 256 {
 257     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 258     EXPECT_EQ(OC_STACK_INVALID_CALLBACK, OCRDDelete(NULL, "127.0.0.1", CT_ADAPTER_IP, nullptr,
 259                                                     0, 0, OC_LOW_QOS));
 260 }
 261
 262 TEST_F(RDTests, RDDeleteAllResource)
 263 {
 264     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 265
 266     OCCallbackData cbData;
 267     cbData.cb = &handleDeleteCB;
 268     cbData.cd = NULL;
 269     cbData.context = (void*) DEFAULT_CONTEXT_VALUE;
 270
 271     EXPECT_EQ(OC_STACK_OK, OCRDDelete(NULL, "127.0.0.1", CT_ADAPTER_IP, nullptr, 0, &cbData,
 272                                       OC_LOW_QOS));
 273 }
 274
 275 TEST_F(RDTests, RDDeleteSpecificResource)
 276 {
 277     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 278
 279     OCCallbackData cbData;
 280     cbData.cb = &handleDeleteCB;
 281     cbData.cd = NULL;
 282     cbData.context = (void*) DEFAULT_CONTEXT_VALUE;
 283
 284     OCResourceHandle handle;
 285
 286     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle, "core.light",
 287                                             "oic.if.baseline", "/a/light", rdEntityHandler,
 288                                             NULL, OC_DISCOVERABLE | OC_OBSERVABLE));
 289
 290     EXPECT_EQ(OC_STACK_OK, OCRDDelete(NULL, "127.0.0.1", CT_ADAPTER_IP, &handle,
 291                                       1, &cbData, OC_LOW_QOS));
 292 }
 293 #endif