};

        FwAssistantDirector assistantDirector = createMockAssistantDirector();
        customHook.hook(assistantDirector);

        // Verify that exception was handled
        assertTrue(exceptionHandled.get());
    }

    // Test with a custom ClassLoader to simulate class availability
    @Test
    public void test_hook_withCustomClassLoader() throws Exception {

    @PathSensitive(PathSensitivity.RELATIVE)
    public abstract DirectoryProperty getJsonFilesDirectory();

    @TaskAction
    public void checkMissingFiles() {
        String directoryPath = getDocumentationRoot().get().toString();
        FileCollection jsonFiles = getJsonFilesDirectory().getAsFileTree().filter(file -> file.getName().endsWith(".json"));

        try {
            List<String> allErrors = new ArrayList<>();

    /*
     * We need to wait for the runner to exit. It used to be that the runner would get stuck in the
     * busy loop when interrupt threw.
     *
     * While we're at it, we confirm that the interrupt happened as expected.
     */
    ExecutionException fromRunInterruptibly =
        assertThrows(ExecutionException.class, () -> taskResult.get(10, SECONDS));

    }

    @Override
    Cell<R, C, V> get(int index) {
      return getCell(index);
    }

    @Override
    public boolean contains(@Nullable Object object) {
      if (object instanceof Cell) {
        Cell<?, ?, ?> cell = (Cell<?, ?, ?>) object;
        Object value = RegularImmutableTable.this.get(cell.getRowKey(), cell.getColumnKey());

    int size = getNumElements();

    assertThrows(
        NullPointerException.class, () -> multimap().putAll(k3(), newArrayList(v3(), null)));

    Collection<V> values = multimap().get(k3());
    if (values.size() == 0) {
      expectUnchanged();
      // Be extra thorough in case internal state was corrupted by the expected null.
      assertEquals(new ArrayList<>(), new ArrayList<>(values));

    /*
     * We need to wait for the runner to exit. It used to be that the runner would get stuck in the
     * busy loop when interrupt threw.
     *
     * While we're at it, we confirm that the interrupt happened as expected.
     */
    ExecutionException fromRunInterruptibly =
        assertThrows(ExecutionException.class, () -> taskResult.get(10, SECONDS));

        if (ongoing.get(new TransferResourceIdentifier(event.getResource())) == Boolean.FALSE) {
            throw new TransferCancelledException();
        }
        put(event, false);
    }

    @Override
    public void transferProgressed(TransferEvent event) throws TransferCancelledException {
        if (ongoing.get(new TransferResourceIdentifier(event.getResource())) == Boolean.FALSE) {

      return array;
    }
    Method emptyGenerate = EMPTY_GENERATORS.get(rawType);
    if (emptyGenerate != null) {
      if (emptyInstanceGenerated.containsKey(type.getType())) {
        // empty instance already generated
        if (emptyInstanceGenerated.get(type.getType()) == freshness.get()) {
          // same freshness, generate again.
          return invokeGeneratorMethod(emptyGenerate);

#### Blocking APIs

Blocking APIs are convenient because you get top-to-bottom procedural code without indirection. Network calls work like regular method calls: ask for data and it is returned. If the request fails, you get a stacktrace right where the call was made.

      if (++bucketSize > MAX_HASH_BUCKET_LENGTH) {
        throw new BucketOverflowException();
      }
    }
  }

  @Override
  public @Nullable V get(@Nullable Object key) {
    return RegularImmutableMap.get(key, keyTable, mask);
  }

  @Override
  ImmutableSet<Entry<K, V>> createEntrySet() {
    return isEmpty()
        ? ImmutableSet.of()