Java CompilerFactory.getCompiler方法代码示例

import vk.core.api.CompilerFactory; //导入方法依赖的package包/类
public String acceptanceCheck() {
	acceptance = false;
	CompilationUnit classToTest = new CompilationUnit(myClass, myCode, false);
	CompilationUnit aTest = new CompilationUnit(acceptanceTestName, acceptanceTest, true);
	JavaStringCompiler myCompileObject = CompilerFactory.getCompiler(classToTest, aTest);
	myCompileObject.compileAndRunTests();
	CompilerResult cpResult = myCompileObject.getCompilerResult();
	
	String result = "";
	
	if(cpResult.hasCompileErrors()) {
		result = handleErrors(cpResult, aTest);
	}
	else if(testCode.contains("@Test")) {
		result = handleAcceptanceTests(myCompileObject);
		if(testSuccess && acceptance) acceptance = true;
		else acceptance = false;
	}
	else result = "Please add a proper Acceptance Test!";
	
	return result;
}
 

import vk.core.api.CompilerFactory; //导入方法依赖的package包/类
/**
 * Compiles the passed code and sets info to compile errors if there are any.
 * @param code The code that is going to be compiled
 * @param className The classname of the code
    * @return True if the code is compilable. Otherwise false.
    */
public boolean compileCode(String code, String className) {
	//String className       = findClassName(code).trim();
	CompilationUnit cu     = new CompilationUnit(className, code, false);
	JavaStringCompiler jsc = CompilerFactory.getCompiler(cu);

	jsc.compileAndRunTests();
	CompilerResult cr = jsc.getCompilerResult();

	if (cr.hasCompileErrors()) {
		info = formatCompileErrors(cr, cu);
		return false;
	}

	return true;
}
 

import vk.core.api.CompilerFactory; //导入方法依赖的package包/类
/**
 * Compiles and runs the passed test and sets info to any error that may have occured.
 * @param code Code of code to be compiled
 * @param codeClassName Classname of the code
 * @param test Code of tests to be compiled
 * @param testClassName Classname of the test
 * @return True if the test is compile- and runnable. Otherwise false.
 */
public boolean compileAndRunTests(String code, String codeClassName, String test, String testClassName) {
	CompilationUnit cuCode = new CompilationUnit(codeClassName, code, false);
	CompilationUnit cuTest = new CompilationUnit(testClassName, test, true);
	JavaStringCompiler jsc = CompilerFactory.getCompiler(cuCode, cuTest);
	jsc.compileAndRunTests();
	CompilerResult cr = jsc.getCompilerResult();

	if (cr.hasCompileErrors()) {
		info = formatCompileErrors(cr, cuCode);
		info += formatCompileErrors(cr, cuTest);
		return false;
	}

	TestResult tr = jsc.getTestResult();

	if (tr.getNumberOfFailedTests() != 0) {
		info = formatFailingTests(tr);
		return false;
	}

	return true;
}
 

import vk.core.api.CompilerFactory; //导入方法依赖的package包/类
public JavaStringCompiler CompilerRun(String className, String classContent, boolean isTest) {
	CompilationUnit unit = new CompilationUnit(className, classContent, isTest);
	JavaStringCompiler compiler = CompilerFactory.getCompiler(unit);
	compiler.compileAndRunTests();
	CompilerResult compilerResult = compiler.getCompilerResult();
	Collection<CompileError> errs = compilerResult.getCompilerErrorsForCompilationUnit(unit);
	for (CompileError e : errs) {
		System.out.println(e.getMessage());
		System.out.println(e.getCodeLineContainingTheError());
	}
	System.out.println("End of errors");
	return compiler;
}
 

import vk.core.api.CompilerFactory; //导入方法依赖的package包/类
/**
 * pr�ft ob {@link testClass} und {@link sourceClass} compilierbar sind
 * @return true / false
 */
public static boolean checkCompile() { //  check ob es compiled // es muss eine loesung er damit es nicht 3fach gemacht wird
	JavaStringCompiler compiler = CompilerFactory.getCompiler(testClass,sourceClass);
	compiler.compileAndRunTests();
	
	return compiler.getCompilerResult().getCompilerErrorsForCompilationUnit(sourceClass).isEmpty()
			&& compiler.getCompilerResult().getCompilerErrorsForCompilationUnit(testClass).isEmpty();
}
 

import vk.core.api.CompilerFactory; //导入方法依赖的package包/类
/**
 * pr�ft ob {@link testClass} nur einen fehlschlagenden test beinhaltet
 * @return true / false
 */
public static boolean checkTests1Failed() { // checkt ob nur 1 test failt 
	JavaStringCompiler compiler = CompilerFactory.getCompiler(testClass,sourceClass);
	compiler.compileAndRunTests();
	
	return compiler.getTestResult().getNumberOfFailedTests() == 1;
}
 

import vk.core.api.CompilerFactory; //导入方法依赖的package包/类
/**
 * pr�ft ob {@link testClass} alle tests bestanden werden
 * @return true / false
 */
public static boolean checkTestsAllSuccess() { // checkt ob alle tests failen
	JavaStringCompiler compiler = CompilerFactory.getCompiler(testClass,sourceClass);
	compiler.compileAndRunTests();
	
	return compiler.getTestResult().getNumberOfFailedTests() == 0;
}
 

import vk.core.api.CompilerFactory; //导入方法依赖的package包/类
/**
 * sammelt compiler errors in einem String 
 * gibt entweder f�r die {@link sourceClass} oder f�r die {@link testClass} die  compiler errors zur�ck
 * @param klasse 1 oder 2 entscheidet ob man die errors von der testclass oder von der sourceclass haben m�chte
 * @return Compile Errors as String of sourceclass or testclass
 */
public static String getCompileErrors(int klasse) {
	JavaStringCompiler compiler = CompilerFactory.getCompiler(testClass,sourceClass);
	compiler.compileAndRunTests();
	
	if(klasse == 1) return compiler.getCompilerResult().getCompilerErrorsForCompilationUnit(testClass).toString();
	if(klasse == 2) return compiler.getCompilerResult().getCompilerErrorsForCompilationUnit(sourceClass).toString();
	else return "";
}
 

import vk.core.api.CompilerFactory; //导入方法依赖的package包/类
/**
 * sammelt alle fehlschlagende tests in einem String 
 * @return einen String welcher alle fehlschlagende testresultate beeinhaltet
 */
public static String getTestFails() { // gibt alle falschen tests an
	JavaStringCompiler compiler = CompilerFactory.getCompiler(testClass,sourceClass);
	compiler.compileAndRunTests();
	
	compiler.getTestResult().getTestFailures().stream().forEach(e -> { fails = fails + e.getMessage() +"\n";});
	return fails;
}
 

import vk.core.api.CompilerFactory; //导入方法依赖的package包/类
@Test
public void testSomething() {
	CompilationUnit sourceClass = new CompilationUnit("Bar" ,"public class Bar { \n"
			+ " public static int fourtyTwo() { \n"
			+ "    return 41 + 1; \n"
			+ " }\n"
			+ "}" ,false);
	CompilationUnit otherClass = new CompilationUnit("Foo","public class Foo {}",true);
	JavaStringCompiler compiler = CompilerFactory.getCompiler(sourceClass);
	compiler.compileAndRunTests();
}
 

import vk.core.api.CompilerFactory; //导入方法依赖的package包/类
/**
 * Compiles and runs tests
 */
public void compileAndRunTests() {
	List<CompilationUnit> compilationUnits = new ArrayList<CompilationUnit>();
	for (Test exerciseTest : exercise.getTests()) {
		compilationUnits.add(new CompilationUnit(exerciseTest.getName(), exerciseTest.getContent(), true));
	}

	for (Class exerciseClass : exercise.getClasses()) {
		compilationUnits.add(new CompilationUnit(exerciseClass.getName(), exerciseClass.getContent(), false));
	}
	compiler = CompilerFactory.getCompiler(compilationUnits.toArray(new CompilationUnit[0]));
	compiler.compileAndRunTests();
	compilerResult = compiler.getCompilerResult();
}
 

import vk.core.api.CompilerFactory; //导入方法依赖的package包/类
public String[] executeCompiler() {
	//führt den Compiler aus. Unterscheidet zwischen Testklasse und Hauptklasse
	testSuccess = false;
	CompilationUnit classToTest = new CompilationUnit(myClass, myCode, false);
	CompilationUnit theTest = new CompilationUnit(testClass, testCode, true);		
	JavaStringCompiler myCompileObject = CompilerFactory.getCompiler(classToTest, theTest);
	myCompileObject.compileAndRunTests();
	CompilerResult cpResult = myCompileObject.getCompilerResult();
	
	String[] results = {"", "", "", ""};
	
	if(cpResult.hasCompileErrors()) {
		results[0] = handleErrors(cpResult, classToTest);
		results[1] = handleErrors(cpResult, theTest);
		
	}
	else if(testCode.contains("@Test")) {
			results[2] = handleTests(myCompileObject);
	}
	else results[2] = "Please add a proper Test!";
	
	String acceptanceResults = "";
	if(acceptanceTest != null) acceptanceResults = acceptanceCheck();
	
	results[3] = acceptanceResults;
	
	return results;
}
 

import vk.core.api.CompilerFactory; //导入方法依赖的package包/类
/**
 * Creates a new Instance of KataLiveCompiler, compiles the code and runs
 * the tests.
 * 
 * @param codeClassSourcecode
 *            The sourcecode of the class to test
 * @param testClassSourcecode
 *            The sourcecode of the class which contains the tests
 */
public KataLiveCompiler(String codeClassSourcecode, String testClassSourcecode) {
	codeClass = new CompilationUnit(this.getClassName(codeClassSourcecode), codeClassSourcecode, false);
	testClass = new CompilationUnit(this.getClassName(testClassSourcecode), testClassSourcecode, true);
	compiler = CompilerFactory.getCompiler(codeClass, testClass);
	compiler.compileAndRunTests();
}
 

import vk.core.api.CompilerFactory; //导入方法依赖的package包/类
/**
 * Method: testCompilerInit
 * <p>
 * Task: Initializes the test compiler.
 *
 * @param compUnit
 *            needs a Compilation Unit to starting the compiler.
 * @param compilationTestUnit
 *
 * @return void
 */

private void testCompilerInit(CompilationUnit compUnit, CompilationUnit compilationTestUnit) {
    testComp = CompilerFactory.getCompiler(compUnit, compilationTestUnit);
    testComp.compileAndRunTests();
}