assertEquals("q", outputs2[1]);
        assertEquals("r", outputs2[2]);
    }

    @Test
    public void test_defensiveCopy_nullArrays() {
        // Test that defensive copy handles null arrays correctly
        SynonymItem item1 = new SynonymItem(1, new String[] { "a" }, new String[] { "x" });

        // Set to null
        item1.setNewInputs(null);
        item1.setNewOutputs(null);

        // Ensure proper cleanup before delete
        file.close();
        Thread.sleep(500); // Give more time for handle release
        System.gc(); // Force garbage collection
        Thread.sleep(200);

        // Delete using a completely new context to avoid handle issues
        CIFSContext deleteContext = createFreshContext();

            // When
            SmbWatchHandle watchHandle = mockResource.watch(filter, true);

            // Then
            assertNotNull(watchHandle, "Watch handle should not be null");
            assertSame(mockWatchHandle, watchHandle, "Should return expected watch handle");
        }
    }

    @Nested
    @DisplayName("Security Operations Tests")
    class SecurityOperationsTests {

        @Test

import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import org.jspecify.annotations.Nullable;

/**
 * Abstract {@link Hasher} that handles converting primitives to bytes using a scratch {@code
 * ByteBuffer} and streams all bytes to a sink to compute the hash.
 *
 * @author Colin Decker
 */
abstract class AbstractByteHasher extends AbstractHasher {

        // Configure transport to throw exception on release
        Mockito.doThrow(new RuntimeException("Test exception")).when(mockTransport).release();

        session.acquire();

        // Should handle exceptions gracefully
        assertDoesNotThrow(() -> session.release());
    }

    /**
     * Test AutoCloseable pattern
     */
    @Test
    @Timeout(5)

    * Numbers (`int`, `float`) with min and max values, etc.

* Validation for more exotic types, like:
    * URL.
    * Email.
    * UUID.
    * ...and others.

All the validation is handled by the well-established and robust **Pydantic**.

### Security and authentication { #security-and-authentication }

Security and authentication integrated. Without any compromise with databases or data models.

			}
		}
		if closer, ok := enc.(expfmt.Closer); ok {
			closer.Close()
		}
	})
}

func metricsBucketHandler() http.Handler {
	return metricsHTTPHandler(bucketCollector, "handler.MetricsBucket")
}

func metricsServerHandler() http.Handler {
	registry := prometheus.NewRegistry()

	// Report all other metrics
	logger.CriticalIf(GlobalContext, registry.Register(clusterCollector))

        }
    }

    /**
     * Processes all thread information and sends it to the provided consumer.
     *
     * @param writer the consumer that will handle each line of thread dump output
     */
    public static void processThreadDump(final Consumer<String> writer) {
        for (final Map.Entry<Thread, StackTraceElement[]> entry : Thread.getAllStackTraces().entrySet()) {

      actions += { stream -> stream.sink.close() }
    }

  fun sleep(
    duration: Long,
    unit: TimeUnit,
  ) = apply {
    actions += { Thread.sleep(unit.toMillis(duration)) }
  }

  override fun handle(socket: Socket) {
    val task = serviceSocketTask(socket.asBufferedSocket())
    results.add(task)
    task.run()
  }

  /** Returns a task that processes both request and response from [socket]. */

    }
  }

  public static void main(String... args) throws Exception {
    new RequestBodyCompression().run();
  }

  /** This interceptor compresses the HTTP request body. Many webservers can't handle this! */
  static class GzipRequestInterceptor implements Interceptor {
    @Override public Response intercept(Chain chain) throws IOException {
      Request originalRequest = chain.request();