optimism 3.1__tar.gz → 3.1.2__tar.gz

{optimism-3.1 → optimism-3.1.2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: optimism
-Version: 3.1
-Summary: Very simple testing framework suitable for beginner programmers, with easy functions for accomplishing most common testing tasks like providing input. Use with Python >=3.9 for best results, but it should be compatible with Python >=3.6.
+Version: 3.1.2
+Summary: Very simple testing framework suitable for beginner programmers, with easy functions for accomplishing most common testing tasks like providing input. Requires Python 3.8+.
 Home-page: https://cs.wellesley.edu/~pmwh/optimism/docs/optimism.html
 Author: Peter Mawhorter
 Author-email: pmawhort@wellesley.edu
@@ -14,7 +14,7 @@ Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
 Classifier: Natural Language :: English
 Classifier: Topic :: Education
-Requires-Python: >=3.6
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Provides-Extra: test

optimism-3.1.2/optimism/__init__.py

@@ -0,0 +1,21 @@
+"""
+This package init just imports everything from optimism.py, including
+explicitly the version number (which otherwise would be skipped since it
+starts with '_'). That way, importing optimism-the-package is the same as
+importing optimism-the-file, except that private variables are not
+exported by the package. So you can distribute the package OR just the
+optimism.py file and both should work the same.
+"""
+
+from .optimism import *
+
+# Setuptools versions on Python 3.10 won't allow us to just import the
+# version from optimism, but we want the version to be defined in that
+# file so that a single-file distribution is equivalent to this packaged
+# distribution. So we define a version here as well, but...
+__version__ = "3.1.2"
+
+# ...then we assert it matches so testing will catch it if I forget to
+# keep them in sync before a release. T_T
+from .optimism import __version__ as match
+assert __version__ == match

optimism-3.1.2/optimism/examples/a.txt

@@ -0,0 +1,2 @@
+abc
+def

optimism-3.1.2/optimism/examples/b.txt

@@ -0,0 +1,3 @@
+1
+2
+3

optimism-3.1.2/optimism/examples/bad.py

@@ -0,0 +1,6 @@
+def f():
+    """
+    Function which crashes.
+    """
+    z = 3 / 0
+    print(z)

optimism-3.1.2/optimism/examples/basic.py

@@ -0,0 +1,72 @@
+"""
+Basic demonstration of optimism core testing functionality.
+"""
+
+import optimism
+
+
+# Simple example function
+def f(x, y):
+    "Example function"
+    return x + y + 1
+
+
+# Simple test for that function
+t = optimism.testFunction(f)
+t.case(1, 2).checkReturnValue(4)  # line 16
+
+
+# Function that prints multiple lines of output
+def display(message):
+    print("The message is:")
+    print('-' + message + '-')
+
+
+# Multi-line output test
+t = optimism.testFunction(display)
+t.case('hello').checkPrintedLines('The message is:', '-hello-')  # line 27
+
+
+def askNameAge():
+    "A function that uses input."
+    name = input("What is your name? ")
+    age = input("How old are you? ")
+    return (name, age)
+
+
+# One test case with specific inputs that checks both the return value
+# and what is printed
+test = optimism.testFunction(askNameAge)  # line 39
+case = test.case()
+case.provideInputs("Name", "thirty")
+case.checkReturnValue(('Name', 'thirty'))  # line 42
+case.checkPrintedLines(  # line 43
+    'What is your name? Name',
+    'How old are you? thirty'  # line 45
+)
+
+optimism.showSummary()
+
+# These checks will show details about the expressions used (like the
+# value of x):
+x = 3
+y = 4
+optimism.testFunction(f).case(x + x, y).checkReturnValue(10)  # fails (is 11)
+optimism.expect(f(x + x, y), 10)  # fails; shows x
+
+# Increase detail level
+optimism.detailLevel(1)
+
+c = optimism.testFunction(display).case('nope')
+c.checkReturnValue(False)  # fails (result is None)
+c.checkPrintedLines('The message is:', '-nope-')  # succeeds
+
+optimism.detailLevel(0)
+c.checkPrintedLines('The message is:', '-yep-')  # fails
+
+# For loop test
+for x in range(3):
+    t = optimism.testFunction(f).case(x, x).checkReturnValue(5)
+    # fails except when x == 2
+
+optimism.showSummary()

optimism-3.1.2/optimism/examples/bits.py

@@ -0,0 +1,28 @@
+import optimism as opt
+
+x = [1, 2, 3]
+y = [4, 5, 6]
+x.append(y)
+
+opt.detailLevel(1)
+
+opt.expect(x, [1, 2, 3, [4, 5, 6]])
+
+y.pop()
+opt.expect(x, [1, 2, 3, [4, 5]])
+opt.expect(x[3], y)
+opt.expect(x[3][-1], 5)
+
+x.pop()
+opt.expect(x, [1, 2, 3])
+opt.expect(x[1], 2)
+
+opt.expect(x, [1, 2, 3])
+x.pop()
+opt.expect(x, [1, 2])
+
+# This... doesn't work
+opt.expect(x[-1], x.pop())
+
+opt.expectType(x, list)
+opt.expectType(x[0], int)

optimism-3.1.2/optimism/examples/block.py

@@ -0,0 +1,30 @@
+import optimism as opt
+
+x = 3
+
+m = opt.testBlock(
+    """\
+print(x)
+x += 1
+print(x)"""
+)
+c = m.case()
+c.checkPrintedLines('3', '4')
+c.checkVariableValue('x', 5)
+c = m.case(x=5)
+c.checkPrintedLines('5', '6')
+c.checkVariableValue('x', 6)
+
+
+m = opt.testBlock(
+    """\
+x = 3
+print(x)
+x += 1
+print(x)
+x += 1"""
+)
+c = m.case()
+c.checkPrintedLines('3', '4')
+c.checkVariableValue('x', 5)
+c.checkVariableValue('x', 6)

optimism-3.1.2/optimism/examples/catch_and_release.py

@@ -0,0 +1,44 @@
+import optimism as opt
+
+
+def interactive():
+    """
+    An interactive function for testing purposes.
+    """
+    x = input('Y?')
+    print(x + ' Z!')
+    return x
+
+
+# Call it once before testing
+interactive()
+
+m = opt.testFunction(interactive)
+c = m.case()
+c.provideInputs('Q')
+c.checkPrintedLines('Y?Q', 'Q Z!')
+c.checkReturnValue('Q')
+
+c = m.case()
+c.provideInputs('A')
+c.checkPrintedLines('Y?A', 'A Z!')
+c.checkReturnValue('A')
+
+c = m.case()
+c.provideInputs('A')
+c.provideInputs('B') # this is okay, and redefines the inputs
+c.checkPrintedLines('Y?B', 'B Z!')
+c.checkReturnValue('B')
+
+
+# This isn't allowed
+try:
+    c.provideInputs('N')
+except opt.TestError:
+    print("Re-providing input was blocked.")
+
+# Does input/output capturing mess with this?
+print("Hello")
+
+# Call it again after releasing input & output
+interactive()

optimism-3.1.2/optimism/examples/code.py

@@ -0,0 +1,96 @@
+"""
+Basic demonstration of optimism code-structure checking functionality.
+"""
+
+import optimism
+
+optimism.skipChecksAfterFail(None)
+
+
+def askNameAge():
+    "A function that uses input."
+    name = input("What is your name? ")
+    age = input("How old are you? ")
+    return (name, age)
+
+
+# Test manager for that function
+tester = optimism.testFunction(askNameAge)
+
+# A structural check to ensure that the above function uses `input`
+tester.checkCodeContains(optimism.Call('input'))
+
+# Checks with bounds on the number of use sites
+tester.checkCodeContains(optimism.Call('input', min=2))
+tester.checkCodeContains(optimism.Call('input', n=2))
+tester.checkCodeContains(optimism.Call('input', max=2))
+
+# A simple loop that uses print multiple times
+for x in range(4):
+    print(x)
+
+# Some operators
+if x < 3:
+    print(x not in (1, 2, 3))
+
+
+# Tester for this file
+fileTester = optimism.testFile(__file__)
+
+fileTester.checkCodeContains(optimism.Def())  # succeeds
+fileTester.checkCodeContains(optimism.Def('askNameAge'))  # succeeds
+fileTester.checkCodeContains(optimism.Def('functionName'))  # fails
+
+fileTester.checkCodeContains(optimism.Def().contains(optimism.Return()))  # ✓
+fileTester.checkCodeContains(optimism.Def().contains(optimism.Loop()))  # ✗
+fileTester.checkCodeContains(optimism.Loop().contains(optimism.Def()))  # ✗
+fileTester.checkCodeContains(optimism.Loop(only="while"))  # ✗
+fileTester.checkCodeContains(optimism.Loop(only="for"))  # ✓
+
+fileTester.checkCodeContains(
+    optimism.Loop().contains(optimism.Call('print'))
+)  # ✓
+fileTester.checkCodeContains(
+    optimism.Loop().contains(optimism.Call('range'))
+)  # ✓
+fileTester.checkCodeContains(
+    optimism.Loop().contains(optimism.Call('print', n=1))
+)  # ✓
+fileTester.checkCodeContains(
+    optimism.Loop().contains(optimism.Call('print', n=4))
+)  # ✗
+fileTester.checkCodeContains(
+    optimism.Loop().contains(optimism.Call('print', min=4))
+)  # ✗
+fileTester.checkCodeContains(
+    optimism.Loop().contains(optimism.Call('print', max=1))
+)  # ✓
+fileTester.checkCodeContains(
+    optimism.Loop().contains(optimism.Call('print', max=0))
+)  # ✗
+fileTester.checkCodeContains(
+    optimism.Loop().contains(optimism.Call('notCalled', min=0))
+)  # ✓
+
+fileTester.checkCodeContains(
+    optimism.IfElse().contains(optimism.Operator('<'))
+)  # ✓
+fileTester.checkCodeContains(
+    optimism.IfElse().contains(optimism.Operator('>'))
+)  # ✗
+fileTester.checkCodeContains(
+    optimism.IfElse().contains(optimism.Operator('in'))
+)  # ✓
+fileTester.checkCodeContains(
+    optimism.IfElse().contains(optimism.Operator('not in'))
+)  # ✓
+
+# Testing constant matching w/ types/values
+('a', 2, 5.0)
+fileTester.checkCodeContains(optimism.Constant('a'))  # ✓
+fileTester.checkCodeContains(optimism.Constant(2))  # ✓
+fileTester.checkCodeContains(optimism.Constant(4.0 / 2))  # ✓
+fileTester.checkCodeContains(optimism.Constant(4.0 / 2, float))  # ✗
+fileTester.checkCodeContains(optimism.Constant(4.0 / 2, int))  # ✓
+fileTester.checkCodeContains(optimism.Constant(5.0, int))  # ✗
+fileTester.checkCodeContains(optimism.Constant(5.0, float))  # ✓

optimism-3.1.2/optimism/examples/core.py

@@ -0,0 +1,40 @@
+from optimism import *
+
+# Simple example function
+def f(x, y):
+    "Example function"
+    return x + y + 1
+
+# Simple test for that function
+test = testFunction(f) # line 9
+case = test.case(1, 2)
+case.checkReturnValue(3) # line 11
+
+
+# Function that prints multiple lines of output
+def display(message):
+    print("The message is:")
+    print('-' + message + '-')
+
+
+# One test case with two lines of output
+test = testFunction(display) # line 20
+case = test.case('hello')
+case.checkPrintedLines('The message is:', '-hello-') # line 22
+
+
+# A function that uses input
+def askNameAge():
+    name = input("What is your name? ")
+    age = input("How old are you? ")
+    return (name, age)
+
+
+test = testFunction(askNameAge) # line 31
+case = test.case()
+case.provideInputs("Name", "thirty")
+case.checkReturnValue(('Name', 'thirty')) # line 34
+case.checkPrintedLines(
+    'What is your name? Name',
+    'How old are you? thirty' # line 37
+)

optimism-3.1.2/optimism/examples/doc_example.py

@@ -0,0 +1,34 @@
+"""
+Module docstring.
+
+>>> 5
+5
+"""
+
+def f():
+    """
+    Inner docstring.
+
+    >>> f()
+    5
+    """
+    return 5
+
+
+class C:
+    """
+    Class docstring.
+
+    >>> C().c(10)
+    5
+    """
+
+    def c(self, n):
+        """
+        Method docstring.
+
+        >>> c = C()  # counts as an example
+        >>> c.c(10)  # not a duplicate; different AST
+        5
+        """
+        return n // 2