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.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
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
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 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))
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.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)
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 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
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)
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 underscore import Underscore _ = Underscore() print _.map([1, 2], lambda x: x * 6)
