if (!entry.isDirectory()) {
                    final String[] names = StreamUtil.split(entry.getName(), "/")
                            .get(stream -> stream.filter(s -> !"..".equals(s)).toArray(n -> new String[n]));
                    if (names.length < 2) {
                        continue;
                    }
                    if (logger.isDebugEnabled()) {

	}

	for i, testCase := range testCases {
		data, err := xml.Marshal(testCase.name)
		expectErr := (err != nil)

		if expectErr != testCase.expectErr {
			t.Fatalf("test %v: error: expected: %v, got: %v", i+1, testCase.expectErr, expectErr)
		}

		if !testCase.expectErr {
			if !reflect.DeepEqual(data, testCase.expectedData) {

   * iterable is empty, {@code Optional.absent()} is returned.
   *
   * <p><b>{@code Stream} equivalent:</b> if the goal is to obtain any element, {@link
   * Stream#findAny}; if it must specifically be the <i>first</i> element, {@code Stream#findFirst}.
   *
   * @throws NullPointerException if the first element is null; if this is a possibility, use {@code

	defer func() {
		err = os.Remove(f.Name())
		if err != nil {
			t.Fatal(err)
		}
	}()

	rlk, err := RLockedOpenFile(f.Name())
	if err != nil {
		t.Fatal(err)
	}
	isClosed := rlk.IsClosed()
	if isClosed {
		t.Fatal("File ref count shouldn't be zero")
	}

	// Increase reference count to 2.
	rlk.IncLockRef()

	isClosed = rlk.IsClosed()
	if isClosed {
		t.Fatal("File ref count shouldn't be zero")

		if err != nil && !errors.Is(err, ft.expectedErr) {
			t.Fatalf("ToFileInfo failed due to %v", err)
		}
		if got := fi.TierFreeVersion(); got != ft.expectedFree {
			t.Fatalf("Expected free-version=%v but got free-version=%v", ft.expectedFree, got)
		}
		if ft.afterFn != nil {
			_, err = ft.afterFn(fi)
			if err != nil {
				t.Fatalf("ft.afterFn failed with err %v", err)

        this.open = false;
        if (this.input != null) {
            this.input.close();
            this.input = null;
        }

        if (this.output != null) {
            this.output.close();
            this.output = null;
        }

        try {
            if (wasOpen) {
                this.handle.close();
            } else if (this.handle != null) {

        if (StringUtil.isBlank(objectName)) {
            return StringUtil.EMPTY;
        }
        // Remove trailing slash if present
        String name = objectName;
        if (name.endsWith("/")) {
            name = name.substring(0, name.length() - 1);
        }
        final String[] values = name.split("/");
        if (values.length == 0) {
            return StringUtil.EMPTY;

  /** Flag values. */
  private val values = IntArray(COUNT)

  /** Returns -1 if unset. */
  val headerTableSize: Int
    get() {
      val bit = 1 shl HEADER_TABLE_SIZE
      return if (bit and set != 0) values[HEADER_TABLE_SIZE] else -1
    }

  val initialWindowSize: Int
    get() {
      val bit = 1 shl INITIAL_WINDOW_SIZE
      return if (bit and set != 0) values[INITIAL_WINDOW_SIZE] else DEFAULT_INITIAL_WINDOW_SIZE
    }

	sepIndex := strings.Index(byteRangeString, "-")
	if sepIndex == -1 {
		return nil, fmt.Errorf("'%s' does not have a valid range value", rangeString)
	}

	offsetBeginString := byteRangeString[:sepIndex]
	offsetBegin := int64(-1)
	// Convert offsetBeginString only if its not empty.
	if len(offsetBeginString) > 0 {
		if offsetBeginString[0] == '+' {
			return nil, fmt.Errorf("Byte position ('%s') must not have a sign", offsetBeginString)

     * @param charsetName the character encoding to use
     * @return the parsed RobotsTxt object, or null if disabled
     * @throws RobotsTxtException if a fatal I/O error occurs
     */
    public RobotsTxt parse(final InputStream stream, final String charsetName) {
        if (!enabled) {
            return null;
        }

        BufferedReader reader = null;
        try {