/**
* Copyright (C) 2010-2017 Gordon Fraser, Andrea Arcuri and EvoSuite
* contributors
*
* This file is part of EvoSuite.
*
* EvoSuite is free software: you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published
* by the Free Software Foundation, either version 3.0 of the License, or
* (at your option) any later version.
*
* EvoSuite is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with EvoSuite. If not, see <http://www.gnu.org/licenses/>.
*/
package org.evosuite.symbolic;
import static org.junit.Assert.assertEquals;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.List;
import org.evosuite.Properties;
import org.evosuite.symbolic.expr.Constraint;
import org.evosuite.testcase.variable.ArrayReference;
import org.evosuite.testcase.DefaultTestCase;
import org.evosuite.testcase.variable.VariableReference;
import org.junit.Test;
import com.examples.with.different.packagename.concolic.Assertions;
import com.examples.with.different.packagename.concolic.Boxer;
import com.examples.with.different.packagename.concolic.Calculator;
import com.examples.with.different.packagename.concolic.Fraction;
import com.examples.with.different.packagename.concolic.IntHolder;
import com.examples.with.different.packagename.concolic.MemoryCell;
import com.examples.with.different.packagename.concolic.MyEnum;
import com.examples.with.different.packagename.concolic.StaticFields;
import com.examples.with.different.packagename.concolic.StringHandler;
import com.examples.with.different.packagename.concolic.TestCase86;
public class SymbolicObserverTest {
public static void printConstraints(List<BranchCondition> branch_conditions) {
System.out.println("Constraints=");
for (BranchCondition branchCondition : branch_conditions) {
for (Constraint<?> constr : branchCondition
.getSupportingConstraints()) {
System.out.println(constr.toString());
}
System.out.println(branchCondition.getConstraint().toString());
}
}
private static void test_input1() {
String string0 = "aaaaaaaaaaab";
String string1 = "a*b";
boolean boolean0 = StringHandler.stringMatches(string0, string1);
boolean boolean1 = true;
StringHandler.checkEquals(boolean0, boolean1);
}
private static DefaultTestCase build_test_input_1()
throws SecurityException, NoSuchMethodException {
test_input1();
Method string_matches_method = StringHandler.class.getMethod(
"stringMatches", String.class, String.class);
Method checkEquals_method = StringHandler.class.getMethod(
"checkEquals", boolean.class, boolean.class);
TestCaseBuilder tc = new TestCaseBuilder();
VariableReference string0 = tc.appendStringPrimitive("aaaaaaaaaaab");
VariableReference string1 = tc.appendStringPrimitive("a*b");
VariableReference boolean0 = tc.appendMethod(null,
string_matches_method, string0, string1);
VariableReference boolean1 = tc.appendBooleanPrimitive(true);
tc.appendMethod(null, checkEquals_method, boolean0, boolean1);
return tc.getDefaultTestCase();
}
@Test
public void test1() throws SecurityException, NoSuchMethodException {
Properties.CLIENT_ON_THREAD = true;
Properties.PRINT_TO_SYSTEM = true;
Properties.TIMEOUT = 5000000;
DefaultTestCase tc = build_test_input_1();
System.out.println("TestCase=");
System.out.println(tc.toCode());
List<BranchCondition> branch_conditions = ConcolicExecution
.executeConcolic(tc);
printConstraints(branch_conditions);
assertEquals(1, branch_conditions.size());
}
private static void test_input2() {
String string0 = "Togliere sta roba";
StringHandler stringHandler0 = new StringHandler(string0);
String string1 = "TOGLIERE STA ROBA";
stringHandler0.toUpperCase();
boolean boolean0 = stringHandler0.equals(string1);
boolean boolean1 = true;
StringHandler.checkEquals(boolean0, boolean1);
}
private static DefaultTestCase build_test_input_2()
throws SecurityException, NoSuchMethodException {
test_input2();
Constructor<?> constructor = StringHandler.class
.getConstructor(String.class);
Method toUpperCase_method = StringHandler.class
.getMethod("toUpperCase");
Method equals_method = StringHandler.class.getMethod("equals",
String.class);
Method checkEquals_method = StringHandler.class.getMethod(
"checkEquals", boolean.class, boolean.class);
TestCaseBuilder tc = new TestCaseBuilder();
VariableReference string0 = tc
.appendStringPrimitive("Togliere sta roba");
VariableReference stringHandler0 = tc.appendConstructor(constructor,
string0);
VariableReference string1 = tc
.appendStringPrimitive("TOGLIERE STA ROBA");
tc.appendMethod(stringHandler0, toUpperCase_method);
VariableReference boolean0 = tc.appendMethod(stringHandler0,
equals_method, string1);
VariableReference boolean1 = tc.appendBooleanPrimitive(true);
tc.appendMethod(null, checkEquals_method, boolean0, boolean1);
return tc.getDefaultTestCase();
}
@Test
public void test2() throws SecurityException, NoSuchMethodException {
Properties.CLIENT_ON_THREAD = true;
Properties.PRINT_TO_SYSTEM = true;
Properties.TIMEOUT = 5000000;
DefaultTestCase tc = build_test_input_2();
System.out.println("TestCase=");
System.out.println(tc.toCode());
List<BranchCondition> branch_conditions = ConcolicExecution
.executeConcolic(tc);
printConstraints(branch_conditions);
assertEquals(1, branch_conditions.size());
}
private static void test_input3() {
String string0 = "add";
Calculator calculator0 = new Calculator(string0);
double double0 = 1.5;
double double1 = -1.5;
double double2 = calculator0.compute(double0, double1);
double double3 = 0.0;
Assertions.checkEquals(double2, double3);
}
private static DefaultTestCase build_test_input_3()
throws SecurityException, NoSuchMethodException {
test_input3();
Constructor<?> constructor = Calculator.class
.getConstructor(String.class);
Method compute_method = Calculator.class.getMethod("compute",
double.class, double.class);
Method checkEquals_method = Assertions.class.getMethod("checkEquals",
double.class, double.class);
TestCaseBuilder tc = new TestCaseBuilder();
VariableReference string0 = tc.appendStringPrimitive("add");
VariableReference calculator0 = tc.appendConstructor(constructor,
string0);
VariableReference double0 = tc.appendDoublePrimitive(1.5);
VariableReference double1 = tc.appendDoublePrimitive(-1.5);
VariableReference double2 = tc.appendMethod(calculator0,
compute_method, double0, double1);
VariableReference double3 = tc.appendDoublePrimitive(0.0);
tc.appendMethod(null, checkEquals_method, double2, double3);
return tc.getDefaultTestCase();
}
@Test
public void test3() throws SecurityException, NoSuchMethodException {
Properties.CLIENT_ON_THREAD = true;
Properties.PRINT_TO_SYSTEM = true;
Properties.TIMEOUT = 5000000;
DefaultTestCase tc = build_test_input_3();
System.out.println("TestCase=");
System.out.println(tc.toCode());
List<BranchCondition> branch_conditions = ConcolicExecution
.executeConcolic(tc);
printConstraints(branch_conditions);
assertEquals(2, branch_conditions.size());
}
private static void test_input4() {
// IntPrimitiveStmt
int int0 = Integer.MAX_VALUE;
// ConstructorStmt
MemoryCell memoryCell0 = new MemoryCell(int0);
// Assignment Stmt (non-static)
memoryCell0.anotherCell = memoryCell0;
// FieldStmt (non-static)
MemoryCell memoryCell1 = memoryCell0.anotherCell;
// MethodStatement
int int1 = memoryCell0.getValue();
// MethodStatement
int int2 = memoryCell1.getValue();
// MethodStatement
Assertions.checkEquals(int1, int2);
}
private static DefaultTestCase build_test_input_4()
throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
test_input4();
Constructor<?> constructor = MemoryCell.class.getConstructor(int.class);
Field anotherCell_field = MemoryCell.class.getField("anotherCell");
Method getValue_method = MemoryCell.class.getMethod("getValue");
Method checkEquals_method = Assertions.class.getMethod("checkEquals",
int.class, int.class);
TestCaseBuilder tc = new TestCaseBuilder();
VariableReference int0 = tc.appendIntPrimitive(Integer.MAX_VALUE);
VariableReference memoryCell0 = tc.appendConstructor(constructor, int0);
tc.appendAssignment(memoryCell0, anotherCell_field, memoryCell0);
VariableReference memoryCell1 = tc.appendFieldStmt(memoryCell0,
anotherCell_field);
VariableReference int1 = tc.appendMethod(memoryCell0, getValue_method);
VariableReference int2 = tc.appendMethod(memoryCell1, getValue_method);
tc.appendMethod(null, checkEquals_method, int1, int2);
return tc.getDefaultTestCase();
}
@Test
public void test4() throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
Properties.CLIENT_ON_THREAD = true;
Properties.PRINT_TO_SYSTEM = true;
Properties.TIMEOUT = 5000000;
DefaultTestCase tc = build_test_input_4();
System.out.println("TestCase=");
System.out.println(tc.toCode());
List<BranchCondition> branch_conditions = ConcolicExecution
.executeConcolic(tc);
printConstraints(branch_conditions);
assertEquals(1, branch_conditions.size());
}
private static void test_input5() {
// IntPrimitiveStmt
int int0 = Integer.MAX_VALUE;
// IntPrimitiveStmt
int int1 = Integer.MIN_VALUE;
// ConstructorStmt
IntHolder intHolder0 = new IntHolder(int0);
// ConstructorStmt
IntHolder intHolder1 = new IntHolder(int1);
// FieldStmt (non-static)
int int2 = intHolder0.intValue;
// Assignment Stmt (non-static)
intHolder1.intValue = int2;
// MethodStatement
int int3 = intHolder0.getValue();
// MethodStatement
int int4 = intHolder0.getValue();
// MethodStatement
Assertions.checkEquals(int3, int4);
}
private static DefaultTestCase build_test_input_5()
throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
test_input5();
Constructor<?> newIntHolder = IntHolder.class.getConstructor(int.class);
Field intValue = IntHolder.class.getField("intValue");
Method getValue = IntHolder.class.getMethod("getValue");
Method checkEquals = Assertions.class.getMethod("checkEquals",
int.class, int.class);
TestCaseBuilder tc = new TestCaseBuilder();
VariableReference int0 = tc.appendIntPrimitive(Integer.MAX_VALUE);
VariableReference int1 = tc.appendIntPrimitive(Integer.MIN_VALUE);
VariableReference intHolder0 = tc.appendConstructor(newIntHolder, int0);
VariableReference intHolder1 = tc.appendConstructor(newIntHolder, int1);
VariableReference int2 = tc.appendFieldStmt(intHolder0, intValue);
tc.appendAssignment(intHolder1, intValue, int2);
VariableReference int3 = tc.appendMethod(intHolder0, getValue);
VariableReference int4 = tc.appendMethod(intHolder1, getValue);
tc.appendMethod(null, checkEquals, int3, int4);
return tc.getDefaultTestCase();
}
@Test
public void test5() throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
Properties.CLIENT_ON_THREAD = true;
Properties.PRINT_TO_SYSTEM = true;
Properties.TIMEOUT = 5000000;
DefaultTestCase tc = build_test_input_5();
System.out.println("TestCase=");
System.out.println(tc.toCode());
List<BranchCondition> branch_conditions = ConcolicExecution
.executeConcolic(tc);
printConstraints(branch_conditions);
assertEquals(1, branch_conditions.size());
}
private static void test_input6() {
String string0 = "Togliere sta roba";
StaticFields.string_field = string0;
String string1 = StaticFields.string_field;
boolean boolean0 = StaticFields.equals(string0, string1);
boolean boolean1 = true;
Assertions.checkEquals(boolean0, boolean1);
}
private static DefaultTestCase build_test_input_6()
throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
test_input6();
Field string_field = StaticFields.class.getField("string_field");
Method equals = StaticFields.class.getMethod("equals", String.class,
String.class);
Method checkEquals = Assertions.class.getMethod("checkEquals",
boolean.class, boolean.class);
TestCaseBuilder tc = new TestCaseBuilder();
VariableReference string0 = tc
.appendStringPrimitive("Togliere sta roba");
tc.appendAssignment(null, string_field, string0);
VariableReference string1 = tc.appendStaticFieldStmt(string_field);
VariableReference boolean0 = tc.appendMethod(null, equals, string0,
string1);
VariableReference boolean1 = tc.appendBooleanPrimitive(true);
tc.appendMethod(null, checkEquals, boolean0, boolean1);
return tc.getDefaultTestCase();
}
@Test
public void test6() throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
Properties.CLIENT_ON_THREAD = true;
Properties.PRINT_TO_SYSTEM = true;
Properties.TIMEOUT = 5000000;
DefaultTestCase tc = build_test_input_6();
System.out.println("TestCase=");
System.out.println(tc.toCode());
List<BranchCondition> branch_conditions = ConcolicExecution
.executeConcolic(tc);
printConstraints(branch_conditions);
assertEquals(1, branch_conditions.size());
}
private static void test_input7() {
// NullStmt
String string0 = null;
// Assignment Stmt
String string1 = string0;
}
private static void test_input8() {
// EnumPrimitiveStmt
MyEnum myEnum0 = MyEnum.VALUE1;
MyEnum myEnum1 = MyEnum.VALUE1;
MyEnum myEnum2 = MyEnum.VALUE2;
}
private static DefaultTestCase build_test_input_7()
throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
test_input7();
TestCaseBuilder tc = new TestCaseBuilder();
tc.appendNull(String.class);
return tc.getDefaultTestCase();
}
@Test
public void test7() throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
Properties.CLIENT_ON_THREAD = true;
Properties.PRINT_TO_SYSTEM = true;
Properties.TIMEOUT = 5000000;
DefaultTestCase tc = build_test_input_7();
System.out.println("TestCase=");
System.out.println(tc.toCode());
List<BranchCondition> branch_conditions = ConcolicExecution
.executeConcolic(tc);
printConstraints(branch_conditions);
assertEquals(0, branch_conditions.size());
}
private static DefaultTestCase build_test_input_8()
throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
test_input8();
TestCaseBuilder tc = new TestCaseBuilder();
tc.appendEnumPrimitive(MyEnum.VALUE1);
tc.appendEnumPrimitive(MyEnum.VALUE1);
tc.appendEnumPrimitive(MyEnum.VALUE2);
return tc.getDefaultTestCase();
}
@Test
public void test8() throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
Properties.CLIENT_ON_THREAD = true;
Properties.PRINT_TO_SYSTEM = true;
Properties.TIMEOUT = 5000000;
DefaultTestCase tc = build_test_input_8();
System.out.println("TestCase=");
System.out.println(tc.toCode());
List<BranchCondition> branch_conditions = ConcolicExecution
.executeConcolic(tc);
printConstraints(branch_conditions);
assertEquals(0, branch_conditions.size());
}
private static void test_input9() {
// ArrayStmt
int[] intArray0 = new int[10];
// ArrayStmt
double[] doubleArray0 = new double[10];
// ArrayStmt
String[] stringArray0 = new String[10];
// ArrayStmt
int[][] intMatrix0 = new int[3][3];
// IntPrimitiveStmt
int int0 = Integer.MAX_VALUE;
// store
intArray0[1] = int0;
// IntPrimitiveStmt
int int1 = Integer.MIN_VALUE;
// load
int1 = intArray0[1];
// checkEquals
Assertions.checkEquals(int0, int1);
}
private static DefaultTestCase build_test_input_9()
throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
test_input9();
Method checkEquals = Assertions.class.getMethod("checkEquals",
int.class, int.class);
TestCaseBuilder tc = new TestCaseBuilder();
ArrayReference intArray0 = tc.appendArrayStmt(int[].class, 10);
tc.appendArrayStmt(double[].class, 11);
tc.appendArrayStmt(String[].class, 12);
tc.appendArrayStmt(int[].class, 3, 3);
VariableReference int0 = tc.appendIntPrimitive(Integer.MAX_VALUE);
tc.appendAssignment(intArray0, 1, int0);
VariableReference int1 = tc.appendIntPrimitive(Integer.MIN_VALUE);
tc.appendAssignment(int1, intArray0, 1);
tc.appendMethod(null, checkEquals, int0, int1);
return tc.getDefaultTestCase();
}
@Test
public void test9() throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
Properties.CLIENT_ON_THREAD = true;
Properties.PRINT_TO_SYSTEM = true;
Properties.TIMEOUT = 5000000;
DefaultTestCase tc = build_test_input_9();
System.out.println("TestCase=");
System.out.println(tc.toCode());
List<BranchCondition> branch_conditions = ConcolicExecution
.executeConcolic(tc);
printConstraints(branch_conditions);
assertEquals(1, branch_conditions.size());
}
private static void test_input10() {
// IntPrimitiveStmt
int int0 = Integer.MAX_VALUE;
// IntPrimitiveStmt
int int1 = Integer.MIN_VALUE;
// MethodStmt
int int2 = Math.max(int0, int1);
// MethodStmt
Assertions.checkEquals(int0, int2);
}
private static DefaultTestCase build_test_input_10()
throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
test_input10();
Method checkEquals = Assertions.class.getMethod("checkEquals",
int.class, int.class);
Method max = Math.class.getMethod("max", int.class, int.class);
TestCaseBuilder tc = new TestCaseBuilder();
VariableReference int0 = tc.appendIntPrimitive(Integer.MAX_VALUE);
VariableReference int1 = tc.appendIntPrimitive(Integer.MIN_VALUE);
VariableReference int2 = tc.appendMethod(null, max, int0, int1);
tc.appendMethod(null, checkEquals, int0, int2);
return tc.getDefaultTestCase();
}
@Test
public void test10() throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
Properties.CLIENT_ON_THREAD = true;
Properties.PRINT_TO_SYSTEM = true;
Properties.TIMEOUT = 5000000;
DefaultTestCase tc = build_test_input_10();
System.out.println("TestCase=");
System.out.println(tc.toCode());
List<BranchCondition> branch_conditions = ConcolicExecution
.executeConcolic(tc);
printConstraints(branch_conditions);
assertEquals(1, branch_conditions.size());
}
private static DefaultTestCase build_test_input_11()
throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
Constructor<?> newBoolean = Boolean.class.getConstructor(boolean.class);
Constructor<?> newInteger = Integer.class.getConstructor(int.class);
Constructor<?> newByte = Byte.class.getConstructor(byte.class);
Constructor<?> newShort = Short.class.getConstructor(short.class);
Constructor<?> newChar = Character.class.getConstructor(char.class);
Constructor<?> newLong = Long.class.getConstructor(long.class);
Constructor<?> newFloat = Float.class.getConstructor(float.class);
Constructor<?> newDouble = Double.class.getConstructor(double.class);
Method booleanValue = Boolean.class.getMethod("booleanValue");
Method intValue = Integer.class.getMethod("intValue");
Method byteValue = Byte.class.getMethod("byteValue");
Method shortValue = Short.class.getMethod("shortValue");
Method charValue = Character.class.getMethod("charValue");
Method longValue = Long.class.getMethod("longValue");
Method floatValue = Float.class.getMethod("floatValue");
Method doubleValue = Double.class.getMethod("doubleValue");
Method checkBooleanEquals = Assertions.class.getMethod("checkEquals",
boolean.class, boolean.class);
Method checkIntEquals = Assertions.class.getMethod("checkEquals",
int.class, int.class);
Method checkByteEquals = Assertions.class.getMethod("checkEquals",
byte.class, byte.class);
Method checkShortEquals = Assertions.class.getMethod("checkEquals",
short.class, short.class);
Method checkCharEquals = Assertions.class.getMethod("checkEquals",
char.class, char.class);
Method checkLongEquals = Assertions.class.getMethod("checkEquals",
long.class, long.class);
Method checkFloatEquals = Assertions.class.getMethod("checkEquals",
float.class, float.class);
Method checkDoubleEquals = Assertions.class.getMethod("checkEquals",
double.class, double.class);
TestCaseBuilder tc = new TestCaseBuilder();
VariableReference int0 = tc.appendIntPrimitive(Integer.MAX_VALUE);
VariableReference integer0 = tc.appendConstructor(newInteger, int0);
VariableReference int1 = tc.appendMethod(integer0, intValue);
VariableReference byte0 = tc.appendBytePrimitive(Byte.MAX_VALUE);
VariableReference byte_instance0 = tc.appendConstructor(newByte, byte0);
VariableReference byte1 = tc.appendMethod(byte_instance0, byteValue);
VariableReference short0 = tc.appendShortPrimitive(Short.MAX_VALUE);
VariableReference short_instance0 = tc.appendConstructor(newShort,
short0);
VariableReference short1 = tc.appendMethod(short_instance0, shortValue);
VariableReference char0 = tc.appendCharPrimitive(Character.MAX_VALUE);
VariableReference character0 = tc.appendConstructor(newChar, char0);
VariableReference char1 = tc.appendMethod(character0, charValue);
VariableReference long0 = tc.appendLongPrimitive(Long.MAX_VALUE);
VariableReference long_instance0 = tc.appendConstructor(newLong, long0);
VariableReference long1 = tc.appendMethod(long_instance0, longValue);
VariableReference float1 = tc.appendFloatPrimitive(Float.MAX_VALUE);
VariableReference float_instance1 = tc.appendConstructor(newFloat,
float1);
VariableReference float2 = tc.appendMethod(float_instance1, floatValue);
VariableReference double0 = tc.appendDoublePrimitive(Double.MAX_VALUE);
VariableReference double_instance1 = tc.appendConstructor(newDouble,
double0);
VariableReference double1 = tc.appendMethod(double_instance1,
doubleValue);
VariableReference boolean0 = tc.appendBooleanPrimitive(Boolean.TRUE);
VariableReference boolean_instance0 = tc.appendConstructor(newBoolean,
boolean0);
VariableReference boolean1 = tc.appendMethod(boolean_instance0,
booleanValue);
tc.appendMethod(null, checkIntEquals, int0, int1);
tc.appendMethod(null, checkByteEquals, byte0, byte1);
tc.appendMethod(null, checkShortEquals, short0, short1);
tc.appendMethod(null, checkCharEquals, char0, char1);
tc.appendMethod(null, checkFloatEquals, float1, float2);
tc.appendMethod(null, checkLongEquals, long0, long1);
tc.appendMethod(null, checkDoubleEquals, double0, double1);
tc.appendMethod(null, checkBooleanEquals, boolean0, boolean1);
return tc.getDefaultTestCase();
}
@Test
public void test11() throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
Properties.CLIENT_ON_THREAD = true;
Properties.PRINT_TO_SYSTEM = true;
Properties.TIMEOUT = 5000000;
DefaultTestCase tc = build_test_input_11();
System.out.println("TestCase=");
System.out.println(tc.toCode());
List<BranchCondition> branch_conditions = ConcolicExecution
.executeConcolic(tc);
printConstraints(branch_conditions);
assertEquals(8, branch_conditions.size());
}
private static DefaultTestCase build_test_input_12()
throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
Constructor<?> newString = String.class.getConstructor(String.class);
Method length = String.class.getMethod("length");
Method checkIntEquals = Assertions.class.getMethod("checkEquals",
int.class, int.class);
TestCaseBuilder tc = new TestCaseBuilder();
VariableReference string0 = tc
.appendStringPrimitive("Togliere sta roba");
VariableReference string1 = tc.appendConstructor(newString, string0);
VariableReference int0 = tc.appendMethod(string0, length);
VariableReference int1 = tc.appendMethod(string1, length);
tc.appendMethod(null, checkIntEquals, int0, int1);
return tc.getDefaultTestCase();
}
@Test
public void test12() throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
Properties.CLIENT_ON_THREAD = true;
Properties.PRINT_TO_SYSTEM = true;
Properties.TIMEOUT = 5000000;
DefaultTestCase tc = build_test_input_12();
System.out.println("TestCase=");
System.out.println(tc.toCode());
List<BranchCondition> branch_conditions = ConcolicExecution
.executeConcolic(tc);
printConstraints(branch_conditions);
assertEquals(1, branch_conditions.size());
}
private static DefaultTestCase build_test_input_13()
throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
Method checkDoubleEquals = Assertions.class.getMethod("checkEquals",
double.class, double.class);
TestCaseBuilder tc = new TestCaseBuilder();
VariableReference int0 = tc.appendIntPrimitive(10);
VariableReference int1 = tc.appendIntPrimitive(20);
tc.appendMethod(null, checkDoubleEquals, int0, int1);
return tc.getDefaultTestCase();
}
@Test
public void test13() throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
Properties.CLIENT_ON_THREAD = true;
Properties.PRINT_TO_SYSTEM = true;
Properties.TIMEOUT = 5000000;
DefaultTestCase tc = build_test_input_13();
System.out.println("TestCase=");
System.out.println(tc.toCode());
List<BranchCondition> branch_conditions = ConcolicExecution
.executeConcolic(tc);
printConstraints(branch_conditions);
assertEquals(1, branch_conditions.size());
}
@Test
public void test_input_14() {
int int0 = Integer.MAX_VALUE;
Integer integer0 = Boxer.boxInteger(int0);
int int1 = Boxer.unboxInteger(integer0);
Assertions.checkEquals(int0, int1);
}
private static DefaultTestCase build_test_input_14()
throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
Method checkIntEquals = Assertions.class.getMethod("checkEquals",
int.class, int.class);
Method boxInteger = Boxer.class.getMethod("boxInteger", Integer.class);
Method unboxInteger = Boxer.class.getMethod("unboxInteger", int.class);
TestCaseBuilder tc = new TestCaseBuilder();
VariableReference int0 = tc.appendIntPrimitive(Integer.MAX_VALUE);
VariableReference integer0 = tc.appendMethod(null, boxInteger, int0);
VariableReference int1 = tc.appendMethod(null, unboxInteger, integer0);
tc.appendMethod(null, checkIntEquals, int0, int1);
return tc.getDefaultTestCase();
}
@Test
public void test14() throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
Properties.CLIENT_ON_THREAD = true;
Properties.PRINT_TO_SYSTEM = true;
Properties.TIMEOUT = 5000000;
DefaultTestCase tc = build_test_input_14();
System.out.println("TestCase=");
System.out.println(tc.toCode());
List<BranchCondition> branch_conditions = ConcolicExecution
.executeConcolic(tc);
printConstraints(branch_conditions);
assertEquals(1, branch_conditions.size());
}
// Fraction fraction0 = Fraction.ONE_FIFTH;
private static DefaultTestCase build_test_input_15()
throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
Field one_fifth = Fraction.class.getField("ONE_FIFTH");
TestCaseBuilder tc = new TestCaseBuilder();
tc.appendStaticFieldStmt(one_fifth);
return tc.getDefaultTestCase();
}
@Test
public void test15() throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
Properties.CLIENT_ON_THREAD = true;
Properties.PRINT_TO_SYSTEM = true;
Properties.TIMEOUT = 5000000;
DefaultTestCase tc = build_test_input_15();
System.out.println("TestCase=");
System.out.println(tc.toCode());
List<BranchCondition> branch_conditions = ConcolicExecution
.executeConcolic(tc);
printConstraints(branch_conditions);
assertEquals(0, branch_conditions.size());
}
// Double double0 = null;
// Double double1 = Double.valueOf((double) double0);
private static DefaultTestCase build_test_input_16()
throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
Method valueOf = Double.class.getMethod("valueOf", double.class);
TestCaseBuilder tc = new TestCaseBuilder();
VariableReference double0 = tc.appendNull(Double.class);
tc.appendMethod(null, valueOf, double0);
return tc.getDefaultTestCase();
}
@Test
public void test16() throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
Properties.CLIENT_ON_THREAD = true;
Properties.PRINT_TO_SYSTEM = true;
Properties.TIMEOUT = 5000000;
DefaultTestCase tc = build_test_input_16();
System.out.println("TestCase=");
System.out.println(tc.toCode());
List<BranchCondition> branch_conditions = ConcolicExecution
.executeConcolic(tc);
printConstraints(branch_conditions);
assertEquals(0, branch_conditions.size());
}
private static DefaultTestCase build_test_input_17()
throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
Method test = TestCase86.class.getMethod("test", int.class);
TestCaseBuilder tc = new TestCaseBuilder();
VariableReference int0 = tc.appendIntPrimitive(Integer.MAX_VALUE);
tc.appendMethod(null, test, int0);
return tc.getDefaultTestCase();
}
@Test
public void test17() throws SecurityException, NoSuchMethodException,
NoSuchFieldException {
Properties.CLIENT_ON_THREAD = true;
Properties.PRINT_TO_SYSTEM = true;
Properties.TIMEOUT = 5000000;
DefaultTestCase tc = build_test_input_17();
System.out.println("TestCase=");
System.out.println(tc.toCode());
List<BranchCondition> branch_conditions = ConcolicExecution
.executeConcolic(tc);
printConstraints(branch_conditions);
assertEquals(1, branch_conditions.size());
}
}