If("bool1", "b1", "b2")),
		Bloc("b1",
			Valu("ptr1", OpAddr, ptrType, 0, nil, "sb"),
			Goto("checkPtr")),
		Bloc("b2",
			Valu("ptr2", OpAddr, ptrType, 0, nil, "sb"),
			Goto("checkPtr")),
		// both ptr1 and ptr2 are guaranteed non-nil here
		Bloc("checkPtr",
			Valu("phi", OpPhi, ptrType, 0, nil, "ptr1", "ptr2"),
			Valu("bool2", OpIsNonNil, c.config.Types.Bool, 0, nil, "phi"),

org.checkerframework.checker.propkey.qual
org.checkerframework.checker.regex
org.checkerframework.checker.regex.qual
org.checkerframework.checker.signature
org.checkerframework.checker.signature.qual
org.checkerframework.checker.signedness
org.checkerframework.checker.signedness.qual
org.checkerframework.checker.tainting
org.checkerframework.checker.tainting.qual
org.checkerframework.checker.units
org.checkerframework.checker.units.qual

)

// Each applies the given per-response function across all responses.
func Each(v Visitor) echo.Checker {
	return v.Checker()
}

// And is an aggregate Checker that requires all Checkers succeed. Any nil Checkers are ignored.
func And(checkers ...echo.Checker) echo.Checker {
	return func(result echo.CallResult, err error) error {
		for _, c := range filterNil(checkers) {

                    assert actualValue instanceof Map
                    checkMap(actualValue, expectedValue, checker)
                } else {
                    checker(actualValue, expectedValue)
                }
            } else if (checker instanceof List) {
                def subSpecs = checker as List
                checkModel(actualValue, expectedValue, subSpecs)
            } else {

			expectEsimatedCost: func(c checker.CostEstimate) checker.CostEstimate {
				return checker.CostEstimate{Min: c.Min + 5, Max: c.Max + 9}
			},
			expectRuntimeCost: func(c uint64) uint64 { return c + 5 },
		},
		{
			ops: []string{".containsCIDR(cidr('192.168.0.0/16'))"},
			expectEsimatedCost: func(c checker.CostEstimate) checker.CostEstimate {
				return checker.CostEstimate{Min: c.Min + 5, Max: c.Max + 9}
			},

// 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
}

        1 * checker.isDependent(child1, "testRuntime", child2) >> false
        1 * checker.isDependent(child1, "testRuntime", child3) >> true
        1 * context.add(child3.tasks["buildDependents"])
        0 * _
    }

    def "knows which tasks come from dependent projects with specific configuration"() {
        def checker = new TasksFromDependentProjects.TaskDependencyChecker()

	}
	return 1
}

func (l *CostEstimator) sizeEstimate(t checker.AstNode) checker.SizeEstimate {
	if sz := t.ComputedSize(); sz != nil {
		return *sz
	}
	if sz := l.EstimateSize(t); sz != nil {
		return *sz
	}
	return checker.SizeEstimate{Min: 0, Max: math.MaxUint64}
}

func (l *CostEstimator) listElementNode(list checker.AstNode) checker.AstNode {
	if params := list.Type().Parameters(); len(params) > 0 {

// run -race -gcflags=all=-d=checkptr=0

//go:build ((linux && amd64) || (linux && ppc64le) || (darwin && amd64) || (freebsd && amd64) || (netbsd && amd64) || (windows && amd64)) && cgo

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Although -race turns on -d=checkptr, the explicit -d=checkptr=0
// should override it.

package main

	// MatchSupportedTargets returns a Matcher for filtering unsupported targets.
	MatchSupportedTargets() match.Matcher

	// Check returns an echo.Checker for validating response based on the request information.
	Check(opts echo.CallOptions, expectAllowed bool) echo.Checker
}

var _ Provider = &providerImpl{}

type providerImpl struct {
	name              string
	api               API