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
 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
 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
 999         platformInfo = new OcPlatformInfo("myPlatformID", "myManuName", "myManuUrl");
1000
1001         platformInfo.setModelNumber("myModelNumber");
1002         platformInfo.setDateOfManufacture("myDateOfManufacture");
1003         platformInfo.setPlatformVersion("myPlatformVersion");
1004         platformInfo.setOperatingSystemVersion("myOperatingSystemVersion");
1005         platformInfo.setHardwareVersion("myHardwareVersion");
1006         platformInfo.setFirmwareVersion("myFirmwareVersion");
1007         platformInfo.setSupportUrl("mySupportUrl");
1008         platformInfo.setSystemTime("mySystemTime");
1009
1010         try {
1011             //server
1012             OcPlatform.registerPlatformInfo(platformInfo);
1013
1014             //client
1015             OcPlatform.getPlatformInfo(
1016                     "",
1017                     OcPlatform.WELL_KNOWN_PLATFORM_QUERY,
1018                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1019                     platformFoundListener);
1020
1021             //wait for onPlatformFound event
1022             assertTrue(signal.await(60, TimeUnit.SECONDS));
1023         } catch (OcException e) {
1024             Log.e(TAG, e.getMessage() + platformInfo.toString());
1025             assertTrue(false);
1026         }
1027     }
1028
1029     public void testRegisterDeviceInfoGetDeviceInfo() throws InterruptedException {
1030         final String resourceType = "unit.test.resource" + new Date().getTime();
1031         final CountDownLatch signal = new CountDownLatch(1);
1032
1033         OcPlatform.OnDeviceFoundListener deviceFoundListener = new OcPlatform.OnDeviceFoundListener() {
1034             @Override
1035             public void onDeviceFound(OcRepresentation ocRepresentation) {
1036                 try {
1037                     Log.i(TAG, "Device Name: " + ocRepresentation.getValue("n"));
1038                 } catch (OcException e) {
1039                     Log.e(TAG, e.toString());
1040                     assertTrue(false);
1041                 }
1042                 boolean hasDeviceNameAtr = ocRepresentation.hasAttribute("n");
1043                 assertTrue(hasDeviceNameAtr);
1044                 boolean hasNonExistingAtr = ocRepresentation.hasAttribute("NonExisting");
1045                 assertFalse(hasNonExistingAtr);
1046                 Log.i(TAG, "URI: " + ocRepresentation.getUri());
1047                 signal.countDown();
1048             }
1049         };
1050
1051         OcDeviceInfo devInfo = new OcDeviceInfo("myDeviceName");
1052
1053         try {
1054             //server
1055             OcPlatform.registerDeviceInfo(devInfo);
1056             //client
1057             OcPlatform.getDeviceInfo(
1058                     "",
1059                     OcPlatform.WELL_KNOWN_DEVICE_QUERY,
1060                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1061                     deviceFoundListener);
1062
1063             //wait for onDeviceFound event
1064             assertTrue(signal.await(60, TimeUnit.SECONDS));
1065
1066         } catch (OcException e) {
1067             Log.e(TAG, e.getMessage());
1068             assertTrue(false);
1069         }
1070     }
1071
1072     public void testBindUnbindResources() throws InterruptedException {
1073         final String resourceType = "unit.test.resource" + new Date().getTime();
1074         final CountDownLatch signal1 = new CountDownLatch(3);
1075         final CountDownLatch signal2 = new CountDownLatch(2);
1076         final CountDownLatch signal3 = new CountDownLatch(1);
1077         final CountDownLatch signal4 = new CountDownLatch(3);
1078         final CountDownLatch signal5 = new CountDownLatch(3);
1079         final CountDownLatch signal6 = new CountDownLatch(1);
1080
1081         OcPlatform.EntityHandler entityHandler = new OcPlatform.EntityHandler() {
1082             @Override
1083             public EntityHandlerResult handleEntity(OcResourceRequest ocResourceRequest) {
1084                 return EntityHandlerResult.OK;
1085             }
1086         };
1087
1088         OcPlatform.OnResourceFoundListener resourceFoundListener1 = new OcPlatform.OnResourceFoundListener() {
1089             @Override
1090             public void onResourceFound(OcResource resource) {
1091                 signal1.countDown();
1092             }
1093         };
1094
1095         OcPlatform.OnResourceFoundListener resourceFoundListener2 = new OcPlatform.OnResourceFoundListener() {
1096             @Override
1097             public void onResourceFound(OcResource resource) {
1098                 signal2.countDown();
1099             }
1100         };
1101
1102         OcPlatform.OnResourceFoundListener resourceFoundListener3 = new OcPlatform.OnResourceFoundListener() {
1103             @Override
1104             public void onResourceFound(OcResource resource) {
1105                 signal3.countDown();
1106             }
1107         };
1108
1109         OcPlatform.OnResourceFoundListener resourceFoundListener4 = new OcPlatform.OnResourceFoundListener() {
1110             @Override
1111             public void onResourceFound(OcResource resource) {
1112                 signal4.countDown();
1113             }
1114         };
1115
1116         OcPlatform.OnResourceFoundListener resourceFoundListener5 = new OcPlatform.OnResourceFoundListener() {
1117             @Override
1118             public void onResourceFound(OcResource resource) {
1119                 signal5.countDown();
1120             }
1121         };
1122
1123         OcPlatform.OnResourceFoundListener resourceFoundListener6 = new OcPlatform.OnResourceFoundListener() {
1124             @Override
1125             public void onResourceFound(OcResource resource) {
1126                 signal6.countDown();
1127             }
1128         };
1129
1130         try {
1131
1132             //server
1133             OcResourceHandle resourceHandleCollection = OcPlatform.registerResource(
1134                     "/a/unittest1",
1135                     resourceType,
1136                     OcPlatform.DEFAULT_INTERFACE,
1137                     entityHandler,
1138                     EnumSet.of(ResourceProperty.DISCOVERABLE)
1139             );
1140
1141             OcResourceHandle resourceHandle1 = OcPlatform.registerResource(
1142                     "/a/unittest2",
1143                     resourceType,
1144                     OcPlatform.DEFAULT_INTERFACE,
1145                     entityHandler,
1146                     EnumSet.of(ResourceProperty.DISCOVERABLE)
1147             );
1148
1149             OcResourceHandle resourceHandle2 = OcPlatform.registerResource(
1150                     "/a/unittest3",
1151                     resourceType,
1152                     OcPlatform.DEFAULT_INTERFACE,
1153                     entityHandler,
1154                     EnumSet.of(ResourceProperty.DISCOVERABLE)
1155             );
1156
1157             //client
1158             OcPlatform.findResource("",
1159                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
1160                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1161                     resourceFoundListener1);
1162
1163             //wait for onResourceFound event to find 3 registered resources
1164             assertTrue(signal1.await(60, TimeUnit.SECONDS));
1165
1166             //server
1167             OcPlatform.bindResource(resourceHandleCollection, resourceHandle1);
1168             OcPlatform.bindResource(resourceHandleCollection, resourceHandle2);
1169
1170             //client
1171             OcPlatform.findResource("",
1172                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
1173                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1174                     resourceFoundListener3);
1175
1176             //wait for onResourceFound event to find 1 collection resources
1177             assertTrue(signal3.await(60, TimeUnit.SECONDS));
1178
1179             //server
1180             OcPlatform.unbindResource(resourceHandleCollection, resourceHandle1);
1181
1182             //client
1183             OcPlatform.findResource("",
1184                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
1185                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1186                     resourceFoundListener2);
1187
1188             //wait for onResourceFound event to find 2 resources
1189             assertTrue(signal2.await(60, TimeUnit.SECONDS));
1190
1191             //server
1192             OcPlatform.unbindResource(resourceHandleCollection, resourceHandle2);
1193
1194             //client
1195             OcPlatform.findResource("",
1196                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
1197                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1198                     resourceFoundListener4);
1199
1200             //wait for onResourceFound event to find 3 registered resources
1201             assertTrue(signal4.await(60, TimeUnit.SECONDS));
1202
1203             //Bind/unbind a list of resource handles
1204             List<OcResourceHandle> resourceHandleList = new LinkedList<OcResourceHandle>();
1205             resourceHandleList.add(resourceHandle1);
1206             resourceHandleList.add(resourceHandle2);
1207             OcPlatform.bindResources(resourceHandleCollection, resourceHandleList);
1208
1209             //client
1210             OcPlatform.findResource("",
1211                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
1212                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1213                     resourceFoundListener6);
1214
1215             //wait for onResourceFound event to find 1 collection resources
1216             assertTrue(signal6.await(60, TimeUnit.SECONDS));
1217
1218             OcPlatform.unbindResources(resourceHandleCollection, resourceHandleList);
1219
1220             //client
1221             OcPlatform.findResource("",
1222                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
1223                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1224                     resourceFoundListener5);
1225
1226             //wait for onResourceFound event to find 1 collection resources
1227             assertTrue(signal5.await(60, TimeUnit.SECONDS));
1228
1229             //server
1230             OcPlatform.unregisterResource(resourceHandleCollection);
1231             OcPlatform.unregisterResource(resourceHandle1);
1232             OcPlatform.unregisterResource(resourceHandle2);
1233         } catch (OcException e) {
1234             Log.e(TAG, e.getMessage());
1235             assertTrue(false);
1236         }
1237     }
1238
1239     public void testResourceMethods() throws InterruptedException {
1240         final String resourceType1 = "unit.test.resource" + new Date().getTime();
1241         final String resourceType2 = "unit.test.resource" + new Date().getTime();
1242
1243         final CountDownLatch signal = new CountDownLatch(2);
1244         final List<OcResource> resourceList = new LinkedList<OcResource>();
1245
1246         OcPlatform.EntityHandler entityHandler = new OcPlatform.EntityHandler() {
1247             @Override
1248             public EntityHandlerResult handleEntity(OcResourceRequest ocResourceRequest) {
1249                 return EntityHandlerResult.OK;
1250             }
1251         };
1252
1253         OcPlatform.OnResourceFoundListener resourceFoundListener =
1254                 new OcPlatform.OnResourceFoundListener() {
1255                     @Override
1256                     public void onResourceFound(OcResource resource) {
1257                         resourceList.add(resource);
1258                         Log.i(TAG, "Host: " + resource.getHost());
1259                         Log.i(TAG, "Uri: " + resource.getUri());
1260                         Log.i(TAG, "Observable: " + resource.isObservable());
1261
1262                         for (String resourceType : resource.getResourceTypes()) {
1263                             Log.i(TAG, "Type: " + resourceType);
1264                         }
1265
1266                         for (String resourceInterface : resource.getResourceInterfaces()) {
1267                             Log.i(TAG, "Interface: " + resourceInterface);
1268                         }
1269
1270                         List<OcHeaderOption> headerOptionList = new LinkedList<OcHeaderOption>();
1271                         headerOptionList.add(new OcHeaderOption(2885, "OptionData1"));
1272                         headerOptionList.add(new OcHeaderOption(2886, "OptionData2"));
1273                         resource.setHeaderOptions(headerOptionList);
1274
1275                         resource.setHeaderOptions(headerOptionList);
1276                         resource.unsetHeaderOptions();
1277
1278                         OcResourceIdentifier resourceIdentifier = resource.getUniqueIdentifier();
1279                         OcResourceIdentifier resourceIdentifier2 = resource.getUniqueIdentifier();
1280                         assertTrue(resourceIdentifier.equals(resourceIdentifier2));
1281
1282                         signal.countDown();
1283                     }
1284                 };
1285
1286         try {
1287             //server
1288             OcResourceHandle resourceHandle1 = OcPlatform.registerResource(
1289                     "/a/unittest1",
1290                     resourceType1,
1291                     OcPlatform.DEFAULT_INTERFACE,
1292                     entityHandler,
1293                     EnumSet.of(ResourceProperty.DISCOVERABLE)
1294             );
1295
1296             OcResourceHandle resourceHandle2 = OcPlatform.registerResource(
1297                     "/a/unittest2",
1298                     resourceType2,
1299                     OcPlatform.DEFAULT_INTERFACE,
1300                     entityHandler,
1301                     EnumSet.of(ResourceProperty.DISCOVERABLE)
1302             );
1303
1304             //client
1305             OcPlatform.findResource("",
1306                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType1,
1307                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1308                     resourceFoundListener);
1309
1310             OcPlatform.findResource("",
1311                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType2,
1312                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1313                     resourceFoundListener);
1314
1315             //wait for onResourceFound event
1316             assertTrue(signal.await(60, TimeUnit.SECONDS));
1317
1318             assertTrue(2 == resourceList.size());
1319
1320             OcResource res0 = resourceList.get(0);
1321             OcResource res1 = resourceList.get(1);
1322             assertFalse(res0.getUniqueIdentifier().equals(res1.getUniqueIdentifier()));
1323             assertTrue(res0.getUniqueIdentifier().equals(res0.getUniqueIdentifier()));
1324
1325             //server
1326             OcPlatform.unregisterResource(resourceHandle1);
1327             OcPlatform.unregisterResource(resourceHandle2);
1328
1329         } catch (OcException e) {
1330             Log.e(TAG, e.getMessage());
1331             assertTrue(false);
1332         }
1333     }
1334
1335     public void testCreateResourceProxy() throws InterruptedException {
1336         final String resourceType = "unit.test.resource" + new Date().getTime();
1337         final CountDownLatch signal = new CountDownLatch(1);
1338
1339         OcPlatform.EntityHandler entityHandler = new OcPlatform.EntityHandler() {
1340             @Override
1341             public EntityHandlerResult handleEntity(OcResourceRequest ocResourceRequest) {
1342                 return EntityHandlerResult.OK;
1343             }
1344         };
1345
1346         OcPlatform.OnResourceFoundListener resourceFoundListener =
1347                 new OcPlatform.OnResourceFoundListener() {
1348                     @Override
1349                     public void onResourceFound(OcResource resource) {
1350
1351                         try {
1352                             //client: construct resource proxy
1353                             OcResource resourceProxy = OcPlatform.constructResourceObject(
1354                                     resource.getHost(),
1355                                     resource.getUri(),
1356                                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1357                                     resource.isObservable(),
1358                                     resource.getResourceTypes(),
1359                                     resource.getResourceInterfaces());
1360
1361                             //client: register resource proxy
1362                             OcResourceHandle resourceProxyHandle =
1363                                     OcPlatform.registerResource(resourceProxy);
1364
1365                             OcPlatform.unregisterResource(resourceProxyHandle);
1366                         } catch (OcException e) {
1367                             assertTrue(false);
1368                         }
1369                         signal.countDown();
1370                     }
1371                 };
1372
1373         try {
1374             //server
1375             OcResourceHandle resourceHandle = OcPlatform.registerResource(
1376                     "/a/unittest",
1377                     resourceType,
1378                     OcPlatform.DEFAULT_INTERFACE,
1379                     entityHandler,
1380                     EnumSet.of(ResourceProperty.DISCOVERABLE)
1381             );
1382
1383             //client
1384             OcPlatform.findResource("",
1385                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
1386                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1387                     resourceFoundListener);
1388
1389             //wait for onResourceFound event
1390             assertTrue(signal.await(60, TimeUnit.SECONDS));
1391
1392             //server
1393             OcPlatform.unregisterResource(resourceHandle);
1394
1395         } catch (OcException e) {
1396             Log.e(TAG, e.getMessage());
1397             assertTrue(false);
1398         }
1399
1400         try {
1401             //server
1402             OcResourceHandle resourceHandle = OcPlatform.registerResource(
1403                     "/a/unittest",
1404                     resourceType,
1405                     OcPlatform.DEFAULT_INTERFACE,
1406                     entityHandler,
1407                     EnumSet.of(ResourceProperty.DISCOVERABLE)
1408             );
1409
1410             //client
1411             OcPlatform.findResource("",
1412                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
1413                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1414                     resourceFoundListener);
1415
1416             //wait for onResourceFound event
1417             assertTrue(signal.await(60, TimeUnit.SECONDS));
1418
1419             //server
1420             OcPlatform.unregisterResource(resourceHandle);
1421
1422         } catch (OcException e) {
1423             Log.e(TAG, e.getMessage());
1424             assertTrue(false);
1425         }
1426     }
1427
1428     public void testObserveClientServer() throws InterruptedException {
1429         final int NUM_OBSERVES = 20;
1430         final Timer timer = new Timer();
1431         final List<OcResource> resourceList = new LinkedList<OcResource>();
1432         final List<OcResourceHandle> resourceHandleList = new LinkedList<OcResourceHandle>();
1433         final CountDownLatch signal1 = new CountDownLatch(1);
1434         final CountDownLatch signal2 = new CountDownLatch(NUM_OBSERVES);
1435         final CountDownLatch signal3 = new CountDownLatch(1);
1436
1437         final String resourceType = "unit.test.resource" + new Date().getTime();
1438
1439         final OcResource.OnObserveListener observeListener = new OcResource.OnObserveListener() {
1440             @Override
1441             public void onObserveCompleted(
1442                     List<OcHeaderOption> headerOptionList,
1443                     OcRepresentation ocRepresentation,
1444                     int sequenceNumber) {
1445
1446                 try {
1447                     Log.i(TAG, "Observe #" + sequenceNumber + " power: " +
1448                             ocRepresentation.getValue("power"));
1449                 } catch (OcException e) {
1450                     Log.e(TAG, e.toString());
1451                     assertTrue(false);
1452                 }
1453                 signal2.countDown();
1454             }
1455
1456             @Override
1457             public void onObserveFailed(Throwable ex) {
1458                 if (ex instanceof OcException) {
1459                     OcException ocEx = (OcException) ex;
1460                     ErrorCode errCode = ocEx.getErrorCode();
1461                 }
1462                 Log.e(TAG, ex.toString());
1463                 assertTrue(false);
1464             }
1465         };
1466
1467         final List<Byte> observationIdList = new LinkedList<Byte>();
1468         OcPlatform.EntityHandler entityHandler = new OcPlatform.EntityHandler() {
1469             @Override
1470             public EntityHandlerResult handleEntity(OcResourceRequest ocResourceRequest) {
1471                 EnumSet<RequestHandlerFlag> handlerFlagSet = ocResourceRequest.getRequestHandlerFlagSet();
1472                 RequestType requestType = ocResourceRequest.getRequestType();
1473
1474                 if (handlerFlagSet.contains(RequestHandlerFlag.INIT)) {
1475
1476                 }
1477                 if (handlerFlagSet.contains(RequestHandlerFlag.REQUEST)) {
1478                     OcResourceResponse ocResourceResponse = new OcResourceResponse();
1479                     ocResourceResponse.setRequestHandle(ocResourceRequest.getRequestHandle());
1480                     ocResourceResponse.setResourceHandle(ocResourceRequest.getResourceHandle());
1481
1482                     switch (requestType) {
1483                         case GET:
1484                             ocResourceResponse.setErrorCode(200);
1485                             ocResourceResponse.setResponseResult(EntityHandlerResult.OK);
1486                             ocResourceResponse.setResourceRepresentation(
1487                                     getRepresentation(
1488                                             rnd.nextInt(100)));
1489                             try {
1490                                 OcPlatform.sendResponse(ocResourceResponse);
1491                             } catch (OcException e) {
1492                                 Log.e(TAG, e.getMessage());
1493                                 return EntityHandlerResult.ERROR;
1494                             }
1495                             break;
1496                     }
1497                 }
1498
1499                 if (handlerFlagSet.contains(RequestHandlerFlag.OBSERVER)) {
1500                     ObservationInfo observationInfo = ocResourceRequest.getObservationInfo();
1501
1502                     switch (observationInfo.getObserveAction()) {
1503                         case REGISTER:
1504                             synchronized (observationIdList) {
1505                                 observationIdList.add(observationInfo.getOcObservationId());
1506                                 timer.schedule(new TimerTask() {
1507                                     int numNotified = 1;
1508
1509                                     @Override
1510                                     public void run() {
1511                                         if (0 < resourceHandleList.size()) {
1512                                             synchronized (observationIdList) {
1513                                                 if (numNotified > NUM_OBSERVES) {
1514                                                     timer.cancel();
1515                                                     timer.purge();
1516                                                     signal3.countDown();
1517                                                 } else {
1518                                                     try {
1519                                                         OcPlatform.notifyAllObservers(
1520                                                                 resourceHandleList.get(0));
1521                                                     } catch (OcException e) {
1522                                                         if (ErrorCode.NO_OBSERVERS == e.getErrorCode()) {
1523                                                             timer.cancel();
1524                                                             timer.purge();
1525                                                             signal3.countDown();
1526                                                         }
1527                                                         Log.e(TAG, e.getMessage());
1528                                                     }
1529                                                     numNotified++;
1530                                                 }
1531                                             }
1532                                         }
1533
1534                                     }
1535                                 }, 0, 100);
1536                             }
1537                             break;
1538                         case UNREGISTER:
1539                             //TODO unregister isn't implemented in C++ API, yet
1540                             synchronized (observationIdList) {
1541                                 timer.cancel();
1542                                 break;
1543                             }
1544                     }
1545                 }
1546                 return EntityHandlerResult.OK;
1547             }
1548         };
1549
1550         OcPlatform.OnResourceFoundListener resourceFoundListener =
1551                 new OcPlatform.OnResourceFoundListener() {
1552                     @Override
1553                     public void onResourceFound(OcResource resource) {
1554                         resourceList.add(resource);
1555                         if (resource.isObservable()) {
1556                             try {
1557                                 resource.observe(
1558                                         ObserveType.OBSERVE,
1559                                         new HashMap<String, String>(),
1560                                         observeListener);
1561
1562                                 signal1.countDown();
1563                             } catch (OcException e) {
1564                                 Log.e(TAG, e.getMessage());
1565                                 assertTrue(false);
1566                             }
1567                         }
1568                     }
1569                 };
1570         try {
1571             //server
1572             OcResourceHandle resourceHandle = OcPlatform.registerResource(
1573                     "/a/unittest",
1574                     resourceType,
1575                     OcPlatform.DEFAULT_INTERFACE,
1576                     entityHandler,
1577                     EnumSet.of(ResourceProperty.DISCOVERABLE, ResourceProperty.OBSERVABLE)
1578             );
1579
1580             resourceHandleList.add(resourceHandle);
1581
1582             //client
1583             OcPlatform.findResource("",
1584                     OcPlatform.WELL_KNOWN_QUERY + "?rt=" + resourceType,
1585                     EnumSet.of(OcConnectivityType.CT_DEFAULT),
1586                     resourceFoundListener);
1587
1588             //wait for onResourceFound event
1589             assertTrue(signal1.await(60, TimeUnit.SECONDS));
1590
1591             //wait for OnObserveListener event to observe 20 values
1592             assertTrue(signal2.await(60, TimeUnit.SECONDS));
1593
1594             if (resourceList.size() > 0) {
1595                 OcResource resource = resourceList.get(0);
1596                 if (resource.isObservable()) {
1597                     resource.cancelObserve();
1598                 }
1599             }
1600
1601             //wait for server to finish
1602             assertTrue(signal3.await(60, TimeUnit.SECONDS));
1603
1604             //server
1605             OcPlatform.unregisterResource(resourceHandle);
1606
1607         } catch (OcException e) {
1608             Log.e(TAG, e.getMessage());
1609             assertTrue(false);
1610         }
1611     }
1612
1613     private OcRepresentation getRepresentation(int value) {
1614         OcRepresentation rep = new OcRepresentation();
1615         try {
1616             rep.setValue("power", value);
1617         } catch (OcException e) {
1618             Log.e(TAG, e.toString());
1619             assertTrue(false);
1620         }
1621         return rep;
1622     }
1623
1624     private OcRepresentation getRepresentation() {
1625         return getRepresentation(74);
1626     }
1627 }