* ClosingFuture#finishToValueAndCloser(ValueAndCloserConsumer, Executor)}.
 */
@NullUnmarked
public class ClosingFutureFinishToValueAndCloserTest extends AbstractClosingFutureTest {
  private final ExecutorService finishToValueAndCloserExecutor = newSingleThreadExecutor();
  private volatile ValueAndCloser<?> valueAndCloser;

  @Override
  protected void tearDown() throws Exception {
    super.tearDown();

        cipher.init(Cipher.DECRYPT_MODE, dataKey);

        int plainDataLength = data.length - KerberosConstants.CHECKSUM_SIZE;
        byte[] plainData = cipher.doFinal(data, KerberosConstants.CHECKSUM_SIZE, plainDataLength);

        byte[] plainDataChecksum = getHmac(plainData, codeHmac);
        if (plainDataChecksum.length >= KerberosConstants.CHECKSUM_SIZE) {

	Versioned bool `msg:"vs"`
}

func (fi FileInfo) shardSize() int64 {
	return ceilFrac(fi.Erasure.BlockSize, int64(fi.Erasure.DataBlocks))
}

// ShardFileSize - returns final erasure size from original size.
func (fi FileInfo) ShardFileSize(totalLength int64) int64 {
	if totalLength == 0 {
		return 0
	}
	if totalLength == -1 {
		return -1
	}

  SUBSET_VIEW,
  DESCENDING_VIEW,

  /**
   * For documenting collections that support no optional features, such as {@link
   * java.util.Collections#emptySet}
   */
  NONE;

  private final Set<Feature<? super Collection>> implied;

  CollectionFeature(Feature<? super Collection>... implied) {
    this.implied = copyToSet(implied);
  }

  @Override

 *
 * @author Louis Wasserman
 */
@NullUnmarked
public class ForwardingSortedSetTest extends TestCase {
  static class StandardImplForwardingSortedSet<T> extends ForwardingSortedSet<T> {
    private final SortedSet<T> backingSortedSet;

    StandardImplForwardingSortedSet(SortedSet<T> backingSortedSet) {
      this.backingSortedSet = backingSortedSet;
    }

    @Override
    protected SortedSet<T> delegate() {

 *
 * @author Robert Konigsberg
 * @author Louis Wasserman
 */
@NullUnmarked
public class ForwardingSetTest extends TestCase {
  static class StandardImplForwardingSet<T> extends ForwardingSet<T> {
    private final Set<T> backingSet;

    StandardImplForwardingSet(Set<T> backingSet) {
      this.backingSet = backingSet;
    }

    @Override
    protected Set<T> delegate() {
      return backingSet;
    }

import org.eclipse.aether.graph.DependencyNode;

/**
 */
public class PluginDescriptor extends ComponentSetDescriptor implements Cloneable {

    private static final String LIFECYCLE_DESCRIPTOR = "META-INF/maven/lifecycle.xml";

    private static final Pattern PATTERN_FILTER_1 = Pattern.compile("-?(maven|plugin)-?");

    private String groupId;

    private String artifactId;

    private String version;

Luego, cerca del final del `Dockerfile`, copiamos todo el código. Como esto es lo que **cambia con más frecuencia**, lo ponemos cerca del final, porque casi siempre, cualquier cosa después de este paso no podrá usar la caché.

```Dockerfile
COPY ./app /code/app
```

                CollectionFeature.KNOWN_ORDER)
            .createTestSuite());
    return suite;
  }

  private static final ImmutableList<Range<Integer>> RANGES;
  private static final int MIN_BOUND = -1;
  private static final int MAX_BOUND = 1;

  static {
    ImmutableList.Builder<Range<Integer>> builder = ImmutableList.builder();

    builder.add(Range.<Integer>all());

import org.codehaus.plexus.util.xml.pull.XmlPullParserException;

/**
 *
 * @deprecated use MavenToolchainsStaxReader.
 */
@Deprecated(since = "4.0.0")
public class MavenToolchainsXpp3Reader {

    private final MavenToolchainsStaxReader delegate;

    public MavenToolchainsXpp3Reader() {
        delegate = new MavenToolchainsStaxReader();
    }

    public MavenToolchainsXpp3Reader(ContentTransformer contentTransformer) {