def run_test_practice_problem4a():
""" Tests the practice_problem4a function. """
# ------------------------------------------------------------------
# 4 tests. They use the imported simple_testing (st) module.
# Each test is a SimpleTestCase with 3 arguments:
# -- the function to test,
# -- a list containing the argument(s) to send to the function,
# -- the correct returned value.
# For example, the first test below will call
# practice_problem4v((9, 33, 8, 8, 0, 4, 4, 8))
# and compare the returned value against [2, 5] (the correct answer).
# ------------------------------------------------------------------
tests = [
st.SimpleTestCase(practice_problem4a, [(9, 33, 8, 8, 0, 4, 4, 8)],
[2, 5]),
st.SimpleTestCase(practice_problem4a, [(9, 9, 9, 9, 0, 9, 9, 9)],
[0, 1, 2, 5, 6]),
st.SimpleTestCase(practice_problem4a, [(4, 5, 4, 5, 4, 5, 4)], []),
st.SimpleTestCase(practice_problem4a, ['abbabbb'], [1, 4, 5]),
]
# Run the 4 tests in the tests list constructed above.
st.SimpleTestCase.run_tests('practice_problem4a', tests)
def run_test_practice_problem3a():
""" Tests the practice_problem3a function. """
# ------------------------------------------------------------------
# 6 tests.
# They use the imported simple_testing (st) module.
# Each test is a SimpleTestCase with 3 arguments:
# -- the function to test,
# -- a list containing the argument(s) to send to the function,
# -- the correct returned value.
# For example, the first test below will call
# practice_problem3a((rg.Circle(rg.Point(5, 10), 20),
# rg.Circle(rg.Point(2, 20), 20),
# rg.Circle(rg.Point(7, 30), 10),
# rg.Circle(rg.Point(10, 40), 20),
# rg.Circle(rg.Point(2, 50), 10)))
# and compare the returned value against 1400 (the correct answer).
# ------------------------------------------------------------------
tests = [st.SimpleTestCase(practice_problem3a,
[(rg.Circle(rg.Point(5, 10), 20),
rg.Circle(rg.Point(2, 20), 20),
rg.Circle(rg.Point(7, 30), 10),
rg.Circle(rg.Point(10, 40), 20),
rg.Circle(rg.Point(2, 50), 10))],
5 * 2 * 7 * 10 * 2),
st.SimpleTestCase(practice_problem3a,
[(rg.Circle(rg.Point(58, 10), 20),)],
58),
st.SimpleTestCase(practice_problem3a,
[(rg.Circle(rg.Point(84, 100), 200),
rg.Circle(rg.Point(28, 200), 200),
rg.Circle(rg.Point(10005, 300), 100))],
84 * 28 * 10005),
st.SimpleTestCase(practice_problem3a,
[()],
1),
st.SimpleTestCase(practice_problem3a,
[(rg.Circle(rg.Point(5, 10), 20),
rg.Circle(rg.Point(0, 20), 20),
rg.Circle(rg.Point(7, 30), 10),
rg.Circle(rg.Point(10, 40), 20),
rg.Circle(rg.Point(2, 50), 10))],
5 * 0 * 7 * 10 * 2),
]
circles = []
for k in range(1, 101):
circles.append(rg.Circle(rg.Point(k, k + 20), 5 * k))
answer = math.factorial(100)
tests.append(st.SimpleTestCase(practice_problem3a,
[circles],
answer))
# ------------------------------------------------------------------
# Run the 6 tests in the tests list constructed above.
# ------------------------------------------------------------------
st.SimpleTestCase.run_tests('practice_problem3a', tests)
def run_test_problem2b():
""" Tests the problem2b function. """
tests = [
st.SimpleTestCase(problem2b, [[1, 20, 30], [1, 2, 3]], 1),
st.SimpleTestCase(problem2b, [[0, -50, 30], [1, 2, 3]], 2),
st.SimpleTestCase(problem2b, [[10, 11, 12], [1, 2, 3]], 0),
st.SimpleTestCase(problem2b, [[111], [222]], -1),
st.SimpleTestCase(problem2b, [[], []], -1),
st.SimpleTestCase(problem2b, [[3, 3, -3, -3], [3, 3, -3, -30]], 3),
]
st.SimpleTestCase.run_tests('test_problem2b', tests)
def run_test_problem2a():
""" Tests the problem2a function. """
tests = [
st.SimpleTestCase(
problem2a,
[[rg.Point(3, 4), rg.Point(3, 4),
rg.Point(3, 4)]], 12),
st.SimpleTestCase(problem2a,
[[rg.Point(3, 4), rg.Point(3, -4)]], 0),
st.SimpleTestCase(problem2a, [[rg.Point(3, 4)]], 4),
st.SimpleTestCase(problem2a, [[]], 0),
st.SimpleTestCase(problem2a, [[
rg.Point(100, 40),
rg.Point(50, 10),
rg.Point(200, 50),
rg.Point(120, 30),
rg.Point(40, 88),
rg.Point(90, 60)
]], 278),
st.SimpleTestCase(problem2a, [[
rg.Point(200, 40),
rg.Point(50, 10),
rg.Point(10, 50),
rg.Point(120, 30),
rg.Point(40, 88),
rg.Point(90, 60)
]], 278),
st.SimpleTestCase(problem2a, [[
rg.Point(1, 40),
rg.Point(2, 10),
rg.Point(3, 50),
rg.Point(4, 30),
rg.Point(5, 88),
rg.Point(6, 66),
rg.Point(7, 55),
rg.Point(8, 44),
rg.Point(9, 99),
rg.Point(10, 6)
]], 488),
]
st.SimpleTestCase.run_tests('problem2a', tests)
def test_problem1a():
""" Tests the problem1a function. """
tests = [
st.SimpleTestCase(problem1a, [[
rg.Point(28, 6),
rg.Point(5, 13),
rg.Point(24, 6),
rg.Point(5, 6),
rg.Point(28, 6),
rg.Point(6, 5),
]], rg.Point(28, 6)),
st.SimpleTestCase(problem1a, [[
rg.Point(44, 6),
rg.Point(5, 13),
rg.Point(24, 6),
rg.Point(5, 6),
rg.Point(28, 6),
rg.Point(6, 5),
]], rg.Point(28, 6)),
st.SimpleTestCase(problem1a, [[
rg.Point(24, 6),
rg.Point(5, 13),
rg.Point(24, 6),
rg.Point(5, 6),
rg.Point(496, 28),
rg.Point(6, 5),
]], rg.Point(496, 28)),
st.SimpleTestCase(problem1a, [[
rg.Point(20, 6),
rg.Point(5, 13),
rg.Point(24, 6),
rg.Point(5, 6),
rg.Point(22, 6),
rg.Point(493, 24),
]], 'BAD'),
st.SimpleTestCase(problem1a, [[]], 'BAD'),
st.SimpleTestCase(problem1a, [[
rg.Point(23, 6),
rg.Point(5, 13),
rg.Point(496, 6),
rg.Point(5, 6),
rg.Point(20, 6),
rg.Point(6, 5),
]], rg.Point(496, 6)),
]
st.SimpleTestCase.run_tests('problem1a', tests)
def run_test_problem1c():
""" Tests the problem1c function. """
tests = [
st.SimpleTestCase(problem1c, [["foo", "robots"]],
["foo", "robots", "robots"]),
st.SimpleTestCase(
problem1c, [["a", "robots", "b", "robots", "c"]],
["a", "robots", "robots", "b", "robots", "robots", "c"]),
st.SimpleTestCase(
problem1c, [["foo", "robots", "robots", "ok"]],
["foo", "robots", "robots", "robots", "robots", "ok"]),
st.SimpleTestCase(problem1c, [["foo", "the end"]], ["foo", "the end"]),
st.SimpleTestCase(
problem1c, [["robots", "foo", "robots", "bar"]],
["robots", "robots", "foo", "robots", "robots", "bar"]),
st.SimpleTestCase(
problem1c, [["robots", "robots", "robots"]],
["robots", "robots", "robots", "robots", "robots", "robots"]),
st.SimpleTestCase(problem1c, [[]], []),
]
st.SimpleTestCase.run_tests('problem1c', tests)
def run_test_practice_problem3e():
""" Tests the practice_problem3e function. """
# ------------------------------------------------------------------
# 5 tests. They use the imported simple_testing (st) module.
# Each test is a SimpleTestCase with 3 arguments:
# -- the function to test,
# -- a list containing the argument(s) to send to the function,
# -- the correct returned value.
# For example, the first test below will call
# practice_problem3e((12, 33, 18, 9, 13, 3, 9, 20, 19, 20))
# and compare the returned value against 161 (the correct answer).
# ------------------------------------------------------------------
tests = [
st.SimpleTestCase(practice_problem3e,
[(12, 33, 18, 9, 13, 3, 99, 20, 19, 20)], 161),
st.SimpleTestCase(practice_problem3e, [(3, 12, 10, 8, 8, 9, 8, 11)],
29),
st.SimpleTestCase(practice_problem3e, [(-9999999999, 8888888888)],
-9999999999),
st.SimpleTestCase(practice_problem3e, [(8888888888, -9999999999)],
8888888888),
st.SimpleTestCase(practice_problem3e,
[(-77, 20000, -33, 40000, -55, 60000, -11)], -176),
st.SimpleTestCase(practice_problem3e, [()], 0),
st.SimpleTestCase(practice_problem3e, [[]], 0),
st.SimpleTestCase(practice_problem3e, [[8]], 8),
st.SimpleTestCase(practice_problem3e, [(-77, 8)], -77),
st.SimpleTestCase(practice_problem3e, [(-77, 8, 77)], 0),
st.SimpleTestCase(practice_problem3e, [(-77, 8, 78)], 1),
st.SimpleTestCase(practice_problem3e, [(-77, 8, 78, 100)], 1),
]
# ------------------------------------------------------------------
# Run the 5 tests in the tests list constructed above.
# ------------------------------------------------------------------
st.SimpleTestCase.run_tests('practice_problem3e', tests)
def run_test_practice_problem3b():
""" Tests the practice_problem3b function. """
# ------------------------------------------------------------------
# 13 tests. They use the imported simple_testing (st) module.
# Each test is a SimpleTestCase with 3 arguments:
# -- the function to test,
# -- a list containing the argument(s) to send to the function,
# -- the correct returned value.
# For example, the first test below will call
# practice_problem3b([12, 33, 18, 'hello', 9, 13, 3, 9])
# and compare the returned value against True (the correct answer).
# ------------------------------------------------------------------
tests = [
st.SimpleTestCase(practice_problem3b,
[[12, 33, 18, 'hello', 9, 13, 3, 9]], True),
st.SimpleTestCase(practice_problem3b,
[[12, 12, 33, 'hello', 5, 33, 5, 9]], False),
st.SimpleTestCase(practice_problem3b,
[(77, 112, 33, 'hello', 0, 43, 5, 77)], True),
st.SimpleTestCase(practice_problem3b, [[1, 1, 1, 1, 1, 1, 2]], False),
st.SimpleTestCase(practice_problem3b, [['aa', 'a']], False),
st.SimpleTestCase(practice_problem3b, ['aaa'], True),
st.SimpleTestCase(practice_problem3b,
[['aa', 'a', 'b', 'a', 'b', 'a']], True),
st.SimpleTestCase(practice_problem3b, [[9]], False),
st.SimpleTestCase(practice_problem3b,
[(12, 33, 8, 'hello', 99, 'hello')], True),
st.SimpleTestCase(practice_problem3b,
[['hello there', 'he', 'lo', 'hello']], False),
st.SimpleTestCase(practice_problem3b,
[((8, ), '8', (4 + 4, 4 + 4), [8, 8], 7, 8)], False),
st.SimpleTestCase(practice_problem3b, [[(8, ), '8', [4 + 4, 4 + 4],
(8, 8), 7, [8, 8]]], True),
st.SimpleTestCase(practice_problem3b,
[[(8, ), '8', [4 + 4, 4 + 4], [8, 8], 7,
(8, 8)]], False),
]
# Run the 13 tests in the tests list constructed above.
st.SimpleTestCase.run_tests('practice_problem3b', tests)
def run_test_practice_problem3():
""" Tests the practice_problem3 function. """
####################################################################
# Done: 2. Implement this TEST function.
# It TESTS the practice_problem3 function defined below.
# Include at least ** 2 ** ADDITIONAL tests beyond those we wrote.
#
# Try to choose tests that might expose errors in your code!
#
# As usual, include both EXPECTED and ACTUAL results in your tests
# and compute the latter BY HAND (not by running your program).
####################################################################
# DIFFICULTY AND TIME RATINGS (see top of this file for explanation)
# DIFFICULTY: 3
# TIME ESTIMATE: 10 minutes.
####################################################################
# ------------------------------------------------------------------
# 13 tests, plus a 14th after these.
# They use the imported simple_testing (st) module.
# Each test is a SimpleTestCase with 3 arguments:
# -- the function to test,
# -- a list containing the argument(s) to send to the function,
# -- the correct returned value.
# For example, the first test below will call
# practice_problem3(-2, 2, 1.3)
# and compare the returned value against [1, 7] (the correct answer).
# ------------------------------------------------------------------
tests = [
st.SimpleTestCase(practice_problem3, [-2, 2, 1.3], [1, 7]),
st.SimpleTestCase(practice_problem3, [-5, 3, 0.25], [-5, 0, 1]),
st.SimpleTestCase(practice_problem3, [-5, 4, 0.25], [-5, 0, 1, 2]),
st.SimpleTestCase(practice_problem3, [-5, 5, 0.25], [-5, 0, 1, 2, 6]),
st.SimpleTestCase(practice_problem3, [-5, 6, 0.25],
[-5, 0, 1, 2, 6, 7]),
st.SimpleTestCase(practice_problem3, [-5, 7, 0.25],
[-5, 0, 1, 2, 6, 7, 8]),
st.SimpleTestCase(practice_problem3, [-3, 3, -1.0], [-1, 0, 1]),
st.SimpleTestCase(practice_problem3, [-3, 4, -1.0], [-1, 0, 1, 2]),
st.SimpleTestCase(practice_problem3, [-3, 5, -1.0], [-1, 0, 1, 2, 3]),
st.SimpleTestCase(practice_problem3, [-3, 6, -1.0],
[-1, 0, 1, 2, 3, 5]),
st.SimpleTestCase(practice_problem3, [30, 0, -1000], []),
st.SimpleTestCase(practice_problem3, [100, 5, 1.414],
[139, 183, 516, 560, 849]),
st.SimpleTestCase(practice_problem3, [0, 1, 1.414213562373], [286602]),
]
# 14th test:
big_list = []
for k in range(888, 1888):
big_list.append(k)
tests.append(
st.SimpleTestCase(practice_problem3,
[888, 1000, -math.sqrt(2) - 0.00000000001],
big_list))
# ------------------------------------------------------------------
# Run the 14 tests in the tests list constructed above.
# ------------------------------------------------------------------
st.SimpleTestCase.run_tests('practice_problem3', tests)
####################################################################
# TO DO 2 continued: More tests:
# YOU add at least ** 2 ** additional tests here.
#
# You can use the SimpleTestCase class as above, or use
# the ordinary expected/actual way, your choice.
#
# SUGGESTION: Ask an assistant to CHECK your tests to confirm
# that they are adequate tests!
####################################################################
test = st.SimpleTestCase(practice_problem3, [0, 1, 1], [1])
test2 = st.SimpleTestCase(practice_problem3, [-5, 3, .25], [-5, 0, 1])
test.run_test()
test2.run_test()
def test_problem3b():
""" Tests the problem3b function. """
# ------------------------------------------------------------------
# Several tests.
# They use the imported simple_testing (st) module.
# Each test is a SimpleTestCase with 3 arguments:
# -- the function to test,
# -- a list containing the argument(s) to send to the function,
# -- the correct returned value.
# For example, the first test below will call
# problem3b(Point(2, 4),
# [Point(2, 10), Point(2, 13), Point(2, 7), Point(2, 11)])
# and compare the returned value against Point(2, 13) (the correct answer).
# ------------------------------------------------------------------
tests = [
st.SimpleTestCase(problem3b, [
Point(2, 4),
(
Point(2, 10),
Point(2, 13),
Point(2, 7),
Point(2, 11),
)
], Point(2, 13)),
st.SimpleTestCase(problem3b, [
Point(3, 4),
(
Point(50, 4),
Point(4, 13),
Point(7, 7),
Point(8, 11),
)
], Point(50, 4)),
st.SimpleTestCase(problem3b, [Point(3, 4), (Point(5000, 4000), )],
Point(5000, 4000)),
st.SimpleTestCase(problem3b, [
Point(100, 43),
(
Point(50, 40),
Point(99, 83),
Point(33, 41),
Point(70, 7),
Point(88, 11),
Point(44, 88),
Point(55, 78),
Point(95, 90),
Point(90, 97),
Point(50, 50),
)
], Point(44, 88)),
st.SimpleTestCase(problem3b, [
Point(100, 43),
(
Point(44, 88),
Point(50, 40),
Point(99, 83),
Point(33, 41),
Point(70, 7),
Point(88, 11),
Point(55, 78),
Point(95, 90),
Point(90, 97),
Point(50, 50),
)
], Point(44, 88)),
st.SimpleTestCase(problem3b, [
Point(100, 43),
(
Point(50, 40),
Point(99, 83),
Point(33, 41),
Point(70, 7),
Point(88, 11),
Point(55, 78),
Point(95, 90),
Point(90, 97),
Point(50, 50),
Point(44, 88),
)
], Point(44, 88)),
st.SimpleTestCase(problem3b, [
Point(100, 43),
(
Point(50, 40),
Point(99, 83),
Point(33, 41),
Point(70, 7),
Point(88, 11),
Point(44, 88),
Point(55, 78),
Point(95, 90),
Point(90, 97),
Point(50, 50),
)
], Point(44, 88)),
st.SimpleTestCase(problem3b, [
Point(100, 43),
(
Point(50, 40),
Point(99, 83),
Point(33, 41),
Point(70, 7),
Point(88, 11),
Point(44, 88),
Point(55, 78),
Point(95, 90),
Point(90, 97),
Point(50, 50),
)
], Point(44, 88)),
]
st.SimpleTestCase.run_tests('problem3b', tests)
def run_test_practice_problem2b():
""" Tests the practice_problem2b function. """
# ------------------------------------------------------------------
# 4 tests, plus a 5th after these.
# They use the imported simple_testing (st) module.
# Each test is a SimpleTestCase with 3 arguments:
# -- the function to test,
# -- a list containing the argument(s) to send to the function,
# -- the correct returned value.
# For example, the first test below will call
# practice_problem2b(('hello', 'Bye', 'ok joe'))
# and compare the returned value against 'hBo' (the correct answer).
# ------------------------------------------------------------------
tests = [st.SimpleTestCase(practice_problem2b,
[('hello', 'Bye', 'ok joe')],
'hBo'),
st.SimpleTestCase(practice_problem2b,
[('Alice', 'Bob', 'Carson', 'Devi')],
'ABCD'),
st.SimpleTestCase(practice_problem2b,
[('', 'tricky', '', 'one, no?', '!')],
'to!'),
st.SimpleTestCase(practice_problem2b,
[('my very long string', 'ok', 'mmmm')],
'mom'),
]
jokes = """
Q: What is it called when a cat wins a dog show?
A: A CAT-HAS-TROPHY!
Q: What do you call a pile of kittens?
A: a meowntain
Q: Why don't cats like online shopping?
A: They prefer a cat-alogue.
Q: What did the cat say when he lost all his money?
A: I'm paw!
Q: Did you hear about the cat who swallowed a ball of yarn?
A: She had a litter of mittens.
Q: What do you call a lion who has eaten your mother's sister?
A: An aunt-eater!
Q. How do you know when your cat's done cleaning herself?
A. She's smoking a cigarette.
source: http://www.jokes4us.com/animaljokes/catjokes.html
"""
# 5th test: Split jokes at spaces to get a list of strings.
sequence = jokes.split()
answer = ('QWiicwacwadsAACQWdycapokAamQWdclosAT' +
'pacQWdtcswhlahmAIpQDyhatcwsaboyAShalom' +
'QWdycalwheymsAAaQHdykwycdchASsacsh')
tests.append(st.SimpleTestCase(practice_problem2b,
[sequence],
answer))
# ------------------------------------------------------------------
# Run the 5 tests in the tests list constructed above.
# ------------------------------------------------------------------
st.SimpleTestCase.run_tests('practice_problem2b', tests)
def run_test_practice_problem3a():
""" Tests the practice_problem3a function. """
###########################################################################
# DONE: 3. Implement this TEST function.
# It TESTS the practice_problem3a function defined below.
# Include at least ** 1 ** ADDITIONAL test beyond those we wrote.
# __
# Try to choose tests that might expose errors in your code!
# __
# As usual, include both EXPECTED and ACTUAL results in your tests
# and compute the latter BY HAND (not by running your program).
###########################################################################
# DIFFICULTY AND TIME RATINGS (see top of this file for explanation)
# DIFFICULTY: 3
# TIME ESTIMATE: 10 minutes.
###########################################################################
# -------------------------------------------------------------------------
# Many tests, followed by extra ones appended at the end.
# They use the imported simple_testing (st) module.
# Each test is a SimpleTestCase with 3 arguments:
# -- the function to test,
# -- a list containing the argument(s) to send to the function,
# -- the correct returned value.
# For example, the first test below will call
# practice_problem3a(6, 8, 0.81)
# and compare the returned value against [7, 8] (the correct answer).
# -------------------------------------------------------------------------
tests = [
st.SimpleTestCase(practice_problem3a, [6, 8, 0.81], [7, 8]),
st.SimpleTestCase(practice_problem3a, [-4, 9, 0.25],
[0, 1, 2, 6, 7, 8]),
st.SimpleTestCase(practice_problem3a, [-5, 4, 0.25], [-5, 0, 1, 2]),
st.SimpleTestCase(practice_problem3a, [-3, 8, 0.65], [0, 1, 6, 7, 8]),
st.SimpleTestCase(practice_problem3a, [-4, 8, 0.65], [0, 1, 6, 7, 8]),
st.SimpleTestCase(practice_problem3a, [-5, 8, 0.65],
[-5, 00, 1, 6, 7, 8]),
st.SimpleTestCase(practice_problem3a, [-3, 3, -1.0], [-1, 0, 1, 2, 3]),
st.SimpleTestCase(practice_problem3a, [-3, 4, -1.0], [-1, 0, 1, 2, 3]),
st.SimpleTestCase(practice_problem3a, [-3, 5, -1.0],
[-1, 0, 1, 2, 3, 5]),
st.SimpleTestCase(practice_problem3a, [-3, 6, -1.0],
[-1, 0, 1, 2, 3, 5, 6]),
st.SimpleTestCase(practice_problem3a, [30, 0, -1000], []),
st.SimpleTestCase(practice_problem3a, [100, 1000, 1.414],
[139, 183, 516, 560, 849, 893]),
st.SimpleTestCase(
practice_problem3a,
[-1000, 1000000, math.sqrt(2) - 0.0000000001],
[286602, 599291, 911980]),
st.SimpleTestCase(practice_problem3a, [-1000, 1000000, 1.414213562373],
[286602]),
st.SimpleTestCase(practice_problem3a, [-1000, 1000000, 1.414213562374],
[]),
]
# More tests, with larger lists as the expected returned values
big_list = []
for k in range(900, 1001):
big_list.append(k)
tests.append(
st.SimpleTestCase(practice_problem3a,
[900, 1000, -math.sqrt(2) + 0.00001], big_list))
big_list_without_915 = big_list.copy()
big_list_without_915.remove(915)
tests.append(
st.SimpleTestCase(practice_problem3a,
[900, 1000, -math.sqrt(2) + 0.0001],
big_list_without_915))
# -------------------------------------------------------------------------
# Run the tests in the tests list constructed above.
# -------------------------------------------------------------------------
st.SimpleTestCase.run_tests('practice_problem3a', tests)
def run_test_practice_problem3():
""" Tests the practice_problem3 function. """
####################################################################
# DONE: 2. Implement this TEST function.
# It TESTS the practice_problem3 function defined below.
# Include at least ** 2 ** ADDITIONAL tests beyond those we wrote.
#
# Try to choose tests that might expose errors in your code!
#
# As usual, include both EXPECTED and ACTUAL results in your tests
# and compute the latter BY HAND (not by running your program).
####################################################################
# DIFFICULTY AND TIME RATINGS (see top of this file for explanation)
# DIFFICULTY: 3
# TIME ESTIMATE: 10 minutes.
####################################################################
# ------------------------------------------------------------------
# 13 tests, plus a 14th after these.
# They use the imported simple_testing (st) module.
# Each test is a SimpleTestCase with 3 arguments:
# -- the function to test,
# -- a list containing the argument(s) to send to the function,
# -- the correct returned value.
# For example, the first test below will call
# practice_problem3(-2, 2, 1.3)
# and compare the returned value against [1, 7] (the correct answer).
# ------------------------------------------------------------------
tests = [st.SimpleTestCase(practice_problem3,
[-2, 2, 1.3],
[1, 7]),
st.SimpleTestCase(practice_problem3,
[-5, 3, 0.25],
[-5, 0, 1]),
st.SimpleTestCase(practice_problem3,
[-5, 4, 0.25],
[-5, 0, 1, 2]),
st.SimpleTestCase(practice_problem3,
[-5, 5, 0.25],
[-5, 0, 1, 2, 6]),
st.SimpleTestCase(practice_problem3,
[-5, 6, 0.25],
[-5, 0, 1, 2, 6, 7]),
st.SimpleTestCase(practice_problem3,
[-5, 7, 0.25],
[-5, 0, 1, 2, 6, 7, 8]),
st.SimpleTestCase(practice_problem3,
[-3, 3, -1.0],
[-1, 0, 1]),
st.SimpleTestCase(practice_problem3,
[-3, 4, -1.0],
[-1, 0, 1, 2]),
st.SimpleTestCase(practice_problem3,
[-3, 5, -1.0],
[-1, 0, 1, 2, 3]),
st.SimpleTestCase(practice_problem3,
[-3, 6, -1.0],
[-1, 0, 1, 2, 3, 5]),
st.SimpleTestCase(practice_problem3,
[30, 0, -1000],
[]),
st.SimpleTestCase(practice_problem3,
[100, 5, 1.414],
[139, 183, 516, 560, 849]),
st.SimpleTestCase(practice_problem3,
[0, 1, 1.414213562373],
[286602]),
]
# 14th test:
big_list = []
for k in range(888, 1888):
big_list.append(k)
tests.append(st.SimpleTestCase(practice_problem3,
[888, 1000,
- math.sqrt(2) - 0.00000000001],
big_list))
# ------------------------------------------------------------------
# Run the 14 tests in the tests list constructed above.
# ------------------------------------------------------------------
st.SimpleTestCase.run_tests('practice_problem3', tests)
# Test 2:
expected2 = [1, 7]
answer2=practice_problem3(-2,2,1.3)
print()
print('Test 2:')
print(' Expected:', expected2)
print(' Actual: ', answer2)
# Test 3:
expected3 = [-5, 0, 1, 2, 6, 7, 8]
answer3=practice_problem3(-5, 7, 0.25)
print()
print('Test 3:')
print(' Expected:', expected3)
print(' Actual: ', answer3)
def run_test_practice_problem3b():
""" Tests the practice_problem3b function. """
###########################################################################
# DONE: 5. Implement this TEST function.
# It TESTS the practice_problem3b function defined below.
# Include at least ** 2 ** ADDITIONAL tests beyond those we wrote.
# __
# Try to choose tests that might expose errors in your code!
# __
# As usual, include both EXPECTED and ACTUAL results in your tests
# and compute the latter BY HAND (not by running your program).
###########################################################################
# DIFFICULTY AND TIME RATINGS (see top of this file for explanation)
# DIFFICULTY: 3
# TIME ESTIMATE: 10 minutes.
###########################################################################
# -------------------------------------------------------------------------
# Many tests, followed by extra ones appended at the end.
# They use the imported simple_testing (st) module.
# Each test is a SimpleTestCase with 3 arguments:
# -- the function to test,
# -- a list containing the argument(s) to send to the function,
# -- the correct returned value.
# For example, the first test below will call
# practice_problem3b(-2, 2, 1.3)
# and compare the returned value against [1, 7] (the correct answer).
# -------------------------------------------------------------------------
tests = [
st.SimpleTestCase(practice_problem3b, [-2, 2, 1.3], [1, 7]),
st.SimpleTestCase(practice_problem3b, [-5, 3, 0.25], [-5, 0, 1]),
st.SimpleTestCase(practice_problem3b, [-5, 4, 0.25], [-5, 0, 1, 2]),
st.SimpleTestCase(practice_problem3b, [-5, 5, 0.25], [-5, 0, 1, 2, 6]),
st.SimpleTestCase(practice_problem3b, [-5, 6, 0.25],
[-5, 0, 1, 2, 6, 7]),
st.SimpleTestCase(practice_problem3b, [-5, 7, 0.25],
[-5, 0, 1, 2, 6, 7, 8]),
st.SimpleTestCase(practice_problem3b, [-3, 3, -1.0], [-1, 0, 1]),
st.SimpleTestCase(practice_problem3b, [-3, 4, -1.0], [-1, 0, 1, 2]),
st.SimpleTestCase(practice_problem3b, [-3, 5, -1.0], [-1, 0, 1, 2, 3]),
st.SimpleTestCase(practice_problem3b, [-3, 6, -1.0],
[-1, 0, 1, 2, 3, 5]),
st.SimpleTestCase(practice_problem3b, [30, 0, -1000], []),
st.SimpleTestCase(practice_problem3b, [100, 5, 1.414],
[139, 183, 516, 560, 849]),
st.SimpleTestCase(practice_problem3b, [0, 1, 1.414213562373],
[286602]),
]
# More tests, with larger lists as the expected returned values
big_list = []
for k in range(888, 988):
big_list.append(k)
tests.append(
st.SimpleTestCase(practice_problem3b,
[888, 100, -math.sqrt(2) + 0.00000000001], big_list))
another_big_list = big_list.copy()
another_big_list.remove(915)
another_big_list.remove(959)
another_big_list.append(988)
another_big_list.append(989)
tests.append(
st.SimpleTestCase(practice_problem3b,
[888, 100, -math.sqrt(2) + 0.001], another_big_list))
# -------------------------------------------------------------------------
# Run the tests in the tests list constructed above.
# -------------------------------------------------------------------------
st.SimpleTestCase.run_tests('practice_problem3b', tests)
###########################################################################
# DONE: 5 continued: More tests:
# YOU add at least ** 2 ** additional tests here.
# __
# You can use the SimpleTestCase class as above, or use
# the ordinary expected/actual way, your choice.
# __
# SUGGESTION: Ask an assistant to CHECK your tests to confirm
# that they are adequate tests!
###########################################################################
expected = ([1, 2, 3, 4, 5])
print("Expected:", expected)
actual = practice_problem3b(1, 5, 2)
print("Actual:", actual)
expected = ([])
print("Expected:", expected)
actual = practice_problem3b(5, 0, 1)
print("Actual:", actual)
def test_problem2a():
""" Tests the problem2a function. """
# ------------------------------------------------------------------
# These tests use the imported simple_testing (st) module.
# Each test is a SimpleTestCase with 3 arguments:
# -- the function to test,
# -- a list containing the argument(s) to send to the function,
# -- the correct returned value.
# For example, the first test below will call
# problem2a([Point(100, 3), Point(50, 10), Point(7, 11)])
# and compare the returned value against 157 (the correct answer).
# ------------------------------------------------------------------
tests = [
st.SimpleTestCase(problem2a, [
[Point(100, 3), Point(50, 10),
Point(7, 11)],
], 157),
st.SimpleTestCase(problem2a, [
[Point(77, 555)],
], 77),
st.SimpleTestCase(problem2a, [
[Point(10, 5), Point(10, 8),
Point(10, 8)],
], 30),
st.SimpleTestCase(problem2a, [
[Point(200, 200),
Point(500, 500),
Point(400, 400)],
], 1100),
st.SimpleTestCase(problem2a, [
[
Point(100, 10),
Point(7, 10),
Point(57, 10),
Point(10, 10),
Point(4, 10),
Point(33, 10),
Point(20, 10),
Point(21, 10),
Point(38, 10),
Point(59, 10),
Point(77, 10),
Point(50, 10),
Point(37, 10),
Point(33, 10),
Point(0, 10),
Point(90, 10),
Point(70, 10)
],
], 706),
st.SimpleTestCase(problem2a, [
[Point(0, 3), Point(0, 10),
Point(0, 11)],
], 0),
st.SimpleTestCase(problem2a, [
[
Point(-5, 3),
Point(0, 10),
Point(5, 11),
Point(0, 10),
Point(40, 11),
Point(-30, 11),
Point(-10, 11)
],
], 0),
st.SimpleTestCase(problem2a, [
[],
], 0),
]
# ------------------------------------------------------------------
# Run the tests in the tests list constructed above.
# ------------------------------------------------------------------
st.SimpleTestCase.run_tests('problem2a', tests)
def test_problem2b():
""" Tests the problem2b function. """
tests = [
st.SimpleTestCase(problem2b, [
[Point(100, 3), Point(50, 10),
Point(7, 11)],
Point(49, 13),
], Point(50, 10)),
st.SimpleTestCase(problem2b, [
[
Point(77, 555),
],
Point(1000, 10000),
], Point(77, 555)),
st.SimpleTestCase(problem2b, [
[Point(100, 50), Point(10, 8),
Point(10, 8)],
Point(11, 7),
], Point(10, 8)),
st.SimpleTestCase(problem2b, [
[Point(100, 20), Point(1000, 1000),
Point(0, 60)],
Point(50, 40),
], Point(100, 20)),
st.SimpleTestCase(problem2b, [
[
Point(10, 10),
Point(20, 20),
Point(30, 30),
Point(20, 20),
Point(15, 15),
],
Point(11, 11),
], Point(10, 10)),
st.SimpleTestCase(problem2b, [
[
Point(10, 10),
Point(20, 20),
Point(30, 30),
Point(40, 40),
Point(15, 15),
],
Point(14, 14),
], Point(15, 15)),
st.SimpleTestCase(problem2b, [
[
Point(10, 57),
Point(10, 56),
Point(10, 53),
Point(10, 56),
Point(9, 55),
],
Point(10, 54),
], Point(10, 53)),
st.SimpleTestCase(problem2b, [
[
Point(57, 10),
Point(56, 10),
Point(53, 10),
Point(56, 10),
Point(54, 9),
],
Point(54, 10),
], Point(53, 10)),
st.SimpleTestCase(problem2b, [
[
Point(77, 555),
Point(0, 0),
Point(0, 0),
Point(0, 0),
Point(0, 0),
],
Point(1000, 10000),
], Point(77, 555)),
st.SimpleTestCase(problem2b, [
[
Point(77, 555),
Point(56, 30),
Point(40, 100),
Point(0, 0),
Point(1, 1),
Point(30, 10),
Point(40, 70),
Point(20, 5)
],
Point(1000, 10000),
], Point(77, 555)),
st.SimpleTestCase(problem2b, [
[
Point(77, 555),
Point(56, 30),
Point(40, 100),
Point(0, 0),
Point(1, 1),
Point(30, 10),
Point(40, 70),
Point(20, 5)
],
Point(40, 33),
], Point(56, 30)),
st.SimpleTestCase(problem2b, [
[
Point(77, 555),
Point(56, 30),
Point(40, 100),
Point(0, 0),
Point(1, 1),
Point(30, 10),
Point(40, 70),
Point(20, 5)
],
Point(45, 85),
], Point(40, 100)),
st.SimpleTestCase(problem2b, [
[
Point(77, 555),
Point(56, 30),
Point(40, 100),
Point(0, 0),
Point(1, 1),
Point(30, 10),
Point(40, 70),
Point(20, 5)
],
Point(45, 84),
], Point(40, 70)),
st.SimpleTestCase(problem2b, [
[
Point(77, 555),
Point(56, 30),
Point(40, 100),
Point(0, 0),
Point(1, 1),
Point(30, 10),
Point(40, 70),
Point(20, 5)
],
Point(0, 1),
], Point(0, 0)),
st.SimpleTestCase(problem2b, [
[
Point(77, 555),
Point(56, 30),
Point(40, 100),
Point(1, 1),
Point(0, 0),
Point(30, 10),
Point(40, 70),
Point(20, 5)
],
Point(0, 1),
], Point(1, 1)),
st.SimpleTestCase(problem2b, [
[
Point(77, 555),
Point(56, 30),
Point(40, 100),
Point(1, 1),
Point(0, 0),
Point(30, 10),
Point(40, 70),
Point(20, 5)
],
Point(25, 7),
], Point(20, 5)),
]
# ------------------------------------------------------------------
# Run the tests in the tests list constructed above.
# ------------------------------------------------------------------
st.SimpleTestCase.run_tests('problem2b', tests)
