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.commons.lang3.builder;
18  
19  import static org.junit.jupiter.api.Assertions.assertEquals;
20  import static org.junit.jupiter.api.Assertions.assertNotNull;
21  import static org.junit.jupiter.api.Assertions.assertSame;
22  import static org.junit.jupiter.api.Assertions.assertThrows;
23  
24  import java.util.ArrayList;
25  import java.util.HashMap;
26  import java.util.List;
27  
28  import org.apache.commons.lang3.AbstractLangTest;
29  import org.junit.jupiter.api.Test;
30  
31  /**
32   * Unit tests for {@link org.apache.commons.lang3.builder.ToStringBuilder}.
33   */
34  public class ToStringBuilderTest extends AbstractLangTest {
35  
36      /**
37       * Test fixture for ReflectionToStringBuilder.toString() for statics.
38       */
39      @SuppressWarnings("unused")
40      final class InheritedReflectionStaticFieldsFixture extends SimpleReflectionStaticFieldsFixture {
41          static final String staticString2 = "staticString2";
42          static final int staticInt2 = 67890;
43      }
44      /**
45       * Points out failure to print anything from appendToString methods using MULTI_LINE_STYLE.
46       * See issue LANG-372.
47       */
48      final class MultiLineTestObject {
49          Integer i = Integer.valueOf(31337);
50          @Override
51          public String toString() {
52              return new ToStringBuilder(this).append("testInt", i).toString();
53          }
54      }
55      static class ObjectCycle {
56          Object obj;
57  
58          @Override
59          public String toString() {
60              return new ToStringBuilder(this).append(obj).toString();
61          }
62      }
63  
64      static class Outer {
65          final class Inner {
66              @Override
67              public String toString() {
68                  return ToStringBuilder.reflectionToString(this);
69              }
70          }
71          Inner inner = new Inner();
72          @Override
73          public String toString() {
74              return ToStringBuilder.reflectionToString(this);
75          }
76      }
77  
78      /**
79       * Tests ReflectionToStringBuilder.toString() for statics.
80       */
81      final class ReflectionStaticFieldsFixture {
82          static final String staticString = "staticString";
83          static final int staticInt = 12345;
84          static final transient String staticTransientString = "staticTransientString";
85          static final transient int staticTransientInt = 54321;
86          String instanceString = "instanceString";
87          int instanceInt = 67890;
88          transient String transientString = "transientString";
89          transient int transientInt = 98765;
90      }
91  
92      /**
93       * A reflection test fixture.
94       */
95      static class ReflectionTestCycleA {
96          ReflectionTestCycleB b;
97  
98          @Override
99          public String toString() {
100             return ToStringBuilder.reflectionToString(this);
101         }
102     }
103 
104     /**
105      * A reflection test fixture.
106      */
107     static class ReflectionTestCycleB {
108         ReflectionTestCycleA a;
109 
110         @Override
111         public String toString() {
112             return ToStringBuilder.reflectionToString(this);
113         }
114     }
115 
116     static class ReflectionTestFixtureA {
117         @SuppressWarnings("unused")
118         private final char a='a';
119         @SuppressWarnings("unused")
120         private final transient char transientA='t';
121     }
122 
123     static class ReflectionTestFixtureB extends ReflectionTestFixtureA {
124         @SuppressWarnings("unused")
125         private final char b='b';
126         @SuppressWarnings("unused")
127         private final transient char transientB='t';
128     }
129 
130     private static final class SelfInstanceTwoVarsReflectionTestFixture {
131         @SuppressWarnings("unused")
132         private final SelfInstanceTwoVarsReflectionTestFixture typeIsSelf;
133         private final String otherType = "The Other Type";
134 
135         SelfInstanceTwoVarsReflectionTestFixture() {
136             this.typeIsSelf = this;
137         }
138 
139         public String getOtherType() {
140             return this.otherType;
141         }
142 
143         @Override
144         public String toString() {
145             return ToStringBuilder.reflectionToString(this);
146         }
147       }
148 
149     private static final class SelfInstanceVarReflectionTestFixture {
150         @SuppressWarnings("unused")
151         private final SelfInstanceVarReflectionTestFixture typeIsSelf;
152 
153         SelfInstanceVarReflectionTestFixture() {
154             this.typeIsSelf = this;
155         }
156 
157         @Override
158         public String toString() {
159             return ToStringBuilder.reflectionToString(this);
160         }
161       }
162 
163     /**
164      * Test fixture for ReflectionToStringBuilder.toString() for statics.
165      */
166     class SimpleReflectionStaticFieldsFixture {
167         static final String staticString = "staticString";
168         static final int staticInt = 12345;
169     }
170 
171     /**
172      * A reflection test fixture.
173      */
174     static class SimpleReflectionTestFixture {
175         Object o;
176 
177         SimpleReflectionTestFixture() {
178         }
179 
180         SimpleReflectionTestFixture(final Object o) {
181             this.o = o;
182         }
183 
184         @Override
185         public String toString() {
186             return ToStringBuilder.reflectionToString(this);
187         }
188     }
189 
190     // Reflection Array tests
191 
192     //
193     // Note on the following line of code repeated in the reflection array tests.
194     //
195     // assertReflectionArray("<null>", array);
196     //
197     // The expected value is not baseStr + "[<null>]" since array==null and is typed as Object.
198     // The null array does not carry array type information.
199     // If we added a primitive array type constructor and pile of associated methods,
200     // then type declaring type information could be carried forward. IMHO, null is null.
201     //
202     // Gary Gregory - 2003-03-12 - ggregory@seagullsw.com
203     //
204 
205     // See LANG-1337 for more.
206     private static final int ARRAYLIST_INITIAL_CAPACITY = 10;
207 
208     private final Integer base = Integer.valueOf(5);
209 
210     private final String baseStr = base.getClass().getName() + "@" + Integer.toHexString(System.identityHashCode(base));
211 
212     public void assertReflectionArray(final String expected, final Object actual) {
213         if (actual == null) {
214             // Until ToStringBuilder supports null objects.
215             return;
216         }
217         assertEquals(expected, ToStringBuilder.reflectionToString(actual));
218         assertEquals(expected, ToStringBuilder.reflectionToString(actual, null));
219         assertEquals(expected, ToStringBuilder.reflectionToString(actual, null, true));
220         assertEquals(expected, ToStringBuilder.reflectionToString(actual, null, false));
221     }
222 
223     /**
224      * Tests ReflectionToStringBuilder setUpToClass().
225      */
226     @Test
227     public void test_setUpToClass_invalid() {
228         final Integer val = Integer.valueOf(5);
229         final ReflectionToStringBuilder test = new ReflectionToStringBuilder(val);
230         assertThrows(IllegalArgumentException.class, () -> test.setUpToClass(String.class));
231         test.toString();
232     }
233 
234     /**
235      * Tests ReflectionToStringBuilder setUpToClass().
236      */
237     @Test
238     public void test_setUpToClass_valid() {
239         final Integer val = Integer.valueOf(5);
240         final ReflectionToStringBuilder test = new ReflectionToStringBuilder(val);
241         test.setUpToClass(Number.class);
242         test.toString();
243     }
244 
245     @Test
246     public void testAppendAsObjectToString() {
247         final String objectToAppend1 = "";
248         final Boolean objectToAppend2 = Boolean.TRUE;
249         final Object objectToAppend3 = new Object();
250 
251         assertEquals(baseStr + "[" + toBaseString(objectToAppend1) + "]",
252                 new ToStringBuilder(base).appendAsObjectToString(objectToAppend1).toString());
253         assertEquals(baseStr + "[" + toBaseString(objectToAppend2) + "]",
254                 new ToStringBuilder(base).appendAsObjectToString(objectToAppend2).toString());
255         assertEquals(baseStr + "[" + toBaseString(objectToAppend3) + "]",
256                 new ToStringBuilder(base).appendAsObjectToString(objectToAppend3).toString());
257     }
258 
259     @Test
260     public void testAppendAsObjectToStringNullPointerException() {
261         ToStringBuilder builder = new ToStringBuilder(1);
262         assertThrows(NullPointerException.class, () -> builder.appendAsObjectToString(null));
263         builder.toString();
264     }
265 
266     @Test
267     public void testAppendBooleanArrayWithFieldName() {
268         final boolean[] array = { true, false, false };
269         assertEquals(baseStr + "[flags={true,false,false}]",
270                 new ToStringBuilder(base).append("flags", array).toString());
271         assertEquals(baseStr + "[flags=<null>]",
272                 new ToStringBuilder(base).append("flags", (boolean[]) null).toString());
273         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(null, (boolean[]) null).toString());
274         assertEquals(baseStr + "[{true,false,false}]", new ToStringBuilder(base).append(null, array).toString());
275     }
276 
277     @Test
278     public void testAppendBooleanArrayWithFieldNameAndFullDetatil() {
279         final boolean[] array = { true, false, false };
280         assertEquals(baseStr + "[flags={true,false,false}]",
281                 new ToStringBuilder(base).append("flags", array, true).toString());
282         assertEquals(baseStr + "[length=<size=3>]",
283                 new ToStringBuilder(base).append("length", array, false).toString());
284         assertEquals(baseStr + "[flags=<null>]",
285                 new ToStringBuilder(base).append("flags", (boolean[]) null, true).toString());
286         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(null, (boolean[]) null, false).toString());
287         assertEquals(baseStr + "[<size=3>]", new ToStringBuilder(base).append(null, array, false).toString());
288      }
289 
290     // Reflection Array Array tests
291 
292     @Test
293     public void testAppendByteArrayWithFieldName() {
294         final byte[] array = { 1, 2, -3, 4 };
295         assertEquals(baseStr + "[values={1,2,-3,4}]", new ToStringBuilder(base).append("values", array).toString());
296         assertEquals(baseStr + "[values=<null>]",
297                 new ToStringBuilder(base).append("values", (boolean[]) null).toString());
298         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(null, (boolean[]) null).toString());
299         assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(null, array).toString());
300     }
301 
302 
303     @Test
304     public void testAppendByteArrayWithFieldNameAndFullDetatil() {
305         final byte[] array = { 1, 2, -3, 4 };
306         assertEquals(baseStr + "[values={1,2,-3,4}]",
307                 new ToStringBuilder(base).append("values", array, true).toString());
308         assertEquals(baseStr + "[length=<size=4>]",
309                 new ToStringBuilder(base).append("length", array, false).toString());
310         assertEquals(baseStr + "[values=<null>]",
311                 new ToStringBuilder(base).append("values", (boolean[]) null, true).toString());
312         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(null, (boolean[]) null, false).toString());
313         assertEquals(baseStr + "[<size=4>]", new ToStringBuilder(base).append(null, array, false).toString());
314     }
315 
316     @Test
317     public void testAppendCharArrayWithFieldName() {
318         final char[] array = { 'A', '2', '_', 'D' };
319         assertEquals(baseStr + "[chars={A,2,_,D}]", new ToStringBuilder(base).append("chars", array).toString());
320         assertEquals(baseStr + "[letters={A,2,_,D}]", new ToStringBuilder(base).append("letters", array).toString());
321         assertEquals(baseStr + "[flags=<null>]",
322                 new ToStringBuilder(base).append("flags", (boolean[]) null).toString());
323         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(null, (boolean[]) null).toString());
324         assertEquals(baseStr + "[{A,2,_,D}]", new ToStringBuilder(base).append(null, array).toString());
325     }
326 
327     @Test
328     public void testAppendCharArrayWithFieldNameAndFullDetatil() {
329         final char[] array = { 'A', '2', '_', 'D' };
330         assertEquals(baseStr + "[chars={A,2,_,D}]", new ToStringBuilder(base).append("chars", array, true).toString());
331         assertEquals(baseStr + "[letters=<size=4>]",
332                 new ToStringBuilder(base).append("letters", array, false).toString());
333         assertEquals(baseStr + "[flags=<null>]",
334                 new ToStringBuilder(base).append("flags", (boolean[]) null, true).toString());
335         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(null, (boolean[]) null, false).toString());
336         assertEquals(baseStr + "[<size=4>]", new ToStringBuilder(base).append(null, array, false).toString());
337     }
338 
339     @Test
340     public void testAppendDoubleArrayWithFieldName() {
341         final double[] array = { 1.0, 2.9876, -3.00001, 4.3 };
342         assertEquals(baseStr + "[values={1.0,2.9876,-3.00001,4.3}]",
343                 new ToStringBuilder(base).append("values", array).toString());
344         assertEquals(baseStr + "[values=<null>]",
345                 new ToStringBuilder(base).append("values", (boolean[]) null).toString());
346         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(null, (boolean[]) null).toString());
347         assertEquals(baseStr + "[{1.0,2.9876,-3.00001,4.3}]", new ToStringBuilder(base).append(null, array).toString());
348     }
349 
350     @Test
351     public void testAppendDoubleArrayWithFieldNameAndFullDetatil() {
352         final double[] array = { 1.0, 2.9876, -3.00001, 4.3 };
353         assertEquals(baseStr + "[values={1.0,2.9876,-3.00001,4.3}]",
354                 new ToStringBuilder(base).append("values", array, true).toString());
355         assertEquals(baseStr + "[length=<size=4>]",
356                 new ToStringBuilder(base).append("length", array, false).toString());
357         assertEquals(baseStr + "[values=<null>]",
358                 new ToStringBuilder(base).append("values", (boolean[]) null, true).toString());
359         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(null, (boolean[]) null, false).toString());
360         assertEquals(baseStr + "[<size=4>]", new ToStringBuilder(base).append(null, array, false).toString());
361     }
362 
363     @Test
364     public void testAppendFloatArrayWithFieldName() {
365         final float[] array = { 1.0f, 2.9876f, -3.00001f, 4.3f };
366         assertEquals(baseStr + "[values={1.0,2.9876,-3.00001,4.3}]",
367                 new ToStringBuilder(base).append("values", array).toString());
368         assertEquals(baseStr + "[values=<null>]",
369                 new ToStringBuilder(base).append("values", (boolean[]) null).toString());
370         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(null, (boolean[]) null).toString());
371         assertEquals(baseStr + "[{1.0,2.9876,-3.00001,4.3}]", new ToStringBuilder(base).append(null, array).toString());
372     }
373 
374     @Test
375     public void testAppendFloatArrayWithFieldNameAndFullDetatil() {
376         final float[] array = { 1.0f, 2.9876f, -3.00001f, 4.3f };
377         assertEquals(baseStr + "[values={1.0,2.9876,-3.00001,4.3}]",
378                 new ToStringBuilder(base).append("values", array, true).toString());
379         assertEquals(baseStr + "[length=<size=4>]",
380                 new ToStringBuilder(base).append("length", array, false).toString());
381         assertEquals(baseStr + "[values=<null>]",
382                 new ToStringBuilder(base).append("values", (boolean[]) null, true).toString());
383         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(null, (boolean[]) null, false).toString());
384         assertEquals(baseStr + "[<size=4>]", new ToStringBuilder(base).append(null, array, false).toString());
385     }
386 
387     @Test
388     public void testAppendIntArrayWithFieldName() {
389         final int[] array = { 1, 2, -3, 4 };
390         assertEquals(baseStr + "[values={1,2,-3,4}]", new ToStringBuilder(base).append("values", array).toString());
391         assertEquals(baseStr + "[values=<null>]",
392                 new ToStringBuilder(base).append("values", (boolean[]) null).toString());
393         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(null, (boolean[]) null).toString());
394         assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(null, array).toString());
395     }
396 
397     @Test
398     public void testAppendIntArrayWithFieldNameAndFullDetatil() {
399         final int[] array = { 1, 2, -3, 4 };
400         assertEquals(baseStr + "[values={1,2,-3,4}]",
401                 new ToStringBuilder(base).append("values", array, true).toString());
402         assertEquals(baseStr + "[length=<size=4>]",
403                 new ToStringBuilder(base).append("length", array, false).toString());
404         assertEquals(baseStr + "[values=<null>]",
405                 new ToStringBuilder(base).append("values", (boolean[]) null, true).toString());
406         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(null, (boolean[]) null, false).toString());
407         assertEquals(baseStr + "[<size=4>]", new ToStringBuilder(base).append(null, array, false).toString());
408     }
409 
410     @Test
411     public void testAppendLongArrayWithFieldName() {
412        final long[] array = { 1, 2, -3, 4 };
413        assertEquals(baseStr + "[values={1,2,-3,4}]", new ToStringBuilder(base).append("values", array).toString());
414        assertEquals(baseStr + "[values=<null>]",
415                new ToStringBuilder(base).append("values", (boolean[]) null).toString());
416        assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(null, (boolean[]) null).toString());
417        assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(null, array).toString());
418     }
419 
420     @Test
421     public void testAppendLongArrayWithFieldNameAndFullDetatil() {
422         final long[] array = { 1, 2, -3, 4 };
423         assertEquals(baseStr + "[values={1,2,-3,4}]",
424                 new ToStringBuilder(base).append("values", array, true).toString());
425         assertEquals(baseStr + "[length=<size=4>]",
426                 new ToStringBuilder(base).append("length", array, false).toString());
427         assertEquals(baseStr + "[values=<null>]",
428                 new ToStringBuilder(base).append("values", (boolean[]) null, true).toString());
429         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(null, (boolean[]) null, false).toString());
430         assertEquals(baseStr + "[<size=4>]", new ToStringBuilder(base).append(null, array, false).toString());
431     }
432 
433     @Test
434     public void testAppendObjectArrayWithFieldName() {
435         final Object[] array = { null, base, new int[] { 3, 6 } };
436         assertEquals(baseStr + "[values={<null>,5,{3,6}}]",
437                 new ToStringBuilder(base).append("values", array).toString());
438         assertEquals(baseStr + "[values=<null>]",
439                 new ToStringBuilder(base).append("values", (boolean[]) null).toString());
440         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(null, (boolean[]) null).toString());
441         assertEquals(baseStr + "[{<null>,5,{3,6}}]", new ToStringBuilder(base).append(null, array).toString());
442     }
443 
444     @Test
445     public void testAppendObjectArrayWithFieldNameAndFullDetatil() {
446        final Object[] array = { null, base, new int[] { 3, 6 } };
447        assertEquals(baseStr + "[values={<null>,5,{3,6}}]",
448                new ToStringBuilder(base).append("values", array, true).toString());
449        assertEquals(baseStr + "[length=<size=3>]",
450                new ToStringBuilder(base).append("length", array, false).toString());
451        assertEquals(baseStr + "[values=<null>]",
452                new ToStringBuilder(base).append("values", (boolean[]) null, true).toString());
453        assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(null, (boolean[]) null, false).toString());
454        assertEquals(baseStr + "[<size=3>]", new ToStringBuilder(base).append(null, array, false).toString());
455     }
456 
457     // Reflection cycle tests
458 
459     @Test
460     public void testAppendShortArrayWithFieldName() {
461         final short[] array = { 1, 2, -3, 4 };
462         assertEquals(baseStr + "[values={1,2,-3,4}]", new ToStringBuilder(base).append("values", array).toString());
463         assertEquals(baseStr + "[values=<null>]",
464                 new ToStringBuilder(base).append("values", (boolean[]) null).toString());
465         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(null, (boolean[]) null).toString());
466         assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(null, array).toString());
467     }
468 
469     @Test
470     public void testAppendShortArrayWithFieldNameAndFullDetatil() {
471         final short[] array = { 1, 2, -3, 4 };
472         assertEquals(baseStr + "[values={1,2,-3,4}]",
473                 new ToStringBuilder(base).append("values", array, true).toString());
474         assertEquals(baseStr + "[length=<size=4>]",
475                 new ToStringBuilder(base).append("length", array, false).toString());
476         assertEquals(baseStr + "[values=<null>]",
477                 new ToStringBuilder(base).append("values", (boolean[]) null, true).toString());
478         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(null, (boolean[]) null, false).toString());
479         assertEquals(baseStr + "[<size=4>]", new ToStringBuilder(base).append(null, array, false).toString());
480     }
481 
482     @Test
483     public void testAppendSuper() {
484         assertEquals(baseStr + "[]", new ToStringBuilder(base).appendSuper("Integer@8888[]").toString());
485         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).appendSuper("Integer@8888[<null>]").toString());
486 
487         assertEquals(baseStr + "[a=hello]", new ToStringBuilder(base).appendSuper("Integer@8888[]").append("a", "hello").toString());
488         assertEquals(baseStr + "[<null>,a=hello]", new ToStringBuilder(base).appendSuper("Integer@8888[<null>]").append("a", "hello").toString());
489         assertEquals(baseStr + "[a=hello]", new ToStringBuilder(base).appendSuper(null).append("a", "hello").toString());
490     }
491 
492     @Test
493     public void testAppendToString() {
494         assertEquals(baseStr + "[]", new ToStringBuilder(base).appendToString("Integer@8888[]").toString());
495         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).appendToString("Integer@8888[<null>]").toString());
496 
497         assertEquals(baseStr + "[a=hello]", new ToStringBuilder(base).appendToString("Integer@8888[]").append("a", "hello").toString());
498         assertEquals(baseStr + "[<null>,a=hello]", new ToStringBuilder(base).appendToString("Integer@8888[<null>]").append("a", "hello").toString());
499         assertEquals(baseStr + "[a=hello]", new ToStringBuilder(base).appendToString(null).append("a", "hello").toString());
500     }
501 
502     @Test
503     public void testAppendToStringUsingMultiLineStyle() {
504         final MultiLineTestObject obj = new MultiLineTestObject();
505         final ToStringBuilder testBuilder = new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE)
506                                           .appendToString(obj.toString());
507         assertEquals(-1, testBuilder.toString().indexOf("testInt=31337"));
508     }
509 
510     @Test
511     public void testBlank() {
512         assertEquals(baseStr + "[]", new ToStringBuilder(base).toString());
513     }
514 
515     @Test
516     public void testBoolean() {
517         assertEquals(baseStr + "[true]", new ToStringBuilder(base).append(true).toString());
518         assertEquals(baseStr + "[a=true]", new ToStringBuilder(base).append("a", true).toString());
519         assertEquals(baseStr + "[a=true,b=false]", new ToStringBuilder(base).append("a", true).append("b", false).toString());
520     }
521 
522     @Test
523     public void testBooleanArray() {
524         boolean[] array = {true, false, false};
525         assertEquals(baseStr + "[{true,false,false}]", new ToStringBuilder(base).append(array).toString());
526         assertEquals(baseStr + "[{true,false,false}]", new ToStringBuilder(base).append((Object) array).toString());
527         array = null;
528         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(array).toString());
529         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append((Object) array).toString());
530     }
531 
532 
533     @Test
534     public void testBooleanArrayArray() {
535         boolean[][] array = {{true, false}, null, {false}};
536         assertEquals(baseStr + "[{{true,false},<null>,{false}}]", new ToStringBuilder(base).append(array).toString());
537         assertEquals(baseStr + "[{{true,false},<null>,{false}}]", new ToStringBuilder(base).append((Object) array).toString());
538         array = null;
539         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(array).toString());
540         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append((Object) array).toString());
541     }
542 
543     @Test
544     public void testByte() {
545         assertEquals(baseStr + "[3]", new ToStringBuilder(base).append((byte) 3).toString());
546         assertEquals(baseStr + "[a=3]", new ToStringBuilder(base).append("a", (byte) 3).toString());
547         assertEquals(baseStr + "[a=3,b=4]", new ToStringBuilder(base).append("a", (byte) 3).append("b", (byte) 4).toString());
548     }
549 
550     @Test
551     public void testByteArray() {
552         byte[] array = {1, 2, -3, 4};
553         assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString());
554         assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString());
555         array = null;
556         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(array).toString());
557         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append((Object) array).toString());
558     }
559 
560 
561     @Test
562     public void testByteArrayArray() {
563         byte[][] array = {{1, 2}, null, {5}};
564         assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append(array).toString());
565         assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append((Object) array).toString());
566         array = null;
567         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(array).toString());
568         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append((Object) array).toString());
569     }
570 
571     @Test
572     public void testChar() {
573         assertEquals(baseStr + "[A]", new ToStringBuilder(base).append((char) 65).toString());
574         assertEquals(baseStr + "[a=A]", new ToStringBuilder(base).append("a", (char) 65).toString());
575         assertEquals(baseStr + "[a=A,b=B]", new ToStringBuilder(base).append("a", (char) 65).append("b", (char) 66).toString());
576     }
577 
578     @Test
579     public void testCharArray() {
580         char[] array = {'A', '2', '_', 'D'};
581         assertEquals(baseStr + "[{A,2,_,D}]", new ToStringBuilder(base).append(array).toString());
582         assertEquals(baseStr + "[{A,2,_,D}]", new ToStringBuilder(base).append((Object) array).toString());
583         array = null;
584         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(array).toString());
585         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append((Object) array).toString());
586     }
587 
588     @Test
589     public void testCharArrayArray() {
590         char[][] array = {{'A', 'B'}, null, {'p'}};
591         assertEquals(baseStr + "[{{A,B},<null>,{p}}]", new ToStringBuilder(base).append(array).toString());
592         assertEquals(baseStr + "[{{A,B},<null>,{p}}]", new ToStringBuilder(base).append((Object) array).toString());
593         array = null;
594         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(array).toString());
595         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append((Object) array).toString());
596     }
597 
598     @Test
599     public void testConstructorEx1() {
600         assertEquals("<null>", new ToStringBuilder(null).toString());
601     }
602 
603     @Test
604     public void testConstructorEx2() {
605         assertEquals("<null>", new ToStringBuilder(null, null).toString());
606         new ToStringBuilder(this.base, null).toString();
607     }
608 
609     @Test
610     public void testConstructorEx3() {
611         assertEquals("<null>", new ToStringBuilder(null, null, null).toString());
612         new ToStringBuilder(this.base, null, null).toString();
613         new ToStringBuilder(this.base, ToStringStyle.DEFAULT_STYLE, null).toString();
614     }
615 
616     @Test
617     public void testConstructToStringBuilder() {
618         final ToStringBuilder stringBuilder1 = new ToStringBuilder(base, null, null);
619         final ToStringBuilder stringBuilder2 = new ToStringBuilder(base, ToStringStyle.DEFAULT_STYLE, new StringBuffer(1024));
620         assertEquals(ToStringStyle.DEFAULT_STYLE, stringBuilder1.getStyle());
621         assertNotNull(stringBuilder1.getStringBuffer());
622         assertNotNull(stringBuilder1.toString());
623         assertEquals(ToStringStyle.DEFAULT_STYLE, stringBuilder2.getStyle());
624         assertNotNull(stringBuilder2.getStringBuffer());
625         assertNotNull(stringBuilder2.toString());
626     }
627 
628     @Test
629     public void testDouble() {
630         assertEquals(baseStr + "[3.2]", new ToStringBuilder(base).append(3.2).toString());
631         assertEquals(baseStr + "[a=3.2]", new ToStringBuilder(base).append("a", 3.2).toString());
632         assertEquals(baseStr + "[a=3.2,b=4.3]", new ToStringBuilder(base).append("a", 3.2).append("b", 4.3).toString());
633     }
634 
635     @Test
636     public void testDoubleArray() {
637         double[] array = {1.0, 2.9876, -3.00001, 4.3};
638         assertEquals(baseStr + "[{1.0,2.9876,-3.00001,4.3}]", new ToStringBuilder(base).append(array).toString());
639         assertEquals(baseStr + "[{1.0,2.9876,-3.00001,4.3}]", new ToStringBuilder(base).append((Object) array).toString());
640         array = null;
641         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(array).toString());
642         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append((Object) array).toString());
643     }
644 
645     @Test
646     public void testDoubleArrayArray() {
647         double[][] array = {{1.0, 2.29686}, null, {Double.NaN}};
648         assertEquals(baseStr + "[{{1.0,2.29686},<null>,{NaN}}]", new ToStringBuilder(base).append(array).toString());
649         assertEquals(baseStr + "[{{1.0,2.29686},<null>,{NaN}}]", new ToStringBuilder(base).append((Object) array).toString());
650         array = null;
651         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(array).toString());
652         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append((Object) array).toString());
653     }
654 
655     @Test
656     public void testFloat() {
657         assertEquals(baseStr + "[3.2]", new ToStringBuilder(base).append((float) 3.2).toString());
658         assertEquals(baseStr + "[a=3.2]", new ToStringBuilder(base).append("a", (float) 3.2).toString());
659         assertEquals(baseStr + "[a=3.2,b=4.3]", new ToStringBuilder(base).append("a", (float) 3.2).append("b", (float) 4.3).toString());
660     }
661 
662     @Test
663     public void testFloatArray() {
664         float[] array = {1.0f, 2.9876f, -3.00001f, 4.3f};
665         assertEquals(baseStr + "[{1.0,2.9876,-3.00001,4.3}]", new ToStringBuilder(base).append(array).toString());
666         assertEquals(baseStr + "[{1.0,2.9876,-3.00001,4.3}]", new ToStringBuilder(base).append((Object) array).toString());
667         array = null;
668         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(array).toString());
669         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append((Object) array).toString());
670     }
671 
672     @Test
673     public void testFloatArrayArray() {
674         float[][] array = {{1.0f, 2.29686f}, null, {Float.NaN}};
675         assertEquals(baseStr + "[{{1.0,2.29686},<null>,{NaN}}]", new ToStringBuilder(base).append(array).toString());
676         assertEquals(baseStr + "[{{1.0,2.29686},<null>,{NaN}}]", new ToStringBuilder(base).append((Object) array).toString());
677         array = null;
678         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(array).toString());
679         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append((Object) array).toString());
680     }
681 
682     @Test
683     public void testGetSetDefault() {
684         try {
685             ToStringBuilder.setDefaultStyle(ToStringStyle.NO_FIELD_NAMES_STYLE);
686             assertSame(ToStringStyle.NO_FIELD_NAMES_STYLE, ToStringBuilder.getDefaultStyle());
687         } finally {
688             // reset for other tests
689             ToStringBuilder.setDefaultStyle(ToStringStyle.DEFAULT_STYLE);
690         }
691     }
692 
693     /**
694      * Tests ReflectionToStringBuilder.toString() for statics.
695      */
696     @Test
697     public void testInheritedReflectionStatics() {
698         final InheritedReflectionStaticFieldsFixture instance1 = new InheritedReflectionStaticFieldsFixture();
699         assertEquals(
700             this.toBaseString(instance1) + "[staticInt2=67890,staticString2=staticString2]",
701             ReflectionToStringBuilder.toString(instance1, null, false, true, InheritedReflectionStaticFieldsFixture.class));
702         assertEquals(
703             this.toBaseString(instance1) + "[staticInt2=67890,staticString2=staticString2,staticInt=12345,staticString=staticString]",
704             ReflectionToStringBuilder.toString(instance1, null, false, true, SimpleReflectionStaticFieldsFixture.class));
705         assertEquals(
706             this.toBaseString(instance1) + "[staticInt2=67890,staticString2=staticString2,staticInt=12345,staticString=staticString]",
707             this.toStringWithStatics(instance1, null, SimpleReflectionStaticFieldsFixture.class));
708         assertEquals(
709             this.toBaseString(instance1) + "[staticInt2=67890,staticString2=staticString2,staticInt=12345,staticString=staticString]",
710             this.toStringWithStatics(instance1, null, SimpleReflectionStaticFieldsFixture.class));
711     }
712 
713     @Test
714     public void testInnerClassReflection() {
715         final Outer outer = new Outer();
716         assertEquals(toBaseString(outer) + "[inner=" + toBaseString(outer.inner) + "[]]", outer.toString());
717     }
718 
719     @Test
720     public void testInt() {
721         assertEquals(baseStr + "[3]", new ToStringBuilder(base).append(3).toString());
722         assertEquals(baseStr + "[a=3]", new ToStringBuilder(base).append("a", 3).toString());
723         assertEquals(baseStr + "[a=3,b=4]", new ToStringBuilder(base).append("a", 3).append("b", 4).toString());
724     }
725 
726     @Test
727     public void testIntArray() {
728         int[] array = {1, 2, -3, 4};
729         assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString());
730         assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString());
731         array = null;
732         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(array).toString());
733         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append((Object) array).toString());
734     }
735 
736     @Test
737     public void testIntArrayArray() {
738         int[][] array = {{1, 2}, null, {5}};
739         assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append(array).toString());
740         assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append((Object) array).toString());
741         array = null;
742         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(array).toString());
743         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append((Object) array).toString());
744     }
745 
746     @Test
747     public void testLong() {
748         assertEquals(baseStr + "[3]", new ToStringBuilder(base).append(3L).toString());
749         assertEquals(baseStr + "[a=3]", new ToStringBuilder(base).append("a", 3L).toString());
750         assertEquals(baseStr + "[a=3,b=4]", new ToStringBuilder(base).append("a", 3L).append("b", 4L).toString());
751     }
752 
753     @Test
754     public void testLongArray() {
755         long[] array = {1, 2, -3, 4};
756         assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString());
757         assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString());
758         array = null;
759         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(array).toString());
760         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append((Object) array).toString());
761     }
762 
763     @Test
764     public void testLongArrayArray() {
765         long[][] array = {{1, 2}, null, {5}};
766         assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append(array).toString());
767         assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append((Object) array).toString());
768         array = null;
769         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(array).toString());
770         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append((Object) array).toString());
771     }
772 
773     @Test
774     public void testObject() {
775         final Integer i3 = Integer.valueOf(3);
776         final Integer i4 = Integer.valueOf(4);
777         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append((Object) null).toString());
778         assertEquals(baseStr + "[3]", new ToStringBuilder(base).append(i3).toString());
779         assertEquals(baseStr + "[a=<null>]", new ToStringBuilder(base).append("a", (Object) null).toString());
780         assertEquals(baseStr + "[a=3]", new ToStringBuilder(base).append("a", i3).toString());
781         assertEquals(baseStr + "[a=3,b=4]", new ToStringBuilder(base).append("a", i3).append("b", i4).toString());
782         assertEquals(baseStr + "[a=<Integer>]", new ToStringBuilder(base).append("a", i3, false).toString());
783         assertEquals(baseStr + "[a=<size=0>]", new ToStringBuilder(base).append("a", new ArrayList<>(), false).toString());
784         assertEquals(baseStr + "[a=[]]", new ToStringBuilder(base).append("a", new ArrayList<>(), true).toString());
785         assertEquals(baseStr + "[a=<size=0>]", new ToStringBuilder(base).append("a", new HashMap<>(), false).toString());
786         assertEquals(baseStr + "[a={}]", new ToStringBuilder(base).append("a", new HashMap<>(), true).toString());
787         assertEquals(baseStr + "[a=<size=0>]", new ToStringBuilder(base).append("a", (Object) new String[0], false).toString());
788         assertEquals(baseStr + "[a={}]", new ToStringBuilder(base).append("a", (Object) new String[0], true).toString());
789     }
790 
791     @Test
792     public void testObjectArray() {
793         Object[] array = {null, base, new int[] {3, 6}};
794         assertEquals(baseStr + "[{<null>,5,{3,6}}]", new ToStringBuilder(base).append(array).toString());
795         assertEquals(baseStr + "[{<null>,5,{3,6}}]", new ToStringBuilder(base).append((Object) array).toString());
796         array = null;
797         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(array).toString());
798         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append((Object) array).toString());
799     }
800 
801 
802     @Test
803     public void testObjectBuild() {
804         final Integer i3 = Integer.valueOf(3);
805         final Integer i4 = Integer.valueOf(4);
806         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append((Object) null).build());
807         assertEquals(baseStr + "[3]", new ToStringBuilder(base).append(i3).build());
808         assertEquals(baseStr + "[a=<null>]", new ToStringBuilder(base).append("a", (Object) null).build());
809         assertEquals(baseStr + "[a=3]", new ToStringBuilder(base).append("a", i3).build());
810         assertEquals(baseStr + "[a=3,b=4]", new ToStringBuilder(base).append("a", i3).append("b", i4).build());
811         assertEquals(baseStr + "[a=<Integer>]", new ToStringBuilder(base).append("a", i3, false).build());
812         assertEquals(baseStr + "[a=<size=0>]", new ToStringBuilder(base).append("a", new ArrayList<>(), false).build());
813         assertEquals(baseStr + "[a=[]]", new ToStringBuilder(base).append("a", new ArrayList<>(), true).build());
814         assertEquals(baseStr + "[a=<size=0>]", new ToStringBuilder(base).append("a", new HashMap<>(), false).build());
815         assertEquals(baseStr + "[a={}]", new ToStringBuilder(base).append("a", new HashMap<>(), true).build());
816         assertEquals(baseStr + "[a=<size=0>]", new ToStringBuilder(base).append("a", (Object) new String[0], false).build());
817         assertEquals(baseStr + "[a={}]", new ToStringBuilder(base).append("a", (Object) new String[0], true).build());
818     }
819 
820     @Test
821     public void testObjectCycle() {
822         final ObjectCycle a = new ObjectCycle();
823         final ObjectCycle b = new ObjectCycle();
824         a.obj = b;
825         b.obj = a;
826 
827         final String expected = toBaseString(a) + "[" + toBaseString(b) + "[" + toBaseString(a) + "]]";
828         assertEquals(expected, a.toString());
829     }
830 
831     /**
832      * Test a nasty combination of arrays and Objects pointing to each other.
833      * objects[0] -&gt; SimpleReflectionTestFixture[ o -&gt; objects ]
834      */
835     @Test
836     public void testReflectionArrayAndObjectCycle() {
837         final Object[] objects = new Object[1];
838         final SimpleReflectionTestFixture simple = new SimpleReflectionTestFixture(objects);
839         objects[0] = simple;
840         assertEquals(
841             this.toBaseString(objects)
842                 + "[{"
843                 + this.toBaseString(simple)
844                 + "[o="
845                 + this.toBaseString(objects)
846                 + "]"
847                 + "}]",
848             ToStringBuilder.reflectionToString(objects));
849         assertEquals(
850             this.toBaseString(simple)
851                 + "[o={"
852                 + this.toBaseString(simple)
853                 + "}]",
854             ToStringBuilder.reflectionToString(simple));
855     }
856 
857     @Test
858     public void testReflectionArrayArrayCycle() {
859         final Object[][] objects = new Object[2][2];
860         objects[0][0] = objects;
861         objects[0][1] = objects;
862         objects[1][0] = objects;
863         objects[1][1] = objects;
864         final String basicToString = this.toBaseString(objects);
865         assertEquals(
866             basicToString
867                 + "[{{"
868                 + basicToString
869                 + ","
870                 + basicToString
871                 + "},{"
872                 + basicToString
873                 + ","
874                 + basicToString
875                 + "}}]",
876             ToStringBuilder.reflectionToString(objects));
877     }
878 
879     /**
880      * Test an array element pointing to its container.
881      */
882     @Test
883     public void testReflectionArrayCycle() {
884         final Object[] objects = new Object[1];
885         objects[0] = objects;
886         assertEquals(
887             this.toBaseString(objects) + "[{" + this.toBaseString(objects) + "}]",
888             ToStringBuilder.reflectionToString(objects));
889     }
890 
891     /**
892      * Test an array element pointing to its container.
893      */
894     @Test
895     public void testReflectionArrayCycleLevel2() {
896         final Object[] objects = new Object[1];
897         final Object[] objectsLevel2 = new Object[1];
898         objects[0] = objectsLevel2;
899         objectsLevel2[0] = objects;
900         assertEquals(
901             this.toBaseString(objects) + "[{{" + this.toBaseString(objects) + "}}]",
902             ToStringBuilder.reflectionToString(objects));
903         assertEquals(
904             this.toBaseString(objectsLevel2) + "[{{" + this.toBaseString(objectsLevel2) + "}}]",
905             ToStringBuilder.reflectionToString(objectsLevel2));
906     }
907 
908     /**
909      * Test wrapper for char boolean.
910      */
911     @Test
912     public void testReflectionBoolean() {
913         Boolean b;
914         b = Boolean.TRUE;
915         assertEquals(this.toBaseString(b) + "[value=true]", ToStringBuilder.reflectionToString(b));
916         b = Boolean.FALSE;
917         assertEquals(this.toBaseString(b) + "[value=false]", ToStringBuilder.reflectionToString(b));
918     }
919 
920     @Test
921     public void testReflectionBooleanArray() {
922         boolean[] array = { true, false, false };
923         final String baseString = this.toBaseString(array);
924         assertEquals(baseString + "[{true,false,false}]", ToStringBuilder.reflectionToString(array));
925         array = null;
926         assertReflectionArray("<null>", array);
927     }
928 
929     @Test
930     public void testReflectionBooleanArrayArray() {
931         boolean[][] array = { { true, false }, null, { false } };
932         final String baseString = this.toBaseString(array);
933         assertEquals(baseString + "[{{true,false},<null>,{false}}]", ToStringBuilder.reflectionToString(array));
934         assertEquals(baseString + "[{{true,false},<null>,{false}}]", ToStringBuilder.reflectionToString(array));
935         array = null;
936         assertReflectionArray("<null>", array);
937     }
938 
939     @Test
940     public void testReflectionByteArrayArray() {
941         byte[][] array = { { 1, 2 }, null, { 5 } };
942         final String baseString = this.toBaseString(array);
943         assertEquals(baseString + "[{{1,2},<null>,{5}}]", ToStringBuilder.reflectionToString(array));
944         array = null;
945         assertReflectionArray("<null>", array);
946     }
947 
948 
949     /**
950      * Test wrapper for char primitive.
951      */
952     @Test
953     public void testReflectionCharacter() {
954         final Character c = 'A';
955         assertEquals(this.toBaseString(c) + "[value=A]", ToStringBuilder.reflectionToString(c));
956     }
957 
958     @Test
959     public void testReflectionCharArray() {
960         char[] array = { 'A', '2', '_', 'D' };
961         final String baseString = this.toBaseString(array);
962         assertEquals(baseString + "[{A,2,_,D}]", ToStringBuilder.reflectionToString(array));
963         array = null;
964         assertReflectionArray("<null>", array);
965     }
966 
967     @Test
968     public void testReflectionCharArrayArray() {
969         char[][] array = { { 'A', 'B' }, null, { 'p' } };
970         final String baseString = this.toBaseString(array);
971         assertEquals(baseString + "[{{A,B},<null>,{p}}]", ToStringBuilder.reflectionToString(array));
972         array = null;
973         assertReflectionArray("<null>", array);
974     }
975 
976     @Test
977     public void testReflectionDoubleArray() {
978         double[] array = { 1.0, 2.9876, -3.00001, 4.3 };
979         final String baseString = this.toBaseString(array);
980         assertEquals(baseString + "[{1.0,2.9876,-3.00001,4.3}]", ToStringBuilder.reflectionToString(array));
981         array = null;
982         assertReflectionArray("<null>", array);
983     }
984 
985     @Test
986     public void testReflectionDoubleArrayArray() {
987         double[][] array = { { 1.0, 2.29686 }, null, { Double.NaN } };
988         final String baseString = this.toBaseString(array);
989         assertEquals(baseString + "[{{1.0,2.29686},<null>,{NaN}}]", ToStringBuilder.reflectionToString(array));
990         array = null;
991         assertReflectionArray("<null>", array);
992     }
993 
994     @Test
995     public void testReflectionFloatArray() {
996         float[] array = { 1.0f, 2.9876f, -3.00001f, 4.3f };
997         final String baseString = this.toBaseString(array);
998         assertEquals(baseString + "[{1.0,2.9876,-3.00001,4.3}]", ToStringBuilder.reflectionToString(array));
999         array = null;
1000         assertReflectionArray("<null>", array);
1001     }
1002 
1003     @Test
1004     public void testReflectionFloatArrayArray() {
1005         float[][] array = { { 1.0f, 2.29686f }, null, { Float.NaN } };
1006         final String baseString = this.toBaseString(array);
1007         assertEquals(baseString + "[{{1.0,2.29686},<null>,{NaN}}]", ToStringBuilder.reflectionToString(array));
1008         array = null;
1009         assertReflectionArray("<null>", array);
1010     }
1011 
1012     @Test
1013     public void testReflectionHierarchy() {
1014         final ReflectionTestFixtureA baseA = new ReflectionTestFixtureA();
1015         String baseString = this.toBaseString(baseA);
1016         assertEquals(baseString + "[a=a]", ToStringBuilder.reflectionToString(baseA));
1017         assertEquals(baseString + "[a=a]", ToStringBuilder.reflectionToString(baseA, null));
1018         assertEquals(baseString + "[a=a]", ToStringBuilder.reflectionToString(baseA, null, false));
1019         assertEquals(baseString + "[a=a,transientA=t]", ToStringBuilder.reflectionToString(baseA, null, true));
1020         assertEquals(baseString + "[a=a]", ToStringBuilder.reflectionToString(baseA, null, false, null));
1021         assertEquals(baseString + "[a=a]", ToStringBuilder.reflectionToString(baseA, null, false, Object.class));
1022         assertEquals(baseString + "[a=a]", ToStringBuilder.reflectionToString(baseA, null, false, ReflectionTestFixtureA.class));
1023 
1024         final ReflectionTestFixtureB baseB = new ReflectionTestFixtureB();
1025         baseString = this.toBaseString(baseB);
1026         assertEquals(baseString + "[b=b,a=a]", ToStringBuilder.reflectionToString(baseB));
1027         assertEquals(baseString + "[b=b,a=a]", ToStringBuilder.reflectionToString(baseB));
1028         assertEquals(baseString + "[b=b,a=a]", ToStringBuilder.reflectionToString(baseB, null));
1029         assertEquals(baseString + "[b=b,a=a]", ToStringBuilder.reflectionToString(baseB, null, false));
1030         assertEquals(baseString + "[b=b,transientB=t,a=a,transientA=t]", ToStringBuilder.reflectionToString(baseB, null, true));
1031         assertEquals(baseString + "[b=b,a=a]", ToStringBuilder.reflectionToString(baseB, null, false, null));
1032         assertEquals(baseString + "[b=b,a=a]", ToStringBuilder.reflectionToString(baseB, null, false, Object.class));
1033         assertEquals(baseString + "[b=b,a=a]", ToStringBuilder.reflectionToString(baseB, null, false, ReflectionTestFixtureA.class));
1034         assertEquals(baseString + "[b=b]", ToStringBuilder.reflectionToString(baseB, null, false, ReflectionTestFixtureB.class));
1035     }
1036 
1037     // Reflection hierarchy tests
1038     @Test
1039     public void testReflectionHierarchyArrayList() {
1040         // LANG-1337 without this, the generated string can differ depending on the JVM version/vendor
1041         final List<Object> list = new ArrayList<>(ARRAYLIST_INITIAL_CAPACITY);
1042         final String baseString = this.toBaseString(list);
1043         final String expectedWithTransients = baseString + "[elementData={<null>,<null>,<null>,<null>,<null>,<null>,<null>,<null>,<null>,<null>},size=0,modCount=0]";
1044         final String toStringWithTransients = ToStringBuilder.reflectionToString(list, null, true);
1045         if (!expectedWithTransients.equals(toStringWithTransients)) {
1046             assertEquals(expectedWithTransients, toStringWithTransients);
1047         }
1048         final String expectedWithoutTransients = baseString + "[size=0]";
1049         final String toStringWithoutTransients = ToStringBuilder.reflectionToString(list, null, false);
1050         if (!expectedWithoutTransients.equals(toStringWithoutTransients)) {
1051             assertEquals(expectedWithoutTransients, toStringWithoutTransients);
1052         }
1053     }
1054 
1055     @Test
1056     public void testReflectionhortArrayArray() {
1057         short[][] array = { { 1, 2 }, null, { 5 } };
1058         final String baseString = this.toBaseString(array);
1059         assertEquals(baseString + "[{{1,2},<null>,{5}}]", ToStringBuilder.reflectionToString(array));
1060         array = null;
1061         assertReflectionArray("<null>", array);
1062     }
1063 
1064     @Test
1065     public void testReflectionIntArray() {
1066         int[] array = { 1, 2, -3, 4 };
1067         final String baseString = this.toBaseString(array);
1068         assertEquals(baseString + "[{1,2,-3,4}]", ToStringBuilder.reflectionToString(array));
1069         array = null;
1070         assertReflectionArray("<null>", array);
1071     }
1072 
1073     @Test
1074     public void testReflectionIntArrayArray() {
1075         int[][] array = { { 1, 2 }, null, { 5 } };
1076         final String baseString = this.toBaseString(array);
1077         assertEquals(baseString + "[{{1,2},<null>,{5}}]", ToStringBuilder.reflectionToString(array));
1078         array = null;
1079         assertReflectionArray("<null>", array);
1080     }
1081 
1082     /**
1083      * Test wrapper for int primitive.
1084      */
1085     @Test
1086     public void testReflectionInteger() {
1087         assertEquals(baseStr + "[value=5]", ToStringBuilder.reflectionToString(base));
1088     }
1089 
1090     @Test
1091     public void testReflectionLongArray() {
1092         long[] array = { 1, 2, -3, 4 };
1093         final String baseString = this.toBaseString(array);
1094         assertEquals(baseString + "[{1,2,-3,4}]", ToStringBuilder.reflectionToString(array));
1095         array = null;
1096         assertReflectionArray("<null>", array);
1097     }
1098 
1099     @Test
1100     public void testReflectionLongArrayArray() {
1101         long[][] array = { { 1, 2 }, null, { 5 } };
1102         final String baseString = this.toBaseString(array);
1103         assertEquals(baseString + "[{{1,2},<null>,{5}}]", ToStringBuilder.reflectionToString(array));
1104         array = null;
1105         assertReflectionArray("<null>", array);
1106     }
1107 
1108     @Test
1109     public void testReflectionNull() {
1110         assertEquals("<null>", ReflectionToStringBuilder.toString(null));
1111     }
1112 
1113     @Test
1114     public void testReflectionObjectArray() {
1115         Object[] array = { null, base, new int[] { 3, 6 } };
1116         final String baseString = this.toBaseString(array);
1117         assertEquals(baseString + "[{<null>,5,{3,6}}]", ToStringBuilder.reflectionToString(array));
1118         array = null;
1119         assertReflectionArray("<null>", array);
1120     }
1121 
1122     /**
1123      * Test Objects pointing to each other.
1124      */
1125     @Test
1126     public void testReflectionObjectCycle() {
1127         final ReflectionTestCycleA a = new ReflectionTestCycleA();
1128         final ReflectionTestCycleB b = new ReflectionTestCycleB();
1129         a.b = b;
1130         b.a = a;
1131         assertEquals(
1132             this.toBaseString(a) + "[b=" + this.toBaseString(b) + "[a=" + this.toBaseString(a) + "]]",
1133             a.toString());
1134     }
1135 
1136     @Test
1137     public void testReflectionShortArray() {
1138         short[] array = { 1, 2, -3, 4 };
1139         final String baseString = this.toBaseString(array);
1140         assertEquals(baseString + "[{1,2,-3,4}]", ToStringBuilder.reflectionToString(array));
1141         array = null;
1142         assertReflectionArray("<null>", array);
1143     }
1144 
1145     /**
1146      * Tests ReflectionToStringBuilder.toString() for statics.
1147      */
1148     @Test
1149     public void testReflectionStatics() {
1150         final ReflectionStaticFieldsFixture instance1 = new ReflectionStaticFieldsFixture();
1151         assertEquals(
1152             this.toBaseString(instance1) + "[instanceInt=67890,instanceString=instanceString,staticInt=12345,staticString=staticString]",
1153             ReflectionToStringBuilder.toString(instance1, null, false, true, ReflectionStaticFieldsFixture.class));
1154         assertEquals(
1155             this.toBaseString(instance1) + "[instanceInt=67890,instanceString=instanceString,staticInt=12345,staticString=staticString,staticTransientInt=54321,staticTransientString=staticTransientString,transientInt=98765,transientString=transientString]",
1156             ReflectionToStringBuilder.toString(instance1, null, true, true, ReflectionStaticFieldsFixture.class));
1157         assertEquals(
1158             this.toBaseString(instance1) + "[instanceInt=67890,instanceString=instanceString,staticInt=12345,staticString=staticString]",
1159             this.toStringWithStatics(instance1, null, ReflectionStaticFieldsFixture.class));
1160         assertEquals(
1161             this.toBaseString(instance1) + "[instanceInt=67890,instanceString=instanceString,staticInt=12345,staticString=staticString]",
1162             this.toStringWithStatics(instance1, null, ReflectionStaticFieldsFixture.class));
1163     }
1164 
1165     @Test
1166     public void testReflectionyteArray() {
1167         byte[] array = { 1, 2, -3, 4 };
1168         final String baseString = this.toBaseString(array);
1169         assertEquals(baseString + "[{1,2,-3,4}]", ToStringBuilder.reflectionToString(array));
1170         array = null;
1171         assertReflectionArray("<null>", array);
1172     }
1173 
1174     /**
1175      * Test a class that defines an ivar pointing to itself.  This test was
1176      * created to show that handling cyclical object resulted in a missing endFieldSeparator call.
1177      */
1178     @Test
1179     public void testSelfInstanceTwoVarsReflectionObjectCycle() {
1180         final SelfInstanceTwoVarsReflectionTestFixture test = new SelfInstanceTwoVarsReflectionTestFixture();
1181         assertEquals(this.toBaseString(test) + "[otherType=" + test.getOtherType().toString() + ",typeIsSelf=" + this.toBaseString(test)  + "]", test.toString());
1182     }
1183 
1184     /**
1185      * Test a class that defines an ivar pointing to itself.
1186      */
1187     @Test
1188     public void testSelfInstanceVarReflectionObjectCycle() {
1189         final SelfInstanceVarReflectionTestFixture test = new SelfInstanceVarReflectionTestFixture();
1190         assertEquals(this.toBaseString(test) + "[typeIsSelf=" + this.toBaseString(test) + "]", test.toString());
1191     }
1192 
1193     @Test
1194     public void testSetDefaultEx() {
1195         assertThrows(NullPointerException.class, () -> ToStringBuilder.setDefaultStyle(null));
1196     }
1197 
1198     @Test
1199     public void testShort() {
1200         assertEquals(baseStr + "[3]", new ToStringBuilder(base).append((short) 3).toString());
1201         assertEquals(baseStr + "[a=3]", new ToStringBuilder(base).append("a", (short) 3).toString());
1202         assertEquals(baseStr + "[a=3,b=4]", new ToStringBuilder(base).append("a", (short) 3).append("b", (short) 4).toString());
1203     }
1204 
1205     @Test
1206     public void testShortArray() {
1207         short[] array = {1, 2, -3, 4};
1208         assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString());
1209         assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString());
1210         array = null;
1211         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(array).toString());
1212         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append((Object) array).toString());
1213     }
1214 
1215     @Test
1216     public void testShortArrayArray() {
1217         short[][] array = {{1, 2}, null, {5}};
1218         assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append(array).toString());
1219         assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append((Object) array).toString());
1220         array = null;
1221         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append(array).toString());
1222         assertEquals(baseStr + "[<null>]", new ToStringBuilder(base).append((Object) array).toString());
1223     }
1224 
1225     /**
1226      * Test an Object pointing to itself, the simplest test.
1227      */
1228     @Test
1229     public void testSimpleReflectionObjectCycle() {
1230         final SimpleReflectionTestFixture simple = new SimpleReflectionTestFixture();
1231         simple.o = simple;
1232         assertEquals(this.toBaseString(simple) + "[o=" + this.toBaseString(simple) + "]", simple.toString());
1233     }
1234 
1235     @Test
1236     public void testSimpleReflectionStatics() {
1237         final SimpleReflectionStaticFieldsFixture instance1 = new SimpleReflectionStaticFieldsFixture();
1238         assertEquals(
1239             this.toBaseString(instance1) + "[staticInt=12345,staticString=staticString]",
1240             ReflectionToStringBuilder.toString(instance1, null, false, true, SimpleReflectionStaticFieldsFixture.class));
1241         assertEquals(
1242             this.toBaseString(instance1) + "[staticInt=12345,staticString=staticString]",
1243             ReflectionToStringBuilder.toString(instance1, null, true, true, SimpleReflectionStaticFieldsFixture.class));
1244         assertEquals(
1245             this.toBaseString(instance1) + "[staticInt=12345,staticString=staticString]",
1246             this.toStringWithStatics(instance1, null, SimpleReflectionStaticFieldsFixture.class));
1247         assertEquals(
1248             this.toBaseString(instance1) + "[staticInt=12345,staticString=staticString]",
1249             this.toStringWithStatics(instance1, null, SimpleReflectionStaticFieldsFixture.class));
1250     }
1251 
1252     /**
1253      * Create the same toString() as Object.toString().
1254      * @param o the object to create the string for.
1255      * @return a String in the Object.toString format.
1256      */
1257     private String toBaseString(final Object o) {
1258         return o.getClass().getName() + "@" + Integer.toHexString(System.identityHashCode(o));
1259     }
1260 
1261     /**
1262      * <p>This method uses reflection to build a suitable
1263      * {@code toString} value which includes static fields.</p>
1264      *
1265      * <p>It uses {@code AccessibleObject.setAccessible} to gain access to private
1266      * fields. This means that it will throw a security exception if run
1267      * under a security manager, if the permissions are not set up correctly.
1268      * It is also not as efficient as testing explicitly.</p>
1269      *
1270      * <p>Transient fields are not output.</p>
1271      *
1272      * <p>Superclass fields will be appended up to and including the specified superclass.
1273      * A null superclass is treated as {@code java.lang.Object}.</p>
1274      *
1275      * <p>If the style is {@code null}, the default
1276      * {@code ToStringStyle} is used.</p>
1277      *
1278      * @param <T> the type of the output object
1279      * @param object  the Object to be output
1280      * @param style  the style of the {@code toString} to create,
1281      *  may be {@code null}
1282      * @param reflectUpToClass  the superclass to reflect up to (inclusive),
1283      *  may be {@code null}
1284      * @return the String result
1285      * @throws IllegalArgumentException if the Object is {@code null}
1286      */
1287     public <T> String toStringWithStatics(final T object, final ToStringStyle style, final Class<? super T> reflectUpToClass) {
1288         return ReflectionToStringBuilder.toString(object, style, false, true, reflectUpToClass);
1289     }
1290 
1291 }