byte[] buffer2 = new byte[200];
        int encoded2 = request2.encode(buffer2, 0);
        assertEquals(request2.size(), encoded2);
    }

    @Test
    @DisplayName("Test multiple encodes produce same result")
    void testMultipleEncodesProduceSameResult() {
        // Setup
        String pipeName = "RepeatedEncode";
        long timeout = 3000L;

        text: error strings should not be capitalized or end with punctuation or a newline
    paths:
      - third_party$
      - builtin$
      - examples$
issues:
  max-issues-per-linter: 100
  max-same-issues: 100
formatters:
  enable:
    - gofumpt
    - goimports
  exclusions:
    generated: lax
    paths:
      - third_party$
      - builtin$

    THE COVERED SOFTWARE IS WITH YOU. SHOULD ANY COVERED SOFTWARE PROVE
    DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY
    OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING,
    REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN
    ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED SOFTWARE IS
    AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.

 * The cache stores its data in a directory on the filesystem. This directory must be exclusive to
 * the cache; the cache may delete or overwrite files from its directory. It is an error for
 * multiple processes to use the same cache directory at the same time.
 *
 * This cache limits the number of bytes that it will store on the filesystem. When the number of
 * stored bytes exceeds the limit, the cache will remove entries in the background until the limit

    worked everywhere that I know of except for one place: when running the GWT
    util.concurrent tests under Guava.

    The problem is that GWT responds poorly to two .gwt.xml files in the same
    Java package; see
    https://groups.google.com/g/google-web-toolkit-contributors/c/CqYH59Dt_rQ/m/uVGW1QdUsXUJ
    for details.

    The summary is that it ignores one file in favor of the other.

      overriddenAndAnnotatedInSubclassEvents.add(o);
    }
  }

  static class SubClass extends SuperClass {
    @Override
    // We are testing how we treat an override with the same behavior and annotations.
    @SuppressWarnings("RedundantOverride")
    public void overriddenInSubclassNowhereAnnotated(Object o) {
      super.overriddenInSubclassNowhereAnnotated(o);
    }

    @Subscribe

        ResponseData responseData = new ResponseData();
        assertTrue(deserializedRule.match(responseData));
    }

    /**
     * Test multiple rules with same ResponseProcessor
     */
    public void test_multipleRulesWithSameProcessor() {
        TestResponseProcessor sharedProcessor = new TestResponseProcessor("shared");

   *
   * TODO(cpovirk): Could this be simplified if we modified implementations of LegacyConverter to
   * override methods (probably called "unsafeDoForward" and "unsafeDoBackward") with the same
   * signatures as the methods below, rather than overriding the same doForward and doBackward
   * methods as implementations of normal converters do?
   *
   * But no matter what we do, it's worth remembering that the resulting code is going to be unsound

      HashFunction hasher = Hashing.goodFastHash(i);
      assertTrue(hasher.bits() >= i);
      HashTestUtils.assertInvariants(hasher);
    }
  }

  // goodFastHash(32) uses Murmur3_32. Use the same epsilon bounds.
  public void testGoodFastHash32() {
    HashTestUtils.check2BitAvalanche(Hashing.goodFastHash(32), 250, 0.20);
    HashTestUtils.checkAvalanche(Hashing.goodFastHash(32), 250, 0.17);

 * (unless there are {@link Double#NaN NaN} values, see below); otherwise, the result is the average
 * of the values which would appear at the indexes floor(x) and ceil(x) weighted by (1-frac(x)) and
 * frac(x) respectively. This is the same definition as used by Excel and by S, it is the Type 7
 * definition in <a
 * href="http://stat.ethz.ch/R-manual/R-devel/library/stats/html/quantile.html">R</a>, and it is
 * described by <a