// Copyright 2020 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.

// Test that a method of a reachable type is not necessarily
// live even if it matches an interface method, as long as
// the type is never converted to an interface.

package main

type I interface{ M() }

type T int

func (T) M() { println("XXX") }

var p *T

    T getOrElse(T defaultValue);

    /**
     * Returns a new {@link Provider} whose value is the value of this provider transformed using the given function.
     *
     * <p>
     * The resulting provider will be live, so that each time it is queried, it queries the original (this) provider
     * and applies the transformation to the result. Whenever the original provider has no value, the new provider

jwksloc =
# Set this to the base URL of a Collaborator server, somewhere you can read live logs, a Request Bin etc.
httplistener =

[customising]
useragent = Mozilla/5.0 (Windows NT 10.0; Win64; x64) jwt_tool

[input]
wordlist = jwt-common.txt
commonHeaders = common-headers.txt

import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

/**
 * Factory for creating build scoped {@link org.gradle.cache.CacheBuilder}s. These typically live under the ~/.gradle directory of the build.
 */
@ServiceScope(Scope.Build.class)
public interface BuildScopedCacheBuilderFactory extends ScopedCacheBuilderFactory {

type TestFieldManager interface {
	// APIVersion of the object that we're tracking.
	APIVersion() string
	// Reset resets the state of the liveObject by resetting it to an empty object.
	Reset()
	// Live returns a copy of the current liveObject.
	Live() runtime.Object
	// Apply applies the given object on top of the current liveObj, for the
	// given manager and force flag.
	Apply(obj runtime.Object, manager string, force bool) error

        when:
        deps = dependencies.getDependencies(Stub(Task))

        then:
        visited == 2
        deps as List == [dependency]
    }

    def "collection dependencies are live"() {
        def task = Stub(Task)
        def dependency1 = Stub(Task)
        def dependency2 = Stub(Task)
        def dependencySource = Mock(TaskDependencyContainer)

//     chain rooted at hash bucket 0x111.
//  3. The main binary then asks for the itab for *dynamodbstreamsevt.Event /
//     json.Unmarshaler.  This itab happens to also live in bucket 0x111.
//     The lookup code goes into an infinite loop searching for this itab.
//
// The code is carefully crafted so that the two itabs are both from the
// same bucket, and so that the second itab doesn't exist in

        calledFor == []

        when:
        component1.remove("b")
        component2.remove("d")

        then:
        calledFor == ["b", "d"]
    }

    def "filtered collection is live"() {
        given:
        def component1 = collection("a", "j")
        def component2 = collection("b", "k")
        def composite = composite(component1, component2)

                testImplementation(testFixtures(project(":sub")))
            }
        """
        addPersonDomainClass("sub", "groovy")
        addPersonTestFixture("sub", "groovy")
        // the test will live in the current project, instead of "sub"
        // which demonstrates that the test fixtures are exposed
        addPersonTestUsingTestFixtures()

        when:
        succeeds ':compileTestJava'

        then:

 */
public interface Buildable {
    /**
     * Returns a dependency which contains the tasks which build this artifact. All {@code Buildable} implementations
     * must ensure that the returned dependency object is live, so that it tracks changes to the dependencies of this
     * buildable.
     *
     * @return The dependency. Never returns null. Returns an empty dependency when this artifact is not built by any
     *         tasks.