public abstract class Example
{
    public abstract string Foo();

    public List<string> Bar()
    {
        PreMethod();

        var list = new List<string>();

        var stack = new Stack<string>();
        foreach (var item in Stuff)
        {
            stack.Push(item);
        }

        while (stack.Any())
        {
            SomeThing = stack.Pop();
            var f = Foo();
            list.Add(f);
        }

        PostMethod();
        return list;
    }

    public abstract void PreMethod();

    public abstract void PostMethod();

    public abstract IEnumerable<string> Stuff { get; }

    public abstract string SomeThing { set; get; }
}

[TestClass]
public class ExampleTest
{
    private Example example;

    private MockRepository mocks;

    [TestInitialize]
    public void InitializeTest()
    {
        mocks = new MockRepository();
        example = MockRepository.GeneratePartialMock<Example>();
    }

    [TestMethod]
    public void BarTest()
    {
        using (mocks.Ordered())
        {
            example.Expect(e => e.PreMethod());
            example.Expect(e => e.Stuff).Return(new[] { "One", "Two" });

            using (mocks.Unordered())
            {
                using (mocks.Ordered())
                {
                    example.Expect(e => e.SomeThing).SetPropertyWithArgument("One");
                    example.Expect(e => e.Foo()).Return("one");
                }

                using (mocks.Ordered())
                {
                    example.Expect(e => e.SomeThing).SetPropertyWithArgument("Two");
                    example.Expect(e => e.Foo()).Return("two");
                }
            }


            example.Expect(e => e.PostMethod());
        }

        mocks.ReplayAll();


        var actual = example.Bar();
        Assert.AreEqual(2, actual.Count);
        Assert.AreEqual("two", actual[0]);
        Assert.AreEqual("one", actual[1]);
    }
}