fix tests finally

tcp/txqueue_test.go

@@ -4,11 +4,12 @@ import (
 	"bytes"
 	"fmt"
 	"math/rand"
+	"slices"
 	"testing"
 )
 
 func TestTxQueue(t *testing.T) {
-	var msgBuf, buf, aux [1024]byte
+	var msgBuf, ringBuf, readBuf, aux [1024]byte
 	rng := rand.New(rand.NewSource(1))
 
 	var rtx ringTx
@@ -22,20 +23,54 @@ func TestTxQueue(t *testing.T) {
 		0: {
 			name: "SequentialMessages",
 			test: func(t *testing.T) {
+				const startAck = 0
 				for i := 0; i < 10; i++ {
 					rng.Read(msgBuf[:])
-					msgs := bytes.SplitAfter(msgBuf[:], []byte{0})
-					testTxQueue_SequentialMessages(t, &rtx, msgs, buf[:], aux[:], rng.Intn(4)+1, 0)
+					msgs := removeEmptyMsgs(bytes.SplitAfter(msgBuf[:], []byte{0}))
+					currentAck := Value(startAck)
+					rtx.Reset(ringBuf[:], rng.Intn(4)+1, startAck)
+					for imsg, msg := range msgs {
+						// Write and create packet from single messages.
+						currentAck = Add(currentAck, Size(len(msg)))
+						operateOnRing(t, &rtx, msg, readBuf[:], aux[:], &currentAck)
+						buffered := rtx.Buffered()
+						if buffered != 0 {
+							t.Fatalf("msg%d: want no buffered data after transaction, got %d", imsg, buffered)
+						}
+						newSeq := rtx.currentSeq()
+						wantSeq := currentAck
+						if newSeq != wantSeq {
+							t.Fatalf("msg%d: want seq %d, got %d", imsg, wantSeq, newSeq)
+						}
+						if t.Failed() {
+							t.Fatalf("failed on msg %d", imsg)
+						}
+					}
 				}
 			},
 		},
 		1: {
 			name: "N-Messages",
 			test: func(t *testing.T) {
+				const startAck = 0
 				for i := 0; i < 10; i++ {
 					rng.Read(msgBuf[:])
-					msgs := bytes.SplitAfter(msgBuf[:], []byte{0})
-					testTxQueue_NMessages(t, &rtx, msgs, buf[:], aux[:], len(msgs), 0)
+					msgs := removeEmptyMsgs(bytes.SplitAfter(msgBuf[:], []byte{0}))
+					currentAck := Value(startAck)
+					rtx.Reset(ringBuf[:], rng.Intn(4)+1, startAck)
+					for _, msg := range msgs {
+						// Send all messages.
+						operateOnRing(t, &rtx, msg, nil, aux[:], nil)
+						if t.Failed() {
+							return
+						}
+						gotSeq := rtx.currentSeq()
+						if gotSeq != startAck {
+							t.Fatalf("expected seq to not change during writes")
+						}
+						currentAck = Add(currentAck, Size(len(msg)))
+					}
+					operateOnRing(t, &rtx, nil, readBuf[:], aux[:], &currentAck)
 				}
 			},
 		},
@@ -76,12 +111,12 @@ func testTxQueue_NMessages(t *testing.T, rtx *ringTx, msgs [][]byte, buf, aux []
 		testQueueSanity(t, rtx)
 		unsent := rtx.Buffered()
 		if unsent != n {
-			t.Fatalf("want unset %d, got %d", n, unsent)
+			t.Fatalf("want unsent %d, got %d", n, unsent)
 		}
 		testQueueSanity(t, rtx)
 		n, seq, err := rtx.MakePacket(aux[sent : sent+len(msg)])
 		if err != nil {
-			t.Fatal(err)
+			t.Fatal("MakePacket: ", err)
 		} else if seq != prevSeq {
 			t.Fatalf("want seq %d, got %d", prevSeq, seq)
 		} else if n != len(msg) {
@@ -106,6 +141,10 @@ func testTxQueue_SequentialMessages(t *testing.T, rtx *ringTx, msgs [][]byte, bu
 	}
 	prevSeq := Value(startAck)
 	for i, msg := range msgs {
+		if t.Failed() {
+			t.Errorf("%s failed on message %d", t.Name(), i)
+			return
+		}
 		if len(aux) < len(msg) {
 			panic("need aux to contain message")
 		}
@@ -148,17 +187,30 @@ func testTxQueue_SequentialMessages(t *testing.T, rtx *ringTx, msgs [][]byte, bu
 		if err != nil {
 			t.Fatal(err)
 		}
+		sent = rtx.BufferedSent()
+		unsent = rtx.Buffered()
+		if sent != 0 {
+			t.Errorf("message not marked as sent- expected no data left got %d", sent)
+		}
+		if unsent != 0 {
+			t.Errorf("huge bug, unexpected data loaded to unsent buffer")
+		}
 		testQueueSanity(t, rtx)
 	}
 }
 
 func testQueueSanity(t *testing.T, rtx *ringTx) {
 	// t.Helper()
-	defer func() {
-		if t.Failed() {
-			t.Log("\n" + rtx.string())
-		}
-	}()
+	alreadyFailed := t.Failed()
+	if !alreadyFailed {
+		defer func() {
+			if t.Failed() {
+				t.Helper()
+				t.Log("sanity failed with:\n" + rtx.string())
+			}
+		}()
+	}
+
 	if rtx.emptyRing != (ringidx{}) {
 		t.Fatalf("empty ring not empty")
 	}
@@ -184,7 +236,7 @@ func testQueueSanity(t *testing.T, rtx *ringTx) {
 		} else if rsent.End == 0 {
 			t.Fatalf("expected not empty sent buffer End to be !=0, got %d", rsent.End)
 		}
-		gotSentEnd := rtx.addOff(rsent.Off, sent)
+		gotSentEnd := rtx.addEnd(rsent.Off, sent)
 		if gotSentEnd != rsent.End {
 			t.Fatalf("calculated sent end mismatches lim sent end %d != %d", gotSentEnd, rsent.End)
 		}
@@ -195,7 +247,7 @@ func testQueueSanity(t *testing.T, rtx *ringTx) {
 		} else if runsent.End == 0 {
 			t.Fatalf("expected not empty unsent buffer End to be !=0, got %d", runsent.End)
 		}
-		gotUnsentEnd := rtx.addOff(runsent.Off, unsent)
+		gotUnsentEnd := rtx.addEnd(runsent.Off, unsent)
 		if gotUnsentEnd != runsent.End {
 			t.Fatalf("calculated unsent end mismatches lim unsent end %d != %d", gotUnsentEnd, runsent.End)
 		}
@@ -276,3 +328,106 @@ func (rx *ringTx) string() string {
 	l2.WriteTo(&l1)
 	return l1.String()
 }
+
+func removeEmptyMsgs(msgs [][]byte) [][]byte {
+	return slices.DeleteFunc(msgs, func(b []byte) bool { return len(b) == 0 })
+}
+
+func operateOnRing(t *testing.T, rtx *ringTx, write, readPacket, aux []byte, argRecvAck *Value) {
+	if len(aux) < rtx.Size() {
+		panic("too small auxiliary buffer")
+	}
+	free := rtx.Free()
+	// Prepare aux with data expected from read after write.
+	runsent, _ := rtx.unsentRing()
+	unsent := runsent.Buffered()
+
+	wantWritten := min(free, len(write))
+	wantBufRead := aux[:min(unsent+wantWritten, len(readPacket))]
+
+	if len(wantBufRead) > 0 {
+		testQueueSanity(t, rtx)
+		var n int
+		if runsent.Buffered() > 0 {
+			ngot, err := runsent.Read(wantBufRead)
+			wantRead := len(wantBufRead)
+			if err != nil {
+				panic(err)
+			} else if ngot < wantRead {
+				panic("expected read of at least length calculated above")
+			}
+			n = ngot
+		}
+		copy(wantBufRead[n:], write)
+	}
+
+	prevSeq := rtx.currentSeq()
+	if len(write) != 0 {
+		testQueueSanity(t, rtx)
+		preBuffered := rtx.Buffered()
+		n, err := rtx.Write(write)
+		if err != nil && wantWritten > 0 {
+			t.Errorf("error writing packet: %s", err)
+		} else if n != wantWritten {
+			t.Errorf("want %d written, got %d", wantWritten, n)
+		}
+		newBuffered := rtx.Buffered()
+		gotWritten := newBuffered - preBuffered
+		if gotWritten != wantWritten {
+			t.Errorf("expected %d data written, got %d", wantWritten, gotWritten)
+		}
+	}
+
+	if !t.Failed() && len(readPacket) != 0 {
+		testQueueSanity(t, rtx)
+		preSent := rtx.BufferedSent()
+		canRead := rtx.Buffered()
+		wantRead := min(canRead, len(readPacket))
+		if wantRead != len(wantBufRead) {
+			t.Fatalf("miscalculated expect read %d != %d", wantRead, len(wantBufRead))
+		}
+		n, seq, err := rtx.MakePacket(readPacket)
+		if err != nil && wantRead != 0 {
+			t.Errorf("error reading: %s", err)
+		} else if n != wantRead {
+			t.Errorf("want read %d, got %d", wantRead, n)
+		}
+		wantSeq := prevSeq
+		if seq != wantSeq {
+			t.Errorf("want new seq %d, got %d", wantSeq, seq)
+		}
+		if !bytes.Equal(readPacket[:n], wantBufRead) {
+			t.Error("data content packet read not match wanted packet")
+		}
+		gotCalcRead := rtx.BufferedSent() - preSent
+		if gotCalcRead != n {
+			t.Errorf("want data written to be %d calculated from BufferedSent diff, got %d", n, gotCalcRead)
+		}
+	}
+
+	if !t.Failed() && argRecvAck != nil {
+		testQueueSanity(t, rtx)
+		preAcked := rtx.BufferedSent()
+		rcvAck := *argRecvAck
+		seq := rtx.currentSeq()
+		startSeq := Add(seq, Size(-rtx.BufferedSent()))
+		acklInSentRange := startSeq.LessThan(rcvAck) && rcvAck.LessThanEq(seq)
+		err := rtx.RecvACK(rcvAck)
+		if err != nil && acklInSentRange {
+			t.Errorf("expected correct acking %d < %d <= %d: %s", startSeq, rcvAck, seq, err)
+		}
+		gotCalcAcked := preAcked - rtx.BufferedSent()
+		wantAcked := int(Sizeof(prevSeq, rtx.currentSeq()))
+		if gotCalcAcked != wantAcked {
+			t.Errorf("want acked %d, got %d", wantAcked, gotCalcAcked)
+		}
+	}
+	testQueueSanity(t, rtx)
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}