private final ProjectsSelector projectsSelector = new DefaultProjectsSelector(projectBuilder);

    // Not using mocks for these strategies - a mock would just copy the actual implementation.

    private final ModelProcessor modelProcessor = new DefaultModelProcessor(null, Map.of());
    private final PomlessCollectionStrategy pomlessCollectionStrategy = new PomlessCollectionStrategy(projectBuilder);

    assertCollectionSize(map.entrySet(), size);
    assertCollectionSize(map.values(), size);
  }

  @SuppressWarnings("IterablesSizeOfCollection") // we are testing our iterator implementation
  private void assertCollectionSize(Collection<?> collection, int size) {
    assertThat(collection.size()).isEqualTo(size);
    if (size > 0) {
      assertThat(collection.isEmpty()).isFalse();
    } else {

      return of();
    } else if (length == 1) {
      return of(get(fromIndex));
    } else {
      return subListUnchecked(fromIndex, toIndex);
    }
  }

  /**
   * Called by the default implementation of {@link #subList} when {@code toIndex - fromIndex > 1},
   * after index validation has already been performed.
   */
  ImmutableList<E> subListUnchecked(int fromIndex, int toIndex) {

    private TestNameServicePacket packet;
    @Mock
    private Configuration mockConfig;
    @Mock
    private Name mockQuestionName;
    @Mock
    private Name mockRecordName;

    // Concrete implementation of NameServicePacket for testing
    private static class TestNameServicePacket extends NameServicePacket {
        public TestNameServicePacket(Configuration config) {
            super(config);
        }

            + "issue, or move Guava to your system class path.";

    @Override
    public @Nullable Class<?> loadFinalizer() {
      /*
       * We use URLClassLoader because it's the only concrete class loader implementation in the
       * JDK. If we used our own ClassLoader subclass, Finalizer would indirectly reference this
       * class loader:
       *

        // After wiping, operations that require keys should fail

        // Attempting to use the context after wiping should handle gracefully
        // Note: The actual implementation might throw an exception or handle differently
    }

    @Test
    @DisplayName("Should securely wipe keys when closing context")
    void testAutoCloseableSecureWipe() {
        // Given

              : new DescendingImmutableSortedMultiset<E>(this);
    }
    return result;
  }

  /**
   * {@inheritDoc}
   *
   * <p>This implementation is guaranteed to throw an {@link UnsupportedOperationException}.
   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @CanIgnoreReturnValue
  @Deprecated

    /**
     * Retrieves the session data associated with this session.
     *
     * @return the session data, never {@code null}
     */
    @Nonnull
    SessionData getData();

    /**
     * Default implementation at {@link ProtoSession} level, as the notion of project
     * does not exist there.
     */
    @Nonnull
    default Map<String, String> getEffectiveProperties() {
        return getEffectiveProperties(null);

import jcifs.dcerpc.DcerpcMessage;
import jcifs.dcerpc.rpc;
import jcifs.dcerpc.ndr.NdrBuffer;
import jcifs.dcerpc.ndr.NdrException;
import jcifs.dcerpc.ndr.NdrObject;

/**
 * Security Account Manager Remote (SAMR) protocol implementation.
 * This class provides DCE/RPC interface for SAM database operations including
 * user account management, group operations, and domain security functions.
 */
@SuppressWarnings("all")
public class samr {

import jcifs.smb1.dcerpc.rpc;
import jcifs.smb1.dcerpc.ndr.NdrBuffer;
import jcifs.smb1.dcerpc.ndr.NdrException;
import jcifs.smb1.dcerpc.ndr.NdrObject;

/**
 * Security Account Manager Remote (SAMR) protocol implementation for SMB1.
 * This class provides DCE/RPC interface for SAM database operations including
 * user account management, group operations, and domain security functions.
 */
public class samr {

    /**