Google Git
Sign in
apache / commons-lang / fc457a4a71a2f4500efaf8f2f752a37e52886ef1 / . / src / test / java / org / apache / commons / lang / builder / ToStringBuilderTest.java
blob: a9089267053f9b6ac3d12d94905bdaf4a7db502d [file] [log] [blame]
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.lang.builder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import junit.framework.TestCase;
/**
* Unit tests for {@link org.apache.commons.lang.builder.ToStringBuilder}.
*
* @author Apache Software Foundation
* @author <a href="mailto:ggregory@seagullsw.com">Gary Gregory</a>
* @author <a href="mailto:alex@apache.org">Alex Chaffee</a>
* @version $Id$
*/
public class ToStringBuilderTest extends TestCase {
private final Integer base = new Integer(5);
private final String baseStr = base.getClass().getName() + "@" + Integer.toHexString(System.identityHashCode(base));
public ToStringBuilderTest(String name) {
super(name);
}
//-----------------------------------------------------------------------
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 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 testSetDefaultEx() {
try {
ToStringBuilder.setDefaultStyle(null);
} catch (IllegalArgumentException ex) {
return;
}
fail();
}
public void testBlank() {
assertEquals(baseStr + "[]", new ToStringBuilder(base).toString());
}
/**
* Test wrapper for int primitive.
*/
public void testReflectionInteger() {
assertEquals(baseStr + "[value=5]", ToStringBuilder.reflectionToString(base));
}
/**
* Test wrapper for char primitive.
*/
public void testReflectionCharacter() {
Character c = new Character('A');
assertEquals(this.toBaseString(c) + "[value=A]", ToStringBuilder.reflectionToString(c));
}
/**
* Test wrapper for char boolean.
*/
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));
}
/**
* Create the same toString() as Object.toString().
* @param o the object to create the string for.
* @return a String in the Object.toString format.
*/
private String toBaseString(Object o) {
return o.getClass().getName() + "@" + Integer.toHexString(System.identityHashCode(o));
}
// Reflection Array tests
//
// Note on the following line of code repeated in the reflection array tests.
//
// assertReflectionArray("<null>", array);
//
// The expected value is not baseStr + "[<null>]" since array==null and is typed as Object.
// The null array does not carry array type information.
// If we added a primitive array type constructor and pile of associated methods,
// then type declaring type information could be carried forward. IMHO, null is null.
//
// Gary Gregory - 2003-03-12 - ggregory@seagullsw.com
//
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 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.validateNullToStringStyleRegistry();
}
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.validateNullToStringStyleRegistry();
}
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.validateNullToStringStyleRegistry();
}
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.validateNullToStringStyleRegistry();
}
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.validateNullToStringStyleRegistry();
}
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.validateNullToStringStyleRegistry();
}
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.validateNullToStringStyleRegistry();
}
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.validateNullToStringStyleRegistry();
}
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.validateNullToStringStyleRegistry();
}
// Reflection Array Array tests
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.validateNullToStringStyleRegistry();
}
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.validateNullToStringStyleRegistry();
}
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.validateNullToStringStyleRegistry();
}
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.validateNullToStringStyleRegistry();
}
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.validateNullToStringStyleRegistry();
}
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.validateNullToStringStyleRegistry();
}
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.validateNullToStringStyleRegistry();
}
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.validateNullToStringStyleRegistry();
}
// Reflection hierarchy tests
/* Following Test removed because its dependant on the Java implementation
* (currently passes using Sun/Oracle implementations, but fails for IBM's JDK 6)
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.validateNullToStringStyleRegistry();
}
*/
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, 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, ReflectionTestFixtureA.class));
assertEquals(baseStr + "[b=b]", ToStringBuilder.reflectionToString(baseB, null, false, ReflectionTestFixtureB.class));
this.validateNullToStringStyleRegistry();
}
static class ReflectionTestFixtureA {
private char a='a';
private transient char transientA='t';
}
static class ReflectionTestFixtureB extends ReflectionTestFixtureA {
private char b='b';
private transient char transientB='t';
}
public void testInnerClassReflection() {
Outer outer = new Outer();
assertEquals(toBaseString(outer) + "[inner=" + toBaseString(outer.inner) + "[]]", outer.toString());
}
static class Outer {
Inner inner = new Inner();
class Inner {
public String toString() {
return ToStringBuilder.reflectionToString(this);
}
}
public String toString() {
return ToStringBuilder.reflectionToString(this);
}
}
// Reflection cycle tests
/**
* Test an array element pointing to its container.
*/
public void testReflectionArrayCycle() throws Exception {
Object[] objects = new Object[1];
objects[0] = objects;
assertEquals(
this.toBaseString(objects) + "[{" + this.toBaseString(objects) + "}]",
ToStringBuilder.reflectionToString(objects));
this.validateNullToStringStyleRegistry();
}
/**
* 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.validateNullToStringStyleRegistry();
}
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.validateNullToStringStyleRegistry();
}
/**
* A reflection test fixture.
*/
static class ReflectionTestCycleA {
ReflectionTestCycleB b;
public String toString() {
return ToStringBuilder.reflectionToString(this);
}
}
/**
* A reflection test fixture.
*/
static class ReflectionTestCycleB {
ReflectionTestCycleA a;
public String toString() {
return ToStringBuilder.reflectionToString(this);
}
}
/**
* A reflection test fixture.
*/
static class SimpleReflectionTestFixture {
Object o;
public SimpleReflectionTestFixture() {
}
public SimpleReflectionTestFixture(Object o) {
this.o = o;
}
public String toString() {
return ToStringBuilder.reflectionToString(this);
}
}
private static class SelfInstanceVarReflectionTestFixture {
private SelfInstanceVarReflectionTestFixture typeIsSelf;
public SelfInstanceVarReflectionTestFixture() {
this.typeIsSelf = this;
}
public String toString() {
return ToStringBuilder.reflectionToString(this);
}
}
private static class SelfInstanceTwoVarsReflectionTestFixture {
private SelfInstanceTwoVarsReflectionTestFixture typeIsSelf;
private String otherType = "The Other Type";
public SelfInstanceTwoVarsReflectionTestFixture() {
this.typeIsSelf = this;
}
public String getOtherType(){
return this.otherType;
}
public String toString() {
return ToStringBuilder.reflectionToString(this);
}
}
/**
* Test an Object pointing to itself, the simplest test.
*
* @throws Exception
*/
public void testSimpleReflectionObjectCycle() throws Exception {
SimpleReflectionTestFixture simple = new SimpleReflectionTestFixture();
simple.o = simple;
assertEquals(this.toBaseString(simple) + "[o=" + this.toBaseString(simple) + "]", simple.toString());
this.validateNullToStringStyleRegistry();
}
/**
* Test a class that defines an ivar pointing to itself.
*
* @throws Exception
*/
public void testSelfInstanceVarReflectionObjectCycle() throws Exception {
SelfInstanceVarReflectionTestFixture test = new SelfInstanceVarReflectionTestFixture();
assertEquals(this.toBaseString(test) + "[typeIsSelf=" + this.toBaseString(test) + "]", test.toString());
this.validateNullToStringStyleRegistry();
}
/**
* 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.
*
* @throws Exception
*/
public void testSelfInstanceTwoVarsReflectionObjectCycle() throws Exception {
SelfInstanceTwoVarsReflectionTestFixture test = new SelfInstanceTwoVarsReflectionTestFixture();
assertEquals(this.toBaseString(test) + "[typeIsSelf=" + this.toBaseString(test) + ",otherType=" + test.getOtherType().toString() + "]", test.toString());
this.validateNullToStringStyleRegistry();
}
/**
* Test Objects pointing to each other.
*
* @throws Exception
*/
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.validateNullToStringStyleRegistry();
}
/**
* Test a nasty combination of arrays and Objects pointing to each other.
* objects[0] -> SimpleReflectionTestFixture[ o -> objects ]
*
* @throws Exception
*/
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.validateNullToStringStyleRegistry();
}
void validateNullToStringStyleRegistry() {
if (ToStringStyle.getRegistry() != null) {
System.out.println(ToStringStyle.getRegistry());
}
assertNull(ToStringStyle.getRegistry());
}
// End: Reflection cycle tests
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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 testObjectCycle() {
ObjectCycle a = new ObjectCycle();
ObjectCycle b = new ObjectCycle();
a.obj = b;
b.obj = a;
String expected = toBaseString(a) + "[" + toBaseString(b) + "[" + toBaseString(a) + "]]";
assertEquals(expected, a.toString());
validateNullToStringStyleRegistry();
}
static class ObjectCycle {
Object obj;
public String toString() {
return new ToStringBuilder(this).append(obj).toString();
}
}
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));
}
/**
* Tests ReflectionToStringBuilder.toString() for statics.
*/
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 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));
}
/**
* <p>This method uses reflection to build a suitable
* <code>toString</code> value which includes static fields.</p>
*
* <p>It uses <code>AccessibleObject.setAccessible</code> 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. </p>
*
* <p>Transient fields are not output.</p>
*
* <p>Superclass fields will be appended up to and including the specified superclass.
* A null superclass is treated as <code>java.lang.Object</code>.</p>
*
* <p>If the style is <code>null</code>, the default
* <code>ToStringStyle</code> is used.</p>
*
* @param object the Object to be output
* @param style the style of the <code>toString</code> to create,
* may be <code>null</code>
* @param reflectUpToClass the superclass to reflect up to (inclusive),
* may be <code>null</code>
* @return the String result
* @throws IllegalArgumentException if the Object is <code>null</code>
*/
public Object toStringWithStatics(Object object, ToStringStyle style, Class reflectUpToClass) {
return ReflectionToStringBuilder.toString(object, style, false, true, reflectUpToClass);
}
/**
* Tests ReflectionToStringBuilder setUpToClass().
*/
public void test_setUpToClass_valid() {
Integer val = new Integer(5);
ReflectionToStringBuilder test = new ReflectionToStringBuilder(val);
test.setUpToClass(Number.class);
}
/**
* Tests ReflectionToStringBuilder setUpToClass().
*/
public void test_setUpToClass_invalid() {
Integer val = new Integer(5);
ReflectionToStringBuilder test = new ReflectionToStringBuilder(val);
try {
test.setUpToClass(String.class);
fail();
} catch (IllegalArgumentException ex) {
// expected
}
}
/**
* Tests ReflectionToStringBuilder.toString() for statics.
*/
class ReflectionStaticFieldsFixture {
static final String staticString = "staticString";
static final int staticInt = 12345;
static final transient String staticTransientString = "staticTransientString";
static final transient int staticTransientInt = 54321;
String instanceString = "instanceString";
int instanceInt = 67890;
transient String transientString = "transientString";
transient int transientInt = 98765;
}
/**
* Test fixture for ReflectionToStringBuilder.toString() for statics.
*/
class SimpleReflectionStaticFieldsFixture {
static final String staticString = "staticString";
static final int staticInt = 12345;
}
/**
* Test fixture for ReflectionToStringBuilder.toString() for statics.
*/
class InheritedReflectionStaticFieldsFixture extends SimpleReflectionStaticFieldsFixture {
static final String staticString2 = "staticString2";
static final int staticInt2 = 67890;
}
public void testReflectionNull() {
assertEquals("<null>", ReflectionToStringBuilder.toString(null));
}
/**
* Points out failure to print anything from appendToString methods using MULTI_LINE_STYLE.
* See issue LANG-372.
*/
class MultiLineTestObject {
Integer i = new Integer(31337);
public String toString() {
return new ToStringBuilder(this).append("testInt", i).toString();
}
}
public void testAppendToStringUsingMultiLineStyle() {
MultiLineTestObject obj = new MultiLineTestObject();
ToStringBuilder testBuilder = new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE)
.appendToString(obj.toString());
assertEquals(testBuilder.toString().indexOf("testInt=31337"), -1);
}
}