// Check if mixins are present without flattening enabled
        if (!model.getMixins().isEmpty() && !flattenEnabled && !model.isPreserveModelVersion()) {
            throw new MavenException("The consumer POM for "
                    + project.getId()
                    + " cannot be created because the POM contains mixins. "
                    + "Mixins are not supported in the default consumer POM format. "

        <!-- Mixins                                                                 -->
        <!-- ====================================================================== -->

        <field xdoc.separator="blank">
          <name>mixins</name>
          <version>4.2.0+</version>
          <description>Mixins...</description>
          <association>
            <type>Mixin</type>

    private static final String BASE_DIR = "src/test";

    private static final String BASE_POM_DIR = BASE_DIR + "/resources-project-builder";

    private static final String BASE_MIXIN_DIR = BASE_DIR + "/resources-mixins";

    @Inject
    private DefaultProjectBuilder projectBuilder;

    @Inject
    private MavenRepositorySystem repositorySystem;

    @Inject
    private PlexusContainer container;

    /** Gets the value for the entry. */
    V getValue();
  }

  /*
   * Note: the following classes have a lot of duplicate code. It sucks, but it saves a lot of
   * memory. If only Java had mixins!
   */

  /** Base class for {@link InternalEntry} implementations for strong keys. */
  abstract static class AbstractStrongKeyEntry<K, V, E extends InternalEntry<K, V, E>>
      implements InternalEntry<K, V, E> {

        byte[] buffer = new byte[22];
        long maxLong = Long.MAX_VALUE;
        int maxInt = Integer.MAX_VALUE;

        // Encode test data
        int offset = 0;
        SMBUtil.writeInt8(maxLong, buffer, offset);
        offset += 8;
        SMBUtil.writeInt8(maxLong, buffer, offset);
        offset += 8;
        SMBUtil.writeInt4(maxInt, buffer, offset);
        offset += 4;
        buffer[offset++] = (byte) 0xFF;

  static <E> Queue<E> discardingQueue() {
    return (Queue) DISCARDING_QUEUE;
  }

  /*
   * Note: All of this duplicate code sucks, but it saves a lot of memory. If only Java had mixins!
   * To maintain this code, make a change for the strong reference type. Then, cut and paste, and
   * replace "Strong" with "Soft" or "Weak" within the pasted text. The primary difference is that

                } else if ("".equals(artifact.getClassifier())) {
                    mains.add(artifact);
                }
            }
        }
        if (!mains.isEmpty() && !consumers.isEmpty()) {
            ArrayList<Artifact> result = new ArrayList<>(artifacts);
            for (Artifact main : mains) {
                result.remove(main);
                if (deployBuildPom) {

This is in contrast to the **development** stages, where you are constantly changing the code, breaking it and fixing it, stopping and restarting the development server, etc.

## Deployment Strategies { #deployment-strategies }

There are several ways to do it depending on your specific use case and the tools that you use.

        void testEncodeMaxValues() {
            // Given
            long maxLong = Long.MAX_VALUE;
            int maxInt = Integer.MAX_VALUE;
            SrvCopychunk chunk = new SrvCopychunk(maxLong, maxLong, maxInt);

            // When
            int bytesWritten = chunk.encode(buffer, startIndex);

            // Then
            assertEquals(EXPECTED_SIZE, bytesWritten);

## Code size { #code-size }

This example might seem verbose. Keep in mind that we are mixing security, data models, utility functions and *path operations* in the same file.

But here's the key point.

The security and dependency injection stuff is written once.