fork/gdu

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

yurenchen000Feat: Show symlink target #260 (#612)1eaa266

ignore
22.5 KiB759 linesraw
1package stdout
2
3import (
4	"bytes"
5	"os"
6	"path/filepath"
7	"regexp"
8	"strings"
9	"testing"
10
11	log "github.com/sirupsen/logrus"
12
13	"github.com/dundee/gdu/v5/internal/testanalyze"
14	"github.com/dundee/gdu/v5/internal/testdev"
15	"github.com/dundee/gdu/v5/internal/testdir"
16	"github.com/dundee/gdu/v5/pkg/analyze"
17	"github.com/dundee/gdu/v5/pkg/device"
18	"github.com/stretchr/testify/assert"
19)
20
21func init() {
22	log.SetLevel(log.WarnLevel)
23}
24
25func TestMain(m *testing.M) {
26	os.Unsetenv("BLOCK_SIZE")
27	os.Unsetenv("BLOCKSIZE")
28	os.Exit(m.Run())
29}
30
31func TestAnalyzePath(t *testing.T) {
32	fin := testdir.CreateTestDir()
33	defer fin()
34
35	buff := make([]byte, 10)
36	output := bytes.NewBuffer(buff)
37
38	ui := CreateStdoutUI(output, false, false, false, false, false, false, false, "", 0, false, 0)
39	ui.SetIgnoreDirPaths([]string{"/xxx"})
40	err := ui.AnalyzePath("test_dir", nil)
41	assert.Nil(t, err)
42	err = ui.StartUILoop()
43
44	assert.Nil(t, err)
45	assert.Contains(t, output.String(), "nested")
46}
47
48func TestShowItemCountInNonInteractiveMode(t *testing.T) {
49	tmpDir := t.TempDir()
50
51	for dirName, fileCount := range map[string]int{"a": 5, "b": 10, "c": 15} {
52		dirPath := filepath.Join(tmpDir, dirName)
53		err := os.Mkdir(dirPath, 0o755)
54		assert.Nil(t, err)
55
56		for i := 0; i < fileCount; i++ {
57			filePath := filepath.Join(dirPath, "f"+string(rune('a'+i)))
58			err = os.WriteFile(filePath, []byte("x"), 0o644)
59			assert.Nil(t, err)
60		}
61	}
62
63	output := bytes.NewBuffer(make([]byte, 10))
64	ui := CreateStdoutUI(output, false, false, false, false, false, false, false, "", 0, false, 0)
65	ui.SetShowItemCount()
66
67	err := ui.AnalyzePath(tmpDir, nil)
68	assert.Nil(t, err)
69
70	out := output.String()
71	assert.Regexp(t, regexp.MustCompile(`(?m)\s+5\s+/a$`), out)
72	assert.Regexp(t, regexp.MustCompile(`(?m)\s+10\s+/b$`), out)
73	assert.Regexp(t, regexp.MustCompile(`(?m)\s+15\s+/c$`), out)
74}
75
76func TestShowItemCountInNonInteractiveModeWithColorsAndFile(t *testing.T) {
77	tmpDir := t.TempDir()
78	filePath := filepath.Join(tmpDir, "single")
79	err := os.WriteFile(filePath, []byte("x"), 0o644)
80	assert.Nil(t, err)
81
82	output := bytes.NewBuffer(make([]byte, 10))
83	ui := CreateStdoutUI(output, true, false, false, false, false, false, false, "", 0, false, 0)
84	ui.SetShowItemCount()
85
86	err = ui.AnalyzePath(tmpDir, nil)
87	assert.Nil(t, err)
88
89	out := output.String()
90	assert.Regexp(t, regexp.MustCompile(`(?m)\s+1\s+single$`), out)
91}
92
93func TestShowSummaryApparentSizeForFilePath(t *testing.T) {
94	tmpDir := t.TempDir()
95	filePath := filepath.Join(tmpDir, "small.txt")
96	err := os.WriteFile(filePath, []byte("hello"), 0o644)
97	assert.Nil(t, err)
98
99	output := bytes.NewBuffer(make([]byte, 10))
100
101	// showApparentSize=true, summarize=true
102	ui := CreateStdoutUI(output, false, false, true, false, true, false, false, "", 0, false, 0)
103	err = ui.AnalyzePath(filePath, nil)
104	assert.Nil(t, err)
105
106	out := output.String()
107	// With apparent size, a 5-byte file should show "5 B", not "4.0 KiB"
108	assert.Contains(t, out, "5 B")
109	assert.Contains(t, out, "small.txt")
110}
111
112func TestShowSummaryDiskUsageForFilePath(t *testing.T) {
113	tmpDir := t.TempDir()
114	filePath := filepath.Join(tmpDir, "small.txt")
115	err := os.WriteFile(filePath, []byte("hello"), 0o644)
116	assert.Nil(t, err)
117
118	output := bytes.NewBuffer(make([]byte, 10))
119
120	// showApparentSize=false, summarize=true
121	ui := CreateStdoutUI(output, false, false, false, false, true, false, false, "", 0, false, 0)
122	err = ui.AnalyzePath(filePath, nil)
123	assert.Nil(t, err)
124
125	out := output.String()
126	// Without apparent size, should show disk usage (>= 5 bytes, typically 4 KiB)
127	assert.Contains(t, out, "small.txt")
128	assert.NotContains(t, out, "5 B")
129}
130
131func TestShowSummary(t *testing.T) {
132	fin := testdir.CreateTestDir()
133	defer fin()
134
135	buff := make([]byte, 10)
136	output := bytes.NewBuffer(buff)
137
138	ui := CreateStdoutUI(output, true, false, true, false, true, false, false, "", 0, false, 0)
139	ui.SetIgnoreDirPaths([]string{"/xxx"})
140	err := ui.AnalyzePath("test_dir", nil)
141	assert.Nil(t, err)
142	err = ui.StartUILoop()
143
144	assert.Nil(t, err)
145	assert.Contains(t, output.String(), "test_dir")
146}
147
148func TestShowSummaryBw(t *testing.T) {
149	fin := testdir.CreateTestDir()
150	defer fin()
151
152	buff := make([]byte, 10)
153	output := bytes.NewBuffer(buff)
154
155	ui := CreateStdoutUI(output, false, false, false, false, true, false, false, "", 0, false, 0)
156	ui.SetIgnoreDirPaths([]string{"/xxx"})
157	err := ui.AnalyzePath("test_dir", nil)
158	assert.Nil(t, err)
159	err = ui.StartUILoop()
160
161	assert.Nil(t, err)
162	assert.Contains(t, output.String(), "test_dir")
163}
164
165func TestShowTop(t *testing.T) {
166	fin := testdir.CreateTestDir()
167	defer fin()
168
169	buff := make([]byte, 10)
170	output := bytes.NewBuffer(buff)
171
172	ui := CreateStdoutUI(output, true, false, true, false, true, false, false, "", 2, false, 0)
173	ui.SetIgnoreDirPaths([]string{"/xxx"})
174	err := ui.AnalyzePath("test_dir", nil)
175	assert.Nil(t, err)
176	err = ui.StartUILoop()
177
178	assert.Nil(t, err)
179	assert.Contains(t, output.String(), "test_dir/nested/subnested/file")
180	assert.Contains(t, output.String(), "test_dir/nested/file2")
181}
182
183func TestShowTopBw(t *testing.T) {
184	fin := testdir.CreateTestDir()
185	defer fin()
186
187	buff := make([]byte, 10)
188	output := bytes.NewBuffer(buff)
189
190	ui := CreateStdoutUI(output, false, false, false, false, true, false, false, "", 2, false, 0)
191	ui.SetIgnoreDirPaths([]string{"/xxx"})
192	err := ui.AnalyzePath("test_dir", nil)
193	assert.Nil(t, err)
194	err = ui.StartUILoop()
195
196	assert.Nil(t, err)
197	assert.Contains(t, output.String(), "test_dir/nested/subnested/file")
198	assert.Contains(t, output.String(), "test_dir/nested/file2")
199}
200
201func TestShowDepth(t *testing.T) {
202	fin := testdir.CreateTestDir()
203	defer fin()
204
205	buff := make([]byte, 10)
206	output := bytes.NewBuffer(buff)
207
208	ui := CreateStdoutUI(output, false, false, false, false, false, false, false, "", 0, false, 2)
209	ui.SetIgnoreDirPaths([]string{"/xxx"})
210	err := ui.AnalyzePath("test_dir", nil)
211	assert.Nil(t, err)
212	err = ui.StartUILoop()
213
214	assert.Nil(t, err)
215	assert.Contains(t, output.String(), "test_dir")
216	assert.Contains(t, output.String(), "test_dir/nested")
217	assert.Contains(t, output.String(), "test_dir/nested/subnested")
218}
219
220func TestShowDepthWithColors(t *testing.T) {
221	fin := testdir.CreateTestDir()
222	defer fin()
223
224	buff := make([]byte, 10)
225	output := bytes.NewBuffer(buff)
226
227	ui := CreateStdoutUI(output, true, false, false, false, false, false, false, "", 0, false, 2)
228	ui.SetIgnoreDirPaths([]string{"/xxx"})
229	err := ui.AnalyzePath("test_dir", nil)
230	assert.Nil(t, err)
231	err = ui.StartUILoop()
232
233	assert.Nil(t, err)
234	assert.Contains(t, output.String(), "test_dir")
235	assert.Contains(t, output.String(), "test_dir/nested")
236}
237
238func TestShowDepthWithReverseSort(t *testing.T) {
239	fin := testdir.CreateTestDir()
240	defer fin()
241
242	buff := make([]byte, 10)
243	output := bytes.NewBuffer(buff)
244
245	ui := CreateStdoutUI(output, false, false, false, false, false, false, false, "", 0, true, 2)
246	ui.SetIgnoreDirPaths([]string{"/xxx"})
247	err := ui.AnalyzePath("test_dir", nil)
248	assert.Nil(t, err)
249	err = ui.StartUILoop()
250
251	assert.Nil(t, err)
252	outputStr := output.String()
253	assert.Contains(t, outputStr, "test_dir")
254	assert.Contains(t, outputStr, "test_dir/nested")
255	assert.Contains(t, outputStr, "test_dir/nested/subnested")
256}
257
258func TestAnalyzeSubdir(t *testing.T) {
259	fin := testdir.CreateTestDir()
260	defer fin()
261
262	buff := make([]byte, 10)
263	output := bytes.NewBuffer(buff)
264
265	ui := CreateStdoutUI(output, false, false, false, false, false, false, false, "", 0, false, 0)
266	ui.SetIgnoreDirPaths([]string{"/xxx"})
267	err := ui.AnalyzePath("test_dir/nested", nil)
268	assert.Nil(t, err)
269	err = ui.StartUILoop()
270
271	assert.Nil(t, err)
272	assert.Contains(t, output.String(), "file2")
273}
274
275func TestAnalyzePathWithTypeFiltering(t *testing.T) {
276	fin := testdir.CreateTestDir()
277	defer fin()
278
279	buff := make([]byte, 10)
280	output := bytes.NewBuffer(buff)
281
282	ui := CreateStdoutUI(output, false, false, false, false, false, false, false, "", 0, false, 0)
283	ui.SetIncludeTypes([]string{"go"})
284	ui.SetIgnoreDirPaths([]string{"/xxx"})
285	err := ui.AnalyzePath("test_dir", nil)
286	assert.Nil(t, err)
287	err = ui.StartUILoop()
288
289	assert.Nil(t, err)
290	assert.Contains(t, output.String(), "nested")
291}
292
293func TestAnalyzePathWithColors(t *testing.T) {
294	fin := testdir.CreateTestDir()
295	defer fin()
296
297	buff := make([]byte, 10)
298	output := bytes.NewBuffer(buff)
299
300	ui := CreateStdoutUI(output, true, false, true, false, false, false, false, "", 0, false, 0)
301	ui.SetIgnoreTypes([]string{"go"})
302	ui.SetIgnoreDirPaths([]string{"/xxx"})
303	err := ui.AnalyzePath("test_dir/nested", nil)
304
305	assert.Nil(t, err)
306	assert.Contains(t, output.String(), "subnested")
307}
308
309func TestAnalyzePathWoUnicode(t *testing.T) {
310	fin := testdir.CreateTestDir()
311	defer fin()
312
313	buff := make([]byte, 10)
314	output := bytes.NewBuffer(buff)
315
316	ui := CreateStdoutUI(output, false, true, true, false, false, false, false, "", 0, false, 0)
317	ui.UseOldProgressRunes()
318	err := ui.AnalyzePath("test_dir/nested", nil)
319
320	assert.Nil(t, err)
321	assert.Contains(t, output.String(), "subnested")
322}
323
324func TestItemRows(t *testing.T) {
325	output := bytes.NewBuffer(make([]byte, 10))
326
327	ui := CreateStdoutUI(output, false, true, false, false, false, false, false, "", 0, false, 0)
328	ui.Analyzer = &testanalyze.MockedAnalyzer{}
329	err := ui.AnalyzePath("test_dir", nil)
330
331	assert.Nil(t, err)
332	assert.Contains(t, output.String(), "B")
333}
334
335func TestAnalyzePathWithProgress(t *testing.T) {
336	fin := testdir.CreateTestDir()
337	defer fin()
338
339	output := bytes.NewBuffer(make([]byte, 10))
340
341	ui := CreateStdoutUI(output, false, true, true, false, false, false, false, "", 0, false, 0)
342	ui.SetIgnoreDirPaths([]string{"/xxx"})
343	err := ui.AnalyzePath("test_dir", nil)
344
345	assert.Nil(t, err)
346	assert.Contains(t, output.String(), "nested")
347}
348
349func TestShowDevices(t *testing.T) {
350	output := bytes.NewBuffer(make([]byte, 10))
351
352	ui := CreateStdoutUI(output, false, true, false, false, false, false, false, "", 0, false, 0)
353	err := ui.ListDevices(getDevicesInfoMock())
354
355	assert.Nil(t, err)
356	assert.Contains(t, output.String(), "Device")
357	assert.Contains(t, output.String(), "xxx")
358}
359
360func TestShowDevicesWithColor(t *testing.T) {
361	output := bytes.NewBuffer(make([]byte, 10))
362
363	ui := CreateStdoutUI(output, true, true, true, false, false, false, false, "", 0, false, 0)
364	err := ui.ListDevices(getDevicesInfoMock())
365
366	assert.Nil(t, err)
367	assert.Contains(t, output.String(), "Device")
368	assert.Contains(t, output.String(), "xxx")
369}
370
371func TestReadAnalysisWithColor(t *testing.T) {
372	input, err := os.OpenFile("../internal/testdata/test.json", os.O_RDONLY, 0o644)
373	assert.Nil(t, err)
374
375	output := bytes.NewBuffer(make([]byte, 10))
376
377	ui := CreateStdoutUI(output, true, true, true, false, false, false, false, "", 0, false, 0)
378	err = ui.ReadAnalysis(input)
379
380	assert.Nil(t, err)
381	assert.Contains(t, output.String(), "main.go")
382}
383
384func TestReadAnalysisBw(t *testing.T) {
385	input, err := os.OpenFile("../internal/testdata/test.json", os.O_RDONLY, 0o644)
386	assert.Nil(t, err)
387
388	output := bytes.NewBuffer(make([]byte, 10))
389
390	ui := CreateStdoutUI(output, false, false, false, false, false, false, false, "", 0, false, 0)
391	err = ui.ReadAnalysis(input)
392
393	assert.Nil(t, err)
394	assert.Contains(t, output.String(), "main.go")
395}
396
397func TestReadAnalysisWithWrongFile(t *testing.T) {
398	input, err := os.OpenFile("../internal/testdata/wrong.json", os.O_RDONLY, 0o644)
399	assert.Nil(t, err)
400
401	output := bytes.NewBuffer(make([]byte, 10))
402
403	ui := CreateStdoutUI(output, true, true, true, false, false, false, false, "", 0, false, 0)
404	err = ui.ReadAnalysis(input)
405
406	assert.NotNil(t, err)
407}
408
409func TestReadAnalysisWithSummarize(t *testing.T) {
410	input, err := os.OpenFile("../internal/testdata/test.json", os.O_RDONLY, 0o644)
411	assert.Nil(t, err)
412
413	output := bytes.NewBuffer(make([]byte, 10))
414
415	ui := CreateStdoutUI(output, false, false, false, false, true, false, false, "", 0, false, 0)
416	err = ui.ReadAnalysis(input)
417
418	assert.Nil(t, err)
419	assert.Contains(t, output.String(), " gdu\n")
420}
421
422func TestMaxInt(t *testing.T) {
423	assert.Equal(t, 5, maxInt(2, 5))
424	assert.Equal(t, 4, maxInt(4, 2))
425}
426
427func TestFormatSize(t *testing.T) {
428	output := bytes.NewBuffer(make([]byte, 10))
429
430	ui := CreateStdoutUI(output, true, true, true, false, false, false, false, "", 0, false, 0)
431
432	assert.Contains(t, ui.formatSize(1), "B")
433	assert.Contains(t, ui.formatSize(1<<10+1), "KiB")
434	assert.Contains(t, ui.formatSize(1<<20+1), "MiB")
435	assert.Contains(t, ui.formatSize(1<<30+1), "GiB")
436	assert.Contains(t, ui.formatSize(1<<40+1), "TiB")
437	assert.Contains(t, ui.formatSize(1<<50+1), "PiB")
438	assert.Contains(t, ui.formatSize(1<<60+1), "EiB")
439}
440
441func TestFormatSizeDec(t *testing.T) {
442	output := bytes.NewBuffer(make([]byte, 10))
443
444	ui := CreateStdoutUI(output, true, true, true, false, false, true, false, "", 0, false, 0)
445
446	assert.Contains(t, ui.formatSize(1), "B")
447	assert.Contains(t, ui.formatSize(1<<10+1), "kB")
448	assert.Contains(t, ui.formatSize(1<<20+1), "MB")
449	assert.Contains(t, ui.formatSize(1<<30+1), "GB")
450	assert.Contains(t, ui.formatSize(1<<40+1), "TB")
451	assert.Contains(t, ui.formatSize(1<<50+1), "PB")
452	assert.Contains(t, ui.formatSize(1<<60+1), "EB")
453}
454
455func TestFormatCount(t *testing.T) {
456	output := bytes.NewBuffer(make([]byte, 10))
457	ui := CreateStdoutUI(output, true, true, true, false, false, true, false, "", 0, false, 0)
458
459	assert.Equal(t, "42", ui.formatCount(42))
460	assert.Equal(t, "1.5k", ui.formatCount(1500))
461	assert.Equal(t, "2.5M", ui.formatCount(2500000))
462	assert.Equal(t, "3.5G", ui.formatCount(3500000000))
463}
464
465func TestFormatSizeRaw(t *testing.T) {
466	output := bytes.NewBuffer(make([]byte, 10))
467
468	ui := CreateStdoutUI(output, true, true, true, false, false, true, true, "", 0, false, 0)
469
470	assert.Equal(t, ui.formatSize(1), "1")
471	assert.Equal(t, ui.formatSize(1<<10+1), "1025")
472	assert.Equal(t, ui.formatSize(1<<20+1), "1048577")
473	assert.Equal(t, ui.formatSize(1<<30+1), "1073741825")
474	assert.Equal(t, ui.formatSize(1<<40+1), "1099511627777")
475	assert.Equal(t, ui.formatSize(1<<50+1), "1125899906842625")
476	assert.Equal(t, ui.formatSize(1<<60+1), "1152921504606846977")
477}
478func TestFormatSizeFixedUnitBinary(t *testing.T) {
479	output := bytes.NewBuffer(make([]byte, 10))
480
481	ui := CreateStdoutUI(output, false, false, false, false, false, false, false, "k", 0, false, 0)
482	assert.Equal(t, "0.1 KiB", ui.formatSize(100))
483	assert.Equal(t, "1500.0 KiB", ui.formatSize(1536000))
484
485	ui = CreateStdoutUI(output, false, false, false, false, false, false, false, "m", 0, false, 0)
486	assert.Equal(t, "0.1 MiB", ui.formatSize(100*1024))
487	assert.Equal(t, "1500.0 MiB", ui.formatSize(1536000*1024))
488
489	ui = CreateStdoutUI(output, false, false, false, false, false, false, false, "g", 0, false, 0)
490	assert.Equal(t, "0.1 GiB", ui.formatSize(100*1024*1024))
491	assert.Equal(t, "1500.0 GiB", ui.formatSize(1536000*1024*1024))
492}
493func TestFormatSizeFixedUnitSI(t *testing.T) {
494	output := bytes.NewBuffer(make([]byte, 10))
495
496	// -k --si
497	ui := CreateStdoutUI(output, false, false, false, false, false, true, false, "k", 0, false, 0)
498	assert.Equal(t, "0.1 kB", ui.formatSize(100))
499	assert.Equal(t, "1500.0 kB", ui.formatSize(15e+5))
500
501	ui = CreateStdoutUI(output, false, false, false, false, false, true, false, "m", 0, false, 0)
502	assert.Equal(t, "0.1 MB", ui.formatSize(1e+5))
503	assert.Equal(t, "1500.0 MB", ui.formatSize(1.5e+9))
504
505	ui = CreateStdoutUI(output, false, false, false, false, false, true, false, "g", 0, false, 0)
506	assert.Equal(t, "0.1 GB", ui.formatSize(1e+8))
507	assert.Equal(t, "1500.0 GB", ui.formatSize(1.5e+12))
508}
509
510// func printBuffer(buff *bytes.Buffer) {
511// 	for i, x := range buff.String() {
512// 		println(i, string(x))
513// 	}
514// }
515
516func getDevicesInfoMock() device.DevicesInfoGetter {
517	item := &device.Device{
518		Name: "xxx",
519	}
520
521	mock := testdev.DevicesInfoGetterMock{}
522	mock.Devices = []*device.Device{item}
523	return mock
524}
525
526// New tests for reverse sort functionality
527func TestAnalyzePathWithReverseSort(t *testing.T) {
528	fin := testdir.CreateTestDir()
529	defer fin()
530
531	buff := make([]byte, 10)
532	output := bytes.NewBuffer(buff)
533
534	ui := CreateStdoutUI(output, false, false, false, false, false, false, false, "", 0, true, 0)
535	ui.SetIgnoreDirPaths([]string{"/xxx"})
536	err := ui.AnalyzePath("test_dir", nil)
537	assert.Nil(t, err)
538	err = ui.StartUILoop()
539
540	assert.Nil(t, err)
541	assert.Contains(t, output.String(), "nested")
542
543	// Verify that smaller items appear first when reverse sort is enabled
544	outputStr := output.String()
545	lines := strings.Split(outputStr, "\n")
546
547	// Filter out empty lines and progress lines
548	var fileLines []string
549	for _, line := range lines {
550		if strings.Contains(line, " ") && !strings.Contains(line, "Scanning") {
551			fileLines = append(fileLines, line)
552		}
553	}
554
555	// With reverse sort, smaller files should appear before larger ones
556	assert.True(t, len(fileLines) > 0, "Should have file entries in output")
557}
558
559func TestAnalyzePathWithoutReverseSort(t *testing.T) {
560	fin := testdir.CreateTestDir()
561	defer fin()
562
563	buff := make([]byte, 10)
564	output := bytes.NewBuffer(buff)
565
566	ui := CreateStdoutUI(output, false, false, false, false, false, false, false, "", 0, false, 0)
567	ui.SetIgnoreDirPaths([]string{"/xxx"})
568	err := ui.AnalyzePath("test_dir", nil)
569	assert.Nil(t, err)
570	err = ui.StartUILoop()
571
572	assert.Nil(t, err)
573	assert.Contains(t, output.String(), "nested")
574}
575
576func TestReverseSortWithColors(t *testing.T) {
577	fin := testdir.CreateTestDir()
578	defer fin()
579
580	buff := make([]byte, 10)
581	output := bytes.NewBuffer(buff)
582
583	ui := CreateStdoutUI(output, true, false, true, false, false, false, false, "", 0, true, 0)
584	ui.SetIgnoreDirPaths([]string{"/xxx"})
585	err := ui.AnalyzePath("test_dir/nested", nil)
586
587	assert.Nil(t, err)
588	assert.Contains(t, output.String(), "subnested")
589}
590
591func TestReverseSortWithSummarize(t *testing.T) {
592	fin := testdir.CreateTestDir()
593	defer fin()
594
595	buff := make([]byte, 10)
596	output := bytes.NewBuffer(buff)
597
598	ui := CreateStdoutUI(output, false, false, false, false, true, false, false, "", 0, true, 0)
599	ui.SetIgnoreDirPaths([]string{"/xxx"})
600	err := ui.AnalyzePath("test_dir", nil)
601	assert.Nil(t, err)
602	err = ui.StartUILoop()
603
604	assert.Nil(t, err)
605	assert.Contains(t, output.String(), "test_dir")
606}
607
608func TestReverseSortWithTop(t *testing.T) {
609	fin := testdir.CreateTestDir()
610	defer fin()
611
612	buff := make([]byte, 10)
613	output := bytes.NewBuffer(buff)
614
615	ui := CreateStdoutUI(output, true, false, true, false, true, false, false, "", 2, true, 0)
616	ui.SetIgnoreDirPaths([]string{"/xxx"})
617	err := ui.AnalyzePath("test_dir", nil)
618	assert.Nil(t, err)
619	err = ui.StartUILoop()
620
621	assert.Nil(t, err)
622	assert.Contains(t, output.String(), "test_dir/nested/subnested/file")
623	assert.Contains(t, output.String(), "test_dir/nested/file2")
624}
625
626func TestReverseSortFromAnalysisFile(t *testing.T) {
627	input, err := os.OpenFile("../internal/testdata/test.json", os.O_RDONLY, 0o644)
628	assert.Nil(t, err)
629
630	output := bytes.NewBuffer(make([]byte, 10))
631
632	ui := CreateStdoutUI(output, true, true, true, false, false, false, false, "", 0, true, 0)
633	err = ui.ReadAnalysis(input)
634
635	assert.Nil(t, err)
636	assert.Contains(t, output.String(), "main.go")
637}
638
639func TestDefaultAnalyzerIsTopDir(t *testing.T) {
640	output := bytes.NewBuffer(make([]byte, 10))
641	ui := CreateStdoutUI(output, false, false, false, false, false, false, false, "", 0, false, 0)
642
643	_, ok := ui.Analyzer.(*analyze.TopDirAnalyzer)
644	assert.True(t, ok, "default analyzer should be TopDirAnalyzer")
645}
646
647func TestAnalyzerWithTopIsParallel(t *testing.T) {
648	output := bytes.NewBuffer(make([]byte, 10))
649	ui := CreateStdoutUI(output, false, false, false, false, false, false, false, "", 5, false, 0)
650
651	_, ok := ui.Analyzer.(*analyze.ParallelAnalyzer)
652	assert.True(t, ok, "analyzer with top > 0 should be ParallelAnalyzer")
653}
654
655func TestAnalyzerWithDepthIsParallel(t *testing.T) {
656	output := bytes.NewBuffer(make([]byte, 10))
657	ui := CreateStdoutUI(output, false, false, false, false, false, false, false, "", 0, false, 3)
658
659	_, ok := ui.Analyzer.(*analyze.ParallelAnalyzer)
660	assert.True(t, ok, "analyzer with depth > 0 should be ParallelAnalyzer")
661}
662
663func TestAnalyzePathWithTopDirAnalyzer(t *testing.T) {
664	fin := testdir.CreateTestDir()
665	defer fin()
666
667	output := bytes.NewBuffer(make([]byte, 10))
668	ui := CreateStdoutUI(output, false, false, false, false, false, false, false, "", 0, false, 0)
669	err := ui.AnalyzePath("test_dir", nil)
670	assert.Nil(t, err)
671	err = ui.StartUILoop()
672	assert.Nil(t, err)
673	assert.Contains(t, output.String(), "nested")
674}
675
676func TestBlockSizeEnvironment(t *testing.T) {
677	t.Setenv("BLOCK_SIZE", "1K")
678	t.Setenv("BLOCKSIZE", "1MB")
679	ui := CreateStdoutUI(bytes.NewBuffer(nil), false, false, false, false, false, false, false, "", 0, false, 0)
680	assert.Equal(t, "2", ui.formatSize(1025))
681}
682
683func TestBlockSizeEnvironmentFormats(t *testing.T) {
684	tests := []struct {
685		name      string
686		blockSize string
687		size      int64
688		expected  string
689	}{
690		{name: "decimal suffix", blockSize: "kB", size: 1025, expected: "2kB"},
691		{name: "numeric suffix", blockSize: "2kB", size: 1025, expected: "1"},
692	}
693
694	for _, test := range tests {
695		t.Run(test.name, func(t *testing.T) {
696			t.Setenv("BLOCK_SIZE", test.blockSize)
697			t.Setenv("BLOCKSIZE", "")
698			ui := CreateStdoutUI(bytes.NewBuffer(nil), false, false, false, false, false, false, false, "", 0, false, 0)
699			assert.Equal(t, test.expected, ui.formatSize(test.size))
700		})
701	}
702}
703
704func TestBlockSizeEnvironmentHumanReadableModes(t *testing.T) {
705	t.Run("binary", func(t *testing.T) {
706		t.Setenv("BLOCK_SIZE", "human-readable")
707		ui := CreateStdoutUI(bytes.NewBuffer(nil), false, false, false, false, false, false, false, "", 0, false, 0)
708		assert.Equal(t, "1.0 KiB", ui.formatSize(1025))
709	})
710	t.Run("si", func(t *testing.T) {
711		t.Setenv("BLOCK_SIZE", "si")
712		ui := CreateStdoutUI(bytes.NewBuffer(nil), false, false, false, false, false, false, false, "", 0, false, 0)
713		assert.Equal(t, "1.0 kB", ui.formatSize(1025))
714	})
715}
716
717func TestBlockSizeEnvironmentIsOverriddenByFlags(t *testing.T) {
718	t.Setenv("BLOCK_SIZE", "1K")
719	ui := CreateStdoutUI(bytes.NewBuffer(nil), false, false, false, false, false, false, true, "", 0, false, 0)
720	assert.Equal(t, "1025", ui.formatSize(1025))
721}
722
723func TestBlockSizeEnvironmentSIFlagOverridesEnvironment(t *testing.T) {
724	t.Setenv("BLOCK_SIZE", "1K")
725	ui := CreateStdoutUI(bytes.NewBuffer(nil), false, false, false, false, false, true, false, "", 0, false, 0)
726	assert.Equal(t, "1.0 kB", ui.formatSize(1025))
727}
728
729func newStdoutSymlinkFile() *analyze.File {
730	dir := &analyze.Dir{File: &analyze.File{Name: "test_dir"}}
731	return &analyze.File{
732		Name:    "bin",
733		Parent:  dir,
734		Size:    7,
735		Flag:    '@',
736		Symlink: "usr/bin",
737	}
738}
739
740func TestPrintItemShowsSymlinkTarget(t *testing.T) {
741	output := bytes.NewBuffer(nil)
742	ui := CreateStdoutUI(output, false, false, false, false, false, false, false, "", 0, false, 0)
743	ui.SetShowSymlinkTarget(true)
744
745	ui.printItem(newStdoutSymlinkFile())
746
747	assert.Contains(t, output.String(), "bin -> usr/bin")
748}
749
750func TestPrintItemHidesSymlinkTargetByDefault(t *testing.T) {
751	output := bytes.NewBuffer(nil)
752	ui := CreateStdoutUI(output, false, false, false, false, false, false, false, "", 0, false, 0)
753
754	ui.printItem(newStdoutSymlinkFile())
755
756	out := output.String()
757	assert.NotContains(t, out, "-> usr/bin")
758	assert.Contains(t, out, "bin")
759}