/** * Attempt to resolve all segments for the supplied unique ID. */ private Deque<TestDescriptor> resolveAllSegments(UniqueId uniqueId) { List<Segment> segments = uniqueId.getSegments(); Deque<TestDescriptor> resolvedDescriptors = new LinkedList<>(); resolvedDescriptors.addFirst(this.engineDescriptor); for (int index = 1; index < segments.size() && resolvedDescriptors.size() == index; index++) { Segment segment = segments.get(index); TestDescriptor parent = resolvedDescriptors.getLast(); UniqueId partialUniqueId = parent.getUniqueId().append(segment); Optional<TestDescriptor> resolvedDescriptor = findTestDescriptorByUniqueId(partialUniqueId); if (!resolvedDescriptor.isPresent()) { // @formatter:off resolvedDescriptor = this.resolvers.stream() .map(resolver -> resolver.resolveUniqueId(segment, parent)) .filter(Optional::isPresent) .map(Optional::get) .findFirst(); // @formatter:on resolvedDescriptor.ifPresent(parent::addChild); } resolvedDescriptor.ifPresent(resolvedDescriptors::addLast); } return resolvedDescriptors; }
private boolean isForVintageEngine(UniqueId uniqueId) { // @formatter:off return uniqueId.getEngineId() .map(engineId -> engineId.equals(ENGINE_ID)) .orElse(false); // @formatter:on }
private UniqueId createUniqueId(Method method, TestDescriptor parent) { String methodId = String.format("%s(%s)", method.getName(), ClassUtils.nullSafeToString(method.getParameterTypes())); return parent.getUniqueId().append(this.segmentType, methodId); }
private Optional<String> determineTestClassName(UniqueId uniqueId) { Segment runnerSegment = uniqueId.getSegments().get(1); // skip engine node if (SEGMENT_TYPE_RUNNER.equals(runnerSegment.getType())) { return Optional.of(runnerSegment.getValue()); } logger.warn( () -> format("Unresolvable Unique ID (%s): Unique ID segment after engine segment must be of type \"" + SEGMENT_TYPE_RUNNER + "\"", uniqueId)); return Optional.empty(); }
@Example void plainProperty() { Method method = TestHelper.getMethod(TestContainer.class, "plainProperty"); UniqueId uniqueId = JqwikUniqueIDs.appendProperty(UniqueId.forEngine(JqwikTestEngine.ENGINE_ID), method); ContainerClassDescriptor classDescriptor = buildContainerDescriptor(TestContainer.class); Optional<TestDescriptor> descriptor = resolver.resolveUniqueId(uniqueId.getSegments().get(1), classDescriptor); PropertyMethodDescriptor propertyMethodDescriptor = (PropertyMethodDescriptor) descriptor.get(); assertThat(propertyMethodDescriptor.getLabel()).isEqualTo("plainProperty"); assertDefaultConfigurationProperties(propertyMethodDescriptor); }
@Override public TestDescriptor discover(EngineDiscoveryRequest discoveryRequest, UniqueId uniqueId) { this.discoveryRequestForDiscovery = discoveryRequest; this.uniqueIdForDiscovery = uniqueId; UniqueId engineUniqueId = UniqueId.forEngine(ID); TestDescriptorStub engineDescriptor = new TestDescriptorStub(engineUniqueId, ID); TestDescriptorStub testDescriptor = new TestDescriptorStub(engineUniqueId.append("test", "test"), "test"); engineDescriptor.addChild(testDescriptor); return engineDescriptor; }
public static UniqueId engineId() { return UniqueId.forEngine(JqwikTestEngine.ENGINE_ID); }
private void writeXmlReportInCaseOfRoot(TestIdentifier testIdentifier) { if (isRoot(testIdentifier)) { String rootName = UniqueId.parse(testIdentifier.getUniqueId()).getSegments().get(0).getValue(); writeXmlReportSafely(testIdentifier, rootName); } }
/** * Create an engine's unique ID from its {@code engineId} using the default * format. * * <p>The engine ID will be stored in a {@link Segment} with * {@link Segment#getType type} {@code "engine"}. * * @param engineId the engine ID; never {@code null} or blank * @see #root(String, String) */ public static UniqueId forEngine(String engineId) { Preconditions.notBlank(engineId, "engineId must not be null or blank"); return root(ENGINE_SEGMENT_TYPE, engineId); }
@Override public String getUniqueId() { return getTestDescriptor().getUniqueId().toString(); }
@Override public final boolean equals(Object other) { if (other == null) { return false; } if (this.getClass() != other.getClass()) { return false; } TestDescriptor that = (TestDescriptor) other; return this.getUniqueId().equals(that.getUniqueId()); }
/** * Create a {@code UniqueIdSelector} for the supplied unique ID. * * @param uniqueId the unique ID to select; never {@code null} or blank * @see UniqueIdSelector */ public static UniqueIdSelector selectUniqueId(String uniqueId) { Preconditions.notBlank(uniqueId, "Unique ID must not be null or blank"); return new UniqueIdSelector(UniqueId.parse(uniqueId)); }
private RunnerTestDescriptor createCompleteRunnerTestDescriptor(Class<?> testClass, Runner runner, UniqueId engineId) { UniqueId id = engineId.append(SEGMENT_TYPE_RUNNER, testClass.getName()); RunnerTestDescriptor runnerTestDescriptor = new RunnerTestDescriptor(id, testClass, runner); addChildrenRecursively(runnerTestDescriptor); return runnerTestDescriptor; }
private void handleResolvedDescriptorsForUniqueId(UniqueId uniqueId, Deque<TestDescriptor> resolvedDescriptors) { List<Segment> segments = uniqueId.getSegments(); int numSegmentsToResolve = segments.size() - 1; int numSegmentsResolved = resolvedDescriptors.size() - 1; if (numSegmentsResolved == 0) { logger.warn(() -> format("Unique ID '%s' could not be resolved.", uniqueId)); } else if (numSegmentsResolved != numSegmentsToResolve) { if (resolvedDescriptors.getLast() instanceof Filterable) { ((Filterable) resolvedDescriptors.getLast()).getDynamicDescendantFilter().allow(uniqueId); } else { logger.warn(() -> { List<Segment> unresolved = segments.subList(1, segments.size()); // Remove engine ID unresolved = unresolved.subList(numSegmentsResolved, unresolved.size()); // Remove resolved segments return format("Unique ID '%s' could only be partially resolved. " + "All resolved segments will be executed; however, the " + "following segments could not be resolved: %s", uniqueId, unresolved); }); } } else { resolveChildren(resolvedDescriptors.getLast()); } }
@Example void propertyWithParams() { Method method = TestHelper.getMethod(TestContainer.class, "propertyWithParams"); UniqueId uniqueId = JqwikUniqueIDs.appendProperty(UniqueId.forEngine(JqwikTestEngine.ENGINE_ID), method); ContainerClassDescriptor classDescriptor = buildContainerDescriptor(TestContainer.class); Optional<TestDescriptor> descriptor = resolver.resolveUniqueId(uniqueId.getSegments().get(1), classDescriptor); assertThat(descriptor).isPresent(); PropertyMethodDescriptor propertyMethodDescriptor = (PropertyMethodDescriptor) descriptor.get(); assertThat(propertyMethodDescriptor.getLabel()).isEqualTo("propertyWithParams"); }
private TestEngineIntegrationTests() { testEngine = new JqwikTestEngine(this::configuration); eventRecorder = Mockito.mock(EngineExecutionListener.class); engineId = UniqueId.forEngine(testEngine.getId()); }
MockExecutionTask(String name) { this(UniqueId.root("test", name), name); }
@Override public String getUniqueId() { return getBenchmarkDescriptor().getUniqueId().toString(); }
@Override public Optional<? extends TestDescriptor> findByUniqueId(UniqueId uniqueId) { Preconditions.notNull(uniqueId, "UniqueId must not be null"); if (getUniqueId().equals(uniqueId)) { return Optional.of(this); } // @formatter:off return this.children.stream() .map(child -> child.findByUniqueId(uniqueId)) .filter(Optional::isPresent) .findAny() .orElse(Optional.empty()); // @formatter:on }