}

    @Test
    public void test_isSecureCookie_noRequest() {
        UserInfoHelper userInfoHelper = new UserInfoHelper();
        userInfoHelper.setCookieSecure(null);

        assertFalse(userInfoHelper.isSecureCookie());
    }

    @Test
    public void test_getUserCodeFromCookie() {
        UserInfoHelper userInfoHelper = new UserInfoHelper() {
            @Override

public class ChatSessionTest extends UnitFessTestCase {

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {
        super.setUp(testInfo);
    }

    @Override
    protected void tearDown(TestInfo testInfo) throws Exception {
        super.tearDown(testInfo);
    }

    @Test
    public void test_defaultConstructor() {
        final ChatSession session = new ChatSession();

  private static final String EVENT = "Hello";
  private static final String BUS_IDENTIFIER = "test-bus";

  private EventBus bus;

  @Override
  protected void setUp() throws Exception {
    super.setUp();
    bus = new EventBus(BUS_IDENTIFIER);
  }

  public void testBasicCatcherDistribution() {
    StringCatcher catcher = new StringCatcher();
    bus.register(catcher);
    bus.post(EVENT);

  private static final String EVENT = "Hello";
  private static final String BUS_IDENTIFIER = "test-bus";

  private EventBus bus;

  @Override
  protected void setUp() throws Exception {
    super.setUp();
    bus = new EventBus(BUS_IDENTIFIER);
  }

  public void testBasicCatcherDistribution() {
    StringCatcher catcher = new StringCatcher();
    bus.register(catcher);
    bus.post(EVENT);

        @DisplayName("Should implement AutoCloseable interface")
        void shouldImplementAutoCloseable() {
            assertTrue(AutoCloseable.class.isAssignableFrom(SmbSession.class), "SmbSession should implement AutoCloseable interface");
        }

        @Test
        @DisplayName("Should define close method that overrides AutoCloseable")
        void shouldDefineCloseMethod() throws Exception {
            assertDoesNotThrow(() -> {

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {
        super.setUp(testInfo);
    }

    @Test
    public void test_constructor() {
        LogNotificationHelper helper = new LogNotificationHelper();
        assertNotNull(helper);
    }

    @Test
    public void test_init_and_destroy() {

  @CollectionSize.Require(absent = ZERO)
  public void testAddAtIndex_supportedPresent() {
    getList().add(0, e0());
    expectAdded(0, e0());
  }

  @ListFeature.Require(absent = SUPPORTS_ADD_WITH_INDEX)
  @CollectionSize.Require(absent = ZERO)
  /*
   * absent = ZERO isn't required, since unmodList.add() must
   * throw regardless, but it keeps the method name accurate.
   */
  public void testAddAtIndex_unsupportedPresent() {

  @CollectionSize.Require(SEVERAL)
  public void testRemovePresentConcurrentWithValuesIteration() {
    assertThrows(
        ConcurrentModificationException.class,
        () -> {
          Iterator<V> iterator = getMap().values().iterator();
          getMap().remove(k0());
          iterator.next();
        });
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testRemove_notPresent() {

    @SuppressWarnings("unused") // accessed reflectively
    public void testPublic() {}

    @SuppressWarnings("unused") // accessed reflectively
    void testNotPublic() {}
  }

  // Shouldn't be mistaken as Foo's test
  static class Foo2Test {
    @SuppressWarnings("unused") // accessed reflectively
    public void testPublic() {}
  }

  private List<Class<?>> findClassesToTest(

public class CacheBuilderTest extends TestCase {

  public void testNewBuilder() {
    CacheLoader<Object, Integer> loader = constantLoader(1);

    LoadingCache<String, Integer> cache =
        CacheBuilder.newBuilder().removalListener(countingRemovalListener()).build(loader);

    assertThat(cache.getUnchecked("one")).isEqualTo(1);
    assertThat(cache.size()).isEqualTo(1);
  }

  public void testInitialCapacity_negative() {