1// Protocol Buffers for Go with Gadgets
2//
3// Copyright (c) 2015, The GoGo Authors. All rights reserved.
4// http://github.com/gogo/protobuf
5//
6// Redistribution and use in source and binary forms, with or without
7// modification, are permitted provided that the following conditions are
8// met:
9//
10// * Redistributions of source code must retain the above copyright
11// notice, this list of conditions and the following disclaimer.
12// * Redistributions in binary form must reproduce the above
13// copyright notice, this list of conditions and the following disclaimer
14// in the documentation and/or other materials provided with the
15// distribution.
16//
17// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
29package theproto3
30
31import (
32 "reflect"
33 "testing"
34
35 "github.com/gogo/protobuf/proto"
36)
37
38func TestNilMaps(t *testing.T) {
39 m := &AllMaps{StringToMsgMap: map[string]*FloatingPoint{"a": nil}}
40 data, err := proto.Marshal(m)
41 if err != nil {
42 t.Fatal(err)
43 }
44 size := m.Size()
45 protoSize := proto.Size(m)
46 marshaledSize := len(data)
47 if size != protoSize || marshaledSize != protoSize {
48 t.Errorf("size %d != protoSize %d != marshaledSize %d", size, protoSize, marshaledSize)
49 }
50 m2 := &AllMaps{}
51 if err := proto.Unmarshal(data, m2); err != nil {
52 t.Fatal(err)
53 }
54 if v, ok := m2.StringToMsgMap["a"]; !ok {
55 t.Error("element not in map")
56 } else if v != nil {
57 t.Errorf("element should be nil, but its %v", v)
58 }
59}
60
61func TestNilMapsBytes(t *testing.T) {
62 m := &AllMaps{StringToBytesMap: map[string][]byte{"a": nil}}
63 data, err := proto.Marshal(m)
64 if err != nil {
65 t.Fatal(err)
66 }
67 size := m.Size()
68 protoSize := proto.Size(m)
69 marshaledSize := len(data)
70 if size != protoSize || marshaledSize != protoSize {
71 t.Errorf("size %d != protoSize %d != marshaledSize %d", size, protoSize, marshaledSize)
72 }
73 m2 := &AllMaps{}
74 if err := proto.Unmarshal(data, m2); err != nil {
75 t.Fatal(err)
76 }
77 if v, ok := m2.StringToBytesMap["a"]; !ok {
78 t.Error("element not in map")
79 } else if len(v) != 0 {
80 t.Errorf("element should be empty, but its %v", v)
81 }
82}
83
84func TestEmptyMapsBytes(t *testing.T) {
85 m := &AllMaps{StringToBytesMap: map[string][]byte{"b": {}}}
86 data, err := proto.Marshal(m)
87 if err != nil {
88 t.Fatal(err)
89 }
90 size := m.Size()
91 protoSize := proto.Size(m)
92 marshaledSize := len(data)
93 if size != protoSize || marshaledSize != protoSize {
94 t.Errorf("size %d != protoSize %d != marshaledSize %d", size, protoSize, marshaledSize)
95 }
96 m2 := &AllMaps{}
97 if err := proto.Unmarshal(data, m2); err != nil {
98 t.Fatal(err)
99 }
100 if v, ok := m2.StringToBytesMap["b"]; !ok {
101 t.Error("element not in map")
102 } else if len(v) != 0 {
103 t.Errorf("element should be empty, but its %v", v)
104 }
105}
106
107func TestCustomTypeSize(t *testing.T) {
108 m := &Uint128Pair{}
109 m.Size() // Should not panic.
110}
111
112func TestCustomTypeMarshalUnmarshal(t *testing.T) {
113 m1 := &Uint128Pair{}
114 if b, err := proto.Marshal(m1); err != nil {
115 t.Fatal(err)
116 } else {
117 m2 := &Uint128Pair{}
118 if err := proto.Unmarshal(b, m2); err != nil {
119 t.Fatal(err)
120 }
121 if !m1.Equal(m2) {
122 t.Errorf("expected %+v, got %+v", m1, m2)
123 }
124 }
125}
126
127func TestNotPackedToPacked(t *testing.T) {
128 input := []uint64{1, 10e9}
129 notpacked := &NotPacked{Key: input}
130 if data, err := proto.Marshal(notpacked); err != nil {
131 t.Fatal(err)
132 } else {
133 packed := &Message{}
134 if err := proto.Unmarshal(data, packed); err != nil {
135 t.Fatal(err)
136 }
137 output := packed.Key
138 if !reflect.DeepEqual(input, output) {
139 t.Fatalf("expected %#v, got %#v", input, output)
140 }
141 }
142}
143
144func TestPackedToNotPacked(t *testing.T) {
145 input := []uint64{1, 10e9}
146 packed := &Message{Key: input}
147 if data, err := proto.Marshal(packed); err != nil {
148 t.Fatal(err)
149 } else {
150 notpacked := &NotPacked{}
151 if err := proto.Unmarshal(data, notpacked); err != nil {
152 t.Fatal(err)
153 }
154 output := notpacked.Key
155 if !reflect.DeepEqual(input, output) {
156 t.Fatalf("expected %#v, got %#v", input, output)
157 }
158 }
159}
View as plain text