// [Index] creation time is O(N) for N = len(data).
func New(data []byte) *Index {
	ix := &Index{data: data}
	if len(data) <= maxData32 {
		ix.sa.int32 = make([]int32, len(data))
		text_32(data, ix.sa.int32)
	} else {
		ix.sa.int64 = make([]int64, len(data))
		text_64(data, ix.sa.int64)
	}
	return ix
}

// writeInt writes an int x to w using buf to buffer the write.
func writeInt(w io.Writer, buf []byte, x int) error {

func TestNew32(t *testing.T) {
	test(t, func(x []byte) []int {
		sa := make([]int32, len(x))
		text_32(x, sa)
		out := make([]int, len(sa))
		for i, v := range sa {
			out[i] = int(v)
		}
		return out
	})
}

func TestNew64(t *testing.T) {
	test(t, func(x []byte) []int {
		sa := make([]int64, len(x))
		text_64(x, sa)
		out := make([]int, len(sa))
		for i, v := range sa {
			out[i] = int(v)
		}

        def text2 = "more text"

        when:
        userInputReceiver.readAndForwardStdin(new ReadStdInEvent())
        source << text

        then:
        receiveStdin text

        when:
        source << text2
        userInputReceiver.readAndForwardStdin(new ReadStdInEvent())

        then:
        receiveStdin text2

        when:
        forwarder.stop()

        def dispatch = Mock(OutputEventListener)
        def stream = new StdInStream(dispatch)
        def text1 = "some text"
        def bytes1 = text1.bytes
        def text2 = "more"
        def bytes2 = text2.bytes

        when:
        async {
            start {
                def buffer = new byte[1024]

                def nread = stream.read(buffer)