Exception level3 = new IllegalArgumentException("Level 3 - Root cause");
        Exception level2 = new IllegalStateException("Level 2", level3);
        Exception level1 = new IOException("Level 1", level2);
        CrawlerSystemException topLevel = new CrawlerSystemException("Top level", level1);

        // Verify chain
        assertSame(level1, topLevel.getCause());

        // Verify parent directories were created
        SmbFile level1 = new SmbFile(baseUrl + "shared/level1_" + timestamp + "/", checkContext);
        SmbFile level2 = new SmbFile(baseUrl + "shared/level1_" + timestamp + "/level2/", checkContext);

        assertTrue(level1.exists(), "Level1 directory should exist");
        assertTrue(level2.exists(), "Level2 directory should exist");
    }

    @Test

     *
     * @param level the severity level of the message
     * @param message the message to be logged
     */
    default void log(@Nonnull Level level, @Nonnull String message) {
        log(level, message, null);
    }

    /**
     * Logs a message at the specified level with an associated exception.
     *
     * @param level the severity level of the message

    if (bubbledTo == vacated) {
      // Could not bubble toTrickle up min levels, try moving
      // it from min level to max level (or max to min level) and bubble up
      // there.
      return heap.tryCrossOverAndBubbleUp(index, vacated, toTrickle);
    } else {
      return (bubbledTo < index) ? new MoveDesc<E>(toTrickle, elementData(index)) : null;
    }
  }

 *       <ul>
 *         <li>2 levels: average of 64ns per lock()/unlock()
 *         <li>3 levels: average of 77ns per lock()/unlock()
 *         <li>4 levels: average of 99ns per lock()/unlock()
 *         <li>5 levels: average of 103ns per lock()/unlock()
 *         <li>10 levels: average of 184ns per lock()/unlock()
 *         <li>20 levels: average of 393ns per lock()/unlock()
 *       </ul>
 * </ul>

    }

    /**
     * Event severity levels
     */
    public enum Severity {
        INFO(0), WARNING(1), ERROR(2), CRITICAL(3);

        private final int level;

        Severity(int level) {
            this.level = level;
        }

        public int getLevel() {
            return level;
        }
    }

    private static class SingletonHolder {

            assertEquals(0, e.getChildUrlList().size());
        }
    }

    public void test_deeplyNestedDirectories() throws Exception {
        String deepFileUrl = deepUrl + "level1/level2/level3/level4/level5/deepfile.txt";

        SmbClient client = new SmbClient();
        client.setResolveSids(false);
        StandardCrawlerContainer container =

        int setRootLoggerLevelCallCount = 0;
        Level lastSetLevel = null;

        @Override
        public void setRootLoggerLevel(Level level) {
            setRootLoggerLevelCallCount++;
            lastSetLevel = level;

            // Simulate what MavenSimpleConfiguration does
            String value =
                    switch (level) {
                        case DEBUG -> "debug";

      message = "moved to var",
      replaceWith = ReplaceWith(expression = "level"),
      level = DeprecationLevel.ERROR,
    )
    fun getLevel(): Level = level

    @Throws(IOException::class)
    override fun intercept(chain: Interceptor.Chain): Response {
      val level = this.level

      val request = chain.request()
      if (level == Level.NONE) {
        return chain.proceed(request)
      }

    assertThat(applicationInterceptor.level).isEqualTo(Level.NONE)
    for (level in Level.entries) {
      applicationInterceptor.setLevel(level)
      assertThat(applicationInterceptor.level).isEqualTo(level)
    }
  }

  @Test
  fun setLevelShouldReturnSameInstanceOfInterceptor() {
    for (level in Level.entries) {
      assertThat(applicationInterceptor.setLevel(level)).isSameInstanceAs(applicationInterceptor)
    }