final Object value = map.get(key);
        if (value instanceof Map) {
            return (Map<String, Object>) value;
        }
        return null;
    }

    /**
     * Checks if the map contains the specified key and the value is not null.
     *
     * @param map The source map
     * @param key The key to check
     * @return true if the key exists and its value is not null
     */

import okio.ByteString.Companion.encodeUtf8

/**
 * An [RFC 3492] punycode decoder for converting ASCII to Unicode domain name labels. This is
 * intended for use in Internationalized Domain Names (IDNs).
 *
 * This class contains a Kotlin implementation of the pseudocode specified by RFC 3492. It includes
 * direct translation of the pseudocode presented there.
 *
 * Partner this class with [UTS #46] to implement IDNA2008 [RFC 5890] like most browsers do.

    TimeoutException e =
        assertThrows(
            TimeoutException.class, () -> service.startAsync().awaitRunning(1, MILLISECONDS));
    assertThat(e).hasMessageThat().contains(Service.State.STARTING.toString());
  }

  private static final class TimeoutOnStartUp extends AbstractExecutionThreadService {
    @Override
    protected Executor executor() {
      return new Executor() {

        interpolator.interpolateModel(model, null, request, collector);

        assertCollectorState(0, 2, 0, collector);
        assertTrue(collector.getErrors().get(0).contains("Detected the following recursive expression cycle"));
    }

    @Test
    public void testRecursiveExpressionCycleBaseDir() throws Exception {
        Map<String, String> props = new HashMap<>();

        try {
            booleanQueryCommand.execute(context, termQuery, 1.0f);
            fail("Should throw InvalidQueryException");
        } catch (InvalidQueryException e) {
            assertTrue(e.getMessage().contains("Unknown q:"));
        }
    }

    // Test convertBooleanQuery with MUST clause
    @Test
    public void test_convertBooleanQuery_withMustClause() {

        try {
            rateLimiter.checkAttempt(username, ip);
            fail("Should throw SmbException for locked account");
        } catch (SmbException e) {
            assertTrue(e.getMessage().contains("locked out"), "Should indicate account lockout");
        }
    }

    @Test
    public void testIpRateLimit() throws Exception {
        String ip = "192.168.1.3";

When you PUT an object in a versioning-enabled bucket, the noncurrent version is not overwritten. The following figure shows that when a new version of `spark.csv` is PUT into a bucket that already contains an object with the same name, the original object (ID = `ede336f2`) remains in the bucket, MinIO generates a new version (ID = `fae684da`), and adds the newer version to the bucket.

	b := rZipBytes()
	return bytes.NewReader(b), int64(len(b))
}

// biggestZipBytes returns the bytes of a zip file biggest.zip
// that contains a zip file bigger.zip that contains a zip file
// big.zip that contains big.file, which contains 2³²-1 zeros.
// The big.zip file is interesting because it has no zip64 header,
// much like the innermost zip files in the well-known 42.zip.
//

        // Test that the crawler list is synchronized
        List<org.codelibs.fess.crawler.Crawler> crawlerList = webFsIndexHelper.crawlerList;
        assertTrue(crawlerList.getClass().getName().contains("Synchronized"));
    }

    @Test
    public void test_defaultValues() {
        assertEquals(Long.MAX_VALUE, webFsIndexHelper.maxAccessCount);

      )

  /**
   * ```
   * Extension ::= SEQUENCE  {
   *   extnID      OBJECT IDENTIFIER,
   *   critical    BOOLEAN DEFAULT FALSE,
   *   extnValue   OCTET STRING
   *     -- contains the DER encoding of an ASN.1 value
   *     -- corresponding to the extension type identified
   *     -- by extnID
   * }
   * ```
   */
  internal val extension: BasicDerAdapter<Extension> =