response = new Smb2QueryDirectoryResponse(mockConfig, Smb2QueryDirectoryRequest.FILE_BOTH_DIRECTORY_INFO);

        byte[] buffer = new byte[512];
        int bufferIndex = 0;

        // Verify results is initially null
        assertNull(response.getResults());

        // Set structure size to 9
        SMBUtil.writeInt2(9, buffer, bufferIndex);
        // Set buffer offset

        assertTrue(mockService.unregisterWitness(regId));
        assertEquals(0, mockService.getRegistrationCount());
        assertFalse(mockService.hasRegistration(regId));

        // 5. Verify heartbeat fails after unregistration
        assertFalse(mockService.processHeartbeat(regId, 4));
    }

    /**
     * Test error conditions and edge cases
     */
    @Test

        logger.logAuthentication(true, "user", "DOMAIN", "192.168.1.1");

        logger.setJsonLoggingEnabled(false);
        logger.logAuthentication(true, "user2", "DOMAIN", "192.168.1.2");

        // Verify that both events were logged
        Map<EventType, Long> stats = logger.getStatistics();
        assertEquals(Long.valueOf(2), stats.get(EventType.AUTHENTICATION_SUCCESS), "Should have 2 authentication success events");
    }

        for (int i = 0; i < count; i++) {
            elements[i] = String.valueOf(i);
        }
        String result = StringUtil.join(",", elements);

        // Verify result contains all elements
        String[] parts = result.split(",");
        assertEquals(count, parts.length);
        for (int i = 0; i < count; i++) {
            assertEquals(String.valueOf(i), parts[i]);

URLs are abstract:

        @Test
        @DisplayName("Should maintain exception hierarchy")
        void testExceptionHierarchy() {
            TransportException exception = new TransportException("Test");

            // Verify the exception hierarchy
            assertTrue(exception instanceof IOException);
            assertTrue(exception instanceof Exception);
            assertTrue(exception instanceof Throwable);
        }

Your code needs to run on [all versions of Java that Gradle supports](platforms/documentation/docs/src/docs/userguide/releases/compatibility.adoc) and across all supported operating systems (macOS, Windows, Linux). The Gradle CI system will verify this, but here are some pointers that will avoid surprises:

* Be careful when using features introduced in Java 9 or later. Some parts of Gradle still need to run on Java 8.

        FuzzyQuery fuzzyQuery = new FuzzyQuery(term);

        QueryBuilder result = fuzzyQueryCommand.convertFuzzyQuery(context, fuzzyQuery, 1.0f);
        assertNotNull(result);

        // Verify that the query was processed successfully
        assertTrue(result instanceof FuzzyQueryBuilder);
        FuzzyQueryBuilder fqb = (FuzzyQueryBuilder) result;
        assertEquals("title", fqb.fieldName());

    AccessibleObject.setAccessible(methods, true);
    for (Method method : methods) {
      // Interfaces can have default methods that aren't abstract.
      // No need to verify them.
      // Can't check isDefault() for Android compatibility.
      if (!Modifier.isAbstract(method.getModifiers())) {
        continue;
      }
      // The interface could be package-private or private.

    * Add `-prof async` to see hotspots.
* Have your benchmarks peer-reviewed.

### Don't

* Blindly believe the numbers that your microbenchmark produces but verify them by measuring e.g. with `-prof perfasm`.
* Run more threads than your number of CPU cores (in case you run multi-threaded microbenchmarks).