def testContains(self):
"""Accepts KernelArg."""
kv1 = kernel_cmdline.KernelArg('a', None)
kv2 = kernel_cmdline.KernelArg('arg', 'value')
kv3 = kernel_cmdline.KernelArg('z', None)
kl = kernel_cmdline.KernelArgList('a arg=value b c')
self.assertTrue(kv1 in kl)
self.assertTrue(kv2 in kl)
self.assertFalse(kv3 in kl)
def testGetVerityArg(self):
"""Test that GetVerityArg works."""
arg = ['v1 u1 f1 1', '0 1 verity a1 a2=v2']
a1 = kernel_cmdline.KernelArg('a1', None)
a2 = kernel_cmdline.KernelArg('a2', 'v2')
dd = kernel_cmdline.DmDevice(arg)
self.assertEqual(a1, dd.GetVerityArg('a1'))
self.assertEqual(a2, dd.GetVerityArg('a2'))
self.assertEqual(None, dd.GetVerityArg('a3', default=None))
self.assertEqual(a1, dd.GetVerityArg('a3', default=a1))
def testUpdateVerityArg(self):
"""Test that UpdateVerityArg works."""
arg = ['v1 u1 f1 1', '0 1 verity a1 a2=v2']
dd = kernel_cmdline.DmDevice(arg)
dd.UpdateVerityArg('a2', 'new')
self.assertEqual(kernel_cmdline.KernelArg('a2', 'new'),
dd.rows[0].args[1])
dd.UpdateVerityArg('a3', None)
self.assertEqual(kernel_cmdline.KernelArg('a3', None),
dd.rows[0].args[2])
def testEqual(self):
"""Test __eq__()."""
kv1 = kernel_cmdline.KernelArg('a', 'b')
kv2 = kernel_cmdline.KernelArg('a', 'b')
kv3 = kernel_cmdline.KernelArg('b', 'c')
kv4 = kernel_cmdline.KernelArg('a', '9 9')
kv5 = kernel_cmdline.KernelArg('a', '"9 9"')
self.assertTrue(kv1 == kv2)
self.assertFalse(kv1 == kv3)
self.assertFalse(kv1 == kv4)
self.assertTrue(kv4 == kv5)
def testAddsQuotes(self):
"""Test that init adds double-quotes when needed."""
kv1 = kernel_cmdline.KernelArg('d', '9 9')
self.assertEqual('d', kv1.arg)
# Value is unmodified.
self.assertEqual('9 9', kv1.value)
self.assertEqual('d="9 9"', kv1.Format())
kv2 = kernel_cmdline.KernelArg('d', '"a a"')
self.assertEqual('d', kv2.arg)
# Value is unmodified.
self.assertEqual('"a a"', kv2.value)
self.assertEqual('d="a a"', kv2.Format())
def testExpandsDm(self):
"""Test that we do not expand dm="..."."""
expected_kern = [
kernel_cmdline.KernelArg('a', None),
kernel_cmdline.KernelArg('dm', '"1 vroot b=c 1,0 1200"'),
kernel_cmdline.KernelArg('c.d', 'e')
]
expected_init = [
kernel_cmdline.KernelArg('dm', '"not split"'),
kernel_cmdline.KernelArg('a', None)
]
cmd = kernel_cmdline.CommandLine(
'a dm="1 vroot b=c 1,0 1200" c.d=e -- dm="not split" a')
self.assertEqual(expected_kern, cmd.kern_args)
self.assertEqual(expected_init, cmd.init_args)
def testUpdateVerityArgMultiLine(self):
"""Test that UpdateVerityArg works."""
arg = [
'v1 u1 f1 3', '9 9 xx a3 a4=v4', '0 1 verity a1 a2=v2',
'9 9 verity a1 a2=v2 an'
]
dd = kernel_cmdline.DmDevice(arg)
a2 = kernel_cmdline.KernelArg('a2', 'new')
dd.UpdateVerityArg('a2', 'new')
self.assertEqual(a2, dd.rows[1].args[1])
self.assertEqual(a2, dd.rows[2].args[1])
a3 = kernel_cmdline.KernelArg('a3', None)
dd.UpdateVerityArg('a3', None)
self.assertEqual(a3, dd.rows[1].args[2])
self.assertEqual(a3, dd.rows[2].args[3])
def testForcesInternalType(self):
"""Test that the internal type is correctly forced."""
expected = [
kernel_cmdline.KernelArg('c', 'd'),
kernel_cmdline.KernelArg('a', 'b'),
]
# Pass in an OrderedDict with |expected| being the keys.
kl = kernel_cmdline.KernelArgList(
collections.OrderedDict((x, 0) for x in expected))
self.assertEqual(type(kl._data), list)
self.assertEqual(kl, expected)
# Test len().
self.assertEqual(2, len(kl))
# Test __iter__().
self.assertEqual(expected, [x for x in kl])
def testEmptyKern(self):
"""Test that '-- a' behaves as expected."""
expected_kern = []
expected_init = [kernel_cmdline.KernelArg('a', None)]
cmd = kernel_cmdline.CommandLine('-- a')
self.assertEqual(expected_kern, cmd.kern_args)
self.assertEqual(expected_init, cmd.init_args)
def testSimple(self):
"""Test a simple command line string."""
expected = [
kernel_cmdline.KernelArg('a', None),
kernel_cmdline.KernelArg('b', ''),
kernel_cmdline.KernelArg('c', 'd'),
kernel_cmdline.KernelArg('e.f', '"d e"'),
kernel_cmdline.KernelArg('a', None),
kernel_cmdline.KernelArg('--', None),
kernel_cmdline.KernelArg('x', None),
kernel_cmdline.KernelArg('y', ''),
kernel_cmdline.KernelArg('z', 'zz'),
kernel_cmdline.KernelArg('y', None)
]
kl = kernel_cmdline.KernelArgList(
'a b= c=d e.f="d e" a -- x y= z=zz y')
self.assertEqual(kl, expected)
self.assertEqual(len(expected), len(kl))
self.assertEqual(expected, [x for x in kl])
def testSimple(self):
"""Test a simple command line string."""
expected_kern = [
kernel_cmdline.KernelArg('a', None),
kernel_cmdline.KernelArg('b', ''),
kernel_cmdline.KernelArg('c', 'd'),
kernel_cmdline.KernelArg('e.f', 'd'),
kernel_cmdline.KernelArg('a', None)
]
expected_init = [
kernel_cmdline.KernelArg('x', None),
kernel_cmdline.KernelArg('y', ''),
kernel_cmdline.KernelArg('z', 'zz'),
kernel_cmdline.KernelArg('y', None)
]
cmd = kernel_cmdline.CommandLine('a b= c=d e.f=d a -- x y= z=zz y')
self.assertEqual(cmd.kern_args, expected_kern)
self.assertEqual(cmd.init_args, expected_init)
def testSetslice(self):
"""Test that __setslice__ works."""
kv = kernel_cmdline.KernelArgList('a x y d')
# Test setting a slice to a KernelArgList.
ins = kernel_cmdline.KernelArgList('b c')
kv[1:3] = ins
self.assertEqual(kernel_cmdline.KernelArgList('a b c d'), kv)
# Test setting a slice to a list of KernelArg.
kv[1:2] = [kernel_cmdline.KernelArg('a', '3')]
self.assertEqual(kernel_cmdline.KernelArgList('a a=3 c d'), kv)
# Test setting a slice to a string.
kv[1:2] = 'x y=4'
self.assertEqual(kernel_cmdline.KernelArgList('a x y=4 c d'), kv)
def testInsert(self):
"""Test that insert() works."""
kv = kernel_cmdline.KernelArgList('a b=3 c d')
kv.insert(1, kernel_cmdline.KernelArg('f', None))
kv.insert('c', kernel_cmdline.KernelArg('g', None))
with self.assertRaises(KeyError):
kv.insert('z', kernel_cmdline.KernelArg('h', None))
expected = kernel_cmdline.KernelArgList([
kernel_cmdline.KernelArg('a', None),
kernel_cmdline.KernelArg('f', None),
kernel_cmdline.KernelArg('b', '3'),
kernel_cmdline.KernelArg('g', None),
kernel_cmdline.KernelArg('c', None),
kernel_cmdline.KernelArg('d', None)
])
self.assertEqual(expected, kv)
with self.assertRaises(ValueError):
kv.insert('z', 'badval')
# Verify that KernelArgList is a bad value.
with self.assertRaises(ValueError):
kv.insert('z', expected)
def testRejectsBadValue(self):
"""Rejects non-string values."""
kv = [kernel_cmdline.KernelArg('b', None)]
with self.assertRaises(ValueError):
kernel_cmdline.KernelArg('a', kv)
with self.assertRaises(ValueError):
kernel_cmdline.KernelArg('a', 1)
# Test various forms of bad quoting.
with self.assertRaises(ValueError):
kernel_cmdline.KernelArg('a', '"aaa"aaaa"')
with self.assertRaises(ValueError):
kernel_cmdline.KernelArg('a', 'aaa"aaaa')
with self.assertRaises(ValueError):
kernel_cmdline.KernelArg('a', 'aaa "a" aaa')
with self.assertRaises(ValueError):
kernel_cmdline.KernelArg('a', 'aaa"')
with self.assertRaises(ValueError):
kernel_cmdline.KernelArg('a', '"aaaa')
def testget(self):
"""Test that Get returns the correct value for all key types."""
kv = kernel_cmdline.KernelArgList('a b=c d e')
self.assertEqual(kernel_cmdline.KernelArg('d', None), kv.get(2))
self.assertEqual(kernel_cmdline.KernelArg('d', None), kv.get('d'))
self.assertEqual('default', kv.get('z', default='default'))
def testGetitemAcceptsInt(self):
"""Test that __getitem__ works with an integer index."""
self.assertEqual(
kernel_cmdline.KernelArgList('a b=3 c d').__getitem__(1),
kernel_cmdline.KernelArg('b', '3'))
def testGetitemAcceptsStr(self):
"""Test that __getitem__ works with a str."""
self.assertEqual(
kernel_cmdline.KernelArgList('a b=3 c d').__getitem__('b'),
kernel_cmdline.KernelArg('b', '3'))
def testSetitemAcceptsInt(self):
"""Test that __setitem__ works with an integer index."""
kv = kernel_cmdline.KernelArgList('a b=3 c d')
new_val = kernel_cmdline.KernelArg('b', '4')
kv[1] = new_val
self.assertEqual(kv[1], new_val)
def testSetDmConfig(self):
"""Test that SetDmConfig sets the dm= parameter."""
cmd = kernel_cmdline.CommandLine('a -- b')
cmd.SetDmConfig(kernel_cmdline.DmConfig(DM))
self.assertEqual(kernel_cmdline.KernelArg('dm', DM), cmd.kern_args[1])
def testKernelArg(self):
"""Expands arg=value arg."""
kv = kernel_cmdline.KernelArg('arg', 'value')
self.assertEqual('arg', kv.arg)
self.assertEqual('value', kv.value)
self.assertEqual('arg=value', kv.Format())
def testSetitemAcceptsStr(self):
"""Test that __setitem__ works with a str."""
kv = kernel_cmdline.KernelArgList('a b=3 c d')
new_val = kernel_cmdline.KernelArg('b', '4')
kv['b'] = new_val
self.assertEqual(kv[1], new_val)
def testSetitemAppendsWithNewKeyStr(self):
"""Test that __setitem__ appends with a new key (str)."""
kv = kernel_cmdline.KernelArgList('a b=3 c d')
new_val = kernel_cmdline.KernelArg('y', '4')
kv.__setitem__('y', new_val)
self.assertEqual(kv[4], new_val)
def testKeyOnly(self):
"""Expands arg-only arg."""
kv = kernel_cmdline.KernelArg('arg', None)
self.assertEqual('arg', kv.arg)
self.assertEqual(None, kv.value)
self.assertEqual('arg', kv.Format())
