/*
netstring -- netstring format serialization library
Copyright (C) 2015 Sergey Matveev <stargrave@stargrave.org>

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

package netstring

import (
	"bytes"
	"testing"
	"testing/quick"
)

func TestTrivial(t *testing.T) {
	buf := bytes.NewBuffer(nil)
	w := NewWriter(buf)
	if n, err := w.Write([]byte{}); err != nil || n != 3 || string(buf.Next(3)) != "0:," {
		t.Fail()
	}
	if n, err := w.Write([]byte("foo")); err != nil || n != 6 {
		t.Fail()
	}
	if n, err := w.Write([]byte("barz")); err != nil || n != 7 {
		t.Fail()
	}
	if string(buf.Bytes()) != "3:foo,4:barz," {
		t.Fail()
	}
	r := NewReader(buf)
	if n, err := r.Iter(); err != nil || n != 3 {
		t.Fail()
	}
	if r.Discard() != nil {
		t.Fail()
	}
	if n, err := r.Iter(); err != nil || n != 4 {
		t.Fail()
	}
	m := make([]byte, int(4))
	if r.Read(m) != nil {
		t.Fail()
	}
	if bytes.Compare(m, []byte("barz")) != 0 {
		t.Fail()
	}
}

func TestSymmetric(t *testing.T) {
	buf := bytes.NewBuffer(nil)
	w := NewWriter(buf)
	r := NewReader(buf)
	f := func(i uint8, data []byte) bool {
		var n uint8
		for n = 0; n < i; n++ {
			if _, err := w.Write(data); err != nil {
				return false
			}
		}
		for n = 0; n < i; n++ {
			size, err := r.Iter()
			if err != nil || int(size) != len(data) {
				return false
			}
			read := make([]byte, size)
			if r.Read(read) != nil {
				return false
			}
			if bytes.Compare(read, data) != 0 {
				return false
			}
		}
		return true
	}
	if err := quick.Check(f, nil); err != nil {
		t.Error(err)
	}
}

func TestErrors(t *testing.T) {
	b := bytes.NewBufferString("junk")
	r := NewReader(b)
	if _, err := r.Iter(); err == nil {
		t.FailNow()
	}

	b = bytes.NewBufferString("1111111111111111111111:")
	r = NewReader(b)
	if _, err := r.Iter(); err == nil {
		t.FailNow()
	}

	b = bytes.NewBufferString("6foobar")
	r = NewReader(b)
	if _, err := r.Iter(); err == nil {
		t.FailNow()
	}

	data := make([]byte, 1<<10)

	b = bytes.NewBufferString("0:foobar,")
	r = NewReader(b)
	if _, err := r.Iter(); err != nil {
		t.FailNow()
	}
	if r.Read(data) == nil {
		t.FailNow()
	}

	b = bytes.NewBufferString("0:foobar")
	r = NewReader(b)
	if _, err := r.Iter(); err != nil {
		t.FailNow()
	}
	if r.Read(data) == nil {
		t.FailNow()
	}

	b = bytes.NewBufferString("6:foobar")
	r = NewReader(b)
	if _, err := r.Iter(); err != nil {
		t.FailNow()
	}
	if r.Read(data) == nil {
		t.FailNow()
	}

}