Render beautiful dot graphs to SVG at http://rise4fun.com/agl – yes you can render any graph there. If your graph is big enough, it will trigger the new edge bundling feature that looks AMAZING! Try loading this url with modern browser with SVG support…. click, zoom out and wait for the magic.

http://www.rise4fun.com/Agl/cilreader

We have just published a new game where you have to figure out the secret regular expression. Try it out, you might be surprised what you will find there.

http://www.rise4fun.com/Rex

We just released Pex and Moles v0.94 which brings MSBuild support for Moles! 

Moles is now entirely based on MSBuild and does not require to check in any generated files. All the previous headaches related to locked files in TFS are now a history. Moles assemblies will be generated on demand during the build. We strongly recommend you read the upgrade instructions in the release to see how you can smoothly upgrade to v0.94.

And while the installer is running, don’t forget to solve a duel or two at http://www.pexforfun.com …

Cheers, the Pex Team.

Ever wanted to see the Code Contracts directly in your Intellisense? Well, it is possible now thanks to the Code Contracts Editor Extensions. Get it now on Visual Studio Code Gallery!

We have added a new step-by-step tutorial to help testing Asp.NET applications with Pex and Moles. You will find as part of the installer or simply at

http://research.microsoft.com/en-us/projects/pex/molesaspnet.pdf

Is there anything else to say than… try it out now at http://www.pexforfun.com !

We’ve just released a new version of Pex and Moles v0.92. This version brings Rex integration (smarter about regular expressions), Silverlight support (Alpha) and a number of bugs/improvements here and there.

Read all about the new stuff on the release notes page. Happy Pexing!

I just uploaded a refresh of the QuickGraph binaries with Code Contracts references and documentation instrumented with the Contracts.

Are you using Code Contracts ? or not? Give us 5 minutes of your time and fill up the survey that the BCL has put up…

http://codecontracts.questionpro.com/

This post shows how you can leverage the un-typed Detours API to extend any mock framework to support static methods, sealed types, etc…

Moles is an isolation framework for .NET that the Pex team designed to make Pex happy. It relies heavily on delegates and comes with a syntax of its own. Moles is actually a simple strongly typed layer on top of a un-typed general purpose detour API. If you do not like the Moles syntax, you can still leverage the detours API to deal with static methods or sealed types.

Let us see how we can use the detour API to build a micro-mock-framework using expressions trees. Let’s call it Deq.

The Challenge

As usual, we’ll toy with an example where we need a very particular DateTime.Now value. Since DateTime.Now is a struct living in mscorlib.dll, it cannot be mocked using traditional approaches –DateTime.Now can’t be overloaded. The test case looks like this and will most likely fail.

The Whish

We would like to be able to replace the implementation of DateTime.Now with a method that always returns the year 2000 in the context of the test. If possible, we would like to use a strongly typed, Linq-ish, expression tree based syntax to do this. For example, we could think that a Deq class would define a Replace(Expression<Func<T>> method, Func<T> detour) method that would achieve this detour:

 Implementing Deq on top of MoleRuntime

The implementation of Deq.Replace relies on MoleRuntime.SetMole, an un-typed API to replace methods that Moles builds upon. First, one needs to walk the expression tree to extract the MethodInfo that the user wanted to replace (I’m not showing this code here, it is beyond the point of this blog post). Once you have the method, you can use the Moles API to install the detour. This happens through the MoleRuntime.SetMole method and the rest is taken care of the Moles runtime.

That’s it. You’ve just written a micro-mock framework that can isolate from static methods.

To get this code to compile, you will need a reference to Microsoft.ExtendedReflection.dll and Microsoft.Moles.Framework.dll. Also, since the Replace method only works for the Func<T> method, you’ll probably want to write a T4 template that takes care of all the other delegates (Func<T,T2>, Action<…> etc…).

Deq Sources?

The Deq sources are available in the Samples solution that ships with Pex.

Nikolai Tillmann announced it on our page, he just finished integrating Rex in to Pex….

Although Pex is only available for MSDN subscribers, Moles can be freely downloaded as a standalone tool on Visual Studio Gallery.

http://visualstudiogallery.msdn.microsoft.com/en-us/b3b41648-1c21-471f-a2b0-f76d8fb932ee

(off course, both tools are also available under an academic license too)

We just uploaded a new release 0.91 on MSDN, Visual Studio gallery and our research web site. Learn more about the changes at http://research.microsoft.com/en-us/projects/pex/releasenotes.aspx#0_91

Get and download Pex!

La presentation sur Pex et Moles pour SharePoint que j’avais presente a Paris est online…

We did the Chilly Hilly 2010 bike race with Elliott last Saturday, along with 6000 other riders. Lots of hills and fun.

We just released an update of Pex on Devlabs that adds support for Visual Studio 2010 RC (the release also contains a number of bug fixes). Read more about it on our release notes page.

We just released a new version of Pex and Moles that brings a number of bug fixes and various improvements to the behaviors for SharePoint and Asp.NET.

Improvements

• Interaction with the Source Control provider has been significantly improved for Moles
• Support for Moles of nested types.
• Improved logging in the Host Type
• Improved Behaved collections
• Added Behaved types for mscorlib and System.Web types.

Bug fixes

• Updated several outdated section in the documentation
• Updated missing classes in the SharePoint samples
• Fixed a limitation of the profiler that would silently fail to instrument certain methods

Breaking Changes

• We have formalized the naming convention of Moles and Stubs and found some holes along the way. Some mole method might have a new name under this version of the compiler.

We did a super-short movie with Nikolai Tillmann on how to use Moles to test code depending on DateTime.Now. Enjoy!

In WPF, one needs to implement the DependencyProperty pattern to make properties bindable. It usually involves a lot of boiler plate code:

• adding a static field that names the depency property,
• adding the instance property to the type (and make sure you follow the naming convention),
• add validation methods and wire them in the dependency constructor

These are a number steps that need to be done again and again if you are building new WPF controls.

This is where a little transformation using CciSharp really helps with such boiler plate code. Using the DependencyAutoProperty mutator, you can define dependency properties with a single attribute. The rest is taken and validated by the compiler.

The simple scenario: Add [DependencyAutoProperty]

The rewritten code will contain a dependency property for the Value property, and will rewrite the value property getter and setters to use GetValue, SetValue instead.

Supporting default values

Default values can be specified in the DependencyProperty register method, so we want to support this as well through the DependencyAutoProperty constructor.

Supporting validation

Callbacks can be passed in the constructor of DependencyProperty to validate the values of the property. To support this, we use a simple naming convention: if you specify the Validate = true constructor argument, the rewritter will look for a static “Validate” + property name method whose signature is Func<T, bool>, where T is the property type. The rewritter will make sure this method is used – or raise a compilation error if it is missing.

An interresting point here is that the callbacks passed in the DependencyProperty.Register method are untyped (Func<object, bool>) and the user needs to make the appropriate casts himself. This is taken care of by the rewritter:

Have fun!

The new version of Visual Studio 2010 supports a very cool graph viewer (powered by MSAGL) and a simple XML file format (DGML) to load your own graph. I’ve added support in QuickGraph to emit .dgml file from any graph (you will need to build the sources). For example, this snippet display a very simple graph:

And the result opens magically in Visual Studio 2010!

Je présenterai une session en francais sur l’utilisation de Pex et Moles pour tester des services SharePoint aux TechDays Paris le 8 Février de 17:30 à 18:30.

Test Unitaire de Services SharePoint avec Pex et Moles.

Durant cette session, nous montrerons comment appliquer Moles et Pex pour écrire des Test Unitaires de Services SharePoint. Moles est un outil qui permet de remplacer n'importe quelle fonction .NET par un délégué ce qui permet d'isoler le code par rapport aux objets SharePoint. De plus, à partir d'un test unitaire paramétré, Pex génère automatiquement une suite de test unitaire afin de couvrir un maximum de code. Plus d'information sur Pex et Moles sur research.microsoft.com/pex

We just released Pex 0.21.50115.2. This release brings bug fixes, a big renaming from “Stubs” to “Moles” and improved infrastructure to build behaved types (formerly known as beavers).

Bug Fixes

• The Moles VsHost fails to execute unit tests in different assemblies.
• Pex deletes the report folder it is currently writing to.
• Support for named indexers in Stubs
• Fixed bugs in how Pex reasons about System.Convert.ToBase64, DateTime
• Invalid support for protected members in the stubs generation

Breaking changes

• The Stubs framework was renamed to Moles framework. We have decided to make the Moles the center of the framework and as a consequence, renamed ‘Stubs’ to ‘Moles’. (This does not mean that we encourage writing untestable code, as Mole help to make it testable. You should still refactor your code to make it testable whenever possible, and only use Moles when that’s the only choice). The impact is that
  • Microsoft.Stubs.Framework was renamed to Microsoft.Moles.Framework
  • The moles and stubs get generated in subnamespaces ‘.Moles’ rather ‘.Stubs’.
  • See below for the list of steps to upgrade your applications.
• BaseMembers in Moles have been deprecated: this helper is not useful as it can be acheive in a better way through a constructor. We decided to remove it to reduce code size. The second reason is that BaseMembers would only work for types inside of the same assembly, which might seem inconsistent.
• PexGoal.Reached is replaced by PexAssert.ReachEventually(). The PexGoal class has been integrated into PexAssert through the ReachEventually method which should be used with the [PexAssertReachEventually] attribute.
• PexChoose simplified: we’ve simplified the PexChoose API; you can now get auxiliary test inputs with a single method call: PexChoose.Value<T>(“foo”).

Migrating from previous version of Pex

Since we’ve renamed Stubs to Moles, any existing .stubx files will not work anymore.

Take a deep breath, and apply the following steps to adapt your projects:

• change the project reference from Microsoft.Stubs.Framework.dll to Microsoft.Moles.Framework.dll
• rename all .stubx files to .moles, and
  • rename the top <Stubs xml element to <Moles.
  • Change the XSD namespace to http://schemas.microsoft.com/moles/2010/
  • Right click on the .moles file in the Solution Explorer and change the Custom Tool Name to ‘MolesGenerator’.
  • Delete all the nested files under the .moles files
• Remove references to any compiled .Stubs.dll files in your project
• In general, remove all .Stubs.dll, .Stubs.xml files from your projects.
• Rename .Stubs namespace suffixes to .Moles.
• replace all [HostType(“Pex”)] attribute with [HostType(“Moles”)]
• in PexAssemblyInfo.cs,
  • rename using Microsoft.Pex.Framework.Stubs to Microsoft.Pex.Framework.Moles
  • rename [assembly: PexChooseAsStubFallbackBehavior] to [assembly: PexChooseAsBehavedCurrentBehavior]
  • rename [assembly: PexChooseAsStubFallbackBehavior] to [assembly: PexChooseAsMoleCurrentBehavior]
• In general, the ‘Fallback’ prefix has been dropped in the following methods:
  • rename FallbackAsNotImplemented() to BehaveAsNotImplemented()
  • rename class MoleFallbackBehavior to MoleBehaviors
  • rename class StubFallbackBehavior to BehavedBehavors

Picture-in-Picture is a very cool feature of Camtasia that allows to embed a movie stream into a screencast. It makes the screencast more lively while keeping a perfect quality of the computer screen. You've seen this kind of screencast all over the place on Channel9. Unfortunately, this feature was limited for screen recording and whiteboard session would never look that good since we had to zoom in and out to capture… not anymore.

We invested in an eBeam device that can capture the pen strokes on any whiteboard and display them on the computer. Using this device, we can do Picture-in-Picture for Whiteboard recordings! Using that device, we use the following setup: a camera on a tripod to record the person on the whiteboard, the eBeam capture software running and Camtasia recording the computer screen. The first result of this experiment is the first episode of a new show, The Verification Corner, where Rustan Leino explains Loop Invariants. The other benefit of recording the whiteboard is that you get a hard copy out it. If you go to the Channel9 page, you’ll see that you can also download a .pdf or .pptx of all the whiteboard that Rustan wrote during the session… Go check it out and tell us what you think…