import gherkin.ast.Feature; //导入依赖的package包/类
@Override
public SpecflowFileContents translate(Feature content, SpecflowFileContents scenarios, ITestFrameworkConstants constants) {
    String featureContent = String.format(BodyContent,
            constants.getExpectedClassAttributes(content.getName()),
            content.getName().replaceAll("[^A-Za-z0-9]", ""),
            constants.getTestFixtureSetupHeader(),
            content.getName(),
            content.getDescription(),
            constants.getTestFixtureTearDownHeader(),
            constants.getTestScenarioSetupHeader(),
            constants.getTestScenarioTearDownHeader(),
            scenarios.feature);
    String stepsContent = String.format(StepsFeatureBody,
            content.getName().replaceAll("[^A-Za-z0-9]", ""),
            scenarios.steps);
    return new SpecflowFileContents(featureContent,stepsContent);
}
 

import gherkin.ast.Feature; //导入依赖的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.Feature; //导入依赖的package包/类
public List<Pickle> compile(GherkinDocument gherkinDocument, String path) {
    List<Pickle> pickles = new ArrayList<>();
    Feature feature = gherkinDocument.getFeature();
    if (feature == null) {
        return pickles;
    }

    List<Tag> featureTags = feature.getTags();
    List<PickleStep> backgroundSteps = new ArrayList<>();

    for (ScenarioDefinition scenarioDefinition : feature.getChildren()) {
        if (scenarioDefinition instanceof Background) {
            backgroundSteps = pickleSteps(scenarioDefinition, path);
        } else if (scenarioDefinition instanceof Scenario) {
            compileScenario(pickles, backgroundSteps, (Scenario) scenarioDefinition, featureTags, path);
        } else {
            compileScenarioOutline(pickles, backgroundSteps, (ScenarioOutline) scenarioDefinition, featureTags, path);
        }
    }
    return pickles;
}
 

import gherkin.ast.Feature; //导入依赖的package包/类
private List<ScenarioDefinition> scenarios(Feature feature)
{
    List<ScenarioDefinition> result = new ArrayList<>();

    for (ScenarioDefinition scenario : feature.getChildren())
    {
        if (isScenarioNormal(scenario))
        {
            result.add(scenario);
        }
        else if (isScenarioOutline(scenario))
        {
            ScenarioOutline scenarioOutline = (ScenarioOutline) scenario;

            for (Examples examples : scenarioOutline.getExamples())
            {
                for (TableRow row : examples.getTableBody())
                {
                    result.add(concreteScenario(scenarioOutline, parametersMap(examples.getTableHeader(), row)));
                }
            }
        }
    }

    return result;
}
 

import gherkin.ast.Feature; //导入依赖的package包/类
public List<Pickle> compile(GherkinDocument gherkinDocument) {
    List<Pickle> pickles = new ArrayList<>();
    Feature feature = gherkinDocument.getFeature();
    if (feature == null) {
        return pickles;
    }

    List<Tag> featureTags = feature.getTags();
    List<PickleStep> backgroundSteps = new ArrayList<>();

    for (ScenarioDefinition scenarioDefinition : feature.getChildren()) {
        if (scenarioDefinition instanceof Background) {
            backgroundSteps = pickleSteps(scenarioDefinition);
        } else if (scenarioDefinition instanceof Scenario) {
            compileScenario(pickles, backgroundSteps, (Scenario) scenarioDefinition, featureTags);
        } else {
            compileScenarioOutline(pickles, backgroundSteps, (ScenarioOutline) scenarioDefinition, featureTags);
        }
    }
    return pickles;
}
 

import gherkin.ast.Feature; //导入依赖的package包/类
public List<Pickle> compile(GherkinDocument gherkinDocument) {
    List<Pickle> pickles = new ArrayList<>();
    Feature feature = gherkinDocument.getFeature();
    if (feature == null) {
        return pickles;
    }

    String language = feature.getLanguage();
    List<Tag> featureTags = feature.getTags();
    List<PickleStep> backgroundSteps = new ArrayList<>();

    for (ScenarioDefinition scenarioDefinition : feature.getChildren()) {
        if (scenarioDefinition instanceof Background) {
            backgroundSteps = pickleSteps(scenarioDefinition);
        } else if (scenarioDefinition instanceof Scenario) {
            compileScenario(pickles, backgroundSteps, (Scenario) scenarioDefinition, featureTags, language);
        } else {
            compileScenarioOutline(pickles, backgroundSteps, (ScenarioOutline) scenarioDefinition, featureTags, language);
        }
    }
    return pickles;
}
 

import gherkin.ast.Feature; //导入依赖的package包/类
public Feature getFeature(final String path) {
    if (!pathToAstMap.containsKey(path)) {
        parseGherkinSource(path);
    }
    if (pathToAstMap.containsKey(path)) {
        return pathToAstMap.get(path).getFeature();
    }
    return null;
}
 

import gherkin.ast.Feature; //导入依赖的package包/类
public String getKeywordFromSource(final String uri, final int stepLine) {
    final Feature feature = getFeature(uri);
    if (feature != null) {
        final TestSourceRead event = getTestSourceReadEvent(uri);
        final String trimmedSourceLine = event.source.split("\n")[stepLine - 1].trim();
        final GherkinDialect dialect = new GherkinDialectProvider(feature.getLanguage()).getDefaultDialect();
        for (String keyword : dialect.getStepKeywords()) {
            if (trimmedSourceLine.startsWith(keyword)) {
                return keyword;
            }
        }
    }
    return "";
}
 

import gherkin.ast.Feature; //导入依赖的package包/类
@Override
public SpecflowFileContents analyze(String file, String namespace) {
    Feature feature = parser.parse(file).getFeature();
    SpecflowFileContents scenariosTranslate = translator.translate(feature.getChildren(), feature.getTags(), constants);
    SpecflowFileContents featureTranslate = translator.translate(feature,scenariosTranslate, constants);
    SpecflowFileContents FileTranslate = translator.translate(namespace,featureTranslate, constants);
    return FileTranslate;
}
 

import gherkin.ast.Feature; //导入依赖的package包/类
@Test
public void analizeCallsCorrectProcess() throws Exception {
    Parser<GherkinDocument> parser = (Parser<GherkinDocument>) mock(Parser.class);
    ISpecflowTranslator translator = mock(ISpecflowTranslator.class);
    ITestFrameworkConstants constants = mock(ITestFrameworkConstants.class);

    String document = Faker.getRandomString();
    GherkinDocument gherkinDocument = mock(GherkinDocument.class);
    when(parser.parse(document)).thenReturn(gherkinDocument);
    Feature feature = mock(Feature.class);
    List<ScenarioDefinition> scenarios = new ArrayList<>();
    List<Tag> tags = new ArrayList<>();
    when(feature.getChildren()).thenReturn(scenarios);
    when(feature.getTags()).thenReturn(tags);

    when(gherkinDocument.getFeature()).thenReturn(feature);
    SpecflowFileContents translatedScenarios =new SpecflowFileContents(Faker.getRandomString(), Faker.getRandomString());
    SpecflowFileContents translatedFeature =new SpecflowFileContents(Faker.getRandomString(), Faker.getRandomString());
    SpecflowFileContents translatedFile =new SpecflowFileContents(Faker.getRandomString(), Faker.getRandomString());
    String namespace = Faker.getRandomString();
    when(translator.translate(scenarios, tags, constants)).thenReturn(translatedScenarios);
    when(translator.translate(feature, translatedScenarios,constants)).thenReturn(translatedFeature);
    when(translator.translate(namespace,translatedFeature, constants)).thenReturn(translatedFile);

    SpecflowAnalyzer analyzer = new SpecflowAnalyzer(parser, translator, constants);
    SpecflowFileContents contents = analyzer.analyze(document, namespace);

    verify(parser).parse(document);
    assertEquals(translatedFile.feature, contents.feature);
    assertEquals(translatedFile.steps, contents.steps);
}
 

import gherkin.ast.Feature; //导入依赖的package包/类
@Test
public void translateFeatureTest() {

    SpecflowTranslatorCSharp translator = new SpecflowTranslatorCSharp();

    Feature feature = mock(Feature.class);
    ITestFrameworkConstants constants = mock(ITestFrameworkConstants.class);

    when(feature.getName()).thenReturn(Faker.getRandomString().replace('-', ' ') + "("+Faker.getRandomString()+"<>!)");
    when(feature.getDescription()).thenReturn(Faker.getRandomString().replace('-', ' ') + "("+Faker.getRandomString()+"<>!)");
    when(constants.getExpectedClassAttributes(feature.getName())).thenReturn(Faker.getRandomString());
    when(constants.getTestFixtureSetupHeader()).thenReturn(Faker.getRandomString());
    when(constants.getTestFixtureTearDownHeader()).thenReturn(Faker.getRandomString());
    when(constants.getTestScenarioSetupHeader()).thenReturn(Faker.getRandomString());
    when(constants.getTestScenarioTearDownHeader()).thenReturn(Faker.getRandomString());

    SpecflowFileContents scenarionContent = new SpecflowFileContents(Faker.getRandomString(), Faker.getRandomString());

    SpecflowFileContents contents = translator.translate(feature, scenarionContent, constants);
    String ExpectedFeatureContent = String.format(BodyContent,
            constants.getExpectedClassAttributes(feature.getName()),
            feature.getName().replaceAll("[^A-Za-z0-9]", ""),
            constants.getTestFixtureSetupHeader(),
            feature.getName(),
            feature.getDescription(),
            constants.getTestFixtureTearDownHeader(),
            constants.getTestScenarioSetupHeader(),
            constants.getTestScenarioTearDownHeader(),
            scenarionContent.feature);

    String ExpectedStepsContent = String.format(StepsFeatureBody,
            feature.getName().replaceAll("[^A-Za-z0-9]", ""),
            scenarionContent.steps);
    assertEquals(ExpectedFeatureContent, contents.feature);
    assertEquals(ExpectedStepsContent, contents.steps);
}
 

import gherkin.ast.Feature; //导入依赖的package包/类
public void parse(File file) {
    if (file != null && file.exists()) {
        try {
            Feature feature = GHERKIN_PARSER.parse(new FileReader(file)).getFeature();
            String featureName = feature.getName();
            createTestCases(updateInfo(create(featureName), feature),
                    feature);
            File tp = new File(sMainFrame.getProject().getLocation(), "TestPlan");
            Files.copy(file, new File(tp, file.getName()));
        } catch (Exception ex) {
            Logger.getLogger(BddParser.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}
 

import gherkin.ast.Feature; //导入依赖的package包/类
private Scenario updateInfo(Scenario scn, Feature feature) {
    String desc = feature.getDescription();
    List<Tag> tags = toTag(feature.getTags());
    Meta metaRes = pModel().findScenario(scn.getName())
            .orElseGet(() -> {
                Meta meta = Meta.createScenario(scn.getName());
                pModel().addMeta(meta);
                return meta;
            });
    metaRes.setTags(tags);
    metaRes.getAttributes().add(Attribute.create("feature.line", feature.getLocation().getLine()));
    metaRes.setDesc(desc);
    return scn;
}
 

import gherkin.ast.Feature; //导入依赖的package包/类
private List<ScenarioDefinition> backgrounds(Feature feature)
{
    List<ScenarioDefinition> result = new ArrayList<>();

    for (ScenarioDefinition scenario : feature.getChildren())
    {
        if (gherkin.ast.Background.class.isInstance(scenario))
        {
            result.add(scenario);
        }
    }

    return result;
}
 

import gherkin.ast.Feature; //导入依赖的package包/类
/**
 * Generates a single Cucumber runner for each separate feature file.
 *
 * @param outputDirectory the output directory to place generated files
 * @param featureFiles    The feature files to create runners for
 * @throws MojoExecutionException if something goes wrong
 */
public void generateCucumberITFiles(final File outputDirectory,
                                    final Collection<File> featureFiles) throws MojoExecutionException {
    final Parser<Feature> parser = new Parser<Feature>(new AstBuilder());
    Feature feature = null;
    for (final File file : featureFiles) {

        try {
            feature = parser.parse(new FileReader(file), new TokenMatcher());
        } catch (final FileNotFoundException e) {
            // should never happen
            // TODO - proper logging
            System.out.println(format("WARNING: Failed to parse '%s'...IGNORING",
                    file.getName()));
        }

        if (shouldSkipFeature(feature)) {
            continue;
        }


        outputFileName = classNamingScheme.generate(file.getName());
        setFeatureFileLocation(file);
        setParsedFeature(feature);
        writeFile(outputDirectory);

    }
}
 

import gherkin.ast.Feature; //导入依赖的package包/类
private boolean shouldSkipFeature(final Feature feature) {
    if (!overriddenParameters.getTags().isEmpty()) {
        final TagFilter tagFilter = new TagFilter(overriddenParameters.getTags());
        if (tagFilter.matchingScenariosAndExamples(feature).isEmpty()) {
            return true;
        }

        //
        // if (!featureContainsMatchingTags(feature)) {
        // return true;
        // }
    }
    return false;
}
 

import gherkin.ast.Feature; //导入依赖的package包/类
/**
 * Generates a Cucumber runner for each scenario, or example in a scenario outline.
 *
 * @param outputDirectory the output directory to place generated files
 * @param featureFiles    The feature files to create runners for
 * @throws MojoExecutionException if something goes wrong
 */
public void generateCucumberITFiles(final File outputDirectory,
                                    final Collection<File> featureFiles) throws MojoExecutionException {
    final Parser<Feature> parser = new Parser<Feature>(new AstBuilder());
    Feature feature = null;
    final TagFilter tagFilter = new TagFilter(overriddenParameters.getTags());

    for (final File file : featureFiles) {

        try {
            feature = parser.parse(new FileReader(file), new TokenMatcher());
        } catch (final FileNotFoundException e) {
            // should never happen
            // TODO - proper logging
            System.out.println(format("WARNING: Failed to parse '%s'...IGNORING",
                            file.getName()));
        }

        final Collection<ScenarioAndLocation> matchingScenariosAndExamples =
                        tagFilter.matchingScenariosAndExamples(feature);

        for (final ScenarioAndLocation match : matchingScenariosAndExamples) {
            outputFileName = classNamingScheme.generate(file.getName());
            setFeatureFileLocation(file, match.getLocation());
            setParsedFeature(feature);
            setParsedScenario(match.getScenario());
            writeFile(outputDirectory);
        }

    }
}
 

import gherkin.ast.Feature; //导入依赖的package包/类
@Test
public void shouldFindAllScenariosWhenTagsAreNull() {
    final TagFilter tagFilter = new TagFilter(null);
    final Feature feature = parseFeature("src/test/resources/features/filterByTag.feature");

    final Collection<ScenarioAndLocation> matchingScenariosAndExamples =
                    tagFilter.matchingScenariosAndExamples(feature);

    assertThat(matchingScenariosAndExamples).hasSize(3);
}
 

import gherkin.ast.Feature; //导入依赖的package包/类
@Test
public void shouldFindScenariosWithAndedTags() {

    final TagFilter tagFilter = new TagFilter(asList("@tag1", "@tag2"));
    final Feature feature = parseFeature("src/test/resources/features/filterByTag.feature");

    final Collection<ScenarioAndLocation> matchingScenariosAndExamples =
                    tagFilter.matchingScenariosAndExamples(feature);

    assertThat(matchingScenariosAndExamples).hasSize(1);
}
 

import gherkin.ast.Feature; //导入依赖的package包/类
@Test
public void shouldFindScenariosWhenFilteringByOrTags() throws Exception {

    final TagFilter tagFilter = new TagFilter(singletonList("@tag1,@tag2"));
    final Feature feature = parseFeature("src/test/resources/features/filterByTag.feature");

    final Collection<ScenarioAndLocation> matchingScenariosAndExamples =
                    tagFilter.matchingScenariosAndExamples(feature);

    assertThat(matchingScenariosAndExamples).hasSize(3);
}