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}
244