* <p>A typical usage is to invoke this method for all dependencies having a
     * {@link DependencyScope#TEST TEST} or {@link DependencyScope#TEST_ONLY TEST_ONLY}
     * {@linkplain Dependency#getScope() scope}. An {@code --add-reads} option may need
     * to be generated for compiling and running the test classes that use such dependencies.</p>
     *
     * @param dependency path to the dependency for which to get the module name

	// provided buffer.
	if cr.offset > 0 {
		n = copy(buf, cr.buffer[cr.offset:])
		if n == len(buf) {
			cr.offset += n
			return n, nil
		}
		cr.offset = 0
		buf = buf[n:]
	}
	// mustRead reads from input and compares against provided slice.
	mustRead := func(b ...byte) error {
		for _, want := range b {
			got, err := cr.reader.ReadByte()
			if err == io.EOF {
				return io.ErrUnexpectedEOF
			}

        return (GetCheckedTypeValidator) theClass.getEnumConstants()[0];
      } catch (ClassNotFoundException
          | RuntimeException
          | Error t) { // ensure we really catch *everything*
        return weakSetValidator();
      }
    }
  }

  // TODO(cpovirk): change parameter order to match other helper methods (Class, Throwable)?

   * auth param in the challenge at key null. Invalid headers and challenges are ignored.
   * No semantic validation is done, for example that `Basic` auth must have a `realm`
   * auth param, this is up to the caller that interprets these challenges.
   */
  fun challenges(): List<Challenge> {
    return headers.parseChallenges(
      when (code) {

            } catch (Exception e) {
                exceptions.add(e);
            } finally {
                endLatch.countDown();
            }
        });

        // Thread 2: Continuously reads trees
        executor.submit(() -> {
            try {
                for (int i = 0; i < iterations; i++) {
                    // This would cause ConcurrentModificationException with ArrayList

		"Cluster object size distribution", "range")
	usageVersionsDistributionMD = NewGaugeMD(usageVersionCountDistribution,
		"Cluster object version count distribution", "range")
)

// loadClusterUsageObjectMetrics - reads cluster usage metrics.
//
// This is a `MetricsLoaderFn`.
func loadClusterUsageObjectMetrics(ctx context.Context, m MetricValues, c *metricsCache) error {
	dataUsageInfo, err := c.dataUsageInfo.Get()
	if err != nil {

details can be found in the [DNS README](https://github.com/kubernetes/kubernetes/blob/release-1.2/cluster/saltbase/salt/kube-dns/README.md#a-records-and-hostname-based-on-pod-annotations---a-beta-feature-in-kubernetes-v12). Changes were introduced in PR [#20688](https://github.com/kubernetes/kubernetes/pull/20688).

      /*
       * Since reflection can't tell the difference between <T> and <T extends Object>, it doesn't
       * make a ton of sense to have a separate tests for each. But having tests for each doesn't
       * really hurt anything, and maybe it will serve a purpose in a future in which Java has a
       * built-in nullness feature?
       */
      "ExtendsObject",
    })
    <T extends Object> void withObjectBound(List<T> list) {}

 * test with reference to the same "lock-like object", and then their interactions with that object
 * are choreographed via the various methods on this class.
 *
 * <p>A "lock-like object" is really any object that may be used for concurrency control. If the
 * {@link #callAndAssertBlocks} method is ever called in a test, the lock-like object must have a

            <multiplicity>*</multiplicity>
          </association>
          <comment><![CDATA[ This may be removed or relocated in the near
            future. It is undecided whether plugins really need a remote
            repository set of their own. ]]></comment>
        </field>
      </fields>
    </class>
    <class>
      <name>Activation</name>
      <version>1.0.0</version>