package tag

import (
	"bytes"
	"testing"

	"git.smesh.lol/nostr/pkg/hex"
)

// upperHex renders src as uppercase hex. Equals carries separate branches for
// the 'A'-'F' nibbles that a lowercase encoder never reaches.
func upperHex(src []byte) (out []byte) {
	tbl := []byte("0123456789ABCDEF")
	out = []byte{:len(src) * 2}
	for i := range src {
		out[i*2] = tbl[int32(src[i]>>4)]
		out[i*2+1] = tbl[int32(src[i]&0x0F)]
	}
	return
}

const zeroHex64 = "0000000000000000000000000000000000000000000000000000000000000000"

func TestNewAndFree(t *testing.T) {
	nt := New()
	if nt == nil {
		t.Fatal("New returned nil")
	}
	if nt.Len() != 0 {
		t.Fatalf("New().Len() = %d, want 0", nt.Len())
	}
	nt.T = push(nt.T, []byte("k"))
	if nt.Len() != 1 {
		t.Fatalf("Len after push = %d, want 1", nt.Len())
	}
	nt.Free()
	if nt.T != nil {
		t.Fatal("Free did not clear the slice")
	}
	if nt.Len() != 0 {
		t.Fatalf("Len after Free = %d, want 0", nt.Len())
	}
	capped := NewWithCap(8)
	if capped.Len() != 0 {
		t.Fatalf("NewWithCap(8).Len() = %d, want 0", capped.Len())
	}
}

func TestLenNilReceiver(t *testing.T) {
	var nt *T
	if nt.Len() != 0 {
		t.Fatalf("nil Len = %d, want 0", nt.Len())
	}
}

func TestLenLessSwapContains(t *testing.T) {
	a := NewFromBytesSlice([]byte("a"), []byte("one"))
	b := NewFromBytesSlice([]byte("b"), []byte("two"))
	if a.Len() != 2 || b.Len() != 2 {
		t.Fatalf("Len: a=%d b=%d, want 2 each", a.Len(), b.Len())
	}
	if !a.Less(0, 1) {
		t.Fatal("Less(0,1) should be true for a<one")
	}
	if a.Less(1, 0) {
		t.Fatal("Less(1,0) should be false")
	}
	b.Swap(0, 1)
	if !bytes.Equal(b.T[0], []byte("two")) {
		t.Fatalf("Swap left value = %s", b.T[0])
	}
	if !bytes.Equal(b.T[1], []byte("b")) {
		t.Fatalf("Swap left key = %s", b.T[1])
	}
	if !a.Contains([]byte("a")) {
		t.Fatal("Contains should find the key")
	}
	if !a.Contains([]byte("one")) {
		t.Fatal("Contains should find the value")
	}
	if a.Contains([]byte("zzz")) {
		t.Fatal("Contains should not find an absent field")
	}
	if New().Contains([]byte("a")) {
		t.Fatal("empty tag should contain nothing")
	}
}

func TestAccessors(t *testing.T) {
	empty := New()
	if empty.Key() != nil {
		t.Fatal("empty Key should be nil")
	}
	if empty.Value() != nil {
		t.Fatal("empty Value should be nil")
	}
	if empty.Relay() != nil {
		t.Fatal("empty Relay should be nil")
	}
	one := NewFromBytesSlice([]byte("k"))
	if !bytes.Equal(one.Key(), []byte("k")) {
		t.Fatalf("Key = %s, want k", one.Key())
	}
	if one.Value() != nil {
		t.Fatal("one-field Value should be nil")
	}
	if one.Relay() != nil {
		t.Fatal("one-field Relay should be nil")
	}
	two := NewFromBytesSlice([]byte("k"), []byte("v"))
	if !bytes.Equal(two.Key(), []byte("k")) {
		t.Fatalf("two-field Key = %s", two.Key())
	}
	if !bytes.Equal(two.Value(), []byte("v")) {
		t.Fatalf("two-field Value = %s", two.Value())
	}
	if two.Relay() != nil {
		t.Fatal("two-field Relay should be nil")
	}
	three := NewFromBytesSlice([]byte("k"), []byte("v"), []byte("r"))
	if !bytes.Equal(three.Relay(), []byte("r")) {
		t.Fatalf("three-field Relay = %s", three.Relay())
	}
	var nt *T
	if nt.Value() != nil {
		t.Fatal("nil receiver Value should be nil")
	}
}

func TestMarshalTag(t *testing.T) {
	tv := NewFromBytesSlice([]byte("t"), []byte("test"))
	got := string(tv.Marshal(nil))
	if got != "[\"t\",\"test\"]" {
		t.Fatalf("Marshal = %s", got)
	}
	gotDst := string(tv.Marshal([]byte("pre")))
	if gotDst != "pre[\"t\",\"test\"]" {
		t.Fatalf("Marshal into dst = %s", gotDst)
	}
	if string(New().Marshal(nil)) != "[]" {
		t.Fatalf("empty Marshal = %s", string(New().Marshal(nil)))
	}
	esc := NewFromBytesSlice([]byte("t"), []byte("a\"b\\c"))
	gotEsc := string(esc.Marshal(nil))
	if gotEsc != "[\"t\",\"a\\\"b\\\\c\"]" {
		t.Fatalf("escaped Marshal = %s", gotEsc)
	}
	jb, jerr := tv.MarshalJSON()
	if jerr != nil {
		t.Fatal(jerr)
		return
	}
	if string(jb) != "[\"t\",\"test\"]" {
		t.Fatalf("MarshalJSON = %s", string(jb))
	}
}

func TestMarshalBinaryValue(t *testing.T) {
	bin := []byte{:33}
	bin[0] = 0x5a
	bin[1] = 0xa5
	bt := NewFromBytesSlice([]byte("e"), bin)
	hx := hex.EncAppend(nil, bin[:HashLen])
	want := string([]byte("[\"e\",\"") | hx | []byte("\"]"))
	got := string(bt.Marshal(nil))
	if got != want {
		t.Fatalf("binary Marshal = %s, want %s", got, want)
	}
	// A 33-byte value whose last byte is not zero is not binary-encoded, so it
	// must be quoted raw rather than rendered as hex.
	notBin := []byte{:33}
	notBin[32] = 1
	nb := NewFromBytesSlice([]byte("e"), notBin)
	gotNb := string(nb.Marshal(nil))
	if gotNb == want {
		t.Fatal("non-binary 33-byte value must not be hex-encoded")
	}
}

func TestUnmarshalTag(t *testing.T) {
	tt := New()
	rem, err := tt.Unmarshal([]byte("[\"t\",\"test\"],tail"))
	if err != nil {
		t.Fatal(err)
		return
	}
	if tt.Len() != 2 {
		t.Fatalf("Len = %d, want 2", tt.Len())
	}
	if !bytes.Equal(tt.Key(), []byte("t")) {
		t.Fatalf("Key = %s", tt.Key())
	}
	if !bytes.Equal(tt.Value(), []byte("test")) {
		t.Fatalf("Value = %s", tt.Value())
	}
	if string(rem) != ",tail" {
		t.Fatalf("remainder = %s, want ,tail", string(rem))
	}
	et := New()
	remEmpty, errEmpty := et.Unmarshal([]byte("[]"))
	if errEmpty != nil {
		t.Fatal(errEmpty)
		return
	}
	if et.Len() != 0 || len(remEmpty) != 0 {
		t.Fatalf("empty parse: Len=%d rem=%s", et.Len(), string(remEmpty))
	}
	esc := New()
	_, errEsc := esc.Unmarshal([]byte("[\"t\",\"a\\nb\"]"))
	if errEsc != nil {
		t.Fatal(errEsc)
		return
	}
	if !bytes.Equal(esc.Value(), []byte("a\nb")) {
		t.Fatalf("unescaped Value = %s", esc.Value())
	}
	three := New()
	_, errThree := three.Unmarshal([]byte("[\"k\",\"v\",\"r\"]"))
	if errThree != nil {
		t.Fatal(errThree)
		return
	}
	if !bytes.Equal(three.Relay(), []byte("r")) {
		t.Fatalf("Relay = %s", three.Relay())
	}
}

func TestUnmarshalTagBinary(t *testing.T) {
	raw := []byte{:32}
	raw[0] = 0x5a
	raw[1] = 0xa5
	hx := hex.EncAppend(nil, raw)
	ej := New()
	_, ejErr := ej.Unmarshal([]byte("[\"e\",\"") | hx | []byte("\"]"))
	if ejErr != nil {
		t.Fatal(ejErr)
		return
	}
	if !isBinaryEncoded(ej.Value()) {
		t.Fatal("e tag with 64-hex value should be binary-encoded")
	}
	if !bytes.Equal(ej.ValueHex(), hx) {
		t.Fatalf("ValueHex = %s, want %s", ej.ValueHex(), hx)
	}
	if !bytes.Equal(ej.ValueBinary(), raw) {
		t.Fatalf("ValueBinary = %s, want %s", ej.ValueBinary(), raw)
	}
	pj := New()
	_, pjErr := pj.Unmarshal([]byte("[\"p\",\"") | hx | []byte("\"]"))
	if pjErr != nil {
		t.Fatal(pjErr)
		return
	}
	if !isBinaryEncoded(pj.Value()) {
		t.Fatal("p tag with 64-hex value should be binary-encoded")
	}
	// A key whose length is not one is never optimized.
	kj := New()
	_, kjErr := kj.Unmarshal([]byte("[\"ab\",\"") | hx | []byte("\"]"))
	if kjErr != nil {
		t.Fatal(kjErr)
		return
	}
	if isBinaryEncoded(kj.Value()) {
		t.Fatal("multi-char key must not be optimized")
	}
	// A single-char key that is neither e nor p is never optimized.
	tj := New()
	_, tjErr := tj.Unmarshal([]byte("[\"t\",\"") | hx | []byte("\"]"))
	if tjErr != nil {
		t.Fatal(tjErr)
		return
	}
	if isBinaryEncoded(tj.Value()) {
		t.Fatal("t tag must not be optimized")
	}
	// A value of the wrong length is never optimized.
	sj := New()
	_, sjErr := sj.Unmarshal([]byte("[\"e\",\"short\"]"))
	if sjErr != nil {
		t.Fatal(sjErr)
		return
	}
	if isBinaryEncoded(sj.Value()) {
		t.Fatal("short e value must not be optimized")
	}
	// A 64-byte value with a non-hex character is stored raw.
	badHex := []byte("z" | zeroHex64[1:])
	bj := New()
	_, bjErr := bj.Unmarshal([]byte("[\"e\",\"") | badHex | []byte("\"]"))
	if bjErr != nil {
		t.Fatal(bjErr)
		return
	}
	if isBinaryEncoded(bj.Value()) {
		t.Fatal("non-hex 64-byte value must not be optimized")
	}
}

func TestUnmarshalTagMalformed(t *testing.T) {
	uq := New()
	if _, uqErr := uq.Unmarshal([]byte("[\"t")); uqErr == nil {
		t.Fatal("unterminated quote should error")
	}
	// A closing bracket with no opening one used to be accepted: the ']'
	// early-return skipped the !openedBracket guard at the end of Unmarshal.
	qonly := New()
	if _, qonlyErr := qonly.Unmarshal([]byte("\"t\",\"v\"]")); qonlyErr == nil {
		t.Fatal("closing bracket without an opening one should error")
	}
	nb := New()
	if _, nbErr := nb.Unmarshal([]byte("\"t\",\"v\"")); nbErr == nil {
		t.Fatal("input with no brackets should error")
	}
	jt := New()
	if jtErr := jt.UnmarshalJSON([]byte("[\"t")); jtErr == nil {
		t.Fatal("UnmarshalJSON should propagate parse errors")
	}
	jok := New()
	if jokErr := jok.UnmarshalJSON([]byte("[\"a\",\"b\"]")); jokErr != nil {
		t.Fatal(jokErr)
		return
	}
	if !bytes.Equal(jok.Value(), []byte("b")) {
		t.Fatalf("UnmarshalJSON Value = %s", jok.Value())
	}
}

func TestParseHelpers(t *testing.T) {
	if !isBinaryOptimizedTag('e') {
		t.Fatal("e should be binary-optimized")
	}
	if !isBinaryOptimizedTag('p') {
		t.Fatal("p should be binary-optimized")
	}
	if isBinaryOptimizedTag('t') {
		t.Fatal("t should not be binary-optimized")
	}
	if !isValidHex([]byte("0123456789abcdefABCDEF")) {
		t.Fatal("valid hex rejected")
	}
	var noHex []byte
	if !isValidHex(noHex) {
		t.Fatal("empty input is valid hex")
	}
	if isValidHex([]byte("xyz")) {
		t.Fatal("invalid hex accepted")
	}
	shortVal := []byte("short")
	if isBinaryEncoded(shortVal) {
		t.Fatal("short value should not be binary-encoded")
	}
	exact := []byte{:33}
	if !isBinaryEncoded(exact) {
		t.Fatal("33-byte zero-tailed value should be binary-encoded")
	}
	exact[32] = 1
	if isBinaryEncoded(exact) {
		t.Fatal("33-byte value with non-zero tail should not be binary-encoded")
	}
	zeroHex := []byte(zeroHex64)
	badHex := []byte("z" | zeroHex64[1:])
	if shouldOptimize([]byte("ab"), zeroHex) {
		t.Fatal("multi-char key should not optimize")
	}
	if shouldOptimize([]byte("t"), zeroHex) {
		t.Fatal("non-e/p key should not optimize")
	}
	if shouldOptimize([]byte("e"), shortVal) {
		t.Fatal("short value should not optimize")
	}
	if !shouldOptimize([]byte("e"), zeroHex) {
		t.Fatal("64-hex e value should optimize")
	}
	if shouldOptimize([]byte("e"), badHex) {
		t.Fatal("non-hex value should not optimize")
	}
}

func TestFieldHelpers(t *testing.T) {
	fv := tagFieldValue([]byte("a\\nb"), 0, 4)
	if !bytes.Equal(fv, []byte("a\nb")) {
		t.Fatalf("tagFieldValue = %s", fv)
	}
	sub := tagFieldValue([]byte("xxyy"), 2, 4)
	if !bytes.Equal(sub, []byte("yy")) {
		t.Fatalf("tagFieldValue slice = %s", sub)
	}
	bin, ok := tagFieldBinary([]byte(zeroHex64))
	if !ok || len(bin) != BinaryEncodedLen {
		t.Fatalf("tagFieldBinary ok=%v len=%d", ok, len(bin))
	}
	if bin[HashLen] != 0 {
		t.Fatalf("tagFieldBinary tail = %d, want 0", bin[HashLen])
	}
	bad, badOk := tagFieldBinary([]byte("xyz"))
	if badOk || bad != nil {
		t.Fatal("tagFieldBinary should reject non-hex input")
	}
}

func TestParseTags(t *testing.T) {
	tsA, remA, errA := parseTags([]byte(",[[\"a\",\"b\"]]"))
	if errA != nil {
		t.Fatal(errA)
		return
	}
	if len(tsA) != 1 || len(remA) != 0 {
		t.Fatalf("leading comma: tags=%d rem=%s", len(tsA), string(remA))
	}
	tsB, _, errB := parseTags([]byte("x[[\"a\",\"b\"]]"))
	if errB != nil {
		t.Fatal(errB)
		return
	}
	if len(tsB) != 1 {
		t.Fatalf("leading junk: tags=%d", len(tsB))
	}
	tsC, remC, errC := parseTags([]byte("]junk"))
	if errC != nil {
		t.Fatal(errC)
		return
	}
	if len(tsC) != 0 || string(remC) != "junk" {
		t.Fatalf("leading close: tags=%d rem=%s", len(tsC), string(remC))
	}
	tsD, _, errD := parseTags([]byte("[[\"a\",\"b\"] junk]"))
	if errD != nil {
		t.Fatal(errD)
		return
	}
	if len(tsD) != 1 {
		t.Fatalf("inner junk: tags=%d", len(tsD))
	}
	tsE, _, errE := parseTags([]byte("[[\"a\",\"b\"]"))
	if errE != nil {
		t.Fatal(errE)
		return
	}
	if len(tsE) != 1 {
		t.Fatalf("missing outer close: tags=%d", len(tsE))
	}
	tsF, _, errF := parseTags([]byte("[[\"t"))
	if errF == nil {
		t.Fatalf("unterminated tag should error, got tags=%d", len(tsF))
	}
}

func TestValueHexBinary(t *testing.T) {
	var nt *T
	if nt.ValueHex() != nil {
		t.Fatal("nil ValueHex should be nil")
	}
	if nt.ValueBinary() != nil {
		t.Fatal("nil ValueBinary should be nil")
	}
	one := NewFromBytesSlice([]byte("k"))
	if one.ValueHex() != nil {
		t.Fatal("one-field ValueHex should be nil")
	}
	if one.ValueBinary() != nil {
		t.Fatal("one-field ValueBinary should be nil")
	}
	plain := NewFromBytesSlice([]byte("k"), []byte("plain"))
	if !bytes.Equal(plain.ValueHex(), []byte("plain")) {
		t.Fatalf("plain ValueHex = %s", plain.ValueHex())
	}
	if plain.ValueBinary() != nil {
		t.Fatal("plain ValueBinary should be nil")
	}
	bin := []byte{:33}
	bin[0] = 0x5a
	bin[1] = 0xa5
	bt := NewFromBytesSlice([]byte("e"), bin)
	hx := hex.EncAppend(nil, bin[:HashLen])
	if !bytes.Equal(bt.ValueHex(), hx) {
		t.Fatalf("binary ValueHex = %s, want %s", bt.ValueHex(), hx)
	}
	if !bytes.Equal(bt.ValueBinary(), bin[:HashLen]) {
		t.Fatalf("binary ValueBinary = %s, want %s", bt.ValueBinary(), bin[:HashLen])
	}
}

func TestNewFromAny(t *testing.T) {
	tt := NewFromAny("a", "b", "c")
	if tt.Len() != 3 {
		t.Fatalf("Len = %d, want 3", tt.Len())
	}
	if !bytes.Equal(tt.Key(), []byte("a")) {
		t.Fatalf("Key = %s", tt.Key())
	}
	if !bytes.Equal(tt.Value(), []byte("b")) {
		t.Fatalf("Value = %s", tt.Value())
	}
	if !bytes.Equal(tt.Relay(), []byte("c")) {
		t.Fatalf("Relay = %s", tt.Relay())
	}
	if NewFromAny().Len() != 0 {
		t.Fatal("NewFromAny() should be empty")
	}
}

func TestEquals(t *testing.T) {
	var na, nb *T
	if !na.Equals(nb) {
		t.Fatal("nil.Equals(nil) should be true")
	}
	a1 := NewFromBytesSlice([]byte("k"))
	if a1.Equals(nb) {
		t.Fatal("tag.Equals(nil) should be false")
	}
	if na.Equals(a1) {
		t.Fatal("nil.Equals(tag) should be false")
	}
	a2 := NewFromBytesSlice([]byte("k"), []byte("v"))
	a3 := NewFromBytesSlice([]byte("k"))
	if a2.Equals(a3) {
		t.Fatal("different lengths should not be equal")
	}
	a4 := NewFromBytesSlice([]byte("k"), []byte("v"))
	if !a2.Equals(a4) {
		t.Fatal("plain equal tags should be equal")
	}
	a5 := NewFromBytesSlice([]byte("k"), []byte("w"))
	if a2.Equals(a5) {
		t.Fatal("different plain values should not be equal")
	}
	a6 := NewFromBytesSlice([]byte("z"), []byte("v"))
	if a2.Equals(a6) {
		t.Fatal("different keys should not be equal")
	}

	binA := []byte{:33}
	binA[0] = 0x5a
	binA[1] = 0xa5
	binB := []byte{:33}
	binB[0] = 0x5a
	binB[1] = 0xa5
	binC := []byte{:33}
	binC[0] = 0x5a
	binC[1] = 0xa5
	binC[2] = 1
	tagA := NewFromBytesSlice([]byte("e"), binA)
	tagB := NewFromBytesSlice([]byte("e"), binB)
	tagC := NewFromBytesSlice([]byte("e"), binC)
	if !tagA.Equals(tagB) {
		t.Fatal("identical binary tags should be equal")
	}
	if tagA.Equals(tagC) {
		t.Fatal("differing binary tags should not be equal")
	}

	hx := hex.EncAppend(nil, binA[:HashLen])
	hexTag := NewFromBytesSlice([]byte("e"), hx)
	if !tagA.Equals(hexTag) {
		t.Fatal("binary should equal its lowercase hex form")
	}
	if !hexTag.Equals(tagA) {
		t.Fatal("lowercase hex should equal its binary form")
	}
	up := upperHex(binA[:HashLen])
	upTag := NewFromBytesSlice([]byte("e"), up)
	if !tagA.Equals(upTag) {
		t.Fatal("binary should equal its uppercase hex form")
	}

	wrongHex := NewFromBytesSlice([]byte("e"), []byte(zeroHex64))
	if tagA.Equals(wrongHex) {
		t.Fatal("binary vs differing valid hex should not be equal")
	}
	shortRaw := NewFromBytesSlice([]byte("e"), []byte("short"))
	if tagA.Equals(shortRaw) {
		t.Fatal("binary vs short raw should not be equal")
	}
	badHi := NewFromBytesSlice([]byte("e"), []byte("z" | zeroHex64[1:]))
	if tagA.Equals(badHi) {
		t.Fatal("invalid high nibble should not be equal")
	}
	badLo := NewFromBytesSlice([]byte("e"), []byte(zeroHex64[:1] | "z" | zeroHex64[2:]))
	if tagA.Equals(badLo) {
		t.Fatal("invalid low nibble should not be equal")
	}
}

func TestSAppendLenLessSwap(t *testing.T) {
	s := NewS()
	if s.Len() != 0 {
		t.Fatalf("empty S Len = %d", s.Len())
	}
	ta := NewFromBytesSlice([]byte("a"))
	tb := NewFromBytesSlice([]byte("b"))
	s.Append(ta)
	s.Append(tb)
	if s.Len() != 2 {
		t.Fatalf("S Len = %d, want 2", s.Len())
	}
	if !s.Less(0, 1) {
		t.Fatal("S.Less(0,1) should be true")
	}
	if s.Less(1, 0) {
		t.Fatal("S.Less(1,0) should be false")
	}
	s.Swap(0, 1)
	if !bytes.Equal(s.T[0].T[0], []byte("b")) {
		t.Fatalf("S.Swap[0] = %s", s.T[0].T[0])
	}
	if !bytes.Equal(s.T[1].T[0], []byte("a")) {
		t.Fatalf("S.Swap[1] = %s", s.T[1].T[0])
	}
	var ns *S
	if ns.Len() != 0 {
		t.Fatalf("nil S Len = %d", ns.Len())
	}
	capped := NewSWithCap(4)
	if capped.Len() != 0 {
		t.Fatalf("NewSWithCap Len = %d", capped.Len())
	}
}

func TestSContainsAny(t *testing.T) {
	bin := []byte{:33}
	bin[0] = 0x5a
	bin[1] = 0xa5
	eTag := NewFromBytesSlice([]byte("e"), bin)
	tTag := NewFromBytesSlice([]byte("t"), []byte("test"))
	short := NewFromBytesSlice([]byte("x"))
	s := NewS(eTag, tTag, short)
	if !s.ContainsAny([]byte("t"), [][]byte{[]byte("te")}) {
		t.Fatal("prefix of t value should match")
	}
	if s.ContainsAny([]byte("t"), [][]byte{[]byte("zz")}) {
		t.Fatal("absent prefix should not match")
	}
	hx := hex.EncAppend(nil, bin[:HashLen])
	if !s.ContainsAny([]byte("e"), [][]byte{hx[:4]}) {
		t.Fatal("hex prefix of binary e value should match")
	}
	if s.ContainsAny([]byte("e"), [][]byte{[]byte("ff")}) {
		t.Fatal("absent hex prefix should not match")
	}
	if s.ContainsAny([]byte("x"), [][]byte{[]byte("")}) {
		t.Fatal("one-field tag should be skipped")
	}
	if s.ContainsAny([]byte("q"), [][]byte{[]byte("")}) {
		t.Fatal("unknown tag should not match")
	}
	var noName []byte
	if s.ContainsAny(noName, [][]byte{[]byte("a")}) {
		t.Fatal("empty tag name should not match")
	}
	var ns *S
	if ns.ContainsAny([]byte("t"), [][]byte{[]byte("t")}) {
		t.Fatal("nil S should not match")
	}
}

func TestSGetFirstGetAll(t *testing.T) {
	var ns *S
	if ns.GetFirst([]byte("a")) != nil {
		t.Fatal("nil S GetFirst should be nil")
	}
	if ns.GetAll([]byte("a")) != nil {
		t.Fatal("nil S GetAll should be nil")
	}
	es := NewS()
	if es.GetFirst([]byte("a")) != nil {
		t.Fatal("empty S GetFirst should be nil")
	}
	if es.GetAll([]byte("a")) != nil {
		t.Fatal("empty S GetAll should be nil")
	}
	emptyTag := New()
	a1 := NewFromBytesSlice([]byte("a"), []byte("1"))
	a2 := NewFromBytesSlice([]byte("a"), []byte("2"))
	b1 := NewFromBytesSlice([]byte("b"), []byte("1"))
	s := NewS(emptyTag, a1, b1, a2)
	f := s.GetFirst([]byte("a"))
	if f == nil || !bytes.Equal(f.Value(), []byte("1")) {
		t.Fatal("GetFirst should return the first a tag")
	}
	if s.GetFirst([]byte("z")) != nil {
		t.Fatal("GetFirst of absent key should be nil")
	}
	all := s.GetAll([]byte("a"))
	if len(all) != 2 {
		t.Fatalf("GetAll len = %d, want 2", len(all))
	}
	if !bytes.Equal(all[0].Value(), []byte("1")) || !bytes.Equal(all[1].Value(), []byte("2")) {
		t.Fatal("GetAll should preserve order")
	}
	if len(s.GetAll([]byte("z"))) != 0 {
		t.Fatal("GetAll of absent key should be empty")
	}
	// The zero-length tag must be skipped by both accessors.
	if s.GetFirst([]byte("")) != nil {
		t.Fatal("GetFirst should skip zero-length tags")
	}
	if len(s.GetAll([]byte(""))) != 0 {
		t.Fatal("GetAll should skip zero-length tags")
	}
	// More matches than the initial capacity forces mxutil.Ensure to grow.
	many := NewS()
	for i := 0; i < 6; i++ {
		many.Append(NewFromBytesSlice([]byte("m"), []byte("v")))
	}
	mall := many.GetAll([]byte("m"))
	if len(mall) != 6 {
		t.Fatalf("GetAll growth len = %d, want 6", len(mall))
	}
}

func TestSGetTagElement(t *testing.T) {
	var ns *S
	if ns.GetTagElement(0) != nil {
		t.Fatal("nil S GetTagElement should be nil")
	}
	a1 := NewFromBytesSlice([]byte("a"), []byte("1"))
	a2 := NewFromBytesSlice([]byte("b"), []byte("2"))
	s := NewS(a1, a2)
	if s.GetTagElement(0) != a1 {
		t.Fatal("GetTagElement(0) should be the first tag")
	}
	if s.GetTagElement(1) != a2 {
		t.Fatal("GetTagElement(1) should be the second tag")
	}
	if s.GetTagElement(5) != nil {
		t.Fatal("out-of-range GetTagElement should be nil")
	}
	// The bound used to be `len(s.T) < i`, so i == Len() indexed one past the
	// end and panicked instead of returning nil.
	if s.GetTagElement(s.Len()) != nil {
		t.Fatal("GetTagElement(Len()) should be nil, not a panic")
	}
	if s.GetTagElement(-1) != nil {
		t.Fatal("negative GetTagElement should be nil")
	}
}

func TestSMarshal(t *testing.T) {
	s := NewS(
		NewFromBytesSlice([]byte("t"), []byte("test")),
		NewFromBytesSlice([]byte("p"), []byte("abc")),
	)
	want := "[[\"t\",\"test\"],[\"p\",\"abc\"]]"
	got := string(s.Marshal(nil))
	if got != want {
		t.Fatalf("S.Marshal = %s, want %s", got, want)
	}
	gotDst := string(s.Marshal([]byte("x")))
	if gotDst != ("x" | want) {
		t.Fatalf("S.Marshal into dst = %s", gotDst)
	}
	if string(NewS().Marshal(nil)) != "[]" {
		t.Fatalf("empty S.Marshal = %s", string(NewS().Marshal(nil)))
	}
	var ns *S
	if ns.Marshal(nil) != nil {
		t.Fatal("nil S.Marshal should return nil")
	}
}

func TestSMarshalJSON(t *testing.T) {
	s1 := NewS(NewFromBytesSlice([]byte("t"), []byte("test")))
	jb, jerr := s1.MarshalJSON()
	if jerr != nil {
		t.Fatal(jerr)
		return
	}
	if string(jb) != "[[\"t\",\"test\"]]" {
		t.Fatalf("S.MarshalJSON = %s", string(jb))
	}
	s2 := NewS(
		NewFromBytesSlice([]byte("a"), []byte("1")),
		NewFromBytesSlice([]byte("b"), []byte("2")),
	)
	jb2, jerr2 := s2.MarshalJSON()
	if jerr2 != nil {
		t.Fatal(jerr2)
		return
	}
	if string(jb2) != "[[\"a\",\"1\"],[\"b\",\"2\"]]" {
		t.Fatalf("S.MarshalJSON two = %s", string(jb2))
	}
}

func TestSUnmarshal(t *testing.T) {
	raw := []byte("[[\"t\",\"test\"],[\"p\",\"abc\"]]")
	s := NewS()
	rem, err := s.Unmarshal(raw)
	if err != nil {
		t.Fatal(err)
		return
	}
	if s.Len() != 2 {
		t.Fatalf("S.Len = %d, want 2", s.Len())
	}
	if len(rem) != 0 {
		t.Fatalf("S.Unmarshal remainder = %s", string(rem))
	}
	if !bytes.Equal(s.T[0].Value(), []byte("test")) {
		t.Fatalf("first value = %s", s.T[0].Value())
	}
	if !bytes.Equal(s.T[1].Key(), []byte("p")) {
		t.Fatalf("second key = %s", s.T[1].Key())
	}
	sj := NewS()
	if sjErr := sj.UnmarshalJSON(raw); sjErr != nil {
		t.Fatal(sjErr)
		return
	}
	if sj.Len() != 2 {
		t.Fatalf("UnmarshalJSON Len = %d", sj.Len())
	}
	sr := NewS()
	remR, errR := sr.Unmarshal([]byte("[[\"a\",\"b\"]]tail"))
	if errR != nil {
		t.Fatal(errR)
		return
	}
	if string(remR) != "tail" {
		t.Fatalf("S.Unmarshal remainder = %s, want tail", string(remR))
	}
	se := NewS()
	_, errE := se.Unmarshal([]byte("[]"))
	if errE != nil {
		t.Fatal(errE)
		return
	}
	if se.Len() != 0 {
		t.Fatalf("empty array Len = %d", se.Len())
	}
	sm := NewS()
	if _, errM := sm.Unmarshal([]byte("[[\"t")); errM == nil {
		t.Fatal("unterminated tag should error")
	}
	smj := NewS()
	if errMJ := smj.UnmarshalJSON([]byte("[[\"t")); errMJ == nil {
		t.Fatal("UnmarshalJSON should propagate parse errors")
	}
}