package org.gradle.integtests.resolve.ivy

import org.gradle.integtests.fixtures.AbstractHttpDependencyResolutionTest

class IvyChangingModuleRemoteResolveIntegrationTest extends AbstractHttpDependencyResolutionTest {

    def "detects changed module descriptor when flagged as changing"() {
        given:
        buildFile << """
repositories {
    ivy { url "${ivyHttpRepo.uri}" }
}

configurations { compile }

configurations.all {

import org.gradle.integtests.fixtures.CompiledLanguage
import spock.lang.Issue

abstract class AbstractSourceIncrementalCompilationIntegrationTest extends AbstractJavaGroovyIncrementalCompilationSupport {

    def "detects class changes in subsequent runs ensuring the class dependency data is refreshed"() {
        source "class A {}", "class B {}", "class C {}"
        outputs.snapshot { run language.compileTaskName }

        when:

        when:
        source api: ["class B { /* change */ }"]
        run "impl:${language.compileTaskName}"

        then:
        impl.noneRecompiled()
    }

    def "detects that changed class still has the same constants so no recompile is necessary"() {
        source api: ["class A { public static final int FOO = 123;}"],
            impl: ["class B { void foo() { int x = 123; }}"]

     * And if the provided timestamp is in `millisecond` precision, then we will definitely detect changes for that file correctly.
     * But if it's in `second` precision we might not detect changes, and we might need to discard the hash at the end of the build.
     */
    private boolean isReliableTimestampPrecision(long timestamp) {

    abstract boolean isSupportsEmptyClassWithRunner()

    // TODO: See if there is some way we can implement the custom runner class as a JUnit Jupiter extension
    def "detects test classes"() {
        given:
        file('src/test/java/org/gradle/AbstractHasRunWith.java') << """
            package org.gradle;

            ${testFrameworkImports}

    TestFileContentCacheFactory cacheFactory = new TestFileContentCacheFactory()
    JavaModuleDetector moduleDetector = new JavaModuleDetector(cacheFactory, TestFiles.fileCollectionFactory())

    def "detects modules on classpath"() {
        def path = path('lib.jar', 'module.jar', 'classes', 'classes-module', 'automaticModule.jar', 'mrjarModule.jar')

        expect:
        inferClasspath(path) == ['lib.jar', 'classes']

  }

  @Test
  fun protocolErrorBeforeCloseSendsFailure() {
    server.sink.write("0a00".decodeHex()).emit() // Invalid non-final ping frame.
    client.processNextFrame() // Detects error, send close, close connection.
    taskFaker.runTasks()
    client.webSocket!!.finishReader()
    assertThat(client.closed).isTrue()
    client.listener.assertFailure(
      ProtocolException::class.java,

ztunnel only supports 2 (custom) xDS resources: [`Workload`](../../pkg/workloadapi/workload.proto) and [`Authorization`](../../pkg/workloadapi/security/authorization.proto). As such, ztunnel does not receive `PeerAuthentication`s directly; when istiod detects a `PeerAuthentication` resource that targets an Ambient captured workload, it computes the effective policy for that workload (taking into account the mesh-wide -> namespace -> workload precedence rules) and sends that policy to ztunnel. The exact...

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

// Package sigchanyzer defines an Analyzer that detects
// misuse of unbuffered signal as argument to signal.Notify.
package sigchanyzer

import (
	"bytes"
	_ "embed"
	"go/ast"
	"go/format"
	"go/token"
	"go/types"

	"golang.org/x/tools/go/analysis"

If file system watching does not work on your system, then continuous build won't work either.
In particular, continuous build does not work when using `--no-daemon`.

When Gradle detects a change to the inputs, it will not trigger the build immediately.
Instead, it will wait until no additional changes are detected for a certain period of time - the quiet period.