| # Copyright 2019 The ChromiumOS Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Test the kernel_cmdline module.""" |
| |
| import collections |
| |
| from chromite.lib import cros_test_lib |
| from chromite.lib import kernel_cmdline |
| |
| |
| # pylint: disable=protected-access |
| |
| |
| # A partial, but sufficiently complicated command line. DmConfigTest uses |
| # more complicated configs, with multiple devices. DM is split out here for |
| # CommandLineTest.test*DmConfig(). |
| DM = ( |
| "1 vroot none ro 1,0 3891200 verity payload=PARTUUID=%U/PARTNROFF=1 " |
| "hashtree=PARTUUID=%U/PARTNROFF=1 hashstart=3891200 alg=sha1 " |
| "root_hexdigest=9999999999999999999999999999999999999999 " |
| "salt=bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" |
| ) |
| CMDLINE = ( |
| "console= loglevel=7 init=/sbin/init cros_secure oops=panic panic=-1 " |
| "root=/dev/dm-0 rootwait ro dm_verity.error_behavior=3 " |
| 'dm_verity.max_bios=-1 dm_verity.dev_wait=1 dm="' |
| + DM |
| + '" noinitrd cros_debug vt.global_cursor_default=0 kern_guid=%U ' |
| "-- run_level=3" |
| ) |
| |
| |
| class KernelArgTest(cros_test_lib.TestCase): |
| """Test KernelArg.""" |
| |
| 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()) |
| |
| def testKeyEqual(self): |
| """Expands arg= arg.""" |
| kv = kernel_cmdline.KernelArg("arg", "") |
| self.assertEqual("arg", kv.arg) |
| self.assertEqual("", kv.value) |
| self.assertEqual("arg=", kv.Format()) |
| |
| 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 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 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 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 testNotEqual(self): |
| """Test __ne__().""" |
| 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.assertFalse(kv1 != kv2) |
| self.assertTrue(kv1 != kv3) |
| self.assertTrue(kv1 != kv4) |
| self.assertFalse(kv4 != kv5) |
| |
| |
| class KernelArgListTest(cros_test_lib.TestCase): |
| """Test KernelArgList().""" |
| |
| 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, list(kl)) |
| |
| def testSetDefaultValue(self): |
| """Test that we can create an instance with no value given.""" |
| kl = kernel_cmdline.KernelArgList() |
| self.assertEqual([], kl._data) |
| self.assertEqual(0, len(kl)) |
| |
| def testReturnsEmptyList(self): |
| """Test that strings with no arguments return an empty list.""" |
| self.assertEqual([], kernel_cmdline.KernelArgList(" ")._data) |
| |
| 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, list(kl)) |
| |
| def testRejectsInvalidInput(self): |
| """Test that invalid command line strings are rejected.""" |
| # Non-KernelArg values. |
| with self.assertRaises(ValueError): |
| kernel_cmdline.KernelArgList({1: 2, 3: 4}) |
| # The first and non-first arguments are different in the re. |
| with self.assertRaises(ValueError): |
| kernel_cmdline.KernelArgList("=3") |
| with self.assertRaises(ValueError): |
| kernel_cmdline.KernelArgList("a =3") |
| # Various bad quote usages. |
| with self.assertRaises(ValueError): |
| kernel_cmdline.KernelArgList('a b="foo"3 c') |
| with self.assertRaises(ValueError): |
| kernel_cmdline.KernelArgList('a b=" c') |
| |
| def testEqual(self): |
| """Test __eq__().""" |
| kv1 = kernel_cmdline.KernelArgList("a b= c") |
| kv2 = kernel_cmdline.KernelArgList("a b= c") |
| kv3 = kernel_cmdline.KernelArgList("a b= c d") |
| self.assertTrue(kv1 == kv2) |
| self.assertTrue(kv1 == kv2._data) |
| self.assertFalse(kv1 == kv3) |
| |
| def testNotEqual(self): |
| """Test __ne__().""" |
| kv1 = kernel_cmdline.KernelArgList("a b= c") |
| kv2 = kernel_cmdline.KernelArgList("a b= c") |
| kv3 = kernel_cmdline.KernelArgList("a b= c d") |
| self.assertFalse(kv1 != kv2) |
| self.assertFalse(kv1 != kv2._data) |
| self.assertTrue(kv1 != kv3) |
| |
| def testAdd(self): |
| """Adding two KernelArgLists yields the correct KernelArgList.""" |
| kv1 = kernel_cmdline.KernelArgList("a b") |
| kv2 = kernel_cmdline.KernelArgList("a d") |
| res = kv1 + kv2 |
| self.assertEqual(type(res), kernel_cmdline.KernelArgList) |
| self.assertEqual(res, kernel_cmdline.KernelArgList("a b a d")) |
| |
| def testIadd(self): |
| """Test that += yields the correct KernelArgList.""" |
| kv1 = kernel_cmdline.KernelArgList("a b") |
| kv2 = kernel_cmdline.KernelArgList("a d") |
| kv1 += kv2 |
| self.assertEqual(type(kv1), kernel_cmdline.KernelArgList) |
| self.assertEqual(kv1, kernel_cmdline.KernelArgList("a b a d")) |
| |
| 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 testContainsAcceptsString(self): |
| """Accepts KernelArg.""" |
| kl = kernel_cmdline.KernelArgList("a arg=value b c") |
| self.assertTrue("a" in kl) |
| self.assertTrue("arg" in kl) |
| self.assertFalse("z" in kl) |
| |
| def testDelitem(self): |
| """Test del.""" |
| kl = kernel_cmdline.KernelArgList("a b=3 c d e") |
| del kl[0] |
| del kl["b"] |
| with self.assertRaises(KeyError): |
| del kl["z"] |
| self.assertEqual(kl, kernel_cmdline.KernelArgList("c d e")) |
| |
| def testDelslice(self): |
| """Test del.""" |
| kl = kernel_cmdline.KernelArgList("a b=3 c d e") |
| del kl[1:3] |
| self.assertEqual(kl, kernel_cmdline.KernelArgList("a d e")) |
| |
| def testGetslice(self): |
| """Test that __getslice__ works.""" |
| kl = kernel_cmdline.KernelArgList("a b c d") |
| sl = kl[1:3] |
| self.assertEqual(type(sl), kernel_cmdline.KernelArgList) |
| self.assertEqual( |
| kernel_cmdline.KernelArgList("a b c d")[1:3], |
| kernel_cmdline.KernelArgList("b c"), |
| ) |
| |
| 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 testGetItemRaisesKeyError(self): |
| """Test that __getitem__ raises KeyError on invalid key.""" |
| kv = kernel_cmdline.KernelArgList("a x y d") |
| with self.assertRaises(KeyError): |
| kv.__getitem__("z") |
| |
| 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 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 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 testSetitemRejectsBadValues(self): |
| """Test that __setitem__ rejects bad values.""" |
| kv = kernel_cmdline.KernelArgList("a b=3 c d") |
| with self.assertRaises(ValueError): |
| # Strings are not KernelArgs |
| kv["foo"] = "bar" |
| with self.assertRaises(ValueError): |
| # Int is not KernelArg |
| kv["foo"] = 1 |
| |
| 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 testFormat(self): |
| """Test that Format works.""" |
| self.assertEqual( |
| "a x= b=c d", kernel_cmdline.KernelArgList("a x= b=c d").Format() |
| ) |
| |
| def testIndex(self): |
| """Test that index finds the correct thing.""" |
| kv = kernel_cmdline.KernelArgList("a b=c d e") |
| self.assertEqual(1, kv.index(1)) |
| self.assertEqual(1, kv.index("b")) |
| self.assertEqual(None, kv.index("z")) |
| |
| 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 testUpdateAcceptsKwargs(self): |
| """Test update() with kwargs.""" |
| kv1 = kernel_cmdline.KernelArgList("a b c") |
| kv1.update(b="f") |
| kv2 = kernel_cmdline.KernelArgList("a b=f c") |
| self.assertEqual(kv2, kv1) |
| |
| def testUpdateAcceptsDict(self): |
| """Test update() accepts a dict.""" |
| kl1 = kernel_cmdline.KernelArgList("a=b") |
| other = {"arg": "value"} |
| kl1.update(other) |
| expected = kernel_cmdline.KernelArgList("a=b arg=value") |
| self.assertEqual(expected, kl1) |
| |
| def testUpdateAcceptsKernelArgList(self): |
| """Test update() accepts a KernelArg.""" |
| kl1 = kernel_cmdline.KernelArgList("a=b") |
| kl2 = kernel_cmdline.KernelArgList("arg=value") |
| kl1.update(kl2) |
| expected = kernel_cmdline.KernelArgList("a=b arg=value") |
| self.assertEqual(expected, kl1) |
| |
| def testUpdateAcceptsSetKernelArgUsage(self): |
| kl1 = kernel_cmdline.KernelArgList('a dm="foo baz" b') |
| kl1.update({"dm": DM}) |
| expected = kernel_cmdline.KernelArgList('a dm="%s" b' % DM) |
| self.assertEqual(expected, kl1) |
| |
| def testUpdateAppends(self): |
| """Test update() appends new arg.""" |
| kv = kernel_cmdline.KernelArgList("a b c") |
| kv.update(kernel_cmdline.KernelArgList("d=99"), e="zz") |
| expected = kernel_cmdline.KernelArgList("a b c d=99 e=zz") |
| self.assertEqual(expected, kv) |
| |
| |
| class CommandLineTest(cros_test_lib.MockTestCase): |
| """Test the CommandLine class.""" |
| |
| 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 testEmptyInit(self): |
| """Test that 'a --' behaves as expected.""" |
| expected_kern = [kernel_cmdline.KernelArg("a", None)] |
| expected_init = [] |
| cmd = kernel_cmdline.CommandLine("a --") |
| self.assertEqual(expected_kern, cmd.kern_args) |
| self.assertEqual(expected_init, cmd.init_args) |
| |
| 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 testEmptyArg(self): |
| """Test that '' behaves as expected.""" |
| expected_kern = [] |
| expected_init = [] |
| cmd = kernel_cmdline.CommandLine("") |
| self.assertEqual(expected_kern, cmd.kern_args) |
| self.assertEqual(expected_init, cmd.init_args) |
| |
| def testEqual(self): |
| """Test that CommandLine equal compare works.""" |
| # Confirm that != is False, and == is True |
| self.assertFalse( |
| kernel_cmdline.CommandLine("a b -- d e") |
| != kernel_cmdline.CommandLine("a b -- d e") |
| ) |
| self.assertTrue( |
| kernel_cmdline.CommandLine("a b -- d e") |
| == kernel_cmdline.CommandLine("a b -- d e") |
| ) |
| |
| def testNotEqual(self): |
| """Test that CommandLine equal compare works.""" |
| # Confirm that == is False, and != is True |
| self.assertFalse( |
| kernel_cmdline.CommandLine("a b -- d e") |
| == kernel_cmdline.CommandLine("a b -- d f") |
| ) |
| self.assertTrue( |
| kernel_cmdline.CommandLine("a b -- d e") |
| != kernel_cmdline.CommandLine("a b -- d f") |
| ) |
| |
| def testDashesOnly(self): |
| """Test that '--' behaves as expected.""" |
| expected_kern = [] |
| expected_init = [] |
| cmd = kernel_cmdline.CommandLine("--") |
| self.assertEqual(expected_kern, cmd.kern_args) |
| self.assertEqual(expected_init, cmd.init_args) |
| |
| 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 testGetKernelParameter(self): |
| """Test GetKernelParameter calls Get.""" |
| get = self.PatchObject(kernel_cmdline.KernelArgList, "get") |
| cmd = kernel_cmdline.CommandLine("a b c b=3") |
| cmd.GetKernelParameter(1) |
| get.assert_called_once_with(1, default=None) |
| |
| def testGetKernelParameterPassesDefault(self): |
| """Test GetKernelParameter calls Get with default=.""" |
| get = self.PatchObject(kernel_cmdline.KernelArgList, "get") |
| cmd = kernel_cmdline.CommandLine("a b c b=3") |
| cmd.GetKernelParameter(1, default=3) |
| get.assert_called_once_with(1, default=3) |
| |
| def testSetKernelParameter(self): |
| """Test SetKernelParameter calls update.""" |
| mock_update = self.PatchObject(kernel_cmdline.KernelArgList, "update") |
| cmd = kernel_cmdline.CommandLine("a b c b=3") |
| cmd.SetKernelParameter("d", "e") |
| mock_update.assert_called_once_with({"d": "e"}) |
| |
| def testFormat(self): |
| """Test that the output is correct.""" |
| self.assertEqual(CMDLINE, kernel_cmdline.CommandLine(CMDLINE).Format()) |
| |
| def testGetDmConfig(self): |
| """Test that GetDmConfig returns the DmConfig we expect.""" |
| cmd = kernel_cmdline.CommandLine(CMDLINE) |
| dm = kernel_cmdline.DmConfig(DM) |
| self.assertEqual(dm, cmd.GetDmConfig()) |
| |
| def testGetDmConfigHandlesMissing(self): |
| """Test that GetDmConfig works with no dm= parameter.""" |
| cmd = kernel_cmdline.CommandLine("a b") |
| self.assertEqual(None, cmd.GetDmConfig()) |
| |
| 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 testSetDmConfigAcceptsNone(self): |
| """Test that SetDmConfig deletes the dm= parameter when set to None.""" |
| cmd = kernel_cmdline.CommandLine('a dm="0 vroot none 0" -- b') |
| cmd.SetDmConfig(None) |
| self.assertEqual(None, cmd.GetDmConfig()) |
| self.assertFalse("dm" in cmd.kern_args) |
| |
| |
| class DmConfigTest(cros_test_lib.TestCase): |
| """Test DmConfig.""" |
| |
| def testParses(self): |
| """Verify that DmConfig correctly parses the config from DmDevice.""" |
| device_data = [ |
| ["vboot uuid ro 1", "0 1 verity arg1 arg2"], |
| [ |
| "vblah uuid2 ro 2", |
| "100 9 stripe larg1=val1", |
| "200 10 stripe larg2=val2", |
| ], |
| ["vroot uuid3 ro 1", "99 3 linear larg1 larg2"], |
| ] |
| dm_arg = ", ".join(",".join(x for x in data) for data in device_data) |
| devices = [kernel_cmdline.DmDevice(x) for x in device_data] |
| dc = kernel_cmdline.DmConfig("%d %s" % (len(device_data), dm_arg)) |
| self.assertEqual(len(device_data), dc.num_devices) |
| self.assertEqual(devices, list(dc.devices.values())) |
| |
| def testIgnoresQuotes(self): |
| """Verify that DmConfig works with quoted string.""" |
| device_data = [ |
| ["vboot uuid ro 1", "0 1 verity arg1 arg2"], |
| [ |
| "vblah uuid2 ro 2", |
| "100 9 stripe larg1=val1", |
| "200 10 stripe larg2=val2", |
| ], |
| ["vroot uuid3 ro 1", "99 3 linear larg1 larg2"], |
| ] |
| dm_arg = ", ".join(",".join(x for x in data) for data in device_data) |
| devices = [kernel_cmdline.DmDevice(x) for x in device_data] |
| dc = kernel_cmdline.DmConfig('"%d %s"' % (len(device_data), dm_arg)) |
| self.assertEqual(len(device_data), dc.num_devices) |
| self.assertEqual(devices, list(dc.devices.values())) |
| |
| def testFormats(self): |
| """Verify that DmConfig recreates its input string.""" |
| device_data = [ |
| ["vboot uuid ro 1", "0 1 verity arg1 arg2"], |
| [ |
| "vblah uuid2 ro 2", |
| "100 9 stripe larg1=val1", |
| "200 10 stripe larg2=val2", |
| ], |
| ["vroot uuid3 ro 1", "99 3 linear larg1 larg2"], |
| ] |
| dm_arg = ", ".join(",".join(x for x in data) for data in device_data) |
| dm_config_val = "%d %s" % (len(device_data), dm_arg) |
| dc = kernel_cmdline.DmConfig(dm_config_val) |
| self.assertEqual(dm_config_val, dc.Format()) |
| |
| def testEqual(self): |
| """Test that equal instances are equal.""" |
| arg = "2 v1 u1 f1 1,0 1 t1 a1, v2 u2 f2 2,3 4 t2 a2,5 6 t3 a3" |
| dc = kernel_cmdline.DmConfig(arg) |
| self.assertEqual(dc, kernel_cmdline.DmConfig(arg)) |
| self.assertTrue(dc == kernel_cmdline.DmConfig(arg)) |
| # Also verify that != is False. |
| self.assertFalse(dc != kernel_cmdline.DmConfig(arg)) |
| |
| def testNotEqual(self): |
| """Test that unequal instances are unequal.""" |
| # Start with duplicated instances, and change fields to verify that all |
| # the fields matter. |
| arg = "2 v1 u1 f1 1,0 1 t1 a1, v2 u2 f2 2,3 4 t2 a2,5 6 t3 a3" |
| dc1 = kernel_cmdline.DmConfig(arg) |
| self.assertNotEqual(dc1, "") |
| dc2 = kernel_cmdline.DmConfig(arg) |
| dc2.num_devices = 1 |
| self.assertNotEqual(dc1, dc2) |
| dc3 = kernel_cmdline.DmConfig(arg) |
| dc3.devices = [] |
| self.assertNotEqual(dc1, dc3) |
| |
| 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 testGetVerityArgMultiLine(self): |
| """Test that GetVerityArg works.""" |
| arg = [ |
| "v1 u1 f1 3", |
| "9 9 xx a3 a4=v4", |
| "0 1 verity a1 a2=v2", |
| "9 9 verity a3 a2=v4", |
| ] |
| 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")) |
| self.assertEqual(None, dd.GetVerityArg("a9", default=None)) |
| self.assertEqual(a1, dd.GetVerityArg("a9", 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 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]) |
| |
| |
| class DmDeviceTest(cros_test_lib.TestCase): |
| """Test DmDevice.""" |
| |
| def testParsesOneLine(self): |
| """Verify that DmDevice correctly handles the results from DmLine.""" |
| lines = ["vboot none ro 1", "0 1 verity arg"] |
| dd = kernel_cmdline.DmDevice(lines) |
| self.assertEqual("vboot", dd.name) |
| self.assertEqual("none", dd.uuid) |
| self.assertEqual("ro", dd.flags) |
| self.assertEqual(1, dd.num_rows) |
| self.assertEqual([kernel_cmdline.DmLine("0 1 verity arg")], dd.rows) |
| |
| def testParsesMultiLine(self): |
| """Verify that DmDevice correctly handles multiline device.""" |
| lines = ["vboot none ro 2", "0 1 verity arg", "9 10 type a2"] |
| dd = kernel_cmdline.DmDevice(lines) |
| self.assertEqual("vboot", dd.name) |
| self.assertEqual("none", dd.uuid) |
| self.assertEqual("ro", dd.flags) |
| self.assertEqual(2, dd.num_rows) |
| self.assertEqual( |
| [ |
| kernel_cmdline.DmLine("0 1 verity arg"), |
| kernel_cmdline.DmLine("9 10 type a2"), |
| ], |
| dd.rows, |
| ) |
| |
| def testParsesIgnoresExcessRows(self): |
| """Verify that DmDevice ignores excess rows.""" |
| lines = [ |
| "vboot none ro 2", |
| "0 1 verity arg", |
| "9 10 type a2", |
| "4 5 t a3", |
| ] |
| dd = kernel_cmdline.DmDevice(lines) |
| self.assertEqual("vboot", dd.name) |
| self.assertEqual("none", dd.uuid) |
| self.assertEqual("ro", dd.flags) |
| self.assertEqual(2, dd.num_rows) |
| self.assertEqual( |
| [ |
| kernel_cmdline.DmLine("0 1 verity arg"), |
| kernel_cmdline.DmLine("9 10 type a2"), |
| ], |
| dd.rows, |
| ) |
| |
| def testEqual(self): |
| """Test that equal instances are equal.""" |
| dd = kernel_cmdline.DmDevice(["v u f 1", "0 1 typ a"]) |
| self.assertEqual(dd, kernel_cmdline.DmDevice(["v u f 1", "0 1 typ a"])) |
| self.assertTrue(dd == kernel_cmdline.DmDevice(["v u f 1", "0 1 typ a"])) |
| self.assertFalse( |
| dd != kernel_cmdline.DmDevice(["v u f 1", "0 1 typ a"]) |
| ) |
| |
| def testMultiLineEqual(self): |
| """Test that equal instances are equal.""" |
| dd = kernel_cmdline.DmDevice(["v u f 2", "0 1 typ a", "2 3 t b"]) |
| self.assertEqual( |
| dd, kernel_cmdline.DmDevice(["v u f 2", "0 1 typ a", "2 3 t b"]) |
| ) |
| self.assertFalse( |
| dd != kernel_cmdline.DmDevice(["v u f 2", "0 1 typ a", "2 3 t b"]) |
| ) |
| |
| def testNotEqual(self): |
| """Test that unequal instances are unequal.""" |
| dd = kernel_cmdline.DmDevice(["v u f 2", "0 1 typ a", "2 3 t b"]) |
| self.assertNotEqual(dd, "") |
| self.assertNotEqual( |
| dd, kernel_cmdline.DmDevice(["x u f 2", "0 1 typ a", "2 3 t b"]) |
| ) |
| self.assertNotEqual( |
| dd, kernel_cmdline.DmDevice(["v x f 2", "0 1 typ a", "2 3 t b"]) |
| ) |
| self.assertNotEqual( |
| dd, kernel_cmdline.DmDevice(["v u x 2", "0 1 typ a", "2 3 t b"]) |
| ) |
| self.assertNotEqual( |
| dd, kernel_cmdline.DmDevice(["v u f 1", "0 1 typ a", "2 3 t b"]) |
| ) |
| self.assertNotEqual( |
| dd, kernel_cmdline.DmDevice(["v u f 2", "9 1 typ a", "2 3 t b"]) |
| ) |
| |
| |
| class DmLineTest(cros_test_lib.TestCase): |
| """Test DmLine.""" |
| |
| def testParses(self): |
| """Verify that DmLine correctly parses a line, and returns it.""" |
| text = "0 1 verity a1 a2=v2 a3" |
| dl = kernel_cmdline.DmLine(text) |
| self.assertEqual(0, dl.start) |
| self.assertEqual(1, dl.num) |
| self.assertEqual("verity", dl.target_type) |
| self.assertEqual(kernel_cmdline.KernelArgList("a1 a2=v2 a3"), dl.args) |
| self.assertEqual(text, dl.Format()) |
| |
| def testAllowsWhitespace(self): |
| """Verify that leading/trailing whitespace is ignored.""" |
| text = "0 1 verity a1 a2=v2 a3" |
| dl = kernel_cmdline.DmLine(" %s " % text) |
| self.assertEqual(0, dl.start) |
| self.assertEqual(1, dl.num) |
| self.assertEqual("verity", dl.target_type) |
| self.assertEqual(kernel_cmdline.KernelArgList("a1 a2=v2 a3"), dl.args) |
| self.assertEqual(text, dl.Format()) |
| |
| def testEqual(self): |
| """Test that equal instances are equal.""" |
| dl = kernel_cmdline.DmLine("0 1 verity a1 a2=v2 a3") |
| self.assertEqual(dl, kernel_cmdline.DmLine("0 1 verity a1 a2=v2 a3")) |
| self.assertFalse(dl != kernel_cmdline.DmLine("0 1 verity a1 a2=v2 a3")) |
| |
| def testNotEqual(self): |
| """Test that unequal instances are unequal.""" |
| dl = kernel_cmdline.DmLine("0 1 verity a1 a2=v2 a3") |
| self.assertNotEqual(dl, "") |
| self.assertNotEqual(dl, kernel_cmdline.DmLine("1 1 verity a1 a2=v2 a3")) |
| self.assertNotEqual(dl, kernel_cmdline.DmLine("0 2 verity a1 a2=v2 a3")) |
| self.assertNotEqual(dl, kernel_cmdline.DmLine("0 1 verit a1 a2=v2 a3")) |
| self.assertNotEqual(dl, kernel_cmdline.DmLine("0 1 verity aN a2=v2 a3")) |
