@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());
  }

        SuggestSettings settings = suggester.settings();
        int num = 10000;

        addDocument(indexName, client, num);

        ESSourceReader reader = new ESSourceReader(client, settings, indexName);
        reader.setScrollSize(1000);
        reader.addSort(SortBuilders.fieldSort("field2"));
        int count = 0;
        int prev = -1;
        Map<String, Object> source;

          streamId: Int,
          streamDependency: Int,
          weight: Int,
          exclusive: Boolean,
        ) {
          assertThat(streamDependency).isEqualTo(0)
          assertThat(weight).isEqualTo(256)
          assertThat(exclusive).isFalse()
        }

        override fun headers(
          inFinished: Boolean,
          streamId: Int,
          associatedStreamId: Int,

		ACB_DONT_REQUIRE_PREAUTH   = 0x00010000  /* 1 = Preauth not required */
	} SamrAcctFlags;

	[op(0x01)]
	int SamrCloseHandle([in] policy_handle *handle);

	[op(0x39)]
	int SamrConnect2([in,string,unique] wchar_t *system_name,
			[in] uint32_t access_mask,
			[out] policy_handle *handle);

	[op(0x3e)]
	int SamrConnect4([in,string,unique] wchar_t *system_name,
			[in] uint32_t unknown,
			[in] uint32_t access_mask,

  abstract List<E> delegateList();

  public int indexOf(@Nullable Object object) {
    return delegateList().indexOf(object);
  }

  public int lastIndexOf(@Nullable Object object) {
    return delegateList().lastIndexOf(object);
  }

  public E get(int index) {
    return delegateList().get(index);
  }

  public ImmutableList<E> subList(int fromIndex, int toIndex) {

  public long getCount() {
    return count;
  }

  @Override
  public int read() throws IOException {
    int result = in.read();
    if (result != -1) {
      count++;
    }
    return result;
  }

  @Override
  public int read(byte[] b, int off, int len) throws IOException {
    int result = in.read(b, off, len);
    if (result != -1) {
      count += result;
    }
    return result;

  private transient int size;
  private transient int mask;
  private transient int modCount;

  private HashBiMap(int expectedSize) {
    init(expectedSize);
  }

  private void init(int expectedSize) {
    checkNonnegative(expectedSize, "expectedSize");
    int tableSize = Hashing.closedTableSize(expectedSize, LOAD_FACTOR);

    }


    @Override
    int writeBodyWireFormat ( byte[] dst, int dstIndex ) {
        return writeQuestionSectionWireFormat(dst, dstIndex);
    }


    @Override
    int readBodyWireFormat ( byte[] src, int srcIndex ) {
        return readQuestionSectionWireFormat(src, srcIndex);
    }


    @Override
    int writeRDataWireFormat ( byte[] dst, int dstIndex ) {
        return 0;
    }

/**
 * @author mbechler
 *
 */
public class ByteEncodable implements Encodable {

    private byte[] bytes;
    private int off;
    private int len;


    /**
     * @param b
     * @param off
     * @param len
     */
    public ByteEncodable ( byte[] b, int off, int len ) {
        this.bytes = b;
        this.off = off;
        this.len = len;
    }


    /**
     * {@inheritDoc}

-{
-  size_t __result = 0;
-  while (__s[__result] != '\0' && __s[__result] != __reject1
-	 && __s[__result] != __reject2)
-    ++__result;
-  return __result;
-}
-
-__STRING_INLINE size_t __strcspn_c3 (const char *__s, int __reject1,
-				     int __reject2, int __reject3);
-__STRING_INLINE size_t
-__strcspn_c3 (const char *__s, int __reject1, int __reject2,
-	      int __reject3)
-{