class UnderscoreTestCase(unittest.TestCase): def setUp(self): self._ = Underscore() def tearDown(self): self._ = None def test_mixins(self): def test_method(x, y): return x + y self._.mixin({ 'test_method': test_method }) self.assertTrue(self._.test_method) self.assertEqual(self._.test_method(5, 4), 9) def test_each(self): my_seq = [1,2,3,4,5] self.assertTrue(self._.each) # Test functional-style self.assertEqual(self._.each(my_seq, lambda x: x + 1), [2,3,4,5,6]) # Test OOP-style self.assertEqual(self._(my_seq).each(lambda x: x + 2), [3,4,5,6,7])
class UnderscoreTest(unittest.TestCase): def setUp(self): # create an instance of the Underscore module we created self._ = Underscore() # initialize a list to run our tests on self.test_list = [1,2,3,4,5] def testMap(self): self.assertEqual([1,4,9,16,25], self._.map(self.test_list, lambda x: x*x)) self.assertNotEqual([1,4,9,16,25], self._.map(self.test_list, lambda x: x*3)) def testReduce(self): self.assertEqual(15, self._.reduce(self.test_list, lambda x,y: x+y, 0)) self.assertNotEqual(15, self._.reduce(self.test_list, lambda x,y: x*y, 0)) def testFind(self): self.assertEqual(4, self._.find(self.test_list, lambda x: x==4)) self.assertFalse(self._.find(self.test_list, lambda x: x==8)) def testFilter(self): self.assertEqual([3], self._.filter(self.test_list, lambda x: x%3==0)) self.assertEqual([2,4], self._.filter(self.test_list, lambda x: x%2==0)) def testReject(self): self.assertEqual([1,2,4,5], self._.reject(self.test_list, lambda x: x%3==0)) self.assertEqual([1,3,5], self._.reject(self.test_list, lambda x: x%2==0))
class UnderscoreTest(unittest.TestCase): def setUp(self): # create an instance of the Underscore module we created self._ = Underscore() # initialize a list to run our tests on self.squared = lambda x: x * x self.map_result = self._.map([1, 2, 3, 4, 5], self.squared) self.sum = lambda x, y: x + y self.reduce_result = self._.reduce([1, 2, 3, 4, 5], self.sum, 0) self.find_result1 = self._.find([0, 1, 2, 3, 4], lambda x: x == 2) self.filter_result1 = self._.filter([0, 1, 2, 3, 4], lambda x: x > 2) self.reject_result1 = self._.reject([0, 1, 2, 3, 4], lambda x: x > 2) def testMap(self): return self.assertEqual([1, 4, 9, 16, 25], self.map_result) def testReduce(self): return self.assertEqual(15, self.reduce_result) def testFind(self): return self.assertEqual(2, self.find_result1) def testFilter(self): return self.assertEqual([3, 4], self.filter_result1) def testReject(self): return self.assertEqual([0, 1, 2], self.reject_result1)
class UnderscoreTest(unittest.TestCase): def setUp(self): # create an instance of the Underscore module we created self._ = Underscore() # initialize a list to run our tests on self.test_list = [1, 2, 3, 4, 5] self.map_result = self._.map(self.test_list, lambda x: x + 1) self.reduce_result = self._.reduce(self.test_list, lambda x, y: x * y, 1) self.find_result = self._.find(self.test_list, lambda x: x % 3 == 0) self.filter_result = self._.filter(self.test_list, lambda x: x % 2 == 0) self.reject_result = self._.reject(self.test_list, lambda x: x % 2 == 0) def testMap(self): return self.assertEqual([2, 3, 4, 5, 6], self.map_result) def testReduce(self): return self.assertEqual(720, self.reduce_result) def testFind(self): return self.assertEqual(3, self.find_result) def testFilter(self): return self.assertEqual([2, 4, 6], self.filter_result) def testReject(self): return self.assertEqual([3, 5], self.reject_result)
class UnderscoreTest(unittest.TestCase): def setUp(self): # create an instance of the Underscore module we created self._ = Underscore() # initialize a list to run our tests on def testMap(self): self.test_list = [1, 2, 3, 4] self.map_result = self._.map(self.test_list, lambda x: x**2) return self.assertEqual([1, 4, 9, 16], self.test_list) def testReduce(self): self.test_list = [1, 2, 3, 4] self.reduce_result = self._.reduce(self.test_list, lambda x, y: x * y, 1) return self.assertEqual(24, self.reduce_result) def testFind(self): self.test_list = [1, 2, 3, 4, 5, 6] self.find_result = self._.find(self.test_list, lambda x: x > 3) self.assertEqual(4, self.find_result) def testFilter(self): self.test_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] self.filter_result = self._.filter(self.test_list, lambda x: x > 6) self.assertEqual([7, 8, 9, 10], self.filter_result) def testReject(self): self.test_list = [1, 2, 3, 4, 5] self.reject_result = self._.reject(self.test_list, lambda x: x == 3) self.assertEqual([1, 2, 4, 5], self.reject_result)
class UnderscoreTest(unittest.TestCase): def setUp(self): # create an instance of the Underscore module we created self._ = Underscore() # initialize a list to run our tests on self.map_test_list = [1,2,3,4,5] self.test_list = [1,2,3,4,5] # set up test functions with inputs self.testMaptest = self._.map(self.map_test_list, lambda num: num**2) #result: [1, 4, 9, 16, 25] #print self.test_list this is how i debugged, the list was already changed in place self.testReducetest = self._.reduce(self.test_list, lambda memo, num: memo+num, 0) #result: 15 self.testFindtest = self._.find(self.test_list, lambda num: num % 2 == 0 and num > 3) #result: 4 self.testFiltertest = self._.filter(self.test_list, lambda num: num % 2 == 1) #result: [1, 3, 5] self.testRejecttest = self._.reject(self.test_list, lambda num: num % 2 == 1) #result: [2,4] def testMap(self): return self.assertEqual([1, 4, 9, 16, 25], self.testMaptest) def testReduce(self): return self.assertEqual(15, self.testReducetest) def testFind(self): return self.assertEqual(4, self.testFindtest) def testFilter(self): return self.assertEqual([1, 3, 5], self.testFiltertest) def testReject(self): return self.assertEqual([2,4], self.testRejecttest)
def setUp(self): # create an instance of the Underscore module we created self._ = Underscore() # initialize a list to run our tests on self.squared = lambda x: x * x self.map_result = self._.map([1, 2, 3, 4, 5], self.squared) self.sum = lambda x, y: x + y self.reduce_result = self._.reduce([1, 2, 3, 4, 5], self.sum, 0) self.find_result1 = self._.find([0, 1, 2, 3, 4], lambda x: x == 2) self.filter_result1 = self._.filter([0, 1, 2, 3, 4], lambda x: x > 2) self.reject_result1 = self._.reject([0, 1, 2, 3, 4], lambda x: x > 2)
def setUp(self): # create an instance of the Underscore module we created self._ = Underscore() # initialize a list to run our tests on self.test_list = [1, 2, 3, 4, 5] self.map_result = self._.map(self.test_list, lambda x: x + 1) self.reduce_result = self._.reduce(self.test_list, lambda x, y: x * y, 1) self.find_result = self._.find(self.test_list, lambda x: x % 3 == 0) self.filter_result = self._.filter(self.test_list, lambda x: x % 2 == 0) self.reject_result = self._.reject(self.test_list, lambda x: x % 2 == 0)
class UnderscoreTest(unittest.TestCase): def setUp(self): # create an instance of the Underscore module we created self._ = Underscore() # initialize a list to run our tests on self.test_list = [1, 2, 3, 4, 5] def testMap(self): return self.assertIsInstance(self._.map(self.test_list, lambda x: x + 2), list) def testReduce(self): return self.assertEqual(1, len(self._.reduce(self.test_list))) def testFind(self): return self.assertEqual(True, self._.find(self.test_list, lambda x, num: x == num, 4)) def testFilter(self): return self.assertIsInstance(self._.filter(self.test_list, lambda x: x % 2 == 0), list) def testReject(self): return self.assertIsInstance(self._.reject(self.test_list, lambda num, x: num == x, 3), list)
class Underscore_test(unittest.TestCase): def setUp(self): # create an instance of the Underscore module we created self._ = Underscore() # initialize a list to run our tests on self.test_list = [1, 2, 3, 4, 5] def test_map(self): result = self._.map(self.test_list, lambda x: x * 2) return (self.assertEqual([2, 4, 6, 8, 10], result)) def test_reduce_zero_memo(self): result = self._.reduce(self.test_list, lambda i, x: i + x, 0) return (self.assertEqual(15, result)) def test_reduce_nonzero_memo(self): result = self._.reduce(self.test_list, lambda i, x: i + x, 13) return (self.assertEqual(28, result)) def test_find_mod2(self): result = self._.find(self.test_list, lambda x: x % 2 == 0) return (self.assertEqual(2, result)) def test_find_mod5(self): result = self._.find(self.test_list, lambda x: x % 5 == 0) return (self.assertEqual(5, result)) def test_filter(self): result = self._.filter(self.test_list, lambda x: x % 2 == 0) return (self.assertEqual([2, 4], result)) def test_reject(self): result = self._.reject(self.test_list, lambda x: x % 2 == 0) return (self.assertEqual([1, 3, 5], result))
def setUp(self): # create an instance of the Underscore module we created self._ = Underscore() # initialize a list to run our tests on self.test_list = [1,2,3,4,5,6,7] self.map_result = self._.map(self.test_list, lambda x: x + 1) self.reduce_result = self._.reduce(self.test_list, (lambda mem, x: mem - x), 28) self.find_result = self._.find(self.test_list, lambda x: x%2 == 0) self.filter_result = self._.filter(self.test_list, lambda x: x%2 == 0) self.reject_result = self._.reject(self.test_list, lambda x: x%2 == 0)
class UnderscoreTest(unittest.TestCase): def setUp(self): # create an instance of the Underscore module we created self._ = Underscore() # initialize a list to run our tests on self.test_list = [1,2,3,4] def testMap(self): self.result = self._.map(self.test_list, lambda x: x*2) return self.assertEqual([2,4,6,8], self.result) def testReduce(self): self.result = self._.reduce(self.test_list, lambda x,y: x+y) return self.assertEqual(10, self.result) def testFind(self): self.result = self._.find(self.test_list, lambda x,y: x==y, self.test_list[2]) return self.assertEqual([3], self.result) def testFilter(self): self.result = self._.filter(lambda x: x%2==0, self.test_list) return self.assertEqual([2,4], self.result) def testReject(self): self.result = self._.reject(lambda x: x%2==0, self.test_list) return self.assertEqual([1,3], self.result)
class UnderscoreTest(unittest.TestCase): def setUp(self): # create an instance of the Underscore module we created self._ = Underscore() # initialize a list to run our tests on self.test_list = [1,2,3,4,5,6,7] self.map_result = self._.map(self.test_list, lambda x: x + 1) self.reduce_result = self._.reduce(self.test_list, (lambda mem, x: mem - x), 28) self.find_result = self._.find(self.test_list, lambda x: x%2 == 0) self.filter_result = self._.filter(self.test_list, lambda x: x%2 == 0) self.reject_result = self._.reject(self.test_list, lambda x: x%2 == 0) def testMap(self): return self.assertEqual([2,3,4,5,6,7,8], self.map_result) def testReduce(self): return self.assertEqual(-7, self.reduce_result) def testFind(self): return self.assertEqual(2, self.find_result) def testFilter(self): return self.assertEqual([2,4,6,8], self.filter_result) def testReject(self): return self.assertEqual([3,5,7], self.reject_result)
class UnderscoreTest(unittest.TestCase): def setUp(self): # create an instance of the Underscore module we created self._ = Underscore() # initialize a list to run our tests on self.test_list = [1,2,3,4,5] def testMap(self): self.result = self._.map(self.test_list, lambda x: x * 3) # [3, 6, 9, 12, 15] return self.assertEqual([3, 6, 9, 12, 15], self.result) pass def testReduce(self): self.result = self._.reduce(self.test_list, lambda x, y: x + y, 0) return self.assertEqual(15, self.result) def testFind(self): self.result = self._.find(self.test_list, lambda x: x == 5) return self.assertEqual(5, self.result) def testFindfalse(self): self.result = self._.find(self.test_list, lambda x: x == 0) return self.assertFalse(self.result) def testFilter(self): self.result = self._.filter(self.test_list, lambda x: x % 2 == 0) return self.assertEqual([2,4], self.result) def testReject(self): self.result = self._.reject(self.test_list, lambda x: x % 2 == 0) return self.assertEqual([1,3,5], self.result)
class UnderscoreTest(unittest.TestCase): def setUp(self): # create an instance of the Underscore module we created self._ = Underscore() # initialize a list to run our tests on self.test_list = [1,2,3,4,5] def testMap(self): self.assertEqual([1,4,9,16,25],self._.map(self.test_list[:], lambda x:x**2)) def testReduce(self): pass def testFind(self): pass def testFilter(self): pass def testReject(self): pass
def setUp(self): self._ = Underscore()
def setUp(self): # create an instance of the Underscore module we created self._ = Underscore() # initialize a list to run our tests on self.test_list = [1,2,3,4]
from underscore import Underscore # you just created a library with 5 methods! # let's create an instance of our class _ = Underscore( ) # yes we are setting our instance to a variable that is an underscore # Map result = _.map([1, 3, 8], lambda x: x * 2) print result #evens = _.filter([1, 2, 3, 4, 5, 6], lambda x: x % 2 == 0) # should return [2, 4, 6] after you finish implementing the code above
from math_dojo import MathDojo import call_center import hospital from underscore import Underscore bmx = Bike(100, "30 mph") print bmx.__repr__() toyota = Car(20000, "120 mph", "Full", 50000) print toyota.__repr__() mouse = Product(10, "Computer Mouse", "5 ounces", "Logitech", 5) print mouse.__repr__() electronics = Store("San Jose, CA", "Me Me") print electronics.__repr__() hamster = animal.Animal("Hammy", 50) print hamster.__repr__() spot = animal.Dog() print spot.__repr__() maggie = animal.Dragon() print maggie.__repr__() al = MathDojo() print al.__repr__() call1 = call_center.Call("Aaron", "268-347-1484", 911, "Complaint") print call1.__repr__() center1 = call_center.CallCenter() print center1.__repr__() patient1 = hospital.Patient(135, "Deborah", "sulfonamides") print patient1.__repr__() general = hospital.Hospital("BB General", 100) print general.__repr__() _ = Underscore() print _.__repr__()
def setUp(self): # create an instance of the Underscore module we created self._ = Underscore() # initialize a list to run our tests on self.test_list = [1, 2, 3, 4, 5]
from underscore import Underscore _ = Underscore() print _.map([1, 2], lambda x: x * 6)
class UnderscoreTestCase(unittest.TestCase): def setUp(self): self._ = Underscore() def tearDown(self): self._ = None def test_mixins(self): def test_method(x, y): return x + y self._.mixin({ 'test_method': test_method }) self.assertTrue(self._.test_method) self.assertEqual(self._.test_method(5, 4), 9) def test_each(self): my_seq = [1,2,3,4,5] self.assertTrue(self._.each) # Test functional-style self.assertEqual(self._.each(my_seq, lambda x: x + 1), [2,3,4,5,6]) # Test OOP-style self.assertEqual(self._(my_seq).each(lambda x: x + 2), [3,4,5,6,7]) def test_filter(self): my_seq = [1,2,3,4,5] self.assertTrue(self._.filter) # Test functional-style self.assertEqual(self._.filter(my_seq, lambda x: x % 2 == 0), [2,4]) # Test OOP-style self.assertEqual(self._(my_seq).filter(lambda x: x % 2 == 0), [2,4]) def test_all(self): my_seq = [1,2,False,None,True] self.assertTrue(self._.all) # Test functional-style self.assertEqual(self._.all(my_seq), [1,2,True]) # Test OOP-style self.assertEqual(self._(my_seq).all(), [1,2,True]) def test_generator(self): my_seq = [1,2,3,4,5] self.assertTrue(self._.generator) # Test functional-style if it returns a generator self.assertTrue(isinstance(self._.generator(my_seq), types.GeneratorType)) # Test OOP-style if it returns a generator self.assertTrue(isinstance(self._(my_seq).generator(), types.GeneratorType)) # Test return values self.assertEqual([i for i in self._.generator(my_seq)], my_seq) self.assertEqual([i for i in self._(my_seq).generator()], my_seq) # Test chaining self.assertEqual(self._.chain() .generator(my_seq) .each(lambda x: x + 1) .value(), [2,3,4,5,6]) def test_chaining(self): my_seq = [1,2,3,4,5] self.assertTrue(self._.chain) # Test functional-style self.assertEqual(self._ .chain(my_seq) .each(lambda x: x + 1) .filter(lambda x: x % 2 == 0) .value(), [2,4,6]) # Test OOP-style self.assertEqual(self._(my_seq) .chain() .each(lambda x: x + 1) .filter(lambda x: x % 2 == 0) .value(), [2,4,6])
def setUp(self): # create an instance of the Underscore module we created self._ = Underscore()