public CallbackTests()
 {
     System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
     mocks = new MockRepository();
     demo = (IDemo) mocks.StrictMock(typeof (IDemo));
     callbackCalled = false;
 }

		public CallbackTests()
		{
			System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;

            demo = MockRepository.Mock<IDemo>();
			callbackCalled = false;
		}

 public CallbackExpectationTests()
 {
     mocks = new MockRepository();
     demo = (IDemo) mocks.StrictMock(typeof (IDemo));
     method = typeof (IDemo).GetMethod("VoidThreeArgs");
     callbackCalled = false;
 }

 public void CallbackThatThrows()
 {
     demo = (IDemo) mocks.StrictMock(typeof (IDemo));
     demo.VoidNoArgs();
     LastCall.Callback(new DelegateDefinations.NoArgsDelegate(ThrowFromCallback));
     mocks.ReplayAll();
     demo.VoidNoArgs();
 }

 public void CallbackThatThrows()
 {
     demo = (IDemo)mocks.StrictMock(typeof(IDemo));
     demo.VoidNoArgs();
     LastCall.Callback(new DelegateDefinations.NoArgsDelegate(ThrowFromCallback));
     mocks.ReplayAll();
     Assert.Throws<AddressAlreadyInUseException>(() => demo.VoidNoArgs());
 }

 public IMethodRecorderTests()
 {
     demo = MockRepository.GenerateStrictMock(typeof(IDemo), null, null) as IDemo;
     voidNoArgs = typeof (IDemo).GetMethod("VoidNoArgs");
     voidThreeArgs = typeof (IDemo).GetMethod("VoidThreeStringArgs");
     expectationOne = new AnyArgsExpectation(new FakeInvocation(this.voidNoArgs), new Range(1, 1));
     expectationTwo = new AnyArgsExpectation(new FakeInvocation(voidThreeArgs), new Range(1, 1));
     recorder = CreateRecorder();
     ChildSetup();
 }

 void AddToMenu(IDemo demo)
 {
     Control control = demo.GetControl();
     FlowMenu.AddMenuItem(new MetroMenuItem(control, MetroMenuTransition.EaseIn, demo.DemoName));
     demo.ChangeDemo += (o, e) =>
     {
         FlowMenu.ShowMenu(e.DemoName);
     };
     RegisterForDragFeedback(control);
 }

        private static void CanCreateAStrictMultiMockFromTwoInterfacesCommon(IDemo demo)
        {
            demo.Expect(x => x.ReturnIntNoArgs())
                .Return(1);

            IDisposable disposable = demo as IDisposable;
            Assert.NotNull(disposable);

            disposable.Expect(x => x.Dispose());

            Assert.Equal(1, demo.ReturnIntNoArgs());
            disposable.Dispose();

            demo.VerifyAllExpectations();
        }

        private void openDemoToolStripMenuItem_Click(object sender, EventArgs e)
        {
            DialogResult r = openDemoDialog.ShowDialog();
            if (r == DialogResult.OK)
            {
                demo = Plugin.GetPlugin<IDemo>(openDemoDialog.FileName);

                if (demo == null)
                {
                    MessageBox.Show("Could not find an IDemo in that assembly. :(", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                demo.Init(demoSplit.Panel1.Handle);
                ProgressWindow progressWindow = new ProgressWindow("Loading demo");
                progressWindow.Show(this);
                demo.Load(progressWindow);
                progressWindow.Hide();
            }
        }

        public DefaultController(IDemo demo)
        {
            _demo = demo;

            var blah = _demo.Id;
        }

 public RhinoMockTests()
 {
     mocks = new MockRepository();
     demo = this.mocks.StrictMock(typeof(IDemo)) as IDemo;
 }

 private static void RecordOrdered(MockRepository mocks, IDemo demo)
 {
     using (mocks.Ordered())
     {
         demo.ReturnStringNoArgs();
         LastCall.On(demo).Return(null);
         demo.VoidNoArgs();
         LastCall.On(demo).Repeat.Twice();
         demo.VoidStringArg("Hello");
         demo.VoidStringArg("World");
     }
 }

        public void SteppingFromInnerOrderringToOuterWithoutFullifingAllOrderringInInnerThrows()
        {
            demo = (IDemo)mocks.StrictMock(typeof(IDemo));
            demo.VoidThreeStringArgs("", "", "");
            using (mocks.Ordered())
            {
                demo.VoidNoArgs();
                demo.VoidStringArg("Ayende");
            }
            mocks.Replay(demo);
            demo.VoidNoArgs();

            string expectedMessage = "Unordered method call! The expected call is: 'Ordered: { IDemo.VoidStringArg(\"Ayende\"); }' but was: 'IDemo.VoidThreeStringArgs(\"\", \"\", \"\");'";
            ExpectationViolationException ex = Assert.Throws<ExpectationViolationException>(
                            () => demo.VoidThreeStringArgs("", "", ""));
            Assert.Equal(expectedMessage, ex.Message);
        }

 public void RecursiveExpectationsOnUnordered()
 {
     demo = (IDemo)mocks.StrictMock(typeof(IDemo));
     demo.VoidNoArgs();
     LastCall.On(demo).Callback(new DelegateDefinations.NoArgsDelegate(CallMethodOnDemo));
     demo.VoidStringArg("Ayende");
     mocks.Replay(demo);
     demo.VoidNoArgs();
     mocks.Verify(demo);
 }

 public void RecursiveExpectationsOnOrdered()
 {
     demo = (IDemo)mocks.StrictMock(typeof(IDemo));
     using (mocks.Ordered())
     {
         demo.VoidNoArgs();
         LastCall.On(demo).Callback(CallMethodOnDemo);
         demo.VoidStringArg("Ayende");
     }
     mocks.Replay(demo);
     string expectedMessage = "Unordered method call! The expected call is: 'Ordered: { IDemo.VoidNoArgs(callback method: RhinoMockTests.CallMethodOnDemo); }' but was: 'IDemo.VoidStringArg(\"Ayende\");'";
     ExpectationViolationException ex = Assert.Throws<ExpectationViolationException>(
                     () => demo.VoidNoArgs());
     Assert.Equal(expectedMessage, ex.Message);
 }

        public void GetArgsOfEpectedAndActualMethodCallOnException()
        {
            demo = (IDemo)mocks.StrictMock(typeof(IDemo));
            demo.VoidThreeStringArgs("a", "b", "c");
            mocks.Replay(demo);

            string expectedMessage = "IDemo.VoidThreeStringArgs(\"c\", \"b\", \"a\"); Expected #0, Actual #1.\r\nIDemo.VoidThreeStringArgs(\"a\", \"b\", \"c\"); Expected #1, Actual #0.";
            ExpectationViolationException ex = Assert.Throws<ExpectationViolationException>(
                            () => demo.VoidThreeStringArgs("c", "b", "a"));
            Assert.Equal(expectedMessage, ex.Message);
        }

		public MockedObjectsComparerTests()
		{
            one = MockRepository.Mock<IDemo>();
            two = MockRepository.Mock<IDemo>();
		}

 public When_mocking_properties_with_RhinoMocks_stub()
 {
     _demo = MockRepository.GenerateStub<IDemo>();
     SetValuesOnMock();
 }

 public void SetUp()
 {
     mocks = new MockRepository();
     demo = mocks.StrictMock(typeof (IDemo)) as IDemo;
 }

 public LastCallTests()
 {
     mocks = new MockRepository();
     demo = (IDemo) mocks.StrictMock(typeof (IDemo));
 }