}

    @Override
    BoundType typeAsLowerBound() {
      return BoundType.CLOSED;
    }

    @Override
    BoundType typeAsUpperBound() {
      return BoundType.OPEN;
    }

    @Override
    Cut<C> withLowerBoundType(BoundType boundType, DiscreteDomain<C> domain) {
      switch (boundType) {
        case CLOSED:
          return this;
        case OPEN:

        RdmaMemoryRegion region;

        while ((region = availableSendRegions.poll()) != null) {
            region.close();
            totalReleased.incrementAndGet();
        }

        while ((region = availableReceiveRegions.poll()) != null) {
            region.close();
            totalReleased.incrementAndGet();
        }

  }

  private final class Out extends TestOutputStream {

    Out() throws IOException {
      super(bytes, options);
    }

    @Override
    public void close() throws IOException {
      outputStreamClosed = true;
      super.close();
    }
  }

import jcifs.dcerpc.rpc.policy_handle;

/**
 * Microsoft RPC SAM close handle request.
 * This class implements the SAMR close handle operation.
 *
 * @author mbechler
 */
public class MsrpcSamrCloseHandle extends samr.SamrCloseHandle {

    /**
     * Creates a new request to close a SAM handle.
     *
     * @param handle the policy handle to close
     */
    public MsrpcSamrCloseHandle(final policy_handle handle) {

 *
 * @author mbechler
 *
 */
public interface SmbRandomAccess extends DataOutput, DataInput, AutoCloseable {

    /**
     * Close the file
     *
     * @throws SmbException if an I/O error occurs during close
     */
    @Override
    void close() throws SmbException;

    /**
     * Read a single byte from the current position
     *
     * @return read byte, -1 if EOF

				t.Fatalf("unable to write previously parsed content: %s", err)
			}
		}
		if err := w.Close(); err != nil {
			t.Fatalf("Unable to write archive: %s", err)
		}

		// TODO: We may want to check if the archive roundtrips. This would require
		// taking into account addition of the two zero trailer blocks that Writer.Close
		// appends.
	})

import jcifs.smb1.dcerpc.rpc;

/**
 * MS-RPC SAMR close handle operation.
 *
 * This class implements the SAMR CloseHandle operation for releasing
 * Security Account Manager (SAM) handles.
 */
public class MsrpcSamrCloseHandle extends samr.SamrCloseHandle {

    /**
     * Creates a new request to close a SAM handle.
     *
     * @param policyHandle the policy handle to close
     */

                  return true;
                }
                return false;
              }
            },
            isParallel)
        .onClose(streamA::close)
        .onClose(streamB::close);
  }

  /**
   * Invokes {@code consumer} once for each pair of <i>corresponding</i> elements in {@code streamA}

     */
    <T extends SmbTransport> T unwrap(Class<T> type);

    /**
     *
     * {@inheritDoc}
     *
     * @see java.lang.AutoCloseable#close()
     */
    @Override
    void close();

    /**
     * Gets the address of the remote SMB server.
     *
     * @return the connected address
     */
    Address getRemoteAddress();

    /**

            return false;
        }
    }

    /**
     * Get cluster name for witness discovery
     *
     * @param serverAddress the server address
     * @return cluster name or null
     */
    private String getClusterName(InetAddress serverAddress) {
        // Simple implementation - could be enhanced with proper cluster discovery
        String hostname = serverAddress.getHostName();