// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the Apache 2.0 License.
// See the LICENSE file in the project root for more information.
using System.Linq.Expressions;
using System.Numerics;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Dynamic;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
#if FEATURE_REMOTING
using System.Security.Policy;
#endif
using System.Text;
using System.Threading;
#if FEATURE_WPF
using System.Windows.Markup;
#endif
using Microsoft.Scripting;
using Microsoft.Scripting.Generation;
using Microsoft.Scripting.Hosting;
using Microsoft.Scripting.Runtime;
using IronPython;
using IronPython.Hosting;
using IronPython.Runtime;
using IronPython.Runtime.Exceptions;
using IronPython.Runtime.Operations;
using IronPython.Runtime.Types;
using NUnit.Framework;
#if FEATURE_WPF
using DependencyObject = System.Windows.DependencyObject;
#endif
[assembly: ExtensionType(typeof(IronPythonTest.IFooable), typeof(IronPythonTest.FooableExtensions))]
namespace IronPythonTest {
internal class Common {
public static string RootDirectory;
public static string RuntimeDirectory;
public static string ScriptTestDirectory;
public static string InputTestDirectory;
static Common() {
RuntimeDirectory = Path.GetDirectoryName(typeof(PythonContext).Assembly.Location);
RootDirectory = FindRoot();
ScriptTestDirectory = Path.Combine(RootDirectory, "Tests");
InputTestDirectory = Path.Combine(ScriptTestDirectory, "Inputs");
}
private static string FindRoot() {
// we start at the current directory and look up until we find the "Src" directory
var current = System.Reflection.Assembly.GetExecutingAssembly().Location;
var found = false;
while (!found && !string.IsNullOrEmpty(current)) {
var test = Path.Combine(current, "Src", "StdLib", "Lib");
if (Directory.Exists(test)) {
return current;
}
current = Path.GetDirectoryName(current);
}
return string.Empty;
}
}
public static class TestHelpers {
public static LanguageContext GetContext(CodeContext context) {
return context.LanguageContext;
}
public static int HashObject(object o) {
return o.GetHashCode();
}
}
public delegate int IntIntDelegate(int arg);
public delegate string RefStrDelegate(ref string arg);
public delegate int RefIntDelegate(ref int arg);
public delegate T GenericDelegate(U arg1, V arg2);
#if FEATURE_WPF
[ContentProperty("Content")]
public class XamlTestObject : DependencyObject {
public event IntIntDelegate Event;
public int Method(int arg) {
if (Event != null)
return Event(arg);
return -1;
}
public object Content {
get;
set;
}
}
[ContentProperty("Content")]
[RuntimeNameProperty("MyName")]
public class InnerXamlTextObject : DependencyObject {
public object Content {
get;
set;
}
public string MyName {
get;
set;
}
}
[ContentProperty("Content")]
[RuntimeNameProperty("Name")]
public class InnerXamlTextObject2 : DependencyObject {
public object Content {
get;
set;
}
public string Name {
get;
set;
}
}
#endif
public class ClsPart {
public int Field;
private int m_property;
public int Property { get { return m_property; } set { m_property = value; } }
public event IntIntDelegate Event;
public int Method(int arg) {
if (Event != null)
return Event(arg);
else
return -1;
}
// Private members
#pragma warning disable 169
// This field is accessed from the test
private int privateField;
private int privateProperty { get { return m_property; } set { m_property = value; } }
private event IntIntDelegate privateEvent;
private int privateMethod(int arg) {
if (privateEvent != null)
return privateEvent(arg);
else
return -1;
}
private static int privateStaticMethod() {
return 100;
}
#pragma warning restore 169
}
internal class InternalClsPart {
#pragma warning disable 649
// This field is accessed from the test
internal int Field;
#pragma warning restore 649
private int m_property;
internal int Property { get { return m_property; } set { m_property = value; } }
internal event IntIntDelegate Event;
internal int Method(int arg) {
if (Event != null)
return Event(arg);
else
return -1;
}
}
public class EngineTest
#if FEATURE_REMOTING
: MarshalByRefObject
#endif
{
private readonly ScriptEngine _pe;
private readonly ScriptRuntime _env;
public EngineTest() {
// Load a script with all the utility functions that are required
// pe.ExecuteFile(InputTestDirectory + "\\EngineTests.py");
_env = Python.CreateRuntime();
_pe = _env.GetEngine("py");
}
// Used to test exception thrown in another domain can be shown correctly.
public void Run(string script) {
ScriptScope scope = _env.CreateScope();
_pe.CreateScriptSourceFromString(script, SourceCodeKind.File).Execute(scope);
}
private static readonly string clspartName = "clsPart";
#if FEATURE_REMOTING
// [Test] // https://github.com/IronLanguages/ironpython3/issues/904
public void ScenarioHostingHelpers() {
AppDomain remote = AppDomain.CreateDomain("foo");
Dictionary options = new Dictionary();
// DLR ScriptRuntime options
options["Debug"] = true;
options["PrivateBinding"] = true;
// python options
options["StripDocStrings"] = true;
options["Optimize"] = true;
options["RecursionLimit"] = 42;
options["WarningFilters"] = new string[] { "warnonme" };
ScriptEngine engine1 = Python.CreateEngine();
ScriptEngine engine2 = Python.CreateEngine(AppDomain.CurrentDomain);
ScriptEngine engine3 = Python.CreateEngine(remote);
TestEngines(null, new ScriptEngine[] { engine1, engine2, engine3 });
ScriptEngine engine4 = Python.CreateEngine(options);
ScriptEngine engine5 = Python.CreateEngine(AppDomain.CurrentDomain, options);
ScriptEngine engine6 = Python.CreateEngine(remote, options);
TestEngines(options, new ScriptEngine[] { engine4, engine5, engine6 });
ScriptRuntime runtime1 = Python.CreateRuntime();
ScriptRuntime runtime2 = Python.CreateRuntime(AppDomain.CurrentDomain);
ScriptRuntime runtime3 = Python.CreateRuntime(remote);
TestRuntimes(null, new ScriptRuntime[] { runtime1, runtime2, runtime3 });
ScriptRuntime runtime4 = Python.CreateRuntime(options);
ScriptRuntime runtime5 = Python.CreateRuntime(AppDomain.CurrentDomain, options);
ScriptRuntime runtime6 = Python.CreateRuntime(remote, options);
TestRuntimes(options, new ScriptRuntime[] { runtime4, runtime5, runtime6 });
}
private void TestEngines(Dictionary options, ScriptEngine[] engines) {
foreach (ScriptEngine engine in engines) {
TestEngine(engine, options);
TestRuntime(engine.Runtime, options);
}
}
private void TestRuntimes(Dictionary options, ScriptRuntime[] runtimes) {
foreach (ScriptRuntime runtime in runtimes) {
TestRuntime(runtime, options);
TestEngine(Python.GetEngine(runtime), options);
}
}
private void TestEngine(ScriptEngine scriptEngine, Dictionary options) {
// basic smoke tests that the engine is alive and working
Assert.That(42, Is.EqualTo((int)(object)scriptEngine.Execute("42")));
if (options != null) {
// TODO:
#pragma warning disable 618 // obsolete API
PythonOptions po = (PythonOptions)Microsoft.Scripting.Hosting.Providers.HostingHelpers.CallEngine(
scriptEngine,
(lc, obj) => lc.Options,
null
);
#pragma warning restore 618
Assert.That(true, Is.EqualTo(po.StripDocStrings));
Assert.That(true, Is.EqualTo(po.Optimize));
Assert.That(42, Is.EqualTo(po.RecursionLimit));
Assert.That("warnonme", Is.EqualTo(po.WarningFilters[0]));
}
Assert.That("cli", Is.EqualTo(Python.GetSysModule(scriptEngine).GetVariable("platform")));
Assert.That(true, Is.EqualTo(Python.GetBuiltinModule(scriptEngine).GetVariable("True")));
if (System.Environment.OSVersion.Platform == System.PlatformID.Unix) {
Assert.That(0, Is.EqualTo(Python.ImportModule(scriptEngine, "posix").GetVariable("F_OK")));
} else {
Assert.That(0, Is.EqualTo(Python.ImportModule(scriptEngine, "nt").GetVariable("F_OK")));
}
Assert.Throws(() => {
Python.ImportModule(scriptEngine, "non_existant_module");
});
}
private void TestRuntime(ScriptRuntime runtime, Dictionary options) {
// basic smoke tests that the runtime is alive and working
runtime.Globals.SetVariable("hello", 42);
Assert.That(runtime.GetEngine("py"), Is.Not.Null);
if (options != null) {
Assert.That(true, Is.EqualTo(runtime.Setup.DebugMode));
Assert.That(true, Is.EqualTo(runtime.Setup.PrivateBinding));
}
Assert.That("cli", Is.EqualTo(Python.GetSysModule(runtime).GetVariable("platform")));
Assert.That(true, Is.EqualTo(Python.GetBuiltinModule(runtime).GetVariable("True")));
if (System.Environment.OSVersion.Platform == System.PlatformID.Unix) {
Assert.That(0, Is.EqualTo(Python.ImportModule(runtime, "posix").GetVariable("F_OK")));
} else {
Assert.That(0, Is.EqualTo(Python.ImportModule(runtime, "nt").GetVariable("F_OK")));
}
Assert.Throws(() => {
Python.ImportModule(runtime, "non_existant_module");
});
}
#endif
public class ScopeDynamicObject : DynamicObject {
internal readonly Dictionary _members = new Dictionary();
public override bool TryGetMember(GetMemberBinder binder, out object result) {
return _members.TryGetValue(binder.Name, out result);
}
public override bool TrySetMember(SetMemberBinder binder, object value) {
_members[binder.Name] = value;
return true;
}
public override bool TryDeleteMember(DeleteMemberBinder binder) {
return _members.Remove(binder.Name);
}
}
public class ScopeDynamicObject2 : ScopeDynamicObject {
public readonly object __doc__ = null;
}
public class ScopeDynamicObject3 : ScopeDynamicObject {
public object __doc__ {
get {
return null;
}
}
}
public class ScopeDynamicObject4 : ScopeDynamicObject {
private object _doc;
public object __doc__ {
get {
return _doc;
}
set {
_doc = value;
}
}
}
public class ScopeDynamicObject5 : ScopeDynamicObject {
public object __doc__;
}
public class ScopeDynamicObject6 : ScopeDynamicObject {
public void __doc__() {
}
}
public class ScopeDynamicObject7 : ScopeDynamicObject {
public class __doc__ {
}
}
public class ScopeDynamicObject8 : ScopeDynamicObject {
#pragma warning disable 67
public event EventHandler __doc__;
#pragma warning restore 67
}
[Test]
public void ScenarioDynamicObjectAsScope() {
var engine = Python.CreateEngine();
// tests where __doc__ gets assigned into the members dictionary
foreach (var myScope in new ScopeDynamicObject[] { new ScopeDynamicObject(), new ScopeDynamicObject2(), new ScopeDynamicObject3(), new ScopeDynamicObject6(), new ScopeDynamicObject7(), new ScopeDynamicObject8() }) {
var scope = engine.CreateScope(myScope);
engine.Execute(@"
x = 42", scope);
var source = engine.CreateScriptSourceFromString("x = 42", SourceCodeKind.File);
source.Compile().Execute(scope);
Assert.That(true, Is.EqualTo(myScope._members.ContainsKey("__doc__")));
Assert.That(true, Is.EqualTo(myScope._members.ContainsKey("x")));
Assert.That(true, Is.EqualTo(myScope._members.ContainsKey("__file__")));
source = engine.CreateScriptSourceFromString("'hello world'", SourceCodeKind.File);
source.Compile().Execute(scope);
Assert.That("hello world", Is.EqualTo(myScope._members["__doc__"]));
}
// tests where __doc__ gets assigned into a field/property
{
ScopeDynamicObject myScope = new ScopeDynamicObject4();
var scope = engine.CreateScope(myScope);
var source = engine.CreateScriptSourceFromString("'hello world'\nx=42\n", SourceCodeKind.File);
source.Compile().Execute(scope);
Assert.That("hello world", Is.EqualTo(((ScopeDynamicObject4)myScope).__doc__));
myScope = new ScopeDynamicObject5();
scope = engine.CreateScope(myScope);
source.Compile().Execute(scope);
Assert.That("hello world", Is.EqualTo(((ScopeDynamicObject5)myScope).__doc__));
}
}
[Test]
public void ScenarioCodePlex20472() {
#if NETCOREAPP
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
#endif
// This test file is encoded in Windows codepage 1251 (Cyrilic) but lacks a magic comment (PEP-263)
string fileName = Path.Combine(Path.Combine(Common.ScriptTestDirectory, "encoded_files"), "cp20472.py");
try {
_pe.CreateScriptSourceFromFile(fileName).Compile();
// The line above should have thrown a syntax exception or an import error
// because the default source file encoding is UTF-8 and there are decoding errors
throw new Exception("ScenarioCodePlex20472");
} catch (SyntaxErrorException) { }
// Opening the file with explicitly specifying the correct encoding should work
CompiledCode prog = _pe.CreateScriptSourceFromFile(fileName, Encoding.GetEncoding(1251)).Compile();
prog.Execute();
Assert.That(prog.DefaultScope.GetVariable("s"), Is.EqualTo("\u041F\u0436\u0451"));
}
[Test]
public void ScenarioInterpreterNestedVariables() {
ParameterExpression arg = Expression.Parameter(typeof(object), "tmp");
var argBody = Expression.Lambda>(
Expression.RuntimeVariables(
arg
),
arg
);
var vars = CompilerHelpers.LightCompile(argBody)(42);
Assert.That(42, Is.EqualTo(vars[0]));
ParameterExpression tmp = Expression.Parameter(typeof(object), "tmp");
var body = Expression.Lambda>(
Expression.Block(
Expression.Block(
new[] { tmp },
Expression.Assign(tmp, Expression.Constant(42, typeof(object)))
),
Expression.Block(
new[] { tmp },
tmp
)
)
);
Assert.That(ClrModule.IsNetCoreApp || ClrModule.IsMono ? (object)42 : null, Is.EqualTo(body.Compile()())); // https://github.com/IronLanguages/ironpython3/issues/908
Assert.That(null, Is.EqualTo(CompilerHelpers.LightCompile(body)()));
body = Expression.Lambda>(
Expression.Block(
Expression.Block(
new[] { tmp },
Expression.Block(
Expression.Assign(tmp, Expression.Constant(42, typeof(object))),
Expression.Block(
new[] { tmp },
tmp
)
)
)
)
);
Assert.That(null, Is.EqualTo(CompilerHelpers.LightCompile(body)()));
Assert.That(null, Is.EqualTo(body.Compile()()));
}
public class TestCodePlex23562 {
public bool MethodCalled = false;
public TestCodePlex23562() {
}
public void TestMethod() {
MethodCalled = true;
}
}
[Test]
public void ScenarioCodePlex23562() {
string pyCode = @"
test = TestCodePlex23562()
test.TestMethod()
";
var scope = _pe.CreateScope();
scope.SetVariable("TestCodePlex23562", typeof(TestCodePlex23562));
_pe.Execute(pyCode, scope);
TestCodePlex23562 temp = scope.GetVariable("test");
Assert.That(temp.MethodCalled);
}
[Test]
public void ScenarioCodePlex18595() {
string pyCode = @"
str_tuple = ('ab', 'cd')
str_list = ['abc', 'def', 'xyz']
py_func_called = False
def py_func():
global py_func_called
py_func_called = True
";
var scope = _pe.CreateScope();
_pe.Execute(pyCode, scope);
IList str_tuple = scope.GetVariable>("str_tuple");
Assert.That(2, Is.EqualTo(str_tuple.Count));
IList str_list = scope.GetVariable>("str_list");
Assert.That(3, Is.EqualTo(str_list.Count));
VoidDelegate py_func = scope.GetVariable("py_func");
py_func();
Assert.That(true, Is.EqualTo(scope.GetVariable("py_func_called")));
}
[Test]
public void ScenarioCodePlex24077() {
string pyCode = @"
class K(object):
def __init__(self, a, b, c):
global A, B, C
A = a
B = b
C = c
";
var scope = _pe.CreateScope();
_pe.Execute(pyCode, scope);
object KKlass = scope.GetVariable("K");
object[] Kparams = new object[] { 1, 3.14, "abc" };
_pe.Operations.CreateInstance(KKlass, Kparams);
Assert.That(1, Is.EqualTo(scope.GetVariable("A")));
}
// Execute
[Test]
public void ScenarioExecute() {
ClsPart clsPart = new ClsPart();
ScriptScope scope = _env.CreateScope();
scope.SetVariable(clspartName, clsPart);
// field: assign and get back
_pe.Execute("clsPart.Field = 100", scope);
_pe.Execute("if 100 != clsPart.Field: raise AssertionError('test failed')", scope);
Assert.That(clsPart.Field, Is.EqualTo(100));
// property: assign and get back
_pe.Execute("clsPart.Property = clsPart.Field", scope);
_pe.Execute("if 100 != clsPart.Property: raise AssertionError('test failed')", scope);
Assert.That(clsPart.Property, Is.EqualTo(100));
// method: Event not set yet
_pe.Execute("a = clsPart.Method(2)", scope);
_pe.Execute("if -1 != a: raise AssertionError('test failed')", scope);
// method: add python func as event handler
_pe.Execute("def f(x) : return x * x", scope);
_pe.Execute("clsPart.Event += f", scope);
_pe.Execute("a = clsPart.Method(2)", scope);
_pe.Execute("if 4 != a: raise AssertionError('test failed')", scope);
// ===============================================
// reset the same variable with instance of the same type
scope.SetVariable(clspartName, new ClsPart());
_pe.Execute("if 0 != clsPart.Field: raise AssertionError('test failed')", scope);
// add cls method as event handler
scope.SetVariable("clsMethod", new IntIntDelegate(Negate));
_pe.Execute("clsPart.Event += clsMethod", scope);
_pe.Execute("a = clsPart.Method(2)", scope);
_pe.Execute("if -2 != a: raise AssertionError('test failed')", scope);
// ===============================================
// reset the same variable with integer
scope.SetVariable(clspartName, 1);
_pe.Execute("if 1 != clsPart: raise AssertionError('test failed')", scope);
Assert.That(1, Is.EqualTo((int)(object)scope.GetVariable(clspartName)));
ScriptSource su = _pe.CreateScriptSourceFromString("");
Assert.Throws(() => {
su.Execute(null);
});
}
[Test]
public static void ScenarioTryGetMember() {
var engine = Python.CreateEngine();
var str = ClrModule.GetPythonType(typeof(string));
object result;
Assert.That(true, Is.EqualTo(engine.Operations.TryGetMember(str, "Equals", out result)));
Assert.That("IronPython.Runtime.Types.BuiltinFunction", Is.EqualTo(result.ToString()));
}
[Test]
public static void ScenarioComprehensionScope() {
var engine = Python.CreateEngine();
var scope = engine.CreateScope();
var source = engine.CreateScriptSourceFromString("assert [lambda: i for i in [1,2]][0]() == 2");
var compiledCode = source.Compile();
compiledCode.Execute(scope);
}
[Test]
public static void ScenarioComprehensionScopeGlobal() {
var engine = Python.CreateEngine();
var source = engine.CreateScriptSourceFromString("assert [lambda: i for i in global_list][0]() == res");
var compiledCode = source.Compile();
var scope = engine.CreateScope();
scope.SetVariable("global_list", new[] { 1, 2 });
scope.SetVariable("res", 2);
compiledCode.Execute(scope);
}
[Test]
public static void ScenarioInterfaceExtensions() {
var engine = Python.CreateEngine();
engine.Runtime.LoadAssembly(typeof(Fooable).Assembly);
ScriptSource src = engine.CreateScriptSourceFromString("x.Bar()");
ScriptScope scope = engine.CreateScope();
scope.SetVariable("x", new Fooable());
Assert.That("Bar Called", Is.EqualTo((object)src.Execute(scope)));
}
private class MyInvokeMemberBinder : InvokeMemberBinder {
public MyInvokeMemberBinder(string name, CallInfo callInfo)
: base(name, false, callInfo) {
}
public override DynamicMetaObject FallbackInvokeMember(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion) {
return errorSuggestion ?? new DynamicMetaObject(
Expression.Constant("FallbackInvokeMember"),
target.Restrictions.Merge(BindingRestrictions.Combine(args)).Merge(target.Restrict(target.LimitType).Restrictions)
);
}
public override DynamicMetaObject FallbackInvoke(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion) {
return new DynamicMetaObject(
Expression.Dynamic(new MyInvokeBinder(CallInfo), typeof(object), Microsoft.Scripting.Utils.DynamicUtils.GetExpressions(Microsoft.Scripting.Utils.ArrayUtils.Insert(target, args))),
target.Restrictions.Merge(BindingRestrictions.Combine(args))
);
}
}
private class MyInvokeBinder : InvokeBinder {
public MyInvokeBinder(CallInfo callInfo)
: base(callInfo) {
}
public override DynamicMetaObject FallbackInvoke(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion) {
return new DynamicMetaObject(
Expression.Call(
typeof(String).GetMethod("Concat", new Type[] { typeof(object), typeof(object) }),
Expression.Constant("FallbackInvoke"),
target.Expression
),
BindingRestrictionsHelpers.GetRuntimeTypeRestriction(target)
);
}
}
private class MyGetIndexBinder : GetIndexBinder {
public MyGetIndexBinder(CallInfo args)
: base(args) {
}
public override DynamicMetaObject FallbackGetIndex(DynamicMetaObject target, DynamicMetaObject[] indexes, DynamicMetaObject errorSuggestion) {
return new DynamicMetaObject(
Expression.Call(
typeof(String).GetMethod("Concat", new Type[] { typeof(object), typeof(object) }),
Expression.Constant("FallbackGetIndex"),
indexes[0].Expression
),
BindingRestrictionsHelpers.GetRuntimeTypeRestriction(target)
);
}
}
private class MySetIndexBinder : SetIndexBinder {
public MySetIndexBinder(CallInfo args)
: base(args) {
}
public override DynamicMetaObject FallbackSetIndex(DynamicMetaObject target, DynamicMetaObject[] indexes, DynamicMetaObject value, DynamicMetaObject errorSuggestion) {
return new DynamicMetaObject(
Expression.Call(
typeof(String).GetMethod("Concat", new Type[] { typeof(object), typeof(object), typeof(object) }),
Expression.Constant("FallbackSetIndex"),
indexes[0].Expression,
value.Expression
),
BindingRestrictionsHelpers.GetRuntimeTypeRestriction(target)
);
}
}
private class MyGetMemberBinder : GetMemberBinder {
public MyGetMemberBinder(string name)
: base(name, false) {
}
public override DynamicMetaObject FallbackGetMember(DynamicMetaObject target, DynamicMetaObject errorSuggestion) {
return new DynamicMetaObject(
Expression.Constant("FallbackGetMember"),
BindingRestrictionsHelpers.GetRuntimeTypeRestriction(target)
);
}
}
private class MyInvokeBinder2 : InvokeBinder {
public MyInvokeBinder2(CallInfo args)
: base(args) {
}
public override DynamicMetaObject FallbackInvoke(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion) {
Expression[] exprs = new Expression[args.Length + 1];
exprs[0] = Expression.Constant("FallbackInvoke");
for (int i = 0; i < args.Length; i++) {
exprs[i + 1] = args[i].Expression;
}
return new DynamicMetaObject(
Expression.Call(
typeof(String).GetMethod("Concat", new Type[] { typeof(object[]) }),
Expression.NewArrayInit(
typeof(object),
exprs
)
),
BindingRestrictionsHelpers.GetRuntimeTypeRestriction(target)
);
}
}
private class MyConvertBinder : ConvertBinder {
private object _result;
public MyConvertBinder(Type type) : this(type, "Converted") {
}
public MyConvertBinder(Type type, object result)
: base(type, true) {
_result = result;
}
public override DynamicMetaObject FallbackConvert(DynamicMetaObject target, DynamicMetaObject errorSuggestion) {
return new DynamicMetaObject(
Expression.Constant(_result),
BindingRestrictionsHelpers.GetRuntimeTypeRestriction(target)
);
}
}
private class MyUnaryBinder : UnaryOperationBinder {
public MyUnaryBinder(ExpressionType et)
: base(et) {
}
public override DynamicMetaObject FallbackUnaryOperation(DynamicMetaObject target, DynamicMetaObject errorSuggestion) {
return new DynamicMetaObject(
Expression.Constant("UnaryFallback"),
BindingRestrictionsHelpers.GetRuntimeTypeRestriction(target)
);
}
}
private void TestTarget(object sender, EventArgs args) {
}
[Test]
public void ScenarioDocumentation() {
ScriptScope scope = _pe.CreateScope();
ScriptSource src = _pe.CreateScriptSourceFromString(@"
import System
import clr
def f0(a, b): pass
def f1(a, *b): pass
def f2(a, **b): pass
def f3(a, *b, **c): pass
class C:
m0 = f0
m1 = f1
m2 = f2
m3 = f3
def __init__(self):
self.foo = 42
class SC(C): pass
inst = C()
class NC(object):
m0 = f0
m1 = f1
m2 = f2
m3 = f3
def __init__(self):
self.foo = 42
class SNC(NC): pass
ncinst = C()
class EmptyNC(object): pass
enc = EmptyNC()
m0 = C.m0
m1 = C.m1
m2 = C.m2
m3 = C.m3
i = int
", SourceCodeKind.File);
var doc = _pe.GetService();
src.Execute(scope);
scope.SetVariable("dlg", new EventHandler(TestTarget));
object f0 = scope.GetVariable("f0");
object f1 = scope.GetVariable("f1");
object f2 = scope.GetVariable("f2");
object f3 = scope.GetVariable("f3");
object dlg = scope.GetVariable("dlg");
object m0 = scope.GetVariable("m0");
object m1 = scope.GetVariable("m1");
object m2 = scope.GetVariable("m2");
object m3 = scope.GetVariable("m3");
var tests = new[] {
new {
Obj=f0,
Result = new [] {
new[] {
new { ParamName="a", ParamAttrs = ParameterFlags.None },
new { ParamName="b", ParamAttrs = ParameterFlags.None }
}
}
},
new {
Obj=f1,
Result = new [] {
new[] {
new { ParamName="a", ParamAttrs = ParameterFlags.None },
new { ParamName="b", ParamAttrs = ParameterFlags.ParamsArray }
}
}
},
new {
Obj=f2,
Result = new [] {
new[] {
new { ParamName="a", ParamAttrs = ParameterFlags.None },
new { ParamName="b", ParamAttrs = ParameterFlags.ParamsDict}
}
}
},
new {
Obj=f3,
Result = new [] {
new [] {
new { ParamName="a", ParamAttrs = ParameterFlags.None},
new { ParamName="b", ParamAttrs = ParameterFlags.ParamsArray},
new { ParamName="c", ParamAttrs = ParameterFlags.ParamsDict}
}
}
},
new {
Obj=dlg,
Result = new [] {
new [] {
new { ParamName="sender", ParamAttrs = ParameterFlags.None},
new { ParamName="e", ParamAttrs = ParameterFlags.None},
}
}
},
new {
Obj=m0,
Result = new [] {
new[] {
new { ParamName="a", ParamAttrs = ParameterFlags.None },
new { ParamName="b", ParamAttrs = ParameterFlags.None }
}
}
},
new {
Obj=m1,
Result = new [] {
new[] {
new { ParamName="a", ParamAttrs = ParameterFlags.None },
new { ParamName="b", ParamAttrs = ParameterFlags.ParamsArray }
}
}
},
new {
Obj=m2,
Result = new [] {
new[] {
new { ParamName="a", ParamAttrs = ParameterFlags.None },
new { ParamName="b", ParamAttrs = ParameterFlags.ParamsDict}
}
}
},
new {
Obj=m3,
Result = new [] {
new [] {
new { ParamName="a", ParamAttrs = ParameterFlags.None},
new { ParamName="b", ParamAttrs = ParameterFlags.ParamsArray},
new { ParamName="c", ParamAttrs = ParameterFlags.ParamsDict}
}
}
},
};
foreach (var test in tests) {
var result = new List(doc.GetOverloads(test.Obj));
Assert.That(test.Result.Length, Is.EqualTo(result.Count));
for (int i = 0; i < result.Count; i++) {
var received = result[i]; ;
var expected = test.Result[i];
Assert.That(expected.Length, Is.EqualTo(received.Parameters.Count));
var recvParams = new List(received.Parameters);
for (int j = 0; j < expected.Length; j++) {
var receivedParam = recvParams[j];
var expectedParam = expected[j];
Assert.That(expectedParam.ParamAttrs, Is.EqualTo(receivedParam.Flags));
Assert.That(expectedParam.ParamName, Is.EqualTo(receivedParam.Name));
}
}
}
object inst = scope.GetVariable("inst");
object ncinst = scope.GetVariable("ncinst");
object klass = scope.GetVariable("C");
object newklass = scope.GetVariable("NC");
object subklass = scope.GetVariable("SC");
object subnewklass = scope.GetVariable("SNC");
object System = scope.GetVariable("System");
object clr = scope.GetVariable("clr");
foreach (object o in new[] { inst, ncinst }) {
var members = doc.GetMembers(o);
ContainsMemberName(members, "m0", MemberKind.Method);
ContainsMemberName(members, "foo", MemberKind.None);
}
ContainsMemberName(doc.GetMembers(klass), "m0", MemberKind.Method);
ContainsMemberName(doc.GetMembers(newklass), "m0", MemberKind.Method);
ContainsMemberName(doc.GetMembers(subklass), "m0", MemberKind.Method);
ContainsMemberName(doc.GetMembers(subnewklass), "m0", MemberKind.Method);
ContainsMemberName(doc.GetMembers(System), "Collections", MemberKind.Namespace);
ContainsMemberName(doc.GetMembers(clr), "AddReference", MemberKind.Function);
object intType = scope.GetVariable("i");
foreach (object o in new object[] { intType, 42 }) {
var members = doc.GetMembers(o);
ContainsMemberName(members, "__add__", MemberKind.Method);
ContainsMemberName(members, "conjugate", MemberKind.Method);
ContainsMemberName(members, "real", MemberKind.Property);
}
ContainsMemberName(doc.GetMembers(new List