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