import unittest import utils class TestMain(unittest.TestCase): def setUp(self): '''before each test function''' pass def tearDown(self): '''after each test function''' pass def do(self, func): n = [1, 1, 2] self.assertEqual(func(n), 2) self.assertEqual(n[0:2], [1, 2]) n = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4] self.assertEqual(func(n), 5) self.assertEqual(n[0:5], [0, 1, 2, 3, 4]) def test_func(self): self.do(removeDuplicates) if __name__ == "__main__": count = 10000 nums = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4] utils.print_func_run_time(count, removeDuplicates, nums=nums) unittest.main()
def do(self, func): self.assertTrue(func(121)) self.assertTrue(func(0)) self.assertTrue(func(6)) self.assertTrue(func(11)) def test_func1(self): self.do(isPalindrome1) def test_func2(self): self.do(isPalindrome2) if __name__ == "__main__": count = 100000 utils.print_func_run_time(count, isPalindrome1, x = 123454321) utils.print_func_run_time(count, isPalindrome2, x = 123454321) unittest.main() # .. # ---------------------------------------------------------------------- # Ran 2 tests in 0.000s # # OK # isPalindrome1 run 100000 times used 0.142989s # isPalindrome2 run 100000 times used 0.143997s # .. # ---------------------------------------------------------------------- # Ran 2 tests in 0.000s #
self.assertEqual(func(nums), -1) nums = [1, 2] self.assertEqual(func(nums), 3) nums = [1, 1, -2] self.assertEqual(func(nums), 2) nums = [3, 1, -3, -3, 2, -1] self.assertEqual(func(nums), 4) nums = [8, -19, 5, -4, 20] self.assertEqual(func(nums), 21) nums = [2, 0, -3, 2, 1, 0, 1, -2] self.assertEqual(func(nums), 4) # for nums in TEST_LISTS: # self.assertEqual(s.maxSubArray2(nums), func(nums)) def test_func(self): s = Solution() self.do(s.maxSubArray4) self.do(s.maxSubArray3) self.do(s.maxSubArray2) self.do(s.maxSubArray1) if __name__ == "__main__": count = 100 tm = TestMain() utils.print_func_run_time(count, s.maxSubArray2, nums=NUMS_FOR53) utils.print_func_run_time(count, s.maxSubArray3, nums=NUMS_FOR53) utils.print_func_run_time(count, s.maxSubArray4, nums=NUMS_FOR53) # utils.print_func_run_time1(count, tm.do, s.maxSubArray3) unittest.main()
pass def do(self, func): nums = [1, 8, 6, 2, 5, 4, 8, 3, 7] self.assertEqual(func(nums), 49) nums = [1] self.assertEqual(func(nums), 0) nums = [1, 2] self.assertEqual(func(nums), 1) nums = [1, 2, 3] self.assertEqual(func(nums), 2) nums = [1, 8, 3, 4] self.assertEqual(func(nums), 8) nums = [1, 1, 1, 4] self.assertEqual(func(nums), 3) def test_func(self): self.do(s.maxArea2) self.do(s.maxArea1) self.do(s.maxArea) if __name__ == "__main__": count = 10000 nums = [1, 8, 6, 2, 5, 4, 8, 3, 7] utils.print_func_run_time(count, s.maxArea1, height=nums) utils.print_func_run_time(count, s.maxArea2, height=nums) utils.print_func_run_time(count, s.maxArea, height=nums) unittest.main()
res = [] while i < n: res.append(i) return res import utils import unittest class TestMain(unittest.TestCase): def setUp(self): '''before each test function''' pass def tearDown(self): '''after each test function''' pass def test_func(self): n = 100 self.assertEqual(loop_for(n), loop_while(n)) if __name__ == "__main__": count = 1000 n = 1000 utils.print_func_run_time(count, loop_for, n=n) utils.print_func_run_time(count, loop_while, n=n) unittest.main()
def setUp(self): '''before each test function''' pass def tearDown(self): '''after each test function''' pass def do(self, func): self.assertEqual(func("adbabcbb"), 3) self.assertEqual(func("bbbbb"), 1) self.assertEqual(func("pwwkew"), 3) self.assertEqual(func(" "), 1) self.assertEqual(func("aab"), 2) self.assertEqual(func("dvdf"), 3) self.assertEqual(func("aabaab!bb"), 3) def test_func1(self): self.do(lengthOfLongestSubstring1) def test_func2(self): self.do(lengthOfLongestSubstring2) if __name__ == "__main__": count = 10000 utils.print_func_run_time(count, lengthOfLongestSubstring1, s = "aabaab!bb") utils.print_func_run_time(count, lengthOfLongestSubstring2, s = "aabaab!bb") unittest.main()
def loop_list_compre(n): res = [abs(i) for i in range(n)] return res def loop_map(n): return map(abs, range(n)) import utils if __name__ == "__main__": count = 1000 n = 1000 gen_res = loop_generator(10) map_res = loop_map(10) list_res = loop_list_compre(10) # print(isinstance(loop_list_compre(10), Iterable)) # print(isinstance(map_res, Generator)) # print(isinstance(map_res, Iterator)) # print(isinstance(list_res, Iterator)) utils.print_func_run_time(count, loop_list_compre, n=n) utils.print_func_run_time(count, loop_map, n=n) utils.print_func_run_time(count, loop_generator, n=n) # loop_list_compre run 1000 times used 0.08865494900237536s # loop_map run 1000 times used 0.0007684140000492334s # loop_generator run 1000 times used 0.0009459810025873594s
import unittest class TestMain(unittest.TestCase): def setUp(self): '''before each test function''' pass def tearDown(self): '''after each test function''' pass def do(self, func): '''todo''' res = [1, 4, 6, 4, 1] self.assertEqual(func(4), res) pass def test_func(self): self.do(s.generate) # self.do(s.generate1) if __name__ == "__main__": import utils count = 100 utils.print_func_run_time(count, s.generate, numRows=100) # utils.print_func_run_time(count, s.generate1, numRows = 100) unittest.main()
'''before each test function''' pass def tearDown(self): '''after each test function''' pass def do(self, func): self.assertFalse(func("[)")) self.assertTrue(func("[]")) self.assertTrue(func("")) self.assertTrue(func("()[]{}")) self.assertFalse(func("[()")) self.assertFalse(func("(])")) self.assertFalse(func("([)])")) self.assertFalse(func("(()(")) self.assertFalse(func("([)]")) self.assertFalse(func("]")) self.assertFalse(func("()]")) self.assertTrue(func("{[]}")) self.assertTrue(func("(([]){})")) def test_func1(self): self.do(isValid) if __name__ == "__main__": import utils count = 10000 utils.print_func_run_time(count, isValid, s = "(([]){})") unittest.main()
listNodeToArray(func(makeListNode([]), makeListNode([]))), []) self.assertEqual( listNodeToArray(func(makeListNode([2]), makeListNode([1]))), [1, 2]) def test_func(self): self.do(mergeTwoLists) self.do(mergeTwoLists1) self.do(mergeTwoLists2) self.do(mergeTwoLists3) if __name__ == "__main__": count = 10000 utils.print_func_run_time(count, mergeTwoLists, l1=makeListNode([2, 3, 4, 7, 8, 9]), l2=makeListNode([4, 5])) utils.print_func_run_time(count, mergeTwoLists1, l1=makeListNode([2, 3, 4, 7, 8, 9]), l2=makeListNode([4, 5])) utils.print_func_run_time(count, mergeTwoLists2, l1=makeListNode([2, 3, 4, 7, 8, 9]), l2=makeListNode([4, 5])) utils.print_func_run_time(count, mergeTwoLists3, l1=makeListNode([2, 3, 4, 7, 8, 9]), l2=makeListNode([4, 5])) unittest.main()
'''before each test function''' pass def tearDown(self): '''after each test function''' pass def test_func(self): items = make_data(10) flag = (loop_list_compre(items) == loop_map(items)) self.assertTrue(flag) if __name__ == "__main__": count = 1000 n = 1000 items = make_data(1000) utils.print_func_run_time(count, loop_list_compre, items = items) utils.print_func_run_time(count, loop_map, items = items) unittest.main() # . # ---------------------------------------------------------------------- # Ran 1 test in 0.000s # # OK # loop_for run 1000 times used 0.14018906400087872s # loop_while run 1000 times used 0.21399457900042762s # loop_generator run 1000 times used 0.12857274799898732s # loop_list_compre run 1000 times used 0.08585307099929196s # loop_map run 1000 times used 0.043123570998432115s
class TestMain(unittest.TestCase): def setUp(self): '''before each test function''' pass def tearDown(self): '''after each test function''' pass def do(self, func): self.assertEqual(func(1), 1) self.assertEqual(func(2), 2) self.assertEqual(func(3), 3) self.assertEqual(func(4), 5) def test_func(self): self.do(s.climbStairs) self.do(s.climbStairs1) self.do(s.climbStairs2) if __name__ == "__main__": count = 1 # utils.print_func_run_time(count, s.climbStairs, n = 38) utils.print_func_run_time(count, s.climbStairs1, n=10000) utils.print_func_run_time(count, s.climbStairs2, n=10000) unittest.main()
def tearDown(self): '''after each test function''' pass def do(self, func): n = [3,2,2,3] self.assertEqual(func(n, 3), 2) # self.assertEqual(n[0:2], [2, 2]) n = [0,1,2,2,3,0,4,2] self.assertEqual(func(n, 2), 5) # self.assertEqual(n[0:5], [0, 1, 3, 0, 4]) n = [2] self.assertEqual(func(n, 3), 1) # self.assertEqual(n[0:1], [2]) n = [3, 3] self.assertEqual(func(n, 5), 2) # self.assertEqual(n[0:2], [3, 3]) def test_func(self): self.do(removeElement) self.do(removeElement1) self.do(removeElement2) if __name__ == "__main__": count = 10000 nums = [0,1,2,2,3,0,4,2] utils.print_func_run_time(count, removeElement, nums = nums, val = 2) utils.print_func_run_time(count, removeElement1, nums = nums, val = 2) utils.print_func_run_time(count, removeElement2, nums = nums, val = 2) unittest.main()
def tearDown(self): '''after each test function''' pass def do(self, func): '''todo''' self.assertEqual(func("hello", "ll"), 2) self.assertEqual(func("aaaaa", "bba"), -1) self.assertEqual(func("aaaac", "aac"), 2) pass def test_func(self): self.do(s.strStr) self.assertEqual(s.make_prefix("abc"), [-1, 0, 0]) self.assertEqual(s.make_prefix("aac"), [-1, 0, 1]) self.assertEqual(s.make_prefix("ababc"), [-1, 0, 0, 1, 2]) if __name__ == "__main__": count = 100000 t = "ababcabcde" p = "abcd" utils.print_func_run_time(count, s.strStr, t = t, p = p) b = timeit.default_timer() for i in range(count): t.index(p) print(timeit.default_timer() - b) unittest.main()
# # print(name, func.) # funcs = (bubble_sort, selection_sort, insertion_sort, quick_sort, # quick_sort_3partition, heap_sort, merge_sort, merge_sort_fastest, # counting_sort, bucket_sort, bucket_sort_array, radix_sort) times = [] # for f in funcs: # n, t = utils.print_func_run_time(length, f, utils.generate_random(int(n))[0]) # # times.append((n, t)) # # times.sort(key = lambda x: x[1]) # # for n, t in times: # # print(n, t) times.append( utils.print_func_run_time(length, bubble_sort, utils.generate_random(n)[0])) times.append( utils.print_func_run_time(length, selection_sort, utils.generate_random(n)[0])) times.append( utils.print_func_run_time(length, insertion_sort, utils.generate_random(n)[0])) times.append( utils.print_func_run_time(length, quick_sort, utils.generate_random(n)[0])) times.append( utils.print_func_run_time(length, quick_sort_3partition, utils.generate_random(n)[0])) times.append( utils.print_func_run_time(length, heap_sort, utils.generate_random(n)[0]))
pass def do(self, func): self.assertEqual(func("42"), 42) self.assertEqual(func(" -42"), -42) self.assertEqual(func("4193 with words"), 4193) self.assertEqual(func("words and 987"), 0) self.assertEqual(func(" +0 123"), 0) self.assertEqual(func("+-2"), 0) self.assertEqual(func("0-1"), 0) self.assertEqual(func("-91283472332"), MIN) self.assertEqual(func("912834723320"), MAX) self.assertEqual(func(" 0000000000012345678"), 12345678) self.assertEqual(func("-000000000000001"), -1) self.assertEqual(func(" -0012a42"), -12) self.assertEqual(func("- 234"), 0) self.assertEqual(func(" -88827 5655 U"), -88827) def test_func(self): self.do(myAtoi1) self.do(myAtoi2) if __name__ == "__main__": import utils count = 1000 utils.print_func_run_time(count, myAtoi1, s="4193 with words") utils.print_func_run_time(count, myAtoi2, s="4193 with words") unittest.main()