Monitor monitor = this.monitor;
    monitor.enter();
    try {
      return q.toString();
    } finally {
      monitor.leave();
    }
  }

  /**
   * @throws UnsupportedOperationException {@inheritDoc}
   * @throws ClassCastException {@inheritDoc}
   * @throws NullPointerException {@inheritDoc}
   * @throws IllegalArgumentException {@inheritDoc}
   */

        testCoverage: TestCoverage,
        bucketIndex: Int,
    ): FunctionalTest

    fun getName(testCoverage: TestCoverage): String = throw UnsupportedOperationException()

    fun getDescription(testCoverage: TestCoverage): String = throw UnsupportedOperationException()
}

data class GradleSubproject(
    val name: String,
    val path: String,
    val unitTests: Boolean = true,

        if (!iterator.hasNext()) {
          iterator = iterable.iterator();
        }
        return iterator.next();
      }

      @Override
      public void remove() {
        throw new UnsupportedOperationException();
      }
    };
  }

  static <T extends @Nullable Object> T get(Iterator<T> iterator, int position) {
    for (int i = 0; i < position; i++) {
      iterator.next();
    }

                    InvalidDependencyVersionException, PluginManagerException, PluginConfigurationException {
        throw new UnsupportedOperationException();
    }

    @Override
    public Object getPluginComponent(Plugin plugin, String role, String roleHint)
            throws PluginManagerException, ComponentLookupException {

  @Override
  public ImmutableSet<V> values() {
    return inverse().keySet();
  }

  public final @Nullable V forcePut(K key, V value) {
    throw new UnsupportedOperationException();
  }

   * (might fail some JDKs).
   *
   * <p>See <a href="https://github.com/google/guava/issues/2887">Throwables#lazyStackTrace throws
   * UnsupportedOperationException</a>.
   */
  @J2ktIncompatible
  @GwtIncompatible // java.lang.reflect
  private static @Nullable Method getSizeMethod(Object jla) {
    try {

                throw new IllegalArgumentException();
              }

              @Override
              public Integer next() {
                // Wrong exception type.
                throw new UnsupportedOperationException();
              }

              @Override
              public boolean hasNext() {
                return false;
              }
            };
          }
        };

        i = inc(i);
      }
      count = 0;
      putIndex = 0;
      takeIndex = 0;
    } finally {
      monitor.leave();
    }
  }

  /**
   * @throws UnsupportedOperationException {@inheritDoc}
   * @throws ClassCastException {@inheritDoc}
   * @throws NullPointerException {@inheritDoc}
   * @throws IllegalArgumentException {@inheritDoc}
   */
  @CanIgnoreReturnValue
  @Override

   *
   * <p>Because of the nature of single-thread execution, the methods {@code scheduleAtFixedRate}
   * and {@code scheduleWithFixedDelay} are not supported by this class and will throw an
   * UnsupportedOperationException.
   *
   * <p>The implementation deviates from the {@code ExecutorService} specification with regards to
   * the {@code shutdownNow} method. First, "best-effort" with regards to canceling running tasks is

    extends AbstractMultimapTester<K, V, Multimap<K, V>> {
  @MapFeature.Require(absent = SUPPORTS_PUT)
  public void testPutUnsupported() {
    assertThrows(UnsupportedOperationException.class, () -> multimap().put(k3(), v3()));
  }

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutEmpty() {
    int size = getNumElements();

    assertGet(k3(), ImmutableList.of());