.clearHeaders()
        .addHeader("Content-Length: 3")
        .build(),
    )
    assertContent("abc", getResponse(newRequest("/")))
  }

  @Test
  fun contentDisagreesWithContentLengthHeaderBodyTooShort() {
    server.enqueue(
      MockResponse
        .Builder()
        .body("abc")
        .setHeader("Content-Length", "5")
        .onResponseEnd(ShutdownConnection)
        .build(),

    for (Method method : testClass.getDeclaredMethods()) {
      if (Modifier.isPublic(method.getModifiers())
          && method.getReturnType() == void.class
          && method.getParameterTypes().length == 0
          && method.getName().startsWith("test")) {
        result.add(method);
      }
    }
    return ImmutableList.copyOf(result);
  }

    }

    protected void createSynonymMap(final boolean reload) {
        try (Reader rulesReader = getReader(reload)) {
            if (rulesReader instanceof StringReader && ((StringReader) rulesReader).toString().length() == 0) {
                synonymMap = null;
                return;
            }

            SynonymMap.Builder parser = null;

            if ("wordnet".equalsIgnoreCase(settings.get("format"))) {

        assertEquals(3, permissions.length);
        assertEquals("Rgroup1", permissions[0]);
        assertEquals("Rgroup2", permissions[1]);
        assertEquals("Utestuser", permissions[2]);

        // Verify callback was called
        assertTrue(activityHelperCalled.get());
        assertNotNull(rolesFromCallback.get());
        assertEquals(2, rolesFromCallback.get().length);

    for (int i = 0; i < IntMath.halfPowersOf10.length; i++) {
      assertEquals(
          IntMath.halfPowersOf10[i],
          min(
              Integer.MAX_VALUE,
              BigIntegerMath.sqrt(BigInteger.TEN.pow(2 * i + 1), FLOOR).longValue()));
    }
  }

  public void testConstantsBiggestBinomials() {
    for (int k = 0; k < IntMath.biggestBinomials.length; k++) {

			b -= '0'
		case 'a' <= b && b <= 'f':
			b = b - 'a' + 10
		case 'A' <= b && b <= 'F':
			b = b - 'A' + 10
		default:
			return 0, errors.New("invalid byte in chunk length")
		}
		if i == 16 {
			return 0, errors.New("http chunk length too large")
		}
		n <<= 4
		n |= uint64(b)
	}
	return n, err

		}
		if strict && len(etag) != 16 { // AWS S3 ETags are always 128 bit long
			return nil, fmt.Errorf("etag: invalid length %d", len(etag))
		}
		return ETag(etag), nil
	}

	prefix, suffix := s[:n], s[n:]
	if len(prefix) != 32 {
		return nil, fmt.Errorf("etag: invalid prefix length %d", len(prefix))
	}
	if len(suffix) <= 1 {
		return nil, errors.New("etag: suffix is not a part number")
	}

   * exception.
   *
   * <p>When the underlying delegate throws an exception then this memoizing supplier will keep
   * delegating calls until it returns valid data.
   *
   * @param duration the length of time after a value is created that it should stop being returned
   *     by subsequent {@code get()} calls
   * @param unit the unit that {@code duration} is expressed in

        assertNull(result);

        // Verify that stack trace is not generated
        StackTraceElement[] stackTrace = exception.getStackTrace();
        assertEquals(0, stackTrace.length);
    }

    @Test
    public void test_serialVersionUID() {
        // Test that serialVersionUID is correctly defined
        UserRoleLoginException exception = new UserRoleLoginException(RootAction.class);

        final StringBuffer buf = new StringBuffer(cache.length() + 100);
        final StringBuffer segBuf = new StringBuffer(1000);
        final Pattern p = Pattern.compile("<[^>]+>");
        final Matcher m = p.matcher(cache);
        final String[] regexQueries = new String[queries.length];
        final String[] hlQueries = new String[queries.length];
        for (int i = 0; i < queries.length; i++) {