@SuppressWarnings("serial") // we're overriding default serialization
// TODO(kevinb): I think we should push everything down to "BaseImmutableCollection" or something,
// just to do everything we can to emphasize the "practically an interface" nature of this class.
public abstract class ImmutableCollection<E> extends AbstractCollection<E> implements Serializable {
  /*
   * We expect SIZED (and SUBSIZED, if applicable) to be added by the spliterator factory methods.

<module>
<source path="">
  <!-- Hack to keep collect from hiding collect.testing supersource: -->
  <exclude name="**/testing/**"/>
</source>

<!--
    We used to set this only for packages that had manual supersource. That
    worked everywhere that I know of except for one place: when running the GWT
    util.concurrent tests under Guava.

    The problem is that GWT responds poorly to two .gwt.xml files in the same
    Java package; see

    false
  }

/**
 * Returns true if new reads and writes should be attempted on this.
 *
 * Unfortunately Java's networking APIs don't offer a good health check, so we go on our own by
 * attempting to read with a short timeout. If the fails immediately we know the socket is
 * unhealthy.
 *
 * @param source the source used to read bytes from the socket.
 */
internal fun Socket.isHealthy(source: BufferedSource): Boolean =

    return emptySet();
  }

  protected Collection<Method> suppressForVector() {
    return emptySet();
  }

  @SuppressWarnings("EmptyList") // We specifically want to test emptyList()
  public Test testsForEmptyList() {
    return ListTestSuiteBuilder.using(
            new TestStringListGenerator() {
              @Override

		// If we don't have permission to compute the HMAC, don't change the cred.
		return globalActiveCred
	}
	if err != nil {
		logger.Fatal(err, "Unable to generate root access key using KMS")
	}

	sKey, err := GlobalKMS.MAC(GlobalContext, &kms.MACRequest{Message: []byte("root secret key")})
	if err != nil {
		// Here, we must have permission. Otherwise, we would have failed earlier.

		records, err := c.list(key, false)
		if err != nil {
			return nil, err
		}
		// Make sure we have record.Key is empty
		// this can only happen when record.Key
		// has bucket entry with exact prefix
		// match any record.Key which do not
		// match the prefixes we skip them.
		for _, record := range records {
			if record.Key != "" {
				continue
			}
			srvRecords = append(srvRecords, record)

            }
            metadataSources {
                artifact()
            }
            content {
                includeModule('gradle', 'gradle')
            }
        }
    }
}

// We support multiple accepted public api changes JSON files, but "accepted-public-api-changes.json"
// is the "main" one that is also shown in HTML report

You have found a bug or you have an idea for a cool new feature? Contributing
code is a great way to give something back to the open source community. Before
you dig right into the code, there are a few guidelines that we need
contributors to follow so that we can have a chance of keeping on top of
things.

Some of the ideas are documented in the [Maven Wiki][maven-wiki]
which might be interesting to read and for further discussion.

Getting Started

 * under GWT but with a slightly different signature.
 *
 * <p>We can't use {@code PartiallyGwtIncompatible} because then the GWT compiler wouldn't recognize
 * it as a {@code GwtIncompatible} annotation. And for {@code Futures.catching}, we need the GWT
 * compiler to autostrip the normal server method in order to expose the special, inherited GWT
 * version.
 */
@GwtCompatible

		return false, ctx.Err()
	}
	if len(args.UID) == 0 {
		for _, resource := range args.Resources {
			lris, ok := l.lockMap[resource]
			if !ok {
				continue
			}
			// Collect uids, so we don't mutate while we delete
			uids := make([]string, 0, len(lris))
			for _, lri := range lris {
				uids = append(uids, lri.UID)
			}

			// Delete collected uids:
			for _, uid := range uids {