* them under J2CL—or, as an unfortunate side effect, under GWT. We do still give the fields
   * themselves their proper values under GWT, since GWT's EnumMap does need the Class instance.
   *
   * Note that sometimes these fields *do* have correct values under J2CL: They will if the caller
   * calls `create(Foo.class)`, rather than `create(map)`. That's fine; we just shouldn't rely on
   * it.
   */

						// the len argument is the array/slice object
						n.High = nil
					}
				}
			}
		}
		// Note: We could also simplify slice expressions of the form s[0:b] to s[:b]
		//       but we leave them as is since sometimes we want to be very explicit
		//       about the lower bound.
		// An example where the 0 helps:
		//       x, y, z := b[0:2], b[2:4], b[4:6]
		// An example where it does not:
		//       x, y := b[:n], b[n:]

        try {
            GradleExecuter executer = createExecuter(args, flags);
            if (expectFailure) {
                // TODO(mlopatkin) sometimes it is still possible to save the configuration cache state in the event of failure.
                //  We need to figure out how to separate expected failure from the CC store failure.

ellipses syntax such as `minio server http://host{1...4}/disk{1...4}` this requirement added an additional burden to have sequential hostnames for us to make sure that we can provide horizontal distribution, however we have come across situations where sometimes this is not feasible and there are no easier alternatives without modifying /etc/hosts on the host system as root user.  Many times in airgapped deployments this is not allowed or requires audits and approvals.

MinIO server configuration file...

                executable = '${TextUtil.escapeString(AvailableJavaHomes.getJdk8().javaExecutable)}'
            }
        """
        // Test workers that die very quickly after startup can cause an unexpected stack trace sometimes
        executer.withStackTraceChecksDisabled()

        when:
        testModuleInfo('requires junit')
        testModuleClass('')

        then:
        fails "test"

import java.util.concurrent.Future

/**
 * See https://github.com/gradle/gradle-private/issues/3919
 *
 * When merging `releaseX` branch into `master`, we should only use the release note from the `master` branch,
 * but sometimes changes on release notes.md was brought to master and merged unnoticed,
 * e.g https://github.com/gradle/gradle/pull/25825
 *
 * This script is to check if there is any merge commit that brings changes from release branch to master.

        releaseLatch.countDown()

        and:
        waitForCompletionThread.join(30000)

        then:
        !waitForCompletionThread.alive
        // The main thread sometimes processes items when there are more items than threads available, so
        // we may only submit workerCount - 1 work processors, but we should never submit more than workerCount

            val buckets: List<SmallSubprojectBucket> = testCoverageAndBucket.getJSONArray("buckets").map {
                FunctionalTestBucket(it as JSONObject).toBuildTypeBucket(model.subprojects)
            }

            // Sometimes people may add new subproject into `subprojects.json`
            // in this case we have no historical test running time, so we simply add these subprojects into first available bucket

	f.Add([]byte(`\`))
	f.Add([]byte(`"broken\"" "extra" \`))

	f.Fuzz(func(t *testing.T, b []byte) {
		t.Parallel()

		if bytes.ContainsAny(b, "*?[#~%\x00{}!") {
			t.Skipf("skipping %#q: contains a sometimes-quoted character", b)
		}
		// splitPkgConfigOutput itself rejects inputs that contain unquoted
		// shell operator characters. (Quoted shell characters are fine.)

		for _, c := range b {
			if c > unicode.MaxASCII {

[[continuous_build_limitations]]
== Limitations
Under some circumstances, continuous build may not detect changes to inputs.

[[sec:continuous_build_missing_files]]
=== Creating input directories
Sometimes, creating an input directory that was previously missing does not trigger a build, due to the way file system watching works.
For example, creating the `src/main/java` directory may not trigger a build.