Expand testing

[Miista]

We need tests for shimming a:

• instance method
• Specific instance methods (should verify that we only shim methods for that specific instance)
• Static method
• Getter
• Setter
• ref type constructor
• value type constructor (is this possible)
• abstract type (method + constructor?)

At the same time we could update the tests to a more modern test framework

The "hierarchy" of tests is as follows:

Please see alternate hierarchy below.

Note: Assume that all members are public.

1. Static methods
2. Static properties
   2.1 Getters
   2.2 Setters
3. Methods on reference type
   3.1 Methods on any instance
   3.2 Methods on specific instance
   3.3 Methods on abstract reference type
4. Methods on value types
   4.1 Methods on any instance
   4.2 Methods on specific instance This is not supported! It's only here for completeness sake.
5. Constructors
   5.1 Reference types
   5.2 Value types

There is the following alternate hierarchy (which I might be more partial to):

Isolation

These tests exercise the entire library via PoseContext.Isolate.

Shimming

Note: These tests should be renamed to "Isolation".
These are the full-blown tests which test the entire stack.

We want to test the following:

1. Methods
   1.1 Static types
   1.2 Reference types
   1.2.1 Any instance
   1.2.2 Specific instance
   1.3 Value types
   1.3.1 Any instance
   1.3.2 Specific instance of value type This is not supported! It's only here for completeness sake.
   1.4 Abstract methods
   1.5 Sealed types (both reference and value types)
2. Getters
   2.1 Static types
   2.2 Reference types
   2.2.1 Any instance
   2.2.2 Specific instance
   2.3 Value types
   2.3.1 Any instance
   2.3.2 Specific instance (Is this supported?)
   2.4 Sealed types (both reference and value types)
3. Setters
   3.1 Static types
   3.2 Reference types
   3.2.1 Any instance
   3.2.2 Specific instance
   3.3 Value types
   3.3.1 Any instance
   3.3.2 Specific instance (Is this supported?)
   3.4 Sealed types (both reference and value types)
4. Constructors
   4.1 Static types Not currently possible
   4.2 Reference types
   4.3 Value types It seems this isn't supported
   4.4 Sealed types (both reference and value types)

Method rewriting

These tests should only be concerned with rewriting methods.
We wants to test for:

• Rewriting static methods
• Rewriting instance methods of reference types
• Rewriting instance methods of value types
• Rewriting abstract methods
• Rewriting unsafe methods Note that this is in an ideal world. See Add support for rewriting unsafe methods #9
• Rewriting async methods See Add support for async/await #12
• Not being able to rewrite methods in System.Private.CoreLib

IL generation (via stubs)

These tests are concerned with generating IL for stubs (which will later be used to inject the shims).

We want to test that we can generate stubs for:

• Direct calls
• Virtual calls
  • Including for a constrained type (What does this mean?)
• Object initialization (constructor invocations)
• Direct load (What does this mean?)
• Virtual load (What does this mean?)

Other

These tests I have not been able to put into any specific category. They are therefore lumped together here.

We want to test the following:

• That we can correctly determine whether a method is in System.Private.CoreLib (both positive and negative verification)
• That we can verify whether a method is an override (both positive and negative verification)