Java 类org.junit.experimental.theories.PotentialAssignment 实例源码

@Override
public List<PotentialAssignment> getValueSources(final ParameterSignature param) {
    final ArrayList<PotentialAssignment> list = new ArrayList<>();
    list.add(PotentialAssignment.forValue("", "foo"));
    list.add(PotentialAssignment.forValue("", "bar"));
    list.add(PotentialAssignment.forValue("", "foo"));
    list.add(PotentialAssignment.forValue("", "bar"));
    list.add(PotentialAssignment.forValue("", "foobar"));
    list.add(PotentialAssignment.forValue("", "foobar"));
    list.add(PotentialAssignment.forValue("", "foobar"));
    list.add(PotentialAssignment.forValue("", "whut?"));
    list.add(PotentialAssignment.forValue("", "OMGWTFBBQ"));
    list.add(PotentialAssignment.forValue("", "muahhahahahahahahaha"));
    list.add(PotentialAssignment.forValue("", "ijrobbeoubgt3t9hboebalnpajtih39"));
    list.add(PotentialAssignment.forValue("", "ijrobbeoubgt3t9hboebalnpajtih39"));
    return list;
}

private void addMultiPointMethods(ParameterSignature sig, List<PotentialAssignment> list) throws Throwable {
    for (FrameworkMethod dataPointsMethod : getDataPointsMethods(sig)) {
        Class<?> returnType = dataPointsMethod.getReturnType();

        if ((returnType.isArray() && sig.canPotentiallyAcceptType(returnType.getComponentType())) ||
                Iterable.class.isAssignableFrom(returnType)) {
            try {
                addDataPointsValues(returnType, sig, dataPointsMethod.getName(), list, 
                        dataPointsMethod.invokeExplosively(null));
            } catch (Throwable throwable) {
                DataPoints annotation = dataPointsMethod.getAnnotation(DataPoints.class);
                if (annotation != null && isAssignableToAnyOf(annotation.ignoredExceptions(), throwable)) {
                    return;
                } else {
                    throw throwable;
                }
            }
        }
    }
}

private void addFields(ParameterSignature sig,
        List<PotentialAssignment> list) {
    for (final Field field : fClass.getJavaClass().getFields()) {
        if (Modifier.isStatic(field.getModifiers())) {
            Class<?> type = field.getType();
            if (sig.canAcceptArrayType(type)
                    && field.getAnnotation(DataPoints.class) != null) {
                try {
                    addArrayValues(field.getName(), list, getStaticFieldValue(field));
                } catch (Throwable e) {
                    // ignore and move on
                }
            } else if (sig.canAcceptType(type)
                    && field.getAnnotation(DataPoint.class) != null) {
                list.add(PotentialAssignment
                        .forValue(field.getName(), getStaticFieldValue(field)));
            }
        }
    }
}

@Override
protected void runWithIncompleteAssignment(Assignments incomplete) throws Throwable{
    for(PotentialAssignment source:incomplete.potentialsForNextUnassigned()){
        final Assignments nextAssignment = incomplete.assignNext(source);
        ForkJoinTask<?> run = new RecursiveAction(){
            @Override
            protected void compute(){
                try{
                    ParallelTheoryAnchor.this.runWithAssignment(nextAssignment);
                }catch(Throwable t){
                    throw new RuntimeException(t);
                }
            }
        };
        runs.addFirst(run.fork());
    }
}

private void addFields(ParameterSignature sig,
        List<PotentialAssignment> list) {
    for (final Field field : fClass.getJavaClass().getFields()) {
        if (Modifier.isStatic(field.getModifiers())) {
            Class<?> type = field.getType();
            if (sig.canAcceptArrayType(type)
                    && field.getAnnotation(DataPoints.class) != null) {
                try {
                    addArrayValues(field.getName(), list, getStaticFieldValue(field));
                } catch (Throwable e) {
                    // ignore and move on
                }
            } else if (sig.canAcceptType(type)
                    && field.getAnnotation(DataPoint.class) != null) {
                list.add(PotentialAssignment
                        .forValue(field.getName(), getStaticFieldValue(field)));
            }
        }
    }
}

private void addFields(final ParameterSignature sig, final List<PotentialAssignment> list) {
    for (final Field field : fClass.getJavaClass().getFields()) {
        if (Modifier.isStatic(field.getModifiers())) {
            Class<?> type = field.getType();
            if (sig.canAcceptArrayType(type) && field.getAnnotation(DataPoints.class) != null) {
                try {
                    addArrayValues(field.getName(), list, getStaticFieldValue(field));
                } catch (Throwable e) {
                    // ignore and move on
                }
            } else if (sig.canAcceptType(type) && field.getAnnotation(DataPoint.class) != null) {
                list.add(PotentialAssignment.forValue(field.getName(), getStaticFieldValue(field)));
            }
        }
    }
}

@Override
public List<PotentialAssignment> getValueSources(ParameterSignature sig) throws Throwable {

    final List<PotentialAssignment> list = new ArrayList<PotentialAssignment>();

    list.add(PotentialAssignment.forValue("long", 2L));
    list.add(PotentialAssignment.forValue("float", 5.00f));
    list.add(PotentialAssignment.forValue("double", 89d));

    return list;
}

@Override
public List<PotentialAssignment> getValueSources(final ParameterSignature signature) {
    final ArrayList<PotentialAssignment> list = new ArrayList<>();
    list.add(PotentialAssignment.forValue("", new Object[]{-100L, 50L, 1L, 11L}));
    list.add(PotentialAssignment.forValue("", new Object[]{null}));
    list.add(PotentialAssignment.forValue("", new Object[]{"OMGWTFBBQ", "TEST test!!!"}));
    list.add(PotentialAssignment.forValue("", new Object[]{-100L}));
    list.add(PotentialAssignment.forValue("", new Object[]{0.3562}));
    list.add(PotentialAssignment.forValue("", new Object[]{}));
    return list;
}

@Override
public List<PotentialAssignment> getValueSources(final ParameterSignature signature) {
    final ArrayList<PotentialAssignment> list = new ArrayList<>();
    final Random randomGen = new Random();
    for (int i = 0; i < 20; ++i) {
        list.add(PotentialAssignment.forValue("", randomGen.nextLong()));
    }
    return list;
}

@Override
public List<PotentialAssignment> getValueSources(final ParameterSignature signature) {
    final ArrayList<PotentialAssignment> list = new ArrayList<>();
    final Random randomGen = new Random();
    for (int i = 0; i < 20; ++i) {
        list.add(PotentialAssignment.forValue("", randomGen.nextGaussian()));
    }
    return list;
}

@Override
public List<PotentialAssignment> getValueSources(final ParameterSignature arg0) {
    final ArrayList<PotentialAssignment> list = new ArrayList<>();
    list.add(PotentialAssignment.forValue("", new Boolean(true)));
    list.add(PotentialAssignment.forValue("", new Boolean(true)));
    list.add(PotentialAssignment.forValue("", new Boolean(true)));
    list.add(PotentialAssignment.forValue("", new Boolean(false)));
    list.add(PotentialAssignment.forValue("", new Boolean(false)));
    list.add(PotentialAssignment.forValue("", new Boolean(false)));
    list.add(PotentialAssignment.forValue("", new Boolean(false)));
    return list;
}

@Override
public List<PotentialAssignment> getValueSources(ParameterSignature sig) {
    List<PotentialAssignment> list = new ArrayList<PotentialAssignment>();
    TestedOn testedOn = sig.getAnnotation(TestedOn.class);
    int[] ints = testedOn.ints();
    for (final int i : ints) {
        list.add(PotentialAssignment.forValue("ints", i));
    }
    return list;
}

@Override
public List<PotentialAssignment> getValueSources(ParameterSignature sig) throws Throwable {
    List<PotentialAssignment> list = new ArrayList<PotentialAssignment>();

    addSinglePointFields(sig, list);
    addMultiPointFields(sig, list);
    addSinglePointMethods(sig, list);
    addMultiPointMethods(sig, list);

    return list;
}

private void addSinglePointMethods(ParameterSignature sig, List<PotentialAssignment> list) {
    for (FrameworkMethod dataPointMethod : getSingleDataPointMethods(sig)) {
        if (sig.canAcceptType(dataPointMethod.getType())) {
            list.add(new MethodParameterValue(dataPointMethod));
        }
    }
}

private void addSinglePointFields(ParameterSignature sig, List<PotentialAssignment> list) {
    for (final Field field : getSingleDataPointFields(sig)) {
        Object value = getStaticFieldValue(field);

        if (sig.canAcceptValue(value)) {
            list.add(PotentialAssignment.forValue(field.getName(), value));
        }
    }
}

private void addDataPointsValues(Class<?> type, ParameterSignature sig, String name, 
        List<PotentialAssignment> list, Object value) {
    if (type.isArray()) {
        addArrayValues(sig, name, list, value);
    }
    else if (Iterable.class.isAssignableFrom(type)) {
        addIterableValues(sig, name, list, (Iterable<?>) value);
    }
}

private void addArrayValues(ParameterSignature sig, String name, List<PotentialAssignment> list, Object array) {
    for (int i = 0; i < Array.getLength(array); i++) {
        Object value = Array.get(array, i);
        if (sig.canAcceptValue(value)) {
            list.add(PotentialAssignment.forValue(name + "[" + i + "]", value));
        }
    }
}

private void addIterableValues(ParameterSignature sig, String name, List<PotentialAssignment> list, Iterable<?> iterable) {
    Iterator<?> iterator = iterable.iterator();
    int i = 0;
    while (iterator.hasNext()) {
        Object value = iterator.next();
        if (sig.canAcceptValue(value)) {
            list.add(PotentialAssignment.forValue(name + "[" + i + "]", value));
        }
        i += 1;
    }
}

@Override
public List<PotentialAssignment> getValueSources(ParameterSignature sig) {
    Object[] enumValues = enumType.getEnumConstants();

    List<PotentialAssignment> assignments = new ArrayList<PotentialAssignment>();
    for (Object value : enumValues) {
        assignments.add(PotentialAssignment.forValue(value.toString(), value));
    }

    return assignments;
}

/**
 * Returns a new assignment list for {@code testMethod}, with no params
 * assigned.
 */
public static Assignments allUnassigned(Method testMethod,
        TestClass testClass) {
    List<ParameterSignature> signatures;
    signatures = ParameterSignature.signatures(testClass
            .getOnlyConstructor());
    signatures.addAll(ParameterSignature.signatures(testMethod));
    return new Assignments(new ArrayList<PotentialAssignment>(),
            signatures, testClass);
}

public Assignments assignNext(PotentialAssignment source) {
    List<PotentialAssignment> assigned = new ArrayList<PotentialAssignment>(
            fAssigned);
    assigned.add(source);

    return new Assignments(assigned, fUnassigned.subList(1,
            fUnassigned.size()), fClass);
}

public List<PotentialAssignment> potentialsForNextUnassigned()
        throws Throwable {
    ParameterSignature unassigned = nextUnassigned();
    List<PotentialAssignment> assignments = getSupplier(unassigned).getValueSources(unassigned);

    if (assignments.size() == 0) {
        assignments = generateAssignmentsFromTypeAlone(unassigned);
    }

    return assignments;
}

private List<PotentialAssignment> generateAssignmentsFromTypeAlone(ParameterSignature unassigned) {
    Class<?> paramType = unassigned.getType();

    if (paramType.isEnum()) {
        return new EnumSupplier(paramType).getValueSources(unassigned);  
    } else if (paramType.equals(Boolean.class) || paramType.equals(boolean.class)) {
        return new BooleanSupplier().getValueSources(unassigned);
    } else {
        return emptyList();
    }
}

@Test
public void shouldUseQuotedValueInDescription() throws CouldNotGenerateValueException {
    String name = "stringDatapoint";
    Object value = new Object() {
        @Override
        public String toString() {
            return "string value";
        }
    };

    PotentialAssignment assignment = PotentialAssignment.forValue(name, value);

    assertEquals("\"string value\" <from stringDatapoint>", assignment.getDescription());
}

@Test
public void shouldNotUseQuotesForNullValueDescriptions() throws CouldNotGenerateValueException {
    String name = "nullDatapoint";
    Object value = null;

    PotentialAssignment assignment = PotentialAssignment.forValue(name, value);

    assertEquals("null <from nullDatapoint>", assignment.getDescription());
}

@Test
public void shouldIncludeFailureInDescriptionIfToStringFails() throws CouldNotGenerateValueException {
    String name = "explodingValue";
    Object value = new Object() {
        @Override
        public String toString() {
            throw new RuntimeException("Oh no!");
        }
    };

    PotentialAssignment assignment = PotentialAssignment.forValue(name, value);

    assertEquals("[toString() threw RuntimeException: Oh no!] <from explodingValue>", assignment.getDescription());
}

@Test
public void shouldReturnOnlyTheNamedDataPoints() throws Throwable {
    SpecificDataPointsSupplier supplier = new SpecificDataPointsSupplier(new TestClass(TestClassWithNamedDataPoints.class));

    List<PotentialAssignment> assignments = supplier.getValueSources(signature("methodWantingAllNamedStrings"));
    List<String> assignedStrings = getStringValuesFromAssignments(assignments);

    assertEquals(4, assignedStrings.size());
    assertThat(assignedStrings, hasItems("named field", "named method", "named single value", "named single method value"));
}

@Test
public void shouldReturnOnlyTheNamedFieldDataPoints() throws Throwable {
    SpecificDataPointsSupplier supplier = new SpecificDataPointsSupplier(new TestClass(TestClassWithNamedDataPoints.class));

    List<PotentialAssignment> assignments = supplier.getValueSources(signature("methodWantingNamedFieldString"));
    List<String> assignedStrings = getStringValuesFromAssignments(assignments);

    assertEquals(1, assignedStrings.size());
    assertThat(assignedStrings, hasItem("named field"));
}

@Test
public void shouldReturnOnlyTheNamedMethodDataPoints() throws Throwable {
    SpecificDataPointsSupplier supplier = new SpecificDataPointsSupplier(new TestClass(TestClassWithNamedDataPoints.class));

    List<PotentialAssignment> assignments = supplier.getValueSources(signature("methodWantingNamedMethodString"));
    List<String> assignedStrings = getStringValuesFromAssignments(assignments);

    assertEquals(1, assignedStrings.size());
    assertThat(assignedStrings, hasItem("named method"));
}

@Test
public void shouldReturnOnlyTheNamedSingleFieldDataPoints() throws Throwable {
    SpecificDataPointsSupplier supplier = new SpecificDataPointsSupplier(new TestClass(TestClassWithNamedDataPoints.class));

    List<PotentialAssignment> assignments = supplier.getValueSources(signature("methodWantingNamedSingleFieldString"));
    List<String> assignedStrings = getStringValuesFromAssignments(assignments);

    assertEquals(1, assignedStrings.size());
    assertThat(assignedStrings, hasItem("named single value"));
}

@Test
public void shouldReturnOnlyTheNamedSingleMethodDataPoints() throws Throwable {
    SpecificDataPointsSupplier supplier = new SpecificDataPointsSupplier(new TestClass(TestClassWithNamedDataPoints.class));

    List<PotentialAssignment> assignments = supplier.getValueSources(signature("methodWantingNamedSingleMethodString"));
    List<String> assignedStrings = getStringValuesFromAssignments(assignments);

    assertEquals(1, assignedStrings.size());
    assertThat(assignedStrings, hasItem("named single method value"));
}

@Test
public void shouldReturnNothingIfTheNamedDataPointsAreMissing() throws Throwable {
    SpecificDataPointsSupplier supplier = new SpecificDataPointsSupplier(new TestClass(TestClassWithNamedDataPoints.class));

    List<PotentialAssignment> assignments = supplier.getValueSources(signature("methodWantingWrongNamedString"));
    List<String> assignedStrings = getStringValuesFromAssignments(assignments);

    assertEquals(0, assignedStrings.size());
}

private List<String> getStringValuesFromAssignments(List<PotentialAssignment> assignments) throws CouldNotGenerateValueException {
    List<String> stringValues = new ArrayList<String>();
    for (PotentialAssignment assignment : assignments) {
        stringValues.add((String) assignment.getValue());
    }
    return stringValues;
}

@Test
public void dataPointsArrayShouldBeRecognized() throws Throwable {
    List<PotentialAssignment> assignments = potentialAssignments(
            HasDataPointsArrayField.class.getMethod("theory", String.class));

    assertEquals(2, assignments.size());
}

@Test
public void dataPointsArrayShouldBeRecognizedOnValueTypeNotFieldType() throws Throwable {
    List<PotentialAssignment> assignments = potentialAssignments(
            HasDataPointsArrayWithMatchingButInaccurateTypes.class.getMethod("theory", Integer.class));

    assertEquals(2, assignments.size());
}

@Test
public void dataPointMethodShouldBeRecognizedForOverlyGeneralParameters() throws Throwable {
    List<PotentialAssignment> assignments = potentialAssignments(
            HasDataPointMethodWithOverlyGeneralTypes.class.getMethod("theory", Object.class));

    assertEquals(1, assignments.size());
}

@Test
public void dataPointsAnnotationMeansTreatAsArrayOnly() throws Throwable {
    List<PotentialAssignment> assignments = potentialAssignments(
            HasDataPointsWithObjectParameter.class.getMethod("theory", Object.class));

    assertEquals(2, assignments.size());
    for (PotentialAssignment assignment : assignments) {
        assertNotEquals(HasDataPointsWithObjectParameter.objectField, assignment.getValue());
    }
}

private List<PotentialAssignment> allMemberValuesFor(Class<?> testClass,
        Class<?>... constructorParameterTypes) throws Throwable {
    return new AllMembersSupplier(new TestClass(testClass))
            .getValueSources(ParameterSignature.signatures(
                    testClass.getConstructor(constructorParameterTypes))
                    .get(0));
}

@Test
public void dataPointsCollectionFieldsShouldBeRecognized() throws Throwable {
    List<PotentialAssignment> assignments = potentialAssignments(
        HasDataPointsListField.class.getMethod("theory", String.class));

    assertEquals(2, assignments.size());
}

@Test
public void dataPointsCollectionMethodShouldBeRecognized() throws Throwable {
    List<PotentialAssignment> assignments = potentialAssignments(
        HasDataPointsListMethod.class.getMethod("theory", String.class));

    assertEquals(2, assignments.size());
}