fork/gdu

git clone https://git.julia.blue/fork/gdu

Daniel Mildefeat: show bar for item count (#649)daaae96

master
7.3 KiB426 linesraw
1package analyze
2
3import (
4	"slices"
5	"testing"
6	"time"
7
8	"github.com/dundee/gdu/v5/pkg/fs"
9	"github.com/stretchr/testify/assert"
10)
11
12func TestIsDir(t *testing.T) {
13	dir := Dir{
14		File: &File{
15			Name: "xxx",
16			Size: 5,
17		},
18		ItemCount: 2,
19	}
20	file := &File{
21		Name:   "yyy",
22		Size:   2,
23		Parent: &dir,
24	}
25	dir.Files = fs.Files{file}
26
27	assert.True(t, dir.IsDir())
28	assert.False(t, file.IsDir())
29}
30
31func TestGetType(t *testing.T) {
32	dir := Dir{
33		File: &File{
34			Name: "xxx",
35			Size: 5,
36		},
37		ItemCount: 2,
38	}
39	file := &File{
40		Name:   "yyy",
41		Size:   2,
42		Parent: &dir,
43		Flag:   ' ',
44	}
45	file2 := &File{
46		Name:   "yyy",
47		Size:   2,
48		Parent: &dir,
49		Flag:   '@',
50	}
51	dir.Files = fs.Files{file, file2}
52
53	assert.Equal(t, "Directory", dir.GetType())
54	assert.Equal(t, "File", file.GetType())
55	assert.Equal(t, "Other", file2.GetType())
56}
57
58func TestFind(t *testing.T) {
59	dir := Dir{
60		File: &File{
61			Name: "xxx",
62			Size: 5,
63		},
64		ItemCount: 2,
65	}
66
67	file := &File{
68		Name:   "yyy",
69		Size:   2,
70		Parent: &dir,
71	}
72	file2 := &File{
73		Name:   "zzz",
74		Size:   3,
75		Parent: &dir,
76	}
77	dir.Files = fs.Files{file, file2}
78
79	i, _ := dir.Files.IndexOf(file)
80	assert.Equal(t, 0, i)
81	i, _ = dir.Files.IndexOf(file2)
82	assert.Equal(t, 1, i)
83}
84
85func TestRemove(t *testing.T) {
86	dir := Dir{
87		File: &File{
88			Name: "xxx",
89			Size: 5,
90		},
91		ItemCount: 2,
92	}
93
94	file := &File{
95		Name:   "yyy",
96		Size:   2,
97		Parent: &dir,
98	}
99	file2 := &File{
100		Name:   "zzz",
101		Size:   3,
102		Parent: &dir,
103	}
104	dir.Files = fs.Files{file, file2}
105
106	dir.Files = dir.Files.Remove(file)
107
108	assert.Equal(t, 1, len(dir.Files))
109	assert.Equal(t, file2, dir.Files[0])
110}
111
112func TestRemoveByName(t *testing.T) {
113	dir := Dir{
114		File: &File{
115			Name:  "xxx",
116			Size:  5,
117			Usage: 8,
118		},
119		ItemCount: 2,
120	}
121
122	file := &File{
123		Name:   "yyy",
124		Size:   2,
125		Usage:  4,
126		Parent: &dir,
127	}
128	file2 := &File{
129		Name:   "zzz",
130		Size:   3,
131		Usage:  4,
132		Parent: &dir,
133	}
134	dir.Files = fs.Files{file, file2}
135
136	dir.Files = dir.Files.RemoveByName("yyy")
137
138	assert.Equal(t, 1, len(dir.Files))
139	assert.Equal(t, file2, dir.Files[0])
140}
141
142func TestRemoveNotInDir(t *testing.T) {
143	dir := Dir{
144		File: &File{
145			Name:  "xxx",
146			Size:  5,
147			Usage: 8,
148		},
149		ItemCount: 2,
150	}
151
152	file := &File{
153		Name:   "yyy",
154		Size:   2,
155		Usage:  4,
156		Parent: &dir,
157	}
158	file2 := &File{
159		Name:  "zzz",
160		Size:  3,
161		Usage: 4,
162	}
163	dir.Files = fs.Files{file}
164
165	_, ok := dir.Files.IndexOf(file2)
166	assert.Equal(t, false, ok)
167
168	dir.Files = dir.Files.Remove(file2)
169
170	assert.Equal(t, 1, len(dir.Files))
171}
172
173func TestRemoveByNameNotInDir(t *testing.T) {
174	dir := Dir{
175		File: &File{
176			Name:  "xxx",
177			Size:  5,
178			Usage: 8,
179		},
180		ItemCount: 2,
181	}
182
183	file := &File{
184		Name:   "yyy",
185		Size:   2,
186		Usage:  4,
187		Parent: &dir,
188	}
189	file2 := &File{
190		Name:  "zzz",
191		Size:  3,
192		Usage: 4,
193	}
194	dir.Files = fs.Files{file}
195
196	_, ok := dir.Files.IndexOf(file2)
197	assert.Equal(t, false, ok)
198
199	dir.Files = dir.Files.RemoveByName("zzz")
200
201	assert.Equal(t, 1, len(dir.Files))
202}
203
204func TestUpdateStats(t *testing.T) {
205	dir := Dir{
206		File: &File{
207			Name:  "xxx",
208			Size:  1,
209			Mtime: time.Date(2021, 8, 19, 0, 40, 0, 0, time.UTC),
210		},
211		ItemCount: 1,
212	}
213
214	file := &File{
215		Name:   "yyy",
216		Size:   2,
217		Mtime:  time.Date(2021, 8, 19, 0, 41, 0, 0, time.UTC),
218		Parent: &dir,
219	}
220	file2 := &File{
221		Name:   "zzz",
222		Size:   3,
223		Mtime:  time.Date(2021, 8, 19, 0, 42, 0, 0, time.UTC),
224		Parent: &dir,
225	}
226	dir.Files = fs.Files{file, file2}
227
228	dir.UpdateStats(nil)
229
230	assert.Equal(t, int64(5), dir.Size)
231	assert.Equal(t, 42, dir.GetMtime().Minute())
232}
233
234func TestUpdateStatsWithFileFiltering(t *testing.T) {
235	dir := Dir{
236		File: &File{
237			Name:  "xxx",
238			Size:  1,
239			Mtime: time.Date(2021, 8, 19, 0, 40, 0, 0, time.UTC),
240		},
241		ItemCount: 1,
242	}
243
244	file := &File{
245		Name:   "yyy.go",
246		Size:   2,
247		Usage:  2048,
248		Mtime:  time.Date(2021, 8, 19, 0, 41, 0, 0, time.UTC),
249		Parent: &dir,
250	}
251	file2 := &File{
252		Name:   "zzz.go",
253		Size:   3,
254		Usage:  1024,
255		Mtime:  time.Date(2021, 8, 19, 0, 42, 0, 0, time.UTC),
256		Parent: &dir,
257	}
258	subdir := &Dir{
259		File: &File{
260			Name:   "subdir",
261			Size:   4,
262			Mtime:  time.Date(2021, 8, 19, 0, 43, 0, 0, time.UTC),
263			Parent: &dir,
264		},
265		ItemCount: 1,
266	}
267	subsubdir := &Dir{
268		File: &File{
269			Name:   "subsubdir",
270			Size:   4,
271			Mtime:  time.Date(2021, 8, 19, 0, 43, 0, 0, time.UTC),
272			Parent: subdir,
273		},
274		ItemCount: 1,
275	}
276	subdir.Files = fs.Files{subsubdir}
277	dir.Files = fs.Files{file, file2, subdir}
278
279	dir.UpdateStatsWithFileFiltering(nil)
280
281	assert.Equal(t, int64(1024+5), dir.Size)
282	assert.Equal(t, int64(4), dir.ItemCount)
283	assert.Equal(t, int64(1024+2048), dir.Usage)
284	assert.Equal(t, 43, dir.GetMtime().Minute())
285}
286
287func TestGetMultiLinkedInode(t *testing.T) {
288	file := &File{
289		Name: "xxx",
290		Mli:  5,
291	}
292
293	assert.Equal(t, uint64(5), file.GetMultiLinkedInode())
294}
295
296func TestGetPathWithoutLeadingSlash(t *testing.T) {
297	dir := &Dir{
298		File: &File{
299			Name:  "C:\\",
300			Size:  5,
301			Usage: 12,
302		},
303		ItemCount: 3,
304		BasePath:  "",
305	}
306
307	assert.Equal(t, "C:\\", dir.GetPath())
308}
309
310func TestSetParent(t *testing.T) {
311	dir := &Dir{
312		File: &File{
313			Name:  "root",
314			Size:  5,
315			Usage: 12,
316		},
317		ItemCount: 3,
318		BasePath:  "/",
319	}
320	file := &File{
321		Name: "xxx",
322		Mli:  5,
323	}
324	file.SetParent(dir)
325
326	assert.Equal(t, "root", file.GetParent().GetName())
327}
328
329func TestGetFiles(t *testing.T) {
330	file := &File{
331		Name: "xxx",
332		Mli:  5,
333	}
334	dir := &Dir{
335		File: &File{
336			Name:  "root",
337			Size:  5,
338			Usage: 12,
339		},
340		ItemCount: 3,
341		BasePath:  "/",
342		Files:     fs.Files{file},
343	}
344
345	dirFiles := slices.Collect(dir.GetFiles(fs.SortByName, fs.SortAsc))
346	assert.Equal(t, file.Name, dirFiles[0].GetName())
347	fileFiles := slices.Collect(file.GetFiles(fs.SortByName, fs.SortAsc))
348	assert.Equal(t, 0, len(fileFiles))
349}
350
351func TestGetFilesLocked(t *testing.T) {
352	file := &File{
353		Name: "xxx",
354		Mli:  5,
355	}
356	dir := &Dir{
357		File: &File{
358			Name:  "root",
359			Size:  5,
360			Usage: 12,
361		},
362		ItemCount: 3,
363		BasePath:  "/",
364		Files:     fs.Files{file},
365	}
366
367	unlock := dir.RLock()
368	defer unlock()
369	files := slices.Collect(dir.GetFiles(fs.SortByName, fs.SortAsc))
370	locked := slices.Collect(dir.GetFilesLocked(fs.SortByName, fs.SortAsc))
371	assert.Equal(t, len(files), len(locked))
372	assert.Equal(t, files[0].GetName(), locked[0].GetName())
373}
374
375func TestAddFilePanicsOnFile(t *testing.T) {
376	file := &File{
377		Name: "xxx",
378		Mli:  5,
379	}
380	assert.Panics(t, func() {
381		file.AddFile(file)
382	})
383}
384
385func TestStatsFromJSONArePreserved(t *testing.T) {
386	dir := &Dir{
387		File: &File{
388			Name:  "summary",
389			Size:  4096,
390			Usage: 2048,
391		},
392		ItemCount: 2,
393	}
394	dir.SetStatsFromJSON()
395
396	dir.UpdateStats(make(fs.HardLinkedItems, 10))
397	assert.Equal(t, int64(4096), dir.GetSize())
398	assert.Equal(t, int64(2048), dir.GetUsage())
399	assert.Equal(t, int64(2), dir.GetItemCount())
400
401	dir.UpdateStatsWithFileFiltering(make(fs.HardLinkedItems, 10))
402	count, size, usage := dir.GetItemStats(make(fs.HardLinkedItems, 10), true)
403	assert.Equal(t, int64(2), count)
404	assert.Equal(t, int64(4096), size)
405	assert.Equal(t, int64(2048), usage)
406}
407
408func TestDisplayedItemCount(t *testing.T) {
409	file := &File{Name: "file"}
410
411	emptyDir := &Dir{
412		File:      &File{Name: "empty"},
413		ItemCount: 1,
414	}
415
416	dirWithThree := &Dir{
417		File:      &File{Name: "three"},
418		ItemCount: 4,
419	}
420
421	// a file counts itself
422	assert.Equal(t, int64(1), fs.DisplayedItemCount(file))
423	// a directory does not count itself
424	assert.Equal(t, int64(0), fs.DisplayedItemCount(emptyDir))
425	assert.Equal(t, int64(3), fs.DisplayedItemCount(dirWithThree))
426}