features.add(NoRecurse.DESCENDING);
    features.addAll(parentBuilder.getFeatures());

    return subSuiteUsing(new DescendingTestMapGenerator<K, V>(delegate))
        .named(parentBuilder.getName() + " descending")
        .withFeatures(features)
        .suppressing(parentBuilder.getSuppressedTests())
        .createTestSuite();
  }

        } catch (IllegalStateException e) {
            assertTrue(e.getMessage().contains("crawlerContainer"));
        } catch (Exception e) {
            fail("Expected IllegalStateException but got: " + e.getClass().getName());
        }
    }

    /**
     * Test creation with null component name
     */
    public void test_create_nullComponentName() {

            final String refPath = dr.getPath() != null ? '\\' + dr.getPath() : "";
            final String nextPath = refPath + (path != null ? path.substring(r.getPathConsumed()) : "");
            if (log.isDebugEnabled()) {
                log.debug(String.format("Intermediate referral, server %s share %s refPath %s origPath %s nextPath %s", r.getServer(),
                        r.getShare(), r.getPath(), path, nextPath));
            }

            mojos.remove(Thread.currentThread());
        }

        private OwnerReentrantLock getProjectLock(MavenSession session) {
            SessionData data = session.getSession().getData();
            Map<MavenProject, OwnerReentrantLock> locks = data.computeIfAbsent(PROJECT_LOCKS, ConcurrentHashMap::new);
            return locks.computeIfAbsent(session.getCurrentProject(), p -> new OwnerReentrantLock());

            return updateEntity(source, result);
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }

    protected <RESULT extends CrawlingInfo> RESULT updateEntity(Map<String, Object> source, RESULT result) {
        return result;

            return updateEntity(source, result);
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }

    protected <RESULT extends ElevateWord> RESULT updateEntity(Map<String, Object> source, RESULT result) {
        return result;
    }

            return updateEntity(source, result);
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }

    protected <RESULT extends PathMapping> RESULT updateEntity(Map<String, Object> source, RESULT result) {
        return result;
    }

            this.nameidSPNameQualifier = nameidSPNameQualifier;
            this.groups = groups;
            this.roles = roles;
        }

        @Override
        public String getName() {
            return nameId;
        }

        @Override
        public String[] getRoleNames() {
            return roles;
        }

        @Override

                try {
                    l.onConnect();
                } catch (final Exception e) {
                    logger.warn("Failed to invoke onConnect listener: listener={}", l.getClass().getName(), e);
                }
            });

            connected = true;
        } else {
            logger.warn("Could not connect to {}", address);
        }
    }

    /**

        @Override
        protected SmbResource adapt(FileEntry e) throws MalformedURLException {
            return resource;
        }
    }

    @BeforeEach
    void setUp() {
        lenient().when(fileEntry.getName()).thenReturn("test");
    }

    @Test
    @DisplayName("Iterator without filter - simple case")
    void iteratorWithoutFilter() {
        // Setup: constructor calls advance() once