interface rpc
{
	/* base types */

	typedef unsigned char uint8_t;
	typedef unsigned short uint16_t;
	typedef unsigned int uint32_t;

	/* dce */

	typedef struct {
	    uint32_t time_low;
	    uint16_t time_mid;
	    uint16_t time_hi_and_version;
	    uint8_t clock_seq_hi_and_reserved;
	    uint8_t clock_seq_low;
	    uint8_t node[6];
	} uuid_t;

	/* win32 stuff */

	typedef struct {
		uint32_t type;

        // 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 };

        assertEquals(new BigDecimal("1"), BigDecimalConversionUtil.toBigDecimal(Byte.valueOf((byte) 1)));
        assertEquals(new BigDecimal("10"), BigDecimalConversionUtil.toBigDecimal(Short.valueOf((short) 10)));
        assertEquals(new BigDecimal("100"), BigDecimalConversionUtil.toBigDecimal(Integer.valueOf(100)));
        assertEquals(new BigDecimal("1000"), BigDecimalConversionUtil.toBigDecimal(Long.valueOf(1000L)));

     */
    static boolean matchPattern(ArtifactRepository originalRepository, String pattern) {
        boolean result = false;
        String originalId = originalRepository.getId();

        // simple checks first to short circuit processing below.
        if (WILDCARD.equals(pattern) || pattern.equals(originalId)) {
            result = true;
        } else {
            // process the list
            String[] repos = pattern.split(",");

            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),

   *
   * @param bytes a byte buffer
   * @return this instance
   * @since 23.0
   */
  @CanIgnoreReturnValue
  PrimitiveSink putBytes(ByteBuffer bytes);

  /** Puts a short into this sink. */
  @CanIgnoreReturnValue
  PrimitiveSink putShort(short s);

  /** Puts an int into this sink. */
  @CanIgnoreReturnValue
  PrimitiveSink putInt(int i);

  /** Puts a long into this sink. */
  @CanIgnoreReturnValue

            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);

  }

  /**
   * 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

     * @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) {

  }

  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))
  })
}