View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.juneau.a.rttests;
18  
19  import static org.apache.juneau.common.utils.Utils.*;
20  import static org.junit.jupiter.api.Assertions.*;
21  
22  import java.util.*;
23  
24  import org.junit.jupiter.params.*;
25  import org.junit.jupiter.params.provider.*;
26  
27  /**
28   * Tests designed to serialize and parse objects to make sure we end up
29   * with the same objects for all serializers and parsers.
30   */
31  class PrimitivesBeans_RoundTripTest extends RoundTripTest_Base {
32  
33  	//====================================================================================================
34  	// testPrimitivesBean
35  	//====================================================================================================
36  
37  	@ParameterizedTest
38  	@MethodSource("testers")
39  	void a01_primitivesBean(RoundTrip_Tester t) throws Exception {
40  		var x = new PrimitivesBean().init();
41  		x = t.roundTrip(x, PrimitivesBean.class);
42  
43  		// primitives
44  		assertEquals(true, x.pBoolean);
45  		assertEquals(1, x.pByte);
46  		assertEquals('a', x.pChar);
47  		assertEquals(2, x.pShort);
48  		assertEquals(3, x.pInt);
49  		assertEquals(4L, x.pLong);
50  		assertEquals(5f, x.pFloat, 0.1f);
51  		assertEquals(6d, x.pDouble, 0.1f);
52  
53  		// uninitialized primitives
54  		assertEquals(false, x.puBoolean);
55  		assertEquals(0, x.puByte);
56  		assertEquals((char)0, x.puChar);
57  		assertEquals(0, x.puShort);
58  		assertEquals(0, x.puInt);
59  		assertEquals(0L, x.puLong);
60  		assertEquals(0f, x.puFloat, 0.1f);
61  		assertEquals(0d, x.puDouble, 0.1f);
62  
63  		// primitive arrays
64  		assertEquals(false, x.paBoolean[1][0]);
65  		assertEquals(2, x.paByte[1][0]);
66  		assertEquals('b', x.paChar[1][0]);
67  		assertEquals(2, x.paShort[1][0]);
68  		assertEquals(2, x.paInt[1][0]);
69  		assertEquals(2L, x.paLong[1][0]);
70  		assertEquals(2f, x.paFloat[1][0], 0.1f);
71  		assertEquals(2d, x.paDouble[1][0], 0.1f);
72  		assertNull(x.paBoolean[2]);
73  		assertNull(x.paByte[2]);
74  		assertNull(x.paChar[2]);
75  		assertNull(x.paShort[2]);
76  		assertNull(x.paInt[2]);
77  		assertNull(x.paLong[2]);
78  		assertNull(x.paFloat[2]);
79  		assertNull(x.paDouble[2]);
80  
81  		// uninitialized primitive arrays
82  		assertNull(x.pauBoolean);
83  		assertNull(x.pauByte);
84  		assertNull(x.pauChar);
85  		assertNull(x.pauShort);
86  		assertNull(x.pauInt);
87  		assertNull(x.pauLong);
88  		assertNull(x.pauFloat);
89  		assertNull(x.pauDouble);
90  
91  		// anonymous list of primitive arrays
92  		assertEquals(true, x.palBoolean.get(0)[0]);
93  		assertEquals(1, x.palByte.get(0)[0]);
94  		assertEquals('a', x.palChar.get(0)[0]);
95  		assertEquals(1, x.palShort.get(0)[0]);
96  		assertEquals(1, x.palInt.get(0)[0]);
97  		assertEquals(1L, x.palLong.get(0)[0]);
98  		assertEquals(1f, x.palFloat.get(0)[0], 0.1f);
99  		assertEquals(1d, x.palDouble.get(0)[0], 0.1f);
100 		assertNull(x.palBoolean.get(1));
101 		assertNull(x.palByte.get(1));
102 		assertNull(x.palChar.get(1));
103 		assertNull(x.palShort.get(1));
104 		assertNull(x.palInt.get(1));
105 		assertNull(x.palLong.get(1));
106 		assertNull(x.palFloat.get(1));
107 		assertNull(x.palDouble.get(1));
108 
109 		// regular list of primitive arrays
110 		assertEquals(true, x.plBoolean.get(0)[0]);
111 		assertEquals(1, x.plByte.get(0)[0]);
112 		assertEquals('a', x.plChar.get(0)[0]);
113 		assertEquals(1, x.plShort.get(0)[0]);
114 		assertEquals(1, x.plInt.get(0)[0]);
115 		assertEquals(1L, x.plLong.get(0)[0]);
116 		assertEquals(1f, x.plFloat.get(0)[0], 0.1f);
117 		assertEquals(1d, x.plDouble.get(0)[0], 0.1f);
118 		assertNull(x.plBoolean.get(1));
119 		assertNull(x.plByte.get(1));
120 		assertNull(x.plChar.get(1));
121 		assertNull(x.plShort.get(1));
122 		assertNull(x.plInt.get(1));
123 		assertNull(x.plLong.get(1));
124 		assertNull(x.plFloat.get(1));
125 		assertNull(x.plDouble.get(1));
126 	}
127 
128 	public static class PrimitivesBean {
129 
130 		// primitives
131 		public boolean pBoolean;
132 		public byte pByte;
133 		public char pChar;
134 		public short pShort;
135 		public int pInt;
136 		public long pLong;
137 		public float pFloat;
138 		public double pDouble;
139 
140 		// uninitialized primitives
141 		public boolean puBoolean;
142 		public byte puByte;
143 		public char puChar;
144 		public short puShort;
145 		public int puInt;
146 		public long puLong;
147 		public float puFloat;
148 		public double puDouble;
149 
150 		// primitive arrays
151 		public boolean[][] paBoolean;
152 		public byte[][] paByte;
153 		public char[][] paChar;
154 		public short[][] paShort;
155 		public int[][] paInt;
156 		public long[][] paLong;
157 		public float[][] paFloat;
158 		public double[][] paDouble;
159 
160 		// uninitialized primitive arrays
161 		public boolean[][] pauBoolean;
162 		public byte[][] pauByte;
163 		public char[][] pauChar;
164 		public short[][] pauShort;
165 		public int[][] pauInt;
166 		public long[][] pauLong;
167 		public float[][] pauFloat;
168 		public double[][] pauDouble;
169 
170 		// Regular lists of primitives
171 		public List<boolean[]> plBoolean;
172 		public List<byte[]> plByte;
173 		public List<char[]> plChar;
174 		public List<short[]> plShort;
175 		public List<int[]> plInt;
176 		public List<long[]> plLong;
177 		public List<float[]> plFloat;
178 		public List<double[]> plDouble;
179 
180 		// Anonymous list of primitives
181 		public List<boolean[]> palBoolean;
182 		public List<byte[]> palByte;
183 		public List<char[]> palChar;
184 		public List<short[]> palShort;
185 		public List<int[]> palInt;
186 		public List<long[]> palLong;
187 		public List<float[]> palFloat;
188 		public List<double[]> palDouble;
189 
190 		public PrimitivesBean init() {
191 			// primitives
192 			pBoolean = true;
193 			pByte = 1;
194 			pChar = 'a';
195 			pShort = 2;
196 			pInt = 3;
197 			pLong = 4L;
198 			pFloat = 5f;
199 			pDouble = 6d;
200 
201 			// primitive arrays
202 			paBoolean = new boolean[][]{{true},{false},null};
203 			paByte = new byte[][]{{1},{2},null};
204 			paChar = new char[][]{{'a'},{'b'},null};
205 			paShort = new short[][]{{1},{2},null};
206 			paInt = new int[][]{{1},{2},null};
207 			paLong = new long[][]{{1},{2},null};
208 			paFloat = new float[][]{{1},{2},null};
209 			paDouble = new double[][]{{1},{2},null};
210 
211 			// Regular lists of primitives
212 			plBoolean = alist(new boolean[]{true}, null);
213 			plByte = alist(new byte[]{1}, null);
214 			plChar = alist(new char[]{'a'}, null);
215 			plShort = alist(new short[]{1}, null);
216 			plInt = alist(new int[]{1}, null);
217 			plLong = alist(new long[]{1}, null);
218 			plFloat = alist(new float[]{1}, null);
219 			plDouble = alist(new double[]{1}, null);
220 
221 			// Anonymous list of primitives
222 			palBoolean = new ArrayList<>();
223 			palBoolean.add(new boolean[]{true});
224 			palBoolean.add(null);
225 			palByte = new ArrayList<>();
226 			palByte.add(new byte[]{1});
227 			palByte.add(null);
228 			palChar = new ArrayList<>();
229 			palChar.add(new char[]{'a'});
230 			palChar.add(null);
231 			palShort = new ArrayList<>();
232 			palShort.add(new short[]{1});
233 			palShort.add(null);
234 			palInt = new ArrayList<>();
235 			palInt.add(new int[]{1});
236 			palInt.add(null);
237 			palLong = new ArrayList<>();
238 			palLong.add(new long[]{1});
239 			palLong.add(null);
240 			palFloat = new ArrayList<>();
241 			palFloat.add(new float[]{1});
242 			palFloat.add(null);
243 			palDouble = new ArrayList<>();
244 			palDouble.add(new double[]{1});
245 			palDouble.add(null);
246 			return this;
247 		}
248 	}
249 
250 	//====================================================================================================
251 	// List of PrimitivesBean
252 	//====================================================================================================
253 
254 	@ParameterizedTest
255 	@MethodSource("testers")
256 	void a02_primitivesBeanList(RoundTrip_Tester t) throws Exception {
257 		var x = alist(new PrimitivesBean().init(), null, new PrimitivesBean().init());
258 		if (t.getParser() == null)
259 			return;
260 		x = t.roundTrip(x, List.class, PrimitivesBean.class);
261 
262 		var t2 = x.get(2);
263 
264 		// primitives
265 		assertEquals(true, t2.pBoolean);
266 		assertEquals(1, t2.pByte);
267 		assertEquals('a', t2.pChar);
268 		assertEquals(2, t2.pShort);
269 		assertEquals(3, t2.pInt);
270 		assertEquals(4L, t2.pLong);
271 		assertEquals(5f, t2.pFloat, 0.1f);
272 		assertEquals(6d, t2.pDouble, 0.1f);
273 
274 		// uninitialized primitives
275 		assertEquals(false, t2.puBoolean);
276 		assertEquals(0, t2.puByte);
277 		assertEquals((char)0, t2.puChar);
278 		assertEquals(0, t2.puShort);
279 		assertEquals(0, t2.puInt);
280 		assertEquals(0L, t2.puLong);
281 		assertEquals(0f, t2.puFloat, 0.1f);
282 		assertEquals(0d, t2.puDouble, 0.1f);
283 
284 		// primitive arrays
285 		assertEquals(false, t2.paBoolean[1][0]);
286 		assertEquals(2, t2.paByte[1][0]);
287 		assertEquals('b', t2.paChar[1][0]);
288 		assertEquals(2, t2.paShort[1][0]);
289 		assertEquals(2, t2.paInt[1][0]);
290 		assertEquals(2L, t2.paLong[1][0]);
291 		assertEquals(2f, t2.paFloat[1][0], 0.1f);
292 		assertEquals(2d, t2.paDouble[1][0], 0.1f);
293 		assertNull(t2.paBoolean[2]);
294 		assertNull(t2.paByte[2]);
295 		assertNull(t2.paChar[2]);
296 		assertNull(t2.paShort[2]);
297 		assertNull(t2.paInt[2]);
298 		assertNull(t2.paLong[2]);
299 		assertNull(t2.paFloat[2]);
300 		assertNull(t2.paDouble[2]);
301 
302 		// uninitialized primitive arrays
303 		assertNull(t2.pauBoolean);
304 		assertNull(t2.pauByte);
305 		assertNull(t2.pauChar);
306 		assertNull(t2.pauShort);
307 		assertNull(t2.pauInt);
308 		assertNull(t2.pauLong);
309 		assertNull(t2.pauFloat);
310 		assertNull(t2.pauDouble);
311 
312 		// anonymous list of primitive arrays
313 		assertEquals(true, t2.palBoolean.get(0)[0]);
314 		assertEquals(1, t2.palByte.get(0)[0]);
315 		assertEquals('a', t2.palChar.get(0)[0]);
316 		assertEquals(1, t2.palShort.get(0)[0]);
317 		assertEquals(1, t2.palInt.get(0)[0]);
318 		assertEquals(1L, t2.palLong.get(0)[0]);
319 		assertEquals(1f, t2.palFloat.get(0)[0], 0.1f);
320 		assertEquals(1d, t2.palDouble.get(0)[0], 0.1f);
321 		assertNull(t2.palBoolean.get(1));
322 		assertNull(t2.palByte.get(1));
323 		assertNull(t2.palChar.get(1));
324 		assertNull(t2.palShort.get(1));
325 		assertNull(t2.palInt.get(1));
326 		assertNull(t2.palLong.get(1));
327 		assertNull(t2.palFloat.get(1));
328 		assertNull(t2.palDouble.get(1));
329 
330 		// regular list of primitive arrays
331 		assertEquals(true, t2.plBoolean.get(0)[0]);
332 		assertEquals(1, t2.plByte.get(0)[0]);
333 		assertEquals('a', t2.plChar.get(0)[0]);
334 		assertEquals(1, t2.plShort.get(0)[0]);
335 		assertEquals(1, t2.plInt.get(0)[0]);
336 		assertEquals(1L, t2.plLong.get(0)[0]);
337 		assertEquals(1f, t2.plFloat.get(0)[0], 0.1f);
338 		assertEquals(1d, t2.plDouble.get(0)[0], 0.1f);
339 		assertNull(t2.plBoolean.get(1));
340 		assertNull(t2.plByte.get(1));
341 		assertNull(t2.plChar.get(1));
342 		assertNull(t2.plShort.get(1));
343 		assertNull(t2.plInt.get(1));
344 		assertNull(t2.plLong.get(1));
345 		assertNull(t2.plFloat.get(1));
346 		assertNull(t2.plDouble.get(1));
347 
348 		assertNull(x.get(1));
349 	}
350 }