}

  private final int[] factorials = new int[ARRAY_SIZE];
  private final int[][] binomials = new int[ARRAY_SIZE][2];
  private final int[][] nonnegInt = new int[ARRAY_SIZE][2];
  private final long[][] nonnegLong = new long[ARRAY_SIZE][2];
  private final int[][] intsToAdd = new int[ARRAY_SIZE][2];
  private final int[][] intsToMul = new int[ARRAY_SIZE][2];
  private final long[][] longsToAdd = new long[ARRAY_SIZE][2];

@DoNotMock
public final class GraphBuilder<N> extends AbstractGraphBuilder<N> {

  /** Creates a new instance with the specified edge directionality. */
  private GraphBuilder(boolean directed) {
    super(directed);
  }

  /** Returns a {@link GraphBuilder} for building directed graphs. */
  public static GraphBuilder<Object> directed() {
    return new GraphBuilder<>(true);
  }

  }

  private final int[] factorials = new int[ARRAY_SIZE];
  private final int[][] binomials = new int[ARRAY_SIZE][2];
  private final int[][] nonnegInt = new int[ARRAY_SIZE][2];
  private final long[][] nonnegLong = new long[ARRAY_SIZE][2];
  private final int[][] intsToAdd = new int[ARRAY_SIZE][2];
  private final int[][] intsToMul = new int[ARRAY_SIZE][2];
  private final long[][] longsToAdd = new long[ARRAY_SIZE][2];

                }
            }
        }

        ArtifactFilter scopeFilter = new ScopeArtifactFilter( scope );

        ArtifactFilter filter;

        if ( ! exclusions.isEmpty() )
        {
            filter = new AndArtifactFilter( Arrays.asList( new ArtifactFilter[]{
                new ExcludesArtifactFilter( exclusions ), scopeFilter } ) );
        }
        else
        {

        final ProcessBuilder pb = new ProcessBuilder(cmdList);
        pbCall.accept(pb);

        // Remove and destroy any existing process for this session
        final JobProcess oldProcess = runningProcessMap.remove(sessionId);
        if (oldProcess != null) {
            destroyProcess(sessionId, oldProcess);
        }

        // Start the new process and add it to the map
        try {

    private final String name;
    private final AtomicReference<State> state = new AtomicReference<>(State.CLOSED);
    private final AtomicInteger consecutiveFailures = new AtomicInteger(0);
    private final AtomicInteger halfOpenSuccesses = new AtomicInteger(0);
    private final AtomicLong lastFailureTime = new AtomicLong(0);
    private final AtomicLong stateChangeTime = new AtomicLong(System.currentTimeMillis());

    // Statistics

    void testReadFromDifferentPositions() throws Exception {
        byte[] buffer = new byte[200];

        // Test at various positions in the buffer
        int[] positions = { 0, 10, 50, 100, 150 };

        for (int pos : positions) {
            when(mockConfig.getPid()).thenReturn(1234); // Mock getPid for each new instance
            response = new TestSmbComNtTransactionResponse(mockConfig); // Reset response

        MockitoAnnotations.openMocks(this);
        testMessage = new TestServerMessageBlock2(mockConfig);
    }

    @Nested
    @DisplayName("Constructor Tests")
    class ConstructorTests {

        @Test
        @DisplayName("Should create with configuration only")
        void testConstructorWithConfig() {
            ServerMessageBlock2 msg = new TestServerMessageBlock2(mockConfig);
            assertNotNull(msg);

        final ApiStartJobResponse response = new ApiStartJobResponse();
        final ApiStartJobResponse returned = response.jobLogId("abc123def456");
        assertSame(response, returned);
        assertEquals("abc123def456", response.jobLogId);
    }

    @Test
    public void test_ApiStartJobResponse_withNullJobLogId() {
        final ApiStartJobResponse response = new ApiStartJobResponse();
        response.jobLogId(null);

                "Raw bytes for empty string should be empty");

        byte[] emptyBytes = new byte[0];
        AvTargetName avTargetNameFromBytes = new AvTargetName(emptyBytes);
        assertEquals(emptyString, avTargetNameFromBytes.getTargetName(),
                "Empty string should be handled correctly from raw bytes constructor");