@Override public List<String> getRequirementTypes() { Set<String> requirementTypes = Sets.newHashSet(); for(Requirement requirement : getAllRequirements()) { requirementTypes.add(requirement.getType()); } return ImmutableList.copyOf(requirementTypes); }
@Override public List<String> getRequirementTypes() { Set<String> requirementTypes = Sets.newHashSet(); for(Requirement requirement : getAllRequirements()) { requirementTypes.add(requirement.getType()); } return ImmutableList.copyOf(requirementTypes); }
private Optional<Requirement> findMatchingRequirementWithName(Collection<Requirement> knownRequirements, String featureName, String featureType) { for(Requirement requirement : knownRequirements) { if (requirement.getName().equalsIgnoreCase(featureName) && requirement.getType().equalsIgnoreCase(featureType)) { return Optional.of(requirement); } } return Optional.empty(); }
public String getType() { if (requirementOutcomes.isEmpty()) { return "requirement"; } else { return requirementOutcomes.get(0).getRequirement().getType(); } }
public List<String> getTopLevelRequirementTypes() { List<String> requirementTypes = new ArrayList<>(); for(Requirement requirement : getRequirements()) { requirementTypes.add(requirement.getType()); } return requirementTypes; }
public String getType() { if (requirementOutcomes.isEmpty()) { return "requirement"; } else { return requirementOutcomes.get(0).getRequirement().getType(); } }
private Collection<String> requirementTypesDefinedIn(List<Requirement> requirements) { List<String> requirementTypes = new ArrayList<>(); for(Requirement requirement : requirements) { if (!requirementTypes.contains(requirement.getType())) { requirementTypes.add(requirement.getType()); } if (!requirement.getChildren().isEmpty()) { requirementTypes.addAll(requirementTypesDefinedIn(requirement.getChildren())); } } return requirementTypes; }
public String toString() { ByteArrayOutputStream printedRequirement = new ByteArrayOutputStream(); PrintStream printStream = new PrintStream(printedRequirement); printStream.println(indent + "- " + requirement.getType() + ": " + requirement.getDisplayName()); for(Requirement child : requirement.getChildren()) { printStream.print(stringFormOf(child).withIndentationLevel(level + 1)); } return printedRequirement.toString(); } }
public Optional<Requirement> getRequirementFor(TestTag testTag) { for (Requirement requirement : getFlattenedRequirements()) { if (requirement.getName().equalsIgnoreCase(testTag.getName()) && requirement.getType().equalsIgnoreCase(testTag.getType())) { return Optional.of(requirement); } } return Optional.absent(); }
public Optional<Requirement> getRequirementFor(TestTag testTag) { for (Requirement requirement : getFlattenedRequirements()) { if (requirement.getName().equalsIgnoreCase(testTag.getName()) && requirement.getType().equalsIgnoreCase(testTag.getType())) { return Optional.of(requirement); } } return Optional.absent(); }
public java.util.Optional<Requirement> getRequirementFor(TestTag testTag) { for (Requirement requirement : AllRequirements.in(getRequirements())) { if (requirement.getName().equalsIgnoreCase(testTag.getName()) && requirement.getType().equalsIgnoreCase(testTag.getType())) { return Optional.of(requirement); } } return Optional.empty(); }
private String typeOfFirstChildPresent() { for (RequirementOutcome outcome : requirementOutcomes) { if (!outcome.getRequirement().getChildren().isEmpty()) { Requirement firstChildRequirement = outcome.getRequirement().getChildren().get(0); return firstChildRequirement.getType(); } } return null; }
private String typeOfFirstChildPresent() { for (RequirementOutcome outcome : requirementOutcomes) { if (!outcome.getRequirement().getChildren().isEmpty()) { Requirement firstChildRequirement = outcome.getRequirement().getChildren().get(0); return firstChildRequirement.getType(); } } return null; }
public RequirementsOutcomes requirementsOfType(String type) { List<Requirement> matchingRequirements = Lists.newArrayList(); List<TestOutcome> matchingTests = Lists.newArrayList(); for(RequirementOutcome requirementOutcome : getFlattenedRequirementOutcomes()) { if (requirementOutcome.getRequirement().getType().equalsIgnoreCase(type)) { matchingRequirements.add(requirementOutcome.getRequirement()); matchingTests.addAll(requirementOutcome.getTestOutcomes().getOutcomes()); } } return new RequirementsOutcomes(matchingRequirements, TestOutcomes.of(matchingTests), issueTracking, environmentVariables, requirementsTagProviders); }
@Override public Set<TestTag> getTagsFor(TestOutcome testOutcome) { Set<TestTag> result = new HashSet<TestTag>(); for (Requirement requirement : getAllRequirements()) { if (isMatchingRequirementFor(testOutcome, requirement)) { result.add(TestTag.withName(humanReadableVersionOf(requirement.getName())).andType(requirement.getType())); } } return result; }
private Node toNode(Requirement requirement,RequirementsOutcomes requirementsOutcomes) { List<Node> children = requirement.getChildren().stream() .map(child -> toNode(child, requirementsOutcomes)) .distinct() .collect(Collectors.toList()); TestResult result = matchingOutcome(requirement, requirementsOutcomes); String label = new ResultIconFormatter().forResult(result); String childCount = (children.isEmpty()) ? countScenariosIn(requirement, requirementsOutcomes) : countChildRequirementsIn(requirement); String report = new ReportNameProvider().forRequirement(requirement); return new Node(requirement.getName(), requirement.getType(), report, label, childCount, children); }
private String countChildRequirementsIn(Requirement requirement) { Inflector inflection = new Inflector(); return "<span class='feature-count'>" + requirement.getChildren().size() + " " + inflection.of(requirement.getChildren().size()).times(requirement.getChildren().get(0).getType()).inPluralForm().toString() + "</span>"; }
private boolean testsExistFor(Requirement requirement) { TestTag requirementTag = TestTag.withName(requirement.getName()).andType(requirement.getType()); return !getTestOutcomes().withTag(requirementTag).getOutcomes().isEmpty(); //return !getTestOutcomes().withTag(requirement.asTag()).getOutcomes().isEmpty(); }
private boolean testsExistFor(Requirement requirement) { TestTag requirementTag = TestTag.withName(requirement.getName()).andType(requirement.getType()); return !getTestOutcomes().withTag(requirementTag).getOutcomes().isEmpty(); //return !getTestOutcomes().withTag(requirement.asTag()).getOutcomes().isEmpty(); }