}

    @Test
    void testReadTagNumber_HighTag() throws IOException {
        // High tag number (31)
        InputStream s = new ByteArrayInputStream(new byte[] { 0x1F });
        int tagNo = ASN1Util.readTagNumber(s, 0x1F);
        assertEquals(31, tagNo);
    }

    @Test
    void testReadTagNumber_MultiByte() throws IOException {
        // Multi-byte tag (e.g., 80)

        // Verify witness service is authorized
        if (!isAuthorizedWitnessServer(witnessServer)) {
            throw new SecurityException("Unauthorized witness server: " + witnessServer);
        }
    }
    
    public void validateNotification(WitnessNotification notification) throws SecurityException {

    void testGetByNameWithLocalhost() throws UnknownHostException {
        // When
        Address address = nameServiceClient.getByName("localhost");

        // Then
        assertNotNull(address, "Should return address for localhost");
    }

    @Test
    @DisplayName("Should handle IP address in getByName")
    void testGetByNameWithIPAddress() throws UnknownHostException {
        // When

     * @param wagon
     * @param repository
     *
     * @throws ConnectionException
     * @throws AuthenticationException
     */
    private void connectWagon(Wagon wagon, ArtifactRepository repository)
            throws ConnectionException, AuthenticationException {
        // MNG-5509
        // See org.eclipse.aether.connector.wagon.WagonRepositoryConnector.connectWagon(Wagon)
        if (legacySupport.getRepositorySession() != null) {

     * Establish RDMA connection
     */
    public abstract void connect() throws IOException;
    
    /**
     * Send data using RDMA
     */
    public abstract void send(ByteBuffer data, RdmaMemoryRegion region) throws IOException;
    
    /**
     * Receive data using RDMA  
     */
    public abstract ByteBuffer receive(int timeout) throws IOException;
    
    /**
     * Perform RDMA read operation

  /**
   * Guaranteed to throw an exception and leave the underlying data unmodified.
   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final void add(@ParametricNullness E e) {
    throw new UnsupportedOperationException();
  }

  /**

    verifyThreadWasNotInterrupted();
  }

  public void testFailed() throws Exception {
    Exception e = new Exception();
    TrustedListenableFutureTask<Integer> task =
        TrustedListenableFutureTask.create(
            new Callable<Integer>() {
              @Override
              public Integer call() throws Exception {
                throw e;
              }
            });
    task.run();

   *
   * @throws TimeoutException if this thread does not offer a response within a reasonable amount of
   *     time
   * @throws AssertionFailedError if the given method name does not match the name of the method
   *     this thread has called most recently
   */
  private Response getResponse(String methodName) throws Exception {
    Response response = responseQueue.poll(TIMEOUT_MILLIS, MILLISECONDS);

     * @param maxSize maximum allowed size
     * @throws SmbException if validation fails
     */
    public void validateBuffer(byte[] buffer, int expectedSize, int maxSize) throws SmbException {
        totalValidations.incrementAndGet();

        if (buffer == null) {
            failedValidations.incrementAndGet();
            throw new SmbException("Response buffer is null");
        }

        }
    }

    /**
     * Establishes a connection to the SMB server.
     *
     * @throws SmbException if the connection fails
     */
    public void connect() throws SmbException {
        try {
            super.connect(RESPONSE_TIMEOUT);
        } catch (final TransportException te) {
            throw new SmbException("Failed to connect: " + address, te);
        }
    }

    @Override