1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
package hotline
import (
"bytes"
"encoding/binary"
"os"
"path/filepath"
"reflect"
"testing"
)
func TestEncodeFilePath(t *testing.T) {
var tests = []struct {
filePath string
want []byte
}{
{
filePath: "kitten1.jpg",
want: []byte{
0x00, 0x01, // number of items in path
0x00, 0x00, // leading path separator
0x0b, // length of next path section (11)
0x6b, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x31, 0x2e, 0x6a, 0x70, 0x67, // kitten1.jpg
},
},
{
filePath: "foo/kitten1.jpg",
want: []byte{
0x00, 0x02, // number of items in path
0x00, 0x00,
0x03,
0x66, 0x6f, 0x6f,
0x00, 0x00, // leading path separator
0x0b, // length of next path section (11)
0x6b, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x31, 0x2e, 0x6a, 0x70, 0x67, // kitten1.jpg
},
},
}
for _, test := range tests {
got := EncodeFilePath(test.filePath)
if !bytes.Equal(got, test.want) {
t.Errorf("field mismatch: want: %#v got: %#v", test.want, got)
}
}
}
func TestCalcTotalSize(t *testing.T) {
cwd, _ := os.Getwd()
defer func() { _ = os.Chdir(cwd) }()
_ = os.Chdir("test/config/Files")
type args struct {
filePath string
}
tests := []struct {
name string
args args
want []byte
wantErr bool
}{
{
name: "Foo",
args: args{
filePath: "test",
},
want: []byte{0x00, 0x00, 0x18, 0x00},
wantErr: false,
},
// TODO: Add more test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := CalcTotalSize(tt.args.filePath)
if (err != nil) != tt.wantErr {
t.Errorf("CalcTotalSize() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("CalcTotalSize() got = %v, want %v", got, tt.want)
}
})
}
}
func createTestDirStructure(baseDir string, structure map[string]string) error {
// First pass: create directories
for path, content := range structure {
if content == "dir" {
if err := os.MkdirAll(filepath.Join(baseDir, path), 0755); err != nil {
return err
}
}
}
// Second pass: create files
for path, content := range structure {
if content != "dir" {
fullPath := filepath.Join(baseDir, path)
dir := filepath.Dir(fullPath)
if err := os.MkdirAll(dir, 0755); err != nil {
return err
}
if err := os.WriteFile(fullPath, []byte(content), 0644); err != nil {
return err
}
}
}
return nil
}
func TestCalcItemCount(t *testing.T) {
tests := []struct {
name string
structure map[string]string
expected uint16
}{
{
name: "directory with files",
structure: map[string]string{
"file1.txt": "content1",
"file2.txt": "content2",
"subdir/": "dir",
"subdir/file3.txt": "content3",
},
expected: 4, // 3 files and 1 directory, should count 4 items
},
{
name: "directory with hidden files",
structure: map[string]string{
".hiddenfile": "hiddencontent",
"file1.txt": "content1",
},
expected: 1, // 1 non-hidden file
},
{
name: "empty directory",
structure: map[string]string{},
expected: 0, // 0 files
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Create a temporary directory for the test
tempDir, err := os.MkdirTemp("", "test")
if err != nil {
t.Fatalf("Failed to create temp dir: %v", err)
}
defer os.RemoveAll(tempDir)
// Create the test directory structure
if err := createTestDirStructure(tempDir, tt.structure); err != nil {
t.Fatalf("Failed to create test dir structure: %v", err)
}
// Calculate item count
result, err := CalcItemCount(tempDir)
if err != nil {
t.Fatalf("CalcItemCount returned an error: %v", err)
}
// Convert result to uint16
count := binary.BigEndian.Uint16(result)
if count != tt.expected {
t.Errorf("expected %d, got %d", tt.expected, count)
}
})
}
}
|
