Intellij上Java单元测试运行成功，但在maven上失败

我面临一个问题，单元测试用例通过了IntelliJ，但在mvn test命令上失败了.我认为问题出在Java 17上，但我不确定.SRC代码可以找到here

Maven版本(带有JDK 17):

Apache Maven 3.6.3 (cecedd343002696d0abb50b32b541b8a6ba2883f)
Maven home: D:\Apps\maven-3.6.3\bin\..
Java version: 17.0.1, vendor: Oracle Corporation, runtime: D:\Program Files\jdk17\app
Default locale: en_US, platform encoding: Cp1258
OS name: "windows 10", version: "10.0", arch: "amd64", family: "windows"

-pom.xml:

<properties>
    <maven.compiler.release>17</maven.compiler.release>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<dependencies>
    <!-- https://mvnrepository.com/artifact/com.google.inject/guice -->
    <dependency>
        <groupId>com.google.inject</groupId>
        <artifactId>guice</artifactId>
        <version>5.1.0</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/javax.inject/javax.inject -->
    <dependency>
        <groupId>javax.inject</groupId>
        <artifactId>javax.inject</artifactId>
        <version>1</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>2.13.3</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.13.3</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.jsoup/jsoup -->
    <dependency>
        <groupId>org.jsoup</groupId>
        <artifactId>jsoup</artifactId>
        <version>1.14.3</version>
    </dependency>

    <!-- Test Dependencies -->
    <!-- https://mvnrepository.com/artifact/com.google.truth/truth -->
    <dependency>
        <groupId>com.google.truth</groupId>
        <artifactId>truth</artifactId>
        <version>1.1.3</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>5.8.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                    <configuration>
                        <archive>
                            <manifest>
                                <mainClass>
                                    com.udacity.webcrawler.main.WebCrawlerMain
                                </mainClass>
                            </manifest>
                        </archive>
                        <descriptorRefs>
                            <descriptorRef>jar-with-dependencies</descriptorRef>
                        </descriptorRefs>
                        <appendAssemblyId>false</appendAssemblyId>
                    </configuration>
                </execution>
            </executions>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <configuration>
                <trimStackTrace>false</trimStackTrace>
                <systemProperties>
                    <property>
                        <name>testDataDir</name>
                        <value>${project.basedir}/src/test/data</value>
                    </property>
                    <property>
                        <name>crawlerImplementations</name>
                        <value>
                            com.udacity.webcrawler.SequentialWebCrawler
                            com.udacity.webcrawler.ParallelWebCrawler
                        </value>
                    </property>
                </systemProperties>
            </configuration>
            <version>3.1.0</version>
            <dependencies>
                <dependency>
                    <groupId>org.junit.jupiter</groupId>
                    <artifactId>junit-jupiter-engine</artifactId>
                    <version>5.8.2</version>
                </dependency>
            </dependencies>
        </plugin>
    </plugins>
</build>

以下是代码:

public final class ProfilerImplTest {
    private final FakeClock clock = new FakeClock();
    private final Profiler profiler = new ProfilerImpl(clock, true);
    private final ProfiledInterfaceImpl delegate = new ProfiledInterfaceImpl(clock);

    @Test
    public void delegateHasNoMethodsAnnotated() {
        assertThrows(
                IllegalArgumentException.class,
                () -> profiler.wrap(NonProfiledInterface.class, new NonProfiledInterfaceImpl()),
                "Profiler.wrap() should throw an IllegalArgumentException if the wrapped interface does " +
                        "not contain a @Profiled method.");
    }

    @Test
    public void testToString() {
        ProfiledInterface proxy = profiler.wrap(ProfiledInterface.class, delegate);

        assertWithMessage("The proxy should delegate toString() calls to the wrapped object.")
                .that(proxy.toString())
                .isEqualTo(delegate.toString());
    }

    @Test
    public void testHashCode() {
        ProfiledInterface proxy = profiler.wrap(ProfiledInterface.class, delegate);

        assertWithMessage("The proxy should delegate hashCode() calls to the wrapped object.")
                .that(proxy.hashCode())
                .isEqualTo(delegate.hashCode());
    }

    @Test
    public void testEquals() {
        ProfiledInterface proxy1 = profiler.wrap(ProfiledInterface.class, delegate);
        ProfiledInterface proxy2 = profiler.wrap(ProfiledInterface.class, delegate);

        assertThat(proxy1).isNotSameInstanceAs(delegate);
        assertThat(proxy1).isEqualTo(delegate);
        assertThat(delegate).isEqualTo(proxy1);

        assertWithMessage("Each call to Profiler.wrap() should create a new proxy object.")
                .that(proxy1)
                .isNotSameInstanceAs(proxy2);
        assertWithMessage("Two proxies should be equal if their wrapped objects are equal")
                .that(proxy1)
                .isEqualTo(proxy2);
        assertWithMessage("Two proxies should be equal if their wrapped objects are equal")
                .that(proxy2)
                .isEqualTo(proxy1);
    }

    @Test
    public void testNonObjectEquals() {
        ProfiledInterface proxy = profiler.wrap(ProfiledInterface.class, delegate);

        assertWithMessage("Incorrect equals() method was called")
                .that(proxy.equals("foo", "bar"))
                .isFalse();

        assertThat(delegate.wasFakeEqualsCalled()).isTrue();
    }

    @Test
    public void testBasicProfiling() throws Exception {
        ProfiledInterface proxy = profiler.wrap(ProfiledInterface.class, delegate);

        Instant beforeInvocation = clock.instant();

        assertWithMessage("The intercepted method did not forward the return value correctly")
                .that(proxy.profiled())
                .isEqualTo("profiled");
        Instant afterInvocation = clock.instant();
        assertWithMessage("Expected time to advance from invocation.")
                .that(beforeInvocation)
                .isLessThan(afterInvocation);

        // Run the method again a few more times to aggregate some data.
        proxy.profiled();
        proxy.profiled();

        CloseableStringWriter writer = new CloseableStringWriter();
        profiler.writeData(writer);
        assertWithMessage("Streams should usually be closed in the same scope where they were created")
                .that(writer.isClosed())
                .isFalse();
        String written = writer.toString();
        assertWithMessage("The profile data was not written or is incorrect")
                .that(written)
                .contains(
                        "com.udacity.webcrawler.profiler.ProfilerImplTest$ProfiledInterfaceImpl#profiled");
        assertThat(written).contains("0m 3s 0ms");
    }

    @Test
    public void testDeclaredExceptionHandling() throws Exception {
        ProfiledInterface proxy = profiler.wrap(ProfiledInterface.class, delegate);

        Instant beforeInvocation = clock.instant();
        Throwable expected = assertThrows(
                Throwable.class,
                () -> proxy.throwSomething(new Throwable("expected exception")),
                "The method interceptor should forward exceptions thrown by the wrapped object");
        assertWithMessage("The proxy threw a different exception than was thrown by the wrapped object")
                .that(expected)
                .hasMessageThat()
                .isEqualTo("expected exception");

        Instant afterInvocation = clock.instant();
        assertWithMessage("Expected time to advance from invocation.")
                .that(beforeInvocation)
                .isLessThan(afterInvocation);

        CloseableStringWriter writer = new CloseableStringWriter();
        profiler.writeData(writer);
        assertWithMessage("Streams should usually be closed in the same scope where they were created")
                .that(writer.isClosed())
                .isFalse();
        String written = writer.toString();
        assertWithMessage("Profile data should still be recorded if an exception was thrown.")
                .that(written)
                .contains("com.udacity.webcrawler.profiler.ProfilerImplTest$ProfiledInterfaceImpl");
        assertThat(written).contains("0m 1s 0ms");
    }

    @Test
    public void testServiceLoader() throws Exception {
        Field metadataField = ProfilerImpl.class.getDeclaredField("serviceMetadata");
        metadataField.setAccessible(true);
        Profiler trueProfiler = new ProfilerImpl(clock, true);
        Profiler falseProfiler = new ProfilerImpl(clock, false);

        assertEquals(2, ((Map<Class<?>, ServiceMetadata<?>>) metadataField.get(falseProfiler)).size());
        assertEquals(3, ((Map<Class<?>, ServiceMetadata<?>>) metadataField.get(trueProfiler)).size());
    }

    /**
     * A test interface that does not have any {@link Profiled} methods.
     */
    private interface NonProfiledInterface {
    }

    /**
     * Concrete implementation of {@link NonProfiledInterface}.
     */
    private static final class NonProfiledInterfaceImpl implements NonProfiledInterface {
    }

    /**
     * A test interface that has a method annotated with {@link Profiled}.
     */
    private interface ProfiledInterface {
        @Profiled
        String profiled();

        @Profiled
        void throwSomething(Throwable throwable) throws Throwable;

        boolean equals(String foo, String bar);
    }

    /**
     * Concrete implementation of {@link ProfiledInterface}.
     */
    @Wrapped
    private static final class ProfiledInterfaceImpl implements ProfiledInterface {
        private final FakeClock fakeClock;
        private boolean wasFakeEqualsCalled = false;

        ProfiledInterfaceImpl(FakeClock fakeClock) {
            this.fakeClock = Objects.requireNonNull(fakeClock);
        }

        @Override
        public String profiled() {
            fakeClock.tick(Duration.ofSeconds(1));
            return "profiled";
        }

        @Override
        public void throwSomething(Throwable throwable) throws Throwable {
            fakeClock.tick(Duration.ofSeconds(1));
            throw throwable;
        }

        @Override
        public boolean equals(Object other) {
            // All instances of ProfiledInterface are equal to one another.
            return (other instanceof ProfiledInterface);
        }

        @Override
        public boolean equals(String foo, String bar) {
            Objects.requireNonNull(foo);
            Objects.requireNonNull(bar);
            wasFakeEqualsCalled = true;
            return false;
        }

        public boolean wasFakeEqualsCalled() {
            return wasFakeEqualsCalled;
        }
    }
}

在第private final Profiler profiler = new ProfilerImpl(clock, true);行抛出异常，我不知道为什么.请判断以下代码:

/**
 * Concrete implementation of the {@link Profiler}.
 */
final class ProfilerImpl implements Profiler {
    private final Map<Class<?>, ServiceMetadata<?>> serviceMetadata;
    private final Clock clock;
    private final ProfilingState state = new ProfilingState();
    private final ZonedDateTime startTime;

    @Inject
    ProfilerImpl(Clock clock, boolean includeTest) {
        this.clock = Objects.requireNonNull(clock);
        this.startTime = ZonedDateTime.now(clock);
        ServiceLocator<Class<?>> serviceLocator = ServiceLocator.webCrawlerLocator(includeTest);
        serviceMetadata = serviceLocator.parse(serviceLocator.locateService());
    }

    private ServiceMetadata<?> profiledClass(Class<?> klass) {
        for (Class<?> clazz : serviceMetadata.keySet()) {
            if (klass.isAssignableFrom(clazz)) {
                return serviceMetadata.get(clazz);
            }
        }
        return null;
    }

    @Override
    public <T> T wrap(Class<T> klass, T delegate) {
        Objects.requireNonNull(klass);

        ServiceMetadata<?> profiledClass = profiledClass(klass);
        if (profiledClass == null) {
            throw new IllegalArgumentException(klass.getName() + "doesn't have profiled methods.");
        }

        ProfilingMethodInterceptor interceptor = new ProfilingMethodInterceptor(clock, delegate, state, startTime, profiledClass);

        Object proxy = Proxy.newProxyInstance(
                ProfilerImpl.class.getClassLoader(),
                new Class[]{klass},
                interceptor
        );

        return (T) proxy;
    }

    @Override
    public void writeData(Path path) {
        Objects.requireNonNull(path);

        try (Writer writer = Files.newBufferedWriter(path, StandardOpenOption.CREATE, StandardOpenOption.APPEND)) {
            writeData(writer);
            writer.flush();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    @Override
    public void writeData(Writer writer) throws IOException {
        writer.write("Run at " + RFC_1123_DATE_TIME.format(startTime));
        writer.write(System.lineSeparator());
        state.write(writer);
        writer.write(System.lineSeparator());
    }
}

堆栈跟踪:

Caused by: java.lang.ClassNotFoundException: target.classes.com.udacity.webcrawler.IgnoredUrls
        at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:641)
        at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:188)
        at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:520)
        at com.google.common.reflect.ClassPath$ClassInfo.load(ClassPath.java:360)
        ... 88 more

请帮帮忙