try {
            Field f = findField(target.getClass(), name);
            f.setAccessible(true);
            f.set(target, value);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    // Utility: reflectively get a private/protected field (searches up the hierarchy)
    private static Object getField(Object target, String name) {
        try {

     */
    @Override
    public SmbResource get(final String url) throws CIFSException {
        try {
            return new SmbFile(url, this);
        } catch (final MalformedURLException e) {
            throw new CIFSException("Invalid URL " + url, e);
        }
    }

    /**
     *
     * {@inheritDoc}
     *
     * @see jcifs.CIFSContext#getPipe(java.lang.String, int)
     */
    @Override

            getMap()
                .compute(
                    k0(),
                    (k, v) -> {
                      assertEquals(k0(), k);
                      assertEquals(v0(), v);
                      throw new SomeUncheckedException();
                    }));
    expectUnchanged();
  }

  @MapFeature.Require({SUPPORTS_PUT, SUPPORTS_REMOVE})
  public void testCompute_absentFunctionThrows() {
    assertThrows(

      @Override
      public V load(K key) {
        throw e;
      }
    };
  }

  /** Returns a {@link CacheLoader} that throws the given exception for every request. */
  static <K, V> CacheLoader<K, V> exceptionLoader(Exception e) {
    checkNotNull(e);
    return new CacheLoader<K, V>() {
      @Override
      public V load(K key) throws Exception {
        throw e;
      }
    };
  }

    FutureCallback<String> callback =
        new FutureCallback<String>() {
          @Override
          public void onSuccess(String result) {
            successCalls[0]++;
            throw exception;
          }

          @Override
          public void onFailure(Throwable t) {
            failureCalls[0]++;
          }
        };
    addCallback(future, callback, directExecutor());

            getMap()
                .compute(
                    k0(),
                    (k, v) -> {
                      assertEquals(k0(), k);
                      assertEquals(v0(), v);
                      throw new SomeUncheckedException();
                    }));
    expectUnchanged();
  }

  @MapFeature.Require({SUPPORTS_PUT, SUPPORTS_REMOVE})
  public void testCompute_absentFunctionThrows() {
    assertThrows(

  public int add(@ParametricNullness E element, int occurrences) {
    throw new UnsupportedOperationException();
  }

  @CanIgnoreReturnValue
  @Override
  public final boolean remove(@Nullable Object element) {
    return remove(element, 1) > 0;
  }

  @CanIgnoreReturnValue
  @Override
  public int remove(@Nullable Object element, int occurrences) {
    throw new UnsupportedOperationException();
  }

  @CanIgnoreReturnValue

        testProcessHelper.exitValue = 1;
        testProcessHelper.processOutput = "Generation failed";

        try {
            thumbnailJob.executeThumbnailGenerator();
            fail("Should throw JobProcessingException");
        } catch (JobProcessingException e) {
            assertTrue(e.getMessage().contains("Thumbnail Process terminated."));
        } catch (NullPointerException e) {

  private val dnsServers: List<InetAddress>,
) : Dns {
  @Throws(UnknownHostException::class)
  override fun lookup(hostname: String): List<InetAddress> {
    if (this.dnsHostname != hostname) {
      throw UnknownHostException(
        "BootstrapDns called for $hostname instead of $dnsHostname",
      )
    }

    return dnsServers
  }

  Table<String, Integer, Character> makeTable() {
    return ArrayTable.create(asList("foo", "bar", "dog"), asList(1, 2, 3));
  }

  @Override
  protected Map<String, Map<Integer, Character>> makeEmptyMap() {
    throw new UnsupportedOperationException();
  }