shouldError bool
	}{
		{
			name:        "valid",
			shouldError: false,
		},
		{
			name: "invalid: new runtime service fails",
			prepare: func(mock *fakeImpl) {
				mock.NewRemoteRuntimeServiceReturns(nil, errTest)
			},
			shouldError: true,
		},
		{
			name: "invalid: new image service fails",
			prepare: func(mock *fakeImpl) {
				mock.NewRemoteImageServiceReturns(nil, errTest)
			},

        delegate.resolveArtifact(artifact, moduleSources, result) >> { throw exception }
        repositoryBlacklister.isDisabled(REPOSITORY_ID) >> false

        when: 'repo is not disabled'
        access.resolveArtifact(artifact, moduleSources, result)

        then: 'resolution fails and repo is disabled'
        1 * repositoryBlacklister.tryDisableRepository(REPOSITORY_ID, { hasCause(it, exception) })

        (findRequiredKeystoreFile(false) != null) == keystoreExpected

        where:
        kind                    | enabled   | keystoreExpected
        EncryptionKind.NONE     | false     | false
        EncryptionKind.KEYSTORE | true      | true
        EncryptionKind.ENV_VAR  | true      | false
    }

    private boolean isFoundInDirectory(File startDir, byte[] toFind) {

        when: 'task fails'
        buildFile '''
            tasks.register('fail') {
                doLast { assert false }
            }
        '''
        configurationCacheFails 'fail'

        then: 'flow action reacts to build failure'
        outputContains '(red)'
        configCache.assertStateStored()

        when: 'task from cache fails'
        configurationCacheFails 'fail'

            def someMethod() {}
            apply from: "script2.gradle"
        """

        file("script2.gradle") << """
            someMethod()
        """

        when:
        fails "help"

        then:
        failure.assertHasFileName("Script '${file("script2.gradle").absolutePath}'")
        failure.assertThatCause(containsText("Could not find method someMethod()"))
    }

    bool verify_numeric = false, bool whole_model_verify = false,
    bool legacy_float_scale = true,
    const absl::flat_hash_set<std::string> &denylisted_ops = {},
    const absl::flat_hash_set<std::string> &denylisted_nodes = {},
    bool enable_variable_quantization = false,
    bool disable_per_channel_for_dense_layers = false,
    const std::optional<const tensorflow::converter::DebugOptions>

                            bool enable_numeric_verify = false,
                            bool enable_whole_model_verify = false,
                            PyObject* op_denylist = nullptr,
                            PyObject* node_denylist = nullptr,
                            bool enable_variable_quantization = false,
                            bool disable_per_channel_for_dense_layers = false,

                configurations {
                    compileFreeDebug {
                        canBeConsumed = false
                        canBeResolved = false
                    }
                    compileFreeRelease {
                        canBeConsumed = false
                        canBeResolved = false
                    }
                    compileFreeDebugPath {

	if d.trackBucket == len(d.hist) {
		return math.NaN(), math.NaN(), false
	}
	return float64(d.trackBucket) / mudDegree, float64(d.trackBucket+1) / mudDegree, true
}

// invCumulativeSum returns x such that the integral of d from -∞ to x
// is y. If the total weight of d is less than y, it returns the
// maximum of the distribution and false.
//
// Specifically, y is a cumulative duration, and invCumulativeSum

				{"tcp", "[" + addr + "%" + ifi.Name + "]:0", false},
			}...)
			ipv6LinkLocalUnicastUDPTests = append(ipv6LinkLocalUnicastUDPTests, []ipv6LinkLocalUnicastTest{
				{"udp", "[" + addr + "%" + ifi.Name + "]:0", false},
			}...)
		}
		ipv6LinkLocalUnicastTCPTests = append(ipv6LinkLocalUnicastTCPTests, []ipv6LinkLocalUnicastTest{
			{"tcp6", "[" + addr + "%" + ifi.Name + "]:0", false},
		}...)