}

  @Test
  @TestMetadata("unresolved.kt")
  public void testUnresolved() {
    runTest("analysis/analysis-api/testData/components/typeCreator/classType/unresolved.kt");
  }

                assertHasErrorOutput("buildSrc/src/main/kotlin/plugin-without-plugins.gradle.kts:1:9 Unresolved reference: libs")
                assertHasErrorOutput("buildSrc/src/main/kotlin/plugin-with-plugins.gradle.kts:3:21 Unresolved reference: libs")
            }
        }
    }

    private
    fun withSimpleVersionCatalog() {
        withFile(

    @Test
    fun `collects successful resolution of function`() {
        val resolver = tracingCodeResolver()
        val result = schema.resolve(
            """
            f(0) // must be an unresolved property x
            """.trimIndent(),
            resolver
        )

        val call = result.additions.single().dataObject.originElement as FunctionCall

    }

    private static class MacroSerializer implements Serializer<Macro> {
        private static final byte SIMPLE = (byte) 1;
        private static final byte COMPLEX = (byte) 2;
        private static final byte UNRESOLVED = (byte) 3;
        private final Serializer<IncludeType> enumSerializer;
        private final Serializer<List<Expression>> expressionSerializer;

  }

  @Test
  @TestMetadata("unresolved.kt")
  public void testUnresolved() {
    runTest("analysis/analysis-api/testData/components/typeCreator/classType/unresolved.kt");
  }

            }

            task verify {
                doLast {
                    assert configurations.customCompileClasspath.state.toString() == "UNRESOLVED"
                    assert configurations.customRuntimeClasspath.state.toString() == "UNRESOLVED"
                }
            }
        """

        expect:
        succeeds("verify")
    }

    /**
     * Retrieves all dependencies, including unresolved dependencies.
     * Resolved dependencies are represented by instances of {@link ResolvedDependencyResult},
     * unresolved dependencies by {@link UnresolvedDependencyResult}.
     *
     * In dependency graph terminology, this method returns the edges of the graph.
     *
     * @return all dependencies, including unresolved dependencies.
     */

}
"""
        def content = getFile([print : true], 'root.iml').text

        //then
        assert content.count("artifactTwo-2.0.jar") == 1
        assert content.count("unresolved dependency - groupOne artifactTwo") >= 1
    }

    @Test
    @ToBeFixedForConfigurationCache
    void "does not break when extra dependency not in lockfile is defined"() {
        //given

    }

    def "matches unresolved dependencies"() {
        expect:
        new DependencyResultSpec(notation).isSatisfiedBy(newUnresolvedDependency("org.foo", "foo-core", "5.0"))

        where:
        notation << ['core', 'foo-core', 'foo-core:5.0', 'org.foo:foo-core:5.0', '5.0']
    }

    def "does not match unresolved dependencies"() {
        expect:

				if x, ok := s.X.(*syntax.Name); ok {
					obj := uses[x]
					if obj == nil {
						t.Errorf("%s: unresolved qualified identifier %s", x.Pos(), x.Value)
						return false
					}
					if _, ok := obj.(*PkgName); ok && uses[s.Sel] == nil {
						t.Errorf("%s: unresolved selector %s", s.Sel.Pos(), s.Sel.Value)
						return false
					}
					return false
				}
				return true
			}