@RunWith(JUnit4.class)

public final class NetworkMutationTest {
  private static final int NUM_TRIALS = 5;
  private static final int NUM_NODES = 20;
  private static final int NUM_EDGES = 100;
  private static final int NODE_POOL_SIZE = 1000; // must be >> NUM_NODES

  @Test
  public void directedNetwork() {
    testNetworkMutation(NetworkBuilder.directed());
  }

        return this.endOfFile;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode ( byte[] buffer, int bufferIndex, int len ) throws SMBProtocolDecodingException {
        int start = bufferIndex;
        this.allocationSize = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;

        gt: Optional[float] = None,
        ge: Optional[float] = None,
        lt: Optional[float] = None,
        le: Optional[float] = None,
        min_length: Optional[int] = None,
        max_length: Optional[int] = None,
        pattern: Optional[str] = None,
        regex: Annotated[
            Optional[str],
            deprecated(

    public static final int KERB_CHECKSUM_HMAC_MD5 = 0xFFFFFF76;
    public static final int HMAC_SHA1_96_AES128 = 0x0000000F;
    public static final int HMAC_SHA1_96_AES256 = 0x00000010;

    public static final int ETYPE_ARCFOUR_HMAC = 23;
    public static final int ETYPE_AES128_CTS_HMAC_SHA1_96 = 17;
    public static final int ETYPE_AES256_CTS_HMAC_SHA1_96 = 18;

    private int type;
    private byte[] checksum;

  public Object measureSize() {
    list = impl.newExecutionList();
    for (int i = 0; i < numListeners; i++) {
      list.add(listener, directExecutor());
    }
    return list.getImpl();
  }

  @Benchmark
  int addThenExecute_singleThreaded(int reps) {
    int returnValue = 0;
    for (int i = 0; i < reps; i++) {
      list = impl.newExecutionList();

     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#writeBytesWireFormat(byte[], int)
     */
    @Override
    protected int writeBytesWireFormat ( byte[] dst, int dstIndex ) {
        int start = dstIndex;
        SMBUtil.writeInt2(24, dst, dstIndex);
        SMBUtil.writeInt2(this.closeFlags, dst, dstIndex + 2);
        dstIndex += 4;
        dstIndex += 4; // Reserved

    }

    protected int engineDigest(byte[] buf, int offset, int len) {
        byte[] digest = md5.digest();
        md5.update(opad);
        md5.update(digest);
        try {
            return md5.digest(buf, offset, len);
        } catch (Exception ex) {
            throw new IllegalStateException();
        }
    }

    protected int engineGetDigestLength() {

     */
    public HMACT64 ( byte[] key ) {
        super("HMACT64");
        int length = Math.min(key.length, BLOCK_LENGTH);
        for ( int i = 0; i < length; i++ ) {
            this.ipad[ i ] = (byte) ( key[ i ] ^ IPAD );
            this.opad[ i ] = (byte) ( key[ i ] ^ OPAD );
        }
        for ( int i = length; i < BLOCK_LENGTH; i++ ) {
            this.ipad[ i ] = IPAD;
            this.opad[ i ] = OPAD;

    static final int[] maxValueMods = new int[Character.MAX_RADIX + 1];
    static final int[] maxSafeDigits = new int[Character.MAX_RADIX + 1];

    static {
      BigInteger overflow = new BigInteger("10000000000000000", 16);
      for (int i = Character.MIN_RADIX; i <= Character.MAX_RADIX; i++) {
        maxValueDivs[i] = divide(MAX_VALUE, i);
        maxValueMods[i] = (int) remainder(MAX_VALUE, i);

   * hereby disclaims copyright to this source code.
   */
  static int smear(int hashCode) {
    return (int) (C2 * Integer.rotateLeft((int) (hashCode * C1), 15));
  }

  static int smearedHash(@CheckForNull Object o) {
    return smear((o == null) ? 0 : o.hashCode());
  }

  private static final int MAX_TABLE_SIZE = Ints.MAX_POWER_OF_TWO;

  static int closedTableSize(int expectedEntries, double loadFactor) {