// Write PAX records to the output.
	isGlobal := hdr.Typeflag == TypeXGlobalHeader
	if len(paxHdrs) > 0 || isGlobal {
		// Write each record to a buffer.
		var buf strings.Builder
		// Sort keys for deterministic ordering.
		for _, k := range slices.Sorted(maps.Keys(paxHdrs)) {
			rec, err := formatPAXRecord(k, paxHdrs[k])
			if err != nil {
				return err
			}
			buf.WriteString(rec)
		}

            }
            sort(
                (Entry<K, V>[]) entries, // Entries up to size are not null
                0,
                size,
                Ordering.from(valueComparator).onResultOf(Maps.valueFunction()));
          }
          entriesUsed = true;
          return RegularImmutableBiMap.fromEntryArray(size, entries);
      }
    }

    /**

        CommonServerMessageBlock smb = (CommonServerMessageBlock) request;
        byte[] buffer = this.getContext().getBufferCache().getBuffer();
        try {
            // synchronize around encode and write so that the ordering for SMB1 signing can be maintained
            synchronized ( this.outLock ) {
                int n = smb.encode(buffer, 4);
                Encdec.enc_uint32be(n & 0xFFFF, buffer, 0); /* 4 byte session message header */

			}
			if !tc.hasRules && len(rules) > 0 {
				t.Fatalf("%d: Expected no rules to match but got matches %v", i+1, rules)
			}
		})
	}
}

// TestDeleteAllVersions tests ordering among events, especially ones which
// expire all versions like ExpiredObjectDeleteAllVersions and
// DelMarkerExpiration
func TestDeleteAllVersions(t *testing.T) {
	// ExpiredObjectDeleteAllVersions

  // component responsible for a finalizer later in the list, resulting in a deadlock.
  // Without enforced ordering finalizers are free to order amongst themselves and
  // are not vulnerable to ordering changes in the list.
  // +optional
  // +patchStrategy=merge
  repeated string finalizers = 14;

  // ManagedFields maps workflow-id and version to the set of fields

</p>

<p>
If the effects of a goroutine must be observed by another goroutine,
use a synchronization mechanism such as a lock or channel
communication to establish a relative ordering.
</p>

<h3 id="chan">Channel communication</h3>

<p>
Channel communication is the main method of synchronization
between goroutines.  Each send on a particular channel

				return
			}

			if currentDisk := s.erasureDisks[setIndex][diskIndex]; currentDisk != nil {
				if !reflect.DeepEqual(currentDisk.Endpoint(), disk.Endpoint()) {
					err = fmt.Errorf("Detected unexpected drive ordering refusing to use the drive: expecting %s, found %s, refusing to use the drive",
						currentDisk.Endpoint(), disk.Endpoint())
					printEndpointError(endpoint, err, false)
					disk.Close()
					s.erasureDisksMu.Unlock()

		if err != nil {
			return s, err
		}
		diskID := format.Erasure.This
		if m != ep.SetIdx || n != ep.DiskIdx {
			storageLogOnceIf(context.Background(),
				fmt.Errorf("unexpected drive ordering on pool: %s: found drive at (set=%s, drive=%s), expected at (set=%s, drive=%s): %s(%s): %w",
					humanize.Ordinal(ep.PoolIdx+1), humanize.Ordinal(m+1), humanize.Ordinal(n+1), humanize.Ordinal(ep.SetIdx+1), humanize.Ordinal(ep.DiskIdx+1),

   * computation is {@linkplain java.util.concurrent.Future#isDone() complete} or, if the
   * computation is already complete, immediately.
   *
   * <p>The callback is run on {@code executor}. There is no guaranteed ordering of execution of
   * callbacks, but any callback added through this method is guaranteed to be called once the
   * computation is complete.
   *

        V value = (V) requireNonNull(alternatingKeysAndValues[2 * i + 1]);
        entries[i] = new AbstractMap.SimpleImmutableEntry<Object, V>(key, value);
      }
      Arrays.sort(
          entries, 0, size, Ordering.from(valueComparator).onResultOf(Maps.<V>valueFunction()));
      for (int i = 0; i < size; i++) {
        alternatingKeysAndValues[2 * i] = entries[i].getKey();