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