@CheckForNull
  public Range<C> rangeContaining(C value) {
    int index =
        SortedLists.binarySearch(
            ranges,
            Range::lowerBound,
            Cut.belowValue(value),
            Ordering.natural(),
            ANY_PRESENT,
            NEXT_LOWER);
    if (index != -1) {
      Range<C> range = ranges.get(index);
      return range.contains(value) ? range : null;
    }
    return null;
  }

        try {
            final Object value = supplier.get();
            if (value == null) {
                tempBuf.append("null");
            } else if (value instanceof Integer || value instanceof Long) {
                tempBuf.append(value);
            } else if (value instanceof Short) {
                tempBuf.append(((Short) value).shortValue());
            } else if (value instanceof double[]) {

        if (StringUtil.isNotBlank(name) && StringUtil.isNotBlank(value)) {
            searchFieldLogList.add(new Pair<>(name, value));
        }
    }

    public void addRequestHeaderValue(final String name, final String value) {
        if (StringUtil.isNotBlank(name) && StringUtil.isNotBlank(value)) {
            headerList.add(new Pair<>(name, value));
        }
    }

        Map<String, Object> value = new LinkedHashMap<>();
        DocMap docMap = new DocMap(value);
        assertTrue(docMap.isEmpty());
        value.clear();

        List<String> keys = Arrays.asList("test_2", "test_0", "lang", "test_1");
        value.put(keys.get(0), true);
        value.put(keys.get(1), 1000);
        value.put(keys.get(2), "ja");
        value.put(keys.get(3), "str");

        <set>
          <option value="io.reactivex.annotations.Beta" />
          <option value="io.reactivex.annotations.Experimental" />
          <option value="org.apache.http.annotation.Beta" />
          <option value="org.gradle.api.Incubating" />
          <option value="org.jetbrains.annotations.ApiStatus.Experimental" />
          <option value="rx.annotations.Beta" />
          <option value="rx.annotations.Experimental" />

    public static <E> Iterable<E> iterable(final E value) {
        return () -> new SingleValueIterator<>(value);
    }

    /**
     * インスタンスを構築します。
     *
     * @param value
     *            反復子が返す唯一の値
     */
    public SingleValueIterator(final E value) {
        this.value = value;
    }

    @Override
    public boolean hasNext() {
        return hasNext;
    }

    @Override

    // For datasets of many double values created from an array, we test many combinations of finite
    // and non-finite values:
    for (ManyValues values : ALL_MANY_VALUES) {
      double mean = Stats.of(values.asArray()).mean();
      if (values.hasAnyNaN()) {
        assertWithMessage("mean of " + values).that(mean).isNaN();
      } else if (values.hasAnyPositiveInfinity() && values.hasAnyNegativeInfinity()) {

            String value = null;
            if (StringUtil.isNotEmpty(url)) {
                value = url;
            } else if (StringUtil.isNotEmpty(resourceName)) {
                value = resourceName;
            }

            if (value != null) {
                for (final Map.Entry<Pattern, String> entry : passwordMap.entrySet()) {

    for (Entry<Object, Object> entry : result.entrySet()) {
      Object key = entry.getKey();
      Object value = entry.getValue();
      assertSame(value, result.get(key));
      assertNull(result.get(value));
      assertSame(value, cache.asMap().get(key));
      assertSame(key, cache.asMap().get(value));
    }
  }

  public void testBulkLoad_clobber() throws ExecutionException {

    public void test_parsePath() {
        String[] values;

        values = storageClient.parsePath("bucket/path");
        assertEquals("bucket", values[0]);
        assertEquals("path", values[1]);

        values = storageClient.parsePath("bucket/path1/path2");
        assertEquals("bucket", values[0]);
        assertEquals("path1/path2", values[1]);

        values = storageClient.parsePath("bucket/");