Java PotentialAssignment类代码示例

import org.junit.experimental.theories.PotentialAssignment; //导入依赖的package包/类
@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;
}
 

import org.junit.experimental.theories.PotentialAssignment; //导入依赖的package包/类
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;
                }
            }
        }
    }
}
 

import org.junit.experimental.theories.PotentialAssignment; //导入依赖的package包/类
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)));
            }
        }
    }
}
 

import org.junit.experimental.theories.PotentialAssignment; //导入依赖的package包/类
@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());
    }
}
 

import org.junit.experimental.theories.PotentialAssignment; //导入依赖的package包/类
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)));
			}
		}
	}
}
 

import org.junit.experimental.theories.PotentialAssignment; //导入依赖的package包/类
@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;
}
 

import org.junit.experimental.theories.PotentialAssignment; //导入依赖的package包/类
@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;
}
 

import org.junit.experimental.theories.PotentialAssignment; //导入依赖的package包/类
@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;
}
 

import org.junit.experimental.theories.PotentialAssignment; //导入依赖的package包/类
private void addSinglePointMethods(ParameterSignature sig, List<PotentialAssignment> list) {
    for (FrameworkMethod dataPointMethod : getSingleDataPointMethods(sig)) {
        if (sig.canAcceptType(dataPointMethod.getType())) {
            list.add(new MethodParameterValue(dataPointMethod));
        }
    }
}
 

import org.junit.experimental.theories.PotentialAssignment; //导入依赖的package包/类
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));
        }
    }
}
 

import org.junit.experimental.theories.PotentialAssignment; //导入依赖的package包/类
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);
    }
}
 

import org.junit.experimental.theories.PotentialAssignment; //导入依赖的package包/类
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));
        }
    }
}
 

import org.junit.experimental.theories.PotentialAssignment; //导入依赖的package包/类
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;
    }
}
 

import org.junit.experimental.theories.PotentialAssignment; //导入依赖的package包/类
@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;
}
 

import org.junit.experimental.theories.PotentialAssignment; //导入依赖的package包/类
/**
 * 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);
}