AKASHI Takahiro | 615af9a | 2018-09-11 15:59:19 +0900 | [diff] [blame^] | 1 | # SPDX-License-Identifier: GPL-2.0+ |
| 2 | # Copyright (c) 2018, Linaro Limited |
| 3 | # Author: Takahiro Akashi <takahiro.akashi@linaro.org> |
| 4 | # |
| 5 | # U-Boot File System:Basic Test |
| 6 | |
| 7 | """ |
| 8 | This test verifies basic read/write operation on file system. |
| 9 | """ |
| 10 | |
| 11 | import pytest |
| 12 | import re |
| 13 | from fstest_defs import * |
| 14 | |
| 15 | @pytest.mark.boardspec('sandbox') |
| 16 | class TestFsBasic(object): |
| 17 | def test_fs1(self, u_boot_console, fs_obj_basic): |
| 18 | """ |
| 19 | Test Case 1 - ls command, listing a root directory and invalid directory |
| 20 | """ |
| 21 | fs_type,fs_img,md5val = fs_obj_basic |
| 22 | with u_boot_console.log.section('Test Case 1a - ls'): |
| 23 | # Test Case 1 - ls |
| 24 | output = u_boot_console.run_command_list([ |
| 25 | 'host bind 0 %s' % fs_img, |
| 26 | '%sls host 0:0' % fs_type]) |
| 27 | assert(re.search('2621440000 *%s' % BIG_FILE, ''.join(output))) |
| 28 | assert(re.search('1048576 *%s' % SMALL_FILE, ''.join(output))) |
| 29 | |
| 30 | with u_boot_console.log.section('Test Case 1b - ls (invalid dir)'): |
| 31 | # In addition, test with a nonexistent directory to see if we crash. |
| 32 | output = u_boot_console.run_command( |
| 33 | '%sls host 0:0 invalid_d' % fs_type) |
| 34 | if fs_type == 'ext4': |
| 35 | assert('Can not find directory' in output) |
| 36 | else: |
| 37 | assert('' == output) |
| 38 | |
| 39 | def test_fs2(self, u_boot_console, fs_obj_basic): |
| 40 | """ |
| 41 | Test Case 2 - size command for a small file |
| 42 | """ |
| 43 | fs_type,fs_img,md5val = fs_obj_basic |
| 44 | with u_boot_console.log.section('Test Case 2a - size (small)'): |
| 45 | # 1MB is 0x0010 0000 |
| 46 | # Test Case 2a - size of small file |
| 47 | output = u_boot_console.run_command_list([ |
| 48 | 'host bind 0 %s' % fs_img, |
| 49 | '%ssize host 0:0 /%s' % (fs_type, SMALL_FILE), |
| 50 | 'printenv filesize', |
| 51 | 'setenv filesize']) |
| 52 | assert('filesize=100000' in ''.join(output)) |
| 53 | |
| 54 | with u_boot_console.log.section('Test Case 2b - size (/../<file>)'): |
| 55 | # Test Case 2b - size of small file via a path using '..' |
| 56 | output = u_boot_console.run_command_list([ |
| 57 | '%ssize host 0:0 /SUBDIR/../%s' % (fs_type, SMALL_FILE), |
| 58 | 'printenv filesize', |
| 59 | 'setenv filesize']) |
| 60 | assert('filesize=100000' in ''.join(output)) |
| 61 | |
| 62 | def test_fs3(self, u_boot_console, fs_obj_basic): |
| 63 | """ |
| 64 | Test Case 3 - size command for a large file |
| 65 | """ |
| 66 | fs_type,fs_img,md5val = fs_obj_basic |
| 67 | with u_boot_console.log.section('Test Case 3 - size (large)'): |
| 68 | # 2.5GB (1024*1024*2500) is 0x9C40 0000 |
| 69 | # Test Case 3 - size of big file |
| 70 | output = u_boot_console.run_command_list([ |
| 71 | 'host bind 0 %s' % fs_img, |
| 72 | '%ssize host 0:0 /%s' % (fs_type, BIG_FILE), |
| 73 | 'printenv filesize', |
| 74 | 'setenv filesize']) |
| 75 | assert('filesize=9c400000' in ''.join(output)) |
| 76 | |
| 77 | def test_fs4(self, u_boot_console, fs_obj_basic): |
| 78 | """ |
| 79 | Test Case 4 - load a small file, 1MB |
| 80 | """ |
| 81 | fs_type,fs_img,md5val = fs_obj_basic |
| 82 | with u_boot_console.log.section('Test Case 4 - load (small)'): |
| 83 | # Test Case 4a - Read full 1MB of small file |
| 84 | output = u_boot_console.run_command_list([ |
| 85 | 'host bind 0 %s' % fs_img, |
| 86 | '%sload host 0:0 %x /%s' % (fs_type, ADDR, SMALL_FILE), |
| 87 | 'printenv filesize']) |
| 88 | assert('filesize=100000' in ''.join(output)) |
| 89 | |
| 90 | # Test Case 4b - Read full 1MB of small file |
| 91 | output = u_boot_console.run_command_list([ |
| 92 | 'md5sum %x $filesize' % ADDR, |
| 93 | 'setenv filesize']) |
| 94 | assert(md5val[0] in ''.join(output)) |
| 95 | |
| 96 | def test_fs5(self, u_boot_console, fs_obj_basic): |
| 97 | """ |
| 98 | Test Case 5 - load, reading first 1MB of 3GB file |
| 99 | """ |
| 100 | fs_type,fs_img,md5val = fs_obj_basic |
| 101 | with u_boot_console.log.section('Test Case 5 - load (first 1MB)'): |
| 102 | # Test Case 5a - First 1MB of big file |
| 103 | output = u_boot_console.run_command_list([ |
| 104 | 'host bind 0 %s' % fs_img, |
| 105 | '%sload host 0:0 %x /%s %x 0x0' % (fs_type, ADDR, BIG_FILE, LENGTH), |
| 106 | 'printenv filesize']) |
| 107 | assert('filesize=100000' in ''.join(output)) |
| 108 | |
| 109 | # Test Case 5b - First 1MB of big file |
| 110 | output = u_boot_console.run_command_list([ |
| 111 | 'md5sum %x $filesize' % ADDR, |
| 112 | 'setenv filesize']) |
| 113 | assert(md5val[1] in ''.join(output)) |
| 114 | |
| 115 | def test_fs6(self, u_boot_console, fs_obj_basic): |
| 116 | """ |
| 117 | Test Case 6 - load, reading last 1MB of 3GB file |
| 118 | """ |
| 119 | fs_type,fs_img,md5val = fs_obj_basic |
| 120 | with u_boot_console.log.section('Test Case 6 - load (last 1MB)'): |
| 121 | # fails for ext as no offset support |
| 122 | # Test Case 6a - Last 1MB of big file |
| 123 | output = u_boot_console.run_command_list([ |
| 124 | 'host bind 0 %s' % fs_img, |
| 125 | '%sload host 0:0 %x /%s %x 0x9c300000' |
| 126 | % (fs_type, ADDR, BIG_FILE, LENGTH), |
| 127 | 'printenv filesize']) |
| 128 | assert('filesize=100000' in ''.join(output)) |
| 129 | |
| 130 | # Test Case 6b - Last 1MB of big file |
| 131 | output = u_boot_console.run_command_list([ |
| 132 | 'md5sum %x $filesize' % ADDR, |
| 133 | 'setenv filesize']) |
| 134 | assert(md5val[2] in ''.join(output)) |
| 135 | |
| 136 | def test_fs7(self, u_boot_console, fs_obj_basic): |
| 137 | """ |
| 138 | Test Case 7 - load, 1MB from the last 1MB in 2GB |
| 139 | """ |
| 140 | fs_type,fs_img,md5val = fs_obj_basic |
| 141 | with u_boot_console.log.section('Test Case 7 - load (last 1MB in 2GB)'): |
| 142 | # fails for ext as no offset support |
| 143 | # Test Case 7a - One from the last 1MB chunk of 2GB |
| 144 | output = u_boot_console.run_command_list([ |
| 145 | 'host bind 0 %s' % fs_img, |
| 146 | '%sload host 0:0 %x /%s %x 0x7ff00000' |
| 147 | % (fs_type, ADDR, BIG_FILE, LENGTH), |
| 148 | 'printenv filesize']) |
| 149 | assert('filesize=100000' in ''.join(output)) |
| 150 | |
| 151 | # Test Case 7b - One from the last 1MB chunk of 2GB |
| 152 | output = u_boot_console.run_command_list([ |
| 153 | 'md5sum %x $filesize' % ADDR, |
| 154 | 'setenv filesize']) |
| 155 | assert(md5val[3] in ''.join(output)) |
| 156 | |
| 157 | def test_fs8(self, u_boot_console, fs_obj_basic): |
| 158 | """ |
| 159 | Test Case 8 - load, reading first 1MB in 2GB |
| 160 | """ |
| 161 | fs_type,fs_img,md5val = fs_obj_basic |
| 162 | with u_boot_console.log.section('Test Case 8 - load (first 1MB in 2GB)'): |
| 163 | # fails for ext as no offset support |
| 164 | # Test Case 8a - One from the start 1MB chunk from 2GB |
| 165 | output = u_boot_console.run_command_list([ |
| 166 | 'host bind 0 %s' % fs_img, |
| 167 | '%sload host 0:0 %x /%s %x 0x80000000' |
| 168 | % (fs_type, ADDR, BIG_FILE, LENGTH), |
| 169 | 'printenv filesize']) |
| 170 | assert('filesize=100000' in ''.join(output)) |
| 171 | |
| 172 | # Test Case 8b - One from the start 1MB chunk from 2GB |
| 173 | output = u_boot_console.run_command_list([ |
| 174 | 'md5sum %x $filesize' % ADDR, |
| 175 | 'setenv filesize']) |
| 176 | assert(md5val[4] in ''.join(output)) |
| 177 | |
| 178 | def test_fs9(self, u_boot_console, fs_obj_basic): |
| 179 | """ |
| 180 | Test Case 9 - load, 1MB crossing 2GB boundary |
| 181 | """ |
| 182 | fs_type,fs_img,md5val = fs_obj_basic |
| 183 | with u_boot_console.log.section('Test Case 9 - load (crossing 2GB boundary)'): |
| 184 | # fails for ext as no offset support |
| 185 | # Test Case 9a - One 1MB chunk crossing the 2GB boundary |
| 186 | output = u_boot_console.run_command_list([ |
| 187 | 'host bind 0 %s' % fs_img, |
| 188 | '%sload host 0:0 %x /%s %x 0x7ff80000' |
| 189 | % (fs_type, ADDR, BIG_FILE, LENGTH), |
| 190 | 'printenv filesize']) |
| 191 | assert('filesize=100000' in ''.join(output)) |
| 192 | |
| 193 | # Test Case 9b - One 1MB chunk crossing the 2GB boundary |
| 194 | output = u_boot_console.run_command_list([ |
| 195 | 'md5sum %x $filesize' % ADDR, |
| 196 | 'setenv filesize']) |
| 197 | assert(md5val[5] in ''.join(output)) |
| 198 | |
| 199 | def test_fs10(self, u_boot_console, fs_obj_basic): |
| 200 | """ |
| 201 | Test Case 10 - load, reading beyond file end'): |
| 202 | """ |
| 203 | fs_type,fs_img,md5val = fs_obj_basic |
| 204 | with u_boot_console.log.section('Test Case 10 - load (beyond file end)'): |
| 205 | # Generic failure case |
| 206 | # Test Case 10 - 2MB chunk from the last 1MB of big file |
| 207 | output = u_boot_console.run_command_list([ |
| 208 | 'host bind 0 %s' % fs_img, |
| 209 | '%sload host 0:0 %x /%s 0x00200000 0x9c300000' |
| 210 | % (fs_type, ADDR, BIG_FILE), |
| 211 | 'printenv filesize', |
| 212 | 'md5sum %x $filesize' % ADDR, |
| 213 | 'setenv filesize']) |
| 214 | assert('filesize=100000' in ''.join(output)) |
| 215 | |
| 216 | def test_fs11(self, u_boot_console, fs_obj_basic): |
| 217 | """ |
| 218 | Test Case 11 - write' |
| 219 | """ |
| 220 | fs_type,fs_img,md5val = fs_obj_basic |
| 221 | with u_boot_console.log.section('Test Case 11 - write'): |
| 222 | # Read 1MB from small file |
| 223 | # Write it back to test the writes |
| 224 | # Test Case 11a - Check that the write succeeded |
| 225 | output = u_boot_console.run_command_list([ |
| 226 | 'host bind 0 %s' % fs_img, |
| 227 | '%sload host 0:0 %x /%s' % (fs_type, ADDR, SMALL_FILE), |
| 228 | '%swrite host 0:0 %x /%s.w $filesize' |
| 229 | % (fs_type, ADDR, SMALL_FILE)]) |
| 230 | assert('1048576 bytes written' in ''.join(output)) |
| 231 | |
| 232 | # Test Case 11b - Check md5 of written to is same |
| 233 | # as the one read from |
| 234 | output = u_boot_console.run_command_list([ |
| 235 | '%sload host 0:0 %x /%s.w' % (fs_type, ADDR, SMALL_FILE), |
| 236 | 'md5sum %x $filesize' % ADDR, |
| 237 | 'setenv filesize']) |
| 238 | assert(md5val[0] in ''.join(output)) |
| 239 | |
| 240 | def test_fs12(self, u_boot_console, fs_obj_basic): |
| 241 | """ |
| 242 | Test Case 12 - write to "." directory |
| 243 | """ |
| 244 | fs_type,fs_img,md5val = fs_obj_basic |
| 245 | with u_boot_console.log.section('Test Case 12 - write (".")'): |
| 246 | # Next test case checks writing a file whose dirent |
| 247 | # is the first in the block, which is always true for "." |
| 248 | # The write should fail, but the lookup should work |
| 249 | # Test Case 12 - Check directory traversal |
| 250 | output = u_boot_console.run_command_list([ |
| 251 | 'host bind 0 %s' % fs_img, |
| 252 | '%swrite host 0:0 %x /. 0x10' % (fs_type, ADDR)]) |
| 253 | assert('Unable to write' in ''.join(output)) |
| 254 | |
| 255 | def test_fs13(self, u_boot_console, fs_obj_basic): |
| 256 | """ |
| 257 | Test Case 13 - write to a file with "/./<filename>" |
| 258 | """ |
| 259 | fs_type,fs_img,md5val = fs_obj_basic |
| 260 | with u_boot_console.log.section('Test Case 13 - write ("./<file>")'): |
| 261 | # Read 1MB from small file |
| 262 | # Write it via "same directory", i.e. "." dirent |
| 263 | # Test Case 13a - Check directory traversal |
| 264 | output = u_boot_console.run_command_list([ |
| 265 | 'host bind 0 %s' % fs_img, |
| 266 | '%sload host 0:0 %x /%s' % (fs_type, ADDR, SMALL_FILE), |
| 267 | '%swrite host 0:0 %x /./%s2 $filesize' |
| 268 | % (fs_type, ADDR, SMALL_FILE)]) |
| 269 | assert('1048576 bytes written' in ''.join(output)) |
| 270 | |
| 271 | # Test Case 13b - Check md5 of written to is same |
| 272 | # as the one read from |
| 273 | output = u_boot_console.run_command_list([ |
| 274 | 'mw.b %x 00 100' % ADDR, |
| 275 | '%sload host 0:0 %x /./%s2' % (fs_type, ADDR, SMALL_FILE), |
| 276 | 'md5sum %x $filesize' % ADDR, |
| 277 | 'setenv filesize']) |
| 278 | assert(md5val[0] in ''.join(output)) |
| 279 | |
| 280 | # Test Case 13c - Check md5 of written to is same |
| 281 | # as the one read from |
| 282 | output = u_boot_console.run_command_list([ |
| 283 | 'mw.b %x 00 100' % ADDR, |
| 284 | '%sload host 0:0 %x /%s2' % (fs_type, ADDR, SMALL_FILE), |
| 285 | 'md5sum %x $filesize' % ADDR, |
| 286 | 'setenv filesize']) |
| 287 | assert(md5val[0] in ''.join(output)) |