]> git.r.bdr.sh - rbdr/mobius/commitdiff
git.r.bdr.sh / rbdr / mobius / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side (from parent 1: f8e4cd5)
Use fixed size array types in Transaction fields
authorJeff Halter <redacted>
Tue, 18 Jun 2024 03:30:49 +0000 (20:30 -0700)
committerJeff Halter <redacted>
Tue, 18 Jun 2024 03:30:49 +0000 (20:30 -0700)
hotline/client.go patch | blob | blame | history
hotline/client_conn.go patch | blob | blame | history
hotline/server_blackbox_test.go patch | blob | blame | history
hotline/transaction.go patch | blob | blame | history
hotline/transaction_handlers.go patch | blob | blame | history
hotline/transaction_handlers_test.go patch | blob | blame | history
hotline/transaction_test.go patch | blob | blame | history

diff --git a/hotline/client.go b/hotline/client.go
index 33dbd0d814b46fc5bf7f2ca22ad41047f5a14c0b..cd6fa12497391b61e985d0a7c4ad0800c81293be 100644 (file)
--- a/hotline/client.go
+++ b/hotline/client.go
@@ -142,11 +142,11 @@ func (c *Client) Handshake() error {
 }
 
 func (c *Client) Send(t Transaction) error {
 }
 
 func (c *Client) Send(t Transaction) error {
-       requestNum := binary.BigEndian.Uint16(t.Type)
+       requestNum := binary.BigEndian.Uint16(t.Type[:])
 
        // if transaction is NOT reply, add it to the list to transactions we're expecting a response for
        if t.IsReply == 0 {
 
        // if transaction is NOT reply, add it to the list to transactions we're expecting a response for
        if t.IsReply == 0 {
-               c.activeTasks[binary.BigEndian.Uint32(t.ID)] = &t
+               c.activeTasks[binary.BigEndian.Uint32(t.ID[:])] = &t
        }
 
        n, err := io.Copy(c.Connection, &t)
        }
 
        n, err := io.Copy(c.Connection, &t)
@@ -165,16 +165,16 @@ func (c *Client) Send(t Transaction) error {
 func (c *Client) HandleTransaction(ctx context.Context, t *Transaction) error {
        var origT Transaction
        if t.IsReply == 1 {
 func (c *Client) HandleTransaction(ctx context.Context, t *Transaction) error {
        var origT Transaction
        if t.IsReply == 1 {
-               requestID := binary.BigEndian.Uint32(t.ID)
+               requestID := binary.BigEndian.Uint32(t.ID[:])
                origT = *c.activeTasks[requestID]
                t.Type = origT.Type
        }
 
                origT = *c.activeTasks[requestID]
                t.Type = origT.Type
        }
 
-       if handler, ok := c.Handlers[binary.BigEndian.Uint16(t.Type)]; ok {
+       if handler, ok := c.Handlers[binary.BigEndian.Uint16(t.Type[:])]; ok {
                c.Logger.Debug(
                        "Received transaction",
                        "IsReply", t.IsReply,
                c.Logger.Debug(
                        "Received transaction",
                        "IsReply", t.IsReply,
-                       "type", binary.BigEndian.Uint16(t.Type),
+                       "type", binary.BigEndian.Uint16(t.Type[:]),
                )
                outT, err := handler(ctx, c, t)
                if err != nil {
                )
                outT, err := handler(ctx, c, t)
                if err != nil {
@@ -189,7 +189,7 @@ func (c *Client) HandleTransaction(ctx context.Context, t *Transaction) error {
                c.Logger.Debug(
                        "Unimplemented transaction type",
                        "IsReply", t.IsReply,
                c.Logger.Debug(
                        "Unimplemented transaction type",
                        "IsReply", t.IsReply,
-                       "type", binary.BigEndian.Uint16(t.Type),
+                       "type", binary.BigEndian.Uint16(t.Type[:]),
                )
        }
 
                )
        }
 
diff --git a/hotline/client_conn.go b/hotline/client_conn.go
index c886dfcc712e88eed55b99dc3a80c2d22aced448..0a7768f78835597e1026f386ac82dc3da9ac5702 100644 (file)
--- a/hotline/client_conn.go
+++ b/hotline/client_conn.go
@@ -54,7 +54,7 @@ func (cc *ClientConn) sendAll(t int, fields ...Field) {
 }
 
 func (cc *ClientConn) handleTransaction(transaction Transaction) error {
 }
 
 func (cc *ClientConn) handleTransaction(transaction Transaction) error {
-       requestNum := binary.BigEndian.Uint16(transaction.Type)
+       requestNum := binary.BigEndian.Uint16(transaction.Type[:])
        if handler, ok := TransactionHandlers[requestNum]; ok {
                for _, reqField := range handler.RequiredFields {
                        field := transaction.GetField(reqField.ID)
        if handler, ok := TransactionHandlers[requestNum]; ok {
                for _, reqField := range handler.RequiredFields {
                        field := transaction.GetField(reqField.ID)
@@ -168,10 +168,10 @@ func (cc *ClientConn) notifyOthers(t Transaction) (trans []Transaction) {
 func (cc *ClientConn) NewReply(t *Transaction, fields ...Field) Transaction {
        return Transaction{
                IsReply:   0x01,
 func (cc *ClientConn) NewReply(t *Transaction, fields ...Field) Transaction {
        return Transaction{
                IsReply:   0x01,
-               Type:      []byte{0x00, 0x00},
+               Type:      [2]byte{0x00, 0x00},
                ID:        t.ID,
                clientID:  cc.ID,
                ID:        t.ID,
                clientID:  cc.ID,
-               ErrorCode: []byte{0, 0, 0, 0},
+               ErrorCode: [4]byte{0, 0, 0, 0},
                Fields:    fields,
        }
 }
                Fields:    fields,
        }
 }
@@ -181,9 +181,9 @@ func (cc *ClientConn) NewErrReply(t *Transaction, errMsg string) Transaction {
        return Transaction{
                clientID:  cc.ID,
                IsReply:   0x01,
        return Transaction{
                clientID:  cc.ID,
                IsReply:   0x01,
-               Type:      []byte{0, 0},
+               Type:      [2]byte{0, 0},
                ID:        t.ID,
                ID:        t.ID,
-               ErrorCode: []byte{0, 0, 0, 1},
+               ErrorCode: [4]byte{0, 0, 0, 1},
                Fields: []Field{
                        NewField(FieldError, []byte(errMsg)),
                },
                Fields: []Field{
                        NewField(FieldError, []byte(errMsg)),
                },
diff --git a/hotline/server_blackbox_test.go b/hotline/server_blackbox_test.go
index b45e279c8a7a6644090196da01d1e74990a7b65f..3e23d27f6ada00f9dde75623d0f2fabff3d1e921 100644 (file)
--- a/hotline/server_blackbox_test.go
+++ b/hotline/server_blackbox_test.go
@@ -36,7 +36,7 @@ func tranAssertEqual(t *testing.T, tran1, tran2 []Transaction) bool {
        var newT2 []Transaction
 
        for _, trans := range tran1 {
        var newT2 []Transaction
 
        for _, trans := range tran1 {
-               trans.ID = []byte{0, 0, 0, 0}
+               trans.ID = [4]byte{0, 0, 0, 0}
                var fs []Field
                for _, field := range trans.Fields {
                        if field.ID == [2]byte{0x00, 0x6b} { // FieldRefNum
                var fs []Field
                for _, field := range trans.Fields {
                        if field.ID == [2]byte{0x00, 0x6b} { // FieldRefNum
@@ -52,7 +52,7 @@ func tranAssertEqual(t *testing.T, tran1, tran2 []Transaction) bool {
        }
 
        for _, trans := range tran2 {
        }
 
        for _, trans := range tran2 {
-               trans.ID = []byte{0, 0, 0, 0}
+               trans.ID = [4]byte{0, 0, 0, 0}
                var fs []Field
                for _, field := range trans.Fields {
                        if field.ID == [2]byte{0x00, 0x6b} { // FieldRefNum
                var fs []Field
                for _, field := range trans.Fields {
                        if field.ID == [2]byte{0x00, 0x6b} { // FieldRefNum
diff --git a/hotline/transaction.go b/hotline/transaction.go
index 39dcd81f0c97dec02a8eb3425e491855706f19f3..0caf72f652e3d255505f4b15dbeebbf219996621 100644 (file)
--- a/hotline/transaction.go
+++ b/hotline/transaction.go
@@ -73,14 +73,14 @@ const (
 )
 
 type Transaction struct {
 )
 
 type Transaction struct {
-       Flags      byte   // Reserved (should be 0)
-       IsReply    byte   // Request (0) or reply (1)
-       Type       []byte // Requested operation (user defined)
-       ID         []byte // Unique transaction ID (must be != 0)
-       ErrorCode  []byte // Used in the reply (user defined, 0 = no error)
-       TotalSize  []byte // Total data size for the transaction (all parts)
-       DataSize   []byte // Size of data in this transaction part. This allows splitting large transactions into smaller parts.
-       ParamCount []byte // Number of the parameters for this transaction
+       Flags      byte    // Reserved (should be 0)
+       IsReply    byte    // Request (0) or reply (1)
+       Type       [2]byte // Requested operation (user defined)
+       ID         [4]byte // Unique transaction ID (must be != 0)
+       ErrorCode  [4]byte // Used in the reply (user defined, 0 = no error)
+       TotalSize  [4]byte // Total data size for the transaction (all parts)
+       DataSize   [4]byte // Size of data in this transaction part. This allows splitting large transactions into smaller parts.
+       ParamCount [2]byte // Number of the parameters for this transaction
        Fields     []Field
 
        clientID   *[]byte // Internal identifier for target client
        Fields     []Field
 
        clientID   *[]byte // Internal identifier for target client
@@ -95,13 +95,10 @@ func NewTransaction(t int, clientID *[]byte, fields ...Field) *Transaction {
        binary.BigEndian.PutUint32(idSlice, rand.Uint32())
 
        return &Transaction{
        binary.BigEndian.PutUint32(idSlice, rand.Uint32())
 
        return &Transaction{
-               clientID:  clientID,
-               Flags:     0x00,
-               IsReply:   0x00,
-               Type:      typeSlice,
-               ID:        idSlice,
-               ErrorCode: []byte{0, 0, 0, 0},
-               Fields:    fields,
+               clientID: clientID,
+               Type:     [2]byte(typeSlice),
+               ID:       [4]byte(idSlice),
+               Fields:   fields,
        }
 }
 
        }
 }
 
@@ -133,12 +130,12 @@ func (t *Transaction) Write(p []byte) (n int, err error) {
 
        t.Flags = p[0]
        t.IsReply = p[1]
 
        t.Flags = p[0]
        t.IsReply = p[1]
-       t.Type = p[2:4]
-       t.ID = p[4:8]
-       t.ErrorCode = p[8:12]
-       t.TotalSize = p[12:16]
-       t.DataSize = p[16:20]
-       t.ParamCount = p[20:22]
+       t.Type = [2]byte(p[2:4])
+       t.ID = [4]byte(p[4:8])
+       t.ErrorCode = [4]byte(p[8:12])
+       t.TotalSize = [4]byte(p[12:16])
+       t.DataSize = [4]byte(p[16:20])
+       t.ParamCount = [2]byte(p[20:22])
 
        return len(p), err
 }
 
        return len(p), err
 }
@@ -223,9 +220,9 @@ func (t *Transaction) Read(p []byte) (int, error) {
 
        buf := slices.Concat(
                []byte{t.Flags, t.IsReply},
 
        buf := slices.Concat(
                []byte{t.Flags, t.IsReply},
-               t.Type,
-               t.ID,
-               t.ErrorCode,
+               t.Type[:],
+               t.ID[:],
+               t.ErrorCode[:],
                payloadSize,
                payloadSize, // this is the dataSize field, but seeming the same as totalSize
                fieldCount,
                payloadSize,
                payloadSize, // this is the dataSize field, but seeming the same as totalSize
                fieldCount,
@@ -267,5 +264,5 @@ func (t *Transaction) GetField(id int) Field {
 }
 
 func (t *Transaction) IsError() bool {
 }
 
 func (t *Transaction) IsError() bool {
-       return bytes.Equal(t.ErrorCode, []byte{0, 0, 0, 1})
+       return t.ErrorCode == [4]byte{0, 0, 0, 1}
 }
 }
diff --git a/hotline/transaction_handlers.go b/hotline/transaction_handlers.go
index 0fb250f2cd60e761e62516dab9b93eabdffcafd0..cff19d52d4630e2e8f67588c7330eb43820897a2 100644 (file)
--- a/hotline/transaction_handlers.go
+++ b/hotline/transaction_handlers.go
@@ -995,9 +995,7 @@ func HandleGetClientInfoText(cc *ClientConn, t *Transaction) (res []Transaction,
 }
 
 func HandleGetUserNameList(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 }
 
 func HandleGetUserNameList(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
-       res = append(res, cc.NewReply(t, cc.Server.connectedUsers()...))
-
-       return res, err
+       return []Transaction{cc.NewReply(t, cc.Server.connectedUsers()...)}, nil
 }
 
 func HandleTranAgreed(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 }
 
 func HandleTranAgreed(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
diff --git a/hotline/transaction_handlers_test.go b/hotline/transaction_handlers_test.go
index 09cb1cbdac2132406ec8d5c474be579178bc6875..9ea4a0a11f72afe28c31a74e6fb35de567445a1d 100644 (file)
--- a/hotline/transaction_handlers_test.go
+++ b/hotline/transaction_handlers_test.go
@@ -67,11 +67,8 @@ func TestHandleSetChatSubject(t *testing.T) {
                                        },
                                },
                                t: &Transaction{
                                        },
                                },
                                t: &Transaction{
-                                       Flags:     0x00,
-                                       IsReply:   0x00,
-                                       Type:      []byte{0, 0x6a},
-                                       ID:        []byte{0, 0, 0, 1},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       Type: [2]byte{0, 0x6a},
+                                       ID:   [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldChatID, []byte{0, 0, 0, 1}),
                                                NewField(FieldChatSubject, []byte("Test Subject")),
                                        Fields: []Field{
                                                NewField(FieldChatID, []byte{0, 0, 0, 1}),
                                                NewField(FieldChatSubject, []byte("Test Subject")),
@@ -80,24 +77,16 @@ func TestHandleSetChatSubject(t *testing.T) {
                        },
                        want: []Transaction{
                                {
                        },
                        want: []Transaction{
                                {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x00,
-                                       Type:      []byte{0, 0x77},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 1},
+                                       Type:     [2]byte{0, 0x77},
                                        Fields: []Field{
                                                NewField(FieldChatID, []byte{0, 0, 0, 1}),
                                                NewField(FieldChatSubject, []byte("Test Subject")),
                                        },
                                },
                                {
                                        Fields: []Field{
                                                NewField(FieldChatID, []byte{0, 0, 0, 1}),
                                                NewField(FieldChatSubject, []byte("Test Subject")),
                                        },
                                },
                                {
-                                       clientID:  &[]byte{0, 2},
-                                       Flags:     0x00,
-                                       IsReply:   0x00,
-                                       Type:      []byte{0, 0x77},
-                                       ID:        []byte{0xf0, 0xc5, 0x34, 0x1e}, // Random ID from rand.Seed(1)
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 2},
+                                       Type:     [2]byte{0, 0x77},
                                        Fields: []Field{
                                                NewField(FieldChatID, []byte{0, 0, 0, 1}),
                                                NewField(FieldChatSubject, []byte("Test Subject")),
                                        Fields: []Field{
                                                NewField(FieldChatID, []byte{0, 0, 0, 1}),
                                                NewField(FieldChatSubject, []byte("Test Subject")),
@@ -176,12 +165,10 @@ func TestHandleLeaveChat(t *testing.T) {
                        },
                        want: []Transaction{
                                {
                        },
                        want: []Transaction{
                                {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x00,
-                                       Type:      []byte{0, 0x76},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 1},
+                                       Flags:    0x00,
+                                       IsReply:  0x00,
+                                       Type:     [2]byte{0, 0x76},
                                        Fields: []Field{
                                                NewField(FieldChatID, []byte{0, 0, 0, 1}),
                                                NewField(FieldUserID, []byte{0, 2}),
                                        Fields: []Field{
                                                NewField(FieldChatID, []byte{0, 0, 0, 1}),
                                                NewField(FieldUserID, []byte{0, 2}),
@@ -239,19 +226,12 @@ func TestHandleGetUserNameList(t *testing.T) {
                                                },
                                        },
                                },
                                                },
                                        },
                                },
-                               t: &Transaction{
-                                       ID:   []byte{0, 0, 0, 1},
-                                       Type: []byte{0, 1},
-                               },
+                               t: &Transaction{},
                        },
                        want: []Transaction{
                                {
                        },
                        want: []Transaction{
                                {
-                                       clientID:  &[]byte{1, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0, 0, 0, 1},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{1, 1},
+                                       IsReply:  0x01,
                                        Fields: []Field{
                                                NewField(
                                                        FieldUsernameWithInfo,
                                        Fields: []Field{
                                                NewField(
                                                        FieldUsernameWithInfo,
@@ -327,23 +307,19 @@ func TestHandleChatSend(t *testing.T) {
                        },
                        want: []Transaction{
                                {
                        },
                        want: []Transaction{
                                {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x00,
-                                       Type:      []byte{0, 0x6a},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 1},
+                                       Flags:    0x00,
+                                       IsReply:  0x00,
+                                       Type:     [2]byte{0, 0x6a},
                                        Fields: []Field{
                                                NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
                                        },
                                },
                                {
                                        Fields: []Field{
                                                NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
                                        },
                                },
                                {
-                                       clientID:  &[]byte{0, 2},
-                                       Flags:     0x00,
-                                       IsReply:   0x00,
-                                       Type:      []byte{0, 0x6a},
-                                       ID:        []byte{0xf0, 0xc5, 0x34, 0x1e}, // Random ID from rand.Seed(1)
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 2},
+                                       Flags:    0x00,
+                                       IsReply:  0x00,
+                                       Type:     [2]byte{0, 0x6a},
                                        Fields: []Field{
                                                NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
                                        },
                                        Fields: []Field{
                                                NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
                                        },
@@ -389,23 +365,15 @@ func TestHandleChatSend(t *testing.T) {
                        },
                        want: []Transaction{
                                {
                        },
                        want: []Transaction{
                                {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x00,
-                                       Type:      []byte{0, 0x6a},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 1},
+                                       Type:     [2]byte{0, 0x6a},
                                        Fields: []Field{
                                                NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
                                        },
                                },
                                {
                                        Fields: []Field{
                                                NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
                                        },
                                },
                                {
-                                       clientID:  &[]byte{0, 2},
-                                       Flags:     0x00,
-                                       IsReply:   0x00,
-                                       Type:      []byte{0, 0x6a},
-                                       ID:        []byte{0xf0, 0xc5, 0x34, 0x1e}, // Random ID from rand.Seed(1)
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 2},
+                                       Type:     [2]byte{0, 0x6a},
                                        Fields: []Field{
                                                NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
                                        },
                                        Fields: []Field{
                                                NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
                                        },
@@ -434,11 +402,8 @@ func TestHandleChatSend(t *testing.T) {
                        },
                        want: []Transaction{
                                {
                        },
                        want: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to participate in chat.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to participate in chat.")),
                                        },
@@ -484,23 +449,19 @@ func TestHandleChatSend(t *testing.T) {
                        },
                        want: []Transaction{
                                {
                        },
                        want: []Transaction{
                                {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x00,
-                                       Type:      []byte{0, 0x6a},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 1},
+                                       Flags:    0x00,
+                                       IsReply:  0x00,
+                                       Type:     [2]byte{0, 0x6a},
                                        Fields: []Field{
                                                NewField(FieldData, []byte("\r*** Testy McTest performed action")),
                                        },
                                },
                                {
                                        Fields: []Field{
                                                NewField(FieldData, []byte("\r*** Testy McTest performed action")),
                                        },
                                },
                                {
-                                       clientID:  &[]byte{0, 2},
-                                       Flags:     0x00,
-                                       IsReply:   0x00,
-                                       Type:      []byte{0, 0x6a},
-                                       ID:        []byte{0xf0, 0xc5, 0x34, 0x1e},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 2},
+                                       Flags:    0x00,
+                                       IsReply:  0x00,
+                                       Type:     [2]byte{0, 0x6a},
                                        Fields: []Field{
                                                NewField(FieldData, []byte("\r*** Testy McTest performed action")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldData, []byte("\r*** Testy McTest performed action")),
                                        },
@@ -546,23 +507,15 @@ func TestHandleChatSend(t *testing.T) {
                        },
                        want: []Transaction{
                                {
                        },
                        want: []Transaction{
                                {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x00,
-                                       Type:      []byte{0, 0x6a},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 1},
+                                       Type:     [2]byte{0, 0x6a},
                                        Fields: []Field{
                                                NewField(FieldData, []byte("\r Testy McTest:  hello")),
                                        },
                                },
                                {
                                        Fields: []Field{
                                                NewField(FieldData, []byte("\r Testy McTest:  hello")),
                                        },
                                },
                                {
-                                       clientID:  &[]byte{0, 2},
-                                       Flags:     0x00,
-                                       IsReply:   0x00,
-                                       Type:      []byte{0, 0x6a},
-                                       ID:        []byte{0xf0, 0xc5, 0x34, 0x1e},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 2},
+                                       Type:     [2]byte{0, 0x6a},
                                        Fields: []Field{
                                                NewField(FieldData, []byte("\r Testy McTest:  hello")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldData, []byte("\r Testy McTest:  hello")),
                                        },
@@ -610,12 +563,8 @@ func TestHandleChatSend(t *testing.T) {
                        },
                        want: []Transaction{
                                {
                        },
                        want: []Transaction{
                                {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x00,
-                                       Type:      []byte{0, 0x6a},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 1},
+                                       Type:     [2]byte{0, 0x6a},
                                        Fields: []Field{
                                                NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
                                        },
                                        Fields: []Field{
                                                NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
                                        },
@@ -679,24 +628,16 @@ func TestHandleChatSend(t *testing.T) {
                        },
                        want: []Transaction{
                                {
                        },
                        want: []Transaction{
                                {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x00,
-                                       Type:      []byte{0, 0x6a},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 1},
+                                       Type:     [2]byte{0, 0x6a},
                                        Fields: []Field{
                                                NewField(FieldChatID, []byte{0, 0, 0, 1}),
                                                NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
                                        },
                                },
                                {
                                        Fields: []Field{
                                                NewField(FieldChatID, []byte{0, 0, 0, 1}),
                                                NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
                                        },
                                },
                                {
-                                       clientID:  &[]byte{0, 2},
-                                       Flags:     0x00,
-                                       IsReply:   0x00,
-                                       Type:      []byte{0, 0x6a},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 2},
+                                       Type:     [2]byte{0, 0x6a},
                                        Fields: []Field{
                                                NewField(FieldChatID, []byte{0, 0, 0, 1}),
                                                NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
                                        Fields: []Field{
                                                NewField(FieldChatID, []byte{0, 0, 0, 1}),
                                                NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
@@ -753,12 +694,9 @@ func TestHandleGetFileInfo(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 1},
+                                       IsReply:  0x01,
+                                       Type:     [2]byte{0, 0},
                                        Fields: []Field{
                                                NewField(FieldFileName, []byte("testfile.txt")),
                                                NewField(FieldFileTypeString, []byte("Text File")),
                                        Fields: []Field{
                                                NewField(FieldFileName, []byte("testfile.txt")),
                                                NewField(FieldFileTypeString, []byte("Text File")),
@@ -822,11 +760,8 @@ func TestHandleNewFolder(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to create folders.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to create folders.")),
                                        },
@@ -871,12 +806,8 @@ func TestHandleNewFolder(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 1},
+                                       IsReply:  0x01,
                                },
                        },
                        wantErr: false,
                                },
                        },
                        wantErr: false,
@@ -912,12 +843,8 @@ func TestHandleNewFolder(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 1},
+                                       IsReply:  0x01,
                                },
                        },
                        wantErr: false,
                                },
                        },
                        wantErr: false,
@@ -988,12 +915,8 @@ func TestHandleNewFolder(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 1},
+                                       IsReply:  0x01,
                                },
                        }, wantErr: false,
                },
                                },
                        }, wantErr: false,
                },
@@ -1037,12 +960,8 @@ func TestHandleNewFolder(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42}, // Random ID from rand.Seed(1)
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 1},
+                                       IsReply:  0x01,
                                },
                        }, wantErr: false,
                },
                                },
                        }, wantErr: false,
                },
@@ -1108,11 +1027,7 @@ func TestHandleUploadFile(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       IsReply: 0x01,
                                        Fields: []Field{
                                                NewField(FieldRefNum, []byte{0x52, 0xfd, 0xfc, 0x07}), // rand.Seed(1)
                                        },
                                        Fields: []Field{
                                                NewField(FieldRefNum, []byte{0x52, 0xfd, 0xfc, 0x07}), // rand.Seed(1)
                                        },
@@ -1144,11 +1059,8 @@ func TestHandleUploadFile(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to upload files.")), // rand.Seed(1)
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to upload files.")), // rand.Seed(1)
                                        },
@@ -1222,12 +1134,8 @@ func TestHandleMakeAlias(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 0},
-                                       Fields:    []Field(nil),
+                                       IsReply: 0x01,
+                                       Fields:  []Field(nil),
                                },
                        },
                        wantErr: false,
                                },
                        },
                        wantErr: false,
@@ -1273,11 +1181,8 @@ func TestHandleMakeAlias(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("Error creating alias")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("Error creating alias")),
                                        },
@@ -1324,11 +1229,8 @@ func TestHandleMakeAlias(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to make aliases.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to make aliases.")),
                                        },
@@ -1390,11 +1292,7 @@ func TestHandleGetUser(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       IsReply: 0x01,
                                        Fields: []Field{
                                                NewField(FieldUserName, []byte("Guest")),
                                                NewField(FieldUserLogin, encodeString([]byte("guest"))),
                                        Fields: []Field{
                                                NewField(FieldUserName, []byte("Guest")),
                                                NewField(FieldUserLogin, encodeString([]byte("guest"))),
@@ -1426,11 +1324,8 @@ func TestHandleGetUser(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to view accounts.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to view accounts.")),
                                        },
@@ -1462,9 +1357,8 @@ func TestHandleGetUser(t *testing.T) {
                                {
                                        Flags:     0x00,
                                        IsReply:   0x01,
                                {
                                        Flags:     0x00,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       Type:      [2]byte{0, 0},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("Account does not exist.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("Account does not exist.")),
                                        },
@@ -1530,12 +1424,10 @@ func TestHandleDeleteUser(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 0},
-                                       Fields:    []Field(nil),
+                                       Flags:   0x00,
+                                       IsReply: 0x01,
+                                       Type:    [2]byte{0, 0},
+                                       Fields:  []Field(nil),
                                },
                        },
                        wantErr: assert.NoError,
                                },
                        },
                        wantErr: assert.NoError,
@@ -1561,11 +1453,8 @@ func TestHandleDeleteUser(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to delete accounts.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to delete accounts.")),
                                        },
@@ -1618,11 +1507,7 @@ func TestHandleGetMsgs(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       IsReply: 0x01,
                                        Fields: []Field{
                                                NewField(FieldData, []byte("TEST")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldData, []byte("TEST")),
                                        },
@@ -1650,11 +1535,8 @@ func TestHandleGetMsgs(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to read news.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to read news.")),
                                        },
@@ -1706,11 +1588,8 @@ func TestHandleNewUser(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to create new accounts.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to create new accounts.")),
                                        },
@@ -1748,11 +1627,8 @@ func TestHandleNewUser(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("Cannot create account with more access than yourself.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("Cannot create account with more access than yourself.")),
                                        },
@@ -1804,11 +1680,8 @@ func TestHandleListUsers(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to view accounts.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to view accounts.")),
                                        },
@@ -1845,11 +1718,7 @@ func TestHandleListUsers(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       IsReply: 0x01,
                                        Fields: []Field{
                                                NewField(FieldData, []byte{
                                                        0x00, 0x04, 0x00, 0x66, 0x00, 0x05, 0x67, 0x75, 0x65, 0x73, 0x74, 0x00, 0x69, 0x00, 0x05, 0x98,
                                        Fields: []Field{
                                                NewField(FieldData, []byte{
                                                        0x00, 0x04, 0x00, 0x66, 0x00, 0x05, 0x67, 0x75, 0x65, 0x73, 0x74, 0x00, 0x69, 0x00, 0x05, 0x98,
@@ -1901,11 +1770,8 @@ func TestHandleDownloadFile(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to download files.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to download files.")),
                                        },
@@ -1945,11 +1811,7 @@ func TestHandleDownloadFile(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       IsReply: 0x01,
                                        Fields: []Field{
                                                NewField(FieldRefNum, []byte{0x52, 0xfd, 0xfc, 0x07}),
                                                NewField(FieldWaitingCount, []byte{0x00, 0x00}),
                                        Fields: []Field{
                                                NewField(FieldRefNum, []byte{0x52, 0xfd, 0xfc, 0x07}),
                                                NewField(FieldWaitingCount, []byte{0x00, 0x00}),
@@ -2036,11 +1898,7 @@ func TestHandleDownloadFile(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       IsReply: 0x01,
                                        Fields: []Field{
                                                NewField(FieldRefNum, []byte{0x52, 0xfd, 0xfc, 0x07}),
                                                NewField(FieldWaitingCount, []byte{0x00, 0x00}),
                                        Fields: []Field{
                                                NewField(FieldRefNum, []byte{0x52, 0xfd, 0xfc, 0x07}),
                                                NewField(FieldWaitingCount, []byte{0x00, 0x00}),
@@ -2116,11 +1974,8 @@ func TestHandleUpdateUser(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to create new accounts.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to create new accounts.")),
                                        },
@@ -2172,11 +2027,8 @@ func TestHandleUpdateUser(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to modify accounts.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to modify accounts.")),
                                        },
@@ -2214,11 +2066,8 @@ func TestHandleUpdateUser(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to delete accounts.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to delete accounts.")),
                                        },
@@ -2268,11 +2117,8 @@ func TestHandleDelNewsArt(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to delete news articles.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to delete news articles.")),
                                        },
@@ -2321,11 +2167,8 @@ func TestHandleDisconnectUser(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to disconnect users.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to disconnect users.")),
                                        },
@@ -2367,11 +2210,8 @@ func TestHandleDisconnectUser(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("unnamed is not allowed to be disconnected.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("unnamed is not allowed to be disconnected.")),
                                        },
@@ -2420,11 +2260,8 @@ func TestHandleSendInstantMsg(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to send private messages.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to send private messages.")),
                                        },
@@ -2471,13 +2308,9 @@ func TestHandleSendInstantMsg(t *testing.T) {
                                        NewField(FieldOptions, []byte{0, 1}),
                                ),
                                {
                                        NewField(FieldOptions, []byte{0, 1}),
                                ),
                                {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 0},
-                                       Fields:    []Field(nil),
+                                       clientID: &[]byte{0, 1},
+                                       IsReply:  0x01,
+                                       Fields:   []Field(nil),
                                },
                        },
                        wantErr: assert.NoError,
                                },
                        },
                        wantErr: assert.NoError,
@@ -2531,13 +2364,9 @@ func TestHandleSendInstantMsg(t *testing.T) {
                                        NewField(FieldOptions, []byte{0, 1}),
                                ),
                                {
                                        NewField(FieldOptions, []byte{0, 1}),
                                ),
                                {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 0},
-                                       Fields:    []Field(nil),
+                                       clientID: &[]byte{0, 1},
+                                       IsReply:  0x01,
+                                       Fields:   []Field(nil),
                                },
                        },
                        wantErr: assert.NoError,
                                },
                        },
                        wantErr: assert.NoError,
@@ -2582,13 +2411,9 @@ func TestHandleSendInstantMsg(t *testing.T) {
                                        NewField(FieldOptions, []byte{0, 2}),
                                ),
                                {
                                        NewField(FieldOptions, []byte{0, 2}),
                                ),
                                {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 0},
-                                       Fields:    []Field(nil),
+                                       clientID: &[]byte{0, 1},
+                                       IsReply:  0x01,
+                                       Fields:   []Field(nil),
                                },
                        },
                        wantErr: assert.NoError,
                                },
                        },
                        wantErr: assert.NoError,
@@ -2664,11 +2489,8 @@ func TestHandleDeleteFile(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to delete files.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to delete files.")),
                                        },
@@ -2729,12 +2551,8 @@ func TestHandleDeleteFile(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x0, 0x0, 0x0, 0x0},
-                                       ErrorCode: []byte{0, 0, 0, 0},
-                                       Fields:    []Field(nil),
+                                       IsReply: 0x01,
+                                       Fields:  []Field(nil),
                                },
                        },
                        wantErr: assert.NoError,
                                },
                        },
                        wantErr: assert.NoError,
@@ -2797,11 +2615,8 @@ func TestHandleGetFileNameList(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to view drop boxes.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to view drop boxes.")),
                                        },
@@ -2832,11 +2647,7 @@ func TestHandleGetFileNameList(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       IsReply: 0x01,
                                        Fields: []Field{
                                                NewField(
                                                        FieldFileNameWithInfo,
                                        Fields: []Field{
                                                NewField(
                                                        FieldFileNameWithInfo,
@@ -2906,11 +2717,8 @@ func TestHandleGetClientInfoText(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to get client info.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to get client info.")),
                                        },
@@ -2965,11 +2773,7 @@ func TestHandleGetClientInfoText(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       IsReply: 0x01,
                                        Fields: []Field{
                                                NewField(FieldData, []byte(
                                                        strings.ReplaceAll(`Nickname:   Testy McTest
                                        Fields: []Field{
                                                NewField(FieldData, []byte(
                                                        strings.ReplaceAll(`Nickname:   Testy McTest
@@ -3059,24 +2863,16 @@ func TestHandleTranAgreed(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x00,
-                                       Type:      []byte{0, 0x7a},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 1},
+                                       Type:     [2]byte{0, 0x7a},
                                        Fields: []Field{
                                                NewField(FieldBannerType, []byte("JPEG")),
                                        },
                                },
                                {
                                        Fields: []Field{
                                                NewField(FieldBannerType, []byte("JPEG")),
                                        },
                                },
                                {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 0},
-                                       Fields:    []Field{},
+                                       clientID: &[]byte{0, 1},
+                                       IsReply:  0x01,
+                                       Fields:   []Field{},
                                },
                        },
                        wantErr: assert.NoError,
                                },
                        },
                        wantErr: assert.NoError,
@@ -3133,12 +2929,8 @@ func TestHandleSetClientUserInfo(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x00,
-                                       Type:      []byte{0x01, 0x2d},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 1},
+                                       Type:     [2]byte{0x01, 0x2d},
                                        Fields: []Field{
                                                NewField(FieldUserID, []byte{0, 1}),
                                                NewField(FieldUserIconID, []byte{0, 1}),
                                        Fields: []Field{
                                                NewField(FieldUserID, []byte{0, 1}),
                                                NewField(FieldUserIconID, []byte{0, 1}),
@@ -3204,11 +2996,8 @@ func TestHandleDelNewsItem(t *testing.T) {
                        wantRes: []Transaction{
                                {
                                        clientID:  &[]byte{0, 1},
                        wantRes: []Transaction{
                                {
                                        clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to delete news categories.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to delete news categories.")),
                                        },
@@ -3248,11 +3037,8 @@ func TestHandleDelNewsItem(t *testing.T) {
                        wantRes: []Transaction{
                                {
                                        clientID:  &[]byte{0, 1},
                        wantRes: []Transaction{
                                {
                                        clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to delete news folders.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to delete news folders.")),
                                        },
@@ -3301,13 +3087,9 @@ func TestHandleDelNewsItem(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 0},
-                                       Fields:    []Field{},
+                                       clientID: &[]byte{0, 1},
+                                       IsReply:  0x01,
+                                       Fields:   []Field{},
                                },
                        },
                        wantErr: assert.NoError,
                                },
                        },
                        wantErr: assert.NoError,
@@ -3353,11 +3135,8 @@ func TestHandleTranOldPostNews(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to post news.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to post news.")),
                                        },
@@ -3393,11 +3172,7 @@ func TestHandleTranOldPostNews(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       IsReply: 0x01,
                                },
                        },
                        wantErr: assert.NoError,
                                },
                        },
                        wantErr: assert.NoError,
@@ -3441,11 +3216,8 @@ func TestHandleInviteNewChat(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to request private chat.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to request private chat.")),
                                        },
@@ -3486,12 +3258,8 @@ func TestHandleInviteNewChat(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       clientID:  &[]byte{0, 2},
-                                       Flags:     0x00,
-                                       IsReply:   0x00,
-                                       Type:      []byte{0, 0x71},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 2},
+                                       Type:     [2]byte{0, 0x71},
                                        Fields: []Field{
                                                NewField(FieldChatID, []byte{0x52, 0xfd, 0xfc, 0x07}),
                                                NewField(FieldUserName, []byte("UserA")),
                                        Fields: []Field{
                                                NewField(FieldChatID, []byte{0x52, 0xfd, 0xfc, 0x07}),
                                                NewField(FieldUserName, []byte("UserA")),
@@ -3500,12 +3268,8 @@ func TestHandleInviteNewChat(t *testing.T) {
                                },
 
                                {
                                },
 
                                {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 1},
+                                       IsReply:  0x01,
                                        Fields: []Field{
                                                NewField(FieldChatID, []byte{0x52, 0xfd, 0xfc, 0x07}),
                                                NewField(FieldUserName, []byte("UserA")),
                                        Fields: []Field{
                                                NewField(FieldChatID, []byte{0x52, 0xfd, 0xfc, 0x07}),
                                                NewField(FieldUserName, []byte("UserA")),
@@ -3550,12 +3314,8 @@ func TestHandleInviteNewChat(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x00,
-                                       Type:      []byte{0, 0x68},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 1},
+                                       Type:     [2]byte{0, 0x68},
                                        Fields: []Field{
                                                NewField(FieldData, []byte("UserB does not accept private chats.")),
                                                NewField(FieldUserName, []byte("UserB")),
                                        Fields: []Field{
                                                NewField(FieldData, []byte("UserB does not accept private chats.")),
                                                NewField(FieldUserName, []byte("UserB")),
@@ -3564,12 +3324,8 @@ func TestHandleInviteNewChat(t *testing.T) {
                                        },
                                },
                                {
                                        },
                                },
                                {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       clientID: &[]byte{0, 1},
+                                       IsReply:  0x01,
                                        Fields: []Field{
                                                NewField(FieldChatID, []byte{0x52, 0xfd, 0xfc, 0x07}),
                                                NewField(FieldUserName, []byte("UserA")),
                                        Fields: []Field{
                                                NewField(FieldChatID, []byte{0x52, 0xfd, 0xfc, 0x07}),
                                                NewField(FieldUserName, []byte("UserA")),
@@ -3624,11 +3380,8 @@ func TestHandleGetNewsArtData(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
                                        IsReply:   0x01,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to read news.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to read news.")),
                                        },
@@ -3681,8 +3434,8 @@ func TestHandleGetNewsArtNameList(t *testing.T) {
                                {
                                        Flags:     0x00,
                                        IsReply:   0x01,
                                {
                                        Flags:     0x00,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       Type:      [2]byte{0, 0},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to read news.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to read news.")),
                                        },
@@ -3744,10 +3497,7 @@ func TestHandleGetNewsArtNameList(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       IsReply: 0x01,
                                        Fields: []Field{
                                                NewField(FieldNewsArtListData, []byte{
                                                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
                                        Fields: []Field{
                                                NewField(FieldNewsArtListData, []byte{
                                                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
@@ -3807,8 +3557,8 @@ func TestHandleNewNewsFldr(t *testing.T) {
                                {
                                        Flags:     0x00,
                                        IsReply:   0x01,
                                {
                                        Flags:     0x00,
                                        IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       Type:      [2]byte{0, 0},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to create news folders.")),
                                        },
                                        Fields: []Field{
                                                NewField(FieldError, []byte("You are not allowed to create news folders.")),
                                        },
@@ -3860,13 +3610,9 @@ func TestHandleNewNewsFldr(t *testing.T) {
                        },
                        wantRes: []Transaction{
                                {
                        },
                        wantRes: []Transaction{
                                {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
-                                       IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 0},
-                                       Fields:    []Field{},
+                                       clientID: &[]byte{0, 1},
+                                       IsReply:  0x01,
+                                       Fields:   []Field{},
                                },
                        },
                        wantErr: assert.NoError,
                                },
                        },
                        wantErr: assert.NoError,
@@ -3920,8 +3666,8 @@ func TestHandleNewNewsFldr(t *testing.T) {
                //                      clientID:  &[]byte{0, 1},
                //                      Flags:     0x00,
                //                      IsReply:   0x01,
                //                      clientID:  &[]byte{0, 1},
                //                      Flags:     0x00,
                //                      IsReply:   0x01,
-               //                      Type:      []byte{0, 0},
-               //                      ErrorCode: []byte{0, 0, 0, 1},
+               //                      Type:      [2]byte{0, 0},
+               //                      ErrorCode: [4]byte{0, 0, 0, 1},
                //                      Fields: []Field{
                //                              NewField(FieldError, []byte("Error creating news folder.")),
                //                      },
                //                      Fields: []Field{
                //                              NewField(FieldError, []byte("Error creating news folder.")),
                //                      },
diff --git a/hotline/transaction_test.go b/hotline/transaction_test.go
index cdb6f1e627a40ab0d4f0ec59459b15c8ae33d292..b5ee9901b524c853909090a4a8dbedb3b742b775 100644 (file)
--- a/hotline/transaction_test.go
+++ b/hotline/transaction_test.go
@@ -304,12 +304,12 @@ func TestTransaction_Read(t1 *testing.T) {
                clientID   *[]byte
                Flags      byte
                IsReply    byte
                clientID   *[]byte
                Flags      byte
                IsReply    byte
-               Type       []byte
-               ID         []byte
-               ErrorCode  []byte
-               TotalSize  []byte
-               DataSize   []byte
-               ParamCount []byte
+               Type       [2]byte
+               ID         [4]byte
+               ErrorCode  [4]byte
+               TotalSize  [4]byte
+               DataSize   [4]byte
+               ParamCount [2]byte
                Fields     []Field
                readOffset int
        }
                Fields     []Field
                readOffset int
        }
@@ -329,9 +329,9 @@ func TestTransaction_Read(t1 *testing.T) {
                        fields: fields{
                                Flags:     0x00,
                                IsReply:   0x01,
                        fields: fields{
                                Flags:     0x00,
                                IsReply:   0x01,
-                               Type:      []byte{0, 0},
-                               ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                               ErrorCode: []byte{0, 0, 0, 0},
+                               Type:      [2]byte{0, 0},
+                               ID:        [4]byte{0x9a, 0xcb, 0x04, 0x42},
+                               ErrorCode: [4]byte{0, 0, 0, 0},
                                Fields: []Field{
                                        NewField(FieldData, []byte("TEST")),
                                },
                                Fields: []Field{
                                        NewField(FieldData, []byte("TEST")),
                                },
@@ -348,9 +348,9 @@ func TestTransaction_Read(t1 *testing.T) {
                        fields: fields{
                                Flags:     0x00,
                                IsReply:   0x01,
                        fields: fields{
                                Flags:     0x00,
                                IsReply:   0x01,
-                               Type:      []byte{0, 0},
-                               ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                               ErrorCode: []byte{0, 0, 0, 0},
+                               Type:      [2]byte{0, 0},
+                               ID:        [4]byte{0x9a, 0xcb, 0x04, 0x42},
+                               ErrorCode: [4]byte{0, 0, 0, 0},
                                Fields: []Field{
                                        NewField(FieldData, []byte("TEST")),
                                },
                                Fields: []Field{
                                        NewField(FieldData, []byte("TEST")),
                                },
@@ -368,9 +368,9 @@ func TestTransaction_Read(t1 *testing.T) {
                        fields: fields{
                                Flags:     0x00,
                                IsReply:   0x01,
                        fields: fields{
                                Flags:     0x00,
                                IsReply:   0x01,
-                               Type:      []byte{0, 0},
-                               ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                               ErrorCode: []byte{0, 0, 0, 0},
+                               Type:      [2]byte{0, 0},
+                               ID:        [4]byte{0x9a, 0xcb, 0x04, 0x42},
+                               ErrorCode: [4]byte{0, 0, 0, 0},
                                Fields: []Field{
                                        NewField(FieldData, []byte("TEST")),
                                },
                                Fields: []Field{
                                        NewField(FieldData, []byte("TEST")),
                                },
Friendship Quest remix of mobius, a hotline server in go #cli