nunit24/NUnitMocks/mocks/Mock.cs

   1 // ****************************************************************
   2 // Copyright 2007, Charlie Poole
   3 // This is free software licensed under the NUnit license. You may
   4 // obtain a copy of the license at http://nunit.org/?p=license&r=2.4
   5 // ****************************************************************
   6
   7 using System;
   8 using System.Collections;
   9 using System.Runtime.Remoting.Proxies;
  10 using System.Runtime.Remoting.Messaging;
  11 using NUnit.Framework;
  12
  13 namespace NUnit.Mocks
  14 {
  15         /// <summary>
  16         /// Summary description for MockObject.
  17         /// </summary>
  18         public class Mock : IMock
  19         {
  20                 #region Private Fields
  21
  22                 private string name;
  23
  24                 private bool strict;
  25
  26                 private IDictionary methods = new Hashtable();
  27
  28                 private Exception lastException;
  29
  30                 #endregion
  31
  32                 #region Properties
  33
  34                 public Exception LastException
  35                 {
  36                         get { return lastException; }
  37                 }
  38
  39                 #endregion
  40
  41                 #region Constructors
  42
  43                 public Mock() : this( "Mock" ) { }
  44
  45                 public Mock( string name )
  46                 {
  47                         this.name = name;
  48                 }
  49
  50                 #endregion
  51
  52                 #region IMock Members
  53
  54                 public string Name
  55                 {
  56                         get { return name; }
  57                 }
  58
  59                 public bool Strict
  60                 {
  61                         get { return strict; }
  62                         set { strict = value; }
  63                 }
  64
  65                 public void Expect( string methodName, params object[] args )
  66                 {
  67                         ExpectAndReturn( methodName, null, args );
  68                 }
  69
  70                 public void Expect( string methodName )
  71                 {
  72                         ExpectAndReturn( methodName, null, null );
  73                 }
  74
  75                 public void ExpectNoCall( string methodName )
  76                 {
  77                         methods[methodName] = new MockMethod( methodName, null,
  78                                 new AssertionException("Unexpected call to method " + methodName) );
  79                 }
  80
  81                 public void ExpectAndReturn( string methodName, object returnVal, params object[] args )
  82                 {
  83                         AddExpectedCall( methodName, returnVal, null, args );
  84                 }
  85
  86                 public void ExpectAndThrow( string methodName, Exception exception, params object[] args )
  87                 {
  88                         AddExpectedCall( methodName, null, exception, args );
  89                 }
  90
  91                 public void SetReturnValue( string methodName, object returnVal )
  92                 {
  93                         methods[methodName] = new MockMethod( methodName, returnVal );
  94                 }
  95
  96                 #endregion
  97
  98                 #region IVerify Members
  99
 100                 public virtual void Verify()
 101                 {
 102                         foreach( IMethod method in methods.Values )
 103                                 method.Verify();
 104                 }
 105
 106                 #endregion
 107
 108                 #region ICallHandler Members
 109
 110                 public virtual object Call( string methodName, params object[] args )
 111                 {
 112                         if ( methods.Contains( methodName ) )
 113                         {
 114                                 try
 115                                 {
 116                                         IMethod method = (IMethod)methods[methodName];
 117                                         return method.Call( args );
 118                                 }
 119                                 catch( Exception exception )
 120                                 {
 121                                         // Save exception in case MO is running on a separate thread
 122                                         lastException = exception;
 123                                         throw;
 124                                 }
 125                         }
 126                         else // methodName is not listed in methods
 127                         if ( Strict )
 128                                 Assert.Fail( "Unexpected call to " + methodName );
 129
 130                         // not listed but Strict is not specified
 131                         return null;
 132                 }
 133
 134                 #endregion
 135
 136                 #region Helper Methods
 137
 138                 private void AddExpectedCall( string methodName, object returnVal, Exception exception, object[] args )
 139                 {
 140                         IMethod method = (IMethod)methods[methodName];
 141                         if ( method == null )
 142                         {
 143                                 method = new MockMethod( methodName );
 144                                 methods[methodName] = method;
 145                         }
 146
 147                         Type[] argTypes = MethodSignature.GetArgTypes( args );
 148                         MethodSignature signature = new MethodSignature( this.Name, methodName, argTypes );
 149
 150                         method.Expect( new MockCall( signature, returnVal, exception, args ) );
 151                 }
 152
 153                 #endregion
 154         }
 155 }