6

I'm not sure if I should ask this here but here we go, while unit testing a private static method that has as parameter a short I'm getting a MissingMethodException only when this parameter is 0.

I'm using VS 2010 SP1 targeting the Framework 4 (full), here is the bare minimum code to reproduce this error (we are upgrading a VB6 code so don't be rude):

    [DataContract]
  public enum NotificationResult
  {
    [EnumMember]
    Success,
    [EnumMember]
    StoredError,
    [EnumMember]
    InvalidId,
    [EnumMember]
    OperationError,
  }

    public sealed class NotificationContext
  {
    private static NotificationResult GetExecuteResult(short result)
    {
      NotificationResult executeResult;
      switch (result)
      {
        case 0:
          executeResult = NotificationResult.Success;
          break;
        case 1:
          executeResult = NotificationResult.StoredError;
          break;
        case 2:
          executeResult = NotificationResult.InvalidId;
          break;
        default:
          executeResult = NotificationResult.OperationError;
          break;
      }

      return executeResult;
    }
  }

Here is how I'm testing the code:

 PrivateType privateHelperType = new PrivateType(typeof(NotificationContext));
      var actual = (NotificationResult)privateHelperType.InvokeStatic(
        "GetExecuteResult", (short)1);
      var actual2 = (NotificationResult)privateHelperType.InvokeStatic(
        "GetExecuteResult", (short)0); //here is where i get the exception

In the first invocation i get the expected result, in the second invocation I get the exception (I added the cast to short thinking that maybe the exception was because it was not finding a method with an int as a parameter).

Is anybody able to reproduce the behavior?, am I doing something wrong?

Thanks for your help.

Juan Zamudio
  • 373
  • 11
  • 35
  • 1
    @Jason i know, but like i said, we are upgrading a VB6 app and this method was not getting 100% coverage and we need to verify it worked as specified. – Juan Zamudio Jan 18 '12 at 04:55
  • You do not need 100% coverage on your private methods; only your non-private methods. – jason Jan 19 '12 at 04:03

3 Answers3

9

The problem is that there are two overloads of this method (there are others, but they don't matter here):

The difference is that the second overload has a parameter of type BindingFlags, which is an enum. And when you pass literal 0 as the second parameter, this overload is chosen, because the literal 0 is implicitly convertible to any enum and not using params is deemed better than using it in overload resolution. So, basically

  • privateType.InvokeStatic("GetExecuteResult", 1) is compiled into privateType.InvokeStatic("GetExecuteResult", new object[] { 1 })
  • privateType.InvokeStatic("GetExecuteResult", 0) is compiled into privateType.InvokeStatic("GetExecuteResult", 0, new object[] { })

This is the cause of your problem. I think the cleanest way to avoid it would be to create the array explicitly:

privateType.InvokeStatic("GetExecuteResult", new object[] { 0 })

Except in your code you don't pass the literal 0 to the method, you cast it first. According to the specification, the BindingFlags overload should not be chosen in this case. But errors like this are a known bug, that won't be fixed, because it would break some working programs.

svick
  • 236,525
  • 50
  • 385
  • 514
  • I believe the bug you are looking for is it's just that the 0 constant (even with the cast) as originally expressed in the question goes to the enum overload. See [this](http://stackoverflow.com/questions/2043554/method-overload-resolution-unexpected-behavior), which points to [this](http://blogs.msdn.com/ericlippert/archive/2006/03/29/the-root-of-all-evil-part-two.aspx). – Anthony Pegram Jan 18 '12 at 04:03
  • @AnthonyPegram, that article from Eric Lippert is the one I was thinking about. I have added a link to it to the answer. – svick Jan 18 '12 at 04:14
3

Interesting... I was able to reproduce it, and I found a way to fix it.

short s = 0;
var actual2 = (NotificationResult)privateHelperType.InvokeStatic(
        "GetExecuteResult", s);
Nick Bray
  • 1,953
  • 12
  • 18
  • funny, I never tried that because I was using an internal static class with all my constants, in my class I had this "internal const short Success = 0;" and still getting the error. – Juan Zamudio Jan 18 '12 at 03:48
  • I think It is because the type of the parameter is object. When you cast it, it doesn't change the type of the instance of the object. It just allows the instance of the object to be referenced by a variable of that type. When you pass the object you pass by reference a value in memory of type Int16. – Nick Bray Jan 18 '12 at 03:50
-3

I would try making your class not sealed. This is purely a guess but maybe it is subclassing your NotificationContext as a part of PrivateType.

My second recommendation is to download something like dotpeek: http://blogs.jetbrains.com/dotnet/2011/05/free-net-decompiler-is-available-for-early-access/ to have a look at what PrivateType looks like. Understanding how it works will help work out what is actually happening.

Dessus
  • 2,147
  • 1
  • 14
  • 24