WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package resolver

import (
	"strings"

	"k8s.io/apimachinery/pkg/api/meta"
	"k8s.io/apimachinery/pkg/runtime/schema"
	"k8s.io/client-go/discovery"
)

type ResourceResolver interface {

/**
 * The only purpose of this class is to expose the resolution [trace] to the consumers.
 */
class TracingResolver(
    private val resolver: Resolver,
    val trace: ResolutionTrace
) : Resolver {
    override fun resolve(schema: AnalysisSchema, imports: List<Import>, topLevelBlock: Block): ResolutionResult = resolver.resolve(schema, imports, topLevelBlock)

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package resolver

import (
	"fmt"

	"k8s.io/apimachinery/pkg/runtime/schema"
	"k8s.io/kube-openapi/pkg/validation/spec"
)

// SchemaResolver finds the OpenAPI schema for the given GroupVersionKind.

    @Nullable
    private final HashCode includedBy;
    private final HashCode resolvedTo;

    public IncludeFileEdge(String includePath, @Nullable HashCode includedBy, HashCode resolvedTo) {
        this.includePath = includePath;
        this.includedBy = includedBy;
        this.resolvedTo = resolvedTo;
    }

    public String getIncludePath() {
        return includePath;
    }

    @Nullable

        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
        assertIs<ObjectOrigin.FunctionOrigin>(resolver.trace.expressionResolution(call).result)

}

func TestForceGoDNS(t *testing.T) {
	var resolver *Resolver
	if runtime.GOOS == "plan9" {
		resolver = &Resolver{
			Dial: func(_ context.Context, _, _ string) (Conn, error) {
				panic("unreachable")
			},
		}
	}
	defer forceGoDNS()()
	order, _ := systemConf().hostLookupOrder(resolver, "go.dev")
	if order == hostLookupCgo {
		t.Fatalf("hostLookupOrder returned: %v, want go resolver order", order)
	}

            val rhs = replaceInnerReceiverWithTopLevel(assignment.rhs)

            assertEquals(topLevelReceiver, (lhs as ObjectOrigin.ImplicitThisReceiver).resolvedTo)
            assertEquals(topLevelReceiver, ((rhs as ObjectOrigin.NewObjectFromMemberFunction).receiver as ObjectOrigin.ImplicitThisReceiver).resolvedTo)
        }
    }

    @Test
    fun `replaces added object receiver`() {
        with(resolution("adding { addingValue(value()) }")) {

    <dependency>
      <groupId>org.apache.maven.resolver</groupId>
      <artifactId>maven-resolver-api</artifactId>
    </dependency>
    <dependency>
      <groupId>org.apache.maven.resolver</groupId>
      <artifactId>maven-resolver-spi</artifactId>
    </dependency>
    <dependency>
      <groupId>org.apache.maven.resolver</groupId>
      <artifactId>maven-resolver-util</artifactId>
    </dependency>
    <dependency>

        res = resolver.resolveConflicts(graph, ArtifactScopeEnum.runtime);

        assertNotNull(res, "null graph after resolver");
        assertNotNull(res.getVertices(), "no vertices in the resulting graph after resolver");
        assertNotNull(res.getExcidentEdges(v1), "no edges in the resulting graph after resolver");

        assertEquals(4, res.getVertices().size(), "wrong # of vertices in the resulting graph after resolver");

    private ScriptClassPathResolver resolver;

    public BuildSrcBuildListenerFactory(Action<ProjectInternal> buildSrcRootProjectConfiguration, ScriptClassPathResolver resolver) {
        this.buildSrcRootProjectConfiguration = buildSrcRootProjectConfiguration;
        this.resolver = resolver;
    }

    Listener create() {
        return new Listener(buildSrcRootProjectConfiguration, resolver);
    }

    /**