throw new RuntimeException("Repository error");
            }
        };

        try {
            errorHelper.getAvailableArtifacts(ArtifactType.DATA_STORE);
            fail("Expected PluginException");
        } catch (PluginException e) {
            assertTrue(e.getMessage().contains("Failed to access"));
        }
    }

    @Test
    public void test_getInstalledArtifacts_unknown() {

    }

    /** Awaits the latch and asserts that operation completed in the expected timeframe. */
    final void awaitSuccessfully() {
      awaitLatchUninterruptibly();
      completed.assertCompletionExpected();
      assertEquals(0, getCount());
    }

    /**
     * Awaits the latch with a timeout and asserts that operation completed in the expected
     * timeframe.
     */

    private void assertArrayEquals(String[] expected, String[] actual) {
        if (expected == null && actual == null) {
            return;
        }
        if (expected == null || actual == null) {
            fail("Arrays are not equal: one is null");
        }
        assertEquals("Array lengths differ", expected.length, actual.length);
        for (int i = 0; i < expected.length; i++) {

    ValueAndCloser<?> valueAndCloser = finishToValueAndCloser(closingFuture);
    try {
      valueAndCloser.get();
      fail();
    } catch (ExecutionException expected) {
      assertThat(expected).hasCauseThat().isSameInstanceAs(exception);
    }
    valueAndCloser.closeAsync();
  }

  @Override
  void assertBecomesCanceled(ClosingFuture<?> closingFuture) throws ExecutionException {

  @CollectionSize.Require(absent = ZERO)
  public void testReplace_unsupportedPresent() {
    try {
      getMap().replace(k0(), v3());
      fail("Expected UnsupportedOperationException");
    } catch (UnsupportedOperationException expected) {
    } catch (ClassCastException tolerated) {
      // for ClassToInstanceMap
    }

    expectUnchanged();
  }

            } catch (FileAlreadyExistsException expected) {
              // if a file already exists, that's fine... just continue
            }

            try {
              method.delete(dirToDelete);
            } catch (FileSystemException expected) {
              // the delete method may or may not throw an exception, but if it does that's fine
              // and expected
            }

  }

  private static void assertValueAndTypeEquals(Object expected, Object actual) {
    assertEquals(expected, actual);
    assertEquals(expected.getClass(), actual.getClass());
  }

    private boolean expectCall = false;
    private final CountDownLatch calledCountDown = new CountDownLatch(1);

    @Override
    public void run() {
      assertTrue("Listener called before it was expected", expectCall);
      assertFalse("Listener called more than once", wasCalled());
      calledCountDown.countDown();
    }

    void expectCall() {
      assertFalse("expectCall is already true", expectCall);

 * or method references instead of classes, leaving your code easier to migrate in the future.
 *
 * <p>To use an existing function (say, named {@code function}) in a context where the <i>other
 * type</i> of function is expected, use the method reference {@code function::apply}. A future
 * version of {@code com.google.common.base.Function} will be made to <i>extend</i> {@code

                  sink.flush()
                  sleep(100)
                }
                fail("Expected connection to be closed")
              }
            },
        ),
      )
    cancelLater(call, 500)
    assertFailsWith<IOException> {
      call.execute()
    }.also { expected ->
      assertEquals(cancelMode == INTERRUPT, Thread.interrupted())
    }
  }

  @Test