public void ApplyExpectation(IExpectation expectation)
        {
            if (expectation is HasTypeExpectation)
            {
                HandleHasTypeExpectation(expectation as HasTypeExpectation);
                return;
            }

            if (expectation is HasInstanceExpectation)
            {
                HandleHasInstanceExpectation(expectation as HasInstanceExpectation);
                return;
            }

            if (expectation is DoesNotHaveTypeExpectation)
            {
                HandleDoesNotHaveTypeExpectation(expectation as DoesNotHaveTypeExpectation);
                return;
            }

            if (expectation is DoesNotHaveInstanceExpectation)
            {
                HandleDoesNotHaveInstanceExpectation(expectation as DoesNotHaveInstanceExpectation);
                return;
            }

            // TODO: Open/Closed priciple!?
            // TODO: Refactor to Expectation applyer!? Use extension methods?

            throw new ArgumentOutOfRangeException("expectation");
        }

        public override void AddToBatch(IExpectation expectation)
        {
            totalExpectedRowsAffected += expectation.ExpectedRowCount;
            var batchUpdate = CurrentCommand;

            string lineWithParameters = null;
            var sqlStatementLogger = Factory.Settings.SqlStatementLogger;
            if (sqlStatementLogger.IsDebugEnabled || log.IsDebugEnabled)
            {
                lineWithParameters = sqlStatementLogger.GetCommandLineWithParameters(batchUpdate);
                var formatStyle = sqlStatementLogger.DetermineActualStyle(FormatStyle.Basic);
                lineWithParameters = formatStyle.Formatter.Format(lineWithParameters);
                currentBatchCommandsLog.Append("command ")
                    .Append(currentBatch.CountOfCommands)
                    .Append(":")
                    .AppendLine(lineWithParameters);
            }
            if (log.IsDebugEnabled)
            {
                log.Debug("Adding to batch:" + lineWithParameters);
            }
            currentBatch.Append(((ProfiledSqlDbCommand)batchUpdate).Command);

            if (currentBatch.CountOfCommands >= batchSize)
            {
                ExecuteBatchWithTiming(batchUpdate);
            }
        }

 /// <summary>
 /// Creates a new <see cref="ConstraintsExpectation"/> instance.
 /// </summary>
 /// <param name="expectation">Expectation.</param>
 /// <param name="constraints">Constraints.</param>
 public ConstraintsExpectation(IExpectation expectation, AbstractConstraint[] constraints)
     : base(expectation)
 {
     Validate.IsNotNull(() => constraints);
     this.constraints = constraints;
     ConstraintsMatchMethod();
 }

        public override void AddToBatch(IExpectation expectation)
        {
            _totalExpectedRowsAffected += expectation.ExpectedRowCount;
            var batchUpdate = CurrentCommand;
            Driver.AdjustCommand(batchUpdate);
            var sqlStatementLogger = Factory.Settings.SqlStatementLogger;
            if (sqlStatementLogger.IsDebugEnabled)
            {
                var lineWithParameters = sqlStatementLogger.GetCommandLineWithParameters(batchUpdate);
                var formatStyle = sqlStatementLogger.DetermineActualStyle(FormatStyle.Basic);
                lineWithParameters = formatStyle.Formatter.Format(lineWithParameters);
                _currentBatchCommandsLog.Append("command ")
                    .Append(_currentBatch.CountOfCommands)
                    .Append(":")
                    .AppendLine(lineWithParameters);
            }

            var update = batchUpdate as ProfiledGenericDbCommand<SqlCommand>;
            if (update != null)
            {
                _currentBatch.Append(update.Command);
            }
            else
            {
                _currentBatch.Append((SqlCommand)batchUpdate);
            }

            if (_currentBatch.CountOfCommands >= _batchSize)
            {
                ExecuteBatchWithTiming(batchUpdate);
            }
        }

		/// <summary>
		/// Executes the current <see cref="IDbCommand"/> and compares the row Count
		/// to the <c>expectedRowCount</c>.
		/// </summary>
		/// <param name="expectation">
		/// The expected number of rows affected by the query.  A value of less than <c>0</c>
		/// indicates that the number of rows to expect is unknown or should not be a factor.
		/// </param>
		/// <exception cref="HibernateException">
		/// Thrown when there is an expected number of rows to be affected and the
		/// actual number of rows is different.
		/// </exception>
		public override void AddToBatch(IExpectation expectation)
		{
			IDbCommand cmd = CurrentCommand;
			Driver.AdjustCommand(cmd);
			int rowCount = ExecuteNonQuery(cmd);
			expectation.VerifyOutcomeNonBatched(rowCount, cmd);
		}

 public override void AddToBatch(IExpectation expectation)
 {
     #region NHibernate code
     _totalExpectedRowsAffected += expectation.ExpectedRowCount;
     IDbCommand batchUpdate = CurrentCommand;
     Driver.AdjustCommand(batchUpdate);
     string lineWithParameters = null;
     var sqlStatementLogger = Factory.Settings.SqlStatementLogger;
     if (sqlStatementLogger.IsDebugEnabled || Log.IsDebugEnabled)
     {
         lineWithParameters = sqlStatementLogger.GetCommandLineWithParameters(batchUpdate);
         var formatStyle = sqlStatementLogger.DetermineActualStyle(FormatStyle.Basic);
         lineWithParameters = formatStyle.Formatter.Format(lineWithParameters);
         _currentBatchCommandsLog.Append("command ")
             .Append(_currentBatch.CountOfCommands)
             .Append(":")
             .AppendLine(lineWithParameters);
     }
     if (Log.IsDebugEnabled)
     {
         Log.Debug("Adding to batch:" + lineWithParameters);
     }
     #endregion
     _currentBatch.Append((System.Data.SqlClient.SqlCommand)(ReliableSqlCommand)batchUpdate);
     #region NHibernate code
     if (_currentBatch.CountOfCommands >= _batchSize)
     {
         ExecuteBatchWithTiming(batchUpdate);
     }
     #endregion
 }

		protected static void SetupExpectation(IExpectation expectation, Range r, int actual)
		{
			expectation.Expected = r;
			for (int i = 0; i < actual; i++)
			{
				expectation.AddActualCall();
			}
		}

 /// <summary>
 /// Creates a new <see cref="ProxyMethodExpectationTriplet"/> instance.
 /// </summary>
 /// <param name="proxy">Proxy.</param>
 /// <param name="method">Method.</param>
 /// <param name="expectation">Expectation.</param>
 public ProxyMethodExpectationTriplet(object proxy, MethodInfo method, IExpectation expectation)
 {
     Validate.IsNotNull(proxy, "proxy");
     Validate.IsNotNull(method, "method");
     Validate.IsNotNull(expectation, "expectation");
     this.proxy = proxy;
     this.method = method;
     this.expectation = expectation;
 }

 /// <summary>
 /// Logs the expectation as is was recorded
 /// </summary>
 /// <param name="invocation">
 /// The invocation.
 /// </param>
 /// <param name="expectation">
 /// The expectation.
 /// </param>
 public void LogRecordedExpectation(IInvocation invocation, IExpectation expectation)
 {
     if (_logRecorded)
     {
         string methodCall =
             MethodCallUtil.StringPresentation(invocation, invocation.Method, invocation.Arguments);
         Trace.WriteLine(string.Format("Recorded expectation: {0}", methodCall));
     }
 }

        public override void AddToBatch(IExpectation expectation)
        {
            totalExpectedRowsAffected += expectation.ExpectedRowCount;
            log.Debug("Adding to batch:");
            IDbCommand batchUpdate = CurrentCommand;
            LogCommand(batchUpdate);

            CurrentBatch.Append(batchUpdate);
            if (CurrentBatch.CountOfCommands >= batchSize)
            {
                DoExecuteBatch(batchUpdate);
            }
        }

        TestResult CreateTestResultFromExpectation(IExpectation expectation)
        {
            var result = new TestResult(new TestName { Name = expectation.Message });

            if (expectation.IsFail)
                result.Failure(expectation.ToString(), "");
            else if (expectation.IsPass)
                result.Success();
            else if (expectation.IsPending)
                result.Ignore(expectation.ToString(), "");

            return result;
        }

		public override void AddToBatch(IExpectation expectation)
		{
            bool firstOnBatch = true;
			totalExpectedRowsAffected += expectation.ExpectedRowCount;
			log.Info("Adding to batch");
            LogCommand(CurrentCommand);

            if (currentBatch == null)
            {
                // use first command as the batching command
                currentBatch = CurrentCommand;
                parameterValueArrayHashTable = new Hashtable();
                //oracle does not allow array containing all null values
                // so this HashTable is keeping track if all values are null or not
                parameterIsAllNullsHashTable = new Hashtable();
            }
            else
            {
                firstOnBatch = false;
            }

            ArrayList parameterValueArray;
            foreach (IDataParameter currentParameter in CurrentCommand.Parameters)
            {                
                if (firstOnBatch)
                {
                    parameterValueArray = new ArrayList();
                    parameterValueArrayHashTable.Add(currentParameter.ParameterName, parameterValueArray);
                    parameterIsAllNullsHashTable.Add(currentParameter.ParameterName, true);
                }
                else
                {
                    parameterValueArray = parameterValueArrayHashTable[currentParameter.ParameterName] as ArrayList;
                }

                if (currentParameter.Value != System.DBNull.Value)
                {
                    parameterIsAllNullsHashTable[currentParameter.ParameterName] = false;
                }
                parameterValueArray.Add(currentParameter.Value);
            } 
            
            countOfCommands++;

            if (countOfCommands >= batchSize)
            {
                DoExecuteBatch(currentBatch);
            }

            
		}

		public override void AddToBatch(IExpectation expectation)
		{
			totalExpectedRowsAffected += expectation.ExpectedRowCount;
			log.Debug("Adding to batch:");
			IDbCommand batchUpdate = CurrentCommand;
			string commandLoggedText = GetCommandLogString(batchUpdate);
			currentBatchCommandsLog.Append("Batch command: ").
				AppendLine(commandLoggedText);
			currentBatch.Append((System.Data.SqlClient.SqlCommand) batchUpdate);
			if (currentBatch.CountOfCommands >= batchSize)
			{
				DoExecuteBatch(batchUpdate);
			}
		}

		public override void AddToBatch(IExpectation expectation)
		{
			bool firstOnBatch = true;
			totalExpectedRowsAffected += expectation.ExpectedRowCount;
			log.Info("Adding to batch");
			LogCommand(CurrentCommand);

			if (currentBatch == null)
			{
				// use first command as the batching command
				currentBatch = CurrentCommand;
				parameterValueListHashTable = new Dictionary<string, List<object>>();
				//oracle does not allow array containing all null values
				// so this Dictionary is keeping track if all values are null or not
				parameterIsAllNullsHashTable = new Dictionary<string, bool>();
			}
			else
			{
				firstOnBatch = false;
			}

			List<object> parameterValueList;
			foreach (IDataParameter currentParameter in CurrentCommand.Parameters)
			{                
				if (firstOnBatch)
				{
					parameterValueList = new List<object>();
					parameterValueListHashTable.Add(currentParameter.ParameterName, parameterValueList);
					parameterIsAllNullsHashTable.Add(currentParameter.ParameterName, true);
				}
				else
				{
					parameterValueList = parameterValueListHashTable[currentParameter.ParameterName];
				}

				if (currentParameter.Value != DBNull.Value)
				{
					parameterIsAllNullsHashTable[currentParameter.ParameterName] = false;
				}
				parameterValueList.Add(currentParameter.Value);
			} 
			
			countOfCommands++;

			if (countOfCommands >= batchSize)
			{
				ExecuteBatchWithTiming(currentBatch);
			}
		}

        public override void AddToBatch(IExpectation expectation)
        {
            this.totalExpectedRowsAffected += expectation.ExpectedRowCount;
            IDbCommand batchUpdate = CurrentCommand;
            Driver.AdjustCommand(batchUpdate);
            string lineWithParameters = null;
            var sqlStatementLogger = Factory.Settings.SqlStatementLogger;
            if (sqlStatementLogger.IsDebugEnabled || Log.IsDebugEnabled)
            {
                lineWithParameters = sqlStatementLogger.GetCommandLineWithParameters(batchUpdate);
                var formatStyle = sqlStatementLogger.DetermineActualStyle(FormatStyle.Basic);
                lineWithParameters = formatStyle.Formatter.Format(lineWithParameters);
                this.currentBatchCommandsLog.Append("command ")
                    .Append(this.currentBatch.CountOfCommands)
                    .Append(":")
                    .AppendLine(lineWithParameters);
            }
            if (Log.IsDebugEnabled)
            {
                Log.Debug("Adding to batch:" + lineWithParameters);
            }

            if (batchUpdate is ProfiledSqlCommand)
            {
                var sqlCommand = ((ProfiledSqlCommand)batchUpdate).SqlCommand;
                this.currentBatch.Append(sqlCommand);
                if (this.profiler != null)
                {
                    this.profiler.ExecuteStart(sqlCommand, ExecuteType.NonQuery);
                }
            }
            else
            {
                this.currentBatch.Append((System.Data.SqlClient.SqlCommand)batchUpdate);
            }

            if (this.currentBatch.CountOfCommands >= this.batchSize)
            {
                this.ExecuteBatchWithTiming(batchUpdate);
            }
        }

		public override void AddToBatch(IExpectation expectation)
		{
			bool firstOnBatch = true;
			totalExpectedRowsAffected += expectation.ExpectedRowCount;
            string lineWithParameters = null;
            var sqlStatementLogger = Factory.Settings.SqlStatementLogger;
            if (sqlStatementLogger.IsDebugEnabled || log.IsDebugEnabled)
            {
                lineWithParameters = sqlStatementLogger.GetCommandLineWithParameters(CurrentCommand);
                var formatStyle = sqlStatementLogger.DetermineActualStyle(FormatStyle.Basic);
                lineWithParameters = formatStyle.Formatter.Format(lineWithParameters);
                currentBatchCommandsLog.Append("command ")
                    .Append(countOfCommands)
                    .Append(":")
                    .AppendLine(lineWithParameters);
            }
            if (log.IsDebugEnabled)
            {
                log.Debug("Adding to batch:" + lineWithParameters);
            }

			if (currentBatch == null)
			{
				// use first command as the batching command
				currentBatch = CurrentCommand;
				parameterValueListHashTable = new Dictionary<string, List<object>>();
				//oracle does not allow array containing all null values
				// so this Dictionary is keeping track if all values are null or not
				parameterIsAllNullsHashTable = new Dictionary<string, bool>();
			}
			else
			{
				firstOnBatch = false;
			}

			List<object> parameterValueList;
			foreach (IDataParameter currentParameter in CurrentCommand.Parameters)
			{                
				if (firstOnBatch)
				{
					parameterValueList = new List<object>();
					parameterValueListHashTable.Add(currentParameter.ParameterName, parameterValueList);
					parameterIsAllNullsHashTable.Add(currentParameter.ParameterName, true);
				}
				else
				{
					parameterValueList = parameterValueListHashTable[currentParameter.ParameterName];
				}

				if (currentParameter.Value != DBNull.Value)
				{
					parameterIsAllNullsHashTable[currentParameter.ParameterName] = false;
				}
				parameterValueList.Add(currentParameter.Value);
			} 
			
			countOfCommands++;

			if (countOfCommands >= batchSize)
			{
				ExecuteBatchWithTiming(currentBatch);
			}
		}

		/// <summary>
		/// Adds the expected row count into the batch.
		/// </summary>
		/// <param name="expectation">The number of rows expected to be affected by the query.</param>
		/// <remarks>
		/// If Batching is not supported, then this is when the Command should be executed.  If Batching
		/// is supported then it should hold of on executing the batch until explicitly told to.
		/// </remarks>
		public abstract void AddToBatch(IExpectation expectation);

 protected override void DoReplaceExpectation(object proxy, MethodInfo method, IExpectation oldExpectation, IExpectation newExpectation)
 {
     DoReplaceExpectationCalled = true;
 }

		protected object PerformInsert(object ownerId, IPersistentCollection collection, IExpectation expectation,
		                               object entry, int index, bool useBatch, bool callable, ISessionImplementor session)
		{
			object entryId = null;
			int offset = 0;
			IDbCommand st = useBatch
			                	? session.Batcher.PrepareBatchCommand(SqlInsertRowString.CommandType, SqlInsertRowString.Text,
			                	                                      SqlInsertRowString.ParameterTypes)
			                	: session.Batcher.PrepareCommand(SqlInsertRowString.CommandType, SqlInsertRowString.Text,
			                	                                 SqlInsertRowString.ParameterTypes);
			try
			{
				//offset += expectation.Prepare(st, factory.ConnectionProvider.Driver);
				offset = WriteKey(st, ownerId, offset, session);
				if (hasIdentifier)
				{
					entryId = collection.GetIdentifier(entry, index);
					offset = WriteIdentifier(st, entryId, offset, session);
				}
				if (hasIndex)
				{
					offset = WriteIndex(st, collection.GetIndex(entry, index, this), offset, session);
				}
				WriteElement(st, collection.GetElement(entry), offset, session);
				if (useBatch)
				{
					session.Batcher.AddToBatch(expectation);
				}
				else
				{
					expectation.VerifyOutcomeNonBatched(session.Batcher.ExecuteNonQuery(st), st);
				}
			}
			catch (Exception e)
			{
				if (useBatch)
				{
					session.Batcher.AbortBatch(e);
				}
				throw;
			}
			finally
			{
				if (!useBatch)
				{
					session.Batcher.CloseCommand(st, null);
				}
			}
			return entryId;
		}

 /// <summary>
 /// Logs the expectation as it was recorded
 /// </summary>
 /// <param name="invocation">
 /// The invocation.
 /// </param>
 /// <param name="expectation">
 /// The expectation.
 /// </param>
 public void LogReplayedExpectation(IInvocation invocation, IExpectation expectation)
 {
     string methodCall = MethodCallUtil.StringPresentation(invocation, invocation.Method, invocation.Arguments);
     WriteLine("Replayed expectation: {0}", methodCall);
     WriteCurrentMethod();
 }