assertEquals("\"longKey\":9876543210", buf.toString());
    }

    // Test append method with Short value
    @Test
    public void test_append_shortValue() {
        StringBuilder buf = new StringBuilder();
        Supplier<Object> supplier = () -> Short.valueOf((short) 42);

        monitorTarget.append(buf, "shortKey", supplier);
        assertEquals("\"shortKey\":42", buf.toString());
    }

            buffer.encode(dst, 0);

            ByteBuffer bb = ByteBuffer.wrap(dst).order(ByteOrder.LITTLE_ENDIAN);
            // -1 as unsigned short should be 65535
            assertEquals((short) -1, bb.getShort());
            assertEquals(65535, Short.toUnsignedInt((short) -1));
        }
    }

    @Nested
    @DisplayName("Integration Tests with SMBUtil")
    class SMBUtilIntegrationTests {

        @Test

            when(mockFile.getType()).thenReturn(SmbConstants.TYPE_FILESYSTEM);

            // Capture the ReadAndX request; throw to short-circuit network
            doAnswer(inv -> {
                throw new SmbException("short-circuit");
            }).when(mockTree)
                    .send(any(jcifs.internal.CommonServerMessageBlockRequest.class),

  }

  /**
   * Returns a predicate that evaluates to {@code true} if each of its components evaluates to
   * {@code true}. The components are evaluated in order, and evaluation will be "short-circuited"
   * as soon as a false predicate is found. It defensively copies the iterable passed in, so future
   * changes to it won't alter the behavior of this predicate. If {@code components} is empty, the

            entry.name.buffer = new short[] { 't', 'e', 's', 't' };

            // When: Encoding entry
            entry.encode(mockNdrBuffer);

            // Then: Should encode all fields
            verify(mockNdrBuffer).align(4);
            verify(mockNdrBuffer).enc_ndr_long(1);
            verify(mockNdrBuffer).enc_ndr_short((short) 4);
            verify(mockNdrBuffer).enc_ndr_short((short) 6);

        // Verify
        assertEquals(defaultType, pacSignature.getType());
        assertArrayEquals(checksum, pacSignature.getChecksum());
    }

    /**
     * Test constructor with malformed data (too short).
     */
    @Test
    void testConstructorMalformedData() {
        // Prepare data (only 2 bytes, less than an int)
        byte[] data = new byte[] { 0x01, 0x02 };

     * @throws XmlPullParserException XmlPullParserException if
     * any.
     * @return short
     */
    private short getShortValue(String s, String attribute, XmlPullParser parser, boolean strict)
            throws XmlPullParserException {
        if (s != null) {
            try {
                return Short.valueOf(s).shortValue();
            } catch (NumberFormatException nfe) {
                if (strict) {

    }

    // Optimization: check whether hostname is too short to match the pattern. hostName must be at
    // least as long as the pattern because asterisk must match the whole left-most label and
    // hostname starts with a non-empty label. Thus, asterisk has to match one or more characters.
    if (hostname.length < pattern.length) {
      return false // Hostname too short to match the pattern.
    }

    if ("*." == pattern) {

    }

    @Override
    public final void writeShort(final int v) throws SmbException {
        Encdec.enc_uint16be((short) v, tmp, 0);
        write(tmp, 0, 2);
    }

    @Override
    public final void writeChar(final int v) throws SmbException {
        Encdec.enc_uint16be((short) v, tmp, 0);
        write(tmp, 0, 2);
    }

    @Override
    public final void writeInt(final int v) throws SmbException {

      || (containerTests.isPresent && containerTests.get().toBoolean())
  }

  jvmArgs(
    "-Dokhttp.platform=$platform",
  )

  if (platform == "loom") {
    jvmArgs(
      "-Djdk.tracePinnedThreads=short",
    )
  }

  val javaToolchains = project.extensions.getByType<JavaToolchainService>()
  javaLauncher.set(javaToolchains.launcherFor {
    languageVersion.set(JavaLanguageVersion.of(testJavaVersion))
  })
}