assertEquals(1, ndrBuffer.getIndex());
        assertEquals(1, ndrBuffer.getLength());
        assertEquals((byte) 0xAB, buffer[0]);

        ndrBuffer.setIndex(0); // Reset index for reading
        int val = ndrBuffer.dec_ndr_small();
        assertEquals(0xAB, val);
        assertEquals(1, ndrBuffer.getIndex());
    }

    @Test
    void testEncDecNdrShort() {

{* ../../docs_src/handling_errors/tutorial005.py hl[14] *}

Now try sending an invalid item like:

```JSON
{
  "title": "towel",
  "size": "XL"
}
```

You will receive a response telling you that the data is invalid containing the received body:

```JSON hl_lines="12-15"
{
  "detail": [
    {
      "loc": [
        "body",
        "size"
      ],

        setupCountField.setAccessible(true);
        assertEquals(128, setupCountField.get(response));
    }

    @Test
    @DisplayName("Test reading from different buffer positions")
    void testReadFromDifferentPositions() throws Exception {
        byte[] buffer = new byte[200];

        // Test at various positions in the buffer

            and .java files in c.g.c.collect.testModule, one that it doesn't[*]. Consequently,
            c.g.c.base.testModule transitively pulls in .java files from both modules while reading
            the module description of only the prod module. And the prod module doesn't inherit all
            the modules that the test module classes use, so we get errors.

	if !opts.NoAuditLog {
		auditObjectErasureSet(ctx, "GetObjectInfo", object, &er)
	}

	if !opts.NoLock {
		// Lock the object before reading.
		lk := er.NewNSLock(bucket, object)
		lkctx, err := lk.GetRLock(ctx, globalOperationTimeout)
		if err != nil {
			return ObjectInfo{}, err
		}
		ctx = lkctx.Context()
		defer lk.RUnlock(lkctx)
	}

    /*
     * We overload this because we want readAndXWireFormat to
     * read the parameter words and bytes. This is so when
     * commands are batched together we can recursivly call
     * readAndXWireFormat without reading the non-existent header.
     */

    @Override
    public int decode(final byte[] buffer, int bufferIndex) throws SMBProtocolDecodingException {
        final int start = this.headerStart = bufferIndex;

                    throw new ServletException(e);
                }
            }
        };

        assertDoesNotThrow(() -> networkExplorer.init(servletConfig));

        // Verify parameter reading
        verify(servletConfig).getInitParameter("jcifs.smb.client.domain");
        verify(servletConfig).getInitParameter("jcifs.http.enableBasic");
    }

    /**

deepest contempt.  `I've seen a good many little girls in my
time, but never ONE with such a neck as that!  No, no!  You're a
serpent; and there's no use denying it.  I suppose you'll be
telling me next that you never tasted an egg!'

  `I HAVE tasted eggs, certainly,' said Alice, who was a very
truthful child; `but little girls eat eggs quite as much as
serpents do, you know.'

import org.codelibs.fess.dict.DictionaryFile;
import org.codelibs.fess.util.ComponentUtil;
import org.dbflute.optional.OptionalEntity;

/**
 * Manages a dictionary file for synonyms.
 * This class handles reading, parsing, and updating files that contain
 * synonym rules. The file format supports both explicit mappings (e.g., `a => b`)
 * and equivalent synonyms (e.g., `a, b, c`).
 *

  }

  /**
   * Read 100 MiB of 'a' chars. This was really slow due to a performance bug in [MultipartReader],
   * and will be really slow if we regress the fix for that.
   */
  @Test
  fun `reading a large part with small byteCount`() {
    val multipartBody =
      MultipartBody
        .Builder("foo")
        .addPart(
          headersOf("header-name", "header-value"),
          object : RequestBody() {