Java tutorial
/** * Copyright (C) 2010-2016 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.testcase.statements; import java.io.PrintStream; import java.lang.reflect.Array; import java.lang.reflect.InvocationTargetException; import java.util.ArrayList; import java.util.Arrays; import java.util.LinkedHashSet; import java.util.List; import java.util.Set; import org.apache.commons.lang3.ArrayUtils; import org.evosuite.Properties; import org.evosuite.testcase.variable.ArrayIndex; import org.evosuite.testcase.variable.ArrayReference; import org.evosuite.testcase.variable.FieldReference; import org.evosuite.testcase.TestCase; import org.evosuite.testcase.TestFactory; import org.evosuite.testcase.variable.VariableReference; import org.evosuite.testcase.execution.CodeUnderTestException; import org.evosuite.testcase.execution.Scope; import org.evosuite.utils.generic.GenericAccessibleObject; import org.evosuite.utils.generic.GenericClass; import org.evosuite.utils.LoggingUtils; import org.evosuite.utils.Randomness; /** * An array statement creates a new array * * @author Gordon Fraser */ /* * TODO: The length is currently stored in ArrayReference and the ArrayStatement. * This is bound to lead to inconsistencies. */ public class ArrayStatement extends AbstractStatement { private static final long serialVersionUID = -2858236370873914156L; private static int[] createRandom(int dimensions) { int[] result = new int[dimensions]; for (int idx = 0; idx < dimensions; idx++) { result[idx] = Randomness.nextInt(Properties.MAX_ARRAY); } return result; } /** * <p> * determineDimensions * </p> * * @param type * a {@link java.lang.reflect.Type} object. * @return a int. */ public static int determineDimensions(java.lang.reflect.Type type) { String name = type.toString().replace("class", "").trim(); int count = 0; for (int i = 0; i < name.length(); i++) { if (name.charAt(i) == '[') { count++; } } return count; } private int[] lengths; /** * <p> * Constructor for ArrayStatement. * </p> * * @param tc * a {@link org.evosuite.testcase.TestCase} object. * @param arrayReference * a {@link org.evosuite.testcase.variable.ArrayReference} object. */ public ArrayStatement(TestCase tc, ArrayReference arrayReference) { this(tc, arrayReference, createRandom(determineDimensions(arrayReference.getType()))); } /** * <p> * Constructor for ArrayStatement. * </p> * * @param tc * a {@link org.evosuite.testcase.TestCase} object. * @param arrayReference * a {@link org.evosuite.testcase.variable.ArrayReference} object. * @param length * an array of int. */ public ArrayStatement(TestCase tc, ArrayReference arrayReference, int[] length) { super(tc, arrayReference); setLengths(length); arrayReference.setLengths(lengths); } /** * <p> * Constructor for ArrayStatement. * </p> * * @param tc * a {@link org.evosuite.testcase.TestCase} object. * @param type * a {@link java.lang.reflect.Type} object. */ public ArrayStatement(TestCase tc, java.lang.reflect.Type type) { this(tc, type, createRandom(determineDimensions(type))); } /** * <p> * Constructor for ArrayStatement. * </p> * * @param tc * a {@link org.evosuite.testcase.TestCase} object. * @param type * a {@link java.lang.reflect.Type} object. * @param length * a int. */ public ArrayStatement(TestCase tc, java.lang.reflect.Type type, int length) { this(tc, type, new int[] { length }); } /** * <p> * Constructor for ArrayStatement. * </p> * * @param tc * a {@link org.evosuite.testcase.TestCase} object. * @param type * a {@link java.lang.reflect.Type} object. * @param length * an array of int. */ public ArrayStatement(TestCase tc, java.lang.reflect.Type type, int[] length) { this(tc, new ArrayReference(tc, new GenericClass(type), length), length); } /** {@inheritDoc} */ @Override public Statement copy(TestCase newTestCase, int offset) { ArrayStatement copy = new ArrayStatement(newTestCase, retval.getType(), lengths); // copy.assertions = copyAssertions(newTestCase, offset); return copy; } /** {@inheritDoc} */ @Override public boolean equals(Object s) { if (this == s) return true; if (s == null) return false; if (getClass() != s.getClass()) return false; ArrayStatement as = (ArrayStatement) s; if (!Arrays.equals(lengths, as.lengths)) return false; if (retval.equals(as.retval)) { return true; } else { return false; } // if (!Arrays.equals(variables, other.variables)) // return false; } /** {@inheritDoc} */ @Override public Throwable execute(Scope scope, PrintStream out) throws InvocationTargetException, IllegalArgumentException, IllegalAccessException, InstantiationException { Throwable exceptionThrown = null; // Add array variable to pool try { Class<?> componentType = retval.getComponentClass(); while (componentType.isArray()) componentType = componentType.getComponentType(); retval.setObject(scope, Array.newInstance(componentType, lengths)); } catch (CodeUnderTestException e) { exceptionThrown = e.getCause(); } return exceptionThrown; } /** {@inheritDoc} */ @Override public GenericAccessibleObject<?> getAccessibleObject() { return null; } /** * <p> * Getter for the field <code>lengths</code>. * </p> * * @return an array of int. */ public List<Integer> getLengths() { return Arrays.asList(ArrayUtils.toObject(lengths)); } /* * (non-Javadoc) * * @see * org.evosuite.testcase.Statement#getUniqueVariableReferences() */ /** {@inheritDoc} */ @Override public List<VariableReference> getUniqueVariableReferences() { return new ArrayList<VariableReference>(getVariableReferences()); } /** {@inheritDoc} */ @Override public Set<VariableReference> getVariableReferences() { Set<VariableReference> references = new LinkedHashSet<VariableReference>(); references.add(retval); return references; } /** {@inheritDoc} */ @Override public int hashCode() { final int prime = 31; int result = retval.hashCode(); result = prime * result + Arrays.hashCode(lengths); return result; } /** {@inheritDoc} */ @Override public boolean isAssignmentStatement() { return false; } /* (non-Javadoc) * @see org.evosuite.testcase.StatementInterface#isValid() */ /** {@inheritDoc} */ @Override public boolean isValid() { int maxAssignment = 0; for (Statement statement : this.tc) { for (VariableReference var : statement.getVariableReferences()) { if (var.getAdditionalVariableReference() == this.retval) { VariableReference currentVar = var; while (currentVar instanceof FieldReference) { currentVar = ((FieldReference) currentVar).getSource(); } ArrayIndex index = (ArrayIndex) currentVar; maxAssignment = Math.max(maxAssignment, index.getArrayIndex()); } } } if (maxAssignment > lengths[0]) { logger.warn("Max assignment = " + maxAssignment + ", length = " + lengths[0]); return false; } return super.isValid(); } /* (non-Javadoc) * @see org.evosuite.testcase.AbstractStatement#mutate(org.evosuite.testcase.TestCase, org.evosuite.testcase.AbstractTestFactory) */ /** {@inheritDoc} */ @Override public boolean mutate(TestCase test, TestFactory factory) { int maxAssignment = 0; for (Statement statement : test) { for (VariableReference var : statement.getVariableReferences()) { if (var.getAdditionalVariableReference() == this.retval) { VariableReference currentVar = var; while (currentVar instanceof FieldReference) { currentVar = ((FieldReference) currentVar).getSource(); } if (!(currentVar instanceof ArrayIndex)) { LoggingUtils.getEvoLogger().error("Found assignment to array without ArrayIndex:"); LoggingUtils.getEvoLogger().error(test.toCode()); LoggingUtils.getEvoLogger().error(statement.getPosition() + ", " + statement.getCode()); } ArrayIndex index = (ArrayIndex) currentVar; maxAssignment = Math.max(maxAssignment, index.getArrayIndex()); } } } int dim = 0; if (lengths.length > 1) { dim = Randomness.nextInt(lengths.length - 1); } int newLength = lengths[dim]; while (newLength == lengths[dim]) { if (Randomness.nextDouble() <= Properties.RANDOM_PERTURBATION) { newLength = Randomness.nextInt(maxAssignment, Math.max(maxAssignment + 1, Properties.MAX_ARRAY)) + 1; } else { int max = Math.min(Math.abs(lengths[dim] - maxAssignment - 1), Properties.MAX_DELTA); if (max > 0) newLength = lengths[dim] + Randomness.nextInt(2 * max) - max; else newLength = lengths[dim] + Randomness.nextInt(Properties.MAX_DELTA); } } // TODO: Need to make sure this doesn't happen by construction if (newLength <= 0) newLength = 1; lengths[dim] = newLength; ((ArrayReference) retval).setLengths(lengths); return true; } /* (non-Javadoc) * @see org.evosuite.testcase.StatementInterface#replace(org.evosuite.testcase.VariableReference, org.evosuite.testcase.VariableReference) */ /** {@inheritDoc} */ @Override public void replace(VariableReference var1, VariableReference var2) { } /** {@inheritDoc} */ @Override public boolean same(Statement s) { if (this == s) return true; if (s == null) return false; if (getClass() != s.getClass()) return false; ArrayStatement as = (ArrayStatement) s; if (!Arrays.equals(lengths, as.lengths)) return false; if (retval.same(as.retval)) { return true; } else { return false; } } /** * <p> * Setter for the field <code>lengths</code>. * </p> * * @param lengths * an array of int. */ public void setLengths(int[] lengths) { this.lengths = new int[lengths.length]; for (int i = 0; i < lengths.length; i++) { this.lengths[i] = lengths[i]; } ((ArrayReference) retval).setLengths(lengths); } /** * <p> * setSize * </p> * * @param size * a int. */ public void setSize(int size) { /// assert lengths.length == 1; this.lengths[0] = size; ((ArrayReference) retval).setArrayLength(size); } /** * <p> * size * </p> * * @return a int. */ public int size() { // assert lengths.length == 1; return lengths[0]; } public ArrayReference getArrayReference() { return (ArrayReference) getReturnValue(); } }