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     public void testPost_P01()
 356     {
 357         boolean result = true;
 358         ListenerObject listenerObject = null;
 359         lockObject = new CountDownLatch(1);
 360
 361         SimulatorResourceModel model = new SimulatorResourceModel();
 362         try
 363         {
 364             model.addAttributeInt("intensity", 8);
 365             //model.addAttributeString("power", "off");
 366
 367             listenerObject = new ListenerObject();
 368             PostListener postListener = new PostListener(lockObject, listenerObject);
 369
 370             simulatorRemoteResource.post(model, null, postListener);
 371         }
 372         catch(Exception e)
 373         {
 374             result = false;
 375         }
 376
 377         try
 378         {
 379             lockObject.await(10, TimeUnit.SECONDS);
 380         }
 381         catch (InterruptedException e)
 382         {
 383         }
 384
 385         assertTrue(result && listenerObject != null && listenerObject.getRepresentation() != null && listenerObject.getuId() != null);
 386     }
 387
 388     public void testGet_P01()
 389     {
 390         boolean result = true;
 391         ListenerObject listenerObject = null;
 392         lockObject = new CountDownLatch(1);
 393
 394         try
 395         {
 396             listenerObject = new ListenerObject();
 397             GetListener onGetListener = new GetListener(lockObject, listenerObject);
 398
 399             String resInterface = simulatorRemoteResource.getResourceInterfaces().get(0);
 400
 401             if(resInterface == null)
 402                 simulatorRemoteResource.get(resInterface, null, onGetListener);
 403             else
 404                 result = false;
 405         }
 406         catch(Exception e)
 407         {
 408             result = false;
 409         }
 410
 411         try
 412         {
 413             lockObject.await(10, TimeUnit.SECONDS);
 414         }
 415         catch (InterruptedException e)
 416         {
 417         }
 418
 419         assertTrue(result && listenerObject != null && listenerObject.getRepresentation() != null && listenerObject.getuId() != null);
 420     }
 421
 422     /**
 423      * null resInterface
 424      */
 425     public void testGet_N01()
 426     {
 427         boolean result = false;
 428         ListenerObject listenerObject = null;
 429         lockObject = new CountDownLatch(1);
 430
 431         try
 432         {
 433             listenerObject = new ListenerObject();
 434             GetListener onGetListener = new GetListener(lockObject, listenerObject);
 435
 436             simulatorRemoteResource.get(null, null, onGetListener);
 437             result = false;
 438         }
 439         catch(Exception e)
 440         {
 441             result = true;
 442         }
 443
 444         try
 445         {
 446             lockObject.await(10, TimeUnit.SECONDS);
 447         }
 448         catch (InterruptedException e)
 449         {
 450         }
 451
 452         assertTrue(result);
 453     }
 454
 455     /**
 456      * null listener
 457      */
 458     public void testGet_N02()
 459     {
 460         boolean result = false;
 461         try
 462         {
 463             String resInterface = simulatorRemoteResource.getResourceInterfaces().get(0);
 464
 465             if(resInterface == null)
 466                 simulatorRemoteResource.get(resInterface, null, null);
 467             else
 468                 result = false;
 469         }
 470         catch(Exception e)
 471         {
 472             result = true;
 473         }
 474
 475         assertTrue(result);
 476     }
 477
 478     /**
 479      * all params as null
 480      */
 481     public void testGet_N03()
 482     {
 483         boolean result = false;
 484         try
 485         {
 486             simulatorRemoteResource.get(null, null, null);
 487             result = false;
 488         }
 489         catch(Exception e)
 490         {
 491             result = true;
 492         }
 493
 494         assertTrue(result);
 495     }
 496
 497     public void testGetWithoutResInterface_P01()
 498     {
 499         boolean result = true;
 500         ListenerObject listenerObject = null;
 501         lockObject = new CountDownLatch(1);
 502
 503         try
 504         {
 505             listenerObject = new ListenerObject();
 506             GetListener onGetListener = new GetListener(lockObject, listenerObject);
 507
 508             simulatorRemoteResource.get(null, onGetListener);
 509         }
 510         catch(Exception e)
 511         {
 512             result = false;
 513         }
 514
 515         try
 516         {
 517             lockObject.await(10, TimeUnit.SECONDS);
 518         }
 519         catch (InterruptedException e)
 520         {
 521         }
 522
 523         assertTrue(result && listenerObject != null && listenerObject.getRepresentation() != null && listenerObject.getuId() != null);
 524     }
 525
 526     /**
 527      * null listener
 528      */
 529     public void testGetWithoutResInterface_N01()
 530     {
 531         boolean result = false;
 532         try
 533         {
 534             simulatorRemoteResource.get(null, null);
 535             result = false;
 536         }
 537         catch(Exception e)
 538         {
 539             result = true;
 540         }
 541
 542         assertTrue(result);
 543     }
 544
 545     public void testSetConfigInfo_P01()
 546     {
 547         boolean result = true;
 548         try
 549         {
 550             simulatorRemoteResource.setConfigInfo(CONFIG_PATH);
 551         }
 552         catch (Exception e2)
 553         {
 554             e2.printStackTrace();
 555             result = false;
 556         }
 557
 558         lockObject = new CountDownLatch(1);
 559         VerifyListenerObject verifyListenerObject = new VerifyListenerObject();
 560         VerifyListener verifyListener = new VerifyListener(lockObject, verifyListenerObject);
 561
 562         try
 563         {
 564             simulatorRemoteResource.startVerification(SimulatorVerificationType.RQ_TYPE_POST, verifyListener);
 565         }
 566         catch (Exception e1)
 567         {
 568             e1.printStackTrace();
 569             result = false;
 570         }
 571
 572         try
 573         {
 574             lockObject.await(10, TimeUnit.MILLISECONDS);
 575         }
 576         catch (InterruptedException e)
 577         {
 578         }
 579
 580         assertTrue(result && verifyListenerObject.getWhichOne().equals("started")&&
 581                    verifyListenerObject.getuId() != null &&
 582                    verifyListenerObject.getId() != -1);
 583     }
 584
 585     /**
 586      * Passing empty
 587      */
 588     public void testSetConfigInfo_N01()
 589     {
 590         boolean result = true;
 591         try
 592         {
 593             simulatorRemoteResource.setConfigInfo("");
 594             result = false;
 595         }
 596         catch (Exception e2)
 597         {
 598             result = true;
 599         }
 600
 601         assertTrue(result);
 602     }
 603
 604     public void testStartVerification_P01()
 605     {
 606         boolean result = true;
 607         lockObject = new CountDownLatch(1);
 608         try
 609         {
 610             simulatorRemoteResource.setConfigInfo(CONFIG_PATH);
 611         }
 612         catch (Exception e1)
 613         {
 614             e1.printStackTrace();
 615             result = false;
 616         }
 617
 618         VerifyListenerObject verifyListenerObject = new VerifyListenerObject();
 619         VerifyListener verifyListener = new VerifyListener(lockObject, verifyListenerObject);
 620         try
 621         {
 622             result =  result && simulatorRemoteResource.startVerification(SimulatorVerificationType.RQ_TYPE_POST, verifyListener) != -1;
 623         }
 624         catch (Exception e1)
 625         {
 626             e1.printStackTrace();
 627             result = false;
 628         }
 629
 630         try
 631         {
 632             lockObject.await(10, TimeUnit.MILLISECONDS);
 633         }
 634         catch (InterruptedException e)
 635         {
 636         }
 637
 638         assertTrue(result && verifyListenerObject.getWhichOne().equals("started") &&
 639                    verifyListenerObject.getuId() != null &&
 640                    verifyListenerObject.getId() != -1);
 641     }
 642
 643     public void testStartVerification_P02()
 644     {
 645         boolean result = true;
 646         lockObject = new CountDownLatch(1);
 647         try
 648         {
 649             simulatorRemoteResource.setConfigInfo(CONFIG_PATH);
 650         }
 651         catch (Exception e1)
 652         {
 653             e1.printStackTrace();
 654             result = false;
 655         }
 656
 657         VerifyListenerObject verifyListenerObject = new VerifyListenerObject();
 658         VerifyListener verifyListener = new VerifyListener(lockObject, verifyListenerObject);
 659         try
 660         {
 661             result =  result && simulatorRemoteResource.startVerification(SimulatorVerificationType.RQ_TYPE_PUT, verifyListener) != -1;
 662         }
 663         catch (Exception e1)
 664         {
 665             e1.printStackTrace();
 666             result = false;
 667         }
 668
 669         try
 670         {
 671             lockObject.await(10, TimeUnit.MILLISECONDS);
 672         }
 673         catch (InterruptedException e)
 674         {
 675         }
 676
 677         assertTrue(result && verifyListenerObject.getWhichOne().equals("started") &&
 678                    verifyListenerObject.getuId() != null &&
 679                    verifyListenerObject.getId() != -1);
 680     }
 681
 682     public void testStartVerification_P03()
 683     {
 684         boolean result = true;
 685         lockObject = new CountDownLatch(1);
 686         try
 687         {
 688             simulatorRemoteResource.setConfigInfo(CONFIG_PATH);
 689         }
 690         catch (Exception e1)
 691         {
 692             e1.printStackTrace();
 693             result = false;
 694         }
 695
 696         VerifyListenerObject verifyListenerObject = new VerifyListenerObject();
 697         VerifyListener verifyListener = new VerifyListener(lockObject, verifyListenerObject);
 698         try
 699         {
 700             result =  result && simulatorRemoteResource.startVerification(SimulatorVerificationType.RQ_TYPE_GET, verifyListener) != -1;
 701         }
 702         catch (Exception e1)
 703         {
 704             e1.printStackTrace();
 705             result = false;
 706         }
 707
 708         try
 709         {
 710             lockObject.await(10, TimeUnit.MILLISECONDS);
 711         }
 712         catch (InterruptedException e)
 713         {
 714         }
 715
 716         assertTrue(result && verifyListenerObject.getWhichOne().equals("started") &&
 717                    verifyListenerObject.getuId() != null &&
 718                    verifyListenerObject.getId() != -1);
 719     }
 720
 721     /**
 722      * setting listener to null
 723      */
 724     public void testStartVerification_N01()
 725     {
 726         boolean result = true;
 727         try
 728         {
 729             simulatorRemoteResource.setConfigInfo(CONFIG_PATH);
 730         }
 731         catch (Exception e)
 732         {
 733             e.printStackTrace();
 734             result = false;
 735         }
 736
 737         try
 738         {
 739             result = result && (simulatorRemoteResource.startVerification(SimulatorVerificationType.RQ_TYPE_POST, null) == -1);
 740             result = false;
 741         }
 742         catch (Exception e)
 743         {
 744             result = true;
 745         }
 746         assertTrue(result);
 747     }
 748
 749     public void testStopVerification_P01()
 750     {
 751         boolean result = true;
 752         lockObject = new CountDownLatch(2);
 753         try
 754         {
 755             simulatorRemoteResource.setConfigInfo(CONFIG_PATH);
 756         }
 757         catch (Exception e1)
 758         {
 759             e1.printStackTrace();
 760             result = false;
 761         }
 762
 763         VerifyListenerObject verifyListenerObject = new VerifyListenerObject();
 764         VerifyListener verifyListener = new VerifyListener(lockObject, verifyListenerObject);
 765         try
 766         {
 767             result =  result && simulatorRemoteResource.startVerification(SimulatorVerificationType.RQ_TYPE_POST, verifyListener) != -1;
 768         }
 769         catch (Exception e1)
 770         {
 771             e1.printStackTrace();
 772             result = false;
 773         }
 774
 775         try
 776         {
 777             lockObject.await(10, TimeUnit.MILLISECONDS);
 778         }
 779         catch (InterruptedException e)
 780         {
 781         }
 782
 783         result = result && verifyListenerObject.getWhichOne().equals("started") &&
 784                  verifyListenerObject.getuId() != null &&
 785                  verifyListenerObject.getId() != -1;
 786
 787         try
 788         {
 789             simulatorRemoteResource.stopVerification(verifyListenerObject.getId());
 790         }
 791         catch (Exception e1)
 792         {
 793             e1.printStackTrace();
 794             result = false;
 795         }
 796
 797         try
 798         {
 799
 800             lockObject.await(100, TimeUnit.MILLISECONDS);
 801         }
 802         catch (InterruptedException e)
 803         {
 804         }
 805
 806         assertTrue(result && verifyListenerObject.getWhichOne().equals("aborted") &&
 807                    verifyListenerObject.getuId() != null &&
 808                    verifyListenerObject.getId() != -1);
 809     }
 810
 811     /**
 812      * Random id. This is just to check the crash
 813      */
 814     public void testStopVerification_N01()
 815     {
 816         boolean result = true;
 817         lockObject = new CountDownLatch(1);
 818         try
 819         {
 820             simulatorRemoteResource.setConfigInfo(CONFIG_PATH);
 821         }
 822         catch (Exception e2)
 823         {
 824             result = false;
 825             e2.printStackTrace();
 826         }
 827
 828         VerifyListenerObject verifyListenerObject = new VerifyListenerObject();
 829         VerifyListener verifyListener = new VerifyListener(lockObject, verifyListenerObject);
 830         try
 831         {
 832             result =  result && simulatorRemoteResource.startVerification(SimulatorVerificationType.RQ_TYPE_POST, verifyListener) != -1;
 833         }
 834         catch (Exception e1)
 835         {
 836             e1.printStackTrace();
 837             result = false;
 838         }
 839
 840         try
 841         {
 842             lockObject.await(10, TimeUnit.SECONDS);
 843         }
 844         catch (InterruptedException e)
 845         {
 846         }
 847
 848         result = result && verifyListenerObject.getWhichOne().equals("started") &&
 849                  verifyListenerObject.getuId() != null &&
 850                  verifyListenerObject.getId() != -1;
 851
 852         try
 853         {
 854             simulatorRemoteResource.stopVerification(123435);
 855             result = false;
 856         }
 857         catch (Exception e)
 858         {
 859             result = true;
 860         }
 861
 862         assertTrue(result);
 863     }
 864 }