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)