* contains objects that are supposed to be equal to each other. Objects of different groups are
 * expected to be unequal. For example:
 *
 * {@snippet :
 * EquivalenceTester.of(someStringEquivalence)
 *     .addEquivalenceGroup("hello", "h" + "ello")
 *     .addEquivalenceGroup("world", "wor" + "ld")
 *     .test();
 * }
 *

 * contains objects that are supposed to be equal to each other. Objects of different groups are
 * expected to be unequal. For example:
 *
 * {@snippet :
 * EquivalenceTester.of(someStringEquivalence)
 *     .addEquivalenceGroup("hello", "h" + "ello")
 *     .addEquivalenceGroup("world", "wor" + "ld")
 *     .test();
 * }
 *

			actualSize: -1,
			sha256hex:  "88d4266fd4e6338d13b845fcf289579d209c897823b9217da3e161936f031589",
			err:        ioutil.ErrOverread,
		},
		7: {
			desc:       "Correct sha256, nested, truncated, swapped",
			src:        mustReader(t, bytes.NewReader([]byte("abcd-more-stuff-to-be ignored")), 4, "", "", -1),
			size:       4,
			actualSize: -1,
			sha256hex:  "88d4266fd4e6338d13b845fcf289579d209c897823b9217da3e161936f031589",

 * generally prefer the methods in {@link Comparator}; see <a href="#java8">below</a>.
 *
 * <p>Example usage of {@code ComparisonChain}:
 *
 * {@snippet :
 * public int compareTo(Foo that) {
 *   return ComparisonChain.start()
 *       .compare(this.aString, that.aString)
 *       .compare(this.anInt, that.anInt)

```sh
docker ps -a
```

`-a` flag makes sure you get all the containers (Created, Running, Exited). Then identify the `Container ID` from the output.

### Starting and Stopping Containers

To start a stopped container, you can use the [`docker start`](https://docs.docker.com/engine/reference/commandline/start/) command.

```sh
docker start <container_id>
```

   * {@code Comparator}) input elements, in ascending order, as an unmodifiable {@code List}. Ties
   * are broken arbitrarily.
   *
   * <p>For example:
   *
   * {@snippet :
   * Stream.of("foo", "quux", "banana", "elephant")
   *     .collect(least(2, comparingInt(String::length)))
   * // returns {"foo", "quux"}
   * }
   *

     * <p>Returns {@code true} if the given object is also a multiset entry and the two entries
     * represent the same element and count. That is, two entries {@code a} and {@code b} are equal
     * if:
     *
     * {@snippet :
     * Objects.equals(a.getElement(), b.getElement())
     *     && a.getCount() == b.getCount()
     * }
     */
    @Override
    // TODO(kevinb): check this wrt TreeMultiset?

 * annotated by {@link TestSubtype}.
 *
 * <p>These declaration methods rely on Java static type checking to make sure what we want to
 * assert as subtypes are really subtypes according to javac. For example:
 *
 * {@snippet :
 * class MySubtypeTests extends SubtypeTester {
 *   @TestSubtype(suppressGetSubtype = true, suppressGetSupertype = true)
 *   public <T> Iterable<? extends T> listIsSubtypeOfIterable(List<T> list) {

The tests:

## Code snippets { #code-snippets }

//// tab | Test

This is a code snippet: `foo`. And this is another code snippet: `bar`. And another one: `baz quux`.

////

//// tab | Info

Content of code snippets should be left as is.

 * its {@code close} method. You could use a finalizer to accomplish this, but that has a
 * number of well-known problems. Here is how you might use this class instead:
 *
 * {@snippet :
 * public class MyServer implements Closeable {
 *   private static final FinalizableReferenceQueue frq = new FinalizableReferenceQueue();
 *   // You might also share this between several objects.
 *