this.logFile = logFile
        this.charset = charset
    }

    File getFile() {
        return logFile
    }

    String getText() throws IOException {
        return logFile.getText(charset.name())
    }

    Stream<String> lines() throws IOException {
        return Files.lines(logFile.toPath(), charset)
    }

    @Override
    String toString() {

    }

    protected ArtifactRepository getLocalRepository() throws Exception {
        File repoDir = new File(getBasedir(), "target/local-repo").getAbsoluteFile();

        return repositorySystem.createLocalRepository(repoDir);
    }

    @Test
    void testThatASystemScopedDependencyIsNotResolvedFromRepositories() throws Exception {
        //

                @org.junit.Test public void foo() throws Exception {
                     org.junit.Assert.assertEquals(1, 1);
                }
            }
        """
        file('src/test/java/example/SecondTest.java').text = """
            package example;
            public class SecondTest {
                @org.junit.Test public void bar() throws Exception {
                     org.junit.Assert.assertEquals(1, 1);

                } catch (FileNotFoundException | URISyntaxException e) {
                    throw new IllegalStateException("Missing test POM for " + artifact, e);
                }
            } else {
                result.addException(new ArtifactNotFoundException(artifact, (RemoteRepository) null));
                throw new ArtifactResolutionException(results);
            }
        }

        return results;
    }

        return displayName.getCapitalizedDisplayName();
    }

    @Override
    public T get() throws IllegalStateException {
        return getValue().get();
    }

    @Override
    public Try<T> getValue() throws IllegalStateException {
        Try<T> result = this.result;
        if (result == null) {
            throw new IllegalStateException(String.format("Value for %s has not been calculated yet.", displayName));
        }

    @Inject
    private RepositorySystem repositorySystem;

    @Inject
    PlexusContainer container;

    @Test
    @Disabled
    void testShouldNotCarryExclusionsOverFromDependencyToDependency() throws Exception {
        /*
        Dependency dep1 = new Dependency();
        dep1.setGroupId( "test" );
        dep1.setArtifactId( "test-artifact" );
        dep1.setVersion( "1" );
        dep1.setType( "jar" );

  }

  /** Returns a plan for the first attempt at [route]. This throws if no plan is possible. */
  @Throws(IOException::class)
  internal fun planConnectToRoute(
    route: Route,
    routes: List<Route>? = null,
  ): ConnectPlan {
    if (route.address.sslSocketFactory == null) {
      if (ConnectionSpec.CLEARTEXT !in route.address.connectionSpecs) {
        throw UnknownServiceException("CLEARTEXT communication not enabled for client")

    private final EmptyChmod chmod = new EmptyChmod();

    @Override
    public int getUnixMode(File f) throws IOException {
        maybeWarn();
        return stat.getUnixMode(f);
    }

    @Override
    public void chmod(File file, int mode) throws Exception {
        maybeWarn();
        chmod.chmod(file, mode);
    }

    private void maybeWarn() {

    MetadataGraphEdge e1;
    MetadataGraphEdge e2;
    MetadataGraphEdge e3;

    // ------------------------------------------------------------------------------------------
    @BeforeEach
    void setUp() throws Exception {
        policy = new DefaultGraphConflictResolutionPolicy();
        e1 = new MetadataGraphEdge("1.1", true, null, null, 2, 1);
        e2 = new MetadataGraphEdge("1.2", true, null, null, 3, 2);

    public static final IntSetSerializer INSTANCE = new IntSetSerializer();

    private IntSetSerializer() {
    }

    @Override
    public IntSet read(Decoder decoder) throws EOFException, Exception {
        int size = decoder.readInt();
        if (size == 0) {
            return IntSets.EMPTY_SET;
        }
        IntSet result = new IntOpenHashSet(size);