Diff & Merge 4 free

DiffMerge SourceGear offers their 3-way Diff/Merge tool for free. DiffMerge is an application to visually compare and merge files for Windows, Mac OS X and Unix.

Product Features (from their Website):

  • Diff. Graphically shows the changes between two files. Includes intra-line highlighting and full support for editing.
  • Merge. Graphically shows the changes between 3 files. Allows automatic merging (when safe to do so) and full control over editing the resulting file.
  • Folder Diff. Performs a side-by-side comparison of 2 folders, showing which files are only present in one file or the other, as well as file pairs which are identical or different.
  • Configurable. Rulesets and options provide for customized appearance and behavior.
  • International. Compatible with 42 different character encodings.
  • FREE. Full featured. Not a demo!
Advertisements

Private Accessor class ignores generic constraint

These days, i came across a problem with Team System Unit Testing. I found that the automatically created accessor class ignores generic constraints – at least in the following case:

Assume you have the following class:

namespace MyLibrary
{
  public class MyClass
  {
    public Nullable<T> MyMethod<T>(string s) where T : struct
    {
      return (T)Enum.Parse(typeof(T), s, true);
    }
  }
}

If you want to test MyMethod, you can create a test project with the following test method:

public enum TestEnum { Item1, Item2, Item3 }

[TestMethod()]
public void MyMethodTest()
{
  MyClass c = new MyClass();
  PrivateObject po = new PrivateObject(c);
  MyClass_Accessor target = new MyClass_Accessor(po);

  // The following line produces the following error:
  // Unit Test Adapter threw exception: GenericArguments[0], 'T', on
  // 'System.Nullable`1[T]' violates the constraint of type parameter 'T'..
  TestEnum? e1 = target.MyMethod("item2");

  // The following line works great but does not work for testing private methods.
  TestEnum? e2 = c.MyMethod("item2");
}

Running the test will fail with the error mentioned in the comment of the snippet above. The problem is the accessor class created by Visual Studio. If you go into it, you will come up to the following code:

namespace MyLibrary
{
  [Shadowing("MyLibrary.MyClass")]
  public class MyClass_Accessor : BaseShadow
  {
    protected static PrivateType m_privateType;

    [Shadowing(".ctor@0")]
    public MyClass_Accessor();
    public MyClass_Accessor(PrivateObject __p1);
    public static PrivateType ShadowedType { get; }
    public static MyClass_Accessor AttachShadow(object __p1);

    [Shadowing("MyMethod@1")]
    public T? MyMethod(string s);
  }
}

As you can see, there is no constraint for the generic type parameter of the MyMethod method.

Is that a bug? Is that by design? Who knows how to work around that problem?

Feel free to download the Visual Studio 2008 Solution that demonstrates the problem in the Download Area.