public String getName() {
    return name;
  }

  // Test suppression

  private final Set<Method> suppressedTests = new HashSet<>();

  /**
   * Prevents the given methods from being run as part of the test suite.
   *
   * <p>Note: in principle this should never need to be used, but it might be useful if the
   * semantics of an implementation disagree in unforeseen ways with the semantics expected by a

        totalAllocated.incrementAndGet();

        log.trace("Registered resource: {} ({})", resourceId, resource.getClass().getSimpleName());

        return resourceId;
    }

    /**
     * Mark a resource as closed
     *
     * @param resourceId the resource ID
     */
    public void markClosed(String resourceId) {
        ResourceHolder holder = activeResources.get(resourceId);

            assertEquals(2048, response.getCount());
            assertEquals(1024, response.getRemaining());
        }

        @Test
        @DisplayName("Should handle response as part of ServerMessageBlock2")
        void testAsServerMessageBlock2Response() {
            // Verify inheritance
            assertTrue(response instanceof ServerMessageBlock2);

 * even when the result of the comparison is already known from previous {@code .compare} calls.
 * That can be expensive.
 *
 * @author Mark Davis
 * @author Kevin Bourrillion
 * @since 2.0
 */
@GwtCompatible
public abstract class ComparisonChain {
  private ComparisonChain() {}

                        currentDirectiveList.add(currentDirective);
                        continue;
                    }

                    // Mark that we've seen group-member records
                    isGroupRecordStarted = true;

                    // Try to parse as Disallow directive
                    value = getValue(DISALLOW_RECORD, line);

            @Override
            int readHeaderWireFormat(byte[] buffer, int bufferIndex) {
                return 33;
            }
        };
        // Set command to NT_CREATE_ANDX and mark extended
        resp.command = ServerMessageBlock.SMB_COM_NT_CREATE_ANDX;
        resp.isExtended = true;

        byte[] buf = new byte[256];
        buf[33] = 34; // baseline wordCount reported by server

    .build();
```

With a server that holds a certificate and a client that trusts it we have enough for an HTTPS
handshake. The best part of this example is that we don't need to make our test code insecure with a
a fake `HostnameVerifier` or `X509TrustManager`.

Certificate Authorities
-----------------------

        }
    }

    /**
     * @return the resolveHashes
     */
    @Override
    public boolean isResolveHashes() {
        return this.resolveHashes;
    }

    /**
     * Mark this referral as intermediate (requires further resolution)
     */
    public void intermediate() {
        this.intermediate = true;
    }

    /**
     * @return the intermediate
     */

    public void destroy() throws DestroyFailedException {
        if (!destroyed) {
            boolean failedToDestroy = false;
            Exception destroyException = null;

            try {
                // Mark as destroyed first to prevent further operations
                destroyed = true;

                // Try to destroy master key if it implements Destroyable
                if (masterKey instanceof Destroyable) {

        // Assert: overloads consistent
        assertArrayEquals(viaHash, viaPassword, "Both overloads must compute same NTLMv2 key");

        // Changing domain should change the key (domain is part of MAC input)
        byte[] differentDomain = NtlmUtil.nTOWFv2("DOMAIN", user, password);
        assertFalse(Arrays.equals(viaPassword, differentDomain), "Different domain should produce a different key");
    }