Commit 4bc392b

@@ -21,6 +21,7 @@ namespace Gorilla.Commons.Infrastructure.Cloning
         protected static string file_name;
     }
 
+    [Concern(typeof(BinarySerializer<TestItem>))]
     public class when_serializing_an_item : behaves_like_serializer
     {
         it should_serialize_the_item_to_a_file = () => FileAssert.Exists(file_name);
@@ -28,6 +29,7 @@ namespace Gorilla.Commons.Infrastructure.Cloning
         because b = () => sut.serialize(new TestItem(string.Empty));
     }
 
+    [Concern(typeof(BinarySerializer<TestItem>))]
     public class when_deserializing_an_item : behaves_like_serializer
     {
         it should_be_able_to_deserialize_from_a_serialized_file = () => result.should_be_equal_to(original);

@@ -10,6 +10,7 @@ namespace Gorilla.Commons.Infrastructure.Container
     {
     }
 
+    [Concern(typeof(Resolve))]
     public class when_resolving_a_dependency_using_the_container : behaves_like_a_inversion_of_control_container
     {
         context c = () =>
@@ -34,6 +35,7 @@ namespace Gorilla.Commons.Infrastructure.Container
         static ICommand presenter;
     }
 
+    [Concern(typeof(Resolve))]
     public class when_resolving_a_dependency_that_is_not_registered_ : behaves_like_a_inversion_of_control_container
     {
         context c = () =>

@@ -6,7 +6,7 @@ using Rhino.Mocks;
 
 namespace Gorilla.Commons.Infrastructure.Eventing
 {
-    public class behaves_like_event_aggregator : concerns_for<IEventAggregator, EventAggregator>
+    public abstract class behaves_like_event_aggregator : concerns_for<IEventAggregator, EventAggregator>
     {
         public override IEventAggregator create_sut()
         {
@@ -14,6 +14,7 @@ namespace Gorilla.Commons.Infrastructure.Eventing
         }
     }
 
+    [Concern(typeof(EventAggregator))]
     public class when_a_event_is_raised_in_the_system : behaves_like_event_aggregator
     {
         it should_notify_all_subscribers_of_the_event = () =>
@@ -46,6 +47,7 @@ namespace Gorilla.Commons.Infrastructure.Eventing
         static IEventSubscriber<AnotherEvent> incorrect_subscriber;
     }
 
+    [Concern(typeof(EventAggregator))]
     public class when_publishing_a_call_to_all_subscribers : behaves_like_event_aggregator
     {
         it should_make_the_call_on_each_subscriber = () => connection.was_told_to(x => x.ChangeDatabase("localhost"));

@@ -7,6 +7,7 @@ namespace Gorilla.Commons.Infrastructure.Proxies
     {
     }
 
+    [Concern(typeof(ProxyFactory))]
     public class when_proxying_a_class_with_interceptors_applied : concerns
     {
         context c = () =>

@@ -13,6 +13,7 @@ namespace Gorilla.Commons.Infrastructure.Threading
         protected static IDependencyRegistry registry;
     }
 
+    [Concern(typeof (BackgroundThreadFactory))]
     public class when_creating_a_background_thread : behaves_like_a_background_thread_factory
     {
         it should_return_an_instance_of_a_background_thread = () => result.should_not_be_null();

@@ -18,6 +18,7 @@ namespace Gorilla.Commons.Infrastructure.Threading
         protected static IWorkerThread worker_thread;
     }
 
+    [Concern(typeof (BackgroundThread))]
     public class when_executing_a_command_on_a_background_thread : behaves_like_a_background_thread
     {
         it should_execute_the_command_asynchronously = () => command_to_execute.was_told_to(c => c.run());
@@ -31,6 +32,7 @@ namespace Gorilla.Commons.Infrastructure.Threading
                         };
     }
 
+    [Concern(typeof (BackgroundThread))]
     public class when_disposing_a_background_thread : behaves_like_a_background_thread
     {
         it should_dispose_the_command_running_on_the_thread = () => worker_thread.was_told_to(w => w.Dispose());

@@ -9,6 +9,7 @@ namespace Gorilla.Commons.Infrastructure.Threading
     {
     }
 
+    [Concern(typeof (CommandProcessor))]
     public class when_running_all_the_queued_commands_waiting_for_execution : behaves_like_a_command_processor
     {
         it should_run_the_first_command_in_the_queue = () => first_command.was_told_to(f => f.run());
@@ -32,6 +33,7 @@ namespace Gorilla.Commons.Infrastructure.Threading
         static ICommand second_command;
     }
 
+    [Concern(typeof (CommandProcessor))]
     public class when_attempting_to_rerun_the_command_processor : behaves_like_a_command_processor
     {
         it should_not_re_run_the_commands_that_have_already_executed =

@@ -14,6 +14,7 @@ namespace Gorilla.Commons.Infrastructure.Threading
         protected static ITimerFactory factory;
     }
 
+    [Concern(typeof (IntervalTimer))]
     public class when_starting_a_timer_for_a_new_client : behaves_like_an_interval_timer
     {
         static ITimerClient client;
@@ -34,6 +35,7 @@ namespace Gorilla.Commons.Infrastructure.Threading
         because b = () => sut.start_notifying(client, new TimeSpan(0, 10, 0));
     }
 
+    [Concern(typeof (IntervalTimer))]
     public class when_starting_a_timer_for_an_existing_client : behaves_like_an_interval_timer
     {
         it should_stop_the_previously_started_timer = () =>
@@ -65,6 +67,7 @@ namespace Gorilla.Commons.Infrastructure.Threading
         static Timer second_timer;
     }
 
+    [Concern(typeof (IntervalTimer))]
     public class when_a_timer_elapses : behaves_like_an_interval_timer
     {
         it should_notify_the_timer_client = () => client.was_told_to(c => c.notify());
@@ -86,6 +89,7 @@ namespace Gorilla.Commons.Infrastructure.Threading
                         };
     }
 
+    [Concern(typeof (IntervalTimer))]
     public class when_stopping_notifications_for_an_existing_timer_client : behaves_like_an_interval_timer
     {
         static ITimerClient client;
@@ -111,6 +115,7 @@ namespace Gorilla.Commons.Infrastructure.Threading
                         };
     }
 
+    [Concern(typeof (IntervalTimer))]
     public class when_attempting_to_stop_notification_for_a_client_that_doesnt_have_a_timer_started_for_it :
         behaves_like_an_interval_timer
     {

@@ -14,6 +14,7 @@ namespace Gorilla.Commons.Infrastructure.Threading
         }
     }
 
+    [Concern(typeof (TimerFactory))]
     public class when_creating_a_timer : behaves_like_a_timer_factory
     {
         it should_return_a_timer_with_the_correct_interval = () => result.Interval.should_be_equal_to(1000);
@@ -23,6 +24,7 @@ namespace Gorilla.Commons.Infrastructure.Threading
         static Timer result;
     }
 
+    [Concern(typeof (TimerFactory))]
     public class when_creating_a_timer_with_an_interval_in_milliseconds : behaves_like_a_timer_factory
     {
         it should_return_a_timer_with_the_correct_polling_interval =

@@ -9,6 +9,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
     {
     }
 
+    [Concern(typeof (ChangeTrackerFactory))]
     public class when_creating_a_change_tracker_for_an_item : concerns_for<IChangeTrackerFactory, ChangeTrackerFactory>
     {
         it should_return_a_new_tracker = () => result.should_not_be_null();

@@ -23,6 +23,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
         static protected IStatementRegistry registry;
     }
 
+    [Concern(typeof (ChangeTracker<IIdentifiable<Guid>>))]
     public class when_commit_that_changes_made_to_an_item : behaves_like_change_tracker
     {
         it should_save_the_changes_to_the_database = () => database.was_told_to(x => x.apply(statement));
@@ -51,6 +52,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
         static IStatement statement;
     }
 
+    [Concern(typeof (ChangeTracker<IIdentifiable<Guid>>))]
     public class when_checking_if_there_are_changes_and_there_are : behaves_like_change_tracker
     {
         it should_tell_the_truth = () => result.should_be_true();
@@ -75,6 +77,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
         static IIdentifiable<Guid> item;
     }
 
+    [Concern(typeof (ChangeTracker<IIdentifiable<Guid>>))]
     public class when_checking_if_there_are_changes_and_there_are_not : behaves_like_change_tracker
     {
         it should_tell_the_truth = () => result.should_be_false();

@@ -8,6 +8,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
     {
     }
 
+    [Concern(typeof (ContextFactory))]
     public class when_creating_a_new_context : concerns_for<IContextFactory, ContextFactory>
     {
         context c = () =>

@@ -12,6 +12,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
         }
     }
 
+    [Concern(typeof (IdentityMap<,>))]
     public class when_getting_an_item_from_the_identity_map_for_an_item_that_has_been_added : behaves_like_identity_map
     {
         it should_return_the_item_that_was_added_for_the_given_key = () => result.should_be_equal_to("1");
@@ -25,6 +26,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
         static string result;
     }
 
+    [Concern(typeof (IdentityMap<,>))]
     public class when_getting_an_item_from_the_identity_map_that_has_not_been_added : behaves_like_identity_map
     {
         it should_return_the_default_value_for_that_type = () => result.should_be_equal_to(null);
@@ -34,6 +36,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
         static string result;
     }
 
+    [Concern(typeof (IdentityMap<,>))]
     public class when_checking_if_an_item_has_been_added_to_the_identity_map_that_has_been_added :
         behaves_like_identity_map
     {
@@ -48,6 +51,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
         static bool result;
     }
 
+    [Concern(typeof (IdentityMap<,>))]
     public class when_checking_if_an_item_has_been_added_to_the_identity_map_that_has_not_been_added :
         behaves_like_identity_map
     {
@@ -58,6 +62,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
         static bool result;
     }
 
+    [Concern(typeof (IdentityMap<,>))]
     public class when_updating_the_value_for_a_key_that_has_already_been_added_to_the_identity_map :
         behaves_like_identity_map
     {
@@ -73,6 +78,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
         static string result;
     }
 
+    [Concern(typeof (IdentityMap<,>))]
     public class when_updating_the_value_for_a_key_that_has_not_been_added_to_the_identity_map :
         behaves_like_identity_map
     {

@@ -9,6 +9,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
     {
     }
 
+    [Concern(typeof (PerThreadScopedStorage))]
     public class when_retrieving_the_storage_for_a_specific_thread :
         concerns_for<IScopedStorage, PerThreadScopedStorage>
     {

@@ -7,6 +7,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
     {
     }
 
+    [Concern(typeof (SessionFactory))]
     public class when_creating_a_new_session : concerns_for<ISessionFactory, SessionFactory>
     {
         it should_return_a_new_session = () => result.should_not_be_null();

@@ -22,6 +22,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
         static protected IDatabase database;
     }
 
+    [Concern(typeof (Session))]
     public class when_saving_a_transient_item_to_a_session : behaves_like_session
     {
         it should_add_the_entity_to_the_identity_map = () => map.was_told_to(x => x.add(guid, entity));
@@ -45,6 +46,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
         static Guid guid;
     }
 
+    [Concern(typeof (Session))]
     public class when_commiting_the_changes_made_in_a_session : behaves_like_session
     {
         it should_commit_all_the_changes_from_the_running_transaction =
@@ -60,6 +62,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
                         };
     }
 
+    [Concern(typeof (Session))]
     public class when_closing_a_session_before_flushing_the_changes : behaves_like_session
     {
         it should_rollback_any_changes_made_in_the_current_transaction =
@@ -68,6 +71,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
         because b = () => sut.Dispose();
     }
 
+    [Concern(typeof (Session))]
     public class when_loading_all_instances_of_a_certain_type_and_some_have_already_been_loaded : behaves_like_session
     {
         it should_return_the_items_from_the_cache = () => results.should_contain(cached_item);
@@ -112,6 +116,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
         static ITestEntity uncached_item;
     }
 
+    [Concern(typeof (Session))]
     public class when_looking_up_a_specific_entity_by_its_id_and_it_has_not_been_loaded_into_the_cache :
         behaves_like_session
     {
@@ -143,6 +148,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
         static IIdentityMap<Guid, ITestEntity> map;
     }
 
+    [Concern(typeof (Session))]
     public class when_deleting_an_item_from_the_database : behaves_like_session
     {
         it should_remove_that_item_from_the_cache = () => map.was_told_to(x => x.evict(id));

@@ -14,6 +14,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
     {
     }
 
+    [Concern(typeof (ITrackerEntry<>))]
     public class when_comparing_the_current_instance_of_a_component_with_its_original_and_it_has_changes :
         behaves_like_tracker_entry
     {
@@ -29,6 +30,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
         static bool result;
     }
 
+    [Concern(typeof (ITrackerEntry<>))]
     public class when_the_original_instance_has_a_null_field_that_is_now_not_null :
         behaves_like_tracker_entry
     {
@@ -44,6 +46,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
         static bool result;
     }
 
+    [Concern(typeof (ITrackerEntry<>))]
     public class when_the_original_instance_had_a_non_null_field_and_the_current_instance_has_a_null_field :
         behaves_like_tracker_entry
     {
@@ -68,6 +71,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
         static Pillow current;
     }
 
+    [Concern(typeof (ITrackerEntry<>))]
     public class when_the_original_instance_has_the_same_value_as_the_current_instance :
         behaves_like_tracker_entry
     {

@@ -9,6 +9,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
     {
     }
 
+    [Concern(typeof (Transaction))]
     public class behaves_like_transaction : concerns_for<ITransaction, Transaction>
     {
         context c = () =>
@@ -23,6 +24,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
         static protected IChangeTrackerFactory factory;
     }
 
+    [Concern(typeof (Transaction))]
     public class when_creating_an_identity_map_for_a_specific_entity : behaves_like_transaction
     {
         it should_return_a_new_identity_map = () => result.should_not_be_null();
@@ -32,6 +34,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
         static IIdentityMap<Guid, IIdentifiable<Guid>> result;
     }
 
+    [Concern(typeof (Transaction))]
     public class when_committing_a_transaction_and_an_item_in_the_identity_map_has_changed : behaves_like_transaction
     {
         it should_commit_the_changes_to_that_item = () => tracker.was_told_to<IChangeTracker<IMovie>>(x => x.commit_to(database));
@@ -57,6 +60,7 @@ namespace Gorilla.Commons.Infrastructure.Transactions
         static IChangeTracker<IMovie> tracker;
     }
 
+    [Concern(typeof (Transaction))]
     public class when_deleting_a_set_of_entities_from_the_database : behaves_like_transaction
     {
         it should_prepare_to_delete_that_item_form_the_database = () => tracker.was_told_to(x => x.delete(movie));

@@ -8,6 +8,7 @@ using Gorilla.Commons.Testing;
 
 namespace Gorilla.Commons.Infrastructure.Autofac
 {
+    [Concern(typeof (ContainerBuilder))]
     public class when_trying_to_register_a_single_item_in_the_autofac_container : concerns
     {
         it should_resolve_that_item = () => result.should_be_an_instance_of<A>();
@@ -28,6 +29,7 @@ namespace Gorilla.Commons.Infrastructure.Autofac
         static ITestItem result;
     }
 
+    [Concern(typeof (ContainerBuilder))]
     public class when_trying_to_resolve_all_the_components_that_implement_a_common_interface : concerns
     {
         it should_return_each_component = () =>

@@ -6,7 +6,7 @@ using Gorilla.Commons.Testing;
 
 namespace Gorilla.Commons.Infrastructure.Castle.DynamicProxy.Interceptors
 {
-    [Concern(typeof (MethodCallTracker<IAnInterface>))]
+    [Concern(typeof (MethodCallTracker<>))]
     public class behaves_like_method_call_tracker :
         concerns_for<IMethodCallTracker<IAnInterface>, MethodCallTracker<IAnInterface>>
     {
@@ -16,6 +16,7 @@ namespace Gorilla.Commons.Infrastructure.Castle.DynamicProxy.Interceptors
         }
     }
 
+    [Concern(typeof (MethodCallTracker<>))]
     public class when_tracking_the_calls_to_intercept_on_a_type : behaves_like_method_call_tracker
     {
         static IInvocation invocation;

@@ -7,7 +7,7 @@ using MoMoney.Utility.Core;
 namespace Gorilla.Commons.Infrastructure.Castle.DynamicProxy.Interceptors
 {
     [Concern(typeof (RunOnBackgroundThreadInterceptor<>))]
-    public class behaves_like_background_thread_interceptor :
+    public abstract class behaves_like_background_thread_interceptor :
         concerns_for<IInterceptor, RunOnBackgroundThreadInterceptor<IDisposableCommand>>
     {
         context c = () => { thread_factory = the_dependency<IBackgroundThreadFactory>(); };
@@ -15,6 +15,7 @@ namespace Gorilla.Commons.Infrastructure.Castle.DynamicProxy.Interceptors
         static protected IBackgroundThreadFactory thread_factory;
     }
 
+    [Concern(typeof (RunOnBackgroundThreadInterceptor<>))]
     public class when_intercepting_a_call_to_a_method_that_takes_a_long_time_to_complete :
         behaves_like_background_thread_interceptor
     {

@@ -4,7 +4,7 @@ using Gorilla.Commons.Testing;
 namespace Gorilla.Commons.Infrastructure.Castle.DynamicProxy
 {
     [Concern(typeof (InterceptorConstraintFactory))]
-    public class behaves_like_constraint_factory :
+    public abstract class behaves_like_constraint_factory :
         concerns_for<IInterceptorConstraintFactory, InterceptorConstraintFactory>
     {
         context c = () => { method_call_tracker_factory = the_dependency<IMethodCallTrackerFactory>(); };
@@ -12,6 +12,7 @@ namespace Gorilla.Commons.Infrastructure.Castle.DynamicProxy
         protected static IMethodCallTrackerFactory method_call_tracker_factory;
     }
 
+    [Concern(typeof (InterceptorConstraintFactory))]
     public class when_creating_a_constraint_for_a_type_to_intercept_on : behaves_like_constraint_factory
     {
         static IInterceptorConstraint<string> result;

@@ -5,14 +5,15 @@ using Gorilla.Commons.Testing;
 
 namespace Gorilla.Commons.Infrastructure.Castle.DynamicProxy
 {
-    [Concern(typeof (InterceptorConstraint<string>))]
-    public class behaves_like_constraint : concerns_for<IInterceptorConstraint<string>, InterceptorConstraint<string>>
+    [Concern(typeof (InterceptorConstraint<>))]
+    public abstract class behaves_like_constraint : concerns_for<IInterceptorConstraint<string>, InterceptorConstraint<string>>
     {
         context c = () => { method_call_tracker = the_dependency<IMethodCallTracker<string>>(); };
 
         protected static IMethodCallTracker<string> method_call_tracker;
     }
 
+    [Concern(typeof (InterceptorConstraint<>))]
     public class when_asking_for_all_the_methods_to_intercept : behaves_like_constraint
     {
         static IEnumerable<string> result;

@@ -8,8 +8,8 @@ using Gorilla.Commons.Testing;
 
 namespace Gorilla.Commons.Infrastructure.Castle.DynamicProxy
 {
-    [Concern(typeof (ProxyBuilder<IAnInterface>))]
-    public class behaves_like_proxy_builder : concerns_for<IProxyBuilder<IAnInterface>, ProxyBuilder<IAnInterface>>
+    [Concern(typeof (ProxyBuilder<>))]
+    public abstract class behaves_like_proxy_builder : concerns_for<IProxyBuilder<IAnInterface>, ProxyBuilder<IAnInterface>>
     {
         public override IProxyBuilder<IAnInterface> create_sut()
         {
@@ -17,6 +17,7 @@ namespace Gorilla.Commons.Infrastructure.Castle.DynamicProxy
         }
     }
 
+    [Concern(typeof (ProxyBuilder<>))]
     public class when_building_a_proxy_for_a_type : behaves_like_proxy_builder
     {
         it should_make_sure_the_original_call_gets_forwarded_to_the_item_to_proxy =
@@ -54,6 +55,7 @@ namespace Gorilla.Commons.Infrastructure.Castle.DynamicProxy
     }
 
     [Integration]
+    [Concern(typeof (ProxyBuilder<>))]
     public class when_building_a_proxy_to_target_certain_methods_on_a_type : behaves_like_proxy_builder
     {
         it should_only_intercept_calls_on_the_method_that_was_specified =
@@ -84,6 +86,7 @@ namespace Gorilla.Commons.Infrastructure.Castle.DynamicProxy
         static IAnInterface an_implementation;
     }
 
+    [Concern(typeof (ProxyBuilder<>))]
     public class when_proxying_all_calls_on_a_target : behaves_like_proxy_builder
     {
         it should_intercept_each_call =

@@ -16,6 +16,7 @@ namespace Gorilla.Commons.Infrastructure.Castle.DynamicProxy
         }
     }
 
+    [Concern(typeof(ProxyFactory))]
     public class when_creating_a_proxy_with_a_target : behaves_like_proxy_factory
     {
         it should_forward_all_calls_to_the_target = () => target.was_told_to(x => x.Open());
@@ -43,6 +44,7 @@ namespace Gorilla.Commons.Infrastructure.Castle.DynamicProxy
         static TestInterceptor interceptor;
     }
 
+    [Concern(typeof(ProxyFactory))]
     public class when_creating_a_proxy_of_a_target_but_a_call_has_not_been_made_to_the_proxy_yet :
         behaves_like_proxy_factory
     {
@@ -57,6 +59,7 @@ namespace Gorilla.Commons.Infrastructure.Castle.DynamicProxy
         static IDisposable result;
     }
 
+    [Concern(typeof(ProxyFactory))]
     public class when_creating_a_proxy_of_a_component_that_does_not_implement_an_interface : behaves_like_proxy_factory
     {
         it should_return_a_proxy = () => AssertionExtensions.should_not_be_null(result);

@@ -9,7 +9,7 @@ using Gorilla.Commons.Utility.Extensions;
 
 namespace Gorilla.Commons.Infrastructure.Castle.Windsor
 {
-    internal class WindsorDependencyRegistry : IDependencyRegistration, IDependencyRegistry
+    public class WindsorDependencyRegistry : IDependencyRegistration, IDependencyRegistry
     {
         readonly IWindsorContainer underlying_container;
 

@@ -7,12 +7,12 @@ using Gorilla.Commons.Testing;
 namespace Gorilla.Commons.Infrastructure.Castle.Windsor
 {
     [Concern(typeof (WindsorDependencyRegistry))]
-    internal class behaves_like_windsor_dependency_registry :
-        concerns_for<IDependencyRegistry, WindsorDependencyRegistry>
+    public abstract class behaves_like_windsor_dependency_registry : concerns_for<IDependencyRegistry, WindsorDependencyRegistry>
     {
     }
 
-    internal class when_registering_a_singleton_component_with_the_windsor_container :
+    [Concern(typeof (WindsorDependencyRegistry))]
+    public class when_registering_a_singleton_component_with_the_windsor_container :
         behaves_like_windsor_dependency_registry
     {
         it should_return_the_same_instance_each_time_its_resolved =

@@ -18,6 +18,7 @@ namespace Gorilla.Commons.Infrastructure
         protected static IDependencyRegistry test_container;
     }
 
+    [Concern(typeof (Lazy))]
     public class when_calling_a_method_with_no_arguments_on_a_lazy_loaded_proxy : behaves_like_a_lazy_loaded_object
     {
         it should_forward_the_original_call_to_the_target = () => target.was_told_to<ITargetObject>(t => t.OneMethod());
@@ -37,6 +38,7 @@ namespace Gorilla.Commons.Infrastructure
         static ITargetObject target;
     }
 
+    [Concern(typeof (Lazy))]
     public class when_calling_a_method_that_returns_an_argument_on_a_lazy_loaded_proxy :
         behaves_like_a_lazy_loaded_object
     {
@@ -59,6 +61,7 @@ namespace Gorilla.Commons.Infrastructure
         static int result;
     }
 
+    [Concern(typeof (Lazy))]
     public class when_calling_different_methods_on_an_proxied_object : behaves_like_a_lazy_loaded_object
     {
         it should_only_load_the_object_once =
@@ -78,6 +81,7 @@ namespace Gorilla.Commons.Infrastructure
                         };
     }
 
+    [Concern(typeof (Lazy))]
     public class when_calling_a_method_that_takes_in_a_single_input_parameter_on_a_proxied_object :
         behaves_like_a_lazy_loaded_object
     {
@@ -104,6 +108,7 @@ namespace Gorilla.Commons.Infrastructure
         static int result;
     }
 
+    [Concern(typeof (Lazy))]
     public class when_accessing_the_value_of_a_property_on_a_proxied_object : behaves_like_a_lazy_loaded_object
     {
         it should_return_the_correct_value = () => result.should_be_equal_to("mo");
@@ -125,6 +130,7 @@ namespace Gorilla.Commons.Infrastructure
         static string result;
     }
 
+    [Concern(typeof (Lazy))]
     public class when_setting_the_value_of_a_property_on_a_proxied_object : behaves_like_a_lazy_loaded_object
     {
         it should_set_the_value_on_the_original_target =
@@ -145,6 +151,7 @@ namespace Gorilla.Commons.Infrastructure
         static ITargetObject target;
     }
 
+    [Concern(typeof (Lazy))]
     public class when_calling_a_generic_method_on_a_proxied_object : behaves_like_a_lazy_loaded_object
     {
         it should_forward_the_call_to_the_target =

@@ -7,6 +7,7 @@ namespace Gorilla.Commons.Utility.Core
     {
     }
 
+    [Concern(typeof (NotSpecification<>))]
     public class when_checking_if_a_condition_is_not_met : concerns_for<ISpecification<int>, NotSpecification<int>>
     {
         static protected ISpecification<int> criteria;
@@ -19,6 +20,7 @@ namespace Gorilla.Commons.Utility.Core
         }
     }
 
+    [Concern(typeof (NotSpecification<>))]
     public class when_a_condition_is_not_met : when_checking_if_a_condition_is_not_met
     {
         context c = () => when_the(criteria).is_told_to(x => x.is_satisfied_by(1)).it_will_return(false);
@@ -30,6 +32,7 @@ namespace Gorilla.Commons.Utility.Core
         static bool result;
     }
 
+    [Concern(typeof (NotSpecification<>))]
     public class when_a_condition_is_met : when_checking_if_a_condition_is_not_met
     {
         context c = () => when_the(criteria).is_told_to(x => x.is_satisfied_by(1)).it_will_return(true);

@@ -3,8 +3,8 @@ using Gorilla.Commons.Testing;
 
 namespace Gorilla.Commons.Utility.Core
 {
-    public abstract class when_checking_if_one_of_two_conditions_are_met :
-        concerns_for<ISpecification<int>, OrSpecification<int>>
+    [Concern(typeof (OrSpecification<>))]
+    public abstract class when_checking_if_one_of_two_conditions_are_met : concerns_for<ISpecification<int>, OrSpecification<int>>
     {
         public override ISpecification<int> create_sut()
         {
@@ -21,6 +21,7 @@ namespace Gorilla.Commons.Utility.Core
         protected static ISpecification<int> right;
     }
 
+    [Concern(typeof (OrSpecification<>))]
     public class when_one_of_the_conditions_is_met : when_checking_if_one_of_two_conditions_are_met
     {
         it should_return_true = () => result.should_be_true();
@@ -31,6 +32,7 @@ namespace Gorilla.Commons.Utility.Core
         static bool result;
     }
 
+    [Concern(typeof (OrSpecification<>))]
     public class when_the_second_condition_is_met : when_checking_if_one_of_two_conditions_are_met
     {
         it should_return_true = () => result.should_be_true();
@@ -41,6 +43,7 @@ namespace Gorilla.Commons.Utility.Core
         static bool result;
     }
 
+    [Concern(typeof (OrSpecification<>))]
     public class when_neither_conditions_are_met : when_checking_if_one_of_two_conditions_are_met
     {
         it should_return_false = () => result.should_be_false();

@@ -8,6 +8,7 @@ namespace Gorilla.Commons.Utility.Extensions
     {
     }
 
+    [Concern(typeof (EnumerableExtensions))]
     public class when_joining_one_collection_with_another : concerns
     {
         it should_return_the_items_from_both = () =>
@@ -21,6 +22,7 @@ namespace Gorilla.Commons.Utility.Extensions
         static IEnumerable<int> results;
     }
 
+    [Concern(typeof (EnumerableExtensions))]
     public class when_attemping_to_join_a_list_with_a_null_value : concerns
     {
         it should_return_the_original_list = () => new List<int> {1}.join_with(null).should_contain(1);

@@ -4,6 +4,7 @@ using Gorilla.Commons.Testing;
 
 namespace Gorilla.Commons.Utility.Extensions
 {
+    [Concern(typeof (ListExtensions))]
     public class when_adding_an_item_to_a_list : concerns
     {
         because b = () =>
@@ -17,6 +18,7 @@ namespace Gorilla.Commons.Utility.Extensions
         static List<string> list;
     }
 
+    [Concern(typeof (ListExtensions))]
     public abstract class when_asked_to_only_add_an_item_to_a_list_if_a_condition_is_not_met : concerns
     {
         context c = () => { list = new List<string>(); };
@@ -24,6 +26,7 @@ namespace Gorilla.Commons.Utility.Extensions
         static protected List<string> list;
     }
 
+    [Concern(typeof (ListExtensions))]
     public class when_the_condition_is_not_met : when_asked_to_only_add_an_item_to_a_list_if_a_condition_is_not_met
     {
         because b = () => list.add("mo").unless(x => false);
@@ -31,6 +34,7 @@ namespace Gorilla.Commons.Utility.Extensions
         it should_add_the_item_to_the_list = () => list.should_contain("mo");
     }
 
+    [Concern(typeof (ListExtensions))]
     public class when_the_condition_is_met : when_asked_to_only_add_an_item_to_a_list_if_a_condition_is_not_met
     {
         because b = () => list.add("mo").unless(x => true);
@@ -38,6 +42,7 @@ namespace Gorilla.Commons.Utility.Extensions
         it should_not_add_the_item_to_the_list = () => list.should_not_contain("mo");
     }
 
+    [Concern(typeof (ListExtensions))]
     public class when_some_of_the_items_meet_the_conditions_and_some_do_not :
         when_asked_to_only_add_an_item_to_a_list_if_a_condition_is_not_met
     {

@@ -1,9 +1,8 @@
 using developwithpassion.bdd.contexts;
 using Gorilla.Commons.Testing;
 using Gorilla.Commons.Utility.Core;
-using Gorilla.Commons.Utility.Extensions;
 
-namespace MoMoney.Utility.Extensions
+namespace Gorilla.Commons.Utility.Extensions
 {
     [Concern(typeof (MappingExtensions))]
     public class when_transforming_type_A_to_type_B_then_C : concerns
@@ -16,8 +15,8 @@ namespace MoMoney.Utility.Extensions
                             second_mapper = an<IMapper<string, int>>();
                             a = 1;
 
-                            MockingExtensions.it_will_return(MockingExtensions.is_told_to(when_the(first_mapper), x => x.map_from(a)), "1");
-                            MockingExtensions.it_will_return(MockingExtensions.is_told_to(when_the(second_mapper), x => x.map_from("1")), 1);
+                            when_the(first_mapper).is_told_to(x => x.map_from(a)).it_will_return("1");
+                            when_the(second_mapper).is_told_to(x => x.map_from("1")).it_will_return(1);
                         };
 
         because b = () => { result = first_mapper.then(second_mapper).map_from(a); };

@@ -3,6 +3,7 @@ using Gorilla.Commons.Testing;
 
 namespace Gorilla.Commons.Utility.Extensions
 {
+    [Concern(typeof (NumericConversions))]
     public class when_converting_a_valid_string_to_a_long : concerns
     {
         it should_return_the_correct_result = () => result.should_be_equal_to(88L);
@@ -15,6 +16,7 @@ namespace Gorilla.Commons.Utility.Extensions
         static string valid_numeric_string;
     }
 
+    [Concern(typeof (NumericConversions))]
     public class when_converting_a_valid_string_to_an_int : concerns
     {
         it should_return_the_correct_result = () => result.should_be_equal_to(66);

@@ -4,7 +4,7 @@ using Gorilla.Commons.Utility.Core;
 
 namespace Gorilla.Commons.Utility.Extensions
 {
-    public class when_evaluating_two_conditions : concerns
+    public abstract class when_evaluating_two_conditions : concerns
     {
         context c = () =>
                         {
@@ -16,6 +16,7 @@ namespace Gorilla.Commons.Utility.Extensions
         static protected ISpecification<int> right;
     }
 
+    [Concern(typeof (SpecificationExtensions))]
     public class when_checking_if_two_conditions_are_met_and_they_are : when_evaluating_two_conditions
     {
         it should_return_true = () => result.should_be_true();
@@ -31,6 +32,7 @@ namespace Gorilla.Commons.Utility.Extensions
         static bool result;
     }
 
+    [Concern(typeof (SpecificationExtensions))]
     public class when_checking_if_one_of_two_conditions_are_met_and_the_left_one_is_not : when_evaluating_two_conditions
     {
         it should_return_true = () => result.should_be_true();
@@ -46,6 +48,7 @@ namespace Gorilla.Commons.Utility.Extensions
         static bool result;
     }
 
+    [Concern(typeof (SpecificationExtensions))]
     public class when_checking_if_one_of_two_conditions_are_met_and_the_right_one_is_not :
         when_evaluating_two_conditions
     {

@@ -4,17 +4,20 @@ using Gorilla.Commons.Utility.Core;
 
 namespace Gorilla.Commons.Utility.Extensions
 {
+    [Concern(typeof (TypeExtensions))]
     public class when_getting_the_last_interface_for_a_type : concerns
     {
         it should_return_the_correct_one =
             () => typeof (TestType).last_interface().should_be_equal_to(typeof (ITestType));
     }
 
+    [Concern(typeof (TypeExtensions))]
     public class when_getting_the_first_interface_for_a_type : concerns
     {
         it should_return_the_correct_one = () => typeof (TestType).first_interface().should_be_equal_to(typeof (IBase));
     }
 
+    [Concern(typeof (TypeExtensions))]
     public class when_checking_if_a_type_represents_a_generic_type_definition : concerns
     {
         it should_tell_the_truth = () => { 

@@ -3,26 +3,31 @@ using Gorilla.Commons.Testing;
 
 namespace Gorilla.Commons.Utility
 {
+    [Concern(typeof (Percent))]
     public class when_comparing_fifty_divided_by_one_hundred_to_fifty_percent : concerns
     {
         it they_should_be_equal = () => new Percent(50, 100).should_be_equal_to<Percent>(50);
     }
 
+    [Concern(typeof (Percent))]
     public class when_calculating_a_fractional_percentage : concerns
     {
         it should_return_the_correct_percentage = () => new Percent(30, 90).should_be_equal_to<Percent>(33.3);
     }
 
+    [Concern(typeof (Percent))]
     public class when_checking_if_50_percent_is_less_than_51_percent : concerns
     {
         it should_return_true = () => new Percent(50).is_less_than(new Percent(51)).should_be_true();
     }
 
+    [Concern(typeof (Percent))]
     public class when_checking_if_51_percent_is_less_than_50_percent : concerns
     {
         it should_return_false = () => new Percent(51).is_less_than(new Percent(50)).should_be_false();
     }
 
+    [Concern(typeof (Percent))]
     public class when_checking_if_50_percent_is_less_than_50_percent : concerns
     {
         it should_return_false = () => new Percent(50).is_less_than(new Percent(50)).should_be_false();

@@ -9,7 +9,7 @@ namespace Gorilla.Commons.Windows.Forms.Databinding
     {
     }
 
-    [Concern(typeof (BindingSelector<IAnInterface>))]
+    [Concern(typeof (BindingSelector<>))]
     public class when_selecting_a_property_as_the_target_of_a_binding : concerns_for<IBindingSelector<IAnInterface>>
     {
         it should_return_a_binder_bound_to_the_correct_property =

@@ -4,7 +4,7 @@ using Gorilla.Commons.Testing;
 
 namespace Gorilla.Commons.Windows.Forms.Databinding
 {
-    [Concern(typeof (PropertyBinder<IAnInterface, string>))]
+    [Concern(typeof (PropertyBinder<,>))]
     public abstract class behaves_like_a_property_binder :
         concerns_for<IPropertyBinder<IAnInterface, string>, PropertyBinder<IAnInterface, string>>
     {
@@ -23,6 +23,7 @@ namespace Gorilla.Commons.Windows.Forms.Databinding
         static protected PropertyInfo property;
     }
 
+    [Concern(typeof (PropertyBinder<,>))]
     public class when_changing_the_value_of_correctly_bound_property : behaves_like_a_property_binder
     {
         it should_update_the_value_of_the_property_of_the_target_of_the_binder =
@@ -33,6 +34,7 @@ namespace Gorilla.Commons.Windows.Forms.Databinding
         const string first_name = "mo";
     }
 
+    [Concern(typeof (PropertyBinder<,>))]
     public class when_retrieving_the_current_value_of_a_bound_property : behaves_like_a_property_binder
     {
         it should_return_the_correct_value = () => result.should_be_equal_to("malik");

@@ -4,7 +4,7 @@ using Gorilla.Commons.Testing;
 
 namespace Gorilla.Commons.Windows.Forms.Databinding
 {
-    [Concern(typeof (PropertyInspector<IAnInterface, string>))]
+    [Concern(typeof (PropertyInspector<,>))]
     public class when_parsing_a_valie_expression_for_the_information_on_the_property :
         concerns_for<IPropertyInspector<IAnInterface, string>, PropertyInspector<IAnInterface, string>>
     {

@@ -5,13 +5,14 @@ using Gorilla.Commons.Testing;
 
 namespace Gorilla.Commons.Windows.Forms.Helpers
 {
+    [Concern(typeof (EventTrigger))]
     public class when_invoking_a_call_on_a_target_via_reflection : concerns
     {
         it should_correctly_call_that_method =
             () =>
                 {
-                    Assertions.should_be_true(control.called_on_key_press);
-                    Assertions.should_be_false(control.called_on_enter);
+                    control.called_on_key_press.should_be_true();
+                    control.called_on_enter.should_be_false();
                 };
 
         context c = () => { control = new TestControl(); };
@@ -23,6 +24,7 @@ namespace Gorilla.Commons.Windows.Forms.Helpers
         static TestControl control;
     }
 
+    [Concern(typeof (EventTrigger))]
     public class when_invoking_a_call_on_a_target_by_passing_in_a_parameter : concerns
     {
         it should_make_the_call_correctly = () => control.key_press_arguments.should_be_equal_to(args);