spoon.processing.Processor Java Examples

protected void runTests(String[] testClasses, NopolContext nopolContext, SpoonedProject spooner, Processor processor) {
	ClassLoader cl = spooner.processedAndDumpedToClassLoader(processor);
	TestCasesListener listener = new TestCasesListener();
	Map<String, Boolean> resultsPerNameOfTest = new HashMap<>();
	Map<String, Map<SourceLocation, Boolean>> linesExecutedPerTestNames = new HashMap<>();
	nbFailingTest = 0;
	nbSucceedTest = 0;
	for (int i = 0; i < testClasses.length; i++) {
		try {
			List<String> testMethods = new ArrayList<>();
			if (testClasses[i].contains("#")) {
				testMethods.add(testClasses[i]);
			} else {
				testMethods.addAll(getTestMethods(cl.loadClass(testClasses[i])));
			}
			for (String testMethod : testMethods) {
				TestSuiteExecution.runTest(testMethod, cl, listener, nopolContext);
				//Since we executed one test at the time, the listener contains one and only one TestCase
				boolean testSucceed = listener.numberOfFailedTests() == 0;
				resultsPerNameOfTest.put(testMethod, testSucceed);
				if (testSucceed) {
					nbSucceedTest++;
				} else {
					nbFailingTest++;
				}
				linesExecutedPerTestNames.put(testMethod, copyExecutedLinesAndReinit(_Instrumenting.lines));
			}
		} catch (ClassNotFoundException e) {
			throw new RuntimeException(e);
		}
	}
	this.buildTestResultPerSourceLocation(resultsPerNameOfTest, linesExecutedPerTestNames);
}
 

public TestSpooner process(Class<? extends Processor>... processors) throws Exception {
	// Build spoon model
	compiler.build();
	
	List<Processor<?>> processorsNames = new ArrayList<>();
	for (Class<? extends Processor> processor : processors) {
		processorsNames.add(processor.newInstance());
	}
	compiler.process(processorsNames);

	return this;
}
 

public TestSpooner process(CtElement element, Class<? extends Processor>... processors) throws Exception {
	// Build spoon model
	compiler.build();

	ProcessingManager processing = new QueueProcessingManager(compiler.getFactory());

	for (Class<? extends Processor> processorClz : processors) {
		processing.addProcessor(processorClz.getName());
	}
	processing.process(element);

	return this;
}
 

public ConstraintModelBuilder(RuntimeValues<Boolean> runtimeValues, SourceLocation sourceLocation, Processor<?> processor, SpoonedProject spooner, NopolContext nopolContext) {
    this.sourceLocation = sourceLocation;
    this.nopolContext = nopolContext;
    String qualifiedName = sourceLocation.getRootClassName();
    SpoonedClass fork = spooner.forked(qualifiedName);
    try {
        classLoader = fork.processedAndDumpedToClassLoader(processor);
    } catch (DynamicCompilationException e) {
        logger.error("Unable to compile the change: \n" + fork.getSimpleType());
        throw e;
    }
    this.runtimeValues = runtimeValues;
}
 

@Override
public void process(CtStatement element) {
    for (Processor processor : this.processors) {
        processor.process(element);
    }
    this.process = false;
}
 

protected synchronized void processModelledClasses(Collection<? extends CtType<?>> modelledClasses, Collection<? extends Processor<?>> processors) {
    setProcessors(processors);
    for (CtType<?> modelledClass : modelledClasses) {
        String qualifiedName = modelledClass.getQualifiedName();
        //logDebug(logger(), format("[Spoon processing of %s]", qualifiedName));
        try {
            processingManager().process(modelledClass);
        } catch (ProcessInterruption e) {
            continue;
        }
    }
}
 

public void generateOutputFile(File destinationFolder) {
    Environment env = factory.getEnvironment();
    env.setSourceOutputDirectory(destinationFolder);
    JavaOutputProcessor javaOutputProcessor = new JavaOutputProcessor(prettyPrinter);
    javaOutputProcessor.setFactory(factory);
    Processor<?> writer = javaOutputProcessor;
    process(writer);
}
 

public ClassLoader processedAndDumpedToClassLoader(Collection<String> qualifiedNames, Processor<?> processor) {
    return processedAndDumpedToClassLoader(qualifiedNames, asList(processor));
}
 

public MutationTester(String src, TestDriver tester, Processor mutator) {
	this.sourceCodeToBeMutated = src;
	this.testDriver = tester;
	this.mutator = mutator;
}
 

public DelegatingProcessor addProcessor(final Processor<CtElement> processor) {
    this.processors.add(processor);
    return this;
}
 

private void setProcessors(Collection<? extends Processor<?>> processors) {
    processingManager().getProcessors().clear();
    for (Processor<?> processor : processors) {
        processingManager().addProcessor(processor);
    }
}
 

public void process(Collection<? extends Processor<?>> processors) {
    processModelledClasses(modelledClasses(), processors);
}
 

public void process(Processor<?> processor) {
    process(asList(processor));
}
 

public ClassLoader processedAndDumpedToClassLoader(Collection<? extends Processor<?>> processors) {
    process(processors);
    return dumpedToClassLoader();
}
 

public ClassLoader processedAndDumpedToClassLoader(Processor<?> processor) {
    return processedAndDumpedToClassLoader(asList(processor));
}
 

private List<Processor<? super T>> subprocessors() {
    return subprocessors;
}
 

@Override
public void process(T element) {
    for (Processor<? super T> subprocessor : subprocessors()) {
        subprocessor.process(element);
    }
}
 

public CompoundProcessor(Class<T> targetClass, Collection<Processor<? super T>> processors) {
    this.targetCtClass = targetClass;
    subprocessors = MetaList.newLinkedList();
    subprocessors().addAll(processors);
}
 

public CompoundProcessor(Class<T> targetClass, Processor<? super T>... processors) {
    this(targetClass, asList(processors));
}
 

public void processClasses(Collection<String> qualifiedNames, Collection<? extends Processor<?>> processors) {
    super.processModelledClasses(modelledClasses(qualifiedNames), processors);
}
 

public void processClass(Collection<String> qualifiedNames, Processor<?> processor) {
    processClasses(qualifiedNames, asList(processor));
}
 

public void processClass(String qualifiedName, Processor<?> processor) {
    processClass(asList(qualifiedName), processor);
}
 

public ClassLoader processedAndDumpedToClassLoader(Collection<String> qualifiedNames, Collection<? extends Processor<?>> processors) {
    processClasses(qualifiedNames, processors);
    return super.newBytecodeClassloader(compiledClasses());
}
 

private void setProcessor(Processor processor) {
	manager.getProcessors().clear();

	manager.addProcessor(processor);

}