Beispiel #1
0
 private ValidationInfo(string name, Type type, object expectedValue, IAsserter asserter)
 {
     _name          = name;
     _type          = type;
     _expectedValue = expectedValue;
     _asserter      = asserter;
 }
Beispiel #2
0
        private static void InvokeMethod(IAsserter asserter, MethodInfo method, Type type, object optionalInstance, object[] args)
        {
            var thrownExceptions = new List <Exception>();

            try
            {
                var taskResult = method.Invoke(optionalInstance, args) as Task;
                if (taskResult != null)
                {
                    taskResult.Wait();
                }
            }
            catch (AggregateException aggregateException)
            {
                thrownExceptions.AddRange(aggregateException.InnerExceptions);
            }
            catch (TargetInvocationException targetInvocationException)
            {
                thrownExceptions.Add(targetInvocationException.InnerException);
            }
            catch (Exception genericException)
            {
                thrownExceptions.Add(genericException);
            }

            for (int i = 0; i < thrownExceptions.Count; i++)
            {
                if (thrownExceptions[i] == null)
                {
                    continue;
                }

                asserter.AssertMethodException(thrownExceptions[i], type, method);
            }
        }
Beispiel #3
0
        public void SetUp()
        {
            _asserter = MockRepository.GenerateStub <IAsserter>();
            _asserter.Stub(stub => stub.NotNull(null, null, null)).IgnoreArguments().WhenCalled(
                invocation =>
            {
                if (invocation.Arguments[0] == null)
                {
                    throw new Exception(string.Format((string)invocation.Arguments[1], (object[])invocation.Arguments[2]));
                }
            });
            _asserter.Stub(stub => stub.IsNull(null, null, null)).IgnoreArguments().WhenCalled(
                invocation =>
            {
                if (invocation.Arguments[0] != null)
                {
                    throw new Exception(string.Format((string)invocation.Arguments[1], (object[])invocation.Arguments[2]));
                }
            });
            _asserter.Stub(stub => stub.AreEqual(null, null, null, null)).IgnoreArguments().WhenCalled(
                invocation =>
            {
                if (invocation.Arguments[0] != null)
                {
                    if (!invocation.Arguments[0].Equals(invocation.Arguments[1]))
                    {
                        throw new Exception(string.Format((string)invocation.Arguments[2], (object[])invocation.Arguments[3]));
                    }
                }
                else if (invocation.Arguments[1] != null)
                {
                    throw new Exception(string.Format((string)invocation.Arguments[2], (object[])invocation.Arguments[3]));
                }
            });
            _asserter.Stub(stub => stub.GreaterThan(null, null, null, null)).IgnoreArguments().WhenCalled(
                invocation =>
            {
                if (invocation.Arguments[0] != null)
                {
                    if (((IComparable)invocation.Arguments[0]).CompareTo(invocation.Arguments[1]) <= 0)
                    {
                        throw new Exception(string.Format((string)invocation.Arguments[2], (object[])invocation.Arguments[3]));
                    }
                }
            });
            _asserter.Stub(stub => stub.IsTrue(true, null, new object[3])).IgnoreArguments().WhenCalled(
                invocation =>
            {
                if (!((bool)invocation.Arguments[0]))
                {
                    throw new Exception(string.Format((string)invocation.Arguments[1], (object[])invocation.Arguments[2]));
                }
            })
            ;

            _htmlHelper = new ConcreteHtmlHelper(_asserter);
            _htmlHelper.Writer.Write(c_document);
        }
 /// <summary>
 /// Runs the test as an application with GUI
 /// </summary>
 /// <param name="data"></param>
 /// <param name="asserter"></param>
 /// <returns></returns>
 public IWorld CreateSelfTestInCommandLineContext(CommandLineData data, IAsserter asserter)
 {
     var holder = new NetworkServerData();
     holder.Port = DefaultPort;
     holder.LoadingData = new LoadingData { AssemblyName = data.Unnamed[0], Level = data.Unnamed[1] };
     var test = GetTest(holder.LoadingData, data.Unnamed[3]);
     new Action<ICvarcTest, IAsserter, NetworkServerData>(SelfTestClientThread).BeginInvoke(test, asserter, holder, null, null);
     var proposal = SettingsProposal.FromCommandLineData(data);
     CreateSelfTestServer(holder, proposal);
     return holder.World;
 }
        /// <summary>
        /// Helper method to get the asserter to be used for a test case.
        /// Asserters can be specified at a class, method or parameter level.
        /// The asserter specified at a specific level overrides the one specified at a more generic level.
        /// </summary>
        /// <param name="testFixture"></param>
        /// <param name="mInfo"></param>
        /// <param name="pInfo"></param>
        /// <returns>Returns the asserter applicable for the specified parameter</returns>
        private static IAsserter GetOutputAsserter(object testFixture, MethodInfo mInfo, ParameterInfo pInfo)
        {
            IAsserter outputAsserter = null;

            object[] classAttributes = testFixture.GetType().GetCustomAttributes(false);
            for (int i = 0; i < classAttributes.Length; ++i)
            {
                if (null != classAttributes[i].GetType().GetInterface("IAsserter", true))
                {
                    outputAsserter = (IAsserter)classAttributes[i];
                    break;
                }
            }

            object[] methodAttributes = mInfo.GetCustomAttributes(false);
            for (int i = 0; i < methodAttributes.Length; ++i)
            {
                //Use the class asserter if a method level asserter is not assigned.
                if (null != methodAttributes[i].GetType().GetInterface("IAsserter", true))
                {
                    outputAsserter = (IAsserter)methodAttributes[i];
                    break;
                }
            }

            object[] paramAttributes = pInfo.GetCustomAttributes(false);
            for (int i = 0; i < paramAttributes.Length; ++i)
            {
                if (null != paramAttributes[i].GetType().GetInterface("IAsserter", false))
                {
                    outputAsserter = (IAsserter)paramAttributes[i];
                    break;
                }
            }
            return(outputAsserter);
        }
Beispiel #6
0
 private ValidationInfo(string name, Type type, IAsserter asserter)
 {
     _name     = name;
     _type     = type;
     _asserter = asserter;
 }
Beispiel #7
0
		static public void DoAssert( IAsserter asserter )
		{
			Assert.IncrementAssertCount();
			if ( !asserter.Test() )
				throw new AssertionException( asserter.Message );
		}
        /// <summary>
        /// Runs the test as a Unit test.
        /// </summary>
        /// <param name="assemblyName"></param>
        /// <param name="level"></param>
        /// <param name="testName"></param>
        /// <param name="asserter"></param>
        public void RunSelfTestInVSContext(string assemblyName, string level, string testName, IAsserter asserter)
        {
            var holder = new NetworkServerData();
            holder.Port = DefaultPort;
            holder.LoadingData = new LoadingData { AssemblyName = assemblyName, Level = level };
            var test = GetTest(holder.LoadingData, testName);

            var thread = new Thread(() =>
            {
                var proposal = new SettingsProposal { SpeedUp = true };
                CreateSelfTestServer(holder, proposal);
                holder.World.RunActively(1);
                holder.Close();
            }) { IsBackground = true };
            thread.Start();

            try
            {
                SelfTestClientThread(test, asserter, holder);

            }
            catch (Exception e)
            {
                throw e;
            }
            finally
            {
                holder.Close();
            }
        }
 /// <summary>
 /// The entry point for a client that performs a test
 /// </summary>
 /// <param name="test"></param>
 /// <param name="asserter"></param>
 /// <param name="holder"></param>
 void SelfTestClientThread(ICvarcTest test, IAsserter asserter, NetworkServerData holder)
 {
     holder.WaitForServer();
     test.Run(holder, asserter);
 }
 private MockMethodBase(string name, ICounter counter, IAsserter asserter)
 {
     _name           = name;
     _invokedCounter = counter;
     _asserter       = asserter;
 }
 public ConcreteHtmlHelper(IAsserter asserter)
     : base(asserter.AreEqual, asserter.GreaterThan, asserter.NotNull, asserter.IsNull, asserter.IsTrue)
 {
 }
Beispiel #12
0
        /// <summary>
        /// This is the method used to invoke a test method for a specific scenario.
        /// </summary>
        /// <param name="methodName">The test method to execute. This must be a private instance method
        /// in the TestFixture class.</param>
        /// <param name="scenarioName">The test scenario.</param>
        /// <param name="testFixture">The class containing the test method.</param>
        /// <remarks>
        /// this method is called from an NUnit test case and does the following:
        /// <list type="bullet">
        /// <item>
        /// Calls the method specified by the <c>methodName</c> parameter;
        /// passing in all input parameters by using the concrete implementation of <see cref="IDataProvider"/> configured for each parameter.
        /// </item>
        /// <item>
        /// Captures the actual output returned from the test method and
        /// compares it with the expected output using the concrete implementation of <see cref="IAsserter"/> configured for each return value
        /// and out/ref parameter.
        /// </item>
        /// </list>
        /// </remarks>
        public static void Invoke(string methodName, string scenarioName, Object testFixture)
        {
            MethodInfo mInfo = testFixture.GetType().GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.IgnoreCase);

            ParameterInfo[]      pInfos          = mInfo.GetParameters();
            ParameterInfo        returnParamInfo = mInfo.ReturnParameter;
            ArrayList            allParameters   = new ArrayList();
            List <ParameterInfo> outParameters   = new List <ParameterInfo>();

            foreach (ParameterInfo pInfo in pInfos)
            {
                Object parameter = null;
                //Try to load a parameter
                //only if it is an input parameter.
                //Otherwise, just add the parameterInfo for that parameter
                //into an array for assertion later.
                if (pInfo.IsOut)
                {
                    outParameters.Add(pInfo);
                }
                else
                {
                    IDataProvider dataProvider = GetDataProvider(testFixture, mInfo, pInfo);
                    if (null != dataProvider)
                    {
                        parameter = dataProvider.GetData(pInfo, methodName, scenarioName, testFixture);
                    }
                }
                //Add the parameter to the array to be used to call the method
                //irrespective of whether or not it is an out parameter.
                //For out parameters, a "null" is added in the array.
                //This is replaced by an actual object after the method is invoked.
                allParameters.Add(parameter);
            }
            //Call the test method.
            try
            {
                Object[] parameters = allParameters.ToArray();
                Object   returnObj  = mInfo.Invoke(testFixture, parameters);
                //Save the returned value
                //and call the corresponding assertion only if the return type is not void.
                if (returnParamInfo.ParameterType.Name != "Void")
                {
                    IAsserter outputAsserter = GetOutputAsserter(testFixture, mInfo, returnParamInfo);
                    if (null != outputAsserter)
                    {
                        outputAsserter.AssertOutput(returnObj, returnParamInfo, methodName, scenarioName, testFixture);
                    }
                }
                //Save the remaining out parameters and
                //call the corresponding assertions.
                foreach (ParameterInfo outPInfo in outParameters)
                {
                    object    outParameter   = parameters[outPInfo.Position];
                    IAsserter outputAsserter = GetOutputAsserter(testFixture, mInfo, outPInfo);
                    if (null != outputAsserter)
                    {
                        outputAsserter.AssertOutput(outParameter, outPInfo, methodName, scenarioName, testFixture);
                    }
                }
            }
            catch (TargetInvocationException e)
            {
                throw e.InnerException;
            }
        }