@Override
            protected long getCurrentTime() {
                return System.currentTimeMillis();
            }
        };
        roleQueryHelper.init();

        // Mock request with cached USER_ROLES
        Set<String> cachedRoles = new HashSet<>();
        cachedRoles.add("cached_role");
        getMockRequest().setAttribute("userRoles", cachedRoles);

  }

  /**
   * Invoked when a response will be served from the cache or network based on validating the
   * cached Response freshness. Will be followed by cacheHit or cacheMiss after the network
   * Response is available.
   *
   * This event will only be received when a Cache is configured for the client.
   */
  open fun cacheConditionalHit(
    call: Call,
    cachedResponse: Response,
  ) {
  }

 *
 * ### The response body must be closed.
 *
 * Each response body is backed by a limited resource like a socket (live network responses) or
 * an open file (for cached responses). Failing to close the response body will leak resources and
 * may ultimately cause the application to slow down or crash.
 *
 * Both this class and [Response] implement [Closeable]. Closing a response simply

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.cache2

import java.io.File
import java.io.IOException
import java.io.RandomAccessFile
import okhttp3.internal.closeQuietly
import okhttp3.internal.concurrent.Lockable
import okhttp3.internal.concurrent.notifyAll

```java
/** Dangerous interceptor that rewrites the server's cache-control header. */
private static final Interceptor REWRITE_CACHE_CONTROL_INTERCEPTOR = new Interceptor() {

         * It's very unlikely that any loaded Futures class will see getChecked called with more
         * than a handful of exceptions. But it seems prudent to set a cap on how many we'll cache.
         * This avoids out-of-control memory consumption, and it keeps the cache from growing so
         * large that doing the lookup is noticeably slower than redoing the work would be.
         *

 * Fix: Persist proper `Content-Encoding` header to cache for GZip responses.
 * Fix: Eliminate rare race condition in SPDY streams that would prevent connection reuse.
 * Fix: Change HTTP date formats to UTC to conform to RFC2616 section 3.3.
 * Fix: Support SPDY header blocks with trailing bytes.
 * Fix: Allow `;` as separator for `Cache-Control` header.

import org.codelibs.core.exception.UnsupportedEncodingRuntimeException;
import org.codelibs.core.misc.Base64Util;

/**
 * A utility class for encrypting and decrypting data using a cached {@link Cipher} instance.
 */
public class CachedCipher {

    /**
     * Creates a new {@link CachedCipher} instance.
     */
    public CachedCipher() {
    }

        }).orElse(StringUtil.EMPTY_STRINGS);
    }

    /**
     * Retrieves or creates the result document IDs cache from the session.
     * The cache is implemented as an LRU map to limit memory usage.
     *
     * @param session the HTTP session
     * @return the result document IDs cache map
     */
    private Map<String, String[]> getResultDocIdsCache(final HttpSession session) {

      apply {
        this.headers = headers.newBuilder()
      }

    /**
     * Sets this request's `Cache-Control` header, replacing any cache control headers already
     * present. If [cacheControl] doesn't define any directives, this clears this request's
     * cache-control headers.
     */
    open fun cacheControl(cacheControl: CacheControl): Builder {
      val value = cacheControl.toString()