*/
  @JvmStatic
  fun fragmentBuffer(buffer: Buffer): Buffer {
    // Write each byte into a new buffer, then clone it so that the segments are shared.
    // Shared segments cannot be compacted so we'll get a long chain of short segments.
    val result = Buffer()
    while (!buffer.exhausted()) {
      val box = Buffer()
      box.write(buffer, 1)
      result.write(box.copy(), 1)
    }
    return result
  }

        final CachedCipher cipher = new CachedCipher();
        cipher.setKey("mySecretKey");

        final StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 1000; i++) {
            sb.append("Long text for testing. ");
        }
        final String original = sb.toString();
        final String encrypted = cipher.encryptText(original);
        final String decrypted = cipher.decryptText(encrypted);

    private static final char HANKAKU_KATAKANA_LAST_CHAR = HANKAKU_KATAKANA[HANKAKU_KATAKANA.length - 1];

    @Override
    public String normalize(final String s, final String field, final String... langs) {
        if (s == null || s.length() == 0) {
            return s;
        }
        if (s.length() == 1) {
            return hankakuKatakanaToZenkakuKatakana(s.charAt(0)) + "";
        }

common:windows --config=clang_local

# Do not risk cache corruption. See:
# https://github.com/bazelbuild/bazel/issues/3360
common:linux --experimental_guard_against_concurrent_changes

# Configure short or long logs
common:short_logs --output_filter=DONT_MATCH_ANYTHING
common:verbose_logs --output_filter=

# Instruction set optimizations
# TODO(gunan): Create a feature in toolchains for avx/avx2 to

        assertEquals("query1", facetInfo.query[0]);
        assertEquals("query2", facetInfo.query[1]);
        assertEquals(Integer.valueOf(100), facetInfo.size);
        assertEquals(Long.valueOf(5), facetInfo.minDocCount);
        assertEquals("count", facetInfo.sort);
        assertEquals("other", facetInfo.missing);
    }

    @Test
    public void test_createFacetInfo_withOnlyFields() {

        }
        if (StringUtil.isNotBlank(relatedQueryPager.queries)) {
            cb.query().setQueries_Wildcard(wrapQuery(relatedQueryPager.queries));
        }
        // TODO Long, Integer, String supported only.

        // setup condition
        cb.query().addOrderBy_Term_Asc();
        cb.query().addOrderBy_CreatedTime_Asc();

        // search

    }

) : RoutePlanner,
  Closeable {
  val pool = factory.newConnectionPool()
  val events = LinkedBlockingDeque<String>()
  var canceled = false
  var autoGeneratePlans = false
  var defaultConnectionIdleAtNanos = Long.MAX_VALUE
  private var nextPlanId = 0
  private var nextPlanIndex = 0
  val plans = mutableListOf<FakePlan>()

  override val deferredPlans = ArrayDeque<RoutePlanner.Plan>()

   * of the same class. For example, if sublists of {@code MyList} instances were serializable,
   * those sublists might implement a private {@code MySubList} type but serialize as a plain {@code
   * MyList} to save space. So long as {@code MyList} has all the public supertypes of {@code
   * MySubList}, this is safe. For these cases, for which {@code reserializeAndAssert} is too
   * strict, use {@link #reserialize}.
   *

    }

    @Override
    public String toString() {
      return "Enums.stringConverter(" + enumClass.getName() + ".class)";
    }

    @J2ktIncompatible private static final long serialVersionUID = 0L;
  }

            return true; // BAD!!
          }

          @Override
          public String get() {
            return "foo"; // BAD!!
          }

          @Override
          public String get(long time, TimeUnit unit) {
            return "foo"; // BAD!!
          }

          @Override
          public void addListener(Runnable runnable, Executor executor) {
            executor.execute(runnable);