"""
                )
            }
        ) {
            assertHasErrors(
                "Method com.example.Task.getSourceCompatibility(): Is not binary compatible." to listOf("Method return type has changed", "Method is now abstract"),
                removed("Method", "Task.setSourceCompatibility(java.lang.String)"),
            )
        }
    }

    @Test

class JavaCompileAvoidanceWithBuildCacheServiceIntegrationTest extends AbstractIntegrationSpec implements DirectoryBuildCacheFixture {

    def "classes from cache are used when dependent class is changed in ABI compatible way"() {
        given:
        project_a_depends_on_project_b()

        when:
        withBuildCache().run 'assemble'

        then:
        executedAndNotSkipped ':b:jar'

        outputDir.file("A").text == "original"

        when:
        packDir.file("A") << "-changed"
        packDir."$packType"(sourceFile)

        then:
        buildTriggeredAndSucceeded()
        executedAndNotSkipped(":unpack")
        outputDir.file("A").text == "original-changed"

        where:
        type      | packType | resourceType | source

        stdout.toString().contains('A warning using Log4j')
        stdout.toString().contains('A warning using JUL')
        if (targetVersion.baseVersion >= GradleVersion.version('4.7')) {
            // Changed handling of error log messages
            stdout.toString().contains('this is stderr')
        } else {
            stderr.toString().contains('this is stderr')
        }
    }

			}},
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			changed := SetStatusCondition(&test.conditions, test.toAdd)
			if test.expectChanged != changed {
				t.Errorf("expectChanged=%t != changed=%t", test.expectChanged, changed)
			}
			if !reflect.DeepEqual(test.conditions, test.expected) {
				t.Error(test.conditions)
			}
		})
	}
}

`, 1008-limit),
		"main.startChain": fmt.Sprintf(
			`main.startChain<0>
    grows 32 bytes, calls main.chain0<0>
        grows 48 bytes, calls main.chainEnd<0>
            grows 1008 bytes
            %d bytes over limit
    grows 32 bytes, calls main.chain2<0>
        grows 80 bytes, calls main.chainEnd<0>
            grows 1008 bytes
            %d bytes over limit
`, 32+48+1008-limit, 32+80+1008-limit),
		"main.startRec": `main.startRec<0>

	expectNoUpdate("unchanged foo")

	m.Set(barID, Failure, pod)
	expectNoUpdate("unchanged bar")

	// Changed results should send an update.
	m.Set(fooID, Failure, pod)
	expectUpdate(Update{fooID, Failure, pod.UID}, "changed foo")

	m.Set(barID, Success, pod)
	expectUpdate(Update{barID, Success, pod.UID}, "changed bar")
}

func TestResult_ToPrometheusType(t *testing.T) {
	tests := []struct {
		name     string

            task ok
        """

        configurationCache = newConfigurationCacheFixture()
    }

    @Issue("https://github.com/gradle/gradle/issues/23273")
    def "invalidates cache if remote script was changed"() {
        when:
        configurationCacheRun 'ok'

        then:
        configurationCache.assertStateStored()

        when:
        scriptFile << """
            print 'update remote script'

// based signing. It's used by the signing controller.
type CertificateAuthority struct {
	// RawCert is an optional field to determine if signing cert/key pairs have changed
	RawCert []byte
	// RawKey is an optional field to determine if signing cert/key pairs have changed
	RawKey []byte

	Certificate *x509.Certificate
	PrivateKey  crypto.Signer
}

// Sign signs a certificate request, applying a SigningPolicy and returns a DER

      if (!params) {
        quantized_.erase(op);
        continue;
      }
      changed |= SetBiasParamsWithAdjustments(op, bias_operand_idx,
                                              non_bias_operand_indices, params);
    }
  }

  return changed;
}

// Finalizes the arguments and result states in the function.
void QuantizationDriver::Finalize() {