import org.gradle.integtests.fixtures.CompiledLanguage

abstract class CrossTaskClassChangesIncrementalCompilationIntegrationTest extends AbstractCrossTaskIncrementalCompilationSupport {

    def "detects changed class in an upstream project"() {
        source api: ["class A {}", "class B {}"], impl: ["class ImplA extends A {}", "class ImplB extends B {}"]
        impl.snapshot { run language.compileTaskName }

        when:

    }

    /**
     * Test scenario from {@link BaseIncrementalCompilationAfterFailureIntegrationTest#detects deletion of a source base class that leads to compilation failure but keeps old files()}
     * but for the CLI compiler where incremental compilation after failure is not supported.
     */
    def "detects deletion of a source base class that leads to compilation failure"() {
        def a = source "class A {}"

    }

    def "detects cycles early"() {
        replacements.module("o:a").replacedBy("o:b")
        when: replacements.module("o:b").replacedBy("o:a")

        then:
        def ex = thrown(InvalidUserDataException)
        ex.message == "Cannot declare module replacement o:b->o:a because it introduces a cycle: o:b->o:a->o:b"
    }

    def "detects transitive cycles early"() {

apiVersion: release-notes/v2
kind: feature
area: istioctl
releaseNotes:
  - |

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

// Package appends defines an Analyzer that detects
// if there is only one variable in append.
//
// # Analyzer appends
//
// appends: check for missing values after append
//
// This checker reports calls to append that pass
// no values to be appended to the slice.
//

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

// Package assign defines an Analyzer that detects useless assignments.
//
// # Analyzer assign
//
// assign: check for useless assignments
//
// This checker reports assignments of the form x = x or a[i] = a[i].
// These are almost always useless, and even when they aren't they are

        when:
        withBuildCache().run(first, second)
        then:
        firstOutput.assertExists()
        secondOutput.assertExists()
        // Only the first task can be cached since the second detects the overlap
        assertTaskOutputCached(first)
        assertTaskOutputNotCached(second)

        when:
        cleanBuildDir()
        withBuildCache().run(first, second)
        then:

        abstract void setValue(String value)
    }

    def "detects managed property"() {
        expect:
        ModelSchemaUtils.isMethodDeclaredInManagedType(ModelSchemaUtils.getCandidateMethods(ManagedType).methodsNamed("getValue").values().flatten())
    }

    class UnmanagedType  {
        String value
    }

    def "detects unmanaged property"() {
        expect:

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

// Package sigchanyzer defines an Analyzer that detects
// misuse of unbuffered signal as argument to signal.Notify.
//
// # Analyzer sigchanyzer
//
// sigchanyzer: check for unbuffered channel of os.Signal
//
// This checker reports call expression of the form
//

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 inuserns

// RunningInUserNS detects whether the current process is running in a user namespace.
func RunningInUserNS() bool {
	return false