@Override
        public void execute(Runnable command) {}
      };
    }

    @Override
    protected void run() throws Exception {}
  }

  public void testStopWhileStarting_runNotCalled() throws Exception {
    CountDownLatch started = new CountDownLatch(1);
    FakeService service =
        new FakeService() {
          @Override
          protected void startUp() throws Exception {

            @Override
            public void sendError(int sc, String msg) throws IOException {
            }

            @Override
            public void sendError(int sc) throws IOException {
            }

            @Override
            public void sendRedirect(String location) throws IOException {
            }

            @Override

        @Override
        protected void scheduleParentGroupLookup(EntraIdUser user, List<String> initialGroups, List<String> initialRoles,
                List<String> groupIds) {
            scheduleParentGroupLookupCalled.set(true);
            // Don't call super to avoid actual scheduling in tests
        }

        @Override

        }

        @Override
        public void setRawPayload(byte[] payload) {
            this.rawPayload = payload;
        }

        @Override
        public boolean verifySignature(byte[] data, int offset, int length) {
            return true; // Default to successful verification
        }

        public void setRetainPayload(boolean retain) {
            this.retainPayload = retain;

        .isEqualTo(expectedClosure);
  }

  @Test
  public void transpose_undirectedGraph() {
    MutableGraph<Integer> undirectedGraph = GraphBuilder.undirected().build();
    undirectedGraph.putEdge(N1, N2);

    assertThat(transpose(undirectedGraph)).isSameInstanceAs(undirectedGraph);
  }

  @Test
  public void transpose_directedGraph() {

    }
  }

  public void testFloorPowerOfTwoNegative() {
    for (int x : NEGATIVE_INTEGER_CANDIDATES) {
      assertThrows(IllegalArgumentException.class, () -> IntMath.floorPowerOfTwo(x));
    }
  }

  public void testCeilingPowerOfTwoZero() {
    assertThrows(IllegalArgumentException.class, () -> IntMath.ceilingPowerOfTwo(0));
  }

  public void testFloorPowerOfTwoZero() {

@GwtIncompatible
@RunWith(JUnit4.class)
@NullUnmarked
public class FinalizableReferenceQueueTest {

  private @Nullable FinalizableReferenceQueue frq;

  @After
  public void tearDown() throws Exception {
    frq = null;
  }

  @Test
  public void testFinalizeReferentCalled() {
    MockReference reference = new MockReference(frq = new FinalizableReferenceQueue());

                                   &t));
  return wrap(t);
}

void TF_DeleteExecutionContext(TF_ExecutionContext* c) { unwrap(c)->Release(); }

TF_AbstractOp* TF_NewAbstractOp(TF_ExecutionContext* c) {
  return wrap((unwrap(c)->CreateOperation()));
}

void TF_DeleteAbstractOp(TF_AbstractOp* op) { unwrap(op)->Release(); }

void TF_DeleteAbstractTensor(TF_AbstractTensor* t) { unwrap(t)->Unref(); }

            @Override
            public void head(Node node, int depth) {
                if (node.nodeName().equals("#comment")) {
                    node.remove();
                }
            }

            @Override
            public void tail(Node node, int depth) {
                // Do nothing
            }
        });
    }

    private void wrapH2InSectionTopic(Document document) {

    private static final int TEST_BATCH_SIZE = 8192;

    @BeforeEach
    void setUp() throws Exception {
        MockitoAnnotations.openMocks(this);
        Properties props = new Properties();
        config = new PropertyConfiguration(props);
    }

    @Test
    void testConstructor() {
        // Test constructor initializes all fields correctly