public void testForEachUnknownOrder() {
    List<E> elements = new ArrayList<>();
    collection.forEach(elements::add);
    Helpers.assertEqualIgnoringOrder(asList(createSamplesArray()), elements);
  }

  @CollectionFeature.Require(KNOWN_ORDER)
  public void testForEachKnownOrder() {
    List<E> elements = new ArrayList<>();
    collection.forEach(elements::add);

  @CollectionSize.Require(absent = ZERO)
  public void testToArray_tooSmall() {
    Object[] actual = getList().toArray(new Object[0]);
    assertArrayEquals("toArray(tooSmall) order should match list", createOrderedArray(), actual);
  }

  public void testToArray_largeEnough() {
    Object[] actual = getList().toArray(new Object[getNumElements()]);
    assertArrayEquals("toArray(largeEnough) order should match list", createOrderedArray(), actual);

    @Mock
    private Principal mockPrincipal;

    private NtlmHttpServletRequest ntlmRequest;

    @BeforeEach
    void setUp() {
        // Create a new NtlmHttpServletRequest with mocked dependencies before each test
        ntlmRequest = new NtlmHttpServletRequest(mockRequest, mockPrincipal);
    }

    /**
     * Test method for {@link NtlmHttpServletRequest#getRemoteUser()}.

            }

            @Override
            public ExtendedPluginDescriptor build() {
                return new ExtendedPluginDescriptor(this);
            }
        }
    }

    @Test
    void testExtendedPluginDescriptor() {
        ExtendedPluginDescriptor.Builder builder = new ExtendedPluginDescriptor.Builder();
        // make sure to call the subclasses' builder methods first, otherwise fluent API would not work

        when(transport.isSMB2()).thenThrow(new SmbException("negotiation missing"));
        assertFalse(handle.isSMB2());
    }

    @Test
    @DisplayName("Null treeConnection throws NPE")
    void constructorNullTreeConnection() {
        // Null treeConnection throws NPE when acquire() is called
        assertThrows(NullPointerException.class, () -> new SmbTreeHandleImpl(resourceLoc, null));
    }

    @Test

    //                                         Actually Crud
    //                                         -------------
    /**
     * Creates a new role item.
     *
     * @param form the create form containing the new item data
     * @return HTML response redirecting to the list page after creation
     */
    @Execute
    @Secured({ ROLE })

            return updateEntity(source, result);
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }

    protected <RESULT extends FileAuthentication> RESULT updateEntity(Map<String, Object> source, RESULT result) {
        return result;

      // This can replace an existing character (the builder is re-usable).
      replacementMap.put(c, replacement);
      return this;
    }

    /** Returns a new escaper based on the current state of the builder. */
    public Escaper build() {
      return new ArrayBasedCharEscaper(replacementMap, safeMin, safeMax) {
        private final char @Nullable [] replacementChars =

    void testConcurrentLogging() throws InterruptedException {
        int threadCount = 10;
        int eventsPerThread = 100;
        Thread[] threads = new Thread[threadCount];

        for (int i = 0; i < threadCount; i++) {
            final int threadId = i;
            threads[i] = new Thread(() -> {
                for (int j = 0; j < eventsPerThread; j++) {

    for (ImmutableList<Class<?>> sig : allSignatures(Object.class)) {
      Method checkArgumentMethod =
          Preconditions.class.getMethod("checkNotNull", sig.toArray(new Class<?>[] {}));
      checkArgumentMethod.invoke(
          null /* static method */, getParametersForSignature(new Object(), sig));

      Object[] failingParams = getParametersForSignature(null, sig);
      InvocationTargetException ite =
          assertThrows(