testRequest.encode(buffer, 0);
            });

            assertTrue(exception.getMessage().contains("Wrong size calculation"));
        }
    }

    // Test implementation classes
    private static class TestServerMessageBlock2Request extends ServerMessageBlock2Request<TestServerMessageBlock2Response> {
        private TestServerMessageBlock2Response testResponse;
        private int testSize = 64;

        assertDoesNotThrow(() -> {
            new MsrpcLookupSids(null, testSids);
        });
    }

    @Test
    void constructor_shouldThrowExceptionWithNullSids() {
        // Act & Assert - Null SID array causes NPE when accessing length
        assertThrows(NullPointerException.class, () -> {
            new MsrpcLookupSids(mockPolicyHandle, null);
        });
    }

    @Test

        annotations = new ArrayList<>();
        for (Annotation a : classOrMethod.getDeclaredAnnotations()) {
          /*
           * We avoid reflecting on NullMarked because its @Target(..., MODULE) causes problems
           * under JDK 8.
           */
          if (!(a instanceof NullMarked)
              && a.annotationType().isAnnotationPresent(TesterAnnotation.class)) {
            annotations.add(a);

        UnsupportedOperationException ex = assertThrows(UnsupportedOperationException.class, iterator::remove);
        assertEquals("Not supported", ex.getMessage());
    }

    @Test
    @DisplayName("Null delegate causes NPE")
    void nullDelegate() {
        assertThrows(NullPointerException.class, () -> {
            new FileEntryAdapterIterator(parent, null, null) {
                @Override

      public void handlePotentialDeadlock(PotentialDeadlockException e) {
        logger.get().log(Level.SEVERE, "Detected potential deadlock", e);
      }
    },

    /**
     * Disables cycle detection. This option causes the factory to return unmodified lock
     * implementations provided by the JDK, and is provided to allow applications to easily
     * parameterize when cycle detection is enabled.
     *

    }

    // Helper methods for creating mock objects
    private SearchRequestParams createMockSearchRequestParams() {
        return new MockSearchRequestParams();
    }

    // Mock classes
    private static class MockFessConfig extends FessConfig.SimpleImpl {
        private static final long serialVersionUID = 1L;

        @Override
        public String getCookieSearchParameterRequiredKeys() {

        uniqueQueries.add("filetype:others");

        for (String query : uniqueQueries) {
            assertTrue(testFacetInfo.getAddedQueries().contains(query));
        }
    }

    // Helper classes for testing
    private static class TestFacetInfo extends FacetInfo {
        private final List<String> addedQueries = new ArrayList<>();

        @Override
        public void addQuery(String s) {

    * Because pydantic data structures are just instances of classes you define; auto-completion, linting, mypy and your intuition should all work properly with your validated data.
* Validate **complex structures**:
    * Use of hierarchical Pydantic models, Python `typing`’s `List` and `Dict`, etc.

    Object writeReplace() {
    return super.writeReplace();
  }

  // This class is never actually serialized directly, but we have to make the
  // warning go away (and suppressing would suppress for all nested classes too)
  @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;

        end = srcIndex + rDataLength;
        /* Apparently readRDataWireFormat can return 0 if resultCode != 0 in
        which case this will look indefinitely. Putting this else clause around
        the loop might fix that. But I would need to see a capture to confirm.
        if (resultCode != 0) {
            srcIndex += rDataLength;
        } else {
        */