1/*
2 * Licensed to the Apache Software Foundation (ASF) under one
3 * or more contributor license agreements. See the NOTICE file
4 * distributed with this work for additional information
5 * regarding copyright ownership. The ASF licenses this file
6 * to you under the Apache License, Version 2.0 (the
7 * "License"); you may not use this file except in compliance
8 * with the License. You may obtain a copy of the License at
9 *
10 *   http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing,
13 * software distributed under the License is distributed on an
14 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 * KIND, either express or implied. See the License for the
16 * specific language governing permissions and limitations
17 * under the License.
18 *
19 * Contains some contributions under the Thrift Software License.
20 * Please see doc/old-thrift-license.txt in the Thrift distribution for
21 * details.
22 */
23
24namespace c_glib TTest
25namespace cpp thrift.test
26namespace delphi Thrift.Test
27namespace go thrifttest
28namespace java thrift.test
29namespace js ThriftTest
30namespace lua ThriftTest
31namespace netstd ThriftTest
32namespace perl ThriftTest
33namespace php ThriftTest
34namespace py ThriftTest
35namespace py.twisted ThriftTest
36namespace rb Thrift.Test
37namespace st ThriftTest
38namespace xsd test (uri = 'http://thrift.apache.org/ns/ThriftTest')
39
40// Presence of namespaces and sub-namespaces for which there is
41// no generator should compile with warnings only
42namespace noexist ThriftTest
43namespace cpp.noexist ThriftTest
44
45namespace * thrift.test
46
47/**
48 * Docstring!
49 */
50enum Numberz
51{
52  ONE = 1,
53  TWO,
54  THREE,
55  FIVE = 5,
56  SIX,
57  EIGHT = 8
58}
59
60const Numberz myNumberz = Numberz.ONE;
61// the following is expected to fail:
62// const Numberz urNumberz = ONE;
63
64typedef i64 UserId
65
66struct Bonk
67{
68  1: string message,
69  2: i32 type
70}
71
72typedef map<string,Bonk> MapType
73
74struct Bools {
75  1: bool im_true,
76  2: bool im_false,
77}
78
79struct Xtruct
80{
81  1:  string string_thing,
82  4:  i8     byte_thing,
83  9:  i32    i32_thing,
84  11: i64    i64_thing
85}
86
87struct Xtruct2
88{
89  1: i8     byte_thing,  // used to be byte, hence the name
90  2: Xtruct struct_thing,
91  3: i32    i32_thing
92}
93
94struct Xtruct3
95{
96  1:  string string_thing,
97  4:  i32    changed,
98  9:  i32    i32_thing,
99  11: i64    i64_thing
100}
101
102
103struct Insanity
104{
105  1: map<Numberz, UserId> userMap,
106  2: list<Xtruct> xtructs
107} (python.immutable= "")
108
109struct CrazyNesting {
110  1: string string_field,
111  2: optional set<Insanity> set_field,
112  // Do not insert line break as test/go/Makefile.am is removing this line with pattern match
113  3: required list<map<set<i32> (python.immutable = ""), map<i32,set<list<map<Insanity,string>(python.immutable = "")> (python.immutable = "")>>>> list_field,
114  4: binary binary_field
115  5: uuid uuid_field
116}
117
118union SomeUnion {
119  1: map<Numberz, UserId> map_thing,
120  2: string string_thing,
121  3: i32 i32_thing,
122  4: Xtruct3 xtruct_thing,
123  5: Insanity insanity_thing
124}
125
126exception Xception {
127  1: i32 errorCode,
128  2: string message
129}
130
131exception Xception2 {
132  1: i32 errorCode,
133  2: Xtruct struct_thing
134}
135
136struct EmptyStruct {}
137
138struct OneField {
139  1: EmptyStruct field
140}
141
142service ThriftTest
143{
144  /**
145   * Prints "testVoid()" and returns nothing.
146   */
147  void         testVoid(),
148
149  /**
150   * Prints 'testString("%s")' with thing as '%s'
151   * @param string thing - the string to print
152   * @return string - returns the string 'thing'
153   */
154  string       testString(1: string thing),
155
156  /**
157   * Prints 'testBool("%s")' where '%s' with thing as 'true' or 'false'
158   * @param bool  thing - the bool data to print
159   * @return bool  - returns the bool 'thing'
160   */
161  bool         testBool(1: bool thing),
162
163  /**
164   * Prints 'testByte("%d")' with thing as '%d'
165   * The types i8 and byte are synonyms, use of i8 is encouraged, byte still exists for the sake of compatibility.
166   * @param byte thing - the i8/byte to print
167   * @return i8 - returns the i8/byte 'thing'
168   */
169  i8           testByte(1: i8 thing),
170
171  /**
172   * Prints 'testI32("%d")' with thing as '%d'
173   * @param i32 thing - the i32 to print
174   * @return i32 - returns the i32 'thing'
175   */
176  i32          testI32(1: i32 thing),
177
178  /**
179   * Prints 'testI64("%d")' with thing as '%d'
180   * @param i64 thing - the i64 to print
181   * @return i64 - returns the i64 'thing'
182   */
183  i64          testI64(1: i64 thing),
184
185  /**
186   * Prints 'testDouble("%f")' with thing as '%f'
187   * @param double thing - the double to print
188   * @return double - returns the double 'thing'
189   */
190  double       testDouble(1: double thing),
191
192  /**
193   * Prints 'testBinary("%s")' where '%s' is a hex-formatted string of thing's data
194   * @param binary  thing - the binary data to print
195   * @return binary  - returns the binary 'thing'
196   */
197  binary       testBinary(1: binary thing),
198
199  /**
200   * Prints 'testUuid("%s")' where '%s' is the uuid given. Note that the uuid byte order should be correct.
201   * @param uuid  thing - the uuid to print
202   * @return uuid  - returns the uuid 'thing'
203   */
204  uuid       testUuid(1: uuid thing),
205
206  /**
207   * Prints 'testStruct("{%s}")' where thing has been formatted into a string of comma separated values
208   * @param Xtruct thing - the Xtruct to print
209   * @return Xtruct - returns the Xtruct 'thing'
210   */
211  Xtruct       testStruct(1: Xtruct thing),
212
213  /**
214   * Prints 'testNest("{%s}")' where thing has been formatted into a string of the nested struct
215   * @param Xtruct2 thing - the Xtruct2 to print
216   * @return Xtruct2 - returns the Xtruct2 'thing'
217   */
218  Xtruct2      testNest(1: Xtruct2 thing),
219
220  /**
221   * Prints 'testMap("{%s")' where thing has been formatted into a string of 'key => value' pairs
222   *  separated by commas and new lines
223   * @param map<i32,i32> thing - the map<i32,i32> to print
224   * @return map<i32,i32> - returns the map<i32,i32> 'thing'
225   */
226  map<i32,i32> testMap(1: map<i32,i32> thing),
227
228  /**
229   * Prints 'testStringMap("{%s}")' where thing has been formatted into a string of 'key => value' pairs
230   *  separated by commas and new lines
231   * @param map<string,string> thing - the map<string,string> to print
232   * @return map<string,string> - returns the map<string,string> 'thing'
233   */
234  map<string,string> testStringMap(1: map<string,string> thing),
235
236  /**
237   * Prints 'testSet("{%s}")' where thing has been formatted into a string of values
238   *  separated by commas and new lines
239   * @param set<i32> thing - the set<i32> to print
240   * @return set<i32> - returns the set<i32> 'thing'
241   */
242  set<i32>     testSet(1: set<i32> thing),
243
244  /**
245   * Prints 'testList("{%s}")' where thing has been formatted into a string of values
246   *  separated by commas and new lines
247   * @param list<i32> thing - the list<i32> to print
248   * @return list<i32> - returns the list<i32> 'thing'
249   */
250  list<i32>    testList(1: list<i32> thing),
251
252  /**
253   * Prints 'testEnum("%d")' where thing has been formatted into its numeric value
254   * @param Numberz thing - the Numberz to print
255   * @return Numberz - returns the Numberz 'thing'
256   */
257  Numberz      testEnum(1: Numberz thing),
258
259  /**
260   * Prints 'testTypedef("%d")' with thing as '%d'
261   * @param UserId thing - the UserId to print
262   * @return UserId - returns the UserId 'thing'
263   */
264  UserId       testTypedef(1: UserId thing),
265
266  /**
267   * Prints 'testMapMap("%d")' with hello as '%d'
268   * @param i32 hello - the i32 to print
269   * @return map<i32,map<i32,i32>> - returns a dictionary with these values:
270   *   {-4 => {-4 => -4, -3 => -3, -2 => -2, -1 => -1, }, 4 => {1 => 1, 2 => 2, 3 => 3, 4 => 4, }, }
271   */
272  map<i32,map<i32,i32>> testMapMap(1: i32 hello),
273
274  /**
275   * So you think you've got this all worked out, eh?
276   *
277   * Creates a map with these values and prints it out:
278   *   { 1 => { 2 => argument,
279   *            3 => argument,
280   *          },
281   *     2 => { 6 => <empty Insanity struct>, },
282   *   }
283   * @return map<UserId, map<Numberz,Insanity>> - a map with the above values
284   */
285  map<UserId, map<Numberz,Insanity>> testInsanity(1: Insanity argument),
286
287  /**
288   * Prints 'testMulti()'
289   * @param i8 arg0 -
290   * @param i32 arg1 -
291   * @param i64 arg2 -
292   * @param map<i16, string> arg3 -
293   * @param Numberz arg4 -
294   * @param UserId arg5 -
295   * @return Xtruct - returns an Xtruct with string_thing = "Hello2, byte_thing = arg0, i32_thing = arg1
296   *    and i64_thing = arg2
297   */
298  Xtruct testMulti(1: i8 arg0, 2: i32 arg1, 3: i64 arg2, 4: map<i16, string> arg3, 5: Numberz arg4, 6: UserId arg5),
299
300  /**
301   * Print 'testException(%s)' with arg as '%s'
302   * @param string arg - a string indication what type of exception to throw
303   * if arg == "Xception" throw Xception with errorCode = 1001 and message = arg
304   * else if arg == "TException" throw TException
305   * else do not throw anything
306   */
307  void testException(1: string arg) throws(1: Xception err1),
308
309  /**
310   * Print 'testMultiException(%s, %s)' with arg0 as '%s' and arg1 as '%s'
311   * @param string arg - a string indicating what type of exception to throw
312   * if arg0 == "Xception" throw Xception with errorCode = 1001 and message = "This is an Xception"
313   * else if arg0 == "Xception2" throw Xception2 with errorCode = 2002 and struct_thing.string_thing = "This is an Xception2"
314   * else do not throw anything
315   * @return Xtruct - an Xtruct with string_thing = arg1
316   */
317  Xtruct testMultiException(1: string arg0, 2: string arg1) throws(1: Xception err1, 2: Xception2 err2)
318
319  /**
320   * Print 'testOneway(%d): Sleeping...' with secondsToSleep as '%d'
321   * sleep 'secondsToSleep'
322   * Print 'testOneway(%d): done sleeping!' with secondsToSleep as '%d'
323   * @param i32 secondsToSleep - the number of seconds to sleep
324   */
325  oneway void testOneway(1:i32 secondsToSleep)
326}
327
328service SecondService
329{
330  /**
331   * Prints 'testString("%s")' with thing as '%s'
332   * @param string thing - the string to print
333   * @return string - returns the string 'thing'
334   */
335  string secondtestString(1: string thing)
336}
337
338struct VersioningTestV1 {
339       1: i32 begin_in_both,
340       3: string old_string,
341       12: i32 end_in_both
342}
343
344struct VersioningTestV2 {
345       1: i32 begin_in_both,
346
347       2: i32 newint,
348       3: i8 newbyte,
349       4: i16 newshort,
350       5: i64 newlong,
351       6: double newdouble
352       7: Bonk newstruct,
353       8: list<i32> newlist,
354       9: set<i32> newset,
355       10: map<i32, i32> newmap,
356       11: string newstring,
357       12: i32 end_in_both
358}
359
360struct ListTypeVersioningV1 {
361       1: list<i32> myints;
362       2: string hello;
363}
364
365struct ListTypeVersioningV2 {
366       1: list<string> strings;
367       2: string hello;
368}
369
370struct GuessProtocolStruct {
371  7: map<string,string> map_field,
372}
373
374struct LargeDeltas {
375  1: Bools b1,
376  10: Bools b10,
377  100: Bools b100,
378  500: bool check_true,
379  1000: Bools b1000,
380  1500: bool check_false,
381  2000: VersioningTestV2 vertwo2000,
382  2500: set<string> a_set2500,
383  3000: VersioningTestV2 vertwo3000,
384  4000: list<i32> big_numbers
385}
386
387struct NestedListsI32x2 {
388  1: list<list<i32>> integerlist
389}
390struct NestedListsI32x3 {
391  1: list<list<list<i32>>> integerlist
392}
393struct NestedMixedx2 {
394  1: list<set<i32>> int_set_list
395  2: map<i32,set<string>> map_int_strset
396  3: list<map<i32,set<string>>> map_int_strset_list
397}
398struct ListBonks {
399  1: list<Bonk> bonk
400}
401struct NestedListsBonk {
402  1: list<list<list<Bonk>>> bonk
403}
404
405struct BoolTest {
406  1: optional bool b = true;
407  2: optional string s = "true";
408}
409
410struct StructA {
411  1: required string s;
412}
413
414struct StructB {
415  1: optional StructA aa;
416  2: required StructA ab;
417}
418
419struct OptionalSetDefaultTest {
420  1: optional set<string> with_default = [ "test" ]
421}
422
423struct OptionalBinary {
424  1: optional set<binary> bin_set = {}
425  2: optional map<binary,i32> bin_map = {}
426}
427