/
sortUrlsTests.py
executable file
·186 lines (150 loc) · 7.56 KB
/
sortUrlsTests.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
#! /usr/bin/env python
import unittest
import sortUrls
from sortfunctions.comparators import length
from urltools import validator, normalizer
class TestUrlsSorting(unittest.TestCase):
#Setup for the tests, runs automatically before each test
def setUp(self):
#A list of urls to sort
self.urls = ["www.google.com", "http://www.google.com", "a", "blarg@gmail.com", "facebook.com", "CS.WASHINGTON.EDU", "HTTPS://WWW.YAHOO.COM/"]
#Expected output of validator
self.validUrls = ["http://www.google.com", "HTTPS://WWW.YAHOO.COM/"]
#Expected output of the sort-by-length functions
self.sortedByLength = ["a", "facebook.com", "www.google.com", "blarg@gmail.com", "CS.WASHINGTON.EDU", "http://www.google.com", "HTTPS://WWW.YAHOO.COM/"]
#Expected output of the sort-by-alphabetical functions
self.sortedByAlphabetical = ["CS.WASHINGTON.EDU", "HTTPS://WWW.YAHOO.COM/", "a", "blarg@gmail.com", "facebook.com", "http://www.google.com", "www.google.com"]
#Edge case where list is empty
self.emptyUrls = []
#Edge case where list has a single url
self.singleUrl = ["google.com"]
#Insertion Sort (by length) tests
def test_insertionsort(self):
sortedList = sortUrls.insertionsort(self.urls).sort()
self.assertEquals(sortedList, self.sortedByLength)
def test_insertionsort_empty(self):
sortedList = sortUrls.insertionsort(self.emptyUrls).sort()
self.assertEquals(sortedList, self.emptyUrls)
def test_insertionsort_single(self):
sortedList = sortUrls.insertionsort(self.singleUrl).sort()
self.assertEquals(sortedList, self.singleUrl)
#Merge Sort (by length) tests
def test_mergesort(self):
sortedList = sortUrls.mergesort(self.urls).sort()
self.assertEquals(sortedList, self.sortedByLength)
def test_mergesort_empty(self):
sortedList = sortUrls.mergesort(self.emptyUrls).sort()
self.assertEquals(sortedList, self.emptyUrls)
def test_mergesort_single(self):
sortedList = sortUrls.mergesort(self.singleUrl).sort()
self.assertEquals(sortedList, self.singleUrl)
#Quick Sort (by length) tests
def test_quicksort(self):
sortedList = sortUrls.quicksort(self.urls).sort()
self.assertEquals(sortedList, self.sortedByLength)
def test_quicksort_empty(self):
sortedList = sortUrls.quicksort(self.emptyUrls).sort()
self.assertEquals(sortedList, self.emptyUrls)
def test_quicksort_single(self):
sortedList = sortUrls.quicksort(self.singleUrl).sort()
self.assertEquals(sortedList, self.singleUrl)
#Bucket Sort (by length) tests
def test_bucketsort(self):
sortedList = sortUrls.bucketsort(self.urls).sort()
self.assertEquals(sortedList, self.sortedByLength)
def test_bucketsort_empty(self):
sortedList = sortUrls.bucketsort(self.emptyUrls).sort()
self.assertEquals(sortedList, self.emptyUrls)
def test_bucketsort_single(self):
sortedList = sortUrls.bucketsort(self.singleUrl).sort()
self.assertEquals(sortedList, self.singleUrl)
#Selection Sort (alphabetical) tests
def test_selectionsort_alphabetical(self):
sortedList = sortUrls.selectionsort_alphabetical(self.urls).sort()
self.assertEquals(sortedList, self.sortedByAlphabetical)
def test_selectionsort_alphabetical_empty(self):
sortedList = sortUrls.selectionsort_alphabetical(self.emptyUrls).sort()
self.assertEquals(sortedList, self.emptyUrls)
def test_selectionsort_alphabetical_single(self):
sortedList = sortUrls.selectionsort_alphabetical(self.singleUrl).sort()
self.assertEquals(sortedList, self.singleUrl)
#Radix Sort (alphabetical) tests
def test_radixsort_alphabetical(self):
sortedList = sortUrls.radixsort_alphabetical(self.urls).sort()
self.assertEquals(sortedList, self.sortedByAlphabetical)
def test_radixsort_alphabetical_empty(self):
sortedList = sortUrls.radixsort_alphabetical(self.emptyUrls).sort()
self.assertEquals(sortedList, self.emptyUrls)
def test_radixsort_alphabetical_single(self):
sortedList = sortUrls.radixsort_alphabetical(self.singleUrl).sort()
self.assertEquals(sortedList, self.singleUrl)
#Merge Sort (alphabetical) tests
def test_mergesort_alphabetical(self):
sortedList = sortUrls.mergesort_alphabetical(self.urls).sort()
self.assertEquals(sortedList, self.sortedByAlphabetical)
def test_mergesort_alphabetical_empty(self):
sortedList = sortUrls.mergesort_alphabetical(self.emptyUrls).sort()
self.assertEquals(sortedList, self.emptyUrls)
def test_mergesort_alphabetical_single(self):
sortedList = sortUrls.mergesort_alphabetical(self.singleUrl).sort()
self.assertEquals(sortedList, self.singleUrl)
#Heap Sort (alphabetical) tests
def test_heapsort_alphabetical(self):
sortedList = sortUrls.heapsort_alphabetical(self.urls).sort()
self.assertEquals(sortedList, self.sortedByAlphabetical)
def test_heapsort_alphabetical_empty(self):
sortedList = sortUrls.heapsort_alphabetical(self.emptyUrls).sort()
self.assertEquals(sortedList, self.emptyUrls)
def test_heapsort_alphabetical_single(self):
sortedList = sortUrls.heapsort_alphabetical(self.singleUrl).sort()
self.assertEquals(sortedList, self.singleUrl)
#Tests for our comparator by length function
def test_comparator_length(self):
res = length("asdfasdf", "asdf")
self.assertEquals(res, 4)
res = length("", "")
self.assertEquals(res, 0)
res = length("","asdf")
self.assertEquals(res, -4)
res = length("a", "")
self.assertEquals(res, 1)
res = length(".dfk1", "9)-.'")
self.assertEquals(res, 0)
res = length("a", "9358")
self.assertEquals(res, -3)
#########################################
# URL Validation & Normalization Tests #
#########################################
def test_append_slash(self):
url = 'HTTP://WWW.fakeurl.COM/testdir'
exp = 'http://www.fakeurl.com/testdir'
self.assertEquals(normalizer._lowercase(url), exp)
self.assertEquals(normalizer._lowercase(exp), exp)
def test_capitalize_escapes(self):
url = 'http://WWW.example.com/a%c2%b1b'
exp = 'http://WWW.example.com/a%C2%B1b'
self.assertEquals(normalizer._capitalize_escapes(url), exp)
def test_remove_default_port(self):
url = 'http://www.google.com:80/'
exp = 'http://www.google.com/'
self.assertEquals(normalizer._remove_default_port(url), exp)
def test_add_trailing_slash(self):
url1 = 'http://www.fakeurl.com/testfile.html'
exp1 = url1
url2 = 'http://www.fakeurl.com/testdir'
exp2 = 'http://www.fakeurl.com/testdir/'
self.assertEquals(normalizer._add_trailing_slash(url1), exp1)
self.assertEquals(normalizer._add_trailing_slash(url2), exp2)
def test_remove_dot_segments(self):
url = 'http://www.testsite.com/dir1/dir2a/../dir2b/./file.txt'
exp = 'http://www.testsite.com/dir1/dir2b/file.txt'
self.assertEquals(normalizer._remove_dot_segments(url), exp)
def test_remove_empty_querystring(self):
url = 'http://www.google.com/?'
exp = 'http://www.google.com/'
self.assertEquals(normalizer._remove_empty_querystring(url), exp)
def test_validator(self):
res = validator.validate(self.urls)
self.assertEquals(res, self.validUrls)
if __name__ == "__main__":
unittest.main()