private static List<JvmBytecodeCallInterceptor.Factory> loadFactories(ClassLoader classLoader, String forPackage) {
            ImmutableList.Builder<JvmBytecodeCallInterceptor.Factory> factories = ImmutableList.builder();
            for (JvmBytecodeCallInterceptor.Factory factory : ServiceLoader.load(JvmBytecodeCallInterceptor.Factory.class, classLoader)) {
                if (factory.getClass().getPackage().getName().startsWith(forPackage)) {

            registerProvider(factory = ::KaFirForLoopInReference)
            registerProvider(factory = ::KaFirInvokeFunctionReference)
            registerProvider(factory = ::KaFirPropertyDelegationMethodsReference)
            registerProvider(factory = ::KaFirDestructuringDeclarationReference)
            registerProvider(factory = ::KaFirArrayAccessReference)
            registerProvider(factory = ::KaFirConstructorDelegationReference)

    @Rule
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    TestFile projectDir
    DefaultFilePropertyFactory factory

    def setup() {
        projectDir = tmpDir.createDir("project")
        factory = new DefaultFilePropertyFactory(Stub(PropertyHost), TestFiles.resolver(projectDir), TestFiles.fileCollectionFactory())
    }

        when:
        ITestListener listener1 = factory.createAdapter(listener);
        ITestListener listener2 = factory.createAdapter(listener);
        ITestListener differentListener = factory.createAdapter(otherListener);

        then:
        listener1.equals(listener2) && listener1.hashCode() == listener2.hashCode()
        !listener1.equals(listener)
        !listener1.equals(differentListener)

        given:
        Publication pub = publication("test")
        NamedDomainObjectFactory<Publication> factory = Mock()
        container.registerFactory(Publication, factory)

        when:
        container.create("name", Publication) {
            value = 2
        }

        then:
        1 * factory.create("name") >> pub

        and:
        container.getByName("test") == pub
        pub.value == 2
    }

    def userCodeContext = Mock(UserCodeApplicationContext)
    def factory = new DefaultProblemDiagnosticsFactory(DefaultFailureFactory.withDefaultClassifier(), locationAnalyzer, userCodeContext, 2)

    def "uses caller's stack trace to calculate problem location"() {
        given:
        def location = Stub(Location)
        def stream = factory.newStream()

        when:
        def diagnostics = stream.forCurrentCaller()

    @ClassRule
    @Shared
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    def factory = new DefaultFileCollectionFactory(TestFiles.pathToFileResolver(tmpDir.testDirectory), TestFiles.taskDependencyFactory(), TestFiles.directoryFileTreeFactory(), Stub(Factory), Stub(PropertyHost), TestFiles.fileSystem())

    def "lazily queries contents of collection created from MinimalFileSet"() {

        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 {