public final boolean readBoolean() throws SmbException {
        if (read(tmp, 0, 1) < 0) {
            throw new SmbException("EOF");
        }
        return tmp[0] != (byte) 0x00;
    }

    @Override
    public final byte readByte() throws SmbException {
        if (read(tmp, 0, 1) < 0) {
            throw new SmbException("EOF");
        }
        return tmp[0];
    }

    @Override

                // to be processed in the outer catch block
                throw e;
            } catch (RuntimeException e) {
                throw new PluginExecutionException(mojoExecution, project, e);
            }
        } catch (MavenException e) {
            throw e;
        } catch (PluginContainerException e) {
            mojoExecutionListener.afterExecutionFailure(

      throw new Error();
    } catch (AssertionFailedError expected) {
    }

    try {
      assertContentsInOrder(list, "a", "c", "b");
      throw new Error();
    } catch (AssertionFailedError expected) {
    }

    try {
      assertContentsInOrder(list, "a", "B", "c");
      throw new Error();
    } catch (AssertionFailedError expected) {
    }
  }

  public void testAssertContains() {

      throw new Error();
    } catch (AssertionFailedError expected) {
    }

    try {
      assertContentsInOrder(list, "a", "c", "b");
      throw new Error();
    } catch (AssertionFailedError expected) {
    }

    try {
      assertContentsInOrder(list, "a", "B", "c");
      throw new Error();
    } catch (AssertionFailedError expected) {
    }
  }

  public void testAssertContains() {

        if (token.length <= 0) {
            throw new PACDecodingException("Empty kerberos token");
        }

        byte[] content;
        try (ASN1InputStream stream = new ASN1InputStream(token)) {
            content = ASN1Util.readUnparsedTagged(0, 0x8000, stream);
        } catch (IOException e) {
            throw new PACDecodingException("Malformed kerberos token", e);
        }

                  throws Throwable {
                throw exception;
              }
            });
    T wrapper = wrapperFunction.apply(proxy);
    try {
      method.invoke(wrapper, getParameterValues(method));
      fail(method + " failed to throw exception as is.");
    } catch (InvocationTargetException e) {
      if (exception != e.getCause()) {
        throw new RuntimeException(e);
      }

        // Fail 3 times to open circuit
        for (int i = 0; i < 3; i++) {
            final int index = i;
            try {
                circuitBreaker.executeWithCircuitBreaker(() -> {
                    throw new RuntimeException("Test failure " + index);
                });
                fail("Should have thrown exception");
            } catch (CIFSException e) {
                // Expected
            }
        }

        throw new UnsupportedOperationException("Cannot get available versions in this test case");
    }

    @Override
    public List<ArtifactVersion> retrieveAvailableVersionsFromDeploymentRepository(
            Artifact artifact, ArtifactRepository localRepository, ArtifactRepository remoteRepository)
            throws ArtifactMetadataRetrievalException {

            return compressLZ77Huffman(data, offset, length);

        case COMPRESSION_LZNT1:
            throw new CIFSException("LZNT1 compression not yet implemented");

        case COMPRESSION_PATTERN_V1:
            throw new CIFSException("Pattern_V1 compression not yet implemented");

        default:
            throw new CIFSException("Unknown compression algorithm: " + algorithm);
        }
    }

    @Override

     */
    public String validatePath(String path) throws SmbException {
        if (path == null || path.isEmpty()) {
            throw new SmbException("Path cannot be null or empty");
        }

        // Check length
        if (path.length() > maxPathLength) {
            throw new SmbException("Path exceeds maximum length: " + path.length() + " > " + maxPathLength);
        }

        // Check for null bytes