gt: 		VariableReference char0 = tc.appendCharPrimitive('a');
context: /**
   * Copyright (C) 2010-2015 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 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 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.Method;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  
  import org.evosuite.Properties;
  import org.evosuite.TestGenerationContext;
  import org.evosuite.symbolic.expr.Variable;
  import org.evosuite.testcase.DefaultTestCase;
  import org.evosuite.testcase.execution.TestCaseExecutor;
  import org.evosuite.testcase.variable.VariableReference;
  import org.junit.After;
  import org.junit.Before;
  import org.junit.Test;
  
  import com.examples.with.different.packagename.concolic.TestCase0;
  import com.examples.with.different.packagename.concolic.TestCase1;
  import com.examples.with.different.packagename.concolic.TestCase10;
  import com.examples.with.different.packagename.concolic.TestCase100;
  import com.examples.with.different.packagename.concolic.TestCase101;
  import com.examples.with.different.packagename.concolic.TestCase11;
  import com.examples.with.different.packagename.concolic.TestCase12;
  import com.examples.with.different.packagename.concolic.TestCase13;
  import com.examples.with.different.packagename.concolic.TestCase14;
  import com.examples.with.different.packagename.concolic.TestCase15;
  import com.examples.with.different.packagename.concolic.TestCase16;
  import com.examples.with.different.packagename.concolic.TestCase17;
  import com.examples.with.different.packagename.concolic.TestCase18;
  import com.examples.with.different.packagename.concolic.TestCase19;
  import com.examples.with.different.packagename.concolic.TestCase2;
  import com.examples.with.different.packagename.concolic.TestCase20;
  import com.examples.with.different.packagename.concolic.TestCase21;
  import com.examples.with.different.packagename.concolic.TestCase22;
  import com.examples.with.different.packagename.concolic.TestCase23;
  import com.examples.with.different.packagename.concolic.TestCase24;
  import com.examples.with.different.packagename.concolic.TestCase25;
  import com.examples.with.different.packagename.concolic.TestCase26;
  import com.examples.with.different.packagename.concolic.TestCase27;
  import com.examples.with.different.packagename.concolic.TestCase28;
  import com.examples.with.different.packagename.concolic.TestCase29;
  import com.examples.with.different.packagename.concolic.TestCase3;
  import com.examples.with.different.packagename.concolic.TestCase30;
  import com.examples.with.different.packagename.concolic.TestCase31;
  import com.examples.with.different.packagename.concolic.TestCase32;
  import com.examples.with.different.packagename.concolic.TestCase33;
  import com.examples.with.different.packagename.concolic.TestCase34;
  import com.examples.with.different.packagename.concolic.TestCase35;
  import com.examples.with.different.packagename.concolic.TestCase36;
  import com.examples.with.different.packagename.concolic.TestCase37;
  import com.examples.with.different.packagename.concolic.TestCase38;
  import com.examples.with.different.packagename.concolic.TestCase39;
  import com.examples.with.different.packagename.concolic.TestCase4;
  import com.examples.with.different.packagename.concolic.TestCase40;
  import com.examples.with.different.packagename.concolic.TestCase41;
  import com.examples.with.different.packagename.concolic.TestCase42;
  import com.examples.with.different.packagename.concolic.TestCase43;
  import com.examples.with.different.packagename.concolic.TestCase44;
  import com.examples.with.different.packagename.concolic.TestCase45;
  import com.examples.with.different.packagename.concolic.TestCase46;
  import com.examples.with.different.packagename.concolic.TestCase47;
  import com.examples.with.different.packagename.concolic.TestCase48;
  import com.examples.with.different.packagename.concolic.TestCase49;
  import com.examples.with.different.packagename.concolic.TestCase5;
  import com.examples.with.different.packagename.concolic.TestCase50;
  import com.examples.with.different.packagename.concolic.TestCase51;
  import com.examples.with.different.packagename.concolic.TestCase52;
  import com.examples.with.different.packagename.concolic.TestCase54;
  import com.examples.with.different.packagename.concolic.TestCase56;
  import com.examples.with.different.packagename.concolic.TestCase57;
  import com.examples.with.different.packagename.concolic.TestCase58;
  import com.examples.with.different.packagename.concolic.TestCase59;
  import com.examples.with.different.packagename.concolic.TestCase6;
  import com.examples.with.different.packagename.concolic.TestCase60;
  import com.examples.with.different.packagename.concolic.TestCase61;
  import com.examples.with.different.packagename.concolic.TestCase62;
  import com.examples.with.different.packagename.concolic.TestCase63;
  import com.examples.with.different.packagename.concolic.TestCase64;
  import com.examples.with.different.packagename.concolic.TestCase65;
  import com.examples.with.different.packagename.concolic.TestCase66;
  import com.examples.with.different.packagename.concolic.TestCase67;
  import com.examples.with.different.packagename.concolic.TestCase68;
  import com.examples.with.different.packagename.concolic.TestCase69;
  import com.examples.with.different.packagename.concolic.TestCase7;
  import com.examples.with.different.packagename.concolic.TestCase71;
  import com.examples.with.different.packagename.concolic.TestCase72;
  import com.examples.with.different.packagename.concolic.TestCase73;
  import com.examples.with.different.packagename.concolic.TestCase74;
  import com.examples.with.different.packagename.concolic.TestCase75;
  import com.examples.with.different.packagename.concolic.TestCase76;
  import com.examples.with.different.packagename.concolic.TestCase77;
  import com.examples.with.different.packagename.concolic.TestCase78;
  import com.examples.with.different.packagename.concolic.TestCase79;
  import com.examples.with.different.packagename.concolic.TestCase8;
  import com.examples.with.different.packagename.concolic.TestCase80;
  import com.examples.with.different.packagename.concolic.TestCase81;
  import com.examples.with.different.packagename.concolic.TestCase82;
  import com.examples.with.different.packagename.concolic.TestCase83;
  import com.examples.with.different.packagename.concolic.TestCase84;
  import com.examples.with.different.packagename.concolic.TestCase85;
  import com.examples.with.different.packagename.concolic.TestCase87;
  import com.examples.with.different.packagename.concolic.TestCase88;
  import com.examples.with.different.packagename.concolic.TestCase89;
  import com.examples.with.different.packagename.concolic.TestCase9;
  import com.examples.with.different.packagename.concolic.TestCase90;
  import com.examples.with.different.packagename.concolic.TestCase91;
  import com.examples.with.different.packagename.concolic.TestCase92;
  import com.examples.with.different.packagename.concolic.TestCase94;
  import com.examples.with.different.packagename.concolic.TestCase95;
  import com.examples.with.different.packagename.concolic.TestCase96;
  import com.examples.with.different.packagename.concolic.TestCase97;
  import com.examples.with.different.packagename.concolic.TestCase98;
  import com.examples.with.different.packagename.concolic.TestCase99;
  
  public class ConcolicExecutionTest {
  
  	@After
  	public void resetStaticVariables() {
  		TestGenerationContext.getInstance().resetContext();
  	}
  
  	@Before
  	public void initializeExecutor() {
  		TestCaseExecutor.getInstance().newObservers();
  		TestCaseExecutor.initExecutor();
  	}
  
  	@Test
  	public void testCase0() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase0();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(0, branch_conditions.size());
  	}
  
  	@Test
  	public void testCase1() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase1();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(1, branch_conditions.size());
  	}
  
  	private List<BranchCondition> executeTest(DefaultTestCase tc) {
  		Properties.CLIENT_ON_THREAD = true;
  		Properties.PRINT_TO_SYSTEM = false;
  		Properties.TIMEOUT = 5000;
  		Properties.CONCOLIC_TIMEOUT = 5000000;
  
  		List<BranchCondition> branch_conditions = ConcolicExecution
  				.executeConcolic(tc);
  
  		return branch_conditions;
  	}
  
  	private DefaultTestCase buildTestCase0() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		Method method = TestCase0.class.getMethod("test");
  		tc.appendMethod(null, method);
  		return tc.getDefaultTestCase();
  	}
  
  	/*
  	 * int int0 = ConcolicMarker.mark(179,"int0");
  	 * 
  	 * int int1 = ConcolicMarker.mark(-374,"int1");
  	 */
  	private DefaultTestCase buildTestCase1() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference int0 = tc.appendIntPrimitive(179);
  		VariableReference int1 = tc.appendIntPrimitive(179);
  		Method method = TestCase1.class.getMethod("test", int.class, int.class);
  		tc.appendMethod(null, method, int0, int1);
  		return tc.getDefaultTestCase();
  	}
  
  	//
  	// double double0 = ConcolicMarker.mark(-2020.5367255717083,"var1");
  	// double double1 = ConcolicMarker.mark(698.931685369782,"var2");
  	// double double3 = ConcolicMarker.mark(1.8078644807328579,"var3");
  	// double double4 = ConcolicMarker.mark(1756.567093813958,"var4");
  	//
  	private DefaultTestCase buildTestCase10() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference double0 = tc
  				.appendDoublePrimitive(-2020.5367255717083);
  		VariableReference double1 = tc.appendDoublePrimitive(698.931685369782);
  		VariableReference double3 = tc
  				.appendDoublePrimitive(1.8078644807328579);
  		VariableReference double4 = tc.appendDoublePrimitive(1756.567093813958);
  		Method method = TestCase10.class.getMethod("test", double.class,
  				double.class, double.class, double.class);
  		tc.appendMethod(null, method, double0, double1, double3, double4);
  		return tc.getDefaultTestCase();
  	}
  
  	// int int0 = ConcolicMarker.mark(1, "var1");
  	// int int1 = ConcolicMarker.mark(4, "var2");
  	// int int3 = ConcolicMarker.mark(16, "var3");
  	// int int5 = ConcolicMarker.mark(0, "var4");
  	private DefaultTestCase buildTestCase11() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference int0 = tc.appendIntPrimitive(1);
  		VariableReference int1 = tc.appendIntPrimitive(4);
  		VariableReference int3 = tc.appendIntPrimitive(16);
  		VariableReference int5 = tc.appendIntPrimitive(0);
  		Method method = TestCase11.class.getMethod("test", int.class,
  				int.class, int.class, int.class);
  		tc.appendMethod(null, method, int0, int1, int3, int5);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase10() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase10();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(1, branch_conditions.size());
  	}
  
  	@Test
  	public void testCase11() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase11();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(3, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase12() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference long0 = tc.appendLongPrimitive(1);
  		VariableReference long1 = tc.appendLongPrimitive(4);
  		VariableReference long3 = tc.appendLongPrimitive(16);
  		VariableReference long5 = tc.appendLongPrimitive(0);
  		Method method = TestCase12.class.getMethod("test", long.class,
  				long.class, long.class, long.class);
  		tc.appendMethod(null, method, long0, long1, long3, long5);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase12() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase12();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(3, branch_conditions.size());
  	}
  
  	// double double0 = ConcolicMarker.mark(DOUBLE_VALUE, "double0");
  	private DefaultTestCase buildTestCase13() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference double0 = tc
  				.appendDoublePrimitive(TestCase13.DOUBLE_VALUE);
  		Method method = TestCase13.class.getMethod("test", double.class);
  		tc.appendMethod(null, method, double0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase13() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase13();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(1, branch_conditions.size());
  	}
  
  	// double double1 = ConcolicMarker.mark(DOUBLE_VALUE, "double1");
  	private DefaultTestCase buildTestCase14() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference double1 = tc
  				.appendDoublePrimitive(TestCase14.DOUBLE_VALUE);
  		Method method = TestCase14.class.getMethod("test", double.class);
  		tc.appendMethod(null, method, double1);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase14() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase14();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(22, branch_conditions.size());
  	}
  
  	// double double0 = ConcolicMarker.mark(DOUBLE_CONSTANT, "double0");
  	private DefaultTestCase buildTestCase15() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference double1 = tc
  				.appendDoublePrimitive(TestCase15.DOUBLE_CONSTANT);
  		Method method = TestCase15.class.getMethod("test", double.class);
  		tc.appendMethod(null, method, double1);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase15() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase15();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(4, branch_conditions.size());
  	}
  
  	// int int0 = ConcolicMarker.mark(-99100191, "int0");
  	// int int1 = ConcolicMarker.mark(99100191, "int1");
  	// long long0 = ConcolicMarker.mark(-991001911414177541L, "long0");
  	// long long1 = ConcolicMarker.mark(991001911414177541L, "long1");
  	// float float0 = ConcolicMarker.mark(-0.0099100191F, "float0");
  	// float float1 = ConcolicMarker.mark(+0.0099100191F, "float1");
  	// double double0 = ConcolicMarker.mark(-0.0099100191F, "double0");
  	// double double1 = ConcolicMarker.mark(+0.0099100191F, "double1");
  	private DefaultTestCase buildTestCase16() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference int0 = tc.appendIntPrimitive(-99100191);
  		VariableReference int1 = tc.appendIntPrimitive(99100191);
  
  		VariableReference long0 = tc.appendLongPrimitive(-991001911414177541L);
  		VariableReference long1 = tc.appendLongPrimitive(991001911414177541L);
  
  		VariableReference float0 = tc.appendFloatPrimitive(-0.0099100191F);
  		VariableReference float1 = tc.appendFloatPrimitive(+0.0099100191F);
  
  		VariableReference double0 = tc.appendDoublePrimitive(-0.0099100191F);
  		VariableReference double1 = tc.appendDoublePrimitive(+0.0099100191F);
  
  		Method method = TestCase16.class.getMethod("test", int.class,
  				int.class, long.class, long.class, float.class, float.class,
  				double.class, double.class);
  		tc.appendMethod(null, method, int0, int1, long0, long1, float0, float1,
  				double0, double1);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase16() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase16();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(4, branch_conditions.size());
  	}
  
  	// float float0 = ConcolicMarker.mark(FLOAT_VALUE, "float0");
  	// double double0 = ConcolicMarker.mark(DOUBLE_VALUE, "double0");
  	private DefaultTestCase buildTestCase17() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference float0 = tc
  				.appendFloatPrimitive(TestCase17.FLOAT_VALUE);
  		VariableReference double0 = tc
  				.appendDoublePrimitive(TestCase17.DOUBLE_VALUE);
  
  		Method method = TestCase17.class.getMethod("test", float.class,
  				double.class);
  		tc.appendMethod(null, method, float0, double0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase17() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase17();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(2, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase18() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference float0 = tc
  				.appendFloatPrimitive(TestCase18.FLOAT_VALUE);
  		VariableReference double0 = tc
  				.appendDoublePrimitive(TestCase18.DOUBLE_VALUE);
  
  		Method method = TestCase18.class.getMethod("test", float.class,
  				double.class);
  		tc.appendMethod(null, method, float0, double0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase18() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase18();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(2, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase19() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference float0 = tc
  				.appendFloatPrimitive(TestCase19.FLOAT_VALUE);
  		VariableReference double0 = tc
  				.appendDoublePrimitive(TestCase19.DOUBLE_VALUE);
  
  		Method method = TestCase19.class.getMethod("test", float.class,
  				double.class);
  		tc.appendMethod(null, method, float0, double0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase19() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase19();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(2, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase20() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference float0 = tc
  				.appendFloatPrimitive(TestCase20.FLOAT_VALUE);
  		VariableReference double0 = tc
  				.appendDoublePrimitive(TestCase20.DOUBLE_VALUE);
  
  		Method method = TestCase20.class.getMethod("test", float.class,
  				double.class);
  		tc.appendMethod(null, method, float0, double0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase20() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase20();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(2, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase21() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference float0 = tc
  				.appendFloatPrimitive(TestCase21.FLOAT_VALUE);
  		VariableReference double0 = tc
  				.appendDoublePrimitive(TestCase21.DOUBLE_VALUE);
  
  		Method method = TestCase21.class.getMethod("test", float.class,
  				double.class);
  		tc.appendMethod(null, method, float0, double0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase21() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase21();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(2, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase22() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference float0 = tc
  				.appendFloatPrimitive(TestCase22.FLOAT_VALUE_1);
  		VariableReference double0 = tc
  				.appendDoublePrimitive(TestCase22.DOUBLE_VALUE_1);
  
  		Method method = TestCase22.class.getMethod("test", float.class,
  				double.class);
  		tc.appendMethod(null, method, float0, double0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase22() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase22();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(2, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase23() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string0 = tc
  				.appendStringPrimitive(TestCase23.STRING_VALUE);
  
  		Method method = TestCase23.class.getMethod("test", String.class);
  		tc.appendMethod(null, method, string0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase23() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase23();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(1, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase24() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string0 = tc
  				.appendStringPrimitive(TestCase24.STRING_VALUE);
  
  		Method method = TestCase24.class.getMethod("test", String.class);
  		tc.appendMethod(null, method, string0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase24() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase24();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(3, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase25() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string0 = tc
  				.appendStringPrimitive(TestCase25.STRING_VALUE);
  
  		Method method = TestCase25.class.getMethod("test", String.class);
  		tc.appendMethod(null, method, string0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase25() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase25();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(8, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase26() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string0 = tc
  				.appendStringPrimitive(TestCase26.STRING_VALUE_PART_1);
  
  		Method method = TestCase26.class.getMethod("test", String.class);
  		tc.appendMethod(null, method, string0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase26() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase26();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(1, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase27() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string0 = tc
  				.appendStringPrimitive(TestCase27.STRING_VALUE);
  
  		Method method = TestCase27.class.getMethod("test", String.class);
  		tc.appendMethod(null, method, string0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase27() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase27();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(8, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase28() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string0 = tc
  				.appendStringPrimitive(TestCase28.STRING_VALUE);
  
  		Method method = TestCase28.class.getMethod("test", String.class);
  		tc.appendMethod(null, method, string0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase28() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase28();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(5, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase29() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference boolean0 = tc.appendBooleanPrimitive(true);
  		VariableReference boolean1 = tc.appendBooleanPrimitive(false);
  		Method method = TestCase29.class.getMethod("test", boolean.class,
  				boolean.class);
  		tc.appendMethod(null, method, boolean0, boolean1);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase29() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase29();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(2, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase30() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string0 = tc
  				.appendStringPrimitive(TestCase30.STRING_VALUE);
  
  		Method method = TestCase30.class.getMethod("test", String.class);
  		tc.appendMethod(null, method, string0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase30() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase30();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(0, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase31() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string0 = tc
  				.appendStringPrimitive(TestCase31.STRING_VALUE);
  
  		Method method = TestCase31.class.getMethod("test", String.class);
  		tc.appendMethod(null, method, string0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase31() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase31();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(2, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase32() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string0 = tc
  				.appendStringPrimitive(TestCase32.STRING_VALUE);
  
  		Method method = TestCase32.class.getMethod("test", String.class);
  		tc.appendMethod(null, method, string0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase32() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase32();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(0, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase33() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string0 = tc.appendStringPrimitive("foo");
  
  		Method method = TestCase33.class.getMethod("test", String.class);
  		tc.appendMethod(null, method, string0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase33() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase33();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(1, branch_conditions.size());
  	}
  
  	// String string0 = ConcolicMarker.mark("Togliere sta roba", "string0");
  	private DefaultTestCase buildTestCase34() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string0 = tc
  				.appendStringPrimitive("Togliere sta roba");
  
  		Method method = TestCase34.class.getMethod("test", String.class);
  		tc.appendMethod(null, method, string0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase34() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase34();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(1, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase35() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string0 = tc
  				.appendStringPrimitive(TestCase35.STRING_VALUE);
  
  		Method method = TestCase35.class.getMethod("test", String.class);
  		tc.appendMethod(null, method, string0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase35() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase35();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(3, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase36() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string0 = tc
  				.appendStringPrimitive(TestCase36.STRING_VALUE);
  
  		Method method = TestCase36.class.getMethod("test", String.class);
  		tc.appendMethod(null, method, string0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase36() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase36();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(0, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase37() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference int0 = tc.appendIntPrimitive(Integer.MAX_VALUE);
  
  		Method method = TestCase37.class.getMethod("test", int.class);
  		tc.appendMethod(null, method, int0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase37() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase37();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(1, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase3() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference int0 = tc.appendIntPrimitive(-1);
  
  		Method method = TestCase3.class.getMethod("test", int.class);
  		tc.appendMethod(null, method, int0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase3() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase3();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(2, branch_conditions.size());
  	}
  
  	// int int0 = ConcolicMarker.mark(15, "int0");
  	// boolean boolean0 = ConcolicMarker.mark(true, "boolean0");
  	// short short0 = ConcolicMarker.mark(Short.MAX_VALUE, "short0");
  	// byte byte0 = ConcolicMarker.mark(Byte.MAX_VALUE, "byte0");
  	// char char0 = ConcolicMarker.mark(Character.MAX_VALUE, "char0");
  	// long long0 = ConcolicMarker.mark(Long.MAX_VALUE, "long0");
  	// float float0 = ConcolicMarker.mark(Float.MAX_VALUE, "float0");
  	// double double0 = ConcolicMarker.mark(Double.MAX_VALUE, "double0");
  	private DefaultTestCase buildTestCase38() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference int0 = tc.appendIntPrimitive(15);
  		VariableReference boolean0 = tc.appendBooleanPrimitive(true);
  		VariableReference short0 = tc.appendShortPrimitive(Short.MAX_VALUE);
  		VariableReference byte0 = tc.appendBytePrimitive(Byte.MAX_VALUE);
  		VariableReference char0 = tc.appendCharPrimitive(Character.MAX_VALUE);
  		VariableReference long0 = tc.appendLongPrimitive(Long.MAX_VALUE);
  		VariableReference float0 = tc.appendFloatPrimitive(Float.MAX_VALUE);
  		VariableReference double0 = tc.appendDoublePrimitive(Float.MAX_VALUE);
  
  		Method method = TestCase38.class.getMethod("test", int.class,
  				boolean.class, short.class, byte.class, char.class, long.class,
  				float.class, double.class);
  		tc.appendMethod(null, method, int0, boolean0, short0, byte0, char0,
  				long0, float0, double0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase38() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase38();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(7, branch_conditions.size());
  	}
  
  	// final int ARRAY_SIZE = 20;
  	// int int0 = ConcolicMarker.mark(ARRAY_SIZE, "int0");
  	// String string2 = ConcolicMarker.mark(ROBA, "string2");
  	private DefaultTestCase buildTestCase39() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference int0 = tc.appendIntPrimitive(20);
  		VariableReference string2 = tc.appendStringPrimitive(TestCase39.ROBA);
  
  		Method method = TestCase39.class.getMethod("test", int.class,
  				String.class);
  		tc.appendMethod(null, method, int0, string2);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase39() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase39();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(2, branch_conditions.size());
  	}
  
  	// int int0 = ConcolicMarker.mark(10, "int0");
  	// int int1 = ConcolicMarker.mark(1, "int1");
  	// float float0 = ConcolicMarker.mark(Float.POSITIVE_INFINITY, "float0");
  	private DefaultTestCase buildTestCase40() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference int0 = tc.appendIntPrimitive(10);
  		VariableReference int1 = tc.appendIntPrimitive(1);
  		VariableReference float0 = tc
  				.appendFloatPrimitive(Float.POSITIVE_INFINITY);
  
  		Method method = TestCase40.class.getMethod("test", int.class,
  				int.class, float.class);
  		tc.appendMethod(null, method, int0, int1, float0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase40() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase40();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(1, branch_conditions.size());
  	}
  
  	// int int0 = ConcolicMarker.mark(0,"var0");
  	// int int1 = ConcolicMarker.mark(0,"var1");
  	// int int3 = ConcolicMarker.mark(1,"var2");
  	// int int4 = ConcolicMarker.mark(1,"var3");
  	private DefaultTestCase buildTestCase41() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference int0 = tc.appendIntPrimitive(0);
  		VariableReference int1 = tc.appendIntPrimitive(0);
  		VariableReference int3 = tc.appendIntPrimitive(1);
  		VariableReference int4 = tc.appendIntPrimitive(1);
  
  		Method method = TestCase41.class.getMethod("test", int.class,
  				int.class, int.class, int.class);
  		tc.appendMethod(null, method, int0, int1, int3, int4);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase41() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase41();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(8, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase42() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  
  		Method method = TestCase42.class.getMethod("test");
  		tc.appendMethod(null, method);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase42() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase42();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(0, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase43() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference int0 = tc.appendIntPrimitive(Integer.MAX_VALUE);
  
  		Method method = TestCase43.class.getMethod("test", int.class);
  		tc.appendMethod(null, method, int0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase43() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase43();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(1, branch_conditions.size());
  	}
  
  	// int int0 = ConcolicMarker.mark(1111, "var0");
  	// int int1 = ConcolicMarker.mark(1111, "var1");
  	// int int2 = ConcolicMarker.mark(1111, "var2");
  	// int int3 = ConcolicMarker.mark(1111, "var3");
  	// int int4 = ConcolicMarker.mark(-285, "var4");
  	// int int5 = ConcolicMarker.mark(-285, "var5");
  	// int int6 = ConcolicMarker.mark(6, "var6");
  	// int int7 = ConcolicMarker.mark(302, "var7");
  	// int int8 = ConcolicMarker.mark(1565, "var8");
  	// int int9 = ConcolicMarker.mark(1893, "var9");
  	// int int10 = ConcolicMarker.mark(-1956, "var10");
  	private DefaultTestCase buildTestCase44() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference int0 = tc.appendIntPrimitive(1111);
  		VariableReference int1 = tc.appendIntPrimitive(1111);
  		VariableReference int2 = tc.appendIntPrimitive(1111);
  		VariableReference int3 = tc.appendIntPrimitive(1111);
  		VariableReference int4 = tc.appendIntPrimitive(-285);
  		VariableReference int5 = tc.appendIntPrimitive(-285);
  		VariableReference int6 = tc.appendIntPrimitive(6);
  		VariableReference int7 = tc.appendIntPrimitive(302);
  		VariableReference int8 = tc.appendIntPrimitive(1565);
  		VariableReference int9 = tc.appendIntPrimitive(1893);
  		VariableReference int10 = tc.appendIntPrimitive(-1956);
  
  		Method method = TestCase44.class.getMethod("test", int.class,
  				int.class, int.class, int.class, int.class, int.class,
  				int.class, int.class, int.class, int.class, int.class);
  		tc.appendMethod(null, method, int0, int1, int2, int3, int4, int5, int6,
  				int7, int8, int9, int10);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase44() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase44();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(10, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase45() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  
  		Method method = TestCase45.class.getMethod("test");
  		tc.appendMethod(null, method);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase45() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase45();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(0, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase46() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string0 = tc
  				.appendStringPrimitive("\\5b;\u001C,?\u0011\u0010\u001E]\"");
  		VariableReference string1 = tc
  				.appendStringPrimitive("\\5b;\u001C,?\u0011\u0010\u001E]\"");
  		VariableReference string2 = tc
  				.appendStringPrimitive("\\5b;\u001C,?\u0011\u0010\u001E]\"");
  		VariableReference string3 = tc
  				.appendStringPrimitive("\\5b;\u001C,?\u0011\u0010\u001E]\"");
  		VariableReference string4 = tc
  				.appendStringPrimitive("\\5b;\u001C,?\u0011\u0010\u001E]\"");
  		VariableReference string5 = tc
  				.appendStringPrimitive("\\5b;\u001C,?\u0011\u0010\u001E]\"");
  		VariableReference string6 = tc
  				.appendStringPrimitive("\\5b;\u001C,?\u0011\u0010\u001E]\"");
  		VariableReference string7 = tc
  				.appendStringPrimitive("\\5b;\u001C,?\u0011\u0010\u001E]\"");
  		VariableReference string8 = tc.appendStringPrimitive("ness");
  		VariableReference string9 = tc.appendStringPrimitive("iciti");
  		VariableReference string10 = tc.appendStringPrimitive("iciti");
  		VariableReference string11 = tc.appendStringPrimitive("doc");
  		VariableReference string12 = tc.appendStringPrimitive("text");
  		VariableReference string13 = tc.appendStringPrimitive("text");
  		VariableReference string14 = tc.appendStringPrimitive("text");
  		VariableReference string15 = tc.appendStringPrimitive("text");
  		VariableReference string16 = tc.appendStringPrimitive("text");
  		VariableReference string17 = tc.appendStringPrimitive("text");
  		VariableReference string18 = tc.appendStringPrimitive("");
  		VariableReference string19 = tc.appendStringPrimitive("");
  		VariableReference string20 = tc
  				.appendStringPrimitive("urVf3T\r\t\u0019\u000B0 eiM I");
  		VariableReference string21 = tc
  				.appendStringPrimitive("urVf3T\r\t\u0019\u000B0 eiM I");
  		VariableReference string22 = tc
  				.appendStringPrimitive("urVf3T\r\t\u0019\u000B0 eiM I");
  		VariableReference string23 = tc.appendStringPrimitive("ical");
  		Method method = TestCase46.class.getMethod("test", String.class,
  				String.class, String.class, String.class, String.class,
  				String.class, String.class, String.class, String.class,
  				String.class, String.class, String.class, String.class,
  				String.class, String.class, String.class, String.class,
  				String.class, String.class, String.class, String.class,
  				String.class, String.class, String.class);
  
  		tc.appendMethod(null, method, string0, string1, string2, string3,
  				string4, string5, string6, string7, string8, string9, string10,
  				string11, string12, string13, string14, string15, string16,
  				string17, string18, string19, string20, string21, string22,
  				string23);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase46() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase46();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(10, branch_conditions.size());
  	}
  
  	// char char0 = ConcolicMarker.mark('\u0007', "char0");
  	// char char1 = ConcolicMarker.mark('\t', "char1");
  	// char char2 = ConcolicMarker.mark('\u0015', "char2");
  	// char char3 = ConcolicMarker.mark('\u0015', "char3");
  	private DefaultTestCase buildTestCase47() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference char0 = tc.appendCharPrimitive('\u0007');
  		VariableReference char1 = tc.appendCharPrimitive('\t');
  		VariableReference char2 = tc.appendCharPrimitive('\u0015');
  		VariableReference char3 = tc.appendCharPrimitive('\u0015');
  
  		Method method = TestCase47.class.getMethod("test", char.class,
  				char.class, char.class, char.class);
  		tc.appendMethod(null, method, char0, char1, char2, char3);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase47() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase47();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(9, branch_conditions.size());
  	}
  
  	// char char0 = ConcolicMarker.mark('y',"char0");
  	// char char1 = ConcolicMarker.mark('y',"char1");
  	// char char2 = ConcolicMarker.mark('y',"char2");
  	// char char3 = ConcolicMarker.mark('y',"char3");
  	// char char4 = ConcolicMarker.mark('y',"char4");
  	// char char5 = ConcolicMarker.mark('I',"char5");
  	// char char6 = ConcolicMarker.mark('I',"char6");
  	// char char7 = ConcolicMarker.mark('V',"char7");
  	// char char8 = ConcolicMarker.mark('R',"char8");
  	private DefaultTestCase buildTestCase48() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference char0 = tc.appendCharPrimitive('y');
  		VariableReference char1 = tc.appendCharPrimitive('y');
  		VariableReference char2 = tc.appendCharPrimitive('y');
  		VariableReference char3 = tc.appendCharPrimitive('y');
  		VariableReference char4 = tc.appendCharPrimitive('y');
  		VariableReference char5 = tc.appendCharPrimitive('I');
  		VariableReference char6 = tc.appendCharPrimitive('I');
  		VariableReference char7 = tc.appendCharPrimitive('V');
  		VariableReference char8 = tc.appendCharPrimitive('R');
  
  		Method method = TestCase48.class.getMethod("test", char.class,
  				char.class, char.class, char.class, char.class, char.class,
  				char.class, char.class, char.class);
  		tc.appendMethod(null, method, char0, char1, char2, char3, char4, char5,
  				char6, char7, char8);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase48() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase48();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(0, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase49() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  
  		Method method = TestCase49.class.getMethod("test");
  		tc.appendMethod(null, method);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase49() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase49();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(0, branch_conditions.size());
  	}
  
  	// char char0 = ConcolicMarker.mark('U', "char0");
  	// char char1 = ConcolicMarker.mark('U', "char1");
  	// char char2 = ConcolicMarker.mark(')', "char2");
  	// char char3 = ConcolicMarker.mark('j', "char3");
  	// char char4 = ConcolicMarker.mark('s', "char4");
  	// char char5 = ConcolicMarker.mark('\u001A', "char5");
  	private DefaultTestCase buildTestCase50() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference char0 = tc.appendCharPrimitive('U');
  		VariableReference char1 = tc.appendCharPrimitive('U');
  		VariableReference char2 = tc.appendCharPrimitive(')');
  		VariableReference char3 = tc.appendCharPrimitive('j');
  		VariableReference char4 = tc.appendCharPrimitive('s');
  		VariableReference char5 = tc.appendCharPrimitive('\u001A');
  
  		Method method = TestCase50.class.getMethod("test", char.class,
  				char.class, char.class, char.class, char.class, char.class);
  		tc.appendMethod(null, method, char0, char1, char2, char3, char4, char5);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase50() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase50();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(15, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase51() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  
  		Method method = TestCase51.class.getMethod("test");
  		tc.appendMethod(null, method);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase51() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase51();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(0, branch_conditions.size());
  	}
  
  	// String string0 = ConcolicMarker.mark("Togliere sta roba", "string0");
  	// String string1 = ConcolicMarker.mark(" ", "string1");
  	private DefaultTestCase buildTestCase52() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string0 = tc
  				.appendStringPrimitive("Togliere sta roba");
  		VariableReference string1 = tc.appendStringPrimitive(" ");
  
  		Method method = TestCase52.class.getMethod("test", String.class,
  				String.class);
  		tc.appendMethod(null, method, string0, string1);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase52() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase52();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(0, branch_conditions.size());
  	}
  
  	// int int0 = ConcolicMarker.mark(-756,"var1");
  	// int int1 = ConcolicMarker.mark(-542,"var2");
  	// int int3 = ConcolicMarker.mark(1,"var3");
  	// int int8 = ConcolicMarker.mark(-1480,"var4");
  	// int int11 = ConcolicMarker.mark(-1637,"var5");
  	private DefaultTestCase buildTestCase2() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference int0 = tc.appendIntPrimitive(-756);
  		VariableReference int1 = tc.appendIntPrimitive(-542);
  		VariableReference int3 = tc.appendIntPrimitive(1);
  		VariableReference int8 = tc.appendIntPrimitive(-1480);
  		VariableReference int11 = tc.appendIntPrimitive(-1637);
  
  		Method method = TestCase2.class.getMethod("test", int.class, int.class,
  				int.class, int.class, int.class);
  		tc.appendMethod(null, method, int0, int1, int3, int8, int11);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase2() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase2();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(4, branch_conditions.size());
  	}
  
  	// long long0 = ConcolicMarker.mark(1554151784714561687L,"var1");
  	// int int0 = ConcolicMarker.mark(0, "var2");
  	private DefaultTestCase buildTestCase4() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference long0 = tc.appendLongPrimitive(1554151784714561687L);
  		VariableReference int0 = tc.appendIntPrimitive(0);
  
  		Method method = TestCase4.class
  				.getMethod("test", long.class, int.class);
  		tc.appendMethod(null, method, long0, int0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase4() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase4();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(2, branch_conditions.size());
  	}
  
  	// float float0 = ConcolicMarker.mark(882.70544F,"var1");
  	// float float1 = ConcolicMarker.mark(882.70544F,"var2");
  	// float float2 = ConcolicMarker.mark(882.70544F, "var3");
  	// float float3 = ConcolicMarker.mark(1.0F,"var4");
  	// float float4 = ConcolicMarker.mark(63.534046F,"var5");
  	private DefaultTestCase buildTestCase5() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference float0 = tc.appendFloatPrimitive(882.70544F);
  		VariableReference float1 = tc.appendFloatPrimitive(882.70544F);
  		VariableReference float2 = tc.appendFloatPrimitive(882.70544F);
  		VariableReference float3 = tc.appendFloatPrimitive(1.0F);
  		VariableReference float4 = tc.appendFloatPrimitive(63.534046F);
  
  		Method method = TestCase5.class.getMethod("test", float.class,
  				float.class, float.class, float.class, float.class);
  		tc.appendMethod(null, method, float0, float1, float2, float3, float4);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase5() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase5();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(1, branch_conditions.size());
  	}
  
  	// int int0 = ConcolicMarker.mark(1515, "int0");
  	// int int2 = ConcolicMarker.mark(1541, "int2");
  	private DefaultTestCase buildTestCase56() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference int0 = tc.appendIntPrimitive(1515);
  		VariableReference int2 = tc.appendIntPrimitive(1541);
  
  		Method method = TestCase56.class
  				.getMethod("test", int.class, int.class);
  		tc.appendMethod(null, method, int0, int2);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase56() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase56();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(2, branch_conditions.size());
  	}
  
  	// String string1 = ConcolicMarker.mark("Togliere sta roba".toUpperCase(),
  	// "string1");
  	// String string3 = ConcolicMarker.mark("Togliere", "string3");
  	private DefaultTestCase buildTestCase57() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string1 = tc
  				.appendStringPrimitive("Togliere sta roba".toUpperCase());
  		VariableReference string3 = tc.appendStringPrimitive("Togliere");
  
  		Method method = TestCase57.class.getMethod("test", String.class,
  				String.class);
  		tc.appendMethod(null, method, string1, string3);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase57() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase57();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(2, branch_conditions.size());
  	}
  
  	// String string1 = ConcolicMarker.mark("Togliere sta roba".toUpperCase(),
  	// "string1");
  	private DefaultTestCase buildTestCase58() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string1 = tc
  				.appendStringPrimitive("Togliere sta roba".toUpperCase());
  
  		Method method = TestCase58.class.getMethod("test", String.class);
  		tc.appendMethod(null, method, string1);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase58() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase58();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(2, branch_conditions.size());
  	}
  
  	// String string1 = ConcolicMarker.mark(string0, "string1");
  	// int int1 = ConcolicMarker.mark(5, "int1");
  	private DefaultTestCase buildTestCase59() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string1 = tc
  				.appendStringPrimitive("Togliere sta roba");
  		VariableReference int1 = tc.appendIntPrimitive(5);
  
  		Method method = TestCase59.class.getMethod("test", String.class,
  				int.class);
  		tc.appendMethod(null, method, string1, int1);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase59() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase59();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(2, branch_conditions.size());
  	}
  
  	// float float0 = ConcolicMarker.mark(1442.5817F,"var1");
  	// float float1 = ConcolicMarker.mark(1.0F,"var2");
  	private DefaultTestCase buildTestCase6() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference float0 = tc.appendFloatPrimitive(1442.5817F);
  		VariableReference float1 = tc.appendFloatPrimitive(1.0F);
  
  		Method method = TestCase6.class.getMethod("test", float.class,
  				float.class);
  		tc.appendMethod(null, method, float0, float1);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase6() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase6();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(1, branch_conditions.size());
  	}
  
  	// String string1 = ConcolicMarker.mark(string0, "string1");
  	private DefaultTestCase buildTestCase60() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string1 = tc
  				.appendStringPrimitive("Togliere sta roba");
  
  		Method method = TestCase60.class.getMethod("test", String.class);
  		tc.appendMethod(null, method, string1);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase60() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase60();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(1, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase61() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string1 = tc
  				.appendStringPrimitive("Togliere sta roba");
  
  		Method method = TestCase61.class.getMethod("test", String.class);
  		tc.appendMethod(null, method, string1);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase61() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase61();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(4, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase62() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string1 = tc
  				.appendStringPrimitive("Togliere sta roba");
  
  		Method method = TestCase62.class.getMethod("test", String.class);
  		tc.appendMethod(null, method, string1);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase62() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase62();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(4, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase63() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string1 = tc
  				.appendStringPrimitive("Togliere sta roba");
  
  		Method method = TestCase63.class.getMethod("test", String.class);
  		tc.appendMethod(null, method, string1);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase63() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase63();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(5, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase64() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string1 = tc
  				.appendStringPrimitive("Togliere sta roba");
  
  		Method method = TestCase64.class.getMethod("test", String.class);
  		tc.appendMethod(null, method, string1);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase64() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase64();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(1, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase65() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string1 = tc
  				.appendStringPrimitive("Togliere sta roba");
  
  		Method method = TestCase65.class.getMethod("test", String.class);
  		tc.appendMethod(null, method, string1);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase65() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase65();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(4, branch_conditions.size());
  	}
  
  	// String string1 = ConcolicMarker.mark(string0, "string0");
  	private DefaultTestCase buildTestCase66() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string1 = tc
  				.appendStringPrimitive("Togliere sta roba");
  
  		Method method = TestCase66.class.getMethod("test", String.class);
  		tc.appendMethod(null, method, string1);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase66() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase66();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(1, branch_conditions.size());
  	}
  
  	// String string1 = ConcolicMarker.mark(string0, "string0");
  	private DefaultTestCase buildTestCase67() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string1 = tc
  				.appendStringPrimitive("Togliere sta roba");
  
  		Method method = TestCase67.class.getMethod("test", String.class);
  		tc.appendMethod(null, method, string1);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase67() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase67();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(1, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase68() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string1 = tc
  				.appendStringPrimitive("Togliere sta roba");
  
  		Method method = TestCase68.class.getMethod("test", String.class);
  		tc.appendMethod(null, method, string1);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase68() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase68();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(3, branch_conditions.size());
  	}
  
  	private DefaultTestCase buildTestCase69() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  
  		Method method = TestCase69.class.getMethod("test");
  		tc.appendMethod(null, method);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase69() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase69();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(0, branch_conditions.size());
  	}
  
  	// long long0 = ConcolicMarker.mark(0L,"var1");
  	// long long1 = ConcolicMarker.mark(0L, "var2");
  	// float float0 = ConcolicMarker.mark(1442.5817F,"var1");
  	// float float1 = ConcolicMarker.mark(1.0F,"var2");
  	private DefaultTestCase buildTestCase7() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference long0 = tc.appendLongPrimitive(0L);
  		VariableReference long1 = tc.appendLongPrimitive(0L);
  
  		Method method = TestCase7.class.getMethod("test", long.class,
  				long.class);
  		tc.appendMethod(null, method, long0, long1);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase7() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase7();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(0, branch_conditions.size());
  	}
  
  	// String string0 = ConcolicMarker.mark("enci", "string0");
  	// String string9 = ConcolicMarker.mark("nov", "string9");
  	private DefaultTestCase buildTestCase72() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string0 = tc.appendStringPrimitive("enci");
  		VariableReference string9 = tc.appendStringPrimitive("nov");
  		Method method = TestCase72.class.getMethod("test", String.class,
  				String.class);
  		tc.appendMethod(null, method, string0, string9);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase72() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase72();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(163, branch_conditions.size());
  	}
  
  	// String string0 = ConcolicMarker.mark("enci", "string0");
  	// String string1 = ConcolicMarker.mark("c", "string1");
  	private DefaultTestCase buildTestCase73() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string0 = tc.appendStringPrimitive("enci");
  		VariableReference string1 = tc.appendStringPrimitive("c");
  		Method method = TestCase73.class.getMethod("test", String.class,
  				String.class);
  		tc.appendMethod(null, method, string0, string1);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase73() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase73();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(1, branch_conditions.size());
  	}
  
  	// String string0 = ConcolicMarker.mark("Togliere ", "string0");
  	// String string1 = ConcolicMarker.mark("sta ", "string1");
  	// String string2 = ConcolicMarker.mark("roba ", "string2");
  	private DefaultTestCase buildTestCase74() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string0 = tc.appendStringPrimitive("Togliere");
  		VariableReference string1 = tc.appendStringPrimitive("sta");
  		VariableReference string2 = tc.appendStringPrimitive("roba");
  		Method method = TestCase74.class.getMethod("test", String.class,
  				String.class, String.class);
  		tc.appendMethod(null, method, string0, string1, string2);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase74() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase74();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(3, branch_conditions.size());
  	}
  
  	// String string0 = ConcolicMarker.mark("Togliere ", "string0");
  	// String string1 = ConcolicMarker.mark("sta ", "string1");
  	// String string2 = ConcolicMarker.mark("roba ", "string2");
  	private DefaultTestCase buildTestCase75() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference string0 = tc.appendStringPrimitive("Togliere");
  		VariableReference string1 = tc.appendStringPrimitive("sta");
  		VariableReference string2 = tc.appendStringPrimitive("roba");
  		Method method = TestCase75.class.getMethod("test", String.class,
  				String.class, String.class);
  		tc.appendMethod(null, method, string0, string1, string2);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase75() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase75();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(2, branch_conditions.size());
  	}
  
  	// int int0 = ConcolicMarker.mark(10, "int0");
  	// int int1 = ConcolicMarker.mark(0, "int1");
  	// int int2 = ConcolicMarker.mark(-1, "int2");
  	private DefaultTestCase buildTestCase76() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference int0 = tc.appendIntPrimitive(10);
  		VariableReference int1 = tc.appendIntPrimitive(0);
  		VariableReference int2 = tc.appendIntPrimitive(-1);
  
  		Method method = TestCase76.class.getMethod("test", int.class,
  				int.class, int.class);
  		tc.appendMethod(null, method, int0, int1, int2);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase76() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase76();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(1, branch_conditions.size());
  	}
  
  	// int int0 = ConcolicMarker.mark(10,"int0");
  	// int int1 = ConcolicMarker.mark(20,"int1");
  	// int int2 = ConcolicMarker.mark(30,"int2");
  	private DefaultTestCase buildTestCase77() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference int0 = tc.appendIntPrimitive(10);
  		VariableReference int1 = tc.appendIntPrimitive(20);
  		VariableReference int2 = tc.appendIntPrimitive(30);
  
  		Method method = TestCase77.class.getMethod("test", int.class,
  				int.class, int.class);
  		tc.appendMethod(null, method, int0, int1, int2);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase77() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase77();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(0, branch_conditions.size());
  	}
  
  	// int int0 = ConcolicMarker.mark(10, "int0");
  	private DefaultTestCase buildTestCase78() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference int0 = tc.appendIntPrimitive(10);
  
  		Method method = TestCase78.class.getMethod("test", int.class);
  		tc.appendMethod(null, method, int0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase78() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase78();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(1, branch_conditions.size());
  	}
  
  	// long long0 = ConcolicMarker.mark(10L, "long0");
  	private DefaultTestCase buildTestCase79() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference long0 = tc.appendLongPrimitive(10L);
  
  		Method method = TestCase79.class.getMethod("test", long.class);
  		tc.appendMethod(null, method, long0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase79() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase79();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(1, branch_conditions.size());
  	}
  
  	// int int0 = ConcolicMarker.mark(-1,"var1");
  	private DefaultTestCase buildTestCase8() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference int0 = tc.appendIntPrimitive(-1);
  
  		Method method = TestCase8.class.getMethod("test", int.class);
  		tc.appendMethod(null, method, int0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase8() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase8();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(0, branch_conditions.size());
  	}
  
  	// float float0 = ConcolicMarker.mark(1.5f, "float0");
  	private DefaultTestCase buildTestCase80() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference float0 = tc.appendFloatPrimitive(1.5f);
  
  		Method method = TestCase80.class.getMethod("test", float.class);
  		tc.appendMethod(null, method, float0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase80() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase80();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(1, branch_conditions.size());
  	}
  
  	// double double0 = ConcolicMarker.mark(1.5, "double0");
  	private DefaultTestCase buildTestCase81() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  		VariableReference double0 = tc.appendDoublePrimitive(1.5);
  
  		Method method = TestCase81.class.getMethod("test", double.class);
  		tc.appendMethod(null, method, double0);
  		return tc.getDefaultTestCase();
  	}
  
  	@Test
  	public void testCase81() throws SecurityException, NoSuchMethodException {
  		DefaultTestCase tc = buildTestCase81();
  		List<BranchCondition> branch_conditions = executeTest(tc);
  		assertEquals(1, branch_conditions.size());
  	}
  
  	// char char0 = ConcolicMarker.mark('a', "char0");
  	// boolean boolean0 = ConcolicMarker.mark(true, "boolean0");
  	// short short0 = ConcolicMarker.mark((short) 1, "short0");
  	// byte byte0 = ConcolicMarker.mark((byte) 1, "byte0");
  	private DefaultTestCase buildTestCase82() throws SecurityException,
  			NoSuchMethodException {
  		TestCaseBuilder tc = new TestCaseBuilder();
  