encoder.writeString(value.toString());
        }
    }

    private static class ByteArraySerializer extends AbstractSerializer<byte[]> {
        @Override
        public byte[] read(Decoder decoder) throws Exception {
            return decoder.readBinary();
        }

        @Override
        public void write(Encoder encoder, byte[] value) throws Exception {

  }

  public void testSuccessful() throws Exception {
    assertThat(future.set(1)).isTrue();
    assertSuccessful(future, 1);
  }

  public void testFailed() throws Exception {
    Exception cause = new Exception();
    assertThat(future.setException(cause)).isTrue();
    assertFailed(future, cause);
  }

  public void testCanceled() throws Exception {

    private Artifact projectArtifact;

    @BeforeEach
    @Override
    public void setUp() throws Exception {
        super.setUp();

        projectArtifact = createLocalArtifact("project", "3.0");
    }

    @Override
    protected DefaultRepositorySystemSession initRepoSession() throws Exception {
        DefaultRepositorySystemSession session = super.initRepoSession();

   *
   * @throws NoSuchFileException if the file does not exist <i>(optional specific exception)</i>
   * @throws NotDirectoryException if the file could not be opened because it is not a directory
   *     <i>(optional specific exception)</i>
   * @throws IOException if an I/O error occurs
   */
  public static ImmutableList<Path> listFiles(Path dir) throws IOException {

        public void encode ( NdrBuffer _dst ) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_long(this.length);
            _dst.enc_ndr_short(this.impersonation_level);
            _dst.enc_ndr_small(this.context_mode);
            _dst.enc_ndr_small(this.effective_only);

        }


        @Override
        public void decode ( NdrBuffer _src ) throws NdrException {
            _src.align(4);

     * If the owner is already being evaluated, throws {@link CircularEvaluationException}.
     *
     * @param owner the object to evaluate
     * @param evaluation the evaluation
     * @param <R> the type of the result
     * @param <E> (optional) exception type being thrown by the evaluation
     * @return the result of the evaluation
     * @throws E exception from the {@code evaluation} is propagated

    }

    protected void createLocalArtifact(Artifact artifact) throws Exception {
        createArtifact(artifact, localRepository());
    }

    protected void createRemoteArtifact(Artifact artifact) throws Exception {
        createArtifact(artifact, remoteRepository());
    }

    protected void createArtifact(Artifact artifact, ArtifactRepository repository) throws Exception {
        String path = repository.pathOf(artifact);

    return suite;
  }

  public void testRoundTripSources() throws Exception {
    File asciiFile = getTestFile("ascii.txt");
    ByteSource byteSource = Files.asByteSource(asciiFile);
    assertSame(byteSource, byteSource.asCharSource(Charsets.UTF_8).asByteSource(Charsets.UTF_8));
  }

  public void testToByteArray() throws IOException {
    File asciiFile = getTestFile("ascii.txt");

    ) throws IOException {
        return Instrumented.groovyFileGetText(self, consumer);
    }

    @InterceptGroovyCalls
    @InstanceMethod
    @WithExtensionReferences(toClass = ResourceGroovyMethods.class)
    public static String intercept_getText(
        @Receiver File self,
        String charset,
        @CallerClassName String consumer
    ) throws IOException {

        public Object call(Object receiver, Object[] args) throws Throwable {
            CallInterceptor interceptor = resolveCallInterceptor(InterceptScope.methodsNamed(getName()));
            if (interceptor != null) {
                return interceptor.intercept(new AbstractInvocation<Object>(receiver, args) {
                    @Override
                    public Object callOriginal() throws Throwable {