public void store(DataStoreParams paramMap, Map<String, Object> dataMap) {
                try {
                    Thread.sleep(10); // Simulate processing time
                } catch (InterruptedException e) {
                    // Ignore
                }
                totalTime = System.currentTimeMillis() - startTime;
            }

            @Override
            public long getDocumentSize() {

                    watchCount++;
                    try {
                        // Simulate some processing time
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                    return Arrays.asList(createMockNotification("file" + watchCount + ".txt"));
                }

            if (goal == null) {
                return badGoalsErrorMessage("Unknown goal: " + goalName, context);
            }

            return goal.execute(context);
        } catch (InterruptedException | InterruptedIOException | UserInterruptException e) {
            context.logger.error("Goal canceled by user.");
            return CANCELED;
        } catch (Exception e) {

            if (goal == null) {
                return badGoalsErrorMessage("Unknown goal: " + goalName, context);
            }

            return goal.execute(context);
        } catch (InterruptedException | InterruptedIOException | UserInterruptException e) {
            context.logger.error("Goal canceled by user.");
            return CANCELED;
        } catch (Exception e) {

   *     ExecutionException} is thrown <a
   *     href="https://github.com/google/guava/wiki/CachesExplained#interruption">even if
   *     computation was interrupted by an {@code InterruptedException}</a>.)
   * @throws UncheckedExecutionException if an unchecked exception was thrown while loading the
   *     value
   * @throws ExecutionError if an error was thrown while loading the value
   */

   * request was sent as intended. This method will block until the request is available, possibly
   * forever.
   *
   * @return the head of the request queue
   */
  @Throws(InterruptedException::class)
  public fun takeRequest(): RecordedRequest = requestQueue.take()

  /**
   * Awaits the next HTTP request (waiting up to the specified wait time if necessary), removes it,

        }
        responseQueue.put(new Response(request.methodName, result, null));
      }
    } catch (ThreadDeath death) {
      return;
    } catch (InterruptedException ignored) {
      // SynchronousQueue sometimes throws InterruptedException while the threads are stopping.
    } catch (Throwable uncaught) {
      this.uncaughtThrowable = uncaught;
    }
  }

  private static class Request {

                  // own. See Cleaner class inside {@link LogManager}.
                  service.awaitTermination(terminationTimeout, timeUnit);
                } catch (InterruptedException ignored) {
                  // We're shutting down anyway, so just ignore.
                }
              }));
    }

    @VisibleForTesting
    void addShutdownHook(Thread hook) {

    assertEquals(Strength.WEAK, internerImpl.map.keyStrength());
    assertEquals(concurrencyLevel, internerImpl.map.concurrencyLevel);
  }


  public void testWeak_afterGC() throws InterruptedException {
    MyInt canonical = new MyInt(5);
    MyInt not = new MyInt(5);

    Interner<MyInt> pool = Interners.newWeakInterner();
    assertThat(pool.intern(canonical)).isSameInstanceAs(canonical);

    private volatile boolean running = false;

    @Override
    public @Nullable Void call() throws InterruptedException {
      running = true;
      startLatch.countDown();
      stopLatch.await();
      running = false;
      return null;
    }

    void waitForStart() throws InterruptedException {
      startLatch.await();
    }

    void stop() {
      stopLatch.countDown();
    }