service/simulator/unittests/SimulatorTest/src/org/oic/simulator/client/test/SimulatorRemoteResourceTest.java

   1 /*
   2  * Copyright 2015 Samsung Electronics All Rights Reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.oic.simulator.client.test;
  18
  19 import java.util.HashMap;
  20 import java.util.Map;
  21 import java.util.concurrent.CountDownLatch;
  22 import java.util.concurrent.TimeUnit;
  23
  24 import org.oic.simulator.AttributeValue;
  25 import org.oic.simulator.InvalidArgsException;
  26 import org.oic.simulator.SimulatorException;
  27 import org.oic.simulator.SimulatorManager;
  28 import org.oic.simulator.SimulatorResourceAttribute;
  29 import org.oic.simulator.SimulatorResourceModel;
  30 import org.oic.simulator.SimulatorResult;
  31 import org.oic.simulator.client.FindResourceListener;
  32 import org.oic.simulator.client.SimulatorRemoteResource;
  33 import org.oic.simulator.server.SimulatorSingleResource;
  34 import org.oic.simulator.test.ExceptionType;
  35 import org.oic.simulator.utils.ObjectHolder;
  36
  37 import junit.framework.TestCase;
  38
  39 /**
  40  * This class tests the APIs of SimulatorRemoteResource class.
  41  */
  42 public class SimulatorRemoteResourceTest extends TestCase {
  43     private static final String            SINGLE_RES_RAML = "./ramls/oic.r.light.raml";
  44     private static SimulatorSingleResource singleResource  = null;
  45     private static SimulatorRemoteResource remoteResource  = null;
  46
  47     static {
  48         System.loadLibrary("SimulatorManager");
  49         System.loadLibrary("RamlParser");
  50         System.loadLibrary("oc");
  51         System.loadLibrary("oc_logger");
  52         System.loadLibrary("octbstack");
  53     }
  54
  55     protected void setUp() throws Exception {
  56         super.setUp();
  57
  58         // Create single resource for first time
  59         if (null == singleResource) {
  60             singleResource = (SimulatorSingleResource) SimulatorManager
  61                     .createResource(SINGLE_RES_RAML);
  62             singleResource.start();
  63         }
  64
  65         // Find the created resource for first time
  66         if (null != singleResource && null == remoteResource) {
  67             CountDownLatch lockObject = new CountDownLatch(1);
  68             ObjectHolder<SimulatorRemoteResource> resourceHolder = new ObjectHolder<>();
  69             FindResourceCallbackListener listener = new FindResourceCallbackListener(
  70                     lockObject, resourceHolder);
  71
  72             try {
  73                 SimulatorManager.findResource(singleResource.getResourceType(),
  74                         listener);
  75
  76                 try {
  77                     lockObject.await(10, TimeUnit.SECONDS);
  78                 } catch (InterruptedException e) {
  79                 }
  80
  81             } catch (InvalidArgsException e) {
  82                 e.printStackTrace();
  83             } catch (SimulatorException e) {
  84                 e.printStackTrace();
  85             }
  86
  87             remoteResource = resourceHolder.get();
  88         }
  89     }
  90
  91     protected void tearDown() throws Exception {
  92         super.tearDown();
  93     }
  94
  95     public void testGetUri_P01() {
  96         String serverURI = null;
  97         try {
  98             serverURI = singleResource.getURI();
  99         } catch (SimulatorException e) {
 100             e.printStackTrace();
 101         }
 102
 103         assertNotNull(remoteResource.getURI());
 104         assertEquals(serverURI, remoteResource.getURI());
 105     }
 106
 107     public void testGetConnectivityType_P01() {
 108         assertNotNull(remoteResource.getConnectivityType());
 109     }
 110
 111     public void testGetResourceTypes_P01() {
 112         assertNotNull(remoteResource.getResourceTypes());
 113         assertTrue(remoteResource.getResourceTypes().size() > 0);
 114     }
 115
 116     public void testGetResourceInterfaces_P01() {
 117         assertNotNull(remoteResource.getResourceInterfaces());
 118         assertTrue(remoteResource.getResourceInterfaces().size() > 0);
 119     }
 120
 121     public void testGetHost_P01() {
 122         assertNotNull(remoteResource.getHost());
 123     }
 124
 125     public void testGetId_P01() {
 126         assertNotNull(remoteResource.getId());
 127     }
 128
 129     public void testIsObservable_P01() {
 130         boolean serverObserveState = false;
 131         try {
 132             serverObserveState = singleResource.isObservable();
 133         } catch (SimulatorException e) {
 134             e.printStackTrace();
 135         }
 136
 137         assertEquals(serverObserveState, remoteResource.isObservable());
 138     }
 139
 140     public void testGet_P01() {
 141         CountDownLatch lockObject = new CountDownLatch(1);
 142         boolean syncResult = false;
 143         ObjectHolder<ResponseDetails> response = new ObjectHolder<>();
 144         GetResponseCallbackListener listener = new GetResponseCallbackListener(
 145                 lockObject, response);
 146
 147         try {
 148             remoteResource.get(null, listener);
 149
 150             try {
 151                 lockObject.await(10, TimeUnit.SECONDS);
 152             } catch (InterruptedException e) {
 153             }
 154
 155             syncResult = true;
 156         } catch (InvalidArgsException e) {
 157             e.printStackTrace();
 158         } catch (SimulatorException e) {
 159             e.printStackTrace();
 160         }
 161
 162         assertTrue(syncResult);
 163         assertNotNull(response.get());
 164         assertEquals(remoteResource.getId(), response.get().uid());
 165     }
 166
 167     public void testGet_P02() {
 168         CountDownLatch lockObject = new CountDownLatch(1);
 169         boolean syncResult = false;
 170         ObjectHolder<ResponseDetails> response = new ObjectHolder<>();
 171         GetResponseCallbackListener listener = new GetResponseCallbackListener(
 172                 lockObject, response);
 173
 174         try {
 175             Map<String, String> queryParams = new HashMap<>();
 176             remoteResource.get(queryParams, listener);
 177
 178             try {
 179                 lockObject.await(10, TimeUnit.SECONDS);
 180             } catch (InterruptedException e) {
 181             }
 182
 183             syncResult = true;
 184         } catch (InvalidArgsException e) {
 185             e.printStackTrace();
 186         } catch (SimulatorException e) {
 187             e.printStackTrace();
 188         }
 189
 190         assertTrue(syncResult);
 191         assertNotNull(response.get());
 192         assertEquals(remoteResource.getId(), response.get().uid());
 193     }
 194
 195     public void testGet_P03() {
 196         CountDownLatch lockObject = new CountDownLatch(1);
 197         boolean syncResult = false;
 198         ObjectHolder<ResponseDetails> response = new ObjectHolder<>();
 199         GetResponseCallbackListener listener = new GetResponseCallbackListener(
 200                 lockObject, response);
 201
 202         try {
 203             remoteResource.get(remoteResource.getResourceInterfaces().get(0),
 204                     null, listener);
 205
 206             try {
 207                 lockObject.await(10, TimeUnit.SECONDS);
 208             } catch (InterruptedException e) {
 209             }
 210
 211             syncResult = true;
 212         } catch (InvalidArgsException e) {
 213             e.printStackTrace();
 214         } catch (SimulatorException e) {
 215             e.printStackTrace();
 216         }
 217
 218         assertTrue(syncResult);
 219         assertNotNull(response.get());
 220         assertEquals(remoteResource.getId(), response.get().uid());
 221     }
 222
 223     public void testGet_P04() {
 224         CountDownLatch lockObject = new CountDownLatch(1);
 225         boolean syncResult = false;
 226         ObjectHolder<ResponseDetails> response = new ObjectHolder<>();
 227         GetResponseCallbackListener listener = new GetResponseCallbackListener(
 228                 lockObject, response);
 229
 230         try {
 231             Map<String, String> queryParams = new HashMap<>();
 232             remoteResource.get(remoteResource.getResourceInterfaces().get(0),
 233                     queryParams, listener);
 234
 235             try {
 236                 lockObject.await(10, TimeUnit.SECONDS);
 237             } catch (InterruptedException e) {
 238             }
 239
 240             syncResult = true;
 241         } catch (InvalidArgsException e) {
 242             e.printStackTrace();
 243         } catch (SimulatorException e) {
 244             e.printStackTrace();
 245         }
 246
 247         assertTrue(syncResult);
 248         assertNotNull(response.get());
 249         assertEquals(remoteResource.getId(), response.get().uid());
 250     }
 251
 252     public void testGet_N01() {
 253         ExceptionType exType = ExceptionType.UNKNOWN;
 254
 255         try {
 256             remoteResource.get(null, null);
 257         } catch (InvalidArgsException e) {
 258             exType = ExceptionType.INVALID_ARGS;
 259         } catch (SimulatorException e) {
 260             exType = ExceptionType.SIMULATOR;
 261         }
 262
 263         assertTrue(exType == ExceptionType.INVALID_ARGS);
 264     }
 265
 266     public void testGet_N02() {
 267         ExceptionType exType = ExceptionType.UNKNOWN;
 268
 269         try {
 270             remoteResource.get(remoteResource.getResourceInterfaces().get(0),
 271                     null, null);
 272         } catch (InvalidArgsException e) {
 273             exType = ExceptionType.INVALID_ARGS;
 274         } catch (SimulatorException e) {
 275             exType = ExceptionType.SIMULATOR;
 276         }
 277
 278         assertTrue(exType == ExceptionType.INVALID_ARGS);
 279     }
 280
 281     public void testGet_N03() {
 282         ExceptionType exType = ExceptionType.UNKNOWN;
 283
 284         try {
 285             Map<String, String> queryParams = new HashMap<>();
 286             remoteResource.get(null, queryParams,
 287                     new SimulatorRemoteResource.GetResponseListener() {
 288                         @Override
 289                         public void onGetResponse(String uid,
 290                                 SimulatorResult result,
 291                                 SimulatorResourceModel resourceModel) {
 292                         }
 293                     });
 294         } catch (InvalidArgsException e) {
 295             exType = ExceptionType.INVALID_ARGS;
 296         } catch (SimulatorException e) {
 297             exType = ExceptionType.SIMULATOR;
 298         }
 299
 300         assertTrue(exType == ExceptionType.INVALID_ARGS);
 301     }
 302
 303     public void testPut_P01() {
 304         CountDownLatch lockObject = new CountDownLatch(1);
 305         boolean syncResult = false;
 306         ObjectHolder<ResponseDetails> response = new ObjectHolder<>();
 307         PutResponseCallbackListener listener = new PutResponseCallbackListener(
 308                 lockObject, response);
 309
 310         try {
 311             SimulatorResourceModel resModel = singleResource.getResourceModel();
 312             remoteResource.put(null, resModel, listener);
 313
 314             try {
 315                 lockObject.await(10, TimeUnit.SECONDS);
 316             } catch (InterruptedException e) {
 317             }
 318
 319             syncResult = true;
 320         } catch (InvalidArgsException e) {
 321             e.printStackTrace();
 322         } catch (SimulatorException e) {
 323             e.printStackTrace();
 324         }
 325
 326         assertTrue(syncResult);
 327         assertNotNull(response.get());
 328         assertNotNull(response.get().resourceModel());
 329         assertEquals(remoteResource.getId(), response.get().uid());
 330     }
 331
 332     public void testPut_P02() {
 333         CountDownLatch lockObject = new CountDownLatch(1);
 334         boolean syncResult = false;
 335         ObjectHolder<ResponseDetails> response = new ObjectHolder<>();
 336         PutResponseCallbackListener listener = new PutResponseCallbackListener(
 337                 lockObject, response);
 338
 339         try {
 340             SimulatorResourceModel resModel = singleResource.getResourceModel();
 341             Map<String, String> queryParams = new HashMap<>();
 342             remoteResource.put(queryParams, resModel, listener);
 343
 344             try {
 345                 lockObject.await(10, TimeUnit.SECONDS);
 346             } catch (InterruptedException e) {
 347             }
 348
 349             syncResult = true;
 350         } catch (InvalidArgsException e) {
 351             e.printStackTrace();
 352         } catch (SimulatorException e) {
 353             e.printStackTrace();
 354         }
 355
 356         assertTrue(syncResult);
 357         assertNotNull(response.get());
 358         assertNotNull(response.get().resourceModel());
 359         assertEquals(remoteResource.getId(), response.get().uid());
 360     }
 361
 362     public void testPut_P03() {
 363         CountDownLatch lockObject = new CountDownLatch(1);
 364         boolean syncResult = false;
 365         ObjectHolder<ResponseDetails> response = new ObjectHolder<>();
 366         PutResponseCallbackListener listener = new PutResponseCallbackListener(
 367                 lockObject, response);
 368
 369         try {
 370             SimulatorResourceModel resModel = singleResource.getResourceModel();
 371             remoteResource.put(remoteResource.getResourceInterfaces().get(0),
 372                     null, resModel, listener);
 373
 374             try {
 375                 lockObject.await(10, TimeUnit.SECONDS);
 376             } catch (InterruptedException e) {
 377             }
 378
 379             syncResult = true;
 380         } catch (InvalidArgsException e) {
 381             e.printStackTrace();
 382         } catch (SimulatorException e) {
 383             e.printStackTrace();
 384         }
 385
 386         assertTrue(syncResult);
 387         assertNotNull(response.get());
 388         assertNotNull(response.get().resourceModel());
 389         assertEquals(remoteResource.getId(), response.get().uid());
 390     }
 391
 392     public void testPut_P05() {
 393         CountDownLatch lockObject = new CountDownLatch(1);
 394         boolean syncResult = false;
 395         ObjectHolder<ResponseDetails> response = new ObjectHolder<>();
 396         PutResponseCallbackListener listener = new PutResponseCallbackListener(
 397                 lockObject, response);
 398
 399         try {
 400             SimulatorResourceModel resModel = singleResource.getResourceModel();
 401             Map<String, String> queryParams = new HashMap<>();
 402             remoteResource.put(remoteResource.getResourceInterfaces().get(0),
 403                     queryParams, resModel, listener);
 404
 405             try {
 406                 lockObject.await(10, TimeUnit.SECONDS);
 407             } catch (InterruptedException e) {
 408             }
 409
 410             syncResult = true;
 411         } catch (InvalidArgsException e) {
 412             e.printStackTrace();
 413         } catch (SimulatorException e) {
 414             e.printStackTrace();
 415         }
 416
 417         assertTrue(syncResult);
 418         assertNotNull(response.get());
 419         assertNotNull(response.get().resourceModel());
 420         assertEquals(remoteResource.getId(), response.get().uid());
 421     }
 422
 423     public void testPut_P04() {
 424         CountDownLatch lockObject = new CountDownLatch(1);
 425         boolean syncResult = false;
 426         ObjectHolder<ResponseDetails> response = new ObjectHolder<>();
 427         PutResponseCallbackListener listener = new PutResponseCallbackListener(
 428                 lockObject, response);
 429
 430         try {
 431             SimulatorResourceModel resModel = singleResource.getResourceModel();
 432             Map<String, String> queryParams = new HashMap<>();
 433             remoteResource.put(queryParams, null, listener);
 434
 435             try {
 436                 lockObject.await(10, TimeUnit.SECONDS);
 437             } catch (InterruptedException e) {
 438             }
 439
 440             syncResult = true;
 441         } catch (InvalidArgsException e) {
 442             e.printStackTrace();
 443         } catch (SimulatorException e) {
 444             e.printStackTrace();
 445         }
 446
 447         assertTrue(syncResult);
 448         assertNotNull(response.get());
 449         assertNotNull(response.get().resourceModel());
 450         assertEquals(remoteResource.getId(), response.get().uid());
 451     }
 452
 453     public void testPut_N01() {
 454         ExceptionType exType = ExceptionType.UNKNOWN;
 455
 456         try {
 457             SimulatorResourceModel resModel = singleResource.getResourceModel();
 458             remoteResource.put(null, resModel, null);
 459         } catch (InvalidArgsException e) {
 460             exType = ExceptionType.INVALID_ARGS;
 461         } catch (SimulatorException e) {
 462             exType = ExceptionType.SIMULATOR;
 463         }
 464
 465         assertTrue(exType == ExceptionType.INVALID_ARGS);
 466     }
 467
 468     public void testPut_N02() {
 469         ExceptionType exType = ExceptionType.UNKNOWN;
 470
 471         try {
 472             SimulatorResourceModel resModel = singleResource.getResourceModel();
 473             remoteResource.put(remoteResource.getResourceInterfaces().get(0),
 474                     null, resModel, null);
 475         } catch (InvalidArgsException e) {
 476             exType = ExceptionType.INVALID_ARGS;
 477         } catch (SimulatorException e) {
 478             exType = ExceptionType.SIMULATOR;
 479         }
 480
 481         assertTrue(exType == ExceptionType.INVALID_ARGS);
 482     }
 483
 484     public void testPut_N03() {
 485         ExceptionType exType = ExceptionType.UNKNOWN;
 486
 487         try {
 488             SimulatorResourceModel resModel = singleResource.getResourceModel();
 489             Map<String, String> queryParams = new HashMap<>();
 490             remoteResource.put(null, queryParams, resModel,
 491                     new SimulatorRemoteResource.PutResponseListener() {
 492                         @Override
 493                         public void onPutResponse(String uid,
 494                                 SimulatorResult result,
 495                                 SimulatorResourceModel resourceModel) {
 496                         }
 497                     });
 498         } catch (InvalidArgsException e) {
 499             exType = ExceptionType.INVALID_ARGS;
 500         } catch (SimulatorException e) {
 501             exType = ExceptionType.SIMULATOR;
 502         }
 503
 504         assertTrue(exType == ExceptionType.INVALID_ARGS);
 505     }
 506
 507     public void testPost_P01() {
 508         CountDownLatch lockObject = new CountDownLatch(1);
 509         boolean syncResult = false;
 510         ObjectHolder<ResponseDetails> response = new ObjectHolder<>();
 511         PostResponseCallbackListener listener = new PostResponseCallbackListener(
 512                 lockObject, response);
 513
 514         try {
 515             SimulatorResourceModel resModel = singleResource.getResourceModel();
 516             remoteResource.post(null, resModel, listener);
 517
 518             try {
 519                 lockObject.await(10, TimeUnit.SECONDS);
 520             } catch (InterruptedException e) {
 521             }
 522
 523             syncResult = true;
 524         } catch (InvalidArgsException e) {
 525             e.printStackTrace();
 526         } catch (SimulatorException e) {
 527             e.printStackTrace();
 528         }
 529
 530         assertTrue(syncResult);
 531         assertNotNull(response.get());
 532         assertNotNull(response.get().resourceModel());
 533         assertEquals(remoteResource.getId(), response.get().uid());
 534     }
 535
 536     public void testPost_P02() {
 537         CountDownLatch lockObject = new CountDownLatch(1);
 538         boolean syncResult = false;
 539         ObjectHolder<ResponseDetails> response = new ObjectHolder<>();
 540         PostResponseCallbackListener listener = new PostResponseCallbackListener(
 541                 lockObject, response);
 542
 543         try {
 544             SimulatorResourceModel resModel = singleResource.getResourceModel();
 545             Map<String, String> queryParams = new HashMap<>();
 546             remoteResource.post(queryParams, resModel, listener);
 547
 548             try {
 549                 lockObject.await(10, TimeUnit.SECONDS);
 550             } catch (InterruptedException e) {
 551             }
 552
 553             syncResult = true;
 554         } catch (InvalidArgsException e) {
 555             e.printStackTrace();
 556         } catch (SimulatorException e) {
 557             e.printStackTrace();
 558         }
 559
 560         assertTrue(syncResult);
 561         assertNotNull(response.get());
 562         assertNotNull(response.get().resourceModel());
 563         assertEquals(remoteResource.getId(), response.get().uid());
 564     }
 565
 566     public void testPost_P03() {
 567         CountDownLatch lockObject = new CountDownLatch(1);
 568         boolean syncResult = false;
 569         ObjectHolder<ResponseDetails> response = new ObjectHolder<>();
 570         PostResponseCallbackListener listener = new PostResponseCallbackListener(
 571                 lockObject, response);
 572
 573         try {
 574             SimulatorResourceModel resModel = singleResource.getResourceModel();
 575             remoteResource.post(remoteResource.getResourceInterfaces().get(0),
 576                     null, resModel, listener);
 577
 578             try {
 579                 lockObject.await(10, TimeUnit.SECONDS);
 580             } catch (InterruptedException e) {
 581             }
 582
 583             syncResult = true;
 584         } catch (InvalidArgsException e) {
 585             e.printStackTrace();
 586         } catch (SimulatorException e) {
 587             e.printStackTrace();
 588         }
 589
 590         assertTrue(syncResult);
 591         assertNotNull(response.get());
 592         assertNotNull(response.get().resourceModel());
 593         assertEquals(remoteResource.getId(), response.get().uid());
 594     }
 595
 596     public void testPost_P04() {
 597         CountDownLatch lockObject = new CountDownLatch(1);
 598         boolean syncResult = false;
 599         ObjectHolder<ResponseDetails> response = new ObjectHolder<>();
 600         PostResponseCallbackListener listener = new PostResponseCallbackListener(
 601                 lockObject, response);
 602
 603         try {
 604             SimulatorResourceModel resModel = singleResource.getResourceModel();
 605             Map<String, String> queryParams = new HashMap<>();
 606             remoteResource.post(remoteResource.getResourceInterfaces().get(0),
 607                     queryParams, resModel, listener);
 608
 609             try {
 610                 lockObject.await(10, TimeUnit.SECONDS);
 611             } catch (InterruptedException e) {
 612             }
 613
 614             syncResult = true;
 615         } catch (InvalidArgsException e) {
 616             e.printStackTrace();
 617         } catch (SimulatorException e) {
 618             e.printStackTrace();
 619         }
 620
 621         assertTrue(syncResult);
 622         assertNotNull(response.get());
 623         assertNotNull(response.get().resourceModel());
 624         assertEquals(remoteResource.getId(), response.get().uid());
 625     }
 626
 627     public void testPost_P05() {
 628         CountDownLatch lockObject = new CountDownLatch(1);
 629         boolean syncResult = false;
 630         ObjectHolder<ResponseDetails> response = new ObjectHolder<>();
 631         PostResponseCallbackListener listener = new PostResponseCallbackListener(
 632                 lockObject, response);
 633
 634         try {
 635             SimulatorResourceModel resModel = singleResource.getResourceModel();
 636             Map<String, String> queryParams = new HashMap<>();
 637             remoteResource.post(queryParams, null, listener);
 638
 639             try {
 640                 lockObject.await(10, TimeUnit.SECONDS);
 641             } catch (InterruptedException e) {
 642             }
 643
 644             syncResult = true;
 645         } catch (InvalidArgsException e) {
 646             e.printStackTrace();
 647         } catch (SimulatorException e) {
 648             e.printStackTrace();
 649         }
 650
 651         assertTrue(syncResult);
 652         assertNotNull(response.get());
 653         assertNotNull(response.get().resourceModel());
 654         assertEquals(remoteResource.getId(), response.get().uid());
 655     }
 656
 657     public void testPost_N01() {
 658         ExceptionType exType = ExceptionType.UNKNOWN;
 659
 660         try {
 661             SimulatorResourceModel resModel = singleResource.getResourceModel();
 662             remoteResource.post(null, resModel, null);
 663         } catch (InvalidArgsException e) {
 664             exType = ExceptionType.INVALID_ARGS;
 665         } catch (SimulatorException e) {
 666             exType = ExceptionType.SIMULATOR;
 667         }
 668
 669         assertTrue(exType == ExceptionType.INVALID_ARGS);
 670     }
 671
 672     public void testPost_N02() {
 673         ExceptionType exType = ExceptionType.UNKNOWN;
 674
 675         try {
 676             SimulatorResourceModel resModel = singleResource.getResourceModel();
 677             remoteResource.post(remoteResource.getResourceInterfaces().get(0),
 678                     null, resModel, null);
 679         } catch (InvalidArgsException e) {
 680             exType = ExceptionType.INVALID_ARGS;
 681         } catch (SimulatorException e) {
 682             exType = ExceptionType.SIMULATOR;
 683         }
 684
 685         assertTrue(exType == ExceptionType.INVALID_ARGS);
 686     }
 687
 688     public void testPost_N03() {
 689         ExceptionType exType = ExceptionType.UNKNOWN;
 690
 691         try {
 692             SimulatorResourceModel resModel = singleResource.getResourceModel();
 693             Map<String, String> queryParams = new HashMap<>();
 694             remoteResource.post(null, queryParams, resModel,
 695                     new SimulatorRemoteResource.PostResponseListener() {
 696                         @Override
 697                         public void onPostResponse(String uid,
 698                                 SimulatorResult result,
 699                                 SimulatorResourceModel resourceModel) {
 700                         }
 701                     });
 702         } catch (InvalidArgsException e) {
 703             exType = ExceptionType.INVALID_ARGS;
 704         } catch (SimulatorException e) {
 705             exType = ExceptionType.SIMULATOR;
 706         }
 707
 708         assertTrue(exType == ExceptionType.INVALID_ARGS);
 709     }
 710
 711     public void testStartObserve_P01() {
 712         CountDownLatch lockObject = new CountDownLatch(1);
 713         boolean syncResult = false;
 714         ObjectHolder<ResponseDetails> response = new ObjectHolder<>();
 715         ObserveNotificationCallbackListener listener = new ObserveNotificationCallbackListener(
 716                 lockObject, response);
 717
 718         try {
 719             Map<String, String> queryParams = new HashMap<>();
 720             remoteResource.startObserve(queryParams, listener);
 721             singleResource.addAttribute(new SimulatorResourceAttribute(
 722                     "boolean", new AttributeValue(true), null));
 723             singleResource.removeAttribute("boolean");
 724
 725             try {
 726                 lockObject.await(10, TimeUnit.SECONDS);
 727             } catch (InterruptedException e) {
 728             }
 729
 730             remoteResource.stopObserve();
 731             syncResult = true;
 732         } catch (InvalidArgsException e) {
 733             e.printStackTrace();
 734         } catch (SimulatorException e) {
 735             e.printStackTrace();
 736         }
 737
 738         assertTrue(syncResult);
 739         assertNotNull(response.get());
 740         assertNotNull(response.get().resourceModel());
 741         assertEquals(remoteResource.getId(), response.get().uid());
 742     }
 743
 744     public void testStartObserve_P02() {
 745         CountDownLatch lockObject = new CountDownLatch(1);
 746         boolean syncResult = false;
 747         ObjectHolder<ResponseDetails> response = new ObjectHolder<>();
 748         ObserveNotificationCallbackListener listener = new ObserveNotificationCallbackListener(
 749                 lockObject, response);
 750
 751         try {
 752             remoteResource.startObserve(null, listener);
 753             singleResource.addAttribute(new SimulatorResourceAttribute(
 754                     "boolean", new AttributeValue(true), null));
 755             singleResource.removeAttribute("boolean");
 756
 757             try {
 758                 lockObject.await(10, TimeUnit.SECONDS);
 759             } catch (InterruptedException e) {
 760             }
 761
 762             remoteResource.stopObserve();
 763             syncResult = true;
 764         } catch (InvalidArgsException e) {
 765             e.printStackTrace();
 766         } catch (SimulatorException e) {
 767             e.printStackTrace();
 768         }
 769
 770         assertTrue(syncResult);
 771         assertNotNull(response.get());
 772         assertNotNull(response.get().resourceModel());
 773         assertEquals(remoteResource.getId(), response.get().uid());
 774     }
 775
 776     public void testStartObserve_N01() {
 777         ExceptionType exType = ExceptionType.UNKNOWN;
 778
 779         try {
 780             Map<String, String> queryParams = new HashMap<>();
 781             remoteResource.startObserve(queryParams, null);
 782
 783         } catch (InvalidArgsException e) {
 784             exType = ExceptionType.INVALID_ARGS;
 785         } catch (SimulatorException e) {
 786             exType = ExceptionType.SIMULATOR;
 787         }
 788
 789         assertTrue(exType == ExceptionType.INVALID_ARGS);
 790     }
 791
 792     public void testStopObserve_P01() {
 793         CountDownLatch lockObject = new CountDownLatch(1);
 794         boolean syncResult = false;
 795         ObjectHolder<ResponseDetails> response = new ObjectHolder<>();
 796         ObserveNotificationCallbackListener listener = new ObserveNotificationCallbackListener(
 797                 lockObject, response);
 798
 799         try {
 800             Map<String, String> queryParams = new HashMap<>();
 801             remoteResource.startObserve(queryParams, listener);
 802
 803             try {
 804                 lockObject.await(10, TimeUnit.SECONDS);
 805             } catch (InterruptedException e) {
 806             }
 807
 808             response.set(null);
 809             remoteResource.stopObserve();
 810             singleResource.addAttribute(new SimulatorResourceAttribute(
 811                     "boolean", new AttributeValue(true), null));
 812             singleResource.removeAttribute("boolean");
 813
 814             try {
 815                 lockObject.await(10, TimeUnit.SECONDS);
 816             } catch (InterruptedException e) {
 817             }
 818
 819             syncResult = true;
 820         } catch (InvalidArgsException e) {
 821             e.printStackTrace();
 822         } catch (SimulatorException e) {
 823             e.printStackTrace();
 824         }
 825
 826         assertTrue(syncResult);
 827         assertNull(response.get());
 828     }
 829
 830     public void testSetConfigInfo_P01() {
 831         boolean syncResult = false;
 832         try {
 833             remoteResource.setConfigInfo(SINGLE_RES_RAML);
 834             syncResult = true;
 835         } catch (InvalidArgsException e) {
 836             e.printStackTrace();
 837         } catch (SimulatorException e) {
 838             e.printStackTrace();
 839         }
 840
 841         assertTrue(syncResult);
 842     }
 843
 844     public void testSetConfigInfo_N01() {
 845         ExceptionType exType = ExceptionType.UNKNOWN;
 846
 847         try {
 848             remoteResource.setConfigInfo("");
 849         } catch (InvalidArgsException e) {
 850             exType = ExceptionType.INVALID_ARGS;
 851         } catch (SimulatorException e) {
 852             exType = ExceptionType.SIMULATOR;
 853         }
 854
 855         assertTrue(exType == ExceptionType.INVALID_ARGS);
 856     }
 857
 858     public void testSetConfigInfo_N02() {
 859         ExceptionType exType = ExceptionType.UNKNOWN;
 860
 861         try {
 862             remoteResource.setConfigInfo(null);
 863         } catch (InvalidArgsException e) {
 864             exType = ExceptionType.INVALID_ARGS;
 865         } catch (SimulatorException e) {
 866             exType = ExceptionType.SIMULATOR;
 867         }
 868
 869         assertTrue(exType == ExceptionType.INVALID_ARGS);
 870     }
 871
 872     public void testStartVerification_P01() {
 873         CountDownLatch lockObject = new CountDownLatch(1);
 874         boolean syncResult = false;
 875         ObjectHolder<ResponseDetails> response = new ObjectHolder<>();
 876         VerificationCallbackListener listener = new VerificationCallbackListener(
 877                 lockObject, response);
 878
 879         try {
 880             remoteResource.setConfigInfo(SINGLE_RES_RAML);
 881             remoteResource.startVerification(
 882                     SimulatorRemoteResource.VerificationType.GET, listener);
 883
 884             try {
 885                 lockObject.await(10, TimeUnit.SECONDS);
 886             } catch (InterruptedException e) {
 887             }
 888
 889             syncResult = true;
 890         } catch (InvalidArgsException e) {
 891             e.printStackTrace();
 892         } catch (SimulatorException e) {
 893             e.printStackTrace();
 894         }
 895
 896         assertTrue(syncResult);
 897         assertNotNull(response.get());
 898         assertEquals(remoteResource.getId(), response.get().uid());
 899     }
 900
 901     public void testStartVerification_P02() {
 902         CountDownLatch lockObject = new CountDownLatch(1);
 903         boolean syncResult = false;
 904         ObjectHolder<ResponseDetails> response = new ObjectHolder<>();
 905         VerificationCallbackListener listener = new VerificationCallbackListener(
 906                 lockObject, response);
 907
 908         try {
 909             remoteResource.setConfigInfo(SINGLE_RES_RAML);
 910             remoteResource.startVerification(
 911                     SimulatorRemoteResource.VerificationType.PUT, listener);
 912
 913             try {
 914                 lockObject.await(10, TimeUnit.SECONDS);
 915             } catch (InterruptedException e) {
 916             }
 917
 918             syncResult = true;
 919         } catch (InvalidArgsException e) {
 920             e.printStackTrace();
 921         } catch (SimulatorException e) {
 922             e.printStackTrace();
 923         }
 924
 925         assertTrue(syncResult);
 926         assertNotNull(response.get());
 927         assertEquals(remoteResource.getId(), response.get().uid());
 928     }
 929
 930     public void testStartVerification_P03() {
 931         CountDownLatch lockObject = new CountDownLatch(1);
 932         boolean syncResult = false;
 933         ObjectHolder<ResponseDetails> response = new ObjectHolder<>();
 934         VerificationCallbackListener listener = new VerificationCallbackListener(
 935                 lockObject, response);
 936
 937         try {
 938             remoteResource.setConfigInfo(SINGLE_RES_RAML);
 939             remoteResource.startVerification(
 940                     SimulatorRemoteResource.VerificationType.POST, listener);
 941
 942             try {
 943                 lockObject.await(10, TimeUnit.SECONDS);
 944             } catch (InterruptedException e) {
 945             }
 946
 947             syncResult = true;
 948         } catch (InvalidArgsException e) {
 949             e.printStackTrace();
 950         } catch (SimulatorException e) {
 951             e.printStackTrace();
 952         }
 953
 954         assertTrue(syncResult);
 955         assertNotNull(response.get());
 956         assertEquals(remoteResource.getId(), response.get().uid());
 957     }
 958
 959     public void testStartVerification_N01() {
 960         ExceptionType exType = ExceptionType.UNKNOWN;
 961
 962         try {
 963             remoteResource.setConfigInfo(SINGLE_RES_RAML);
 964             remoteResource.startVerification(
 965                     SimulatorRemoteResource.VerificationType.GET, null);
 966         } catch (InvalidArgsException e) {
 967             exType = ExceptionType.INVALID_ARGS;
 968         } catch (SimulatorException e) {
 969             exType = ExceptionType.SIMULATOR;
 970         }
 971
 972         assertTrue(exType == ExceptionType.INVALID_ARGS);
 973     }
 974
 975     public void testStopVerification_N01() {
 976         CountDownLatch lockObject = new CountDownLatch(1);
 977         boolean syncResult = false;
 978         ObjectHolder<ResponseDetails> response = new ObjectHolder<>();
 979         VerificationCallbackListener listener = new VerificationCallbackListener(
 980                 lockObject, response);
 981
 982         try {
 983             remoteResource.setConfigInfo(SINGLE_RES_RAML);
 984             int id = remoteResource.startVerification(
 985                     SimulatorRemoteResource.VerificationType.POST, listener);
 986             remoteResource.stopVerification(id);
 987             syncResult = true;
 988         } catch (InvalidArgsException e) {
 989             e.printStackTrace();
 990         } catch (SimulatorException e) {
 991             e.printStackTrace();
 992         }
 993
 994         assertTrue(syncResult);
 995     }
 996 }
 997
 998 class ResponseDetails {
 999     private String                 mUid      = null;
1000     private SimulatorResourceModel mResModel = null;
1001     private SimulatorResult        mResult   = SimulatorResult.SIMULATOR_ERROR;
1002
1003     ResponseDetails(String uid, SimulatorResult result,
1004             SimulatorResourceModel resModel) {
1005         mUid = uid;
1006         mResModel = resModel;
1007         mResult = result;
1008     }
1009
1010     String uid() {
1011         return mUid;
1012     }
1013
1014     SimulatorResourceModel resourceModel() {
1015         return mResModel;
1016     }
1017
1018     SimulatorResult errorCode() {
1019         return mResult;
1020     }
1021 }
1022
1023 class GetResponseCallbackListener implements
1024         SimulatorRemoteResource.GetResponseListener {
1025     private CountDownLatch                mLockObject;
1026     private ObjectHolder<ResponseDetails> mResponse;
1027
1028     public GetResponseCallbackListener(CountDownLatch lockObject,
1029             ObjectHolder<ResponseDetails> response) {
1030         mLockObject = lockObject;
1031         mResponse = response;
1032     }
1033
1034     @Override
1035     public void onGetResponse(String uid, SimulatorResult result,
1036             SimulatorResourceModel resourceModel) {
1037         mResponse.set(new ResponseDetails(uid, result, resourceModel));
1038         mLockObject.countDown();
1039     }
1040 }
1041
1042 class PutResponseCallbackListener implements
1043         SimulatorRemoteResource.PutResponseListener {
1044     private CountDownLatch                mLockObject;
1045     private ObjectHolder<ResponseDetails> mResponse;
1046
1047     public PutResponseCallbackListener(CountDownLatch lockObject,
1048             ObjectHolder<ResponseDetails> response) {
1049         mLockObject = lockObject;
1050         mResponse = response;
1051     }
1052
1053     @Override
1054     public void onPutResponse(String uid, SimulatorResult result,
1055             SimulatorResourceModel resourceModel) {
1056         mResponse.set(new ResponseDetails(uid, result, resourceModel));
1057         mLockObject.countDown();
1058     }
1059 }
1060
1061 class PostResponseCallbackListener implements
1062         SimulatorRemoteResource.PostResponseListener {
1063     private CountDownLatch                mLockObject;
1064     private ObjectHolder<ResponseDetails> mResponse;
1065
1066     public PostResponseCallbackListener(CountDownLatch lockObject,
1067             ObjectHolder<ResponseDetails> response) {
1068         mLockObject = lockObject;
1069         mResponse = response;
1070     }
1071
1072     @Override
1073     public void onPostResponse(String uid, SimulatorResult result,
1074             SimulatorResourceModel resourceModel) {
1075         mResponse.set(new ResponseDetails(uid, result, resourceModel));
1076         mLockObject.countDown();
1077     }
1078 }
1079
1080 class ObserveNotificationCallbackListener implements
1081         SimulatorRemoteResource.ObserveNotificationListener {
1082     private CountDownLatch                mLockObject;
1083     private ObjectHolder<ResponseDetails> mResponse;
1084
1085     public ObserveNotificationCallbackListener(CountDownLatch lockObject,
1086             ObjectHolder<ResponseDetails> response) {
1087         mLockObject = lockObject;
1088         mResponse = response;
1089     }
1090
1091     @Override
1092     public void onObserveNotification(String uid,
1093             SimulatorResourceModel resourceModel, int sequenceNumber) {
1094         mResponse.set(new ResponseDetails(uid, SimulatorResult.SIMULATOR_OK,
1095                 resourceModel));
1096         mLockObject.countDown();
1097     }
1098 }
1099
1100 class VerificationCallbackListener implements
1101         SimulatorRemoteResource.VerificationListener {
1102     private CountDownLatch                mLockObject;
1103     private ObjectHolder<ResponseDetails> mResponse;
1104
1105     public VerificationCallbackListener(CountDownLatch lockObject,
1106             ObjectHolder<ResponseDetails> response) {
1107         mLockObject = lockObject;
1108         mResponse = response;
1109     }
1110
1111     @Override
1112     public void onVerificationStarted(String uid, int id) {
1113         mResponse.set(new ResponseDetails(uid, SimulatorResult.SIMULATOR_OK,
1114                 null));
1115         mLockObject.countDown();
1116     }
1117
1118     @Override
1119     public void onVerificationAborted(String uid, int id) {
1120         mResponse.set(new ResponseDetails(uid, SimulatorResult.SIMULATOR_OK,
1121                 null));
1122         mLockObject.countDown();
1123     }
1124
1125     @Override
1126     public void onVerificationCompleted(String uid, int id) {
1127         mResponse.set(new ResponseDetails(uid, SimulatorResult.SIMULATOR_OK,
1128                 null));
1129         mLockObject.countDown();
1130     }
1131 }
1132
1133 class FindResourceCallbackListener implements FindResourceListener {
1134     private CountDownLatch                        mLockObject;
1135     private ObjectHolder<SimulatorRemoteResource> mResourceHolder;
1136
1137     public FindResourceCallbackListener(CountDownLatch lockObject,
1138             ObjectHolder<SimulatorRemoteResource> resourceHolder) {
1139         mLockObject = lockObject;
1140         mResourceHolder = resourceHolder;
1141     }
1142
1143     @Override
1144     public void onResourceFound(SimulatorRemoteResource resource) {
1145         mResourceHolder.set(resource);
1146         mLockObject.countDown();
1147     }
1148 }