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