*/
  public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> of(E e1, E e2) {
    return copyOf(Ordering.natural(), Arrays.asList(e1, e2));
  }

  /**
   * Returns an immutable sorted multiset containing the given elements sorted by their natural
   * ordering.
   *
   * @throws NullPointerException if any element is null
   */

            final SmbFileFilter ff) throws SmbException {
        try (CloseableIterator<SmbResource> it = doEnum(root, wildcard, searchAttributes,
                fnf == null ? null : new ResourceNameFilterWrapper(fnf), ff == null ? null : new ResourceFilterWrapper(ff))) {

            final List<SmbFile> list = new ArrayList<>();
            while (it.hasNext()) {
                try (SmbResource n = it.next()) {

    }

    @Test
    @DisplayName("Test allowChain with null parameter")
    void testAllowChainWithNull() {
        // Given
        when(request.allowChain(null)).thenReturn(false);

        // When
        boolean result = request.allowChain(null);

        // Then
        assertFalse(result);
        verify(request, times(1)).allowChain(null);
    }

    @Test

        assertNull(DocumentUtil.getValue(null, "key", String.class));
        assertNull(DocumentUtil.getValue(null, "key", Integer.class));
    }

    public void test_getValue_with_null_key() {
        Map<String, Object> doc = new HashMap<>();
        doc.put("key", "value");
        assertNull(DocumentUtil.getValue(doc, null, String.class));
        assertNull(DocumentUtil.getValue(doc, null, Integer.class));
    }

        assertEquals(0, response.writeDataWireFormat(null, 0));

        // Read methods return 0 without accessing null buffer
        assertEquals(0, response.readSetupWireFormat(null, 0, 0));
        assertEquals(0, response.readParametersWireFormat(null, 0, 0));
        assertEquals(0, response.readDataWireFormat(null, 0, 0));
    }

    @Test
    @DisplayName("Methods should handle empty buffer")

        assertEquals(2, transWaitNamedPipe.setupCount);
    }

    @Test
    @DisplayName("Constructor with null pipe name should handle gracefully")
    void testConstructorWithNullPipeName() {
        // Act
        transWaitNamedPipe = new TransWaitNamedPipe(mockConfig, null);

        // Assert
        assertNotNull(transWaitNamedPipe);
        assertNull(transWaitNamedPipe.name);
    }

    @Test

        Set<Artifact> resolved = new LinkedHashSet<>();

        if (projects == null || projects.isEmpty()) {
            return resolved;
        }

        if ((scopesToCollect == null || scopesToCollect.isEmpty())
                && (scopesToResolve == null || scopesToResolve.isEmpty())) {
            return resolved;
        }

        /*

     * Validates that the entity is not null and sets the creation time if not already present.
     *
     * @param crawlingInfo the crawling information entity to prepare for storage
     * @throws FessSystemException if the crawling information is null
     */
    protected void setupStoreCondition(final CrawlingInfo crawlingInfo) {
        if (crawlingInfo == null) {

                assertTrue(true);
                return;
            }
            // Should handle null keywords gracefully
            assertNotNull(functionBuilders);
        } catch (Exception e) {
            // May throw exception due to null handling
            assertNotNull(e);
        }
    }

    public void test_keyMatchHelper_constructor() {

   */
  public void add(Runnable runnable, Executor executor) {
    // Fail fast on a null. We throw NPE here because the contract of Executor states that it throws
    // NPE on null listener, so we propagate that contract up into the add method as well.
    checkNotNull(runnable, "Runnable was null.");
    checkNotNull(executor, "Executor was null.");

    // Lock while we check state. We must maintain the lock while adding the new pair so that