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