HashedMapWithLinearProbingUnitTest.test_binarySearchTree() - 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

test_binarySearchTree() B

↳ Parent: HashedMapWithLinearProbingUnitTest

Complexity

Conditions

Size

Total Lines

Duplication

Lines	42
Ratio	100 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	4
c	1
b	0
f	0
dl	42
loc	42
rs	8.5806

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 )

test_binarySearchTree() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like