These properties CAN be supplemented with command-line options and they SHOULD follow the shared naming scheme described above.

Examples of properties in this category:

* `org.gradle.caching`
* `org.gradle.configuration-cache`

## Consequences

* Internal properties must start with `org.gradle.internal.`
* Properties of pre-incubation features must start with `org.gradle.experimental.`

   *
   * <ul>
   *   <li>{@linkplain LoadingCache#get(Object) awaiting the result of a pending load} rather than
   *       starting a redundant one
   *   <li>eliminating the error-prone caching boilerplate
   *   <li>tracking load {@linkplain #stats statistics}
   * </ul>
   *
   * <p>Among the further improvements that {@code LoadingCache} can provide but this method cannot:
   *
   * <ul>

#   re-running tests. However, note that:
#
#    - New environments like new CUDA versions, changes to manylinux,
#      compilers, etc. can cause undefined behavior such as build failures
#      or tests passing incorrectly.
#    - Automatic LLVM updates are known to extend build time even with
#      the cache; this is unavoidable.
export TFCI=py311,linux_x86,public_cache,disk_cache

# Recommended: Configure Docker. (Linux only)

     */
    open fun <T> tag(
      type: Class<in T>,
      tag: T?,
    ) = tag(type.kotlin, tag)

    /**
     * Override the [Request.url] for caching, if it is either polluted with
     * transient query params, or has a canonical URL possibly for a CDN.
     *
     * Note that POST requests will not be sent to the server if this URL is set

  `Yes,' said Alice, `we learned French and music.'

  `And washing?' said the Mock Turtle.

  `Certainly not!' said Alice indignantly.

  `Ah! then yours wasn't a really good school,' said the Mock
Turtle in a tone of great relief.  `Now at OURS they had at the
end of the bill, "French, music, AND WASHING--extra."'

  `You couldn't have wanted it much,' said Alice; `living at the

should consider your branch publicly shared. Instead of force pushing
you can just add incremental commits; this is generally easier on your
reviewers. If you need to pick up changes from master, you can merge
master into your branch. A reviewer might ask you to rebase a
long-running pull request in which case force pushing is okay for that
request. Note that squashing at the end of the review process should

    implements List<E>, RandomAccess {

  ImmutableList() {}

  public static <E> Collector<E, ?, ImmutableList<E>> toImmutableList() {
    return CollectCollectors.toImmutableList();
  }

  // Casting to any type is safe because the list will never hold any elements.
  @SuppressWarnings("unchecked")
  public static <E> ImmutableList<E> of() {
    return (ImmutableList<E>) RegularImmutableList.EMPTY;
  }

        assertArrayEquals(testMacAddress, nbtAddress.getMacAddress(mockContext));
    }

    @Test
    void testUnwrap() {
        // Test unwrap method for correct type casting
        mockName = new Name(mockConfig, "TEST", 0x20, null);
        NbtAddress nbtAddress = new NbtAddress(mockName, testAddressInt, false, NbtAddress.H_NODE);
        NbtAddress unwrapped = nbtAddress.unwrap(NbtAddress.class);

  }

  @Override
  public boolean equals(@Nullable Object object) {
    return Maps.equalsImpl(this, object);
  }

  @Override
  public int hashCode() {
    // not caching hash code since it could change if map values are mutable
    // in a way that modifies their hash codes
    return entrySet().hashCode();
  }

  @Override
  public String toString() {

                /*
                 * The SMB_COM_NT_CREATE_ANDX response wordCount is wrong. There's an
                 * extra 16 bytes for some "Offline Files (CSC or Client Side Caching)"
                 * junk. We need to bump up the wordCount here so that this method returns
                 * the correct number of bytes for signing purposes. Otherwise we get a
                 * signing verification failure.