* Install **packages**
* Manage package **dependencies and versions** for your project
* Make sure you have an **exact** set of packages and versions to install, including their dependencies, so that you can be sure that you can run your project in production exactly the same as in your computer while developing, this is called **locking**
* And many other things

## Conclusion { #conclusion }

            svr = this.baddr; // bit of a hack but saves a lookup
        }
        name.srcHashCode = svr != null ? svr.hashCode() : 0;
        addr = getCachedAddress(name);

        /*
         * This is almost exactly like InetAddress.java. See the
         * comments there for a description of how the LOOKUP_TABLE prevents
         * redundant queries from going out on the wire.
         */

       *
       * My impression is that an AtomicReferenceFieldUpdater in a static field is similarly fast to
       * Unsafe on modern JVMs (if perhaps not quite as fast as VarHandle?). However, I'm not sure
       * exactly what we've benchmarked, and we certainly haven't benchmarked as far back as JDK 8.
       * (We also haven't benchmarked under Android. We continue to use UnsafeAtomicHelper there so

   * @throws NullPointerException if any of the provided keys is null
   * @throws IllegalArgumentException if {@code rowKeys} or {@code columnKeys} contains duplicates
   *     or if exactly one of {@code rowKeys} or {@code columnKeys} is empty.
   */
  public static <R, C, V> ArrayTable<R, C, V> create(
      Iterable<? extends R> rowKeys, Iterable<? extends C> columnKeys) {

 * <p>Usage example:
 *
 * {@snippet :
 * MinMaxPriorityQueue<User> users = MinMaxPriorityQueue.orderedBy(userComparator)
 *     .maximumSize(1000)
 *     .create();
 * }
 *
 * <p>As a {@link Queue} it functions exactly as a {@link PriorityQueue}: its head element -- the
 * implicit target of the methods {@link #peek()}, {@link #poll()} and {@link #remove()} -- is

  /**
   * Returns a view of the contents of this multiset, grouped into {@code Multiset.Entry} instances,
   * each providing an element of the multiset and the count of that element. This set contains
   * exactly one entry for each distinct element in the multiset (thus it always has the same size
   * as the {@link #elementSet}). The order of the elements in the element set is unspecified.
   *

   * @throws NullPointerException if any of the provided keys is null
   * @throws IllegalArgumentException if {@code rowKeys} or {@code columnKeys} contains duplicates
   *     or if exactly one of {@code rowKeys} or {@code columnKeys} is empty.
   */
  public static <R, C, V> ArrayTable<R, C, V> create(
      Iterable<? extends R> rowKeys, Iterable<? extends C> columnKeys) {

    sampleInstances.putAll(checkNotNull(type), checkNotNull(instances));
  }

  /**
   * Returns a fresh instance for {@code type} if possible. The returned instance could be:
   *
   * <ul>
   *   <li>exactly of the given type, including generic type parameters, such as {@code
   *       ImmutableList<String>};
   *   <li>of the raw type;
   *   <li>null if no value can be generated.
   * </ul>
   */

            assertTrue(result.errorCount() > 0, "Downgrade should result in errors");
            assertFalse(result.success(), "Downgrade should not be successful");
            assertEquals(1, result.errorCount(), "Should have exactly one error");
        }

        @Test
        @DisplayName("should succeed when upgrading from 4.0.0 to 4.1.0")
        void shouldSucceedWhenUpgrading() throws Exception {
            String pomXml = """

        name.srcHashCode = svr != null ? svr.hashCode() : 0;
        addr = getCachedAddress(name);

        if (addr == null) {
            addr = (NbtAddress) checkLookupTable(name);
            /* This is almost exactly like InetAddress.java. See the
             * comments there for a description of how the LOOKUP_TABLE prevents
             * redundant queries from going out on the wire.
             */
            if (addr == null) {