// license that can be found in the LICENSE file.

package types

import (
	"go/ast"
	"go/token"
	. "internal/types/errors"
)

// labels checks correct label use in body.
func (check *Checker) labels(body *ast.BlockStmt) {
	// set of all labels in this body
	all := NewScope(nil, body.Pos(), body.End(), "label")

	fwdJumps := check.blockBranches(all, nil, nil, body.List)

// No-op for Darwin (MacOS), Windows.
func addIPv6Checks(checks []Checker) []Checker {
	return checks
}

// addIPv4Checks adds IPv4 related checks
// No-op for Darwin (MacOS), Windows.
func addIPv4Checks(checks []Checker) []Checker {
	return checks
}

// addSwapCheck adds a swap check
// No-op for Darwin (MacOS), Windows.
func addSwapCheck(checks []Checker) []Checker {
	return checks
}

	"slices"
)

func TestHeap(t *testing.T) {
	var heap []*batchCursor

	// Insert a bunch of values into the heap.
	checkHeap(t, heap)
	heap = heapInsert(heap, makeBatchCursor(5))
	checkHeap(t, heap)
	for i := int64(-20); i < 20; i++ {
		heap = heapInsert(heap, makeBatchCursor(i))
		checkHeap(t, heap)
	}

	// Update an element in the middle to be the new minimum.
	for i := range heap {
		if heap[i].ev.time == 5 {

        succeeds 'checkDeps'
    }

    def "fails gracefully for invalid notations"() {
        when:
        buildFile <<  """
configurations {
    conf
}

dependencies {
    conf 100
}

task checkDeps
"""
        then:
        fails 'checkDeps'

            doLast {
               outFile << 'Hello'
            }
        }

        checkDeps.dependsOn resolve

        """

        when:
        args '-Pproject.version=1.1'
        succeeds 'checkDeps'

        then:
        executedAndNotSkipped ":checkDeps", ":resolve"
        resolve.expectGraph {
            root(":", "org:provider:1.0") {

            }
        """

        when:
        foo.ivy.expectGet()
        foo.artifact.expectGet()
        bar.pom.expectGet()
        bar.artifact.expectGet()

        run 'checkDeps'

        then:
        resolve.expectGraph {
            root(':', ':test:') {
                module('org:foo:1.0')
                module('other:bar:2.0')
            }
        }

        where:

}

configurations.all {
    resolutionStrategy.force 'org:foo:1.4.4'
}

task checkDeps {
    def compileClasspath = configurations.compileClasspath
    doLast {
        assert compileClasspath*.name == ['foo-1.4.4.jar']
    }
}
"""

        expect:
        run("checkDeps")
    }

    void "can force the version of a transitive dependency module"() {

        buildFile << """
            dependencies {
                implementation 'org.readonly:core:1.0'
            }
        """

        when:
        withReadOnlyCache()
        succeeds ':checkDeps'

        then:
        resolve.expectGraph {
            root(':', 'org.gradle:ro-test:20') {
                module('org.readonly:core:1.0')
            }
        }

        and:

'''
        file("sub/build.gradle") << '''
            dependencies {
                compile files('sub.jar') { builtBy jar }
            }
'''

        when:
        run ":checkDeps"

        then:
        executed ":jar", ":sub:jar", ":checkDeps"
        resolve.expectGraph {
            root(":", ":main:") {
                files << "main.jar"
                files << "sub.jar"
                project(":sub", "main:sub:") {

  auto* host = corert->GetHostContext();
  auto [bef_buffer, bef_file] = CreateBefFile(host);
  auto* func = bef_file->GetFunction("main");
  CHECK(func);
  CHECK_EQ(func->result_types().size(), 113);
  CHECK_EQ(func->argument_types().size(), 113);

  auto arguments = CreateTestArguments(func, host);

  tfrt::ResourceContext resource_ctx;