<compile>org.apache.maven.plugins:maven-compiler-plugin:compile</compile>
        <process-test-resources>org.apache.maven.plugins:maven-resources-plugin:testResources</process-test-resources>
        <test-compile>org.apache.maven.plugins:maven-compiler-plugin:testCompile</test-compile>
        <test>org.apache.maven.plugins:maven-surefire-plugin:test</test>

        }

        /**
         * Check if this file info matches the given attributes
         *
         * @param otherSize size to compare
         * @param otherLastModified last modified time to compare
         * @param otherAttributes attributes to compare
         * @return true if attributes match
         */
        public boolean matches(long otherSize, long otherLastModified, long otherAttributes) {

          <execution>
            <id>default-compile</id>
            <configuration>
              <compilerArgs combine.children="append" combine.self="append">
                <arg>-XDignore.symbol.file</arg>
              </compilerArgs>
            </configuration>
          </execution>
          <execution>
            <id>compile-java9</id>
            <phase>compile</phase>
            <goals>

            "The format of the specified computer name is invalid.", "The pipe has been ended.",
            "The specified local group does not exist.",
            "Logon failure: the user has not been granted the requested logon type at this computer.",
            "The SAM database on the Windows NT Server does not have a computer account for this workstation trust relationship.",

        assertTrue(
            comparator + ".compare(" + lesser + ", " + t + ")", comparator.compare(lesser, t) < 0);
      }

      assertEquals(comparator + ".compare(" + t + ", " + t + ")", 0, comparator.compare(t, t));

      for (int j = i + 1; j < valuesInExpectedOrder.size(); j++) {
        T greater = valuesInExpectedOrder.get(j);
        assertTrue(
            comparator + ".compare(" + greater + ", " + t + ")",

    default Map<String, String> getEffectiveProperties() {
        return getEffectiveProperties(null);
    }

    /**
     * Each invocation computes a new map of effective properties. To be used in interpolation.
     * <p>
     * Effective properties are computed from system, user and optionally project properties, layered with
     * defined precedence onto each other to achieve proper precedence. Precedence is defined as:

         * @param other the other pattern to compare with
         * @return negative if this has higher priority, positive if other has higher priority
         */
        @Override
        public int compareTo(final PathPattern other) {
            // Higher priority length comes first (descending order)
            return Integer.compare(other.priorityLength, this.priorityLength);
        }

   * Generation, described in Knuth's "The Art of Computer Programming", Volume 4, Chapter 7,
   * Section 7.2.1.2. The iteration order follows the lexicographical order. This means that the
   * first permutation will be in ascending order, and the last will be in descending order.
   *
   * <p>Elements that compare equal are considered equal and no new permutations are created by
   * swapping them.
   *

Mikhail Lopatkin <******@****.***> 1701809516 +0100

/**
 * A multiset which maintains the ordering of its elements, according to either their natural order
 * or an explicit {@link Comparator}. In all cases, this implementation uses {@link
 * Comparable#compareTo} or {@link Comparator#compare} instead of {@link Object#equals} to determine
 * equivalence of instances.
 *
 * <p><b>Warning:</b> The comparison must be <i>consistent with equals</i> as explained by the