def test_get_number_of_clones(): """ Tests the get_number_of_clones method of the Line class. """ print() print('-----------------------------------------------------------') print('Testing the get_number_of_clones method') print(' of the Line class:') print('-----------------------------------------------------------') if not is_implemented('get_number_of_clones'): return print('The following are OUR tests (from m1t_test_Line):') line1 = m1.Line(m1.Point(500, 20), m1.Point(100, 8)) line1.reverse() line2 = line1.clone() line1.reverse() line2.reverse() line2.x = m1.Point(0, 0) line3 = line1.clone() line4 = line3.clone() line5 = line1.clone() expected = 3 actual = line1.get_number_of_clones() evaluate_test(expected, actual, 'Testing line1, cloned 3 times:') expected = 0 actual = line2.get_number_of_clones() evaluate_test(expected, actual, 'Testing line2, never cloned:') expected = 1 actual = line3.get_number_of_clones() evaluate_test(expected, actual, 'Testing line3, cloned once:') expected = 0 actual = line4.get_number_of_clones() evaluate_test(expected, actual, 'Testing line4, never cloned:') expected = 0 actual = line5.get_number_of_clones() evaluate_test(expected, actual, 'Testing line5, not yet cloned:') line3 = line5.clone() expected = 0 actual = line3.get_number_of_clones() evaluate_test(expected, actual, 'Testing line3, now a new Line') expected = 1 actual = line5.get_number_of_clones() evaluate_test(expected, actual, 'Testing line5, cloned once:') line5 = line1 expected = 3 actual = line5.get_number_of_clones() evaluate_test(expected, actual, 'Testing line5, now same as line1:') print('\nHere is YOUR test (that YOU wrote in m1_Line):') print()
def test_length(): """ Tests the length method of the Line class. """ print() print('-----------------------------------------------------------') print('Testing the length method of the Line class:') print('-----------------------------------------------------------') if not is_implemented('length'): return print('The following are OUR tests (from m1t_test_Line):') line1 = m1.Line(m1.Point(25, 2), m1.Point(10, 7)) # Length is 15.8113883 line2 = m1.Line(m1.Point(-30, 10), m1.Point(-10, 20)) # Length is 22.3606798 line3 = m1.Line(m1.Point(-100, 20), m1.Point(300, 20)) # Horizontal line, length is 400 line4 = m1.Line(m1.Point(30, 40), m1.Point(30, 100)) # Vertical line, length is 60 line5 = m1.Line(m1.Point(100, 200), m1.Point(100, 200)) # Length is 0 # These tests round all numbers to 6 decimal places before # doing the test for equality. This is necessary since here we # are dealing with floating point numbers that may be computed # slightly differently (but with both ways correct). # ACTUALLY, I think that __eq__ in the Point class now takes # care of the floating-point roundoff. expected = round(15.8113883, 6) actual = round(line1.length(), 6) evaluate_test(expected, actual, 'Testing a negative-slope line:') expected = round(22.3606798, 6) actual = round(line2.length(), 6) evaluate_test(expected, actual, 'Testing a fractional-slope line:') expected = round(400.0, 6) actual = round(line3.length(), 6) evaluate_test(expected, actual, 'Testing a horizontal line') expected = round(60.0, 6) actual = round(line4.length(), 6) evaluate_test(expected, actual, 'Testing a vertical line:') expected = round(0.0, 6) actual = round(line5.length(), 6) evaluate_test(expected, actual, 'Testing a length-zero line:') print('\nHere is YOUR test (that YOU wrote in m1_Line):') print()
def test_reverse(): """ Tests the reverse method of the Line class. """ print() print('-----------------------------------------------------------') print('Testing the reverse method of the Line class:') print('-----------------------------------------------------------') if not is_implemented('reverse'): return print('The following are OUR tests (from m1t_test_Line):') # ------------------------------------------------------------------ # Tests using one line: # ------------------------------------------------------------------ line = m1.Line(m1.Point(12, 88), m1.Point(40, 33)) original_start = line.start original_end = line.end line_clone = m1.Line(m1.Point(12, 88), m1.Point(40, 33)) # ------------------------------------------------------------------ # Reverse the first time: # ------------------------------------------------------------------ line.reverse() expected = original_end actual = line.start evaluate_test(expected, actual, 'Testing START after 1st reverse:') if (expected == actual) and (expected is not actual): print_failure() print_failure(' START is a CLONE of the original END') print_failure(' instead of the original END itself.') expected = original_start actual = line.end evaluate_test(expected, actual, 'Testing END after 1st reverse:') if (expected == actual) and (expected is not actual): print_failure() print_failure(' END is a CLONE of the original START') print_failure(' instead of the original START itself.') # ------------------------------------------------------------------ # After another reverse, line should be back to the original line. # ------------------------------------------------------------------ line.reverse() expected = line_clone actual = line evaluate_test(expected, actual, 'Testing after the 2nd reverse:') print('\nHere is YOUR test (that YOU wrote in m1_Line):') print()
def test_slope(): """ Tests the slope method of the Line class. """ print() print('-----------------------------------------------------------') print('Testing the slope method of the Line class:') print('-----------------------------------------------------------') if not is_implemented('slope'): return print('The following are OUR tests (from m1t_test_Line):') line1 = m1.Line(m1.Point(2, 25), m1.Point(7, 10)) # Slope is -3 line2 = m1.Line(m1.Point(-30, 10), m1.Point(-10, 20)) # Slope is 0.5 line3 = m1.Line(m1.Point(-100, 20), m1.Point(300, 20)) # Slope is 0 line4 = m1.Line(m1.Point(30, 40), m1.Point(30, 100)) # Slope is math.inf expected = -3.0 actual = line1.slope() evaluate_test(expected, actual, 'Testing a negative slope:') expected = 0.5 actual = line2.slope() evaluate_test(expected, actual, 'Testing a fractional slope:') expected = 0.0 actual = line3.slope() if actual == -0.0: expected = -0.0 # Both positive and negative zero are correct. evaluate_test(expected, actual, 'Testing a horizontal line') expected = math.inf actual = line4.slope() evaluate_test(expected, actual, 'Testing a vertical line:') print('\nHere is YOUR test (that YOU wrote in m1_Line):') print()
def test_midpoint(): """ Tests the midpoint method of the Line class. """ print() print('-----------------------------------------------------------') print('Testing the midpoint method of the Line class:') print('-----------------------------------------------------------') if not is_implemented('midpoint'): return print('The following are OUR tests (from m1t_test_Line):') line = m1.Line(m1.Point(-10, 50), m1.Point(30, 20)) # midpoint is (10, 35) expected = m1.Point(10.0, 35.0) actual = line.midpoint() evaluate_test(expected, actual, 'Testing the original line:') expected = m1.Point(10.0, 35.0) actual = line.midpoint() evaluate_test(expected, actual, 'Testing the original line again:') line.start = m1.Point(30.0, 10.0) expected = m1.Point(30.0, 15.0) actual = line.midpoint() evaluate_test(expected, actual, 'Testing a vertical line:') line.end = m1.Point(-30.0, 10.0) expected = m1.Point(0.0, 10.0) actual = line.midpoint() evaluate_test(expected, actual, 'Testing a horizontal line:') line.start = line.end expected = line.start.clone() actual = line.midpoint() evaluate_test(expected, actual, 'Testing a zero-length line:') print('\nHere is YOUR test (that YOU wrote in m1_Line):') print()
def test_reset(): """ Tests the reset method of the Line class. """ print() print('-----------------------------------------------------------') print('Testing the reset method of the Line class:') print('-----------------------------------------------------------') if not is_implemented('reset'): return print('The following are OUR tests (from m1t_test_Line):') p1 = m1.Point(55, 66) p2 = m1.Point(77, 88) p3 = m1.Point(0, 0) p4 = m1.Point(-100, -2) line1 = m1.Line(p1.clone(), p2.clone()) line2 = m1.Line(p3.clone(), p4.clone()) line3 = m1.Line(p1.clone(), p3.clone()) line1.start = m1.Point(100, 300) line2.end = m1.Point(99, 4) line1.reverse() line1.reverse() line2.reverse() line3.reverse() # ------------------------------------------------------------------ # Testing line1 BEFORE the reset, then AFTER the reset. # ------------------------------------------------------------------ expected = False actual = (line1 == m1.Line(p1, p2)) evaluate_test(expected, actual, 'Testing line1 BEFORE the reset:') line1.reset() expected = m1.Line(p1, p2) actual = line1 evaluate_test(expected, actual, 'Testing line1 AFTER the reset:') # ------------------------------------------------------------------ # Testing line2 BEFORE the reset, then AFTER the reset. # ------------------------------------------------------------------ expected = False actual = (line2 == m1.Line(p3, p4)) evaluate_test(expected, actual, 'Testing line2 BEFORE the reset:') line2.reset() expected = m1.Line(p3, p4) actual = line2 evaluate_test(expected, actual, 'Testing line2 AFTER the reset:') # ------------------------------------------------------------------ # Testing line3 BEFORE the reset, then AFTER the reset. # ------------------------------------------------------------------ expected = False actual = (line3 == m1.Line(p1, p3)) evaluate_test(expected, actual, 'Testing line3 BEFORE the reset:') line3.reset() expected = m1.Line(p1, p3) actual = line3 evaluate_test(expected, actual, 'Testing line3 AFTER the reset:') # ------------------------------------------------------------------ # Testing MANY resets, then ONLY resets. # ------------------------------------------------------------------ for _ in range(99): line1.reverse() line1.reset() expected = m1.Line(p1, p2) actual = line1 evaluate_test(expected, actual, 'Testing line1 after MANY resets') line3 = m1.Line(p1.clone(), p4.clone()) for _ in range(1001): line3.reset() expected = m1.Line(p1, p4) actual = line3 evaluate_test(expected, actual, 'Testing line3 after ONLY resets') # ------------------------------------------------------------------ # Testing whether the code CLONED when it stored the original Points # for retrieval by reset. # ------------------------------------------------------------------ line4 = m1.Line(m1.Point(66, 77), m1.Point(88, 99)) line4.start.x = 100 line4.reset() expected = m1.Line(m1.Point(66, 77), m1.Point(88, 99)) actual = line4 title = 'Testing whether the code CLONED when it stored the Points' evaluate_test(expected, actual, title) print('\nHere is YOUR test (that YOU wrote in m1_Line):') print()
def test_init(): """ Tests the __init__ method of the Line class. """ print() print('-----------------------------------------------------------') print('Testing the __init__ method of the Line class:') print('-----------------------------------------------------------') if not is_implemented('__init__'): return print('The following are OUR tests (from m1t_test_Line):') # ------------------------------------------------------------------ # Tests using one line: # ------------------------------------------------------------------ start = m1.Point(12, 88) end = m1.Point(40, 33) start_clone = start.clone() end_clone = end.clone() line = m1.Line(start, end) # Causes __init__ to run # Test whether start is set correctly. expected = start_clone actual = line.start evaluate_test(expected, actual, 'Testing START:') # Test whether end is set correctly. expected = end_clone actual = line.end evaluate_test(expected, actual, 'Testing END:') # Testing whether __init__ CLONED its arguments: message = '\n *** ERROR: FAILED to CLONE the {} argument. ***' if line.start is start: print_failure(message.format('START')) if line.end is end: print_failure(message.format('END')) # ------------------------------------------------------------------ # Tests using another line: # ------------------------------------------------------------------ start = m1.Point(-10, 111) end = m1.Point(222, -20) start_clone = start.clone() end_clone = end.clone() line = m1.Line(start, end) # Causes __init__ to run # Test whether start is set correctly. expected = start_clone actual = line.start evaluate_test(expected, actual, 'Testing START:') # Test whether end is set correctly. expected = end_clone actual = line.end evaluate_test(expected, actual, 'Testing END:') # Testing whether __init__ CLONED its arguments: message = '\n *** ERROR: FAILED to CLONE the {} argument. ***' if line.start is start: print_failure(message.format('START')) if line.end is end: print_failure(message.format('END')) print('\nHere is YOUR test (that YOU wrote in m1_Line):\n')
def test_intersection(): """ Tests the intersection method of the Line class. """ print() print('-----------------------------------------------------------') print('Testing the intersection method of the Line class:') print('-----------------------------------------------------------') if not is_implemented('intersection'): return print('The following are OUR tests (from m1t_test_Line):') line1 = m1.Line(m1.Point(10, 4), m1.Point(24, 4)) line2 = m1.Line(m1.Point(18, 20), m1.Point(18, -5)) line3 = m1.Line(m1.Point(19, 6), m1.Point(14, 1)) line4 = m1.Line(m1.Point(21, 5), m1.Point(11, 0)) expected = m1.Point(18.0, 4.0) actual = line1.intersection(line2) evaluate_test(expected, actual, 'Testing horizontal line crossed by vertical line') expected = m1.Point(18.0, 4.0) actual = line2.intersection(line1) evaluate_test(expected, actual, 'Testing the same, in the other order') expected = m1.Point(17.0, 4.0) actual = line1.intersection(line3) evaluate_test(expected, actual, 'Testing horizontal line crossed by slanted line') expected = m1.Point(18.0, 4.0) actual = line2.intersection(line1) evaluate_test(expected, actual, 'Testing the same, in the other order') expected = m1.Point(15.0, 2.0) actual = line3.intersection(line4) evaluate_test(expected, actual, 'Testing slanted line crossed by slanted line') line5 = m1.Line(m1.Point(10, 4), m1.Point(18, 4)) expected = m1.Point(18.0, 4.0) actual = line5.intersection(line2) evaluate_test(expected, actual, 'Testing two lines that barely cross') line6 = m1.Line(m1.Point(10, 4), m1.Point(17.99, 4)) expected = None actual = line6.intersection(line2) evaluate_test(expected, actual, 'Testing two lines that just miss crossing') line7 = m1.Line(m1.Point(24 * math.pi, 10), m1.Point(20 * math.pi, 30)) line8 = m1.Line(m1.Point(60 * math.pi, -110), m1.Point(68 * math.pi, -150)) expected = None actual = line7.intersection(line8) evaluate_test(expected, actual, 'Testing two parallel lines') print('\nHere is YOUR test (that YOU wrote in m1_Line):') print()
def test_is_parallel(): """ Tests the is_parallel method of the Line class. """ print() print('-----------------------------------------------------------') print('Testing the is_parallel method of the Line class:') print('-----------------------------------------------------------') if not is_implemented('is_parallel'): return print('The following are OUR tests (from m1t_test_Line):') # ------------------------------------------------------------------ # Tests using one pair of lines. Each has slope -5. # ------------------------------------------------------------------ line1 = m1.Line(m1.Point(24, 10), m1.Point(20, 30)) line2 = m1.Line(m1.Point(60, -110), m1.Point(68, -150)) # These both have slope -5 expected = True actual = line1.is_parallel(line2) evaluate_test(expected, actual, 'Testing parallel lines:') expected = True actual = line2.is_parallel(line1) evaluate_test(expected, actual, 'Testing those lines again:') line1.reverse() expected = True actual = line1.is_parallel(line2) evaluate_test(expected, actual, 'Testing after reversing one line:') expected = True actual = line2.is_parallel(line1) evaluate_test(expected, actual, 'Testing that again:') # ------------------------------------------------------------------ # Modifying one of the lines, so that they are no longer parallel: # ------------------------------------------------------------------ line1.start.x = line1.start.x + 0.000001 expected = False actual = line1.is_parallel(line2) evaluate_test(expected, actual, 'Testing lines no longer parallel:') expected = False actual = line2.is_parallel(line1) evaluate_test(expected, actual, 'Testing that again:') # ------------------------------------------------------------------ # Testing horizontal lines: # ------------------------------------------------------------------ line1 = m1.Line(m1.Point(88, 50), m1.Point(99, 50)) line2 = m1.Line(m1.Point(-100, 300), m1.Point(-200, 300)) # These are both horizontal expected = True actual = line1.is_parallel(line2) evaluate_test(expected, actual, 'Testing parallel lines:') expected = True actual = line2.is_parallel(line1) evaluate_test(expected, actual, 'Testing those lines again:') line1.reverse() expected = True actual = line1.is_parallel(line2) evaluate_test(expected, actual, 'Testing after reversing one line:') expected = True actual = line2.is_parallel(line1) evaluate_test(expected, actual, 'Testing that again:') # Modifying one of the lines, so that they are no longer parallel: line2.end.y = line2.end.y + 0.000001 expected = False actual = line1.is_parallel(line2) evaluate_test(expected, actual, 'Testing lines no longer parallel:') expected = False actual = line2.is_parallel(line1) evaluate_test(expected, actual, 'Testing that again:') # ------------------------------------------------------------------ # Testing vertical lines: # ------------------------------------------------------------------ line1 = m1.Line(m1.Point(77, 66), m1.Point(77, -600)) line2 = m1.Line(m1.Point(-110, 33), m1.Point(-110, 300)) # These are both vertical expected = True actual = line1.is_parallel(line2) evaluate_test(expected, actual, 'Testing parallel lines:') expected = True actual = line2.is_parallel(line1) evaluate_test(expected, actual, 'Testing those lines again:') line1.reverse() expected = True actual = line1.is_parallel(line2) evaluate_test(expected, actual, 'Testing after reversing one line:') expected = True actual = line2.is_parallel(line1) evaluate_test(expected, actual, 'Testing that again:') # Modifying one of the lines, so that they are no longer parallel: line1.end.x = line1.end.x + 0.000001 expected = False actual = line1.is_parallel(line2) evaluate_test(expected, actual, 'Testing lines no longer parallel:') expected = False actual = line2.is_parallel(line1) evaluate_test(expected, actual, 'Testing that again:') # ------------------------------------------------------------------ # Testing a situation where floating point arithmetic may say # that two slopes that are equal (in REAL arithmetic) are NOT equal. # # The code must ROUND in comparing the two slopes. # ------------------------------------------------------------------ line1 = m1.Line(m1.Point(24 * math.pi, 10), m1.Point(20 * math.pi, 30)) line2 = m1.Line(m1.Point(60 * math.pi, -110), m1.Point(68 * math.pi, -150)) expected = True actual = line1.is_parallel(line2) evaluate_test(expected, actual, 'Testing whether you ROUNDED in comparing the slopes:') print('\nHere is YOUR test (that YOU wrote in m1_Line):') print()
def test_line_minus(): """ Tests the line_minus method of the Line class. """ print() print('-----------------------------------------------------------') print('Testing the line_minus method of the Line class:') print('-----------------------------------------------------------') if not is_implemented('line_minus'): return print('The following are OUR tests (from m1t_test_Line):') line1 = m1.Line(m1.Point(500, 20), m1.Point(100, 8)) line2 = m1.Line(m1.Point(100, 13), m1.Point(400, 8)) expected = m1.Line(m1.Point(400, 7), m1.Point(-300, 0)) actual = line1.line_minus(line2) evaluate_test(expected, actual, 'Testing line1 - line2:') expected = m1.Line(m1.Point(-400, -7), m1.Point(300, 0)) actual = line2.line_minus(line1) evaluate_test(expected, actual, 'Testing line2 - line1:') expected = m1.Line(m1.Point(-900, -27), m1.Point(200, -8)) actual = line2.line_minus(line1).line_minus(line1) evaluate_test(expected, actual, 'Testing line2 - line1 - line1:') expected = m1.Line(m1.Point(0, 0), m1.Point(0, 0)) actual = line2.line_minus(line2) evaluate_test(expected, actual, 'Testing line2 - line2:') print('\nHere is YOUR test (that YOU wrote in m1_Line):') print()
def test_line_plus(): """ Tests the line_plus method of the Line class. """ print() print('-----------------------------------------------------------') print('Testing the line_plus method of the Line class:') print('-----------------------------------------------------------') if not is_implemented('line_plus'): return print('The following are OUR tests (from m1t_test_Line):') line1 = m1.Line(m1.Point(500, 20), m1.Point(100, 8)) line2 = m1.Line(m1.Point(100, 13), m1.Point(400, 8)) expected = m1.Line(m1.Point(600, 33), m1.Point(500, 16)) actual = line1.line_plus(line2) evaluate_test(expected, actual, 'Testing line1 + line2:') expected = m1.Line(m1.Point(600, 33), m1.Point(500, 16)) actual = line2.line_plus(line1) evaluate_test(expected, actual, 'Testing line2 + line1:') expected = m1.Line(m1.Point(1100, 53), m1.Point(600, 24)) actual = line2.line_plus(line1).line_plus(line1) evaluate_test(expected, actual, 'Testing line2 + line1 + line1:') expected = m1.Line(m1.Point(200, 26), m1.Point(800, 16)) actual = line2.line_plus(line2) evaluate_test(expected, actual, 'Testing line2 + line2:') print('\nHere is YOUR test (that YOU wrote in m1_Line):') print()
def test_clone(): """ Tests the clone method of the Line class. """ print() print('-----------------------------------------------------------') print('Testing the clone method of the Line class:') print('-----------------------------------------------------------') if not is_implemented('clone'): return print('The following are OUR tests (from m1t_test_Line):') # ------------------------------------------------------------------ # Tests using one line: # ------------------------------------------------------------------ start = m1.Point(12, 88) end = m1.Point(40, 33) start_clone = start.clone() end_clone = end.clone() line = m1.Line(start, end) clone = line.clone() # Test that the clone is a clone (copy), not just a 2nd reference. expected = True actual = (line == clone) evaluate_test(expected, actual, 'Testing that (line == clone):') expected = False actual = (line is clone) title = 'Testing that the line and clone are NOT the same object:' evaluate_test(expected, actual, title) expected = False actual = (line.start is clone.start) title = 'Testing that their START points are NOT the same object:' evaluate_test(expected, actual, title) expected = False actual = (line.end is clone.end) title = 'Testing that their END points are NOT the same object:' evaluate_test(expected, actual, title) # Change both line and clone. Neither should affect the other. new_start = m1.Point(100, 200) new_end = m1.Point(300, 400) line.start = new_start clone.end = new_end # Test the clone: expected = start_clone actual = clone.start evaluate_test(expected, actual, 'Testing START for the clone:') expected = new_end actual = clone.end evaluate_test(expected, actual, 'Testing END for the clone:') # Test the line: expected = new_start actual = line.start evaluate_test(expected, actual, 'Testing START for the line:') expected = end_clone actual = line.end evaluate_test(expected, actual, 'Testing END for the line:') # ------------------------------------------------------------------ # Tests using another line: # ------------------------------------------------------------------ start = m1.Point(55, 66) end = m1.Point(77, 88) start_clone = start.clone() end_clone = end.clone() line = m1.Line(start, end) clone = line.clone() # Test that the clone is a clone (copy), not just a 2nd reference. expected = True actual = (line == clone) evaluate_test(expected, actual, 'Testing that (line == clone):') expected = False actual = (line is clone) title = 'Testing that the line and clone are NOT the same object:' evaluate_test(expected, actual, title) print('\nHere is YOUR test (that YOU wrote in m1_Line):') print()