import gherkin.ast.Step; //导入依赖的package包/类
protected Object[] getArguments(Step step, StepImplementation implementation) {
	Method method = implementation.getMethod();
	Parameter[] parameters = method.getParameters();
	Object[] arguments = new Object[parameters.length];

	if (parameters.length > 0) {
		String text = step.getText();
		Pattern pattern = implementation.getPattern();
		Matcher matcher = pattern.matcher(text);
		checkState(matcher.find(),
			"unable to locate substitution parameters for pattern %s with input %s", pattern.pattern(), text);

		int groupCount = matcher.groupCount();
		ConversionService conversionService = SpringPreProcessor.getBean(ConversionService.class);
		for (int i = 0; i < groupCount; i++) {
			String parameterAsString = matcher.group(i + 1);
			Parameter parameter = parameters[i];
			Class<?> parameterType = parameter.getType();

			Object converted = conversionService.convert(parameterAsString, parameterType);
			arguments[i] = converted;
		}
	}
	return arguments;
}
 

import gherkin.ast.Step; //导入依赖的package包/类
@SuppressWarnings("Guava")
@Test
public void testGetParameterizedMartini() throws NoSuchMethodException {
	String id = "Parameterized_Method_Calls:A_Parameterized_Case:25";
	Martini martini = getMartini(id);
	checkState(null != martini, "no Martini found matching ID [%s]", id);

	Map<Step, StepImplementation> stepIndex = martini.getStepIndex();
	Collection<StepImplementation> implementations = stepIndex.values();
	ImmutableList<StepImplementation> filtered = FluentIterable.from(implementations)
		.filter(notNull())
		.filter(Predicates.not(Predicates.instanceOf(UnimplementedStep.class)))
		.toList();
	assertFalse(filtered.isEmpty(), "expected at least one implementation");
	StepImplementation givenImplementation = filtered.get(0);

	Pattern pattern = givenImplementation.getPattern();
	assertNotNull(pattern, "expected implementation to have a Pattern");

	String regex = pattern.pattern();
	assertEquals(regex, "^a pre-existing condition known as \"(.+)\"$", "Pattern contains wrong regex");

	Method method = givenImplementation.getMethod();
	Method expected = ParameterizedTestSteps.class.getDeclaredMethod("aPreExistingConditionKnownAs", String.class);
	assertEquals(method, expected, "implementation contains wrong Method");
}
 

import gherkin.ast.Step; //导入依赖的package包/类
private void createTestCases(Scenario scenario, Feature feature) {
    for (ScenarioDefinition scenarioDef : feature.getChildren()) {
        String scenDefName = scenarioDef.getName();
        TestCase testCase = updateInfo(createTestCase(scenario, scenDefName), scenarioDef);
        testCase.clearSteps();
        for (Step step : scenarioDef.getSteps()) {
            String reusableName = convert(step.getText());
            TestCase reusable = updateInfo(createReusable(create("StepDefinitions"), reusableName), step);
            if (reusable != null) {
                reusable.addNewStep()
                        .setInput(getInputField(testCase.getName(), step.getText()))
                        .setDescription(getDescription(step));
            }
            testCase.addNewStep()
                    .asReusableStep("StepDefinitions", reusableName)
                    .setDescription(getDescription(step));
        }
        if (scenarioDef instanceof ScenarioOutline) {
            ScenarioOutline scOutline = (ScenarioOutline) scenarioDef;
            createTestData(testCase, scOutline.getExamples());
        }
    }
}
 

import gherkin.ast.Step; //导入依赖的package包/类
private TestCase updateInfo(TestCase tc, Step step) {
    if (tc != null) {
        DataItem tcInfo = pModel().getData().find(tc.getName(), tc.getScenario().getName())
                .orElseGet(() -> {
                    DataItem di = DataItem.createTestCase(tc.getName(), tc.getScenario().getName());
                    pModel().addData(di);
                    return di;
                });

        tcInfo.getAttributes().update(Attribute.create("feature.children.step.line", step.getLocation().getLine()));
        tcInfo.getAttributes().update(Attribute.create("feature.children.step.text", step.getText()));
        tcInfo.getAttributes().update(Attribute.create("feature.children.step.argument", step.getArgument()));
        tcInfo.getAttributes().update(Attribute.create("feature.children.step.keyword", step.getKeyword()));
        pModel().addData(tcInfo);
    }
    return tc;
}
 

import gherkin.ast.Step; //导入依赖的package包/类
/**
 * Converts a list of Gherkin steps to Cucable steps including data tables.
 *
 * @param gherkinSteps a {@link Step} list.
 * @return a {@link com.trivago.rta.vo.Step} list.
 */
List<com.trivago.rta.vo.Step> convertGherkinStepsToCucableSteps(final List<Step> gherkinSteps) {
    List<com.trivago.rta.vo.Step> steps = new ArrayList<>();

    for (Step gherkinStep : gherkinSteps) {
        com.trivago.rta.vo.Step step;
        com.trivago.rta.vo.DataTable dataTable = null;

        Node argument = gherkinStep.getArgument();
        if (argument instanceof DataTable) {
            dataTable = convertGherkinDataTableToCucumberDataTable((DataTable) argument);
        }

        String keywordAndName = gherkinStep.getKeyword().concat(gherkinStep.getText());
        step = new com.trivago.rta.vo.Step(keywordAndName, dataTable);
        steps.add(step);
    }
    return steps;
}
 

import gherkin.ast.Step; //导入依赖的package包/类
@Test
public void convertGherkinStepsToCucableStepsTest() {
    List<Step> gherkinSteps = Arrays.asList(
            new Step(new Location(1, 1),
                    "Given ", "this is a test step", null),
            new Step(new Location(2, 1),
                    "Then ", "I get a test result", null)
    );

    List<com.trivago.rta.vo.Step> steps = gherkinToCucableConverter.convertGherkinStepsToCucableSteps(gherkinSteps);
    assertThat(steps.size(), is(gherkinSteps.size()));
    com.trivago.rta.vo.Step firstStep = steps.get(0);
    assertThat(firstStep.getName(), is("Given this is a test step"));
    com.trivago.rta.vo.Step secondStep = steps.get(1);
    assertThat(secondStep.getName(), is("Then I get a test result"));
}
 

import gherkin.ast.Step; //导入依赖的package包/类
@Override
public void stepFailed(Step s, Throwable t) {
    // The additional " " is expected
    if (!"When ".equals(s.getKeyword())) {
        if (CommandLineOptions.hasOption("error")) {
            StringWriter errors = new StringWriter();
            t.printStackTrace(new PrintWriter(errors));
            reporter.report("    Step " + s.getText() + " " + Style.red("failed") + ":\n"
                    + errors.toString());
        }
        else {
            reporter.report("    Step " + s.getText() + " " + Style.red("failed")
                    + ":    \n" + t.getMessage());
        }
    }
}
 

import gherkin.ast.Step; //导入依赖的package包/类
private ScenarioDefinition concreteScenario(ScenarioOutline abstractScenario, Map<String, String> parameters)
{
    List<Step> steps = new ArrayList<>();

    for (Step step : abstractScenario.getSteps())
    {
        steps.add(concreteStep(step, parameters));
    }

    return new gherkin.ast.Scenario(
            abstractScenario.getTags(),
            abstractScenario.getLocation(),
            abstractScenario.getKeyword(),
            abstractScenario.getName(),
            abstractScenario.getDescription(),
            steps);
}
 

import gherkin.ast.Step; //导入依赖的package包/类
private Step concreteStep(Step abstractStep, Map<String, String> parameters)
{
    String text = abstractStep.getText();

    for (Entry<String, String> entry : parameters.entrySet())
    {
        String target = String.format("<%s>", entry.getKey());
        String replacement = entry.getValue();

        text = text.replace(target, replacement);
    }

    return new Step(
            abstractStep.getLocation(),
            abstractStep.getKeyword(),
            text,
            abstractStep.getArgument());
}
 

import gherkin.ast.Step; //导入依赖的package包/类
private void processStep(Step step, List<StepDefinition> stepDefinitions)
{
    String keyword = step.getKeyword().trim();
    String text = step.getText().trim();
    Node argument = step.getArgument();

    testLog.logStep(keyword, text);

    for (StepDefinition stepDefinition : stepDefinitions)
    {
        if (stepDefinition.matches(text))
        {
            stepDefinition.invoke(text, argument);
            return;
        }
    }

    throw new StepDefinitionNotFoundException(keyword, text);
}
 

import gherkin.ast.Step; //导入依赖的package包/类
public void execute() throws InvocationTargetException, IllegalAccessException {
	assertNotInterrupted();
	try {
		Martini martini = martiniResult.getMartini();
		Map<Step, StepImplementation> stepIndex = martini.getStepIndex();
		martiniResult.setStartTimestamp(System.currentTimeMillis());

		DefaultStepResult lastResult = null;
		for (Map.Entry<Step, StepImplementation> mapEntry : stepIndex.entrySet()) {
			assertNotInterrupted();
			Step step = mapEntry.getKey();
			eventManager.publishBeforeStep(this, martiniResult);

			StepImplementation implementation = mapEntry.getValue();
			if (null == lastResult || Status.PASSED == lastResult.getStatus()) {
				lastResult = execute(step, implementation);
			}
			else {
				lastResult = new DefaultStepResult(step, implementation);
				lastResult.setStatus(Status.SKIPPED);
			}
			martiniResult.add(lastResult);
			eventManager.publishAfterStep(this, martiniResult);
		}
	}
	finally {
		martiniResult.setEndTimestamp(System.currentTimeMillis());
	}
}
 

import gherkin.ast.Step; //导入依赖的package包/类
@Override
public SpecflowFileContents translate(List<ScenarioDefinition> scenarios, List<Tag> tags, ITestFrameworkConstants constants) {
    String featureContent = scenarios.stream()
            .map( scenario -> {
                String stepsString = scenario.getSteps().stream()
                        .map( step -> String.format(StepBody, step.getKeyword(), step.getText()) )
                        .collect( Collectors.joining( System.getProperty("line.separator")) );
                String tagsString = tags.stream()
                        .map(tg -> String.format("\"%1$s\"", tg.getName()))
                        .collect(Collectors.joining(","));
                return String.format(ScenarioBody,
                        constants.getTestScenarioMethodHeader(scenario.getName()),
                        scenario.getName().replaceAll("[^A-Za-z0-9]", ""),
                        scenario.getName(),
                        tagsString,
                        stepsString);
            })
            .collect( Collectors.joining( System.getProperty("line.separator")) );
    List<Step> stepsDone= new ArrayList<>();
    String stepString = scenarios.stream()
            .map(ScenarioDefinition::getSteps)
            .flatMap(List::stream)
            .filter(step -> !stepsDone.stream().anyMatch(stepDone -> step.getText() == stepDone.getText() && step.getKeyword() == stepDone.getKeyword()))
            .peek(step -> stepsDone.add(step))
            .map(step -> String.format(StepsStepsBody,
                    step.getKeyword(),
                    step.getText(),
                    step.getText().replaceAll("[^A-Za-z0-9]", "")))
            .collect( Collectors.joining( System.getProperty("line.separator")) );

    return new SpecflowFileContents(featureContent, stepString);
}
 

import gherkin.ast.Step; //导入依赖的package包/类
protected DefaultMartini(
	Recipe recipe,
	ImmutableMap<Step, StepImplementation> stepIndex,
	Iterable<DefaultMartiniTag> tags
) {
	this.recipe = recipe;
	this.stepIndex = stepIndex;
	this.tags = ImmutableSet.copyOf(tags);
}
 

import gherkin.ast.Step; //导入依赖的package包/类
@Override
public boolean isAnyStepAnnotated(Class<? extends Annotation> annotationClass) {
	checkNotNull(annotationClass, "null Class");
	Map<Step, StepImplementation> index = getStepIndex();

	boolean evaluation = false;
	Iterator<Map.Entry<Step, StepImplementation>> i = index.entrySet().iterator();
	while (!evaluation && i.hasNext()) {
		Map.Entry<Step, StepImplementation> mapEntry = i.next();
		StepImplementation implementation = mapEntry.getValue();
		Method method = implementation.getMethod();
		evaluation = null != method && method.isAnnotationPresent(annotationClass);
	}
	return evaluation;
}
 

import gherkin.ast.Step; //导入依赖的package包/类
@Override
public ImmutableList<Martini> getMartinis() {
	synchronized (martinisReference) {
		ImmutableList<Martini> martinis = martinisReference.get();
		if (null == martinis) {
			Map<String, StepImplementation> index = context.getBeansOfType(StepImplementation.class);
			Collection<StepImplementation> implementations = index.values();

			ImmutableList.Builder<Martini> builder = ImmutableList.builder();
			for (Recipe recipe : recipes) {
				DefaultMartini.Builder martiniBuilder = DefaultMartini.builder().setRecipe(recipe);
				Pickle pickle = recipe.getPickle();
				Background background = recipe.getBackground();
				ScenarioDefinition scenarioDefinition = recipe.getScenarioDefinition();
				List<PickleStep> steps = pickle.getSteps();
				for (PickleStep step : steps) {
					Step gherkinStep = getGherkinStep(background, scenarioDefinition, step);
					StepImplementation implementation = getImplementation(gherkinStep, implementations);
					martiniBuilder.add(gherkinStep, implementation);
				}
				Martini martini = martiniBuilder.build();
				builder.add(martini);
			}
			martinis = builder.build();
			martinisReference.set(martinis);
		}
		return martinis;
	}
}
 

import gherkin.ast.Step; //导入依赖的package包/类
protected StepImplementation getImplementation(
	gherkin.ast.Step step, Collection<StepImplementation> implementations
) {

	List<StepImplementation> matches = Lists.newArrayList();
	for (StepImplementation implementation : implementations) {
		if (implementation.isMatch(step)) {
			matches.add(implementation);
		}
	}

	StepImplementation match;

	int count = matches.size();
	if (1 == count) {
		match = matches.get(0);
	}
	else if (count > 1) {
		throw AmbiguousStepException.builder().setStep(step).setMatches(matches).build();
	}
	else if (unimplementedStepsFatal) {
		throw UnimplementedStepException.builder().build(step);
	}
	else {
		match = getUnimplemented(step);
	}
	return match;
}
 

import gherkin.ast.Step; //导入依赖的package包/类
protected JsonObject build() {
	Step step = stepResult.getStep();
	addStartTimestamp();
	addEndTimestamp();
	addKeyword(step);
	addText(step);
	addLocation(step);
	addMethod();
	addStatus();
	addEmbedded();
	addException();
	return serialized;
}
 

import gherkin.ast.Step; //导入依赖的package包/类
@Test
public void testBackground() {
	String id = "Fairytales:Sleeping_Beauty:22";
	Martini martini = this.getMartini(id);
	checkState(null != martini, "unable to retrieve Martini by ID %s", id);

	Map<Step, StepImplementation> index = martini.getStepIndex();
	checkState(4 == index.size(), "wrong number of steps returned, expected 4 but found %s", index.size());
}
 

import gherkin.ast.Step; //导入依赖的package包/类
private List<PickleStep> pickleSteps(ScenarioDefinition scenarioDefinition, String path) {
    List<PickleStep> result = new ArrayList<>();
    for (Step step : scenarioDefinition.getSteps()) {
        result.add(pickleStep(step, path));
    }
    return unmodifiableList(result);
}
 

import gherkin.ast.Step; //导入依赖的package包/类
private PickleStep pickleStep(Step step, String path) {
    return new PickleStep(
            step.getText(),
            createPickleArguments(step.getArgument(), path),
            singletonList(pickleStepLocation(step, path)),
            step.getKeyword().trim()
    );
}