for (E element : getOrderedElements()) {
      expectedHashCode = 31 * expectedHashCode + ((element == null) ? 0 : element.hashCode());
    }
    assertEquals(
        "A List's hashCode() should be computed from those of its elements.",
        expectedHashCode,
        getList().hashCode());
  }

  /**
   * Returns the {@link Method} instance for {@link #testHashCode()} so that list tests on

    for (E element : getOrderedElements()) {
      expectedHashCode = 31 * expectedHashCode + ((element == null) ? 0 : element.hashCode());
    }
    assertEquals(
        "A List's hashCode() should be computed from those of its elements.",
        expectedHashCode,
        getList().hashCode());
  }

  /**
   * Returns the {@link Method} instance for {@link #testHashCode()} so that list tests on

        // root fallback
        SmbResourceLocatorImpl d = locator("smb:///");
        assertEquals("smb://", d.getName());
    }

    @Test
    @DisplayName("Parent URL is computed correctly")
    void testGetParent() {
        SmbResourceLocatorImpl a = locator("smb://server/share/dir/file.txt");
        assertEquals("smb://server/share/dir/", a.getParent());

    steps:
    - name: Checkout repository
      uses: actions/checkout@v6
      # Checkout must run before the caching key is computed using the `hashFiles` method

    - name: Cache Gradle Modules
      uses: actions/cache@v5
      with:
        path: |
          ~/.gradle/caches/modules-2/
          ~/.gradle/caches/build-cache-1/

And it will save the returned value in a <abbr title="A utility/system to store computed/generated values, to reuse them instead of computing them again.">"cache"</abbr> and pass it to all the "dependants" that need it in that specific request, instead of calling the dependency multiple times for the same request.

                coordinates.add(coordinate);
                context.debug("Found artifact: " + coordinate.toGAV() + " from " + pomPath);
            }
        }

        context.info("Computed " + coordinates.size() + " unique artifact(s) for inference");
        return coordinates;
    }

        /** User's group memberships. */
        protected volatile String[] groups;

        /** User's role assignments. */
        protected volatile String[] roles;

        /** User's computed permissions. */
        protected volatile String[] permissions;

        /** Entra ID authentication result. */
        protected IAuthenticationResult authResult;

        /**

        Optional<BuildStep> planStep = plan.step(project, BuildStep.PLAN);
        if (planStep.isPresent() && planStep.get().status.get() == BuildStep.PLANNING) {
            writer.accept("Build plan will be lazily computed");
        } else {
            plan.steps(project)
                    .filter(step ->
                            step.phase != null && step.executions().findAny().isPresent())

        List<String> allPhases = graph.visitAll();
        Collections.reverse(allPhases);
        List<String> computed =
                allPhases.stream().filter(s -> !s.startsWith("$")).collect(Collectors.toList());
        return computed;
    }

    private static void addPhase(
            Graph graph, Graph.Vertex before, Graph.Vertex after, org.apache.maven.api.Lifecycle.Phase phase) {

        if (len == 0) {
            return; /* CRITICAL */
        }
        digest.update(input, offset, len);
        updates++;
    }

    /**
     * Computes and returns the message digest.
     *
     * @return the computed digest bytes
     */
    public byte[] digest() {
        byte[] b = digest.digest();

        if (LogStream.level >= 5) {
            log.println("digest: ");