1// Protocol Buffers for Go with Gadgets
2//
3// Copyright (c) 2016, 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 types
30
31import (
32 "testing"
33 "time"
34 math_rand "math/rand"
35
36 "github.com/gogo/protobuf/proto"
37 "github.com/gogo/protobuf/jsonpb"
38)
39
40func TestFullCircleProtoToStd(t *testing.T) {
41 seed := time.Now().UnixNano()
42 popr := math_rand.New(math_rand.NewSource(seed))
43 protoMsg := NewPopulatedProtoTypes(popr, true)
44 protoData, err := proto.Marshal(protoMsg)
45 if err != nil {
46 t.Fatal(err)
47 }
48 stdMsg := &StdTypes{}
49 if err2 := proto.Unmarshal(protoData, stdMsg); err2 != nil {
50 t.Fatal(err)
51 }
52 stdData, err := proto.Marshal(stdMsg)
53 if err != nil {
54 t.Fatal(err)
55 }
56 protoMsgOut := &ProtoTypes{}
57 if err3 := proto.Unmarshal(stdData, protoMsgOut); err3 != nil {
58 t.Fatal(err)
59 }
60 if !protoMsg.Equal(protoMsgOut) {
61 t.Fatalf("want %#v got %#v", protoMsg, protoMsgOut)
62 }
63}
64
65func TestJsonFullCircleProtoToStd(t *testing.T) {
66 seed := time.Now().UnixNano()
67 popr := math_rand.New(math_rand.NewSource(seed))
68 protoMsg := NewPopulatedProtoTypes(popr, true)
69 j := &jsonpb.Marshaler{}
70 protoData, err := j.MarshalToString(protoMsg)
71 if err != nil {
72 t.Fatal(err)
73 }
74 stdMsg := &StdTypes{}
75 if err2 := jsonpb.UnmarshalString(protoData, stdMsg); err2 != nil {
76 t.Fatal(err)
77 }
78 stdData, err := j.MarshalToString(stdMsg)
79 if err != nil {
80 t.Fatal(err)
81 }
82 protoMsgOut := &ProtoTypes{}
83 if err3 := jsonpb.UnmarshalString(stdData, protoMsgOut); err3 != nil {
84 t.Fatal(err)
85 }
86 if !protoMsg.Equal(protoMsgOut) {
87 t.Fatalf("want %#v got %#v", protoMsg, protoMsgOut)
88 }
89}
90
91func TestFullCircleRepProtoToStd(t *testing.T) {
92 seed := time.Now().UnixNano()
93 popr := math_rand.New(math_rand.NewSource(seed))
94 protoMsg := NewPopulatedRepProtoTypes(popr, true)
95 protoData, err := proto.Marshal(protoMsg)
96 if err != nil {
97 t.Fatal(err)
98 }
99 stdMsg := &RepStdTypes{}
100 if err2 := proto.Unmarshal(protoData, stdMsg); err2 != nil {
101 t.Fatal(err)
102 }
103 stdData, err := proto.Marshal(stdMsg)
104 if err != nil {
105 t.Fatal(err)
106 }
107 protoMsgOut := &RepProtoTypes{}
108 if err3 := proto.Unmarshal(stdData, protoMsgOut); err3 != nil {
109 t.Fatal(err)
110 }
111 if !protoMsg.Equal(protoMsgOut) {
112 t.Fatalf("want %#v got %#v", protoMsg, protoMsgOut)
113 }
114}
115
116func TestJsonFullCircleRepProtoToStd(t *testing.T) {
117 seed := time.Now().UnixNano()
118 popr := math_rand.New(math_rand.NewSource(seed))
119 protoMsg := NewPopulatedRepProtoTypes(popr, true)
120 j := &jsonpb.Marshaler{}
121 protoData, err := j.MarshalToString(protoMsg)
122 if err != nil {
123 t.Fatal(err)
124 }
125 stdMsg := &RepStdTypes{}
126 if err2 := jsonpb.UnmarshalString(protoData, stdMsg); err2 != nil {
127 t.Fatal(err)
128 }
129 stdData, err := j.MarshalToString(stdMsg)
130 if err != nil {
131 t.Fatal(err)
132 }
133 protoMsgOut := &RepProtoTypes{}
134 if err3 := jsonpb.UnmarshalString(stdData, protoMsgOut); err3 != nil {
135 t.Fatal(err)
136 }
137 if !protoMsg.Equal(protoMsgOut) {
138 t.Fatalf("want %#v got %#v", protoMsg, protoMsgOut)
139 }
140}
141
142
143func TestFullCircleMapProtoToStd(t *testing.T) {
144 seed := time.Now().UnixNano()
145 popr := math_rand.New(math_rand.NewSource(seed))
146 protoMsg := NewPopulatedMapProtoTypes(popr, true)
147 protoData, err := proto.Marshal(protoMsg)
148 if err != nil {
149 t.Fatal(err)
150 }
151 stdMsg := &MapStdTypes{}
152 if err2 := proto.Unmarshal(protoData, stdMsg); err2 != nil {
153 t.Fatal(err)
154 }
155 stdData, err := proto.Marshal(stdMsg)
156 if err != nil {
157 t.Fatal(err)
158 }
159 protoMsgOut := &MapProtoTypes{}
160 if err3 := proto.Unmarshal(stdData, protoMsgOut); err3 != nil {
161 t.Fatal(err)
162 }
163 if !protoMsg.Equal(protoMsgOut) {
164 t.Fatalf("want %#v got %#v", protoMsg, protoMsgOut)
165 }
166}
167
168func TestJsonFullCircleMapProtoToStd(t *testing.T) {
169 seed := time.Now().UnixNano()
170 popr := math_rand.New(math_rand.NewSource(seed))
171 protoMsg := NewPopulatedMapProtoTypes(popr, true)
172 j := &jsonpb.Marshaler{}
173 protoData, err := j.MarshalToString(protoMsg)
174 if err != nil {
175 t.Fatal(err)
176 }
177 stdMsg := &MapStdTypes{}
178 if err2 := jsonpb.UnmarshalString(protoData, stdMsg); err2 != nil {
179 t.Fatal(err)
180 }
181 stdData, err := j.MarshalToString(stdMsg)
182 if err != nil {
183 t.Fatal(err)
184 }
185 protoMsgOut := &MapProtoTypes{}
186 if err3 := jsonpb.UnmarshalString(stdData, protoMsgOut); err3 != nil {
187 t.Fatal(err)
188 }
189 if !protoMsg.Equal(protoMsgOut) {
190 t.Fatalf("want %#v got %#v", protoMsg, protoMsgOut)
191 }
192}
193
194func TestFullCircleOneofProtoToStd(t *testing.T) {
195 seed := time.Now().UnixNano()
196 popr := math_rand.New(math_rand.NewSource(seed))
197 protoMsg := NewPopulatedOneofProtoTypes(popr, true)
198 protoData, err := proto.Marshal(protoMsg)
199 if err != nil {
200 t.Fatal(err)
201 }
202 stdMsg := &OneofStdTypes{}
203 if err2 := proto.Unmarshal(protoData, stdMsg); err2 != nil {
204 t.Fatal(err)
205 }
206 stdData, err := proto.Marshal(stdMsg)
207 if err != nil {
208 t.Fatal(err)
209 }
210 protoMsgOut := &OneofProtoTypes{}
211 if err3 := proto.Unmarshal(stdData, protoMsgOut); err3 != nil {
212 t.Fatal(err)
213 }
214 if !protoMsg.Equal(protoMsgOut) {
215 t.Fatalf("want %#v got %#v", protoMsg, protoMsgOut)
216 }
217}
218
219func TestJsonFullCircleOneofProtoToStd(t *testing.T) {
220 seed := time.Now().UnixNano()
221 popr := math_rand.New(math_rand.NewSource(seed))
222 protoMsg := NewPopulatedOneofProtoTypes(popr, true)
223 j := &jsonpb.Marshaler{}
224 protoData, err := j.MarshalToString(protoMsg)
225 if err != nil {
226 t.Fatal(err)
227 }
228 stdMsg := &OneofStdTypes{}
229 if err2 := jsonpb.UnmarshalString(protoData, stdMsg); err2 != nil {
230 t.Fatal(err)
231 }
232 stdData, err := j.MarshalToString(stdMsg)
233 if err != nil {
234 t.Fatal(err)
235 }
236 protoMsgOut := &OneofProtoTypes{}
237 if err3 := jsonpb.UnmarshalString(stdData, protoMsgOut); err3 != nil {
238 t.Fatal(err)
239 }
240 if !protoMsg.Equal(protoMsgOut) {
241 t.Fatalf("want %#v got %#v", protoMsg, protoMsgOut)
242 }
243}
View as plain text