headerValue = null
  }

  return CacheControl(
    noCache = noCache,
    noStore = noStore,
    maxAgeSeconds = maxAgeSeconds,
    sMaxAgeSeconds = sMaxAgeSeconds,
    isPrivate = isPrivate,
    isPublic = isPublic,
    mustRevalidate = mustRevalidate,
    maxStaleSeconds = maxStaleSeconds,
    minFreshSeconds = minFreshSeconds,
    onlyIfCached = onlyIfCached,
    noTransform = noTransform,

  }

  /** Returns true if the element is package-private. */
  public final boolean isPackagePrivate() {
    return !isPrivate() && !isPublic() && !isProtected();
  }

  /** Returns true if the element is private. */
  public final boolean isPrivate() {
    return Modifier.isPrivate(getModifiers());
  }

  /** Returns true if the element is static. */
  public final boolean isStatic() {

    assertThat(cacheControl.immutable).isTrue()

    // These members are accessible to response headers only.
    assertThat(cacheControl.sMaxAgeSeconds).isEqualTo(-1)
    assertThat(cacheControl.isPrivate).isFalse()
    assertThat(cacheControl.isPublic).isFalse()
    assertThat(cacheControl.mustRevalidate).isFalse()
  }

  @Test
  @Throws(Exception::class)
  fun parseEmpty() {
    val cacheControl =

        try {
            Constructor<SystemUtil> constructor = SystemUtil.class.getDeclaredConstructor();
            assertTrue("Constructor should be private", java.lang.reflect.Modifier.isPrivate(constructor.getModifiers()));

            // Test that constructor is accessible when made accessible
            constructor.setAccessible(true);
            SystemUtil instance = constructor.newInstance();

    assertTrue(delegate.isPrivate());
    assertFalse(delegate.isOverridable());
    assertFalse(delegate.isVarArgs());
  }

  public void testPrivateFinalInstanceMethod_isOverridable() throws Exception {
    Invokable<?, ?> delegate = Prepender.method("privateFinalMethod");
    assertTrue(delegate.isPrivate());
    assertTrue(delegate.isFinal());

                assertTrue("Private append methods should be private: " + method.getName(),
                        java.lang.reflect.Modifier.isPrivate(method.getModifiers()));
            }
        }
    }

    @Test
    public void test_multiple_instances() {
        SystemMonitorTarget target1 = new SystemMonitorTarget();

        try {
            Constructor<WebApiUtil> constructor = WebApiUtil.class.getDeclaredConstructor();
            assertTrue("Constructor should be private", java.lang.reflect.Modifier.isPrivate(constructor.getModifiers()));

            // Test that constructor is accessible when made accessible
            constructor.setAccessible(true);
            WebApiUtil instance = constructor.newInstance();

        try {
            Constructor<KuromojiCSVUtil> constructor = KuromojiCSVUtil.class.getDeclaredConstructor();
            assertTrue("Constructor should be private", java.lang.reflect.Modifier.isPrivate(constructor.getModifiers()));

            // Test that constructor is accessible when made accessible
            constructor.setAccessible(true);
            KuromojiCSVUtil instance = constructor.newInstance();

        assertNotNull(serialVersionField);
        assertTrue(Modifier.isStatic(serialVersionField.getModifiers()));
        assertTrue(Modifier.isFinal(serialVersionField.getModifiers()));
        assertTrue(Modifier.isPrivate(serialVersionField.getModifiers()));
        serialVersionField.setAccessible(true);
        assertEquals(1L, serialVersionField.getLong(null));
    }

    /**

          if (response.header("Expires") == null &&
            response.cacheControl.maxAgeSeconds == -1 &&
            !response.cacheControl.isPublic &&
            !response.cacheControl.isPrivate
          ) {
            return false
          }
        }

        else -> {
          // All other codes cannot be cached.
          return false
        }
      }