}

  private static class UrlByteSourceFactory extends FileByteSourceFactory {

    @SuppressWarnings("CheckReturnValue") // only using super.createSource to create a file
    @Override
    public ByteSource createSource(byte[] bytes) throws IOException {
      super.createSource(bytes);
      return Resources.asByteSource(getFile().toURI().toURL());
    }
  }

        String name = decoder.readString();
        byte[] sha1 = decoder.readBinary();
        DefaultMetadataFileSource source = createSource(sha1, group, module, version, name);
        return source;
    }

    private DefaultMetadataFileSource createSource(byte[] sha1, String group, String module, String version, String name) {

 * limitations under the License.
 */

package org.gradle.caching.internal.tasks;

import org.openjdk.jmh.annotations.Level;

import java.io.IOException;

public interface DataAccessor {
    DataSource createSource(String name, byte[] bytes, Level level) throws IOException;
    DataTarget createTarget(String name, Level level);
    DataTargetFactory createTargetFactory(String root, Level level) throws IOException;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class InMemoryDataAccessor implements DataAccessor {
    @Override
    public DataSource createSource(String name, byte[] bytes, Level level) {
        return new Source(name, bytes);
    }

    @Override
    public DataTarget createTarget(String name, Level level) {
        return new Target(name);
    }

    public AbstractFileAccessor(DirectoryProvider directoryProvider) {
        this.directoryProvider = directoryProvider;
    }

    @Override
    public DataSource createSource(String name, byte[] bytes, Level level) throws IOException {
        Path path = getPath(name, level);
        Files.write(path, bytes, StandardOpenOption.CREATE_NEW);
        return new Source(path);
    }

  /** Factory for byte or char sources. */
  public interface SourceFactory<S, T> extends SourceSinkFactory<S, T> {

    /** Creates a new source containing some or all of the given data. */
    S createSource(T data) throws IOException;
  }

  /** Factory for byte or char sinks. */
  public interface SinkFactory<S, T> extends SourceSinkFactory<S, T> {

    /** Creates a new sink. */

    super(factory, string, suiteName, caseDesc, method);
    this.expectedLines = getLines(expected);
  }

  @Override
  protected void setUp() throws Exception {
    this.source = factory.createSource(data);
  }

  public void testOpenStream() throws IOException {
    Reader reader = source.openStream();

    StringWriter writer = new StringWriter();
    char[] buf = new char[64];
    int read;

            int fileSize = minFileSize + random.nextInt(maxFileSize - minFileSize);
            byte[] buffer = new byte[fileSize];
            random.nextBytes(buffer);
            DataSource input = accessor.createSource(name, buffer, Level.Trial);
            inputs.add(input);
        }
        return inputs.build();
    }

    super(factory, bytes, suiteName, caseDesc, method);
  }

  @Override
  public void setUp() throws IOException {
    source = factory.createSource(data);
  }

  public void testOpenStream() throws IOException {
    InputStream in = source.openStream();
    try {
      byte[] readBytes = ByteStreams.toByteArray(in);
      assertExpectedBytes(readBytes);