1# SPDX-License-Identifier:      GPL-2.0+
2# Copyright 2025 Gabriel Dalimonte <gabriel.dalimonte@gmail.com>
3#
4# U-Boot File System:rename Test
5
6
7import pytest
8
9from fstest_defs import *
10from fstest_helpers import assert_fs_integrity
11
12@pytest.mark.boardspec('sandbox')
13@pytest.mark.slow
14class TestRename(object):
15    def test_rename1(self, ubman, fs_obj_rename):
16        """
17        Test Case 1 - rename a file (successful mv)
18        """
19        fs_type, fs_img, md5val = fs_obj_rename
20        with ubman.log.section('Test Case 1 - rename a file'):
21            d = 'test1'
22            src = '%s/file1' % d
23            dst = '%s/file2' % d
24            output = ubman.run_command_list([
25                'host bind 0 %s' % fs_img,
26                'setenv filesize',
27                'mv host 0:0 %s %s' % (src, dst),
28            ])
29            assert('' == ''.join(output))
30
31            output = ubman.run_command_list([
32                'load host 0:0 %x /%s' % (ADDR, dst),
33                'printenv filesize'])
34            assert('filesize=400' in output)
35
36            output = ubman.run_command_list([
37                'ls host 0:0 %s' % (d),
38            ])
39            assert('file1' not in ''.join(output))
40
41            output = ubman.run_command_list([
42                'md5sum %x $filesize' % ADDR,
43                'setenv filesize'])
44            assert(md5val['test1'] in ''.join(output))
45            assert_fs_integrity(fs_type, fs_img)
46
47    def test_rename2(self, ubman, fs_obj_rename):
48        """
49        Test Case 2 - rename a file to an existing file (successful mv)
50        """
51        fs_type, fs_img, md5val = fs_obj_rename
52        with ubman.log.section('Test Case 2 - rename a file to an existing file'):
53            d = 'test2'
54            src = '%s/file1' % d
55            dst = '%s/file_exist' % d
56            output = ubman.run_command_list([
57                'host bind 0 %s' % fs_img,
58                'setenv filesize',
59                'mv host 0:0 %s %s' % (src, dst),
60            ])
61            assert('' == ''.join(output))
62
63            output = ubman.run_command_list([
64                'load host 0:0 %x /%s' % (ADDR, dst),
65                'printenv filesize'])
66            assert('filesize=400' in output)
67
68            output = ubman.run_command_list([
69                'ls host 0:0 %s' % (d),
70            ])
71            assert('file1' not in ''.join(output))
72
73            output = ubman.run_command_list([
74                'md5sum %x $filesize' % ADDR,
75                'setenv filesize'])
76            assert(md5val['test2'] in ''.join(output))
77            assert_fs_integrity(fs_type, fs_img)
78
79    def test_rename3(self, ubman, fs_obj_rename):
80        """
81        Test Case 3 - rename a directory (successful mv)
82        """
83        fs_type, fs_img, md5val = fs_obj_rename
84        with ubman.log.section('Test Case 3 - rename a directory'):
85            d = 'test3'
86            src = '%s/dir1' % d
87            dst = '%s/dir2' % d
88            output = ubman.run_command_list([
89                'host bind 0 %s' % fs_img,
90                'setenv filesize',
91                'mv host 0:0 %s %s' % (src, dst),
92            ])
93            assert('' == ''.join(output))
94
95            output = ubman.run_command_list([
96                'load host 0:0 %x /%s/file1' % (ADDR, dst),
97                'printenv filesize'])
98            assert('filesize=400' in output)
99
100            output = ubman.run_command_list([
101                'ls host 0:0 %s' % (d),
102            ])
103            assert('dir1' not in ''.join(output))
104
105            output = ubman.run_command_list([
106                'md5sum %x $filesize' % ADDR,
107                'setenv filesize'])
108            assert(md5val['test3'] in ''.join(output))
109            assert_fs_integrity(fs_type, fs_img)
110
111    def test_rename4(self, ubman, fs_obj_rename):
112        """
113        Test Case 4 - rename a directory to an existing directory (successful
114        mv)
115        """
116        fs_type, fs_img, md5val = fs_obj_rename
117        with ubman.log.section('Test Case 4 - rename a directory to an existing directory'):
118            d = 'test4'
119            src = '%s/dir1' % d
120            dst = '%s/dir2' % d
121            output = ubman.run_command_list([
122                'host bind 0 %s' % fs_img,
123                'setenv filesize',
124                'mv host 0:0 %s %s' % (src, dst),
125            ])
126            assert('' == ''.join(output))
127
128            output = ubman.run_command_list([
129                'load host 0:0 %x /%s/dir1/file1' % (ADDR, dst),
130                'printenv filesize'])
131            assert('filesize=400' in output)
132
133            output = ubman.run_command_list([
134                'ls host 0:0 %s' % (d),
135            ])
136            assert('dir1' not in ''.join(output))
137
138            output = ubman.run_command_list([
139                'md5sum %x $filesize' % ADDR,
140                'setenv filesize'])
141            assert(md5val['test4'] in ''.join(output))
142            assert_fs_integrity(fs_type, fs_img)
143
144    def test_rename5(self, ubman, fs_obj_rename):
145        """
146        Test Case 5 - rename a directory to an existing file (failed mv)
147        """
148        fs_type, fs_img, md5val = fs_obj_rename
149        with ubman.log.section('Test Case 5 - rename a directory to an existing file'):
150            d = 'test5'
151            src = '%s/dir1' % d
152            dst = '%s/file2' % d
153            output = ubman.run_command_list([
154                'host bind 0 %s' % fs_img,
155                'setenv filesize',
156                'mv host 0:0 %s %s' % (src, dst),
157            ])
158            assert('' == ''.join(output))
159
160            output = ubman.run_command_list([
161                'ls host 0:0 %s' % (d),
162            ])
163            assert('dir1' in ''.join(output))
164            assert('file2' in ''.join(output))
165
166            output = ubman.run_command_list([
167                'load host 0:0 %x /%s' % (ADDR, dst),
168                'printenv filesize'])
169            assert('filesize=400' in output)
170
171            output = ubman.run_command_list([
172                'md5sum %x $filesize' % ADDR,
173                'setenv filesize'])
174            assert(md5val['test5'] in ''.join(output))
175            assert_fs_integrity(fs_type, fs_img)
176
177    def test_rename6(self, ubman, fs_obj_rename):
178        """
179        Test Case 6 - rename a file to an existing empty directory (failed mv)
180        """
181        fs_type, fs_img, md5val = fs_obj_rename
182        with ubman.log.section('Test Case 6 - rename a file to an existing empty directory'):
183            d = 'test6'
184            src = '%s/existing' % d
185            dst = '%s/dir2' % d
186            output = ubman.run_command_list([
187                'host bind 0 %s' % fs_img,
188                'setenv filesize',
189                'mv host 0:0 %s %s' % (src, dst),
190            ])
191            assert('' == ''.join(output))
192
193            output = ubman.run_command_list([
194                'load host 0:0 %x /%s' % (ADDR, src),
195                'printenv filesize'])
196            assert('filesize=400' in output)
197
198            output = ubman.run_command_list([
199                'ls host 0:0 %s' % (d),
200            ])
201            assert('dir2' in ''.join(output))
202            assert('existing' in ''.join(output))
203
204            output = ubman.run_command_list([
205                'md5sum %x $filesize' % ADDR,
206                'setenv filesize'])
207            assert(md5val['test6'] in ''.join(output))
208            assert_fs_integrity(fs_type, fs_img)
209
210    def test_rename7(self, ubman, fs_obj_rename):
211        """
212        Test Case 7 - rename a directory to a non-empty directory (failed mv)
213        """
214        fs_type, fs_img, md5val = fs_obj_rename
215        with ubman.log.section('Test Case 7 - rename a directory to a non-empty directory'):
216            d = 'test7'
217            src = '%s/dir1' % d
218            dst = '%s/dir2' % d
219            output = ubman.run_command_list([
220                'host bind 0 %s' % fs_img,
221                'setenv filesize',
222                'mv host 0:0 %s %s' % (src, dst),
223            ])
224            assert('' == ''.join(output))
225
226            output = ubman.run_command_list([
227                'load host 0:0 %x /%s/dir1/file1' % (ADDR, dst),
228                'printenv filesize'])
229            assert('filesize=400' in output)
230
231            output = ubman.run_command_list([
232                'ls host 0:0 %s' % (d),
233            ])
234            assert('dir1' in ''.join(output))
235            assert('dir2' in ''.join(output))
236
237            output = ubman.run_command_list([
238                'md5sum %x $filesize' % ADDR,
239                'setenv filesize'])
240            assert(md5val['test7'] in ''.join(output))
241            assert_fs_integrity(fs_type, fs_img)
242
243    def test_rename8(self, ubman, fs_obj_rename):
244        """
245        Test Case 8 - rename a directory inside itself (failed mv)
246        """
247        fs_type, fs_img, md5val = fs_obj_rename
248        with ubman.log.section('Test Case 8 - rename a directory inside itself'):
249            d = 'test8'
250            src = '%s/dir1' % d
251            dst = '%s/dir1/dir1' % d
252            output = ubman.run_command_list([
253                'host bind 0 %s' % fs_img,
254                'setenv filesize',
255                'mv host 0:0 %s %s' % (src, dst),
256            ])
257            assert('' == ''.join(output))
258
259            output = ubman.run_command_list([
260                'load host 0:0 %x /%s/file1' % (ADDR, src),
261                'printenv filesize'])
262            assert('filesize=400' in output)
263
264            output = ubman.run_command_list([
265                'ls host 0:0 %s' % (d),
266            ])
267            assert('dir1' in ''.join(output))
268
269            output = ubman.run_command_list([
270                'ls host 0:0 %s' % (src),
271            ])
272            assert('file1' in ''.join(output))
273            assert('dir1' not in ''.join(output))
274
275            output = ubman.run_command_list([
276                'md5sum %x $filesize' % ADDR,
277                'setenv filesize'])
278            assert(md5val['test8'] in ''.join(output))
279            assert_fs_integrity(fs_type, fs_img)
280
281    def test_rename9(self, ubman, fs_obj_rename):
282        """
283        Test Case 9 - rename a directory inside itself with backtracks (failed
284        mv)
285        """
286        fs_type, fs_img, md5val = fs_obj_rename
287        with ubman.log.section('Test Case 9 - rename a directory inside itself with backtracks'):
288            d = 'test9'
289            src = '%s/dir1/nested' % d
290            dst = '%s/dir1/nested/inner/./../../../dir1/nested/inner/another' % d
291            output = ubman.run_command_list([
292                'host bind 0 %s' % fs_img,
293                'setenv filesize',
294                'mv host 0:0 %s %s' % (src, dst),
295            ])
296            assert('' == ''.join(output))
297
298            output = ubman.run_command_list([
299                'ls host 0:0 %s/dir1' % (d),
300            ])
301            assert('nested' in ''.join(output))
302
303            output = ubman.run_command_list([
304                'ls host 0:0 %s' % (src),
305            ])
306            assert('inner' in ''.join(output))
307            assert('nested' not in ''.join(output))
308            assert_fs_integrity(fs_type, fs_img)
309
310    def test_rename10(self, ubman, fs_obj_rename):
311        """
312        Test Case 10 - rename a file to itself (successful mv)
313        """
314        fs_type, fs_img, md5val = fs_obj_rename
315        with ubman.log.section('Test Case 10 - rename a file to itself'):
316            d = 'test10'
317            src = '%s/file1' % d
318            output = ubman.run_command_list([
319                'host bind 0 %s' % fs_img,
320                'setenv filesize',
321                'mv host 0:0 %s %s' % (src, src),
322            ])
323            assert('' == ''.join(output))
324
325            output = ubman.run_command_list([
326                'load host 0:0 %x /%s' % (ADDR, src),
327                'printenv filesize'])
328            assert('filesize=400' in output)
329
330            output = ubman.run_command_list([
331                'ls host 0:0 %s' % (d),
332            ])
333            assert('file1' in ''.join(output))
334
335            output = ubman.run_command_list([
336                'md5sum %x $filesize' % ADDR,
337                'setenv filesize'])
338            assert(md5val['test10'] in ''.join(output))
339            assert_fs_integrity(fs_type, fs_img)
340
341    def test_rename11(self, ubman, fs_obj_rename):
342        """
343        Test Case 11 - rename a directory to itself (successful mv)
344        """
345        fs_type, fs_img, md5val = fs_obj_rename
346        with ubman.log.section('Test Case 11 - rename a directory to itself'):
347            # / at the end here is intentional. Ensures trailing / doesn't
348            # affect mv producing an updated dst path for fs_rename
349            d = 'test11/'
350            src = '%sdir1' % d
351            output = ubman.run_command_list([
352                'host bind 0 %s' % fs_img,
353                'setenv filesize',
354                'mv host 0:0 %s %s' % (src, d),
355            ])
356            assert('' == ''.join(output))
357
358            output = ubman.run_command_list([
359                'load host 0:0 %x /%s/file1' % (ADDR, src),
360                'printenv filesize'])
361            assert('filesize=400' in output)
362
363            output = ubman.run_command_list([
364                'ls host 0:0 %s' % (d),
365            ])
366            assert('dir1' in ''.join(output))
367
368            output = ubman.run_command_list([
369                'md5sum %x $filesize' % ADDR,
370                'setenv filesize'])
371            assert(md5val['test11'] in ''.join(output))
372            assert_fs_integrity(fs_type, fs_img)
373