@SuppressWarnings("unchecked")
  protected B self() {
    return (B) this;
  }

  // Test Data

  private @Nullable G subjectGenerator;
  // Gets run before every test.
  private Runnable setUp;
  // Gets run at the conclusion of every test.
  private Runnable tearDown;

  @CanIgnoreReturnValue
  protected B usingGenerator(G subjectGenerator) {
    this.subjectGenerator = subjectGenerator;

    """

    @Language("kotlin")
    private
    val existingSource = """

        class ExistingClass {

            class ExistingNestedClass(foo: String)

        }

        val valTurnedIntoVar: String
            get() = ""

        typealias ExistingTypeAlias = String
    """

    @Language("kotlin")
    private
    val internalSource = """

        $internalMembers

    private ExceptionWithSomePrivateConstructors(String a) {}

    private ExceptionWithSomePrivateConstructors(String a, String b) {}

    public ExceptionWithSomePrivateConstructors(String a, String b, String c) {}

    private ExceptionWithSomePrivateConstructors(String a, String b, String c, String d) {}

    private ExceptionWithSomePrivateConstructors(

internal abstract class NullawayStatusService : BuildService<BuildServiceParameters.None>, Closeable {
    private val projectsWithNullAwayEnabled = ConcurrentHashMap.newKeySet<String>()
    private val projectsWithUncheckedDeps = ConcurrentHashMap.newKeySet<String>()
    private val projectsToEnableNullaway = ConcurrentHashMap.newKeySet<String>()

    private fun ensureProjectNotSeen(projectPath: String) {
        require(projectPath !in projectsWithNullAwayEnabled)

 */
@Named
public class BuildPlanExecutor {

    private static final Object GLOBAL = new Object();

    private final Logger logger = LoggerFactory.getLogger(getClass());

    private final MojoExecutor mojoExecutor;
    private final ExecutionEventCatapult eventCatapult;
    private final ProjectExecutionListener projectExecutionListener;
    private final TransformerManager transformerManager;

@GwtCompatible
@NullMarked
abstract class AbstractIteratorTester<E extends @Nullable Object, I extends Iterator<E>> {
  private final Stimulus<E, ? super I>[] stimuli;
  private final Iterator<E> elementsToInsert;
  private final Set<IteratorFeature> features;
  private final List<E> expectedElements;
  private final int startIndex;
  private final KnownOrder knownOrder;

  /**

   * limit for string literals in Java.
   */
  private static class ChunksCharSequence implements CharSequence {
    private final ImmutableList<CharSequence> chunks;
    private final int length;
    private final int chunkShift;
    private final int chunkMask;

    ChunksCharSequence(ImmutableList<CharSequence> chunks, int chunkShift) {
      this.chunks = chunks;

     */
    public static final int OVERHEAD = Smb2Constants.SMB2_HEADER_LENGTH + 48;

    private byte[] data;
    private int dataOffset;
    private int dataLength;

    private byte[] fileId;
    private long offset;
    private int channel;
    private int remainingBytes;
    private int writeFlags;
    private RdmaChannelInfo rdmaChannelInfo;

    /**

public class CrawlerTest extends UnitFessTestCase {

    private Crawler crawler;
    private SearchEngineClient searchEngineClient;
    private WebFsIndexHelper webFsIndexHelper;
    private DataIndexHelper dataIndexHelper;
    private PathMappingService pathMappingService;
    private CrawlingInfoService crawlingInfoService;
    private CrawlingInfoHelper crawlingInfoHelper;
    private SystemHelper systemHelper;
    private FessConfig fessConfig;

   * CompactHashMap.
   */

  private Object requireTable() {
    return requireNonNull(table);
  }

  private int[] requireEntries() {
    return requireNonNull(entries);
  }

  private @Nullable Object[] requireElements() {
    return requireNonNull(elements);
  }

  @SuppressWarnings("unchecked")
  private E element(int i) {
    return (E) requireElements()[i];
  }