DiffTest.test_double_changes_with_same_diff() - Code Metrics - Inspection of "Don't raise conflicts" - coala-analyzer/coala - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#2465)

unknown

created 2016-07-20 21:07 UTC

DiffTest.test_double_changes_with_same_diff() A

↳ Parent: DiffTest

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
c	1
b	0
f	0
dl	0
loc	8
rs	9.4285

import json
import unittest
from unittest.case import SkipTest

from coalib.output.JSONEncoder import create_json_encoder
from coalib.results.Diff import ConflictError, Diff, SourceRange


class DiffTest(unittest.TestCase):

    def setUp(self):
        self.file = ["1", "2", "3", "4"]
        self.uut = Diff(self.file)

    def test_add_lines(self):
        self.uut.add_lines(0, [])
        self.uut.add_lines(0, ["t"])
        self.uut.add_lines(0, [])

    def test_double_addition(self):
        self.uut.add_lines(0, ["t"])

        # No double addition allowed
        self.assertRaises(ConflictError, self.uut.add_lines, 0, ["t"])
        self.assertRaises(ValueError, self.uut.add_lines, -1, ["t"])
        self.assertRaises(TypeError, self.uut.add_lines, "str", ["t"])

    def test_delete_line(self):
        self.uut.delete_line(1)
        self.uut.delete_line(1)  # Double deletion possible without conflict
        self.assertRaises(ValueError, self.uut.delete_line, 0)

    def test_change_line(self):
        self.assertEqual(len(self.uut), 0)
        self.uut.change_line(2, "1", "2")
        self.assertEqual(len(self.uut), 2)
        self.assertRaises(ConflictError, self.uut.change_line, 2, "1", "3")
        self.assertRaises(ValueError, self.uut.change_line, 0, "1", "2")

        self.uut.delete_line(1)
        # Line was deleted, unchangeable
        self.assertRaises(ConflictError, self.uut.change_line, 1, "1", "2")

    def test_double_changes_with_same_diff(self):
        self.uut.change_line(2, "1", "2")

        # Double addition when diff is equal is allowed
        try:
            self.uut.change_line(2, "1", "2")
        except Exception:
            self.fail('We should not have a conflict on same diff!')

    def test_affected_code(self):
        self.assertEqual(self.uut.affected_code("file"), [])

        self.uut.add_lines(0, ["test"])
        affected_code = [
            SourceRange.from_values("file", start_line=1)]
        self.assertEqual(self.uut.affected_code("file"), affected_code)

        self.uut.delete_line(2)
        affected_code = [
            SourceRange.from_values("file", start_line=1),
            SourceRange.from_values("file", start_line=2)]
        self.assertEqual(self.uut.affected_code("file"), affected_code)

        self.uut.delete_line(3)
        affected_code = [
            SourceRange.from_values("file", start_line=1),
            SourceRange.from_values("file", start_line=2, end_line=3)]
        self.assertEqual(self.uut.affected_code("file"), affected_code)

        self.uut.delete_line(6)
        affected_code = [
            SourceRange.from_values("file", start_line=1),
            SourceRange.from_values("file", start_line=2, end_line=3),
            SourceRange.from_values('file', start_line=6)]
        self.assertEqual(self.uut.affected_code("file"), affected_code)

    def test_len(self):
        self.uut.delete_line(2)
        self.assertEqual(len(self.uut), 1)
        self.uut.add_lines(2, ["2.3", "2.5", "2.6"])
        self.assertEqual(len(self.uut), 4)
        self.uut.change_line(1, "1", "1.1")
        self.assertEqual(len(self.uut), 6)

    def test_stats(self):
        self.uut.delete_line(2)
        self.assertEqual(self.uut.stats(), (0, 1))
        self.uut.add_lines(2, ["2.3", "2.5", "2.6"])
        self.assertEqual(self.uut.stats(), (3, 1))
        self.uut.change_line(1, "1", "1.1")
        self.assertEqual(self.uut.stats(), (4, 2))

    def test_modified(self):
        result_file = ["0.1",
                       "0.2",
                       "1",
                       "1.1",
                       "3.changed",
                       "4"]

        self.uut.delete_line(2)
        self.uut.add_lines(0, ["0.1", "0.2"])
        self.uut.add_lines(1, ["1.1"])
        self.uut.change_line(3, "3", "3.changed")

        self.assertEqual(self.uut.modified, result_file)
        self.assertEqual(self.uut.original, self.file)

        self.uut.delete_line(len(self.file))
        del result_file[len(result_file) - 1]
        self.assertEqual(self.uut.modified, result_file)

        self.uut.delete_line(1)
        del result_file[2]
        self.assertEqual(self.uut.modified, result_file)

    def test_addition(self):
        self.assertRaises(TypeError, self.uut.__add__, 5)

        result_file = ["1",
                       "2",
                       "2"]

        other = Diff(self.file)
        other.delete_line(1)
        other.change_line(2, "1", "2")
        other.add_lines(0, ["1"])

        self.uut.delete_line(1)
        self.uut.delete_line(3)
        self.uut.change_line(4, "4", "2")
        result = self.uut + other

        self.assertEqual(result.modified, result_file)
        # Make sure it didn't happen in place!
        self.assertNotEqual(self.uut.modified, result_file)

    def test_addition_rename(self):
        uut = Diff(self.file, rename=False)
        other = Diff(self.file, rename=False)
        self.assertEqual((other + uut).rename, False)

        other.rename = "some.py"
        self.assertEqual((other + uut).rename, "some.py")

        uut.rename = "some.py"
        self.assertEqual((other + uut).rename, "some.py")

        uut.rename = "other.py"
        self.assertRaises(ConflictError, other.__add__, uut)

    def test_from_string_arrays(self):
        a = ["q", "a", "b", "x", "c", "d"]
        b = ["a", "b", "y", "c", "d", "f"]
        self.uut = Diff.from_string_arrays(a, b)
        self.assertEqual(self.uut.modified, b)

        a = ["first", "fourth"]
        b = ["first", "second", "third", "fourth"]
        self.uut = Diff.from_string_arrays(a, b)
        self.assertEqual(self.uut.modified, b)

        a = ["first", "fourth"]
        b = ["first_changed", "second", "third", "fourth"]
        self.uut = Diff.from_string_arrays(a, b)
        self.assertEqual(self.uut.modified, b)

        a = ["first", "second", "third", "fourth"]
        b = ["first", "fourth"]
        self.uut = Diff.from_string_arrays(a, b)
        self.assertEqual(self.uut.modified, b)

        a = ["first", "second", "third", "fourth"]
        b = ["first_changed", "second_changed", "fourth"]
        self.uut = Diff.from_string_arrays(a, b)
        self.assertEqual(self.uut.modified, b)

    def test_from_clang_fixit(self):
        try:
            from clang.cindex import Index, LibclangError
        except ImportError as err:
            raise SkipTest(str(err))

        joined_file = 'struct { int f0; }\nx = { f0 :1 };\n'
        file = joined_file.splitlines(True)
        fixed_file = ['struct { int f0; }\n', 'x = { .f0 = 1 };\n']
        try:
            tu = Index.create().parse('t.c', unsaved_files=[
                ('t.c', joined_file)])
        except LibclangError as err:
            raise SkipTest(str(err))

        fixit = tu.diagnostics[0].fixits[0]
        clang_fixed_file = Diff.from_clang_fixit(fixit, file).modified
        self.assertEqual(fixed_file, clang_fixed_file)

    def test_equality(self):
        a = ["first", "second", "third"]
        b = ["first", "third"]
        diff_1 = Diff.from_string_arrays(a, b)

        a[1] = "else"
        diff_2 = Diff.from_string_arrays(a, b)
        self.assertEqual(diff_1, diff_2)

        diff_1.rename = "abcd"
        self.assertNotEqual(diff_1, diff_2)
        diff_1.rename = False

        diff_1.delete = True
        self.assertNotEqual(diff_1, diff_2)
        diff_1.delete = False

        diff_1.add_lines(1, ["1"])
        self.assertNotEqual(diff_1, diff_2)

    def test_json_export(self):
        JSONEncoder = create_json_encoder()
        a = ["first\n", "second\n", "third\n"]
        b = ["first\n", "third\n"]
        diff = Diff.from_string_arrays(a, b)
        self.assertEqual(
            json.dumps(diff, cls=JSONEncoder, sort_keys=True),
            '"--- \\n'
            '+++ \\n'
            '@@ -1,3 +1,2 @@\\n'
            ' first\\n'
            '-second\\n'
            ' third\\n"')

    def test_rename(self):
        self.uut.rename = False
        self.uut.rename = "1234"
        with self.assertRaises(TypeError):
            self.uut.rename = True
        with self.assertRaises(TypeError):
            self.uut.rename = 1234

    def test_delete(self):
        self.uut.delete = True
        self.uut.delete = False
        # Double deletion is allowed
        self.uut.delete = False
        with self.assertRaises(TypeError):
            self.uut.delete = "abcd"

        # If delete is True then modified returns an empty list
        self.uut.delete = True
        self.assertEqual(self.uut.modified, [])
        self.uut.delete = False


1			import json
2			import unittest
3			from unittest.case import SkipTest
4
5			from coalib.output.JSONEncoder import create_json_encoder
6			from coalib.results.Diff import ConflictError, Diff, SourceRange
7
8
9			class DiffTest(unittest.TestCase):
10
11			def setUp(self):
12			self.file = ["1", "2", "3", "4"]
13			self.uut = Diff(self.file)
14
15			def test_add_lines(self):
16			self.uut.add_lines(0, [])
17			self.uut.add_lines(0, ["t"])
18			self.uut.add_lines(0, [])
19
20			def test_double_addition(self):
21			self.uut.add_lines(0, ["t"])
22
23			# No double addition allowed
24			self.assertRaises(ConflictError, self.uut.add_lines, 0, ["t"])
25			self.assertRaises(ValueError, self.uut.add_lines, -1, ["t"])
26			self.assertRaises(TypeError, self.uut.add_lines, "str", ["t"])
27
28			def test_delete_line(self):
29			self.uut.delete_line(1)
30			self.uut.delete_line(1) # Double deletion possible without conflict
31			self.assertRaises(ValueError, self.uut.delete_line, 0)
32
33			def test_change_line(self):
34			self.assertEqual(len(self.uut), 0)
35			self.uut.change_line(2, "1", "2")
36			self.assertEqual(len(self.uut), 2)
37			self.assertRaises(ConflictError, self.uut.change_line, 2, "1", "3")
38			self.assertRaises(ValueError, self.uut.change_line, 0, "1", "2")
39
40			self.uut.delete_line(1)
41			# Line was deleted, unchangeable
42			self.assertRaises(ConflictError, self.uut.change_line, 1, "1", "2")
43
44			def test_double_changes_with_same_diff(self):
45			self.uut.change_line(2, "1", "2")
46
47			# Double addition when diff is equal is allowed
48			try:
49			self.uut.change_line(2, "1", "2")
50			except Exception:
51			self.fail('We should not have a conflict on same diff!')
52
53			def test_affected_code(self):
54			self.assertEqual(self.uut.affected_code("file"), [])
55
56			self.uut.add_lines(0, ["test"])
57			affected_code = [
58			SourceRange.from_values("file", start_line=1)]
59			self.assertEqual(self.uut.affected_code("file"), affected_code)
60
61			self.uut.delete_line(2)
62			affected_code = [
63			SourceRange.from_values("file", start_line=1),
64			SourceRange.from_values("file", start_line=2)]
65			self.assertEqual(self.uut.affected_code("file"), affected_code)
66
67			self.uut.delete_line(3)
68			affected_code = [
69			SourceRange.from_values("file", start_line=1),
70			SourceRange.from_values("file", start_line=2, end_line=3)]
71			self.assertEqual(self.uut.affected_code("file"), affected_code)
72
73			self.uut.delete_line(6)
74			affected_code = [
75			SourceRange.from_values("file", start_line=1),
76			SourceRange.from_values("file", start_line=2, end_line=3),
77			SourceRange.from_values('file', start_line=6)]
78			self.assertEqual(self.uut.affected_code("file"), affected_code)
79
80			def test_len(self):
81			self.uut.delete_line(2)
82			self.assertEqual(len(self.uut), 1)
83			self.uut.add_lines(2, ["2.3", "2.5", "2.6"])
84			self.assertEqual(len(self.uut), 4)
85			self.uut.change_line(1, "1", "1.1")
86			self.assertEqual(len(self.uut), 6)
87
88			def test_stats(self):
89			self.uut.delete_line(2)
90			self.assertEqual(self.uut.stats(), (0, 1))
91			self.uut.add_lines(2, ["2.3", "2.5", "2.6"])
92			self.assertEqual(self.uut.stats(), (3, 1))
93			self.uut.change_line(1, "1", "1.1")
94			self.assertEqual(self.uut.stats(), (4, 2))
95
96			def test_modified(self):
97			result_file = ["0.1",
98			"0.2",
99			"1",
100			"1.1",
101			"3.changed",
102			"4"]
103
104			self.uut.delete_line(2)
105			self.uut.add_lines(0, ["0.1", "0.2"])
106			self.uut.add_lines(1, ["1.1"])
107			self.uut.change_line(3, "3", "3.changed")
108
109			self.assertEqual(self.uut.modified, result_file)
110			self.assertEqual(self.uut.original, self.file)
111
112			self.uut.delete_line(len(self.file))
113			del result_file[len(result_file) - 1]
114			self.assertEqual(self.uut.modified, result_file)
115
116			self.uut.delete_line(1)
117			del result_file[2]
118			self.assertEqual(self.uut.modified, result_file)
119
120			def test_addition(self):
121			self.assertRaises(TypeError, self.uut.__add__, 5)
122
123			result_file = ["1",
124			"2",
125			"2"]
126
127			other = Diff(self.file)
128			other.delete_line(1)
129			other.change_line(2, "1", "2")
130			other.add_lines(0, ["1"])
131
132			self.uut.delete_line(1)
133			self.uut.delete_line(3)
134			self.uut.change_line(4, "4", "2")
135			result = self.uut + other
136
137			self.assertEqual(result.modified, result_file)
138			# Make sure it didn't happen in place!
139			self.assertNotEqual(self.uut.modified, result_file)
140
141			def test_addition_rename(self):
142			uut = Diff(self.file, rename=False)
143			other = Diff(self.file, rename=False)
144			self.assertEqual((other + uut).rename, False)
145
146			other.rename = "some.py"
147			self.assertEqual((other + uut).rename, "some.py")
148
149			uut.rename = "some.py"
150			self.assertEqual((other + uut).rename, "some.py")
151
152			uut.rename = "other.py"
153			self.assertRaises(ConflictError, other.__add__, uut)
154
155			def test_from_string_arrays(self):
156			a = ["q", "a", "b", "x", "c", "d"]
157			b = ["a", "b", "y", "c", "d", "f"]
158			self.uut = Diff.from_string_arrays(a, b)
159			self.assertEqual(self.uut.modified, b)
160
161			a = ["first", "fourth"]
162			b = ["first", "second", "third", "fourth"]
163			self.uut = Diff.from_string_arrays(a, b)
164			self.assertEqual(self.uut.modified, b)
165
166			a = ["first", "fourth"]
167			b = ["first_changed", "second", "third", "fourth"]
168			self.uut = Diff.from_string_arrays(a, b)
169			self.assertEqual(self.uut.modified, b)
170
171			a = ["first", "second", "third", "fourth"]
172			b = ["first", "fourth"]
173			self.uut = Diff.from_string_arrays(a, b)
174			self.assertEqual(self.uut.modified, b)
175
176			a = ["first", "second", "third", "fourth"]
177			b = ["first_changed", "second_changed", "fourth"]
178			self.uut = Diff.from_string_arrays(a, b)
179			self.assertEqual(self.uut.modified, b)
180
181			def test_from_clang_fixit(self):
182			try:
183			from clang.cindex import Index, LibclangError
184			except ImportError as err:
185			raise SkipTest(str(err))
186
187			joined_file = 'struct { int f0; }\nx = { f0 :1 };\n'
188			file = joined_file.splitlines(True)
189			fixed_file = ['struct { int f0; }\n', 'x = { .f0 = 1 };\n']
190			try:
191			tu = Index.create().parse('t.c', unsaved_files=[
192			('t.c', joined_file)])
193			except LibclangError as err:
194			raise SkipTest(str(err))
195
196			fixit = tu.diagnostics[0].fixits[0]
197			clang_fixed_file = Diff.from_clang_fixit(fixit, file).modified
198			self.assertEqual(fixed_file, clang_fixed_file)
199
200			def test_equality(self):
201			a = ["first", "second", "third"]
202			b = ["first", "third"]
203			diff_1 = Diff.from_string_arrays(a, b)
204
205			a[1] = "else"
206			diff_2 = Diff.from_string_arrays(a, b)
207			self.assertEqual(diff_1, diff_2)
208
209			diff_1.rename = "abcd"
210			self.assertNotEqual(diff_1, diff_2)
211			diff_1.rename = False
212
213			diff_1.delete = True
214			self.assertNotEqual(diff_1, diff_2)
215			diff_1.delete = False
216
217			diff_1.add_lines(1, ["1"])
218			self.assertNotEqual(diff_1, diff_2)
219
220			def test_json_export(self):
221			JSONEncoder = create_json_encoder()
222			a = ["first\n", "second\n", "third\n"]
223			b = ["first\n", "third\n"]
224			diff = Diff.from_string_arrays(a, b)
225			self.assertEqual(
226			json.dumps(diff, cls=JSONEncoder, sort_keys=True),
227			'"--- \\n'
228			'+++ \\n'
229			'@@ -1,3 +1,2 @@\\n'
230			' first\\n'
231			'-second\\n'
232			' third\\n"')
233
234			def test_rename(self):
235			self.uut.rename = False
236			self.uut.rename = "1234"
237			with self.assertRaises(TypeError):
238			self.uut.rename = True
239			with self.assertRaises(TypeError):
240			self.uut.rename = 1234
241
242			def test_delete(self):
243			self.uut.delete = True
244			self.uut.delete = False
245			# Double deletion is allowed
246			self.uut.delete = False
247			with self.assertRaises(TypeError):
248			self.uut.delete = "abcd"
249
250			# If delete is True then modified returns an empty list
251			self.uut.delete = True
252			self.assertEqual(self.uut.modified, [])
253			self.uut.delete = False
254

coala-analyzer / coala

Pull Request — master (#2465)

DiffTest.test_double_changes_with_same_diff() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like