Java CtNamedElement类代码示例

import spoon.reflect.declaration.CtNamedElement; //导入依赖的package包/类
@Override
public double codeFragmentCoverage(CodeFragment stmt) {

    CtElement e = stmt.getCtCodeFragment();

    boolean foundMethod = false;
    while ( e != null && !foundMethod ) {
        e = e.getParent();
        foundMethod = e != null && (e instanceof spoon.reflect.declaration.CtMethod || e instanceof  CtConstructor);
    }

    if (foundMethod ) {
        String className = stmt.getCtCodeFragment().getParent(CtType.class).getQualifiedName();
        return methodSignatures.contains(className + "." + ((CtNamedElement)e).getSimpleName()) ? 1.0 : 0.0;
    }
    return 0.0;
    //throw new RuntimeException("Unable to find parent method");

}
 

import spoon.reflect.declaration.CtNamedElement; //导入依赖的package包/类
public static TestListener runFromSpoonNodes(InputConfiguration configuration,
                                                String classpath,
                                                CtType<?> testClass,
                                                Collection<CtMethod<?>> testMethods) {
	return run(configuration,
			classpath,
			testClass,
			testMethods.stream()
					.map(CtNamedElement::getSimpleName)
					.collect(Collectors.toList())
	);
}
 

import spoon.reflect.declaration.CtNamedElement; //导入依赖的package包/类
@Override
public List<CtMethod<?>> selectToAmplify(List<CtMethod<?>> testsToBeAmplified) {
	if (this.currentClassTestToBeAmplified == null && !testsToBeAmplified.isEmpty()) {
		this.currentClassTestToBeAmplified = testsToBeAmplified.get(0).getDeclaringType();
		this.initialCoverage = new JacocoExecutor(this.program, this.configuration, this.currentClassTestToBeAmplified).executeJacoco(this.currentClassTestToBeAmplified);
		this.selectedToBeAmplifiedCoverageResultsMap = null;
		this.selectedAmplifiedTest.clear();
	}
	final List<String> methodNames = testsToBeAmplified.stream().map(CtNamedElement::getSimpleName).collect(Collectors.toList());
	final Map<String, CoverageResults> coverageResultsMap = new JacocoExecutor(this.program, this.configuration, this.currentClassTestToBeAmplified)
			.executeJacoco(this.currentClassTestToBeAmplified, methodNames);
	final List<String> pathExecuted = new ArrayList<>();
	final List<CtMethod<?>> filteredTests = testsToBeAmplified.stream()
			.filter(ctMethod -> {
				final String pathByExecInstructions = computePathExecuted.apply(coverageResultsMap.get(ctMethod.getSimpleName()).getCoverageBuilder());
				if (pathExecuted.contains(pathByExecInstructions)) {
					return false;
				} else {
					pathExecuted.add(pathByExecInstructions);
					return true;
				}
			}).collect(Collectors.toList());

	if (this.selectedToBeAmplifiedCoverageResultsMap == null) {
		final List<String> filteredMethodNames = filteredTests.stream()
				.map(CtNamedElement::getSimpleName)
				.collect(Collectors.toList());
		this.selectedToBeAmplifiedCoverageResultsMap = coverageResultsMap.keySet()
				.stream()
				.filter(filteredMethodNames::contains)
				.collect(Collectors.toMap(Function.identity(), coverageResultsMap::get));
	}
	return filteredTests;
}
 

import spoon.reflect.declaration.CtNamedElement; //导入依赖的package包/类
@Override
public List<CtMethod<?>> selectToKeep(List<CtMethod<?>> amplifiedTestToBeKept) {

    final String classpath = AutomaticBuilderFactory.getAutomaticBuilder(this.configuration)
            .buildClasspath(this.program.getProgramDir()) +
            System.getProperty("path.separator") +
            this.pathToChangedVersionOfProgram + "/" + this.program.getClassesDir() +
            System.getProperty("path.separator") +
            this.program.getProgramDir() + "/" + this.program.getTestClassesDir();

    final TestListener results = TestLauncher.run(this.configuration,
            classpath,
            this.currentClassTestToBeAmplified,
            amplifiedTestToBeKept.stream()
                    .map(CtNamedElement::getSimpleName)
                    .collect(Collectors.toList())
    );

    if (!results.getFailingTests().isEmpty()) {
        final List<String> failingTestName = results.getFailingTests()
                .stream()
                .map(Failure::getDescription)
                .map(Description::getMethodName)
                .collect(Collectors.toList());
        amplifiedTestToBeKept
                .stream()
                .filter(ctMethod -> failingTestName.contains(ctMethod.getSimpleName()))
                .forEach(this.selectedAmplifiedTest::add);
    }
    return amplifiedTestToBeKept;
}
 

import spoon.reflect.declaration.CtNamedElement; //导入依赖的package包/类
public void process(CtElement element) {
	if (element instanceof CtNamedElement || element instanceof CtField || element instanceof CtExecutable) {
		if (((CtModifiable) element).getModifiers().contains(ModifierKind.PUBLIC) || ((CtModifiable) element).getModifiers().contains(ModifierKind.PROTECTED)) {
			if (element.getDocComment() == null || element.getDocComment().equals("")) {
				undocumentedElements.add(element);
			}
		}
	}
}
 

import spoon.reflect.declaration.CtNamedElement; //导入依赖的package包/类
@Override
protected void enter(final @NotNull CtElement e) {
	super.enter(e);
	System.out.print('\n');
	printTabs();
	System.out.print(e.getClass().getSimpleName());

	if(e instanceof CtNamedElement) {
		System.out.print(": " + ((CtNamedElement) e).getSimpleName() + " " + SpoonHelper.INSTANCE.formatPosition(e.getPosition()));
	}else if(e instanceof CtReference) {
		System.out.print(": " + ((CtReference) e).getSimpleName() + " " + SpoonHelper.INSTANCE.formatPosition(e.getPosition()));
	}

	nbTab++;
}
 

import spoon.reflect.declaration.CtNamedElement; //导入依赖的package包/类
@Override
public List<CtMethod<?>> selectToKeep(List<CtMethod<?>> amplifiedTestToBeKept) {
	if (amplifiedTestToBeKept.isEmpty()) {
		return amplifiedTestToBeKept;
	}
	final List<String> methodNames = amplifiedTestToBeKept.stream().map(CtNamedElement::getSimpleName).collect(Collectors.toList());
	final Map<String, CoverageResults> coverageResultsMap = new JacocoExecutor(this.program, this.configuration, this.currentClassTestToBeAmplified).executeJacoco(
			this.currentClassTestToBeAmplified, methodNames);
	final List<String> pathExecuted = new ArrayList<>();
	final List<CtMethod<?>> methodsKept = amplifiedTestToBeKept.stream()
			.filter(ctMethod ->
					this.selectedToBeAmplifiedCoverageResultsMap.get(
							getFirstParentThatHasBeenRun(ctMethod).getSimpleName()) == null ||
							coverageResultsMap.get(ctMethod.getSimpleName()).isBetterThan(
							this.selectedToBeAmplifiedCoverageResultsMap.get(
									getFirstParentThatHasBeenRun(ctMethod).getSimpleName())) &&
							!computePathExecuted.apply(coverageResultsMap.get(ctMethod.getSimpleName()).getCoverageBuilder())
							.equals(computePathExecuted.apply(this.selectedToBeAmplifiedCoverageResultsMap.get(
									getFirstParentThatHasBeenRun(ctMethod).getSimpleName()).getCoverageBuilder()))
			)
			.filter(ctMethod -> {
				final String pathByExecInstructions = computePathExecuted.apply(coverageResultsMap.get(ctMethod.getSimpleName()).getCoverageBuilder());
				if (pathExecuted.contains(pathByExecInstructions)) {
					return false;
				} else {
					pathExecuted.add(pathByExecInstructions);
					return true;
				}
			})
			.collect(Collectors.toList());

	this.selectedToBeAmplifiedCoverageResultsMap.putAll(methodsKept.stream()
			.map(CtNamedElement::getSimpleName)
			.collect(
					Collectors.toMap(Function.identity(), coverageResultsMap::get)
			)
	);

	this.selectedAmplifiedTest.addAll(new ArrayList<>(methodsKept));
	return methodsKept;
}
 

import spoon.reflect.declaration.CtNamedElement; //导入依赖的package包/类
private static boolean isStmtToLog(String filter, CtStatement statement) {
    if (!(statement.getParent() instanceof CtBlock)) {
        return false;
    }
    if (statement instanceof CtInvocation) {
        CtInvocation invocation = (CtInvocation) statement;
        //type tested by the test class
        String targetType = "";
        if (invocation.getTarget() != null &&
                invocation.getTarget().getType() != null) {
            targetType = invocation.getTarget().getType().getQualifiedName();
        }
        if (targetType.startsWith(filter)) {
            return (!isVoidReturn(invocation)
                    && !isGetter(invocation));
        } else {
            return !isVoidReturn(invocation);
        }

    }

    if (statement instanceof CtLocalVariable ||
            statement instanceof CtAssignment ||
            statement instanceof CtVariableWrite) {

        if (statement instanceof CtNamedElement) {
            if (((CtNamedElement)statement).getSimpleName()
                    .startsWith("__DSPOT_")) {
                return false;
            }
        }

        final CtTypeReference type = ((CtTypedElement) statement).getType();
        if (type.getQualifiedName().startsWith(filter)) {
            return true;
        } else {
            try {
                return type.getActualClass() == String.class;
            } catch (SpoonClassNotFoundException e) {
                return false;
            }
        }
    } else {
        return false;
    }
}
 

import spoon.reflect.declaration.CtNamedElement; //导入依赖的package包/类
@Override
public boolean isToBeProcessed(CtNamedElement candidate) {
    return classes.contains(candidate.getSimpleName());
}
 

import spoon.reflect.declaration.CtNamedElement; //导入依赖的package包/类
@Override
public void scanCtNamedElement(CtNamedElement e) {
	label = e.getSimpleName();
}