.containsExactly(rootDir, fileA, fileB, dir1, dir2);
  }

  @CanIgnoreReturnValue
  private File newDir(String name) {
    File file = new File(rootDir, name);
    file.mkdir();
    return file;
  }

  @CanIgnoreReturnValue
  private File newFile(String name) throws IOException {
    File file = new File(rootDir, name);
    file.createNewFile();
    return file;
  }

 * propagated out from the {@link Flushables#flush} method if {@code swallowException} is true.
 *
 * @author Michael Lancaster
 */
@NullUnmarked
public class FlushablesTest extends TestCase {
  private Flushable mockFlushable;

  public void testFlush_clean() throws IOException {
    // make sure that no exception is thrown regardless of value of
    // 'swallowException' when the mock does not throw an exception.

    return ImmutableSet.of(immutableEntry(singleKey, singleValue));
  }

  @Override
  ImmutableSet<K> createKeySet() {
    return ImmutableSet.of(singleKey);
  }

  private final transient @Nullable ImmutableBiMap<V, K> inverse;
  @LazyInit @RetainedWith private transient @Nullable ImmutableBiMap<V, K> lazyInverse;

  @Override
  public ImmutableBiMap<V, K> inverse() {
    if (inverse != null) {
      return inverse;

 *
 * @see java.io.Serializable
 */
public class RequestHeader implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * The name of the request header.
     */
    private String name;

    /**
     * The value of the request header.
     */
    private String value;

    /**
     * Constructs a new RequestHeader with the specified name and value.
     *

import java.util.Random;
import org.jspecify.annotations.NullUnmarked;

/** Benchmark for {@code BaseEncoding} performance. */
@NullUnmarked
public class BaseEncodingBenchmark {
  private static final int INPUTS_COUNT = 0x1000;
  private static final int INPUTS_MASK = 0xFFF;

  enum EncodingOption {
    BASE64(BaseEncoding.base64()),
    BASE64_URL(BaseEncoding.base64Url()),
    BASE32(BaseEncoding.base32()),

import org.jspecify.annotations.NullMarked;

/**
 * @author David Beaumont
 */
@GwtCompatible
@NullMarked
public class ArrayBasedCharEscaperTest extends TestCase {
  private static final ImmutableMap<Character, String> NO_REPLACEMENTS = ImmutableMap.of();
  private static final ImmutableMap<Character, String> SIMPLE_REPLACEMENTS =
      ImmutableMap.of(
          '\n', "<newline>",
          '\t', "<tab>",
          '&', "<and>");

     * The unique identifier for this URL filter.
     */
    private String id;

    /**
     * The session ID associated with this URL filter.
     */
    private String sessionId;

    /**
     * The type of filter (e.g., include, exclude).
     */
    private String filterType;

    /**
     * The URL pattern for this filter.
     */
    private String url;

    /**
     * Returns the ID.

 */
public class Skip implements RestTestTransformGlobalSetup, RestTestTransformByParentObject {

    private static JsonNodeFactory jsonNodeFactory = JsonNodeFactory.withExactBigDecimals(false);

    private final String skipReason;
    private final String testName;

    public Skip(String testName, String skipReason) {
        this.skipReason = skipReason;
        this.testName = testName;

@J2ktIncompatible
@GwtIncompatible
public final class InetAddresses {
  private static final int IPV4_PART_COUNT = 4;
  private static final int IPV6_PART_COUNT = 8;
  private static final char IPV4_DELIMITER = '.';
  private static final char IPV6_DELIMITER = ':';
  private static final CharMatcher IPV4_DELIMITER_MATCHER = CharMatcher.is(IPV4_DELIMITER);
  private static final CharMatcher IPV6_DELIMITER_MATCHER = CharMatcher.is(IPV6_DELIMITER);

import org.lastaflute.di.core.meta.impl.InstanceDefFactory;
import org.lastaflute.di.naming.NamingConvention;

public class PagerCreatorTest extends UnitFessTestCase {

    private PagerCreator pagerCreator;
    private NamingConvention namingConvention;

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {
        super.setUp(testInfo);
        namingConvention = new MockNamingConvention();