Merge branch 'feature/style' into develop

Author: codejsha

python-algorithm/algorithm/greedy/test/test_cashier_change.py

@@ -4,10 +4,13 @@
 
 
 @pytest.mark.benchmark(group="cashier_change")
-@pytest.mark.parametrize("denominations, price, expected", [
-    ([25, 10, 5, 1], 30, 2),
-    ([25, 10, 5, 1], 24, 6),
-], ids=["successful1", "successful2"])
+@pytest.mark.parametrize(
+    argnames="denominations, price, expected",
+    argvalues=[
+        ([25, 10, 5, 1], 30, 2),
+        ([25, 10, 5, 1], 24, 6)
+    ],
+    ids=["case1", "case2"])
 def test_cashier_change(benchmark, denominations, price, expected):
     result = benchmark(cashier_change, denominations, price)
     assert expected == result

python-algorithm/algorithm/greedy/test/test_interval_schedule.py

@@ -16,9 +16,10 @@
 
 
 @pytest.mark.benchmark(group="interval_scheduling_lecture")
-@pytest.mark.parametrize("lectures, expected", [
-    ([lecture1, lecture2, lecture3], [lecture2, lecture3]),
-], ids=["successful"])
+@pytest.mark.parametrize(
+    argnames="lectures, expected",
+    argvalues=[([lecture1, lecture2, lecture3], [lecture2, lecture3])],
+    ids=["case1"])
 def test_interval_scheduling_lecture(benchmark, lectures, expected):
     result = benchmark(interval_scheduling_lecture, lectures)
     assert expected == result

python-algorithm/algorithm/math/test/test_addition_integer.py

@@ -4,9 +4,10 @@
 
 
 @pytest.mark.benchmark(group="addition_of_binary_number")
-@pytest.mark.parametrize("a, b, expected", [
-    ('1110', '1011', '11001'),
-], ids=["successful"])
+@pytest.mark.parametrize(
+    argnames="a, b, expected",
+    argvalues=[('1110', '1011', '11001')],
+    ids=["case1"])
 def test_addition_of_binary_number(benchmark, a, b, expected):
     result = benchmark(addition_binary_number, a, b)
     assert expected == result

python-algorithm/algorithm/math/test/test_base_expansion.py

@@ -4,11 +4,14 @@
 
 
 @pytest.mark.benchmark(group="base_expansion")
-@pytest.mark.parametrize("number, base, expected", [
-    (12345, 8, '30071'),
-    (177130, 16, '2B3EA'),
-    (241, 2, '11110001'),
-], ids=["base8", "base16", "base2"])
+@pytest.mark.parametrize(
+    argnames="number, base, expected",
+    argvalues=[
+        (12345, 8, '30071'),
+        (177130, 16, '2B3EA'),
+        (241, 2, '11110001')
+    ],
+    ids=["base8", "base16", "base2"])
 def test_base_expansion(benchmark, number, base, expected):
     result = benchmark(base_expansion, number, base)
     assert expected == result

python-algorithm/algorithm/math/test/test_greatest_common_divisor.py

@@ -4,35 +4,41 @@
 
 
 @pytest.mark.benchmark(group="gcd_euclidean")
-@pytest.mark.parametrize("pair, expected", [
-    ((24, 36), 12),
-    ((17, 22), 1),
-    ((120, 500), 20),
-])
+@pytest.mark.parametrize(
+    argnames="pair, expected",
+    argvalues=[
+        ((24, 36), 12),
+        ((17, 22), 1),
+        ((120, 500), 20)
+    ])
 def test_gcd_euclidean(benchmark, pair, expected):
     assert is_positive_integer(*pair) is True
     result = benchmark(gcd_euclidean, *pair)
     assert expected == result
 
 
 @pytest.mark.benchmark(group="gcd_euclidean_divmod")
-@pytest.mark.parametrize("pair, expected", [
-    ((24, 36), 12),
-    ((17, 22), 1),
-    ((120, 500), 20),
-])
+@pytest.mark.parametrize(
+    argnames="pair, expected",
+    argvalues=[
+        ((24, 36), 12),
+        ((17, 22), 1),
+        ((120, 500), 20)
+    ])
 def test_gcd_euclidean_divmod(benchmark, pair, expected):
     assert is_positive_integer(*pair) is True
     result = benchmark(gcd_euclidean_divmod, *pair)
     assert expected == result
 
 
 @pytest.mark.benchmark(group="gcd_extended_euclidean")
-@pytest.mark.parametrize("pair, expected", [
-    ((24, 36), (12, -1, 1)),
-    ((17, 22), (1, -9, 7)),
-    ((120, 500), (20, -4, 1)),
-])
+@pytest.mark.parametrize(
+    argnames="pair, expected",
+    argvalues=[
+        ((24, 36), (12, -1, 1)),
+        ((17, 22), (1, -9, 7)),
+        ((120, 500), (20, -4, 1))
+    ])
 def test_gcd_extended_euclidean(benchmark, pair, expected):
     assert is_positive_integer(*pair) is True
     result = benchmark(gcd_extended_euclidean, *pair)

python-algorithm/algorithm/math/test/test_least_common_multiple.py

@@ -4,11 +4,13 @@
 
 
 @pytest.mark.benchmark(group="lcm")
-@pytest.mark.parametrize("pair, expected", [
-    ((24, 36), 72),
-    ((17, 22), 374),
-    ((120, 500), 3000),
-])
+@pytest.mark.parametrize(
+    argnames="pair, expected",
+    argvalues=[
+        ((24, 36), 72),
+        ((17, 22), 374),
+        ((120, 500), 3000)
+    ])
 def test_lcm(benchmark, pair, expected):
     assert is_positive_integer(*pair) is True
     result = benchmark(lcm, *pair)

python-algorithm/algorithm/math/test/test_matrix_multiplication.py

@@ -9,18 +9,20 @@
 
 
 @pytest.mark.benchmark(group="matrix_multiplication")
-@pytest.mark.parametrize("a, b, expected", [
-    (matrix_a, matrix_b, matrix_ab),
-], ids=["multiply_matrix"])
+@pytest.mark.parametrize(
+    argnames="a, b, expected",
+    argvalues=[(matrix_a, matrix_b, matrix_ab)],
+    ids=["multiply_matrix"])
 def test_matrix_multiplication1(benchmark, a, b, expected):
     result = benchmark(multiply_matrix, a, b)
     assert np.array_equal(expected, result)
 
 
 @pytest.mark.benchmark(group="matrix_multiplication")
-@pytest.mark.parametrize("a, b, expected", [
-    (matrix_a, matrix_b, matrix_ab),
-], ids=["np.dot"])
+@pytest.mark.parametrize(
+    argnames="a, b, expected",
+    argvalues=[(matrix_a, matrix_b, matrix_ab)],
+    ids=["np.dot"])
 def test_matrix_multiplication2(benchmark, a, b, expected):
     result = benchmark(np.dot, a, b)
     assert np.array_equal(expected, result)

python-algorithm/algorithm/search/test/test_binary_search.py

@@ -4,10 +4,13 @@
 
 
 @pytest.mark.benchmark(group="binary_search")
-@pytest.mark.parametrize("sequence, target, expected", [
-    ([1, 2, 3, 4, 5], 5, 4),
-    ([1, 2, 3, 4, 5], 6, -1),
-], ids=["successful1", "successful2"])
+@pytest.mark.parametrize(
+    argnames="sequence, target, expected",
+    argvalues=[
+        ([1, 2, 3, 4, 5], 5, 4),
+        ([1, 2, 3, 4, 5], 6, -1)
+    ],
+    ids=["case1", "case2"])
 def test_binary_search(benchmark, sequence, target, expected):
     result = benchmark(binary_search, sequence, target)
     assert expected == result

python-algorithm/algorithm/search/test/test_dna_search.py

@@ -3,28 +3,34 @@
 
 
 @pytest.mark.benchmark(group="linear_contains")
-@pytest.mark.parametrize("gene, key_codon, expected", [
-    (string_to_gene("ACGTGGCTCTCTAACGTACGTACGTACGGGGTTTATATATACCCTAGGACTCCCTTT"),
-     (Nucleotide.A, Nucleotide.C, Nucleotide.G),
-     True),
-    (string_to_gene("ACGTGGCTCTCTAACGTACGTACGTACGGGGTTTATATATACCCTAGGACTCCCTTT"),
-     (Nucleotide.G, Nucleotide.A, Nucleotide.T),
-     False),
-], ids=["successful", "failed"])
+@pytest.mark.parametrize(
+    argnames="gene, key_codon, expected",
+    argvalues=[
+        (string_to_gene("ACGTGGCTCTCTAACGTACGTACGTACGGGGTTTATATATACCCTAGGACTCCCTTT"),
+         (Nucleotide.A, Nucleotide.C, Nucleotide.G),
+         True),
+        (string_to_gene("ACGTGGCTCTCTAACGTACGTACGTACGGGGTTTATATATACCCTAGGACTCCCTTT"),
+         (Nucleotide.G, Nucleotide.A, Nucleotide.T),
+         False),
+    ],
+    ids=["found", "not_found"])
 def test_linear_contains(benchmark, gene, key_codon, expected):
     result = benchmark(linear_contains, gene, key_codon)
     assert expected == result
 
 
 @pytest.mark.benchmark(group="binary_contains")
-@pytest.mark.parametrize("gene, key_codon, expected", [
-    (sorted(string_to_gene("ACGTGGCTCTCTAACGTACGTACGTACGGGGTTTATATATACCCTAGGACTCCCTTT")),
-     (Nucleotide.A, Nucleotide.C, Nucleotide.G),
-     True),
-    (sorted(string_to_gene("ACGTGGCTCTCTAACGTACGTACGTACGGGGTTTATATATACCCTAGGACTCCCTTT")),
-     (Nucleotide.G, Nucleotide.A, Nucleotide.T),
-     False),
-], ids=["successful", "failed"])
+@pytest.mark.parametrize(
+    argnames="gene, key_codon, expected",
+    argvalues=[
+        (sorted(string_to_gene("ACGTGGCTCTCTAACGTACGTACGTACGGGGTTTATATATACCCTAGGACTCCCTTT")),
+         (Nucleotide.A, Nucleotide.C, Nucleotide.G),
+         True),
+        (sorted(string_to_gene("ACGTGGCTCTCTAACGTACGTACGTACGGGGTTTATATATACCCTAGGACTCCCTTT")),
+         (Nucleotide.G, Nucleotide.A, Nucleotide.T),
+         False),
+    ],
+    ids=["found", "not_found"])
 def test_binary_contains(benchmark, gene, key_codon, expected):
     result = benchmark(binary_contains, gene, key_codon)
     assert expected == result

python-algorithm/algorithm/search/test/test_generic_search.py

@@ -3,19 +3,25 @@
 
 
 @pytest.mark.benchmark(group="linear_contains")
-@pytest.mark.parametrize("elements, target, expected", [
-    ([1, 5, 15, 15, 15, 15, 20], 5, True),
-], ids=["successful"])
+@pytest.mark.parametrize(
+    argnames="elements, target, expected",
+    argvalues=[
+        ([1, 5, 15, 15, 15, 15, 20], 5, True)
+    ],
+    ids=["found"])
 def test_generic_linear_contains(benchmark, elements, target, expected):
     result = benchmark(generic_linear_contains, elements, target)
     assert expected == result
 
 
 @pytest.mark.benchmark(group="binary_contains")
-@pytest.mark.parametrize("elements, target, expected", [
-    (["a", "d", "e", "f", "z"], "f", True),
-    (["john", "mark", "ronald", "sarah"], "sheila", False),
-], ids=["successful", "failed"])
+@pytest.mark.parametrize(
+    argnames="elements, target, expected",
+    argvalues=[
+        (["a", "d", "e", "f", "z"], "f", True),
+        (["john", "mark", "ronald", "sarah"], "sheila", False)
+    ],
+    ids=["found", "not_found"])
 def test_generic_binary_contains(benchmark, elements, target, expected):
     result = benchmark(generic_binary_contains, elements, target)
     assert expected == result