*/
  @IgnoreJRERequirement // Users will use this only if they're already using Duration.
  public static RateLimiter create(double permitsPerSecond, Duration warmupPeriod) {
    return create(permitsPerSecond, toNanosSaturated(warmupPeriod), NANOSECONDS);
  }

  /**
   * Creates a {@code RateLimiter} with the specified stable throughput, given as "permits per

                created = true;
            }
            return created;
        } catch (final Exception e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Failed to create suggest index: index={}", index, e);
            }
            throw new SuggesterException("Failed to create suggest index: " + index, e);
        }
    }

    /**

            }
            boolean created = false;
            try (ImageInputStream input = ImageIO.createImageInputStream(responseData.getResponseBody())) {
                switch (saveImage(input, outputFile)) {
                case OK:
                    created = true;
                    break;
                case FAILED:

   * addition, the cause of any {@code ExecutionException} is wrapped in order to ensure that the
   * new stack trace matches that of the current thread.
   *
   * <p>Instances of {@code exceptionClass} are created by choosing an arbitrary public constructor
   * that accepts zero or more arguments, all of type {@code String} or {@code Throwable}

        // The request should be properly created - we can't easily verify headers without mocking framework
    }

    @Test
    public void test_post() {
        setupMockConfig("localhost:9200", "", "");

        curlHelper.init();
        CurlRequest request = curlHelper.post("/test");

        assertNotNull(request);
        // The request should be properly created
    }

    @Test
    public void test_put() {

        assertFalse(queryFieldConfig.isFacetField("category"));
    }

    /**
     * Test that init() creates Sets when arrays are initialized.
     */
    @Test
    public void test_init_createsSets() {
        queryFieldConfig.init();

        // All Sets should be created during init
        assertNotNull(queryFieldConfig.searchFieldSet);
        assertNotNull(queryFieldConfig.facetFieldSet);

                }))
                .status(ApiResult.Status.OK)
                .result());
    }

    /**
     * Creates a new scheduler setting.
     *
     * @param body the scheduler data to create
     * @return JSON response containing the created scheduler setting ID
     */
    // POST /api/admin/scheduler/setting
    @Execute

 *       verified or created.
 *   <li>If a new edge needs to be created, the outgoing edges of the acquired locks are traversed
 *       to check for a cycle that reaches the lock to be acquired. If no cycle is detected, a new
 *       "safe" edge is created.
 *   <li>If a cycle is detected, an "unsafe" (cyclic) edge is created to represent a potential

    return set;
  }

  // LinkedHashSet

  /**
   * Creates a <i>mutable</i>, empty {@code LinkedHashSet} instance.
   *
   * <p><b>Note:</b> if mutability is not required, use {@link ImmutableSet#of()} instead.
   *
   * <p><b>Note:</b> this method is now unnecessary and should be treated as deprecated. Instead,
   * use the {@code LinkedHashSet} constructor directly, taking advantage of <a

   * \n}. If the source's content does not end in a line termination sequence, it is treated as if
   * it does.
   *
   * @throws IOException if an I/O error occurs while reading from this source
   */
  public @Nullable String readFirstLine() throws IOException {
    Closer closer = Closer.create();
    try {
      BufferedReader reader = closer.register(openBufferedStream());