TestBmpBlock: use real tempdirs instead of $PWD

This lets us do proper out-of-tree builds by not writing to the cwd.

BUG=chromium:466499
TEST=precq still passes
TEST=out-of-tree ebuild passes
BRANCH=None

Change-Id: I49eb013cf9c2f5ff73cfab155612aaa4d1d724cd
Reviewed-on: https://chromium-review.googlesource.com/259520
Trybot-Ready: Mike Frysinger <vapier@chromium.org>
Reviewed-by: Hung-Te Lin <hungte@chromium.org>
Commit-Queue: Mike Frysinger <vapier@chromium.org>
Tested-by: Mike Frysinger <vapier@chromium.org>

1 files changed, 64 insertions, 76 deletions

diff --git a/tests/bitmaps/TestBmpBlock.py b/tests/bitmaps/TestBmpBlock.py
index 2fcfd665..01f85540 100755
--- a/tests/bitmaps/TestBmpBlock.py
+++ b/tests/bitmaps/TestBmpBlock.py
@@ -10,6 +10,7 @@
 import os
 import sys
 import subprocess
+import tempfile
 import unittest
 
 def runprog(*args):
@@ -19,7 +20,20 @@ def runprog(*args):
   return (p.returncode, out, err)
 
 
-class TestFailures(unittest.TestCase):
+class TempDirTestCase(unittest.TestCase):
+  """A TestCase that sets up self.tempdir with a temporary directory."""
+
+  def setUp(self):
+    self.tempdir = tempfile.mkdtemp(prefix='tmp_test_bmp_block')
+    self.tempfile = os.path.join(self.tempdir, 'FOO')
+    self._cwd = os.getcwd()
+
+  def tearDown(self):
+    os.chdir(self._cwd)
+    runprog('rm', '-rf', self.tempdir)
+
+
+class TestFailures(TempDirTestCase):
 
   def testNoArgs(self):
     """Running with no args should print usage and fail."""
@@ -30,129 +44,111 @@ class TestFailures(unittest.TestCase):
 
   def testMissingBmp(self):
     """Missing a bmp specified in the yaml is an error."""
-    rc, out, err = runprog(prog, '-c', 'case_nobmp.yaml', 'FOO')
+    rc, out, err = runprog(prog, '-c', 'case_nobmp.yaml', self.tempfile)
     self.assertNotEqual(0, rc)
     self.assertTrue(err.count("No such file or directory"))
 
   def testInvalidBmp(self):
     """A .bmp file that isn't really a BMP should fail."""
-    rc, out, err = runprog(prog, '-c', 'case_badbmp.yaml', 'FOO')
+    rc, out, err = runprog(prog, '-c', 'case_badbmp.yaml', self.tempfile)
     self.assertNotEqual(0, rc)
     self.assertTrue(err.count("Unsupported image format"))
 
   def testBadCompression(self):
     """Wrong compression types should fail."""
-    rc, out, err = runprog(prog, '-z', '99', '-c', 'case_simple.yaml', 'FOO')
+    rc, out, err = runprog(prog, '-z', '99', '-c', 'case_simple.yaml', self.tempfile)
     self.assertNotEqual(0, rc)
     self.assertTrue(err.count("compression type"))
 
 
-class TestOverWrite(unittest.TestCase):
-
-  def setUp(self):
-    rc, out, err = runprog('/bin/rm', '-rf', './FOO_DIR', 'FOO')
-    self.assertEqual(0, rc)
+class TestOverWrite(TempDirTestCase):
 
   def testOverwrite(self):
     """Create, unpack, unpack again, with and without -f"""
-    rc, out, err = runprog(prog, '-c', 'case_simple.yaml', 'FOO')
+    rc, out, err = runprog(prog, '-c', 'case_simple.yaml', self.tempfile)
     self.assertEqual(0, rc)
-    rc, out, err = runprog(prog, '-x', '-d', './FOO_DIR', 'FOO')
+    rc, out, err = runprog(prog, '-x', '-d', self.tempdir, self.tempfile)
     self.assertEqual(0, rc)
-    rc, out, err = runprog(prog, '-x', '-d', './FOO_DIR', 'FOO')
+    rc, out, err = runprog(prog, '-x', '-d', self.tempdir, self.tempfile)
     self.assertNotEqual(0, rc)
     self.assertTrue(err.count("File exists"))
-    rc, out, err = runprog(prog, '-x', '-d', './FOO_DIR', '-f', 'FOO')
-    self.assertEqual(0, rc)
-
-  def tearDown(self):
-    rc, out, err = runprog('/bin/rm', '-rf', './FOO_DIR', 'FOO')
+    rc, out, err = runprog(prog, '-x', '-d', self.tempdir, '-f', self.tempfile)
     self.assertEqual(0, rc)
 
 
-class TestPackUnpack(unittest.TestCase):
-
-  def setUp(self):
-    self._cwd = os.getcwd()
-    rc, out, err = runprog('/bin/rm', '-rf', './FOO_DIR', 'FOO')
-    self.assertEqual(0, rc)
+class TestPackUnpack(TempDirTestCase):
 
   def testPackUnpack(self):
     """Create, unpack, recreate without compression"""
-    rc, out, err = runprog(prog, '-c', 'case_simple.yaml', 'FOO')
+    foo = os.path.join(self.tempdir, 'FOO')
+    bar = os.path.join(self.tempdir, 'BAR')
+    rc, out, err = runprog(prog, '-c', 'case_simple.yaml', foo)
     self.assertEqual(0, rc)
-    rc, out, err = runprog(prog, '-x', '-d', './FOO_DIR', 'FOO')
+    rc, out, err = runprog(prog, '-x', '-d', self.tempdir, foo)
     self.assertEqual(0, rc)
-    os.chdir('./FOO_DIR')
-    rc, out, err = runprog(prog, '-c', 'config.yaml', 'BAR')
+    os.chdir(self.tempdir)
+    rc, out, err = runprog(prog, '-c', 'config.yaml', bar)
     self.assertEqual(0, rc)
-    rc, out, err = runprog('/usr/bin/cmp', '../FOO', 'BAR')
+    rc, out, err = runprog('/usr/bin/cmp', foo, bar)
     self.assertEqual(0, rc)
-    os.chdir('..')
 
   def doPackUnpackZ(self, comp):
     """Create, unpack, recreate with a given compression"""
-    rc, out, err = runprog(prog, '-z', comp, '-c', 'case_simple.yaml', 'FOO')
+    foo = os.path.join(self.tempdir, 'FOO')
+    bar = os.path.join(self.tempdir, 'BAR')
+    rc, out, err = runprog(prog, '-z', comp, '-c', 'case_simple.yaml', foo)
     self.assertEqual(0, rc)
-    rc, out, err = runprog(prog, '-x', '-d', './FOO_DIR', 'FOO')
+    rc, out, err = runprog(prog, '-x', '-d', self.tempdir, foo)
     self.assertEqual(0, rc)
-    os.chdir('./FOO_DIR')
-    rc, out, err = runprog(prog, '-z', comp, '-c', 'config.yaml', 'BAR')
+    os.chdir(self.tempdir)
+    rc, out, err = runprog(prog, '-z', comp, '-c', 'config.yaml', bar)
     self.assertEqual(0, rc)
-    rc, out, err = runprog('/usr/bin/cmp', '../FOO', 'BAR')
+    rc, out, err = runprog('/usr/bin/cmp', foo, bar)
     self.assertEqual(0, rc)
-    os.chdir('..')
 
   def testPackUnpackZ1(self):
     """Create, unpack, recreate with EFIv1 compression"""
-    self.doPackUnpackZ('1');
+    self.doPackUnpackZ('1')
 
   def testPackUnpackZ2(self):
     """Create, unpack, recreate with LZMA compression"""
-    self.doPackUnpackZ('2');
+    self.doPackUnpackZ('2')
 
   def doPackUnpackImplicitZ(self, comp, noncomp):
     """Create with given compression, unpack, repack without specifying"""
+    foo = os.path.join(self.tempdir, 'FOO')
+    bar = os.path.join(self.tempdir, 'BAR')
     # create with the specified compression scheme
-    rc, out, err = runprog(prog, '-z', comp, '-c', 'case_simple.yaml', 'FOO')
+    rc, out, err = runprog(prog, '-z', comp, '-c', 'case_simple.yaml', foo)
     self.assertEqual(0, rc)
     # unpack. yaml file should have compression scheme in it
-    rc, out, err = runprog(prog, '-f', '-x', '-d', './FOO_DIR', 'FOO')
+    rc, out, err = runprog(prog, '-f', '-x', '-d', self.tempdir, foo)
     self.assertEqual(0, rc)
-    os.chdir('./FOO_DIR')
+    os.chdir(self.tempdir)
     # create with no compression specified, should use default from yaml
-    rc, out, err = runprog(prog, '-c', 'config.yaml', 'BAR')
+    rc, out, err = runprog(prog, '-c', 'config.yaml', bar)
     self.assertEqual(0, rc)
     # so new output should match original
-    rc, out, err = runprog('/usr/bin/cmp', '../FOO', 'BAR')
+    rc, out, err = runprog('/usr/bin/cmp', foo, bar)
     self.assertEqual(0, rc)
     # Now make sure that specifying a compression arg will override the default
     for mycomp in noncomp:
       # create with compression scheme different from default
-      rc, out, err = runprog(prog, '-z', str(mycomp), '-c', 'config.yaml', 'BAR')
+      rc, out, err = runprog(prog, '-z', str(mycomp), '-c', 'config.yaml', bar)
       self.assertEqual(0, rc)
       # should be different binary
-      rc, out, err = runprog('/usr/bin/cmp', '../FOO', 'BAR')
+      rc, out, err = runprog('/usr/bin/cmp', foo, bar)
       self.assertNotEqual(0, rc)
-    os.chdir('..')
 
   def testPackUnpackImplicitZ(self):
     """Create, unpack, recreate with implicit compression"""
     self._allowed = range(3)
     for c in self._allowed:
+      os.chdir(self._cwd)
       self.doPackUnpackImplicitZ(str(c), [x for x in self._allowed if x != c])
 
-  def tearDown(self):
-    os.chdir(self._cwd)
-    rc, out, err = runprog('/bin/rm', '-rf', './FOO_DIR', 'FOO')
-    self.assertEqual(0, rc)
-
-
-class TestReproducable(unittest.TestCase):
 
-  def setUp(self):
-    rc, out, err = runprog('/bin/rm', '-f', 'ORDER1', 'ORDER2')
-    self.assertEqual(0, rc)
+class TestReproducable(TempDirTestCase):
 
   def disabledTestReproduce(self):
     """Equivalent yaml files should produce identical bmpblocks"""
@@ -160,38 +156,30 @@ class TestReproducable(unittest.TestCase):
     # uses a map to hold the images, and the map doesn't preserve image
     # order.  So a simple compare is insufficient to determine that
     # the bmpblocks are equivalent.  See crosbug.com/19541.
-    rc, out, err = runprog(prog, '-c', 'case_order1.yaml', 'ORDER1')
+    order1 = os.path.join(self.tempdir, 'ORDER1')
+    order2 = os.path.join(self.tempdir, 'ORDER2')
+    rc, out, err = runprog(prog, '-c', 'case_order1.yaml', order1)
     self.assertEqual(0, rc)
-    rc, out, err = runprog(prog, '-c', 'case_order2.yaml', 'ORDER2')
+    rc, out, err = runprog(prog, '-c', 'case_order2.yaml', order2)
     self.assertEqual(0, rc)
-    rc, out, err = runprog('/usr/bin/cmp', 'ORDER1', 'ORDER2')
+    rc, out, err = runprog('/usr/bin/cmp', order1, order2)
     self.assertEqual(0, rc)
 
-  def tearDown(self):
-    rc, out, err = runprog('/bin/rm', '-f', 'ORDER1', 'ORDER2')
-    self.assertEqual(0, rc)
 
-class TestReuse(unittest.TestCase):
-
-  def setUp(self):
-    rc, out, err = runprog('/bin/rm', '-rf', './FOO_DIR', 'FOO')
-    self.assertEqual(0, rc)
+class TestReuse(TempDirTestCase):
 
   def testReuse(self):
     """Reusing screens in the yaml file should be okay"""
-    rc, out, err = runprog(prog, '-c', 'case_reuse.yaml', 'FOO')
-    self.assertEqual(0, rc)
-    rc, out, err = runprog(prog, '-x', '-d', './FOO_DIR', 'FOO')
+    foo = os.path.join(self.tempdir, 'FOO')
+    bar = os.path.join(self.tempdir, 'BAR')
+    rc, out, err = runprog(prog, '-c', 'case_reuse.yaml', foo)
     self.assertEqual(0, rc)
-    os.chdir('./FOO_DIR')
-    rc, out, err = runprog(prog, '-c', 'config.yaml', 'BAR')
+    rc, out, err = runprog(prog, '-x', '-d', self.tempdir, foo)
     self.assertEqual(0, rc)
-    rc, out, err = runprog('/usr/bin/cmp', '../FOO', 'BAR')
+    os.chdir(self.tempdir)
+    rc, out, err = runprog(prog, '-c', 'config.yaml', bar)
     self.assertEqual(0, rc)
-    os.chdir('..')
-
-  def tearDown(self):
-    rc, out, err = runprog('/bin/rm', '-rf', './FOO_DIR', 'FOO')
+    rc, out, err = runprog('/usr/bin/cmp', foo, bar)
     self.assertEqual(0, rc)