func TestHandleUnion(t *testing.T) { tests := []test_unions.HandleUnion{ &test_unions.HandleUnionFHandle{system.Handle(&mockHandle{handle: 1})}, &test_unions.HandleUnionFMessagePipe{system.MessagePipeHandle(&mockHandle{handle: 2})}, &test_unions.HandleUnionFDataPipeConsumer{system.ConsumerHandle(&mockHandle{handle: 3})}, &test_unions.HandleUnionFDataPipeProducer{system.ProducerHandle(&mockHandle{handle: 4})}, &test_unions.HandleUnionFSharedBuffer{system.SharedBufferHandle(&mockHandle{handle: 5})}, } for _, union := range tests { var wrapper, zeroWrapper test_unions.WrapperStruct wrapper.HandleUnion = union check(t, &wrapper, &zeroWrapper) } }
func TestStructs(t *testing.T) { s1 := "hello, world!" s2 := "world, hello!" handle := system.Handle(&mockHandle{handle: 1}) messagePipeHandle := system.MessagePipeHandle(&mockHandle{handle: 2}) consumerHandle := system.ConsumerHandle(&mockHandle{handle: 3}) producerHandle := system.ProducerHandle(&mockHandle{handle: 4}) sharedBufferHandle := system.SharedBufferHandle(&mockHandle{handle: 5}) value := bindings.Payload(&test_structs.NoDefaultFieldValues{ F0: true, // bool F1: -2, // int8 F2: 3, // uint8 F3: -4000, // int16 F4: 5000, // uint16 F5: -6000000, // int32 F6: 7000000, // uint32 F7: -8000000000000, // int64 F8: 9000000000000, // uint64 F9: 1e-45, // float F10: -1e45, // double F11: s1, // string F12: &s2, // string? F13: messagePipeHandle, // handle<message_pipe> F14: consumerHandle, // handle<data_pipe_consumer> F15: producerHandle, // handle<data_pipe_producer> F16: &messagePipeHandle, // handle<message_pipe>? F17: &consumerHandle, // handle<data_pipe_consumer>? F18: &producerHandle, // handle<data_pipe_producer>? F19: handle, // handle F20: &handle, // handle? F21: sharedBufferHandle, // handle<shared_buffer> F22: &sharedBufferHandle, // handle<shared_buffer>? F23: []string{s1, s2}, // array<string> F24: []*string{&s1, &s2}, // array<string?> F25: &[]string{s1, s2}, // array<string>? F26: &[]*string{&s1, &s2}, // array<string?>? F27: test_structs.EmptyStruct{}, // EmptyStruct F28: &test_structs.EmptyStruct{}, // EmptyStruct? }) check(t, value, &test_structs.NoDefaultFieldValues{}) value = &test_structs.ScopedConstants{ test_structs.ScopedConstants_EType_E0, test_structs.ScopedConstants_EType_E1, test_structs.ScopedConstants_EType_E2, test_structs.ScopedConstants_EType_E3, test_structs.ScopedConstants_EType_E4, 10, 25, } check(t, value, &test_structs.ScopedConstants{}) value = &test_structs.MapKeyTypes{ F0: map[bool]bool{false: true, true: false}, F1: map[int8]int8{15: -45, -42: 50}, F2: map[uint8]uint8{15: 45, 42: 50}, F3: map[int16]int16{-15: 45, -42: 50}, F4: map[uint16]uint16{15: 45, 42: 50}, F5: map[int32]int32{15: -45, 42: 50}, F6: map[uint32]uint32{15: 45, 42: 50}, F7: map[int64]int64{15: 45, 42: -50}, F8: map[uint64]uint64{15: 45, 42: 50}, F9: map[float32]float32{1.5: 2.5, 3.5: 1e-9}, F10: map[float64]float64{1.5: 2.5, 3.5: 1e-9}, F11: map[string]string{s1: s2, s2: s1}, } check(t, value, &test_structs.MapKeyTypes{}) value = &test_structs.MapValueTypes{ F0: map[string][]string{ s1: []string{s1, s2}, s2: []string{s2, s1}, }, F1: map[string]*[]string{ s1: &[]string{s1, s2}, s2: &[]string{s2, s1}, }, F2: map[string][]*string{ s1: []*string{&s1, &s2}, s2: []*string{&s2, &s1}, }, F3: map[string][2]string{ s1: [2]string{s1, s2}, s2: [2]string{s2, s1}, }, F4: map[string][]*[2]string{ s1: []*[2]string{&[2]string{s1, s2}}, s2: []*[2]string{&[2]string{s1, s2}}, }, F5: map[string][1][2]string{ s1: [1][2]string{[2]string{s1, s2}}, s2: [1][2]string{[2]string{s1, s2}}, }, F6: map[string]*rect.Rect{ s1: &rect.Rect{}, s2: &rect.Rect{3, 4, 5, 6}, }, F7: map[string]map[string]string{ s1: map[string]string{s1: s1, s2: s2}, s2: map[string]string{s1: s2, s2: s1}, }, F8: map[string][]map[string]string{ s1: []map[string]string{ map[string]string{s1: s1, s2: s2}, map[string]string{s1: s2, s2: s1}, }, s2: []map[string]string{ map[string]string{s1: s1, s2: s2}, map[string]string{s1: s2, s2: s1}, }, }, F9: map[string]system.Handle{ s1: handle, s2: handle, }, F10: map[string][]system.Handle{ s1: []system.Handle{handle}, s2: []system.Handle{}, }, F11: map[string]map[string]system.Handle{ s1: map[string]system.Handle{s1: handle}, s2: map[string]system.Handle{s2: handle}, }, } check(t, value, &test_structs.MapValueTypes{}) value = &test_structs.BitArrayValues{ F0: [1]bool{true}, F1: [7]bool{true, false, true, false, true, false, true}, F2: [9]bool{true, true, true, false, false, false, true, true, true}, F3: []bool{true, false, true, false}, F4: [][]bool{[]bool{true}}, F5: []*[]bool{ &[]bool{true, false, true}, &[]bool{false, true}, }, F6: []*[2]bool{ &[2]bool{false, false}, &[2]bool{false, true}, &[2]bool{true, false}, &[2]bool{true, true}, }, } check(t, value, &test_structs.BitArrayValues{}) }