import gherkin.ast.TableRow; //导入依赖的package包/类
private void processScenarioOutlineExamples(
        final Map<Integer, AstNode> nodeMap, final ScenarioOutline scenarioOutline, final AstNode childNode
) {
    scenarioOutline.getExamples().forEach(examples -> {
        final AstNode examplesNode = new AstNode(examples, childNode);
        final TableRow headerRow = examples.getTableHeader();
        final AstNode headerNode = new AstNode(headerRow, examplesNode);
        nodeMap.put(headerRow.getLocation().getLine(), headerNode);
        IntStream.range(0, examples.getTableBody().size()).forEach(i -> {
            final TableRow examplesRow = examples.getTableBody().get(i);
            final Node rowNode = new CucumberSourceUtils.ExamplesRowWrapperNode(examplesRow, i);
            final AstNode expandedScenarioNode = new AstNode(rowNode, examplesNode);
            nodeMap.put(examplesRow.getLocation().getLine(), expandedScenarioNode);
        });
    });
}
 

import gherkin.ast.TableRow; //导入依赖的package包/类
private void createTestData(TestCase testCase, List<Examples> examples) {
    for (Examples example : examples) {
        TestDataModel tdModel = createTestData(testCase.getName());
        List<String> columns = new ArrayList<>();
        for (TableCell tCell : example.getTableHeader().getCells()) {
            columns.add(tCell.getValue());
            tdModel.addColumn(tCell.getValue());
        }
        for (int i = 0; i < example.getTableBody().size(); i++) {
            TableRow tRow = example.getTableBody().get(i);
            tdModel.addRecord();
            Record record = tdModel.getRecords().get(i);
            record.setScenario(testCase.getScenario().getName());
            record.setTestcase(testCase.getName());
            record.setIteration("1");
            record.setSubIteration("" + (i + 1));
            for (int j = 0; j < tRow.getCells().size(); j++) {
                tdModel.setValueAt(tRow.getCells().get(j).getValue(),
                        i,
                        tdModel.getColumnIndex(columns.get(j)));
            }
        }
    }
}
 

import gherkin.ast.TableRow; //导入依赖的package包/类
/**
 * Converts a Gherkin example table to a map of columns (keys) and rows (values)
 *
 * @param exampleTable a Gherkin {@link Examples} instance.
 * @return a map where the keys are the column headers and the values are lists of strings.
 */
Map<String, List<String>> convertGherkinExampleTableToCucableExampleMap(Examples exampleTable) {
    Map<String, List<String>> exampleMap = new LinkedHashMap<>();

    List<TableCell> headerCells = exampleTable.getTableHeader().getCells();
    for (TableCell headerCell : headerCells) {
        exampleMap.put("<" + headerCell.getValue() + ">", new ArrayList<>());
    }
    Object[] columnKeys = exampleMap.keySet().toArray();

    List<TableRow> tableBody = exampleTable.getTableBody();
    for (TableRow tableRow : tableBody) {
        List<TableCell> cells = tableRow.getCells();
        for (int i = 0; i < cells.size(); i++) {
            String columnKey = (String) columnKeys[i];
            List<String> values = exampleMap.get(columnKey);
            values.add(cells.get(i).getValue());
        }
    }
    return exampleMap;
}
 

import gherkin.ast.TableRow; //导入依赖的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.TableRow; //导入依赖的package包/类
private Map<String, String> parametersMap(TableRow header, TableRow row)
{
    List<TableCell> headerCells = header.getCells();
    List<TableCell> rowCells = row.getCells();

    if (headerCells.size() == rowCells.size())
    {
        Map<String, String> parameters = new LinkedHashMap<>();

        for (int i = 0; i < headerCells.size(); i++)
        {
            TableCell headerCell = headerCells.get(i);
            TableCell rowCell = rowCells.get(i);

            parameters.put(headerCell.getValue(), rowCell.getValue());
        }

        return parameters;
    }
    else
    {
        throw new InvalidExampleException(header.getLocation().getLine(), header.getLocation().getColumn());
    }
}
 

import gherkin.ast.TableRow; //导入依赖的package包/类
private Collection<ScenarioAndLocation> matchingExamples(final ScenarioOutline scenario,
                                                         final Set<Tag> allTagsForScenario) {

    final Collection<ScenarioAndLocation> matchingRows =
                    new LinkedList<ScenarioAndLocation>();

    for (final Examples example : scenario.getExamples()) {
        final Collection<Tag> allTagsForExample = new HashSet<Tag>(allTagsForScenario);
        allTagsForExample.addAll(example.getTags());
        if (matches(allTagsForExample)) {
            for (TableRow row : example.getTableBody()) {
                matchingRows.add(new ScenarioAndLocation(scenario, row.getLocation()));
            }
        }
    }

    return matchingRows;
}
 

import gherkin.ast.TableRow; //导入依赖的package包/类
private List<Parameter> getExamplesAsParameters(final ScenarioOutline scenarioOutline) {
    final Examples examples = scenarioOutline.getExamples().get(0);
    final TableRow row = examples.getTableBody().stream()
            .filter(example -> example.getLocation().getLine() == currentTestCase.getLine())
            .findFirst().get();
    return IntStream.range(0, examples.getTableHeader().getCells().size()).mapToObj(index -> {
        final String name = examples.getTableHeader().getCells().get(index).getValue();
        final String value = row.getCells().get(index).getValue();
        return new Parameter().withName(name).withValue(value);
    }).collect(Collectors.toList());
}
 

import gherkin.ast.TableRow; //导入依赖的package包/类
private List<Argument> createPickleArguments(Node argument, List<TableCell> variableCells, List<TableCell> valueCells, String path) {
    List<Argument> result = new ArrayList<>();
    if (argument == null) return result;
    if (argument instanceof DataTable) {
        DataTable t = (DataTable) argument;
        List<TableRow> rows = t.getRows();
        List<PickleRow> newRows = new ArrayList<>(rows.size());
        for (TableRow row : rows) {
            List<TableCell> cells = row.getCells();
            List<PickleCell> newCells = new ArrayList<>();
            for (TableCell cell : cells) {
                newCells.add(
                        new PickleCell(
                                pickleLocation(cell.getLocation(), path),
                                interpolate(cell.getValue(), variableCells, valueCells)
                        )
                );
            }
            newRows.add(new PickleRow(newCells));
        }
        result.add(new PickleTable(newRows));
    } else if (argument instanceof DocString) {
        DocString ds = (DocString) argument;
        result.add(
                new PickleString(
                        pickleLocation(ds.getLocation(), path),
                        interpolate(ds.getContent(), variableCells, valueCells)
                )
        );
    } else {
        throw new RuntimeException("Unexpected argument type: " + argument);
    }
    return result;
}
 

import gherkin.ast.TableRow; //导入依赖的package包/类
private List<TableRow> getTableRows(AstNode node) {
    List<TableRow> rows = new ArrayList<>();
    for (Token token : node.getTokens(TokenType.TableRow)) {
        rows.add(new TableRow(getLocation(token, 0), getCells(token)));
    }
    ensureCellCount(rows);
    return rows;
}
 

import gherkin.ast.TableRow; //导入依赖的package包/类
private void ensureCellCount(List<TableRow> rows) {
    if (rows.isEmpty()) return;

    int cellCount = rows.get(0).getCells().size();
    for (TableRow row : rows) {
        if (row.getCells().size() != cellCount) {
            throw new ParserException.AstBuilderException("inconsistent cell count within the table", row.getLocation());
        }
    }
}
 

import gherkin.ast.TableRow; //导入依赖的package包/类
/**
 * Converts a Gherkin data table to a Cucable data table.
 *
 * @param gherkinDataTable a {@link DataTable}.
 * @return a {@link com.trivago.rta.vo.DataTable}.
 */
private com.trivago.rta.vo.DataTable convertGherkinDataTableToCucumberDataTable(final DataTable gherkinDataTable) {
    com.trivago.rta.vo.DataTable dataTable = new com.trivago.rta.vo.DataTable();
    for (TableRow row : gherkinDataTable.getRows()) {
        List<TableCell> cells = row.getCells();
        List<String> rowValues = new ArrayList<>();
        for (TableCell cell : cells) {
            rowValues.add(cell.getValue());
        }
        dataTable.addRow(rowValues);
    }
    return dataTable;
}
 

import gherkin.ast.TableRow; //导入依赖的package包/类
private List<Argument> createPickleArguments(Node argument, List<TableCell> variableCells, List<TableCell> valueCells) {
    List<Argument> result = new ArrayList<>();
    if (argument == null) return result;
    if (argument instanceof DataTable) {
        DataTable t = (DataTable) argument;
        List<TableRow> rows = t.getRows();
        List<PickleRow> newRows = new ArrayList<>(rows.size());
        for (TableRow row : rows) {
            List<TableCell> cells = row.getCells();
            List<PickleCell> newCells = new ArrayList<>();
            for (TableCell cell : cells) {
                newCells.add(
                        new PickleCell(
                                pickleLocation(cell.getLocation()),
                                interpolate(cell.getValue(), variableCells, valueCells)
                        )
                );
            }
            newRows.add(new PickleRow(newCells));
        }
        result.add(new PickleTable(newRows));
    } else if (argument instanceof DocString) {
        DocString ds = (DocString) argument;
        result.add(
                new PickleString(
                        pickleLocation(ds.getLocation()),
                        interpolate(ds.getContent(), variableCells, valueCells)
                )
        );
    } else {
        throw new RuntimeException("Unexpected argument type: " + argument);
    }
    return result;
}
 

import gherkin.ast.TableRow; //导入依赖的package包/类
private void compileScenarioOutline(List<Pickle> pickles, List<PickleStep> backgroundSteps, ScenarioOutline scenarioOutline, List<Tag> featureTags, String path) {
    if (scenarioOutline.getSteps().isEmpty())
      return;

    int exampleCount = 1;
    for (final Examples examples : scenarioOutline.getExamples()) {
        if (examples.getTableHeader() == null) continue;
        List<TableCell> variableCells = examples.getTableHeader().getCells();
        for (final TableRow values : examples.getTableBody()) {
            List<TableCell> valueCells = values.getCells();

            List<PickleStep> steps = new ArrayList<>();
            steps.addAll(backgroundSteps);

            List<Tag> tags = new ArrayList<>();
            tags.addAll(featureTags);
            tags.addAll(scenarioOutline.getTags());
            tags.addAll(examples.getTags());

            for (Step scenarioOutlineStep : scenarioOutline.getSteps()) {
                String stepText = interpolate(scenarioOutlineStep.getText(), variableCells, valueCells);

                // TODO: Use an Array of location in DataTable/DocString as well.
                // If the Gherkin AST classes supported
                // a list of locations, we could just reuse the same classes

                PickleStep pickleStep = new PickleStep(
                        stepText,
                        createPickleArguments(scenarioOutlineStep.getArgument(), variableCells, valueCells, path),
                        asList(
                                pickleLocation(values.getLocation(), path),
                                pickleStepLocation(scenarioOutlineStep, path)
                        ),
                        scenarioOutlineStep.getKeyword().trim()
                );
                steps.add(pickleStep);
            }

            Pickle pickle = new Pickle(
                    interpolate(scenarioOutline.getName(), variableCells, valueCells)+ " Example No." + exampleCount++,
                    steps,
                    pickleTags(tags, path),
                    asList(
                            pickleLocation(values.getLocation(), path),
                            pickleLocation(scenarioOutline.getLocation(), path)
                    )
            );

            pickles.add(pickle);
        }
    }
}
 

import gherkin.ast.TableRow; //导入依赖的package包/类
private void compileScenarioOutline(List<Pickle> pickles, List<PickleStep> backgroundSteps, ScenarioOutline scenarioOutline, List<Tag> featureTags) {
    if (scenarioOutline.getSteps().isEmpty())
        return;

    for (final Examples examples : scenarioOutline.getExamples()) {
        if (examples.getTableHeader() == null) continue;
        List<TableCell> variableCells = examples.getTableHeader().getCells();
        for (final TableRow values : examples.getTableBody()) {
            List<TableCell> valueCells = values.getCells();

            List<PickleStep> steps = new ArrayList<>();
            steps.addAll(backgroundSteps);

            List<Tag> tags = new ArrayList<>();
            tags.addAll(featureTags);
            tags.addAll(scenarioOutline.getTags());
            tags.addAll(examples.getTags());

            for (Step scenarioOutlineStep : scenarioOutline.getSteps()) {
                String stepText = interpolate(scenarioOutlineStep.getText(), variableCells, valueCells);

                // TODO: Use an Array of location in DataTable/DocString as well.
                // If the Gherkin AST classes supported
                // a list of locations, we could just reuse the same classes

                PickleStep pickleStep = new PickleStep(
                        stepText,
                        createPickleArguments(scenarioOutlineStep.getArgument(), variableCells, valueCells),
                        asList(
                                pickleLocation(values.getLocation()),
                                pickleStepLocation(scenarioOutlineStep)
                        )
                );
                steps.add(pickleStep);
            }

            Pickle pickle = new Pickle(
                    interpolate(scenarioOutline.getName(), variableCells, valueCells),
                    steps,
                    pickleTags(tags),
                    asList(
                            pickleLocation(values.getLocation()),
                            pickleLocation(scenarioOutline.getLocation())
                    )
            );

            pickles.add(pickle);
        }
    }
}
 

import gherkin.ast.TableRow; //导入依赖的package包/类
private void compileScenarioOutline(List<Pickle> pickles, List<PickleStep> backgroundSteps, ScenarioOutline scenarioOutline, List<Tag> featureTags, String language) {
    for (final Examples examples : scenarioOutline.getExamples()) {
        if (examples.getTableHeader() == null) continue;
        List<TableCell> variableCells = examples.getTableHeader().getCells();
        for (final TableRow values : examples.getTableBody()) {
            List<TableCell> valueCells = values.getCells();

            List<PickleStep> steps = new ArrayList<>();
            if (!scenarioOutline.getSteps().isEmpty())
                steps.addAll(backgroundSteps);

            List<Tag> tags = new ArrayList<>();
            tags.addAll(featureTags);
            tags.addAll(scenarioOutline.getTags());
            tags.addAll(examples.getTags());

            for (Step scenarioOutlineStep : scenarioOutline.getSteps()) {
                String stepText = interpolate(scenarioOutlineStep.getText(), variableCells, valueCells);

                // TODO: Use an Array of location in DataTable/DocString as well.
                // If the Gherkin AST classes supported
                // a list of locations, we could just reuse the same classes

                PickleStep pickleStep = new PickleStep(
                        stepText,
                        createPickleArguments(scenarioOutlineStep.getArgument(), variableCells, valueCells),
                        asList(
                                pickleLocation(values.getLocation()),
                                pickleStepLocation(scenarioOutlineStep)
                        )
                );
                steps.add(pickleStep);
            }

            Pickle pickle = new Pickle(
                    interpolate(scenarioOutline.getName(), variableCells, valueCells),
                    language,
                    steps,
                    pickleTags(tags),
                    asList(
                            pickleLocation(values.getLocation()),
                            pickleLocation(scenarioOutline.getLocation())
                    )
            );

            pickles.add(pickle);
        }
    }
}