android/android_api/base/src/androidTest/java/org/iotivity/base/SmokeTest.java

   1 /*
   2  *******************************************************************
   3  *
   4  * Copyright 2015 Intel Corporation.
   5  *
   6  *-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  *-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  21  */
  22
  23 package org.iotivity.base;
  24
  25 import android.test.InstrumentationTestCase;
  26 import android.util.Log;
  27
  28 import java.util.Arrays;
  29 import java.util.Date;
  30 import java.util.EnumSet;
  31 import java.util.HashMap;
  32 import java.util.LinkedList;
  33 import java.util.List;
  34 import java.util.Map;
  35 import java.util.Random;
  36 import java.util.Timer;
  37 import java.util.TimerTask;
  38 import java.util.concurrent.CountDownLatch;
  39 import java.util.concurrent.TimeUnit;
  40
  41 public class SmokeTest extends InstrumentationTestCase {
  42     private static final String TAG = "SmokeTest";
  43     private Random rnd = new Random();
  44
  45     @Override
  46     protected void setUp() throws Exception {
  47         super.setUp();
  48         PlatformConfig cfg = new PlatformConfig(
  49                 getInstrumentation().getContext(),
  50                 ServiceType.IN_PROC,
  51                 ModeType.CLIENT_SERVER,
  52                 "0.0.0.0",
  53                 0,
  54                 QualityOfService.LOW);
  55
  56         OcPlatform.Configure(cfg);
  57     }
  58
  59     @Override
  60     protected void tearDown() throws Exception {
  61         super.tearDown();
  62     }
  63
  64     public void testResourceRegisterUnregister() throws InterruptedException {
  65         final String resourceType = "unit.test.resource" +
  66                 new Date().getTime();
  67         final CountDownLatch signal = new CountDownLatch(1);
  68
  69         OcPlatform.EntityHandler entityHandler = new OcPlatform.EntityHandler() {
  70             @Override
  71             public EntityHandlerResult handleEntity(OcResourceRequest ocResourceRequest) {
  72                 return EntityHandlerResult.OK;
  73             }
  74         };
  75
  76         OcPlatform.OnResourceFoundListener resourceFoundListener =
  77                 new OcPlatform.OnResourceFoundListener() {
  78                     @Override
  79                     public void onResourceFound(OcResource resource) {
  80                         Log.i(TAG, "Host: " + resource.getHost());
  81                         Log.i(TAG, "Server ID: " + resource.getServerId());
  82                         Log.i(TAG, "Connectivity Types: ");
  83                         for (OcConnectivityType connectivityType : resource.getConnectivityTypeSet()) {
  84                             Log.i(TAG, " " + connectivityType);
  85                         }
  86                         signal.countDown();
  87                     }
  88
  89                     @Override
  90                     public void onFindResourceFailed(Throwable ex, String uri) {
  91                         Log.i(TAG, "Find Resource Failed for Uri: " + uri + " Error: " + ex.getMessage());
  92                     }
  93                 };
  94
  95         try {
  96             //server
  97             OcResourceHandle resourceHandle = OcPlatform.registerResource(
  98                     "/a/unittest",
  99                     resourceType,
 100                     OcPlatform.DEFAULT_INTERFACE,
 101                     entityHandler,
 102                     EnumSet.of(ResourceProperty.DISCOVERABLE)
 103             );
 104
 105             //client
 106             OcPlatform.findResource("",
 107                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
 108                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
 109                     resourceFoundListener);
 110
 111             //wait for onResourceFound event
 112             assertTrue(signal.await(60, TimeUnit.SECONDS));
 113
 114             //server
 115             OcPlatform.unregisterResource(resourceHandle);
 116         } catch (OcException e) {
 117             Log.e(TAG, e.getMessage());
 118             assertTrue(false);
 119         }
 120     }
 121
 122     public void testStartStopListenForPresence() throws InterruptedException {
 123         final String resourceType = "unit.test.resource" +
 124                 new Date().getTime();
 125         final CountDownLatch signal = new CountDownLatch(1);
 126
 127         OcPlatform.EntityHandler entityHandler = new OcPlatform.EntityHandler() {
 128             @Override
 129             public EntityHandlerResult handleEntity(OcResourceRequest ocResourceRequest) {
 130                 return EntityHandlerResult.OK;
 131             }
 132         };
 133
 134         final OcPlatform.OnPresenceListener presenceListener = new OcPlatform.OnPresenceListener() {
 135             @Override
 136             public void onPresence(OcPresenceStatus ocPresenceStatus, int nonce, String hostAddress) {
 137                 Log.i(TAG, "onPresence status " + ocPresenceStatus.toString() + " nonce " + nonce);
 138                 signal.countDown();
 139             }
 140         };
 141
 142         OcPlatform.OnResourceFoundListener resourceFoundListener =
 143                 new OcPlatform.OnResourceFoundListener() {
 144                     @Override
 145                     public void onResourceFound(OcResource resource) {
 146                         try {
 147                             //client
 148                             OcPresenceHandle presenceHandle = OcPlatform.subscribePresence(
 149                                     resource.getHost(),
 150                                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
 151                                     presenceListener
 152                             );
 153
 154                             //wait for onPresence event
 155                             assertTrue(signal.await(60, TimeUnit.SECONDS));
 156
 157                             //client
 158                             OcPlatform.unsubscribePresence(presenceHandle);
 159                         } catch (OcException e) {
 160                             assertTrue(false);
 161                         } catch (InterruptedException e) {
 162                             assertTrue(false);
 163                         }
 164                     }
 165
 166                     @Override
 167                     public void onFindResourceFailed(Throwable ex, String uri) {
 168                         Log.i(TAG, "Find Resource Failed for Uri: " + uri + " Error: " + ex.getMessage());
 169                     }
 170                 };
 171
 172         try {
 173             //server
 174             OcResourceHandle resourceHandle = OcPlatform.registerResource(
 175                     "/a/unittest",
 176                     resourceType,
 177                     OcPlatform.DEFAULT_INTERFACE,
 178                     entityHandler,
 179                     EnumSet.of(ResourceProperty.DISCOVERABLE, ResourceProperty.OBSERVABLE)
 180             );
 181
 182             //client
 183             OcPlatform.findResource("",
 184                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
 185                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
 186                     resourceFoundListener);
 187
 188             //server
 189             //wait 2 seconds for the client's resourceFoundListener to set the presenceListener.
 190             //the presenceListener must be set before startPresence() is called to get notified.
 191             try {
 192                 Thread.sleep(2000);
 193             } catch (InterruptedException e) {
 194                 Log.e(TAG, e.getMessage());
 195             }
 196             OcPlatform.startPresence(OcPlatform.DEFAULT_PRESENCE_TTL);
 197
 198             //wait for onPresence event
 199             assertTrue(signal.await(60, TimeUnit.SECONDS));
 200
 201             //server
 202             OcPlatform.stopPresence();
 203
 204             //client
 205             OcPlatform.unregisterResource(resourceHandle);
 206
 207         } catch (OcException e) {
 208             Log.e(TAG, e.getMessage());
 209             assertTrue(false);
 210         }
 211     }
 212
 213     public void testHandleGetRequest() throws InterruptedException {
 214         final String someKey = "SomeKey";
 215         final String someValue = "SomeValue";
 216         final String resourceType = "unit.test.resource" + new Date().getTime();
 217         final CountDownLatch signal1 = new CountDownLatch(1);
 218         final CountDownLatch signal2 = new CountDownLatch(1);
 219         final List<OcResource> ocResourceList = new LinkedList<OcResource>();
 220
 221         //client
 222         final OcResource.OnGetListener onGetListener = new OcResource.OnGetListener() {
 223             @Override
 224             public void onGetCompleted(List<OcHeaderOption> headerOptionList, OcRepresentation ocRepresentation) {
 225                 if (!headerOptionList.isEmpty()) {
 226                     for (OcHeaderOption headerOption : headerOptionList) {
 227                         Log.i(TAG, "Header option " +
 228                                 headerOption.getOptionId() +
 229                                 " : " +
 230                                 headerOption.getOptionData());
 231                     }
 232                 }
 233                 try {
 234                     Log.i(TAG, "Power: " + ocRepresentation.getValue("power"));
 235                 } catch (OcException e) {
 236                     Log.e(TAG, e.toString());
 237                     assertTrue(false);
 238                 }
 239                 signal2.countDown();
 240             }
 241
 242             @Override
 243             public void onGetFailed(Throwable ex) {
 244                 if (ex instanceof OcException) {
 245                     OcException ocEx = (OcException) ex;
 246                     ErrorCode errCode = ocEx.getErrorCode();
 247                     if (ErrorCode.NO_RESOURCE != errCode) {
 248                         Log.e(TAG, ocEx.getMessage());
 249                         assertTrue(false);
 250                     }
 251                 } else {
 252                     Log.e(TAG, ex.getMessage());
 253                     assertTrue(false);
 254                 }
 255             }
 256         };
 257
 258         //client
 259         final OcPlatform.OnResourceFoundListener resourceFoundListener =
 260                 new OcPlatform.OnResourceFoundListener() {
 261                     @Override
 262                     public void onResourceFound(OcResource resource) {
 263                         Map<String, String> queryParamsMap = new HashMap<String, String>();
 264                         queryParamsMap.put(someKey, someValue);
 265
 266                         ocResourceList.add(resource);
 267                         try {
 268                             resource.get(queryParamsMap, onGetListener);
 269 //                            TODO there is a bug in the stack that prevents the usage of the following APIs
 270 //                            resource.get(resourceType, OcPlatform.DEFAULT_INTERFACE, queryParamsMap,
 271 //                                    onGetListener);
 272 //
 273 //                            resource.get(queryParamsMap, onGetListener, QualityOfService.LOW);
 274 //
 275 //                            resource.get(resourceType, OcPlatform.DEFAULT_INTERFACE,queryParamsMap,
 276 //                                    onGetListener, QualityOfService.LOW);
 277                         } catch (OcException e) {
 278                             Log.e(TAG, e.toString());
 279                             assertTrue(false);
 280                         }
 281                         signal1.countDown();
 282                     }
 283
 284                     @Override
 285                     public void onFindResourceFailed(Throwable ex, String uri) {
 286                         Log.i(TAG, "Find Resource Failed for Uri: " + uri + " Error: " + ex.getMessage());
 287                     }
 288                 };
 289
 290         try {
 291             //server
 292             OcResourceHandle resourceHandle = OcPlatform.registerResource(
 293                     "/a/unittest",
 294                     resourceType,
 295                     OcPlatform.DEFAULT_INTERFACE,
 296                     new OcPlatform.EntityHandler() {
 297                         @Override
 298                         public EntityHandlerResult handleEntity(OcResourceRequest ocResourceRequest) {
 299                             EnumSet<RequestHandlerFlag> handlerFlagSet =
 300                                     ocResourceRequest.getRequestHandlerFlagSet();
 301
 302                             RequestType requestType = ocResourceRequest.getRequestType();
 303
 304                             if (handlerFlagSet.contains(RequestHandlerFlag.INIT)) {
 305                             }
 306                             if (handlerFlagSet.contains(RequestHandlerFlag.REQUEST)) {
 307                                 OcResourceResponse ocResourceResponse = new OcResourceResponse();
 308                                 ocResourceResponse.setRequestHandle(
 309                                         ocResourceRequest.getRequestHandle());
 310                                 ocResourceResponse.setResourceHandle(
 311                                         ocResourceRequest.getResourceHandle());
 312
 313                                 switch (requestType) {
 314                                     case GET:
 315                                         Map<String, String> queryParams =
 316                                                 ocResourceRequest.getQueryParameters();
 317
 318                                         if (!(queryParams.containsKey(someKey) &&
 319                                                 someValue.equals(queryParams.get(someKey)))) {
 320                                             assertTrue(false);
 321                                         }
 322
 323                                         ocResourceResponse.setErrorCode(200);
 324                                         ocResourceResponse.setResponseResult(EntityHandlerResult.OK);
 325                                         ocResourceResponse.setResourceRepresentation(
 326                                                 getRepresentation(74));
 327                                         break;
 328                                 }
 329
 330                                 try {
 331                                     OcPlatform.sendResponse(ocResourceResponse);
 332                                 } catch (OcException e) {
 333                                     Log.e(TAG, e.getMessage());
 334                                     return EntityHandlerResult.ERROR;
 335                                 }
 336                             }
 337                             if (handlerFlagSet.contains(RequestHandlerFlag.OBSERVER)) {
 338                             }
 339                             return EntityHandlerResult.OK;
 340                         }
 341                     },
 342                     EnumSet.of(ResourceProperty.DISCOVERABLE)
 343             );
 344
 345             //client
 346             OcPlatform.findResource(null,
 347                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
 348                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
 349                     resourceFoundListener);
 350
 351             //wait for onResourceFound event
 352             assertTrue(signal1.await(60, TimeUnit.SECONDS));
 353
 354             //wait for onGetCompleted event
 355             assertTrue(signal2.await(60, TimeUnit.SECONDS));
 356
 357             //server
 358             OcPlatform.unregisterResource(resourceHandle);
 359
 360         } catch (OcException e) {
 361             Log.e(TAG, e.getMessage());
 362             assertTrue(false);
 363         }
 364     }
 365
 366     public void testHandlePutRequest() throws InterruptedException {
 367         final String resourceType = "unit.test.resource" + new Date().getTime();
 368         final CountDownLatch signal1 = new CountDownLatch(1);
 369         final CountDownLatch signal2 = new CountDownLatch(3);
 370         final List<OcResource> ocResourceList = new LinkedList<OcResource>();
 371
 372         final OcResource.OnPutListener onPutListener = new OcResource.OnPutListener() {
 373             @Override
 374             public void onPutCompleted(List<OcHeaderOption> headerOptionList, OcRepresentation ocRepresentation) {
 375                 if (!headerOptionList.isEmpty()) {
 376                     for (OcHeaderOption headerOption : headerOptionList) {
 377                         Log.i(TAG, "Header option " +
 378                                 headerOption.getOptionId() +
 379                                 " : " +
 380                                 headerOption.getOptionData());
 381                     }
 382                 }
 383                 try {
 384                     Log.i(TAG, "onPutCompleted Power: " + ocRepresentation.getValue("power"));
 385                 } catch (OcException e) {
 386                     Log.e(TAG, e.getMessage());
 387                     assertTrue(false);
 388                 }
 389                 Log.i(TAG, "onPutCompleted Uri: " + ocRepresentation.getUri());
 390                 signal2.countDown();
 391             }
 392
 393             @Override
 394             public void onPutFailed(Throwable ex) {
 395                 if (ex instanceof OcException) {
 396                     OcException ocEx = (OcException) ex;
 397                     ErrorCode errCode = ocEx.getErrorCode();
 398                     if (ErrorCode.NO_RESOURCE != errCode) {
 399                         Log.e(TAG, ocEx.getMessage());
 400                         assertTrue(false);
 401                     }
 402                 } else {
 403                     Log.e(TAG, ex.getMessage());
 404                     assertTrue(false);
 405                 }
 406             }
 407         };
 408
 409         final OcPlatform.OnResourceFoundListener resourceFoundListener =
 410                 new OcPlatform.OnResourceFoundListener() {
 411                     @Override
 412                     public void onResourceFound(OcResource resource) {
 413                         ocResourceList.add(resource);
 414                         try {
 415                             resource.put(
 416                                     getRepresentation(),
 417                                     new HashMap<String, String>(),
 418                                     onPutListener);
 419
 420                             resource.put(
 421                                     getRepresentation(),
 422                                     new HashMap<String, String>(),
 423                                     onPutListener);
 424
 425                             resource.put(
 426                                     getRepresentation(),
 427                                     new HashMap<String, String>(),
 428                                     new OcResource.OnPutListener() {
 429                                         @Override
 430                                         public void onPutCompleted(List<OcHeaderOption> headerOptionList, OcRepresentation ocRepresentation) {
 431                                             signal2.countDown();
 432                                         }
 433
 434                                         @Override
 435                                         public void onPutFailed(Throwable ex) {
 436                                             if (ex instanceof OcException) {
 437                                                 OcException ocEx = (OcException) ex;
 438                                                 ErrorCode errCode = ocEx.getErrorCode();
 439                                                 if (ErrorCode.NO_RESOURCE != errCode) {
 440                                                     Log.e(TAG, ocEx.getMessage());
 441                                                     assertTrue(false);
 442                                                 }
 443                                             } else {
 444                                                 Log.e(TAG, ex.getMessage());
 445                                                 assertTrue(false);
 446                                             }
 447                                         }
 448                                     });
 449
 450                         } catch (OcException e) {
 451                             assertTrue(false);
 452                         }
 453                         signal1.countDown();
 454                     }
 455
 456                     @Override
 457                     public void onFindResourceFailed(Throwable ex, String uri) {
 458                         Log.i(TAG, "Find Resource Failed for Uri: " + uri + " Error: " + ex.getMessage());
 459                     }
 460                 };
 461
 462         try {
 463             //server
 464             OcResourceHandle resourceHandle = OcPlatform.registerResource(
 465                     "/a/unittest",
 466                     resourceType,
 467                     OcPlatform.DEFAULT_INTERFACE,
 468                     new OcPlatform.EntityHandler() {
 469                         @Override
 470                         public EntityHandlerResult handleEntity(OcResourceRequest ocResourceRequest) {
 471                             EnumSet<RequestHandlerFlag> handlerFlagSet = ocResourceRequest.getRequestHandlerFlagSet();
 472                             RequestType requestType = ocResourceRequest.getRequestType();
 473
 474                             if (handlerFlagSet.contains(RequestHandlerFlag.INIT)) {
 475                             }
 476                             if (handlerFlagSet.contains(RequestHandlerFlag.REQUEST)) {
 477                                 OcResourceResponse ocResourceResponse = new OcResourceResponse();
 478                                 ocResourceResponse.setRequestHandle(
 479                                         ocResourceRequest.getRequestHandle());
 480                                 ocResourceResponse.setResourceHandle(
 481                                         ocResourceRequest.getResourceHandle());
 482
 483                                 switch (requestType) {
 484                                     case GET:
 485                                         assertTrue(false);
 486                                         break;
 487                                     case PUT:
 488                                         OcRepresentation rep = ocResourceRequest.getResourceRepresentation();
 489                                         try {
 490                                             Log.i(TAG, "Put res. power: " + rep.getValue("power"));
 491                                         } catch (OcException e) {
 492                                             Log.e(TAG, e.toString());
 493                                             assertTrue(false);
 494                                         }
 495                                         Log.i(TAG, "URI: " + rep.getUri());
 496
 497                                         ocResourceResponse.setResponseResult(EntityHandlerResult.OK);
 498                                         ocResourceResponse.setErrorCode(200);
 499                                         ocResourceResponse.setResourceRepresentation(rep);
 500                                         break;
 501                                     case POST:
 502                                         assertTrue(false);
 503                                         break;
 504                                     case DELETE:
 505                                         break;
 506                                 }
 507
 508                                 try {
 509                                     OcPlatform.sendResponse(ocResourceResponse);
 510                                 } catch (OcException e) {
 511                                     Log.e(TAG, e.getMessage());
 512                                     return EntityHandlerResult.ERROR;
 513                                 }
 514                             }
 515                             if (handlerFlagSet.contains(RequestHandlerFlag.OBSERVER)) {
 516                             }
 517                             return EntityHandlerResult.OK;
 518                         }
 519                     },
 520                     EnumSet.of(ResourceProperty.DISCOVERABLE)
 521             );
 522
 523             //client
 524             OcPlatform.findResource("",
 525                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
 526                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
 527                     resourceFoundListener);
 528
 529             //wait for onResourceFound event
 530             assertTrue(signal1.await(60, TimeUnit.SECONDS));
 531
 532             //wait for onGetCompleted event
 533             assertTrue(signal2.await(60, TimeUnit.SECONDS));
 534
 535             //server
 536             OcPlatform.unregisterResource(resourceHandle);
 537
 538         } catch (OcException e) {
 539             Log.e(TAG, e.getMessage());
 540             assertTrue(false);
 541         }
 542     }
 543
 544     public void testHandlePostRequest() throws InterruptedException {
 545         final String resourceType = "unit.test.resource" + new Date().getTime();
 546         final CountDownLatch signal1 = new CountDownLatch(1);
 547         final CountDownLatch signal2 = new CountDownLatch(3);
 548         final List<OcResource> ocResourceList = new LinkedList<OcResource>();
 549
 550         final OcResource.OnPostListener onPostListener = new OcResource.OnPostListener() {
 551             @Override
 552             public void onPostCompleted(List<OcHeaderOption> headerOptionList, OcRepresentation ocRepresentation) {
 553                 if (!headerOptionList.isEmpty()) {
 554                     for (OcHeaderOption headerOption : headerOptionList) {
 555                         Log.i(TAG, "Header option " +
 556                                 headerOption.getOptionId() +
 557                                 " : " +
 558                                 headerOption.getOptionData());
 559                     }
 560                 }
 561                 try {
 562                     Log.i(TAG, "onPostCompleted Power: " + ocRepresentation.getValue("power"));
 563                 } catch (OcException e) {
 564                     Log.e(TAG, e.toString());
 565                     assertTrue(false);
 566                 }
 567                 Log.i(TAG, "onPostCompleted Uri: " + ocRepresentation.getUri());
 568                 signal2.countDown();
 569             }
 570
 571             @Override
 572             public void onPostFailed(Throwable ex) {
 573                 if (ex instanceof OcException) {
 574                     OcException ocEx = (OcException) ex;
 575                     ErrorCode errCode = ocEx.getErrorCode();
 576                     if (ErrorCode.NO_RESOURCE != errCode) {
 577                         Log.e(TAG, ocEx.getMessage());
 578                         assertTrue(false);
 579                     }
 580                 } else {
 581                     Log.e(TAG, ex.getMessage());
 582                     assertTrue(false);
 583                 }
 584             }
 585         };
 586
 587         final OcPlatform.OnResourceFoundListener resourceFoundListener =
 588                 new OcPlatform.OnResourceFoundListener() {
 589                     @Override
 590                     public void onResourceFound(OcResource resource) {
 591                         ocResourceList.add(resource);
 592                         try {
 593                             resource.post(
 594                                     getRepresentation(),
 595                                     new HashMap<String, String>(),
 596                                     onPostListener);
 597
 598                             resource.post(
 599                                     getRepresentation(),
 600                                     new HashMap<String, String>(),
 601                                     onPostListener);
 602
 603                             resource.post(
 604                                     getRepresentation(),
 605                                     new HashMap<String, String>(),
 606                                     new OcResource.OnPostListener() {
 607                                         @Override
 608                                         public void onPostCompleted(List<OcHeaderOption> headerOptionList, OcRepresentation ocRepresentation) {
 609                                             signal2.countDown();
 610                                         }
 611
 612                                         @Override
 613                                         public void onPostFailed(Throwable ex) {
 614                                             if (ex instanceof OcException) {
 615                                                 OcException ocEx = (OcException) ex;
 616                                                 ErrorCode errCode = ocEx.getErrorCode();
 617                                                 if (ErrorCode.NO_RESOURCE != errCode) {
 618                                                     Log.e(TAG, ocEx.getMessage());
 619                                                     assertTrue(false);
 620                                                 }
 621                                             } else {
 622                                                 Log.e(TAG, ex.getMessage());
 623                                                 assertTrue(false);
 624                                             }
 625                                         }
 626                                     });
 627
 628                         } catch (OcException e) {
 629                             assertTrue(false);
 630                         }
 631                         signal1.countDown();
 632                     }
 633
 634                     @Override
 635                     public void onFindResourceFailed(Throwable ex, String uri) {
 636                         Log.i(TAG, "Find Resource Failed for Uri: " + uri + " Error: " + ex.getMessage());
 637                     }
 638                 };
 639
 640         try {
 641             //server
 642             OcResourceHandle resourceHandle = OcPlatform.registerResource(
 643                     "/a/unittest",
 644                     resourceType,
 645                     OcPlatform.DEFAULT_INTERFACE,
 646                     new OcPlatform.EntityHandler() {
 647                         @Override
 648                         public EntityHandlerResult handleEntity(OcResourceRequest ocResourceRequest) {
 649                             EnumSet<RequestHandlerFlag> handlerFlagSet = ocResourceRequest.getRequestHandlerFlagSet();
 650                             RequestType requestType = ocResourceRequest.getRequestType();
 651
 652                             if (handlerFlagSet.contains(RequestHandlerFlag.INIT)) {
 653                             }
 654                             if (handlerFlagSet.contains(RequestHandlerFlag.REQUEST)) {
 655                                 OcResourceResponse ocResourceResponse = new OcResourceResponse();
 656                                 ocResourceResponse.setRequestHandle(
 657                                         ocResourceRequest.getRequestHandle());
 658                                 ocResourceResponse.setResourceHandle(
 659                                         ocResourceRequest.getResourceHandle());
 660
 661                                 switch (requestType) {
 662                                     case GET:
 663                                         assertTrue(false);
 664                                         break;
 665                                     case PUT:
 666                                         assertTrue(false);
 667                                         break;
 668                                     case POST:
 669                                         OcRepresentation rep = ocResourceRequest.getResourceRepresentation();
 670                                         try {
 671                                             Log.i(TAG, "Post res. power: " + rep.getValue("power"));
 672                                         } catch (OcException e) {
 673                                             Log.e(TAG, e.toString());
 674                                             assertTrue(false);
 675                                         }
 676                                         Log.i(TAG, "URI: " + rep.getUri());
 677
 678                                         ocResourceResponse.setErrorCode(200);
 679                                         ocResourceResponse.setResponseResult(EntityHandlerResult.OK);
 680                                         ocResourceResponse.setResourceRepresentation(
 681                                                 getRepresentation(44));
 682
 683                                         break;
 684                                     case DELETE:
 685                                         assertTrue(false);
 686                                         break;
 687                                 }
 688
 689                                 try {
 690                                     OcPlatform.sendResponse(ocResourceResponse);
 691                                 } catch (OcException e) {
 692                                     Log.e(TAG, e.getMessage());
 693                                     return EntityHandlerResult.ERROR;
 694                                 }
 695                             }
 696                             if (handlerFlagSet.contains(RequestHandlerFlag.OBSERVER)) {
 697                             }
 698                             return EntityHandlerResult.OK;
 699                         }
 700                     },
 701                     EnumSet.of(ResourceProperty.DISCOVERABLE)
 702             );
 703
 704             //client
 705             OcPlatform.findResource("",
 706                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
 707                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
 708                     resourceFoundListener);
 709
 710             //wait for onResourceFound event
 711             assertTrue(signal1.await(60, TimeUnit.SECONDS));
 712
 713             //wait for onPostCompleted event
 714             assertTrue(signal2.await(60, TimeUnit.SECONDS));
 715
 716             //server
 717             OcPlatform.unregisterResource(resourceHandle);
 718
 719         } catch (OcException e) {
 720             Log.e(TAG, e.getMessage());
 721             assertTrue(false);
 722         }
 723
 724     }
 725
 726     public void testHandleDeleteRequest() throws InterruptedException {
 727         final String resourceType = "unit.test.resource" + new Date().getTime();
 728         final CountDownLatch signal1 = new CountDownLatch(1);
 729         final CountDownLatch signal2 = new CountDownLatch(1);
 730         final List<OcResource> ocResourceList = new LinkedList<OcResource>();
 731
 732         final OcResource.OnDeleteListener onDeleteListener = new OcResource.OnDeleteListener() {
 733             @Override
 734             public void onDeleteCompleted(List<OcHeaderOption> headerOptionList) {
 735                 signal2.countDown();
 736             }
 737
 738             @Override
 739             public void onDeleteFailed(Throwable ex) {
 740                 if (ex instanceof OcException) {
 741                     OcException ocEx = (OcException) ex;
 742                     ErrorCode errCode = ocEx.getErrorCode();
 743                     if (ErrorCode.NO_RESOURCE != errCode) {
 744                         Log.e(TAG, ocEx.getMessage());
 745                         assertTrue(false);
 746                     }
 747                 } else {
 748                     Log.e(TAG, ex.getMessage());
 749                     assertTrue(false);
 750                 }
 751             }
 752         };
 753
 754         final OcPlatform.OnResourceFoundListener resourceFoundListener =
 755                 new OcPlatform.OnResourceFoundListener() {
 756                     @Override
 757                     public void onResourceFound(OcResource resource) {
 758                         ocResourceList.add(resource);
 759                         try {
 760                             resource.deleteResource(onDeleteListener);
 761                         } catch (OcException e) {
 762                             assertTrue(false);
 763                         }
 764                         signal1.countDown();
 765                     }
 766
 767                     @Override
 768                     public void onFindResourceFailed(Throwable ex, String uri) {
 769                         Log.i(TAG, "Find Resource Failed for Uri: " + uri + " Error: " + ex.getMessage());
 770                     }
 771                 };
 772
 773         try {
 774             //server
 775             OcResourceHandle resourceHandle = OcPlatform.registerResource(
 776                     "/a/unittest",
 777                     resourceType,
 778                     OcPlatform.DEFAULT_INTERFACE,
 779                     new OcPlatform.EntityHandler() {
 780                         @Override
 781                         public EntityHandlerResult handleEntity(OcResourceRequest ocResourceRequest) {
 782                             EnumSet<RequestHandlerFlag> handlerFlagSet =
 783                                     ocResourceRequest.getRequestHandlerFlagSet();
 784                             RequestType requestType = ocResourceRequest.getRequestType();
 785
 786                             if (handlerFlagSet.contains(RequestHandlerFlag.INIT)) {
 787                             }
 788                             if (handlerFlagSet.contains(RequestHandlerFlag.REQUEST)) {
 789                                 OcResourceResponse ocResourceResponse = new OcResourceResponse();
 790                                 ocResourceResponse.setRequestHandle(
 791                                         ocResourceRequest.getRequestHandle());
 792                                 ocResourceResponse.setResourceHandle(
 793                                         ocResourceRequest.getResourceHandle());
 794
 795                                 switch (requestType) {
 796                                     case DELETE:
 797                                         ocResourceResponse.setErrorCode(200);
 798                                         ocResourceResponse.setResponseResult(
 799                                                 EntityHandlerResult.RESOURCE_DELETED);
 800                                         break;
 801                                 }
 802
 803                                 try {
 804                                     OcPlatform.sendResponse(ocResourceResponse);
 805                                 } catch (OcException e) {
 806                                     Log.e(TAG, e.getMessage());
 807                                     return EntityHandlerResult.ERROR;
 808                                 }
 809                             }
 810                             if (handlerFlagSet.contains(RequestHandlerFlag.OBSERVER)) {
 811                             }
 812                             return EntityHandlerResult.OK;
 813                         }
 814                     },
 815                     EnumSet.of(ResourceProperty.DISCOVERABLE)
 816             );
 817
 818             //client
 819             OcPlatform.findResource("",
 820                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
 821                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
 822                     resourceFoundListener);
 823
 824             //wait for onResourceFound event
 825             assertTrue(signal1.await(60, TimeUnit.SECONDS));
 826
 827             //wait for onDeleteCompleted event
 828             assertTrue(signal2.await(60, TimeUnit.SECONDS));
 829
 830             //server
 831             OcPlatform.unregisterResource(resourceHandle);
 832
 833         } catch (OcException e) {
 834             Log.e(TAG, e.getMessage());
 835             assertTrue(false);
 836         }
 837     }
 838
 839     public void testHandleGetPutPostDeleteFailures() throws InterruptedException {
 840         final String resourceType = "unit.test.resource" + new Date().getTime();
 841         final CountDownLatch signal1 = new CountDownLatch(1);
 842         final CountDownLatch signal2 = new CountDownLatch(1);
 843         final CountDownLatch signal3 = new CountDownLatch(1);
 844         final CountDownLatch signal4 = new CountDownLatch(1);
 845         final CountDownLatch signal5 = new CountDownLatch(1);
 846
 847         final List<OcResource> ocResourceList = new LinkedList<OcResource>();
 848         final OcResource.OnGetListener onGetListener = new OcResource.OnGetListener() {
 849             @Override
 850             public void onGetCompleted(List<OcHeaderOption> headerOptionList,
 851                                        OcRepresentation ocRepresentation) {
 852                 assertTrue(false);
 853             }
 854
 855             @Override
 856             public void onGetFailed(Throwable ex) {
 857                 if (ex instanceof OcException) {
 858                     OcException ocEx = (OcException) ex;
 859                     ErrorCode errCode = ocEx.getErrorCode();
 860                 }
 861                 Log.i(TAG, ex.toString());
 862                 signal2.countDown();
 863             }
 864         };
 865
 866         final OcResource.OnPutListener onPutListener = new OcResource.OnPutListener() {
 867             @Override
 868             public void onPutCompleted(List<OcHeaderOption> headerOptionList,
 869                                        OcRepresentation ocRepresentation) {
 870                 assertTrue(false);
 871             }
 872
 873             @Override
 874             public void onPutFailed(Throwable ex) {
 875                 if (ex instanceof OcException) {
 876                     OcException ocEx = (OcException) ex;
 877                     ErrorCode errCode = ocEx.getErrorCode();
 878                 }
 879                 Log.i(TAG, ex.toString());
 880                 signal3.countDown();
 881             }
 882         };
 883         final OcResource.OnPostListener onPostListener = new OcResource.OnPostListener() {
 884             @Override
 885             public void onPostCompleted(List<OcHeaderOption> headerOptionList,
 886                                         OcRepresentation ocRepresentation) {
 887                 assertTrue(false);
 888             }
 889
 890             @Override
 891             public void onPostFailed(Throwable ex) {
 892                 if (ex instanceof OcException) {
 893                     OcException ocEx = (OcException) ex;
 894                     ErrorCode errCode = ocEx.getErrorCode();
 895                 }
 896                 Log.i(TAG, ex.toString());
 897                 signal4.countDown();
 898             }
 899         };
 900
 901         final OcResource.OnDeleteListener onDeleteListener = new OcResource.OnDeleteListener() {
 902             @Override
 903             public void onDeleteCompleted(List<OcHeaderOption> headerOptionList) {
 904                 assertTrue(false);
 905             }
 906
 907             @Override
 908             public void onDeleteFailed(Throwable ex) {
 909                 if (ex instanceof OcException) {
 910                     OcException ocEx = (OcException) ex;
 911                     ErrorCode errCode = ocEx.getErrorCode();
 912                 }
 913                 Log.i(TAG, ex.toString());
 914                 signal5.countDown();
 915             }
 916         };
 917
 918         final OcPlatform.OnResourceFoundListener resourceFoundListener =
 919                 new OcPlatform.OnResourceFoundListener() {
 920                     @Override
 921                     public void onResourceFound(OcResource resource) {
 922                         ocResourceList.add(resource);
 923                         try {
 924                             resource.get(new HashMap<String, String>(), onGetListener);
 925                             resource.put(new OcRepresentation(), new HashMap<String, String>(),
 926                                     onPutListener);
 927                             resource.post(new OcRepresentation(), new HashMap<String, String>(),
 928                                     onPostListener);
 929                             resource.deleteResource(onDeleteListener);
 930                         } catch (OcException e) {
 931                             assertTrue(false);
 932                         }
 933                         signal1.countDown();
 934                     }
 935
 936                     @Override
 937                     public void onFindResourceFailed(Throwable ex, String uri) {
 938                         Log.i(TAG, "Find Resource Failed for Uri: " + uri + " Error: " + ex.getMessage());
 939                     }
 940                 };
 941
 942         try {
 943             //server
 944             OcResourceHandle resourceHandle = OcPlatform.registerResource(
 945                     "/a/unittest",
 946                     resourceType,
 947                     OcPlatform.DEFAULT_INTERFACE,
 948                     new OcPlatform.EntityHandler() {
 949                         @Override
 950                         public EntityHandlerResult handleEntity(OcResourceRequest ocResourceRequest) {
 951                             EnumSet<RequestHandlerFlag> handlerFlagSet =
 952                                     ocResourceRequest.getRequestHandlerFlagSet();
 953                             RequestType requestType = ocResourceRequest.getRequestType();
 954
 955                             if (handlerFlagSet.contains(RequestHandlerFlag.INIT)) {
 956                             }
 957                             if (handlerFlagSet.contains(RequestHandlerFlag.REQUEST)) {
 958                                 OcResourceResponse ocResourceResponse = new OcResourceResponse();
 959                                 ocResourceResponse.setRequestHandle(
 960                                         ocResourceRequest.getRequestHandle());
 961                                 ocResourceResponse.setResourceHandle(
 962                                         ocResourceRequest.getResourceHandle());
 963
 964                                 switch (requestType) {
 965                                     case GET:
 966                                         ocResourceResponse.setErrorCode(200);
 967                                         ocResourceResponse.setResponseResult(
 968                                                 EntityHandlerResult.ERROR);
 969                                         break;
 970                                     case PUT:
 971                                         ocResourceResponse.setErrorCode(200);
 972                                         ocResourceResponse.setResponseResult(
 973                                                 EntityHandlerResult.ERROR);
 974                                         break;
 975                                     case POST:
 976                                         ocResourceResponse.setErrorCode(200);
 977                                         ocResourceResponse.setResponseResult(
 978                                                 EntityHandlerResult.ERROR);
 979                                         break;
 980                                     case DELETE:
 981                                         ocResourceResponse.setErrorCode(200);
 982                                         ocResourceResponse.setResponseResult(
 983                                                 EntityHandlerResult.ERROR);
 984                                         break;
 985                                 }
 986                                 try {
 987                                     OcPlatform.sendResponse(ocResourceResponse);
 988                                 } catch (OcException e) {
 989                                     Log.e(TAG, e.getMessage());
 990                                     return EntityHandlerResult.ERROR;
 991                                 }
 992                             }
 993                             if (handlerFlagSet.contains(RequestHandlerFlag.OBSERVER)) {
 994                             }
 995                             return EntityHandlerResult.OK;
 996                         }
 997                     },
 998                     EnumSet.of(ResourceProperty.DISCOVERABLE)
 999             );
1000
1001             //client
1002             OcPlatform.findResource("",
1003                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
1004                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1005                     resourceFoundListener);
1006
1007             //wait for onResourceFound event
1008             assertTrue(signal1.await(60, TimeUnit.SECONDS));
1009             //wait for onGetCompleted event
1010             assertTrue(signal2.await(60, TimeUnit.SECONDS));
1011             //wait for onPutCompleted event
1012             assertTrue(signal3.await(60, TimeUnit.SECONDS));
1013             //wait for onPostCompleted event
1014             assertTrue(signal4.await(60, TimeUnit.SECONDS));
1015             //wait for onDeleteCompleted event
1016             assertTrue(signal5.await(60, TimeUnit.SECONDS));
1017
1018             //server
1019             OcPlatform.unregisterResource(resourceHandle);
1020
1021         } catch (OcException e) {
1022             Log.e(TAG, e.getMessage());
1023             assertTrue(false);
1024         }
1025     }
1026
1027     public void testPlatformInfo() throws InterruptedException {
1028         final String resourceType = "unit.test.resource" + new Date().getTime();
1029         final CountDownLatch signal = new CountDownLatch(1);
1030
1031         OcPlatform.OnPlatformFoundListener platformFoundListener = new OcPlatform.OnPlatformFoundListener() {
1032             @Override
1033             public void onPlatformFound(OcRepresentation ocRepresentation) {
1034                 Log.i(TAG, "Platform Info Received: ");
1035                 Log.i(TAG, "URI: " + ocRepresentation.getUri());
1036                 signal.countDown();
1037             }
1038         };
1039
1040         OcPlatformInfo platformInfo = null;
1041
1042         platformInfo = new OcPlatformInfo("myPlatformID", "myManuName", "myManuUrl");
1043
1044         platformInfo.setModelNumber("myModelNumber");
1045         platformInfo.setDateOfManufacture("myDateOfManufacture");
1046         platformInfo.setPlatformVersion("myPlatformVersion");
1047         platformInfo.setOperatingSystemVersion("myOperatingSystemVersion");
1048         platformInfo.setHardwareVersion("myHardwareVersion");
1049         platformInfo.setFirmwareVersion("myFirmwareVersion");
1050         platformInfo.setSupportUrl("mySupportUrl");
1051         platformInfo.setSystemTime("mySystemTime");
1052
1053         try {
1054             //server
1055             OcPlatform.registerPlatformInfo(platformInfo);
1056
1057             //client
1058             OcPlatform.getPlatformInfo(
1059                     "",
1060                     OcPlatform.WELL_KNOWN_PLATFORM_QUERY,
1061                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1062                     platformFoundListener);
1063
1064             //wait for onPlatformFound event
1065             assertTrue(signal.await(60, TimeUnit.SECONDS));
1066         } catch (OcException e) {
1067             Log.e(TAG, e.getMessage() + platformInfo.toString());
1068             assertTrue(false);
1069         }
1070     }
1071
1072     public void testRegisterDeviceInfoGetDeviceInfo() throws InterruptedException {
1073         final String resourceType = "unit.test.resource" + new Date().getTime();
1074         final CountDownLatch signal = new CountDownLatch(1);
1075
1076         OcPlatform.OnDeviceFoundListener deviceFoundListener = new OcPlatform.OnDeviceFoundListener() {
1077             @Override
1078             public void onDeviceFound(OcRepresentation ocRepresentation) {
1079                 try {
1080                     Log.i(TAG, "Device Name: " + ocRepresentation.getValue("n"));
1081                 } catch (OcException e) {
1082                     Log.e(TAG, e.toString());
1083                     assertTrue(false);
1084                 }
1085                 boolean hasDeviceNameAtr = ocRepresentation.hasAttribute("n");
1086                 assertTrue(hasDeviceNameAtr);
1087                 boolean hasNonExistingAtr = ocRepresentation.hasAttribute("NonExisting");
1088                 assertFalse(hasNonExistingAtr);
1089                 Log.i(TAG, "URI: " + ocRepresentation.getUri());
1090                 signal.countDown();
1091             }
1092         };
1093
1094         OcDeviceInfo devInfo = new OcDeviceInfo(
1095                 "myDeviceName",
1096                 Arrays.asList(new String[]{"oic.d.test"})
1097         );
1098
1099         try {
1100             //server
1101             OcPlatform.registerDeviceInfo(devInfo);
1102             //client
1103             OcPlatform.getDeviceInfo(
1104                     "",
1105                     OcPlatform.WELL_KNOWN_DEVICE_QUERY,
1106                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1107                     deviceFoundListener);
1108
1109             //wait for onDeviceFound event
1110             assertTrue(signal.await(60, TimeUnit.SECONDS));
1111
1112         } catch (OcException e) {
1113             Log.e(TAG, e.getMessage());
1114             assertTrue(false);
1115         }
1116     }
1117
1118     public void testBindUnbindResources() throws InterruptedException {
1119         final String resourceType = "unit.test.resource" + new Date().getTime();
1120         final CountDownLatch signal1 = new CountDownLatch(3);
1121         final CountDownLatch signal2 = new CountDownLatch(2);
1122         final CountDownLatch signal3 = new CountDownLatch(1);
1123         final CountDownLatch signal4 = new CountDownLatch(3);
1124         final CountDownLatch signal5 = new CountDownLatch(3);
1125         final CountDownLatch signal6 = new CountDownLatch(1);
1126
1127         OcPlatform.EntityHandler entityHandler = new OcPlatform.EntityHandler() {
1128             @Override
1129             public EntityHandlerResult handleEntity(OcResourceRequest ocResourceRequest) {
1130                 return EntityHandlerResult.OK;
1131             }
1132         };
1133
1134         OcPlatform.OnResourceFoundListener resourceFoundListener1 = new OcPlatform.OnResourceFoundListener() {
1135             @Override
1136             public void onResourceFound(OcResource resource) {
1137                 signal1.countDown();
1138             }
1139
1140             @Override
1141             public void onFindResourceFailed(Throwable ex, String uri) {
1142                 Log.i(TAG, "Find Resource Failed for Uri: " + uri + " Error: " + ex.getMessage());
1143             }
1144         };
1145
1146         OcPlatform.OnResourceFoundListener resourceFoundListener2 = new OcPlatform.OnResourceFoundListener() {
1147             @Override
1148             public void onResourceFound(OcResource resource) {
1149                 signal2.countDown();
1150             }
1151
1152             @Override
1153             public void onFindResourceFailed(Throwable ex, String uri) {
1154                 Log.i(TAG, "Find Resource Failed for Uri: " + uri + " Error: " + ex.getMessage());
1155             }
1156         };
1157
1158         OcPlatform.OnResourceFoundListener resourceFoundListener3 = new OcPlatform.OnResourceFoundListener() {
1159             @Override
1160             public void onResourceFound(OcResource resource) {
1161                 signal3.countDown();
1162             }
1163
1164             @Override
1165             public void onFindResourceFailed(Throwable ex, String uri) {
1166                 Log.i(TAG, "Find Resource Failed for Uri: " + uri + " Error: " + ex.getMessage());
1167             }
1168         };
1169
1170         OcPlatform.OnResourceFoundListener resourceFoundListener4 = new OcPlatform.OnResourceFoundListener() {
1171             @Override
1172             public void onResourceFound(OcResource resource) {
1173                 signal4.countDown();
1174             }
1175
1176             @Override
1177             public void onFindResourceFailed(Throwable ex, String uri) {
1178                 Log.i(TAG, "Find Resource Failed for Uri: " + uri + " Error: " + ex.getMessage());
1179             }
1180         };
1181
1182         OcPlatform.OnResourceFoundListener resourceFoundListener5 = new OcPlatform.OnResourceFoundListener() {
1183             @Override
1184             public void onResourceFound(OcResource resource) {
1185                 signal5.countDown();
1186             }
1187
1188             @Override
1189             public void onFindResourceFailed(Throwable ex, String uri) {
1190                 Log.i(TAG, "Find Resource Failed for Uri: " + uri + " Error: " + ex.getMessage());
1191             }
1192         };
1193
1194         OcPlatform.OnResourceFoundListener resourceFoundListener6 = new OcPlatform.OnResourceFoundListener() {
1195             @Override
1196             public void onResourceFound(OcResource resource) {
1197                 signal6.countDown();
1198             }
1199
1200             @Override
1201             public void onFindResourceFailed(Throwable ex, String uri) {
1202                 Log.i(TAG, "Find Resource Failed for Uri: " + uri + " Error: " + ex.getMessage());
1203             }
1204         };
1205
1206         try {
1207
1208             //server
1209             OcResourceHandle resourceHandleCollection = OcPlatform.registerResource(
1210                     "/a/unittest1",
1211                     resourceType,
1212                     OcPlatform.DEFAULT_INTERFACE,
1213                     entityHandler,
1214                     EnumSet.of(ResourceProperty.DISCOVERABLE)
1215             );
1216
1217             OcResourceHandle resourceHandle1 = OcPlatform.registerResource(
1218                     "/a/unittest2",
1219                     resourceType,
1220                     OcPlatform.DEFAULT_INTERFACE,
1221                     entityHandler,
1222                     EnumSet.of(ResourceProperty.DISCOVERABLE)
1223             );
1224
1225             OcResourceHandle resourceHandle2 = OcPlatform.registerResource(
1226                     "/a/unittest3",
1227                     resourceType,
1228                     OcPlatform.DEFAULT_INTERFACE,
1229                     entityHandler,
1230                     EnumSet.of(ResourceProperty.DISCOVERABLE)
1231             );
1232
1233             //client
1234             OcPlatform.findResource("",
1235                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
1236                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1237                     resourceFoundListener1);
1238
1239             //wait for onResourceFound event to find 3 registered resources
1240             assertTrue(signal1.await(60, TimeUnit.SECONDS));
1241
1242             //server
1243             OcPlatform.bindResource(resourceHandleCollection, resourceHandle1);
1244             OcPlatform.bindResource(resourceHandleCollection, resourceHandle2);
1245
1246             //client
1247             OcPlatform.findResource("",
1248                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
1249                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1250                     resourceFoundListener3);
1251
1252             //wait for onResourceFound event to find 1 collection resources
1253             assertTrue(signal3.await(60, TimeUnit.SECONDS));
1254
1255             //server
1256             OcPlatform.unbindResource(resourceHandleCollection, resourceHandle1);
1257
1258             //client
1259             OcPlatform.findResource("",
1260                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
1261                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1262                     resourceFoundListener2);
1263
1264             //wait for onResourceFound event to find 2 resources
1265             assertTrue(signal2.await(60, TimeUnit.SECONDS));
1266
1267             //server
1268             OcPlatform.unbindResource(resourceHandleCollection, resourceHandle2);
1269
1270             //client
1271             OcPlatform.findResource("",
1272                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
1273                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1274                     resourceFoundListener4);
1275
1276             //wait for onResourceFound event to find 3 registered resources
1277             assertTrue(signal4.await(60, TimeUnit.SECONDS));
1278
1279             //Bind/unbind a list of resource handles
1280             List<OcResourceHandle> resourceHandleList = new LinkedList<OcResourceHandle>();
1281             resourceHandleList.add(resourceHandle1);
1282             resourceHandleList.add(resourceHandle2);
1283             OcPlatform.bindResources(resourceHandleCollection, resourceHandleList);
1284
1285             //client
1286             OcPlatform.findResource("",
1287                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
1288                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1289                     resourceFoundListener6);
1290
1291             //wait for onResourceFound event to find 1 collection resources
1292             assertTrue(signal6.await(60, TimeUnit.SECONDS));
1293
1294             OcPlatform.unbindResources(resourceHandleCollection, resourceHandleList);
1295
1296             //client
1297             OcPlatform.findResource("",
1298                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
1299                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1300                     resourceFoundListener5);
1301
1302             //wait for onResourceFound event to find 1 collection resources
1303             assertTrue(signal5.await(60, TimeUnit.SECONDS));
1304
1305             //server
1306             OcPlatform.unregisterResource(resourceHandleCollection);
1307             OcPlatform.unregisterResource(resourceHandle1);
1308             OcPlatform.unregisterResource(resourceHandle2);
1309         } catch (OcException e) {
1310             Log.e(TAG, e.getMessage());
1311             assertTrue(false);
1312         }
1313     }
1314
1315     public void testResourceMethods() throws InterruptedException {
1316         final String resourceType1 = "unit.test.resource" + new Date().getTime();
1317         final String resourceType2 = "unit.test.resource" + new Date().getTime();
1318
1319         final CountDownLatch signal = new CountDownLatch(2);
1320         final List<OcResource> resourceList = new LinkedList<>();
1321
1322         OcPlatform.OnResourceFoundListener resourceFoundListener =
1323                 new OcPlatform.OnResourceFoundListener() {
1324                     @Override
1325                     public synchronized void onResourceFound(OcResource resource) {
1326                         resourceList.add(resource);
1327                         Log.i(TAG, "Host: " + resource.getHost());
1328                         Log.i(TAG, "Uri: " + resource.getUri());
1329                         Log.i(TAG, "Observable: " + resource.isObservable());
1330
1331                         assertFalse(resource.getResourceTypes().isEmpty());
1332                         for (String resourceType : resource.getResourceTypes()) {
1333                             Log.i(TAG, "Type: " + resourceType);
1334                         }
1335
1336                         assertFalse(resource.getResourceTypes().isEmpty());
1337                         for (String resourceInterface : resource.getResourceInterfaces()) {
1338                             Log.i(TAG, "Interface: " + resourceInterface);
1339                         }
1340
1341                         List<OcHeaderOption> headerOptionList = new LinkedList<OcHeaderOption>();
1342                         headerOptionList.add(new OcHeaderOption(2885, "OptionData1"));
1343                         headerOptionList.add(new OcHeaderOption(2886, "OptionData2"));
1344
1345                         try {
1346                             resource.setHeaderOptions(headerOptionList);
1347                         } catch (OcException e) {
1348                             Log.e(TAG, "onResourceFound, error in setHeaderOptions -- " + e.getMessage());
1349                         }
1350
1351                         resource.unsetHeaderOptions();
1352
1353                         OcResourceIdentifier resourceIdentifier = resource.getUniqueIdentifier();
1354                         OcResourceIdentifier resourceIdentifier2 = resource.getUniqueIdentifier();
1355                         assertTrue(resourceIdentifier.equals(resourceIdentifier2));
1356
1357                         signal.countDown();
1358                     }
1359
1360                     @Override
1361                     public void onFindResourceFailed(Throwable ex, String uri) {
1362                         Log.i(TAG, "Find Resource Failed for Uri: " + uri + " Error: " + ex.getMessage());
1363                     }
1364                 };
1365
1366         try {
1367             //server
1368             OcResourceHandle resourceHandle1 = OcPlatform.registerResource(
1369                     "/a/unittest1",
1370                     resourceType1,
1371                     OcPlatform.DEFAULT_INTERFACE,
1372                     null,
1373                     EnumSet.of(ResourceProperty.DISCOVERABLE)
1374             );
1375
1376             OcResourceHandle resourceHandle2 = OcPlatform.registerResource(
1377                     "/a/unittest2",
1378                     resourceType2,
1379                     OcPlatform.DEFAULT_INTERFACE,
1380                     null,
1381                     EnumSet.of(ResourceProperty.DISCOVERABLE)
1382             );
1383
1384             //client
1385             OcPlatform.findResource("",
1386                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType1,
1387                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1388                     resourceFoundListener);
1389
1390             OcPlatform.findResource("",
1391                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType2,
1392                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1393                     resourceFoundListener);
1394
1395             //wait for onResourceFound event
1396             assertTrue(signal.await(60, TimeUnit.SECONDS));
1397
1398             assertTrue(2 == resourceList.size());
1399
1400             OcResource res0 = resourceList.get(0);
1401             OcResource res1 = resourceList.get(1);
1402             assertFalse(res0.getUniqueIdentifier().equals(res1.getUniqueIdentifier()));
1403             assertTrue(res0.getUniqueIdentifier().equals(res0.getUniqueIdentifier()));
1404
1405             //server
1406             OcPlatform.unregisterResource(resourceHandle1);
1407             OcPlatform.unregisterResource(resourceHandle2);
1408
1409         } catch (OcException e) {
1410             Log.e(TAG, e.getMessage());
1411             assertTrue(false);
1412         }
1413     }
1414
1415     public void testCreateResourceProxy() throws InterruptedException {
1416         final String resourceType = "unit.test.resource" + new Date().getTime();
1417         final CountDownLatch signal = new CountDownLatch(1);
1418
1419         OcPlatform.OnResourceFoundListener resourceFoundListener =
1420                 new OcPlatform.OnResourceFoundListener() {
1421                     @Override
1422                     public void onResourceFound(OcResource resource) {
1423
1424                         try {
1425                             //client: construct resource proxy
1426                             OcResource resourceProxy = OcPlatform.constructResourceObject(
1427                                     resource.getHost(),
1428                                     resource.getUri(),
1429                                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1430                                     resource.isObservable(),
1431                                     resource.getResourceTypes(),
1432                                     resource.getResourceInterfaces());
1433
1434                             //client: register resource proxy
1435                             OcResourceHandle resourceProxyHandle =
1436                                     OcPlatform.registerResource(resourceProxy);
1437
1438                             OcPlatform.unregisterResource(resourceProxyHandle);
1439                         } catch (OcException e) {
1440                             assertTrue(false);
1441                         }
1442                         signal.countDown();
1443                     }
1444
1445                     @Override
1446                     public void onFindResourceFailed(Throwable ex, String uri) {
1447                         Log.i(TAG, "Find Resource Failed for Uri: " + uri + " Error: " + ex.getMessage());
1448                     }
1449                 };
1450
1451         try {
1452             //server
1453             OcResourceHandle resourceHandle = OcPlatform.registerResource(
1454                     "/a/unittest",
1455                     resourceType,
1456                     OcPlatform.DEFAULT_INTERFACE,
1457                     null,
1458                     EnumSet.of(ResourceProperty.DISCOVERABLE)
1459             );
1460
1461             //client
1462             OcPlatform.findResource("",
1463                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
1464                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1465                     resourceFoundListener);
1466
1467             //wait for onResourceFound event
1468             assertTrue(signal.await(60, TimeUnit.SECONDS));
1469
1470             //server
1471             OcPlatform.unregisterResource(resourceHandle);
1472
1473         } catch (OcException e) {
1474             Log.e(TAG, e.getMessage());
1475             assertTrue(false);
1476         }
1477
1478         try {
1479             //server
1480             OcResourceHandle resourceHandle = OcPlatform.registerResource(
1481                     "/a/unittest",
1482                     resourceType,
1483                     OcPlatform.DEFAULT_INTERFACE,
1484                     null,
1485                     EnumSet.of(ResourceProperty.DISCOVERABLE)
1486             );
1487
1488             //client
1489             OcPlatform.findResource("",
1490                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
1491                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1492                     resourceFoundListener);
1493
1494             //wait for onResourceFound event
1495             assertTrue(signal.await(60, TimeUnit.SECONDS));
1496
1497             //server
1498             OcPlatform.unregisterResource(resourceHandle);
1499
1500         } catch (OcException e) {
1501             Log.e(TAG, e.getMessage());
1502             assertTrue(false);
1503         }
1504     }
1505
1506     public void testObserveClientServer() throws InterruptedException {
1507         final int NUM_OBSERVES = 20;
1508         final Timer timer = new Timer();
1509         final List<OcResource> resourceList = new LinkedList<OcResource>();
1510         final List<OcResourceHandle> resourceHandleList = new LinkedList<OcResourceHandle>();
1511         final CountDownLatch signal1 = new CountDownLatch(1);
1512         final CountDownLatch signal2 = new CountDownLatch(NUM_OBSERVES);
1513         final CountDownLatch signal3 = new CountDownLatch(1);
1514
1515         final String resourceType = "unit.test.resource" + new Date().getTime();
1516
1517         final OcResource.OnObserveListener observeListener = new OcResource.OnObserveListener() {
1518             @Override
1519             public void onObserveCompleted(
1520                     List<OcHeaderOption> headerOptionList,
1521                     OcRepresentation ocRepresentation,
1522                     int sequenceNumber) {
1523
1524                 try {
1525                     Log.i(TAG, "Observe #" + sequenceNumber + " power: " +
1526                             ocRepresentation.getValue("power"));
1527                 } catch (OcException e) {
1528                     Log.e(TAG, e.toString());
1529                     assertTrue(false);
1530                 }
1531                 signal2.countDown();
1532             }
1533
1534             @Override
1535             public void onObserveFailed(Throwable ex) {
1536                 if (ex instanceof OcException) {
1537                     OcException ocEx = (OcException) ex;
1538                     ErrorCode errCode = ocEx.getErrorCode();
1539                 }
1540                 Log.e(TAG, ex.toString());
1541                 assertTrue(false);
1542             }
1543         };
1544
1545         final List<Byte> observationIdList = new LinkedList<Byte>();
1546         OcPlatform.EntityHandler entityHandler = new OcPlatform.EntityHandler() {
1547             @Override
1548             public EntityHandlerResult handleEntity(OcResourceRequest ocResourceRequest) {
1549                 EnumSet<RequestHandlerFlag> handlerFlagSet = ocResourceRequest.getRequestHandlerFlagSet();
1550                 RequestType requestType = ocResourceRequest.getRequestType();
1551
1552                 if (handlerFlagSet.contains(RequestHandlerFlag.INIT)) {
1553
1554                 }
1555                 if (handlerFlagSet.contains(RequestHandlerFlag.REQUEST)) {
1556                     OcResourceResponse ocResourceResponse = new OcResourceResponse();
1557                     ocResourceResponse.setRequestHandle(ocResourceRequest.getRequestHandle());
1558                     ocResourceResponse.setResourceHandle(ocResourceRequest.getResourceHandle());
1559
1560                     switch (requestType) {
1561                         case GET:
1562                             ocResourceResponse.setErrorCode(200);
1563                             ocResourceResponse.setResponseResult(EntityHandlerResult.OK);
1564                             ocResourceResponse.setResourceRepresentation(
1565                                     getRepresentation(
1566                                             rnd.nextInt(100)));
1567                             try {
1568                                 OcPlatform.sendResponse(ocResourceResponse);
1569                             } catch (OcException e) {
1570                                 Log.e(TAG, e.getMessage());
1571                                 return EntityHandlerResult.ERROR;
1572                             }
1573                             break;
1574                     }
1575                 }
1576
1577                 if (handlerFlagSet.contains(RequestHandlerFlag.OBSERVER)) {
1578                     ObservationInfo observationInfo = ocResourceRequest.getObservationInfo();
1579
1580                     switch (observationInfo.getObserveAction()) {
1581                         case REGISTER:
1582                             synchronized (observationIdList) {
1583                                 observationIdList.add(observationInfo.getOcObservationId());
1584                                 timer.schedule(new TimerTask() {
1585                                     int numNotified = 1;
1586
1587                                     @Override
1588                                     public void run() {
1589                                         if (0 < resourceHandleList.size()) {
1590                                             synchronized (observationIdList) {
1591                                                 if (numNotified > NUM_OBSERVES) {
1592                                                     timer.cancel();
1593                                                     timer.purge();
1594                                                     signal3.countDown();
1595                                                 } else {
1596                                                     try {
1597                                                         OcPlatform.notifyAllObservers(
1598                                                                 resourceHandleList.get(0));
1599                                                     } catch (OcException e) {
1600                                                         if (ErrorCode.NO_OBSERVERS == e.getErrorCode()) {
1601                                                             timer.cancel();
1602                                                             timer.purge();
1603                                                             signal3.countDown();
1604                                                         }
1605                                                         Log.e(TAG, e.getMessage());
1606                                                     }
1607                                                     numNotified++;
1608                                                 }
1609                                             }
1610                                         }
1611
1612                                     }
1613                                 }, 0, 100);
1614                             }
1615                             break;
1616                         case UNREGISTER:
1617                             //TODO unregister isn't implemented in C++ API, yet
1618                             synchronized (observationIdList) {
1619                                 timer.cancel();
1620                                 break;
1621                             }
1622                     }
1623                 }
1624                 return EntityHandlerResult.OK;
1625             }
1626         };
1627
1628         OcPlatform.OnResourceFoundListener resourceFoundListener =
1629                 new OcPlatform.OnResourceFoundListener() {
1630                     @Override
1631                     public void onResourceFound(OcResource resource) {
1632                         resourceList.add(resource);
1633                         if (resource.isObservable()) {
1634                             try {
1635                                 resource.observe(
1636                                         ObserveType.OBSERVE,
1637                                         new HashMap<String, String>(),
1638                                         observeListener);
1639
1640                                 signal1.countDown();
1641                             } catch (OcException e) {
1642                                 Log.e(TAG, e.getMessage());
1643                                 assertTrue(false);
1644                             }
1645                         }
1646                     }
1647
1648                     @Override
1649                     public void onFindResourceFailed(Throwable ex, String uri) {
1650                         Log.i(TAG, "Find Resource Failed for Uri: " + uri + " Error: " + ex.getMessage());
1651                     }
1652                 };
1653         try {
1654             //server
1655             OcResourceHandle resourceHandle = OcPlatform.registerResource(
1656                     "/a/unittest",
1657                     resourceType,
1658                     OcPlatform.DEFAULT_INTERFACE,
1659                     entityHandler,
1660                     EnumSet.of(ResourceProperty.DISCOVERABLE, ResourceProperty.OBSERVABLE)
1661             );
1662
1663             resourceHandleList.add(resourceHandle);
1664
1665             //client
1666             OcPlatform.findResource("",
1667                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
1668                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1669                     resourceFoundListener);
1670
1671             //wait for onResourceFound event
1672             assertTrue(signal1.await(60, TimeUnit.SECONDS));
1673
1674             //wait for OnObserveListener event to observe 20 values
1675             assertTrue(signal2.await(60, TimeUnit.SECONDS));
1676
1677             if (resourceList.size() > 0) {
1678                 OcResource resource = resourceList.get(0);
1679                 if (resource.isObservable()) {
1680                     resource.cancelObserve();
1681                 }
1682             }
1683
1684             //wait for server to finish
1685             assertTrue(signal3.await(60, TimeUnit.SECONDS));
1686
1687             //server
1688             OcPlatform.unregisterResource(resourceHandle);
1689
1690         } catch (OcException e) {
1691             Log.e(TAG, e.getMessage());
1692             assertTrue(false);
1693         }
1694     }
1695
1696     private OcRepresentation getRepresentation(int value) {
1697         OcRepresentation rep = new OcRepresentation();
1698         try {
1699             rep.setValue("power", value);
1700         } catch (OcException e) {
1701             Log.e(TAG, e.toString());
1702             assertTrue(false);
1703         }
1704         return rep;
1705     }
1706
1707     private OcRepresentation getRepresentation() {
1708         return getRepresentation(74);
1709     }
1710 }