def test_objcol_select(): StrType = fundamental_type.get("Str") # delegate有り col = ObjectCollection() col.push("apple", Object(StrType, "リンゴ")) col.push("gorilla", Object(StrType, "ゴリラ")) col.push("trumpet", Object(StrType, "ラッパ")) col.set_delegation(Object(StrType, "コレクション")) ColType = fundamental_type.get("ObjectCollection") om = select_method("apple", ColType, reciever=col) assert om assert om.display() == ("ObjectMember", "apple", "") # メソッドの移譲 dm = select_method("startswith", ColType, reciever=col) assert dm assert dm.display() == ("ObjectMember", "startswith", "") # delegate無し col.set_delegation(None) om = select_method("gorilla", ColType, reciever=col) assert om assert om.display() == ("ObjectMember", "gorilla", "")
def test_method_loading(): Str = fundamental_type.get("Str") newmethod = Str.select_method("reg-match") assert newmethod assert newmethod.is_loaded() assert newmethod.get_name() == "reg-match" assert newmethod.get_param_count() == 1 assert newmethod.params[0].is_required() assert newmethod.get_required_argument_min() == 1 assert newmethod.get_acceptable_argument_max() == 1 assert newmethod.is_type_bound() is True Type = fundamental_type.get("Type") newmethod = Type.select_method("new") assert newmethod assert newmethod.is_loaded() assert newmethod.get_name() == "new" assert newmethod.get_param_count() == 0 assert newmethod.get_required_argument_min() == 0 assert newmethod.get_acceptable_argument_max() == 0 assert newmethod.is_type_bound() is True t = fundamental_type.define(SomeValue) newmethod = t.select_method("perimeter") assert newmethod.get_param_count() == 0 assert newmethod.get_name() == "perimeter" assert not newmethod.is_type_bound()
def test_context(): from machaon.core.object import ObjectCollection from machaon.core.invocation import InvocationContext from machaon.types.fundamental import fundamental_type inputs = ObjectCollection() inputs.new("this-year", fundamental_type.get("Int"), 2020) inputs.new("this-month", fundamental_type.get("Int"), 8) inputs.new("customer-name", fundamental_type.get("Str"), "Yokomizo") context = InvocationContext(input_objects=inputs, type_module=fundamental_type) return context
def test_scoped_define(): types = TypeModule() assert not hasattr(SpecStrType, "Type_typename") spec_str_t = types.define(SpecStrType, typename="Str", scope="spec") assert spec_str_t is not None assert spec_str_t.is_scope("spec") assert spec_str_t.typename == "Str" assert spec_str_t.get_value_type() is SpecStrType assert spec_str_t.get_describer_qualname( ) == "tests.test_object_type.SpecStrType" assert getattr(SpecStrType, "Type_typename") == "spec.Str" assert not spec_str_t.is_methods_type_bound() assert spec_str_t.is_methods_instance_bound() assert not spec_str_t.is_using_instance_method() str_t = types.define(fundamental_type.get("Str")) assert types.get("Str", scope="spec") is spec_str_t assert types.get("Str") is str_t # enum typelist = list(types.enum()) assert len(typelist) == 2 assert typelist[0] is spec_str_t # 追加順で取り出される assert typelist[1] is str_t
def ltest(s, subject, *rhs): from machaon.core.object import ObjectCollection, Object from machaon.core.invocation import InvocationContext from machaon.types.fundamental import fundamental_type context = InvocationContext(input_objects=ObjectCollection(), type_module=fundamental_type) engine = MessageEngine(s) returned = engine.run(context) if returned.is_error(): spi = TempSpirit() returned.pprint(spi) spi.printout() assert parse_test(engine, context, returned.get_typename(), "Function") fundamental_type.define({ "Typename": "Dog", "name": ("Returns: Str", lambda x: "lucky"), "type": ("Returns: Str", lambda x: "Golden Retriever"), "sex": ("Returns: Str", lambda x: "female"), "age": ("Returns: Int", lambda x: 3), }) subcontext = context.inherit() subj = Object(fundamental_type.get("Dog"), subject) fn = returned.value lhso = fn.run_function(subj, subcontext) assert parse_test(fn, subcontext, lhso, rhs[0]) # 再入 lhso = fn.run_function(subj, subcontext) assert parse_test(fn, subcontext, lhso, rhs[0])
def test_any(): anytype = fundamental_type.get("Any") assert anytype.is_loaded() assert anytype.is_any() assert anytype.value_type is None inst = Dummy_Rabbit() assert anytype.convert_to_string(inst) == anytype.describer.stringify( anytype, inst)
def test_bind1st(): StrType = fundamental_type.get("Str") cxt = instant_context() meth = StrType.select_method("reg-match") oinv = TypeMethodInvocation(StrType, meth) inv = Bind1stInvocation(oinv, "[A-Za-z]+", "str") arg = cxt.new_object("aiueo", type="str") assert inv.prepare_invoke(cxt, arg)._invokeaction() is True
def test_anyobject_method_select(): AnyType = fundamental_type.get("Any") im = select_method("instance-method", AnyType) assert im assert im.display() == ("InstanceMethod", "instance_method", "") gm = select_method("<", AnyType) assert gm assert gm.display() == ("TypeMethod", "GenericMethods:less", "")
def test_method(): regmatch = fundamental_type.get("Str").select_method("reg-match") assert regmatch is not None assert regmatch.name == "reg-match" assert regmatch.get_result().get_typename() == "Bool" act = regmatch.get_action() assert act(None, "0123.txt", "[0-9]+") assert not act(None, "AIUEO.wav", "[0-9]+") assert regmatch.get_action_target() == "Str:reg-match"
def test_fundamental(): Int = fundamental_type.get("int") assert Int.typename == "Int" assert Int.construct(None, "32") == 32 assert Int.convert_to_string(32) == "32" assert Int.convert_to_string(0xFF) == "255" Bool = fundamental_type.get("bool") assert Bool.typename == "Bool" assert Bool.construct(None, "False") is False Float = fundamental_type.get("float") assert Float.typename == "Float" assert Float.construct(None, "-0.05") == -0.05 Complex = fundamental_type.get("complex") assert Complex.typename == "Complex" assert Complex.construct(None, "2+3j") == 2 + 3j Str = fundamental_type.get("str") assert Str.typename == "Str" assert Str.construct(None, "AAA") == "AAA"
def test_straight_select(): StrType = fundamental_type.get("Str") tm = select_method("reg-match", StrType) assert tm assert tm.display() == ("TypeMethod", "Str:reg-match", "") im = select_method("startswith", StrType) assert im assert im.display() == ("InstanceMethod", "startswith", "") gm = select_method("+", StrType) assert gm assert gm.display() == ("TypeMethod", "GenericMethods:add", "")
def test_typemodule_move(): new_typeset = TypeModule() new_typeset.define(typename="AltString") new_typeset.define(Dummy_Rabbit, typename="Second-Rabbit") fundamental_type.add_ancestor(new_typeset) assert fundamental_type.get("Int").construct(None, "0x35") == 0x35 assert fundamental_type.get("AltString").typename == "AltString" assert fundamental_type.get("Dummy_Rabbit") is not None assert fundamental_type.get("Dummy_Rabbit").typename == "Dummy-Rabbit" assert fundamental_type.get( "Dummy_Rabbit" ).describer.describe_count == 2 # Dummy-Rabbit, Second-Rabbitの両方で呼ばれる assert fundamental_type.get("Second_Rabbit") is not None assert fundamental_type.get("Second_Rabbit").typename == "Second-Rabbit"
def test_deduce(): assert fundamental_type.deduce(int) is fundamental_type.get("Int") assert fundamental_type.deduce(str) is fundamental_type.get("Str") assert fundamental_type.deduce(float) is fundamental_type.get("Float") assert fundamental_type.deduce(complex) is fundamental_type.get("Complex") assert fundamental_type.deduce(bool) is fundamental_type.get("Bool") assert fundamental_type.deduce(ValueError) is None types = TypeModule() spec_str_t = types.define(SpecStrType, scope="spec") str_t = types.define(fundamental_type.get("Str")) assert types.deduce(str) is str_t assert types.deduce(SpecStrType) is spec_str_t
def test_modified_select(): StrType = fundamental_type.get("Str") tm = select_method("!reg-search", StrType) assert tm assert tm.display() == ("TypeMethod", "Str:reg-search", "negate") im = select_method("!startswith", StrType) assert im assert im.display() == ("InstanceMethod", "startswith", "negate") gm = select_method("~in", StrType) assert gm assert gm.display() == ("TypeMethod", "GenericMethods:is-in", "reverse-args") gm = select_method("`=", StrType) assert gm assert gm.display() == ("TypeMethod", "GenericMethods:identical", "basic")
def test_function(): fntype = fundamental_type.get("Function") fnpower = fntype.construct(None, "@ * @") assert fnpower from machaon.core.message import MessageEngine assert isinstance(fnpower, MessageEngine)
import pytest from machaon.core.object import Object, ObjectCollection from machaon.types.fundamental import fundamental_type Int = fundamental_type.get("Int") Float = fundamental_type.get("Float") Complex = fundamental_type.get("Complex") def run(f): f() def test_desktop(): desk = ObjectCollection() desk.push("obj-1", Object(Int, 100)) desk.push("obj-2", Object(Int, 7)) desk.push("obj-3", Object(Complex, 3 + 5j)) # desk.push("obj-4", Object(fundamental_type.new("IpAddress"), "128.0.0.1")) assert desk.get("obj-1").value == 100 def test_object_new(): desk = ObjectCollection() o = desk.new("obj-new", Int, 128) assert o.name == "obj-new" assert o.value == 128 assert o.type == Int
def test_method_alias(): Str = fundamental_type.get("Str") newmethod1 = Str.select_method("location") newmethod2 = Str.select_method("loc") assert newmethod1 is newmethod2
def test_typemodule_get(): assert fundamental_type.get("Dummy_Rabbit").typename == "Dummy-Rabbit" assert fundamental_type.get(Dummy_Rabbit).typename == "Dummy-Rabbit" assert fundamental_type.get(Dummy_Rabbit).describer.describe_count == 1
def test_objectref(): StrType = fundamental_type.get("Str") cxt = instant_context() col = ObjectCollection() col.push("apple", Object(StrType, "リンゴ")) col.push("gorilla", Object(StrType, "ゴリラ")) col.push("trumpet", Object(StrType, "ラッパ")) arg = fundamental_type.get("ObjectCollection").new_object(col) inv = ObjectMemberInvocation("apple") assert inv.prepare_invoke(cxt, arg)._invokeaction().value == "リンゴ" assert isinstance(inv._resolved, ObjectMemberGetterInvocation) assert inv.get_min_arity() == 0 assert inv.get_max_arity() == 0 assert inv.get_parameter_spec(0) is None assert inv.get_result_spec().get_typename() == "Str" inv = ObjectMemberInvocation("trumpet") assert inv.prepare_invoke(cxt, arg)._invokeaction().value == "ラッパ" # generic method (Collectionを参照する) inv = ObjectMemberInvocation("=") assert full_qualified_name( type(inv.prepare_invoke( cxt, arg)._invokeaction())) == "machaon.core.object.Object" assert inv.prepare_invoke( cxt, arg)._invokeaction().get_typename() == "ObjectCollection" # delegation col.set_delegation(Object(StrType, "math.pi")) inv = ObjectMemberInvocation("gorilla") assert inv.prepare_invoke(cxt, arg)._invokeaction().value == "ゴリラ" # unary type method import math inv = ObjectMemberInvocation("pyvalue") assert inv.prepare_invoke(cxt, arg)._invokeaction() == math.pi assert isinstance(inv._resolved, TypeMethodInvocation) assert inv.get_min_arity() == 0 assert inv.get_max_arity() == 0 assert inv.get_parameter_spec(0) is None assert inv.get_result_spec().get_typename() == "Any" # unary instance method inv = ObjectMemberInvocation("islower") assert inv.prepare_invoke(cxt, arg)._invokeaction() is True assert isinstance(inv._resolved, InstanceMethodInvocation) # unary generic method inv = ObjectMemberInvocation("length") assert inv.prepare_invoke(cxt, arg)._invokeaction() == len("math.pi") assert isinstance(inv._resolved, TypeMethodInvocation) # binary type method inv = ObjectMemberInvocation("reg-match") assert inv.prepare_invoke( cxt, arg, StrType.new_object("[A-z]+"))._invokeaction() is True assert isinstance(inv._resolved, TypeMethodInvocation) assert inv.get_min_arity() == 1 assert inv.get_max_arity() == 1 assert inv.get_result_spec().get_typename() == "Bool" # generic method (移譲先のオブジェクトを参照する) inv = ObjectMemberInvocation("=") assert full_qualified_name( type(inv.prepare_invoke( cxt, arg)._invokeaction())) == "machaon.core.object.Object" assert inv.prepare_invoke(cxt, arg)._invokeaction().get_typename() == "Str" # generic method (明示的にCollectionを参照する) inv = ObjectMemberInvocation("=", BasicInvocation.MOD_BASE_RECIEVER) assert full_qualified_name( type(inv.prepare_invoke( cxt, arg)._invokeaction())) == "machaon.core.object.Object" assert inv.prepare_invoke( cxt, arg)._invokeaction().get_typename() == "ObjectCollection"