aaronp-zomg 1.0.2.20080827232412

data/test/assets/inherit/IDL1.idl

@@ -0,0 +1,18 @@
+// Description     : Tests includes
+// Comments        : Top level IDL that includes IDL2.idl
+//****************************************************************************
+
+#include <IDL2.idl>
+module M1
+{
+    interface I1
+    {
+        struct S1
+        {
+            short H1;
+            string R1;
+        };
+
+        M2::I2::S2 M1(in long L1, inout S1 s_obj1);
+    };
+};

data/test/assets/inherit/IDL2.idl

@@ -0,0 +1,18 @@
+// Description     : Tests includes
+// Comments        : 2nd most nested IDL in include hierarchy
+//****************************************************************************
+
+#include <IDL3.idl>
+module M2
+{
+    interface I2
+    {
+        struct S2
+        {
+            short H2;
+            string R2;
+        };
+
+        M3::I3::S3 M2(in long L2, out S2 s_obj2);
+    };
+};

data/test/assets/inherit/IDL3.idl

@@ -0,0 +1,18 @@
+// Description     : Tests includes
+// Comments        : 3rd most nested IDL in includes hierarchy
+//****************************************************************************
+
+#include <IDL4.idl>
+module M3
+{
+    interface I3
+    {
+        struct S3
+        {
+            short H3;
+            string R3;
+        };
+
+        M4::I4::S4 M3(in long L3, out S3 s_obj3);
+    };
+};

data/test/assets/inherit/IDL4.idl

@@ -0,0 +1,17 @@
+// Description     : Tests includes
+// Comments        : Most nested IDL in includes hierarchy
+//****************************************************************************
+
+module M4
+{
+    interface I4
+    {
+        struct S4
+        {
+            short H4;
+            string R4;
+        };
+
+        S4 M4(inout long L4, out S4 s_obj4);
+    };
+};

data/test/assets/inherit/diamond_inheritance.idl

@@ -0,0 +1,31 @@
+interface MainGrid {
+void getofMainGrid(in short n);
+long setofMainGrid(in short n);
+
+readonly attribute short length;  // length of the gridmain
+readonly attribute short breadth;   // breadth of the gridmain
+};
+
+
+interface BaseGrid : MainGrid {
+void getofBaseGrid(in short n);
+long setofBaseGrid(in short n);
+};
+
+
+interface GridBase : MainGrid {
+readonly attribute short base;
+};
+
+interface Grid : BaseGrid, GridBase {
+    readonly attribute short height;  // height of the grid
+    readonly attribute short width;   // width of the grid
+
+    // IDL operations
+
+    // set the element [n,m] of the grid, to value:
+    void set(in short n, in short m, in long value);
+
+    // return element [n,m] of the grid:
+    long get(in short n, in short m);
+};

data/test/assets/inherit/inherit.idl

@@ -0,0 +1,27 @@
+interface one {
+    void op_one();
+};
+
+interface two : one {
+    void op_two();
+};
+
+interface three : one {
+    void op_three();
+};
+
+interface four : two, three {
+    void op_four();
+};
+
+interface five : four, three, two {
+    void op_five();
+};
+
+interface factory_interface {
+    one get_one();
+    two get_two();
+    three get_three();
+    four get_four();
+    five get_five();
+};

data/test/assets/limit/longidentifiers.idl

@@ -0,0 +1,25 @@
+
+
+// Check all alphanumeric Characters
+
+typedef float abcdefghijklmnopqrstuvwxyz_12343567890;
+typedef long ABCDEFGHIJKLMNOPQRSTUVWXYZ;
+
+//Check long identifiers
+
+typedef short xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx1;
+typedef long xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx2;
+typedef double xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx3;
+typedef char xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx4;
+
+
+interface idlServer {
+
+    xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx4
+   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(
+    in     xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx4 p1,
+    out  xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx2 p2,
+    inout xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx3 p3
+  );
+};
+

data/test/assets/limit/namelens.idl

@@ -0,0 +1,26 @@
+interface onewaytest {
+    void n0 ();
+    void n01 ();
+    void n012 ();
+    void n0123 ();
+    void n01234 ();
+    void n012345 ();
+    void n0123456 ();
+    void n01234567 ();
+    void n012345678 ();
+    void n0123456789 ();
+    void n01234567890 ();
+    void n012345678901 ();
+    void n0123456789012 ();
+    void n01234567890123 ();
+    void n012345678901234 ();
+    void n0123456789012345 ();
+    void n01234567890123456 ();
+    void n012345678901234567 ();
+    void n0123456789012345678 ();
+    void n01234567890123456789 ();
+    void n012345678901234567890 ();
+};
+
+/* End of file. */
+

data/test/assets/limit/tpztest.idl

@@ -0,0 +1,21 @@
+interface tpztest {
+    typedef octet flypayload[8192];
+    typedef octet lightpayload[16384];
+    typedef octet welterpayload[32768];
+    typedef octet mediumpayload[65536];
+    typedef octet heavypayload[131072];
+    typedef octet superheavypayload[262144];
+
+    flypayload rqst_rspn1();
+    lightpayload rqst_rspn2();
+    welterpayload rqst_rspn3();
+    mediumpayload rqst_rspn4();
+    heavypayload rqst_rspn5();
+    superheavypayload rqst_rspn6();
+
+    oneway void bandwidth(in flypayload pld);
+    superheavypayload bandwidth_pingback(in mediumpayload pld);
+};
+
+/* End of file. */
+

data/test/assets/module/module1.idl

@@ -0,0 +1,29 @@
+/**
+ * Scope resolution
+ */
+module M {
+
+interface foo {
+
+  enum E {
+    A,
+    B,
+    C
+  };
+
+  void bar( in E e_obj );
+};
+
+};
+
+
+module M2
+{
+
+interface foo
+{
+  void bar( in M::foo::E e_obj );
+};
+
+};
+

data/test/assets/module/module2.idl

@@ -0,0 +1,34 @@
+/**
+ * Scope resolution with forward declarations
+ */
+module M1 {
+  typedef char A1;
+};
+
+module M2 {
+  typedef M1::A1 A2;
+};
+
+module M1 {
+  typedef M2::A2 A3;
+};
+
+// Here comes a nasty test with forward declarations
+
+module M3 {
+  interface A;
+};
+
+module M4 {
+  struct S {
+    M3::A a;
+  };
+//typedef M3::A X;
+};
+
+module M3 {
+  interface A {
+    attribute M4::S s;
+  };
+};
+

data/test/assets/module/module3.idl

@@ -0,0 +1,20 @@
+module mod1
+{
+    module mod2
+    {
+    interface ex1
+    {
+        attribute long  l1;
+        readonly attribute long l2;
+
+        long    m1(in long a);
+    };
+
+    interface ex2 : ex1
+    {
+        attribute long  l3;
+
+        long    m2(in long a, out long b);
+    };
+    };
+};

data/test/assets/module/module4.idl

@@ -0,0 +1,15 @@
+module mod1
+{
+    module mod2
+    {
+    struct a {
+     short b;
+    };
+    };
+};
+module mod3 {
+ struct a {
+  short b;
+ };
+};
+

data/test/assets/nested/nested1.idl

@@ -0,0 +1,5 @@
+interface I
+{
+    void connect(in I peer);
+    void f();
+};

data/test/assets/nested/nested2.idl

@@ -0,0 +1,11 @@
+typedef sequence<octet>     OctetSequence;
+typedef OctetSequence       ReferenceData;
+
+interface test
+{
+    attribute ReferenceData     id;
+    attribute OctetSequence     info;
+};
+
+/* End of file. */
+

data/test/assets/operations/Benchmark.idl

@@ -0,0 +1,331 @@
+//
+// User defined types
+//
+
+module UserTypes
+{
+
+enum discrim1 { e1, e2, e3 };
+enum discrim2 { e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15 };
+
+//
+// Unions
+//
+union u1
+switch (discrim1)
+{
+    case e1: short s;
+    case e2: long  l;
+    case e3: char  c;
+};
+
+union u2
+switch (discrim2)
+{
+    case e4: long long ll;
+    case e5: unsigned short us;
+    case e6: unsigned long ul;
+    case e7: unsigned long long ull;
+    case e8: double d;
+    case e10: wchar wc;
+    case e11: string s;
+    case e13: boolean b;
+    case e14: octet o;
+    case e15: any a;
+    default: float f;
+};
+
+struct s1
+{
+    short s;
+};
+
+struct s2
+{
+     short s;
+     long l;
+     long long ll;
+     unsigned short us;
+     unsigned long ul;
+     float f;
+     double d;
+     char c;
+     wchar wc;
+     string st;
+     wstring ws;
+     boolean b;
+     octet o;
+     any a;
+};
+
+
+//
+// User defined interface will test exchange of object references.
+//
+interface I
+{
+    void foo();
+    short bar (in short s);
+    double d ();
+};
+
+}; // End module UserTypes
+
+
+module Benchmark
+{
+
+
+//
+// CORBA IDL Basic Types
+//
+interface BasicTester
+{
+    void ping                   ();
+
+    void short_in_t                         (in short s);
+    void short_out_t                        (out short s);
+    void short_inout_t                      (inout short s);
+    short short_ret_t                       ();
+
+    void long_in_t                          (in long l);
+    void long_out_t                         (out long l);
+    void long_inout_t                       (inout long l);
+    long long_ret_t                         ();
+
+    void longlong_in_t                      (in long long ll);
+    void longlong_out_t                     (out long long ll);
+    void longlong_inout_t                   (inout long long ll);
+    long long longlong_ret_t                ();
+
+    void ushort_in_t                        (in unsigned short us);
+    void ushort_out_t                       (out unsigned short us);
+    void ushort_inout_t                     (inout unsigned short us);
+    unsigned short ushort_ret_t ();
+
+    void ulong_in_t                         (in unsigned long ul);
+    void ulong_out_t                        (out unsigned long ul);
+    void ulong_inout_t                      (inout unsigned long ul);
+    unsigned long ulong_ret_t               ();
+
+    void ulonglong_in_t                     (in unsigned long long ull);
+    void ulonglong_out_t                    (out unsigned long long ull);
+    void ulonglong_inout_t                  (inout unsigned long long ull);
+    unsigned long long ulonglong_ret_t      ();
+
+    void float_in_t                         (in float f);
+    void float_out_t                        (out float f);
+    void float_inout_t                      (inout float f);
+    float float_ret_t                       ();
+
+    void double_in_t                        (in double d);
+    void double_out_t                       (out double d);
+    void double_inout_t                     (inout double d);
+    double double_ret_t                     ();
+
+/*
+    void longdouble_in_t                    (in long double d);
+    void longdouble_out_t                   (out long double d);
+    void longdouble_inout_t                 (inout long double d);
+    long double longdouble_ret_t                 ();
+*/
+
+    void char_in_t                          (in char c);
+    void char_out_t                         (out char c);
+    void char_inout_t                       (inout char c);
+    char char_ret_t                         ();
+
+    void wchar_in_t                         (in wchar wc);
+    void wchar_out_t                        (out wchar wc);
+    void wchar_inout_t                      (inout wchar wc);
+    wchar wchar_ret_t                       ();
+
+    void string_in_t                        (in string s);
+    void string_out_t                       (out string s);
+    void string_inout_t                     (inout string s);
+    string string_ret_t                     ();
+
+    void wstring_in_t                        (in wstring s);
+    void wstring_out_t                       (out wstring s);
+    void wstring_inout_t                     (inout wstring s);
+    wstring wstring_ret_t                     ();
+
+    void boolean_in_t                       (in boolean b);
+    void boolean_out_t                      (out boolean b);
+    void boolean_inout_t                    (inout boolean b);
+    boolean boolean_ret_t                   ();
+
+    void octet_in_t                         (in octet o);
+    void octet_out_t                        (out octet o);
+    void octet_inout_t                      (inout octet o);
+    octet octet_ret_t                       ();
+
+    void any_in_t                           (in any a);
+    void any_out_t                          (out any a);
+    void any_inout_t                        (inout any a);
+    any any_ret_t                           ();
+};
+
+
+interface UserTypeTester
+{
+    void u1_in_t                            (in UserTypes::u1 u);
+    void u1_out_t                           (out UserTypes::u1 u);
+    void u1_inout_t                         (inout UserTypes::u1 u);
+    UserTypes::u1 u1_ret_t                  ();
+
+    void u2_in_t                            (in UserTypes::u2 u);
+    void u2_out_t                           (out UserTypes::u2 u);
+    void u2_inout_t                         (inout UserTypes::u2 u);
+    UserTypes::u2 u2_ret_t                  ();
+
+    void s1_in_t                            (in UserTypes::s1 s);
+    void s1_out_t                           (out UserTypes::s1 s);
+    void s1_inout_t                         (inout UserTypes::s1 s);
+    UserTypes::s1 s1_ret_t                  ();
+
+    void s2_in_t                            (in UserTypes::s2 s);
+    void s2_out_t                           (out UserTypes::s2 s);
+    void s2_inout_t                         (inout UserTypes::s2 s);
+    UserTypes::s2 s2_ret_t                  ();
+
+    void interface_in_t                     (in UserTypes::I interf);
+    void interface_out_t                    (out UserTypes::I interf);
+    void interface_inout_t                  (inout UserTypes::I interf);
+    UserTypes::I interface_ret_t            ();
+};
+
+
+interface SequenceTester
+{
+    //
+    // Note of course that bounded sequences can be of any length up to
+    // their bound. In the benchmark code bounded sequences will be
+    // populated to their maximum length.
+    //
+
+    //
+    // typedefs : standard types
+    //
+    typedef sequence<short>                         ShortSeq_UB;
+    typedef sequence<short, 4>                      ShortSeq_4;
+    typedef sequence<short, 65536>                  ShortSeq_64K;
+
+    typedef sequence<long>                          LongSeq_UB;
+    typedef sequence<long, 4>                       LongSeq_4;
+    typedef sequence<long, 65536>                   LongSeq_64K;
+
+    typedef sequence<long long>                     LongLongSeq_UB;
+    typedef sequence<long long, 4>                  LongLongSeq_4;
+    typedef sequence<long long, 65536>              LongLongSeq_64K;
+
+    typedef sequence<unsigned short>                UShortSeq_UB;
+    typedef sequence<unsigned short, 4>             UShortSeq_4;
+    typedef sequence<unsigned short, 65536>         UShortSeq_64K;
+
+    typedef sequence<unsigned long>                 ULongSeq_UB;
+    typedef sequence<unsigned long, 4>              ULongSeq_4;
+    typedef sequence<unsigned long, 65536>          ULongSeq_64K;
+
+    typedef sequence<unsigned long long>            ULongLongSeq_UB;
+    typedef sequence<unsigned long long, 4>         ULongLongSeq_4;
+    typedef sequence<unsigned long long, 65536>     ULongLongSeq_64K;
+
+    typedef sequence<float>                         FloatSeq_UB;
+    typedef sequence<float, 4>                      FloatSeq_4;
+    typedef sequence<float, 65536>                  FloatSeq_64K;
+
+    typedef sequence<double>                        DoubleSeq_UB;
+    typedef sequence<double, 4>                     DoubleSeq_4;
+    typedef sequence<double, 65536>                 DoubleSeq_64K;
+
+    typedef sequence<char>                          CharSeq_UB;
+    typedef sequence<char, 4>                       CharSeq_4;
+    typedef sequence<char, 65536>                   CharSeq_64K;
+
+    typedef sequence<wchar>                         WCharSeq_UB;
+    typedef sequence<wchar, 4>                      WCharSeq_4;
+    typedef sequence<wchar, 65536>                  WCharSeq_64K;
+
+    typedef sequence<string>                        StringSeq_UB;
+    typedef sequence<string, 4>                     StringSeq_4;
+    typedef sequence<string, 65536>                 StringSeq_64K;
+
+    typedef sequence<boolean>                       BooleanSeq_UB;
+    typedef sequence<boolean, 4>                    BooleanSeq_4;
+    typedef sequence<boolean, 65536>                BooleanSeq_64K;
+
+    typedef sequence<octet>                         OctetSeq_UB;
+    typedef sequence<octet, 4>                      OctetSeq_4;
+    typedef sequence<octet, 65536>                  OctetSeq_64K;
+    typedef sequence<octet, 1048576>                OctetSeq_1M;
+
+    typedef sequence<any>                           AnySeq_UB;
+    typedef sequence<any, 4>                        AnySeq_4;
+    typedef sequence<any, 65536>                    AnySeq_64K;
+
+    //
+    // typedefs: user-defined types (just unbounded for now, phew!)
+    //
+    typedef sequence<UserTypes::u1>                 U1Seq_UB;
+    typedef sequence<UserTypes::u2>                 U2Seq_UB;
+
+    typedef sequence<UserTypes::s1>                 S1Seq_UB;
+    typedef sequence<UserTypes::s2>                 S2Seq_UB;
+
+    typedef sequence<UserTypes::I>                  InterfaceSeq;
+
+    //
+    // Sequences of basic types
+    //
+    void ShortSeq_UB_in_t                           (in ShortSeq_UB s_seq);
+    void ShortSeq_UB_out_t                          (out ShortSeq_UB s_seq);
+    void ShortSeq_UB_inout_t                        (inout ShortSeq_UB s_seq);
+    ShortSeq_UB ShortSeq_UB_ret_t                   ();
+
+    void FloatSeq_64K_in_t                          (in FloatSeq_64K f_seq);
+    void FloatSeq_64K_out_t                         (out FloatSeq_64K f_seq);
+    void FloatSeq_64K_inout_t                       (inout FloatSeq_64K f_seq);
+    FloatSeq_64K FloatSeq_64K_ret_t                 ();
+
+    void StringSeq_UB_in_t                          (in StringSeq_UB s_seq);
+    void StringSeq_UB_out_t                         (out StringSeq_UB s_seq);
+    void StringSeq_UB_inout_t                       (inout StringSeq_UB s_seq);
+    StringSeq_UB StringSeq_UB_ret_t                 ();
+
+    void OctetSeq_1M_in_t                           (in OctetSeq_1M o_seq);
+    void OctetSeq_1M_out_t                          (out OctetSeq_1M o_seq);
+    void OctetSeq_1M_inout_t                        (inout OctetSeq_1M o_seq);
+    OctetSeq_1M OctetSeq_1M_ret_t                   ();
+
+    void AnySeq_UB_in_t                             (in AnySeq_UB a_seq);
+    void AnySeq_UB_out_t                            (out AnySeq_UB a_seq);
+    void AnySeq_UB_inout_t                          (inout AnySeq_UB a_seq);
+    AnySeq_UB AnySeq_UB_ret_t                       ();
+
+    //
+    // Sequences of user-defined types
+    //
+    void U2Seq_UB_in_t                              (in U2Seq_UB u2_seq);
+    void U2Seq_UB_out_t                             (out U2Seq_UB u2_seq);
+    void U2Seq_UB_inout_t                           (inout U2Seq_UB u2_seq);
+    U2Seq_UB U2Seq_UB_ret_t                         ();
+
+    void S2Seq_UB_in_t                              (in S2Seq_UB s2_seq);
+    void S2Seq_UB_out_t                             (out S2Seq_UB s2_seq);
+    void S2Seq_UB_inout_t                           (inout S2Seq_UB s2_seq);
+    S2Seq_UB S2Seq_UB_ret_t                         ();
+
+    //
+    // Sequence of interfaces (passing object references...)
+    //
+    void InterfaceSeq_in_t                          (in InterfaceSeq i_seq);
+    void InterfaceSeq_out_t                         (out InterfaceSeq i_seq);
+    void InterfaceSeq_inout_t                       (inout InterfaceSeq i_seq);
+    InterfaceSeq InterfaceSeq_ret_t                 ();
+
+};
+
+}; // End module Benchmark
+
+