HashedMapWithLinearProbingUnitTest - Code Metrics - Inspection of "Try to find out why unit test failed in python 3.5" - chen0040/pyalgs - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( dd9ec6...39de41 )

by Xianshun

created 2017-05-08 03:15 UTC

HashedMapWithLinearProbingUnitTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	43
Duplicated Lines	100 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
dl	43
loc	43
rs	10
c	1
b	0
f	0
wmc	4

1 Method

Rating	Name	Duplication	Size	Complexity
B	test_hashedmap()	42	42	4

How to fix Duplicated Code

import unittest

from pyalgs.data_structures.commons.hashed_map import HashedMapWithSeparateChaining, HashedMap, \
    HashedMapWithLinearProbing


class HashedMapUnitTest(unittest.TestCase):

    def test_binarySearchTree(self):
        map = HashedMap.create()

        map.put("one", 1)
        map.put("two", 2)
        map.put("three", 3)
        map.put("six", 6)
        map.put("ten", 10)
        map.put("ten", 10)

        self.assertEqual(1, map.get("one"))
        self.assertEqual(2, map.get("two"))
        self.assertEqual(3, map.get("three"))

        self.assertTrue(map.contains_key("one"))
        self.assertTrue(map.contains_key("two"))

        self.assertEqual(5, map.size())
        self.assertFalse(map.is_empty())

        map.delete("one")
        self.assertFalse(map.contains_key("one"))
        self.assertEqual(4, map.size())

        map.delete("ten")
        self.assertFalse(map.contains_key("ten"))
        self.assertEqual(3, map.size())

        map.delete("three")
        self.assertFalse(map.contains_key("three"))
        self.assertEqual(2, map.size())

        for i in range(100):
            map.put(str(i), i)
            self.assertEqual(i, map.get(str(i)))

        for key in map.keys():
            print(key)

        for i in range(100):
            map.delete(str(i))
            self.assertFalse(map.contains_key(str(i)))


class HashedMapWithSeparateChainingUnitTest(unittest.TestCase):

    def test_binarySearchTree(self):
        map = HashedMapWithSeparateChaining()

        map.put("one", 1)
        map.put("two", 2)
        map.put("three", 3)
        map.put("six", 6)
        map.put("ten", 10)
        map.put("ten", 10)

        self.assertEqual(1, map.get("one"))
        self.assertEqual(2, map.get("two"))
        self.assertEqual(3, map.get("three"))

        self.assertTrue(map.contains_key("one"))
        self.assertTrue(map.contains_key("two"))

        self.assertEqual(5, map.size())
        self.assertFalse(map.is_empty())

        map.delete("one")
        self.assertFalse(map.contains_key("one"))
        self.assertEqual(4, map.size())

        map.delete("ten")
        self.assertFalse(map.contains_key("ten"))
        self.assertEqual(3, map.size())

        map.delete("three")
        self.assertFalse(map.contains_key("three"))
        self.assertEqual(2, map.size())

        for i in range(100):
            map.put(str(i), i)
            self.assertEqual(i, map.get(str(i)))

        for key in map.keys():
            print(key)

        for i in range(100):
            map.delete(str(i))
            self.assertFalse(map.contains_key(str(i)))


class HashedMapWithLinearProbingUnitTest(unittest.TestCase):

    def test_hashedmap(self):
        map = HashedMapWithLinearProbing()

        map.put("one", 1)
        map.put("two", 2)
        map.put("three", 3)
        map.put("six", 6)
        map.put("ten", 10)
        map.put("ten", 10)

        self.assertEqual(1, map.get("one"))
        self.assertEqual(2, map.get("two"))
        self.assertEqual(3, map.get("three"))

        self.assertTrue(map.contains_key("one"))
        self.assertTrue(map.contains_key("two"))

        self.assertEqual(5, map.size())
        self.assertFalse(map.is_empty())

        map.delete("one")
        self.assertFalse(map.contains_key("one"))
        self.assertEqual(4, map.size())

        map.delete("ten")
        self.assertFalse(map.contains_key("ten"))
        self.assertEqual(3, map.size())

        map.delete("three")
        self.assertFalse(map.contains_key("three"))
        self.assertEqual(2, map.size())

        for i in range(100):
            map.put(str(i), i)
            self.assertEqual(i, map.get(str(i)))

        for key in map.keys():
            print(key)

        for i in range(100):
            map.delete(str(i))
            self.assertFalse(map.contains_key(str(i)))


if __name__ == '__main__':
    unittest.main()


1		import unittest
2
3		from pyalgs.data_structures.commons.hashed_map import HashedMapWithSeparateChaining, HashedMap, \
4		HashedMapWithLinearProbing
5
6
7	View Code Duplication	class HashedMapUnitTest(unittest.TestCase):
		0 ignored issues – show Duplication introduced 2017-04-26 07:17 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
8		def test_binarySearchTree(self):
9		map = HashedMap.create()
10
11		map.put("one", 1)
12		map.put("two", 2)
13		map.put("three", 3)
14		map.put("six", 6)
15		map.put("ten", 10)
16		map.put("ten", 10)
17
18		self.assertEqual(1, map.get("one"))
19		self.assertEqual(2, map.get("two"))
20		self.assertEqual(3, map.get("three"))
21
22		self.assertTrue(map.contains_key("one"))
23		self.assertTrue(map.contains_key("two"))
24
25		self.assertEqual(5, map.size())
26		self.assertFalse(map.is_empty())
27
28		map.delete("one")
29		self.assertFalse(map.contains_key("one"))
30		self.assertEqual(4, map.size())
31
32		map.delete("ten")
33		self.assertFalse(map.contains_key("ten"))
34		self.assertEqual(3, map.size())
35
36		map.delete("three")
37		self.assertFalse(map.contains_key("three"))
38		self.assertEqual(2, map.size())
39
40		for i in range(100):
41		map.put(str(i), i)
42		self.assertEqual(i, map.get(str(i)))
43
44		for key in map.keys():
45		print(key)
46
47		for i in range(100):
48		map.delete(str(i))
49		self.assertFalse(map.contains_key(str(i)))
50
51
52	View Code Duplication	class HashedMapWithSeparateChainingUnitTest(unittest.TestCase):
		0 ignored issues – show Duplication introduced 2017-04-25 16:58 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
53		def test_binarySearchTree(self):
54		map = HashedMapWithSeparateChaining()
55
56		map.put("one", 1)
57		map.put("two", 2)
58		map.put("three", 3)
59		map.put("six", 6)
60		map.put("ten", 10)
61		map.put("ten", 10)
62
63		self.assertEqual(1, map.get("one"))
64		self.assertEqual(2, map.get("two"))
65		self.assertEqual(3, map.get("three"))
66
67		self.assertTrue(map.contains_key("one"))
68		self.assertTrue(map.contains_key("two"))
69
70		self.assertEqual(5, map.size())
71		self.assertFalse(map.is_empty())
72
73		map.delete("one")
74		self.assertFalse(map.contains_key("one"))
75		self.assertEqual(4, map.size())
76
77		map.delete("ten")
78		self.assertFalse(map.contains_key("ten"))
79		self.assertEqual(3, map.size())
80
81		map.delete("three")
82		self.assertFalse(map.contains_key("three"))
83		self.assertEqual(2, map.size())
84
85		for i in range(100):
86		map.put(str(i), i)
87		self.assertEqual(i, map.get(str(i)))
88
89		for key in map.keys():
90		print(key)
91
92		for i in range(100):
93		map.delete(str(i))
94		self.assertFalse(map.contains_key(str(i)))
95
96
97	View Code Duplication	class HashedMapWithLinearProbingUnitTest(unittest.TestCase):
		0 ignored issues – show Duplication introduced 2017-04-26 07:17 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
98		def test_hashedmap(self):
99		map = HashedMapWithLinearProbing()
100
101		map.put("one", 1)
102		map.put("two", 2)
103		map.put("three", 3)
104		map.put("six", 6)
105		map.put("ten", 10)
106		map.put("ten", 10)
107
108		self.assertEqual(1, map.get("one"))
109		self.assertEqual(2, map.get("two"))
110		self.assertEqual(3, map.get("three"))
111
112		self.assertTrue(map.contains_key("one"))
113		self.assertTrue(map.contains_key("two"))
114
115		self.assertEqual(5, map.size())
116		self.assertFalse(map.is_empty())
117
118		map.delete("one")
119		self.assertFalse(map.contains_key("one"))
120		self.assertEqual(4, map.size())
121
122		map.delete("ten")
123		self.assertFalse(map.contains_key("ten"))
124		self.assertEqual(3, map.size())
125
126		map.delete("three")
127		self.assertFalse(map.contains_key("three"))
128		self.assertEqual(2, map.size())
129
130		for i in range(100):
131		map.put(str(i), i)
132		self.assertEqual(i, map.get(str(i)))
133
134		for key in map.keys():
135		print(key)
136
137		for i in range(100):
138		map.delete(str(i))
139		self.assertFalse(map.contains_key(str(i)))
140
141
142		if __name__ == '__main__':
143		unittest.main()
144

chen0040 / pyalgs

Push — master ( dd9ec6...39de41 )

HashedMapWithLinearProbingUnitTest A

Complexity

Size/Duplication

Importance

1 Method

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like