assertSame(mockProcess, assignedProcess, "Process should be exactly the same instance");
    }

    private Process createMockProcess(String output) {
        return new MockProcess(output);
    }

    private static class MockProcess extends Process {
        private final InputStream inputStream;

        public MockProcess(String output) {

  abstract Cell<R, C, V> getCell(int iterationIndex);

  @Override
  final ImmutableSet<Cell<R, C, V>> createCellSet() {
    return isEmpty() ? ImmutableSet.of() : new CellSet();
  }

  @WeakOuter
  private final class CellSet extends IndexedImmutableSet<Cell<R, C, V>> {
    @Override
    public int size() {
      return RegularImmutableTable.this.size();
    }

    @Override
    Cell<R, C, V> get(int index) {

import jcifs.internal.smb2.rdma.tcp.TcpMemoryRegion;

/**
 * Unit tests for RDMA buffer manager
 */
public class RdmaBufferManagerTest {

    @Mock
    private RdmaProvider mockProvider;

    private RdmaBufferManager bufferManager;
    private AutoCloseable mocks;

    @BeforeEach
    public void setUp() throws Exception {
        mocks = MockitoAnnotations.openMocks(this);

        .exclude("**/.*.swp");

    /*
     * The rules: a map from the rule name, to a rule regex pattern.
     */
    private final Map<String, String> patterns = new HashMap<>();
    private final ProjectLayout projectLayout;

    @Inject
    public ForbiddenPatternsTask(ProjectLayout projectLayout) {
        this.projectLayout = projectLayout;

import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test

/** Confirm we get the expected table whether we build it from the .txt file or compact that. */
class IdnaMappingTableTest {
  private lateinit var table: SimpleIdnaMappingTable
  private lateinit var compactTable: IdnaMappingTable

  @BeforeEach
  fun setUp() {
    val path = "/okhttp3/internal/idna/IdnaMappingTable.txt".toPath()
    val plainTable =

/**
 * Test class for ValidateNegotiateInfoRequest
 */
class ValidateNegotiateInfoRequestTest {

    private static final int DEFAULT_CAPABILITIES = 0x12345678;
    private static final int DEFAULT_SECURITY_MODE = 0x0003;
    private byte[] defaultClientGuid;
    private int[] defaultDialects;

    @BeforeEach
    void setUp() {
        // Initialize default GUID (16 bytes)

        encodedPathSegments[encodedPathSegments.size - 1] = ""
      } else {
        encodedPathSegments.add("")
      }
    }

    private fun isDot(input: String): Boolean = input == "." || input.equals("%2e", ignoreCase = true)

    private fun isDotDot(input: String): Boolean =
      input == ".." ||
        input.equals("%2e.", ignoreCase = true) ||
        input.equals(".%2e", ignoreCase = true) ||

import org.junit.jupiter.api.TestInfo;

import jakarta.validation.ConstraintValidatorContext;
import jakarta.validation.Payload;

public class CustomSizeValidatorTest extends UnitFessTestCase {

    private CustomSizeValidator validator;

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {
        super.setUp(testInfo);
        validator = new CustomSizeValidator();
    }

    @Test

/**
 * Tests for the default implementations of {@code CharSink} methods.
 *
 * @author Colin Decker
 */
@NullUnmarked
public class CharSinkTest extends IoTestCase {

  private static final String STRING = ASCII + I18N;

  private TestCharSink sink;

  @Override
  public void setUp() {
    sink = new TestCharSink();
  }

  public void testOpenBufferedStream() throws IOException {

 *
 * @author Louis Wasserman
 */
@NullUnmarked
public class ForwardingSortedSetTest extends TestCase {
  static class StandardImplForwardingSortedSet<T> extends ForwardingSortedSet<T> {
    private final SortedSet<T> backingSortedSet;

    StandardImplForwardingSortedSet(SortedSet<T> backingSortedSet) {
      this.backingSortedSet = backingSortedSet;
    }

    @Override
    protected SortedSet<T> delegate() {