mirror of
https://github.com/flutter/flutter.git
synced 2026-02-20 02:29:02 +08:00
197 lines
6.9 KiB
Go
197 lines
6.9 KiB
Go
// Copyright 2015 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
package tests
|
|
|
|
import (
|
|
"reflect"
|
|
"testing"
|
|
|
|
"mojo/public/go/bindings"
|
|
"mojo/public/go/system"
|
|
"mojo/public/interfaces/bindings/tests/rect"
|
|
test "mojo/public/interfaces/bindings/tests/serialization_test_structs"
|
|
"mojo/public/interfaces/bindings/tests/test_structs"
|
|
)
|
|
|
|
func check(t *testing.T, value, zeroValue bindings.Payload) {
|
|
message, err := bindings.EncodeMessage(bindings.MessageHeader{}, value)
|
|
if err != nil {
|
|
t.Fatalf("error encoding value %v: %v", value, err)
|
|
}
|
|
decodedMessage, err := bindings.ParseMessage(message.Bytes, message.Handles)
|
|
if err != nil {
|
|
t.Fatalf("error decoding message header from bytes %v for tested value %v: %v", message.Bytes, value, err)
|
|
}
|
|
if err = decodedMessage.DecodePayload(zeroValue); err != nil {
|
|
t.Fatalf("error decoding message payload from bytes %v for tested value %v: %v", message.Payload, value, err)
|
|
}
|
|
if !reflect.DeepEqual(value, zeroValue) {
|
|
t.Fatalf("unexpected value after decoding: expected %v, got %v", value, zeroValue)
|
|
}
|
|
}
|
|
|
|
func TestSerializationTestStructs(t *testing.T) {
|
|
check(t, &test.Struct1{1}, &test.Struct1{})
|
|
check(t, &test.Struct2{&mockHandle{handle: 1}}, &test.Struct2{})
|
|
check(t, &test.Struct3{test.Struct1{2}}, &test.Struct3{})
|
|
check(t, &test.Struct4{[]test.Struct1{test.Struct1{1}, test.Struct1{2}}}, &test.Struct4{})
|
|
check(t, &test.Struct5{[2]test.Struct1{test.Struct1{1}, test.Struct1{2}}}, &test.Struct5{})
|
|
check(t, &test.Struct6{"hello, world!"}, &test.Struct6{})
|
|
|
|
check(t, &test.StructOfNullables{nil, nil, nil}, &test.StructOfNullables{})
|
|
handle := system.Handle(&mockHandle{handle: 1})
|
|
s := "hello, world"
|
|
check(t, &test.StructOfNullables{&handle, nil, nil}, &test.StructOfNullables{})
|
|
check(t, &test.StructOfNullables{&handle, &test.Struct1{3}, nil}, &test.StructOfNullables{})
|
|
check(t, &test.StructOfNullables{&handle, &test.Struct1{3}, &s}, &test.StructOfNullables{})
|
|
check(t, &test.StructOfNullables{&handle, nil, &s}, &test.StructOfNullables{})
|
|
}
|
|
|
|
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{})
|
|
}
|