@RunWith(JUnit4.class)

@NullUnmarked
public final class GraphMutationTest {
  private static final int NUM_TRIALS = 50;
  private static final int NUM_NODES = 100;
  private static final int NUM_EDGES = 1000;
  private static final int NODE_POOL_SIZE = 1000; // must be >> NUM_NODES

  @Test
  public void directedGraph() {
    testGraphMutation(GraphBuilder.directed());

    private String netbiosName = null;

    private CIFSContext transportContext;

    private CredentialsInternal credentials;
    private byte[] sessionKey;
    private boolean extendedSecurity;

    private final AtomicLong usageCount = new AtomicLong(1);
    private final AtomicBoolean transportAcquired = new AtomicBoolean(true);

    private long sessionId;

    private SMBSigningDigest digest;

import okio.buffer
import okio.source

/** A basic HTTP/2 server that serves the contents of a local directory.  */
class Http2Server(
  private val baseDirectory: File,
  private val sslSocketFactory: SSLSocketFactory,
) : Http2Connection.Listener() {
  private fun run() {
    val serverSocket = ServerSocket(8888)
    serverSocket.reuseAddress = true
    while (true) {
      var socket: Socket? = null
      try {

 */
public class ContainerNotAvailableException extends FessSystemException {

    private static final long serialVersionUID = 1L;

    /** The name of the component that is not available. */
    private String componentName;

    /**
     * Constructor with component name.
     * @param componentName The name of the component that is not available.
     */

import org.codelibs.fess.Constants;
import org.codelibs.fess.dict.mapping.CharMappingCreator;
import org.codelibs.fess.unit.UnitFessTestCase;

public class DictionaryManagerTest extends UnitFessTestCase {
    private File testDir;

    private File file1;

    @Override
    public void setUp() throws Exception {
        super.setUp();
        testDir = File.createTempFile("synonymtest", "_dir");
        testDir.delete();

import org.dbflute.optional.OptionalEntity;

/**
 * @author ESFlute (using FreeGen)
 */
public class CrawlingInfoParam extends BsCrawlingInfoParam {

    private static final long serialVersionUID = 1L;

    private OptionalEntity<CrawlingInfo> crawlingInfo;

    public String getId() {
        return asDocMeta().id();
    }

    public void setId(final String id) {
        asDocMeta().id(id);

 */
class OneLineLogFormat : Formatter() {
  private val d =
    DateTimeFormatterBuilder()
      .appendValue(HOUR_OF_DAY, 2)
      .appendLiteral(':')
      .appendValue(MINUTE_OF_HOUR, 2)
      .optionalStart()
      .appendLiteral(':')
      .appendValue(SECOND_OF_MINUTE, 2)
      .optionalStart()
      .appendFraction(NANO_OF_SECOND, 3, 3, true)
      .toFormatter()

  private val offset = ZoneOffset.systemDefault()

import okio.Path.Companion.toPath
import okio.fakefilesystem.FakeFileSystem
import org.junit.AssumptionViolatedException
import org.junit.Before
import org.junit.Test

abstract class BaseOkHttpClientUnitTest {
  private lateinit var client: OkHttpClient

  @Before
  fun setUp() {
    client =
      OkHttpClient
        .Builder()
        .cache(Cache(FakeFileSystem(), "/cache".toPath(), 10_000_000))
        .build()
  }

import okio.Buffer
import okio.BufferedSource
import okio.ByteString.Companion.encodeUtf8
import okio.Options

internal class ServerSentEventReader(
  private val source: BufferedSource,
  private val callback: Callback,
) {
  private var lastId: String? = null

  interface Callback {
    fun onEvent(
      id: String?,
      type: String?,
      data: String,
    )

    }
  }

  private static Set<MethodSignature> getAllRequiredToFauxveride(Class<?> ancestor) {
    return getPublicStaticMethodsBetween(ancestor, Object.class);
  }

  private static Set<MethodSignature> getAllFauxveridden(Class<?> descendant, Class<?> ancestor) {
    return getPublicStaticMethodsBetween(descendant, ancestor);
  }

  private static Set<MethodSignature> getPublicStaticMethodsBetween(