fork/gdu

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

Daniel Mildefix: correct item count and size for empty dirs (#574)272c209

subvolume
9.9 KiB354 linesraw
1package analyze
2
3import (
4	"os"
5	"sort"
6	"testing"
7
8	log "github.com/sirupsen/logrus"
9
10	"github.com/dundee/gdu/v5/internal/testdir"
11	"github.com/dundee/gdu/v5/pkg/fs"
12	"github.com/stretchr/testify/assert"
13)
14
15func init() {
16	log.SetLevel(log.WarnLevel)
17}
18
19func TestAnalyzeDir(t *testing.T) {
20	fin := testdir.CreateTestDir()
21	defer fin()
22
23	analyzer := CreateAnalyzer()
24	dir := analyzer.AnalyzeDir(
25		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
26	).(*Dir)
27
28	progress := analyzer.GetProgress()
29	assert.GreaterOrEqual(t, progress.TotalUsage, int64(0))
30
31	analyzer.GetDone().Wait()
32	analyzer.ResetProgress()
33	dir.UpdateStats(make(fs.HardLinkedItems))
34
35	// test dir info
36	assert.Equal(t, "test_dir", dir.Name)
37	assert.Equal(t, int64(7), dir.Size)
38	assert.Equal(t, int64(5), dir.ItemCount)
39	assert.True(t, dir.IsDir())
40
41	// test dir tree
42	assert.Equal(t, "nested", dir.Files[0].GetName())
43	assert.Equal(t, "subnested", dir.Files[0].(*Dir).Files[1].GetName())
44
45	// test file
46	assert.Equal(t, "file2", dir.Files[0].(*Dir).Files[0].GetName())
47	assert.Equal(t, int64(2), dir.Files[0].(*Dir).Files[0].GetSize())
48
49	assert.Equal(
50		t, "file", dir.Files[0].(*Dir).Files[1].(*Dir).Files[0].GetName(),
51	)
52	assert.Equal(
53		t, int64(5), dir.Files[0].(*Dir).Files[1].(*Dir).Files[0].GetSize(),
54	)
55
56	// test parent link
57	assert.Equal(
58		t,
59		"test_dir",
60		dir.Files[0].(*Dir).
61			Files[1].(*Dir).
62			Files[0].
63			GetParent().
64			GetParent().
65			GetParent().
66			GetName(),
67	)
68}
69
70func TestIgnoreDir(t *testing.T) {
71	fin := testdir.CreateTestDir()
72	defer fin()
73
74	dir := CreateAnalyzer().AnalyzeDir(
75		"test_dir", func(_, _ string) bool { return true }, func(_ string) bool { return false },
76	).(*Dir)
77
78	assert.Equal(t, "test_dir", dir.Name)
79	assert.Equal(t, int64(1), dir.ItemCount)
80}
81
82func TestFlags(t *testing.T) {
83	fin := testdir.CreateTestDir()
84	defer fin()
85
86	err := os.Mkdir("test_dir/empty", 0o644)
87	assert.Nil(t, err)
88
89	err = os.Symlink("test_dir/nested/file2", "test_dir/nested/file3")
90	assert.Nil(t, err)
91
92	analyzer := CreateAnalyzer()
93	dir := analyzer.AnalyzeDir(
94		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
95	).(*Dir)
96	analyzer.GetDone().Wait()
97	dir.UpdateStats(make(fs.HardLinkedItems))
98
99	sort.Sort(sort.Reverse(dir.Files))
100
101	assert.Equal(t, int64(28+512), dir.Size)
102	assert.Equal(t, int64(7), dir.ItemCount)
103
104	// test file3
105	assert.Equal(t, "nested", dir.Files[0].GetName())
106	assert.Equal(t, "file3", dir.Files[0].(*Dir).Files[1].GetName())
107	assert.Equal(t, int64(21), dir.Files[0].(*Dir).Files[1].GetSize())
108	assert.Equal(t, '@', dir.Files[0].(*Dir).Files[1].GetFlag())
109
110	assert.Equal(t, 'e', dir.Files[1].GetFlag())
111}
112
113func TestHardlink(t *testing.T) {
114	fin := testdir.CreateTestDir()
115	defer fin()
116
117	err := os.Link("test_dir/nested/file2", "test_dir/nested/file3")
118	assert.Nil(t, err)
119
120	analyzer := CreateAnalyzer()
121	dir := analyzer.AnalyzeDir(
122		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
123	).(*Dir)
124	analyzer.GetDone().Wait()
125	dir.UpdateStats(make(fs.HardLinkedItems))
126
127	assert.Equal(t, int64(7), dir.Size)      // file2 and file3 are counted just once for size
128	assert.Equal(t, int64(6), dir.ItemCount) // but twice for item count
129
130	// test file3
131	assert.Equal(t, "file3", dir.Files[0].(*Dir).Files[1].GetName())
132	assert.Equal(t, int64(2), dir.Files[0].(*Dir).Files[1].GetSize())
133	assert.Equal(t, 'H', dir.Files[0].(*Dir).Files[1].GetFlag())
134}
135
136func TestFollowSymlink(t *testing.T) {
137	fin := testdir.CreateTestDir()
138	defer fin()
139
140	err := os.Mkdir("test_dir/empty", 0o644)
141	assert.Nil(t, err)
142
143	err = os.Symlink("./file2", "test_dir/nested/file3")
144	assert.Nil(t, err)
145
146	analyzer := CreateAnalyzer()
147	analyzer.SetFollowSymlinks(true)
148	dir := analyzer.AnalyzeDir(
149		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
150	).(*Dir)
151	analyzer.GetDone().Wait()
152	dir.UpdateStats(make(fs.HardLinkedItems))
153
154	sort.Sort(sort.Reverse(dir.Files))
155
156	assert.Equal(t, int64(9+512), dir.Size)
157	assert.Equal(t, int64(7), dir.ItemCount)
158
159	// test file3
160	assert.Equal(t, "nested", dir.Files[0].GetName())
161	assert.Equal(t, "file3", dir.Files[0].(*Dir).Files[1].GetName())
162	assert.Equal(t, int64(2), dir.Files[0].(*Dir).Files[1].GetSize())
163	assert.Equal(t, ' ', dir.Files[0].(*Dir).Files[1].GetFlag())
164
165	assert.Equal(t, 'e', dir.Files[1].GetFlag())
166}
167
168func TestGitAnnexSymlink(t *testing.T) {
169	fin := testdir.CreateTestDir()
170	defer fin()
171
172	err := os.Mkdir("test_dir/empty", 0o644)
173	assert.Nil(t, err)
174
175	err = os.Symlink(
176		".git/annex/objects/qx/qX/SHA256E-s967858083--"+
177			"3e54803fded8dc3a9ea68b106f7b51e04e33c79b4a7b32a860f0b22d89af5c65.mp4/SHA256E-s967858083--"+
178			"3e54803fded8dc3a9ea68b106f7b51e04e33c79b4a7b32a860f0b22d89af5c65.mp4",
179		"test_dir/nested/file3")
180	assert.Nil(t, err)
181
182	analyzer := CreateAnalyzer()
183	analyzer.SetFollowSymlinks(true)
184	analyzer.SetShowAnnexedSize(true)
185	dir := analyzer.AnalyzeDir(
186		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
187	).(*Dir)
188	analyzer.GetDone().Wait()
189	dir.UpdateStats(make(fs.HardLinkedItems))
190
191	sort.Sort(sort.Reverse(dir.Files))
192
193	assert.Equal(t, int64(967858083+7+512), dir.Size)
194	assert.Equal(t, int64(7), dir.ItemCount)
195
196	// test file3
197	assert.Equal(t, "nested", dir.Files[0].GetName())
198	assert.Equal(t, "file3", dir.Files[0].(*Dir).Files[1].GetName())
199	assert.Equal(t, int64(967858083), dir.Files[0].(*Dir).Files[1].GetSize())
200	assert.Equal(t, '@', dir.Files[0].(*Dir).Files[1].GetFlag())
201
202	assert.Equal(t, 'e', dir.Files[1].GetFlag())
203}
204
205func TestBrokenSymlinkSkipped(t *testing.T) {
206	fin := testdir.CreateTestDir()
207	defer fin()
208
209	err := os.Mkdir("test_dir/empty", 0o644)
210	assert.Nil(t, err)
211
212	err = os.Symlink("xxx", "test_dir/nested/file3")
213	assert.Nil(t, err)
214
215	analyzer := CreateAnalyzer()
216	analyzer.SetFollowSymlinks(true)
217	dir := analyzer.AnalyzeDir(
218		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
219	).(*Dir)
220	analyzer.GetDone().Wait()
221	dir.UpdateStats(make(fs.HardLinkedItems))
222
223	sort.Sort(sort.Reverse(dir.Files))
224
225	assert.Equal(t, int64(7+512), dir.Size)
226	assert.Equal(t, int64(6), dir.ItemCount)
227
228	assert.Equal(t, '!', dir.Files[0].GetFlag())
229}
230
231func BenchmarkAnalyzeDir(b *testing.B) {
232	fin := testdir.CreateTestDir()
233	defer fin()
234
235	b.ResetTimer()
236
237	analyzer := CreateAnalyzer()
238	dir := analyzer.AnalyzeDir(
239		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
240	)
241	analyzer.GetDone().Wait()
242	dir.UpdateStats(make(fs.HardLinkedItems))
243}
244
245func TestParallelStableOrderAnalyzerDeterminism(t *testing.T) {
246	fin := testdir.CreateTestDir()
247	defer fin()
248
249	// Run parallel analyzer multiple times and verify results are identical
250	var results [][]string
251	for i := 0; i < 5; i++ {
252		analyzer := CreateStableOrderAnalyzer()
253		dir := analyzer.AnalyzeDir(
254			"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
255		)
256		analyzer.GetDone().Wait()
257		dir.UpdateStats(make(fs.HardLinkedItems))
258
259		names := getFileNames(dir)
260		results = append(results, names)
261	}
262
263	// All runs should produce identical results
264	for i := 1; i < len(results); i++ {
265		assert.Equal(t, results[0], results[i],
266			"Parallel analyzer run %d produced different results than run 0", i)
267	}
268}
269
270func TestParallelVsSequentialConsistency(t *testing.T) {
271	fin := testdir.CreateTestDir()
272	defer fin()
273
274	// Run sequential analyzer
275	seqAnalyzer := CreateSeqAnalyzer()
276	seqDir := seqAnalyzer.AnalyzeDir(
277		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
278	)
279	seqAnalyzer.GetDone().Wait()
280	seqDir.UpdateStats(make(fs.HardLinkedItems))
281	seqNames := getFileNames(seqDir)
282
283	// Run parallel analyzer
284	parAnalyzer := CreateStableOrderAnalyzer()
285	parDir := parAnalyzer.AnalyzeDir(
286		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
287	)
288	parAnalyzer.GetDone().Wait()
289	parDir.UpdateStats(make(fs.HardLinkedItems))
290	parNames := getFileNames(parDir)
291
292	// Results should match
293	assert.Equal(t, seqNames, parNames,
294		"Parallel and sequential analyzers produced different results")
295}
296
297func TestFileDirectoryInterleaving(t *testing.T) {
298	// Create test directory with interleaved files and directories
299	err := os.MkdirAll("test_interleave/aaa_dir", 0755)
300	assert.NoError(t, err)
301	err = os.WriteFile("test_interleave/bbb_file", []byte("content"), 0644)
302	assert.NoError(t, err)
303	err = os.MkdirAll("test_interleave/ccc_dir", 0755)
304	assert.NoError(t, err)
305	err = os.WriteFile("test_interleave/ddd_file", []byte("content"), 0644)
306	assert.NoError(t, err)
307	defer os.RemoveAll("test_interleave")
308
309	// Run sequential analyzer
310	seqAnalyzer := CreateSeqAnalyzer()
311	seqDir := seqAnalyzer.AnalyzeDir(
312		"test_interleave", func(_, _ string) bool { return false }, func(_ string) bool { return false },
313	).(*Dir)
314	seqAnalyzer.GetDone().Wait()
315
316	// Run parallel analyzer
317	parAnalyzer := CreateStableOrderAnalyzer()
318	parDir := parAnalyzer.AnalyzeDir(
319		"test_interleave", func(_, _ string) bool { return false }, func(_ string) bool { return false },
320	).(*Dir)
321	parAnalyzer.GetDone().Wait()
322
323	// Extract file/dir names in order
324	seqOrder := make([]string, len(seqDir.Files))
325	for i, item := range seqDir.Files {
326		seqOrder[i] = item.GetName()
327	}
328
329	parOrder := make([]string, len(parDir.Files))
330	for i, item := range parDir.Files {
331		parOrder[i] = item.GetName()
332	}
333
334	// The order must be identical: [aaa_dir, bbb_file, ccc_dir, ddd_file]
335	assert.Equal(t, seqOrder, parOrder,
336		"Parallel analyzer did not preserve file/directory interleaving")
337
338	// Verify the expected order (alphabetical from os.ReadDir)
339	assert.Equal(t, "aaa_dir", seqOrder[0])
340	assert.Equal(t, "bbb_file", seqOrder[1])
341	assert.Equal(t, "ccc_dir", seqOrder[2])
342	assert.Equal(t, "ddd_file", seqOrder[3])
343}
344
345// getFileNames recursively collects file names from a directory tree
346func getFileNames(item fs.Item) []string {
347	names := []string{item.GetName()}
348	if item.IsDir() {
349		for child := range item.GetFiles(fs.SortByName, fs.SortAsc) {
350			names = append(names, getFileNames(child)...)
351		}
352	}
353	return names
354}