cannam@132: # Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors
cannam@132: # Licensed under the MIT License:
cannam@132: #
cannam@132: # Permission is hereby granted, free of charge, to any person obtaining a copy
cannam@132: # of this software and associated documentation files (the "Software"), to deal
cannam@132: # in the Software without restriction, including without limitation the rights
cannam@132: # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
cannam@132: # copies of the Software, and to permit persons to whom the Software is
cannam@132: # furnished to do so, subject to the following conditions:
cannam@132: #
cannam@132: # The above copyright notice and this permission notice shall be included in
cannam@132: # all copies or substantial portions of the Software.
cannam@132: #
cannam@132: # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
cannam@132: # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
cannam@132: # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
cannam@132: # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
cannam@132: # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
cannam@132: # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
cannam@132: # THE SOFTWARE.
cannam@132: 
cannam@132: @0xd508eebdc2dc42b8;
cannam@132: 
cannam@132: using Cxx = import "c++.capnp";
cannam@132: 
cannam@132: # Use a namespace likely to cause trouble if the generated code doesn't use fully-qualified
cannam@132: # names for stuff in the capnproto namespace.
cannam@132: $Cxx.namespace("capnproto_test::capnp::test");
cannam@132: 
cannam@132: enum TestEnum {
cannam@132:   foo @0;
cannam@132:   bar @1;
cannam@132:   baz @2;
cannam@132:   qux @3;
cannam@132:   quux @4;
cannam@132:   corge @5;
cannam@132:   grault @6;
cannam@132:   garply @7;
cannam@132: }
cannam@132: 
cannam@132: struct TestAllTypes {
cannam@132:   voidField      @0  : Void;
cannam@132:   boolField      @1  : Bool;
cannam@132:   int8Field      @2  : Int8;
cannam@132:   int16Field     @3  : Int16;
cannam@132:   int32Field     @4  : Int32;
cannam@132:   int64Field     @5  : Int64;
cannam@132:   uInt8Field     @6  : UInt8;
cannam@132:   uInt16Field    @7  : UInt16;
cannam@132:   uInt32Field    @8  : UInt32;
cannam@132:   uInt64Field    @9  : UInt64;
cannam@132:   float32Field   @10 : Float32;
cannam@132:   float64Field   @11 : Float64;
cannam@132:   textField      @12 : Text;
cannam@132:   dataField      @13 : Data;
cannam@132:   structField    @14 : TestAllTypes;
cannam@132:   enumField      @15 : TestEnum;
cannam@132:   interfaceField @16 : Void;  # TODO
cannam@132: 
cannam@132:   voidList      @17 : List(Void);
cannam@132:   boolList      @18 : List(Bool);
cannam@132:   int8List      @19 : List(Int8);
cannam@132:   int16List     @20 : List(Int16);
cannam@132:   int32List     @21 : List(Int32);
cannam@132:   int64List     @22 : List(Int64);
cannam@132:   uInt8List     @23 : List(UInt8);
cannam@132:   uInt16List    @24 : List(UInt16);
cannam@132:   uInt32List    @25 : List(UInt32);
cannam@132:   uInt64List    @26 : List(UInt64);
cannam@132:   float32List   @27 : List(Float32);
cannam@132:   float64List   @28 : List(Float64);
cannam@132:   textList      @29 : List(Text);
cannam@132:   dataList      @30 : List(Data);
cannam@132:   structList    @31 : List(TestAllTypes);
cannam@132:   enumList      @32 : List(TestEnum);
cannam@132:   interfaceList @33 : List(Void);  # TODO
cannam@132: }
cannam@132: 
cannam@132: struct TestDefaults {
cannam@132:   voidField      @0  : Void    = void;
cannam@132:   boolField      @1  : Bool    = true;
cannam@132:   int8Field      @2  : Int8    = -123;
cannam@132:   int16Field     @3  : Int16   = -12345;
cannam@132:   int32Field     @4  : Int32   = -12345678;
cannam@132:   int64Field     @5  : Int64   = -123456789012345;
cannam@132:   uInt8Field     @6  : UInt8   = 234;
cannam@132:   uInt16Field    @7  : UInt16  = 45678;
cannam@132:   uInt32Field    @8  : UInt32  = 3456789012;
cannam@132:   uInt64Field    @9  : UInt64  = 12345678901234567890;
cannam@132:   float32Field   @10 : Float32 = 1234.5;
cannam@132:   float64Field   @11 : Float64 = -123e45;
cannam@132:   textField      @12 : Text    = "foo";
cannam@132:   dataField      @13 : Data    = 0x"62 61 72"; # "bar"
cannam@132:   structField    @14 : TestAllTypes = (
cannam@132:       voidField      = void,
cannam@132:       boolField      = true,
cannam@132:       int8Field      = -12,
cannam@132:       int16Field     = 3456,
cannam@132:       int32Field     = -78901234,
cannam@132:       int64Field     = 56789012345678,
cannam@132:       uInt8Field     = 90,
cannam@132:       uInt16Field    = 1234,
cannam@132:       uInt32Field    = 56789012,
cannam@132:       uInt64Field    = 345678901234567890,
cannam@132:       float32Field   = -1.25e-10,
cannam@132:       float64Field   = 345,
cannam@132:       textField      = "baz",
cannam@132:       dataField      = "qux",
cannam@132:       structField    = (
cannam@132:           textField = "nested",
cannam@132:           structField = (textField = "really nested")),
cannam@132:       enumField      = baz,
cannam@132:       # interfaceField can't have a default
cannam@132: 
cannam@132:       voidList      = [void, void, void],
cannam@132:       boolList      = [false, true, false, true, true],
cannam@132:       int8List      = [12, -34, -0x80, 0x7f],
cannam@132:       int16List     = [1234, -5678, -0x8000, 0x7fff],
cannam@132:       int32List     = [12345678, -90123456, -0x80000000, 0x7fffffff],
cannam@132:       int64List     = [123456789012345, -678901234567890, -0x8000000000000000, 0x7fffffffffffffff],
cannam@132:       uInt8List     = [12, 34, 0, 0xff],
cannam@132:       uInt16List    = [1234, 5678, 0, 0xffff],
cannam@132:       uInt32List    = [12345678, 90123456, 0, 0xffffffff],
cannam@132:       uInt64List    = [123456789012345, 678901234567890, 0, 0xffffffffffffffff],
cannam@132:       float32List   = [0, 1234567, 1e37, -1e37, 1e-37, -1e-37],
cannam@132:       float64List   = [0, 123456789012345, 1e306, -1e306, 1e-306, -1e-306],
cannam@132:       textList      = ["quux", "corge", "grault"],
cannam@132:       dataList      = ["garply", "waldo", "fred"],
cannam@132:       structList    = [
cannam@132:           (textField = "x structlist 1"),
cannam@132:           (textField = "x structlist 2"),
cannam@132:           (textField = "x structlist 3")],
cannam@132:       enumList      = [qux, bar, grault]
cannam@132:       # interfaceList can't have a default
cannam@132:       );
cannam@132:   enumField      @15 : TestEnum = corge;
cannam@132:   interfaceField @16 : Void;  # TODO
cannam@132: 
cannam@132:   voidList      @17 : List(Void)    = [void, void, void, void, void, void];
cannam@132:   boolList      @18 : List(Bool)    = [true, false, false, true];
cannam@132:   int8List      @19 : List(Int8)    = [111, -111];
cannam@132:   int16List     @20 : List(Int16)   = [11111, -11111];
cannam@132:   int32List     @21 : List(Int32)   = [111111111, -111111111];
cannam@132:   int64List     @22 : List(Int64)   = [1111111111111111111, -1111111111111111111];
cannam@132:   uInt8List     @23 : List(UInt8)   = [111, 222] ;
cannam@132:   uInt16List    @24 : List(UInt16)  = [33333, 44444];
cannam@132:   uInt32List    @25 : List(UInt32)  = [3333333333];
cannam@132:   uInt64List    @26 : List(UInt64)  = [11111111111111111111];
cannam@132:   float32List   @27 : List(Float32) = [5555.5, inf, -inf, nan];
cannam@132:   float64List   @28 : List(Float64) = [7777.75, inf, -inf, nan];
cannam@132:   textList      @29 : List(Text)    = ["plugh", "xyzzy", "thud"];
cannam@132:   dataList      @30 : List(Data)    = ["oops", "exhausted", "rfc3092"];
cannam@132:   structList    @31 : List(TestAllTypes) = [
cannam@132:       (textField = "structlist 1"),
cannam@132:       (textField = "structlist 2"),
cannam@132:       (textField = "structlist 3")];
cannam@132:   enumList      @32 : List(TestEnum) = [foo, garply];
cannam@132:   interfaceList @33 : List(Void);  # TODO
cannam@132: }
cannam@132: 
cannam@132: struct TestAnyPointer {
cannam@132:   anyPointerField @0 :AnyPointer;
cannam@132: 
cannam@132:   # Do not add any other fields here!  Some tests rely on anyPointerField being the last pointer
cannam@132:   # in the struct.
cannam@132: }
cannam@132: 
cannam@132: struct TestAnyOthers {
cannam@132:   anyStructField @0 :AnyStruct;
cannam@132:   anyListField @1 :AnyList;
cannam@132:   capabilityField @2 :Capability;
cannam@132: }
cannam@132: 
cannam@132: struct TestOutOfOrder {
cannam@132:   foo @3 :Text;
cannam@132:   bar @2 :Text;
cannam@132:   baz @8 :Text;
cannam@132:   qux @0 :Text;
cannam@132:   quux @6 :Text;
cannam@132:   corge @4 :Text;
cannam@132:   grault @1 :Text;
cannam@132:   garply @7 :Text;
cannam@132:   waldo @5 :Text;
cannam@132: }
cannam@132: 
cannam@132: struct TestUnion {
cannam@132:   union0 @0! :union {
cannam@132:     # Pack union 0 under ideal conditions: there is no unused padding space prior to it.
cannam@132:     u0f0s0  @4: Void;
cannam@132:     u0f0s1  @5: Bool;
cannam@132:     u0f0s8  @6: Int8;
cannam@132:     u0f0s16 @7: Int16;
cannam@132:     u0f0s32 @8: Int32;
cannam@132:     u0f0s64 @9: Int64;
cannam@132:     u0f0sp  @10: Text;
cannam@132: 
cannam@132:     # Pack more stuff into union0 -- should go in same space.
cannam@132:     u0f1s0  @11: Void;
cannam@132:     u0f1s1  @12: Bool;
cannam@132:     u0f1s8  @13: Int8;
cannam@132:     u0f1s16 @14: Int16;
cannam@132:     u0f1s32 @15: Int32;
cannam@132:     u0f1s64 @16: Int64;
cannam@132:     u0f1sp  @17: Text;
cannam@132:   }
cannam@132: 
cannam@132:   # Pack one bit in order to make pathological situation for union1.
cannam@132:   bit0 @18: Bool;
cannam@132: 
cannam@132:   union1 @1! :union {
cannam@132:     # Pack pathologically bad case.  Each field takes up new space.
cannam@132:     u1f0s0  @19: Void;
cannam@132:     u1f0s1  @20: Bool;
cannam@132:     u1f1s1  @21: Bool;
cannam@132:     u1f0s8  @22: Int8;
cannam@132:     u1f1s8  @23: Int8;
cannam@132:     u1f0s16 @24: Int16;
cannam@132:     u1f1s16 @25: Int16;
cannam@132:     u1f0s32 @26: Int32;
cannam@132:     u1f1s32 @27: Int32;
cannam@132:     u1f0s64 @28: Int64;
cannam@132:     u1f1s64 @29: Int64;
cannam@132:     u1f0sp  @30: Text;
cannam@132:     u1f1sp  @31: Text;
cannam@132: 
cannam@132:     # Pack more stuff into union1 -- each should go into the same space as corresponding u1f0s*.
cannam@132:     u1f2s0  @32: Void;
cannam@132:     u1f2s1  @33: Bool;
cannam@132:     u1f2s8  @34: Int8;
cannam@132:     u1f2s16 @35: Int16;
cannam@132:     u1f2s32 @36: Int32;
cannam@132:     u1f2s64 @37: Int64;
cannam@132:     u1f2sp  @38: Text;
cannam@132:   }
cannam@132: 
cannam@132:   # Fill in the rest of that bitfield from earlier.
cannam@132:   bit2 @39: Bool;
cannam@132:   bit3 @40: Bool;
cannam@132:   bit4 @41: Bool;
cannam@132:   bit5 @42: Bool;
cannam@132:   bit6 @43: Bool;
cannam@132:   bit7 @44: Bool;
cannam@132: 
cannam@132:   # Interleave two unions to be really annoying.
cannam@132:   # Also declare in reverse order to make sure union discriminant values are sorted by field number
cannam@132:   # and not by declaration order.
cannam@132:   union2 @2! :union {
cannam@132:     u2f0s64 @54: Int64;
cannam@132:     u2f0s32 @52: Int32;
cannam@132:     u2f0s16 @50: Int16;
cannam@132:     u2f0s8 @47: Int8;
cannam@132:     u2f0s1 @45: Bool;
cannam@132:   }
cannam@132: 
cannam@132:   union3 @3! :union {
cannam@132:     u3f0s64 @55: Int64;
cannam@132:     u3f0s32 @53: Int32;
cannam@132:     u3f0s16 @51: Int16;
cannam@132:     u3f0s8 @48: Int8;
cannam@132:     u3f0s1 @46: Bool;
cannam@132:   }
cannam@132: 
cannam@132:   byte0 @49: UInt8;
cannam@132: }
cannam@132: 
cannam@132: struct TestUnnamedUnion {
cannam@132:   before @0 :Text;
cannam@132: 
cannam@132:   union {
cannam@132:     foo @1 :UInt16;
cannam@132:     bar @3 :UInt32;
cannam@132:   }
cannam@132: 
cannam@132:   middle @2 :UInt16;
cannam@132: 
cannam@132:   after @4 :Text;
cannam@132: }
cannam@132: 
cannam@132: struct TestUnionInUnion {
cannam@132:   # There is no reason to ever do this.
cannam@132:   outer :union {
cannam@132:     inner :union {
cannam@132:       foo @0 :Int32;
cannam@132:       bar @1 :Int32;
cannam@132:     }
cannam@132:     baz @2 :Int32;
cannam@132:   }
cannam@132: }
cannam@132: 
cannam@132: struct TestGroups {
cannam@132:   groups :union {
cannam@132:     foo :group {
cannam@132:       corge @0 :Int32;
cannam@132:       grault @2 :Int64;
cannam@132:       garply @8 :Text;
cannam@132:     }
cannam@132:     bar :group {
cannam@132:       corge @3 :Int32;
cannam@132:       grault @4 :Text;
cannam@132:       garply @5 :Int64;
cannam@132:     }
cannam@132:     baz :group {
cannam@132:       corge @1 :Int32;
cannam@132:       grault @6 :Text;
cannam@132:       garply @7 :Text;
cannam@132:     }
cannam@132:   }
cannam@132: }
cannam@132: 
cannam@132: struct TestInterleavedGroups {
cannam@132:   group1 :group {
cannam@132:     foo @0 :UInt32;
cannam@132:     bar @2 :UInt64;
cannam@132:     union {
cannam@132:       qux @4 :UInt16;
cannam@132:       corge :group {
cannam@132:         grault @6 :UInt64;
cannam@132:         garply @8 :UInt16;
cannam@132:         plugh @14 :Text;
cannam@132:         xyzzy @16 :Text;
cannam@132:       }
cannam@132: 
cannam@132:       fred @12 :Text;
cannam@132:     }
cannam@132: 
cannam@132:     waldo @10 :Text;
cannam@132:   }
cannam@132: 
cannam@132:   group2 :group {
cannam@132:     foo @1 :UInt32;
cannam@132:     bar @3 :UInt64;
cannam@132:     union {
cannam@132:       qux @5 :UInt16;
cannam@132:       corge :group {
cannam@132:         grault @7 :UInt64;
cannam@132:         garply @9 :UInt16;
cannam@132:         plugh @15 :Text;
cannam@132:         xyzzy @17 :Text;
cannam@132:       }
cannam@132: 
cannam@132:       fred @13 :Text;
cannam@132:     }
cannam@132: 
cannam@132:     waldo @11 :Text;
cannam@132:   }
cannam@132: }
cannam@132: 
cannam@132: struct TestUnionDefaults {
cannam@132:   s16s8s64s8Set @0 :TestUnion =
cannam@132:       (union0 = (u0f0s16 = 321), union1 = (u1f0s8 = 123), union2 = (u2f0s64 = 12345678901234567),
cannam@132:        union3 = (u3f0s8 = 55));
cannam@132:   s0sps1s32Set @1 :TestUnion =
cannam@132:       (union0 = (u0f1s0 = void), union1 = (u1f0sp = "foo"), union2 = (u2f0s1 = true),
cannam@132:        union3 = (u3f0s32 = 12345678));
cannam@132: 
cannam@132:   unnamed1 @2 :TestUnnamedUnion = (foo = 123);
cannam@132:   unnamed2 @3 :TestUnnamedUnion = (bar = 321, before = "foo", after = "bar");
cannam@132: }
cannam@132: 
cannam@132: struct TestNestedTypes {
cannam@132:   enum NestedEnum {
cannam@132:     foo @0;
cannam@132:     bar @1;
cannam@132:   }
cannam@132: 
cannam@132:   struct NestedStruct {
cannam@132:     enum NestedEnum {
cannam@132:       baz @0;
cannam@132:       qux @1;
cannam@132:       quux @2;
cannam@132:     }
cannam@132: 
cannam@132:     outerNestedEnum @0 :TestNestedTypes.NestedEnum = bar;
cannam@132:     innerNestedEnum @1 :NestedEnum = quux;
cannam@132:   }
cannam@132: 
cannam@132:   nestedStruct @0 :NestedStruct;
cannam@132: 
cannam@132:   outerNestedEnum @1 :NestedEnum = bar;
cannam@132:   innerNestedEnum @2 :NestedStruct.NestedEnum = quux;
cannam@132: }
cannam@132: 
cannam@132: struct TestUsing {
cannam@132:   using OuterNestedEnum = TestNestedTypes.NestedEnum;
cannam@132:   using TestNestedTypes.NestedStruct.NestedEnum;
cannam@132: 
cannam@132:   outerNestedEnum @1 :OuterNestedEnum = bar;
cannam@132:   innerNestedEnum @0 :NestedEnum = quux;
cannam@132: }
cannam@132: 
cannam@132: struct TestLists {
cannam@132:   # Small structs, when encoded as list, will be encoded as primitive lists rather than struct
cannam@132:   # lists, to save space.
cannam@132:   struct Struct0  { f @0 :Void; }
cannam@132:   struct Struct1  { f @0 :Bool; }
cannam@132:   struct Struct8  { f @0 :UInt8; }
cannam@132:   struct Struct16 { f @0 :UInt16; }
cannam@132:   struct Struct32 { f @0 :UInt32; }
cannam@132:   struct Struct64 { f @0 :UInt64; }
cannam@132:   struct StructP  { f @0 :Text; }
cannam@132: 
cannam@132:   # Versions of the above which cannot be encoded as primitive lists.
cannam@132:   struct Struct0c  { f @0 :Void; pad @1 :Text; }
cannam@132:   struct Struct1c  { f @0 :Bool; pad @1 :Text; }
cannam@132:   struct Struct8c  { f @0 :UInt8; pad @1 :Text; }
cannam@132:   struct Struct16c { f @0 :UInt16; pad @1 :Text; }
cannam@132:   struct Struct32c { f @0 :UInt32; pad @1 :Text; }
cannam@132:   struct Struct64c { f @0 :UInt64; pad @1 :Text; }
cannam@132:   struct StructPc  { f @0 :Text; pad @1 :UInt64; }
cannam@132: 
cannam@132:   list0  @0 :List(Struct0);
cannam@132:   list1  @1 :List(Struct1);
cannam@132:   list8  @2 :List(Struct8);
cannam@132:   list16 @3 :List(Struct16);
cannam@132:   list32 @4 :List(Struct32);
cannam@132:   list64 @5 :List(Struct64);
cannam@132:   listP  @6 :List(StructP);
cannam@132: 
cannam@132:   int32ListList @7 :List(List(Int32));
cannam@132:   textListList @8 :List(List(Text));
cannam@132:   structListList @9 :List(List(TestAllTypes));
cannam@132: }
cannam@132: 
cannam@132: struct TestFieldZeroIsBit {
cannam@132:   bit @0 :Bool;
cannam@132:   secondBit @1 :Bool = true;
cannam@132:   thirdField @2 :UInt8 = 123;
cannam@132: }
cannam@132: 
cannam@132: struct TestListDefaults {
cannam@132:   lists @0 :TestLists = (
cannam@132:       list0  = [(f = void), (f = void)],
cannam@132:       list1  = [(f = true), (f = false), (f = true), (f = true)],
cannam@132:       list8  = [(f = 123), (f = 45)],
cannam@132:       list16 = [(f = 12345), (f = 6789)],
cannam@132:       list32 = [(f = 123456789), (f = 234567890)],
cannam@132:       list64 = [(f = 1234567890123456), (f = 2345678901234567)],
cannam@132:       listP  = [(f = "foo"), (f = "bar")],
cannam@132:       int32ListList = [[1, 2, 3], [4, 5], [12341234]],
cannam@132:       textListList = [["foo", "bar"], ["baz"], ["qux", "corge"]],
cannam@132:       structListList = [[(int32Field = 123), (int32Field = 456)], [(int32Field = 789)]]);
cannam@132: }
cannam@132: 
cannam@132: struct TestLateUnion {
cannam@132:   # Test what happens if the unions are not the first ordinals in the struct.  At one point this
cannam@132:   # was broken for the dynamic API.
cannam@132: 
cannam@132:   foo @0 :Int32;
cannam@132:   bar @1 :Text;
cannam@132:   baz @2 :Int16;
cannam@132: 
cannam@132:   theUnion @3! :union {
cannam@132:     qux @4 :Text;
cannam@132:     corge @5 :List(Int32);
cannam@132:     grault @6 :Float32;
cannam@132:   }
cannam@132: 
cannam@132:   anotherUnion @7! :union {
cannam@132:     qux @8 :Text;
cannam@132:     corge @9 :List(Int32);
cannam@132:     grault @10 :Float32;
cannam@132:   }
cannam@132: }
cannam@132: 
cannam@132: struct TestOldVersion {
cannam@132:   # A subset of TestNewVersion.
cannam@132:   old1 @0 :Int64;
cannam@132:   old2 @1 :Text;
cannam@132:   old3 @2 :TestOldVersion;
cannam@132: }
cannam@132: 
cannam@132: struct TestNewVersion {
cannam@132:   # A superset of TestOldVersion.
cannam@132:   old1 @0 :Int64;
cannam@132:   old2 @1 :Text;
cannam@132:   old3 @2 :TestNewVersion;
cannam@132:   new1 @3 :Int64 = 987;
cannam@132:   new2 @4 :Text = "baz";
cannam@132: }
cannam@132: 
cannam@132: struct TestOldUnionVersion {
cannam@132:   union {
cannam@132:     a @0 :Void;
cannam@132:     b @1 :UInt64;
cannam@132:   }
cannam@132: }
cannam@132: 
cannam@132: struct TestNewUnionVersion {
cannam@132:   union {
cannam@132:     a :union {
cannam@132:       a0 @0 :Void;
cannam@132:       a1 @2 :UInt64;
cannam@132:     }
cannam@132:     b @1 :UInt64;
cannam@132:   }
cannam@132: }
cannam@132: 
cannam@132: struct TestStructUnion {
cannam@132:   un @0! :union {
cannam@132:     struct @1 :SomeStruct;
cannam@132:     object @2 :TestAnyPointer;
cannam@132:   }
cannam@132: 
cannam@132:   struct SomeStruct {
cannam@132:     someText @0 :Text;
cannam@132:     moreText @1 :Text;
cannam@132:   }
cannam@132: }
cannam@132: 
cannam@132: struct TestPrintInlineStructs {
cannam@132:   someText @0 :Text;
cannam@132: 
cannam@132:   structList @1 :List(InlineStruct);
cannam@132:   struct InlineStruct {
cannam@132:     int32Field @0 :Int32;
cannam@132:     textField @1 :Text;
cannam@132:   }
cannam@132: }
cannam@132: 
cannam@132: struct TestWholeFloatDefault {
cannam@132:   # At one point, these failed to compile in C++ because it would produce literals like "123f",
cannam@132:   # which is not valid; it needs to be "123.0f".
cannam@132:   field @0 :Float32 = 123;
cannam@132:   bigField @1 :Float32 = 2e30;
cannam@132:   const constant :Float32 = 456;
cannam@132:   const bigConstant :Float32 = 4e30;
cannam@132: }
cannam@132: 
cannam@132: struct TestGenerics(Foo, Bar) {
cannam@132:   foo @0 :Foo;
cannam@132:   rev @1 :TestGenerics(Bar, Foo);
cannam@132: 
cannam@132:   union {
cannam@132:     uv @2:Void;
cannam@132:     ug :group {
cannam@132:       ugfoo @3:Int32;
cannam@132:     }
cannam@132:   }
cannam@132: 
cannam@132:   struct Inner {
cannam@132:     foo @0 :Foo;
cannam@132:     bar @1 :Bar;
cannam@132:   }
cannam@132: 
cannam@132:   struct Inner2(Baz) {
cannam@132:     bar @0 :Bar;
cannam@132:     baz @1 :Baz;
cannam@132:     innerBound @2 :Inner;
cannam@132:     innerUnbound @3 :TestGenerics.Inner;
cannam@132: 
cannam@132:     struct DeepNest(Qux) {
cannam@132:       foo @0 :Foo;
cannam@132:       bar @1 :Bar;
cannam@132:       baz @2 :Baz;
cannam@132:       qux @3 :Qux;
cannam@132:     }
cannam@132:   }
cannam@132: 
cannam@132:   interface Interface(Qux) {
cannam@132:     call @0 Inner2(Text) -> (qux :Qux, gen :TestGenerics(TestAllTypes, TestAnyPointer));
cannam@132:   }
cannam@132: 
cannam@132:   annotation ann(struct) :Foo;
cannam@132: 
cannam@132:   using AliasFoo = Foo;
cannam@132:   using AliasInner = Inner;
cannam@132:   using AliasInner2 = Inner2;
cannam@132:   using AliasInner2Text = Inner2(Text);
cannam@132:   using AliasRev = TestGenerics(Bar, Foo);
cannam@132: 
cannam@132:   struct UseAliases {
cannam@132:     foo @0 :AliasFoo;
cannam@132:     inner @1 :AliasInner;
cannam@132:     inner2 @2 :AliasInner2;
cannam@132:     inner2Bind @3 :AliasInner2(Text);
cannam@132:     inner2Text @4 :AliasInner2Text;
cannam@132:     revFoo @5 :AliasRev.AliasFoo;
cannam@132:   }
cannam@132: }
cannam@132: 
cannam@132: struct TestGenericsWrapper(Foo, Bar) {
cannam@132:   value @0 :TestGenerics(Foo, Bar);
cannam@132: }
cannam@132: 
cannam@132: struct TestGenericsWrapper2 {
cannam@132:   value @0 :TestGenericsWrapper(Text, TestAllTypes);
cannam@132: }
cannam@132: 
cannam@132: interface TestImplicitMethodParams {
cannam@132:   call @0 [T, U] (foo :T, bar :U) -> TestGenerics(T, U);
cannam@132: }
cannam@132: 
cannam@132: interface TestImplicitMethodParamsInGeneric(V) {
cannam@132:   call @0 [T, U] (foo :T, bar :U) -> TestGenerics(T, U);
cannam@132: }
cannam@132: 
cannam@132: struct TestGenericsUnion(Foo, Bar) {
cannam@132:   # At one point this failed to compile.
cannam@132: 
cannam@132:   union {
cannam@132:     foo @0 :Foo;
cannam@132:     bar @1 :Bar;
cannam@132:   }
cannam@132: }
cannam@132: 
cannam@132: struct TestUseGenerics $TestGenerics(Text, Data).ann("foo") {
cannam@132:   basic @0 :TestGenerics(TestAllTypes, TestAnyPointer);
cannam@132:   inner @1 :TestGenerics(TestAllTypes, TestAnyPointer).Inner;
cannam@132:   inner2 @2 :TestGenerics(TestAllTypes, TestAnyPointer).Inner2(Text);
cannam@132:   unspecified @3 :TestGenerics;
cannam@132:   unspecifiedInner @4 :TestGenerics.Inner2(Text);
cannam@132:   wrapper @8 :TestGenericsWrapper(TestAllTypes, TestAnyPointer);
cannam@132:   cap @18 :TestGenerics(TestInterface, Text);
cannam@132:   genericCap @19 :TestGenerics(TestAllTypes, List(UInt32)).Interface(Data);
cannam@132: 
cannam@132:   default @5 :TestGenerics(TestAllTypes, Text) =
cannam@132:       (foo = (int16Field = 123), rev = (foo = "text", rev = (foo = (int16Field = 321))));
cannam@132:   defaultInner @6 :TestGenerics(TestAllTypes, Text).Inner =
cannam@132:       (foo = (int16Field = 123), bar = "text");
cannam@132:   defaultUser @7 :TestUseGenerics = (basic = (foo = (int16Field = 123)));
cannam@132:   defaultWrapper @9 :TestGenericsWrapper(Text, TestAllTypes) =
cannam@132:       (value = (foo = "text", rev = (foo = (int16Field = 321))));
cannam@132:   defaultWrapper2 @10 :TestGenericsWrapper2 =
cannam@132:       (value = (value = (foo = "text", rev = (foo = (int16Field = 321)))));
cannam@132: 
cannam@132:   aliasFoo @11 :TestGenerics(TestAllTypes, TestAnyPointer).AliasFoo = (int16Field = 123);
cannam@132:   aliasInner @12 :TestGenerics(TestAllTypes, TestAnyPointer).AliasInner
cannam@132:       = (foo = (int16Field = 123));
cannam@132:   aliasInner2 @13 :TestGenerics(TestAllTypes, TestAnyPointer).AliasInner2
cannam@132:       = (innerBound = (foo = (int16Field = 123)));
cannam@132:   aliasInner2Bind @14 :TestGenerics(TestAllTypes, TestAnyPointer).AliasInner2(List(UInt32))
cannam@132:       = (baz = [12, 34], innerBound = (foo = (int16Field = 123)));
cannam@132:   aliasInner2Text @15 :TestGenerics(TestAllTypes, TestAnyPointer).AliasInner2Text
cannam@132:       = (baz = "text", innerBound = (foo = (int16Field = 123)));
cannam@132:   aliasRev @16 :TestGenerics(TestAnyPointer, Text).AliasRev.AliasFoo = "text";
cannam@132: 
cannam@132:   useAliases @17 :TestGenerics(TestAllTypes, List(UInt32)).UseAliases = (
cannam@132:       foo = (int16Field = 123),
cannam@132:       inner = (foo = (int16Field = 123)),
cannam@132:       inner2 = (innerBound = (foo = (int16Field = 123))),
cannam@132:       inner2Bind = (baz = "text", innerBound = (foo = (int16Field = 123))),
cannam@132:       inner2Text = (baz = "text", innerBound = (foo = (int16Field = 123))),
cannam@132:       revFoo = [12, 34, 56]);
cannam@132: }
cannam@132: 
cannam@132: struct TestEmptyStruct {}
cannam@132: 
cannam@132: struct TestConstants {
cannam@132:   const voidConst      :Void    = void;
cannam@132:   const boolConst      :Bool    = true;
cannam@132:   const int8Const      :Int8    = -123;
cannam@132:   const int16Const     :Int16   = -12345;
cannam@132:   const int32Const     :Int32   = -12345678;
cannam@132:   const int64Const     :Int64   = -123456789012345;
cannam@132:   const uint8Const     :UInt8   = 234;
cannam@132:   const uint16Const    :UInt16  = 45678;
cannam@132:   const uint32Const    :UInt32  = 3456789012;
cannam@132:   const uint64Const    :UInt64  = 12345678901234567890;
cannam@132:   const float32Const   :Float32 = 1234.5;
cannam@132:   const float64Const   :Float64 = -123e45;
cannam@132:   const textConst      :Text    = "foo";
cannam@132:   const dataConst      :Data    = "bar";
cannam@132:   const structConst    :TestAllTypes = (
cannam@132:       voidField      = void,
cannam@132:       boolField      = true,
cannam@132:       int8Field      = -12,
cannam@132:       int16Field     = 3456,
cannam@132:       int32Field     = -78901234,
cannam@132:       int64Field     = 56789012345678,
cannam@132:       uInt8Field     = 90,
cannam@132:       uInt16Field    = 1234,
cannam@132:       uInt32Field    = 56789012,
cannam@132:       uInt64Field    = 345678901234567890,
cannam@132:       float32Field   = -1.25e-10,
cannam@132:       float64Field   = 345,
cannam@132:       textField      = "baz",
cannam@132:       dataField      = "qux",
cannam@132:       structField    = (
cannam@132:           textField = "nested",
cannam@132:           structField = (textField = "really nested")),
cannam@132:       enumField      = baz,
cannam@132:       # interfaceField can't have a default
cannam@132: 
cannam@132:       voidList      = [void, void, void],
cannam@132:       boolList      = [false, true, false, true, true],
cannam@132:       int8List      = [12, -34, -0x80, 0x7f],
cannam@132:       int16List     = [1234, -5678, -0x8000, 0x7fff],
cannam@132:       int32List     = [12345678, -90123456, -0x80000000, 0x7fffffff],
cannam@132:       int64List     = [123456789012345, -678901234567890, -0x8000000000000000, 0x7fffffffffffffff],
cannam@132:       uInt8List     = [12, 34, 0, 0xff],
cannam@132:       uInt16List    = [1234, 5678, 0, 0xffff],
cannam@132:       uInt32List    = [12345678, 90123456, 0, 0xffffffff],
cannam@132:       uInt64List    = [123456789012345, 678901234567890, 0, 0xffffffffffffffff],
cannam@132:       float32List   = [0, 1234567, 1e37, -1e37, 1e-37, -1e-37],
cannam@132:       float64List   = [0, 123456789012345, 1e306, -1e306, 1e-306, -1e-306],
cannam@132:       textList      = ["quux", "corge", "grault"],
cannam@132:       dataList      = ["garply", "waldo", "fred"],
cannam@132:       structList    = [
cannam@132:           (textField = "x structlist 1"),
cannam@132:           (textField = "x structlist 2"),
cannam@132:           (textField = "x structlist 3")],
cannam@132:       enumList      = [qux, bar, grault]
cannam@132:       # interfaceList can't have a default
cannam@132:       );
cannam@132:   const enumConst      :TestEnum = corge;
cannam@132: 
cannam@132:   const voidListConst      :List(Void)    = [void, void, void, void, void, void];
cannam@132:   const boolListConst      :List(Bool)    = [true, false, false, true];
cannam@132:   const int8ListConst      :List(Int8)    = [111, -111];
cannam@132:   const int16ListConst     :List(Int16)   = [11111, -11111];
cannam@132:   const int32ListConst     :List(Int32)   = [111111111, -111111111];
cannam@132:   const int64ListConst     :List(Int64)   = [1111111111111111111, -1111111111111111111];
cannam@132:   const uint8ListConst     :List(UInt8)   = [111, 222] ;
cannam@132:   const uint16ListConst    :List(UInt16)  = [33333, 44444];
cannam@132:   const uint32ListConst    :List(UInt32)  = [3333333333];
cannam@132:   const uint64ListConst    :List(UInt64)  = [11111111111111111111];
cannam@132:   const float32ListConst   :List(Float32) = [5555.5, inf, -inf, nan];
cannam@132:   const float64ListConst   :List(Float64) = [7777.75, inf, -inf, nan];
cannam@132:   const textListConst      :List(Text)    = ["plugh", "xyzzy", "thud"];
cannam@132:   const dataListConst      :List(Data)    = ["oops", "exhausted", "rfc3092"];
cannam@132:   const structListConst    :List(TestAllTypes) = [
cannam@132:       (textField = "structlist 1"),
cannam@132:       (textField = "structlist 2"),
cannam@132:       (textField = "structlist 3")];
cannam@132:   const enumListConst      :List(TestEnum) = [foo, garply];
cannam@132: }
cannam@132: 
cannam@132: const globalInt :UInt32 = 12345;
cannam@132: const globalText :Text = "foobar";
cannam@132: const globalStruct :TestAllTypes = (int32Field = 54321);
cannam@132: const globalPrintableStruct :TestPrintInlineStructs = (someText = "foo");
cannam@132: const derivedConstant :TestAllTypes = (
cannam@132:     uInt32Field = .globalInt,
cannam@132:     textField = TestConstants.textConst,
cannam@132:     structField = TestConstants.structConst,
cannam@132:     int16List = TestConstants.int16ListConst,
cannam@132:     structList = TestConstants.structListConst);
cannam@132: 
cannam@132: const genericConstant :TestGenerics(TestAllTypes, Text) =
cannam@132:     (foo = (int16Field = 123), rev = (foo = "text", rev = (foo = (int16Field = 321))));
cannam@132: 
cannam@132: const embeddedData :Data = embed "testdata/packed";
cannam@132: const embeddedText :Text = embed "testdata/short.txt";
cannam@132: const embeddedStruct :TestAllTypes = embed "testdata/binary";
cannam@132: 
cannam@132: interface TestInterface {
cannam@132:   foo @0 (i :UInt32, j :Bool) -> (x :Text);
cannam@132:   bar @1 () -> ();
cannam@132:   baz @2 (s: TestAllTypes);
cannam@132: }
cannam@132: 
cannam@132: interface TestExtends extends(TestInterface) {
cannam@132:   qux @0 ();
cannam@132:   corge @1 TestAllTypes -> ();
cannam@132:   grault @2 () -> TestAllTypes;
cannam@132: }
cannam@132: 
cannam@132: interface TestExtends2 extends(TestExtends) {}
cannam@132: 
cannam@132: interface TestPipeline {
cannam@132:   getCap @0 (n: UInt32, inCap :TestInterface) -> (s: Text, outBox :Box);
cannam@132:   testPointers @1 (cap :TestInterface, obj :AnyPointer, list :List(TestInterface)) -> ();
cannam@132: 
cannam@132:   struct Box {
cannam@132:     cap @0 :TestInterface;
cannam@132:   }
cannam@132: }
cannam@132: 
cannam@132: interface TestCallOrder {
cannam@132:   getCallSequence @0 (expected: UInt32) -> (n: UInt32);
cannam@132:   # First call returns 0, next returns 1, ...
cannam@132:   #
cannam@132:   # The input `expected` is ignored but useful for disambiguating debug logs.
cannam@132: }
cannam@132: 
cannam@132: interface TestTailCallee {
cannam@132:   struct TailResult {
cannam@132:     i @0 :UInt32;
cannam@132:     t @1 :Text;
cannam@132:     c @2 :TestCallOrder;
cannam@132:   }
cannam@132: 
cannam@132:   foo @0 (i :Int32, t :Text) -> TailResult;
cannam@132: }
cannam@132: 
cannam@132: interface TestTailCaller {
cannam@132:   foo @0 (i :Int32, callee :TestTailCallee) -> TestTailCallee.TailResult;
cannam@132: }
cannam@132: 
cannam@132: interface TestHandle {}
cannam@132: 
cannam@132: interface TestMoreStuff extends(TestCallOrder) {
cannam@132:   # Catch-all type that contains lots of testing methods.
cannam@132: 
cannam@132:   callFoo @0 (cap :TestInterface) -> (s: Text);
cannam@132:   # Call `cap.foo()`, check the result, and return "bar".
cannam@132: 
cannam@132:   callFooWhenResolved @1 (cap :TestInterface) -> (s: Text);
cannam@132:   # Like callFoo but waits for `cap` to resolve first.
cannam@132: 
cannam@132:   neverReturn @2 (cap :TestInterface) -> (capCopy :TestInterface);
cannam@132:   # Doesn't return.  You should cancel it.
cannam@132: 
cannam@132:   hold @3 (cap :TestInterface) -> ();
cannam@132:   # Returns immediately but holds on to the capability.
cannam@132: 
cannam@132:   callHeld @4 () -> (s: Text);
cannam@132:   # Calls the capability previously held using `hold` (and keeps holding it).
cannam@132: 
cannam@132:   getHeld @5 () -> (cap :TestInterface);
cannam@132:   # Returns the capability previously held using `hold` (and keeps holding it).
cannam@132: 
cannam@132:   echo @6 (cap :TestCallOrder) -> (cap :TestCallOrder);
cannam@132:   # Just returns the input cap.
cannam@132: 
cannam@132:   expectCancel @7 (cap :TestInterface) -> ();
cannam@132:   # evalLater()-loops forever, holding `cap`.  Must be canceled.
cannam@132: 
cannam@132:   methodWithDefaults @8 (a :Text, b :UInt32 = 123, c :Text = "foo") -> (d :Text, e :Text = "bar");
cannam@132: 
cannam@132:   getHandle @9 () -> (handle :TestHandle);
cannam@132:   # Get a new handle. Tests have an out-of-band way to check the current number of live handles, so
cannam@132:   # this can be used to test garbage collection.
cannam@132: 
cannam@132:   getNull @10 () -> (nullCap :TestMoreStuff);
cannam@132:   # Always returns a null capability.
cannam@132: }
cannam@132: 
cannam@132: interface TestMembrane {
cannam@132:   makeThing @0 () -> (thing :Thing);
cannam@132:   callPassThrough @1 (thing :Thing, tailCall :Bool) -> Result;
cannam@132:   callIntercept @2 (thing :Thing, tailCall :Bool) -> Result;
cannam@132:   loopback @3 (thing :Thing) -> (thing :Thing);
cannam@132: 
cannam@132:   interface Thing {
cannam@132:     passThrough @0 () -> Result;
cannam@132:     intercept @1 () -> Result;
cannam@132:   }
cannam@132: 
cannam@132:   struct Result {
cannam@132:     text @0 :Text;
cannam@132:   }
cannam@132: }
cannam@132: 
cannam@132: struct TestContainMembrane {
cannam@132:   cap @0 :TestMembrane.Thing;
cannam@132:   list @1 :List(TestMembrane.Thing);
cannam@132: }
cannam@132: 
cannam@132: struct TestTransferCap {
cannam@132:   list @0 :List(Element);
cannam@132:   struct Element {
cannam@132:     text @0 :Text;
cannam@132:     cap @1 :TestInterface;
cannam@132:   }
cannam@132: }
cannam@132: 
cannam@132: interface TestKeywordMethods {
cannam@132:   delete @0 ();
cannam@132:   class @1 ();
cannam@132:   void @2 ();
cannam@132:   return @3 ();
cannam@132: }
cannam@132: 
cannam@132: interface TestAuthenticatedBootstrap(VatId) {
cannam@132:   getCallerId @0 () -> (caller :VatId);
cannam@132: }
cannam@132: 
cannam@132: struct TestSturdyRef {
cannam@132:   hostId @0 :TestSturdyRefHostId;
cannam@132:   objectId @1 :AnyPointer;
cannam@132: }
cannam@132: 
cannam@132: struct TestSturdyRefHostId {
cannam@132:   host @0 :Text;
cannam@132: }
cannam@132: 
cannam@132: struct TestSturdyRefObjectId {
cannam@132:   tag @0 :Tag;
cannam@132:   enum Tag {
cannam@132:     testInterface @0;
cannam@132:     testExtends @1;
cannam@132:     testPipeline @2;
cannam@132:     testTailCallee @3;
cannam@132:     testTailCaller @4;
cannam@132:     testMoreStuff @5;
cannam@132:   }
cannam@132: }
cannam@132: 
cannam@132: struct TestProvisionId {}
cannam@132: struct TestRecipientId {}
cannam@132: struct TestThirdPartyCapId {}
cannam@132: struct TestJoinResult {}
cannam@132: 
cannam@132: struct TestNameAnnotation $Cxx.name("RenamedStruct") {
cannam@132:   union {
cannam@132:     badFieldName @0 :Bool $Cxx.name("goodFieldName");
cannam@132:     bar @1 :Int8;
cannam@132:   }
cannam@132: 
cannam@132:   enum BadlyNamedEnum $Cxx.name("RenamedEnum") {
cannam@132:     foo @0;
cannam@132:     bar @1;
cannam@132:     baz @2 $Cxx.name("qux");
cannam@132:   }
cannam@132: 
cannam@132:   anotherBadFieldName @2 :BadlyNamedEnum $Cxx.name("anotherGoodFieldName");
cannam@132: 
cannam@132:   struct NestedStruct $Cxx.name("RenamedNestedStruct") {
cannam@132:     badNestedFieldName @0 :Bool $Cxx.name("goodNestedFieldName");
cannam@132:     anotherBadNestedFieldName @1 :NestedStruct $Cxx.name("anotherGoodNestedFieldName");
cannam@132: 
cannam@132:     enum DeeplyNestedEnum $Cxx.name("RenamedDeeplyNestedEnum") {
cannam@132:       quux @0;
cannam@132:       corge @1;
cannam@132:       grault @2 $Cxx.name("garply");
cannam@132:     }
cannam@132:   }
cannam@132: 
cannam@132:   badlyNamedUnion :union $Cxx.name("renamedUnion") {
cannam@132:     badlyNamedGroup :group $Cxx.name("renamedGroup") {
cannam@132:       foo @3 :Void;
cannam@132:       bar @4 :Void;
cannam@132:     }
cannam@132:     baz @5 :NestedStruct $Cxx.name("qux");
cannam@132:   }
cannam@132: }
cannam@132: 
cannam@132: interface TestNameAnnotationInterface $Cxx.name("RenamedInterface") {
cannam@132:   badlyNamedMethod @0 (badlyNamedParam :UInt8 $Cxx.name("renamedParam")) $Cxx.name("renamedMethod");
cannam@132: }