← Back to branch summary

~ubuntu-branches/ubuntu/trusty/erlang/trusty

« back to all changes in this revision

Viewing changes to lib/ic/test/c_client_erl_server_proto_SUITE_data/c_erl_test.idl

  • Committer: Bazaar Package Importer
  • Author(s): Clint Byrum
  • Date: 2011-05-05 15:48:43 UTC
  • mfrom: (3.5.13 sid)
  • Revision ID: james.westby@ubuntu.com-20110505154843-0om6ekzg6m7ugj27
Tags: 1:14.b.2-dfsg-3ubuntu1
* Merge from debian unstable.  Remaining changes:
  - Drop libwxgtk2.8-dev build dependency. Wx isn't in main, and not
    supposed to.
  - Drop erlang-wx binary.
  - Drop erlang-wx dependency from -megaco, -common-test, and -reltool, they
    do not really need wx. Also drop it from -debugger; the GUI needs wx,
    but it apparently has CLI bits as well, and is also needed by -megaco,
    so let's keep the package for now.
  - debian/patches/series: Do what I meant, and enable build-options.patch
    instead.
* Additional changes:
  - Drop erlang-wx from -et
* Dropped Changes:
  - patches/pcre-crash.patch: CVE-2008-2371: outer level option with
    alternatives caused crash. (Applied Upstream)
  - fix for ssl certificate verification in newSSL: 
    ssl_cacertfile_fix.patch (Applied Upstream)
  - debian/patches/series: Enable native.patch again, to get stripped beam
    files and reduce the package size again. (build-options is what
    actually accomplished this)
  - Remove build-options.patch on advice from upstream and because it caused
    odd build failures.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/ic/test/c_client_erl_server_proto_SUITE_data/c_erl_test.idl
 
1
 
 
2
// %CopyrightBegin%
 
3
// 
 
4
// Copyright Ericsson AB 2003-2010. All Rights Reserved.
 
5
// 
 
6
// The contents of this file are subject to the Erlang Public License,
 
7
// Version 1.1, (the "License"); you may not use this file except in
 
8
// compliance with the License. You should have received a copy of the
 
9
// Erlang Public License along with this software. If not, it can be
 
10
// retrieved online at http://www.erlang.org/.
 
11
// 
 
12
// Software distributed under the License is distributed on an "AS IS"
 
13
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 
14
// the License for the specific language governing rights and limitations
 
15
// under the License.
 
16
// 
 
17
// %CopyrightEnd%
 
18
 
 
19
#include "erlang.idl"
 
20
 
 
21
 
 
22
const short TestConst = 1;
 
23
 
 
24
module m {
 
25
 
 
26
  const short TestConst = 2;
 
27
 
 
28
  struct b {
 
29
    long l;
 
30
    char c;
 
31
  }; 
 
32
 
 
33
  struct simple {
 
34
    long l;
 
35
    b    b_t;
 
36
  };
 
37
 
 
38
  enum fruit {orange, banana, apple, peach, pear};
 
39
 
 
40
  typedef sequence<long> lseq;
 
41
 
 
42
  typedef sequence<b> bseq;
 
43
 
 
44
  struct a {
 
45
    long l;
 
46
    bseq y;
 
47
    double d;
 
48
  };
 
49
 
 
50
  typedef sequence<a> aseq;
 
51
 
 
52
  typedef sequence<string> sseq;
 
53
  typedef string str;
 
54
  typedef long myLong;
 
55
 
 
56
  typedef long arr1[500], dd[2][3];
 
57
 
 
58
  typedef erlang::term apa;
 
59
  typedef erlang::port banan;
 
60
 
 
61
  typedef sequence<erlang::term> etseq;
 
62
 
 
63
  struct s {
 
64
    long l;
 
65
    sequence<long> sl;
 
66
  };
 
67
 
 
68
  struct es {
 
69
    fruit f;
 
70
    myLong l;
 
71
  };
 
72
 
 
73
  struct et {
 
74
    erlang::term e;
 
75
    long l;
 
76
  };
 
77
 
 
78
 
 
79
  typedef sequence<char> str1;
 
80
  typedef string<12> str2;
 
81
  typedef char str3[3];         
 
82
 
 
83
  typedef sequence<string> sstr3;  // sequence of string
 
84
  typedef sequence<sstr3> ssstr3;  // sequence of sequences of strings
 
85
 
 
86
  typedef long  arr3[3];           // array of long
 
87
  typedef sequence<arr3> sarr3;    // sequence of array
 
88
  typedef sequence<sarr3> ssarr3;  // sequence of sequnces of arrays of strings
 
89
    
 
90
 struct strRec{
 
91
    boolean bb;
 
92
    string str4;
 
93
    long str7[3][2];
 
94
    sequence<char> str5; 
 
95
    string<12> str6;
 
96
    str3 str8;
 
97
    str2 str9;
 
98
    str1 str10;         
 
99
  };
 
100
 
 
101
 
 
102
  struct dyn {
 
103
    long l;
 
104
    sequence<long> sl;
 
105
  };
 
106
  typedef dyn arr2[1][2];
 
107
 
 
108
 
 
109
  interface i {
 
110
 
 
111
    const short TestConst = 3;  
 
112
 
 
113
    //arr2 suck(in arr2 x, out arr2 y );
 
114
 
 
115
    ///////////////////////////////// attribute long l;
 
116
 
 
117
    // simple types
 
118
    void void_test();
 
119
    long long_test(in long a, out long a1);
 
120
    long long longlong_test(in long long a, out long long a1);  
 
121
    unsigned short ushort_test(in unsigned short a, out unsigned short a1);
 
122
    unsigned long ulong_test(in unsigned long a, out unsigned long a1);
 
123
    unsigned long long ulonglong_test(in unsigned long long a, out unsigned long long a1);
 
124
    double double_test(in double a, out double a1);
 
125
    char char_test(in char a, out char a1);
 
126
    wchar wchar_test(in wchar a, out wchar a1);
 
127
    octet octet_test(in octet a, out octet a1);
 
128
    boolean bool_test(in boolean a, out boolean a1);
 
129
 
 
130
    // Seq. and struct tests
 
131
    b struct_test(in b a, out b a1);
 
132
    es struct2_test(in es a, out es a1);
 
133
    //simple struct3_test(in simple x, out simple y);   
 
134
    bseq seq1_test(in bseq a, out bseq a1);
 
135
    aseq seq2_test(in aseq a, out aseq a1);
 
136
    lseq seq3_test(in lseq a, out lseq a1);
 
137
    ssstr3 seq4_test(in ssstr3 a, out ssstr3 a1);
 
138
    ssarr3 seq5_test(in ssarr3 a, out ssarr3 a1);
 
139
 
 
140
    // Array tests
 
141
    arr1 array1_test(in arr1 a, out arr1 a1);
 
142
    dd array2_test(in dd a, out dd a1);
 
143
 
 
144
    // enum test
 
145
    fruit enum_test(in fruit a, out fruit a1);
 
146
 
 
147
    // string tests
 
148
    string string1_test(in string a, out string a1);
 
149
    wstring wstring1_test(in wstring a, out wstring a1);
 
150
    sseq string2_test(in sseq a, out sseq a1);
 
151
    str string3_test(in str a, out str a1);
 
152
    strRec string4_test(in strRec a, out strRec a1);
 
153
 
 
154
    // Special erlang types
 
155
    erlang::pid pid_test(in erlang::pid a, out erlang::pid a1);
 
156
    erlang::port port_test(in erlang::port a, out erlang::port a1);
 
157
    erlang::ref ref_test(in erlang::ref a, out erlang::ref a1);
 
158
    erlang::term term_test(in erlang::term a, out erlang::term a1);
 
159
    
 
160
    // typedef test
 
161
    long typedef_test(in apa a, in banan b, out apa a1, out banan b1);
 
162
 
 
163
    // inlined seq. test
 
164
    s inline_sequence_test(in s a, out s a1);
 
165
 
 
166
    // term seq. test
 
167
    etseq term_sequence_test(in etseq a, out etseq a1);
 
168
    // term struct test
 
169
    et term_struct_test(in et a, out et a1);
 
170
   
 
171
  };
 
172
 
 
173
};