* element(unresolved1, [], content.size = 0) -> FromUnderlay(documentNode=element(unresolved1, [], content.size = 0))
                * error(UnsupportedSyntax(cause=ElementArgumentFormat)) -> FromUnderlay(documentNode=error(UnsupportedSyntax(cause=ElementArgumentFormat)))
            * element(unresolved3, [], content.size = 0) -> FromUnderlay(documentNode=element(unresolved3, [], content.size = 0))

        def unresolved = Mock(UnresolvedDependency)
        def results = new DefaultVisitedGraphResults(resolutionResult, Collections.singleton(unresolved), resolveEx)

        expect:
        results.resolutionResult == resolutionResult
        results.unresolvedDependencies == ([unresolved] as Set)
        results.resolutionFailure.get() == resolveEx
    }

                    def unresolved = compile.unresolvedModuleDependencies
                    assert unresolved.size() == 2
                    assert unresolved.find { it.selector.group == 'org.foo' && it.selector.name == 'unknown' && it.selector.version == '1.0' }
                    assert unresolved.find { it.selector.name == 'broken' }
                }
            }
        """

        List<Path> unresolved = dispatched.get(PathType.UNRESOLVED);
        assertEquals(3, dispatched.size());
        assertEquals(1, unresolved.size());
        assertEquals(8, classes.size()); // "plexus.pom" and "junit.jar" are excluded.
        assertEquals(1, modules.size());
        assertEquals("plexus-1.0.11.pom", unresolved.get(0).getFileName().toString());

    sealed interface Resolution {
        data class Resolved(val function: DeclarativeRuntimeFunction) : Resolution
        data object Unresolved : Resolution
    }
}


class MemberFunctionResolver(private val configureLambdaHandler: ConfigureLambdaHandler) : RuntimeFunctionResolver {

config.test_exec_root = os.environ['RUNFILES_DIR']

if platform.system() == 'Windows':
  tool_patterns = [
      ToolSubst('FileCheck.exe', unresolved='fatal'),
      #  Handle these specially as they are strings searched for during testing.
      ToolSubst('count.exe', unresolved='fatal'),
      ToolSubst('not.exe', unresolved='fatal')
  ]

  llvm_config.config.substitutions.append(
      ('%python', '"%s"' % (sys.executable)))

        ErrorReason.UnitAssignment -> "assignment of a Unit value"
        ErrorReason.UnresolvedAssignmentLhs -> "unresolved assignment target"
        ErrorReason.UnresolvedAssignmentRhs -> "unresolved assigned value"
        is ErrorReason.UnresolvedReference -> "unresolved reference '${errorReason.reference.sourceData.text()}'"
        ErrorReason.UnusedConfigureLambda -> "a configuring block is not expected"

			}
		}
	}

	// Find unresolved identifiers and uses of top-level declarations.
	depDecls, unresolved := findDeclsAndUnresolved(body, topDecls, typMethods)

	// Remove predeclared identifiers from unresolved list.
	for n := range unresolved {
		if predeclaredTypes[n] || predeclaredConstants[n] || predeclaredFuncs[n] {
			delete(unresolved, n)
		}
	}

     * Plugins can choose to report a warning to users when unresolved paths exist.
     */
    PathType UNRESOLVED = new PathType() {
        @Override
        public String name() {
            return "UNRESOLVED";
        }

        @Override
        public String id() {
            return "UNRESOLVED";
        }

        @Override
        public Optional<String> option() {

        }
    }

    class DummyResolver implements SourceIncludesResolver {
        final Map<String, TestFile> mapping = [:]
        final Set<TestFile> unresolved = []

        void unresolved(TestFile file) {
            unresolved.add(file)
        }

        void resolveAs(String include, TestFile file) {
            mapping[include] = file
        }

        @Override