resource/csdk/stack/test/stacktests.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2014 Intel Mobile Communications GmbH 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
  22 extern "C" {
  23     #include "ocstack.h"
  24     #include "ocstackinternal.h"
  25     #include "logger.h"
  26 }
  27
  28 #include "gtest/gtest.h"
  29 #include <sys/types.h>
  30 #include <sys/stat.h>
  31 #include <errno.h>
  32 #include <fcntl.h>
  33 #include <unistd.h>
  34 #include <stdlib.h>
  35
  36 //-----------------------------------------------------------------------------
  37 // Includes
  38 //-----------------------------------------------------------------------------
  39 #include <stdio.h>
  40 #include <string.h>
  41
  42 #include <iostream>
  43 #include <stdint.h>
  44 using namespace std;
  45
  46 #define CTX_VAL 0x99
  47 //-----------------------------------------------------------------------------
  48 // Private variables
  49 //-----------------------------------------------------------------------------
  50 static const char TAG[] = "TestHarness";
  51
  52 //-----------------------------------------------------------------------------
  53 // Callback functions
  54 //-----------------------------------------------------------------------------
  55 extern "C"  OCStackApplicationResult asyncDoResourcesCallback(void* ctx, OCDoHandle handle, OCClientResponse * clientResponse) {
  56     OC_LOG(INFO, TAG, "Entering asyncDoResourcesCallback");
  57
  58     EXPECT_EQ(OC_STACK_OK, clientResponse->result);
  59
  60     if(ctx == (void*)CTX_VAL) {
  61         OC_LOG_V(INFO, TAG, "Callback Context recvd successfully");
  62     }
  63     OC_LOG_V(INFO, TAG, "result = %d", clientResponse->result);
  64
  65     return OC_STACK_KEEP_TRANSACTION;
  66 }
  67
  68
  69 //-----------------------------------------------------------------------------
  70 //  Tests
  71 //-----------------------------------------------------------------------------
  72 #if 1
  73 TEST(StackTest, StackInitNullAddr) {
  74     EXPECT_EQ(OC_STACK_OK, OCInit(0, 5683, OC_SERVER));
  75     EXPECT_EQ(OC_STACK_OK, OCStop());
  76 }
  77
  78 TEST(StackTest, StackInitNullPort) {
  79     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 0, OC_SERVER));
  80     EXPECT_EQ(OC_STACK_OK, OCStop());
  81 }
  82
  83 TEST(StackTest, StackInitNullAddrAndPort) {
  84     EXPECT_EQ(OC_STACK_OK, OCInit(0, 0, OC_SERVER));
  85     EXPECT_EQ(OC_STACK_OK, OCStop());
  86 }
  87
  88 TEST(StackTest, StackInitInvalidMode) {
  89     EXPECT_EQ(OC_STACK_ERROR, OCInit(0, 0, (OCMode)10));
  90     EXPECT_EQ(OC_STACK_ERROR, OCStop());
  91 }
  92
  93 TEST(StackTest, StackStartSuccessClient) {
  94     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
  95     EXPECT_EQ(OC_STACK_OK, OCStop());
  96 }
  97
  98 TEST(StackTest, StackStartSuccessServer) {
  99     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 100     EXPECT_EQ(OC_STACK_OK, OCStop());
 101 }
 102
 103 TEST(StackTest, StackStartSuccessClientServer) {
 104     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT_SERVER));
 105     EXPECT_EQ(OC_STACK_OK, OCStop());
 106 }
 107
 108 TEST(StackTest, StackStartSuccessiveInits) {
 109     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 110     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.2", 5683, OC_SERVER));
 111     EXPECT_EQ(OC_STACK_OK, OCStop());
 112 }
 113
 114 TEST(StackTest, DoResourceDeviceDiscovery) {
 115     uint8_t addr[20];
 116     uint16_t port = USE_RANDOM_PORT;
 117     uint8_t ifname[] = "eth0";
 118     OCCallbackData cbData;
 119     OCDoHandle handle;
 120
 121     /*Get Ip address on defined interface and initialize coap on it with random port number
 122      * this port number will be used as a source port in all coap communications*/
 123     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
 124     OC_LOG_V(INFO, TAG, "Starting DoResourceDeviceDiscovery test on address %s",addr);
 125
 126     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_CLIENT));
 127     /* Start a discovery query*/
 128     char szQueryUri[64] = { 0 };
 129     strcpy(szQueryUri, OC_WELL_KNOWN_QUERY);
 130     cbData.cb = asyncDoResourcesCallback;
 131     cbData.context = (void*)CTX_VAL;
 132     cbData.cd = NULL;
 133     EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle, OC_REST_GET, szQueryUri, 0, 0, OC_NON_CONFIRMABLE, &cbData), NULL, 0);
 134     //EXPECT_EQ(OC_STACK_OK, OCUpdateResources(SERVICE_URI));
 135     EXPECT_EQ(OC_STACK_OK, OCStop());
 136 }
 137
 138 TEST(StackTest, StackStopWithoutInit) {
 139     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
 140     EXPECT_EQ(OC_STACK_OK, OCStop());
 141     EXPECT_EQ(OC_STACK_ERROR, OCStop());
 142 }
 143
 144 TEST(StackTest, UpdateResourceNullURI) {
 145     uint8_t addr[20];
 146     uint16_t port = USE_RANDOM_PORT;
 147     uint8_t ifname[] = "eth0";
 148     OCCallbackData cbData;
 149     OCDoHandle handle;
 150
 151     /*Get Ip address on defined interface and initialize coap on it with random port number
 152      * this port number will be used as a source port in all coap communications*/
 153     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
 154     OC_LOG_V(INFO, TAG, "Starting UpdateResourceNullURI test on address %s",addr);
 155
 156     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_CLIENT));
 157     /* Start a discovery query*/
 158     char szQueryUri[64] = { 0 };
 159     strcpy(szQueryUri, OC_WELL_KNOWN_QUERY);
 160     cbData.cb = asyncDoResourcesCallback;
 161     cbData.context = (void*)CTX_VAL;
 162     cbData.cd = NULL;
 163     EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle, OC_REST_GET, szQueryUri, 0, 0, OC_NON_CONFIRMABLE, &cbData), NULL, 0);
 164     //EXPECT_EQ(OC_STACK_INVALID_URI, OCUpdateResources(0));
 165     EXPECT_EQ(OC_STACK_OK, OCStop());
 166 }
 167
 168 TEST(StackTest, CreateResourceBadParams) {
 169     uint8_t addr[20];
 170     uint16_t port = USE_RANDOM_PORT;
 171     uint8_t ifname[] = "eth0";
 172
 173     /*Get Ip address on defined interface and initialize coap on it with random port number
 174      * this port number will be used as a source port in all coap communications*/
 175     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
 176
 177     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
 178     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
 179
 180     OCResourceHandle handle;
 181
 182     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(NULL, //&handle,
 183                                             "core.led",
 184                                             "core.rw",
 185                                             "/a/led",
 186                                             0,
 187                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 188
 189     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 190                                             NULL, //"core.led",
 191                                             "core.rw",
 192                                             "/a/led",
 193                                             0,
 194                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 195
 196     // Property bitmask out of range
 197     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 198                                             "core.led",
 199                                             "core.rw",
 200                                             "/a/led",
 201                                             0,
 202                                             16));//OC_DISCOVERABLE|OC_OBSERVABLE));
 203
 204     EXPECT_EQ(OC_STACK_OK, OCStop());
 205 }
 206 #endif
 207
 208 TEST(StackTest, CreateResourceSuccess) {
 209     uint8_t addr[20];
 210     uint16_t port = USE_RANDOM_PORT;
 211     uint8_t ifname[] = "eth0";
 212
 213     /*Get Ip address on defined interface and initialize coap on it with random port number
 214      * this port number will be used as a source port in all coap communications*/
 215     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
 216
 217     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
 218     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
 219
 220     OCResourceHandle handle;
 221     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 222                                             "core.led",
 223                                             "core.rw",
 224                                             "/a/led",
 225                                             0,
 226                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 227     const char *url = OCGetResourceUri(handle);
 228     EXPECT_STREQ("/a/led", url);
 229
 230     EXPECT_EQ(OC_STACK_OK, OCStop());
 231 }
 232
 233 TEST(StackTest, CreateResourceFailDuplicateUri) {
 234     uint8_t addr[20];
 235     uint16_t port = USE_RANDOM_PORT;
 236     uint8_t ifname[] = "eth0";
 237
 238     /*Get Ip address on defined interface and initialize coap on it with random port number
 239      * this port number will be used as a source port in all coap communications*/
 240     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
 241
 242     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
 243     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
 244
 245     OCResourceHandle handle;
 246     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 247                                             "core.led",
 248                                             "core.rw",
 249                                             "/a/led",
 250                                             0,
 251                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 252     const char *url = OCGetResourceUri(handle);
 253     EXPECT_STREQ("/a/led", url);
 254
 255     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 256                                             "core.led",
 257                                             "core.rw",
 258                                             "/a/led",
 259                                             0,
 260                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 261
 262     EXPECT_EQ(OC_STACK_OK, OCStop());
 263 }
 264
 265 TEST(StackTest, CreateResourceMultipleResources) {
 266     uint8_t addr[20];
 267     uint16_t port = USE_RANDOM_PORT;
 268     uint8_t ifname[] = "eth0";
 269
 270     /*Get Ip address on defined interface and initialize coap on it with random port number
 271      * this port number will be used as a source port in all coap communications*/
 272     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
 273
 274     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
 275     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
 276
 277     OCResourceHandle handle1;
 278     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
 279                                             "core.led",
 280                                             "core.rw",
 281                                             "/a/led1",
 282                                             0,
 283                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 284
 285     OCResourceHandle handle2;
 286     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
 287                                             "core.led",
 288                                             "core.rw",
 289                                             "/a/led2",
 290                                             0,
 291                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 292     OCResourceHandle handle3;
 293     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
 294                                             "core.led",
 295                                             "core.rw",
 296                                             "/a/led3",
 297                                             0,
 298                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 299
 300     const char *url = OCGetResourceUri(handle1);
 301     EXPECT_STREQ("/a/led1", url);
 302
 303     url = OCGetResourceUri(handle2);
 304     EXPECT_STREQ("/a/led2", url);
 305
 306     url = OCGetResourceUri(handle3);
 307     EXPECT_STREQ("/a/led3", url);
 308
 309     EXPECT_EQ(OC_STACK_OK, OCStop());
 310 }
 311
 312 TEST(StackTest, CreateResourceBadResoureType) {
 313     uint8_t addr[20];
 314     uint16_t port = USE_RANDOM_PORT;
 315     uint8_t ifname[] = "eth0";
 316
 317     /*Get Ip address on defined interface and initialize coap on it with random port number
 318      * this port number will be used as a source port in all coap communications*/
 319     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
 320
 321     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
 322     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
 323
 324     OCResourceHandle handle;
 325     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 326                                             NULL, //"core.led",
 327                                             "core.rw",
 328                                             "/a/led",
 329                                             0,
 330                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 331
 332     EXPECT_EQ(OC_STACK_OK, OCStop());
 333 }
 334
 335 TEST(StackTest, CreateResourceGoodResourceType) {
 336     uint8_t addr[20];
 337     uint16_t port = USE_RANDOM_PORT;
 338     uint8_t ifname[] = "eth0";
 339
 340     /*Get Ip address on defined interface and initialize coap on it with random port number
 341      * this port number will be used as a source port in all coap communications*/
 342     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
 343
 344     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
 345     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
 346
 347     OCResourceHandle handle;
 348     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 349                                             "core.led",
 350                                             "core.rw",
 351                                             "/a/led",
 352                                             0,
 353                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 354
 355     EXPECT_EQ(OC_STACK_OK, OCStop());
 356 }
 357
 358 TEST(StackTest, ResourceTypeName) {
 359     uint8_t addr[20];
 360     uint16_t port = USE_RANDOM_PORT;
 361     uint8_t ifname[] = "eth0";
 362
 363     /*Get Ip address on defined interface and initialize coap on it with random port number
 364      * this port number will be used as a source port in all coap communications*/
 365     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
 366
 367     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
 368     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
 369
 370     OCResourceHandle handle;
 371     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 372                                             "core.led",
 373                                             "core.rw",
 374                                             "/a/led",
 375                                             0,
 376                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 377
 378     uint8_t numResourceTypes;
 379     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 380     EXPECT_EQ(1, numResourceTypes);
 381     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
 382     EXPECT_STREQ("core.led", resourceTypeName);
 383
 384     // try getting resource type names with an invalid index
 385     resourceTypeName = OCGetResourceTypeName(handle, 1);
 386     EXPECT_STREQ(NULL, resourceTypeName);
 387     // try getting resource type names with an invalid index
 388     resourceTypeName = OCGetResourceTypeName(handle, 10);
 389     EXPECT_STREQ(NULL, resourceTypeName);
 390
 391     EXPECT_EQ(OC_STACK_OK, OCStop());
 392 }
 393
 394 TEST(StackTest, BindResourceTypeNameBad) {
 395     uint8_t addr[20];
 396     uint16_t port = USE_RANDOM_PORT;
 397     uint8_t ifname[] = "eth0";
 398
 399     /*Get Ip address on defined interface and initialize coap on it with random port number
 400      * this port number will be used as a source port in all coap communications*/
 401     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
 402
 403     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
 404     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
 405
 406     OCResourceHandle handle;
 407     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 408                                             "core.led",
 409                                             "core.rw",
 410                                             "/a/led",
 411                                             0,
 412                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 413
 414     uint8_t numResourceTypes;
 415     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 416     EXPECT_EQ(1, numResourceTypes);
 417     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
 418     EXPECT_STREQ("core.led", resourceTypeName);
 419
 420     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, NULL));
 421
 422     EXPECT_EQ(OC_STACK_OK, OCStop());
 423 }
 424
 425 TEST(StackTest, BindResourceTypeNameGood) {
 426     uint8_t addr[20];
 427     uint16_t port = USE_RANDOM_PORT;
 428     uint8_t ifname[] = "eth0";
 429
 430     /*Get Ip address on defined interface and initialize coap on it with random port number
 431      * this port number will be used as a source port in all coap communications*/
 432     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
 433
 434     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
 435     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
 436
 437     OCResourceHandle handle;
 438     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 439                                             "core.led",
 440                                             "core.rw",
 441                                             "/a/led",
 442                                             0,
 443                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 444
 445     uint8_t numResourceTypes;
 446     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 447     EXPECT_EQ(1, numResourceTypes);
 448     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
 449     EXPECT_STREQ("core.led", resourceTypeName);
 450
 451     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
 452     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 453     EXPECT_EQ(2, numResourceTypes);
 454     resourceTypeName = OCGetResourceTypeName(handle, 1);
 455     EXPECT_STREQ("core.brightled", resourceTypeName);
 456
 457     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
 458     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 459     EXPECT_EQ(3, numResourceTypes);
 460     resourceTypeName = OCGetResourceTypeName(handle, 2);
 461     EXPECT_STREQ("core.reallybrightled", resourceTypeName);
 462
 463     EXPECT_EQ(OC_STACK_OK, OCStop());
 464 }
 465
 466 TEST(StackTest, ResourceTypeAttrRepresentation) {
 467     uint8_t addr[20];
 468     uint16_t port = USE_RANDOM_PORT;
 469     uint8_t ifname[] = "eth0";
 470
 471     /*Get Ip address on defined interface and initialize coap on it with random port number
 472      * this port number will be used as a source port in all coap communications*/
 473     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
 474
 475     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
 476     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
 477
 478     OCResourceHandle handle;
 479     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 480                                             "core.led",
 481                                             "core.rw",
 482                                             "/a/led",
 483                                             0,
 484                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 485
 486     uint8_t numResourceTypes;
 487     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 488     EXPECT_EQ(1, numResourceTypes);
 489
 490     EXPECT_EQ(OC_STACK_OK, OCStop());
 491 }
 492
 493 TEST(StackTest, BindResourceTypeAttribRepGood) {
 494     uint8_t addr[20];
 495     uint16_t port = USE_RANDOM_PORT;
 496     uint8_t ifname[] = "eth0";
 497
 498     /*Get Ip address on defined interface and initialize coap on it with random port number
 499      * this port number will be used as a source port in all coap communications*/
 500     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
 501
 502     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
 503     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
 504
 505     OCResourceHandle handle;
 506     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 507                                             "core.led",
 508                                             "core.rw",
 509                                             "/a/led",
 510                                             0,
 511                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 512
 513     uint8_t numResourceTypes;
 514     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 515     EXPECT_EQ(1, numResourceTypes);
 516
 517     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
 518     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 519     EXPECT_EQ(2, numResourceTypes);
 520
 521     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
 522     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 523     EXPECT_EQ(3, numResourceTypes);
 524
 525     EXPECT_EQ(OC_STACK_OK, OCStop());
 526 }
 527
 528 TEST(StackTest, ResourceTypeInterface) {
 529     uint8_t addr[20];
 530     uint16_t port = USE_RANDOM_PORT;
 531     uint8_t ifname[] = "eth0";
 532
 533     /*Get Ip address on defined interface and initialize coap on it with random port number
 534      * this port number will be used as a source port in all coap communications*/
 535     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
 536
 537     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
 538     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
 539
 540     OCResourceHandle handle;
 541     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 542                                             "core.led",
 543                                             "core.rw",
 544                                             "/a/led",
 545                                             0,
 546                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 547
 548     uint8_t numResourceInterfaces;
 549     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 550     EXPECT_EQ(1, numResourceInterfaces);
 551     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
 552     EXPECT_STREQ("core.rw", resourceInterfaceName);
 553
 554     // try getting resource interface names with an invalid index
 555     resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
 556     EXPECT_STREQ(NULL, resourceInterfaceName);
 557     // try getting resource interface names with an invalid index
 558     resourceInterfaceName = OCGetResourceInterfaceName(handle, 10);
 559     EXPECT_STREQ(NULL, resourceInterfaceName);
 560
 561     EXPECT_EQ(OC_STACK_OK, OCStop());
 562 }
 563
 564 TEST(StackTest, BindResourceInterfaceNameBad) {
 565     uint8_t addr[20];
 566     uint16_t port = USE_RANDOM_PORT;
 567     uint8_t ifname[] = "eth0";
 568
 569     /*Get Ip address on defined interface and initialize coap on it with random port number
 570      * this port number will be used as a source port in all coap communications*/
 571     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
 572
 573     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
 574     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
 575
 576     OCResourceHandle handle;
 577     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 578                                             "core.led",
 579                                             "core.rw",
 580                                             "/a/led",
 581                                             0,
 582                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 583
 584     uint8_t numResourceInterfaces;
 585     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 586     EXPECT_EQ(1, numResourceInterfaces);
 587     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
 588     EXPECT_STREQ("core.rw", resourceInterfaceName);
 589
 590     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, NULL));
 591
 592     EXPECT_EQ(OC_STACK_OK, OCStop());
 593 }
 594
 595 TEST(StackTest, BindResourceInterfaceNameGood) {
 596     uint8_t addr[20];
 597     uint16_t port = USE_RANDOM_PORT;
 598     uint8_t ifname[] = "eth0";
 599
 600     /*Get Ip address on defined interface and initialize coap on it with random port number
 601      * this port number will be used as a source port in all coap communications*/
 602     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
 603
 604     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
 605     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
 606
 607     OCResourceHandle handle;
 608     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 609                                             "core.led",
 610                                             "core.rw",
 611                                             "/a/led",
 612                                             0,
 613                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 614
 615     uint8_t numResourceInterfaces;
 616     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 617     EXPECT_EQ(1, numResourceInterfaces);
 618     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
 619     EXPECT_STREQ("core.rw", resourceInterfaceName);
 620
 621     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
 622
 623     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 624     EXPECT_EQ(2, numResourceInterfaces);
 625     resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
 626     EXPECT_STREQ("core.r", resourceInterfaceName);
 627
 628     EXPECT_EQ(OC_STACK_OK, OCStop());
 629 }
 630
 631 TEST(StackTest, ResourceTypeInterfaceMethods) {
 632     uint8_t addr[20];
 633     uint16_t port = USE_RANDOM_PORT;
 634     uint8_t ifname[] = "eth0";
 635
 636     /*Get Ip address on defined interface and initialize coap on it with random port number
 637      * this port number will be used as a source port in all coap communications*/
 638     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
 639
 640     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
 641     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
 642
 643     OCResourceHandle handle;
 644     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 645                                             "core.led",
 646                                             "core.rw",
 647                                             "/a/led",
 648                                             0,
 649                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 650
 651     uint8_t numResourceInterfaces;
 652     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 653     EXPECT_EQ(1, numResourceInterfaces);
 654
 655     EXPECT_EQ(OC_STACK_OK, OCStop());
 656 }
 657
 658 TEST(StackTest, BindResourceInterfaceMethodsBad) {
 659     uint8_t addr[20];
 660     uint16_t port = USE_RANDOM_PORT;
 661     uint8_t ifname[] = "eth0";
 662
 663     /*Get Ip address on defined interface and initialize coap on it with random port number
 664      * this port number will be used as a source port in all coap communications*/
 665     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
 666
 667     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
 668     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
 669
 670     OCResourceHandle handle;
 671     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 672                                             "core.led",
 673                                             "core.rw",
 674                                             "/a/led",
 675                                             0,
 676                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 677
 678     uint8_t numResourceInterfaces;
 679     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 680     EXPECT_EQ(1, numResourceInterfaces);
 681
 682     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, 0));
 683
 684     EXPECT_EQ(OC_STACK_OK, OCStop());
 685 }
 686
 687 TEST(StackTest, BindResourceInterfaceMethodsGood) {
 688     uint8_t addr[20];
 689     uint16_t port = USE_RANDOM_PORT;
 690     uint8_t ifname[] = "eth0";
 691
 692     /*Get Ip address on defined interface and initialize coap on it with random port number
 693      * this port number will be used as a source port in all coap communications*/
 694     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
 695
 696     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
 697     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
 698
 699     OCResourceHandle handle;
 700     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 701                                             "core.led",
 702                                             "core.rw",
 703                                             "/a/led",
 704                                             0,
 705                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 706
 707     uint8_t numResourceInterfaces;
 708     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 709     EXPECT_EQ(1, numResourceInterfaces);
 710
 711     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
 712
 713     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 714     EXPECT_EQ(2, numResourceInterfaces);
 715
 716     EXPECT_EQ(OC_STACK_OK, OCStop());
 717 }
 718
 719 TEST(StackTest, BindContainedResourceBad) {
 720     uint8_t addr[20];
 721     uint16_t port = USE_RANDOM_PORT;
 722     uint8_t ifname[] = "eth0";
 723
 724     /*Get Ip address on defined interface and initialize coap on it with random port number
 725      * this port number will be used as a source port in all coap communications*/
 726     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
 727
 728     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
 729     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
 730
 731     OCResourceHandle containerHandle;
 732     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
 733                                             "core.led",
 734                                             "core.rw",
 735                                             "/a/kitchen",
 736                                             0,
 737                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 738
 739     OCResourceHandle handle0;
 740     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
 741                                             "core.led",
 742                                             "core.rw",
 743                                             "/a/led",
 744                                             0,
 745                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 746
 747     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResource(containerHandle, containerHandle));
 748
 749     EXPECT_EQ(OC_STACK_ERROR, OCBindResource((OCResourceHandle) 0, handle0));
 750
 751     EXPECT_EQ(OC_STACK_OK, OCStop());
 752 }
 753
 754 TEST(StackTest, BindContainedResourceGood) {
 755     uint8_t addr[20];
 756     uint16_t port = USE_RANDOM_PORT;
 757     uint8_t ifname[] = "eth0";
 758
 759     /*Get Ip address on defined interface and initialize coap on it with random port number
 760      * this port number will be used as a source port in all coap communications*/
 761     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
 762
 763     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
 764     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
 765
 766     uint8_t numResources = 0;
 767     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 768     EXPECT_EQ(0, numResources);
 769
 770     OCResourceHandle containerHandle;
 771     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
 772                                             "core.led",
 773                                             "core.rw",
 774                                             "/a/kitchen",
 775                                             0,
 776                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 777     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 778     EXPECT_EQ(1, numResources);
 779
 780     OCResourceHandle handle0;
 781     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
 782                                             "core.led",
 783                                             "core.rw",
 784                                             "/a/led0",
 785                                             0,
 786                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 787     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 788     EXPECT_EQ(2, numResources);
 789
 790     OCResourceHandle handle1;
 791     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
 792                                             "core.led",
 793                                             "core.rw",
 794                                             "/a/led1",
 795                                             0,
 796                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 797     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 798     EXPECT_EQ(3, numResources);
 799
 800     OCResourceHandle handle2;
 801     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
 802                                             "core.led",
 803                                             "core.rw",
 804                                             "/a/led2",
 805                                             0,
 806                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 807     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 808     EXPECT_EQ(4, numResources);
 809
 810     OCResourceHandle handle3;
 811     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
 812                                             "core.led",
 813                                             "core.rw",
 814                                             "/a/led3",
 815                                             0,
 816                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 817     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 818     EXPECT_EQ(5, numResources);
 819
 820     OCResourceHandle handle4;
 821     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
 822                                             "core.led",
 823                                             "core.rw",
 824                                             "/a/led4",
 825                                             0,
 826                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 827     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 828     EXPECT_EQ(6, numResources);
 829
 830     OCResourceHandle handle5;
 831     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
 832                                             "core.led",
 833                                             "core.rw",
 834                                             "/a/led5",
 835                                             0,
 836                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 837     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 838     EXPECT_EQ(7, numResources);
 839
 840
 841     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle0));
 842     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle1));
 843     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle2));
 844     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle3));
 845     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle4));
 846     EXPECT_EQ(OC_STACK_ERROR, OCBindResource(containerHandle, handle5));
 847
 848     EXPECT_EQ(handle0, OCGetResourceHandleFromCollection(containerHandle, 0));
 849     EXPECT_EQ(handle1, OCGetResourceHandleFromCollection(containerHandle, 1));
 850     EXPECT_EQ(handle2, OCGetResourceHandleFromCollection(containerHandle, 2));
 851     EXPECT_EQ(handle3, OCGetResourceHandleFromCollection(containerHandle, 3));
 852     EXPECT_EQ(handle4, OCGetResourceHandleFromCollection(containerHandle, 4));
 853
 854     EXPECT_EQ(NULL, OCGetResourceHandleFromCollection(containerHandle, 5));
 855
 856     EXPECT_EQ(OC_STACK_OK, OCStop());
 857 }
 858
 859 TEST(StackTest, GetResourceByIndex) {
 860     uint8_t addr[20];
 861     uint16_t port = USE_RANDOM_PORT;
 862     uint8_t ifname[] = "eth0";
 863
 864     /*Get Ip address on defined interface and initialize coap on it with random port number
 865      * this port number will be used as a source port in all coap communications*/
 866     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
 867
 868     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
 869     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
 870
 871     uint8_t numResources = 0;
 872     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 873     EXPECT_EQ(0, numResources);
 874
 875     OCResourceHandle containerHandle;
 876     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
 877                                             "core.led",
 878                                             "core.rw",
 879                                             "/a/kitchen",
 880                                             0,
 881                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 882     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 883     EXPECT_EQ(1, numResources);
 884
 885     OCResourceHandle handle0;
 886     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
 887                                             "core.led",
 888                                             "core.rw",
 889                                             "/a/led0",
 890                                             0,
 891                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 892     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 893     EXPECT_EQ(2, numResources);
 894
 895     OCResourceHandle handle1;
 896     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
 897                                             "core.led",
 898                                             "core.rw",
 899                                             "/a/led1",
 900                                             0,
 901                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 902     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 903     EXPECT_EQ(3, numResources);
 904
 905     OCResourceHandle handle2;
 906     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
 907                                             "core.led",
 908                                             "core.rw",
 909                                             "/a/led2",
 910                                             0,
 911                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 912     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 913     EXPECT_EQ(4, numResources);
 914
 915     OCResourceHandle handle3;
 916     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
 917                                             "core.led",
 918                                             "core.rw",
 919                                             "/a/led3",
 920                                             0,
 921                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 922     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 923     EXPECT_EQ(5, numResources);
 924
 925     OCResourceHandle handle4;
 926     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
 927                                             "core.led",
 928                                             "core.rw",
 929                                             "/a/led4",
 930                                             0,
 931                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 932     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 933     EXPECT_EQ(6, numResources);
 934
 935     OCResourceHandle handle5;
 936     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
 937                                             "core.led",
 938                                             "core.rw",
 939                                             "/a/led5",
 940                                             0,
 941                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 942     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 943     EXPECT_EQ(7, numResources);
 944
 945     EXPECT_EQ(containerHandle, OCGetResourceHandle(0));
 946     EXPECT_EQ(handle0, OCGetResourceHandle(1));
 947     EXPECT_EQ(handle1, OCGetResourceHandle(2));
 948     EXPECT_EQ(handle2, OCGetResourceHandle(3));
 949     EXPECT_EQ(handle3, OCGetResourceHandle(4));
 950     EXPECT_EQ(handle4, OCGetResourceHandle(5));
 951     EXPECT_EQ(handle5, OCGetResourceHandle(6));
 952
 953     EXPECT_EQ(OC_STACK_OK, OCStop());
 954 }
 955
 956 TEST(StackTest, BindEntityHandlerBad) {
 957     uint8_t addr[20];
 958     uint16_t port = USE_RANDOM_PORT;
 959     uint8_t ifname[] = "eth0";
 960
 961     /*Get Ip address on defined interface and initialize coap on it with random port number
 962      * this port number will be used as a source port in all coap communications*/
 963     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
 964
 965     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
 966     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
 967
 968     OCResourceHandle handle;
 969     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 970                                             "core.led",
 971                                             "core.rw",
 972                                             "/a/led",
 973                                             0,
 974                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 975
 976     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(handle, NULL));
 977     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(NULL, NULL));
 978
 979     EXPECT_EQ(OC_STACK_OK, OCStop());
 980 }
 981
 982
 983 OCEntityHandlerResult entityHandler(OCEntityHandlerFlag flag, OCEntityHandlerRequest * entityHandlerRequest) {
 984     OC_LOG(INFO, TAG, "Entering entityHandler");
 985
 986     return OC_EH_OK;
 987 }
 988
 989 TEST(StackTest, BindEntityHandlerGood) {
 990     uint8_t addr[20];
 991     uint16_t port = USE_RANDOM_PORT;
 992     uint8_t ifname[] = "eth0";
 993
 994     /*Get Ip address on defined interface and initialize coap on it with random port number
 995      * this port number will be used as a source port in all coap communications*/
 996     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
 997
 998     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
 999     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
1000
1001     OCResourceHandle handle;
1002     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1003                                             "core.led",
1004                                             "core.rw",
1005                                             "/a/led",
1006                                             0,
1007                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1008
1009     OCEntityHandler myHandler = entityHandler;
1010
1011     EXPECT_EQ(OC_STACK_OK, OCBindResourceHandler(handle, myHandler));
1012
1013     EXPECT_EQ(myHandler, OCGetResourceHandler(handle));
1014
1015     EXPECT_EQ(OC_STACK_OK, OCStop());
1016 }
1017
1018 TEST(StackTest, DeleteHeadResource) {
1019     uint8_t addr[20];
1020     uint16_t port = USE_RANDOM_PORT;
1021     uint8_t ifname[] = "eth0";
1022
1023     /*Get Ip address on defined interface and initialize coap on it with random port number
1024      * this port number will be used as a source port in all coap communications*/
1025     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
1026
1027     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
1028     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
1029
1030     uint8_t numResources = 0;
1031     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1032     EXPECT_EQ(0, numResources);
1033
1034     OCResourceHandle handle0;
1035     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1036                                             "core.led",
1037                                             "core.rw",
1038                                             "/a/led0",
1039                                             0,
1040                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1041     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1042     EXPECT_EQ(1, numResources);
1043
1044     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1045     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1046     EXPECT_EQ(0, numResources);
1047
1048     EXPECT_EQ(OC_STACK_OK, OCStop());
1049 }
1050
1051 TEST(StackTest, DeleteHeadResource2) {
1052     uint8_t addr[20];
1053     uint16_t port = USE_RANDOM_PORT;
1054     uint8_t ifname[] = "eth0";
1055
1056     /*Get Ip address on defined interface and initialize coap on it with random port number
1057      * this port number will be used as a source port in all coap communications*/
1058     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
1059
1060     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
1061     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
1062
1063     uint8_t numResources = 0;
1064     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1065     EXPECT_EQ(0, numResources);
1066
1067     OCResourceHandle handle0;
1068     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1069                                             "core.led",
1070                                             "core.rw",
1071                                             "/a/led0",
1072                                             0,
1073                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1074     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1075     EXPECT_EQ(1, numResources);
1076
1077     OCResourceHandle handle1;
1078     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1079                                             "core.led",
1080                                             "core.rw",
1081                                             "/a/led1",
1082                                             0,
1083                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1084     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1085     EXPECT_EQ(2, numResources);
1086
1087     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1088     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1089     EXPECT_EQ(1, numResources);
1090
1091     EXPECT_EQ(handle1, OCGetResourceHandle(0));
1092
1093     EXPECT_EQ(OC_STACK_OK, OCStop());
1094 }
1095
1096
1097 TEST(StackTest, DeleteLastResource) {
1098     uint8_t addr[20];
1099     uint16_t port = USE_RANDOM_PORT;
1100     uint8_t ifname[] = "eth0";
1101
1102     /*Get Ip address on defined interface and initialize coap on it with random port number
1103      * this port number will be used as a source port in all coap communications*/
1104     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
1105
1106     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
1107     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
1108
1109     uint8_t numResources = 0;
1110     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1111     EXPECT_EQ(0, numResources);
1112
1113     OCResourceHandle handle0;
1114     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1115                                             "core.led",
1116                                             "core.rw",
1117                                             "/a/led0",
1118                                             0,
1119                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1120     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1121     EXPECT_EQ(1, numResources);
1122
1123     OCResourceHandle handle1;
1124     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1125                                             "core.led",
1126                                             "core.rw",
1127                                             "/a/led1",
1128                                             0,
1129                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1130     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1131     EXPECT_EQ(2, numResources);
1132
1133     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1134     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1135     EXPECT_EQ(1, numResources);
1136
1137     EXPECT_EQ(handle0, OCGetResourceHandle(0));
1138
1139     OCResourceHandle handle2;
1140     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1141                                             "core.led",
1142                                             "core.rw",
1143                                             "/a/led2",
1144                                             0,
1145                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1146     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1147     EXPECT_EQ(2, numResources);
1148
1149     EXPECT_EQ(OC_STACK_OK, OCStop());
1150 }
1151
1152 TEST(StackTest, DeleteMiddleResource) {
1153     uint8_t addr[20];
1154     uint16_t port = USE_RANDOM_PORT;
1155     uint8_t ifname[] = "eth0";
1156
1157     /*Get Ip address on defined interface and initialize coap on it with random port number
1158      * this port number will be used as a source port in all coap communications*/
1159     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
1160
1161     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
1162     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
1163
1164     uint8_t numResources = 0;
1165     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1166     EXPECT_EQ(0, numResources);
1167
1168     OCResourceHandle handle0;
1169     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1170                                             "core.led",
1171                                             "core.rw",
1172                                             "/a/led0",
1173                                             0,
1174                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1175     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1176     EXPECT_EQ(1, numResources);
1177
1178     OCResourceHandle handle1;
1179     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1180                                             "core.led",
1181                                             "core.rw",
1182                                             "/a/led1",
1183                                             0,
1184                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1185     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1186     EXPECT_EQ(2, numResources);
1187
1188     OCResourceHandle handle2;
1189     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1190                                             "core.led",
1191                                             "core.rw",
1192                                             "/a/led2",
1193                                             0,
1194                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1195     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1196     EXPECT_EQ(3, numResources);
1197
1198     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1199     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1200     EXPECT_EQ(2, numResources);
1201
1202     EXPECT_EQ(handle0, OCGetResourceHandle(0));
1203     EXPECT_EQ(handle2, OCGetResourceHandle(1));
1204
1205     // Make sure the resource elements are still correct
1206     uint8_t numResourceInterfaces;
1207     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle2, &numResourceInterfaces));
1208     EXPECT_EQ(1, numResourceInterfaces);
1209     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle2, 0);
1210     EXPECT_STREQ("core.rw", resourceInterfaceName);
1211
1212     EXPECT_EQ(OC_STACK_OK, OCStop());
1213 }
1214
1215 TEST(StackTest, GetResourceProperties) {
1216     uint8_t addr[20];
1217     uint16_t port = USE_RANDOM_PORT;
1218     uint8_t ifname[] = "eth0";
1219
1220     /*Get Ip address on defined interface and initialize coap on it with random port number
1221      * this port number will be used as a source port in all coap communications*/
1222     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
1223
1224     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
1225     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
1226
1227     OCResourceHandle handle;
1228     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1229                                             "core.led",
1230                                             "core.rw",
1231                                             "/a/led",
1232                                             0,
1233                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1234
1235     EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE, OCGetResourceProperties(handle));
1236     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
1237
1238     EXPECT_EQ(OC_STACK_OK, OCStop());
1239 }
1240
1241 TEST(StackTest, StackTestResourceDiscoverOneResourceBad) {
1242     uint8_t addr[20];
1243     uint16_t port = USE_RANDOM_PORT;
1244     uint8_t ifname[] = "eth0";
1245
1246     /*Get Ip address on defined interface and initialize coap on it with random port number
1247      * this port number will be used as a source port in all coap communications*/
1248     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
1249
1250     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
1251     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
1252
1253     OCResourceHandle handle;
1254     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1255                                             "core.led",
1256                                             "core.rw",
1257                                             "/a1/led",
1258                                             0,
1259                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1260     const char *url = OCGetResourceUri(handle);
1261     EXPECT_STREQ("/a1/led", url);
1262
1263     //EXPECT_EQ(OC_STACK_INVALID_URI, OCHandleServerRequest(&res, uri, query, req, rsp));
1264     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
1265     uint8_t numResources = 0;
1266     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1267     EXPECT_EQ(0, numResources);
1268
1269     EXPECT_EQ(OC_STACK_OK, OCStop());
1270 }
1271
1272 TEST(StackTest, StackTestResourceDiscoverOneResource) {
1273     uint8_t addr[20];
1274     uint16_t port = USE_RANDOM_PORT;
1275     uint8_t ifname[] = "eth0";
1276
1277     /*Get Ip address on defined interface and initialize coap on it with random port number
1278      * this port number will be used as a source port in all coap communications*/
1279     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
1280
1281     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
1282     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
1283
1284     OCResourceHandle handle;
1285     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1286                                             "core.led",
1287                                             "core.rw",
1288                                             "/a/led",
1289                                             0,
1290                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1291     const char *url = OCGetResourceUri(handle);
1292     EXPECT_STREQ("/a/led", url);
1293
1294     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
1295     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
1296
1297     EXPECT_EQ(OC_STACK_OK, OCStop());
1298 }
1299
1300 TEST(StackTest, StackTestResourceDiscoverManyResources) {
1301     uint8_t addr[20];
1302     uint16_t port = USE_RANDOM_PORT;
1303     uint8_t ifname[] = "eth0";
1304
1305     /*Get Ip address on defined interface and initialize coap on it with random port number
1306      * this port number will be used as a source port in all coap communications*/
1307     OCGetInterfaceAddress(ifname, sizeof(ifname), AF_INET, addr, sizeof(addr));
1308
1309     OC_LOG_V(INFO, TAG, "Starting ocserver on address %s:%d",addr,port);
1310     EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, OC_SERVER));
1311
1312     OCResourceHandle handle1;
1313     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1314                                             "core.led",
1315                                             "core.rw",
1316                                             "/a/led1",
1317                                             0,
1318                                             OC_DISCOVERABLE));
1319     const char *url = OCGetResourceUri(handle1);
1320     EXPECT_STREQ("/a/led1", url);
1321
1322     OCResourceHandle handle2;
1323     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1324                                             "core.led",
1325                                             "core.rw",
1326                                             "/a/led2",
1327                                             0,
1328                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1329     url = OCGetResourceUri(handle2);
1330     EXPECT_STREQ("/a/led2", url);
1331
1332     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.brightled"));
1333     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.colorled"));
1334
1335     OCResourceHandle handle3;
1336     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1337                                             "core.led",
1338                                             "core.rw",
1339                                             "/a/led3",
1340                                             0,
1341                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1342     url = OCGetResourceUri(handle3);
1343     EXPECT_STREQ("/a/led3", url);
1344
1345     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, "oc.mi.ll"));
1346     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, "oc.mi.b"));
1347
1348     OCResourceHandle handle4;
1349     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1350                                             "core.led",
1351                                             "core.rw",
1352                                             "/a/led4",
1353                                             0,
1354                                             OC_DISCOVERABLE));
1355     url = OCGetResourceUri(handle4);
1356     EXPECT_STREQ("/a/led4", url);
1357
1358     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle4, "core.brightled"));
1359     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, "oc.mi.ll"));
1360     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, "oc.mi.b"));
1361
1362     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
1363
1364     EXPECT_EQ(OC_STACK_OK, OCStop());
1365 }
1366
1367
1368 #if 0
1369 TEST(StackTest, StackTestResourceDiscoverIfFilteringBad) {
1370     uint8_t addr[20];
1371     uint16_t port = USE_RANDOM_PORT;
1372     uint8_t ifname[] = "eth0";
1373     char uri[] = "/oc/core";
1374     char query[] = "if";
1375     char req[1024] = {};
1376     char rsp[1024] = {};
1377     //OCServerRequestResult res;
1378
1379     //EXPECT_EQ(OC_STACK_INVALID_QUERY, OCHandleServerRequest(&res, uri, query, req, rsp));
1380 }
1381
1382 TEST(StackTest, StackTestResourceDiscoverRtFilteringBad) {
1383     uint8_t addr[20];
1384     uint16_t port = USE_RANDOM_PORT;
1385     uint8_t ifname[] = "eth0";
1386     char uri[] = "/oc/core";
1387     char query[] = "rt";
1388     char req[1024] = {};
1389     char rsp[1024] = {};
1390     //OCServerRequestResult res;
1391
1392     //EXPECT_EQ(OC_STACK_INVALID_QUERY, OCHandleServerRequest(&res, uri, query, req, rsp));
1393 }
1394 TEST(StackTest, StackTestResourceDiscoverIfFiltering) {
1395     uint8_t addr[20];
1396     uint16_t port = USE_RANDOM_PORT;
1397     uint8_t ifname[] = "eth0";
1398     char uri[] = "/oc/core";
1399     char query[] = "if=oc.mi.ll";
1400     char req[1024] = {};
1401     char rsp[1024] = {};
1402     //OCServerRequestResult res;
1403
1404     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
1405 }
1406
1407 TEST(StackTest, StackTestResourceDiscoverRtFiltering) {
1408     uint8_t addr[20];
1409     uint16_t port = USE_RANDOM_PORT;
1410     uint8_t ifname[] = "eth0";
1411     char uri[] = "/oc/core";
1412     char query[] = "rt=core.brightled";
1413     char req[1024] = {};
1414     char rsp[1024] = {};
1415     //OCServerRequestResult res;
1416
1417     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
1418 }
1419 #endif