interop.net.method
index
e:\vslrft\dlr\languages\ironpython\tests\interop\net\method\__init__.py

General
* Where it is defined
* How it is defined
  - Static and instance 
  - Explicit interface method implementation
  - Virtual, new, override
 
Passing arguments with different parameter lists
In C#, 
    public void M1(int x, int y) { }
    public void M2(int x, params int[] y)
    public void M3(int x, [DefaultParameterValue(5)] int y)
    public void M6([Optional] int x, [Optional] object y) 
    public void M7([Out] int x) 
    public void M7([ParamsDictionary] IattributesCollection dict) 
* Methods with  
  - one of such special parameter, 
  - two of such special parameters
  - one normal, the other special parameter. And different orders.
  - 3+ parameters with mixed kind
* Where DefaultParameterValue/Optional Attributes are not the last parameters.
* Different parameter types - string, int, Boolean, Object, self-defined 
  struct, class, variables.
* Check optional (missing) value
* Argument name are language special:
  - (python) True, def
* Params as an intermediate parameter (only via params setter?  Or also via 
  IL or direct attr?)
(Python)
* try with different parameter lists:
  - positional argument, 
  - keyword argument, 
  - *tuple style, 
  - *dictionary style, 
  - Mixed of them.
* Argument for the default value parameter (provide, not provide...)
* Negative scenarios
  - "params" could not be "keyword" argument?
  - Provide parameter more than once (such as positional, and keyword...)
 
Passing arguments for By-ref parameters
In C#,
    public void M1(int x, ref int y) { ... }
    public void M2(int x, out int y) { ... }
* Methods with
  - Similar aspect as the previous scenario
  - Consider mixing with default value/ params arguments
  - Ref, out parameters are not at last.
* Same for constructor.
(Python)
* call each of them with different parameter lists (similar to previous matrix)
* pay attention to: 
  - clr.Reference
  - Whether you need pass argument
  - What kind of argument
  - Mix&match is not supported
* Negative scenarios. 
 
Method Overloads
* Related to method signatures
* Related to argument values/types
* (python?) Related to return values (specifically conversions on returns, 
  nullable types, etc...)
* Methods with different parameters
* Non-generic / generic methods have the same name 
  - Activator.CreateInstance scenario
  - G<T>.M(int), G<T>.M(T)
  - G.M(int), G.M<T>(T)
* Static method and instance method have the same name
  - instance M(C), static M(thisType, C)
* Same name as explicit interface method
 
Operator Overloading
* all supported overloads (well-behavior)
  - http://msdn2.microsoft.com/en-us/library/2sk3x8a7(vs.71).aspx 
* unary/binary overloads (not defined as usual)
  - positive
    * instance method
    * static method where the first parameter is not the declaring type
    * has CodeContext as the first argument
  - negative
    * unary operator has  0, 2, 3 parameter
    * binary operator has 0, 1, 3 parameters
* Call the operator explicitly
* Provide one-side comparison operator overload, but access the reverse-side 
  operator
* Provide simple operator overload, but call in-place operator  
* Overloads 
* Value type which has operator overloads
* Something Python is unable to practice:
  - op_Assign, ...
* Something decorated with special attribute (GetItem, GetBoundMember...)
(Python)
* __xxx__ call style
 
User-defined conversions
* TODO
 
Implicit conversion operator
* Where it is applied: only passing as argument to method
* Where it is defined:
  - Value type, reference type, generics 
* How it is defined: 
  - Instance op_Implicit method
  - Overload scenario
* (python) Implicit vs. Explicit: when do we use what
* C#: http://msdn2.microsoft.com/en-us/library/aa691280(VS.71).aspx 
  - Implicit enumeration conversions 
  - Implicit reference conversions 
  - Boxing conversions 
    * Check the pass-in value/identity?
  - User-defined implicit conversions
    * Builtin number/char/string/bool/enum -> class/struct 
    * Class/struct -> class/struct 
    * Generic types (G<T>, G<int>, GOfInt, G<K, V>)
    * Conversion among base/derived types
 
Explicit conversion operator
* Not supported by the language yet, tracking as bug 314284
* (python) __int__, __long__, __float__, __complex__, __nonzero__

 
Package Contents
       
test_arguments
test_op_explicit
test_op_implicit
test_operators
test_returnvalue