HashedMapWithLinearProbingUnitTest - Code Metrics - Inspection of "Implement hashed map with linear probing" - chen0040/pyalgs - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 90dc7f...bdb684 )

by Xianshun

created 2017-04-26 06:32 UTC

HashedMapWithLinearProbingUnitTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	43
Duplicated Lines	97.67 %

Importance

Changes	1
Bugs	0	Features	0

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

1 Method

Rating	Name	Duplication	Size	Complexity
B	test_binarySearchTree()	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_binarySearchTree(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		class HashedMapUnitTest(unittest.TestCase):
8	View Code Duplication	def test_binarySearchTree(self):
		0 ignored issues – show Duplication introduced 2017-04-26 06:33 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
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		class HashedMapWithSeparateChainingUnitTest(unittest.TestCase):
53	View Code Duplication	def test_binarySearchTree(self):
		0 ignored issues – show Duplication introduced 2017-04-26 06:33 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
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		class HashedMapWithLinearProbingUnitTest(unittest.TestCase):
97	View Code Duplication	def test_binarySearchTree(self):
		0 ignored issues – show Duplication introduced 2017-04-26 06:33 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
98		map = HashedMapWithLinearProbing()
99
100		map.put("one", 1)
101		map.put("two", 2)
102		map.put("three", 3)
103		map.put("six", 6)
104		map.put("ten", 10)
105		map.put("ten", 10)
106
107		self.assertEqual(1, map.get("one"))
108		self.assertEqual(2, map.get("two"))
109		self.assertEqual(3, map.get("three"))
110
111		self.assertTrue(map.contains_key("one"))
112		self.assertTrue(map.contains_key("two"))
113
114		self.assertEqual(5, map.size())
115		self.assertFalse(map.is_empty())
116
117		map.delete("one")
118		self.assertFalse(map.contains_key("one"))
119		self.assertEqual(4, map.size())
120
121		map.delete("ten")
122		self.assertFalse(map.contains_key("ten"))
123		self.assertEqual(3, map.size())
124
125		map.delete("three")
126		self.assertFalse(map.contains_key("three"))
127		self.assertEqual(2, map.size())
128
129		for i in range(100):
130		map.put(str(i), i)
131		self.assertEqual(i, map.get(str(i)))
132
133		for key in map.keys():
134		print(key)
135
136		for i in range(100):
137		map.delete(str(i))
138		self.assertFalse(map.contains_key(str(i)))
139
140		if __name__ == '__main__':
141		unittest.main()
142

chen0040 / pyalgs

Push — master ( 90dc7f...bdb684 )

HashedMapWithLinearProbingUnitTest A

Complexity

Size/Duplication

Importance

1 Method

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like