&& this.dataDisplacement + this.dataCount >= this.totalDataCount) {
            this.hasMore = false;
        }
        return this;
    }

    /**
     * Calculates padding needed for the given offset
     * @param offset
     *            the current offset
     * @return padding size in bytes
     */
    protected int pad(final int offset) {
        final int p = offset % getPadding();

    @DisplayName("Should handle buffer boundary conditions")
    void testBufferBoundaryConditions() throws Exception {
        // Given - notification exactly at buffer end
        byte[] buffer = new byte[104]; // Exact size needed
        int offset = 0;

        setHeaderStart(response, 64);

        // Write structure
        SMBUtil.writeInt2(9, buffer, offset);
        SMBUtil.writeInt2(80 - 64, buffer, offset + 2);

	case syscall.DT_REG:
		typ = 0
	case syscall.DT_DIR:
		typ = os.ModeDir
	case syscall.DT_LNK:
		typ = os.ModeSymlink
	default:
		// Skip all other file types. Revisit if/when this code needs
		// to handle such files, MinIO is only interested in
		// files and directories.
		typ = unexpectedFileMode
	}

	nameBuf := (*[unsafe.Sizeof(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0]))

        }

        @Test
        @DisplayName("Should decode minimum buffer size")
        void testDecodeMinimumBufferSize() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[12]; // Exact size needed
            SMBUtil.writeInt4(3, buffer, 0);
            SMBUtil.writeInt4(4096, buffer, 4);
            SMBUtil.writeInt4(12288, buffer, 8);

            int bytesDecoded = response.decode(buffer, 0, buffer.length);

		}
	} else {
		cfg.RRS.Parity = defaultRRSParity
		if setDriveCount == 1 {
			cfg.RRS.Parity = 0
		}
	}

	// Validation is done after parsing both the storage classes. This is needed because we need one
	// storage class value to deduce the correct value of the other storage class.
	if err = validateParity(cfg.Standard.Parity, cfg.RRS.Parity, setDriveCount); err != nil {
		return Config{}, err
	}

  }

  /**
   * If the client closes the connection while it is consuming the response body, attempts to peek
   * or read the trailers should throw.
   *
   * This test needs to make two interventions to prevent OkHttp from reading the entire response
   * body, which it will attempt to do otherwise:
   *
   *  * Don't cache the response. The cache will try to read the entire response body so that it

    this.sortedDelegate = Collections.unmodifiableSortedSet(sortedDelegate);
  }

  @Override
  public Comparator<? super E> comparator() {
    return sortedDelegate.comparator();
  }

  @Override // needed to unify SortedIterable and Collection iterator() methods
  public UnmodifiableIterator<E> iterator() {
    return super.iterator();
  }

  @Override
  public Object[] toArray() {
    /*

      stream.defaultReadObject();
      setInverse((AbstractBiMap<V, K>) requireNonNull(stream.readObject()));
    }

    @GwtIncompatible // Not needed in the emulated source.
    @J2ktIncompatible
    Object readResolve() {
      return inverse().inverse();
    }

    @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;
  }

### Crie uma classe `Enum` { #create-an-enum-class }

Importe `Enum` e crie uma subclasse que herde de `str` e de `Enum`.

Ao herdar de `str`, a documentação da API saberá que os valores devem ser do tipo `string` e poderá renderizá-los corretamente.

    all of them.

 *  Fix: Address a performance bug in `MultipartReader`. We were scanning the entire input stream
    for a delimiter when we only needed to scan enough to return a result.

 *  Fix: Don't double-compress the public suffix database. OkHttp is usually distributed in a
    compressed file (like a JAR or APK), so compressing its internal data was redundant.