Java PickleTable类代码示例

import gherkin.pickles.PickleTable; //导入依赖的package包/类
private void createDataTableAttachment(final PickleTable pickleTable) {
    final List<PickleRow> rows = pickleTable.getRows();

    final StringBuilder dataTableCsv = new StringBuilder();
    if (!rows.isEmpty()) {
        rows.forEach(dataTableRow -> {
            dataTableCsv.append(
                    dataTableRow.getCells().stream()
                            .map(PickleCell::getValue)
                            .collect(Collectors.joining("\t"))
            );
            dataTableCsv.append('\n');
        });

        final String attachmentSource = lifecycle
                .prepareAttachment("Data table", "text/tab-separated-values", "csv");
        lifecycle.writeAttachment(attachmentSource,
                new ByteArrayInputStream(dataTableCsv.toString().getBytes(Charset.forName("UTF-8"))));
    }
}
 

import gherkin.pickles.PickleTable; //导入依赖的package包/类
private List<Argument> createArgumentsForErrorMessage(PickleStep step) {
    List<Argument> arguments = new ArrayList<>(getArguments());
    if (!step.getArgument().isEmpty()) {
        gherkin.pickles.Argument stepArgument = step.getArgument().get(0);
        if (stepArgument instanceof PickleString) {
            arguments.add(new Argument(-1, "DocString:" + ((PickleString) stepArgument).getContent()));
        } else if (stepArgument instanceof PickleTable) {
            List<List<String>> rows = map(((PickleTable) stepArgument).getRows(), new Mapper<PickleRow, List<String>>() {
                @Override
                public List<String> map(PickleRow row) {
                    List<String> raw = new ArrayList<>(row.getCells().size());
                    for (PickleCell pickleCell : row.getCells()) {
                        raw.add(pickleCell.getValue());
                    }
                    return raw;
                }
            });
            arguments.add(new Argument(-1, "Table:" + rows.toString()));
        }
    }
    return arguments;
}
 

import gherkin.pickles.PickleTable; //导入依赖的package包/类
static <T> List<T> toList(PickleTable dataTable, Type itemType, JsonElement testData) {
    List<T> result = new ArrayList<T>();
    List<String> keys = convertTopCellsToFieldNames(raw(dataTable.getRows().get(0)));
    int count = dataTable.getRows().size();
    for (int i = 1; i < count; i++) {
        List<String> valueRow = raw(dataTable.getRows().get(i));
        T item = (T) SuperReflect.on((Class) itemType).create().get();
        int j = 0;
        for (String cell : valueRow) {
            SuperReflect.on(item).set(keys.get(j), cell);
            j++;
        }
        result.add(item);
    }
    return Collections.unmodifiableList(result);
}
 

import gherkin.pickles.PickleTable; //导入依赖的package包/类
static List<Map<String, String>> toMaps(PickleTable dataTable) {
    List<Map<String, String>> result = new ArrayList<Map<String, String>>();
    List<String> keys = raw(dataTable.getRows().get(0));
    int count = dataTable.getRows().size();
    for (int i = 1; i < count; i++) {
        List<String> valueRow = raw(dataTable.getRows().get(i));
        Map<String, String> map = new LinkedHashMap<String, String>();
        int j = 0;
        for (String cell : valueRow) {
            map.put(keys.get(j), cell);
            j++;
        }
        result.add(Collections.unmodifiableMap(map));
    }
    return Collections.unmodifiableList(result);
}
 

import gherkin.pickles.PickleTable; //导入依赖的package包/类
private Object tableArgument(PickleTable stepArgument, int argIndex, LocalizedXStreams.LocalizedXStream xStream) {
    ParameterInfo parameterInfo = getParameterType(argIndex, DataTable.class);
    TableConverter tableConverter = new TableConverter(xStream, parameterInfo);
    DataTable table = new DataTable(stepArgument, tableConverter);
    Type type = parameterInfo.getType();
    return tableConverter.convert(table, type, parameterInfo.isTransposed());
}
 

import gherkin.pickles.PickleTable; //导入依赖的package包/类
public static <T> T convert(PickleTable dataTable, Type type, JsonElement testData) {

        if (type == null || (type instanceof Class && ((Class) type).isAssignableFrom(PickleTable.class))) {
            return (T) dataTable;
        }

        Type itemType = listItemType(type);
        if (itemType == null) {
            throw new ParserException("Not a List type: " + type);
        }

        Type mapKeyType = mapKeyType(itemType);
        if (mapKeyType != null) {
            Type mapValueType = mapValueType(itemType);
            return (T) toMaps(dataTable);
        }

        Type listitemType = listItemType(itemType);
        if (listitemType != null && ((Class)listitemType).isAssignableFrom(String.class)) {
            return (T) raw(dataTable);
        } else {
            if (((Class)itemType).isAssignableFrom(String.class)) {
                return (T) toStringList(dataTable, testData);
            } else {
                return (T) toList(dataTable, itemType, testData);
            }
        }
    }
 

import gherkin.pickles.PickleTable; //导入依赖的package包/类
static List<String> toStringList(PickleTable dataTable, JsonElement testData) {
    List<String> result = new ArrayList<String>();
    int count = dataTable.getRows().size();
    if (count == 1) {
        for (PickleCell cell : dataTable.getRows().get(0).getCells()) {
            result.add(replaceWithTestData(testData, cell.getValue()));
        }
    } else {
        for (PickleRow row : dataTable.getRows()) {
            result.add(replaceWithTestData(testData, row.getCells().get(0).getValue()));
        }
    }
    return Collections.unmodifiableList(result);
}