var closed = false

        override fun close() {
          closed = true
        }

        override fun read(
          sink: Buffer,
          byteCount: Long,
        ): Long {
          check(!closed)
          return data.read(sink, byteCount)
        }

        override fun timeout(): Timeout = Timeout.NONE
      }
    return source.buffer().asResponseBody(null, -1)
  }

  private fun newResponse(

        } catch (IOException e) {
            throw new IllegalStateException("unable to read the file " + file + " attributes", e);
        }
    }

    /**
     * Returns the files this task will check
     */
    @InputFiles
    @SkipWhenEmpty
    public FileCollection getFiles() {
        return getSources().get()
            .stream()
            .map(sourceTree -> sourceTree.matching(filesFilter))

	info = Info{
		Total:  uint64(s.Frsize) * (s.Blocks - reservedBlocks),
		Free:   uint64(s.Frsize) * s.Bavail,
		Files:  s.Files,
		Ffree:  s.Ffree,
		FSType: getFSType(s.Type),
	}
	// Check for overflows.
	// https://github.com/minio/minio/issues/8035
	// XFS can show wrong values at times error out
	// in such scenarios.
	if info.Free > info.Total {

            // requireNonNull is safe because of the containsColumn check.
            return requireNonNull(get(entry.getKey())).equals(entry.getValue());
          }
        }
        return false;
      }

      @Override
      public boolean remove(@Nullable Object obj) {
        /*
         * `o instanceof Entry` is guaranteed by `contains`, but we check it here to satisfy our
         * nullness checker.
         */

        when:
        def result = gradleRunner("licenseHeaders").buildAndFail()

        then:
        result.task(":licenseHeaders").outcome == TaskOutcome.FAILED
        assertOutputContains(result.output, "> Check failed. License header problems were found. Full details: ./build/reports/licenseHeaders/rat.xml")
        assertOutputContains(result.output, "./src/main/java/org/acme/UnknownLicensed.java")

				format.mustNotBe(FormatPAX)
			} else {
				paxHdrs[paxKey] = formatPAXTime(ts)
			}
		}
		if v, ok := h.PAXRecords[paxKey]; ok && v == formatPAXTime(ts) {
			paxHdrs[paxKey] = v
		}
	}

	// Check basic fields.
	var blk block
	v7 := blk.toV7()
	ustar := blk.toUSTAR()
	gnu := blk.toGNU()
	verifyString(h.Name, len(v7.name()), "Name", paxPath)
	verifyString(h.Linkname, len(v7.linkName()), "Linkname", paxLinkpath)

    /**
     * Validates the provided string against this structure's metadata.
     * Checks that the string length matches the expected length and that
     * null strings have a zero pointer.
     *
     * @param string the string to validate
     * @return the validated string
     * @throws PACDecodingException if validation fails
     */
    public String check(final String string) throws PACDecodingException {

     * version is a release version, a snapshot, or the first alpha version. Subsequent alphas,
     * betas and release candidates need to check the previous prelease tags.
     *
     * @param versionString the version string to check
     * @return whether fetching git tags is required
     */
    @VisibleForTesting
    static boolean needsGitTags(String versionString) {

            // When
            chunk.encode(buffer, startIndex);

            // Then
            // Check bytes before encoded area
            for (int i = 0; i < startIndex; i++) {
                assertEquals(testByte, buffer[i], "Byte at position " + i + " was modified");
            }

            // Check bytes after encoded area
            for (int i = startIndex + EXPECTED_SIZE; i < buffer.length; i++) {

        this.maxReadWriteSize = RdmaCapabilities.DEFAULT_MAX_READ_WRITE_SIZE;
        this.maxFragmentedSize = RdmaCapabilities.DEFAULT_MAX_FRAGMENTED_SIZE;
    }

    /**
     * Check if negotiation was successful
     *
     * @return true if successful, false otherwise
     */
    public boolean isSuccess() {
        return status == 0;
    }

    /**
     * Get negotiation status