import org.spockframework.runtime.model.FeatureInfo; //导入依赖的package包/类
private MethodInfo findCorrespondingFeatureMethod(String featureMethodName)
{
	MethodInfo methodInfo = NOT_FOUND;
	if("setup".equalsIgnoreCase(featureMethodName)) {
		return currentSpec.getSetupMethod();
	}
	if("cleanup".equalsIgnoreCase(featureMethodName)) {
		return currentSpec.getCleanupMethod();
	}
	for (FeatureInfo feature : currentSpec.getAllFeatures())
	{
		MethodInfo featureMethod = feature.getFeatureMethod();
		if (featureMethodName.equals(featureMethod.getName()))
		{
			methodInfo = featureMethod;
			break;
		}
	}
	return methodInfo;
}
 

import org.spockframework.runtime.model.FeatureInfo; //导入依赖的package包/类
@Override
public void visitSpecAnnotation(InheritedUnroll unroll, SpecInfo spec) {
  spec.getFeatures()
    .stream()
    .filter(FeatureInfo::isParameterized)
    .forEach(feature -> visitFeatureAnnotation(unroll, feature));
}
 

import org.spockframework.runtime.model.FeatureInfo; //导入依赖的package包/类
@Override
public void visitFeatureAnnotation(InheritedUnroll unroll, FeatureInfo feature) {
  if (feature.isParameterized()) {
    feature.setReportIterations(true);
    feature.setIterationNameProvider(chooseNameProvider(unroll, feature));
  }
}
 

import org.spockframework.runtime.model.FeatureInfo; //导入依赖的package包/类
private NameProvider<IterationInfo> chooseNameProvider(InheritedUnroll unroll, FeatureInfo feature) {
  if (unroll.value().length() > 0) {
    return new UnrollNameProvider(feature, unroll.value());
  } else if (feature.getName().contains("#")) {
    return new UnrollNameProvider(feature, feature.getName());
  } else {
    return null;
  }
}
 

import org.spockframework.runtime.model.FeatureInfo; //导入依赖的package包/类
@Override
public void visitSpecAnnotation(InheritedTimeout timeout, SpecInfo spec) {
  if (isDebuggerAttached()) {
    return;
  }

  for (FeatureInfo feature : spec.getFeatures()) {
    if (!feature.getFeatureMethod().getReflection().isAnnotationPresent(InheritedTimeout.class)) {
      visitFeatureAnnotation(timeout, feature);
    }
  }
}
 

import org.spockframework.runtime.model.FeatureInfo; //导入依赖的package包/类
@Override
public void addRunningFeature(FeatureInfo featureInfo) {
	SpecInfo specInfo = featureInfo.getSpec();
	Specification specFootprint = findSpecFootprint(featureInfo.getSpec());
	if (specFootprint != null) {
		getRuntimePointerForSpec(specInfo).setFeatureInfo(featureInfo);
		specFootprint.addRunningFeature(featureInfo);
	}
}
 

import org.spockframework.runtime.model.FeatureInfo; //导入依赖的package包/类
@Override
public Iterable<Iteration> findIterationFootprints(FeatureInfo featureInfo) {
	Specification specFootprint = findSpecFootprint(featureInfo.getSpec());
	if (specFootprint != null) {
		return specFootprint.getFeature(featureInfo).getAllTrackedIteration();
	}
	return null;
}
 

import org.spockframework.runtime.model.FeatureInfo; //导入依赖的package包/类
private Feature getFeature(final FeatureInfo featureInfo) {
	return Iterables.find(getAllTrackedFeatures(), new Predicate<Feature>() {
		@Override
		public boolean apply(Feature input) {
			return input != null && featureInfo.equals(input.featureInfo);
		}
	});
}
 

import org.spockframework.runtime.model.FeatureInfo; //导入依赖的package包/类
@Override
public void visitFeatureAnnotation(FailsWithMessage annotation, FeatureInfo feature) {
    feature.getFeatureMethod().addInterceptor(new FailsWithMessageInterceptor(annotation));
}
 

import org.spockframework.runtime.model.FeatureInfo; //导入依赖的package包/类
@Override
public void visitFeatureAnnotation(InheritedTimeout timeout, FeatureInfo feature) {
  feature.getFeatureMethod().addInterceptor(new TimeoutInterceptor(adapt(timeout)));
}
 

import org.spockframework.runtime.model.FeatureInfo; //导入依赖的package包/类
@Override
public void beforeIteration(final IterationInfo iteration) {
    final String uuid = testResults.get();
    final FeatureInfo feature = iteration.getFeature();
    final SpecInfo spec = feature.getSpec();
    final List<Parameter> parameters = getParameters(feature.getDataVariables(), iteration.getDataValues());
    final SpecInfo subSpec = spec.getSubSpec();
    final SpecInfo superSpec = spec.getSuperSpec();
    final String packageName = spec.getPackage();
    final String specName = spec.getName();
    final String testClassName = feature.getDescription().getClassName();
    final String testMethodName = iteration.getName();

    final List<Label> labels = new ArrayList<>();
    labels.addAll(Arrays.asList(
            //Packages grouping
            new Label().withName("package").withValue(packageName),
            new Label().withName("testClass").withValue(testClassName),
            new Label().withName("testMethod").withValue(testMethodName),
            //xUnit grouping
            new Label().withName("suite").withValue(specName),
            //Timeline grouping
            new Label().withName("host").withValue(getHostName()),
            new Label().withName("thread").withValue(getThreadName())
    ));
    if (Objects.nonNull(subSpec)) {
        labels.add(new Label().withName("subSuite").withValue(subSpec.getName()));
    }
    if (Objects.nonNull(superSpec)) {
        labels.add(new Label().withName("parentSuite").withValue(superSpec.getName()));
    }
    labels.addAll(getLabels(iteration));

    final TestResult result = new TestResult()
            .withUuid(uuid)
            .withHistoryId(getHistoryId(getQualifiedName(iteration), parameters))
            .withName(firstNonEmpty(
                    testMethodName,
                    feature.getDescription().getDisplayName(),
                    getQualifiedName(iteration)).orElse("Unknown"))
            .withFullName(getQualifiedName(iteration))
            .withStatusDetails(new StatusDetails()
                    .withFlaky(isFlaky(iteration))
                    .withMuted(isMuted(iteration)))
            .withParameters(parameters)
            .withLinks(getLinks(iteration))
            .withLabels(labels);
    processDescription(iteration, result);
    getLifecycle().scheduleTestCase(result);
    getLifecycle().startTestCase(uuid);
}
 

import org.spockframework.runtime.model.FeatureInfo; //导入依赖的package包/类
Feature(FeatureInfo featureInfo) {
	this.featureInfo = featureInfo;
}
 

import org.spockframework.runtime.model.FeatureInfo; //导入依赖的package包/类
private void setFeatureInfo(FeatureInfo featureInfo) {
	this.featureInfo = featureInfo;
}
 

import org.spockframework.runtime.model.FeatureInfo; //导入依赖的package包/类
@Override
public FeatureInfo getCurrentFeature() {
	return featureInfo;
}
 

import org.spockframework.runtime.model.FeatureInfo; //导入依赖的package包/类
public BaseSpecRunnerMock() {
    supervisor = mock(IRunSupervisor.class);
    currentFeature = mock(FeatureInfo.class, RETURNS_DEEP_STUBS);
    when(currentFeature.getFeatureMethod().getDescription().toString()).thenReturn(RunFeatureMethodInstrumenterTest.MOCKED_FEATURE_ID);
}
 

import org.spockframework.runtime.model.FeatureInfo; //导入依赖的package包/类
abstract void addRunningFeature(FeatureInfo featureInfo); 

import org.spockframework.runtime.model.FeatureInfo; //导入依赖的package包/类
abstract Iterable<? extends NodeFootprint<IterationInfo>> findIterationFootprints(FeatureInfo featureInfo); 

import org.spockframework.runtime.model.FeatureInfo; //导入依赖的package包/类
FeatureInfo getCurrentFeature();