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

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