return factory.getExpected(new String(data, Charsets.UTF_8)).getBytes(Charsets.UTF_8);
      }

      @Override
      public void tearDown() throws IOException {
        factory.tearDown();
      }
    };
  }

  public static CharSourceFactory asCharSourceFactory(final ByteSourceFactory factory) {
    checkNotNull(factory);
    return new CharSourceFactory() {
      @Override

    }

    override fun <TYPE : PsiType> createMethodReturnTypeSource(psiMethodSource: JavaElementPsiSource<out PsiMethod>): JavaElementTypeSource<TYPE> {
        require(psiMethodSource is JavaElementPsiSourceWithSmartPointer)
        return JavaElementDelegatingMethodReturnTypeSourceWithSmartPointer(psiMethodSource.pointer, psiMethodSource.factory)
    }

                if (!anyOrganisation && !anyModule) {
                    return factory.moduleId(moduleId);
                } else if (!anyModule) {
                    return factory.module(moduleId.getName());
                } else if (!anyOrganisation) {
                    return factory.group(moduleId.getGroup());
                } else {
                    return factory.everything();
                }
            } else {

        _ * textOutputFactory.create(_, _) >> textOutput
    }

    def "delegates to each action factory to configure the command-line parser and create the action"() {
        def rawAction = Mock(Action<? super ExecutionListener>)

        when:
        def commandLineExecution = factory.convert(["--some-option"])
        commandLineExecution.execute(executionListener)

        then:

    final DefaultUrlArtifactRepository.Factory urlArtifactRepositoryFactory = new DefaultUrlArtifactRepository.Factory(fileResolver);
    final ProviderFactory providerFactory = Mock()

    final DefaultBaseRepositoryFactory factory = new DefaultBaseRepositoryFactory(

        TasksFactory factory = new TasksFactory(false)

        when:
        factory.allTasks = [:]
        factory.allTasks.put(project, [task] as Set)
        def tasks = factory.getTasks(project)

        then:
        tasks.empty
    }

    def "returns tasks"() {
        TasksFactory factory = new TasksFactory(true)

        when:
        factory.allTasks = [:]

            return doConcatWithReplacement(factory, node, key, typedUsage, val.replace("-jars", ""), LibraryElements.JAR);
        } else if (val.endsWith("-classes")) {
            return doConcatWithReplacement(factory, node, key, typedUsage, val.replace("-classes", ""), LibraryElements.CLASSES);
        } else if (val.endsWith("-resources")) {

  private val routePlanner = FakeRoutePlanner()
  private val factory = routePlanner.factory
  private val taskFaker = routePlanner.taskFaker
  private val peer = MockHttp2Peer()

  /** The fake task runner prevents the cleanup runnable from being started.  */
  private val addressA = factory.newAddress("a")
  private val routeA1 = factory.newRoute(addressA)
  private val addressB = factory.newAddress("b")

    private final ChainingHttpHandler.HandlerFactory<TrackingHttpHandler> factory;

    public DefaultExpectedRequests(ChainingHttpHandler.HandlerFactory<TrackingHttpHandler> factory) {
        this.factory = factory;
    }

    public TrackingHttpHandler create(WaitPrecondition previous) {
        return factory.create(previous);
    }

      String name, ByteSinkFactory factory, String string, String desc) {
    byte[] bytes = string.getBytes(Charsets.UTF_8);
    TestSuite suite = suiteForBytes(name, factory, desc, bytes);
    CharSinkFactory charSinkFactory = SourceSinkFactories.asCharSinkFactory(factory);
    suite.addTest(
        CharSinkTester.suiteForString(
            name + ".asCharSink[Charset]", charSinkFactory, string, desc));
    return suite;
  }