Test Manager fails to load after installing Test Scribe


A few weeks ago I was at a client doing a proof of concept for the testing tools (MTM for manual testing, Visual Studio for automated testing at the UI level and off course also using TFS for full traceability and collaboration between the testing team and the development team). And

I had a little problem MTM was crashing immediately on startup (there is was no evidence why this was happening, just a stack trace on windows event log).

One of the things I was showing them was Test Scribe. Test Scribe is a Test Manager add-on that allows you to generate documentation about your test plans and the test runs. People who use the tool don’t need this since they have live that on TFS but some people like to see documents or we may need to generate some documentation to deliver to the client to show evidence that tests (and which ones) have been executed, or perhaps we need documents to serve as evidence and to be signed by someone due to contractual or auditing reasons. The reason is not very important since everyone will probably have a different.

Test Scribe is freely available and you can download it from Visual Studio Gallery here

Anyway the symptoms are, when you launch test manager you can see splash screen and then application fails. If you uninstall test scribe everything works perfectly. Since uninstalling is not a nice option there is an easier solution. Install Team Explorer 2010 on the machine. Test Scribe has a dependence on Team Explorer but it’s not clear on the site.

If you are a tester and have not installed Team Explorer because you thought it was a developer thing and MTM was all you needed installing Team Explorer also has a nice bonus, it will allow you to perform this useful tasks

  • Manipulate you work items via Excel
  • See reports (which off course and can always see using just a browser if you prefer)
  • Send work items by email (great for emailing a list of bugs)
  • If you also install the TFS Power Tools you will also be able to use the Alerts Explorer to create & manage alerts of things happening on TFS. Alerts are delivered by email, for example you could
    • Be alerted when a bug is resolve and it is assigned to you
    • When a build finishes (you may have some bugs to verify in it Smile)
    • among other things

A little word for Gautam Goenka who helped me track the issue.

Anyway I’m documenting this in case someone is also hit by this problem. If you are, just install Team Explorer 2010 and everything will be fine.

I’m including the full stack trace so people who are affected by this issue can easily find it on their preferred search engine (the stack trace was obtained by using the windows event viewer. No need to enable any kind of tracing to get it).

Application: mtm.exe
Framework Version: v4.0.30319
Description: The process was terminated due to an unhandled exception.
Exception Info: System.Reflection.ReflectionTypeLoadException
   at System.Reflection.RuntimeModule.GetTypes(System.Reflection.RuntimeModule)
   at System.Reflection.RuntimeModule.GetTypes()
   at System.Reflection.Assembly.GetTypes()
   at System.ComponentModel.Composition.Hosting.AssemblyCatalog.get_InnerCatalog()
   at System.ComponentModel.Composition.Hosting.AssemblyCatalog.GetExports(System.ComponentModel.Composition.Primitives.ImportDefinition)
   at System.ComponentModel.Composition.Hosting.AggregateCatalog.GetExports(System.ComponentModel.Composition.Primitives.ImportDefinition)
   at System.ComponentModel.Composition.Hosting.CatalogExportProvider.GetExportsCore(System.ComponentModel.Composition.Primitives.ImportDefinition, System.ComponentModel.Composition.Hosting.AtomicComposition)
   at System.ComponentModel.Composition.Hosting.ExportProvider.TryGetExportsCore(System.ComponentModel.Composition.Primitives.ImportDefinition, System.ComponentModel.Composition.Hosting.AtomicComposition, System.Collections.Generic.IEnumerable`1<System.ComponentModel.Composition.Primitives.Export> ByRef)
   at System.ComponentModel.Composition.Hosting.AggregateExportProvider.GetExportsCore(System.ComponentModel.Composition.Primitives.ImportDefinition, System.ComponentModel.Composition.Hosting.AtomicComposition)
   at System.ComponentModel.Composition.Hosting.ExportProvider.TryGetExportsCore(System.ComponentModel.Composition.Primitives.ImportDefinition, System.ComponentModel.Composition.Hosting.AtomicComposition, System.Collections.Generic.IEnumerable`1<System.ComponentModel.Composition.Primitives.Export> ByRef)
   at System.ComponentModel.Composition.Hosting.ExportProvider.TryGetExports(System.ComponentModel.Composition.Primitives.ImportDefinition, System.ComponentModel.Composition.Hosting.AtomicComposition, System.Collections.Generic.IEnumerable`1<System.ComponentModel.Composition.Primitives.Export> ByRef)
   at System.ComponentModel.Composition.Hosting.CompositionContainer.GetExportsCore(System.ComponentModel.Composition.Primitives.ImportDefinition, System.ComponentModel.Composition.Hosting.AtomicComposition)
   at System.ComponentModel.Composition.Hosting.ExportProvider.TryGetExportsCore(System.ComponentModel.Composition.Primitives.ImportDefinition, System.ComponentModel.Composition.Hosting.AtomicComposition, System.Collections.Generic.IEnumerable`1<System.ComponentModel.Composition.Primitives.Export> ByRef)
   at System.ComponentModel.Composition.Hosting.ExportProvider.GetExports(System.ComponentModel.Composition.Primitives.ImportDefinition, System.ComponentModel.Composition.Hosting.AtomicComposition)
   at System.ComponentModel.Composition.Hosting.ImportEngine.TryGetExports(System.ComponentModel.Composition.Hosting.ExportProvider, System.ComponentModel.Composition.Primitives.ComposablePart, System.ComponentModel.Composition.Primitives.ImportDefinition, System.ComponentModel.Composition.Hosting.AtomicComposition)
   at System.ComponentModel.Composition.Hosting.ImportEngine.TrySatisfyImportSubset(PartManager, System.Collections.Generic.IEnumerable`1<System.ComponentModel.Composition.Primitives.ImportDefinition>, System.ComponentModel.Composition.Hosting.AtomicComposition)
   at System.ComponentModel.Composition.Hosting.ImportEngine.TryPreviewImportsStateMachine(PartManager, System.ComponentModel.Composition.Primitives.ComposablePart, System.ComponentModel.Composition.Hosting.AtomicComposition)
   at System.ComponentModel.Composition.Hosting.ImportEngine.PreviewImports(System.ComponentModel.Composition.Primitives.ComposablePart, System.ComponentModel.Composition.Hosting.AtomicComposition)
   at System.ComponentModel.Composition.Hosting.ComposablePartExportProvider.Compose(System.ComponentModel.Composition.Hosting.CompositionBatch)
   at System.ComponentModel.Composition.Hosting.CompositionContainer.Compose(System.ComponentModel.Composition.Hosting.CompositionBatch)
   at Microsoft.VisualStudio.Tools.Shakespeare.ShakespeareRuntime.Configure(System.String, System.Reflection.Assembly[])
   at Microsoft.TeamFoundation.TestManagement.Activities.Tools.ToolsCenterGroup.Initialize(Microsoft.TeamFoundation.TestManagement.Client.Runtime.IActivityRuntime)
   at Microsoft.TeamFoundation.TestManagement.Client.Runtime.ActivityRuntime.InitializeCenterGroups()
   at Microsoft.TeamFoundation.TestManagement.Client.Runtime.ActivityRuntime.InitializeRuntime()
   at Microsoft.TeamFoundation.TestManagement.Client.Runtime.ActivityRuntime.GetCurrentRuntime()
   at Microsoft.TeamFoundation.TestManagement.Shells.WpfShell.App.OnStartup(System.Windows.StartupEventArgs)
   at System.Windows.Application.<.ctor>b__1(System.Object)
   at System.Windows.Threading.ExceptionWrapper.InternalRealCall(System.Delegate, System.Object, Int32)
   at MS.Internal.Threading.ExceptionFilterHelper.TryCatchWhen(System.Object, System.Delegate, System.Object, Int32, System.Delegate)
   at System.Windows.Threading.DispatcherOperation.InvokeImpl()
   at System.Windows.Threading.DispatcherOperation.InvokeInSecurityContext(System.Object)
   at System.Threading.ExecutionContext.runTryCode(System.Object)
   at System.Runtime.CompilerServices.RuntimeHelpers.ExecuteCodeWithGuaranteedCleanup(TryCode, CleanupCode, System.Object)
   at System.Threading.ExecutionContext.RunInternal(System.Threading.ExecutionContext, System.Threading.ContextCallback, System.Object)
   at System.Threading.ExecutionContext.Run(System.Threading.ExecutionContext, System.Threading.ContextCallback, System.Object, Boolean)
   at System.Threading.ExecutionContext.Run(System.Threading.ExecutionContext, System.Threading.ContextCallback, System.Object)
   at System.Windows.Threading.DispatcherOperation.Invoke()
   at System.Windows.Threading.Dispatcher.ProcessQueue()
   at System.Windows.Threading.Dispatcher.WndProcHook(IntPtr, Int32, IntPtr, IntPtr, Boolean ByRef)
   at MS.Win32.HwndWrapper.WndProc(IntPtr, Int32, IntPtr, IntPtr, Boolean ByRef)
   at MS.Win32.HwndSubclass.DispatcherCallbackOperation(System.Object)
   at System.Windows.Threading.ExceptionWrapper.InternalRealCall(System.Delegate, System.Object, Int32)
   at MS.Internal.Threading.ExceptionFilterHelper.TryCatchWhen(System.Object, System.Delegate, System.Object, Int32, System.Delegate)
   at System.Windows.Threading.Dispatcher.InvokeImpl(System.Windows.Threading.DispatcherPriority, System.TimeSpan, System.Delegate, System.Object, Int32)
   at MS.Win32.HwndSubclass.SubclassWndProc(IntPtr, Int32, IntPtr, IntPtr)
   at MS.Win32.UnsafeNativeMethods.DispatchMessage(System.Windows.Interop.MSG ByRef)
   at System.Windows.Threading.Dispatcher.PushFrameImpl(System.Windows.Threading.DispatcherFrame)
   at System.Windows.Threading.Dispatcher.PushFrame(System.Windows.Threading.DispatcherFrame)
   at System.Windows.Threading.Dispatcher.Run()
   at System.Windows.Application.RunDispatcher(System.Object)
   at System.Windows.Application.RunInternal(System.Windows.Window)
   at System.Windows.Application.Run(System.Windows.Window)
   at Microsoft.TeamFoundation.TestManagement.Shells.WpfShell.SingleInstanceWrapper.Launch(System.String[], Boolean)
   at Microsoft.VisualStudio.TestTools.Common.SingleInstance.SingleInstanceApplicationManager.Run(System.String, System.String, LaunchAction, System.String[])
   at Microsoft.TeamFoundation.TestManagement.Shells.WpfShell.SingleInstanceWrapper.Main(System.String[])

For more information, see Help and Support Center at http://go.microsoft.com/fwlink/events.asp.

Help Improve Visual Studio performance


Performance is something that we can never have enough off. Nobody minds if things would go faster,in fact we always want things to go faster now matter how fast they already are (and any speed improvement won’t be noticeable).

In terms of performance my favorite phrase is a quote from djb “profile don’t speculate”. If you ever tried to optimize code, after you take care of the low hanging fruit making things go faster requires  experimentation, analysis and specially a lot of hard data that you can act upon, so you can optimize the most common paths and operations.

Microsoft has released a tool that can exactly (helo them) do that. Collect real data while you are running Visual Studio in a real environment and allow them to see where are the hotspots in the code, what is most being used and which things are taking longer than they should and report those situations automatically without the need of your intervention (the data is not traceable, it’s anonymous and you have control when the data is sent). Basically the tool detects when the UI has become unresponsive, records information about the length of the unresponsiveness and the root cause of it.

This tool is called PerfWatson it works like a telemetry station getting hard data about VS performance. It’s being distributed as a VS package so installation is a snap and as easy it can get.

VS team uses the aggregation of this data from everyone that is contributing to this effort and uses it to prioritize the options that are needed.

The PerfWatson extension can be downloaded from the Visual Studio Extension Manager or at the VS Gallery.

The gallery page has configuration instructions, there is nothing to configure besides making sure that WER is enabled.

The mininum requirements to run PerfWatson are:

Following are the pre-requisites for installing Visual Studio PerfWatson:

  • Windows Vista/2008/2008 R2/7 (Note: PerfWatson is not supported for Windows XP)
  • Visual Studio 2010 SP1 (Professional, Premium, or Ultimate)

TeamCompanion 4 has been released


Ekobit just released TeamCompanion 4.0, teamcompanion is an outlook addin that allows you to interact with TFS without having to leave outlook.

It allows you to synchronize workitems with outlook so you can manage work items without having to leave it. It also makes a great bridge between work items and your email. You can send a work item by email, send a list of work items and create work items from a received email (if you want the email and attachments can automatically be attached to the workitem itself). It can intelligent detect when you receive a TFS notification by email (checkin event or build event) and with one click you can open the changeset or a build detail for easy inspection just like in Team Explorer.

You can also see TFS reports (and email them !!!! directly from outlook), not to mention it also integrates with sharepoint.

If you receive feature requests or bugs by email TeamCompanion is a great way of entering them directly into TFS without doing a lot of typing and copy & paste of files. It is also great if you want to email a list of tasks to be performed or to send a list of features that have been implemented in a given iteration/release.

Version 4 brings us a bunch of new features.

Offline support for work item, a faster storage mechanism for work items and a SUPER search that not only is fast as hell but is also very flexible. If you are into agile it also has a brand new agile planning capabilities which allows you to easily do your backlog planning and capacity planning for your team.

You can read a much better description than mine on Oggy’s announcement post which has the whole list of new features with lot of screenshots.

If you are someone who likes videos, there is also a bunch of videos available for viewing

I have been using TeamCompanion daily since v1 and I’ve also been using beta testing version 4 (and 3 and 2 Smile) and I must say the new features are great help to my daily work. Specially the search, which blows outlook search out in the water.

TeamCompanion is one of the tools that I recommend to anyone who needs to interact with TFS.

Disclosure: I own 2 licenses of Team Companion one of which has been offered to me by Ekobit so I could use TeamCompanion on my netbook.

Look the good news that MS Teched US is bringing us for Visual Studio


Being a MVP has one downside, you can’t talk about a lot of things that you know. Things that are going to available on future releases, because we know about them, we have seen them (screencasts, conference calls, documentation,etc) or in case some we have already played with them (early bits). Sometimes people ask specifics questions how a certain thing can be accomplished or complain about something that is missing and we simple can’t say that they will be getting that in the next version.

We are allowed to talk about it, when it becomes public information, so here _some_ of the things that we can already talk about the next version of Visual Studio at North America Teched

So here is my take on what has _been announced_. I’m not going to talk about anything that has been announced but I will add some things that I would to be available on the next version (either they will be there or not). This is solely my opinion and interpretation on what HAS BEEN announced, I’m NOT filling any gaps with other information I may or may not have (no a lawyer has not me made write this Smile) 

It’s not be read as something that will be available on next version.


One of the objectives of vNext is going to reduce the gap between the stakeholders and the developers (being the other the operations and developers). This former will be achieved in the following ways

  • Storyboarding tool – Today there are many ways for the developing team (either analysts, developers or designers) communicate with stakeholders what they are going to implement in order to collect their feedback. Some people use Visio, Powerpoint, a paint program or a mockup tool (my favorite is Balsamiq which is a tool simple enough to be used even by me, a person with designing skills of a neardenthal) to communicate intent and how they are planning to articulate the user interface. In order to reduce miscommunication and to set the right expectations Visual Studio is going to include a powerpoint addin which will help you easily design your mockups. Interacting with stakeholders is more than just communicate intent and sharing a (rough) preview of the interface. It is sharing something that they can (slightly) interact, that it can collect feedback (with inline comments, image annotations,some sort of traceable feedback or even allowing changes made by the final user), something that resembles a two way communication and not just unilateral thinking. I place great hopes on this tool.
  • Feedback tool – A tool that works in the spirit of test manager, but that is meant to be executed before the software is ready. Allows persons to run the software in it’s early phases, either interactive mockups, prototypes or early releases. The same way MTM collects information from the running code, so does this tool but with a different objective to learn how people are using the application (for example by recording video , audio or action recording) and specially to allow them to easily add their feedback about the application. Either through annotations, comments, ratings or other imaginative methods. In other words make the process more interactive and traceable (without the need to have a deluge of emails Smile)

For the teams

  • Teams – The concept of teams is going to be introduced. At first glance it may seem like the team members functionality currently available on the power tools, but it’s going to be a lot more deeper than that, it will allow you to organize your teams in a team project and work on that view only in isolation from other teams allowing you to cluster your work and your team work without distractions from the entire worksteam. My wish on this one is that work item queries can also use this information.

For the agilistas

  • A new browser based taskboard (and touched enabled)  planning tool -  that will allow to manage your backlogs and do capacity planning using drag & drop
  • Unit Testing – Visual Studio is going to be more agnostic about unit testing frameworks without forcing you to write your unit tests using MSTest, essentially having feature parity between MSTest and other frameworks with a single runner. This is open, so I expect that people will write the integration glue between visual studio and the huge number of unit test frameworks that exist out there. You can even mix unit tests from more than one framework and have a unified view of all unit tests regardless of their implementation.

Goodies for the developers.

  • Code review will be integrated into Visual Studio/TFS – I don’t think this needs much description. Fully integrated code review with TFS and your collaboration activities
  • Easy detection of duplicated code  – If you dig enough on any code base there probably a lot of duplicated code (code & paste should be disabled on some developers IDEs Smile). The reasons are not very important, but it’s tipically rush to get working code out, lack of time (famous last words: I will refactor this later…), laziness or some other valid reasons make the code reach a level with some degree of unneeded duplication. But finding duplicates is  not an easy task. There are a lot of tools out there that do this like simian (disclaimer: I hold a license that has offered by Simon Harris), atomiq or the free Clone Detective that integrates directly into Visual Studio (unfortunately only VS2008). In the next version VS is going to have an integrated way to easily find code duplication so you can refactor the code to make it more maintainable. This will work not only with code that has been cut & pasted but will find similar code at the semantic level. Code duplication detection is something very powerful, I have a recollection of an incident (I wasn’t involved <g>) in college, when an teaching assistant wrote a code duplication detection tool that worked at the semantic level (it could find identical code at a structural level even if you changed that variable names and other minor changes) and applied it to all students code. Let’s just say this incident consequences affected a large number of people (in some cases due to a similar function only). Smile

somewhat related: Microsoft Research has a very interesting paper on mental models that talks about different types of code duplication

  • Intellitrace – In the next version you will be able to use intellitrace to collect logs from production environments (it works on my machine is getting harder and harder to say <g>)
  • Task based operations in Visual Studio – I don’t have a better naming for this one sorry, but it will mimic more easily the way people work (if you are not a chaotic and totally unstructured kind of person). You can basically say you are working on this task (and pause, stop) and it will remember what kind of operations and which files you have done, allowing you to commit code to your source tree based on the task you are performing. It allows you to make context switches more easily without doing a lot of leg work.

Assorted news

  • Team Web Access (TWA) – The UI of the team web access is going to be revamped and it’s going to have a Metro UI look & feel. I’m still seating on the fence on this one. I love the metro UI on my WP7, it is usable on the Zune software but I’m not that sure on applications that have less linear flows. Let’s wait and see, perhaps I’m just conservative and averse to change <G>.


There has also been an announcement of an integration that will exist between TFS and System Center to reduce the gap between operations people and the development team. BUT this is not going to be available only in dev11, it is going to be available for TFS 2010. A CTP has been announced so I suppose it will be downloadable soon, you can read more about this on this Brian Harry’s post.

You can watch the keynote here all of this has been announced (you will have to click on the keynote tab no direct link sorry. Skip to 1h 14m to see Jason Zander talking about VS. ). This site has interesting videos, but I haven’t found a way to link directly to them individually. Sad smile

You should also watch the Cameron Skinner’s Teched session on The Future of Microsoft Visual Studio Application Lifecycle Management (Cameron also has an interesting video with Brian Keller where he summarizes the features he demoed on the keynote)

You can get more specific information about all of thise (and more) on a whitepaper that Microsoft just released about the vision that is going to be materialized on the next version of Visual Studio. It’s called Visual Studio vNext- Application Lifecycle Management whitepaper.

Other posts on this topic that I’ve read so far

From Microsoft Visual Studio Team

Microsoft Institutional blogs

From Microsoft ALM MVP’s

MS Test Manager– Registering why a test is blocked


This week I was at a client and I have been asked if it is possible to register the reason why a test is blocked.

With test manager you can specifically mark a test as blocked. To mark you can’t test it for some reason (typically an external dependency that needs to be resolved. In Scrum wording an impediment. For example you need some special hardware for the testing and it’s not available or a server broke and it is being repaired (which normally signals you aren’t using Lab Management Smile)).

Below you can see one of the ways to mark a test as blocked.


My initial reaction was to say no and even dare to add  I was 99% sure. (famous last words).

The 1% has bothering me so I had to clear this one out to be 100% sure. While driving back I had an epiphany that it was Indeed possible and I was 100% wrong. Smile

Evidently I fall into the “since it’s not obvious it isn’t possible trap”.

But how can we do it?

After we mark a test has blocked, it will be clearly marked as so in the interface (the result for the last execution of the test)


The fact that the test was blocked also results in auto generation of a test result with a blocked result.  If we examine the test result we can see it is blocked (assuming you haven’t executed the test again), something that you can also see in the history of the test results:


If you want to register why a test has been blocked you can easily access the result and register a note on the blocked test result why the test is blocked.


The note will be visible on the test results history (screenshot below)


That is it. with a few quick steps we can have we can leave a trail as to why a test has been blocked.