void shouldDecodeBufferWithOffset() throws SMBProtocolDecodingException {
            // Given - buffer with padding before actual data
            ByteBuffer buffer = ByteBuffer.allocate(34);
            buffer.order(ByteOrder.LITTLE_ENDIAN);
            buffer.position(10); // Add 10 bytes of padding
            buffer.putLong(2048L);
            buffer.putLong(1024L);
            buffer.putInt(4);

### CLI Improvements
- The kubectl's api-resource command now has a `--sort-by` flag to sort resources by name or kind. ([#81971](https://github.com/kubernetes/kubernetes/pull/81971), [@laddng](https://github.com/laddng))

* Path `prefix`: `/items`.
* `tags`: (just one tag: `items`).
* Extra `responses`.
* `dependencies`: they all need that `X-Token` dependency we created.

So, instead of adding all that to each *path operation*, we can add it to the `APIRouter`.

```Python hl_lines="5-10  16  21" title="app/routers/items.py"
{!../../docs_src/bigger_applications/app/routers/items.py!}
```

import org.opensearch.index.query.QueryShardContext;

/**
 * Default implementation of QueryBuilder that wraps other QueryBuilder instances
 * and provides additional functionality for adding inner queries dynamically.
 * Supports both BoolQueryBuilder and DisMaxQueryBuilder as underlying implementations.
 */
public class DefaultQueryBuilder implements QueryBuilder {

Here the query parameter `needy` is a required query parameter of type `str`.

If you open in your browser a URL like:

```
http://127.0.0.1:8000/items/foo-item
```

...without adding the required parameter `needy`, you will see an error like:

```JSON
{
  "detail": [
    {
      "type": "missing",
      "loc": [
        "query",
        "needy"
      ],

   * Nearly all declarations in this class are package-private,
   * accessed directly by subclasses.
   *
   * Table entries are of class Cell; a variant of AtomicLong padded
   * to reduce cache contention on most processors. Padding is
   * overkill for most Atomics because they are usually irregularly
   * scattered in memory and thus don't interfere much with each
   * other. But Atomic objects residing in arrays will tend to be

    // Delegates to the fast (unsafe) version or the fallback.
    return byteArray.getLongLittleEndian(input, offset);
  }

  /**
   * Similar to load64, but allows offset + 8 > input.length, padding the result with zeroes. This
   * has to explicitly reverse the order of the bytes as it packs them into the result which makes
   * it slower than the native version.
   *
   * @param input the input bytes

    putEdge(1, 2); // Duplicate
    putEdge(4, 5);
  }

  // Element Mutation

  @Test
  public void putEdge_existingNodes() {
    assume().that(graphIsMutable()).isTrue();

    // Adding nodes initially for safety (insulating from possible future
    // modifications to proxy methods)
    addNode(N1);
    addNode(N2);

    assertThat(graphAsMutableGraph.putEdge(N1, N2)).isTrue();
  }

        # o objectTypeTargetList: (NotRequired - Default list:{TABLE;VIEW})
        #  If you want to include other object types in generating target,
        #  you should specify the list of included object types as adding.
        #    e.g. Synonym of Oracle --> list:{TABLE ; VIEW ; SYNONYM}
        #  This is only for the main schema. Additional schemas are unconcerned.
        #  However ReplaceSchema and Sql2Entity task also uses this.

        byte[] buffer = new byte[testString.length() * 2 + 2 + 1]; // +1 for alignment
        int len = smb.writeString(testString, buffer, 1);
        // When dstIndex=1 and headerStart=1, (1-1)%2=0, no alignment padding needed
        // Length is string bytes (15*2) + 2 null terminators = 32
        assertEquals(testString.length() * 2 + 2, len);
        String readString = smb.readString(buffer, 1);