@Test
  public void twoMethodResolutionsByUniqueId() {
    UniqueIdSelector selector1 =
        selectUniqueId(uniqueIdForMethod(MyTestClass.class, "test1()").toString());
    UniqueIdSelector selector2 =
        selectUniqueId(uniqueIdForMethod(MyTestClass.class, "test2()").toString());

    // adding same selector twice should have no effect
    resolver.resolveSelectors(
        request().selectors(selector1, selector2, selector2).build(), engineDescriptor);

    assertEquals(3, engineDescriptor.getAllDescendants().size());
    List<UniqueId> uniqueIds = uniqueIds();
    assertTrue(uniqueIds.contains(uniqueIdForClass(MyTestClass.class)));
    assertTrue(uniqueIds.contains(uniqueIdForMethod(MyTestClass.class, "test1()")));
    assertTrue(uniqueIds.contains(uniqueIdForMethod(MyTestClass.class, "test2()")));

    TestDescriptor classFromMethod1 =
        descriptorByUniqueId(uniqueIdForMethod(MyTestClass.class, "test1()")).getParent().get();
    TestDescriptor classFromMethod2 =
        descriptorByUniqueId(uniqueIdForMethod(MyTestClass.class, "test2()")).getParent().get();

    assertEquals(classFromMethod1, classFromMethod2);
    assertSame(classFromMethod1, classFromMethod2);
  }
  @Test
  public void classpathResolution() {
    File classpath =
        new File(
            DiscoverySelectorResolverTests.class
                .getProtectionDomain()
                .getCodeSource()
                .getLocation()
                .getPath());

    List<DiscoverySelector> selectors = selectClasspathRoots(singleton(classpath));

    resolver.resolveSelectors(request().selectors(selectors).build(), engineDescriptor);

    // 150 is completely arbitrary. At this very second in time, the number is actually 213.
    assertThat(engineDescriptor.getAllDescendants().size())
        .isGreaterThan(150)
        .as("Too few test descriptors in classpath");

    List<UniqueId> uniqueIds = uniqueIds();
    assertTrue(uniqueIds.contains(uniqueIdForClass(Class1WithTestCases.class)));
    assertTrue(uniqueIds.contains(uniqueIdForMethod(Class1WithTestCases.class, "test1()")));
    assertTrue(uniqueIds.contains(uniqueIdForClass(Class2WithTestCases.class)));
    assertTrue(uniqueIds.contains(uniqueIdForMethod(Class2WithTestCases.class, "test2()")));
    assertTrue(
        uniqueIds.contains(
            uniqueIdForMethod(ClassWithStaticInnerTestCases.ShouldBeDiscovered.class, "test1()")));
  }
  @Test
  public void resolvingUniqueIdOfNonTestMethodResolvesNothing() {
    UniqueIdSelector selector = selectUniqueId(uniqueIdForMethod(MyTestClass.class, "notATest()"));
    EngineDiscoveryRequest request = request().selectors(selector).build();

    resolver.resolveSelectors(request, engineDescriptor);
    assertTrue(engineDescriptor.getAllDescendants().isEmpty());
  }
  @Test
  public void resolvingUniqueIdWithUnknownSegmentTypeResolvesNothing() {
    UniqueIdSelector selector = selectUniqueId(engineId().append("bogus", "enigma").toString());
    EngineDiscoveryRequest request = request().selectors(selector).build();

    resolver.resolveSelectors(request, engineDescriptor);
    assertTrue(engineDescriptor.getAllDescendants().isEmpty());
  }
 @Test
 public void resolvingSelectorOfNonTestMethodResolvesNothing() throws NoSuchMethodException {
   Method notATest = MyTestClass.class.getDeclaredMethod("notATest");
   MethodSelector selector = selectMethod(notATest.getDeclaringClass(), notATest);
   EngineDiscoveryRequest request = request().selectors(selector).build();
   resolver.resolveSelectors(request, engineDescriptor);
   assertTrue(engineDescriptor.getAllDescendants().isEmpty());
 }
 private void assertMethodDoesNotMatchPattern(UniqueIdSelector selector) {
   Exception exception =
       expectThrows(
           PreconditionViolationException.class,
           () ->
               resolver.resolveSelectors(request().selectors(selector).build(), engineDescriptor));
   assertThat(exception).hasMessageStartingWith("Method");
   assertThat(exception).hasMessageContaining("does not match pattern");
 }
  @Test
  public void resolvingUniqueIdWithWrongParamsResolvesNothing() {
    UniqueIdSelector selector =
        selectUniqueId(
            uniqueIdForMethod(HerTestClass.class, "test7(java.math.BigDecimal)").toString());
    EngineDiscoveryRequest request = request().selectors(selector).build();

    resolver.resolveSelectors(request, engineDescriptor);
    assertTrue(engineDescriptor.getAllDescendants().isEmpty());
  }
  @Test
  public void methodResolutionFromInheritedMethod() throws NoSuchMethodException {
    MethodSelector selector =
        selectMethod(HerTestClass.class, MyTestClass.class.getDeclaredMethod("test1"));

    resolver.resolveSelectors(request().selectors(selector).build(), engineDescriptor);

    assertEquals(2, engineDescriptor.getAllDescendants().size());
    List<UniqueId> uniqueIds = uniqueIds();
    assertTrue(uniqueIds.contains(uniqueIdForClass(HerTestClass.class)));
    assertTrue(uniqueIds.contains(uniqueIdForMethod(HerTestClass.class, "test1()")));
  }
  @Test
  public void methodResolutionByUniqueId() {
    UniqueIdSelector selector =
        selectUniqueId(uniqueIdForMethod(MyTestClass.class, "test1()").toString());

    resolver.resolveSelectors(request().selectors(selector).build(), engineDescriptor);

    assertEquals(2, engineDescriptor.getAllDescendants().size());
    List<UniqueId> uniqueIds = uniqueIds();
    assertTrue(uniqueIds.contains(uniqueIdForClass(MyTestClass.class)));
    assertTrue(uniqueIds.contains(uniqueIdForMethod(MyTestClass.class, "test1()")));
  }
 @Test
 public void methodResolutionByUniqueIdWithBogusParameters() {
   UniqueIdSelector selector =
       selectUniqueId(
           uniqueIdForMethod(getClass(), "methodName(java.lang.String, junit.foo.Enigma)"));
   Exception exception =
       expectThrows(
           JUnitException.class,
           () ->
               resolver.resolveSelectors(request().selectors(selector).build(), engineDescriptor));
   assertThat(exception).hasMessageStartingWith("Failed to load parameter type");
   assertThat(exception).hasMessageContaining("junit.foo.Enigma");
 }
  @Test
  public void resolvingTestFactoryMethodByUniqueId() {
    UniqueIdSelector selector =
        selectUniqueId(uniqueIdForTestFactoryMethod(MyTestClass.class, "dynamicTest()"));

    resolver.resolveSelectors(request().selectors(selector).build(), engineDescriptor);

    assertThat(engineDescriptor.getAllDescendants()).hasSize(2);

    assertThat(uniqueIds())
        .containsSequence(
            uniqueIdForClass(MyTestClass.class),
            uniqueIdForTestFactoryMethod(MyTestClass.class, "dynamicTest()"));
  }
  @Test
  public void classResolutionOfStaticNestedClass() {
    ClassSelector selector = selectClass(OtherTestClass.NestedTestClass.class);

    resolver.resolveSelectors(request().selectors(selector).build(), engineDescriptor);

    assertEquals(3, engineDescriptor.getAllDescendants().size());
    List<UniqueId> uniqueIds = uniqueIds();
    assertTrue(uniqueIds.contains(uniqueIdForClass(OtherTestClass.NestedTestClass.class)));
    assertTrue(
        uniqueIds.contains(uniqueIdForMethod(OtherTestClass.NestedTestClass.class, "test5()")));
    assertTrue(
        uniqueIds.contains(uniqueIdForMethod(OtherTestClass.NestedTestClass.class, "test6()")));
  }
  @Test
  public void singleClassResolution() {
    ClassSelector selector = selectClass(MyTestClass.class);

    resolver.resolveSelectors(request().selectors(selector).build(), engineDescriptor);

    assertEquals(4, engineDescriptor.getAllDescendants().size());
    List<UniqueId> uniqueIds = uniqueIds();
    assertTrue(uniqueIds.contains(uniqueIdForClass(MyTestClass.class)));
    assertTrue(uniqueIds.contains(uniqueIdForMethod(MyTestClass.class, "test1()")));
    assertTrue(uniqueIds.contains(uniqueIdForMethod(MyTestClass.class, "test2()")));
    assertTrue(
        uniqueIds.contains(uniqueIdForTestFactoryMethod(MyTestClass.class, "dynamicTest()")));
  }
  @Test
  public void nestedTestResolutionFromUniqueIdToMethod() {
    UniqueIdSelector selector =
        selectUniqueId(
            uniqueIdForMethod(TestCaseWithNesting.NestedTestCase.class, "testB()").toString());

    resolver.resolveSelectors(request().selectors(selector).build(), engineDescriptor);

    List<UniqueId> uniqueIds = uniqueIds();
    assertEquals(3, uniqueIds.size());
    assertTrue(uniqueIds.contains(uniqueIdForClass(TestCaseWithNesting.class)));
    assertTrue(uniqueIds.contains(uniqueIdForClass(TestCaseWithNesting.NestedTestCase.class)));
    assertTrue(
        uniqueIds.contains(uniqueIdForMethod(TestCaseWithNesting.NestedTestCase.class, "testB()")));
  }
  @Test
  public void resolvingDynamicTestByUniqueIdResolvesOnlyUpToParentTestFactory() {
    UniqueIdSelector selector =
        selectUniqueId(
            uniqueIdForTestFactoryMethod(MyTestClass.class, "dynamicTest()")
                .append(TestFactoryTestDescriptor.DYNAMIC_TEST_SEGMENT_TYPE, "%1"));

    resolver.resolveSelectors(request().selectors(selector).build(), engineDescriptor);

    assertThat(engineDescriptor.getAllDescendants()).hasSize(2);

    assertThat(uniqueIds())
        .containsSequence(
            uniqueIdForClass(MyTestClass.class),
            uniqueIdForTestFactoryMethod(MyTestClass.class, "dynamicTest()"));
  }
  @Test
  public void packageResolution() {
    PackageSelector selector = selectPackage("org.junit.jupiter.engine.descriptor.subpackage");

    resolver.resolveSelectors(request().selectors(selector).build(), engineDescriptor);

    assertEquals(6, engineDescriptor.getAllDescendants().size());
    List<UniqueId> uniqueIds = uniqueIds();
    assertTrue(uniqueIds.contains(uniqueIdForClass(Class1WithTestCases.class)));
    assertTrue(uniqueIds.contains(uniqueIdForMethod(Class1WithTestCases.class, "test1()")));
    assertTrue(uniqueIds.contains(uniqueIdForClass(Class2WithTestCases.class)));
    assertTrue(uniqueIds.contains(uniqueIdForMethod(Class2WithTestCases.class, "test2()")));
    assertTrue(
        uniqueIds.contains(
            uniqueIdForMethod(ClassWithStaticInnerTestCases.ShouldBeDiscovered.class, "test1()")));
  }
  @Test
  public void duplicateClassSelectorOnlyResolvesOnce() {
    resolver.resolveSelectors(
        request()
            .selectors( //
                selectClass(MyTestClass.class), //
                selectClass(MyTestClass.class) //
                )
            .build(),
        engineDescriptor);

    assertEquals(4, engineDescriptor.getAllDescendants().size());
    List<UniqueId> uniqueIds = uniqueIds();
    assertTrue(uniqueIds.contains(uniqueIdForClass(MyTestClass.class)));
    assertTrue(uniqueIds.contains(uniqueIdForMethod(MyTestClass.class, "test1()")));
    assertTrue(uniqueIds.contains(uniqueIdForMethod(MyTestClass.class, "test2()")));
    assertTrue(
        uniqueIds.contains(uniqueIdForTestFactoryMethod(MyTestClass.class, "dynamicTest()")));
  }
  @Test
  public void doubleNestedTestResolutionFromClass() {
    ClassSelector selector =
        selectClass(TestCaseWithNesting.NestedTestCase.DoubleNestedTestCase.class);

    resolver.resolveSelectors(request().selectors(selector).build(), engineDescriptor);

    List<UniqueId> uniqueIds = uniqueIds();
    assertEquals(4, uniqueIds.size());

    assertTrue(uniqueIds.contains(uniqueIdForClass(TestCaseWithNesting.class)));
    assertTrue(uniqueIds.contains(uniqueIdForClass(TestCaseWithNesting.NestedTestCase.class)));
    assertTrue(
        uniqueIds.contains(
            uniqueIdForClass(TestCaseWithNesting.NestedTestCase.DoubleNestedTestCase.class)));
    assertTrue(
        uniqueIds.contains(
            uniqueIdForMethod(
                TestCaseWithNesting.NestedTestCase.DoubleNestedTestCase.class, "testC()")));
  }
  @Test
  public void methodResolutionInDoubleNestedTestClass() throws NoSuchMethodException {
    MethodSelector selector =
        selectMethod(
            TestCaseWithNesting.NestedTestCase.DoubleNestedTestCase.class,
            TestCaseWithNesting.NestedTestCase.DoubleNestedTestCase.class.getDeclaredMethod(
                "testC"));

    resolver.resolveSelectors(request().selectors(selector).build(), engineDescriptor);

    assertEquals(4, engineDescriptor.getAllDescendants().size());
    List<UniqueId> uniqueIds = uniqueIds();
    assertTrue(uniqueIds.contains(uniqueIdForClass(TestCaseWithNesting.class)));
    assertTrue(uniqueIds.contains(uniqueIdForClass(TestCaseWithNesting.NestedTestCase.class)));
    assertTrue(
        uniqueIds.contains(
            uniqueIdForClass(TestCaseWithNesting.NestedTestCase.DoubleNestedTestCase.class)));
    assertTrue(
        uniqueIds.contains(
            uniqueIdForMethod(
                TestCaseWithNesting.NestedTestCase.DoubleNestedTestCase.class, "testC()")));
  }