zomg 1.0.0

data/test/assets/operations/atomic.idl

@@ -0,0 +1,40 @@
+module Atomic {
+    const short SS = 1;
+    const long LL = 1;
+    const unsigned short US = 1;
+    const unsigned long UL = 1;
+    const float FF = 1.1;
+    const double DD = 1.2;
+    const char CC = 'a';
+    const boolean BB = TRUE;
+
+    interface test {
+      short ShortOperation(in short a,
+              inout short b,
+              out short c);
+      long LongOperation(in long a,
+            inout long b,
+            out long c);
+      unsigned short UShortOperation(in unsigned short a,
+                   inout unsigned short b,
+                   out unsigned short c);
+      unsigned long ULongOperation(in unsigned long a,
+                  inout unsigned long b,
+                  out unsigned long c);
+      float FloatOperation(in float a,
+              inout float b,
+              out float c);
+      double DoubleOperation(in double a,
+              inout double b,
+              out double c);
+      boolean BooleanOperation(in boolean a,
+              inout boolean b,
+              out boolean c);
+      char CharOperation(in char a,
+            inout char b,
+            out char c);
+      octet OctetOperation(in octet a,
+              inout octet b,
+              out octet c);
+    };
+};

data/test/assets/operations/dif2.idl

@@ -0,0 +1,48 @@
+/* A test interface for DIF1 */
+
+interface ex1
+{
+    void op0();
+    float op1(in float f, out double d, inout long l);
+    double op2(in double d, out long l, inout short s);
+    long op3(in long l, out short s, inout unsigned long ul);
+    short op4(in short s, out unsigned long ul, inout unsigned short us);
+    unsigned long op5(inout unsigned long ul, in unsigned short us, out char c, in boolean b);
+    unsigned short op6(out unsigned short us, inout char c);
+};
+
+//interface ex3;
+
+interface ex2 : ex1
+{
+    // operations continued from ex1
+    char op7(in char c, out boolean b, inout octet o);
+    boolean op8(out boolean b, in octet o);
+    octet op9(inout octet o, out string s, in string <10> ls, inout long l);
+    string op10(in string s, out string <10> ls);
+    string <10> op11(inout string <10> ls, out long l);
+    long op12(in long l);
+//  ex3 op13(Environment *ev);
+};
+
+interface ex3 : ex1
+{
+    // attributes
+    readonly attribute float float_attribute;
+    attribute double double_attribute;
+    readonly attribute long long_attribute;
+    attribute short short_attribute;
+    readonly attribute unsigned long unsigned_long_attribute;
+
+};
+
+interface ex4 : ex2, ex3
+{
+    attribute unsigned short unsigned_short_attribute;
+    readonly attribute char char_attribute;
+    attribute boolean boolean_attribute;
+    readonly attribute octet octet_attribute;
+    attribute string string_attribute;
+    readonly attribute string <10> limited_string_attribute;
+//  readonly attribute ex4 an_object_attribute;
+};

data/test/assets/operations/interface1.idl

@@ -0,0 +1,16 @@
+typedef sequence <long, 10> long10;
+
+interface math {
+    short addshort(in short a, in short b);
+    short subshort(in short a, in short b);
+    short multshort(in short a, in short b);
+    long addlong(in long a, in long b);
+    long sublong(in long a, in long b);
+    long multlong(in long a, in long b);
+    long addlonglist(in long10 a);
+    long multlonglist(in long10 a);
+};
+
+interface a {
+    char op(in string <100> s);
+};

data/test/assets/operations/parameters.idl

@@ -0,0 +1,111 @@
+enum Enumeration {ONE, TWO};
+
+struct FStruct {
+    short a;
+};
+
+struct VStruct {
+    string a;
+};
+
+union FUnion switch (long) {
+    case 1: long x;
+    default: char z;
+};
+
+union VUnion switch (long) {
+    case 1: string a;
+    default: char z;
+};
+
+typedef long FArray[10];
+typedef string VArray[10];
+
+typedef sequence<long,10> BFSequence;
+typedef sequence<long>    UFSequence;
+
+typedef sequence<string,10> BVSequence;
+typedef sequence<string>    UVSequence;
+
+interface intf {
+  short ShortOperation(in short a,
+          inout short b,
+          out short c);
+  long LongOperation(in long a,
+        inout long b,
+        out long c);
+  long long LongLongOperation(in long long a,
+             inout long long b,
+             out long long c);
+  unsigned short UShortOperation(in unsigned short a,
+            inout unsigned short b,
+            out unsigned short c);
+  unsigned long ULongOperation(in unsigned long a,
+              inout unsigned long b,
+              out unsigned long c);
+  unsigned long long ULongLongOperation(in unsigned long long a,
+                   inout unsigned long long b,
+                   out unsigned long long c);
+  float FloatOperation(in float a,
+          inout float b,
+          out float c);
+  double DoubleOperation(in double a,
+        inout double b,
+        out double c);
+  boolean BooleanOperation(in boolean a,
+          inout boolean b,
+          out boolean c);
+  char CharOperation(in char a,
+        inout char b,
+        out char c);
+  octet OctetOperation(in octet a,
+          inout octet b,
+          out octet c);
+  Enumeration EnumOperation(in Enumeration a,
+               inout Enumeration b,
+               out Enumeration c);
+  intf ObjectRefOperation(in intf a,
+         inout intf b,
+         out intf c);
+  FStruct FixedStructOperation(in FStruct a,
+              inout FStruct b,
+              out FStruct c);
+  VStruct VarStructOperation(in VStruct a,
+            inout VStruct b,
+            out VStruct c);
+  FUnion FixedUnionOperation(in FUnion a,
+                inout FUnion b,
+                out FUnion c);
+  VUnion VarUnionOperation(in VUnion a,
+              inout VUnion b,
+              out VUnion c);
+  string StringOperation(in string a,
+        inout string b,
+        out string c);
+  string<20> BoundStringOperation(in string<20> a,
+             inout string<20> b,
+             out string<20> c);
+  BFSequence BoundedFixedSequenceOperation(in BFSequence a,
+                  inout BFSequence b,
+                  out BFSequence c);
+  BVSequence BoundedVarSequenceOperation(in BVSequence a,
+                inout BVSequence b,
+                out BVSequence c);
+  UFSequence FixedSequenceOperation(in UFSequence a,
+               inout UFSequence b,
+               out UFSequence c);
+  UVSequence VarSequenceOperation(in UVSequence a,
+             inout UVSequence b,
+             out UVSequence c);
+  FArray FixedArrayOperation(in FArray a,
+            inout FArray b,
+            out FArray c);
+  VArray VarArrayOperation(in VArray a,
+          inout VArray b,
+          out VArray c);
+};
+
+
+
+
+

data/test/assets/operations/perf.idl

@@ -0,0 +1,84 @@
+// Comments        : IDLs to do performance testing of oneway and req/reply
+//                   interfaces  These tests also include arguments of
+//                   various types
+//****************************************************************************
+
+#ifndef _perf_idl_
+#define _perf_idl_
+
+typedef sequence<short>     shortSeq;
+typedef sequence<long>      longSeq;
+typedef sequence<float>     floatSeq;
+typedef sequence<double>    doubleSeq;
+typedef sequence<string>    stringSeq;
+typedef sequence<char>      charSeq;
+
+struct PerfStruct {
+    short       shortVal;
+    long        longVal;
+    float       floatVal;
+    double      doubleVal;
+    char        charVal;
+    string      stringVal;
+};
+
+typedef sequence<PerfStruct>    structSeq;
+typedef PerfStruct      structArray[100];
+
+interface TestOneway
+{
+    oneway void test_no_param();
+
+    oneway void test_prim_args(in short shortVal, in long longVal,
+            in float floatVal, in double doubleVal,
+            in char charVal, in string stringVal);
+
+    oneway void test_struct(in PerfStruct structVal);
+
+    oneway void test_prim_seq(in shortSeq shortVal, in longSeq longVal,
+            in floatSeq floatVal, in doubleSeq doubleVal,
+            in charSeq charVal, in stringSeq stringVal);
+
+    oneway void test_struct_seq(in structSeq structVal);
+
+    oneway void test_struct_array(in structArray arrayVal);
+};
+
+interface TestReqReply
+{
+    long test_prim_args(in short shortVal, in long longVal,
+        in float floatVal, in double doubleVal,
+        in char charVal, in string stringVal,
+        inout short inoutShort, inout long inoutLong,
+        inout float inoutFloat, inout double inoutDouble,
+        inout char inoutChar, inout string inoutString,
+        out short outShort, out long outLong,
+        out float outFloat, out double outDouble,
+        out char outChar, out string outString);
+
+
+    long test_struct_args(in PerfStruct structVal,
+        inout PerfStruct inoutStruct,
+        out PerfStruct outStruct);
+
+    long test_prim_seq(in shortSeq shortVal, in longSeq longVal,
+        in floatSeq floatVal, in doubleSeq doubleVal,
+        in charSeq charVal, in stringSeq stringVal,
+        inout shortSeq inoutShort, inout longSeq inoutLong,
+        inout floatSeq inoutFloat, inout doubleSeq inoutDouble,
+        inout charSeq inoutChar, inout stringSeq inoutString,
+        out shortSeq outShort, out longSeq outLong,
+        out floatSeq outFloat, out doubleSeq outDouble,
+        out charSeq outChar, out stringSeq outString);
+
+    long test_struct_seq(in structSeq structVal,
+        inout structSeq inoutStruct,
+        out structSeq outStruct);
+
+    long test_struct_array(in structArray structVal,
+        inout structArray inoutStruct,
+        out structArray outStruct);
+};
+
+
+#endif

data/test/assets/operations/timer.idl

@@ -0,0 +1,104 @@
+// Description     : Orbix's Performance IDL
+//
+//
+//  The original form of this timer benchmark came from:
+//
+//  Prasad Mokkapati
+//  Post Modern Computing
+//  1897 Landing Drive
+//  Mountain View
+//  Ca - 94043
+//
+//  email: prasad@promoco.com
+//
+//
+// to whom all credit is ascribed.
+//
+//  This code is reproduced with permission from Post Modern Computing.
+//
+
+
+#ifndef _perf_idl_
+#define _perf_idl_
+
+// IDLs to do performance testing of oneway and req/reply interfaces
+// These tests also include arguments of various types
+
+
+
+typedef sequence<short>     shortSeq;
+typedef sequence<long>      longSeq;
+typedef sequence<float>     floatSeq;
+typedef sequence<double>    doubleSeq;
+typedef sequence<string>    stringSeq;
+typedef sequence<char>      charSeq;
+
+struct PerfStruct {
+    short       shortVal;
+    long        longVal;
+    float       floatVal;
+    double      doubleVal;
+    char        charVal;
+    string      stringVal;
+};
+
+typedef sequence<PerfStruct>    structSeq;
+typedef PerfStruct      structArray[100];
+
+interface TestOneway
+{
+    oneway void test_no_param();
+
+    oneway void test_prim_args(in short shortVal, in long longVal,
+            in float floatVal, in double doubleVal,
+            in char charVal, in string stringVal);
+
+    oneway void test_struct(in PerfStruct structVal);
+
+    oneway void test_prim_seq(in shortSeq shortVal, in longSeq longVal,
+            in floatSeq floatVal, in doubleSeq doubleVal,
+            in charSeq charVal, in stringSeq stringVal);
+
+    oneway void test_struct_seq(in structSeq structVal);
+
+    oneway void test_struct_array(in structArray arrayVal);
+};
+
+interface TestReqReply
+{
+    long test_prim_args(in short shortVal, in long longVal,
+        in float floatVal, in double doubleVal,
+        in char charVal, in string stringVal,
+        inout short inoutShort, inout long inoutLong,
+        inout float inoutFloat, inout double inoutDouble,
+        inout char inoutChar, inout string inoutString,
+        out short outShort, out long outLong,
+        out float outFloat, out double outDouble,
+        out char outChar, out string outString);
+
+
+    long test_struct_args(in PerfStruct structVal,
+        inout PerfStruct inoutStruct,
+        out PerfStruct outStruct);
+
+    long test_prim_seq(in shortSeq shortVal, in longSeq longVal,
+        in floatSeq floatVal, in doubleSeq doubleVal,
+        in charSeq charVal, in stringSeq stringVal,
+        inout shortSeq inoutShort, inout longSeq inoutLong,
+        inout floatSeq inoutFloat, inout doubleSeq inoutDouble,
+        inout charSeq inoutChar, inout stringSeq inoutString,
+        out shortSeq outShort, out longSeq outLong,
+        out floatSeq outFloat, out doubleSeq outDouble,
+        out charSeq outChar, out stringSeq outString);
+
+    long test_struct_seq(in structSeq structVal,
+        inout structSeq inoutStruct,
+        out structSeq outStruct);
+
+    long test_struct_array(in structArray structVal,
+        inout structArray inoutStruct,
+        out structArray outStruct);
+};
+
+
+#endif

data/test/assets/preprocess/base_for_diamond_inheritance_with_macros.idl

@@ -0,0 +1,17 @@
+
+struct mystruct
+{
+  short     x;
+  long      y;
+  string    z;
+};
+
+typedef mystruct struct_long_form;
+
+
+typedef struct mystruct1
+{
+  short     x;
+  long      y;
+  string    z;
+} struct_short_form;

data/test/assets/preprocess/basic_macro_marshalling.idl

@@ -0,0 +1,54 @@
+// TEST     basic marshaling tests for all IDL primitive types, modes
+//
+// This test omits constructed types (struct, union, enum, sequence, and
+// array types), and only tests very simple user defined exceptions.
+//
+// Values returned are well defined functions of the input values:
+//
+//  * For numeric types (octet, short, long, longlong, float, double,
+//    longdouble, and unsigned variants) the value is cubed.
+//  * For Boolean, it's the negation.
+//  * For Any, TypeCode, Principal, Object, char and wchar,
+//    string and wstring, it's the input value.
+//
+// The "return" and "out" parameter is the function of the "in" parameter;
+// the "inout" parameter is the function of its original value.
+//
+
+#define DECL_TEST(type) \
+    type test_ ## type ( in type a1, out type a2, inout type a3)
+
+#pragma prefix  "Eng.SUN.COM"   // only for Sun-defined interfaces
+
+interface test1 {
+    void    test_void ();
+
+    typedef unsigned short ushort;
+    typedef unsigned long ulong;
+
+    DECL_TEST (short);
+    DECL_TEST (long);
+    DECL_TEST (ushort);
+    DECL_TEST (ulong);
+    DECL_TEST (float);
+    DECL_TEST (double);
+    DECL_TEST (boolean);
+    DECL_TEST (char);
+    DECL_TEST (octet);
+    DECL_TEST (string);     // unbounded string
+    DECL_TEST (Object);
+    // All cases, "case_num" in the exception is the same as the 'in' param
+    //  * negative or zero, throws x1
+    //  * positive even cases, throws x2 with obj = null objref
+    //  * positive odd cases, throws x2 with obj = target objref
+    //
+    exception x1 { long case_num; };
+    exception x2 { Object obj; long value;};
+    void test_throw (in long case_num) raises (x1, x2);
+
+    //
+    // Aid for test cleanup in case server's not told to quit after
+    // being idle for some time period
+    //
+    oneway void please_exit ();
+};