given:
        LibraryComponentSelector selection = new DefaultLibraryComponentSelector(projectPath, libraryName)

        when:
        LibraryComponentSelector result = serialize(selection, serializer)

        then:
        result.projectPath == projectPath
        result.libraryName == libraryName

        where:

        then:
        defaultBuildComponentSelector.projectPath == ':myPath'
        defaultBuildComponentSelector.libraryName == 'myLib'
        defaultBuildComponentSelector.displayName == /project ':myPath' library 'myLib'/
        defaultBuildComponentSelector.toString() == /project ':myPath' library 'myLib'/
    }

            LibraryComponentSelector libraryComponentSelector = (LibraryComponentSelector) selector;
            String libraryName = GUtil.elvis(libraryComponentSelector.getLibraryName(), "");
            return DefaultModuleVersionSelector.newSelector(DefaultModuleIdentifier.newId(libraryComponentSelector.getProjectPath(), libraryName), "undefined");
        }
        throw new GradleException("Unrecognized component selector: " + selector);
    }

        def project = new XmlSlurper().parse(file(iprFileName))
        def libraryTable = project.component.find { it.@name == "libraryTable" }
        assert libraryTable

        def library = libraryTable.library.find { it.@name == libraryName }

    override val contentScope: GlobalSearchScope,
    override val platform: TargetPlatform,
    override val project: Project,
    private val binaryRoots: Collection<Path>,
    override val libraryName: String,
    override val librarySources: KtLibrarySourceModule?,
) : KtLibraryModule, KtModuleWithPlatform {
    override val transitiveDependsOnDependencies: List<KtModule> by lazy {

    private String[] getLibraryTasks(String libraryName) {
        return getStaticLibraryTasks(libraryName) + getSharedLibraryTasks(libraryName)
    }

    private String[] getStaticLibraryTasks(String libraryName) {
        return [":${libraryName}LibVisualStudioProject", ":${libraryName}LibVisualStudioFilters"]
    }

    private String[] getSharedLibraryTasks(String libraryName) {

import org.gradle.platform.base.VariantComponent;

import java.util.Collection;

public interface LocalLibraryResolver {
    Collection<VariantComponent> resolveCandidates(ModelRegistry projectModel, String libraryName);

                        addBinaryRoot(platformStdlibPath)
                        addBinaryRoots(additionalStdlibRoots)
                        platform = targetPlatform
                        libraryName = "stdlib"
                    }
                )
                sourceModule = addModule(
                    buildKtSourceModule {
                        addSourceRoot(testDataPath("stdlibFunctionUsage"))

	t := &testLib{version: math.MaxUint32}
	for _, o := range options {
		t = o(t)
	}
	return cel.Lib(t)
}

type testLib struct {
	version uint32
}

func (*testLib) LibraryName() string {
	return "k8s.test"
}

type TestOption func(*testLib) *testLib

func TestVersion(version uint32) func(lib *testLib) *testLib {
	return func(sl *testLib) *testLib {
		sl.version = version

                    buildKtLibraryModule {
                        addBinaryRoot(Paths.get("dist/common/kotlin-stdlib-common.jar"))
                        platform = CommonPlatforms.defaultCommonPlatform
                        libraryName = "stdlib"
                    }
                )
                val commonModule = addModule(
                    buildKtSourceModule {
                        addSourceRoot(testDataPath(root).resolve("commonMain"))