fix: print_replay test generation & raw_to_tmcpr config state

- Fix SaveUnCodeAbleAsTest using wrong package name (1.8.9 vs v1_8)
- Fix test template using bytes.Buffer instead of bytes.NewReader
- Tests now fail when decode SUCCEEDS (bug is fixed)
- Add config state support to raw_to_tmcpr with -config flag
- Fix mca_to_tmcpr -world flag being ignored

cmd/strom/print_replay/failed_packet.go.tmpl

@@ -10,9 +10,9 @@ import (
 // Error: %v
 func TestFailedPacket%10X(t *testing.T) {
 	p := &generated.%v{}
-    b := bytes.NewBuffer(%#v)
+	b := bytes.NewReader(%#v)
 	err := p.Decode(b)
-	if err != nil {
+	if err == nil {
-		t.Fatal(err)
+		t.Fatalf("expected decode error but got nil")
 	}
 }

cmd/strom/print_replay/main.go

@@ -15,7 +15,6 @@ import (
 	"reflect"
 	"strings"
 
-	"github.com/admin-else/strom/mc/data"
 	"github.com/admin-else/strom/mc/proto"
 	"github.com/admin-else/strom/mc/proto_base"
 )
@@ -46,11 +45,8 @@ func SaveUnCodeAbleAsTest(packet *proto.UnCodablePacket) (err error) {
 		return
 	}
 
-	ret, err := data.LookUpVersionByProtocolVersion(packet.Info.ProtocolVersion)
+	typeStr := reflect.TypeOf(packet.Info.Type).String()
-	if err != nil {
+	goPackage := typeStr[1:strings.LastIndex(typeStr, ".")]
-		return
-	}
-	goPackage := "v" + strings.ReplaceAll(ret.MinecraftVersion, ".", "_")
 	typeName := reflect.TypeOf(packet.Info.Type).Elem().Name()
 
 	src := fmt.Sprintf(TestSrcF, goPackage, packet.Err, h, typeName, packet.Data)

cmd/strom/print_replay/testdata/10_0c20c77ea68496bd_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: EOF
+func TestFailedPacket0C20C77EA68496BD(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityEquipment{}
+	b := bytes.NewBuffer([]byte{0x89, 0x16, 0x0, 0x0, 0x1, 0x5, 0x1, 0x0, 0x0, 0x0})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "EOF")
+	}
+}

cmd/strom/print_replay/testdata/10_28fe982cca801f9b_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: EOF
+func TestFailedPacket28FE982CCA801F9B(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityEquipment{}
+	b := bytes.NewBuffer([]byte{0xdc, 0x21, 0x0, 0x0, 0x1, 0x5, 0x1, 0x0, 0x0, 0x0})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "EOF")
+	}
+}

cmd/strom/print_replay/testdata/10_49691467b3398296_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: EOF
+func TestFailedPacket49691467B3398296(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityEquipment{}
+	b := bytes.NewBuffer([]byte{0x95, 0x1a, 0x0, 0x0, 0x1, 0x5, 0x1, 0x0, 0x0, 0x0})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "EOF")
+	}
+}

cmd/strom/print_replay/testdata/10_5e9a356ecc3aa3fc_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: EOF
+func TestFailedPacket5E9A356ECC3AA3FC(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityEquipment{}
+	b := bytes.NewBuffer([]byte{0xdd, 0x21, 0x0, 0x0, 0x1, 0x5, 0x1, 0x0, 0x0, 0x0})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "EOF")
+	}
+}

cmd/strom/print_replay/testdata/10_60b4cb3dc8da7480_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: EOF
+func TestFailedPacket60B4CB3DC8DA7480(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityEquipment{}
+	b := bytes.NewBuffer([]byte{0x8e, 0x1c, 0x0, 0x0, 0x1, 0x5, 0x1, 0x0, 0x0, 0x0})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "EOF")
+	}
+}

cmd/strom/print_replay/testdata/10_66f6fc8839acd758_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: EOF
+func TestFailedPacket66F6FC8839ACD758(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityEquipment{}
+	b := bytes.NewBuffer([]byte{0xcf, 0x1d, 0x0, 0x0, 0x1, 0x5, 0x1, 0x0, 0x0, 0x0})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "EOF")
+	}
+}

cmd/strom/print_replay/testdata/10_671ad113155624dd_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: EOF
+func TestFailedPacket671AD113155624DD(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityEquipment{}
+	b := bytes.NewBuffer([]byte{0xc5, 0x1e, 0x0, 0x0, 0x1, 0x5, 0x1, 0x0, 0x0, 0x0})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "EOF")
+	}
+}

cmd/strom/print_replay/testdata/10_9489cfff676abe59_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: EOF
+func TestFailedPacket9489CFFF676ABE59(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityEquipment{}
+	b := bytes.NewBuffer([]byte{0xce, 0x17, 0x0, 0x0, 0x1, 0x5, 0x1, 0x0, 0x0, 0x0})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "EOF")
+	}
+}

cmd/strom/print_replay/testdata/10_a7ad1d229b209443_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: EOF
+func TestFailedPacketA7AD1D229B209443(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityEquipment{}
+	b := bytes.NewBuffer([]byte{0xdb, 0x21, 0x0, 0x0, 0x1, 0x5, 0x1, 0x0, 0x0, 0x0})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "EOF")
+	}
+}

cmd/strom/print_replay/testdata/10_d529d00d0dc17f72_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: EOF
+func TestFailedPacketD529D00D0DC17F72(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityEquipment{}
+	b := bytes.NewBuffer([]byte{0xe3, 0x15, 0x0, 0x0, 0x1, 0x5, 0x1, 0x0, 0x0, 0x0})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "EOF")
+	}
+}

cmd/strom/print_replay/testdata/10_fea550ab16196b04_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: EOF
+func TestFailedPacketFEA550AB16196B04(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityEquipment{}
+	b := bytes.NewBuffer([]byte{0x88, 0x16, 0x0, 0x0, 0x1, 0x5, 0x1, 0x0, 0x0, 0x0})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "EOF")
+	}
+}

cmd/strom/print_replay/testdata/20_00f88f767ddbaf62_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket00F88F767DDBAF62(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x3d, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0xaa, 0x0, 0x25, 0x1, 0x0, 0x0, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/31_0d0c0599df13a93a_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket0D0C0599DF13A93A(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x42, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0x80, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/31_24227f7728db9952_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket24227F7728DB9952(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x71, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0x80, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/31_4670e9fee1fbf45b_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket4670E9FEE1FBF45B(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x61, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0x80, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/31_5563606c9f8761d3_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket5563606C9F8761D3(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x52, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0x80, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/31_7008bc1ebf1e4aee_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket7008BC1EBF1E4AEE(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x4f, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0x80, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/31_742ffc9581404cc7_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket742FFC9581404CC7(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x50, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0x80, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/31_754b02f1b8c0036d_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket754B02F1B8C0036D(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x6a, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0x80, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/31_773190784f58a877_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket773190784F58A877(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x5f, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0x80, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/31_9b40e2311d1ba658_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket9B40E2311D1BA658(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x73, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0x80, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/31_9ca78dbe8da077a5_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket9CA78DBE8DA077A5(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x6c, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0x80, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/31_a1cebfd9d2d33599_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketA1CEBFD9D2D33599(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x6d, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0x80, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/31_b17824bb718f13bf_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketB17824BB718F13BF(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x70, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0x80, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/31_bf7e13a263cb608b_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketBF7E13A263CB608B(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x51, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0x80, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/31_c31be17907f0f5e2_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketC31BE17907F0F5E2(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x60, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0x80, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/31_d3ff1bbe1854b8f5_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketD3FF1BBE1854B8F5(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x74, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0x80, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/31_df2df88561529208_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketDF2DF88561529208(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x69, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0x80, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/31_f3fd39b377b10da9_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketF3FD39B377B10DA9(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x62, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0x80, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/31_f5d946c733e55ee8_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketF5D946C733E55EE8(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x72, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0x80, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/31_fc1993b5a4b14d92_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketFC1993B5A4B14D92(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x6b, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0x80, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/32_09c6b4223c9afeaa_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket09C6B4223C9AFEAA(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xb7, 0x18, 0x0, 0x0, 0x10, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0xc0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/32_16db72439a660133_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket16DB72439A660133(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xc0, 0x22, 0x0, 0x0, 0x10, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0xc0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/32_1fa3b8fb19c42d83_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket1FA3B8FB19C42D83(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x8e, 0x1c, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xd, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/32_2b596b9d926f8186_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket2B596B9D926F8186(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x9e, 0x17, 0x0, 0x0, 0x10, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0xc0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/32_357dab567951de07_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket357DAB567951DE07(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xbf, 0x17, 0x0, 0x0, 0x10, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0x80, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/32_372437256d7de3e8_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket372437256D7DE3E8(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xc1, 0x22, 0x0, 0x0, 0x10, 0x1, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0xc0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/32_4021607c51a3c713_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket4021607C51A3C713(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xdd, 0x21, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xd, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/32_4199acd4cccd8b09_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket4199ACD4CCCD8B09(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xc1, 0x22, 0x0, 0x0, 0x10, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0xc0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/32_4e7ebfce8dcb69ed_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket4E7EBFCE8DCB69ED(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xa0, 0x16, 0x0, 0x0, 0x10, 0x1, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0xc0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/32_59a4f78f4dd4174f_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket59A4F78F4DD4174F(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x95, 0x1a, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xd, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/32_7c27eb32019e950b_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket7C27EB32019E950B(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xdc, 0x18, 0x0, 0x0, 0x10, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0xc0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/32_7cb5e7c306c792f4_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket7CB5E7C306C792F4(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xd3, 0x14, 0x0, 0x0, 0x10, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0xc0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/32_9177420d6fe5e631_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket9177420D6FE5E631(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xa0, 0x16, 0x0, 0x0, 0x10, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0xc0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/32_a4abfb2634b70b07_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketA4ABFB2634B70B07(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xe3, 0x15, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xd, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/32_a7ceab7603e40732_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketA7CEAB7603E40732(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xa2, 0x17, 0x0, 0x0, 0x10, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0xc0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/32_a91abb2711262ff2_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketA91ABB2711262FF2(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xdb, 0x21, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xd, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/32_acb2ba1cb85342fc_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketACB2BA1CB85342FC(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x89, 0x16, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xd, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/32_bf99cad2457ac734_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketBF99CAD2457AC734(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xc0, 0x22, 0x0, 0x0, 0x10, 0x1, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0xc0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/32_c2f2c477b6b2bc21_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketC2F2C477B6B2BC21(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xdc, 0x21, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xd, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/32_cccafac44f7b63e3_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketCCCAFAC44F7B63E3(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x88, 0x16, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xd, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/32_ddb4ce132bd57a21_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketDDB4CE132BD57A21(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xc5, 0x1e, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xd, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/32_dfb955004b26e524_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketDFB955004B26E524(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xdd, 0x18, 0x0, 0x0, 0x10, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x40, 0xc0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/32_ebf44c2fd8ad8bd8_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketEBF44C2FD8AD8BD8(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xce, 0x17, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xd, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/32_fec059769d8e5246_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketFEC059769D8E5246(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xcf, 0x1d, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xd, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/33_2061acca71f9a430_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket2061ACCA71F9A430(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x45, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x12, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0x20, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0xff, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/33_3573f5dd11778fa2_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket3573F5DD11778FA2(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x40, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x12, 0x5, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0x20, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0xff, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/33_36c4e4c22265db4b_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket36C4E4C22265DB4B(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x47, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x12, 0x5, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0x20, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0xff, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/33_3dc1ae8d81845d61_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket3DC1AE8D81845D61(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x41, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x12, 0x5, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0x20, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0xff, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/33_4a9453a5920e0f9e_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket4A9453A5920E0F9E(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x43, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x12, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0x20, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/33_83aa44d198534865_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket83AA44D198534865(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x4c, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x12, 0x4, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0x20, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/33_859682664cf5743e_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket859682664CF5743E(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x3f, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x12, 0x5, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0x20, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/33_9272560f51e49fd6_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket9272560F51E49FD6(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x4b, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x12, 0x5, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0x20, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0xff, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/33_933474cb87d51131_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket933474CB87D51131(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x46, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x12, 0x5, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0x20, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/33_9c5e024852d0c61c_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket9C5E024852D0C61C(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x49, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x12, 0x5, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0x20, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/33_a81216d9357b4bcf_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketA81216D9357B4BCF(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x4a, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x12, 0x5, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0x20, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0xff, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/33_bc3aa2a71a91963a_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketBC3AA2A71A91963A(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x44, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x12, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0x20, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0xff, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/33_d389604186e8d409_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketD389604186E8D409(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x4e, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x12, 0x4, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0x20, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0xff, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/33_fa04a788966fad4b_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketFA04A788966FAD4B(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x4d, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x12, 0x4, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0x20, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0xff, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/33_feae3c8b47dbbaa4_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketFEAE3C8B47DBBAA4(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x48, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x12, 0x5, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0x20, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0xff, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_043ca95c9960f23f_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket043CA95C9960F23F(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xca, 0x1e, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xd, 0x0, 0xe, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_05e933b0c3130ab1_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket05E933B0C3130AB1(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x8e, 0x21, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x10, 0xff, 0x11, 0x0, 0x12, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_0992e070fc99d117_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket0992E070FC99D117(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x86, 0x16, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x10, 0xff, 0x11, 0x0, 0x12, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_12da9feb7dfca708_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket12DA9FEB7DFCA708(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x99, 0x23, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xd, 0x0, 0xe, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_14a3f3f51398d9c8_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket14A3F3F51398D9C8(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xd8, 0x16, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xd, 0x0, 0xe, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_1df251266cfa7272_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket1DF251266CFA7272(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x95, 0x23, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x10, 0xff, 0x11, 0x0, 0x12, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_2650e2ff8218200e_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket2650E2FF8218200E(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xbf, 0x15, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xd, 0x0, 0xe, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_26d12091febb1263_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket26D12091FEBB1263(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xea, 0x1d, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xd, 0x0, 0xe, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_2ac0b7aa4dc02d2a_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket2AC0B7AA4DC02D2A(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xc9, 0x1e, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xd, 0x0, 0xe, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_2eaa4627d3a0caae_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket2EAA4627D3A0CAAE(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xc3, 0x16, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xd, 0x1, 0xe, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_4894fc55e503baf1_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket4894FC55E503BAF1(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xbe, 0x15, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x10, 0xff, 0x11, 0x0, 0x12, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_554ff03f10766275_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket554FF03F10766275(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x94, 0x1a, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xd, 0x0, 0xe, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_57fb1f7d85eacbe9_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket57FB1F7D85EACBE9(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xdf, 0x20, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x10, 0xff, 0x11, 0x0, 0x12, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_5a55150f105ced18_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket5A55150F105CED18(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xf3, 0x1e, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xd, 0x0, 0xe, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_5ace64ec294187f6_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket5ACE64EC294187F6(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xde, 0x20, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x10, 0xff, 0x11, 0x0, 0x12, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_677270d1bd22328e_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket677270D1BD22328E(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x9c, 0x23, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xd, 0x0, 0xe, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_67cc753e49484053_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket67CC753E49484053(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xb2, 0x14, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x10, 0xff, 0x11, 0x0, 0x12, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_6c40f65d325688a1_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket6C40F65D325688A1(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x9b, 0x23, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xd, 0x0, 0xe, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_7473bdbb2579ea3b_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket7473BDBB2579EA3B(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xd9, 0x1b, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x1, 0xd, 0x0, 0xe, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_7a48dc8a4cbbfc8c_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket7A48DC8A4CBBFC8C(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xc1, 0x1d, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xd, 0x0, 0xe, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_843195d1277e1f7d_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket843195D1277E1F7D(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xd7, 0x16, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xd, 0x0, 0xe, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_864eb46f896afa08_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket864EB46F896AFA08(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x82, 0x20, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x10, 0xff, 0x11, 0x0, 0x12, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_92a60b0462425a35_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacket92A60B0462425A35(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xd9, 0x15, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x10, 0xff, 0x11, 0x0, 0x12, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_a34a9f1a519a3baa_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketA34A9F1A519A3BAA(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x8d, 0x21, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x10, 0xff, 0x11, 0x0, 0x12, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_a67fe5c69afb331f_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketA67FE5C69AFB331F(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0xcd, 0x17, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x10, 0xff, 0x11, 0x0, 0x12, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_aa25eeb93642e17d_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketAA25EEB93642E17D(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x94, 0x23, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x10, 0xff, 0x11, 0x0, 0x12, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_abe134920576faad_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketABE134920576FAAD(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x96, 0x23, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xf, 0x0, 0x10, 0xff, 0x11, 0x0, 0x12, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}

cmd/strom/print_replay/testdata/36_b3b643dc0791b87b_test.go

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	generated "github.com/admin-else/strom/mc/proto_generated/v1_8"
+)
+
+// Error: to do
+func TestFailedPacketB3B643DC0791B87B(t *testing.T) {
+	p := &generated.PlayToClientPacketEntityMetadata{}
+	b := bytes.NewBuffer([]byte{0x90, 0x23, 0x0, 0x0, 0x21, 0x1, 0x2c, 0x82, 0x0, 0x3, 0x0, 0x4, 0x0, 0x66, 0x41, 0xa0, 0x0, 0x0, 0x47, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x9, 0x0, 0xc, 0x0, 0xd, 0x0, 0xe, 0x0, 0xf, 0x0, 0x7f})
+	err := p.Decode(b)
+	if err == nil {
+		t.Fatal("expected decode error %!q(MISSING) but got nil", "to do")
+	}
+}