this.settings_ =
        Settings().apply {
          merge(mockResponse.settings)
        }
    }

    public fun code(code: Int): Builder =
      apply {
        this.code = code
      }

    /** Sets the status and returns this. */
    public fun status(status: String): Builder =
      apply {
        this.status = status
      }

    /**

                    TestUtils.createMockContext(tempDir, TestUtils.createOptionsWithModelVersion("4.1.0"));

            // Execute apply goal
            int result = applyGoal.execute(context);

            // Verify success
            assertEquals(0, result, "Apply should succeed");

            // Verify POM was upgraded
            String upgradedPom = Files.readString(pomFile);
            assertTrue(

        String[] args = {"apply", "--plugins"};
        CommonsCliUpgradeOptions options = CommonsCliUpgradeOptions.parse(args);

        assertTrue(options.goals().isPresent(), "Goals should be present");
        assertEquals(1, options.goals().get().size(), "Should have one goal");
        assertEquals("apply", options.goals().get().get(0), "Goal should be 'apply'");
    }

    @Test

  ) = apply {
    actions += { stream ->
      stream.sink.writeUtf8(s)
      stream.sink.flush()
      responseSent.countDown()
    }
  }

  fun exhaustResponse() =
    apply {
      actions += { stream -> stream.sink.close() }
    }

  fun sleep(
    duration: Long,
    unit: TimeUnit,
  ) = apply {
    actions += { Thread.sleep(unit.toMillis(duration)) }
  }

    return Collector.of(
        (Supplier<ImmutableTable.Builder<R, C, V>>) ImmutableTable.Builder::new,
        (builder, t) ->
            builder.put(rowFunction.apply(t), columnFunction.apply(t), valueFunction.apply(t)),
        ImmutableTable.Builder::combine,
        ImmutableTable.Builder::buildOrThrow);
  }

  static <T extends @Nullable Object, R, C, V>

     * @param apply Whether to apply the change immediately (delete matching items)
     * @return The SuggestDeleteResponse
     */
    public SuggestDeleteResponse addBadWord(final String index, final String badWord, final boolean apply) {
        final String normalized = normalizer.normalize(badWord, "");
        settings.badword().add(normalized);
        if (apply) {

        assertTrue(isNotEmpty.apply("test"));
        assertTrue(isNotEmpty.apply("a"));
        assertFalse(isNotEmpty.apply(""));
        assertFalse(isNotEmpty.apply(null));
    }

    @Test
    public void test_apply_integer() {
        BooleanFunction<Integer> isPositive = n -> n != null && n > 0;

        assertTrue(isPositive.apply(1));
        assertTrue(isPositive.apply(100));

    return Collector.of(
        (Supplier<ImmutableTable.Builder<R, C, V>>) ImmutableTable.Builder::new,
        (builder, t) ->
            builder.put(rowFunction.apply(t), columnFunction.apply(t), valueFunction.apply(t)),
        ImmutableTable.Builder::combine,
        ImmutableTable.Builder::buildOrThrow);
  }

  static <T extends @Nullable Object, R, C, V>

     */
    fun cookieJar(cookieJar: CookieJar) =
      apply {
        this.cookieJar = cookieJar
      }

    /** Sets the response cache to be used to read and write cached responses. */
    fun cache(cache: Cache?) =
      apply {
        this.cache = cache
      }

    internal fun taskRunner(taskRunner: TaskRunner) =
      apply {
        this.taskRunner = taskRunner
      }

    /**

    def "restResources does nothing when there are no tests"() {
        given:
        internalBuild()
        buildFile << """
            apply plugin: 'elasticsearch.java'
            apply plugin: 'elasticsearch.rest-resources'
        """

        String api = "foo.json"
        setupRestResources([api])

        when: