Files.createDirectories(target.getParent());
                try {
                    Files.deleteIfExists(target);
                    Files.createLink(target, source);
                } catch (UnsupportedOperationException | IOException suppressed) {
                    LOGGER.info("Copying {} to project local repository.", artifact);
                    try {
                        Files.copy(

      this.unusableDelegate =
          (SetMultimap<K, V>)
              newProxy(
                  SetMultimap.class,
                  (proxy, method, args) -> {
                    throw new UnsupportedOperationException();
                  });
    }

    @Override
    protected Multimap<K, V> delegate() {
      return unusableDelegate;
    }

    @Override
    public boolean put(K key, V value) {

   * The returned collection is a live view of {@code fromCollection}; changes to one affect the
   * other.
   *
   * <p>The returned collection's {@code add()} and {@code addAll()} methods throw an {@link
   * UnsupportedOperationException}. All other collection methods are supported, as long as {@code
   * fromCollection} supports them.
   *
   * <p>The returned collection isn't threadsafe or serializable, even if {@code fromCollection} is.
   *

        override fun configureSocket(sslSocket: SSLSocket): SSLSocket =
          object : DelegatingSSLSocket(sslSocket) {
            override fun getApplicationProtocol(): String = throw UnsupportedOperationException()
          }
      }

    client =
      client
        .newBuilder()
        .sslSocketFactory(delegatingSocketFactory, trustManager)
        .build()

    final String string;

    public HashHostileComparable(String string) {
      this.string = string;
    }

    @Override
    public int hashCode() {
      throw new UnsupportedOperationException();
    }

    @Override
    public int compareTo(HashHostileComparable o) {
      return string.compareTo(o.string);
    }
  }

 * elements. This is simply a refinement of {@code Collection}'s constructor recommendations.
 *
 * <p>As with other collection types, the modification operations are optional, and should throw
 * {@link UnsupportedOperationException} when they are not implemented. Most implementations should
 * support either all add operations or none of them, all removal operations or none of them, and if

         * a clear specification for what annotations should mean on resolved TypeVariables
         * with modified bounds, annotation methods will throw
         * UnsupportedOperationException. Frameworks requiring annotation preservation
         * should use the original TypeVariable when bounds haven't changed.
         */
        if (Types.NativeTypeVariableEquals.NATIVE_TYPE_VARIABLE_ONLY

    }
  }

  /** Subclasses can override to provide different return value for proxied interface methods. */
  @Nullable Object interfaceMethodCalled(Class<?> interfaceType, Method method) {
    throw new UnsupportedOperationException();
  }

  private <T> T pickInstance(T[] instances, T defaultValue) {
    return pickInstance(Arrays.asList(instances), defaultValue);
  }

  }

  public void testFromArrayAndIteratorRemove() {
    FluentIterable<TimeUnit> units = FluentIterable.from(TimeUnit.values());
    assertThrows(UnsupportedOperationException.class, () -> removeIf(units, equalTo(SECONDS)));
  }

  public void testFrom() {
    assertEquals(
        ImmutableList.of(1, 2, 3, 4),

   *
   * @param b the instance to convert; will never be null
   * @return the converted instance; <b>must not</b> be null
   * @throws UnsupportedOperationException if backward conversion is not implemented; this should be
   *     very rare. Note that if backward conversion is not only unimplemented but