this.hashAlgorithm = "sha1"
          this.hash = pin.substring("sha1/".length).decodeBase64() ?: throw IllegalArgumentException("Invalid pin hash: $pin")
        }
        pin.startsWith("sha256/") -> {
          this.hashAlgorithm = "sha256"
          this.hash = pin.substring("sha256/".length).decodeBase64() ?: throw IllegalArgumentException("Invalid pin hash: $pin")
        }

 *
 * <p>It also handles the exclusion of search words based on certain criteria and manages the
 * maximum length of analyzed content.</p>
 *
 * <p>Methods in this class may throw SuggesterException in case of failures during the parsing process.</p>
 *
 * <p>Usage example:</p>
 * <pre>
 * {@code
 * DefaultContentsParser parser = new DefaultContentsParser();

            this.writeSize = sendBufferSize;
            this.writeSizeFile = sendBufferSize;
            return;
        }

        this.openFlags &= ~(SmbConstants.O_CREAT | SmbConstants.O_TRUNC); /* in case we close and reopen */
        this.writeSize = sendBufferSize - 70;

        this.useNTSmbs = th.hasCapability(SmbConstants.CAP_NT_SMBS);
        if (!this.useNTSmbs) {
            log.debug("No support for NT SMBs");

     */
    protected final int initChannelBindingPolicy(String policy) {
        if (policy == null)
            return 1; // preferred
        switch (policy.toLowerCase()) {
        case "disabled":
            return 0;
        case "required":
            return 2;
        default:
            return 1; // preferred
        }
    }

    @Override
    public boolean isUseDirectoryLeasing() {

   * task.
   *
   * <p>Consider using the {@link #newFixedDelaySchedule} and {@link #newFixedRateSchedule} factory
   * methods, these provide {@link Scheduler} instances for the common use case of running the
   * service with a fixed schedule. If more flexibility is needed then consider subclassing {@link
   * CustomScheduler}.
   *
   * @author Luke Sandberg
   * @since 11.0
   */

            SMBUtil.writeInt4(chunkBytes, buffer, 4);
            SMBUtil.writeInt4(totalBytes, buffer, 8);
            return buffer;
        }
    }

    @Nested
    @DisplayName("Edge Case Tests")
    class EdgeCaseTests {

        @Test
        @DisplayName("Should handle maximum values")
        void testMaximumValues() throws SMBProtocolDecodingException {

    @DisplayName("readPacketType with special stream returning -1 should return -1")
    void testReadPacketTypeSpecialStream() throws IOException {
        // Create a mock stream that returns exactly -1 on first read (special case)
        when(mockInputStream.read(any(byte[].class), anyInt(), anyInt())).thenReturn(-1); // Immediate EOF

        byte[] buffer = new byte[10];

        // The readn method will return 0 when stream returns -1

            current = current.getCause();
        }
        return buf.toString();
    }

    /**
     * Checks if a checkbox value represents an enabled state.
     * This method considers "on" and "true" (case-insensitive) as enabled values.
     *
     * @param value the checkbox value to check
     * @return true if the value represents an enabled checkbox, false otherwise
     */

    assertThat(Chars.saturatedCast(Long.MIN_VALUE)).isEqualTo(LEAST);
  }

  private void assertCastFails(long value) {
    try {
      Chars.checkedCast(value);
      fail("Cast to char should have failed: " + value);
    } catch (IllegalArgumentException ex) {
      assertWithMessage("%s not found in exception text: %s", value, ex.getMessage())
          .that(ex.getMessage().contains(String.valueOf(value)))

      Table<String, Integer, Character> table = makeTable();
      populateTable(table);
      return table.rowMap();
    }

    // `protected` to work around b/320650932 / KT-67447 runtime crash
    protected final void populateTable(Table<String, Integer, Character> table) {
      table.put("foo", 1, 'a');
      table.put("bar", 1, 'b');
      table.put("foo", 3, 'c');
    }

    @Override