public ToStringBuilderTest(String name) 
{
    
        super(name);
}

 public  void assertReflectionArray(String expected,
    Object actual) 
{
        if (actual == null) {
            // Until ToStringBuilder supports null objects.
            return;
        }
        assertEquals(expected, ToStringBuilder.reflectionToString(actual));
        assertEquals(expected, ToStringBuilder.reflectionToString(actual, null));
        assertEquals(expected, ToStringBuilder.reflectionToString(actual, null, true));
        assertEquals(expected, ToStringBuilder.reflectionToString(actual, null, false));
}

 public static  void main(String[] args) 
{
        TestRunner.run(suite());
}

 protected  void setUp() throws Exception 
{
        super.setUp();
}

 public static Test suite() 
{
        TestSuite suite = new TestSuite(ToStringBuilderTest.class);
        suite.setName("ToStringBuilder Tests");
        return suite;
}

 protected  void tearDown() throws Exception 
{
        super.tearDown();
}

 public  void testAppendSuper() 
{
        assertEquals(baseStr + "[]", new ToStringBuilder(base).appendSuper("Integer@8888[]").toString());
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).appendSuper("Integer@8888[< null >]").toString());
        assertEquals(baseStr + "[a=hello]", new ToStringBuilder(base).appendSuper("Integer@8888[]").append("a", "hello").toString());
        assertEquals(baseStr + "[< null >,a=hello]", new ToStringBuilder(base).appendSuper("Integer@8888[< null >]").append("a", "hello").toString());
        assertEquals(baseStr + "[a=hello]", new ToStringBuilder(base).appendSuper(null).append("a", "hello").toString());
}

 public  void testAppendToString() 
{
        assertEquals(baseStr + "[]", new ToStringBuilder(base).appendToString("Integer@8888[]").toString());
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).appendToString("Integer@8888[< null >]").toString());
        assertEquals(baseStr + "[a=hello]", new ToStringBuilder(base).appendToString("Integer@8888[]").append("a", "hello").toString());
        assertEquals(baseStr + "[< null >,a=hello]", new ToStringBuilder(base).appendToString("Integer@8888[< null >]").append("a", "hello").toString());
        assertEquals(baseStr + "[a=hello]", new ToStringBuilder(base).appendToString(null).append("a", "hello").toString());
}

 public  void testBlank() 
{
        assertEquals(baseStr + "[]", new ToStringBuilder(base).toString());
}

 public  void testBoolean() 
{
        assertEquals(baseStr + "[true]", new ToStringBuilder(base).append(true).toString());
        assertEquals(baseStr + "[a=true]", new ToStringBuilder(base).append("a", true).toString());
        assertEquals(baseStr + "[a=true,b=false]", new ToStringBuilder(base).append("a", true).append("b", false).toString());
}

 public  void testBooleanArray() 
{
        boolean[] array = new boolean[] {true, false, false};
        assertEquals(baseStr + "[{true,false,false}]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[{true,false,false}]", new ToStringBuilder(base).append((Object) array).toString());
        array = null;
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append((Object) array).toString());
}

 public  void testBooleanArrayArray() 
{
        boolean[][] array = new boolean[][] {{true, false}, null, {false}};
        assertEquals(baseStr + "[{{true,false},< null >,{false}}]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[{{true,false},< null >,{false}}]", new ToStringBuilder(base).append((Object) array).toString());
        array = null;
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append((Object) array).toString());
}

 public  void testByte() 
{
        assertEquals(baseStr + "[3]", new ToStringBuilder(base).append((byte) 3).toString());
        assertEquals(baseStr + "[a=3]", new ToStringBuilder(base).append("a", (byte) 3).toString());
        assertEquals(baseStr + "[a=3,b=4]", new ToStringBuilder(base).append("a", (byte) 3).append("b", (byte) 4).toString());
}

 public  void testByteArray() 
{
        byte[] array = new byte[] {1, 2, -3, 4};
        assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString());
        array = null;
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append((Object) array).toString());
}

 public  void testByteArrayArray() 
{
        byte[][] array = new byte[][] {{1, 2}, null, {5}};
        assertEquals(baseStr + "[{{1,2},< null >,{5}}]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[{{1,2},< null >,{5}}]", new ToStringBuilder(base).append((Object) array).toString());
        array = null;
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append((Object) array).toString());
}

 public  void testChar() 
{
        assertEquals(baseStr + "[A]", new ToStringBuilder(base).append((char) 65).toString());
        assertEquals(baseStr + "[a=A]", new ToStringBuilder(base).append("a", (char) 65).toString());
        assertEquals(baseStr + "[a=A,b=B]", new ToStringBuilder(base).append("a", (char) 65).append("b", (char) 66).toString());
}

 public  void testCharArray() 
{
        char[] array = new char[] {'A", '2", '_", 'D"};
        assertEquals(baseStr + "[{A,2,_,D}]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[{A,2,_,D}]", new ToStringBuilder(base).append((Object) array).toString());
        array = null;
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append((Object) array).toString());
}

 public  void testCharArrayArray() 
{
        char[][] array = new char[][] {{'A", 'B"}, null, {'p"}};
        assertEquals(baseStr + "[{{A,B},< null >,{p}}]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[{{A,B},< null >,{p}}]", new ToStringBuilder(base).append((Object) array).toString());
        array = null;
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append((Object) array).toString());
}

 public  void testConstructorEx1() 
{
        assertEquals("< null >", new ToStringBuilder(null).toString());
}

 public  void testConstructorEx2() 
{
        assertEquals("< null >", new ToStringBuilder(null, null).toString());
        new ToStringBuilder(this.base, null).toString();
}

 public  void testConstructorEx3() 
{
        assertEquals("< null >", new ToStringBuilder(null, null, null).toString());
        new ToStringBuilder(this.base, null, null);
        new ToStringBuilder(this.base, ToStringStyle.DEFAULT_STYLE, null);
}

 public  void testDouble() 
{
        assertEquals(baseStr + "[3.2]", new ToStringBuilder(base).append((double) 3.2).toString());
        assertEquals(baseStr + "[a=3.2]", new ToStringBuilder(base).append("a", (double) 3.2).toString());
        assertEquals(baseStr + "[a=3.2,b=4.3]", new ToStringBuilder(base).append("a", (double) 3.2).append("b", (double) 4.3).toString());
}

 public  void testDoubleArray() 
{
        double[] array = new double[] {1.0, 2.9876, -3.00001, 4.3};
        assertEquals(baseStr + "[{1.0,2.9876,-3.00001,4.3}]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[{1.0,2.9876,-3.00001,4.3}]", new ToStringBuilder(base).append((Object) array).toString());
        array = null;
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append((Object) array).toString());
}

 public  void testDoubleArrayArray() 
{
        double[][] array = new double[][] {{1.0, 2.29686}, null, {Double.NaN}};
        assertEquals(baseStr + "[{{1.0,2.29686},< null >,{NaN}}]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[{{1.0,2.29686},< null >,{NaN}}]", new ToStringBuilder(base).append((Object) array).toString());
        array = null;
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append((Object) array).toString());
}

 public  void testFloat() 
{
        assertEquals(baseStr + "[3.2]", new ToStringBuilder(base).append((float) 3.2).toString());
        assertEquals(baseStr + "[a=3.2]", new ToStringBuilder(base).append("a", (float) 3.2).toString());
        assertEquals(baseStr + "[a=3.2,b=4.3]", new ToStringBuilder(base).append("a", (float) 3.2).append("b", (float) 4.3).toString());
}

 public  void testFloatArray() 
{
        float[] array = new float[] {1.0f, 2.9876f, -3.00001f, 4.3f};
        assertEquals(baseStr + "[{1.0,2.9876,-3.00001,4.3}]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[{1.0,2.9876,-3.00001,4.3}]", new ToStringBuilder(base).append((Object) array).toString());
        array = null;
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append((Object) array).toString());
}

 public  void testFloatArrayArray() 
{
        float[][] array = new float[][] {{1.0f, 2.29686f}, null, {Float.NaN}};
        assertEquals(baseStr + "[{{1.0,2.29686},< null >,{NaN}}]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[{{1.0,2.29686},< null >,{NaN}}]", new ToStringBuilder(base).append((Object) array).toString());
        array = null;
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append((Object) array).toString());
}

 public  void testGetSetDefault() 
{
        try {
            ToStringBuilder.setDefaultStyle(ToStringStyle.NO_FIELD_NAMES_STYLE);
            assertSame(ToStringStyle.NO_FIELD_NAMES_STYLE, ToStringBuilder.getDefaultStyle());
        } finally {
            // reset for other tests
            ToStringBuilder.setDefaultStyle(ToStringStyle.DEFAULT_STYLE);
        }
}

 public  void testInheritedReflectionStatics() 
{
        InheritedReflectionStaticFieldsFixture instance1 = new InheritedReflectionStaticFieldsFixture();
        assertEquals(
            this.toBaseString(instance1) + "[staticString2=staticString2,staticInt2=67890]",
            ReflectionToStringBuilder.toString(instance1, null, false, true, InheritedReflectionStaticFieldsFixture.class));
        assertEquals(
            this.toBaseString(instance1) + "[staticString2=staticString2,staticInt2=67890,staticString=staticString,staticInt=12345]",
            ReflectionToStringBuilder.toString(instance1, null, false, true, SimpleReflectionStaticFieldsFixture.class));
        assertEquals(
            this.toBaseString(instance1) + "[staticString2=staticString2,staticInt2=67890,staticString=staticString,staticInt=12345]",
            this.toStringWithStatics(instance1, null, SimpleReflectionStaticFieldsFixture.class));
        assertEquals(
            this.toBaseString(instance1) + "[staticString2=staticString2,staticInt2=67890,staticString=staticString,staticInt=12345]",
            this.toStringWithStatics(instance1, null, SimpleReflectionStaticFieldsFixture.class));
}

Tests ReflectionToStringBuilder.toString() for statics.

 public  void testInnerClassReflection() 
{
    
        Outer outer = new Outer();
        assertEquals(toBaseString(outer) + "[inner=" + toBaseString(outer.inner) + "[]]", outer.toString());
}

 public  void testInt() 
{
        assertEquals(baseStr + "[3]", new ToStringBuilder(base).append((int) 3).toString());
        assertEquals(baseStr + "[a=3]", new ToStringBuilder(base).append("a", (int) 3).toString());
        assertEquals(baseStr + "[a=3,b=4]", new ToStringBuilder(base).append("a", (int) 3).append("b", (int) 4).toString());
}

 public  void testIntArray() 
{
        int[] array = new int[] {1, 2, -3, 4};
        assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString());
        array = null;
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append((Object) array).toString());
}

 public  void testIntArrayArray() 
{
        int[][] array = new int[][] {{1, 2}, null, {5}};
        assertEquals(baseStr + "[{{1,2},< null >,{5}}]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[{{1,2},< null >,{5}}]", new ToStringBuilder(base).append((Object) array).toString());
        array = null;
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append((Object) array).toString());
}

 public  void testLong() 
{
        assertEquals(baseStr + "[3]", new ToStringBuilder(base).append(3L).toString());
        assertEquals(baseStr + "[a=3]", new ToStringBuilder(base).append("a", 3L).toString());
        assertEquals(baseStr + "[a=3,b=4]", new ToStringBuilder(base).append("a", 3L).append("b", 4L).toString());
}

 public  void testLongArray() 
{
        long[] array = new long[] {1, 2, -3, 4};
        assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString());
        array = null;
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append((Object) array).toString());
}

 public  void testLongArrayArray() 
{
        long[][] array = new long[][] {{1, 2}, null, {5}};
        assertEquals(baseStr + "[{{1,2},< null >,{5}}]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[{{1,2},< null >,{5}}]", new ToStringBuilder(base).append((Object) array).toString());
        array = null;
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append((Object) array).toString());
}

 public  void testObject() 
{
        Integer i3 = new Integer(3);
        Integer i4 = new Integer(4);
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append((Object) null).toString());
        assertEquals(baseStr + "[3]", new ToStringBuilder(base).append(i3).toString());
        assertEquals(baseStr + "[a=< null >]", new ToStringBuilder(base).append("a", (Object) null).toString());
        assertEquals(baseStr + "[a=3]", new ToStringBuilder(base).append("a", i3).toString());
        assertEquals(baseStr + "[a=3,b=4]", new ToStringBuilder(base).append("a", i3).append("b", i4).toString());
        assertEquals(baseStr + "[a=< Integer >]", new ToStringBuilder(base).append("a", i3, false).toString());
        assertEquals(baseStr + "[a=< size=0 >]", new ToStringBuilder(base).append("a", new ArrayList(), false).toString());
        assertEquals(baseStr + "[a=[]]", new ToStringBuilder(base).append("a", new ArrayList(), true).toString());
        assertEquals(baseStr + "[a=< size=0 >]", new ToStringBuilder(base).append("a", new HashMap(), false).toString());
        assertEquals(baseStr + "[a={}]", new ToStringBuilder(base).append("a", new HashMap(), true).toString());
        assertEquals(baseStr + "[a=< size=0 >]", new ToStringBuilder(base).append("a", (Object) new String[0], false).toString());
        assertEquals(baseStr + "[a={}]", new ToStringBuilder(base).append("a", (Object) new String[0], true).toString());
}

 public  void testObjectArray() 
{
        Object[] array = new Object[] {null, base, new int[] {3, 6}};
        assertEquals(baseStr + "[{< null >,5,{3,6}}]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[{< null >,5,{3,6}}]", new ToStringBuilder(base).append((Object) array).toString());
        array = null;
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append((Object) array).toString());
}

 public  void testReflectionArrayAndObjectCycle() throws Exception 
{
        Object[] objects = new Object[1];
        SimpleReflectionTestFixture simple = new SimpleReflectionTestFixture(objects);
        objects[0] = (Object) simple;
        assertEquals(
            this.toBaseString(objects)
                + "[{"
                + this.toBaseString(simple)
                + "[o="
                + this.toBaseString(objects)
                + "]"
                + "}]",
            ToStringBuilder.reflectionToString(objects));
        assertEquals(
            this.toBaseString(simple)
                + "[o={"
                + this.toBaseString(simple)
                + "}]",
            ToStringBuilder.reflectionToString(simple));
        this.validateEmptyReflectionRegistry();
}

Test a nasty combination of arrays and Objects pointing to each other. objects[0] -> SimpleReflectionTestFixture[ o -> objects ]

 public  void testReflectionArrayArrayCycle() throws Exception 
{
        Object[][] objects = new Object[2][2];
        objects[0][0] = objects;
        objects[0][1] = objects;
        objects[1][0] = objects;
        objects[1][1] = objects;
        String basicToString = this.toBaseString(objects);
        assertEquals(
            basicToString
                + "[{{"
                + basicToString
                + ","
                + basicToString
                + "},{"
                + basicToString
                + ","
                + basicToString
                + "}}]",
            ToStringBuilder.reflectionToString(objects));
        this.validateEmptyReflectionRegistry();
}

 public  void testReflectionArrayCycle() throws Exception 
{
        Object[] objects = new Object[1];
        objects[0] = objects;
        assertEquals(
            this.toBaseString(objects) + "[{" + this.toBaseString(objects) + "}]",
            ToStringBuilder.reflectionToString(objects));
        this.validateEmptyReflectionRegistry();
}

Test an array element pointing to its container.

 public  void testReflectionArrayCycleLevel2() throws Exception 
{
        Object[] objects = new Object[1];
        Object[] objectsLevel2 = new Object[1];
        objects[0] = objectsLevel2;
        objectsLevel2[0] = (Object) objects;
        assertEquals(
            this.toBaseString(objects) + "[{{" + this.toBaseString(objects) + "}}]",
            ToStringBuilder.reflectionToString(objects));
        assertEquals(
            this.toBaseString(objectsLevel2) + "[{{" + this.toBaseString(objectsLevel2) + "}}]",
            ToStringBuilder.reflectionToString(objectsLevel2));
        this.validateEmptyReflectionRegistry();
}

Test an array element pointing to its container.

 public  void testReflectionBoolean() 
{
        Boolean b;
        b = Boolean.TRUE;
        assertEquals(this.toBaseString(b) + "[value=true]", ToStringBuilder.reflectionToString(b));
        b = Boolean.FALSE;
        assertEquals(this.toBaseString(b) + "[value=false]", ToStringBuilder.reflectionToString(b));
}

Test wrapper for char boolean.

 public  void testReflectionBooleanArray() 
{
        boolean[] array = new boolean[] { true, false, false };
        String baseStr = this.toBaseString(array);
        assertEquals(baseStr + "[{true,false,false}]", ToStringBuilder.reflectionToString(array));
        array = null;
        assertReflectionArray("< null >", array);
        this.validateEmptyReflectionRegistry();
}

 public  void testReflectionBooleanArrayArray() 
{
        boolean[][] array = new boolean[][] { { true, false }, null, { false } };
        String baseStr = this.toBaseString(array);
        assertEquals(baseStr + "[{{true,false},< null >,{false}}]", ToStringBuilder.reflectionToString(array));
        assertEquals(baseStr + "[{{true,false},< null >,{false}}]", ToStringBuilder.reflectionToString(array));
        array = null;
        assertReflectionArray("< null >", array);
        this.validateEmptyReflectionRegistry();
}

 public  void testReflectionByteArrayArray() 
{
        byte[][] array = new byte[][] { { 1, 2 }, null, { 5 } };
        String baseStr = this.toBaseString(array);
        assertEquals(baseStr + "[{{1,2},< null >,{5}}]", ToStringBuilder.reflectionToString(array));
        array = null;
        assertReflectionArray("< null >", array);
        this.validateEmptyReflectionRegistry();
}

 public  void testReflectionCharArray() 
{
        char[] array = new char[] { 'A", '2", '_", 'D" };
        String baseStr = this.toBaseString(array);
        assertEquals(baseStr + "[{A,2,_,D}]", ToStringBuilder.reflectionToString(array));
        array = null;
        assertReflectionArray("< null >", array);
        this.validateEmptyReflectionRegistry();
}

 public  void testReflectionCharArrayArray() 
{
        char[][] array = new char[][] { { 'A", 'B" }, null, { 'p" } };
        String baseStr = this.toBaseString(array);
        assertEquals(baseStr + "[{{A,B},< null >,{p}}]", ToStringBuilder.reflectionToString(array));
        array = null;
        assertReflectionArray("< null >", array);
        this.validateEmptyReflectionRegistry();
}

 public  void testReflectionCharacter() 
{
        Character c = new Character('A");
        assertEquals(this.toBaseString(c) + "[value=A]", ToStringBuilder.reflectionToString(c));
}

Test wrapper for char primitive.

 public  void testReflectionDoubleArray() 
{
        double[] array = new double[] { 1.0, 2.9876, -3.00001, 4.3 };
        String baseStr = this.toBaseString(array);
        assertEquals(baseStr + "[{1.0,2.9876,-3.00001,4.3}]", ToStringBuilder.reflectionToString(array));
        array = null;
        assertReflectionArray("< null >", array);
        this.validateEmptyReflectionRegistry();
}

 public  void testReflectionDoubleArrayArray() 
{
        double[][] array = new double[][] { { 1.0, 2.29686 }, null, { Double.NaN } };
        String baseStr = this.toBaseString(array);
        assertEquals(baseStr + "[{{1.0,2.29686},< null >,{NaN}}]", ToStringBuilder.reflectionToString(array));
        array = null;
        assertReflectionArray("< null >", array);
        this.validateEmptyReflectionRegistry();
}

 public  void testReflectionFloatArray() 
{
        float[] array = new float[] { 1.0f, 2.9876f, -3.00001f, 4.3f };
        String baseStr = this.toBaseString(array);
        assertEquals(baseStr + "[{1.0,2.9876,-3.00001,4.3}]", ToStringBuilder.reflectionToString(array));
        array = null;
        assertReflectionArray("< null >", array);
        this.validateEmptyReflectionRegistry();
}

 public  void testReflectionFloatArrayArray() 
{
        float[][] array = new float[][] { { 1.0f, 2.29686f }, null, { Float.NaN } };
        String baseStr = this.toBaseString(array);
        assertEquals(baseStr + "[{{1.0,2.29686},< null >,{NaN}}]", ToStringBuilder.reflectionToString(array));
        array = null;
        assertReflectionArray("< null >", array);
        this.validateEmptyReflectionRegistry();
}

 public  void testReflectionHierarchy() 
{
        ReflectionTestFixtureA baseA = new ReflectionTestFixtureA();
        String baseStr = this.toBaseString(baseA);
        assertEquals(baseStr + "[a=a]", ToStringBuilder.reflectionToString(baseA));
        assertEquals(baseStr + "[a=a]", ToStringBuilder.reflectionToString(baseA, null));
        assertEquals(baseStr + "[a=a]", ToStringBuilder.reflectionToString(baseA, null, false));
        assertEquals(baseStr + "[a=a,transientA=t]", ToStringBuilder.reflectionToString(baseA, null, true));
        assertEquals(baseStr + "[a=a]", ToStringBuilder.reflectionToString(baseA, null, false, null));
        assertEquals(baseStr + "[a=a]", ToStringBuilder.reflectionToString(baseA, null, false, Object.class));
        assertEquals(baseStr + "[a=a]", ToStringBuilder.reflectionToString(baseA, null, false, List.class));
        assertEquals(baseStr + "[a=a]", ToStringBuilder.reflectionToString(baseA, null, false, ReflectionTestFixtureA.class));
        ReflectionTestFixtureB baseB = new ReflectionTestFixtureB();
        baseStr = this.toBaseString(baseB);
        assertEquals(baseStr + "[b=b,a=a]", ToStringBuilder.reflectionToString(baseB));
        assertEquals(baseStr + "[b=b,a=a]", ToStringBuilder.reflectionToString(baseB));
        assertEquals(baseStr + "[b=b,a=a]", ToStringBuilder.reflectionToString(baseB, null));
        assertEquals(baseStr + "[b=b,a=a]", ToStringBuilder.reflectionToString(baseB, null, false));
        assertEquals(baseStr + "[b=b,transientB=t,a=a,transientA=t]", ToStringBuilder.reflectionToString(baseB, null, true));
        assertEquals(baseStr + "[b=b,a=a]", ToStringBuilder.reflectionToString(baseB, null, false, null));
        assertEquals(baseStr + "[b=b,a=a]", ToStringBuilder.reflectionToString(baseB, null, false, Object.class));
        assertEquals(baseStr + "[b=b,a=a]", ToStringBuilder.reflectionToString(baseB, null, false, List.class));
        assertEquals(baseStr + "[b=b,a=a]", ToStringBuilder.reflectionToString(baseB, null, false, ReflectionTestFixtureA.class));
        assertEquals(baseStr + "[b=b]", ToStringBuilder.reflectionToString(baseB, null, false, ReflectionTestFixtureB.class));
        this.validateEmptyReflectionRegistry();
}

 public  void testReflectionHierarchyArrayList() 
{
        List base = new ArrayList();
        String baseStr = this.toBaseString(base);
        assertEquals(baseStr + "[elementData={< null >,< null >,< null >,< null >,< null >,< null >,< null >,< null >,< null >,< null >},size=0,modCount=0]", ToStringBuilder.reflectionToString(base, null, true));
        assertEquals(baseStr + "[size=0]", ToStringBuilder.reflectionToString(base, null, false));
        this.validateEmptyReflectionRegistry();
}

 public  void testReflectionIntArray() 
{
        int[] array = new int[] { 1, 2, -3, 4 };
        String baseStr = this.toBaseString(array);
        assertEquals(baseStr + "[{1,2,-3,4}]", ToStringBuilder.reflectionToString(array));
        array = null;
        assertReflectionArray("< null >", array);
        this.validateEmptyReflectionRegistry();
}

 public  void testReflectionIntArrayArray() 
{
        int[][] array = new int[][] { { 1, 2 }, null, { 5 } };
        String baseStr = this.toBaseString(array);
        assertEquals(baseStr + "[{{1,2},< null >,{5}}]", ToStringBuilder.reflectionToString(array));
        array = null;
        assertReflectionArray("< null >", array);
        this.validateEmptyReflectionRegistry();
}

 public  void testReflectionInteger() 
{
        assertEquals(baseStr + "[value=5]", ToStringBuilder.reflectionToString(base));
}

Test wrapper for int primitive.

 public  void testReflectionLongArray() 
{
        long[] array = new long[] { 1, 2, -3, 4 };
        String baseStr = this.toBaseString(array);
        assertEquals(baseStr + "[{1,2,-3,4}]", ToStringBuilder.reflectionToString(array));
        array = null;
        assertReflectionArray("< null >", array);
        this.validateEmptyReflectionRegistry();
}

 public  void testReflectionLongArrayArray() 
{
        long[][] array = new long[][] { { 1, 2 }, null, { 5 } };
        String baseStr = this.toBaseString(array);
        assertEquals(baseStr + "[{{1,2},< null >,{5}}]", ToStringBuilder.reflectionToString(array));
        array = null;
        assertReflectionArray("< null >", array);
        this.validateEmptyReflectionRegistry();
}

 public  void testReflectionNull() 
{
    
        assertEquals("< null >", ReflectionToStringBuilder.toString(null));
}

 public  void testReflectionObjectArray() 
{
        Object[] array = new Object[] { null, base, new int[] { 3, 6 } };
        String baseStr = this.toBaseString(array);
        assertEquals(baseStr + "[{< null >,5,{3,6}}]", ToStringBuilder.reflectionToString(array));
        array = null;
        assertReflectionArray("< null >", array);
        this.validateEmptyReflectionRegistry();
}

 public  void testReflectionObjectCycle() throws Exception 
{
        ReflectionTestCycleA a = new ReflectionTestCycleA();
        ReflectionTestCycleB b = new ReflectionTestCycleB();
        a.b = b;
        b.a = a;
        assertEquals(
            this.toBaseString(a) + "[b=" + this.toBaseString(b) + "[a=" + this.toBaseString(a) + "]]",
            a.toString());
        this.validateEmptyReflectionRegistry();
}

Test Objects pointing to each other.

 public  void testReflectionShortArray() 
{
        short[] array = new short[] { 1, 2, -3, 4 };
        String baseStr = this.toBaseString(array);
        assertEquals(baseStr + "[{1,2,-3,4}]", ToStringBuilder.reflectionToString(array));
        array = null;
        assertReflectionArray("< null >", array);
        this.validateEmptyReflectionRegistry();
}

 public  void testReflectionStatics() 
{
        ReflectionStaticFieldsFixture instance1 = new ReflectionStaticFieldsFixture();
        assertEquals(
            this.toBaseString(instance1) + "[staticString=staticString,staticInt=12345,instanceString=instanceString,instanceInt=67890]",
            ReflectionToStringBuilder.toString(instance1, null, false, true, ReflectionStaticFieldsFixture.class));
        assertEquals(
            this.toBaseString(instance1) + "[staticString=staticString,staticInt=12345,staticTransientString=staticTransientString,staticTransientInt=54321,instanceString=instanceString,instanceInt=67890,transientString=transientString,transientInt=98765]",
            ReflectionToStringBuilder.toString(instance1, null, true, true, ReflectionStaticFieldsFixture.class));
        assertEquals(
            this.toBaseString(instance1) + "[staticString=staticString,staticInt=12345,instanceString=instanceString,instanceInt=67890]",
            this.toStringWithStatics(instance1, null, ReflectionStaticFieldsFixture.class));
        assertEquals(
            this.toBaseString(instance1) + "[staticString=staticString,staticInt=12345,instanceString=instanceString,instanceInt=67890]",
            this.toStringWithStatics(instance1, null, ReflectionStaticFieldsFixture.class));
}

Tests ReflectionToStringBuilder.toString() for statics.

 public  void testReflectionhortArrayArray() 
{
        short[][] array = new short[][] { { 1, 2 }, null, { 5 } };
        String baseStr = this.toBaseString(array);
        assertEquals(baseStr + "[{{1,2},< null >,{5}}]", ToStringBuilder.reflectionToString(array));
        array = null;
        assertReflectionArray("< null >", array);
        this.validateEmptyReflectionRegistry();
}

 public  void testReflectionyteArray() 
{
        byte[] array = new byte[] { 1, 2, -3, 4 };
        String baseStr = this.toBaseString(array);
        assertEquals(baseStr + "[{1,2,-3,4}]", ToStringBuilder.reflectionToString(array));
        array = null;
        assertReflectionArray("< null >", array);
        this.validateEmptyReflectionRegistry();
}

 public  void testSelfInstanceTwoVarsReflectionObjectCycle() throws Exception 
{
        SelfInstanceTwoVarsReflectionTestFixture test = new SelfInstanceTwoVarsReflectionTestFixture();
        assertTrue(ReflectionToStringBuilder.getRegistry().isEmpty());
        assertEquals(this.toBaseString(test) + "[typeIsSelf=" + this.toBaseString(test) + ",otherType=" + test.getOtherType().toString() + "]", test.toString());
        this.validateEmptyReflectionRegistry();
}

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 call.

 public  void testSelfInstanceVarReflectionObjectCycle() throws Exception 
{
        SelfInstanceVarReflectionTestFixture test = new SelfInstanceVarReflectionTestFixture();
        assertTrue(ReflectionToStringBuilder.getRegistry().isEmpty());
        assertEquals(this.toBaseString(test) + "[typeIsSelf=" + this.toBaseString(test) + "]", test.toString());
        this.validateEmptyReflectionRegistry();
}

Test a class that defines an ivar pointing to itself.

 public  void testSetDefaultEx() 
{
        try {
            ToStringBuilder.setDefaultStyle(null);
        } catch (IllegalArgumentException ex) {
            return;
        }
        fail();
}

 public  void testShort() 
{
        assertEquals(baseStr + "[3]", new ToStringBuilder(base).append((short) 3).toString());
        assertEquals(baseStr + "[a=3]", new ToStringBuilder(base).append("a", (short) 3).toString());
        assertEquals(baseStr + "[a=3,b=4]", new ToStringBuilder(base).append("a", (short) 3).append("b", (short) 4).toString());
}

 public  void testShortArray() 
{
        short[] array = new short[] {1, 2, -3, 4};
        assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString());
        array = null;
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append((Object) array).toString());
}

 public  void testShortArrayArray() 
{
        short[][] array = new short[][] {{1, 2}, null, {5}};
        assertEquals(baseStr + "[{{1,2},< null >,{5}}]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[{{1,2},< null >,{5}}]", new ToStringBuilder(base).append((Object) array).toString());
        array = null;
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append(array).toString());
        assertEquals(baseStr + "[< null >]", new ToStringBuilder(base).append((Object) array).toString());
}

 public  void testSimpleReflectionObjectCycle() throws Exception 
{
        SimpleReflectionTestFixture simple = new SimpleReflectionTestFixture();
        simple.o = simple;
        assertTrue(ReflectionToStringBuilder.getRegistry().isEmpty());
        assertEquals(this.toBaseString(simple) + "[o=" + this.toBaseString(simple) + "]", simple.toString());
        this.validateEmptyReflectionRegistry();
}

Test an Object pointing to itself, the simplest test.

 public  void testSimpleReflectionStatics() 
{
        SimpleReflectionStaticFieldsFixture instance1 = new SimpleReflectionStaticFieldsFixture();
        assertEquals(
            this.toBaseString(instance1) + "[staticString=staticString,staticInt=12345]",
            ReflectionToStringBuilder.toString(instance1, null, false, true, SimpleReflectionStaticFieldsFixture.class));
        assertEquals(
            this.toBaseString(instance1) + "[staticString=staticString,staticInt=12345]",
            ReflectionToStringBuilder.toString(instance1, null, true, true, SimpleReflectionStaticFieldsFixture.class));
        assertEquals(
            this.toBaseString(instance1) + "[staticString=staticString,staticInt=12345]",
            this.toStringWithStatics(instance1, null, SimpleReflectionStaticFieldsFixture.class));
        assertEquals(
            this.toBaseString(instance1) + "[staticString=staticString,staticInt=12345]",
            this.toStringWithStatics(instance1, null, SimpleReflectionStaticFieldsFixture.class));
}

 public Object toStringWithStatics(Object object,
    ToStringStyle style,
    Class reflectUpToClass) 
{
        return ReflectionToStringBuilder.toString(object, style, false, true, reflectUpToClass);
}

This method uses reflection to build a suitable toString value which includes static fields.

It uses AccessibleObject.setAccessible to gain access to private fields. This means that it will throw a security exception if run under a security manager, if the permissions are not set up correctly. It is also not as efficient as testing explicitly.

Transient fields are not output.

Superclass fields will be appended up to and including the specified superclass. A null superclass is treated as java.lang.Object.

If the style is null, the default ToStringStyle is used.

  void validateEmptyReflectionRegistry() 
{
        assertTrue(ReflectionToStringBuilder.getRegistry().isEmpty());
}