m := map[int]int{a: 1, a: 2}  // m may be {2: 1} or {2: 2}: evaluation order between the two map assignments is not specified
n := map[int]int{a: f()}      // n may be {2: 3} or {3: 3}: evaluation order between the key and the value is not specified
</pre>

<p>
At package level, initialization dependencies override the left-to-right rule

                                    <la:errors/>
                                </div>
                                    <%-- Form Fields --%>
                                <table class="table table-bordered">
                                    <tbody>
                                    <tr>
                                        <th style="width: 25%"><la:message

    }

    @Test
    void testReadParameterWordsWireFormat() {
        // Prepare a byte array with sample parameter words
        ByteBuffer buffer = ByteBuffer.allocate(34);
        buffer.order(ByteOrder.LITTLE_ENDIAN);
        buffer.putShort((short) 0); // dialectIndex
        buffer.put((byte) 0x0F); // securityMode (user, encrypted, sigs enabled, sigs required)
        buffer.putShort((short) 50); // maxMpxCount

        when(e.getName()).thenReturn(name);
        when(e.getType()).thenReturn(type);
        return e;
    }

    @Test
    @DisplayName("Happy path without filter: iterates all entries in order")
    void happyPath_noFilter_returnsAll() throws Exception {
        SmbFile parent = newParent();
        List<FileEntry> entries = Arrays.asList(entry("foo", SmbConstants.TYPE_SHARE), entry("bar", SmbConstants.TYPE_SHARE));

    checkNotNull(columnFunction, "columnFunction");
    checkNotNull(valueFunction, "valueFunction");
    checkNotNull(mergeFunction, "mergeFunction");

    /*
     * No mutable Table exactly matches the insertion order behavior of ImmutableTable.Builder, but
     * the Builder can't efficiently support merging of duplicate values.  Getting around this
     * requires some work.
     */

    return Collector.of(

                                    <la:errors/>
                                </div>
                                    <%-- Form Fields --%>
                                <table class="table table-bordered">
                                    <tbody>
                                    <tr>
                                        <th style="width: 25%"><la:message

        Iterator<Artifact> i = result.getArtifacts().iterator();
        assertEquals(n, i.next(), "n should be first");
        assertEquals(m, i.next(), "m should be second");

        // inverse order
        set = new LinkedHashSet<>();
        set.add(m);
        set.add(n);

        result = artifactResolver.resolveTransitively(

        String result = StringUtil.join(longDelimiter, "A", "B");
        assertEquals("A" + longDelimiter + "B", result);
    }

    @Test
    @DisplayName("Should preserve element order")
    void testJoinPreservesOrder() {
        String result = StringUtil.join(",", "z", "y", "x", "w", "v");
        assertEquals("z,y,x,w,v", result);
    }

    @Test

   * PermittedMetaException}.
   */
  protected final class MultiExceptionListIterator implements ListIterator<E> {
    // TODO: track seen elements when order isn't guaranteed
    // TODO: verify contents afterward
    // TODO: something shiny and new instead of Stack
    // TODO: test whether null is supported (create a Feature)
    /**

        }
      };

  /**
   * Returns a new {@code MatchResult} that corresponds to a successful match. Apache Harmony (used
   * in Android) requires a successful match in order to generate a {@code MatchResult}:
   * https://cs.android.com/android/platform/superproject/+/android-2.3.7_r1:libcore/luni/src/main/java/java/util/regex/Matcher.java;l=550;drc=5850271b4ab93ebc27c1d49169a348c6be3c7f04
   */