protected void doStart() {
            super.doStart();
            // This will delay service listener execution at least 150 milliseconds
            Uninterruptibles.sleepUninterruptibly(150, MILLISECONDS);
          }
        };
    Service a =
        new NoOpDelayedService(150) {
          @Override
          protected void doStart() {
            b.startAsync();
            super.doStart();
          }

        errors.add(new IllegalArgumentException("Illegal argument error"));

        SuggestDeleteResponse response = new SuggestDeleteResponse(errors, 150);

        assertTrue(response.hasError());
        assertEquals(3, response.getErrors().size());
        assertEquals(150, response.getTook());
    }

          protected void doStart() {
            super.doStart();
            // This will delay service listener execution at least 150 milliseconds
            Uninterruptibles.sleepUninterruptibly(150, MILLISECONDS);
          }
        };
    Service a =
        new NoOpDelayedService(150) {
          @Override
          protected void doStart() {
            b.startAsync();
            super.doStart();
          }

    val delays = mutableListOf(50.µs, 150.µs, -1L)
    redQueue.schedule("task", 100.µs) {
      log += "run@${taskFaker.nanoTime}"
      return@schedule delays.removeAt(0)
    }

    taskFaker.advanceUntil(0.µs)
    assertThat(log).containsExactly()

    taskFaker.advanceUntil(100.µs)
    assertThat(log).containsExactly("run@100000")

    taskFaker.advanceUntil(150.µs)

        response.setTotalTokens(150);
        response.setModel("gpt-4");

        assertEquals("Response content", response.getContent());
        assertEquals("stop", response.getFinishReason());
        assertEquals(Integer.valueOf(100), response.getPromptTokens());
        assertEquals(Integer.valueOf(50), response.getCompletionTokens());
        assertEquals(Integer.valueOf(150), response.getTotalTokens());

                .queryTime(150)
                .partialResults(true)
                .facetResponse(facetResponse)
                .build();

        assertEquals(1, result.getDocumentList().size());
        assertEquals(1000, result.getAllRecordCount());
        assertEquals(Relation.EQUAL_TO.toString(), result.getAllRecordCountRelation());
        assertEquals(150, result.getQueryTime());

            }

            @Override
            public int getLtrWindowSize() {
                return 150;
            }
        });

        RescorerBuilder<?> result3 = ltrQueryRescorer.evaluate(params);
        assertNotNull(result3);
        assertEquals(150, ((QueryRescorerBuilder) result3).windowSize().intValue());
    }

                }
                return null;
            }
        };

        // Test with large number of parameters
        Map<String, Object> largeParams = new HashMap<>();
        for (int i = 0; i < 150; i++) {
            largeParams.put("key" + i, "value" + i);
        }

        assertNotNull(queryRescorer.evaluate(largeParams));

        // Test with small number of parameters

     */
    function autoResizeTextarea() {
        var textarea = elements.chatInput[0];
        textarea.style.height = 'auto';
        textarea.style.height = Math.min(textarea.scrollHeight, 150) + 'px';
    }

    /**
     * Update character counter
     */
    function updateCharCount() {
        var count = elements.chatInput.val().length;
        var maxLength = 4000;

        request.setParameter("geo.location.distance", "10km");

        final GeoInfo geoInfo = new GeoInfo(request);
        String result =
                "{\"geo_distance\":{\"location\":[150.0,34.0],\"distance\":10000.0,\"distance_type\":\"arc\",\"validation_method\":\"STRICT\",\"ignore_unmapped\":false,\"boost\":1.0}}";
        assertEquals(result, geoInfo.toQueryBuilder().toString().replaceAll("[ \n]", ""));
    }