import vk.core.api.JavaStringCompiler; //导入依赖的package包/类
/**
 * Method: setTestResults
 * <p>
 * Task: Method that saves the errors/information from the internal compiler
 * into an ArrayList.
 *
 * @param compiler
 *            so that method can access the information
 *
 * @return void
 */

protected void setTestResults(JavaStringCompiler compiler) {
    CompilerResult compilerResult = compiler.getCompilerResult();
    testResults = new LinkedList<>();
    if (!compilerResult.hasCompileErrors()) {
        int failedTestsNumber = compiler.getTestResult().getNumberOfFailedTests();
        failedTests = Integer.toString(failedTestsNumber);
        int ignoredTestsNumber = compiler.getTestResult().getNumberOfIgnoredTests();
        ignoredTests = Integer.toString(ignoredTestsNumber);
        int successfulTestsNumber = compiler.getTestResult().getNumberOfSuccessfulTests();
        successfulTests = Integer.toString(successfulTestsNumber);

        testResults.add(successfulTests);
        testResults.add(ignoredTests);
        testResults.add(failedTests);

    } else {
        testResults.add("");
        testResults.add("");
        testResults.add("");
    }
}
 

import vk.core.api.JavaStringCompiler; //导入依赖的package包/类
private String handleTests(JavaStringCompiler myCompileObject) {
	String testResults = "";
	TestResult happyEndChecker = myCompileObject.getTestResult();
	if(happyEndChecker.getNumberOfFailedTests() == 0) {
		testResults += "All tests succeeded!\n";
		testSuccess = true;
	}
	else {
		testSuccess = false;
		testResults += "Successful Tests: " + happyEndChecker.getNumberOfSuccessfulTests() + "\n";
		testResults += "Failed Tests: " + happyEndChecker.getNumberOfFailedTests() + "\n\n";
		Collection<TestFailure> fails = happyEndChecker.getTestFailures();
		Iterator<TestFailure> fail = fails.iterator();
		while(fail.hasNext()) {
			TestFailure found = fail.next();
			testResults += "Class: " + found.getTestClassName() + "\n" 
			+ "Method: " + found.getMethodName() + "\n" 
			+ "Message: " + found.getMessage();
		}		
	}
	return testResults;
}
 

import vk.core.api.JavaStringCompiler; //导入依赖的package包/类
private String handleAcceptanceTests(JavaStringCompiler myCompileObject) {
	String testResults = "";
	TestResult happyEndChecker = myCompileObject.getTestResult();
	
	if(happyEndChecker.getNumberOfFailedTests() == 0) {
		testResults += "All tests succeeded!";
		acceptance = true;
	}
	else {
		acceptance = false;
		testResults += "Acceptance Test Failed\n";
		testResults += "Successful Tests: " + happyEndChecker.getNumberOfSuccessfulTests() + "\n";
		testResults += "Failed Tests: " + happyEndChecker.getNumberOfFailedTests() + "\n\n";
		Collection<TestFailure> fails = happyEndChecker.getTestFailures();
		Iterator<TestFailure> fail = fails.iterator();
		while(fail.hasNext()) {
			TestFailure found = fail.next();
			testResults += "Class: " + found.getTestClassName() + "\n" 
			+ "Method: " + found.getMethodName() + "\n" 
			+ "Message: " + found.getMessage();
		}		
	}
	return testResults;
}
 

import vk.core.api.JavaStringCompiler; //导入依赖的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.JavaStringCompiler; //导入依赖的package包/类
/**
 * Gibt Testergebnisse auf die (programminterne) Konsole aus.
 * 
 * Wandelt übergebene Compilationunits mit {@link #getJSC(CompilationUnit[])} in JavaStringCompiler um,
 * bestimmt Anzahl der erfolgreichen und fehlgeschlagenen Tests und gibt dies, sowie genauere Fehlermendungen
 * auf der programminternen Konsole aus.
 */
public static void test(CompilationUnit[] comp_uns){ //gibt testergebnisse auf console aus
	JavaStringCompiler comp = getJSC(comp_uns);
	TestResult test_res = comp.getTestResult();
	int tests_ok = test_res.getNumberOfSuccessfulTests();
	int tests_fail = test_res.getNumberOfFailedTests();
	console.set_textln("Testresult:");
	Collection<TestFailure> fails = test_res.getTestFailures();
	console.set_textln("OK: "+tests_ok+" FAIL: "+tests_fail);
	for(TestFailure fail: fails){
		console.set_textln("Testname: "+fail.getTestClassName());
		console.set_textln("Methodname: "+fail.getMethodName());
		console.set_textln(fail.getMessage());
		console.set_textln("");
	}
	console.set_textln("");

}
 

import vk.core.api.JavaStringCompiler; //导入依赖的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.JavaStringCompiler; //导入依赖的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.JavaStringCompiler; //导入依赖的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.JavaStringCompiler; //导入依赖的package包/类
public boolean TestFehlschlag(String className, String classContent) {

		if(CompileErrors(className, classContent) == false){
		JavaStringCompiler compiler = CompilerRun(className, classContent, true);

		int result = compiler.getTestResult().getNumberOfFailedTests();
		System.out.println("Failed tests " + result);
		if (result != 0) {
			return true;
		}
		return false;

		} return false;

	}
 

import vk.core.api.JavaStringCompiler; //导入依赖的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.JavaStringCompiler; //导入依赖的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.JavaStringCompiler; //导入依赖的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.JavaStringCompiler; //导入依赖的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.JavaStringCompiler; //导入依赖的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.JavaStringCompiler; //导入依赖的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.JavaStringCompiler; //导入依赖的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.JavaStringCompiler; //导入依赖的package包/类
/**
 * Gibt Compilierfehler (wenn vorhanden) auf die (programminterne) Konsole aus
 * 
 * Wandelt übergebene Compilationunits mit {@link #getJSC(CompilationUnit[])} in JavaStringCompiler um,
 * und gibt Compilierfehler mit {@link #print_errors_to_console(Collection)} auf der programminternen Konsole aus.

 */
public static void compile(CompilationUnit[] comp_uns){ //gibt fehlermeldungen, wenn vorhanden auf die console aus
	JavaStringCompiler comp = getJSC(comp_uns);
	CompilerResult comp_res = comp.getCompilerResult();
	if(comp_res.hasCompileErrors()){
		for(CompilationUnit cu: comp_uns){
			Collection<CompileError> errors = comp_res.getCompilerErrorsForCompilationUnit(cu);
			print_errors_to_console(errors);
		}
	} else console.set_textln("No Compilation errors");
}
 

import vk.core.api.JavaStringCompiler; //导入依赖的package包/类
/**
 * Prüft ob Compilierfehler vorliegen.
 */
public static boolean hasCompileErrors(CompilationUnit[] comp_uns){ //fuer next-button
	JavaStringCompiler comp = getJSC(comp_uns);
	CompilerResult comp_res = comp.getCompilerResult();
	compile(comp_uns);
	return comp_res.hasCompileErrors();
}
 

import vk.core.api.JavaStringCompiler; //导入依赖的package包/类
/**
 * Prüft ob alle Tests bestanden werden.
 * 
 * Prüft ob die Compilationunits fehlerlos compilieren und prüft anschließend ob alle enthaltenen Tests erfolgreich sind.
 */
public static boolean tests_passed(CompilationUnit[] comp_uns){ //fuer next-button
	if(!hasCompileErrors(comp_uns)){
		JavaStringCompiler comp = getJSC(comp_uns);
		TestResult test_res = comp.getTestResult();
		test(comp_uns);
		return(test_res.getNumberOfFailedTests() == 0);
	} else return false;
}
 

import vk.core.api.JavaStringCompiler; //导入依赖的package包/类
public GreenValidator(JavaStringCompiler compiler) {
    this.compiler = compiler;
    this.Tests=compiler.getTestResult();
    checkifReady();
    if (Compiled) {
        BadTest();
    }
}