Update docker image name

[rbdr/mobius] / hotline / transaction_handlers_test.go
diff --git a/hotline/transaction_handlers_test.go b/hotline/transaction_handlers_test.go

index dae2dc01e772ab71db807ba51abf4e2296462ecb..b7cc0afbc609ac78dbaeea3506f0029fa57b8bce 100644 (file)
--- a/hotline/transaction_handlers_test.go
+++ b/hotline/transaction_handlers_test.go
@@ -2,14 +2,14 @@ package hotline
  
  import (
         "errors"
  
  import (
         "errors"
-       "fmt"
         "github.com/stretchr/testify/assert"
         "github.com/stretchr/testify/mock"
         "github.com/stretchr/testify/assert"
         "github.com/stretchr/testify/mock"
+       "io"
         "io/fs"
         "io/fs"
-       "math/rand"
         "os"
         "path/filepath"
         "strings"
         "os"
         "path/filepath"
         "strings"
+       "sync"
         "testing"
         "time"
  )
         "testing"
         "time"
  )
@@ -17,13 +17,12 @@ import (
  func TestHandleSetChatSubject(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleSetChatSubject(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
         }
         tests := []struct {
-               name    string
-               args    args
-               want    []Transaction
-               wantErr bool
+               name string
+               args args
+               want []Transaction
         }{
                 {
                         name: "sends chat subject to private chat members",
         }{
                 {
                         name: "sends chat subject to private chat members",
@@ -31,92 +30,74 @@ func TestHandleSetChatSubject(t *testing.T) {
                                 cc: &ClientConn{
                                         UserName: []byte{0x00, 0x01},
                                         Server: &Server{
                                 cc: &ClientConn{
                                         UserName: []byte{0x00, 0x01},
                                         Server: &Server{
-                                               PrivateChats: map[uint32]*PrivateChat{
-                                                       uint32(1): {
+                                               PrivateChats: map[[4]byte]*PrivateChat{
+                                                       [4]byte{0, 0, 0, 1}: {
                                                                 Subject: "unset",
                                                                 Subject: "unset",
-                                                               ClientConn: map[uint16]*ClientConn{
-                                                                       uint16(1): {
+                                                               ClientConn: map[[2]byte]*ClientConn{
+                                                                       [2]byte{0, 1}: {
                                                                                 Account: &Account{
                                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                                 },
                                                                                 Account: &Account{
                                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                                 },
-                                                                               ID: &[]byte{0, 1},
+                                                                               ID: [2]byte{0, 1},
                                                                         },
                                                                         },
-                                                                       uint16(2): {
+                                                                       [2]byte{0, 2}: {
                                                                                 Account: &Account{
                                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                                 },
                                                                                 Account: &Account{
                                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                                 },
-                                                                               ID: &[]byte{0, 2},
+                                                                               ID: [2]byte{0, 2},
                                                                         },
                                                                 },
                                                         },
                                                 },
                                                                         },
                                                                 },
                                                         },
                                                 },
-                                               Clients: map[uint16]*ClientConn{
-                                                       uint16(1): {
+                                               Clients: map[[2]byte]*ClientConn{
+                                                       [2]byte{0, 1}: {
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
-                                                               ID: &[]byte{0, 1},
+                                                               ID: [2]byte{0, 1},
                                                         },
                                                         },
-                                                       uint16(2): {
+                                                       [2]byte{0, 2}: {
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
-                                                               ID: &[]byte{0, 2},
+                                                               ID: [2]byte{0, 2},
                                                         },
                                                 },
                                         },
                                 },
                                                         },
                                                 },
                                         },
                                 },
-                               t: &Transaction{
-                                       Flags:     0x00,
-                                       IsReply:   0x00,
-                                       Type:      []byte{0, 0x6a},
-                                       ID:        []byte{0, 0, 0, 1},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                               t: Transaction{
+                                       Type: [2]byte{0, 0x6a},
+                                       ID:   [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldChatID, []byte{0, 0, 0, 1}),
-                                               NewField(fieldChatSubject, []byte("Test Subject")),
+                                               NewField(FieldChatID, []byte{0, 0, 0, 1}),
+                                               NewField(FieldChatSubject, []byte("Test Subject")),
                                         },
                                 },
                         },
                         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: [2]byte{0, 1},
+                                       Type:     [2]byte{0, 0x77},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldChatID, []byte{0, 0, 0, 1}),
-                                               NewField(fieldChatSubject, []byte("Test Subject")),
+                                               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: [2]byte{0, 2},
+                                       Type:     [2]byte{0, 0x77},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldChatID, []byte{0, 0, 0, 1}),
-                                               NewField(fieldChatSubject, []byte("Test Subject")),
+                                               NewField(FieldChatID, []byte{0, 0, 0, 1}),
+                                               NewField(FieldChatSubject, []byte("Test Subject")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: false,
                 },
         }
         for _, tt := range tests {
                 },
         }
         for _, tt := range tests {
-               rand.Seed(1) // reset seed between tests to make transaction IDs predictable
-
                 t.Run(tt.name, func(t *testing.T) {
                 t.Run(tt.name, func(t *testing.T) {
-                       got, err := HandleSetChatSubject(tt.args.cc, tt.args.t)
-                       if (err != nil) != tt.wantErr {
-                               t.Errorf("HandleSetChatSubject() error = %v, wantErr %v", err, tt.wantErr)
-                               return
-                       }
-                       if !assert.Equal(t, tt.want, got) {
+                       got := HandleSetChatSubject(tt.args.cc, &tt.args.t)
+                       if !tranAssertEqual(t, tt.want, got) {
                                 t.Errorf("HandleSetChatSubject() got = %v, want %v", got, tt.want)
                         }
                 })
                                 t.Errorf("HandleSetChatSubject() got = %v, want %v", got, tt.want)
                         }
                 })
@@ -126,82 +107,71 @@ func TestHandleSetChatSubject(t *testing.T) {
  func TestHandleLeaveChat(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleLeaveChat(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
         }
         tests := []struct {
-               name    string
-               args    args
-               want    []Transaction
-               wantErr bool
+               name string
+               args args
+               want []Transaction
         }{
                 {
                         name: "returns expected transactions",
                         args: args{
                                 cc: &ClientConn{
         }{
                 {
                         name: "returns expected transactions",
                         args: args{
                                 cc: &ClientConn{
-                                       ID: &[]byte{0, 2},
+                                       ID: [2]byte{0, 2},
                                         Server: &Server{
                                         Server: &Server{
-                                               PrivateChats: map[uint32]*PrivateChat{
-                                                       uint32(1): {
-                                                               ClientConn: map[uint16]*ClientConn{
-                                                                       uint16(1): {
+                                               PrivateChats: map[[4]byte]*PrivateChat{
+                                                       [4]byte{0, 0, 0, 1}: {
+                                                               ClientConn: map[[2]byte]*ClientConn{
+                                                                       [2]byte{0, 1}: {
                                                                                 Account: &Account{
                                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                                 },
                                                                                 Account: &Account{
                                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                                 },
-                                                                               ID: &[]byte{0, 1},
+                                                                               ID: [2]byte{0, 1},
                                                                         },
                                                                         },
-                                                                       uint16(2): {
+                                                                       [2]byte{0, 2}: {
                                                                                 Account: &Account{
                                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                                 },
                                                                                 Account: &Account{
                                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                                 },
-                                                                               ID: &[]byte{0, 2},
+                                                                               ID: [2]byte{0, 2},
                                                                         },
                                                                 },
                                                         },
                                                 },
                                                                         },
                                                                 },
                                                         },
                                                 },
-                                               Clients: map[uint16]*ClientConn{
-                                                       uint16(1): {
+                                               Clients: map[[2]byte]*ClientConn{
+                                                       [2]byte{0, 1}: {
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
-                                                               ID: &[]byte{0, 1},
+                                                               ID: [2]byte{0, 1},
                                                         },
                                                         },
-                                                       uint16(2): {
+                                                       [2]byte{0, 2}: {
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
-                                                               ID: &[]byte{0, 2},
+                                                               ID: [2]byte{0, 2},
                                                         },
                                                 },
                                         },
                                 },
                                                         },
                                                 },
                                         },
                                 },
-                               t: NewTransaction(tranDeleteUser, nil, NewField(fieldChatID, []byte{0, 0, 0, 1})),
+                               t: NewTransaction(TranDeleteUser, [2]byte{}, NewField(FieldChatID, []byte{0, 0, 0, 1})),
                         },
                         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: [2]byte{0, 1},
+                                       Type:     [2]byte{0, 0x76},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldChatID, []byte{0, 0, 0, 1}),
-                                               NewField(fieldUserID, []byte{0, 2}),
+                                               NewField(FieldChatID, []byte{0, 0, 0, 1}),
+                                               NewField(FieldUserID, []byte{0, 2}),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: false,
                 },
         }
         for _, tt := range tests {
                 },
         }
         for _, tt := range tests {
-               rand.Seed(1)
                 t.Run(tt.name, func(t *testing.T) {
                 t.Run(tt.name, func(t *testing.T) {
-                       got, err := HandleLeaveChat(tt.args.cc, tt.args.t)
-                       if (err != nil) != tt.wantErr {
-                               t.Errorf("HandleLeaveChat() error = %v, wantErr %v", err, tt.wantErr)
-                               return
-                       }
-                       if !assert.Equal(t, tt.want, got) {
+                       got := HandleLeaveChat(tt.args.cc, &tt.args.t)
+                       if !tranAssertEqual(t, tt.want, got) {
                                 t.Errorf("HandleLeaveChat() got = %v, want %v", got, tt.want)
                         }
                 })
                                 t.Errorf("HandleLeaveChat() got = %v, want %v", got, tt.want)
                         }
                 })
@@ -211,72 +181,58 @@ func TestHandleLeaveChat(t *testing.T) {
  func TestHandleGetUserNameList(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleGetUserNameList(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
         }
         tests := []struct {
-               name    string
-               args    args
-               want    []Transaction
-               wantErr bool
+               name string
+               args args
+               want []Transaction
         }{
                 {
                         name: "replies with userlist transaction",
                         args: args{
                                 cc: &ClientConn{
         }{
                 {
                         name: "replies with userlist transaction",
                         args: args{
                                 cc: &ClientConn{
-
-                                       ID: &[]byte{1, 1},
+                                       ID: [2]byte{0, 1},
                                         Server: &Server{
                                         Server: &Server{
-                                               Clients: map[uint16]*ClientConn{
-                                                       uint16(1): {
-                                                               ID:       &[]byte{0, 1},
+                                               Clients: map[[2]byte]*ClientConn{
+                                                       [2]byte{0, 1}: {
+                                                               ID:       [2]byte{0, 1},
                                                                 Icon:     []byte{0, 2},
                                                                 Icon:     []byte{0, 2},
-                                                               Flags:    []byte{0, 3},
+                                                               Flags:    [2]byte{0, 3},
                                                                 UserName: []byte{0, 4},
                                                         },
                                                                 UserName: []byte{0, 4},
                                                         },
-                                                       uint16(2): {
-                                                               ID:       &[]byte{0, 2},
+                                                       [2]byte{0, 2}: {
+                                                               ID:       [2]byte{0, 2},
                                                                 Icon:     []byte{0, 2},
                                                                 Icon:     []byte{0, 2},
-                                                               Flags:    []byte{0, 3},
+                                                               Flags:    [2]byte{0, 3},
                                                                 UserName: []byte{0, 4},
                                                         },
                                                 },
                                         },
                                 },
                                                                 UserName: []byte{0, 4},
                                                         },
                                                 },
                                         },
                                 },
-                               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: [2]byte{0, 1},
+                                       IsReply:  0x01,
                                         Fields: []Field{
                                                 NewField(
                                         Fields: []Field{
                                                 NewField(
-                                                       fieldUsernameWithInfo,
+                                                       FieldUsernameWithInfo,
                                                         []byte{00, 01, 00, 02, 00, 03, 00, 02, 00, 04},
                                                 ),
                                                 NewField(
                                                         []byte{00, 01, 00, 02, 00, 03, 00, 02, 00, 04},
                                                 ),
                                                 NewField(
-                                                       fieldUsernameWithInfo,
+                                                       FieldUsernameWithInfo,
                                                         []byte{00, 02, 00, 02, 00, 03, 00, 02, 00, 04},
                                                 ),
                                         },
                                 },
                         },
                                                         []byte{00, 02, 00, 02, 00, 03, 00, 02, 00, 04},
                                                 ),
                                         },
                                 },
                         },
-                       wantErr: false,
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-                       got, err := HandleGetUserNameList(tt.args.cc, tt.args.t)
-                       if (err != nil) != tt.wantErr {
-                               t.Errorf("HandleGetUserNameList() error = %v, wantErr %v", err, tt.wantErr)
-                               return
-                       }
+                       got := HandleGetUserNameList(tt.args.cc, &tt.args.t)
                         assert.Equal(t, tt.want, got)
                 })
         }
                         assert.Equal(t, tt.want, got)
                 })
         }
@@ -285,13 +241,12 @@ func TestHandleGetUserNameList(t *testing.T) {
  func TestHandleChatSend(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleChatSend(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
         }
         tests := []struct {
-               name    string
-               args    args
-               want    []Transaction
-               wantErr bool
+               name string
+               args args
+               want []Transaction
         }{
                 {
                         name: "sends chat msg transaction to all clients",
         }{
                 {
                         name: "sends chat msg transaction to all clients",
@@ -306,53 +261,48 @@ func TestHandleChatSend(t *testing.T) {
                                         },
                                         UserName: []byte{0x00, 0x01},
                                         Server: &Server{
                                         },
                                         UserName: []byte{0x00, 0x01},
                                         Server: &Server{
-                                               Clients: map[uint16]*ClientConn{
-                                                       uint16(1): {
+                                               Clients: map[[2]byte]*ClientConn{
+                                                       [2]byte{0, 1}: {
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
-                                                               ID: &[]byte{0, 1},
+                                                               ID: [2]byte{0, 1},
                                                         },
                                                         },
-                                                       uint16(2): {
+                                                       [2]byte{0, 2}: {
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
-                                                               ID: &[]byte{0, 2},
+                                                               ID: [2]byte{0, 2},
                                                         },
                                                 },
                                         },
                                 },
                                                         },
                                                 },
                                         },
                                 },
-                               t: &Transaction{
+                               t: Transaction{
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldData, []byte("hai")),
+                                               NewField(FieldData, []byte("hai")),
                                         },
                                 },
                         },
                         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: [2]byte{0, 1},
+                                       Flags:    0x00,
+                                       IsReply:  0x00,
+                                       Type:     [2]byte{0, 0x6a},
                                         Fields: []Field{
                                         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}),
+                                               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: [2]byte{0, 2},
+                                       Flags:    0x00,
+                                       IsReply:  0x00,
+                                       Type:     [2]byte{0, 0x6a},
                                         Fields: []Field{
                                         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}),
+                                               NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: false,
                 },
                 {
                         name: "treats Chat ID 00 00 00 00 as a public chat message",
                 },
                 {
                         name: "treats Chat ID 00 00 00 00 as a public chat message",
@@ -367,54 +317,45 @@ func TestHandleChatSend(t *testing.T) {
                                         },
                                         UserName: []byte{0x00, 0x01},
                                         Server: &Server{
                                         },
                                         UserName: []byte{0x00, 0x01},
                                         Server: &Server{
-                                               Clients: map[uint16]*ClientConn{
-                                                       uint16(1): {
+                                               Clients: map[[2]byte]*ClientConn{
+                                                       [2]byte{0, 1}: {
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
-                                                               ID: &[]byte{0, 1},
+                                                               ID: [2]byte{0, 1},
                                                         },
                                                         },
-                                                       uint16(2): {
+                                                       [2]byte{0, 2}: {
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
-                                                               ID: &[]byte{0, 2},
+                                                               ID: [2]byte{0, 2},
                                                         },
                                                 },
                                         },
                                 },
                                                         },
                                                 },
                                         },
                                 },
-                               t: &Transaction{
+                               t: Transaction{
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldData, []byte("hai")),
-                                               NewField(fieldChatID, []byte{0, 0, 0, 0}),
+                                               NewField(FieldData, []byte("hai")),
+                                               NewField(FieldChatID, []byte{0, 0, 0, 0}),
                                         },
                                 },
                         },
                         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: [2]byte{0, 1},
+                                       Type:     [2]byte{0, 0x6a},
                                         Fields: []Field{
                                         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}),
+                                               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: [2]byte{0, 2},
+                                       Type:     [2]byte{0, 0x6a},
                                         Fields: []Field{
                                         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}),
+                                               NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: false,
                 },
                 {
                         name: "when user does not have required permission",
                 },
                 {
                         name: "when user does not have required permission",
@@ -431,26 +372,22 @@ func TestHandleChatSend(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranChatSend, &[]byte{0, 1},
-                                       NewField(fieldData, []byte("hai")),
+                                       TranChatSend, [2]byte{0, 1},
+                                       NewField(FieldData, []byte("hai")),
                                 ),
                         },
                         want: []Transaction{
                                 {
                                 ),
                         },
                         want: []Transaction{
                                 {
-                                       Flags:     0x00,
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("You are not allowed to participate in chat.")),
+                                               NewField(FieldError, []byte("You are not allowed to participate in chat.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: false,
                 },
                 {
                 },
                 {
-                       name: "sends chat msg as emote if fieldChatOptions is set to 1",
+                       name: "sends chat msg as emote if FieldChatOptions is set to 1",
                         args: args{
                                 cc: &ClientConn{
                                         Account: &Account{
                         args: args{
                                 cc: &ClientConn{
                                         Account: &Account{
@@ -462,57 +399,52 @@ func TestHandleChatSend(t *testing.T) {
                                         },
                                         UserName: []byte("Testy McTest"),
                                         Server: &Server{
                                         },
                                         UserName: []byte("Testy McTest"),
                                         Server: &Server{
-                                               Clients: map[uint16]*ClientConn{
-                                                       uint16(1): {
+                                               Clients: map[[2]byte]*ClientConn{
+                                                       [2]byte{0, 1}: {
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
-                                                               ID: &[]byte{0, 1},
+                                                               ID: [2]byte{0, 1},
                                                         },
                                                         },
-                                                       uint16(2): {
+                                                       [2]byte{0, 2}: {
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
-                                                               ID: &[]byte{0, 2},
+                                                               ID: [2]byte{0, 2},
                                                         },
                                                 },
                                         },
                                 },
                                                         },
                                                 },
                                         },
                                 },
-                               t: &Transaction{
+                               t: Transaction{
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldData, []byte("performed action")),
-                                               NewField(fieldChatOptions, []byte{0x00, 0x01}),
+                                               NewField(FieldData, []byte("performed action")),
+                                               NewField(FieldChatOptions, []byte{0x00, 0x01}),
                                         },
                                 },
                         },
                         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: [2]byte{0, 1},
+                                       Flags:    0x00,
+                                       IsReply:  0x00,
+                                       Type:     [2]byte{0, 0x6a},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldData, []byte("\r*** Testy McTest performed action")),
+                                               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: [2]byte{0, 2},
+                                       Flags:    0x00,
+                                       IsReply:  0x00,
+                                       Type:     [2]byte{0, 0x6a},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldData, []byte("\r*** Testy McTest performed action")),
+                                               NewField(FieldData, []byte("\r*** Testy McTest performed action")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: false,
                 },
                 {
                 },
                 {
-                       name: "does not send chat msg as emote if fieldChatOptions is set to 0",
+                       name: "does not send chat msg as emote if FieldChatOptions is set to 0",
                         args: args{
                                 cc: &ClientConn{
                                         Account: &Account{
                         args: args{
                                 cc: &ClientConn{
                                         Account: &Account{
@@ -524,54 +456,45 @@ func TestHandleChatSend(t *testing.T) {
                                         },
                                         UserName: []byte("Testy McTest"),
                                         Server: &Server{
                                         },
                                         UserName: []byte("Testy McTest"),
                                         Server: &Server{
-                                               Clients: map[uint16]*ClientConn{
-                                                       uint16(1): {
+                                               Clients: map[[2]byte]*ClientConn{
+                                                       [2]byte{0, 1}: {
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
-                                                               ID: &[]byte{0, 1},
+                                                               ID: [2]byte{0, 1},
                                                         },
                                                         },
-                                                       uint16(2): {
+                                                       [2]byte{0, 2}: {
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
-                                                               ID: &[]byte{0, 2},
+                                                               ID: [2]byte{0, 2},
                                                         },
                                                 },
                                         },
                                 },
                                                         },
                                                 },
                                         },
                                 },
-                               t: &Transaction{
+                               t: Transaction{
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldData, []byte("hello")),
-                                               NewField(fieldChatOptions, []byte{0x00, 0x00}),
+                                               NewField(FieldData, []byte("hello")),
+                                               NewField(FieldChatOptions, []byte{0x00, 0x00}),
                                         },
                                 },
                         },
                         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: [2]byte{0, 1},
+                                       Type:     [2]byte{0, 0x6a},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldData, []byte("\r Testy McTest:  hello")),
+                                               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: [2]byte{0, 2},
+                                       Type:     [2]byte{0, 0x6a},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldData, []byte("\r Testy McTest:  hello")),
+                                               NewField(FieldData, []byte("\r Testy McTest:  hello")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: false,
                 },
                 {
                         name: "only sends chat msg to clients with accessReadChat permission",
                 },
                 {
                         name: "only sends chat msg to clients with accessReadChat permission",
@@ -586,45 +509,40 @@ func TestHandleChatSend(t *testing.T) {
                                         },
                                         UserName: []byte{0x00, 0x01},
                                         Server: &Server{
                                         },
                                         UserName: []byte{0x00, 0x01},
                                         Server: &Server{
-                                               Clients: map[uint16]*ClientConn{
-                                                       uint16(1): {
+                                               Clients: map[[2]byte]*ClientConn{
+                                                       [2]byte{0, 1}: {
                                                                 Account: &Account{
                                                                         Access: func() accessBitmap {
                                                                                 var bits accessBitmap
                                                                                 bits.Set(accessReadChat)
                                                                                 return bits
                                                                         }()},
                                                                 Account: &Account{
                                                                         Access: func() accessBitmap {
                                                                                 var bits accessBitmap
                                                                                 bits.Set(accessReadChat)
                                                                                 return bits
                                                                         }()},
-                                                               ID: &[]byte{0, 1},
+                                                               ID: [2]byte{0, 1},
                                                         },
                                                         },
-                                                       uint16(2): {
+                                                       [2]byte{0, 2}: {
                                                                 Account: &Account{
                                                                         Access: accessBitmap{0, 0, 0, 0, 0, 0, 0, 0},
                                                                 },
                                                                 Account: &Account{
                                                                         Access: accessBitmap{0, 0, 0, 0, 0, 0, 0, 0},
                                                                 },
-                                                               ID: &[]byte{0, 2},
+                                                               ID: [2]byte{0, 2},
                                                         },
                                                 },
                                         },
                                 },
                                                         },
                                                 },
                                         },
                                 },
-                               t: &Transaction{
+                               t: Transaction{
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldData, []byte("hai")),
+                                               NewField(FieldData, []byte("hai")),
                                         },
                                 },
                         },
                         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: [2]byte{0, 1},
+                                       Type:     [2]byte{0, 0x6a},
                                         Fields: []Field{
                                         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}),
+                                               NewField(FieldData, []byte{0x0d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x01, 0x3a, 0x20, 0x20, 0x68, 0x61, 0x69}),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: false,
                 },
                 {
                         name: "only sends private chat msg to members of private chat",
                 },
                 {
                         name: "only sends private chat msg to members of private chat",
@@ -639,107 +557,90 @@ func TestHandleChatSend(t *testing.T) {
                                         },
                                         UserName: []byte{0x00, 0x01},
                                         Server: &Server{
                                         },
                                         UserName: []byte{0x00, 0x01},
                                         Server: &Server{
-                                               PrivateChats: map[uint32]*PrivateChat{
-                                                       uint32(1): {
-                                                               ClientConn: map[uint16]*ClientConn{
-                                                                       uint16(1): {
-                                                                               ID: &[]byte{0, 1},
+                                               PrivateChats: map[[4]byte]*PrivateChat{
+                                                       [4]byte{0, 0, 0, 1}: {
+                                                               ClientConn: map[[2]byte]*ClientConn{
+                                                                       [2]byte{0, 1}: {
+                                                                               ID: [2]byte{0, 1},
                                                                         },
                                                                         },
-                                                                       uint16(2): {
-                                                                               ID: &[]byte{0, 2},
+                                                                       [2]byte{0, 2}: {
+                                                                               ID: [2]byte{0, 2},
                                                                         },
                                                                 },
                                                         },
                                                 },
                                                                         },
                                                                 },
                                                         },
                                                 },
-                                               Clients: map[uint16]*ClientConn{
-                                                       uint16(1): {
+                                               Clients: map[[2]byte]*ClientConn{
+                                                       [2]byte{0, 1}: {
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
                                                                 Account: &Account{
                                                                         Access: accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
                                                                 },
-                                                               ID: &[]byte{0, 1},
+                                                               ID: [2]byte{0, 1},
                                                         },
                                                         },
-                                                       uint16(2): {
+                                                       [2]byte{0, 2}: {
                                                                 Account: &Account{
                                                                         Access: accessBitmap{0, 0, 0, 0, 0, 0, 0, 0},
                                                                 },
                                                                 Account: &Account{
                                                                         Access: accessBitmap{0, 0, 0, 0, 0, 0, 0, 0},
                                                                 },
-                                                               ID: &[]byte{0, 2},
+                                                               ID: [2]byte{0, 2},
                                                         },
                                                         },
-                                                       uint16(3): {
+                                                       [2]byte{0, 3}: {
                                                                 Account: &Account{
                                                                         Access: accessBitmap{0, 0, 0, 0, 0, 0, 0, 0},
                                                                 },
                                                                 Account: &Account{
                                                                         Access: accessBitmap{0, 0, 0, 0, 0, 0, 0, 0},
                                                                 },
-                                                               ID: &[]byte{0, 3},
+                                                               ID: [2]byte{0, 3},
                                                         },
                                                 },
                                         },
                                 },
                                                         },
                                                 },
                                         },
                                 },
-                               t: &Transaction{
+                               t: Transaction{
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldData, []byte("hai")),
-                                               NewField(fieldChatID, []byte{0, 0, 0, 1}),
+                                               NewField(FieldData, []byte("hai")),
+                                               NewField(FieldChatID, []byte{0, 0, 0, 1}),
                                         },
                                 },
                         },
                         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: [2]byte{0, 1},
+                                       Type:     [2]byte{0, 0x6a},
                                         Fields: []Field{
                                         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}),
+                                               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: [2]byte{0, 2},
+                                       Type:     [2]byte{0, 0x6a},
                                         Fields: []Field{
                                         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}),
+                                               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}),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: false,
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-                       got, err := HandleChatSend(tt.args.cc, tt.args.t)
-
-                       if (err != nil) != tt.wantErr {
-                               t.Errorf("HandleChatSend() error = %v, wantErr %v", err, tt.wantErr)
-                               return
-                       }
+                       got := HandleChatSend(tt.args.cc, &tt.args.t)
                         tranAssertEqual(t, tt.want, got)
                 })
         }
  }
  
  func TestHandleGetFileInfo(t *testing.T) {
                         tranAssertEqual(t, tt.want, got)
                 })
         }
  }
  
  func TestHandleGetFileInfo(t *testing.T) {
-       rand.Seed(1) // reset seed between tests to make transaction IDs predictable
-
         type args struct {
                 cc *ClientConn
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
-               wantErr bool
         }{
                 {
                         name: "returns expected fields when a valid file is requested",
                         args: args{
                                 cc: &ClientConn{
         }{
                 {
                         name: "returns expected fields when a valid file is requested",
                         args: args{
                                 cc: &ClientConn{
-                                       ID: &[]byte{0x00, 0x01},
+                                       ID: [2]byte{0x00, 0x01},
                                         Server: &Server{
                                                 FS: &OSFileStore{},
                                                 Config: &Config{
                                         Server: &Server{
                                                 FS: &OSFileStore{},
                                                 Config: &Config{
@@ -751,49 +652,39 @@ func TestHandleGetFileInfo(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranGetFileInfo, nil,
-                                       NewField(fieldFileName, []byte("testfile.txt")),
-                                       NewField(fieldFilePath, []byte{0x00, 0x00}),
+                                       TranGetFileInfo, [2]byte{},
+                                       NewField(FieldFileName, []byte("testfile.txt")),
+                                       NewField(FieldFilePath, []byte{0x00, 0x00}),
                                 ),
                         },
                         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: [2]byte{0, 1},
+                                       IsReply:  0x01,
+                                       Type:     [2]byte{0, 0},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldFileName, []byte("testfile.txt")),
-                                               NewField(fieldFileTypeString, []byte("Text File")),
-                                               NewField(fieldFileCreatorString, []byte("ttxt")),
-                                               NewField(fieldFileComment, []byte{}),
-                                               NewField(fieldFileType, []byte("TEXT")),
-                                               NewField(fieldFileCreateDate, make([]byte, 8)),
-                                               NewField(fieldFileModifyDate, make([]byte, 8)),
-                                               NewField(fieldFileSize, []byte{0x0, 0x0, 0x0, 0x17}),
+                                               NewField(FieldFileName, []byte("testfile.txt")),
+                                               NewField(FieldFileTypeString, []byte("Text File")),
+                                               NewField(FieldFileCreatorString, []byte("ttxt")),
+                                               NewField(FieldFileType, []byte("TEXT")),
+                                               NewField(FieldFileCreateDate, make([]byte, 8)),
+                                               NewField(FieldFileModifyDate, make([]byte, 8)),
+                                               NewField(FieldFileSize, []byte{0x0, 0x0, 0x0, 0x17}),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: false,
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-                       rand.Seed(1) // reset seed between tests to make transaction IDs predictable
-
-                       gotRes, err := HandleGetFileInfo(tt.args.cc, tt.args.t)
-                       if (err != nil) != tt.wantErr {
-                               t.Errorf("HandleGetFileInfo() error = %v, wantErr %v", err, tt.wantErr)
-                               return
-                       }
+                       gotRes := HandleGetFileInfo(tt.args.cc, &tt.args.t)
  
  
-                       // Clear the fileWrapper timestamp fields to work around problems running the tests in multiple timezones
+                       // Clear the file timestamp fields to work around problems running the tests in multiple timezones
                         // TODO: revisit how to test this by mocking the stat calls
                         // TODO: revisit how to test this by mocking the stat calls
+                       gotRes[0].Fields[4].Data = make([]byte, 8)
                         gotRes[0].Fields[5].Data = make([]byte, 8)
                         gotRes[0].Fields[5].Data = make([]byte, 8)
-                       gotRes[0].Fields[6].Data = make([]byte, 8)
-                       if !assert.Equal(t, tt.wantRes, gotRes) {
+
+                       if !tranAssertEqual(t, tt.wantRes, gotRes) {
                                 t.Errorf("HandleGetFileInfo() gotRes = %v, want %v", gotRes, tt.wantRes)
                         }
                 })
                                 t.Errorf("HandleGetFileInfo() gotRes = %v, want %v", gotRes, tt.wantRes)
                         }
                 })
@@ -803,13 +694,12 @@ func TestHandleGetFileInfo(t *testing.T) {
  func TestHandleNewFolder(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleNewFolder(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
-               wantErr bool
         }{
                 {
                         name: "without required permission",
         }{
                 {
                         name: "without required permission",
@@ -823,23 +713,19 @@ func TestHandleNewFolder(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       accessCreateFolder,
-                                       &[]byte{0, 0},
+                                       TranNewFolder,
+                                       [2]byte{0, 0},
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
-                                       Flags:     0x00,
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("You are not allowed to create folders.")),
+                                               NewField(FieldError, []byte("You are not allowed to create folders.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: false,
                 },
                 {
                         name: "when path is nested",
                 },
                 {
                         name: "when path is nested",
@@ -852,7 +738,7 @@ func TestHandleNewFolder(t *testing.T) {
                                                         return bits
                                                 }(),
                                         },
                                                         return bits
                                                 }(),
                                         },
-                                       ID: &[]byte{0, 1},
+                                       ID: [2]byte{0, 1},
                                         Server: &Server{
                                                 Config: &Config{
                                                         FileRoot: "/Files/",
                                         Server: &Server{
                                                 Config: &Config{
                                                         FileRoot: "/Files/",
@@ -866,9 +752,9 @@ func TestHandleNewFolder(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranNewFolder, &[]byte{0, 1},
-                                       NewField(fieldFileName, []byte("testFolder")),
-                                       NewField(fieldFilePath, []byte{
+                                       TranNewFolder, [2]byte{0, 1},
+                                       NewField(FieldFileName, []byte("testFolder")),
+                                       NewField(FieldFilePath, []byte{
                                                 0x00, 0x01,
                                                 0x00, 0x00,
                                                 0x03,
                                                 0x00, 0x01,
                                                 0x00, 0x00,
                                                 0x03,
@@ -878,15 +764,10 @@ 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: [2]byte{0, 1},
+                                       IsReply:  0x01,
                                 },
                         },
                                 },
                         },
-                       wantErr: false,
                 },
                 {
                         name: "when path is not nested",
                 },
                 {
                         name: "when path is not nested",
@@ -899,7 +780,7 @@ func TestHandleNewFolder(t *testing.T) {
                                                         return bits
                                                 }(),
                                         },
                                                         return bits
                                                 }(),
                                         },
-                                       ID: &[]byte{0, 1},
+                                       ID: [2]byte{0, 1},
                                         Server: &Server{
                                                 Config: &Config{
                                                         FileRoot: "/Files",
                                         Server: &Server{
                                                 Config: &Config{
                                                         FileRoot: "/Files",
@@ -913,21 +794,16 @@ func TestHandleNewFolder(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranNewFolder, &[]byte{0, 1},
-                                       NewField(fieldFileName, []byte("testFolder")),
+                                       TranNewFolder, [2]byte{0, 1},
+                                       NewField(FieldFileName, []byte("testFolder")),
                                 ),
                         },
                         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: [2]byte{0, 1},
+                                       IsReply:  0x01,
                                 },
                         },
                                 },
                         },
-                       wantErr: false,
                 },
                 {
                         name: "when Write returns an err",
                 },
                 {
                         name: "when Write returns an err",
@@ -940,7 +816,7 @@ func TestHandleNewFolder(t *testing.T) {
                                                         return bits
                                                 }(),
                                         },
                                                         return bits
                                                 }(),
                                         },
-                                       ID: &[]byte{0, 1},
+                                       ID: [2]byte{0, 1},
                                         Server: &Server{
                                                 Config: &Config{
                                                         FileRoot: "/Files/",
                                         Server: &Server{
                                                 Config: &Config{
                                                         FileRoot: "/Files/",
@@ -954,18 +830,17 @@ func TestHandleNewFolder(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranNewFolder, &[]byte{0, 1},
-                                       NewField(fieldFileName, []byte("testFolder")),
-                                       NewField(fieldFilePath, []byte{
+                                       TranNewFolder, [2]byte{0, 1},
+                                       NewField(FieldFileName, []byte("testFolder")),
+                                       NewField(FieldFilePath, []byte{
                                                 0x00,
                                         }),
                                 ),
                         },
                         wantRes: []Transaction{},
                                                 0x00,
                                         }),
                                 ),
                         },
                         wantRes: []Transaction{},
-                       wantErr: true,
                 },
                 {
                 },
                 {
-                       name: "fieldFileName does not allow directory traversal",
+                       name: "FieldFileName does not allow directory traversal",
                         args: args{
                                 cc: &ClientConn{
                                         Account: &Account{
                         args: args{
                                 cc: &ClientConn{
                                         Account: &Account{
@@ -975,7 +850,7 @@ func TestHandleNewFolder(t *testing.T) {
                                                         return bits
                                                 }(),
                                         },
                                                         return bits
                                                 }(),
                                         },
-                                       ID: &[]byte{0, 1},
+                                       ID: [2]byte{0, 1},
                                         Server: &Server{
                                                 Config: &Config{
                                                         FileRoot: "/Files/",
                                         Server: &Server{
                                                 Config: &Config{
                                                         FileRoot: "/Files/",
@@ -989,23 +864,19 @@ func TestHandleNewFolder(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranNewFolder, &[]byte{0, 1},
-                                       NewField(fieldFileName, []byte("../../testFolder")),
+                                       TranNewFolder, [2]byte{0, 1},
+                                       NewField(FieldFileName, []byte("../../testFolder")),
                                 ),
                         },
                         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: [2]byte{0, 1},
+                                       IsReply:  0x01,
                                 },
                                 },
-                       }, wantErr: false,
+                       },
                 },
                 {
                 },
                 {
-                       name: "fieldFilePath does not allow directory traversal",
+                       name: "FieldFilePath does not allow directory traversal",
                         args: args{
                                 cc: &ClientConn{
                                         Account: &Account{
                         args: args{
                                 cc: &ClientConn{
                                         Account: &Account{
@@ -1015,7 +886,7 @@ func TestHandleNewFolder(t *testing.T) {
                                                         return bits
                                                 }(),
                                         },
                                                         return bits
                                                 }(),
                                         },
-                                       ID: &[]byte{0, 1},
+                                       ID: [2]byte{0, 1},
                                         Server: &Server{
                                                 Config: &Config{
                                                         FileRoot: "/Files/",
                                         Server: &Server{
                                                 Config: &Config{
                                                         FileRoot: "/Files/",
@@ -1029,9 +900,9 @@ func TestHandleNewFolder(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranNewFolder, &[]byte{0, 1},
-                                       NewField(fieldFileName, []byte("testFolder")),
-                                       NewField(fieldFilePath, []byte{
+                                       TranNewFolder, [2]byte{0, 1},
+                                       NewField(FieldFileName, []byte("testFolder")),
+                                       NewField(FieldFilePath, []byte{
                                                 0x00, 0x02,
                                                 0x00, 0x00,
                                                 0x03,
                                                 0x00, 0x02,
                                                 0x00, 0x00,
                                                 0x03,
@@ -1044,24 +915,15 @@ 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: [2]byte{0, 1},
+                                       IsReply:  0x01,
                                 },
                                 },
-                       }, wantErr: false,
+                       },
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-
-                       gotRes, err := HandleNewFolder(tt.args.cc, tt.args.t)
-                       if (err != nil) != tt.wantErr {
-                               t.Errorf("HandleNewFolder() error = %v, wantErr %v", err, tt.wantErr)
-                               return
-                       }
+                       gotRes := HandleNewFolder(tt.args.cc, &tt.args.t)
  
                         if !tranAssertEqual(t, tt.wantRes, gotRes) {
                                 t.Errorf("HandleNewFolder() gotRes = %v, want %v", gotRes, tt.wantRes)
  
                         if !tranAssertEqual(t, tt.wantRes, gotRes) {
                                 t.Errorf("HandleNewFolder() gotRes = %v, want %v", gotRes, tt.wantRes)
@@ -1073,13 +935,12 @@ func TestHandleNewFolder(t *testing.T) {
  func TestHandleUploadFile(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleUploadFile(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
-               wantErr bool
         }{
                 {
                         name: "when request is valid and user has Upload Anywhere permission",
         }{
                 {
                         name: "when request is valid and user has Upload Anywhere permission",
@@ -1104,9 +965,9 @@ func TestHandleUploadFile(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranUploadFile, &[]byte{0, 1},
-                                       NewField(fieldFileName, []byte("testFile")),
-                                       NewField(fieldFilePath, []byte{
+                                       TranUploadFile, [2]byte{0, 1},
+                                       NewField(FieldFileName, []byte("testFile")),
+                                       NewField(FieldFilePath, []byte{
                                                 0x00, 0x01,
                                                 0x00, 0x00,
                                                 0x03,
                                                 0x00, 0x01,
                                                 0x00, 0x00,
                                                 0x03,
@@ -1116,17 +977,12 @@ 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{
                                         Fields: []Field{
-                                               NewField(fieldRefNum, []byte{0x52, 0xfd, 0xfc, 0x07}), // rand.Seed(1)
+                                               NewField(FieldRefNum, []byte{0x52, 0xfd, 0xfc, 0x07}), // rand.Seed(1)
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: false,
                 },
                 {
                         name: "when user does not have required access",
                 },
                 {
                         name: "when user does not have required access",
@@ -1140,9 +996,9 @@ func TestHandleUploadFile(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranUploadFile, &[]byte{0, 1},
-                                       NewField(fieldFileName, []byte("testFile")),
-                                       NewField(fieldFilePath, []byte{
+                                       TranUploadFile, [2]byte{0, 1},
+                                       NewField(FieldFileName, []byte("testFile")),
+                                       NewField(FieldFilePath, []byte{
                                                 0x00, 0x01,
                                                 0x00, 0x00,
                                                 0x03,
                                                 0x00, 0x01,
                                                 0x00, 0x00,
                                                 0x03,
@@ -1152,30 +1008,19 @@ func TestHandleUploadFile(t *testing.T) {
                         },
                         wantRes: []Transaction{
                                 {
                         },
                         wantRes: []Transaction{
                                 {
-                                       Flags:     0x00,
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("You are not allowed to upload files.")), // rand.Seed(1)
+                                               NewField(FieldError, []byte("You are not allowed to upload files.")), // rand.Seed(1)
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: false,
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-                       rand.Seed(1)
-                       gotRes, err := HandleUploadFile(tt.args.cc, tt.args.t)
-                       if (err != nil) != tt.wantErr {
-                               t.Errorf("HandleUploadFile() error = %v, wantErr %v", err, tt.wantErr)
-                               return
-                       }
-
+                       gotRes := HandleUploadFile(tt.args.cc, &tt.args.t)
                         tranAssertEqual(t, tt.wantRes, gotRes)
                         tranAssertEqual(t, tt.wantRes, gotRes)
-
                 })
         }
  }
                 })
         }
  }
@@ -1183,13 +1028,12 @@ func TestHandleUploadFile(t *testing.T) {
  func TestHandleMakeAlias(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleMakeAlias(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
-               wantErr bool
         }{
                 {
                         name: "with valid input and required permissions",
         }{
                 {
                         name: "with valid input and required permissions",
@@ -1224,23 +1068,18 @@ func TestHandleMakeAlias(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranMakeFileAlias, &[]byte{0, 1},
-                                       NewField(fieldFileName, []byte("testFile")),
-                                       NewField(fieldFilePath, EncodeFilePath(strings.Join([]string{"foo"}, "/"))),
-                                       NewField(fieldFileNewPath, EncodeFilePath(strings.Join([]string{"bar"}, "/"))),
+                                       TranMakeFileAlias, [2]byte{0, 1},
+                                       NewField(FieldFileName, []byte("testFile")),
+                                       NewField(FieldFilePath, EncodeFilePath(strings.Join([]string{"foo"}, "/"))),
+                                       NewField(FieldFileNewPath, EncodeFilePath(strings.Join([]string{"bar"}, "/"))),
                                 ),
                         },
                         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,
                 },
                 {
                         name: "when symlink returns an error",
                 },
                 {
                         name: "when symlink returns an error",
@@ -1275,25 +1114,21 @@ func TestHandleMakeAlias(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranMakeFileAlias, &[]byte{0, 1},
-                                       NewField(fieldFileName, []byte("testFile")),
-                                       NewField(fieldFilePath, EncodeFilePath(strings.Join([]string{"foo"}, "/"))),
-                                       NewField(fieldFileNewPath, EncodeFilePath(strings.Join([]string{"bar"}, "/"))),
+                                       TranMakeFileAlias, [2]byte{0, 1},
+                                       NewField(FieldFileName, []byte("testFile")),
+                                       NewField(FieldFilePath, EncodeFilePath(strings.Join([]string{"foo"}, "/"))),
+                                       NewField(FieldFileNewPath, EncodeFilePath(strings.Join([]string{"bar"}, "/"))),
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
-                                       Flags:     0x00,
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("Error creating alias")),
+                                               NewField(FieldError, []byte("Error creating alias")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: false,
                 },
                 {
                         name: "when user does not have required permission",
                 },
                 {
                         name: "when user does not have required permission",
@@ -1316,15 +1151,15 @@ func TestHandleMakeAlias(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranMakeFileAlias, &[]byte{0, 1},
-                                       NewField(fieldFileName, []byte("testFile")),
-                                       NewField(fieldFilePath, []byte{
+                                       TranMakeFileAlias, [2]byte{0, 1},
+                                       NewField(FieldFileName, []byte("testFile")),
+                                       NewField(FieldFilePath, []byte{
                                                 0x00, 0x01,
                                                 0x00, 0x00,
                                                 0x03,
                                                 0x2e, 0x2e, 0x2e,
                                         }),
                                                 0x00, 0x01,
                                                 0x00, 0x00,
                                                 0x03,
                                                 0x2e, 0x2e, 0x2e,
                                         }),
-                                       NewField(fieldFileNewPath, []byte{
+                                       NewField(FieldFileNewPath, []byte{
                                                 0x00, 0x01,
                                                 0x00, 0x00,
                                                 0x03,
                                                 0x00, 0x01,
                                                 0x00, 0x00,
                                                 0x03,
@@ -1334,27 +1169,18 @@ func TestHandleMakeAlias(t *testing.T) {
                         },
                         wantRes: []Transaction{
                                 {
                         },
                         wantRes: []Transaction{
                                 {
-                                       Flags:     0x00,
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("You are not allowed to make aliases.")),
+                                               NewField(FieldError, []byte("You are not allowed to make aliases.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: false,
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-                       gotRes, err := HandleMakeAlias(tt.args.cc, tt.args.t)
-                       if (err != nil) != tt.wantErr {
-                               t.Errorf("HandleMakeAlias(%v, %v)", tt.args.cc, tt.args.t)
-                               return
-                       }
-
+                       gotRes := HandleMakeAlias(tt.args.cc, &tt.args.t)
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
@@ -1363,13 +1189,12 @@ func TestHandleMakeAlias(t *testing.T) {
  func TestHandleGetUser(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleGetUser(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
-               wantErr assert.ErrorAssertionFunc
         }{
                 {
                         name: "when account is valid",
         }{
                 {
                         name: "when account is valid",
@@ -1394,26 +1219,21 @@ func TestHandleGetUser(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranGetUser, &[]byte{0, 1},
-                                       NewField(fieldUserLogin, []byte("guest")),
+                                       TranGetUser, [2]byte{0, 1},
+                                       NewField(FieldUserLogin, []byte("guest")),
                                 ),
                         },
                         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{
                                         Fields: []Field{
-                                               NewField(fieldUserName, []byte("Guest")),
-                                               NewField(fieldUserLogin, negateString([]byte("guest"))),
-                                               NewField(fieldUserPassword, []byte("password")),
-                                               NewField(fieldUserAccess, []byte{0, 0, 0, 0, 0, 0, 0, 0}),
+                                               NewField(FieldUserName, []byte("Guest")),
+                                               NewField(FieldUserLogin, encodeString([]byte("guest"))),
+                                               NewField(FieldUserPassword, []byte("password")),
+                                               NewField(FieldUserAccess, []byte{0, 0, 0, 0, 0, 0, 0, 0}),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
                 {
                         name: "when user does not have required permission",
                 },
                 {
                         name: "when user does not have required permission",
@@ -1430,23 +1250,19 @@ func TestHandleGetUser(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranGetUser, &[]byte{0, 1},
-                                       NewField(fieldUserLogin, []byte("nonExistentUser")),
+                                       TranGetUser, [2]byte{0, 1},
+                                       NewField(FieldUserLogin, []byte("nonExistentUser")),
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
-                                       Flags:     0x00,
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("You are not allowed to view accounts.")),
+                                               NewField(FieldError, []byte("You are not allowed to view accounts.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
                 {
                         name: "when account does not exist",
                 },
                 {
                         name: "when account does not exist",
@@ -1464,32 +1280,26 @@ func TestHandleGetUser(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranGetUser, &[]byte{0, 1},
-                                       NewField(fieldUserLogin, []byte("nonExistentUser")),
+                                       TranGetUser, [2]byte{0, 1},
+                                       NewField(FieldUserLogin, []byte("nonExistentUser")),
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
                                         Flags:     0x00,
                                         IsReply:   0x01,
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
                                         Flags:     0x00,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       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{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("Account does not exist.")),
+                                               NewField(FieldError, []byte("Account does not exist.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-                       gotRes, err := HandleGetUser(tt.args.cc, tt.args.t)
-                       if !tt.wantErr(t, err, fmt.Sprintf("HandleGetUser(%v, %v)", tt.args.cc, tt.args.t)) {
-                               return
-                       }
-
+                       gotRes := HandleGetUser(tt.args.cc, &tt.args.t)
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
@@ -1498,13 +1308,12 @@ func TestHandleGetUser(t *testing.T) {
  func TestHandleDeleteUser(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleDeleteUser(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
-               wantErr assert.ErrorAssertionFunc
         }{
                 {
                         name: "when user dataFile",
         }{
                 {
                         name: "when user dataFile",
@@ -1534,21 +1343,18 @@ func TestHandleDeleteUser(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranDeleteUser, &[]byte{0, 1},
-                                       NewField(fieldUserLogin, negateString([]byte("testuser"))),
+                                       TranDeleteUser, [2]byte{0, 1},
+                                       NewField(FieldUserLogin, encodeString([]byte("testuser"))),
                                 ),
                         },
                         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,
                 },
                 {
                         name: "when user does not have required permission",
                 },
                 {
                         name: "when user does not have required permission",
@@ -1565,32 +1371,24 @@ func TestHandleDeleteUser(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranDeleteUser, &[]byte{0, 1},
-                                       NewField(fieldUserLogin, negateString([]byte("testuser"))),
+                                       TranDeleteUser, [2]byte{0, 1},
+                                       NewField(FieldUserLogin, encodeString([]byte("testuser"))),
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
-                                       Flags:     0x00,
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("You are not allowed to delete accounts.")),
+                                               NewField(FieldError, []byte("You are not allowed to delete accounts.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-                       gotRes, err := HandleDeleteUser(tt.args.cc, tt.args.t)
-                       if !tt.wantErr(t, err, fmt.Sprintf("HandleDeleteUser(%v, %v)", tt.args.cc, tt.args.t)) {
-                               return
-                       }
-
+                       gotRes := HandleDeleteUser(tt.args.cc, &tt.args.t)
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
@@ -1599,13 +1397,12 @@ func TestHandleDeleteUser(t *testing.T) {
  func TestHandleGetMsgs(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleGetMsgs(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
-               wantErr assert.ErrorAssertionFunc
         }{
                 {
                         name: "returns news data",
         }{
                 {
                         name: "returns news data",
@@ -1623,22 +1420,17 @@ func TestHandleGetMsgs(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranGetMsgs, &[]byte{0, 1},
+                                       TranGetMsgs, [2]byte{0, 1},
                                 ),
                         },
                         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{
                                         Fields: []Field{
-                                               NewField(fieldData, []byte("TEST")),
+                                               NewField(FieldData, []byte("TEST")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
                 {
                         name: "when user does not have required permission",
                 },
                 {
                         name: "when user does not have required permission",
@@ -1655,31 +1447,23 @@ func TestHandleGetMsgs(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranGetMsgs, &[]byte{0, 1},
+                                       TranGetMsgs, [2]byte{0, 1},
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
-                                       Flags:     0x00,
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("You are not allowed to read news.")),
+                                               NewField(FieldError, []byte("You are not allowed to read news.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-                       gotRes, err := HandleGetMsgs(tt.args.cc, tt.args.t)
-                       if !tt.wantErr(t, err, fmt.Sprintf("HandleGetMsgs(%v, %v)", tt.args.cc, tt.args.t)) {
-                               return
-                       }
-
+                       gotRes := HandleGetMsgs(tt.args.cc, &tt.args.t)
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
@@ -1688,13 +1472,12 @@ func TestHandleGetMsgs(t *testing.T) {
  func TestHandleNewUser(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleNewUser(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
-               wantErr assert.ErrorAssertionFunc
         }{
                 {
                         name: "when user does not have required permission",
         }{
                 {
                         name: "when user does not have required permission",
@@ -1711,22 +1494,18 @@ func TestHandleNewUser(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranNewUser, &[]byte{0, 1},
+                                       TranNewUser, [2]byte{0, 1},
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
-                                       Flags:     0x00,
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("You are not allowed to create new accounts.")),
+                                               NewField(FieldError, []byte("You are not allowed to create new accounts.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
                 {
                         name: "when user attempts to create account with greater access",
                 },
                 {
                         name: "when user attempts to create account with greater access",
@@ -1744,10 +1523,10 @@ func TestHandleNewUser(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranNewUser, &[]byte{0, 1},
-                                       NewField(fieldUserLogin, []byte("userB")),
+                                       TranNewUser, [2]byte{0, 1},
+                                       NewField(FieldUserLogin, []byte("userB")),
                                         NewField(
                                         NewField(
-                                               fieldUserAccess,
+                                               FieldUserAccess,
                                                 func() []byte {
                                                         var bits accessBitmap
                                                         bits.Set(accessDisconUser)
                                                 func() []byte {
                                                         var bits accessBitmap
                                                         bits.Set(accessDisconUser)
@@ -1758,26 +1537,18 @@ func TestHandleNewUser(t *testing.T) {
                         },
                         wantRes: []Transaction{
                                 {
                         },
                         wantRes: []Transaction{
                                 {
-                                       Flags:     0x00,
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("Cannot create account with more access than yourself.")),
+                                               NewField(FieldError, []byte("Cannot create account with more access than yourself.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-                       gotRes, err := HandleNewUser(tt.args.cc, tt.args.t)
-                       if !tt.wantErr(t, err, fmt.Sprintf("HandleNewUser(%v, %v)", tt.args.cc, tt.args.t)) {
-                               return
-                       }
-
+                       gotRes := HandleNewUser(tt.args.cc, &tt.args.t)
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
@@ -1786,13 +1557,12 @@ func TestHandleNewUser(t *testing.T) {
  func TestHandleListUsers(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleListUsers(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
-               wantErr assert.ErrorAssertionFunc
         }{
                 {
                         name: "when user does not have required permission",
         }{
                 {
                         name: "when user does not have required permission",
@@ -1809,22 +1579,18 @@ func TestHandleListUsers(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranNewUser, &[]byte{0, 1},
+                                       TranNewUser, [2]byte{0, 1},
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
-                                       Flags:     0x00,
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("You are not allowed to view accounts.")),
+                                               NewField(FieldError, []byte("You are not allowed to view accounts.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
                 {
                         name: "when user has required permission",
                 },
                 {
                         name: "when user has required permission",
@@ -1849,19 +1615,15 @@ func TestHandleListUsers(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranGetClientInfoText, &[]byte{0, 1},
-                                       NewField(fieldUserID, []byte{0, 1}),
+                                       TranGetClientInfoText, [2]byte{0, 1},
+                                       NewField(FieldUserID, []byte{0, 1}),
                                 ),
                         },
                         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{
                                         Fields: []Field{
-                                               NewField(fieldData, []byte{
+                                               NewField(FieldData, []byte{
                                                         0x00, 0x04, 0x00, 0x66, 0x00, 0x05, 0x67, 0x75, 0x65, 0x73, 0x74, 0x00, 0x69, 0x00, 0x05, 0x98,
                                                         0x8a, 0x9a, 0x8c, 0x8b, 0x00, 0x6e, 0x00, 0x08, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
                                                         0x00, 0x6a, 0x00, 0x01, 0x78,
                                                         0x00, 0x04, 0x00, 0x66, 0x00, 0x05, 0x67, 0x75, 0x65, 0x73, 0x74, 0x00, 0x69, 0x00, 0x05, 0x98,
                                                         0x8a, 0x9a, 0x8c, 0x8b, 0x00, 0x6e, 0x00, 0x08, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
                                                         0x00, 0x6a, 0x00, 0x01, 0x78,
@@ -1869,15 +1631,11 @@ func TestHandleListUsers(t *testing.T) {
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-                       gotRes, err := HandleListUsers(tt.args.cc, tt.args.t)
-                       if !tt.wantErr(t, err, fmt.Sprintf("HandleListUsers(%v, %v)", tt.args.cc, tt.args.t)) {
-                               return
-                       }
+                       gotRes := HandleListUsers(tt.args.cc, &tt.args.t)
  
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
  
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
@@ -1887,13 +1645,12 @@ func TestHandleListUsers(t *testing.T) {
  func TestHandleDownloadFile(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleDownloadFile(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
-               wantErr assert.ErrorAssertionFunc
         }{
                 {
                         name: "when user does not have required permission",
         }{
                 {
                         name: "when user does not have required permission",
@@ -1907,21 +1664,17 @@ func TestHandleDownloadFile(t *testing.T) {
                                         },
                                         Server: &Server{},
                                 },
                                         },
                                         Server: &Server{},
                                 },
-                               t: NewTransaction(tranDownloadFile, &[]byte{0, 1}),
+                               t: NewTransaction(TranDownloadFile, [2]byte{0, 1}),
                         },
                         wantRes: []Transaction{
                                 {
                         },
                         wantRes: []Transaction{
                                 {
-                                       Flags:     0x00,
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("You are not allowed to download files.")),
+                                               NewField(FieldError, []byte("You are not allowed to download files.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
                 {
                         name: "with a valid file",
                 },
                 {
                         name: "with a valid file",
@@ -1947,28 +1700,23 @@ func TestHandleDownloadFile(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       accessDownloadFile,
-                                       &[]byte{0, 1},
-                                       NewField(fieldFileName, []byte("testfile.txt")),
-                                       NewField(fieldFilePath, []byte{0x0, 0x00}),
+                                       TranDownloadFile,
+                                       [2]byte{0, 1},
+                                       NewField(FieldFileName, []byte("testfile.txt")),
+                                       NewField(FieldFilePath, []byte{0x0, 0x00}),
                                 ),
                         },
                         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{
                                         Fields: []Field{
-                                               NewField(fieldRefNum, []byte{0x52, 0xfd, 0xfc, 0x07}),
-                                               NewField(fieldWaitingCount, []byte{0x00, 0x00}),
-                                               NewField(fieldTransferSize, []byte{0x00, 0x00, 0x00, 0xa5}),
-                                               NewField(fieldFileSize, []byte{0x00, 0x00, 0x00, 0x17}),
+                                               NewField(FieldRefNum, []byte{0x52, 0xfd, 0xfc, 0x07}),
+                                               NewField(FieldWaitingCount, []byte{0x00, 0x00}),
+                                               NewField(FieldTransferSize, []byte{0x00, 0x00, 0x00, 0xa5}),
+                                               NewField(FieldFileSize, []byte{0x00, 0x00, 0x00, 0x17}),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
                 {
                         name: "when client requests to resume 1k test file at offset 256",
                 },
                 {
                         name: "when client requests to resume 1k test file at offset 256",
@@ -2011,30 +1759,23 @@ func TestHandleDownloadFile(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       accessDownloadFile,
-                                       &[]byte{0, 1},
-                                       NewField(fieldFileName, []byte("testfile-1k")),
-                                       NewField(fieldFilePath, []byte{0x00, 0x00}),
+                                       TranDownloadFile,
+                                       [2]byte{0, 1},
+                                       NewField(FieldFileName, []byte("testfile-1k")),
+                                       NewField(FieldFilePath, []byte{0x00, 0x00}),
                                         NewField(
                                         NewField(
-                                               fieldFileResumeData,
+                                               FieldFileResumeData,
                                                 func() []byte {
                                                         frd := FileResumeData{
                                                 func() []byte {
                                                         frd := FileResumeData{
-                                                               Format:    [4]byte{},
-                                                               Version:   [2]byte{},
-                                                               RSVD:      [34]byte{},
                                                                 ForkCount: [2]byte{0, 2},
                                                                 ForkInfoList: []ForkInfoList{
                                                                         {
                                                                                 Fork:     [4]byte{0x44, 0x41, 0x54, 0x41}, // "DATA"
                                                                                 DataSize: [4]byte{0, 0, 0x01, 0x00},       // request offset 256
                                                                 ForkCount: [2]byte{0, 2},
                                                                 ForkInfoList: []ForkInfoList{
                                                                         {
                                                                                 Fork:     [4]byte{0x44, 0x41, 0x54, 0x41}, // "DATA"
                                                                                 DataSize: [4]byte{0, 0, 0x01, 0x00},       // request offset 256
-                                                                               RSVDA:    [4]byte{},
-                                                                               RSVDB:    [4]byte{},
                                                                         },
                                                                         {
                                                                                 Fork:     [4]byte{0x4d, 0x41, 0x43, 0x52}, // "MACR"
                                                                                 DataSize: [4]byte{0, 0, 0, 0},
                                                                         },
                                                                         {
                                                                                 Fork:     [4]byte{0x4d, 0x41, 0x43, 0x52}, // "MACR"
                                                                                 DataSize: [4]byte{0, 0, 0, 0},
-                                                                               RSVDA:    [4]byte{},
-                                                                               RSVDB:    [4]byte{},
                                                                         },
                                                                 },
                                                         }
                                                                         },
                                                                 },
                                                         }
@@ -2046,29 +1787,20 @@ 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{
                                         Fields: []Field{
-                                               NewField(fieldRefNum, []byte{0x52, 0xfd, 0xfc, 0x07}),
-                                               NewField(fieldWaitingCount, []byte{0x00, 0x00}),
-                                               NewField(fieldTransferSize, []byte{0x00, 0x00, 0x03, 0x8d}),
-                                               NewField(fieldFileSize, []byte{0x00, 0x00, 0x03, 0x00}),
+                                               NewField(FieldRefNum, []byte{0x52, 0xfd, 0xfc, 0x07}),
+                                               NewField(FieldWaitingCount, []byte{0x00, 0x00}),
+                                               NewField(FieldTransferSize, []byte{0x00, 0x00, 0x03, 0x8d}),
+                                               NewField(FieldFileSize, []byte{0x00, 0x00, 0x03, 0x00}),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-                       gotRes, err := HandleDownloadFile(tt.args.cc, tt.args.t)
-                       if !tt.wantErr(t, err, fmt.Sprintf("HandleDownloadFile(%v, %v)", tt.args.cc, tt.args.t)) {
-                               return
-                       }
-
+                       gotRes := HandleDownloadFile(tt.args.cc, &tt.args.t)
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
@@ -2077,13 +1809,12 @@ func TestHandleDownloadFile(t *testing.T) {
  func TestHandleUpdateUser(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleUpdateUser(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
-               wantErr assert.ErrorAssertionFunc
         }{
                 {
                         name: "when action is create user without required permission",
         }{
                 {
                         name: "when action is create user without required permission",
@@ -2101,24 +1832,24 @@ func TestHandleUpdateUser(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranUpdateUser,
-                                       &[]byte{0, 0},
-                                       NewField(fieldData, []byte{
+                                       TranUpdateUser,
+                                       [2]byte{0, 0},
+                                       NewField(FieldData, []byte{
                                                 0x00, 0x04, // field count
  
                                                 0x00, 0x04, // field count
  
-                                               0x00, 0x69, // fieldUserLogin = 105
+                                               0x00, 0x69, // FieldUserLogin = 105
                                                 0x00, 0x03,
                                                 0x9d, 0x9d, 0x9d,
  
                                                 0x00, 0x03,
                                                 0x9d, 0x9d, 0x9d,
  
-                                               0x00, 0x6a, // fieldUserPassword = 106
+                                               0x00, 0x6a, // FieldUserPassword = 106
                                                 0x00, 0x03,
                                                 0x9c, 0x9c, 0x9c,
  
                                                 0x00, 0x03,
                                                 0x9c, 0x9c, 0x9c,
  
-                                               0x00, 0x66, // fieldUserName = 102
+                                               0x00, 0x66, // FieldUserName = 102
                                                 0x00, 0x03,
                                                 0x61, 0x61, 0x61,
  
                                                 0x00, 0x03,
                                                 0x61, 0x61, 0x61,
  
-                                               0x00, 0x6e, // fieldUserAccess = 110
+                                               0x00, 0x6e, // FieldUserAccess = 110
                                                 0x00, 0x08,
                                                 0x60, 0x70, 0x0c, 0x20, 0x03, 0x80, 0x00, 0x00,
                                         }),
                                                 0x00, 0x08,
                                                 0x60, 0x70, 0x0c, 0x20, 0x03, 0x80, 0x00, 0x00,
                                         }),
@@ -2126,17 +1857,13 @@ func TestHandleUpdateUser(t *testing.T) {
                         },
                         wantRes: []Transaction{
                                 {
                         },
                         wantRes: []Transaction{
                                 {
-                                       Flags:     0x00,
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("You are not allowed to create new accounts.")),
+                                               NewField(FieldError, []byte("You are not allowed to create new accounts.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
                 {
                         name: "when action is modify user without required permission",
                 },
                 {
                         name: "when action is modify user without required permission",
@@ -2157,24 +1884,24 @@ func TestHandleUpdateUser(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranUpdateUser,
-                                       &[]byte{0, 0},
-                                       NewField(fieldData, []byte{
+                                       TranUpdateUser,
+                                       [2]byte{0, 0},
+                                       NewField(FieldData, []byte{
                                                 0x00, 0x04, // field count
  
                                                 0x00, 0x04, // field count
  
-                                               0x00, 0x69, // fieldUserLogin = 105
+                                               0x00, 0x69, // FieldUserLogin = 105
                                                 0x00, 0x03,
                                                 0x9d, 0x9d, 0x9d,
  
                                                 0x00, 0x03,
                                                 0x9d, 0x9d, 0x9d,
  
-                                               0x00, 0x6a, // fieldUserPassword = 106
+                                               0x00, 0x6a, // FieldUserPassword = 106
                                                 0x00, 0x03,
                                                 0x9c, 0x9c, 0x9c,
  
                                                 0x00, 0x03,
                                                 0x9c, 0x9c, 0x9c,
  
-                                               0x00, 0x66, // fieldUserName = 102
+                                               0x00, 0x66, // FieldUserName = 102
                                                 0x00, 0x03,
                                                 0x61, 0x61, 0x61,
  
                                                 0x00, 0x03,
                                                 0x61, 0x61, 0x61,
  
-                                               0x00, 0x6e, // fieldUserAccess = 110
+                                               0x00, 0x6e, // FieldUserAccess = 110
                                                 0x00, 0x08,
                                                 0x60, 0x70, 0x0c, 0x20, 0x03, 0x80, 0x00, 0x00,
                                         }),
                                                 0x00, 0x08,
                                                 0x60, 0x70, 0x0c, 0x20, 0x03, 0x80, 0x00, 0x00,
                                         }),
@@ -2182,17 +1909,13 @@ func TestHandleUpdateUser(t *testing.T) {
                         },
                         wantRes: []Transaction{
                                 {
                         },
                         wantRes: []Transaction{
                                 {
-                                       Flags:     0x00,
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("You are not allowed to modify accounts.")),
+                                               NewField(FieldError, []byte("You are not allowed to modify accounts.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
                 {
                         name: "when action is delete user without required permission",
                 },
                 {
                         name: "when action is delete user without required permission",
@@ -2212,9 +1935,9 @@ func TestHandleUpdateUser(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranUpdateUser,
-                                       &[]byte{0, 0},
-                                       NewField(fieldData, []byte{
+                                       TranUpdateUser,
+                                       [2]byte{0, 0},
+                                       NewField(FieldData, []byte{
                                                 0x00, 0x01,
                                                 0x00, 0x65,
                                                 0x00, 0x03,
                                                 0x00, 0x01,
                                                 0x00, 0x65,
                                                 0x00, 0x03,
@@ -2224,26 +1947,18 @@ func TestHandleUpdateUser(t *testing.T) {
                         },
                         wantRes: []Transaction{
                                 {
                         },
                         wantRes: []Transaction{
                                 {
-                                       Flags:     0x00,
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("You are not allowed to delete accounts.")),
+                                               NewField(FieldError, []byte("You are not allowed to delete accounts.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-                       gotRes, err := HandleUpdateUser(tt.args.cc, tt.args.t)
-                       if !tt.wantErr(t, err, fmt.Sprintf("HandleUpdateUser(%v, %v)", tt.args.cc, tt.args.t)) {
-                               return
-                       }
-
+                       gotRes := HandleUpdateUser(tt.args.cc, &tt.args.t)
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
@@ -2252,13 +1967,12 @@ func TestHandleUpdateUser(t *testing.T) {
  func TestHandleDelNewsArt(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleDelNewsArt(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
-               wantErr assert.ErrorAssertionFunc
         }{
                 {
                         name: "without required permission",
         }{
                 {
                         name: "without required permission",
@@ -2272,31 +1986,24 @@ func TestHandleDelNewsArt(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranDelNewsArt,
-                                       &[]byte{0, 0},
+                                       TranDelNewsArt,
+                                       [2]byte{0, 0},
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
-                                       Flags:     0x00,
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("You are not allowed to delete news articles.")),
+                                               NewField(FieldError, []byte("You are not allowed to delete news articles.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-                       gotRes, err := HandleDelNewsArt(tt.args.cc, tt.args.t)
-                       if !tt.wantErr(t, err, fmt.Sprintf("HandleDelNewsArt(%v, %v)", tt.args.cc, tt.args.t)) {
-                               return
-                       }
+                       gotRes := HandleDelNewsArt(tt.args.cc, &tt.args.t)
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
@@ -2305,13 +2012,12 @@ func TestHandleDelNewsArt(t *testing.T) {
  func TestHandleDisconnectUser(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleDisconnectUser(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
-               wantErr assert.ErrorAssertionFunc
         }{
                 {
                         name: "without required permission",
         }{
                 {
                         name: "without required permission",
@@ -2325,31 +2031,27 @@ func TestHandleDisconnectUser(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranDelNewsArt,
-                                       &[]byte{0, 0},
+                                       TranDelNewsArt,
+                                       [2]byte{0, 0},
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
-                                       Flags:     0x00,
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("You are not allowed to disconnect users.")),
+                                               NewField(FieldError, []byte("You are not allowed to disconnect users.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
                 {
                         name: "when target user has 'cannot be disconnected' priv",
                         args: args{
                                 cc: &ClientConn{
                                         Server: &Server{
                 },
                 {
                         name: "when target user has 'cannot be disconnected' priv",
                         args: args{
                                 cc: &ClientConn{
                                         Server: &Server{
-                                               Clients: map[uint16]*ClientConn{
-                                                       uint16(1): {
+                                               Clients: map[[2]byte]*ClientConn{
+                                                       [2]byte{0, 1}: {
                                                                 Account: &Account{
                                                                         Login: "unnamed",
                                                                         Access: func() accessBitmap {
                                                                 Account: &Account{
                                                                         Login: "unnamed",
                                                                         Access: func() accessBitmap {
@@ -2370,32 +2072,25 @@ func TestHandleDisconnectUser(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranDelNewsArt,
-                                       &[]byte{0, 0},
-                                       NewField(fieldUserID, []byte{0, 1}),
+                                       TranDelNewsArt,
+                                       [2]byte{0, 0},
+                                       NewField(FieldUserID, []byte{0, 1}),
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
-                                       Flags:     0x00,
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("unnamed is not allowed to be disconnected.")),
+                                               NewField(FieldError, []byte("unnamed is not allowed to be disconnected.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-                       gotRes, err := HandleDisconnectUser(tt.args.cc, tt.args.t)
-                       if !tt.wantErr(t, err, fmt.Sprintf("HandleDisconnectUser(%v, %v)", tt.args.cc, tt.args.t)) {
-                               return
-                       }
+                       gotRes := HandleDisconnectUser(tt.args.cc, &tt.args.t)
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
@@ -2404,13 +2099,12 @@ func TestHandleDisconnectUser(t *testing.T) {
  func TestHandleSendInstantMsg(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleSendInstantMsg(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
-               wantErr assert.ErrorAssertionFunc
         }{
                 {
                         name: "without required permission",
         }{
                 {
                         name: "without required permission",
@@ -2424,23 +2118,19 @@ func TestHandleSendInstantMsg(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranDelNewsArt,
-                                       &[]byte{0, 0},
+                                       TranDelNewsArt,
+                                       [2]byte{0, 0},
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
-                                       Flags:     0x00,
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("You are not allowed to send private messages.")),
+                                               NewField(FieldError, []byte("You are not allowed to send private messages.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
                 {
                         name: "when client 1 sends a message to client 2",
                 },
                 {
                         name: "when client 1 sends a message to client 2",
@@ -2453,44 +2143,39 @@ func TestHandleSendInstantMsg(t *testing.T) {
                                                         return bits
                                                 }(),
                                         },
                                                         return bits
                                                 }(),
                                         },
-                                       ID:       &[]byte{0, 1},
+                                       ID:       [2]byte{0, 1},
                                         UserName: []byte("User1"),
                                         Server: &Server{
                                         UserName: []byte("User1"),
                                         Server: &Server{
-                                               Clients: map[uint16]*ClientConn{
-                                                       uint16(2): {
+                                               Clients: map[[2]byte]*ClientConn{
+                                                       [2]byte{0, 2}: {
                                                                 AutoReply: []byte(nil),
                                                                 AutoReply: []byte(nil),
-                                                               Flags:     []byte{0, 0},
+                                                               Flags:     [2]byte{0, 0},
                                                         },
                                                 },
                                         },
                                 },
                                 t: NewTransaction(
                                                         },
                                                 },
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranSendInstantMsg,
-                                       &[]byte{0, 1},
-                                       NewField(fieldData, []byte("hai")),
-                                       NewField(fieldUserID, []byte{0, 2}),
+                                       TranSendInstantMsg,
+                                       [2]byte{0, 1},
+                                       NewField(FieldData, []byte("hai")),
+                                       NewField(FieldUserID, []byte{0, 2}),
                                 ),
                         },
                         wantRes: []Transaction{
                                 ),
                         },
                         wantRes: []Transaction{
-                               *NewTransaction(
-                                       tranServerMsg,
-                                       &[]byte{0, 2},
-                                       NewField(fieldData, []byte("hai")),
-                                       NewField(fieldUserName, []byte("User1")),
-                                       NewField(fieldUserID, []byte{0, 1}),
-                                       NewField(fieldOptions, []byte{0, 1}),
+                               NewTransaction(
+                                       TranServerMsg,
+                                       [2]byte{0, 2},
+                                       NewField(FieldData, []byte("hai")),
+                                       NewField(FieldUserName, []byte("User1")),
+                                       NewField(FieldUserID, []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: [2]byte{0, 1},
+                                       IsReply:  0x01,
+                                       Fields:   []Field(nil),
                                 },
                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
                 {
                         name: "when client 2 has autoreply enabled",
                 },
                 {
                         name: "when client 2 has autoreply enabled",
@@ -2503,13 +2188,13 @@ func TestHandleSendInstantMsg(t *testing.T) {
                                                         return bits
                                                 }(),
                                         },
                                                         return bits
                                                 }(),
                                         },
-                                       ID:       &[]byte{0, 1},
+                                       ID:       [2]byte{0, 1},
                                         UserName: []byte("User1"),
                                         Server: &Server{
                                         UserName: []byte("User1"),
                                         Server: &Server{
-                                               Clients: map[uint16]*ClientConn{
-                                                       uint16(2): {
-                                                               Flags:     []byte{0, 0},
-                                                               ID:        &[]byte{0, 2},
+                                               Clients: map[[2]byte]*ClientConn{
+                                                       [2]byte{0, 2}: {
+                                                               Flags:     [2]byte{0, 0},
+                                                               ID:        [2]byte{0, 2},
                                                                 UserName:  []byte("User2"),
                                                                 AutoReply: []byte("autohai"),
                                                         },
                                                                 UserName:  []byte("User2"),
                                                                 AutoReply: []byte("autohai"),
                                                         },
@@ -2517,40 +2202,35 @@ func TestHandleSendInstantMsg(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranSendInstantMsg,
-                                       &[]byte{0, 1},
-                                       NewField(fieldData, []byte("hai")),
-                                       NewField(fieldUserID, []byte{0, 2}),
+                                       TranSendInstantMsg,
+                                       [2]byte{0, 1},
+                                       NewField(FieldData, []byte("hai")),
+                                       NewField(FieldUserID, []byte{0, 2}),
                                 ),
                         },
                         wantRes: []Transaction{
                                 ),
                         },
                         wantRes: []Transaction{
-                               *NewTransaction(
-                                       tranServerMsg,
-                                       &[]byte{0, 2},
-                                       NewField(fieldData, []byte("hai")),
-                                       NewField(fieldUserName, []byte("User1")),
-                                       NewField(fieldUserID, []byte{0, 1}),
-                                       NewField(fieldOptions, []byte{0, 1}),
+                               NewTransaction(
+                                       TranServerMsg,
+                                       [2]byte{0, 2},
+                                       NewField(FieldData, []byte("hai")),
+                                       NewField(FieldUserName, []byte("User1")),
+                                       NewField(FieldUserID, []byte{0, 1}),
+                                       NewField(FieldOptions, []byte{0, 1}),
                                 ),
                                 ),
-                               *NewTransaction(
-                                       tranServerMsg,
-                                       &[]byte{0, 1},
-                                       NewField(fieldData, []byte("autohai")),
-                                       NewField(fieldUserName, []byte("User2")),
-                                       NewField(fieldUserID, []byte{0, 2}),
-                                       NewField(fieldOptions, []byte{0, 1}),
+                               NewTransaction(
+                                       TranServerMsg,
+                                       [2]byte{0, 1},
+                                       NewField(FieldData, []byte("autohai")),
+                                       NewField(FieldUserName, []byte("User2")),
+                                       NewField(FieldUserID, []byte{0, 2}),
+                                       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: [2]byte{0, 1},
+                                       IsReply:  0x01,
+                                       Fields:   []Field(nil),
                                 },
                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
                 {
                         name: "when client 2 has refuse private messages enabled",
                 },
                 {
                         name: "when client 2 has refuse private messages enabled",
@@ -2563,54 +2243,45 @@ func TestHandleSendInstantMsg(t *testing.T) {
                                                         return bits
                                                 }(),
                                         },
                                                         return bits
                                                 }(),
                                         },
-                                       ID:       &[]byte{0, 1},
+                                       ID:       [2]byte{0, 1},
                                         UserName: []byte("User1"),
                                         Server: &Server{
                                         UserName: []byte("User1"),
                                         Server: &Server{
-                                               Clients: map[uint16]*ClientConn{
-                                                       uint16(2): {
-                                                               Flags:    []byte{255, 255},
-                                                               ID:       &[]byte{0, 2},
+                                               Clients: map[[2]byte]*ClientConn{
+                                                       [2]byte{0, 2}: {
+                                                               Flags:    [2]byte{255, 255},
+                                                               ID:       [2]byte{0, 2},
                                                                 UserName: []byte("User2"),
                                                         },
                                                 },
                                         },
                                 },
                                 t: NewTransaction(
                                                                 UserName: []byte("User2"),
                                                         },
                                                 },
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranSendInstantMsg,
-                                       &[]byte{0, 1},
-                                       NewField(fieldData, []byte("hai")),
-                                       NewField(fieldUserID, []byte{0, 2}),
+                                       TranSendInstantMsg,
+                                       [2]byte{0, 1},
+                                       NewField(FieldData, []byte("hai")),
+                                       NewField(FieldUserID, []byte{0, 2}),
                                 ),
                         },
                         wantRes: []Transaction{
                                 ),
                         },
                         wantRes: []Transaction{
-                               *NewTransaction(
-                                       tranServerMsg,
-                                       &[]byte{0, 1},
-                                       NewField(fieldData, []byte("User2 does not accept private messages.")),
-                                       NewField(fieldUserName, []byte("User2")),
-                                       NewField(fieldUserID, []byte{0, 2}),
-                                       NewField(fieldOptions, []byte{0, 2}),
+                               NewTransaction(
+                                       TranServerMsg,
+                                       [2]byte{0, 1},
+                                       NewField(FieldData, []byte("User2 does not accept private messages.")),
+                                       NewField(FieldUserName, []byte("User2")),
+                                       NewField(FieldUserID, []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: [2]byte{0, 1},
+                                       IsReply:  0x01,
+                                       Fields:   []Field(nil),
                                 },
                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-                       gotRes, err := HandleSendInstantMsg(tt.args.cc, tt.args.t)
-                       if !tt.wantErr(t, err, fmt.Sprintf("HandleSendInstantMsg(%v, %v)", tt.args.cc, tt.args.t)) {
-                               return
-                       }
-
+                       gotRes := HandleSendInstantMsg(tt.args.cc, &tt.args.t)
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
@@ -2619,13 +2290,12 @@ func TestHandleSendInstantMsg(t *testing.T) {
  func TestHandleDeleteFile(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleDeleteFile(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
-               wantErr assert.ErrorAssertionFunc
         }{
                 {
                         name: "when user does not have required permission to delete a folder",
         }{
                 {
                         name: "when user does not have required permission to delete a folder",
@@ -2662,9 +2332,9 @@ func TestHandleDeleteFile(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranDeleteFile, &[]byte{0, 1},
-                                       NewField(fieldFileName, []byte("testfile")),
-                                       NewField(fieldFilePath, []byte{
+                                       TranDeleteFile, [2]byte{0, 1},
+                                       NewField(FieldFileName, []byte("testfile")),
+                                       NewField(FieldFilePath, []byte{
                                                 0x00, 0x01,
                                                 0x00, 0x00,
                                                 0x03,
                                                 0x00, 0x01,
                                                 0x00, 0x00,
                                                 0x03,
@@ -2674,17 +2344,13 @@ func TestHandleDeleteFile(t *testing.T) {
                         },
                         wantRes: []Transaction{
                                 {
                         },
                         wantRes: []Transaction{
                                 {
-                                       Flags:     0x00,
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("You are not allowed to delete files.")),
+                                               NewField(FieldError, []byte("You are not allowed to delete files.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
                 {
                         name: "deletes all associated metadata files",
                 },
                 {
                         name: "deletes all associated metadata files",
@@ -2727,9 +2393,9 @@ func TestHandleDeleteFile(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranDeleteFile, &[]byte{0, 1},
-                                       NewField(fieldFileName, []byte("testfile")),
-                                       NewField(fieldFilePath, []byte{
+                                       TranDeleteFile, [2]byte{0, 1},
+                                       NewField(FieldFileName, []byte("testfile")),
+                                       NewField(FieldFilePath, []byte{
                                                 0x00, 0x01,
                                                 0x00, 0x00,
                                                 0x03,
                                                 0x00, 0x01,
                                                 0x00, 0x00,
                                                 0x03,
@@ -2739,24 +2405,15 @@ 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,
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-                       gotRes, err := HandleDeleteFile(tt.args.cc, tt.args.t)
-                       if !tt.wantErr(t, err, fmt.Sprintf("HandleDeleteFile(%v, %v)", tt.args.cc, tt.args.t)) {
-                               return
-                       }
-
+                       gotRes := HandleDeleteFile(tt.args.cc, &tt.args.t)
                         tranAssertEqual(t, tt.wantRes, gotRes)
  
                         tt.args.cc.Server.FS.(*MockFileStore).AssertExpectations(t)
                         tranAssertEqual(t, tt.wantRes, gotRes)
  
                         tt.args.cc.Server.FS.(*MockFileStore).AssertExpectations(t)
@@ -2767,16 +2424,15 @@ func TestHandleDeleteFile(t *testing.T) {
  func TestHandleGetFileNameList(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleGetFileNameList(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
-               wantErr assert.ErrorAssertionFunc
         }{
                 {
         }{
                 {
-                       name: "when fieldFilePath is a drop box, but user does not have accessViewDropBoxes ",
+                       name: "when FieldFilePath is a drop box, but user does not have accessViewDropBoxes ",
                         args: args{
                                 cc: &ClientConn{
                                         Account: &Account{
                         args: args{
                                 cc: &ClientConn{
                                         Account: &Account{
@@ -2796,8 +2452,8 @@ func TestHandleGetFileNameList(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranGetFileNameList, &[]byte{0, 1},
-                                       NewField(fieldFilePath, []byte{
+                                       TranGetFileNameList, [2]byte{0, 1},
+                                       NewField(FieldFilePath, []byte{
                                                 0x00, 0x01,
                                                 0x00, 0x00,
                                                 0x08,
                                                 0x00, 0x01,
                                                 0x00, 0x00,
                                                 0x08,
@@ -2807,17 +2463,13 @@ func TestHandleGetFileNameList(t *testing.T) {
                         },
                         wantRes: []Transaction{
                                 {
                         },
                         wantRes: []Transaction{
                                 {
-                                       Flags:     0x00,
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("You are not allowed to view drop boxes.")),
+                                               NewField(FieldError, []byte("You are not allowed to view drop boxes.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
                 {
                         name: "with file root",
                 },
                 {
                         name: "with file root",
@@ -2833,8 +2485,8 @@ func TestHandleGetFileNameList(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranGetFileNameList, &[]byte{0, 1},
-                                       NewField(fieldFilePath, []byte{
+                                       TranGetFileNameList, [2]byte{0, 1},
+                                       NewField(FieldFilePath, []byte{
                                                 0x00, 0x00,
                                                 0x00, 0x00,
                                         }),
                                                 0x00, 0x00,
                                                 0x00, 0x00,
                                         }),
@@ -2842,14 +2494,10 @@ 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(
                                         Fields: []Field{
                                                 NewField(
-                                                       fieldFileNameWithInfo,
+                                                       FieldFileNameWithInfo,
                                                         func() []byte {
                                                                 fnwi := FileNameWithInfo{
                                                                         fileNameWithInfoHeader: fileNameWithInfoHeader{
                                                         func() []byte {
                                                                 fnwi := FileNameWithInfo{
                                                                         fileNameWithInfoHeader: fileNameWithInfoHeader{
@@ -2860,25 +2508,20 @@ func TestHandleGetFileNameList(t *testing.T) {
                                                                                 NameScript: [2]byte{},
                                                                                 NameSize:   [2]byte{0, 0x0b},
                                                                         },
                                                                                 NameScript: [2]byte{},
                                                                                 NameSize:   [2]byte{0, 0x0b},
                                                                         },
-                                                                       name: []byte("testfile-1k"),
+                                                                       Name: []byte("testfile-1k"),
                                                                 }
                                                                 }
-                                                               b, _ := fnwi.MarshalBinary()
+                                                               b, _ := io.ReadAll(&fnwi)
                                                                 return b
                                                         }(),
                                                 ),
                                         },
                                 },
                         },
                                                                 return b
                                                         }(),
                                                 ),
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-                       gotRes, err := HandleGetFileNameList(tt.args.cc, tt.args.t)
-                       if !tt.wantErr(t, err, fmt.Sprintf("HandleGetFileNameList(%v, %v)", tt.args.cc, tt.args.t)) {
-                               return
-                       }
-
+                       gotRes := HandleGetFileNameList(tt.args.cc, &tt.args.t)
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
@@ -2887,13 +2530,12 @@ func TestHandleGetFileNameList(t *testing.T) {
  func TestHandleGetClientInfoText(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleGetClientInfoText(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
-               wantErr assert.ErrorAssertionFunc
         }{
                 {
                         name: "when user does not have required permission",
         }{
                 {
                         name: "when user does not have required permission",
@@ -2910,23 +2552,19 @@ func TestHandleGetClientInfoText(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranGetClientInfoText, &[]byte{0, 1},
-                                       NewField(fieldUserID, []byte{0, 1}),
+                                       TranGetClientInfoText, [2]byte{0, 1},
+                                       NewField(FieldUserID, []byte{0, 1}),
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
-                                       Flags:     0x00,
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("You are not allowed to get client info.")),
+                                               NewField(FieldError, []byte("You are not allowed to get client info.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
                 {
                         name: "with a valid user",
                 },
                 {
                         name: "with a valid user",
@@ -2945,8 +2583,8 @@ func TestHandleGetClientInfoText(t *testing.T) {
                                         },
                                         Server: &Server{
                                                 Accounts: map[string]*Account{},
                                         },
                                         Server: &Server{
                                                 Accounts: map[string]*Account{},
-                                               Clients: map[uint16]*ClientConn{
-                                                       uint16(1): {
+                                               Clients: map[[2]byte]*ClientConn{
+                                                       [2]byte{0, 1}: {
                                                                 UserName:   []byte("Testy McTest"),
                                                                 RemoteAddr: "1.2.3.4:12345",
                                                                 Account: &Account{
                                                                 UserName:   []byte("Testy McTest"),
                                                                 RemoteAddr: "1.2.3.4:12345",
                                                                 Account: &Account{
@@ -2969,20 +2607,16 @@ func TestHandleGetClientInfoText(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranGetClientInfoText, &[]byte{0, 1},
-                                       NewField(fieldUserID, []byte{0, 1}),
+                                       TranGetClientInfoText, [2]byte{0, 1},
+                                       NewField(FieldUserID, []byte{0, 1}),
                                 ),
                         },
                         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{
                                         Fields: []Field{
-                                               NewField(fieldData, []byte(
-                                                       strings.Replace(`Nickname:   Testy McTest
+                                               NewField(FieldData, []byte(
+                                                       strings.ReplaceAll(`Nickname:   Testy McTest
  Name:       test
  Account:    test
  Address:    1.2.3.4:12345
  Name:       test
  Account:    test
  Address:    1.2.3.4:12345
@@ -3007,21 +2641,17 @@ None.
  
  None.
  
  
  None.
  
-`, "\n", "\r", -1)),
+`, "\n", "\r")),
                                                 ),
                                                 ),
-                                               NewField(fieldUserName, []byte("Testy McTest")),
+                                               NewField(FieldUserName, []byte("Testy McTest")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-                       gotRes, err := HandleGetClientInfoText(tt.args.cc, tt.args.t)
-                       if !tt.wantErr(t, err, fmt.Sprintf("HandleGetClientInfoText(%v, %v)", tt.args.cc, tt.args.t)) {
-                               return
-                       }
+                       gotRes := HandleGetClientInfoText(tt.args.cc, &tt.args.t)
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
@@ -3030,13 +2660,12 @@ None.
  func TestHandleTranAgreed(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleTranAgreed(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
-               wantErr assert.ErrorAssertionFunc
         }{
                 {
                         name: "normal request flow",
         }{
                 {
                         name: "normal request flow",
@@ -3050,9 +2679,9 @@ func TestHandleTranAgreed(t *testing.T) {
                                                         return bits
                                                 }()},
                                         Icon:    []byte{0, 1},
                                                         return bits
                                                 }()},
                                         Icon:    []byte{0, 1},
-                                       Flags:   []byte{0, 1},
+                                       Flags:   [2]byte{0, 1},
                                         Version: []byte{0, 1},
                                         Version: []byte{0, 1},
-                                       ID:      &[]byte{0, 1},
+                                       ID:      [2]byte{0, 1},
                                         logger:  NewTestLogger(),
                                         Server: &Server{
                                                 Config: &Config{
                                         logger:  NewTestLogger(),
                                         Server: &Server{
                                                 Config: &Config{
@@ -3061,43 +2690,31 @@ func TestHandleTranAgreed(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranAgreed, nil,
-                                       NewField(fieldUserName, []byte("username")),
-                                       NewField(fieldUserIconID, []byte{0, 1}),
-                                       NewField(fieldOptions, []byte{0, 0}),
+                                       TranAgreed, [2]byte{},
+                                       NewField(FieldUserName, []byte("username")),
+                                       NewField(FieldUserIconID, []byte{0, 1}),
+                                       NewField(FieldOptions, []byte{0, 0}),
                                 ),
                         },
                         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: [2]byte{0, 1},
+                                       Type:     [2]byte{0, 0x7a},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldBannerType, []byte("JPEG")),
+                                               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: [2]byte{0, 1},
+                                       IsReply:  0x01,
+                                       Fields:   []Field{},
                                 },
                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-                       gotRes, err := HandleTranAgreed(tt.args.cc, tt.args.t)
-                       if !tt.wantErr(t, err, fmt.Sprintf("HandleTranAgreed(%v, %v)", tt.args.cc, tt.args.t)) {
-                               return
-                       }
+                       gotRes := HandleTranAgreed(tt.args.cc, &tt.args.t)
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
@@ -3106,13 +2723,12 @@ func TestHandleTranAgreed(t *testing.T) {
  func TestHandleSetClientUserInfo(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleSetClientUserInfo(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
-               wantErr assert.ErrorAssertionFunc
         }{
                 {
                         name: "when client does not have accessAnyName",
         }{
                 {
                         name: "when client does not have accessAnyName",
@@ -3124,48 +2740,39 @@ func TestHandleSetClientUserInfo(t *testing.T) {
                                                         return bits
                                                 }(),
                                         },
                                                         return bits
                                                 }(),
                                         },
-                                       ID:       &[]byte{0, 1},
+                                       ID:       [2]byte{0, 1},
                                         UserName: []byte("Guest"),
                                         UserName: []byte("Guest"),
-                                       Flags:    []byte{0, 1},
+                                       Flags:    [2]byte{0, 1},
                                         Server: &Server{
                                         Server: &Server{
-                                               Clients: map[uint16]*ClientConn{
-                                                       uint16(1): {
-                                                               ID: &[]byte{0, 1},
+                                               Clients: map[[2]byte]*ClientConn{
+                                                       [2]byte{0, 1}: {
+                                                               ID: [2]byte{0, 1},
                                                         },
                                                 },
                                         },
                                 },
                                 t: NewTransaction(
                                                         },
                                                 },
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranSetClientUserInfo, nil,
-                                       NewField(fieldUserIconID, []byte{0, 1}),
-                                       NewField(fieldUserName, []byte("NOPE")),
+                                       TranSetClientUserInfo, [2]byte{},
+                                       NewField(FieldUserIconID, []byte{0, 1}),
+                                       NewField(FieldUserName, []byte("NOPE")),
                                 ),
                         },
                         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: [2]byte{0, 1},
+                                       Type:     [2]byte{0x01, 0x2d},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldUserID, []byte{0, 1}),
-                                               NewField(fieldUserIconID, []byte{0, 1}),
-                                               NewField(fieldUserFlags, []byte{0, 1}),
-                                               NewField(fieldUserName, []byte("Guest"))},
+                                               NewField(FieldUserID, []byte{0, 1}),
+                                               NewField(FieldUserIconID, []byte{0, 1}),
+                                               NewField(FieldUserFlags, []byte{0, 1}),
+                                               NewField(FieldUserName, []byte("Guest"))},
                                 },
                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-                       gotRes, err := HandleSetClientUserInfo(tt.args.cc, tt.args.t)
-                       if !tt.wantErr(t, err, fmt.Sprintf("HandleSetClientUserInfo(%v, %v)", tt.args.cc, tt.args.t)) {
-                               return
-                       }
-
+                       gotRes := HandleSetClientUserInfo(tt.args.cc, &tt.args.t)
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
@@ -3174,13 +2781,12 @@ func TestHandleSetClientUserInfo(t *testing.T) {
  func TestHandleDelNewsItem(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleDelNewsItem(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
-               wantErr assert.ErrorAssertionFunc
         }{
                 {
                         name: "when user does not have permission to delete a news category",
         }{
                 {
                         name: "when user does not have permission to delete a news category",
@@ -3189,21 +2795,19 @@ func TestHandleDelNewsItem(t *testing.T) {
                                         Account: &Account{
                                                 Access: accessBitmap{},
                                         },
                                         Account: &Account{
                                                 Access: accessBitmap{},
                                         },
-                                       ID: &[]byte{0, 1},
+                                       ID: [2]byte{0, 1},
                                         Server: &Server{
                                                 ThreadedNews: &ThreadedNews{Categories: map[string]NewsCategoryListData15{
                                                         "test": {
                                         Server: &Server{
                                                 ThreadedNews: &ThreadedNews{Categories: map[string]NewsCategoryListData15{
                                                         "test": {
-                                                               Type:     []byte{0, 3},
-                                                               Count:    nil,
-                                                               NameSize: 0,
-                                                               Name:     "zz",
+                                                               Type: [2]byte{0, 3},
+                                                               Name: "zz",
                                                         },
                                                 }},
                                         },
                                 },
                                 t: NewTransaction(
                                                         },
                                                 }},
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranDelNewsItem, nil,
-                                       NewField(fieldNewsPath,
+                                       TranDelNewsItem, [2]byte{},
+                                       NewField(FieldNewsPath,
                                                 []byte{
                                                         0, 1,
                                                         0, 0,
                                                 []byte{
                                                         0, 1,
                                                         0, 0,
@@ -3215,18 +2819,14 @@ func TestHandleDelNewsItem(t *testing.T) {
                         },
                         wantRes: []Transaction{
                                 {
                         },
                         wantRes: []Transaction{
                                 {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
+                                       clientID:  [2]byte{0, 1},
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("You are not allowed to delete news categories.")),
+                                               NewField(FieldError, []byte("You are not allowed to delete news categories.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
                 {
                         name: "when user does not have permission to delete a news folder",
                 },
                 {
                         name: "when user does not have permission to delete a news folder",
@@ -3235,21 +2835,19 @@ func TestHandleDelNewsItem(t *testing.T) {
                                         Account: &Account{
                                                 Access: accessBitmap{},
                                         },
                                         Account: &Account{
                                                 Access: accessBitmap{},
                                         },
-                                       ID: &[]byte{0, 1},
+                                       ID: [2]byte{0, 1},
                                         Server: &Server{
                                                 ThreadedNews: &ThreadedNews{Categories: map[string]NewsCategoryListData15{
                                                         "testcat": {
                                         Server: &Server{
                                                 ThreadedNews: &ThreadedNews{Categories: map[string]NewsCategoryListData15{
                                                         "testcat": {
-                                                               Type:     []byte{0, 2},
-                                                               Count:    nil,
-                                                               NameSize: 0,
-                                                               Name:     "test",
+                                                               Type: [2]byte{0, 2},
+                                                               Name: "test",
                                                         },
                                                 }},
                                         },
                                 },
                                 t: NewTransaction(
                                                         },
                                                 }},
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranDelNewsItem, nil,
-                                       NewField(fieldNewsPath,
+                                       TranDelNewsItem, [2]byte{},
+                                       NewField(FieldNewsPath,
                                                 []byte{
                                                         0, 1,
                                                         0, 0,
                                                 []byte{
                                                         0, 1,
                                                         0, 0,
@@ -3261,18 +2859,14 @@ func TestHandleDelNewsItem(t *testing.T) {
                         },
                         wantRes: []Transaction{
                                 {
                         },
                         wantRes: []Transaction{
                                 {
-                                       clientID:  &[]byte{0, 1},
-                                       Flags:     0x00,
+                                       clientID:  [2]byte{0, 1},
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("You are not allowed to delete news folders.")),
+                                               NewField(FieldError, []byte("You are not allowed to delete news folders.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
                 {
                         name: "when user deletes a news folder",
                 },
                 {
                         name: "when user deletes a news folder",
@@ -3285,7 +2879,7 @@ func TestHandleDelNewsItem(t *testing.T) {
                                                         return bits
                                                 }(),
                                         },
                                                         return bits
                                                 }(),
                                         },
-                                       ID: &[]byte{0, 1},
+                                       ID: [2]byte{0, 1},
                                         Server: &Server{
                                                 ConfigDir: "/fakeConfigRoot",
                                                 FS: func() *MockFileStore {
                                         Server: &Server{
                                                 ConfigDir: "/fakeConfigRoot",
                                                 FS: func() *MockFileStore {
@@ -3295,17 +2889,15 @@ func TestHandleDelNewsItem(t *testing.T) {
                                                 }(),
                                                 ThreadedNews: &ThreadedNews{Categories: map[string]NewsCategoryListData15{
                                                         "testcat": {
                                                 }(),
                                                 ThreadedNews: &ThreadedNews{Categories: map[string]NewsCategoryListData15{
                                                         "testcat": {
-                                                               Type:     []byte{0, 2},
-                                                               Count:    nil,
-                                                               NameSize: 0,
-                                                               Name:     "test",
+                                                               Type: [2]byte{0, 2},
+                                                               Name: "test",
                                                         },
                                                 }},
                                         },
                                 },
                                 t: NewTransaction(
                                                         },
                                                 }},
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranDelNewsItem, nil,
-                                       NewField(fieldNewsPath,
+                                       TranDelNewsItem, [2]byte{},
+                                       NewField(FieldNewsPath,
                                                 []byte{
                                                         0, 1,
                                                         0, 0,
                                                 []byte{
                                                         0, 1,
                                                         0, 0,
@@ -3317,89 +2909,16 @@ 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: [2]byte{0, 1},
+                                       IsReply:  0x01,
+                                       Fields:   []Field{},
                                 },
                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-                       gotRes, err := HandleDelNewsItem(tt.args.cc, tt.args.t)
-                       if !tt.wantErr(t, err, fmt.Sprintf("HandleDelNewsItem(%v, %v)", tt.args.cc, tt.args.t)) {
-                               return
-                       }
-                       tranAssertEqual(t, tt.wantRes, gotRes)
-               })
-       }
-}
-
-func TestHandleDownloadBanner(t *testing.T) {
-       type args struct {
-               cc *ClientConn
-               t  *Transaction
-       }
-       tests := []struct {
-               name    string
-               args    args
-               wantRes []Transaction
-               wantErr assert.ErrorAssertionFunc
-       }{
-               {
-                       name: "returns expected response",
-                       args: args{
-                               cc: &ClientConn{
-                                       ID: &[]byte{0, 1},
-                                       transfers: map[int]map[[4]byte]*FileTransfer{
-                                               bannerDownload: {},
-                                       },
-                                       Server: &Server{
-                                               ConfigDir: "/config",
-                                               Config: &Config{
-                                                       BannerFile: "banner.jpg",
-                                               },
-                                               fileTransfers: map[[4]byte]*FileTransfer{},
-                                               FS: func() *MockFileStore {
-                                                       mfi := &MockFileInfo{}
-                                                       mfi.On("Size").Return(int64(100))
-
-                                                       mfs := &MockFileStore{}
-                                                       mfs.On("Stat", "/config/banner.jpg").Return(mfi, nil)
-                                                       return mfs
-                                               }(),
-                                       },
-                               },
-                               t: NewTransaction(tranDownloadBanner, nil),
-                       },
-                       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{
-                                               NewField(fieldRefNum, []byte{1, 2, 3, 4}),
-                                               NewField(fieldTransferSize, []byte{0, 0, 0, 0x64}),
-                                       },
-                               },
-                       },
-                       wantErr: assert.NoError,
-               },
-       }
-       for _, tt := range tests {
-               t.Run(tt.name, func(t *testing.T) {
-                       gotRes, err := HandleDownloadBanner(tt.args.cc, tt.args.t)
-                       if !tt.wantErr(t, err, fmt.Sprintf("HandleDownloadBanner(%v, %v)", tt.args.cc, tt.args.t)) {
-                               return
-                       }
+                       gotRes := HandleDelNewsItem(tt.args.cc, &tt.args.t)
  
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
  
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
@@ -3409,13 +2928,12 @@ func TestHandleDownloadBanner(t *testing.T) {
  func TestHandleTranOldPostNews(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleTranOldPostNews(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
-               wantErr assert.ErrorAssertionFunc
         }{
                 {
                         name: "when user does not have required permission",
         }{
                 {
                         name: "when user does not have required permission",
@@ -3429,23 +2947,19 @@ func TestHandleTranOldPostNews(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranOldPostNews, &[]byte{0, 1},
-                                       NewField(fieldData, []byte("hai")),
+                                       TranOldPostNews, [2]byte{0, 1},
+                                       NewField(FieldData, []byte("hai")),
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
-                                       Flags:     0x00,
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("You are not allowed to post news.")),
+                                               NewField(FieldError, []byte("You are not allowed to post news.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
                 {
                         name: "when user posts news update",
                 },
                 {
                         name: "when user posts news update",
@@ -3469,28 +2983,20 @@ func TestHandleTranOldPostNews(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranOldPostNews, &[]byte{0, 1},
-                                       NewField(fieldData, []byte("hai")),
+                                       TranOldPostNews, [2]byte{0, 1},
+                                       NewField(FieldData, []byte("hai")),
                                 ),
                         },
                         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,
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-                       gotRes, err := HandleTranOldPostNews(tt.args.cc, tt.args.t)
-                       if !tt.wantErr(t, err, fmt.Sprintf("HandleTranOldPostNews(%v, %v)", tt.args.cc, tt.args.t)) {
-                               return
-                       }
+                       gotRes := HandleTranOldPostNews(tt.args.cc, &tt.args.t)
  
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
  
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
@@ -3500,13 +3006,12 @@ func TestHandleTranOldPostNews(t *testing.T) {
  func TestHandleInviteNewChat(t *testing.T) {
         type args struct {
                 cc *ClientConn
  func TestHandleInviteNewChat(t *testing.T) {
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
-               wantErr assert.ErrorAssertionFunc
         }{
                 {
                         name: "when user does not have required permission",
         }{
                 {
                         name: "when user does not have required permission",
@@ -3519,27 +3024,23 @@ func TestHandleInviteNewChat(t *testing.T) {
                                                 }(),
                                         },
                                 },
                                                 }(),
                                         },
                                 },
-                               t: NewTransaction(tranInviteNewChat, &[]byte{0, 1}),
+                               t: NewTransaction(TranInviteNewChat, [2]byte{0, 1}),
                         },
                         wantRes: []Transaction{
                                 {
                         },
                         wantRes: []Transaction{
                                 {
-                                       Flags:     0x00,
                                         IsReply:   0x01,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("You are not allowed to request private chat.")),
+                                               NewField(FieldError, []byte("You are not allowed to request private chat.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
                 {
                         name: "when userA invites userB to new private chat",
                         args: args{
                                 cc: &ClientConn{
                 },
                 {
                         name: "when userA invites userB to new private chat",
                         args: args{
                                 cc: &ClientConn{
-                                       ID: &[]byte{0, 1},
+                                       ID: [2]byte{0, 1},
                                         Account: &Account{
                                                 Access: func() accessBitmap {
                                                         var bits accessBitmap
                                         Account: &Account{
                                                 Access: func() accessBitmap {
                                                         var bits accessBitmap
@@ -3549,61 +3050,51 @@ func TestHandleInviteNewChat(t *testing.T) {
                                         },
                                         UserName: []byte("UserA"),
                                         Icon:     []byte{0, 1},
                                         },
                                         UserName: []byte("UserA"),
                                         Icon:     []byte{0, 1},
-                                       Flags:    []byte{0, 0},
+                                       Flags:    [2]byte{0, 0},
                                         Server: &Server{
                                         Server: &Server{
-                                               Clients: map[uint16]*ClientConn{
-                                                       uint16(2): {
-                                                               ID:       &[]byte{0, 2},
+                                               Clients: map[[2]byte]*ClientConn{
+                                                       [2]byte{0, 2}: {
+                                                               ID:       [2]byte{0, 2},
                                                                 UserName: []byte("UserB"),
                                                                 UserName: []byte("UserB"),
-                                                               Flags:    []byte{0, 0},
                                                         },
                                                 },
                                                         },
                                                 },
-                                               PrivateChats: make(map[uint32]*PrivateChat),
+                                               PrivateChats: make(map[[4]byte]*PrivateChat),
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranInviteNewChat, &[]byte{0, 1},
-                                       NewField(fieldUserID, []byte{0, 2}),
+                                       TranInviteNewChat, [2]byte{0, 1},
+                                       NewField(FieldUserID, []byte{0, 2}),
                                 ),
                         },
                         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: [2]byte{0, 2},
+                                       Type:     [2]byte{0, 0x71},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldChatID, []byte{0x52, 0xfd, 0xfc, 0x07}),
-                                               NewField(fieldUserName, []byte("UserA")),
-                                               NewField(fieldUserID, []byte{0, 1}),
+                                               NewField(FieldChatID, []byte{0x52, 0xfd, 0xfc, 0x07}),
+                                               NewField(FieldUserName, []byte("UserA")),
+                                               NewField(FieldUserID, []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},
+                                       clientID: [2]byte{0, 1},
+                                       IsReply:  0x01,
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldChatID, []byte{0x52, 0xfd, 0xfc, 0x07}),
-                                               NewField(fieldUserName, []byte("UserA")),
-                                               NewField(fieldUserID, []byte{0, 1}),
-                                               NewField(fieldUserIconID, []byte{0, 1}),
-                                               NewField(fieldUserFlags, []byte{0, 0}),
+                                               NewField(FieldChatID, []byte{0x52, 0xfd, 0xfc, 0x07}),
+                                               NewField(FieldUserName, []byte("UserA")),
+                                               NewField(FieldUserID, []byte{0, 1}),
+                                               NewField(FieldUserIconID, []byte{0, 1}),
+                                               NewField(FieldUserFlags, []byte{0, 0}),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
                 {
                         name: "when userA invites userB to new private chat, but UserB has refuse private chat enabled",
                         args: args{
                                 cc: &ClientConn{
                 },
                 {
                         name: "when userA invites userB to new private chat, but UserB has refuse private chat enabled",
                         args: args{
                                 cc: &ClientConn{
-                                       ID: &[]byte{0, 1},
+                                       ID: [2]byte{0, 1},
                                         Account: &Account{
                                                 Access: func() accessBitmap {
                                                         var bits accessBitmap
                                         Account: &Account{
                                                 Access: func() accessBitmap {
                                                         var bits accessBitmap
@@ -3613,79 +3104,231 @@ func TestHandleInviteNewChat(t *testing.T) {
                                         },
                                         UserName: []byte("UserA"),
                                         Icon:     []byte{0, 1},
                                         },
                                         UserName: []byte("UserA"),
                                         Icon:     []byte{0, 1},
-                                       Flags:    []byte{0, 0},
+                                       Flags:    [2]byte{0, 0},
                                         Server: &Server{
                                         Server: &Server{
-                                               Clients: map[uint16]*ClientConn{
-                                                       uint16(2): {
-                                                               ID:       &[]byte{0, 2},
+                                               Clients: map[[2]byte]*ClientConn{
+                                                       [2]byte{0, 2}: {
+                                                               ID:       [2]byte{0, 2},
                                                                 UserName: []byte("UserB"),
                                                                 UserName: []byte("UserB"),
-                                                               Flags:    []byte{255, 255},
+                                                               Flags:    [2]byte{255, 255},
                                                         },
                                                 },
                                                         },
                                                 },
-                                               PrivateChats: make(map[uint32]*PrivateChat),
+                                               PrivateChats: make(map[[4]byte]*PrivateChat),
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranInviteNewChat, &[]byte{0, 1},
-                                       NewField(fieldUserID, []byte{0, 2}),
+                                       TranInviteNewChat, [2]byte{0, 1},
+                                       NewField(FieldUserID, []byte{0, 2}),
                                 ),
                         },
                         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: [2]byte{0, 1},
+                                       Type:     [2]byte{0, 0x68},
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldData, []byte("UserB does not accept private chats.")),
-                                               NewField(fieldUserName, []byte("UserB")),
-                                               NewField(fieldUserID, []byte{0, 2}),
-                                               NewField(fieldOptions, []byte{0, 2}),
+                                               NewField(FieldData, []byte("UserB does not accept private chats.")),
+                                               NewField(FieldUserName, []byte("UserB")),
+                                               NewField(FieldUserID, []byte{0, 2}),
+                                               NewField(FieldOptions, []byte{0, 2}),
                                         },
                                 },
                                 {
                                         },
                                 },
                                 {
-                                       clientID:  &[]byte{0, 1},
+                                       clientID: [2]byte{0, 1},
+                                       IsReply:  0x01,
+                                       Fields: []Field{
+                                               NewField(FieldChatID, []byte{0x52, 0xfd, 0xfc, 0x07}),
+                                               NewField(FieldUserName, []byte("UserA")),
+                                               NewField(FieldUserID, []byte{0, 1}),
+                                               NewField(FieldUserIconID, []byte{0, 1}),
+                                               NewField(FieldUserFlags, []byte{0, 0}),
+                                       },
+                               },
+                       },
+               },
+       }
+       for _, tt := range tests {
+               t.Run(tt.name, func(t *testing.T) {
+                       gotRes := HandleInviteNewChat(tt.args.cc, &tt.args.t)
+
+                       tranAssertEqual(t, tt.wantRes, gotRes)
+               })
+       }
+}
+
+func TestHandleGetNewsArtData(t *testing.T) {
+       type args struct {
+               cc *ClientConn
+               t  Transaction
+       }
+       tests := []struct {
+               name    string
+               args    args
+               wantRes []Transaction
+       }{
+               {
+                       name: "when user does not have required permission",
+                       args: args{
+                               cc: &ClientConn{
+                                       Account: &Account{
+                                               Access: func() accessBitmap {
+                                                       var bits accessBitmap
+                                                       return bits
+                                               }(),
+                                       },
+                                       Server: &Server{
+                                               Accounts: map[string]*Account{},
+                                       },
+                               },
+                               t: NewTransaction(
+                                       TranGetNewsArtData, [2]byte{0, 1},
+                               ),
+                       },
+                       wantRes: []Transaction{
+                               {
+                                       IsReply:   0x01,
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
+                                       Fields: []Field{
+                                               NewField(FieldError, []byte("You are not allowed to read news.")),
+                                       },
+                               },
+                       },
+               },
+       }
+       for _, tt := range tests {
+               t.Run(tt.name, func(t *testing.T) {
+                       gotRes := HandleGetNewsArtData(tt.args.cc, &tt.args.t)
+                       tranAssertEqual(t, tt.wantRes, gotRes)
+               })
+       }
+}
+
+func TestHandleGetNewsArtNameList(t *testing.T) {
+       type args struct {
+               cc *ClientConn
+               t  Transaction
+       }
+       tests := []struct {
+               name    string
+               args    args
+               wantRes []Transaction
+       }{
+               {
+                       name: "when user does not have required permission",
+                       args: args{
+                               cc: &ClientConn{
+                                       Account: &Account{
+                                               Access: func() accessBitmap {
+                                                       var bits accessBitmap
+                                                       return bits
+                                               }(),
+                                       },
+                                       Server: &Server{
+                                               Accounts: map[string]*Account{},
+                                       },
+                               },
+                               t: NewTransaction(
+                                       TranGetNewsArtNameList, [2]byte{0, 1},
+                               ),
+                       },
+                       wantRes: []Transaction{
+                               {
                                         Flags:     0x00,
                                         IsReply:   0x01,
                                         Flags:     0x00,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0},
-                                       ID:        []byte{0, 0, 0, 0},
-                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       Type:      [2]byte{0, 0},
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
+                                       Fields: []Field{
+                                               NewField(FieldError, []byte("You are not allowed to read news.")),
+                                       },
+                               },
+                       },
+               },
+               {
+                       name: "when user has required access",
+                       args: args{
+                               cc: &ClientConn{
+                                       Account: &Account{
+                                               Access: func() accessBitmap {
+                                                       var bits accessBitmap
+                                                       bits.Set(accessNewsReadArt)
+                                                       return bits
+                                               }(),
+                                       },
+                                       Server: &Server{
+                                               ThreadedNews: &ThreadedNews{
+                                                       Categories: map[string]NewsCategoryListData15{
+                                                               "Example Category": {
+                                                                       Type: [2]byte{0, 2},
+                                                                       Name: "",
+                                                                       Articles: map[uint32]*NewsArtData{
+                                                                               uint32(1): {
+                                                                                       Title:  "testTitle",
+                                                                                       Poster: "testPoster",
+                                                                                       Data:   "testBody",
+                                                                               },
+                                                                       },
+                                                                       SubCats:  nil,
+                                                                       GUID:     [16]byte{},
+                                                                       AddSN:    [4]byte{},
+                                                                       DeleteSN: [4]byte{},
+                                                               },
+                                                       },
+                                               },
+
+                                               //Accounts: map[string]*Account{
+                                               //      "guest": {
+                                               //              Name:     "guest",
+                                               //              Login:    "guest",
+                                               //              Password: "zz",
+                                               //              Access:   accessBitmap{255, 255, 255, 255, 255, 255, 255, 255},
+                                               //      },
+                                               //},
+                                       },
+                               },
+                               t: NewTransaction(
+                                       TranGetNewsArtNameList,
+                                       [2]byte{0, 1},
+                                       //  00000000  00 01 00 00 10 45 78 61  6d 70 6c 65 20 43 61 74  |.....Example Cat|
+                                       //  00000010  65 67 6f 72 79                                    |egory|
+                                       NewField(FieldNewsPath, []byte{
+                                               0x00, 0x01, 0x00, 0x00, 0x10, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x43, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79,
+                                       }),
+                               ),
+                       },
+                       wantRes: []Transaction{
+                               {
+                                       IsReply: 0x01,
                                         Fields: []Field{
                                         Fields: []Field{
-                                               NewField(fieldChatID, []byte{0x52, 0xfd, 0xfc, 0x07}),
-                                               NewField(fieldUserName, []byte("UserA")),
-                                               NewField(fieldUserID, []byte{0, 1}),
-                                               NewField(fieldUserIconID, []byte{0, 1}),
-                                               NewField(fieldUserFlags, []byte{0, 0}),
+                                               NewField(FieldNewsArtListData, []byte{
+                                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+                                                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+                                                       0x09, 0x74, 0x65, 0x73, 0x74, 0x54, 0x69, 0x74, 0x6c, 0x65, 0x0a, 0x74, 0x65, 0x73, 0x74, 0x50,
+                                                       0x6f, 0x73, 0x74, 0x65, 0x72, 0x0a, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x70, 0x6c, 0x61, 0x69, 0x6e,
+                                                       0x00, 0x08,
+                                               },
+                                               ),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
                 },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-                       rand.Seed(1)
-                       gotRes, err := HandleInviteNewChat(tt.args.cc, tt.args.t)
-                       if !tt.wantErr(t, err, fmt.Sprintf("HandleInviteNewChat(%v, %v)", tt.args.cc, tt.args.t)) {
-                               return
-                       }
+                       gotRes := HandleGetNewsArtNameList(tt.args.cc, &tt.args.t)
+
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
  }
  
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
  }
  
-func TestHandleGetNewsArtData(t *testing.T) {
+func TestHandleNewNewsFldr(t *testing.T) {
         type args struct {
                 cc *ClientConn
         type args struct {
                 cc *ClientConn
-               t  *Transaction
+               t  Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
         }
         tests := []struct {
                 name    string
                 args    args
                 wantRes []Transaction
-               wantErr assert.ErrorAssertionFunc
         }{
                 {
                         name: "when user does not have required permission",
         }{
                 {
                         name: "when user does not have required permission",
@@ -3702,31 +3345,248 @@ func TestHandleGetNewsArtData(t *testing.T) {
                                         },
                                 },
                                 t: NewTransaction(
                                         },
                                 },
                                 t: NewTransaction(
-                                       tranGetNewsArtData, &[]byte{0, 1},
+                                       TranGetNewsArtNameList, [2]byte{0, 1},
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
                                         Flags:     0x00,
                                         IsReply:   0x01,
                                 ),
                         },
                         wantRes: []Transaction{
                                 {
                                         Flags:     0x00,
                                         IsReply:   0x01,
-                                       Type:      []byte{0, 0x00},
-                                       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{
                                         Fields: []Field{
-                                               NewField(fieldError, []byte("You are not allowed to read news.")),
+                                               NewField(FieldError, []byte("You are not allowed to create news folders.")),
                                         },
                                 },
                         },
                                         },
                                 },
                         },
-                       wantErr: assert.NoError,
                 },
                 },
+               {
+                       name: "with a valid request",
+                       args: args{
+                               cc: &ClientConn{
+                                       Account: &Account{
+                                               Access: func() accessBitmap {
+                                                       var bits accessBitmap
+                                                       bits.Set(accessNewsCreateFldr)
+                                                       return bits
+                                               }(),
+                                       },
+                                       logger: NewTestLogger(),
+                                       ID:     [2]byte{0, 1},
+                                       Server: &Server{
+                                               ConfigDir: "/fakeConfigRoot",
+                                               FS: func() *MockFileStore {
+                                                       mfs := &MockFileStore{}
+                                                       mfs.On("WriteFile", "/fakeConfigRoot/ThreadedNews.yaml", mock.Anything, mock.Anything).Return(nil)
+                                                       return mfs
+                                               }(),
+                                               ThreadedNews: &ThreadedNews{Categories: map[string]NewsCategoryListData15{
+                                                       "test": {
+                                                               Type:    [2]byte{0, 2},
+                                                               Name:    "test",
+                                                               SubCats: make(map[string]NewsCategoryListData15),
+                                                       },
+                                               }},
+                                       },
+                               },
+                               t: NewTransaction(
+                                       TranGetNewsArtNameList, [2]byte{0, 1},
+                                       NewField(FieldFileName, []byte("testFolder")),
+                                       NewField(FieldNewsPath,
+                                               []byte{
+                                                       0, 1,
+                                                       0, 0,
+                                                       4,
+                                                       0x74, 0x65, 0x73, 0x74,
+                                               },
+                                       ),
+                               ),
+                       },
+                       wantRes: []Transaction{
+                               {
+                                       clientID: [2]byte{0, 1},
+                                       IsReply:  0x01,
+                                       Fields:   []Field{},
+                               },
+                       },
+               },
+               //{
+               //      Name: "when there is an error writing the threaded news file",
+               //      args: args{
+               //              cc: &ClientConn{
+               //                      Account: &Account{
+               //                              Access: func() accessBitmap {
+               //                                      var bits accessBitmap
+               //                                      bits.Set(accessNewsCreateFldr)
+               //                                      return bits
+               //                              }(),
+               //                      },
+               //                      logger: NewTestLogger(),
+               //                      ID:     [2]byte{0, 1},
+               //                      Server: &Server{
+               //                              ConfigDir: "/fakeConfigRoot",
+               //                              FS: func() *MockFileStore {
+               //                                      mfs := &MockFileStore{}
+               //                                      mfs.On("WriteFile", "/fakeConfigRoot/ThreadedNews.yaml", mock.Anything, mock.Anything).Return(os.ErrNotExist)
+               //                                      return mfs
+               //                              }(),
+               //                              ThreadedNews: &ThreadedNews{Categories: map[string]NewsCategoryListData15{
+               //                                      "test": {
+               //                                              Type:     []byte{0, 2},
+               //                                              Count:    nil,
+               //                                              NameSize: 0,
+               //                                              Name:     "test",
+               //                                              SubCats:  make(map[string]NewsCategoryListData15),
+               //                                      },
+               //                              }},
+               //                      },
+               //              },
+               //              t: NewTransaction(
+               //                      TranGetNewsArtNameList, [2]byte{0, 1},
+               //                      NewField(FieldFileName, []byte("testFolder")),
+               //                      NewField(FieldNewsPath,
+               //                              []byte{
+               //                                      0, 1,
+               //                                      0, 0,
+               //                                      4,
+               //                                      0x74, 0x65, 0x73, 0x74,
+               //                              },
+               //                      ),
+               //              ),
+               //      },
+               //      wantRes: []Transaction{
+               //              {
+               //                      clientID:  [2]byte{0, 1},
+               //                      Flags:     0x00,
+               //                      IsReply:   0x01,
+               //                      Type:      [2]byte{0, 0},
+               //                      ErrorCode: [4]byte{0, 0, 0, 1},
+               //                      Fields: []Field{
+               //                              NewField(FieldError, []byte("Error creating news folder.")),
+               //                      },
+               //              },
+               //      },
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
         }
         for _, tt := range tests {
                 t.Run(tt.name, func(t *testing.T) {
-                       gotRes, err := HandleGetNewsArtData(tt.args.cc, tt.args.t)
-                       if !tt.wantErr(t, err, fmt.Sprintf("HandleGetNewsArtData(%v, %v)", tt.args.cc, tt.args.t)) {
-                               return
-                       }
+                       gotRes := HandleNewNewsFldr(tt.args.cc, &tt.args.t)
+
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
  }
                         tranAssertEqual(t, tt.wantRes, gotRes)
                 })
         }
  }
+
+func TestHandleDownloadBanner(t *testing.T) {
+       type args struct {
+               cc *ClientConn
+               t  Transaction
+       }
+       tests := []struct {
+               name    string
+               args    args
+               wantRes []Transaction
+       }{
+               // TODO: Add test cases.
+       }
+       for _, tt := range tests {
+               t.Run(tt.name, func(t *testing.T) {
+                       gotRes := HandleDownloadBanner(tt.args.cc, &tt.args.t)
+
+                       assert.Equalf(t, tt.wantRes, gotRes, "HandleDownloadBanner(%v, %v)", tt.args.cc, &tt.args.t)
+               })
+       }
+}
+
+func TestHandlePostNewsArt(t *testing.T) {
+       type args struct {
+               cc *ClientConn
+               t  Transaction
+       }
+       tests := []struct {
+               name    string
+               args    args
+               wantRes []Transaction
+       }{
+               {
+                       name: "without required permission",
+                       args: args{
+                               cc: &ClientConn{
+                                       Account: &Account{
+                                               Access: func() accessBitmap {
+                                                       var bits accessBitmap
+                                                       return bits
+                                               }(),
+                                       },
+                               },
+                               t: NewTransaction(
+                                       TranPostNewsArt,
+                                       [2]byte{0, 0},
+                               ),
+                       },
+                       wantRes: []Transaction{
+                               {
+                                       IsReply:   0x01,
+                                       ErrorCode: [4]byte{0, 0, 0, 1},
+                                       Fields: []Field{
+                                               NewField(FieldError, []byte("You are not allowed to post news articles.")),
+                                       },
+                               },
+                       },
+               },
+               {
+                       name: "with required permission",
+                       args: args{
+                               cc: &ClientConn{
+                                       Server: &Server{
+                                               FS: func() *MockFileStore {
+                                                       mfs := &MockFileStore{}
+                                                       mfs.On("WriteFile", "ThreadedNews.yaml", mock.Anything, mock.Anything).Return(nil, os.ErrNotExist)
+                                                       return mfs
+                                               }(),
+                                               mux:             sync.Mutex{},
+                                               threadedNewsMux: sync.Mutex{},
+                                               ThreadedNews: &ThreadedNews{
+                                                       Categories: map[string]NewsCategoryListData15{
+                                                               "www": {
+                                                                       Type:       [2]byte{},
+                                                                       Name:       "www",
+                                                                       Articles:   map[uint32]*NewsArtData{},
+                                                                       SubCats:    nil,
+                                                                       GUID:       [16]byte{},
+                                                                       AddSN:      [4]byte{},
+                                                                       DeleteSN:   [4]byte{},
+                                                                       readOffset: 0,
+                                                               },
+                                                       },
+                                               },
+                                       },
+                                       Account: &Account{
+                                               Access: func() accessBitmap {
+                                                       var bits accessBitmap
+                                                       bits.Set(accessNewsPostArt)
+                                                       return bits
+                                               }(),
+                                       },
+                               },
+                               t: NewTransaction(
+                                       TranPostNewsArt,
+                                       [2]byte{0, 0},
+                                       NewField(FieldNewsPath, []byte{0x00, 0x01, 0x00, 0x00, 0x03, 0x77, 0x77, 0x77}),
+                                       NewField(FieldNewsArtID, []byte{0x00, 0x00, 0x00, 0x00}),
+                               ),
+                       },
+                       wantRes: []Transaction{
+                               {
+                                       IsReply:   0x01,
+                                       ErrorCode: [4]byte{0, 0, 0, 0},
+                                       Fields:    []Field{},
+                               },
+                       },
+               },
+       }
+       for _, tt := range tests {
+               t.Run(tt.name, func(t *testing.T) {
+                       tranAssertEqual(t, tt.wantRes, HandlePostNewsArt(tt.args.cc, &tt.args.t))
+               })
+       }
+}