def test_make_choice__anycase_accepted_case_sensitity(self):
# -- NOTE: strict=False => Disable errors due to case-mismatch.
parse_choice = TypeBuilder.make_choice(["one", "two", "three"],
strict=False)
schema = "Answer: {answer:NumberWordChoice}"
parser = parse.Parser(schema, dict(NumberWordChoice=parse_choice))
# -- PERFORM TESTS:
# NOTE: Parser uses re.IGNORECASE flag => Any case accepted.
self.assert_match(parser, "Answer: one", "answer", "one")
self.assert_match(parser, "Answer: TWO", "answer", "TWO")
self.assert_match(parser, "Answer: Three", "answer", "Three")
def test_make_choice__anycase_accepted_case_sensitity(self):
# -- NOTE: strict=False => Disable errors due to case-mismatch.
parse_choice = TypeBuilder.make_choice(["one", "two", "three"],
strict=False)
schema = "Answer: {answer:NumberWordChoice}"
parser = parse.Parser(schema, dict(NumberWordChoice=parse_choice))
# -- PERFORM TESTS:
# NOTE: Parser uses re.IGNORECASE flag => Any case accepted.
self.assert_match(parser, "Answer: one", "answer", "one")
self.assert_match(parser, "Answer: TWO", "answer", "TWO")
self.assert_match(parser, "Answer: Three", "answer", "Three")
def test_make_choice__anycase_accepted_lowercase_enforced(self):
# -- NOTE: strict=True => Enable errors due to case-mismatch.
parse_choice = TypeBuilder.make_choice(["one", "two", "three"],
transform=lambda x: x.lower(), strict=True)
schema = "Answer: {answer:NumberWordChoice}"
parser = parse.Parser(schema, dict(NumberWordChoice=parse_choice))
# -- PERFORM TESTS:
# NOTE: Parser uses re.IGNORECASE flag
# => Any case accepted, but result is in lower case.
self.assert_match(parser, "Answer: one", "answer", "one")
self.assert_match(parser, "Answer: TWO", "answer", "two")
self.assert_match(parser, "Answer: Three", "answer", "three")
def test_make_choice__anycase_accepted_lowercase_enforced(self):
# -- NOTE: strict=True => Enable errors due to case-mismatch.
parse_choice = TypeBuilder.make_choice(["one", "two", "three"],
transform=lambda x: x.lower(),
strict=True)
schema = "Answer: {answer:NumberWordChoice}"
parser = parse.Parser(schema, dict(NumberWordChoice=parse_choice))
# -- PERFORM TESTS:
# NOTE: Parser uses re.IGNORECASE flag
# => Any case accepted, but result is in lower case.
self.assert_match(parser, "Answer: one", "answer", "one")
self.assert_match(parser, "Answer: TWO", "answer", "two")
self.assert_match(parser, "Answer: Three", "answer", "three")
def test_make_choice(self):
parse_choice = TypeBuilder.make_choice(["one", "two", "three"])
parse_choice.name = "NumberWordChoice"
extra_types = self.build_type_dict([ parse_choice ])
schema = "Answer: {answer:NumberWordChoice}"
parser = parse.Parser(schema, extra_types)
# -- PERFORM TESTS:
self.assert_match(parser, "Answer: one", "answer", "one")
self.assert_match(parser, "Answer: two", "answer", "two")
self.ensure_can_parse_all_choices(parser,
parse_choice, "Answer: %s", "answer")
# -- PARSE MISMATCH:
self.assert_mismatch(parser, "Answer: __one__", "answer")
self.assert_mismatch(parser, "Answer: one ", "answer")
self.assert_mismatch(parser, "Answer: one ZZZ", "answer")
def test_make_choice(self):
parse_choice = TypeBuilder.make_choice(["one", "two", "three"])
parse_choice.name = "NumberWordChoice"
extra_types = build_type_dict([parse_choice])
schema = "Answer: {answer:NumberWordChoice}"
parser = parse.Parser(schema, extra_types)
# -- PERFORM TESTS:
self.assert_match(parser, "Answer: one", "answer", "one")
self.assert_match(parser, "Answer: two", "answer", "two")
self.ensure_can_parse_all_choices(parser, parse_choice, "Answer: %s",
"answer")
# -- PARSE MISMATCH:
self.assert_mismatch(parser, "Answer: __one__", "answer")
self.assert_mismatch(parser, "Answer: one ", "answer")
self.assert_mismatch(parser, "Answer: one ZZZ", "answer")
def test_cardinality_field_with_zero_or_one(self):
# -- SETUP:
parse_person = TypeBuilder.make_choice(["Alice", "Bob", "Charly"])
parse_person.name = "Person" # For testing only.
extra_types = build_type_dict([ parse_person ])
schema = "Optional: {person:Person?}"
parser = parse.Parser(schema, extra_types)
# -- PERFORM TESTS:
self.assert_match(parser, "Optional: ", "person", None)
self.assert_match(parser, "Optional: Alice", "person", "Alice")
self.assert_match(parser, "Optional: Bob", "person", "Bob")
# -- PARSE MISMATCH:
self.assert_mismatch(parser, "Optional: Anna", "person") # Similar1.
self.assert_mismatch(parser, "Optional: Boby", "person") # Similar2.
self.assert_mismatch(parser, "Optional: a", "person") # INVALID ...
def test_make_choice__with_transform(self):
transform = lambda x: x.upper()
parse_choice = TypeBuilder.make_choice(["ONE", "two", "Three"],
transform)
self.assertSequenceEqual(parse_choice.choices, ["ONE", "TWO", "THREE"])
schema = "Answer: {answer:NumberWordChoice}"
parser = parse.Parser(schema, dict(NumberWordChoice=parse_choice))
# -- PERFORM TESTS:
self.assert_match(parser, "Answer: one", "answer", "ONE")
self.assert_match(parser, "Answer: two", "answer", "TWO")
self.ensure_can_parse_all_choices(parser,
parse_choice, "Answer: %s", "answer")
# -- PARSE MISMATCH:
self.assert_mismatch(parser, "Answer: __one__", "answer")
self.assert_mismatch(parser, "Answer: one ", "answer")
self.assert_mismatch(parser, "Answer: one ZZZ", "answer")
def test_make_choice__with_transform(self):
transform = lambda x: x.upper()
parse_choice = TypeBuilder.make_choice(["ONE", "two", "Three"],
transform)
self.assertSequenceEqual(parse_choice.choices, ["ONE", "TWO", "THREE"])
schema = "Answer: {answer:NumberWordChoice}"
parser = parse.Parser(schema, dict(NumberWordChoice=parse_choice))
# -- PERFORM TESTS:
self.assert_match(parser, "Answer: one", "answer", "ONE")
self.assert_match(parser, "Answer: two", "answer", "TWO")
self.ensure_can_parse_all_choices(parser, parse_choice, "Answer: %s",
"answer")
# -- PARSE MISMATCH:
self.assert_mismatch(parser, "Answer: __one__", "answer")
self.assert_mismatch(parser, "Answer: one ", "answer")
self.assert_mismatch(parser, "Answer: one ZZZ", "answer")
def test_without_cardinality_field(self):
# -- IMPLCIT CARDINALITY: one
# -- SETUP:
parse_person = TypeBuilder.make_choice(["Alice", "Bob", "Charly"])
parse_person.name = "Person" # For testing only.
extra_types = build_type_dict([parse_person])
schema = "One: {person:Person}"
parser = parse.Parser(schema, extra_types)
# -- PERFORM TESTS:
self.assert_match(parser, "One: Alice", "person", "Alice")
self.assert_match(parser, "One: Bob", "person", "Bob")
# -- PARSE MISMATCH:
self.assert_mismatch(parser, "One: ", "person") # Missing.
self.assert_mismatch(parser, "One: BAlice", "person") # Similar1.
self.assert_mismatch(parser, "One: Boby", "person") # Similar2.
self.assert_mismatch(parser, "One: a", "person") # INVALID ...
def test_without_cardinality_field(self):
# -- IMPLCIT CARDINALITY: one
# -- SETUP:
parse_person = TypeBuilder.make_choice(["Alice", "Bob", "Charly"])
parse_person.name = "Person" # For testing only.
extra_types = build_type_dict([ parse_person ])
schema = "One: {person:Person}"
parser = parse.Parser(schema, extra_types)
# -- PERFORM TESTS:
self.assert_match(parser, "One: Alice", "person", "Alice")
self.assert_match(parser, "One: Bob", "person", "Bob")
# -- PARSE MISMATCH:
self.assert_mismatch(parser, "One: ", "person") # Missing.
self.assert_mismatch(parser, "One: BAlice", "person") # Similar1.
self.assert_mismatch(parser, "One: Boby", "person") # Similar2.
self.assert_mismatch(parser, "One: a", "person") # INVALID ...
def test_make_choice__samecase_match_or_error(self):
# -- NOTE: strict=True => Enable errors due to case-mismatch.
parse_choice = TypeBuilder.make_choice(["One", "TWO", "three"],
strict=True)
schema = "Answer: {answer:NumberWordChoice}"
parser = parse.Parser(schema, dict(NumberWordChoice=parse_choice))
# -- PERFORM TESTS: Case matches.
# NOTE: Parser uses re.IGNORECASE flag => Any case accepted.
self.assert_match(parser, "Answer: One", "answer", "One")
self.assert_match(parser, "Answer: TWO", "answer", "TWO")
self.assert_match(parser, "Answer: three", "answer", "three")
# -- PERFORM TESTS: EXACT-CASE MISMATCH
case_mismatch_input_data = ["one", "ONE", "Two", "two", "Three" ]
for input_value in case_mismatch_input_data:
input_text = "Answer: %s" % input_value
with self.assertRaises(ValueError):
parser.parse(input_text)
class step_definitons:
def __init__(self):
pass
@Given('I go to the meeting')
def given_step_impl(context):
print('>>>>>> In given step implementation')
# parsing with split and making as list
def parse_list(parameters):
param_list = parameters.split(",")
# param_list = TypeBuilder.with_one_or_more(parameters, listsep=",")
return param_list
register_type(List=parse_list)
@When('I meet {persons:List}')
def step_impl(context, persons):
print(">>>>> Step Implementation of list of parameters")
for person in persons:
print("Met with people: ", person)
@When(u'I want to meet {a+}{names}')
def step_impl(context, names):
print(">>>>> Implementing cardinality.")
print(type(names))
for name in names:
print('want to meet ppl: ', name)
# getting list using make choice predefined
parse_list = TypeBuilder.make_choice(["Alice", "Bob", "Charly", "Dodo"])
# register_type(mylist=parse_list)
list_input = TypeBuilder.with_one_or_more(parse_list, listsep=",")
register_type(list_names=list_input)
@When('I test cardinality with {names:list_names}')
def step_impl(context, names):
print(
">>>>> Step Implementation of list of parameters with TypeBuilder")
print(type(names))
for name in names:
print(">>>>>> Names in list: ", name)
def test_with_one_or_more_choice(self):
parse_color = TypeBuilder.make_choice(["red", "green", "blue"])
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", [ "green" ])
self.assert_match(parser, "List: red, green", "colors", [ "red", "green" ])
# -- 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_choice__samecase_match_or_error(self):
# -- NOTE: strict=True => Enable errors due to case-mismatch.
parse_choice = TypeBuilder.make_choice(["One", "TWO", "three"],
strict=True)
schema = "Answer: {answer:NumberWordChoice}"
parser = parse.Parser(schema, dict(NumberWordChoice=parse_choice))
# -- PERFORM TESTS: Case matches.
# NOTE: Parser uses re.IGNORECASE flag => Any case accepted.
self.assert_match(parser, "Answer: One", "answer", "One")
self.assert_match(parser, "Answer: TWO", "answer", "TWO")
self.assert_match(parser, "Answer: three", "answer", "three")
# -- PERFORM TESTS: EXACT-CASE MISMATCH
case_mismatch_input_data = ["one", "ONE", "Two", "two", "Three"]
for input_value in case_mismatch_input_data:
input_text = "Answer: %s" % input_value
with self.assertRaises(ValueError):
parser.parse(input_text)
def test_cardinality_field_with_zero_or_one(self):
# -- SETUP:
parse_person = TypeBuilder.make_choice(["Alice", "Bob", "Charly"])
parse_person.name = "Person" # For testing only.
extra_types = build_type_dict([parse_person])
schema = "Optional: {person:Person?}"
parser = parse.Parser(schema, extra_types)
# -- PERFORM TESTS:
self.assert_match(parser, "Optional: ", "person", None)
self.assert_match(parser, "Optional: Alice", "person", "Alice")
self.assert_match(parser, "Optional: Bob", "person", "Bob")
# -- PARSE MISMATCH:
self.assert_mismatch(parser, "Optional: Anna",
"person") # Similar1.
self.assert_mismatch(parser, "Optional: Boby",
"person") # Similar2.
self.assert_mismatch(parser, "Optional: a",
"person") # INVALID ...
def test_cardinality_field_with_one_or_more(self):
# -- SETUP:
parse_person = TypeBuilder.make_choice(["Alice", "Bob", "Charly"])
parse_person.name = "Person" # For testing only.
extra_types = build_type_dict([ parse_person ])
schema = "List: {persons:Person+}"
parser = parse.Parser(schema, extra_types)
# -- PERFORM TESTS:
self.assert_match(parser, "List: Alice", "persons", [ "Alice" ])
self.assert_match(parser, "List: Bob", "persons", [ "Bob" ])
self.assert_match(parser, "List: Bob, Alice",
"persons", [ "Bob", "Alice" ])
# -- PARSE MISMATCH:
self.assert_mismatch(parser, "List: ", "persons") # Zero items.
self.assert_mismatch(parser, "List: BAlice", "persons") # Unknown1.
self.assert_mismatch(parser, "List: Boby", "persons") # Unknown2.
self.assert_mismatch(parser, "List: Alice,", "persons") # Trailing,
self.assert_mismatch(parser, "List: a, b", "persons") # List of...
def test_cardinality_field_with_one_or_more(self):
# -- SETUP:
parse_person = TypeBuilder.make_choice(["Alice", "Bob", "Charly"])
parse_person.name = "Person" # For testing only.
extra_types = build_type_dict([parse_person])
schema = "List: {persons:Person+}"
parser = parse.Parser(schema, extra_types)
# -- PERFORM TESTS:
self.assert_match(parser, "List: Alice", "persons", ["Alice"])
self.assert_match(parser, "List: Bob", "persons", ["Bob"])
self.assert_match(parser, "List: Bob, Alice", "persons",
["Bob", "Alice"])
# -- PARSE MISMATCH:
self.assert_mismatch(parser, "List: ", "persons") # Zero items.
self.assert_mismatch(parser, "List: BAlice",
"persons") # Unknown1.
self.assert_mismatch(parser, "List: Boby", "persons") # Unknown2.
self.assert_mismatch(parser, "List: Alice,",
"persons") # Trailing,
self.assert_mismatch(parser, "List: a, b", "persons") # List of...
from behave import *
from hamcrest import assert_that, equal_to
from vec3 import Vec3, vec3
from vec4 import Vec4, point, vector
import numpy as np
from shape import material, sphere, test_shape, default_world, point_light, glass_sphere
from base import hit, EPSILON, equal, World, render, translation, scaling, view_transform, intersection, intersections, prepare_computations, world, camera, color, rotation_y, rotation_z, rotation_x
from parse_type import TypeBuilder
from step_helper import *
valid_test_objects = ["light"]
parse_test_object = TypeBuilder.make_choice(valid_test_objects)
register_type(TestObject=parse_test_object)
valid_test_variables = ["intensity", "position"]
parse_test_variable = TypeBuilder.make_choice(valid_test_variables)
register_type(TestVariable=parse_test_variable)
valid_light_elements = ["position", "intensity"]
parse_light_element = TypeBuilder.make_choice(valid_light_elements)
register_type(LightElement=parse_light_element)
@given("{item:TestVariable} ← color({r:g}, {g:g}, {b:g})")
def step_impl_color_assign(context, item, r, g, b):
ensure_context_has_tuple(context)
context.tuple[item] = color(float(r), float(g), float(b))
@given("{item:TestVariable} ← point({x:g}, {y:g}, {z:g})")
def step_impl_point_assign(context, item, x, y, z):
from behave import *
from hamcrest import assert_that, equal_to
import base
from parse_type import TypeBuilder
import numpy as np
from step_helper import *
valid_test_matrices = ["m"]
parse_test_matrix = TypeBuilder.make_choice(valid_test_matrices)
register_type(TestMatrix=parse_test_matrix)
valid_vec4_extensions = ["x", "y", "z", "w"]
parse_vec4_extension = TypeBuilder.make_choice(valid_vec4_extensions)
register_type(Vec4Ext=parse_vec4_extension)
valid_test_variables = ["origin", "direction", "m"]
parse_test_variable = TypeBuilder.make_choice(valid_test_variables)
register_type(TestVariable=parse_test_variable)
valid_test_rays = ["r", "r2"]
parse_test_ray = TypeBuilder.make_choice(valid_test_rays)
register_type(TestRay=parse_test_ray)
valid_ray_elements = ["origin", "direction"]
parse_ray_element = TypeBuilder.make_choice(valid_ray_elements)
register_type(RayElement=parse_ray_element)
@given(u'{item:TestVariable} ← point({x:g}, {y:g}, {z:g})')
def step_impl_generic_point(context, item, x, y, z):
ensure_context_has_tuple(context)
from behave import *
from hamcrest import assert_that, equal_to
from parse_type import TypeBuilder
from memblock import *
from step_helper import *
valid_test_variables = ["c", "c1", "c2"]
parse_test_variable = TypeBuilder.make_choice(valid_test_variables)
register_type(TestVariable=parse_test_variable)
valid_color_extensions = ["red", "green", "blue"]
parse_color_extension = TypeBuilder.make_choice(valid_color_extensions)
register_type(ColorExt=parse_color_extension)
valid_test_scalar_operations = ["*", "/", "+", "-"]
parse_test_scalar_operation = TypeBuilder.make_choice(
valid_test_scalar_operations)
register_type(TestScalarOperation=parse_test_scalar_operation)
valid_test_add_operations = ["+", "-"]
parse_test_add_operation = TypeBuilder.make_choice(valid_test_add_operations)
register_type(TestAddOperation=parse_test_add_operation)
@given("{item:TestVariable} ← color({x:g}, {y:g}, {z:g})")
def step_impl_color(context, item, x, y, z):
ensure_context_has_tuple(context)
context.tuple[item] = Vec3(np.float32(x), np.float32(y), np.float32(z))
@then("{item:TestVariable}.{part:ColorExt} = {value:g}")
Scenario:
Given I go to a shop to buy ingredients for a meal
And I buy apples
And I buy beef
"""
# @mark.user_defined_types
# ------------------------------------------------------------------------
# USER-DEFINED TYPES:
# ------------------------------------------------------------------------
from behave import matchers
from parse_type import TypeBuilder
# -- CHOICE: Constrain to a list of supported items (as string).
offered_shop_items = [ "apples", "beef", "potatoes", "pork" ]
parse_shop_item = TypeBuilder.make_choice(offered_shop_items)
matchers.register_type(ShopItem=parse_shop_item)
# @mark.steps
# ----------------------------------------------------------------------------
# STEPS:
# ----------------------------------------------------------------------------
from behave import given, when, then
@given(u"I go to a shop to buy ingredients for a meal")
def step_given_I_go_to_a_shop(context):
context.shopping_cart = [ ]
@when(u"I buy {shop_item:ShopItem}")
def step_when_I_buy(context, shop_item):
assert shop_item in offered_shop_items
def test_with_optional__choice(self):
# -- ALIAS FOR: zero_or_one
parse_color = TypeBuilder.make_choice(["red", "green", "blue"])
parse_opt_color = TypeBuilder.with_optional(parse_color)
self.check_parse_choice_with_optional(parse_opt_color)
ScrollUp = "scroll up"
ScrollDown = "scroll down"
class States:
Visible = "visible"
Showing = "showing"
def get_property_values(target):
values = []
for i in dir(target):
value = getattr(target, i)
if isinstance(value, str):
values.append(value)
return values
behave.register_type(Role=TypeBuilder.make_choice(get_property_values(Roles)))
behave.register_type(
Action=TypeBuilder.make_choice(get_property_values(Actions)))
behave.register_type(
State=TypeBuilder.make_choice(get_property_values(States)))
@parse.with_pattern(r"\s*\"[^\"]+\"\s*")
def parse_name(text: str):
return text.strip(" \t\n\r\"")
behave.register_type(Name=parse_name)
"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"])
parse_person_choice.name = "PersonChoice" # For testing only.
# -----------------------------------------------------------------------------
# ABSTRACT TEST CASE:
# -----------------------------------------------------------------------------
class TestCase(unittest.TestCase):
# -- PYTHON VERSION BACKWARD-COMPATIBILTY:
if not hasattr(unittest.TestCase, "assertIsNone"):
def assertIsNone(self, obj, msg=None):
self.assert_(obj is None, msg)
def assertIsNotNone(self, obj, msg=None):
self.assert_(obj is not None, msg)
# DOMAIN MODEL:
# ----------------------------------------------------------------------------
class Meeting(object):
def __init__(self):
self.persons = set()
# @mark.user_defined_types
# ------------------------------------------------------------------------
# USER-DEFINED TYPES:
# ------------------------------------------------------------------------
from behave import matchers
from parse_type import TypeBuilder
company_persons = [ "Alice", "Bob", "Charly", "Dodo" ]
parse_person = TypeBuilder.make_choice(company_persons)
matchers.register_type(Person=parse_person)
# -- MANY-TYPE: Persons := list<Person> with list-separator = "and"
# parse_persons = TypeBuilder.with_one_or_more(parse_person, listsep="and")
parse_persons = TypeBuilder.with_many(parse_person, listsep="and")
matchers.register_type(PersonAndMore=parse_persons)
# @mark.steps
# ----------------------------------------------------------------------------
# STEPS:
# ----------------------------------------------------------------------------
from behave import given, when, then
# -- MANY-VARIANT 1: Use Cardinality field in parse expression (comma-separated)
from behave import given, when, then, step, register_type
from parse_type import TypeBuilder
import sfctss
from sfctss.scheduler.examples import GreedyShortestDeadlineFirstScheduler, LoadUnawareRoundRobinScheduler, RejectScheduler
SCHEDULER_GREEDY_ORACLE = "GreedyOracle"
SCHEDULER_GREEDY_LOCAL = "GreedyLocal"
SCHEDULER_STATIC = "Static"
SCHEDULER_REJECT = "Reject"
schedulers = [
SCHEDULER_GREEDY_ORACLE, SCHEDULER_GREEDY_LOCAL, SCHEDULER_STATIC,
SCHEDULER_REJECT
]
parse_scheduler = TypeBuilder.make_choice(schedulers)
register_type(Scheduler=parse_scheduler)
DO = 'do'
DO_NOT = 'do not'
do_do_not = [DO, DO_NOT]
parse_do_do_not = TypeBuilder.make_choice(do_do_not)
register_type(DoDoNot=parse_do_do_not)
default_config = {
'sff_bw_capacity': 1000,
'sfi_rate': 15,
'cpu_policy': 'one-at-a-time',
'individual_class_per_egress': False,
'latency_between_sites': 1000,
'latency_within_sites': 10,
from behave import * from hamcrest import assert_that, equal_to from vec3 import Vec3, vec3 from vec4 import Vec4, point, vector from base import equal import numpy as np from shape import material, sphere, test_shape, point_light, plane from base import render, translation, scaling, view_transform, world, camera, color, rotation_y, rotation_z, rotation_x from parse_type import TypeBuilder from step_helper import * valid_test_planes = ["p", "shape", "lower", "upper"] parse_test_plane = TypeBuilder.make_choice(valid_test_planes) register_type(TestPlane=parse_test_plane) valid_test_objects = ["m"] parse_test_object = TypeBuilder.make_choice(valid_test_objects) register_type(TestObject=parse_test_object) valid_intersect_list_names = ["xs"] parse_intersect_list_name = TypeBuilder.make_choice(valid_intersect_list_names) register_type(ListName=parse_intersect_list_name) valid_test_variables = ["n1", "n2", "n3"] parse_test_variable = TypeBuilder.make_choice(valid_test_variables) register_type(TestVariable=parse_test_variable) valid_test_rays = ["r"] parse_test_ray = TypeBuilder.make_choice(valid_test_rays) register_type(TestRay=parse_test_ray)
Scenario:
Given I go to a shop to buy ingredients for a meal
And I buy apples
And I buy beef
"""
# @mark.user_defined_types
# ------------------------------------------------------------------------
# USER-DEFINED TYPES:
# ------------------------------------------------------------------------
from behave import register_type
from parse_type import TypeBuilder
# -- CHOICE: Constrain to a list of supported items (as string).
offered_shop_items = [ "apples", "beef", "potatoes", "pork" ]
parse_shop_item = TypeBuilder.make_choice(offered_shop_items)
register_type(ShopItem=parse_shop_item)
# @mark.steps
# ----------------------------------------------------------------------------
# STEPS:
# ----------------------------------------------------------------------------
from behave import given, when, then
@given(u"I go to a shop to buy ingredients for a meal")
def step_given_I_go_to_a_shop(context):
context.shopping_cart = [ ]
@when(u"I buy {shop_item:ShopItem}")
def step_when_I_buy(context, shop_item):
assert shop_item in offered_shop_items
from behave import *
from hamcrest import assert_that, equal_to
from parse_type import TypeBuilder
from step_helper import *
valid_test_variables = ["c", "c1", "c2", "c3", "red"]
parse_test_variable = TypeBuilder.make_choice(valid_test_variables)
register_type(TestVariable=parse_test_variable)
valid_color_extensions = ["red", "green", "blue"]
parse_color_extension = TypeBuilder.make_choice(valid_color_extensions)
register_type(ColorExt=parse_color_extension)
valid_components = ["width", "height", "background", "data"]
parse_valid_component = TypeBuilder.make_choice(valid_components)
register_type(CanvasComponent=parse_valid_component)
@given(u'{item:TestVariable} ← canvas({width:g}, {height:g})')
def step_impl_generic_canvas(context, item, width, height):
ensure_context_has_dict(context)
context.dict[item] = canvas(int(width), int(height))
@then("{item:TestVariable}.{part:CanvasComponent} = {value:g}")
def step_then_component_equals_value(context, item, part, value):
assert part in valid_components
item_string = 'context.dict["' + str(item) + '"].' + str(part)
assert_that(eval(item_string), equal_to(float(value)))
# @mark.user_defined_types
# ------------------------------------------------------------------------
# USER-DEFINED TYPES:
# ------------------------------------------------------------------------
from behave import matchers
from parse_type import TypeBuilder
def slurp_space(text):
return text
slurp_space.pattern = r"\s*"
matchers.register_type(slurp_space=slurp_space)
parse_color = TypeBuilder.make_choice(["red", "green", "blue", "yellow"])
matchers.register_type(Color=parse_color)
# -- MANY-TYPE: Persons := list<Person> with list-separator = "and"
# parse_colors = TypeBuilder.with_many0(parse_color, listsep="and")
parse_colors0 = TypeBuilder.with_zero_or_more(parse_color, listsep="and")
matchers.register_type(OptionalColorAndMore=parse_colors0)
# @mark.steps
# ----------------------------------------------------------------------------
# STEPS:
# ----------------------------------------------------------------------------
from behave import given, when, then
# -- MANY-VARIANT 1: Use Cardinality field in parse expression (comma-separated)
})
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"])
parse_person_choice.name = "PersonChoice" # For testing only.
# -----------------------------------------------------------------------------
# ABSTRACT TEST CASE:
# -----------------------------------------------------------------------------
class TestCase(unittest.TestCase):
# -- PYTHON VERSION BACKWARD-COMPATIBILTY:
if not hasattr(unittest.TestCase, "assertIsNone"):
def assertIsNone(self, obj, msg=None):
self.assert_(obj is None, msg)
def assertIsNotNone(self, obj, msg=None):
from behave import *
from hamcrest import assert_that, equal_to
from parse_type import TypeBuilder
from step_helper import *
valid_Vec4_extensions = ["x", "y", "z", "w"]
parse_Vec4_extension = TypeBuilder.make_choice(valid_Vec4_extensions)
register_type(Vec4Ext=parse_Vec4_extension)
valid_test_variables = [
"v", "v1", "v2", "p", "a", "b", "zero", "norm", "n", "r"
]
parse_test_variable = TypeBuilder.make_choice(valid_test_variables)
register_type(TestVariable=parse_test_variable)
@given("{item:TestVariable} ← tuple({x}, {y}, {z}, {w})")
def step_impl_generic_tuple(context, item, x, y, z, w):
ensure_context_has_tuple(context)
context.tuple[item] = Vec4(np.float32(x), np.float32(y), np.float32(z),
np.float32(w))
@given(u'{item:TestVariable} ← point({x:g}, {y:g}, {z:g})')
def step_impl_generic_point(context, item, x, y, z):
ensure_context_has_tuple(context)
context.tuple[item] = point(np.float32(x), np.float32(y), np.float32(z))
@given(
u'{item:TestVariable} ← vector(√{x_numerator:g}/{x_denom:g}, √{y_numerator:g}/{y_denom:g}, {z:g})'
from behave import * from hamcrest import assert_that, equal_to from vec3 import Vec3, vec3 from vec4 import Vec4, point, vector from base import equal, normalize, transform, ray import numpy as np from shape import material, sphere, test_shape, normal_at, set_transform, intersect, glass_sphere, point_light from base import render, translation, scaling, view_transform, world, camera, color, rotation_y, rotation_z, rotation_x from parse_type import TypeBuilder from step_helper import * valid_test_solids = ["s", "s2", "s3", "shape"] parse_test_solid = TypeBuilder.make_choice(valid_test_solids) register_type(TestSolid=parse_test_solid) valid_test_objects = ["m"] parse_test_object = TypeBuilder.make_choice(valid_test_objects) register_type(TestObject=parse_test_object) valid_test_matrices = ["t", "m"] parse_test_matrix = TypeBuilder.make_choice(valid_test_matrices) register_type(TestMatrix=parse_test_matrix) valid_vec4_extensions = ["x", "y", "z", "w"] parse_vec4_extension = TypeBuilder.make_choice(valid_vec4_extensions) register_type(Vec4Ext=parse_vec4_extension) valid_test_variables = ["origin", "direction", "n"] parse_test_variable = TypeBuilder.make_choice(valid_test_variables) register_type(TestVariable=parse_test_variable)
from behave import *
from hamcrest import assert_that, equal_to
from vec3 import Vec3, vec3
from vec4 import Vec4, point, vector
import numpy as np
from shape import material, sphere, test_shape, default_world, point_light
from base import equal, intersect_world, shade_hit, is_shadowed, color_at, World, render, translation, scaling, view_transform, world, camera, color, rotation_y, rotation_z, rotation_x
from parse_type import TypeBuilder
from step_helper import *
valid_test_objects = ["cyl"]
parse_test_object = TypeBuilder.make_choice(valid_test_objects)
register_type(TestObject=parse_test_object)
valid_test_variables = ["direction", "normal", "n"]
parse_test_variable = TypeBuilder.make_choice(valid_test_variables)
register_type(TestVariable=parse_test_variable)
valid_light_elements = ["position", "intensity"]
parse_light_element = TypeBuilder.make_choice(valid_light_elements)
register_type(LightElement=parse_light_element)
valid_material_elements = [
"color", "ambient", "diffuse", "specular", "shininess", "reflective",
"transparency", "refractive_index"
]
parse_material_element = TypeBuilder.make_choice(valid_material_elements)
register_type(MaterialElement=parse_material_element)
valid_world_elements = ["light", "objects"]
parse_world_element = TypeBuilder.make_choice(valid_world_elements)
# DOMAIN MODEL:
# ----------------------------------------------------------------------------
class Meeting(object):
def __init__(self):
self.persons = set()
# @mark.user_defined_types
# ------------------------------------------------------------------------
# USER-DEFINED TYPES:
# ------------------------------------------------------------------------
from behave import matchers
from parse_type import TypeBuilder
company_persons = ["Alice", "Bob", "Charly", "Dodo"]
parse_person = TypeBuilder.make_choice(company_persons)
matchers.register_type(Person=parse_person)
# -- MANY-TYPE: Persons := list<Person> with list-separator = "and"
# parse_persons = TypeBuilder.with_one_or_more(parse_person, listsep="and")
parse_persons = TypeBuilder.with_many(parse_person, listsep="and")
matchers.register_type(PersonAndMore=parse_persons)
# @mark.steps
# ----------------------------------------------------------------------------
# STEPS:
# ----------------------------------------------------------------------------
from behave import given, when, then
# -- MANY-VARIANT 1: Use Cardinality field in parse expression (comma-separated)
def calculate_price_for_vegetable(self, vegetable, amount):
price_per_unit = self.vegetable_price_list[vegetable]
return price_per_unit*amount
def calculate_price_for(self, shop_item, amount):
price_per_unit = self.common_price_list[shop_item]
return price_per_unit*amount
# @mark.user_defined_types
# ------------------------------------------------------------------------
# USER-DEFINED TYPES:
# ------------------------------------------------------------------------
from behave import register_type
from parse_type import TypeBuilder
parse_vegetable = TypeBuilder.make_choice(["cucumbers", "lettuce"])
register_type(Vegetable=parse_vegetable)
parse_fruit = TypeBuilder.make_choice(["apples", "pears"])
register_type(Fruit=parse_fruit)
# @mark.steps
# ----------------------------------------------------------------------------
# STEPS:
# ----------------------------------------------------------------------------
from behave import given, when, then
@given(u"I go to a shop")
def step_given_I_go_to_a_shop(context):
context.shop = Shop()
context.shopping_cart = [ ]
from behave import *
from hamcrest import assert_that, equal_to
import base
from parse_type import TypeBuilder
import numpy as np
from step_helper import *
valid_test_objects = ["hsize", "vsize","field_of_view", "c", "w"]
parse_test_object = TypeBuilder.make_choice(valid_test_objects)
register_type(TestObject=parse_test_object)
valid_test_variables = ["up", "from", "to"]
parse_test_variable = TypeBuilder.make_choice(valid_test_variables)
register_type(TestVariable=parse_test_variable)
valid_camera_elements = ["hsize", "vsize", "field_of_view", "transform", "pixel_size"]
parse_camera_element = TypeBuilder.make_choice(valid_camera_elements)
register_type(CameraElement=parse_camera_element)
valid_test_rays = ["r"]
parse_test_ray = TypeBuilder.make_choice(valid_test_rays)
register_type(TestRay=parse_test_ray)
@given("{item:TestObject} ← {value_num}/{value_denom:g}")
def step_given_object_value(context, item, value_num, value_denom):
ensure_context_has_dict(context)
value_num = np.pi if value_num == "π" else float(value_num)
value_denom = float(value_denom)
context.dict[str(item)] = (value_num / value_denom)
from behave import *
from hamcrest import assert_that, equal_to
from parse_type import TypeBuilder
from step_helper import *
valid_test_matrices = ["M", "A", "B", "C", "inv", "half_quarter"]
parse_test_matrix = TypeBuilder.make_choice(valid_test_matrices)
register_type(TestMatrix=parse_test_matrix)
valid_test_variables = ["b", "a"]
parse_test_variable = TypeBuilder.make_choice(valid_test_variables)
register_type(TestVariable=parse_test_variable)
#@given("the following 4x4 matrix {item:TestVariable}: {matrix}")
@given("the following {height:g}x{width:g} matrix {item:TestMatrix}: {matrix}")
def step_impl_matrix(context, height, width, item, matrix):
ensure_context_has_dict(context)
new_matrix_string = "np.array(" + matrix + ", dtype=float)"
new_matrix = eval(new_matrix_string)
assert (new_matrix.shape == (height, width))
context.dict[item] = new_matrix
@given("{item:TestMatrix} ← transpose(identity_matrix)")
def step_identity_transpose_matrix(context, item):
ensure_context_has_dict(context)
dim = 4
new_matrix = np.identity(dim, dtype=float)
assert (new_matrix.shape == (dim, dim))
context.dict[item] = np.transpose(new_matrix)
price_per_unit = self.vegetable_price_list[vegetable]
return price_per_unit * amount
def calculate_price_for(self, shop_item, amount):
price_per_unit = self.common_price_list[shop_item]
return price_per_unit * amount
# @mark.user_defined_types
# ------------------------------------------------------------------------
# USER-DEFINED TYPES:
# ------------------------------------------------------------------------
from behave import matchers
from parse_type import TypeBuilder
parse_vegetable = TypeBuilder.make_choice(["cucumbers", "lettuce"])
matchers.register_type(Vegetable=parse_vegetable)
parse_fruit = TypeBuilder.make_choice(["apples", "pears"])
matchers.register_type(Fruit=parse_fruit)
# @mark.steps
# ----------------------------------------------------------------------------
# STEPS:
# ----------------------------------------------------------------------------
from behave import given, when, then
@given(u"I go to a shop")
def step_given_I_go_to_a_shop(context):
context.shop = Shop()
text = text[1:-1]
# first substitute any {Variable} with context.Variable
result = re.sub(r'{(?P<var>\w+)}', r'context.\g<var>', text)
if isEval:
result = eval(result)
return result
parse_numbers = TypeBuilder.with_many(parse_number, listsep=",")
parse_words = TypeBuilder.with_many(parse_word, listsep=",")
parse_hexs = TypeBuilder.with_many(parse_hex, listsep=",")
parse_one_hex = TypeBuilder.with_zero_or_one(parse_hex)
parse_is_is_not = TypeBuilder.make_choice(["is", "is NOT"])
parse_have_not_have = TypeBuilder.make_choice(["have", "NOT have"])
parse_has_does_not_have = TypeBuilder.make_choice(["has", "does NOT have"])
parse_one_context_variables = TypeBuilder.with_zero_or_one(
parse_context_variable)
type_dict = {
'd+': parse_numbers,
'w+': parse_words,
'h': parse_one_hex,
'h+': parse_hexs,
'is': parse_is_is_not,
'have': parse_have_not_have,
'has': parse_has_does_not_have,
'cv': parse_one_context_variables
}
register_type(**type_dict)
| blue |
"""
# @mark.user_defined_types
# ------------------------------------------------------------------------
# USER-DEFINED TYPES:
# ------------------------------------------------------------------------
from behave import register_type
from parse_type import TypeBuilder
def slurp_space(text):
return text
slurp_space.pattern = r"\s*"
register_type(slurp_space=slurp_space)
parse_color = TypeBuilder.make_choice([ "red", "green", "blue", "yellow" ])
register_type(Color=parse_color)
# -- MANY-TYPE: Persons := list<Person> with list-separator = "and"
# parse_colors = TypeBuilder.with_many0(parse_color, listsep="and")
parse_colors0A= TypeBuilder.with_zero_or_more(parse_color, listsep="and")
register_type(OptionalColorAndMore=parse_colors0A)
# -- NEEDED-UNTIL: parse_type.cfparse.Parser is used by behave.
# parse_colors0C = TypeBuilder.with_zero_or_more(parse_color)
# type_dict = {"Color*": parse_colors0C}
# register_type(**type_dict)
# @mark.steps
# ----------------------------------------------------------------------------
from behave import * from hamcrest import assert_that, equal_to from parse_type import TypeBuilder from step_helper import * valid_test_shapes = ["s"] parse_test_shape = TypeBuilder.make_choice(valid_test_shapes) register_type(TestShape=parse_test_shape) valid_shape_elements = ["material", "transform"] parse_shape_element = TypeBuilder.make_choice(valid_shape_elements) register_type(ShapeElement=parse_shape_element) valid_test_objects = ["m"] parse_test_object = TypeBuilder.make_choice(valid_test_objects) register_type(TestObject=parse_test_object) valid_group_objects = ["g1", "g2"] parse_group_object = TypeBuilder.make_choice(valid_group_objects) register_type(GroupObject=parse_group_object) valid_intersect_list_names = ["xs"] parse_intersect_list_name = TypeBuilder.make_choice(valid_intersect_list_names) register_type(ListName=parse_intersect_list_name) valid_test_variables = ["p", "n"] parse_test_variable = TypeBuilder.make_choice(valid_test_variables) register_type(TestVariable=parse_test_variable) valid_test_rays = ["r"] parse_test_ray = TypeBuilder.make_choice(valid_test_rays)
