xref: /aosp_15_r20/external/autotest/autotest_lib/client/bin/fsinfo_unittest.py (revision 9c5db1993ded3edbeafc8092d69fe5de2ee02df7)
1#!/usr/bin/python3
2
3from __future__ import absolute_import
4from __future__ import division
5from __future__ import print_function
6import unittest, six
7
8import common
9from autotest_lib.client.bin import fsinfo
10from autotest_lib.client.common_lib.test_utils import mock
11
12class fsionfo_test(unittest.TestCase):
13
14    def setUp(self):
15        self.god = mock.mock_god()
16        self.god.stub_function(fsinfo, 'open')
17
18
19    def tearDown(self):
20        self.god.unstub_all()
21
22
23    def create_test_file(self, filename, contents):
24        test_file = six.StringIO(contents)
25        fsinfo.open.expect_call(filename, 'r').and_return(test_file)
26
27
28    def test_ext_mkfs_options(self):
29        tune2fs_dict = {'Filesystem volume name': '<none>',
30                        'Last mounted on': '<not available>',
31                        'Filesystem revision #': '1 (dynamic)',
32                        'Block size': 4096,
33                        'Block count': 263056,
34                        'Fragment size': 4096,
35                        'Blocks per group': 32768,
36                        'Journal inode': 8,
37                        'Reserved block count': 2630,
38                        'Inode count': 131616,
39                        'Filesystem features': 'filetype sparse_super',
40                        'Filesystem OS type': 'Linux'}
41        expected_option = {'-b': 4096,
42                           '-f': 4096,
43                           '-g': 32768,
44                           '-j': None,
45                           '-m': 1,
46                           '-O': 'filetype,sparse_super',
47                           '-o': 'Linux',
48                           '-r': '1'}
49
50        mkfs_option = {}
51        fsinfo.ext_mkfs_options(tune2fs_dict, mkfs_option)
52
53        for option, value in six.iteritems(expected_option):
54            self.assertEqual(value, mkfs_option[option])
55
56
57    def test_xfs_mkfs_options(self):
58        tune2fs_dict = {'meta-data: isize': 256,
59                        'meta-data: agcount': 8,
60                        'meta-data: agsize': 32882,
61                        'meta-data: sectsz': 512,
62                        'meta-data: attr': 0,
63                        'data: bsize': 4096,
64                        'data: imaxpct': 25,
65                        'data: sunit': 0,
66                        'data: swidth': 0,
67                        'data: unwritten': 1,
68                        'naming: version': 2,
69                        'naming: bsize': 4096,
70                        'log: version': 1,
71                        'log: sectsz': 512,
72                        'log: sunit': 0,
73                        'log: lazy-count': 0,
74                        'log: bsize': 4096,
75                        'log: blocks': 2560,
76                        'realtime: extsz': 4096,
77                        'realtime: blocks': 0,
78                        'realtime: rtextents': 0}
79
80        expected_option = {'-i size': 256,
81                           '-d agcount': 8,
82                           '-s size': 512,
83                           '-b size': 4096,
84                           '-i attr': 0,
85                           '-i maxpct': 25,
86                           '-d sunit': 0,
87                           '-d swidth': 0,
88                           '-d unwritten': 1,
89                           '-n version': 2,
90                           '-n size': 4096,
91                           '-l version': 1,
92                           '-l sectsize': 512,
93                           '-l sunit': 0,
94                           '-l lazy-count': 0,
95                           '-r extsize': 4096,
96                           '-r size': 0,
97                           '-r rtdev': 0,
98                           '-l size': 10485760}
99        mkfs_option = {}
100        fsinfo.xfs_mkfs_options(tune2fs_dict, mkfs_option)
101        for option, value in six.iteritems(expected_option):
102            self.assertEqual(value, mkfs_option[option])
103
104
105    def test_opt_string2dict(self):
106        test_string = '-q -b 1234   -O fdasfa,fdasfdas -l adfas -k -L'
107        result = fsinfo.opt_string2dict(test_string)
108        expected_result = {'-q': None,
109                           '-b': 1234,
110                           '-O': 'fdasfa,fdasfdas',
111                           '-l': 'adfas',
112                           '-k': None,
113                           '-L': None}
114        self.assertEqual(expected_result, result)
115
116
117    def test_merge_ext_features(self):
118        conf = 'a,b,d,d,d,d,d,e,e,a,f'.split(',')
119        user = '^e,a,^f,g,h,i'
120        expected_result = ['a', 'b', 'd', 'g', 'h', 'i']
121        result = fsinfo.merge_ext_features(conf, user)
122        self.assertEqual(expected_result, result)
123
124
125    def test_compare_features(self):
126        f1 = ['sparse_super', 'filetype', 'resize_inode', 'dir_index']
127        f2 = ['filetype', 'resize_inode', 'dir_index', 'large_file']
128        self.assertTrue(fsinfo.compare_features(f1, f1))
129        self.assertFalse(fsinfo.compare_features(f1, f2))
130
131
132    def test_mke2fs_conf(self):
133        content = ('[defaults]\n'
134                   'base_features = sparse_super,filetype,resize_inode\n'
135                   '       blocksize = 4096 \n'
136                   '       inode_ratio = 8192  \n'
137                   '\n [fs_types]\n'
138                   '       small = {\n'
139                   '                         blocksize = 1024\n'
140                   '               inode_ratio = 4096 \n'
141                   '                                                 }\n'
142                   '       floppy = {\n'
143                   '                         blocksize = 4096\n'
144                   '                                }\n')
145        self.create_test_file('/etc/mke2fs.conf', content)
146
147        conf_opt = fsinfo.parse_mke2fs_conf('small')
148        mkfs_opt = fsinfo.convert_conf_opt(conf_opt)
149        expected_conf = {'blocksize': 1024,
150                         'inode_ratio': 4096,
151                         'base_features': 'sparse_super,filetype,resize_inode'}
152        expected_mkfs = {'-O': ['sparse_super', 'filetype', 'resize_inode'],
153                         '-i': 4096,
154                         '-b': 1024}
155        self.assertEqual(conf_opt, expected_conf)
156        self.assertEqual(mkfs_opt, expected_mkfs)
157
158
159if __name__ == '__main__':
160    unittest.main()
161