def test_make_enum_with_enum_class(self):
"""
Use :meth:`parse_type.TypeBuilder.make_enum()` with enum34 classes.
"""
class Color(Enum):
red = 1
green = 2
blue = 3
parse_color = TypeBuilder.make_enum(Color)
parse_color.name = "Color"
schema = "Answer: {color:Color}"
parser = parse.Parser(schema, dict(Color=parse_color))
# -- PERFORM TESTS:
self.ensure_can_parse_all_enum_values(parser,
parse_color, "Answer: %s", "color")
# -- VALID:
self.assert_match(parser, "Answer: red", "color", Color.red)
self.assert_match(parser, "Answer: green", "color", Color.green)
self.assert_match(parser, "Answer: blue", "color", Color.blue)
# -- IGNORE-CASE: In parsing, calls type converter function !!!
self.assert_match(parser, "Answer: RED", "color", Color.red)
# -- PARSE MISMATCH:
self.assert_mismatch(parser, "Answer: __RED__", "color")
self.assert_mismatch(parser, "Answer: red ", "color")
self.assert_mismatch(parser, "Answer: redx", "color")
self.assert_mismatch(parser, "Answer: redx ZZZ", "color")
def test_make_enum_with_enum_class(self):
"""
Use :meth:`parse_type.TypeBuilder.make_enum()` with enum34 classes.
"""
class Color(Enum):
red = 1
green = 2
blue = 3
parse_color = TypeBuilder.make_enum(Color)
parse_color.name = "Color"
schema = "Answer: {color:Color}"
parser = parse.Parser(schema, dict(Color=parse_color))
# -- PERFORM TESTS:
self.ensure_can_parse_all_enum_values(parser, parse_color,
"Answer: %s", "color")
# -- VALID:
self.assert_match(parser, "Answer: red", "color", Color.red)
self.assert_match(parser, "Answer: green", "color", Color.green)
self.assert_match(parser, "Answer: blue", "color", Color.blue)
# -- IGNORE-CASE: In parsing, calls type converter function !!!
self.assert_match(parser, "Answer: RED", "color", Color.red)
# -- PARSE MISMATCH:
self.assert_mismatch(parser, "Answer: __RED__", "color")
self.assert_mismatch(parser, "Answer: red ", "color")
self.assert_mismatch(parser, "Answer: redx", "color")
self.assert_mismatch(parser, "Answer: redx ZZZ", "color")
def test_with_one_or_more_enum(self):
parse_color = TypeBuilder.make_enum({"red": 1, "green":2, "blue": 3})
parse_colors = TypeBuilder.with_one_or_more(parse_color)
parse_colors.name = "Colors"
extra_types = build_type_dict([ parse_colors ])
schema = "List: {colors:Colors}"
parser = parse.Parser(schema, extra_types)
# -- PERFORM TESTS:
self.assert_match(parser, "List: green", "colors", [ 2 ])
self.assert_match(parser, "List: red, green", "colors", [ 1, 2 ])
# -- PARSE MISMATCH:
self.assert_mismatch(parser, "List: ", "colors") # Zero items.
self.assert_mismatch(parser, "List: x", "colors") # Not a Color.
self.assert_mismatch(parser, "List: black", "colors") # Unknown
self.assert_mismatch(parser, "List: red,", "colors") # Trailing sep.
self.assert_mismatch(parser, "List: a, b", "colors") # List of ...
def test_make_enum_with_dict(self):
parse_nword = TypeBuilder.make_enum({"one": 1, "two": 2, "three": 3})
parse_nword.name = "NumberAsWord"
extra_types = build_type_dict([parse_nword])
schema = "Answer: {number:NumberAsWord}"
parser = parse.Parser(schema, extra_types)
# -- PERFORM TESTS:
self.ensure_can_parse_all_enum_values(parser, parse_nword,
"Answer: %s", "number")
# -- VALID:
self.assert_match(parser, "Answer: one", "number", 1)
self.assert_match(parser, "Answer: two", "number", 2)
# -- IGNORE-CASE: In parsing, calls type converter function !!!
self.assert_match(parser, "Answer: THREE", "number", 3)
# -- PARSE MISMATCH:
self.assert_mismatch(parser, "Answer: __one__", "number")
self.assert_mismatch(parser, "Answer: one ", "number")
self.assert_mismatch(parser, "Answer: one_", "number")
self.assert_mismatch(parser, "Answer: one ZZZ", "number")
def test_make_enum(self):
parse_nword = TypeBuilder.make_enum({"one": 1, "two": 2, "three": 3})
parse_nword.name = "NumberAsWord"
extra_types = self.build_type_dict([ parse_nword ])
schema = "Answer: {number:NumberAsWord}"
parser = parse.Parser(schema, extra_types)
# -- PERFORM TESTS:
self.ensure_can_parse_all_enum_values(parser,
parse_nword, "Answer: %s", "number")
# -- VALID:
self.assert_match(parser, "Answer: one", "number", 1)
self.assert_match(parser, "Answer: two", "number", 2)
# -- IGNORE-CASE: In parsing, calls type converter function !!!
self.assert_match(parser, "Answer: THREE", "number", 3)
# -- PARSE MISMATCH:
self.assert_mismatch(parser, "Answer: __one__", "number")
self.assert_mismatch(parser, "Answer: one ", "number")
self.assert_mismatch(parser, "Answer: one_", "number")
self.assert_mismatch(parser, "Answer: one ZZZ", "number")
turns text into an int to help make feature files nicer to read
:param text: str text to parse into an int
:return: int parsed text
"""
return int(text.strip())
parse_numbers = TypeBuilder.with_many(parse_number, listsep=',')
register_type(ListInts=parse_numbers)
true_false_mapper = {
'True': True,
'False': False
}
parse_bool = TypeBuilder.make_enum(true_false_mapper)
register_type(Boolean=parse_bool)
use_step_matcher('parse')
@when("I find the multiples of 3 and 5 under {limit:d}")
def i_find_multiples_of_3_and_5_under(context, limit):
context.limit = limit
context.sequence = find_multiples_of_3_and_5(limit)
@when("I find the fibonacci numbers under {limit:d}")
def i_find_the_fibonacci_numbers_under(context, limit):
context.limit = limit
@then(u'{expr} is the following {n:d}x{m:d} matrix')
def step_impl(context, expr, n, m):
expected = table_to_matrix(context.table)
setattr(context, "expected", expected)
context.execute_steps(f"then {expr} == expected")
assert expected.shape == (n, m)
@then(u'{expr} is the following matrix')
def step_impl(context, expr):
expected = table_to_matrix(context.table)
setattr(context, "expected", expected)
context.execute_steps(f"then {expr} == expected")
parse_is_or_is_not = TypeBuilder.make_enum({"is": True, "is not": False})
register_type(IsOrIsNot=parse_is_or_is_not)
@then(u'{name} {x:IsOrIsNot} invertible')
def step_impl(context, name, x):
_name = getattr(context, name)
if x:
assert _name.det() != 0
else:
assert _name.det() == 0
@given(u'C = A * B')
def step_impl(context):
_A = getattr(context, "A")
"Do you love me?": True,
"Do you hate me?": False,
"Do you kiss me?": True,
}
# @mark.user_defined_types
# ------------------------------------------------------------------------
# USER-DEFINED TYPES:
# ------------------------------------------------------------------------
from behave import register_type
from parse_type import TypeBuilder
# -- ENUM: Returns True (for "yes" and "jubilee"), False (for "no")
parse_yesno = TypeBuilder.make_enum({
"yes": True,
"no": False,
"jubilee": True
})
register_type(YesNo=parse_yesno)
# @mark.steps
# ----------------------------------------------------------------------------
# STEPS:
# ----------------------------------------------------------------------------
from behave import when, then
from hamcrest import assert_that, equal_to
@when(u'Romeo asks Julia: "{question}"')
def step_when_romeo_asks_julia(context, question):
context.question = question
import unittest
# -----------------------------------------------------------------------------
# TEST SUPPORT FOR: TypeBuilder Tests
# -----------------------------------------------------------------------------
# -- PROOF-OF-CONCEPT DATATYPE:
def parse_number(text):
return int(text)
parse_number.pattern = r"\d+" # Provide better regexp pattern than default.
parse_number.name = "Number" # For testing only.
# -- ENUM DATATYPE:
parse_yesno = TypeBuilder.make_enum({
"yes": True, "no": False,
"on": True, "off": False,
"true": True, "false": False,
})
parse_yesno.name = "YesNo" # For testing only.
# -- ENUM CLASS:
class Color(Enum):
red = 1
green = 2
blue = 3
parse_color = TypeBuilder.make_enum(Color)
parse_color.name = "Color"
# -- CHOICE DATATYPE:
parse_person_choice = TypeBuilder.make_choice(["Alice", "Bob", "Charly"])
# ------------------------------------------------------------------------
answer_oracle = {
"Do you love me?": True,
"Do you hate me?": False,
"Do you kiss me?": True,
}
# @mark.user_defined_types
# ------------------------------------------------------------------------
# USER-DEFINED TYPES:
# ------------------------------------------------------------------------
from behave import register_type
from parse_type import TypeBuilder
# -- ENUM: Returns True (for "yes" and "jubilee"), False (for "no")
parse_yesno = TypeBuilder.make_enum({"yes": True, "no": False, "jubilee": True})
register_type(YesNo=parse_yesno)
# @mark.steps
# ----------------------------------------------------------------------------
# STEPS:
# ----------------------------------------------------------------------------
from behave import when, then
from hamcrest import assert_that, equal_to
@when(u'Romeo asks Julia: "{question}"')
def step_when_romeo_asks_julia(context, question):
context.question = question
from behave import register_type, given, when
from parse_type import TypeBuilder
from ray_tracer.material import Material, lighting
from ray_tracer.tuples import Point
@given(u'{m} = Material()')
def step_impl(context, m):
_m = Material()
setattr(context, m, _m)
parse_bool = TypeBuilder.make_enum({"True": True, "False": False})
register_type(BoolType=parse_bool)
@when(u'{result} = lighting({material}, {object_}, {light}, Point({x:g},{y:g},{z:g}), {eyev}, {normalv}, {in_shadow:BoolType})')
def step_impl(context, result, material, object_, light, x, y, z, eyev, normalv, in_shadow):
_position = Point(x, y, z)
setattr(context, "position", _position)
context.execute_steps(f"when {result} = lighting({material}, {object_}, {light}, position, {eyev}, {normalv}, {in_shadow})")
@when(u'{result} = lighting({material}, {object_}, {light}, {position}, {eyev}, {normalv}, {in_shadow:BoolType})')
def step_impl(context, result, material, object_, light, position, eyev, normalv, in_shadow):
_material = getattr(context, material)
_object = getattr(context, object_)
_light = getattr(context, light)
_position = getattr(context, position)
import math
from behave import register_type
from parse import with_pattern
from parse_type import TypeBuilder
from ray_tracer.tuples import is_point, is_vector
parse_interesting_trig_values = TypeBuilder.make_enum({
"0": 0,
"√2/2": math.sqrt(2) / 2,
"1": 1,
"√2": math.sqrt(2),
"-√2/2": -math.sqrt(2) / 2,
"-1": -1,
"-3": -3 # This is stoopid - try to define my own parser below
})
register_type(InterestingTrigValue=parse_interesting_trig_values)
# @with_pattern(r'\g+')
# def _parse_float(text):
# return float(text)
# parse_reals = TypeBuilder.make_variant([parse_interesting_trig_values, _parse_float])
# register_type(InterestingRealNumbers=parse_reals)
parse_point_or_vector = TypeBuilder.make_enum({
"point": is_point,
"vector": is_vector,
})
register_type(ElementIn3D=parse_point_or_vector)
# -----------------------------------------------------------------------------
# TEST SUPPORT FOR: TypeBuilder Tests
# -----------------------------------------------------------------------------
# -- PROOF-OF-CONCEPT DATATYPE:
def parse_number(text):
return int(text)
parse_number.pattern = r"\d+" # Provide better regexp pattern than default.
parse_number.name = "Number" # For testing only.
# -- ENUM DATATYPE:
parse_yesno = TypeBuilder.make_enum({
"yes": True,
"no": False,
"on": True,
"off": False,
"true": True,
"false": False,
})
parse_yesno.name = "YesNo" # For testing only.
# -- ENUM CLASS:
class Color(Enum):
red = 1
green = 2
blue = 3
parse_color = TypeBuilder.make_enum(Color)
parse_color.name = "Color"
@given(u'{transform} = Scaling({x:g}, {y:g}, {z:g})')
def step_impl(context, transform, x, y, z):
_transform = Scaling(x, y, z)
setattr(context, transform, _transform)
@given(u'{name} = inverse({transform})')
def step_impl(context, name, transform):
_transform = getattr(context, transform)
inv = inverse(_transform)
setattr(context, name, inv)
parse_rotation_axis = TypeBuilder.make_enum({
"rotation_x": rotation_x,
"rotation_y": rotation_y,
"rotation_z": rotation_z
})
register_type(RotationBy=parse_rotation_axis)
@given(u'{transform} = {rotation:RotationBy}(π/{n:g})')
def step_impl(context, transform, rotation, n):
_transform = rotation(math.pi / n)
setattr(context, transform, _transform)
@given(
u'{transform} = Shearing({xy:g}, {xz:g}, {yx:g}, {yz:g}, {zx:g}, {zy:g})')
def step_impl(context, transform, xy, xz, yx, yz, zx, zy):
_transform = Shearing(xy, xz, yx, yz, zx, zy)
import os
import tempfile
import shutil
import sys
from parse_type import TypeBuilder
from behave import register_type
parse_bool = TypeBuilder.make_enum({"False": False, "True": True})
register_type(Bool=parse_bool)
def before_scenario(context, scenario):
context.tmpdir = tempfile.mkdtemp()
sys.path.append(context.tmpdir + '/output')
os.chdir(context.tmpdir)
def after_scenario(context, scenario):
sys.path.remove(context.tmpdir + '/output')
os.chdir('/')
shutil.rmtree(context.tmpdir)
import math
from behave import register_type, step, when
from parse_type import TypeBuilder
from ray_tracer.camera import Camera, ray_for_pixel, render
parse_interesting_angles = TypeBuilder.make_enum({
"0": 0,
"π/2": math.pi / 2,
"π": math.pi
})
register_type(InterestingAngle=parse_interesting_angles)
@step(u'{c} = camera({hsize:n}, {vsize:n}, {field_of_view:InterestingAngle})')
def step_impl(context, c, hsize, vsize, field_of_view):
_c = Camera(hsize, vsize, field_of_view)
setattr(context, c, _c)
@when(u'{r} = ray_for_pixel({camera}, {x:n}, {y:n})')
def step_impl(context, r, camera, x, y):
_camera = getattr(context, camera)
_r = ray_for_pixel(_camera, x, y)
setattr(context, r, _r)
@when(u'{image} = render({camera}, {world})')
def step_impl(context, image, camera, world):
_camera = getattr(context, camera)
