if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

    public void setName_Terms() {
        setName_Terms(null);
    }

    public void setName_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
        setName_Terms("name", opLambda, null);
    }

    public void setName_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsRoleCA> aggsLambda) {

    }

    @Test
    public void testSingleArgumentConstructor() {
        CurlRequest request = new CurlRequest(Method.POST);

        assertEquals(Method.POST, request.method());
        assertEquals("UTF-8", request.encoding());
        assertEquals(1024 * 1024, request.threshold());
        assertNull(request.proxy());
        assertNull(request.body());
    }

    @Test

    assertThat(LOWER_UNDERSCORE.to(LOWER_CAMEL, "foo")).isEqualTo("foo");
    assertThat(LOWER_UNDERSCORE.to(LOWER_CAMEL, "foo_bar")).isEqualTo("fooBar");
  }

  public void testLowerUnderscoreToUpperCamel() {
    assertThat(LOWER_UNDERSCORE.to(UPPER_CAMEL, "foo")).isEqualTo("Foo");
    assertThat(LOWER_UNDERSCORE.to(UPPER_CAMEL, "foo_bar")).isEqualTo("FooBar");
  }

  @SuppressWarnings("ThrowIfUncheckedKnownUnchecked")
  public void testThrowIfUnchecked_unchecked() {
    assertThrows(
        SomeUncheckedException.class, () -> throwIfUnchecked(new SomeUncheckedException()));
  }

  // We're testing that the method is in fact equivalent to throwing the exception directly.
  @SuppressWarnings("ThrowIfUncheckedKnownUnchecked")
  public void testThrowIfUnchecked_error() {

    return suite;
  }

  // Creation tests

  public void testCreation_noArgs() {
    List<String> list = ImmutableList.of();
    assertEquals(emptyList(), list);
  }

  public void testCreation_oneElement() {
    List<String> list = ImmutableList.of("a");
    assertEquals(singletonList("a"), list);
  }

  public void testCreation_twoElements() {
    List<String> list = ImmutableList.of("a", "b");

    class CacheOperationsTests {

        private Map<String, DfsReferralDataInternal> cacheMap;

        @BeforeEach
        void setupCache() {
            cacheMap = new HashMap<>();
        }

        @Test
        @DisplayName("Should replace entry in cache map")
        void testReplaceCacheWithMap() {
            String key = "test-key";

            // Setup concrete implementation

        }
      };

  public void testServiceStartStop() throws Exception {
    NullService service = new NullService();
    service.startAsync().awaitRunning();
    assertFalse(future.isDone());
    service.stopAsync().awaitTerminated();
    assertTrue(future.isCancelled());
  }

  private class NullService extends AbstractScheduledService {
    @Override
    protected void runOneIteration() throws Exception {}

        }
      };

  public void testServiceStartStop() throws Exception {
    NullService service = new NullService();
    service.startAsync().awaitRunning();
    assertFalse(future.isDone());
    service.stopAsync().awaitTerminated();
    assertTrue(future.isCancelled());
  }

  private class NullService extends AbstractScheduledService {
    @Override
    protected void runOneIteration() throws Exception {}

    private NotificationHelper notificationHelper;

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

    @Test
    public void test_sendToSlack_withBlankWebhookUrls() {
        // Setup mock configuration with blank webhook URLs

    }

    @Test
    public void test_constructor_withNewlineInOutput() {
        // Test newline replacement in output
        String[] inputs = { "input" };
        CharMappingItem item = new CharMappingItem(1L, inputs, "line1\nline2");

        assertEquals("line1 line2", item.getOutput());
    }

    @Test
    public void test_constructor_withNullOutput() {
        // Test with null output