zomg 1.0.0

data/test/assets/complex/complex3.idl

@@ -0,0 +1,181 @@
+// Description        : CORBA IDL containing attributes that causes the
+//                      adapter to perform both one & two-way invocations
+
+/**
+* Module that contains interfaces for complex tests. IDLs contained in
+* this module includes the following:
+* <UL>
+* <LI>Complex data types including structures, sequences, unions, etc.
+* <LI>Interface that contains attributes
+* </UL>
+*/
+module AttributesComplexTest
+{
+    /**
+    * Complex structure consisting of a string value and a
+    * sequence of floating point values
+    */
+    struct ComplexStructure
+    {
+        string string_value;
+        sequence<float> sequence_value;
+    };
+
+    /**
+    * A complex array consisting of 2 elements. Each element is a complex
+    * structure type
+    */
+    typedef ComplexStructure ComplexArray[2];
+
+    /**
+    * A complex unbounded sequence that holds any data types
+    */
+    typedef sequence<any> ComplexSequence;
+
+    /**
+    * An enumeration consisting of 5 elements, E1 to E5. The enumeration
+    * is used to test Union data types, based on a switch case of enum values
+    */
+    enum TestEnum { E1, E2, E3, E4, E5 };
+
+    /**
+    * An array consisting of 5 elements. Each element is a short
+    * data type. The array of 5 shorts is typedef-ed into the name
+    * "short"
+    */
+    typedef short short_array[5];
+
+    /**
+    * An array consisting of 5 elements. Each element is a double
+    * data type. The array of 5 doubled is typedef-ed into the name
+    * "double"
+    */
+    typedef double double_array[5];
+
+    /**
+    * An array consisting of 5 elements. Each element is a string
+    * data type. The array of 5 strings is typedef-ed into the name
+    * "string"
+    */
+    typedef string string_array[5];
+
+    /**
+    * A union that discriminates based on an enumeration, <CODE>TestEnum
+    * </CODE>. The discrimination rules are as follows:
+    * <UL>
+    * <LI>If discriminator is TestEnum::E1, return an array of short values
+    * <LI>If discriminator is TestEnum::E2, return an array of double values
+    * <LI>If discriminator is TestEnum::E3, return a long value
+    * <LI>If discriminator is TestEnum::E4, return a complex structure
+    * <LI>If discriminator is TestEnum::E5, return an array of string values
+    * </UL>
+    */
+    union ComplexUnion switch(TestEnum)
+    {
+    case E1:
+        short_array s;
+    case E2:
+        double_array d;
+    case E3:
+        long l;
+    case E4:
+        ComplexStructure cs;
+    default:
+        string_array str;
+    };
+
+    /**
+    * Attribute interface for complex data types. Clients and servers written
+    * using this interface can be used with all services.
+    */
+    interface comattrcor
+    {
+        /**
+        * Complex structure attribute that tests the adapter's core
+        * functionality.
+        * It is used in both CORBA to SDK and SDK to CORBA two-way scenarios.
+        * For CORBA to SDK, the CORBA client will be written with this attrib.
+        * For SDK to CORBA, the CORBA server will be written with this attrib.
+        * The attribute gets mapped to get_test_struct and set_test_struct in
+        * the adapter.
+        */
+        attribute ComplexStructure test_struct;
+
+        /**
+        * Complex array attribute that tests the adapter's core
+        * functionality.
+        * It is used in both CORBA to SDK and SDK to CORBA two-way scenarios.
+        * For CORBA to SDK, the CORBA client will be written with this attrib.
+        * For SDK to CORBA, the CORBA server will be written with this attrib.
+        * The attribute gets mapped to get_test_array and set_test_array in
+        * the adapter.
+        */
+        attribute ComplexArray test_array;
+
+        /**
+        * Complex sequence attribute that tests the adapter's core
+        * functionality.
+        * It is used in both CORBA to SDK and SDK to CORBA two-way scenarios.
+        * For CORBA to SDK, the CORBA client will be written with this attrib.
+        * For SDK to CORBA, the CORBA server will be written with this attrib.
+        * The attribute gets mapped to get_test_sequence and set_test_sequence
+        * in the adapter.
+        */
+        attribute ComplexSequence test_sequence;
+
+        /**
+        * Complex union attribute that tests the adapter's core
+        * functionality.
+        * It is used in both CORBA to SDK and SDK to CORBA two-way scenarios.
+        * For CORBA to SDK, the CORBA client will be written with this attrib.
+        * For SDK to CORBA, the CORBA server will be written with this attrib.
+        * The attribute gets mapped to get_test_union and set_test_union in
+        * the adapter.
+        */
+        attribute ComplexUnion test_union;
+
+        /**
+        * Complex enumeration attribute that tests the adapter's core
+        * functionality.
+        * It is used in both CORBA to SDK and SDK to CORBA two-way scenarios.
+        * For CORBA to SDK, the CORBA client will be written with this attrib.
+        * For SDK to CORBA, the CORBA server will be written with this attrib.
+        * The attribute gets mapped to get_test_enum and set_test_enum in
+        * the adapter.
+        */
+        attribute TestEnum test_enum;
+
+        /**
+        * Complex short attribute that tests the adapter's core
+        * functionality.
+        * It is used in both CORBA to SDK and SDK to CORBA two-way scenarios.
+        * For CORBA to SDK, the CORBA client will be written with this attrib.
+        * For SDK to CORBA, the CORBA server will be written with this attrib.
+        * The attribute gets mapped to get_test_short and set_test_short in
+       * the adapter.
+        */
+        attribute short test_short;
+
+        /**
+        * Complex double attribute that tests the adapter's core
+        * functionality.
+        * It is used in both CORBA to SDK and SDK to CORBA two-way scenarios.
+        * For CORBA to SDK, the CORBA client will be written with this attrib.
+        * For SDK to CORBA, the CORBA server will be written with this attrib.
+        * The attribute gets mapped to get_test_double and set_test_double in
+        * the adapter.
+        */
+        attribute double test_double;
+
+        /**
+        * Complex string attribute that tests the adapter's core
+        * functionality.
+        * It is used in both CORBA to SDK and SDK to CORBA two-way scenarios.
+        * For CORBA to SDK, the CORBA client will be written with this attrib.
+        * For SDK to CORBA, the CORBA server will be written with this attrib.
+        * The attribute gets mapped to get_test_string and set_test_string in
+        * the adapter.
+        */
+        attribute string test_string;
+    };
+};

data/test/assets/complex/complex4.idl

@@ -0,0 +1,181 @@
+// Description     : Data type tester
+
+typedef long longT;
+typedef short shortT;
+typedef unsigned long ulongT;
+typedef unsigned short ushortT;
+typedef octet octetT;
+typedef char charT;
+typedef float floatT;
+typedef double doubleT;
+typedef boolean boolT;
+typedef string stringT;
+
+interface demoInt1 {
+
+  void     void_op     ();
+
+  longT    long_op     (in longT i,   inout longT io,   out longT o);
+  ulongT   ulong_op    (in ulongT i,  inout ulongT io,  out ulongT o);
+  shortT   short_op    (in shortT i,  inout shortT io,  out shortT o);
+  ushortT  ushort_op   (in ushortT i, inout ushortT io, out ushortT o);
+  octetT   octet_op    (in octetT i,  inout octetT io,  out octetT o);
+  charT    char_op     (in charT i,   inout charT io,   out charT o);
+  floatT   float_op    (in floatT i,  inout floatT io,  out floatT o);
+  doubleT  double_op   (in doubleT i, inout doubleT io, out doubleT o);
+  boolT    boolean_op  (in boolT i,   inout boolT io,   out boolT o);
+  stringT  string_op   (in stringT i, inout stringT io, out stringT o);
+
+};
+
+//
+// demoInt2
+//
+
+struct pstruct {
+  long long_m;
+  unsigned long ulong_m;
+  short short_m;
+  unsigned short ushort_m;
+  octet octet_m;
+  char char_m;
+  float float_m;
+  double double_m;
+  boolean boolean_m;
+  string string_m;
+};
+
+typedef pstruct pstructT;
+
+typedef sequence<long> long_seq;
+typedef sequence<unsigned long> ulong_seq;
+typedef sequence<short> short_seq;
+typedef sequence<unsigned short> ushort_seq;
+typedef sequence<octet> octet_seq;
+typedef sequence<char> char_seq;
+typedef sequence<float> float_seq;
+typedef sequence<double> double_seq;
+typedef sequence<boolean> boolean_seq;
+typedef sequence<string> string_seq;
+
+typedef sequence<pstruct> pstruct_seq;
+
+interface demoInt2 {
+  pstruct pstruct_op(in pstruct i,
+             inout pstruct io,
+             out pstruct o);
+  long_seq long_seq_op(in long_seq i,
+               inout long_seq io,
+               out long_seq o);
+  ulong_seq ulong_seq_op(in ulong_seq i,
+             inout ulong_seq io,
+             out ulong_seq o);
+  short_seq short_seq_op(in short_seq i,
+             inout short_seq io,
+             out short_seq o);
+  ushort_seq ushort_seq_op(in ushort_seq i,
+               inout ushort_seq io,
+               out ushort_seq o);
+  octet_seq octet_seq_op(in octet_seq i,
+             inout octet_seq io,
+             out octet_seq o);
+  char_seq char_seq_op(in char_seq i,
+               inout char_seq io,
+               out char_seq o);
+  float_seq float_seq_op(in float_seq i,
+             inout float_seq io,
+             out float_seq o);
+  double_seq double_seq_op(in double_seq i,
+               inout double_seq io,
+               out double_seq o);
+  boolean_seq boolean_seq_op(in boolean_seq i,
+                 inout boolean_seq io,
+                 out boolean_seq o);
+  string_seq string_seq_op(in string_seq i,
+               inout string_seq io,
+               out string_seq o);
+  pstruct_seq pstruct_seq_op(in pstruct_seq i,
+               inout pstruct_seq io,
+               out pstruct_seq o);
+};
+
+//
+// demoInt3
+//
+
+const longT long_c = 1;
+const shortT short_c = 2;
+const ulongT ulong_c = 3;
+const ushortT ushort_c = 4;
+const charT char_c = 'X';
+const floatT float_c = 7.0;
+const doubleT double_c = 8.0;
+const boolT bool_c = TRUE;
+
+enum penum {
+  zero, one, two, three, four, five
+};
+
+union punion switch (penum) {
+ case zero:
+  longT long_m;
+ case one:
+  doubleT double_m;
+ case two:
+  stringT string_m;
+ case three:
+  pstruct pstruct_m;
+ case four:
+  penum enum_m;
+ default:
+  string_seq seq_m;
+};
+
+typedef longT long_arr[10];
+typedef doubleT double_arr[10];
+typedef stringT string_arr[10];
+typedef pstruct pstruct_arr[10];
+
+struct long_arr_struct {
+  long_arr val;
+};
+
+struct double_arr_struct {
+  double_arr val;
+};
+
+struct string_arr_struct {
+  string_arr val;
+};
+
+struct pstruct_arr_struct {
+  pstruct_arr val;
+};
+
+interface demoInt3 {
+  const longT long_c = 1;
+  const shortT short_c = 2;
+  const ulongT ulong_c = 3;
+  const ushortT ushort_c = 4;
+  const charT char_c = 'X';
+  const floatT float_c = 7.0;
+  const doubleT double_c = 8.0;
+  const boolT bool_c = TRUE;
+
+  penum penum_op(in penum i, inout penum io, out penum o);
+  punion punion_op(in punion i, inout punion io, out punion o);
+
+  long_arr long_arr_op(in long_arr i,
+               inout long_arr io,
+               out long_arr o);
+  double_arr double_arr_op(in double_arr i,
+               inout double_arr io,
+               out double_arr o);
+  string_arr string_arr_op(in string_arr i,
+               inout string_arr io,
+               out string_arr o);
+  pstruct_arr pstruct_arr_op(in pstruct_arr i,
+                 inout pstruct_arr io,
+                 out pstruct_arr o);
+};
+

data/test/assets/complex/interop_wchar.idl

@@ -0,0 +1,60 @@
+// Tests for interoperability between ORBs for sending wchar data
+// The CDR defines separate serialization functions for reading and writing
+// wchar, wchar[] and wstring data. Encapsulated wchar data is also tested.
+
+module interop {
+  typedef wchar warray[10];
+
+  struct wstruct {
+    wchar st_char;
+    wstring st_string;
+    warray st_array;
+    any st_any;
+  };
+
+  enum wchar_types {is_wchar, is_wstring, is_warray};
+
+  union wunion switch (wchar_types) {
+  case is_wchar: wchar u_char;
+  case is_wstring: wstring u_string;
+  case is_warray: warray u_array;
+  };
+
+  interface WChar_Passer {
+    // The server and client for this test should both use a well known test
+    // data to allow individual string comparisons against reference strings.
+    // The separate test key value allows the tester to devise several strings,
+    // arrays, or wchar values that may be tested separately.
+
+    readonly attribute string orb_name;
+
+    boolean wchar_to_server (in wchar test, in short key);
+    wchar wchar_from_server (in short key);
+
+    boolean wstring_to_server (in wstring test, in short key);
+    wstring wstring_from_server (in short key);
+
+    boolean warray_to_server (in warray test, in short key);
+    warray warray_from_server (in short key);
+
+    boolean wstruct_to_server (in wstruct test, in short key);
+    wstruct wstruct_from_server (in short key);
+
+    boolean wunion_to_server (in wunion test, in short key);
+    wunion wunion_from_server (in short key, in wchar_types type);
+
+    boolean any_to_server (in any test, in short key);
+    any any_from_server (in short key, in wchar_types type);
+
+    any any_echo (in any test);
+
+    exception WStringException { wstring why; wchar whynot;};
+    void exception_test(in short key) raises (WStringException);
+
+    /// A method to shutdown the ORB
+    /**
+     * This method is used to simplify the test shutdown process
+     */
+    oneway void shutdown ();
+  };
+};

data/test/assets/constant/constant1.idl

@@ -0,0 +1,37 @@
+const unsigned long hex16 = 0x10;
+const unsigned long oct8 = 010;
+const unsigned long dec10 = 10;
+
+const short l = 4;
+
+enum N { zero, un , deux, trois };
+
+exception E {
+    short cause ;
+};
+
+exception F {
+    long type ;
+};
+
+module M {
+    const short l = 4;
+
+    enum N { zero, un , deux, trois };
+
+    exception E {
+        short cause ;
+        };
+
+    interface A {
+            const short l = 4;
+
+            enum N { zero, un , deux, trois };
+
+        exception E {
+            short cause ;
+            };
+        N foo(in N x, out N y, inout N z) raises (E, F) ;
+    };
+};
+