assertEquals("smb://test/file.txt", t.url, "URL should be parsed");
        }

        @Test
        @DisplayName("Flags can be in any order")
        void flagsInDifferentOrder() {
            TestLocking t = new TestLocking();

            // Parse flags in different order
            String[] args = { "smb://test/file.txt", "-i", "4", "-t", "2", "-d", "150" };
            for (int ai = 0; ai < args.length; ai++) {

{* ../../docs_src/path_params_numeric_validations/tutorial001_an_py310.py hl[10] *}

/// note

路徑參數一定是必填，因為它必須是路徑的一部分。即使你將其宣告為 `None` 或設定預設值，也不會有任何影響，它仍然是必填。

///

## 依需求調整參數順序 { #order-the-parameters-as-you-need }

/// tip

如果你使用 `Annotated`，這點大概沒那麼重要或必要。

///

假設你想把查詢參數 `q` 宣告為必要的 `str`。

而你不需要為該參數宣告其他內容，所以其實不需要用 `Query`。

但你仍需要為路徑參數 `item_id` 使用 `Path`，而且基於某些理由你不想用 `Annotated`。

                    return (Entry<Range<Integer>, String>[]) new Entry<?, ?>[length];
                  }

                  @Override
                  public Iterable<Entry<Range<Integer>, String>> order(
                      List<Entry<Range<Integer>, String>> insertionOrder) {
                    return Range.<Integer>rangeLexOrdering().onKeys().sortedCopy(insertionOrder);
                  }

  }

  static void clearInterrupt() {
    Thread.interrupted();
  }

  /**
   * Retrieves the result of a {@code Future} known to be done but uses the {@code get(long,
   * TimeUnit)} overload in order to test that method.
   */
  static <V extends @Nullable Object> V getDoneFromTimeoutOverload(Future<V> future)
      throws ExecutionException {
    checkState(future.isDone(), "Future was expected to be done: %s", future);

}

spotless {
  java {
    // IDEs can sometimes run annotation processors that leave files in
    // here, causing Spotless to complain. Even though this path ought not
    // to exist, exclude it anyway in order to avoid spurious failures.
    targetExclude 'src/main/generated/**/*.java'
  }

   *
   * <p>Callers must ensure that the source {@code iterators} are in non-descending order as this
   * method does not sort its input.
   *
   * <p>For any equivalent elements across all {@code iterators}, elements are returned in the order
   * of their source iterators. That is, if element A from iterator 1 and element B from iterator 2

   *
   * <p>Callers must ensure that the source {@code iterators} are in non-descending order as this
   * method does not sort its input.
   *
   * <p>For any equivalent elements across all {@code iterators}, elements are returned in the order
   * of their source iterators. That is, if element A from iterator 1 and element B from iterator 2

import okio.FileNotFoundException
import okio.FileSystem
import okio.IOException
import okio.Options
import okio.Path
import okio.use

@JvmField
internal val EMPTY_BYTE_ARRAY: ByteArray = ByteArray(0)

/** Byte order marks. */
internal val UNICODE_BOMS =
  Options.of(
    // UTF-8.
    "efbbbf".decodeHex(),
    // UTF-16BE.
    "feff".decodeHex(),
    // UTF-32LE.
    "fffe0000".decodeHex(),
    // UTF-16LE.

  }

  @Override
  public Entry<String, String> aboveSamplesGreater() {
    return mapEntry("~~ b", "above view");
  }

  @Override
  public Iterable<Entry<String, String>> order(List<Entry<String, String>> insertionOrder) {
    return orderEntriesByKey(insertionOrder);
  }

  @Override
  protected abstract SortedMap<String, String> create(Entry<String, String>[] entries);

  @Override

   *
   * <p>Instead of throwing {@link ArithmeticException}, this method silently saturates to either
   * {@link Long#MAX_VALUE} or {@link Long#MIN_VALUE}. This behavior can be useful when decomposing
   * a duration in order to call a legacy API which requires a {@code long, TimeUnit} pair.
   */
  // We use this method only for cases in which we need to decompose to primitives.