* <p>
 * A type can be marked {@link Consumer} or {@link Provider} but not both. A type is assumed to be
 * {@link Consumer} if it is not marked either {@link Consumer} or {@link Provider}.
 * <p>
 * A package can be marked {@link Provider}. In this case, all types in the package are considered
 * to be a provider type regardless of whether they are marked {@link Consumer} or {@link Provider}.
 *
 * @see Consumer

wait

# Test binaries that panic in TestMain should be marked as failing.

! go test -json ./mainpanic
stdout '"Action":"fail"'
! stdout '"Action":"pass"'

! go tool test2json ./mainpanic.exe
stdout '"Action":"fail"'
! stdout '"Action":"pass"'

# Test binaries that exit with status 0 should be marked as passing.

go test -json ./mainexit0
stdout '"Action":"pass"'

    /**
     * This component was selected by a rule.
     */
    SELECTED_BY_RULE("selected by rule"),

    /**
     * This component was selected because selection was forced on this version.
     */
    FORCED("forced"),

    /**
     * This component was selected between several candidates during conflict resolution.
     */
    CONFLICT_RESOLUTION("conflict resolution"),

    /**

    private void assertNotLocked() {
        if (locked) {
            throw new IllegalStateException("class loader scope is locked, scope identifier is " + id);
        }
    }

    @Override
    public ClassLoaderScope lock() {
        locked = true;
        return this;
    }

    @Override
    public boolean isLocked() {
        return locked;
    }

    @Override

            return ((DefaultProjectDependencyMetadata) dependencyMetadata).forced();
        }
        return new ForcedDependencyMetadataWrapper((ModuleDependencyMetadata) dependencyMetadata);
    }

    @Override
    public boolean isForce() {
        return true;
    }

    @Override
    public ForcingDependencyMetadata forced() {
        return this;
    }

    public ModuleDependencyMetadata unwrap() {

        boolean tryLock() {
            if (!locks.contains(this) && locked) {
                return false
            }
            locked = true
            locks.add(this)
            return true
        }

        @Override
        void unlock() {
            locked = false
            locks.remove(this)
        }

        @Override
        String getDisplayName() {
            return "some lock"

        "org.apache.commons:commons-math3": {
            "locked": "3.6.1",
            "requested": "3.6.1"
        }
    },
    "default": {
        "org.apache.commons:commons-math3": {
            "locked": "3.6.1",
            "requested": "3.6.1"
        }
    },
    "runtimeClasspath": {
        "org.apache.commons:commons-math3": {
            "locked": "3.6.1",
            "requested": "3.6.1"
        }

	// the same thread must be used, and the locked state must match with the thread-lock state of
	// the goroutine which called newcoro. Thread-lock state consists of the thread and the number
	// of internal (cgo callback, etc.) and external (LockOSThread) thread locks.
	locked := gp.lockedm != 0
	if c.mp != nil || locked {
		if mp != c.mp || mp.lockedInt != c.lockedInt || mp.lockedExt != c.lockedExt {

     * Was the dependency created with the 'force' attribute.
     */
    boolean isForce();

    /**
     * Returns a copy of this dependency metadata, using force.
     * @return forced dependency metadata
     */
    ForcingDependencyMetadata forced();

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

//go:norace
func Foo(x int) int { // ERROR "cannot inline Foo: marked go:norace with -race compilation$"
	return x * (x + 1) * (x + 2)
}

func Bar(x int) int { // ERROR "can inline Bar with cost .* as: func\(int\) int { return x \* \(x \+ 1\) \* \(x \+ 2\) }$"
	return x * (x + 1) * (x + 2)