def test_multiple_diffs(self):
l1 = [1, 2, 3, 4, 5]
l2 = [1, 22, 3, 44, 5]
expected = (
([1], compare.Diff(l1[1], l2[1])),
([3], compare.Diff(l1[3], l2[3])),
)
self.assertEqual(expected, tuple(compare(l1, l2)))
def test_multiline_diff(self):
s1 = "foo\nbar\nbaz\n"
s2 = "foo\nBAR\nbaz\n"
expected = (False, [], None)
actual = compare(s1, s2)
diff = '\n'.join(actual[-1])
self.assertEqual(expected[:-1], actual[:-1])
self.assertIn('-bar', diff)
self.assertIn('+BAR', diff)
def test_multiline_diff(self):
s1 = "foo\nbar\nbaz\n"
s2 = "foo\nBAR\nbaz\n"
expected = ([], None)
actual = tuple(compare(s1, s2))[0]
diff = "\n".join(actual[-1])
self.assertEqual(expected[:-1], actual[:-1])
self.assertIn("-bar", diff)
self.assertIn("+BAR", diff)
def test_multiple_diffs(self):
d1 = {"a": 1, "b": 2, "c": 3, "d": 4}
d2 = {"a": 1, "b": 22, "c": 3, "d": 44, "e": 5}
expected = (
(["b"], compare.Diff(d1["b"], d2["b"])),
(["d"], compare.Diff(d1["d"], d2["d"])),
(["e"], compare.Diff(compare.missingKey, d2["e"])),
)
actual = tuple(compare(d1, d2))
self.assertEqual(expected, actual)
def compare_csv(self, first_file_name, second_file_name, key_columns):
self.clean_report_field()
key_columns = [int(i.strip()) for i in key_columns.split(',')]
# Get first dictionary
first_data = get_data_csv(first_file_name, *key_columns)
# Get second dictionary
second_data = get_data_csv(second_file_name, *key_columns)
# Compare
differences = compare(first_data, second_data)
# Report
self.insert_into_report_field(tk.END, generate_report(differences))
def test_rust_code_analysis_tokei_c() -> None:
"""These tests evaluates if rust-code-analysis and tokei produce
the same metrics values for C language.
"""
ret_value = compare(
"rust-code-analysis",
"tokei",
["-g", "-f"],
["SLOC", "PLOC", "CLOC", "BLANK"],
"C",
"bubble_sort.c",
)
assert ret_value == 0
def test_rust_code_analysis_tokei_rust() -> None:
"""These tests evaluates if rust-code-analysis and tokei produce
the same metrics values for Rust language.
"""
ret_value = compare(
"rust-code-analysis",
"tokei",
["-g", "-f"],
# Do not consider SLOC because it is computed wrong in Tokei.
# Do not consider CLOC because comments are counted differently
# among the two software.
["PLOC", "BLANK"],
"Rust",
"resample.rs",
)
assert ret_value == 0
def test_rust_code_analysis_tokei_c() -> None:
"""These tests evaluates if rust-code-analysis and tokei produce
the same metrics values for C language.
"""
ret_value = compare(
"rust-code-analysis",
"tokei",
["-g", "-f"],
# Do not consider BLANK for this case because TOKEI
# counts blank lines inside comments.
# Do not consider CLOC because comments are counted differently
# among the two software.
["SLOC", "PLOC"],
"C",
"resample.c",
)
assert ret_value == 0
def test_same(self):
d1 = {"a":1, "b":2}
d2 = {"a":1, "b":2}
expected = (True, None, None)
self.assertEqual(expected, compare(d1, d2))
def test_diff(self):
s1 = "foo"
s2 = "bar"
expected = ([], compare.Diff(s1, s2))
self.assertEqual(expected, tuple(compare(s1, s2))[0])
def test_none(self):
d1 = {"a":1, "b":2}
d2 = None
expected = (False, [], compare.Diff(d1, d2))
self.assertEqual(expected, compare(d1, d2))
def test_value(self):
l1 = [1, 2, 3]
l2 = [1, 22, 3]
expected = (([1], compare.Diff(l1[1], l2[1])), )
self.assertEqual(expected, tuple(compare(l1, l2)))
def test_none(self):
l1 = [1, 2, 3]
l2 = None
expected = ([], compare.Diff(l1, l2))
self.assertEqual(expected, tuple(compare(l1, l2))[0])
def test_case_same(self):
"""case insensitive keys, use value of "most-lowercase" key"""
d1 = dict(AA=1, Aa=2, aA=3, aa=4, bB=6, BB=7)
d2 = dict(Aa=4, BB=6)
expected = (True, None, None)
self.assertEqual(expected, compare(d1, d2))
def test_same(self):
l1 = [1,2,3]
l2 = [1,2,3]
expected = (True, None, None)
self.assertEqual(expected, compare(l1, l2))
def test_case_diff(self):
"""case insensitive keys, use value of "most-lowercase" key"""
d1 = dict(AA=1, Aa=2, aA=3, aa=22, bB=6, BB=7)
d2 = dict(Aa=4, BB=6)
expected = (["aa"], compare.Diff(d1["aa"], d2["Aa"]))
self.assertEqual(expected, tuple(compare(d1, d2))[0])
def test_same(self):
s1 = "foo"
s2 = "foo"
expected = ()
self.assertEqual(expected, tuple(compare(s1, s2)))
def test_size(self):
d1 = {"a": 1, "b": 2}
d2 = {"a": 1, "b": 2, "c": 3}
expected = ((["c"], compare.Diff(compare.missingKey, d2["c"])), )
actual = tuple(compare(d1, d2))
self.assertEqual(expected, actual)
def test_case_same(self):
"""case insensitive keys, use value of "most-lowercase" key"""
d1 = dict(AA=1, Aa=2, aA=3, aa=4, bB=6, BB=7)
d2 = dict(Aa=4, BB=6)
expected = ()
self.assertEqual(expected, tuple(compare(d1, d2)))
def test_value(self):
d1 = {"a": 1, "b": 2}
d2 = {"a": 1, "b": 22}
expected = ((["b"], compare.Diff(d1["b"], d2["b"])), )
actual = tuple(compare(d1, d2))
self.assertEqual(expected, actual)
def test_same(self):
d1 = {"a": 1, "b": 2}
d2 = {"a": 1, "b": 2}
expected = ()
self.assertEqual(expected, tuple(compare(d1, d2)))
def test_none(self):
d1 = {"a": 1, "b": 2}
d2 = None
expected = ([], compare.Diff(d1, d2))
self.assertEqual(expected, tuple(compare(d1, d2))[0])
def test_value(self):
d1 = {"a":1, "b":2}
d2 = {"a":1, "b":22}
expected = (False, ["b"], compare.Diff(d1['b'], d2['b']))
self.assertEqual(expected, compare(d1, d2))
def test_same(self):
l1 = [1, 2, 3]
l2 = [1, 2, 3]
expected = ()
self.assertEqual(expected, tuple(compare(l1, l2)))
def test_size(self):
d1 = {"a":1, "b":2}
d2 = {"a":1, "b":2, "c":3}
expected = (False, ['c'], compare.Diff(compare.missingKey, d2['c']))
self.assertEqual(expected, compare(d1, d2))
def test_same(self):
s1 = "foo"
s2 = "foo"
expected = (True, None, None)
self.assertEqual(expected, compare(s1, s2))
def test_case_diff(self):
"""case insensitive keys, use value of "most-lowercase" key"""
d1 = dict(AA=1, Aa=2, aA=3, aa=22, bB=6, BB=7)
d2 = dict(Aa=4, BB=6)
expected = (False, ['aa'], compare.Diff(d1['aa'], d2['Aa']))
self.assertEqual(expected, compare(d1, d2))
def test_diff(self):
s1 = "foo"
s2 = "bar"
expected = (False, [], compare.Diff(s1, s2))
self.assertEqual(expected, compare(s1, s2))
def test_none(self):
l1 = [1,2,3]
l2 = None
expected = (False, [], compare.Diff(l1, l2))
self.assertEqual(expected, compare(l1, l2))
def test_multiline_same(self):
s1 = "foo\nbar\nbaz\n"
s2 = "foo\nbar\nbaz\n"
expected = (True, None, None)
self.assertEqual(expected, compare(s1, s2))
def compare_xls(self, first_file_name, second_file_name, key_columns):
self.clean_report_field()
first_data = get_data_xls(first_file_name, *key_columns)
second_data = get_data_xls(second_file_name, *key_columns)
differences = compare(first_data, second_data)
self.insert_into_report_field(tk.END, generate_report(differences))
def test_size(self):
l1 = [1, 2, 3]
l2 = [1, 2]
expected = ([], compare.Diff(l1, l2))
actual = tuple(compare(l1, l2))[0]
self.assertEqual(expected, actual)
def test_value(self):
l1 = [1,2,3]
l2 = [1,22,3]
expected = (False, [1], compare.Diff(l1[1], l2[1]))
self.assertEqual(expected, compare(l1, l2))
def test_multiline_same(self):
s1 = "foo\nbar\nbaz\n"
s2 = "foo\nbar\nbaz\n"
expected = ()
self.assertEqual(expected, tuple(compare(s1, s2)))