I’ve been using E-TextEditor Buy Clonidine Without Prescription, for more than a year now for doing all my JavaScript, Node.js and CoffeeScript development. Clonidine from mexico, You can think of E-TextEditor as TextMate for the Windows platform. I’ve been pretty happy with it throughout this period as it can be extended pretty easily with a whole slew of bundles that are already available for TextMate, cheap Clonidine. Clonidine recreational, E-TextEditor requires you to install Cygwin which happens automatically during installation. Using the Cygwin command-line gave me enough (re-)exposure to a Linux-like environment in order for me wanting to (re-)learn about this other platform, purchase Clonidine for sale. More on that in later blog posts, Buy Clonidine Without Prescription. Low dose Clonidine, Although there haven’t been any new versions of E-TextEditor for quite some time now, the current version enabled me to write JavaScript code in a productive way.

Only recently I found out about another editor called Sublime Text 2 (thanks to Ivan Porto Carrero), Clonidine description. Clonidine overnight, I downloaded this text editor in order to give it a try and I must say that I haven’t opened E-TextEditor ever since. This second version of Sublime Text is still in development but it’s pretty stable as I haven’t run into any issues so far, Clonidine no prescription. Clonidine brand name, The cool part is that this editor is available for both Windows, Linux and OS X which enabled me to move all my Node.js and CoffeeScript development from Cygwin on Windows to Ubuntu Linux. 

CoffeeScript isn’t supported out-of-the-box (yet), purchase Clonidine, Clonidine gel, ointment, cream, pill, spray, continuous-release, extended-release, so I installed the CoffeeScript  TextMate bundle written by Jeremy Ashkenas (yes, the same one from the CoffeeScript and Backbone.js fame), Clonidine long term. Also check out this page on the CoffeeScript wiki for more information on how to bring some CoffeeScript happiness to your own favorite text editor.

Buy Clonidine Without Prescription, Setting up this TextMate bundle for use with Sublime Text 2 was actually pretty easy. Clonidine canada, mexico, india, Just navigate to /home/<my_user_name>/.config/sublime-text-2/Packages in a terminal (or the corresponding file path on Windows) and clone the source of the CoffeeScript TextMate bundle using git:

git clone git://github.com/jashkenas/coffee-script-tmbundle CoffeeScript

Next close all the .coffee files and restart Sublime Text 2. Now we have some nice syntax highlighting and some useful code snippets at our disposal. 

It's also possible to hook into the build system of Sublime Text 2, Clonidine australia, uk, us, usa. Clonidine blogs, You just need to create a new file named CoffeeScript.sublime-build at the following location:

/home/<my_user_name>/.config/sublime-text-2/Packages/User 

You can add the following to this new file for compiling CoffeeScript

{     "cmd": ["coffee", "-c", Clonidine from canada, Is Clonidine addictive, "$file"],     "selector" : "source.coffee", Clonidine pharmacy, Ordering Clonidine online, "path" : "/usr/local/bin"}

{     "cmd": ["coffee", Clonidine for sale, What is Clonidine, "$file"],     "selector" : "source.coffee", get Clonidine, Clonidine class, "path" : "/usr/local/bin"}

Now when you hit F7, this fresh build command is executed when a CoffeeScript source file is showing in the active tab, cheap Clonidine no rx. It’s also possible to change the build short-key to your own taste through the Preferences menu, Buy Clonidine Without Prescription. Fast shipping Clonidine,

Unfortunately, there’s only one build command as I would love to create a separate command for compiling and running CoffeeScript code (or perhaps I missed this feature during the excitement ), buy generic Clonidine. Is Clonidine safe,

Some more usage is definitely needed for me to learn more about this excellent text editor, but currently I’m pretty happy with it, Clonidine trusted pharmacy reviews. Taking Clonidine, I also need to find out how well JavaScript is supported and perhaps see how far one can go when doing some C# development using Mono. I expect that there are a good number of productive features in there for me to discover.

I encourage you have a decent look at this excellent tool, Clonidine dangers. Order Clonidine from mexican pharmacy,

Until next time.

Similar posts: Stromectol For Sale. Buy Soma Without Prescription. Buy Atenolol Without Prescription. Buy Female Pink Viagra Without Prescription. Vermox For Sale. Where can i buy cheapest Antabuse online. Slimex (Obetrim) photos. Augmentin description. Buy Colchicine no prescription. Clonidine natural.
Trackbacks from: Buy Clonidine Without Prescription. Buy Clonidine Without Prescription. Buy Clonidine Without Prescription. Buy Clonidine Without Prescription. Buy Clonidine Without Prescription. Kjøpe Clonidine på nett, köpa Clonidine online. Buy cheap Clonidine no rx. Clonidine use. Clonidine no rx. Online buying Clonidine hcl.

The project started out a couple of years ago on Google code and was first initiated by James Avery. Contribution stopped at some point until recently where Svein Arne Ackenhausen forked the source code and put it on GitHub. Now it runs both for .NET as well as Mono, with NUnit, MSTest and xUnit as the currently supported unit test frameworks.

Here’s a screenshot from the feedback window when all tests pass:

And here you can see the same window after I broke one of my unit tests:

Here you can see which particular unit test has been broken and by clicking the specified link you end up at the right source file in Visual Studio.

I encourage you to pick up this small tool and learn how it can facilitate your TDD flow. Take a look at this page in order to get up-and-running in no time. Also don’t forget to provide the owner(s) of this project with some feedback that you might have. Svein has been very helpful over the last week answering all my stupid questions and remarks (and the Nobel price for this year’s most patient person goes to … ;-) ).

I would definitely like to see this tool becoming more popular, so go check it out.  

This post started to get a little long, so I won’t re-explain the concept.

Joshua Flanagan wrote a nice overview at his Los Techies blog: Auto mocking Explained.

My post is mainly here to describe the Unity version of an automocking container I threw together.

In Jan 2009 I blogged about my initial version of the Unity AutoMocker - Why am I blogging about it again?

I originally wrote the AutoMocker for the Unity container a year ago (Jan 2009, in Silverlight), and finally got around to placing the code up in the moq-contrib project in June of 2009.

I’m writing another post today in hopes to:

1. Get some feedback on how this little snippet of code should continue.
2. Give a little more how-to/example code
3. Describe some updates I made since I originally created it. 

Where can I get it?

This is one part where I’d appreciate some feedback.

I have two slightly different versions out there (currently).

I have one version at the ElegantCode repository where I was working on it, and the other I threw up at moq-contrib.

The core of the UnityAutoMockContainer is the same in both places, it’s how the tests are separated out that differ.

In the ElegantCode repository it’s an all in one self contained single file (that you can copy into your own test project(s)). You can then setup a single test in your own testing framework that runs all internal automocker tests (in case you need to modify it yourself, and don’t want to break any existing functionality). EX: test

[Test]
public void Should_run_all_UnityAutoMockContainer_internal_tests()
{
    Moq.AutoMocking.SelfTesting.UnityAutoMockContainerFixture
        .RunAllTests(Console.WriteLine);
}

I kind of like this format as it makes it easy to port between test libraries. Can’t say I like having the tests in the same file as the core, but it certainly is not a large chunk of code (so far) so it’s relatively small to maintain and definitely easier to manage as a single .cs file than another assembly (which would have to be version dependent on both Unity and Moq).

The moq-contrib is definitely where I think this helper should end up (and it is there). I just happened to break the tests out into the Silverlight test project and the core is alone in a file.

It’s current state isn’t as easy to copy to a test library (Silverlight/Desktop/Unity 1.2/Unity 2.0) as the one at ElegantCode. What does anyone think? Should I put them all together in one file?

However it ends up (1. all in one file or two (1 test) (1 core)) it will continue to be maintained on the moq-contrib project.

What is the high level API of the container?

It’s pretty simple, (currently) there are four methods on the container.

Two for registering items with the container. Say you want to register an already created instance, or say you want to map an interface to a concrete class and _not_ have the container generate mocks automatically for special cases.

And two for pulling items out of the container. Whether you want a instance of T or a Mock<T>, it gives you ways to retrieve both.

How can I setup my own registrations with the container?

Say I don’t want to have the container generate mocks for specific items and I want to supply specific configuration to the UnityContainer.

public UnityAutoMockContainer RegisterInstance<TService>(TService instance)

public UnityAutoMockContainer Register<TService, TImplementation>()
                where TImplementation : TService

Note: both of these registration methods return the container itself so you can fluently stack registration. EX:

AutoMockContainer
    .Register<IServiceA, ServiceA>()
    .Register<IServiceB, ServiceB>();

Let me know: I haven’t tested or played around with how this automocking container deals with any container specific xml configuration… So although I don’t think you should probably have that in a test assembly (stuff happens). Let me know if there are any issues.

How do I get items out of the container?

First is the Resolve<T>(). It will pull an item T out of the container. (Creating it if not already existing)

public T Resolve<T>()

When T is an interface Resolve<T> (unless you setup registration specifically with the container) should return basically “(new Mock<T>()).Object”

When T is a concrete Class, the container should return an instance of T and any of it’s dependencies will be satisfied by mocks. (Note that T will not be any sort of mocked instance of T, unless you used the GetMock<T> as described below first)

public Mock<T> GetMock<T>() where T : class

When T is an interface GetMock<T> should return basically “(new Mock<T>())”

When T is a concrete Class, the container should return a new Mock<T>() and any of it’s dependencies will be satisfied by mocks.

How do I use the UnityAutoMockContainer?

It’s pretty basic, you first create an instance of the UnityAutoMockContainer, and from there you can ask it for mocks of an (Interface, Class, or Abstract Class).

If you request an instance of a concrete class, or abstract class, the UnityAutoMockContainer will stuff mocks in for any constructor dependencies of your concrete class (if it can). You can then request from the container those same dependencies one at a time and either apply mocking setups or verifications.

NOTE: Anything the container creates will live as a singleton instance in the container. So any other requests from the container will always return the originally created instance. Therefore, each distinct scenario in a test suite should have their own instances of the container.

Below his an example of how you can leverage the container in some tests. Given this base fixture class…

public class FixtureBase
{
    private readonly UnityAutoMockContainer _autoMockContainer = new UnityAutoMockContainer();

    protected UnityAutoMockContainer AutoMockContainer
    {
        get { return _autoMockContainer; }
    }

    [TestFixtureSetUp]
    public void SetupContext_ALL()
    {
        Before_all_tests();
        Because();
    }

    [TestFixtureTearDown]
    public void TearDownContext_ALL()
    {
        After_all_tests();
    }

    protected virtual void Before_all_tests()
    {
    }

    protected virtual void Because()
    {
    }

    protected virtual void After_all_tests()
    {
    }
}

If I were given the following system to test.

public interface IServiceA { void RunA(); }
public interface IServiceB { void RunB(); }

public class TestComponent
{
    public TestComponent(IServiceA serviceA, IServiceB serviceB)
    {
        ServiceA = serviceA;
        ServiceB = serviceB;
    }

    public IServiceA ServiceA { get; private set; }
    public IServiceB ServiceB { get; private set; }

    public void RunAll()
    {
        if (!HowDidItGo())
            return;
        ServiceA.RunA();
        ServiceB.RunB();
    }

    public virtual bool HowDidItGo()
    {
        // some really nasty untestable code
        return true;
    }
}

The below example demonstrates simply verifying some behavior on the mocked dependencies of the system under test.

[TestFixture]
public class Example__how_to_pull_items_from_the_UnityAutoMockContainer_when_verifying_behavior_after_an_action_was_taken 
    : FixtureBase
{
    private TestComponent _testComponent;

    protected override void Before_all_tests()
    {
        base.Before_all_tests();
        _testComponent = AutoMockContainer.Resolve<TestComponent>();
    }

    protected override void Because()
    {
        _testComponent.RunAll();
    }

    [Test]
    public void Should_run_ServiceA_RunA()
    {
        AutoMockContainer
            .GetMock<IServiceA>()
            .Verify(v => v.RunA(), Times.Once());
    }

    [Test]
    public void Should_run_ServiceB_RunB()
    {
        AutoMockContainer
            .GetMock<IServiceB>()
            .Verify(v => v.RunB(), Times.Once());
    }
}

Next, you may have noticed that the system under test had a complicated internal method (that may not necessarily be testable). You can use the AutoMocker to create the system under test as a Mock itself, so we can override some of the behavior. Here’s how you could quickly do that.

Aside: I’m not saying this is a good practice or aids in good component design, just saying it’s possible

[TestFixture]
public class Example__how_to_use_the_UnityAutoMockContainer_to_override_a_method_on_the_SystemUnderTest_to_test_a_certain_behavior
    : FixtureBase
{

    private TestComponent _testComponent;

    protected override void Before_all_tests()
    {
        base.Before_all_tests();
        var mockTestComponent = AutoMockContainer.GetMock<TestComponent>();

        mockTestComponent
            .Setup(s => s.HowDidItGo())
            .Returns(false);

        _testComponent = mockTestComponent.Object;
    }

    protected override void Because()
    {
        _testComponent.RunAll();
    }

    [Test]
    public void Should_run_ServiceA_RunA()
    {
        AutoMockContainer
            .GetMock<IServiceA>()
            .Verify(v => v.RunA(), Times.Never());
    }

    [Test]
    public void Should_run_ServiceB_RunB()
    {
        AutoMockContainer
            .GetMock<IServiceB>()
            .Verify(v => v.RunB(), Times.Never());
    }
}

It’s amazing how much redundant test setup code this little helper has saved me in my tests. I hope others can find some use with this as well.

What is it? (Silverlight Testing Automation Tool)

Where can I get StatLight?

Happy Coding !!!

This can be a favorite move of vendors who give away thumb drives at conferences as swag. They want to launch their little demo app or whatever when you plug in the drive.

It can be very annoying.

I am trying to create a Win7 install thumb drive for my wife’s netbook and I have a great 4G thumb drive to hold the media. Unfortunately, my thumb drive had this U3 stuff on it and won’t work as a boot disc as long as that pesky software is on it.

The simple answer is this little utility: U3Uninstall.exe. After running this utility on the thumb drive I have a plain ole storage drive I can use as a Win7 bootable install disc.

Here’s a pointer to the article.

Jeremy’s other contributions to the community include StructureMap and an obtuse fascination with separation patterns for user interfaces.

Story Teller is an alternative for Fitnesse, implemented in .NET and chases the holy grail of executable requirements. If you are interested in how to achieve the promise of shared and executable requirements, this just might be your tool.

• Story Teller
• Jeremy’s StoryTeller post on a preview release

Get the show here

Duh.

I have worked with Team System quite a bit and with alternatives just as much. With a lot of experience behind me on this, I feel confident I can make a legitimate case for using Team System in a small team.

I consider a small team a development organization of fewer than 10 people.

Some Context and Disclosure

• I am a Team System MVP
• I use Team System on a daily basis
• I use SVN+Team City on a daily basis
• I care more about pragmatism and craftsmanship than tooling, and that means focusing on how to use tools, not just the tools themselves
• I have been present on day one of a brand new team
• I have been in a team that has grown quickly over a short time

Focus on the Work

What happens when teams squabble about tools instead of just getting on with it? Lots of churn and wasted energy, is my experience.

I can report having seen small teams succeed and fail. The success or failure in both cases obviously has a lot more to do with leadership and business than developer tools, but I can also say the way companies approach developer tooling can have a lot to do with culture.

Any startup or small team simply must be focused to succeed. This can also be extremely difficult to achieve. A small team simply doesn’t have the capacity or depth to be distracted with issues not pertaining to delivering product. Paradoxically, team members are often wearing several hats. That is, everyone is doing a little of everything. That can quickly trend to entropy, because no one ends focusing on the work at hand.

The last thing I want to do on day 1 of a new team, or very often in a small teams, is visit tooling. Not deliberately making choices about tooling, though, will eventually bite you. Hard. How many of us are in organizations with over 2 brands of source control systems because new ones were added in an ad-hoc manor? I’ve been there. How many unit test frameworks are being used? I have been on a team that used 4 at once. Think that caused some problems?

As team lead, I care far less about optimizations of specific tools, and far more about a cohesive and fluid process enabling flow within the team. I care a great deal that there is a single source of truth for requirements and very little that we are using the coolest new unit test framework.

Often, focusing on work simply means implementing a system of tools and getting past the discussion. Have you ever heard developers purse fight over text editors? Now, there’s a constructive use of energy. The same thing can happen when geeks whip out their favorite source control, merge tools, unit testing frameworks, Visual Studio add-ins, logging library, laptop brand, or bug tracking system.

Point number one is let’s get past the time suck of the my-NAnt-is-better-than-your-MS-Build and just prescribe a toolset so we can get on with the real business of our team.

Team System is Like a Box of Tools at Sears

When I go to Sears and browse the Craftsman (or DeWalt) tools, I usually see some interesting little specialty tools. I might buy a funky swivel socket or a single ratchet, but I rarely browse the aisle with the large all-in-one kits. The reason I don’t browse the kit aisle is because my father-in-law bought be a basic Craftsman starter kit almost 20 years ago and my collection of tools has grown over time.

I don’t still have all of the tools in that original kit, but I do still have many of them. Further, my need for hand tools have gotten more specialized over time. Also, I am making a bit more money than I was when I married my wife, so I may spend extra for a special-purpose hammer rather than always relying on the one that came in the original kit.

Without that original kit, though, I would never have been able to even get started. No, it didn’t have every tool I would ever need, but it had almost everything I needed right then.

Team System is much the same. A team can absolutely hit the ground running with the rich toolset VSTS provides. Maybe you’ll augment the toolbox over time. Maybe you’ll even change tools (can anyone say [TestClass]?) but the kit that comes in the box really can provide most of what a small team needs to get going, and do it in a single solution.

That’s huge.

As soon as I start looking around to sub-optimize my hammer or my source control, I am going to start slowing the team down. GIT? SVN? PerForce? There are a ton of options for source control, each with their strengths and weaknesses. It’s freaking source control. Get on with it. I mean, how sexy can a hammer be?

It May Not Cost What You Think

You can buy a big toolkit at Sears for far less than it costs to buy all the tools individually. Further, buying the toolkit for the person without tools is a good move because they will have all the basics covered in a single purchase.

Craftsman Toolkits are a favorite gift of mine for graduates and newlyweds for this very reason.

Microsoft has the same insight that Sears had. If a person gets accustomed to Craftsman by selling the kit cheaply, they’ll be a customer for life. This is the exact idea behind the BizSpark program. If you aren’t familiar with it, BizSpark is a Microsoft program that allows free (that’s right, free!) access to all developer tools, operating systems, and other software for startups.

Is your company less than 2 years old? Do you make software? If yes, you qualify, I kid you not.

Integration Matters

Even if you are paying full price (which you shouldn’t :) ) I believe the value of VSTS is still there. The productivity loss involved in setting up a system of disparate and non-integrated developer tools is tremendous. I have been there and done that.

I know SVN is good. I know Team City is good. I also know that setting up a basic Continuous Integration build in Team System is stupid simple. And the real money shot comes with Work Item management. How many teams out there are using work item management systems or defect tracking systems they hate?

Well, we all are.

So, we may as well have one that works right in the IDE and allows me to tie check ins to work I am performing. The context switching that occurs in non-integrated systems of reporting, SCC, build, and work item management is HUGE. Huge! No really.

Get On With It

The people involved in the recent online Team System kerfuffle are folks I would consider in the top 1% of developer talent. Quite frankly, it makes a lot of sense to me that people at that level will have replaced their hammer from the kit with one that has an ergonomic grip.

That said, there are a lot of startups and small teams in entropy out there. For those folks, I firmly believe that standardizing on an integrated toolset for the development team is a bigger savings than “free like a puppy” solutions that can work well, but with more churn.

Now quit fussing about source control and learn how to use a decent ORM, people.

This post started to get a little long, so I won’t re-explain the concept.

Joshua Flanagan wrote a nice overview at his Los Techies blog: Auto mocking Explained.

My post is mainly here to describe the Unity version of an automocking container I threw together.

In Jan 2009 I blogged about my initial version of the Unity AutoMocker - Why am I blogging about it again?

I originally wrote the AutoMocker for the Unity container a year ago (Jan 2009, in Silverlight), and finally got around to placing the code up in the moq-contrib project in June of 2009.

I’m writing another post today in hopes to:

1. Get some feedback on how this little snippet of code should continue.
2. Give a little more how-to/example code
3. Describe some updates I made since I originally created it. 

Where can I get it?

This is one part where I’d appreciate some feedback.

I have two slightly different versions out there (currently).

I have one version at the ElegantCode repository where I was working on it, and the other I threw up at moq-contrib.

The core of the UnityAutoMockContainer is the same in both places, it’s how the tests are separated out that differ.

In the ElegantCode repository it’s an all in one self contained single file (that you can copy into your own test project(s)). You can then setup a single test in your own testing framework that runs all internal automocker tests (in case you need to modify it yourself, and don’t want to break any existing functionality). EX: test

[Test]
public void Should_run_all_UnityAutoMockContainer_internal_tests()
{
    Moq.AutoMocking.SelfTesting.UnityAutoMockContainerFixture
        .RunAllTests(Console.WriteLine);
}

I kind of like this format as it makes it easy to port between test libraries. Can’t say I like having the tests in the same file as the core, but it certainly is not a large chunk of code (so far) so it’s relatively small to maintain and definitely easier to manage as a single .cs file than another assembly (which would have to be version dependent on both Unity and Moq).

The moq-contrib is definitely where I think this helper should end up (and it is there). I just happened to break the tests out into the Silverlight test project and the core is alone in a file.

It’s current state isn’t as easy to copy to a test library (Silverlight/Desktop/Unity 1.2/Unity 2.0) as the one at ElegantCode. What does anyone think? Should I put them all together in one file?

However it ends up (1. all in one file or two (1 test) (1 core)) it will continue to be maintained on the moq-contrib project.

What is the high level API of the container?

It’s pretty simple, (currently) there are four methods on the container.

Two for registering items with the container. Say you want to register an already created instance, or say you want to map an interface to a concrete class and _not_ have the container generate mocks automatically for special cases.

And two for pulling items out of the container. Whether you want a instance of T or a Mock<T>, it gives you ways to retrieve both.

How can I setup my own registrations with the container?

Say I don’t want to have the container generate mocks for specific items and I want to supply specific configuration to the UnityContainer.

public UnityAutoMockContainer RegisterInstance<TService>(TService instance)

public UnityAutoMockContainer Register<TService, TImplementation>()
                where TImplementation : TService

Note: both of these registration methods return the container itself so you can fluently stack registration. EX:

AutoMockContainer
    .Register<IServiceA, ServiceA>()
    .Register<IServiceB, ServiceB>();

Let me know: I haven’t tested or played around with how this automocking container deals with any container specific xml configuration… So although I don’t think you should probably have that in a test assembly (stuff happens). Let me know if there are any issues.

How do I get items out of the container?

First is the Resolve<T>(). It will pull an item T out of the container. (Creating it if not already existing)

public T Resolve<T>()

When T is an interface Resolve<T> (unless you setup registration specifically with the container) should return basically “(new Mock<T>()).Object”

When T is a concrete Class, the container should return an instance of T and any of it’s dependencies will be satisfied by mocks. (Note that T will not be any sort of mocked instance of T, unless you used the GetMock<T> as described below first)

public Mock<T> GetMock<T>() where T : class

When T is an interface GetMock<T> should return basically “(new Mock<T>())”

When T is a concrete Class, the container should return a new Mock<T>() and any of it’s dependencies will be satisfied by mocks.

How do I use the UnityAutoMockContainer?

It’s pretty basic, you first create an instance of the UnityAutoMockContainer, and from there you can ask it for mocks of an (Interface, Class, or Abstract Class).

If you request an instance of a concrete class, or abstract class, the UnityAutoMockContainer will stuff mocks in for any constructor dependencies of your concrete class (if it can). You can then request from the container those same dependencies one at a time and either apply mocking setups or verifications.

NOTE: Anything the container creates will live as a singleton instance in the container. So any other requests from the container will always return the originally created instance. Therefore, each distinct scenario in a test suite should have their own instances of the container.

Below his an example of how you can leverage the container in some tests. Given this base fixture class…

public class FixtureBase
{
    private readonly UnityAutoMockContainer _autoMockContainer = new UnityAutoMockContainer();

    protected UnityAutoMockContainer AutoMockContainer
    {
        get { return _autoMockContainer; }
    }

    [TestFixtureSetUp]
    public void SetupContext_ALL()
    {
        Before_all_tests();
        Because();
    }

    [TestFixtureTearDown]
    public void TearDownContext_ALL()
    {
        After_all_tests();
    }

    protected virtual void Before_all_tests()
    {
    }

    protected virtual void Because()
    {
    }

    protected virtual void After_all_tests()
    {
    }
}

If I were given the following system to test.

public interface IServiceA { void RunA(); }
public interface IServiceB { void RunB(); }

public class TestComponent
{
    public TestComponent(IServiceA serviceA, IServiceB serviceB)
    {
        ServiceA = serviceA;
        ServiceB = serviceB;
    }

    public IServiceA ServiceA { get; private set; }
    public IServiceB ServiceB { get; private set; }

    public void RunAll()
    {
        if (!HowDidItGo())
            return;
        ServiceA.RunA();
        ServiceB.RunB();
    }

    public virtual bool HowDidItGo()
    {
        // some really nasty untestable code
        return true;
    }
}

The below example demonstrates simply verifying some behavior on the mocked dependencies of the system under test.

[TestFixture]
public class Example__how_to_pull_items_from_the_UnityAutoMockContainer_when_verifying_behavior_after_an_action_was_taken 
    : FixtureBase
{
    private TestComponent _testComponent;

    protected override void Before_all_tests()
    {
        base.Before_all_tests();
        _testComponent = AutoMockContainer.Resolve<TestComponent>();
    }

    protected override void Because()
    {
        _testComponent.RunAll();
    }

    [Test]
    public void Should_run_ServiceA_RunA()
    {
        AutoMockContainer
            .GetMock<IServiceA>()
            .Verify(v => v.RunA(), Times.Once());
    }

    [Test]
    public void Should_run_ServiceB_RunB()
    {
        AutoMockContainer
            .GetMock<IServiceB>()
            .Verify(v => v.RunB(), Times.Once());
    }
}

Next, you may have noticed that the system under test had a complicated internal method (that may not necessarily be testable). You can use the AutoMocker to create the system under test as a Mock itself, so we can override some of the behavior. Here’s how you could quickly do that.

Aside: I’m not saying this is a good practice or aids in good component design, just saying it’s possible

[TestFixture]
public class Example__how_to_use_the_UnityAutoMockContainer_to_override_a_method_on_the_SystemUnderTest_to_test_a_certain_behavior
    : FixtureBase
{

    private TestComponent _testComponent;

    protected override void Before_all_tests()
    {
        base.Before_all_tests();
        var mockTestComponent = AutoMockContainer.GetMock<TestComponent>();

        mockTestComponent
            .Setup(s => s.HowDidItGo())
            .Returns(false);

        _testComponent = mockTestComponent.Object;
    }

    protected override void Because()
    {
        _testComponent.RunAll();
    }

    [Test]
    public void Should_run_ServiceA_RunA()
    {
        AutoMockContainer
            .GetMock<IServiceA>()
            .Verify(v => v.RunA(), Times.Never());
    }

    [Test]
    public void Should_run_ServiceB_RunB()
    {
        AutoMockContainer
            .GetMock<IServiceB>()
            .Verify(v => v.RunB(), Times.Never());
    }
}

It’s amazing how much redundant test setup code this little helper has saved me in my tests. I hope others can find some use with this as well.