private void writeLittleEndianShort(DataOutputStream dos, short value) throws IOException {
        dos.writeShort(Short.reverseBytes(value));
    }

    private void writeLittleEndianInt(DataOutputStream dos, int value) throws IOException {
        dos.writeInt(Integer.reverseBytes(value));
    }

    private void writeLittleEndianLong(DataOutputStream dos, long value) throws IOException {
        dos.writeLong(Long.reverseBytes(value));

        // Construct a minimal wire format buffer
        byte[] buf = new byte[32];
        int idx = 0;
        // Write values little-endian
        buf[idx++] = 5; // totalParameterCount low byte
        buf[idx++] = 0; // totalParameterCount high byte -> value 5
        buf[idx++] = 3; // totalDataCount low
        buf[idx++] = 0; // totalDataCount high

    };
    int[] bases = {2, 5, 7, 8, 10, 16};
    for (int base : bases) {
      for (String x : tests) {
        BigInteger xValue = new BigInteger(x, 16);
        long xLong = xValue.longValue(); // signed
        assertThat(UnsignedLongs.toString(xLong, base)).isEqualTo(xValue.toString(base));
      }
    }
  }

  public void testJoin() {
    assertThat(UnsignedLongs.join(",")).isEmpty();

    return requireLinks()[i];
  }

  private void setLink(int i, long value) {
    requireLinks()[i] = value;
  }

  /*
   * We don't define getPredecessor+getSuccessor and setPredecessor+setSuccessor here because
   * they're defined above -- including logic to add and subtract 1 to map between the values stored
   * in the predecessor/successor arrays and the indexes in the elements array that they identify.

 * way of "cutting" a "number line" (actually of instances of type {@code C}, not necessarily
 * "numbers") into two sections; this can be done below a certain value, above a certain value,
 * below all values or above all values. With this object defined in this way, an interval can
 * always be represented by a pair of {@code Cut} instances.
 *
 * @author Kevin Bourrillion
 */

---

Но если вам любопытен именно этот пример и всё ещё интересно, вот немного подробностей.

#### Строка и `value.startswith()` { #string-with-value-startswith }

Заметили? Метод строки `value.startswith()` может принимать кортеж — тогда будет проверено каждое значение из кортежа:

{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[16:19] hl[17] *}

     * The timestamp when the job completed execution.
     * This field indicates when the job finished, if it has completed.
     */
    public String endTime;

    /**
     * Initializes the form with default null values.
     * This method resets all fields to their default state for creating a new entry.
     */
    public void initialize() {
        id = null;
        jobName = null;
        jobStatus = null;

                JvmVendor.OPENJDK.name.lowercase(),
                display = ParameterDisplay.PROMPT,
                description = "Java vendor to run the test with",
                options = JvmVendor.values().map { it.displayName to it.name.lowercase() },
            )
            text(
                testTaskOptionsParameterName,
                "",
                display = ParameterDisplay.PROMPT,

  // The first `size` elements are non-null.
  @VisibleForTesting final transient @Nullable Object[] elements;
  private final transient int hashCode;
  // the same values as `elements` in hashed positions (plus nulls)
  @VisibleForTesting final transient @Nullable Object[] table;
  // 'and' with an int to get a valid table index.
  private final transient int mask;

Затем вы можете создать шаблон в `templates/item.html`, например:

```jinja hl_lines="7"
{!../../docs_src/templates/templates/item.html!}
```

### Значения контекста шаблона { #template-context-values }

В HTML, который содержит:

{% raw %}

```jinja
Item ID: {{ id }}
```

{% endraw %}

...будет показан `id`, взятый из переданного вами «context» `dict`:

```Python
{"id": id}
```