Add coverage

tools/telemetry/third_party/coverage/tests/test_data.py

+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt
+
+"""Tests for coverage.data"""
+
+import glob
+import json
+import os
+import os.path
+import re
+
+import mock
+
+from coverage.backward import StringIO
+from coverage.data import CoverageData, CoverageDataFiles, debug_main, canonicalize_json_data
+from coverage.files import PathAliases, canonical_filename
+from coverage.misc import CoverageException
+
+from tests.coveragetest import CoverageTest, DebugControlString
+
+
+LINES_1 = {
+    'a.py': {1: None, 2: None},
+    'b.py': {3: None},
+}
+SUMMARY_1 = {'a.py': 2, 'b.py': 1}
+MEASURED_FILES_1 = ['a.py', 'b.py']
+A_PY_LINES_1 = [1, 2]
+B_PY_LINES_1 = [3]
+
+LINES_2 = {
+    'a.py': {1: None, 5: None},
+    'c.py': {17: None},
+}
+SUMMARY_1_2 = {'a.py': 3, 'b.py': 1, 'c.py': 1}
+MEASURED_FILES_1_2 = ['a.py', 'b.py', 'c.py']
+
+ARCS_3 = {
+    'x.py': {
+        (-1, 1): None,
+        (1, 2): None,
+        (2, 3): None,
+        (3, -1): None,
+    },
+    'y.py': {
+        (-1, 17): None,
+        (17, 23): None,
+        (23, -1): None,
+    },
+}
+X_PY_ARCS_3 = [(-1, 1), (1, 2), (2, 3), (3, -1)]
+Y_PY_ARCS_3 = [(-1, 17), (17, 23), (23, -1)]
+SUMMARY_3 = {'x.py': 3, 'y.py': 2}
+MEASURED_FILES_3 = ['x.py', 'y.py']
+X_PY_LINES_3 = [1, 2, 3]
+Y_PY_LINES_3 = [17, 23]
+
+ARCS_4 = {
+    'x.py': {
+        (-1, 2): None,
+        (2, 5): None,
+        (5, -1): None,
+    },
+    'z.py': {
+        (-1, 1000): None,
+        (1000, -1): None,
+    },
+}
+SUMMARY_3_4 = {'x.py': 5, 'y.py': 2, 'z.py': 1}
+MEASURED_FILES_3_4 = ['x.py', 'y.py', 'z.py']
+
+
+class DataTestHelpers(CoverageTest):
+    """Test helpers for data tests."""
+
+    def assert_line_counts(self, covdata, line_counts, fullpath=False):
+        """Check that the line_counts of `covdata` is `line_counts`."""
+        self.assertEqual(covdata.line_counts(fullpath), line_counts)
+
+    def assert_measured_files(self, covdata, measured):
+        """Check that `covdata`'s measured files are `measured`."""
+        self.assertCountEqual(covdata.measured_files(), measured)
+
+    def assert_lines1_data(self, covdata):
+        """Check that `covdata` has the data from LINES1."""
+        self.assert_line_counts(covdata, SUMMARY_1)
+        self.assert_measured_files(covdata, MEASURED_FILES_1)
+        self.assertCountEqual(covdata.lines("a.py"), A_PY_LINES_1)
+        self.assertEqual(covdata.run_infos(), [])
+        self.assertFalse(covdata.has_arcs())
+
+    def assert_arcs3_data(self, covdata):
+        """Check that `covdata` has the data from ARCS3."""
+        self.assert_line_counts(covdata, SUMMARY_3)
+        self.assert_measured_files(covdata, MEASURED_FILES_3)
+        self.assertCountEqual(covdata.lines("x.py"), X_PY_LINES_3)
+        self.assertCountEqual(covdata.arcs("x.py"), X_PY_ARCS_3)
+        self.assertCountEqual(covdata.lines("y.py"), Y_PY_LINES_3)
+        self.assertCountEqual(covdata.arcs("y.py"), Y_PY_ARCS_3)
+        self.assertTrue(covdata.has_arcs())
+        self.assertEqual(covdata.run_infos(), [])
+
+
+class CoverageDataTest(DataTestHelpers, CoverageTest):
+    """Test cases for CoverageData."""
+
+    run_in_temp_dir = False
+
+    def test_empty_data_is_false(self):
+        covdata = CoverageData()
+        self.assertFalse(covdata)
+
+    def test_line_data_is_true(self):
+        covdata = CoverageData()
+        covdata.add_lines(LINES_1)
+        self.assertTrue(covdata)
+
+    def test_arc_data_is_true(self):
+        covdata = CoverageData()
+        covdata.add_arcs(ARCS_3)
+        self.assertTrue(covdata)
+
+    def test_empty_line_data_is_false(self):
+        covdata = CoverageData()
+        covdata.add_lines({})
+        self.assertFalse(covdata)
+
+    def test_empty_arc_data_is_false(self):
+        covdata = CoverageData()
+        covdata.add_arcs({})
+        self.assertFalse(covdata)
+
+    def test_adding_lines(self):
+        covdata = CoverageData()
+        covdata.add_lines(LINES_1)
+        self.assert_lines1_data(covdata)
+
+    def test_adding_arcs(self):
+        covdata = CoverageData()
+        covdata.add_arcs(ARCS_3)
+        self.assert_arcs3_data(covdata)
+
+    def test_ok_to_add_lines_twice(self):
+        covdata = CoverageData()
+        covdata.add_lines(LINES_1)
+        covdata.add_lines(LINES_2)
+        self.assert_line_counts(covdata, SUMMARY_1_2)
+        self.assert_measured_files(covdata, MEASURED_FILES_1_2)
+
+    def test_ok_to_add_arcs_twice(self):
+        covdata = CoverageData()
+        covdata.add_arcs(ARCS_3)
+        covdata.add_arcs(ARCS_4)
+        self.assert_line_counts(covdata, SUMMARY_3_4)
+        self.assert_measured_files(covdata, MEASURED_FILES_3_4)
+
+    def test_cant_add_arcs_with_lines(self):
+        covdata = CoverageData()
+        covdata.add_lines(LINES_1)
+        with self.assertRaisesRegex(CoverageException, "Can't add arcs to existing line data"):
+            covdata.add_arcs(ARCS_3)
+
+    def test_cant_add_lines_with_arcs(self):
+        covdata = CoverageData()
+        covdata.add_arcs(ARCS_3)
+        with self.assertRaisesRegex(CoverageException, "Can't add lines to existing arc data"):
+            covdata.add_lines(LINES_1)
+
+    def test_touch_file_with_lines(self):
+        covdata = CoverageData()
+        covdata.add_lines(LINES_1)
+        covdata.touch_file('zzz.py')
+        self.assert_measured_files(covdata, MEASURED_FILES_1 + ['zzz.py'])
+
+    def test_touch_file_with_arcs(self):
+        covdata = CoverageData()
+        covdata.add_arcs(ARCS_3)
+        covdata.touch_file('zzz.py')
+        self.assert_measured_files(covdata, MEASURED_FILES_3 + ['zzz.py'])
+
+    def test_no_lines_vs_unmeasured_file(self):
+        covdata = CoverageData()
+        covdata.add_lines(LINES_1)
+        covdata.touch_file('zzz.py')
+        self.assertEqual(covdata.lines('zzz.py'), [])
+        self.assertIsNone(covdata.lines('no_such_file.py'))
+
+    def test_run_info(self):
+        covdata = CoverageData()
+        self.assertEqual(covdata.run_infos(), [])
+        covdata.add_run_info(hello="there")
+        self.assertEqual(covdata.run_infos(), [{"hello": "there"}])
+        covdata.add_run_info(count=17)
+        self.assertEqual(covdata.run_infos(), [{"hello": "there", "count": 17}])
+
+    def test_no_arcs_vs_unmeasured_file(self):
+        covdata = CoverageData()
+        covdata.add_arcs(ARCS_3)
+        covdata.touch_file('zzz.py')
+        self.assertEqual(covdata.lines('zzz.py'), [])
+        self.assertIsNone(covdata.lines('no_such_file.py'))
+        self.assertEqual(covdata.arcs('zzz.py'), [])
+        self.assertIsNone(covdata.arcs('no_such_file.py'))
+
+    def test_file_tracer_name(self):
+        covdata = CoverageData()
+        covdata.add_lines({
+            "p1.foo": dict.fromkeys([1, 2, 3]),
+            "p2.html": dict.fromkeys([10, 11, 12]),
+            "main.py": dict.fromkeys([20]),
+        })
+        covdata.add_file_tracers({"p1.foo": "p1.plugin", "p2.html": "p2.plugin"})
+        self.assertEqual(covdata.file_tracer("p1.foo"), "p1.plugin")
+        self.assertEqual(covdata.file_tracer("main.py"), "")
+        self.assertIsNone(covdata.file_tracer("p3.not_here"))
+
+    def test_cant_file_tracer_unmeasured_files(self):
+        covdata = CoverageData()
+        msg = "Can't add file tracer data for unmeasured file 'p1.foo'"
+        with self.assertRaisesRegex(CoverageException, msg):
+            covdata.add_file_tracers({"p1.foo": "p1.plugin"})
+
+        covdata.add_lines({"p2.html": dict.fromkeys([10, 11, 12])})
+        with self.assertRaisesRegex(CoverageException, msg):
+            covdata.add_file_tracers({"p1.foo": "p1.plugin"})
+
+    def test_cant_change_file_tracer_name(self):
+        covdata = CoverageData()
+        covdata.add_lines({"p1.foo": dict.fromkeys([1, 2, 3])})
+        covdata.add_file_tracers({"p1.foo": "p1.plugin"})
+
+        msg = "Conflicting file tracer name for 'p1.foo': 'p1.plugin' vs 'p1.plugin.foo'"
+        with self.assertRaisesRegex(CoverageException, msg):
+            covdata.add_file_tracers({"p1.foo": "p1.plugin.foo"})
+
+    def test_update_lines(self):
+        covdata1 = CoverageData()
+        covdata1.add_lines(LINES_1)
+
+        covdata2 = CoverageData()
+        covdata2.add_lines(LINES_2)
+
+        covdata3 = CoverageData()
+        covdata3.update(covdata1)
+        covdata3.update(covdata2)
+
+        self.assert_line_counts(covdata3, SUMMARY_1_2)
+        self.assert_measured_files(covdata3, MEASURED_FILES_1_2)
+        self.assertEqual(covdata3.run_infos(), [])
+
+    def test_update_arcs(self):
+        covdata1 = CoverageData()
+        covdata1.add_arcs(ARCS_3)
+
+        covdata2 = CoverageData()
+        covdata2.add_arcs(ARCS_4)
+
+        covdata3 = CoverageData()
+        covdata3.update(covdata1)
+        covdata3.update(covdata2)
+
+        self.assert_line_counts(covdata3, SUMMARY_3_4)
+        self.assert_measured_files(covdata3, MEASURED_FILES_3_4)
+        self.assertEqual(covdata3.run_infos(), [])
+
+    def test_update_run_info(self):
+        covdata1 = CoverageData()
+        covdata1.add_arcs(ARCS_3)
+        covdata1.add_run_info(hello="there", count=17)
+
+        covdata2 = CoverageData()
+        covdata2.add_arcs(ARCS_4)
+        covdata2.add_run_info(hello="goodbye", count=23)
+
+        covdata3 = CoverageData()
+        covdata3.update(covdata1)
+        covdata3.update(covdata2)
+
+        self.assertEqual(covdata3.run_infos(), [
+            {'hello': 'there', 'count': 17},
+            {'hello': 'goodbye', 'count': 23},
+        ])
+
+    def test_update_cant_mix_lines_and_arcs(self):
+        covdata1 = CoverageData()
+        covdata1.add_lines(LINES_1)
+
+        covdata2 = CoverageData()
+        covdata2.add_arcs(ARCS_3)
+
+        with self.assertRaisesRegex(CoverageException, "Can't combine arc data with line data"):
+            covdata1.update(covdata2)
+
+        with self.assertRaisesRegex(CoverageException, "Can't combine line data with arc data"):
+            covdata2.update(covdata1)
+
+    def test_update_file_tracers(self):
+        covdata1 = CoverageData()
+        covdata1.add_lines({
+            "p1.html": dict.fromkeys([1, 2, 3, 4]),
+            "p2.html": dict.fromkeys([5, 6, 7]),
+            "main.py": dict.fromkeys([10, 11, 12]),
+        })
+        covdata1.add_file_tracers({
+            "p1.html": "html.plugin",
+            "p2.html": "html.plugin2",
+        })
+
+        covdata2 = CoverageData()
+        covdata2.add_lines({
+            "p1.html": dict.fromkeys([3, 4, 5, 6]),
+            "p2.html": dict.fromkeys([7, 8, 9]),
+            "p3.foo": dict.fromkeys([1000, 1001]),
+            "main.py": dict.fromkeys([10, 11, 12]),
+        })
+        covdata2.add_file_tracers({
+            "p1.html": "html.plugin",
+            "p2.html": "html.plugin2",
+            "p3.foo": "foo_plugin",
+        })
+
+        covdata3 = CoverageData()
+        covdata3.update(covdata1)
+        covdata3.update(covdata2)
+        self.assertEqual(covdata3.file_tracer("p1.html"), "html.plugin")
+        self.assertEqual(covdata3.file_tracer("p2.html"), "html.plugin2")
+        self.assertEqual(covdata3.file_tracer("p3.foo"), "foo_plugin")
+        self.assertEqual(covdata3.file_tracer("main.py"), "")
+
+    def test_update_conflicting_file_tracers(self):
+        covdata1 = CoverageData()
+        covdata1.add_lines({"p1.html": dict.fromkeys([1, 2, 3])})
+        covdata1.add_file_tracers({"p1.html": "html.plugin"})
+
+        covdata2 = CoverageData()
+        covdata2.add_lines({"p1.html": dict.fromkeys([1, 2, 3])})
+        covdata2.add_file_tracers({"p1.html": "html.other_plugin"})
+
+        msg = "Conflicting file tracer name for 'p1.html': 'html.plugin' vs 'html.other_plugin'"
+        with self.assertRaisesRegex(CoverageException, msg):
+            covdata1.update(covdata2)
+
+        msg = "Conflicting file tracer name for 'p1.html': 'html.other_plugin' vs 'html.plugin'"
+        with self.assertRaisesRegex(CoverageException, msg):
+            covdata2.update(covdata1)
+
+    def test_update_file_tracer_vs_no_file_tracer(self):
+        covdata1 = CoverageData()
+        covdata1.add_lines({"p1.html": dict.fromkeys([1, 2, 3])})
+        covdata1.add_file_tracers({"p1.html": "html.plugin"})
+
+        covdata2 = CoverageData()
+        covdata2.add_lines({"p1.html": dict.fromkeys([1, 2, 3])})
+
+        msg = "Conflicting file tracer name for 'p1.html': 'html.plugin' vs ''"
+        with self.assertRaisesRegex(CoverageException, msg):
+            covdata1.update(covdata2)
+
+        msg = "Conflicting file tracer name for 'p1.html': '' vs 'html.plugin'"
+        with self.assertRaisesRegex(CoverageException, msg):
+            covdata2.update(covdata1)
+
+    def test_add_to_hash_with_lines(self):
+        covdata = CoverageData()
+        covdata.add_lines(LINES_1)
+        hasher = mock.Mock()
+        covdata.add_to_hash("a.py", hasher)
+        self.assertEqual(hasher.method_calls, [
+            mock.call.update([1, 2]),   # lines
+            mock.call.update(""),       # file_tracer name
+        ])
+
+    def test_add_to_hash_with_arcs(self):
+        covdata = CoverageData()
+        covdata.add_arcs(ARCS_3)
+        covdata.add_file_tracers({"y.py": "hologram_plugin"})
+        hasher = mock.Mock()
+        covdata.add_to_hash("y.py", hasher)
+        self.assertEqual(hasher.method_calls, [
+            mock.call.update([(-1, 17), (17, 23), (23, -1)]),   # arcs
+            mock.call.update("hologram_plugin"),                # file_tracer name
+        ])
+
+    def test_add_to_lines_hash_with_missing_file(self):
+        # https://bitbucket.org/ned/coveragepy/issues/403
+        covdata = CoverageData()
+        covdata.add_lines(LINES_1)
+        hasher = mock.Mock()
+        covdata.add_to_hash("missing.py", hasher)
+        self.assertEqual(hasher.method_calls, [
+            mock.call.update([]),
+            mock.call.update(None),
+        ])
+
+    def test_add_to_arcs_hash_with_missing_file(self):
+        # https://bitbucket.org/ned/coveragepy/issues/403
+        covdata = CoverageData()
+        covdata.add_arcs(ARCS_3)
+        covdata.add_file_tracers({"y.py": "hologram_plugin"})
+        hasher = mock.Mock()
+        covdata.add_to_hash("missing.py", hasher)
+        self.assertEqual(hasher.method_calls, [
+            mock.call.update([]),
+            mock.call.update(None),
+        ])
+
+    def test_empty_lines_are_still_lines(self):
+        covdata = CoverageData()
+        covdata.add_lines({})
+        covdata.touch_file("abc.py")
+        self.assertFalse(covdata.has_arcs())
+
+    def test_empty_arcs_are_still_arcs(self):
+        covdata = CoverageData()
+        covdata.add_arcs({})
+        covdata.touch_file("abc.py")
+        self.assertTrue(covdata.has_arcs())
+
+    def test_read_and_write_are_opposites(self):
+        covdata1 = CoverageData()
+        covdata1.add_arcs(ARCS_3)
+        stringio = StringIO()
+        covdata1.write_fileobj(stringio)
+
+        stringio.seek(0)
+        covdata2 = CoverageData()
+        covdata2.read_fileobj(stringio)
+        self.assert_arcs3_data(covdata2)
+
+
+class CoverageDataTestInTempDir(DataTestHelpers, CoverageTest):
+    """Tests of CoverageData that need a temporary directory to make files."""
+
+    def test_read_write_lines(self):
+        covdata1 = CoverageData()
+        covdata1.add_lines(LINES_1)
+        covdata1.write_file("lines.dat")
+
+        covdata2 = CoverageData()
+        covdata2.read_file("lines.dat")
+        self.assert_lines1_data(covdata2)
+
+    def test_read_write_arcs(self):
+        covdata1 = CoverageData()
+        covdata1.add_arcs(ARCS_3)
+        covdata1.write_file("arcs.dat")
+
+        covdata2 = CoverageData()
+        covdata2.read_file("arcs.dat")
+        self.assert_arcs3_data(covdata2)
+
+    def test_read_errors(self):
+        covdata = CoverageData()
+
+        msg = r"Couldn't read data from '{0}': \S+"
+        self.make_file("xyzzy.dat", "xyzzy")
+        with self.assertRaisesRegex(CoverageException, msg.format("xyzzy.dat")):
+            covdata.read_file("xyzzy.dat")
+
+        self.make_file("empty.dat", "")
+        with self.assertRaisesRegex(CoverageException, msg.format("empty.dat")):
+            covdata.read_file("empty.dat")
+
+        with self.assertRaisesRegex(CoverageException, msg.format("nonexistent.dat")):
+            covdata.read_file("nonexistent.dat")
+
+        self.make_file("misleading.dat", CoverageData._GO_AWAY + " this isn't JSON")
+        with self.assertRaisesRegex(CoverageException, msg.format("misleading.dat")):
+            covdata.read_file("misleading.dat")
+
+        # After all that, no data should be in our CoverageData.
+        self.assertFalse(covdata)
+
+    def test_debug_main(self):
+        covdata1 = CoverageData()
+        covdata1.add_lines(LINES_1)
+        covdata1.write_file(".coverage")
+        debug_main([])
+
+        covdata2 = CoverageData()
+        covdata2.add_arcs(ARCS_3)
+        covdata2.add_file_tracers({"y.py": "magic_plugin"})
+        covdata2.add_run_info(version="v3.14", chunks=["z", "a"])
+        covdata2.write_file("arcs.dat")
+
+        covdata3 = CoverageData()
+        covdata3.write_file("empty.dat")
+        debug_main(["arcs.dat", "empty.dat"])
+
+        expected = {
+            ".coverage": {
+                "lines": {
+                    "a.py": [1, 2],
+                    "b.py": [3],
+                },
+            },
+            "arcs.dat": {
+                "arcs": {
+                    "x.py": [[-1, 1], [1, 2], [2, 3], [3, -1]],
+                    "y.py": [[-1, 17], [17, 23], [23, -1]],
+                },
+                "file_tracers": {"y.py": "magic_plugin"},
+                "runs": [
+                    {
+                        "chunks": ["z", "a"],
+                        "version": "v3.14",
+                    },
+                ],
+            },
+            "empty.dat": {},
+        }
+        pieces = re.split(r"(?m)-+ ([\w.]+) -+$", self.stdout())
+        for name, json_out in zip(pieces[1::2], pieces[2::2]):
+            json_got = json.loads(json_out)
+            canonicalize_json_data(json_got)
+            self.assertEqual(expected[name], json_got)
+
+
+class CoverageDataFilesTest(DataTestHelpers, CoverageTest):
+    """Tests of CoverageDataFiles."""
+
+    no_files_in_temp_dir = True
+
+    def setUp(self):
+        super(CoverageDataFilesTest, self).setUp()
+        self.data_files = CoverageDataFiles()
+
+    def test_reading_missing(self):
+        self.assert_doesnt_exist(".coverage")
+        covdata = CoverageData()
+        self.data_files.read(covdata)
+        self.assert_line_counts(covdata, {})
+
+    def test_writing_and_reading(self):
+        covdata1 = CoverageData()
+        covdata1.add_lines(LINES_1)
+        self.data_files.write(covdata1)
+
+        covdata2 = CoverageData()
+        self.data_files.read(covdata2)
+        self.assert_line_counts(covdata2, SUMMARY_1)
+
+    def test_debug_output_with_debug_option(self):
+        # With debug option dataio, we get debug output about reading and
+        # writing files.
+        debug = DebugControlString(options=["dataio"])
+        covdata1 = CoverageData(debug=debug)
+        covdata1.add_lines(LINES_1)
+        self.data_files.write(covdata1)
+
+        covdata2 = CoverageData(debug=debug)
+        self.data_files.read(covdata2)
+        self.assert_line_counts(covdata2, SUMMARY_1)
+
+        self.assertRegex(
+            debug.get_output(),
+            r"^Writing data to '.*\.coverage'\n"
+            r"Reading data from '.*\.coverage'\n$"
+        )
+
+    def test_debug_output_without_debug_option(self):
+        # With a debug object, but not the dataio option, we don't get debug
+        # output.
+        debug = DebugControlString(options=[])
+        covdata1 = CoverageData(debug=debug)
+        covdata1.add_lines(LINES_1)
+        self.data_files.write(covdata1)
+
+        covdata2 = CoverageData(debug=debug)
+        self.data_files.read(covdata2)
+        self.assert_line_counts(covdata2, SUMMARY_1)
+
+        self.assertEqual(debug.get_output(), "")
+
+    def test_explicit_suffix(self):
+        self.assert_doesnt_exist(".coverage.SUFFIX")
+        covdata = CoverageData()
+        covdata.add_lines(LINES_1)
+        self.data_files.write(covdata, suffix='SUFFIX')
+        self.assert_exists(".coverage.SUFFIX")
+        self.assert_doesnt_exist(".coverage")
+
+    def test_true_suffix(self):
+        self.assertEqual(glob.glob(".coverage.*"), [])
+
+        # suffix=True will make a randomly named data file.
+        covdata1 = CoverageData()
+        covdata1.add_lines(LINES_1)
+        self.data_files.write(covdata1, suffix=True)
+        self.assert_doesnt_exist(".coverage")
+        data_files1 = glob.glob(".coverage.*")
+        self.assertEqual(len(data_files1), 1)
+
+        # Another suffix=True will choose a different name.
+        covdata2 = CoverageData()
+        covdata2.add_lines(LINES_1)
+        self.data_files.write(covdata2, suffix=True)
+        self.assert_doesnt_exist(".coverage")
+        data_files2 = glob.glob(".coverage.*")
+        self.assertEqual(len(data_files2), 2)
+
+        # In addition to being different, the suffixes have the pid in them.
+        self.assertTrue(all(str(os.getpid()) in fn for fn in data_files2))
+
+    def test_combining(self):
+        self.assert_doesnt_exist(".coverage.1")
+        self.assert_doesnt_exist(".coverage.2")
+
+        covdata1 = CoverageData()
+        covdata1.add_lines(LINES_1)
+        self.data_files.write(covdata1, suffix='1')
+        self.assert_exists(".coverage.1")
+        self.assert_doesnt_exist(".coverage.2")
+
+        covdata2 = CoverageData()
+        covdata2.add_lines(LINES_2)
+        self.data_files.write(covdata2, suffix='2')
+        self.assert_exists(".coverage.2")
+
+        covdata3 = CoverageData()
+        self.data_files.combine_parallel_data(covdata3)
+        self.assert_line_counts(covdata3, SUMMARY_1_2)
+        self.assert_measured_files(covdata3, MEASURED_FILES_1_2)
+        self.assert_doesnt_exist(".coverage.1")
+        self.assert_doesnt_exist(".coverage.2")
+
+    def test_erasing(self):
+        covdata1 = CoverageData()
+        covdata1.add_lines(LINES_1)
+        self.data_files.write(covdata1)
+
+        covdata1.erase()
+        self.assert_line_counts(covdata1, {})
+
+        self.data_files.erase()
+        covdata2 = CoverageData()
+        self.data_files.read(covdata2)
+        self.assert_line_counts(covdata2, {})
+
+    def test_erasing_parallel(self):
+        self.make_file("datafile.1")
+        self.make_file("datafile.2")
+        self.make_file(".coverage")
+        data_files = CoverageDataFiles("datafile")
+        data_files.erase(parallel=True)
+        self.assert_doesnt_exist("datafile.1")
+        self.assert_doesnt_exist("datafile.2")
+        self.assert_exists(".coverage")
+
+    def read_json_data_file(self, fname):
+        """Read a JSON data file for testing the JSON directly."""
+        with open(fname, 'r') as fdata:
+            go_away = fdata.read(len(CoverageData._GO_AWAY))
+            self.assertEqual(go_away, CoverageData._GO_AWAY)
+            return json.load(fdata)
+
+    def test_file_format(self):
+        # Write with CoverageData, then read the JSON explicitly.
+        covdata = CoverageData()
+        covdata.add_lines(LINES_1)
+        self.data_files.write(covdata)
+
+        data = self.read_json_data_file(".coverage")
+
+        lines = data['lines']
+        self.assertCountEqual(lines.keys(), MEASURED_FILES_1)
+        self.assertCountEqual(lines['a.py'], A_PY_LINES_1)
+        self.assertCountEqual(lines['b.py'], B_PY_LINES_1)
+        # If not measuring branches, there's no arcs entry.
+        self.assertNotIn('arcs', data)
+        # If no file tracers were involved, there's no file_tracers entry.
+        self.assertNotIn('file_tracers', data)
+
+    def test_file_format_with_arcs(self):
+        # Write with CoverageData, then read the JSON explicitly.
+        covdata = CoverageData()
+        covdata.add_arcs(ARCS_3)
+        self.data_files.write(covdata)
+
+        data = self.read_json_data_file(".coverage")
+
+        self.assertNotIn('lines', data)
+        arcs = data['arcs']
+        self.assertCountEqual(arcs.keys(), MEASURED_FILES_3)
+        self.assertCountEqual(arcs['x.py'], map(list, X_PY_ARCS_3))
+        self.assertCountEqual(arcs['y.py'], map(list, Y_PY_ARCS_3))
+        # If no file tracers were involved, there's no file_tracers entry.
+        self.assertNotIn('file_tracers', data)
+
+    def test_writing_to_other_file(self):
+        data_files = CoverageDataFiles(".otherfile")
+        covdata = CoverageData()
+        covdata.add_lines(LINES_1)
+        data_files.write(covdata)
+        self.assert_doesnt_exist(".coverage")
+        self.assert_exists(".otherfile")
+
+        data_files.write(covdata, suffix="extra")
+        self.assert_exists(".otherfile.extra")
+        self.assert_doesnt_exist(".coverage")
+
+    def test_combining_with_aliases(self):
+        covdata1 = CoverageData()
+        covdata1.add_lines({
+            '/home/ned/proj/src/a.py': {1: None, 2: None},
+            '/home/ned/proj/src/sub/b.py': {3: None},
+            '/home/ned/proj/src/template.html': {10: None},
+        })
+        covdata1.add_file_tracers({
+            '/home/ned/proj/src/template.html': 'html.plugin',
+        })
+        self.data_files.write(covdata1, suffix='1')
+
+        covdata2 = CoverageData()
+        covdata2.add_lines({
+            r'c:\ned\test\a.py': {4: None, 5: None},
+            r'c:\ned\test\sub\b.py': {3: None, 6: None},
+        })
+        self.data_files.write(covdata2, suffix='2')
+
+        covdata3 = CoverageData()
+        aliases = PathAliases()
+        aliases.add("/home/ned/proj/src/", "./")
+        aliases.add(r"c:\ned\test", "./")
+        self.data_files.combine_parallel_data(covdata3, aliases=aliases)
+
+        apy = canonical_filename('./a.py')
+        sub_bpy = canonical_filename('./sub/b.py')
+        template_html = canonical_filename('./template.html')
+
+        self.assert_line_counts(covdata3, {apy: 4, sub_bpy: 2, template_html: 1}, fullpath=True)
+        self.assert_measured_files(covdata3, [apy, sub_bpy, template_html])
+        self.assertEqual(covdata3.file_tracer(template_html), 'html.plugin')
+
+    def test_combining_from_different_directories(self):
+        covdata1 = CoverageData()
+        covdata1.add_lines(LINES_1)
+        os.makedirs('cov1')
+        covdata1.write_file('cov1/.coverage.1')
+
+        covdata2 = CoverageData()
+        covdata2.add_lines(LINES_2)
+        os.makedirs('cov2')
+        covdata2.write_file('cov2/.coverage.2')
+
+        # This data won't be included.
+        covdata_xxx = CoverageData()
+        covdata_xxx.add_arcs(ARCS_3)
+        covdata_xxx.write_file('.coverage.xxx')
+
+        covdata3 = CoverageData()
+        self.data_files.combine_parallel_data(covdata3, data_paths=['cov1', 'cov2'])
+
+        self.assert_line_counts(covdata3, SUMMARY_1_2)
+        self.assert_measured_files(covdata3, MEASURED_FILES_1_2)
+        self.assert_doesnt_exist("cov1/.coverage.1")
+        self.assert_doesnt_exist("cov2/.coverage.2")
+        self.assert_exists(".coverage.xxx")
+
+    def test_combining_from_files(self):
+        covdata1 = CoverageData()
+        covdata1.add_lines(LINES_1)
+        os.makedirs('cov1')
+        covdata1.write_file('cov1/.coverage.1')
+
+        covdata2 = CoverageData()
+        covdata2.add_lines(LINES_2)
+        os.makedirs('cov2')
+        covdata2.write_file('cov2/.coverage.2')
+
+        # This data won't be included.
+        covdata_xxx = CoverageData()
+        covdata_xxx.add_arcs(ARCS_3)
+        covdata_xxx.write_file('.coverage.xxx')
+        covdata_xxx.write_file('cov2/.coverage.xxx')
+
+        covdata3 = CoverageData()
+        self.data_files.combine_parallel_data(covdata3, data_paths=['cov1', 'cov2/.coverage.2'])
+
+        self.assert_line_counts(covdata3, SUMMARY_1_2)
+        self.assert_measured_files(covdata3, MEASURED_FILES_1_2)
+        self.assert_doesnt_exist("cov1/.coverage.1")
+        self.assert_doesnt_exist("cov2/.coverage.2")
+        self.assert_exists(".coverage.xxx")
+        self.assert_exists("cov2/.coverage.xxx")
+
+    def test_combining_from_nonexistent_directories(self):
+        covdata = CoverageData()
+        msg = "Couldn't combine from non-existent path 'xyzzy'"
+        with self.assertRaisesRegex(CoverageException, msg):
+            self.data_files.combine_parallel_data(covdata, data_paths=['xyzzy'])