isFinished.set(true);
            return;
        }

        RuntimeException exception = null;

        for (int i = 0; i < maxRetryCount; i++) {
            try {
                final SearchResponse response;
                if (scrollId == null) {
                    final SearchRequestBuilder builder = client.prepareSearch()
                            .setIndices(indexName)

      L created = supplier.get();
      ArrayReference<L> newRef = new ArrayReference<>(created, index, queue);
      while (!locks.compareAndSet(index, existingRef, newRef)) {
        // we raced, we need to re-read and try again
        existingRef = locks.get(index);
        existing = existingRef == null ? null : existingRef.get();
        if (existing != null) {
          return existing;
        }
      }
      drainQueue();

    }

    @Test
    public void test_touch() {
        final ChatSession session = new ChatSession();
        final LocalDateTime initialTime = session.getLastAccessedAt();

        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            // ignore
        }

        session.touch();

      throws ConflictingRequirementsException {
    Class<? extends Annotation> annotationClass = testerAnnotation.annotationType();
    Feature<?>[] presentFeatures;
    Feature<?>[] absentFeatures;
    try {
      presentFeatures = (Feature<?>[]) annotationClass.getMethod("value").invoke(testerAnnotation);
      absentFeatures = (Feature<?>[]) annotationClass.getMethod("absent").invoke(testerAnnotation);
    } catch (Exception e) {

            return isOptionEnabled(options, options.plugins(), true);
        }

        public int testExecuteWithTargetModel(UpgradeContext context, String targetModel) {
            try {
                Map<Path, Document> pomMap = Map.of(); // Empty for this test
                return doUpgrade(context, targetModel, pomMap);
            } catch (Exception e) {
                throw new RuntimeException(e);

        final AtomicInteger totalPolled = new AtomicInteger(0);
        final List<String> allUrls = new ArrayList<>();

        for (int i = 0; i < numThreads; i++) {
            new Thread(() -> {
                try {
                    startLatch.await();
                    int count = 0;
                    while (count < itemsPerThread) {
                        final OpenSearchUrlQueue polled = urlQueueService.poll(sessionId);

                return "file";
            }
        });

        final ProtocolHelper protocolHelper = new ProtocolHelper();
        protocolHelper.init();

        try {
            protocolHelper.isValidWebProtocol(null);
            fail("Should throw exception for null URL");
        } catch (Exception e) {
            // Expected
            assertNotNull(e);
        }

    public static final String ERRORS_APP_DB_ALREADY_UPDATED = "{errors.app.db.already.updated}";

    /** The key of the message: The data already exists. Please try again. */
    public static final String ERRORS_APP_DB_ALREADY_EXISTS = "{errors.app.db.already.exists}";

    /** The key of the message: It may have been processed before this request. Please try again. */

          .post(
            object : RequestBody() {
              override fun contentType(): MediaType? = null

              override fun writeTo(sink: BufferedSink) {
                try {
                  for (i in 0..9) {
                    sink.writeUtf8(".")
                    sink.flush()
                    Thread.sleep(100)
                  }
                } catch (e: IOException) {

    }

    @Test
    public void test_byteCountToDisplaySize_edgeCases() {
        // Test negative values - should throw NullPointerException in private method via BigInteger.valueOf
        try {
            MemoryUtil.byteCountToDisplaySize(-1L);
            // If no exception, verify it handles negative as expected
        } catch (Exception e) {
            // Expected for negative values
        }