1 // Tags: JDK1.4

     2 // Uses: ../../PortableServer/POA/TestBase

     3 

     4 // Copyright (c) IONA Technologies, 2001.

     5 

     6 // Adapted for Mauve by Audrius Meskauskas <audriusa@bluewin.ch>

     7 

     8 // This file is part of Mauve.

     9 

    10 // Mauve is free software; you can redistribute it and/or modify

    11 // it under the terms of the GNU General Public License as published by

    12 // the Free Software Foundation; either version 2, or (at your option)

    13 // any later version.

    14 

    15 // Mauve is distributed in the hope that it will be useful,

    16 // but WITHOUT ANY WARRANTY; without even the implied warranty of

    17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    18 // GNU General Public License for more details.

    19 

    20 // You should have received a copy of the GNU General Public License

    21 // along with Mauve; see the file COPYING.  If not, write to

    22 // the Free Software Foundation, 59 Temple Place - Suite 330,

    23 // Boston, MA 02111-1307, USA.

    24 

    25 /*

    26 This code originally came from the OMG's CORBA Open Source Testing project,

    27 which lived at cost.omg.org. That site no longer exists.

    28 

    29 All the contributing companies agreed to release their tests under the

    30 terms of the GNU Lesser General Public License, available in the file

    31 COPYING.LIB.

    32 

    33 The code has been modified integrating into Mauve test environment and

    34 removing tests that are not yet supported by Suns jre 1.4. Hence the license

    35 is now GPL.

    36 

    37 We downloaded the code from http://sourceforge.net/projects/corba-cost/,

    38 administrated by Duncan Grisby.

    39 */

    40 

    41 

    42 // **********************************************************************

    43 //

    44 // Copyright (c) 2001

    45 // IONA Technologies, Inc.

    46 // Waltham, MA, USA

    47 //

    48 // All Rights Reserved

    49 //

    50 // **********************************************************************

    51 

    52 

    53 package gnu.testlet.org.omg.DynamicAny.DynAny;

    54 

    55 import gnu.testlet.TestHarness;

    56 import gnu.testlet.Testlet;

    57 import gnu.testlet.org.omg.DynamicAny.DynAny.Iona.TestEnum;

    58 import gnu.testlet.org.omg.DynamicAny.DynAny.Iona.TestEnumHelper;

    59 import gnu.testlet.org.omg.DynamicAny.DynAny.Iona.TestStruct;

    60 import gnu.testlet.org.omg.DynamicAny.DynAny.Iona.TestStructHelper;

    61 import gnu.testlet.org.omg.PortableServer.POA.TestBase;

    62 

    63 import org.omg.CORBA.Any;

    64 import org.omg.CORBA.ORB;

    65 import org.omg.CORBA.Object;

    66 import org.omg.CORBA.TCKind;

    67 import org.omg.CORBA.TypeCode;

    68 import org.omg.DynamicAny.DynAny;

    69 import org.omg.DynamicAny.DynAnyFactory;

    70 import org.omg.DynamicAny.DynAnyFactoryHelper;

    71 import org.omg.DynamicAny.DynEnum;

    72 import org.omg.DynamicAny.DynEnumHelper;

    73 import org.omg.DynamicAny.DynFixed;

    74 import org.omg.DynamicAny.DynFixedHelper;

    75 import org.omg.DynamicAny.DynStruct;

    76 import org.omg.DynamicAny.DynStructHelper;

    77 import org.omg.DynamicAny.NameDynAnyPair;

    78 import org.omg.DynamicAny.NameValuePair;

    79 

    80 import java.math.BigDecimal;

    81 

    82 public class BasicTest

    83   extends TestBase

    84   implements Testlet

    85 {

    86   final String ANY_VALUE = "This is a string in an any";

    87   final String STRING_VALUE = "This is a string";

    88   final String WSTRING_VALUE = "This is a wstring";

    89   final boolean BOOLEAN_VALUE = true;

    90   final byte OCTET_VALUE = (byte) 155;

    91   final char CHAR_VALUE = 'Y';

    92   final double DOUBLE_VALUE = 7.31e29;

    93   final float FLOAT_VALUE = (float) 1.9183;

    94   final int LONG_VALUE = -300000;

    95   final int ULONG_VALUE = 500000;

    96   final short SHORT_VALUE = (short) -10000;

    97   final short USHORT_VALUE = (short) 40000;

    98 

    99   //

   100   // Can't do this, because it causes a failure under JDK 1.2.2.

   101   // The problem is that ORB.init() is called before main() has

   102   // a chance to set the ORB properties, so the JDK ORB's

   103   // singleton implementation is used instead. This will result

   104   // in a NullPointerException due to a bug in that ORB.

   105   //

   106   // final TypeCode TYPECODE_VALUE =

   107   // ORB.init().get_primitive_tc(TCKind.tk_float);

   108   TypeCode TYPECODE_VALUE;

   109   final char WCHAR_VALUE = 'Z';

   110   final long LONGLONG_VALUE = -1234567890L;

   111   final long ULONGLONG_VALUE = 9876543210L;

   112   DynAnyFactory factory;

   113   ORB orb;

   114 

   115   public void setUp()

   116   {

   117     orb = org.omg.CORBA.ORB.init(new String[ 0 ], null);

   118     TYPECODE_VALUE = orb.get_primitive_tc(TCKind.tk_float);

   119 

   120     org.omg.CORBA.Object obj = null;

   121 

   122     try

   123       {

   124         obj = orb.resolve_initial_references("DynAnyFactory");

   125         TEST(obj != null);

   126         factory = DynAnyFactoryHelper.narrow(obj);

   127       }

   128     catch (org.omg.CORBA.ORBPackage.InvalidName ex)

   129       {

   130         TEST(false, ex.getMessage());

   131       }

   132   }

   133 

   134   public void allTests(ORB orb, Object o)

   135   {

   136     DynAnyFactory factory = DynAnyFactoryHelper.narrow(o);

   137 

   138     testBasic();

   139     testFixed();

   140     testEnum();

   141     testStruct();

   142   }

   143 

   144   public void test(TestHarness a_harness)

   145   {

   146     harness = a_harness;

   147     setUp();

   148     allTests(orb, factory);

   149     tearDown();

   150   }

   151 

   152   public void testBasic()

   153   {

   154     try

   155       {

   156         org.omg.CORBA.Object obj;

   157         Any any = orb.create_any();

   158         Any av;

   159         DynAny d1 = null;

   160         DynAny d2 = null;

   161         DynAny copy = null;

   162         TypeCode type;

   163         TypeCode tc;

   164 

   165         //

   166         // Test: short

   167         //

   168         type = orb.get_primitive_tc(TCKind.tk_short);

   169         d1 = factory.create_dyn_any_from_type_code(type);

   170         TEST(d1.get_short() == (short) 0);

   171         d1.insert_short((short) -53);

   172         TEST(d1.get_short() == (short) -53);

   173         d1.insert_short((short) 32000);

   174         TEST(d1.get_short() == (short) 32000);

   175 

   176         av = d1.to_any();

   177 

   178         short shortVal = av.extract_short();

   179         TEST(shortVal == (short) 32000);

   180 

   181         any.insert_short((short) 32000);

   182         d2 = factory.create_dyn_any(any);

   183         TEST(d1.equal(d2));

   184 

   185         copy = d1.copy();

   186         TEST(d1.equal(copy));

   187         TEST(copy.get_short() == (short) 32000);

   188 

   189         any.insert_short((short) -99);

   190         d2.from_any(any);

   191         d1.assign(d2);

   192         TEST(d1.equal(d2));

   193 

   194         d1.destroy();

   195         d2.destroy();

   196         copy.destroy();

   197 

   198         testOps(orb, factory, type, false);

   199 

   200         //

   201         // Test: unsigned short

   202         //

   203         type = orb.get_primitive_tc(TCKind.tk_ushort);

   204         d1 = factory.create_dyn_any_from_type_code(type);

   205         TEST(d1.get_ushort() == (short) 0);

   206         d1.insert_ushort((short) 199);

   207         TEST(d1.get_ushort() == (short) 199);

   208         d1.insert_ushort((short) 65001);

   209         TEST(d1.get_ushort() == (short) 65001);

   210 

   211         av = d1.to_any();

   212 

   213         short ushortVal = av.extract_ushort();

   214         TEST(ushortVal == (short) 65001);

   215 

   216         any.insert_ushort((short) 65001);

   217         d2 = factory.create_dyn_any(any);

   218         TEST(d1.equal(d2));

   219 

   220         copy = d1.copy();

   221         TEST(d1.equal(copy));

   222         TEST(copy.get_ushort() == (short) 65001);

   223 

   224         any.insert_ushort((short) 501);

   225         d2.from_any(any);

   226         d1.assign(d2);

   227         TEST(d1.equal(d2));

   228 

   229         d1.destroy();

   230         d2.destroy();

   231         copy.destroy();

   232 

   233         testOps(orb, factory, type, false);

   234 

   235         //

   236         // Test: long

   237         //

   238         type = orb.get_primitive_tc(TCKind.tk_long);

   239         d1 = factory.create_dyn_any_from_type_code(type);

   240         TEST(d1.get_long() == 0);

   241         d1.insert_long(-530000);

   242         TEST(d1.get_long() == -530000);

   243         d1.insert_long(3200000);

   244         TEST(d1.get_long() == 3200000);

   245 

   246         av = d1.to_any();

   247 

   248         int longVal = av.extract_long();

   249         TEST(longVal == 3200000);

   250 

   251         any.insert_long(3200000);

   252         d2 = factory.create_dyn_any(any);

   253         TEST(d1.equal(d2));

   254 

   255         copy = d1.copy();

   256         TEST(d1.equal(copy));

   257         TEST(copy.get_long() == 3200000);

   258 

   259         any.insert_long(-99000);

   260         d2.from_any(any);

   261         d1.assign(d2);

   262         TEST(d1.equal(d2));

   263 

   264         d1.destroy();

   265         d2.destroy();

   266         copy.destroy();

   267 

   268         testOps(orb, factory, type, false);

   269 

   270         //

   271         // Test: unsigned long

   272         //

   273         type = orb.get_primitive_tc(TCKind.tk_ulong);

   274         d1 = factory.create_dyn_any_from_type_code(type);

   275         TEST(d1.get_ulong() == 0);

   276         d1.insert_ulong(199000);

   277         TEST(d1.get_ulong() == 199000);

   278         d1.insert_ulong(65001000);

   279         TEST(d1.get_ulong() == 65001000);

   280 

   281         av = d1.to_any();

   282 

   283         int ulongVal = av.extract_ulong();

   284         TEST(ulongVal == 65001000);

   285 

   286         any.insert_ulong(65001000);

   287         d2 = factory.create_dyn_any(any);

   288         TEST(d1.equal(d2));

   289 

   290         copy = d1.copy();

   291         TEST(d1.equal(copy));

   292         TEST(copy.get_ulong() == 65001000);

   293 

   294         any.insert_ulong(501000);

   295         d2.from_any(any);

   296         d1.assign(d2);

   297         TEST(d1.equal(d2));

   298 

   299         d1.destroy();

   300         d2.destroy();

   301         copy.destroy();

   302 

   303         testOps(orb, factory, type, false);

   304 

   305         //

   306         // Test: float

   307         //

   308         type = orb.get_primitive_tc(TCKind.tk_float);

   309         d1 = factory.create_dyn_any_from_type_code(type);

   310         TEST(d1.get_float() == 0.0f);

   311         d1.insert_float(199.001f);

   312         TEST(d1.get_float() > 199.0f && d1.get_float() < 199.1f);

   313         d1.insert_float(6500.10001f);

   314         TEST(d1.get_float() > 6500.0f && d1.get_float() < 6501.0f);

   315 

   316         av = d1.to_any();

   317 

   318         float floatVal = av.extract_float();

   319         TEST(floatVal > 6500.1 && floatVal < 6500.2);

   320 

   321         any.insert_float((float) 6500.10001);

   322         d2 = factory.create_dyn_any(any);

   323         TEST(d1.equal(d2));

   324 

   325         copy = d1.copy();

   326         TEST(d1.equal(copy));

   327         TEST(copy.get_float() > 6500.1 && copy.get_float() < 6500.2);

   328 

   329         any.insert_float((float) 501.001);

   330         d2.from_any(any);

   331         d1.assign(d2);

   332         TEST(d1.equal(d2));

   333 

   334         d1.destroy();

   335         d2.destroy();

   336         copy.destroy();

   337 

   338         testOps(orb, factory, type, false);

   339 

   340         //

   341         // Test: double

   342         //

   343         type = orb.get_primitive_tc(TCKind.tk_double);

   344         d1 = factory.create_dyn_any_from_type_code(type);

   345         TEST(d1.get_double() == 0.0);

   346         d1.insert_double(199000.001);

   347         TEST(d1.get_double() > 199000.0 && d1.get_double() < 199000.1);

   348         d1.insert_double(6500000.10001);

   349         TEST(d1.get_double() > 6500000.1 && d1.get_double() < 6500000.2);

   350 

   351         av = d1.to_any();

   352 

   353         double doubleVal = av.extract_double();

   354         TEST(doubleVal > 6500000.1 && doubleVal < 6500000.2);

   355 

   356         any.insert_double(6500000.10001);

   357         d2 = factory.create_dyn_any(any);

   358         TEST(d1.equal(d2));

   359 

   360         copy = d1.copy();

   361         TEST(d1.equal(copy));

   362         TEST(copy.get_double() > 6500000.1 && copy.get_double() < 6500000.2);

   363 

   364         any.insert_double(501000.001);

   365         d2.from_any(any);

   366         d1.assign(d2);

   367         TEST(d1.equal(d2));

   368 

   369         d1.destroy();

   370         d2.destroy();

   371         copy.destroy();

   372 

   373         testOps(orb, factory, type, false);

   374 

   375         //

   376         // Test: boolean

   377         //

   378         type = orb.get_primitive_tc(TCKind.tk_boolean);

   379         d1 = factory.create_dyn_any_from_type_code(type);

   380         TEST(d1.get_boolean() == false);

   381         d1.insert_boolean(false);

   382         TEST(d1.get_boolean() == false);

   383         d1.insert_boolean(true);

   384         TEST(d1.get_boolean() == true);

   385 

   386         av = d1.to_any();

   387 

   388         boolean boolVal = av.extract_boolean();

   389         TEST(boolVal == true);

   390 

   391         any.insert_boolean(true);

   392         d2 = factory.create_dyn_any(any);

   393         TEST(d1.equal(d2));

   394 

   395         copy = d1.copy();

   396         TEST(d1.equal(copy));

   397         TEST(copy.get_boolean() == true);

   398 

   399         any.insert_boolean(false);

   400         d2.from_any(any);

   401         d1.assign(d2);

   402         TEST(d1.equal(d2));

   403 

   404         d1.destroy();

   405         d2.destroy();

   406         copy.destroy();

   407 

   408         testOps(orb, factory, type, false);

   409 

   410         //

   411         // Test: char

   412         //

   413         type = orb.get_primitive_tc(TCKind.tk_char);

   414         d1 = factory.create_dyn_any_from_type_code(type);

   415         TEST(d1.get_char() == 0);

   416         d1.insert_char('A');

   417         TEST(d1.get_char() == 'A');

   418         d1.insert_char('z');

   419         TEST(d1.get_char() == 'z');

   420 

   421         av = d1.to_any();

   422 

   423         char charVal = av.extract_char();

   424         TEST(charVal == 'z');

   425 

   426         any.insert_char('z');

   427         d2 = factory.create_dyn_any(any);

   428         TEST(d1.equal(d2));

   429 

   430         copy = d1.copy();

   431         TEST(d1.equal(copy));

   432         TEST(copy.get_char() == 'z');

   433 

   434         any.insert_char('@');

   435         d2.from_any(any);

   436         d1.assign(d2);

   437         TEST(d1.equal(d2));

   438 

   439         d1.destroy();

   440         d2.destroy();

   441         copy.destroy();

   442 

   443         testOps(orb, factory, type, false);

   444 

   445         //

   446         // Test: octet

   447         //

   448         type = orb.get_primitive_tc(TCKind.tk_octet);

   449         d1 = factory.create_dyn_any_from_type_code(type);

   450         TEST(d1.get_octet() == 0);

   451         d1.insert_octet((byte) 255);

   452         TEST(d1.get_octet() == (byte) 255);

   453         d1.insert_octet((byte) 1);

   454         TEST(d1.get_octet() == (byte) 1);

   455 

   456         av = d1.to_any();

   457 

   458         byte octetVal = av.extract_octet();

   459         TEST(octetVal == (byte) 1);

   460 

   461         any.insert_octet((byte) 1);

   462         d2 = factory.create_dyn_any(any);

   463         TEST(d1.equal(d2));

   464 

   465         copy = d1.copy();

   466         TEST(d1.equal(copy));

   467         TEST(copy.get_octet() == (byte) 1);

   468 

   469         any.insert_octet((byte) 127);

   470         d2.from_any(any);

   471         d1.assign(d2);

   472         TEST(d1.equal(d2));

   473 

   474         d1.destroy();

   475         d2.destroy();

   476         copy.destroy();

   477 

   478         testOps(orb, factory, type, false);

   479 

   480         //

   481         // Test: any

   482         //

   483         type = orb.get_primitive_tc(TCKind.tk_any);

   484         d1 = factory.create_dyn_any_from_type_code(type);

   485         any.insert_long(345678);

   486         d1.insert_any(any);

   487         av = d1.get_any();

   488         longVal = av.extract_long();

   489         TEST(longVal == 345678);

   490 

   491         any = orb.create_any();

   492 

   493         Any anyVal = orb.create_any();

   494         anyVal.insert_long(345678);

   495         any.insert_any(anyVal);

   496         d2 = factory.create_dyn_any(any);

   497         TEST(d1.equal(d2));

   498 

   499         av = d1.to_any();

   500 

   501         Any cap = av.extract_any();

   502         longVal = cap.extract_long();

   503         TEST(longVal == 345678);

   504 

   505         anyVal.insert_string("anyValue");

   506         any.insert_any(anyVal);

   507         d2.from_any(any);

   508         d1.assign(d2);

   509         TEST(d1.equal(d2));

   510 

   511         copy = d1.copy();

   512         TEST(d1.equal(copy));

   513 

   514         d1.destroy();

   515         d2.destroy();

   516         copy.destroy();

   517 

   518         testOps(orb, factory, type, false);

   519       }

   520     catch (org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCode ex)

   521       {

   522         TEST(false);

   523       }

   524     catch (org.omg.DynamicAny.DynAnyPackage.TypeMismatch ex)

   525       {

   526         ex.printStackTrace();

   527         TEST(false, ex.getMessage());

   528       }

   529     catch (org.omg.DynamicAny.DynAnyPackage.InvalidValue ex)

   530       {

   531         TEST(false);

   532       }

   533   }

   534 

   535   public void testEnum()

   536   {

   537     try

   538       {

   539         Any any = orb.create_any();

   540         Any av;

   541         DynAny d1 = null;

   542         DynAny d2 = null;

   543         DynAny copy = null;

   544         String str;

   545         DynEnum e1;

   546         DynEnum e2;

   547         TestEnum e;

   548         TypeCode type = TestEnumHelper.type();

   549 

   550         //

   551         // Test: initial value

   552         //

   553         d1 = factory.create_dyn_any_from_type_code(type);

   554         e1 = DynEnumHelper.narrow(d1);

   555         TEST(e1.get_as_ulong() == 0);

   556         str = e1.get_as_string();

   557         TEST(str.equals("red"));

   558 

   559         //

   560         // Test: set_as_string()

   561         //

   562         e1.set_as_string("green");

   563         TEST(e1.get_as_ulong() == 1);

   564         str = e1.get_as_string();

   565         TEST(str.equals("green"));

   566         e1.set_as_string("blue");

   567         TEST(e1.get_as_ulong() == 2);

   568         str = e1.get_as_string();

   569         TEST(str.equals("blue"));

   570 

   571         //

   572         // Test: set_as_ulong()

   573         //

   574         e1.set_as_ulong(1);

   575         TEST(e1.get_as_ulong() == 1);

   576         str = e1.get_as_string();

   577         TEST(str.equals("green"));

   578         e1.set_as_ulong(2);

   579         TEST(e1.get_as_ulong() == 2);

   580         str = e1.get_as_string();

   581         TEST(str.equals("blue"));

   582 

   583         //

   584         // Test: from_any()

   585         //

   586         TestEnumHelper.insert(any, TestEnum.green);

   587         e1.from_any(any);

   588 

   589         //

   590         // Test: to_any()

   591         //

   592         av = e1.to_any();

   593         e = TestEnumHelper.extract(av);

   594         TEST(e == TestEnum.green);

   595 

   596         //

   597         // Test: copy

   598         //

   599         copy = e1.copy();

   600         TEST(e1.equal(copy));

   601 

   602         e1.destroy();

   603         copy.destroy();

   604 

   605         //

   606         // Test: set_as_ulong() InvalidValue exception

   607         //

   608         try

   609           {

   610             d1 = factory.create_dyn_any_from_type_code(type);

   611             e1 = DynEnumHelper.narrow(d1);

   612             e1.set_as_ulong(3);

   613             TEST("set_as_ulong() should not have succeeded" == null);

   614           }

   615         catch (org.omg.DynamicAny.DynAnyPackage.InvalidValue ex)

   616           {

   617             // expected

   618             d1.destroy();

   619           }

   620         try

   621           {

   622             d1 = factory.create_dyn_any_from_type_code(type);

   623             e1 = DynEnumHelper.narrow(d1);

   624 

   625             //

   626             // In Java there is no *unsigned* int, so we need an

   627             // additional test case not required for C++.

   628             //

   629             e1.set_as_ulong(-1);

   630             TEST("set_as_ulong() should not have succeeded" == null);

   631           }

   632         catch (org.omg.DynamicAny.DynAnyPackage.InvalidValue ex)

   633           {

   634             // expected

   635             d1.destroy();

   636           }

   637 

   638         //

   639         // Test: set_as_string() InvalidValue exception

   640         //

   641         try

   642           {

   643             d1 = factory.create_dyn_any_from_type_code(type);

   644             e1 = DynEnumHelper.narrow(d1);

   645             e1.set_as_string("alizarin");

   646             TEST("set_as_string() should not have succeeded" == null);

   647           }

   648         catch (org.omg.DynamicAny.DynAnyPackage.InvalidValue ex)

   649           {

   650             // expected

   651             d1.destroy();

   652           }

   653 

   654         testOps(orb, factory, TestEnumHelper.type(), false);

   655       }

   656     catch (org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCode ex)

   657       {

   658         TEST(false);

   659       }

   660     catch (org.omg.DynamicAny.DynAnyPackage.TypeMismatch ex)

   661       {

   662         TEST(false);

   663       }

   664     catch (org.omg.DynamicAny.DynAnyPackage.InvalidValue ex)

   665       {

   666         TEST(false);

   667       }

   668   }

   669 

   670   public void testFixed()

   671   {

   672     try

   673       {

   674         Any any = orb.create_any();

   675         Any av;

   676         DynAny d1 = null;

   677         DynAny d2 = null;

   678         DynAny copy = null;

   679         TypeCode tc;

   680         String str;

   681         DynFixed f1;

   682         DynFixed f2;

   683         BigDecimal f;

   684 

   685         //

   686         // Create TypeCode

   687         //

   688         tc = orb.create_fixed_tc((short) 5, (short) 2);

   689 

   690         //

   691         // Test: get_value()

   692         //

   693         d1 = factory.create_dyn_any_from_type_code(tc);

   694         f1 = DynFixedHelper.narrow(d1);

   695         str = f1.get_value();

   696         f = new BigDecimal(str);

   697         TEST(Math.abs(f.floatValue() - 0.0) < Float.MIN_VALUE);

   698 

   699         //

   700         // Test: set_value()

   701         //

   702         TEST(f1.set_value("1.1"));

   703         TEST(f1.set_value("123.1"));

   704         TEST(f1.set_value("123.12"));

   705         TEST(!f1.set_value("123.123"));

   706 

   707         //

   708         // Test: from_any()

   709         //

   710         f = new BigDecimal("98");

   711         any.insert_fixed(f, tc);

   712         f1.from_any(any);

   713 

   714         //

   715         // Test: to_any()

   716         //

   717         av = f1.to_any();

   718         f = av.extract_fixed();

   719         TEST(f.equals(new BigDecimal("98")));

   720 

   721         //

   722         // Test: copy

   723         //

   724         copy = f1.copy();

   725         TEST(f1.equal(copy));

   726 

   727         f1.destroy();

   728         copy.destroy();

   729 

   730         //

   731         // Test: set_value() InvalidValue exception (part 1)

   732         //

   733         try

   734           {

   735             d1 = factory.create_dyn_any_from_type_code(tc);

   736             f1 = DynFixedHelper.narrow(d1);

   737             f1.set_value("");

   738             harness.fail("set_value() should not have succeeded");

   739           }

   740         catch (Exception ex)

   741           {

   742             // expected

   743             d1.destroy();

   744           }

   745 

   746         //

   747         // Test: assign() TypeMismatch exception

   748         //

   749         try

   750           {

   751             f = new BigDecimal("99");

   752             any.insert_fixed(f, orb.create_fixed_tc((short) 4, (short) 2));

   753             d1 = factory.create_dyn_any(any);

   754             d2 = factory.create_dyn_any_from_type_code(tc);

   755             d2.assign(d1);

   756             harness.fail("assign() should not have succeeded");

   757           }

   758         catch (org.omg.DynamicAny.DynAnyPackage.TypeMismatch ex)

   759           {

   760             // expected

   761             d1.destroy();

   762             d2.destroy();

   763           }

   764 

   765         //

   766         // Test: from_any() TypeMismatch exception

   767         //

   768         try

   769           {

   770             f = new BigDecimal("99");

   771             any.insert_fixed(f, orb.create_fixed_tc((short) 4, (short) 2));

   772             d1 = factory.create_dyn_any_from_type_code(tc);

   773             d1.from_any(any);

   774             harness.fail("from_any() should not have succeeded");

   775           }

   776         catch (org.omg.DynamicAny.DynAnyPackage.TypeMismatch ex)

   777           {

   778             // expected

   779             d1.destroy();

   780           }

   781 

   782         testOps(orb, factory, tc, false);

   783       }

   784     catch (Exception ex)

   785       {

   786         ex.printStackTrace();

   787         fail(ex);

   788       }

   789   }

   790 

   791   public void testStruct()

   792   {

   793     try

   794       {

   795         int i;

   796         Any any = orb.create_any();

   797         Any av;

   798         DynAny d1;

   799         DynAny d2;

   800         DynAny copy;

   801         String str;

   802         String wstr;

   803         DynStruct s1;

   804         DynStruct s2;

   805         String cp;

   806         TypeCode type;

   807         TypeCode tc;

   808         TestStruct ts = new TestStruct();

   809         TestStruct pts;

   810         NameValuePair[] nvpseq;

   811         NameDynAnyPair[] ndpseq;

   812 

   813         type = TestStructHelper.type();

   814         d1 = factory.create_dyn_any_from_type_code(type);

   815         s1 = DynStructHelper.narrow(d1);

   816 

   817         //

   818         // Test: current_member_name, current_member_kind

   819         //

   820         str = s1.current_member_name();

   821         TEST(str.equals("shortVal"));

   822         TEST(s1.current_member_kind() == TCKind.tk_short);

   823         s1.next();

   824         str = s1.current_member_name();

   825         TEST(str.equals("ushortVal"));

   826         TEST(s1.current_member_kind() == TCKind.tk_ushort);

   827         s1.next();

   828         str = s1.current_member_name();

   829         TEST(str.equals("longVal"));

   830         TEST(s1.current_member_kind() == TCKind.tk_long);

   831         s1.next();

   832         str = s1.current_member_name();

   833         TEST(str.equals("ulongVal"));

   834         TEST(s1.current_member_kind() == TCKind.tk_ulong);

   835         s1.next();

   836         str = s1.current_member_name();

   837         TEST(str.equals("floatVal"));

   838         TEST(s1.current_member_kind() == TCKind.tk_float);

   839         s1.next();

   840         str = s1.current_member_name();

   841         TEST(str.equals("doubleVal"));

   842         TEST(s1.current_member_kind() == TCKind.tk_double);

   843         s1.next();

   844         str = s1.current_member_name();

   845         TEST(str.equals("boolVal"));

   846         TEST(s1.current_member_kind() == TCKind.tk_boolean);

   847         s1.next();

   848         str = s1.current_member_name();

   849         TEST(str.equals("charVal"));

   850         TEST(s1.current_member_kind() == TCKind.tk_char);

   851         s1.next();

   852         str = s1.current_member_name();

   853         TEST(str.equals("octetVal"));

   854         TEST(s1.current_member_kind() == TCKind.tk_octet);

   855         s1.next();

   856         str = s1.current_member_name();

   857         TEST(str.equals("anyVal"));

   858         TEST(s1.current_member_kind() == TCKind.tk_any);

   859         s1.next();

   860         str = s1.current_member_name();

   861         TEST(str.equals("tcVal"));

   862         TEST(s1.current_member_kind() == TCKind.tk_TypeCode);

   863         s1.next();

   864         str = s1.current_member_name();

   865         TEST(str.equals("objectVal"));

   866         TEST(s1.current_member_kind() == TCKind.tk_objref);

   867         s1.next();

   868         str = s1.current_member_name();

   869         TEST(str.equals("stringVal"));

   870         TEST(s1.current_member_kind() == TCKind.tk_string);

   871         s1.next();

   872         str = s1.current_member_name();

   873         TEST(str.equals("longlongVal"));

   874         TEST(s1.current_member_kind() == TCKind.tk_longlong);

   875         s1.next();

   876         str = s1.current_member_name();

   877         TEST(str.equals("ulonglongVal"));

   878         TEST(s1.current_member_kind() == TCKind.tk_ulonglong);

   879         s1.next();

   880         str = s1.current_member_name();

   881         TEST(str.equals("wcharVal"));

   882         TEST(s1.current_member_kind() == TCKind.tk_wchar);

   883         s1.next();

   884         str = s1.current_member_name();

   885         TEST(str.equals("wstringVal"));

   886         TEST(s1.current_member_kind() == TCKind.tk_wstring);

   887 

   888         //

   889         // Test: insert values into members

   890         //

   891         s1.rewind();

   892         s1.insert_short(SHORT_VALUE);

   893         s1.next();

   894         s1.insert_ushort(USHORT_VALUE);

   895         s1.next();

   896         s1.insert_long(LONG_VALUE);

   897         s1.next();

   898         s1.insert_ulong(ULONG_VALUE);

   899         s1.next();

   900         s1.insert_float(FLOAT_VALUE);

   901         s1.next();

   902         s1.insert_double(DOUBLE_VALUE);

   903         s1.next();

   904         s1.insert_boolean(BOOLEAN_VALUE);

   905         s1.next();

   906         s1.insert_char(CHAR_VALUE);

   907         s1.next();

   908         s1.insert_octet(OCTET_VALUE);

   909         s1.next();

   910 

   911         DynAny d1c = d1.current_component();

   912 

   913         any.insert_string(ANY_VALUE);

   914         s1.insert_any(any);

   915         s1.next();

   916         s1.insert_typecode(TYPECODE_VALUE);

   917         s1.next();

   918         s1.insert_reference(null);

   919         s1.next();

   920         s1.insert_string(STRING_VALUE);

   921         s1.next();

   922         s1.insert_longlong(LONGLONG_VALUE);

   923         s1.next();

   924         s1.insert_ulonglong(ULONGLONG_VALUE);

   925         s1.next();

   926         s1.insert_wchar(WCHAR_VALUE);

   927         s1.next();

   928         s1.insert_wstring(WSTRING_VALUE);

   929         s1.next();

   930 

   931         //

   932         // Test: get values from members

   933         //

   934         s1.rewind();

   935         TEST(s1.get_short() == SHORT_VALUE);

   936         s1.next();

   937         TEST(s1.get_ushort() == USHORT_VALUE);

   938         s1.next();

   939         TEST(s1.get_long() == LONG_VALUE);

   940         s1.next();

   941         TEST(s1.get_ulong() == ULONG_VALUE);

   942         s1.next();

   943         TEST(s1.get_float() == FLOAT_VALUE);

   944         s1.next();

   945         TEST(s1.get_double() == DOUBLE_VALUE);

   946         s1.next();

   947         TEST(s1.get_boolean() == BOOLEAN_VALUE);

   948         s1.next();

   949         TEST(s1.get_char() == CHAR_VALUE);

   950         s1.next();

   951         TEST(s1.get_octet() == OCTET_VALUE);

   952         s1.next();

   953         av = s1.get_any();

   954 

   955         TEST(av.extract_string().equals(ANY_VALUE));

   956         s1.next();

   957         tc = s1.get_typecode();

   958         s1.next();

   959         TEST(tc.equal(TYPECODE_VALUE));

   960         TEST(s1.get_reference() == null);

   961         s1.next();

   962         str = s1.get_string();

   963         s1.next();

   964         TEST(str.equals(STRING_VALUE));

   965         TEST(s1.get_longlong() == LONGLONG_VALUE);

   966         s1.next();

   967         TEST(s1.get_ulonglong() == ULONGLONG_VALUE);

   968         s1.next();

   969         TEST(s1.get_wchar() == WCHAR_VALUE);

   970         s1.next();

   971         wstr = s1.get_wstring();

   972         s1.next();

   973         TEST(wstr.equals(WSTRING_VALUE));

   974 

   975         //

   976         // Test: get_members

   977         //

   978         nvpseq = s1.get_members();

   979         s1.rewind();

   980         for (i = 0; i < 11; i++)

   981           {

   982             str = s1.current_member_name();

   983             TEST(str.equals(nvpseq [ i ].id));

   984 

   985             DynAny dv = factory.create_dyn_any(nvpseq [ i ].value);

   986             DynAny comp = s1.current_component();

   987             TEST(dv.equal(comp));

   988             dv.destroy();

   989             s1.next();

   990           }

   991 

   992         //

   993         // Test: get_members_as_dyn_any

   994         //

   995         ndpseq = s1.get_members_as_dyn_any();

   996         s1.rewind();

   997         for (i = 0; i < 11; i++)

   998           {

   999             str = s1.current_member_name();

  1000             TEST(str.equals(ndpseq [ i ].id));

  1001             s1.next();

  1002           }

  1003       }

  1004     catch (Exception ex)

  1005       {

  1006         ex.printStackTrace();

  1007         fail(ex);

  1008       }

  1009   }

  1010 

  1011   protected void tearDown()

  1012   {

  1013     orb.destroy();

  1014   }

  1015 

  1016   void checkStruct(final TestStruct ts)

  1017   {

  1018     TEST(ts.shortVal == SHORT_VALUE);

  1019     TEST(ts.ushortVal == USHORT_VALUE);

  1020     TEST(ts.longVal == LONG_VALUE);

  1021     TEST(ts.ulongVal == ULONG_VALUE);

  1022     TEST(ts.floatVal == FLOAT_VALUE);

  1023     TEST(ts.doubleVal == DOUBLE_VALUE);

  1024     TEST(ts.boolVal == BOOLEAN_VALUE);

  1025     TEST(ts.charVal == CHAR_VALUE);

  1026     TEST(ts.octetVal == OCTET_VALUE);

  1027     TEST(ts.anyVal.extract_string().equals(ANY_VALUE));

  1028     TEST(ts.tcVal.equal(TYPECODE_VALUE));

  1029     TEST(ts.objectVal == null);

  1030     TEST(ts.stringVal.equals(STRING_VALUE));

  1031     TEST(ts.longlongVal == LONGLONG_VALUE);

  1032     TEST(ts.ulonglongVal == ULONGLONG_VALUE);

  1033     TEST(ts.wcharVal == WCHAR_VALUE);

  1034     TEST(ts.wstringVal.equals(WSTRING_VALUE));

  1035   }

  1036 

  1037   void loadStruct(ORB orb, TestStruct ts)

  1038   {

  1039     ts.shortVal = SHORT_VALUE;

  1040     ts.ushortVal = USHORT_VALUE;

  1041     ts.longVal = LONG_VALUE;

  1042     ts.ulongVal = ULONG_VALUE;

  1043     ts.floatVal = FLOAT_VALUE;

  1044     ts.doubleVal = DOUBLE_VALUE;

  1045     ts.boolVal = BOOLEAN_VALUE;

  1046     ts.charVal = CHAR_VALUE;

  1047     ts.octetVal = OCTET_VALUE;

  1048     ts.anyVal = orb.create_any();

  1049     ts.anyVal.insert_string(ANY_VALUE);

  1050     ts.tcVal = TYPECODE_VALUE;

  1051     ts.objectVal = null;

  1052     ts.stringVal = STRING_VALUE;

  1053     ts.longlongVal = LONGLONG_VALUE;

  1054     ts.ulonglongVal = ULONGLONG_VALUE;

  1055     ts.wcharVal = WCHAR_VALUE;

  1056     ts.wstringVal = WSTRING_VALUE;

  1057   }

  1058 

  1059   //

  1060   // Test generic operations

  1061   //

  1062   void testOps(ORB orb, DynAnyFactory factory, TypeCode tc,

  1063                boolean hasComponents

  1064               )

  1065   {

  1066     try

  1067       {

  1068         Any badAny = orb.create_any();

  1069         DynAny d1 = null;

  1070         DynAny d2 = null;

  1071         DynAny d3 = null;

  1072         DynAny copy = null;

  1073         TypeCode origTC = getOrigType(tc);

  1074 

  1075         //

  1076         // Create an any having a TypeCode that will not match tc

  1077         //

  1078         if (tc.kind() != TCKind.tk_short)

  1079           badAny.insert_short((short) 0);

  1080         else

  1081           badAny.insert_ushort((short) 0);

  1082 

  1083         //

  1084         // Test: type()

  1085         //

  1086         d1 = factory.create_dyn_any_from_type_code(tc);

  1087 

  1088         TypeCode tcv = d1.type();

  1089         TEST(tc.equal(tcv));

  1090         d1.destroy();

  1091 

  1092         //

  1093         // Test: assign() TypeMismatch exception

  1094         //

  1095         try

  1096           {

  1097             d1 = factory.create_dyn_any_from_type_code(tc);

  1098             d2 = factory.create_dyn_any(badAny);

  1099             d1.assign(d2);

  1100             TEST("assign() should not have succeeded" == null);

  1101           }

  1102         catch (org.omg.DynamicAny.DynAnyPackage.TypeMismatch ex)

  1103           {

  1104             // expected

  1105             d1.destroy();

  1106             d2.destroy();

  1107           }

  1108 

  1109         //

  1110         // Test: from_any() TypeMismatch exception

  1111         //

  1112         try

  1113           {

  1114             d1 = factory.create_dyn_any_from_type_code(tc);

  1115             d1.from_any(badAny);

  1116             TEST("from_any() should not have succeeded" == null);

  1117           }

  1118         catch (org.omg.DynamicAny.DynAnyPackage.TypeMismatch ex)

  1119           {

  1120             // expected

  1121             d1.destroy();

  1122           }

  1123 

  1124         //

  1125         // Test: from_any() InvalidValue exception

  1126         //

  1127         switch (origTC.kind().value())

  1128           {

  1129             case TCKind._tk_null :

  1130             case TCKind._tk_void :

  1131             case TCKind._tk_TypeCode :

  1132             case TCKind._tk_Principal :

  1133             case TCKind._tk_objref :

  1134             case TCKind._tk_value :