service/simulator/unittests/SimulatorTest/src/org/oic/simulator/clientcontroller/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.clientcontroller.test;
  18
  19 import java.util.HashMap;
  20 import java.util.concurrent.CountDownLatch;
  21 import java.util.concurrent.TimeUnit;
  22
  23 import junit.framework.TestCase;
  24
  25 import org.oic.simulator.SimulatorException;
  26 import org.oic.simulator.SimulatorManager;
  27 import org.oic.simulator.SimulatorResourceModel;
  28 import org.oic.simulator.clientcontroller.SimulatorObserveType;
  29 import org.oic.simulator.clientcontroller.SimulatorRemoteResource;
  30 import org.oic.simulator.clientcontroller.SimulatorVerificationType;
  31 import org.oic.simulator.serviceprovider.SimulatorResourceServer;
  32 import org.oic.simulator.test.FindResourceListener;
  33 import org.oic.simulator.test.ResourceModelChangeListener;
  34 import org.oic.simulator.test.ResourceModelObject;
  35 import org.oic.simulator.test.SimulatorRemoteResourceObject;
  36
  37 /**
  38  * This class tests the functionality of Simulator Remote Resource
  39  * class APIs.
  40  */
  41 public class SimulatorRemoteResourceTest extends TestCase
  42 {
  43     private static final String CONFIG_PATH = "./ramls/simple-light.raml";
  44     //  private static final String RESOURCE_TYPE = "oic.light";
  45
  46     private CountDownLatch lockObject;
  47     private ResourceModelObject resourceModelObject;
  48     private ResourceModelChangeListener resourceModelChangeListener;
  49
  50     private SimulatorRemoteResourceObject simulatorRemoteResourceObject;
  51     private SimulatorRemoteResource simulatorRemoteResource;
  52
  53     private SimulatorResourceServer simulatorResourceServer;
  54
  55     private FindResourceListener findResourceListener;
  56
  57     static
  58     {
  59         System.loadLibrary("SimulatorManager");
  60         System.loadLibrary("RamlParser");
  61         System.loadLibrary("oc");
  62         System.loadLibrary("oc_logger");
  63         System.loadLibrary("octbstack");
  64     }
  65
  66     protected void setUp() throws Exception
  67     {
  68         super.setUp();
  69
  70         lockObject = new CountDownLatch(1);
  71         resourceModelObject = new ResourceModelObject();
  72         resourceModelChangeListener = new ResourceModelChangeListener(resourceModelObject);
  73
  74         simulatorResourceServer = SimulatorManager.createResource(CONFIG_PATH, resourceModelChangeListener);
  75
  76         simulatorRemoteResourceObject = new SimulatorRemoteResourceObject();
  77
  78         findResourceListener = new FindResourceListener(lockObject, simulatorRemoteResourceObject);
  79
  80         SimulatorManager.findResource(findResourceListener);
  81
  82         try
  83         {
  84             lockObject.await(10, TimeUnit.SECONDS);
  85         }
  86         catch (InterruptedException e)
  87         {
  88         }
  89
  90         simulatorRemoteResource = simulatorRemoteResourceObject.getSimulatorRemoteResource();
  91     }
  92
  93     protected void tearDown() throws Exception
  94     {
  95         super.tearDown();
  96
  97         SimulatorManager.deleteResource(simulatorResourceServer);
  98
  99         lockObject = null;
 100         resourceModelObject = null;
 101         resourceModelChangeListener = null;
 102
 103         simulatorRemoteResourceObject = null;
 104         findResourceListener = null;
 105
 106         simulatorRemoteResource = null;
 107     }
 108
 109     public void testGetUri_P01()
 110     {
 111         assertNotNull(simulatorRemoteResource.getUri());
 112     }
 113
 114     public void testGetIsObservable_P01()
 115     {
 116         assertTrue(simulatorRemoteResource.getIsObservable());
 117     }
 118
 119     public void testGetConnectivityType_P01()
 120     {
 121         assertNotNull(simulatorRemoteResource.getConnectivityType());
 122     }
 123
 124     public void testGetResourceTypes_P01()
 125     {
 126         assertTrue(simulatorRemoteResource.getResourceTypes() != null && simulatorRemoteResource.getResourceTypes().size() > 0);
 127     }
 128
 129     public void testGetResourceInterfaces_P01()
 130     {
 131         assertTrue(simulatorRemoteResource.getResourceInterfaces() != null && simulatorRemoteResource.getResourceInterfaces().size() > 0);
 132     }
 133
 134     public void testGetId_P01()
 135     {
 136         assertNotNull(simulatorRemoteResource.getId());
 137     }
 138
 139     public void testStartObserve_P01()
 140     {
 141         boolean result = true;
 142         HashMap<String, String> queryParamMap = new HashMap<String, String>();
 143
 144         lockObject = new CountDownLatch(1);
 145
 146         ObserveListenerObject observeListenerObject = new ObserveListenerObject();
 147         ObserveListener observeListener = new ObserveListener(lockObject, observeListenerObject);
 148
 149         try
 150         {
 151             simulatorRemoteResource.startObserve(SimulatorObserveType.OBSERVE, queryParamMap, observeListener);
 152             simulatorResourceServer.addAttributeString("test", "test");
 153         }
 154         catch (Exception e1)
 155         {
 156             result = false;
 157         }
 158
 159         try
 160         {
 161             lockObject.await(10, TimeUnit.SECONDS);
 162         }
 163         catch (InterruptedException e)
 164         {
 165         }
 166
 167         assertTrue(observeListenerObject.getRepresentation() != null && result);
 168
 169         try
 170         {
 171             simulatorRemoteResource.stopObserve();
 172         }
 173         catch (Exception e)
 174         {
 175             e.printStackTrace();
 176         }
 177
 178         observeListenerObject = null;
 179         observeListener = null;
 180     }
 181
 182     public void testStopObserve_P01()
 183     {
 184         boolean result = true;
 185
 186         HashMap<String, String> queryParamMap = new HashMap<String, String>();
 187         lockObject = new CountDownLatch(1);
 188         ObserveListenerObject observeListenerObject = new ObserveListenerObject();
 189         ObserveListener observeListener = new ObserveListener(lockObject, observeListenerObject);
 190
 191         try
 192         {
 193             simulatorRemoteResource.startObserve(SimulatorObserveType.OBSERVE, queryParamMap, observeListener);
 194             simulatorResourceServer.addAttributeString("test", "test");
 195         }
 196         catch (Exception e1)
 197         {
 198             e1.printStackTrace();
 199             result = false;
 200         }
 201
 202         try
 203         {
 204             lockObject.await(10, TimeUnit.SECONDS);
 205         }
 206         catch (InterruptedException e)
 207         {
 208         }
 209
 210         result = result && observeListenerObject.getRepresentation() != null;
 211
 212         try
 213         {
 214             simulatorRemoteResource.stopObserve();
 215         }
 216         catch (Exception e)
 217         {
 218             result = false;
 219             e.printStackTrace();
 220         }
 221
 222         assertTrue(result);
 223
 224         observeListenerObject = null;
 225         observeListener = null;
 226     }
 227
 228     public void testGetQueryParamGetListener_P01()
 229     {
 230         boolean result = true;
 231         lockObject = new CountDownLatch(1);
 232         HashMap<String, String> queryParamMap = new HashMap<String, String>();
 233
 234         ListenerObject getListenerObject = new ListenerObject();
 235         GetListener getListener = new GetListener(lockObject, getListenerObject);
 236
 237         try
 238         {
 239             simulatorRemoteResource.get(queryParamMap, getListener);
 240         }
 241         catch (Exception e1)
 242         {
 243             e1.printStackTrace();
 244             result = false;
 245         }
 246
 247         try
 248         {
 249             lockObject.await(10, TimeUnit.SECONDS);
 250         }
 251         catch (InterruptedException e)
 252         {
 253         }
 254
 255         if(getListenerObject.getEx() == null)
 256         {
 257             try
 258             {
 259                 result = result && getListenerObject.getRepresentation() != null && getListenerObject.getRepresentation().size() > 0;
 260             }
 261             catch (SimulatorException e)
 262             {
 263                 result = false;
 264                 e.printStackTrace();
 265             }
 266         }
 267         else
 268             result = false;
 269
 270         assertTrue(result);
 271     }
 272
 273     public void testGetStringMapOfStringStringIGetListener_P01()
 274     {
 275         boolean result = true;
 276         lockObject = new CountDownLatch(1);
 277         HashMap<String, String> queryParamMap = new HashMap<String, String>();
 278
 279         String resourceInterface = "oic.if.baseline";
 280
 281         ListenerObject getListenerObject = new ListenerObject();
 282         GetListener getListener = new GetListener(lockObject, getListenerObject);
 283
 284         try
 285         {
 286             simulatorRemoteResource.get(resourceInterface, queryParamMap, getListener);
 287         }
 288         catch (Exception e1)
 289         {
 290             e1.printStackTrace();
 291             result = false;
 292         }
 293
 294         try
 295         {
 296             lockObject.await(10, TimeUnit.SECONDS);
 297         }
 298         catch (InterruptedException e)
 299         {
 300         }
 301
 302         if(getListenerObject.getEx() == null)
 303         {
 304             try
 305             {
 306                 result = result && getListenerObject.getRepresentation() != null && getListenerObject.getRepresentation().size() > 0;
 307             }
 308             catch (SimulatorException e)
 309             {
 310                 result = false;
 311                 e.printStackTrace();
 312             }
 313         }
 314         else
 315             result = false;
 316
 317         assertTrue(result);
 318     }
 319
 320     public void testPut_P01()
 321     {
 322         boolean result = true;
 323         SimulatorResourceModel model = new SimulatorResourceModel();
 324
 325         lockObject = new CountDownLatch(1);
 326
 327         ListenerObject listenerObject = null;
 328
 329         try
 330         {
 331             listenerObject = new ListenerObject();
 332             PutListener putListener = new PutListener(lockObject, listenerObject);
 333
 334             model.addAttributeInt("intensity", 5);
 335             model.addAttributeString("power", "off");
 336
 337             simulatorRemoteResource.put(model, null, putListener);
 338         }
 339         catch(Exception e)
 340         {
 341             result = false;
 342         }
 343
 344         try
 345         {
 346             lockObject.await(10, TimeUnit.SECONDS);
 347         }
 348         catch (InterruptedException e)
 349         {
 350         }
 351
 352         assertTrue(result && listenerObject != null && listenerObject.getRepresentation() != null && listenerObject.getuId() != null);
 353     }
 354
 355     /**
 356      * model as null
 357      */
 358
 359     public void testPut_N01() {
 360         boolean result = true;
 361         ListenerObject listenerObject = new ListenerObject();
 362         PutListener putListener = new PutListener(lockObject, listenerObject);
 363
 364         try {
 365             simulatorRemoteResource.put(null, null, putListener);
 366             result = false;
 367         } catch (Exception e1) {
 368             result = true;
 369         }
 370
 371         try {
 372             lockObject.await(10, TimeUnit.SECONDS);
 373         } catch (InterruptedException e) {
 374         }
 375
 376         assertTrue(result && listenerObject.getRepresentation() == null && listenerObject.getuId() == null);
 377     }
 378
 379     public void testPost_P01()
 380     {
 381         boolean result = true;
 382         ListenerObject listenerObject = null;
 383         lockObject = new CountDownLatch(1);
 384
 385         SimulatorResourceModel model = new SimulatorResourceModel();
 386         try
 387         {
 388             model.addAttributeInt("intensity", 8);
 389
 390             listenerObject = new ListenerObject();
 391             PostListener postListener = new PostListener(lockObject, listenerObject);
 392
 393             simulatorRemoteResource.post(model, null, postListener);
 394         }
 395         catch(Exception e)
 396         {
 397             result = false;
 398         }
 399
 400         try
 401         {
 402             lockObject.await(10, TimeUnit.SECONDS);
 403         }
 404         catch (InterruptedException e)
 405         {
 406         }
 407
 408         assertTrue(result && listenerObject != null && listenerObject.getRepresentation() != null && listenerObject.getuId() != null);
 409     }
 410
 411     /**
 412      * Model is set to null
 413      */
 414
 415     public void testPost_N01() {
 416         boolean result = true;
 417
 418         lockObject = new CountDownLatch(1);
 419
 420         ListenerObject listenerObject = new ListenerObject();
 421         PostListener postListener = new PostListener(lockObject, listenerObject);
 422
 423         try {
 424             simulatorRemoteResource.post(null, null, postListener);
 425             result = false;
 426         } catch (Exception e1) {
 427             result = true;
 428         }
 429
 430         try {
 431             lockObject.await(10, TimeUnit.SECONDS);
 432         } catch (InterruptedException e) {
 433         }
 434
 435         assertTrue(result && listenerObject.getRepresentation() == null && listenerObject.getuId() == null);
 436     }
 437
 438     public void testGet_P01()
 439     {
 440         boolean result = true;
 441         ListenerObject listenerObject = null;
 442         lockObject = new CountDownLatch(1);
 443
 444         try
 445         {
 446             listenerObject = new ListenerObject();
 447             GetListener onGetListener = new GetListener(lockObject, listenerObject);
 448
 449             String resInterface = simulatorRemoteResource.getResourceInterfaces().get(0);
 450
 451             if(resInterface != null)
 452                 simulatorRemoteResource.get(resInterface,null, onGetListener);
 453             else
 454                 result = false;
 455         }
 456         catch(Exception e)
 457         {
 458             result = false;
 459         }
 460
 461         try
 462         {
 463             lockObject.await(10, TimeUnit.SECONDS);
 464         }
 465         catch (InterruptedException e)
 466         {
 467         }
 468
 469         assertTrue(result && listenerObject != null && listenerObject.getRepresentation() != null && listenerObject.getuId() != null);
 470     }
 471
 472     /**
 473      * null resInterface
 474      */
 475     public void testGet_N01()
 476     {
 477         boolean result = false;
 478         ListenerObject listenerObject = null;
 479         lockObject = new CountDownLatch(1);
 480
 481         try
 482         {
 483             listenerObject = new ListenerObject();
 484             GetListener onGetListener = new GetListener(lockObject, listenerObject);
 485
 486             simulatorRemoteResource.get(null, null, onGetListener);
 487             result = false;
 488         }
 489         catch(Exception e)
 490         {
 491             result = true;
 492         }
 493
 494         try
 495         {
 496             lockObject.await(10, TimeUnit.SECONDS);
 497         }
 498         catch (InterruptedException e)
 499         {
 500         }
 501
 502         assertTrue(result);
 503     }
 504
 505     /**
 506      * null listener
 507      */
 508     public void testGet_N02()
 509     {
 510         boolean result = false;
 511         try
 512         {
 513             String resInterface = simulatorRemoteResource.getResourceInterfaces().get(0);
 514
 515             if(resInterface != null)
 516             {
 517                 simulatorRemoteResource.get( resInterface,null, null);
 518             }
 519
 520             result = false;
 521         }
 522         catch(Exception e)
 523         {
 524             result = true;
 525         }
 526
 527         assertTrue(result);
 528     }
 529
 530     /**
 531      * all params as null
 532      */
 533     public void testGet_N03()
 534     {
 535         boolean result = false;
 536         try
 537         {
 538             simulatorRemoteResource.get(null, null, null);
 539             result = false;
 540         }
 541         catch(Exception e)
 542         {
 543             result = true;
 544         }
 545
 546         assertTrue(result);
 547     }
 548
 549     public void testGetWithoutResInterface_P01()
 550     {
 551         boolean result = true;
 552         ListenerObject listenerObject = null;
 553         lockObject = new CountDownLatch(1);
 554
 555         try
 556         {
 557             listenerObject = new ListenerObject();
 558             GetListener onGetListener = new GetListener(lockObject, listenerObject);
 559
 560             simulatorRemoteResource.get(null, onGetListener);
 561         }
 562         catch(Exception e)
 563         {
 564             result = false;
 565         }
 566
 567         try
 568         {
 569             lockObject.await(10, TimeUnit.SECONDS);
 570         }
 571         catch (InterruptedException e)
 572         {
 573         }
 574
 575         assertTrue(result && listenerObject != null && listenerObject.getRepresentation() != null && listenerObject.getuId() != null);
 576     }
 577
 578     /**
 579      * null listener
 580      */
 581     public void testGetWithoutResInterface_N01()
 582     {
 583         boolean result = false;
 584         try
 585         {
 586             simulatorRemoteResource.get(null, null);
 587             result = false;
 588         }
 589         catch(Exception e)
 590         {
 591             result = true;
 592         }
 593
 594         assertTrue(result);
 595     }
 596
 597     public void testSetConfigInfo_P01()
 598     {
 599         boolean result = true;
 600         try
 601         {
 602             simulatorRemoteResource.setConfigInfo(CONFIG_PATH);
 603         }
 604         catch (Exception e2)
 605         {
 606             e2.printStackTrace();
 607             result = false;
 608         }
 609
 610         lockObject = new CountDownLatch(1);
 611         VerifyListenerObject verifyListenerObject = new VerifyListenerObject();
 612         VerifyListener verifyListener = new VerifyListener(lockObject, verifyListenerObject);
 613
 614         try
 615         {
 616             simulatorRemoteResource.startVerification(SimulatorVerificationType.RQ_TYPE_POST, verifyListener);
 617         }
 618         catch (Exception e1)
 619         {
 620             e1.printStackTrace();
 621             result = false;
 622         }
 623
 624         try
 625         {
 626             lockObject.await(10, TimeUnit.MILLISECONDS);
 627         }
 628         catch (InterruptedException e)
 629         {
 630         }
 631
 632         assertTrue(result && verifyListenerObject.getWhichOne().equals("started")&&
 633                    verifyListenerObject.getuId() != null &&
 634                    verifyListenerObject.getId() != -1);
 635     }
 636
 637     /**
 638      * Passing empty
 639      */
 640     public void testSetConfigInfo_N01()
 641     {
 642         boolean result = true;
 643         try
 644         {
 645             simulatorRemoteResource.setConfigInfo("");
 646             result = false;
 647         }
 648         catch (Exception e2)
 649         {
 650             result = true;
 651         }
 652
 653         assertTrue(result);
 654     }
 655
 656     public void testStartVerification_P01()
 657     {
 658         boolean result = true;
 659         lockObject = new CountDownLatch(1);
 660         try
 661         {
 662             simulatorRemoteResource.setConfigInfo(CONFIG_PATH);
 663         }
 664         catch (Exception e1)
 665         {
 666             e1.printStackTrace();
 667             result = false;
 668         }
 669
 670         VerifyListenerObject verifyListenerObject = new VerifyListenerObject();
 671         VerifyListener verifyListener = new VerifyListener(lockObject, verifyListenerObject);
 672         try
 673         {
 674             result =  result && simulatorRemoteResource.startVerification(SimulatorVerificationType.RQ_TYPE_POST, verifyListener) != -1;
 675         }
 676         catch (Exception e1)
 677         {
 678             e1.printStackTrace();
 679             result = false;
 680         }
 681
 682         try
 683         {
 684             lockObject.await(10, TimeUnit.MILLISECONDS);
 685         }
 686         catch (InterruptedException e)
 687         {
 688         }
 689
 690         assertTrue(result && verifyListenerObject.getWhichOne().equals("started") &&
 691                    verifyListenerObject.getuId() != null &&
 692                    verifyListenerObject.getId() != -1);
 693     }
 694
 695     public void testStartVerification_P02()
 696     {
 697         boolean result = true;
 698         lockObject = new CountDownLatch(1);
 699         try
 700         {
 701             simulatorRemoteResource.setConfigInfo(CONFIG_PATH);
 702         }
 703         catch (Exception e1)
 704         {
 705             e1.printStackTrace();
 706             result = false;
 707         }
 708
 709         VerifyListenerObject verifyListenerObject = new VerifyListenerObject();
 710         VerifyListener verifyListener = new VerifyListener(lockObject, verifyListenerObject);
 711         try
 712         {
 713             result =  result && simulatorRemoteResource.startVerification(SimulatorVerificationType.RQ_TYPE_PUT, verifyListener) != -1;
 714         }
 715         catch (Exception e1)
 716         {
 717             e1.printStackTrace();
 718             result = false;
 719         }
 720
 721         try
 722         {
 723             lockObject.await(10, TimeUnit.MILLISECONDS);
 724         }
 725         catch (InterruptedException e)
 726         {
 727         }
 728
 729         assertTrue(result && verifyListenerObject.getWhichOne().equals("started") &&
 730                    verifyListenerObject.getuId() != null &&
 731                    verifyListenerObject.getId() != -1);
 732     }
 733
 734     public void testStartVerification_P03()
 735     {
 736         boolean result = true;
 737         lockObject = new CountDownLatch(1);
 738         try
 739         {
 740             simulatorRemoteResource.setConfigInfo(CONFIG_PATH);
 741         }
 742         catch (Exception e1)
 743         {
 744             e1.printStackTrace();
 745             result = false;
 746         }
 747
 748         VerifyListenerObject verifyListenerObject = new VerifyListenerObject();
 749         VerifyListener verifyListener = new VerifyListener(lockObject, verifyListenerObject);
 750         try
 751         {
 752             result =  result && simulatorRemoteResource.startVerification(SimulatorVerificationType.RQ_TYPE_GET, verifyListener) != -1;
 753         }
 754         catch (Exception e1)
 755         {
 756             e1.printStackTrace();
 757             result = false;
 758         }
 759
 760         try
 761         {
 762             lockObject.await(10, TimeUnit.MILLISECONDS);
 763         }
 764         catch (InterruptedException e)
 765         {
 766         }
 767
 768         assertTrue(result && verifyListenerObject.getWhichOne().equals("started") &&
 769                    verifyListenerObject.getuId() != null &&
 770                    verifyListenerObject.getId() != -1);
 771     }
 772
 773     /**
 774      * setting listener to null
 775      */
 776     public void testStartVerification_N01()
 777     {
 778         boolean result = true;
 779         try
 780         {
 781             simulatorRemoteResource.setConfigInfo(CONFIG_PATH);
 782         }
 783         catch (Exception e)
 784         {
 785             e.printStackTrace();
 786             result = false;
 787         }
 788
 789         try
 790         {
 791             result = result && (simulatorRemoteResource.startVerification(SimulatorVerificationType.RQ_TYPE_POST, null) == -1);
 792             result = false;
 793         }
 794         catch (Exception e)
 795         {
 796             result = true;
 797         }
 798         assertTrue(result);
 799     }
 800
 801     public void testStopVerification_P01()
 802     {
 803         boolean result = true;
 804         lockObject = new CountDownLatch(2);
 805         try
 806         {
 807             simulatorRemoteResource.setConfigInfo(CONFIG_PATH);
 808         }
 809         catch (Exception e1)
 810         {
 811             e1.printStackTrace();
 812             result = false;
 813         }
 814
 815         VerifyListenerObject verifyListenerObject = new VerifyListenerObject();
 816         VerifyListener verifyListener = new VerifyListener(lockObject, verifyListenerObject);
 817         try
 818         {
 819             result =  result && simulatorRemoteResource.startVerification(SimulatorVerificationType.RQ_TYPE_POST, verifyListener) != -1;
 820         }
 821         catch (Exception e1)
 822         {
 823             e1.printStackTrace();
 824             result = false;
 825         }
 826
 827         try
 828         {
 829             lockObject.await(10, TimeUnit.MILLISECONDS);
 830         }
 831         catch (InterruptedException e)
 832         {
 833         }
 834
 835         result = result && verifyListenerObject.getWhichOne().equals("started") &&
 836                  verifyListenerObject.getuId() != null &&
 837                  verifyListenerObject.getId() != -1;
 838
 839         try
 840         {
 841             simulatorRemoteResource.stopVerification(verifyListenerObject.getId());
 842         }
 843         catch (Exception e1)
 844         {
 845             e1.printStackTrace();
 846             result = false;
 847         }
 848
 849         try
 850         {
 851             lockObject.await(100, TimeUnit.MILLISECONDS);
 852         }
 853         catch (InterruptedException e)
 854         {
 855         }
 856
 857         assertTrue(result && verifyListenerObject.getWhichOne().equals("aborted") &&
 858                    verifyListenerObject.getuId() != null &&
 859                    verifyListenerObject.getId() != -1);
 860     }
 861
 862     /**
 863      * Random id. This is just to check the crash
 864      */
 865     public void testStopVerification_N01()
 866     {
 867         boolean result = true;
 868         lockObject = new CountDownLatch(1);
 869         try
 870         {
 871             simulatorRemoteResource.setConfigInfo(CONFIG_PATH);
 872         }
 873         catch (Exception e2)
 874         {
 875             result = false;
 876             e2.printStackTrace();
 877         }
 878
 879         VerifyListenerObject verifyListenerObject = new VerifyListenerObject();
 880         VerifyListener verifyListener = new VerifyListener(lockObject, verifyListenerObject);
 881         try
 882         {
 883             result =  result && simulatorRemoteResource.startVerification(SimulatorVerificationType.RQ_TYPE_POST, verifyListener) != -1;
 884         }
 885         catch (Exception e1)
 886         {
 887             e1.printStackTrace();
 888             result = false;
 889         }
 890
 891         try
 892         {
 893             lockObject.await(10, TimeUnit.SECONDS);
 894         }
 895         catch (InterruptedException e)
 896         {
 897         }
 898
 899         result = result && verifyListenerObject.getWhichOne().equals("started") &&
 900                  verifyListenerObject.getuId() != null &&
 901                  verifyListenerObject.getId() != -1;
 902
 903         try
 904         {
 905             simulatorRemoteResource.stopVerification(123435);
 906             result = false;
 907         }
 908         catch (Exception e)
 909         {
 910             result = true;
 911         }
 912
 913         assertTrue(result);
 914     }
 915 }