p += w;
        }
        log.debug("Write " + length + " took " + ( System.currentTimeMillis() - start ));
    }


    static final void randBytes ( Random r, byte[] buffer ) {
        // regular nextBytes is not reproducible if the reads are not aligned
        for ( int i = 0; i < buffer.length; i++ ) {
            buffer[ i ] = (byte) r.nextInt(256);
        }

    }

                if (to == Bound.NO_BOUND) {
                  extremeValues.remove(extremeValues.size() - 1);
                  extremeValues.remove(extremeValues.size() - 1);
                }

                // the regular values should be visible after filtering
                List<E> allEntries = new ArrayList<>();
                allEntries.addAll(extremeValues);
                allEntries.addAll(normalValues);

   * that pass this regex are valid -- only a performance hit is incurred, not a semantics bug.
   */
  @GwtIncompatible // regular expressions
  static final
  java.util.regex.Pattern
      FLOATING_POINT_PATTERN = fpPattern();

  @GwtIncompatible // regular expressions
  private static
  java.util.regex.Pattern
      fpPattern() {
    /*

   * that pass this regex are valid -- only a performance hit is incurred, not a semantics bug.
   */
  @GwtIncompatible // regular expressions
  static final
  java.util.regex.Pattern
      FLOATING_POINT_PATTERN = fpPattern();

  @GwtIncompatible // regular expressions
  private static
  java.util.regex.Pattern
      fpPattern() {
    /*

    return new CompositionPredicate<>(predicate, function);
  }

  /**
   * Returns a predicate that evaluates to {@code true} if the {@code CharSequence} being tested
   * contains any match for the given regular expression pattern. The test used is equivalent to
   * {@code Pattern.compile(pattern).matcher(arg).find()}
   *
   * @throws IllegalArgumentException if the pattern is invalid
   * @since 3.0
   */

                    .details(type + " aliases must match the following regular expression: " + ALIAS_REGEX)
                    .solution("Make sure the alias matches the " + ALIAS_REGEX + " regular expression")));
        }
    }

    @Override
    public void bundle(String alias, List<String> aliases) {

                @TaskAction action() {
                    fs.delete {
                        delete(missingFile)
                        delete(missingDir)
                    }
                    regularFile.text = "regular file"
                    new File(singleFileInDir, "file.txt").text = "single file in dir"
                    new File(manyFilesInDir, "file-1.txt").text = "file #1 in dir"

				if !isExistingSocket("unix://" + theSocket) {
					t.Fatalf("isExistingSocket(%q) gave unexpected result. Should have been true, instead of false", theSocket)
				}
			},
		},
		{
			name: "Regular file is not a domain socket",
			proc: func(t *testing.T) {
				tmpFile, err := os.CreateTemp("", tempPrefix)
				if err != nil {
					t.Fatalf("unexpected error by TempFile: %v", err)
				}

		}
		if len(rule.APIGroups) > 0 || len(rule.Resources) > 0 || len(rule.ResourceNames) > 0 {
			allErrs = append(allErrs, field.Invalid(fldPath.Child("nonResourceURLs"), rule.NonResourceURLs, "rules cannot apply to both regular resources and non-resource URLs"))
		}
		return allErrs
	}

	if len(rule.APIGroups) == 0 {
		allErrs = append(allErrs, field.Required(fldPath.Child("apiGroups"), "resource rules must supply at least one api group"))

            "Declare the task as untracked by using Task.doNotTrackState(). " +
            getDisableStateTrackingLink())
        failureHasCause("java.io.IOException: Cannot snapshot ${namedPipe}: not a regular file")
    }

    @Requires(UnitTestPreconditions.FilePermissions)
    def "tracked task consuming unreadable content fails"() {
        def rootDir = file("build/root")