dependencies.assertHasModule('COMPILE', "impl")

        dependencies = parseIml("application/application.iml").dependencies
        assert dependencies.modules.size() == 4

        dependencies.assertHasModule('COMPILE', "library")
        dependencies.assertHasModule('COMPILE', "api")
        dependencies.assertHasModule('RUNTIME', "impl")
        dependencies.assertHasModule('TEST', "impl")
    }

    @Test

#include "tensorflow/cc/experimental/libtf/impl/string.h"

#include "tensorflow/core/platform/test.h"

namespace tf {
namespace libtf {
namespace impl {

TEST(StringTest, TestBasicInterning) {
  String s1("foo");
  String s2("foo");
  EXPECT_EQ(&s1.str(), &s2.str());
}

}  // namespace impl
}  // namespace libtf

<component name="ProjectDictionaryState">
  <dictionary name="yan">
    <words>
      <w>barebone</w>
      <w>debuggee</w>
      <w>deserializes</w>
      <w>destructured</w>
      <w>hacky</w>
      <w>impls</w>
      <w>inlined</w>
      <w>kapt</w>
      <w>kotlinc</w>
      <w>mutators</w>
      <w>parcelable</w>
      <w>parceler</w>
      <w>parcelers</w>
      <w>parcelize</w>
      <w>repl</w>
      <w>testdata</w>

        setup:
        Task stubTask = Stub(Task)
        List<PluginDescriptor> descriptors = []
        if (impl != null) {
            descriptors << Stub(PluginDescriptor) {
                getPropertiesFileUrl() >> { new URL("file:///test-plugin/${impl}.properties") }
            }
        }

}

// another test case from the issue

func _() {
	X /* ERROR "cannot infer Q" */ (Interface[*F /* ERROR "not enough type arguments for type F: have 1, want 2" */ [string]](Impl{}))
}

func X[Q Qer](fs Interface[Q]) {
}

type Impl struct{}

func (Impl) M() {}

type Interface[Q Qer] interface {
	M()
}

type Qer interface {
	Q()
}

type F[A, B any] struct{}

#include "tensorflow/cc/experimental/libtf/impl/scalars.h"

#include "tensorflow/core/platform/test.h"

namespace tf {
namespace libtf {
namespace impl {

TEST(ScalarsTest, TestHeterogeneousAddition) {
  ASSERT_EQ((Int64(1) + Float32(0.375)).get(), 1.375);
}

}  // namespace impl
}  // namespace libtf

    }

    MavenHttpModule publishPlugin(
        @Language(value = "groovy", prefix = "void apply(org.gradle.api.Project project) {\n", suffix = "\n}") String impl
    ) {
        pluginBuilder.with {
            addPlugin(impl, PLUGIN_ID)
            publishAs(GROUP, ARTIFACT, VERSION, pluginRepo, executer).allowAll().pluginModule as MavenHttpModule
        }
    }

    MavenHttpModule publishSettingPlugin(

import static org.gradle.internal.cc.impl.fixtures.ExternalProcessFixture.processBuilder
import static org.gradle.internal.cc.impl.fixtures.ExternalProcessFixture.runtimeExec
import static org.gradle.internal.cc.impl.fixtures.ExternalProcessFixture.stringArrayExecute

class ProcessInPluginIntegrationTest extends AbstractProcessIntegrationTest {
    def "using #snippetsFactory.summary in convention plugin #file is a problem"() {

        value.prop == "value"
    }

    static class Base {
        String prop

        Base() {
            prop = "default"
        }
    }

    static abstract class Impl extends Base {
        Impl() {
            throw new RuntimeException("should not be called")
        }
    }

    static abstract class WithServices {
        @Inject
        abstract String getProp()
    }

                            properties.load(in);
                        }
                    }
                    String impl = properties.getProperty(slf4jBinding);
                    if (impl != null) {
                        return (Slf4jConfiguration) Class.forName(impl).newInstance();
                    }
                } catch (IOException | ClassNotFoundException | IllegalAccessException | InstantiationException ex) {