}

func (m *mutator) rand(n int) int {
	return m.r.intn(n)
}

func (m *mutator) randByteOrder() binary.ByteOrder {
	if m.r.bool() {
		return binary.LittleEndian
	}
	return binary.BigEndian
}

// chooseLen chooses length of range mutation in range [1,n]. It gives
// preference to shorter ranges.
func (m *mutator) chooseLen(n int) int {
	switch x := m.rand(100); {
	case x < 90:

	}
	c <- 0
}

// Test a single read/write pair.
func TestPipe1(t *testing.T) {
	c := make(chan int)
	r, w := Pipe()
	var buf = make([]byte, 64)
	go checkWrite(t, w, []byte("hello, world"), c)
	n, err := r.Read(buf)
	if err != nil {
		t.Errorf("read: %v", err)
	} else if n != 12 || string(buf[0:12]) != "hello, world" {
		t.Errorf("bad read: got %q", buf[0:n])
	}
	<-c
	r.Close()
	w.Close()
}

        then:
        data1.read({ it.readInt() } as BinaryStore.ReadAction) == 10
        data1.read({ it.readString() } as BinaryStore.ReadAction) == "x"
        data1.close()

        data2.read({ it.readString() } as BinaryStore.ReadAction) == "y"
        data2.close()

        cleanup:
        store.close()
    }

    def "data can be re-read"() {

        serializer.write(e, data)
        ClassSetAnalysisData read = serializer.read(new InputStreamBackedDecoder(new ByteArrayInputStream(os.toByteArray())))

        then:
        read.dependents.keySet() == data.dependents.keySet()

        ["A", "B", "C"].each {
            assert read.dependents[it].privateDependentClasses == data.dependents[it].privateDependentClasses

    assertEquals(-1, counter.read());
    assertEquals(20, counter.getCount());
  }

  public void testReadArrayEOF() throws IOException {
    assertEquals(20, counter.read(new byte[30]));
    assertEquals(20, counter.getCount());
    assertEquals(-1, counter.read(new byte[30]));
    assertEquals(20, counter.getCount());
  }

  @SuppressWarnings("CheckReturnValue") // calling read() to skip a byte

}

func ExamplePerm() {
	for _, value := range rand.Perm(3) {
		fmt.Println(value)
	}

	// Unordered output: 1
	// 2
	// 0
}

func ExampleN() {
	// Print an int64 in the half-open interval [0, 100).
	fmt.Println(rand.N(int64(100)))

	// Sleep for a random duration between 0 and 100 milliseconds.
	time.Sleep(rand.N(100 * time.Millisecond))
}

func ExampleShuffle() {

                int bufferSize = 4096;
                byte[] buffer = new byte[bufferSize];

                int read = 0;
                try {
                    read = input.read(buffer);
                    while(read != -1) {
                        output.write(buffer, 0, read);
                        read = input.read(buffer);
                    }
                } catch (IOException e) {

            if (toRead == 0) {
                return 0;
            }
            int read = file.read(buffer, offset, toRead);
            if (read < 0) {
                throw new IllegalStateException("Unexpected file length.");
            }
            remaining -= read;
            return read;
        }
    }

    private static class Source<T> implements Closeable {

    }

    @Override
    public int read() throws IOException {
        return inputStream.read();
    }

    @Override
    public int read(final byte[] b, final int off, final int len) throws IOException {
        return inputStream.read(b, off, len);
    }

    @Override
    public int read(final byte[] b) throws IOException {
        return inputStream.read(b);
    }

    @Override

        def inputStream = new ByteArrayInputStream(outputStream.toByteArray())
        def decoder = new EncodedStream.EncodedInput(inputStream)
        decoder.read() == 0
        decoder.read() == 127
        decoder.read() == 128
        decoder.read() == 255
        decoder.read() < 0
    }