Cases

Load requires file name extension. Require can use partial name, but will try to load the .rb file first if it finds one. Dependency assemblies need to be loaded as well. Full and partial paths.

Member Modification

• Add a method
  • Public
  • Private
  • Protected
  • Overloads
  • Various numbers of args
• Add a method which conflicts with Ruby keywords
• Add an overload to an existing method
• Modify a field
  • Static field
  • Instance field
  • Readonly field
  • Volatile field
  • Const field
• Remove a property
  • Different casing (should error out)
  • Created in CLR
  • Created in Ruby
• Remove a property multiple times
• Remove a method
• Remove an existing method
• Remove a method overload (?)
• Change the visibility of an existing method
  
• Instantiate an object and use the above methods.
• Remove an interface method and test for behavior in regard to the broken interface
• Call Type.GetMembers() on a modified class to verify added/deleted members.
• Modify a property defined in an interface
• Use a property defined in an interface
• Modify a virtual method
• Attempt to use a virtual method

Special Parameter types

• Use methods 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)
  • one special parameter
  • two special parameters
  • one normal, one special in both orders
  • multiple parameters of mixed kind
• Use DefaultParameterValue/Optional attributes
  • Can optional parameters be omitted?
  • Do DefaultParameterValue’s get used?
• p2 - Parameter names that collide with keywords or methods
• Use a method with ref and out parameters in all these scenarios

Overloaded Methods

• Override interesting methods like ToString() and ensure Ruby equivalent #to_str still works.
• Add/remove an override for a base-class virtual method. Also, hide the base-class method with a new one
• Add/remove new operator overloads and verify that the operators work in ruby
• Add/remove operators for unsupported operators in Ruby
• Add/remove implicitly and explicitly implemented interfaces
• Pick an override from Ruby
• 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

Ruby Considerations

• Call existing Ruby methods from Object and Kernel on .NET objects
• Use Ruby’s mixin functionality. For example, include Enumerable and define .each, and test for the existence of other Enumerable methods
• Attempt to add a Ruby object to a typed .NET array
• Attempt to assign an object of the wrong type to a field
• Get an unbound .NET method
• Direct call of method vs. send :method vs eval method
• Members that collide with Ruby keywords
  

Indexers

• Use a default indexer from within Ruby
• Read only indexers :[]
• Write only indexers :[]=
• Indexer defined in interface
• Overloaded interface
• p2 - Indexer defined in VB style
• Parameter list on indexer

Other

• Implicit and explicit conversions in Ruby
• Return a private type
• p3 - Check for presence of private members with –X:PrivateBinding
• p2 - Operator overloading and usage
  

Events/Delegates

• Define a delegate from Ruby
• Use a delegate from Ruby
• Generic delegate types
• With overloaded method
• Add a method to a delegate
• Add a method multiple times
• Remove a method from a delegate
• Remove a repeated method from a delegate (one time should remove one occurrence)
• Remove all methods from the delegate (should be benign)
• Remove a non-existent method from a delegate with other methods (should be benign)
• Empty delegate should have an empty invocation list
• Define an event in an interface
• Define an event in a class
• Static events
• Static delegates
• Add a delegate as an event
• Remove a delegate as an event
• Remove a method as an event
• Event with Add only
• Event with Remove only
• Add a method as an event
• Add an incompatible delegate and method to an event
• Call a method with multiple delegates
  

When Ruby code calls #== and #hash

• If the object is a Ruby object, the default implementations of #== and #hash get called. The default implementations call System.Object.ReferenceEquals and System.Runtime.CompileServices.RuntimeHelpers.GetHashCode respectively.
• If the object is a CLR object, System.Object.Equals and System.Object.GetHashCode respectively get called on the CLR object.
• If the object is a Ruby subclass object inheriting from a CLR class, the CLR's class's implementation of System.Object.Equals and System.Object.GetHashCode will get called if the Ruby subclass does not define #== and #hash. If the Ruby subclass defines #== and #hash, those will be called instead.

When static MSIL code calls System.Object.Equals and System.Object.GetHashCode

• If the object is a Ruby objects, the Ruby object will direct the call to #== and #hash. If the Ruby object has implementations for these methods, they will be called. Otherwise, the default implementation mentioned above gets called.
• If the object is a Ruby subclass object inheriting from a CLR class,  the CLR's class's implementation of System.Object.Equals and System.Object.GetHashCode will get called if the Ruby subclass does not define #== and #hash. If the Ruby subclass defines #== and #hash, those will be called instead.

Hashing of mutable objects

The CLR expects that System.Object.GetHashCode always returns the same value for a given object. If this invariant is not maintained, using the object as a key in a System.Collections.Generic.Dictionary<K,V> will misbehave. Ruby allows #hash to return different results, and relies on the user to deal with the scenario of using the object as a key in a Hash. The mapping above between the Ruby and CLR concepts of equality and hashing means that CLR code that deals with Ruby objects has to be aware of the issue. If static MSIL code uses a Ruby object as a the key in a Dictionary<K,V>, unexpected behavior might happen.

To reduce the chances of this happenning when using common Ruby types, IronRuby does not map #hash to GetHashCode for Array and Hash. For other Ruby classes, the user can provide separate implementations for #== and Equals, and #hash and GetHashCode if the Ruby class is mutable but also needs to be usable as a key in a Dictionary<K,V>.