mbunit2 2.4.2.355.20100801

data/docs/extras/Snippets/Exception.cst

@@ -0,0 +1,94 @@
+<%@ CodeTemplate Language="C#" TargetLanguage="Text" Description="Template description here." %>
+<%@ Property Name="ClassName" Type="System.String" Category="Options" Description="Class name." Optional="False"%>
+<%@ Property Name="MessageFormat" Type="System.String" Category="Options" Description="Message format string" Optional="False" %>
+// QuickGraph Library 
+// 
+// Copyright (c) 2004 Jonathan de Halleux
+//
+// This software is provided 'as-is', without any express or implied warranty. 
+// 
+// In no event will the authors be held liable for any damages arising from 
+// the use of this software.
+// Permission is granted to anyone to use this software for any purpose, 
+// including commercial applications, and to alter it and redistribute it 
+// freely, subject to the following restrictions:
+//
+//		1. The origin of this software must not be misrepresented; 
+//		you must not claim that you wrote the original software. 
+//		If you use this software in a product, an acknowledgment in the product 
+//		documentation would be appreciated but is not required.
+//
+//		2. Altered source versions must be plainly marked as such, and must 
+//		not be misrepresented as being the original software.
+//
+//		3. This notice may not be removed or altered from any source 
+//		distribution.
+//		
+//		QuickGraph Library HomePage: http://mbunit.tigris.org
+//		Author: Jonathan de Halleux
+
+
+using System;
+using System.Runtime.Serialization;
+using System.IO;
+
+namespace QuickGraph.Exceptions
+{
+	/// <summary>
+	/// Exception throwed when not finding a vertex.
+	/// </summary>
+	[Serializable]
+	public class <%= FullClassName %> : Exception
+	{
+		public <%= FullClassName %>(String message)
+			: base(message)
+		{}
+
+		/// <summary>
+		/// Constructs an empty exception
+		/// </summary>
+		public <%= FullClassName %>()
+			:base()
+		{}
+		
+		/// <summary>
+		/// Creates an exception with a message
+		/// and an inner exception.
+		/// </summary>
+		/// <param name="message">Error message</param>
+		/// <param name="ex">Inner exception</param>
+		public <%= FullClassName %>(String message, Exception ex)
+			:base(message,ex)
+		{}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="info"></param>
+		/// <param name="ctx"></param>
+		protected <%= FullClassName %>(SerializationInfo info, StreamingContext ctx)
+			:base(info,ctx)
+		{}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <returns></returns>
+		public override string Message
+		{
+			get
+			{
+				return String.Format("<%= MessageFormat %>",base.Message);
+			}
+		}
+	}
+}
+<script runat="template">
+protected string FullClassName
+{
+	get
+	{
+		return this.ClassName + "Exception";
+	}
+}
+</script>

data/docs/extras/Snippets/GrammarPopulator.cst

@@ -0,0 +1,258 @@
+<%@ CodeTemplate Language="C#" TargetLanguage="C#" Description="TestFu Grammar" %>
+<%@ Property Name="Namespace" Type="System.String" 
+	Default="Populators" 
+	Category="Output" 
+	Description="Namespace of the populator." %>
+<%@ Property Name="DataSetNameFormat" Type="System.String" 
+	Default="{0}DataSet" 
+	Category="Output" 
+	Description="Format string to create the DatabaseSet class name." %>
+<%@ Property Name="CrudPopulatorNameFormat" Type="System.String" 
+	Default="{0}CrudPopulator" 
+	Category="Output" 
+	Description="Format string to create the CrudPopulator class name." %>
+<%@ Property Name="DatabasePopulatorNameFormat" Type="System.String" 
+	Default="{0}DatabasePopulator" 
+	Category="Output" 
+	Description="Format string to create the DatabasePopulator class name." %>
+<%@ Property Name="GrammarNameFormat" Type="System.String" 
+	Default="{0}Grammar" 
+	Category="Output" 
+	Description="Format string to create the Grammar class name." %>	
+<%@ Property Name="TableNamePrefix" Type="System.String" 
+	Default="" 
+	Category="Output" 
+	Optional="true"
+	Description="Prefix to be removed." %>
+<%@ Property Name="TablePopulatorNameFormat" Type="System.String" 
+	Default="{0}TablePopulator" 
+	Category="Output" 
+	Description="Format string to create the TablePopulator class names." %>
+<%@ Property Name="ColumnDataGeneratorNameFormat" Type="System.String" 
+	Default="{0}DataGenerator" 
+	Category="Output" 
+	Description="Format string to create the ColumnGenenerator properties." %>
+<%@ Property Name="UniqueValidatorNameFormat" Type="System.String" 
+	Default="{0}Validator" 
+	Category="Output" 
+	Description="Format string to create the UniqueValidator properties." %>
+<%@ Property Name="ForeignKeyProviderNameFormat" Type="System.String" 
+	Default="{0}Provider" 
+	Category="Output" 
+	Description="Format string to create the ForeignKeyProviderNameFormat properties." %>
+<%@ Property Name="Database" Type="SchemaExplorer.DatabaseSchema"
+      Category="Context"
+      Description="Target database for the IDatabasePopulator." %> 
+<%@ Assembly Name="SchemaExplorer" %> 
+<%@ Import Namespace="SchemaExplorer" %>
+//////////////////////////////////////////////////////////////////
+//
+// Strongly typed CRUD populator for the <%= DatabaseName %>
+//
+// This file was generated by CodeSmith. Do not edit it! Modify
+// the template if you need to tweak it for you.
+//
+//////////////////////////////////////////////////////////////////
+
+using System;
+using System.Data;
+using System.Data.SqlClient;
+
+using MbUnit.Core.Framework;
+using MbUnit.Framework;
+
+using TestFu.Data;
+using TestFu.Data.SqlClient;
+using TestFu.Data.Graph;
+using TestFu.Grammars;
+
+namespace <%= Namespace %>
+{
+	/// <summary>
+	/// A strongly-typed <see cref="IGrammar"/> for the 
+	/// <em><%= DatabaseName %> database.
+	/// </summary>
+	public class <%= DatabaseGrammarName %> : Grammar
+	{		
+		#region Fields
+		private <%= CrudPopulatorName%> populator;
+<% foreach(TableSchema table in this.Database.Tables) { %>
+		private <%= TableGrammarName(table) %> <%= FormatLower(TableGrammarPropertyName(table)) %>;
+<%}// foreach(TableSchema table in this.Database.Tables) %>
+		#endregion
+		
+		#region Constructors
+		/// <summary>
+		/// Initializes a new <see cref="<%= DatabaseGrammarName %>"/> instance 
+		/// with a <see cref="<%= CrudPopulatorName%>"/> instance.
+		/// </summary>
+		public <%= DatabaseGrammarName %>(<%= CrudPopulatorName%> populator)
+		{
+			if (populator==null)
+				throw new ArgumentNullException("populator");
+			this.populator = populator;
+
+			AlternativeRule alt = new AlternativeRule();			
+<% foreach(TableSchema table in this.Database.Tables) { %>
+			<%= FormatLower(TableGrammarPropertyName(table))%> = new <%= TableGrammarName(table) %>(populator);
+			alt.Rules.Add(<%= FormatLower(TableGrammarPropertyName(table))%>);
+<%}// foreach(TableSchema table in this.Database.Tables) %>		
+			this.StartRule = Rules.Kleene(alt);
+		}
+		#endregion
+		
+		#region Grammars
+<% foreach(TableSchema table in this.Database.Tables) { %>
+		<%= TableGrammarName(table) %> <%= TableGrammarPropertyName(table) %>
+		{
+			get { return <%= FormatLower(TableGrammarPropertyName(table)) %>;}
+		}
+<% } // %>
+		#endregion
+	
+		#region Grammars Classes
+<% foreach(TableSchema table in this.Database.Tables) { %>
+		#region <%= table.Name %>
+		public class <%= TableGrammarName(table) %> : Grammar
+		{
+			private <%= CrudPopulatorName%> populator;
+			private IRule createRule;
+			private IRule updateRule;
+			private IRule deleteRule;
+			
+			public <%= TableGrammarName(table) %>(<%= CrudPopulatorName%> populator)
+			{
+				if (populator==null)
+					throw new ArgumentNullException("populator");
+				this.populator = populator;
+				this.CreateRules();
+			}
+			
+			public <%= CrudPopulatorName%> Populator
+			{
+				get { return this.populator;}
+			}
+			
+			public IRule CreateRule
+			{
+				get { return this.createRule;}
+			}
+			public IRule UpdateRule
+			{
+				get { return this.updateRule;}				
+			}
+			public IRule DeleteRule
+			{
+				get { return this.deleteRule;}
+			}
+			
+			protected void CreateRules()
+			{
+				this.createRule = Rules.Method(new MethodInvoker(this.Create));
+				this.updateRule = Rules.Method(new MethodInvoker(this.Update));
+				this.deleteRule = Rules.Method(new MethodInvoker(this.Delete));
+				
+				this.StartRule = Rules.Alt(
+					this.createRule
+					,this.updateRule
+//					,this.deleteRule
+					);
+			}
+			
+			private void Create()
+			{
+				DataRow row = this.populator.Create<%= Format(table.Name) %>();
+				Console.WriteLine("Created <%= Format(table.Name) %>");
+			}
+			private void Delete()
+			{
+				this.populator.Delete<%= Format(table.Name) %>();
+				Console.WriteLine("Deleted <%= Format(table.Name) %>");
+			}
+			private void Update()
+			{
+				this.populator.Update<%= Format(table.Name) %>();
+				Console.WriteLine("Updated <%= Format(table.Name) %>");
+			}
+		}
+		#endregion
+<%}// foreach(TableSchema table in this.Database.Tables) %>
+		#endregion
+	}
+}
+<script runat="template">
+#region Properties
+public string DatabaseName
+{ 
+	get
+	{
+		return this.Database.Name;
+	}
+}
+public string DatabaseGrammarName
+{
+	get
+	{
+		return Format(this.GrammarNameFormat,this.DatabaseName);
+	}
+}
+public string TableGrammarName(TableSchema table)
+{
+	return Format(this.GrammarNameFormat, table.Name);
+}
+public string TableGrammarPropertyName(TableSchema table)
+{
+	return Format(table.Name);
+}
+public string DataSetName
+{
+	get{ return Format(this.DataSetNameFormat, this.DatabaseName);}
+}
+public string CrudPopulatorName
+{
+	get{ return Format(this.CrudPopulatorNameFormat,this.DatabaseName);}
+}
+public string DatabasePopulatorName
+{
+	get{ return Format(this.DatabasePopulatorNameFormat,this.DatabaseName);}
+}
+public string GetTablePopulatorName(TableSchema table)
+{
+	return Format(this.TablePopulatorNameFormat, table.Name);
+}
+public string GetTablePopulatorPropertyName(TableSchema table)
+{
+	return Format(table.Name);
+}
+public string GetColumnDataGeneratorName(ColumnSchema column)
+{
+	return Format(ColumnDataGeneratorNameFormat, column.Name);
+}
+public string GetUniqueValidatorName(TableKeySchema unique)
+{
+	return  Format(UniqueValidatorNameFormat, unique.Name);
+}
+public string GetForeignKeyProviderName(TableKeySchema unique)
+{
+	return  Format(ForeignKeyProviderNameFormat, unique.Name);
+}
+protected string FormatLower(string format, params object[] args)
+{
+	string s= Format(format,args);
+	return Char.ToLower(s[0]) + s.Substring(1);
+}
+protected string Format(string format, params Object[] args)
+{
+	string result = string.Format(format,args);
+	if (this.TableNamePrefix!=null && this.TableNamePrefix.Length > 0)
+	{
+		if (result.StartsWith(this.TableNamePrefix))
+			result = result.Substring(this.TableNamePrefix.Length);
+	}
+	
+	result = result.Replace(" ","").Replace("_","").Replace(".","");
+	return result;
+}
+
+#endregion
+</script>

data/docs/extras/Snippets/MockObject.cst

@@ -0,0 +1,296 @@
+<%@ CodeTemplate Language="C#" TargetLanguage="C#" Description="Basic Mock Object template." %>
+<%@ Property Name="Interface" Type="System.String" Category="Options" Description="Interface to mock" %>
+<%@ Property Name="Namespace" Type="System.String" Category="Options" Description="Namespace of the wrapped class" %>
+<%@ Property Name="MockNamespace" Type="System.String" Category="Options" Description="Namespace of the wrapped class" %>
+<%@ Import Namespace="System.Reflection" %>
+<%@ Import Namespace="System.Collections" %>
+<%@ Import Namespace="System.Collections.Specialized" %>
+<%@ Import Namespace="System.IO" %>
+<%@ Import Namespace="System.ComponentModel.Design" %>
+<%@ Import Namespace="System.Drawing.Design" %>
+<%@ Assembly Name="AssemblyHelper"%>
+<%@ Assembly Name="System.Design"%>
+<%@ Import Namespace="AssemblyHelper" %>
+
+using System;
+using DotNetMock;
+using <%= Namespace %>
+
+namespace <%= MockNamespace %>
+{
+	/// <summary>
+	/// Mock of the <%= SeeInterface %> interface.
+	/// </summary>
+	/// <remark>
+	/// This class was generated and needs some work :)
+	/// </remarks>
+	public class <%= MockClass %> : <%= Interface %>, MockObject 
+	{
+		#region Private fields
+<% foreach(ExpectationEntry ep in this.expectations){%>
+		private <%= ep.ExpectedType %> <%= ep.FieldName %> = new <%= ep.ExpectedType %>("<%= MockClass %>.<%= ep.Name %>");
+<%}%>
+		#endregion
+		
+		#region MockObject
+		/// <summary>
+		/// Default Constructor
+		/// </summary>
+		public <%= MockClass %>() {}
+		
+		/// <summary>
+		/// Constructor. Sets the name of this <see cref="<%= MockClass %>"/>
+		/// </summary>
+		/// <param name="name">Name of this MockObject</param>
+		public <%= MockClass %>(string name)
+		:base(name) 
+		{}
+
+<% foreach(ExpectationEntry ep in this.expectations){%>
+		/// <summary>
+		/// Sets the ... affected 
+		/// </summary>
+		/// <param name="expected">
+		/// Expected value.
+		/// </param>
+		public void <%= ep.MethodName() %>(<%= ep.ValueType %> expected)
+		{
+			this.<%= ep.Name %>.Expected = expected;
+			this.NotImplemented("Set<%= ep.MethodName() %>");
+		}
+<%}%>
+
+		#endregion
+		
+		#region <%= Interface %> members 
+<%	foreach(MethodInfo mi in this.InterfaceType.GetMethods()){
+		if (mi.Name.StartsWith("get_") || mi.Name.StartsWith("set_"))
+			continue;
+%>
+		<%= mi.ReturnType %> <%= this.InterfaceType.Name %>.<%= mi.Name %>(<%= MethodParameters(mi) %>)
+		{
+			this.NotImplemented("<%= mi.Name %>");
+		}
+		
+<%	}%>
+<%	foreach(PropertyInfo pi in this.InterfaceType.GetProperties()){%>
+		<%= pi.PropertyType %> <%= this.InterfaceType.Name %>.<%= pi.Name %><%= PropertyParameters(pi) %> 
+		{
+<%      if (pi.CanRead){%>
+            get
+			{
+				this.NotImplemented("get <%= pi.Name %>");
+			}
+<%      }
+        if (pi.CanWrite){%>
+            get
+			{
+				this.NotImplemented("set <%= pi.Name %>");
+			}
+<%      }%>			
+		}
+		
+<%	}%>
+		#endregion
+
+<% foreach(Type it in this.InterfaceType.GetInterfaces()) {%>
+		#region <%= it.Name %> members 
+<%	foreach(MethodInfo mi in it.GetMethods()){
+		if (mi.Name.StartsWith("get_") || mi.Name.StartsWith("set_"))
+			continue;
+%>
+		<%= mi.ReturnType %> <%= it.Name %>.<%= mi.Name %>(<%= MethodParameters(mi) %>)
+		{
+				this.NotImplemented("<%= mi.Name %>");
+		}
+		
+<%	}%>
+<%	foreach(PropertyInfo pi in it.GetProperties()){%>
+		<%= pi.PropertyType %> <%= it.Name %>.<%= pi.Name %><%= PropertyParameters(pi) %> 
+		{
+<%      if (pi.CanRead){%>
+            get
+			{
+				this.NotImplemented("get <%= pi.Name %>");
+			}
+<%      }
+        if (pi.CanWrite){%>
+            get
+			{
+				this.NotImplemented("set <%= pi.Name %>");
+			}
+<%      }%>			
+		}
+		
+<%	}%>
+		#endregion
+<%}%>
+	}
+}
+
+<script runat="template">
+private Assembly assembly;
+private ExpectationEntryCollection expectations = new ExpectationEntryCollection();
+
+[Editor(typeof(AssemblyHelper.AssemblyFilePicker), typeof(System.Drawing.Design.UITypeEditor))]
+[Category("Options")]
+public Assembly AssemblyToLoad
+{
+      get{return assembly;}
+      set{assembly = value;}
+}
+
+[TypeConverter(typeof(ExpandableObjectConverter))] 
+[Category("Options")]
+public class ExpectationEntry
+{
+	private string expectedType;
+	private string fieldName;
+	private string name;
+	private string value;
+	private string valueType;
+	
+	[Category("Options")]
+	public String ExpectedType
+	{	
+		get{ return this.expectedType;}
+		set{ this.expectedType = value;}
+	}
+	[Category("Options")]
+	public String FieldName
+	{	
+		get{ return this.fieldName;}
+		set{ this.fieldName = value;}
+	}	
+	[Category("Options")]
+	public String Name
+	{	
+		get{ return this.name;}
+		set{ this.name = value;}
+	}	
+	[Category("Options")]
+	public String Value
+	{	
+		get{ return this.value;}
+		set{ this.value = value;}
+	}
+	[Category("Options")]
+	public String ValueType
+	{	
+		get{ return this.valueType;}
+		set{ this.valueType = value;}
+	}
+	public Type GetExpectationType()
+	{
+		return System.Type.GetType(this.expectedType, true);
+	}
+	public Type GetValueType()
+	{
+		return System.Type.GetType(this.valueType, true);
+	}	
+	public String ValueToString()
+	{
+		if (GetValueType()== typeof(String))
+			return String.Format("\"{0}\"", this.Value);
+		else
+			return this.Value.ToString();
+	}
+	public String MethodName()
+	{
+		return "See" + Char.ToUpper(fieldName[0]) + fieldName.Substring(1, fieldName.Length-1);
+	}
+}
+
+public class ExpectationEntryCollection : ArrayList
+{
+	public new ExpectationEntry this[int index]
+	{
+		get
+		{
+			return (ExpectationEntry)base[index];
+		}
+		set
+		{
+			base[index] = value;
+		}
+	}
+}
+
+[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
+[Editor(typeof(CollectionEditor), typeof(System.Drawing.Design.UITypeEditor))]
+[Category("Options")]
+public ExpectationEntryCollection Expectations
+{
+      get{return expectations;}
+	  set{expectations = value;}
+}
+
+// fields
+private Type interfaceType = null;
+// mocked class type
+protected Type InterfaceType
+{
+	get
+	{
+		if (this.interfaceType==null)
+		{
+			this.interfaceType=this.AssemblyToLoad.GetType(
+				String.Format("{0}.{1}",
+					this.Namespace,this.Interface), 
+					true);			
+			if (!this.interfaceType.IsInterface)
+				throw new Exception("Type must be an interface");
+		}
+		return this.interfaceType;
+	}
+}
+// <see cref="Interface"/>
+protected string SeeInterface
+{
+	get
+	{
+		return String.Format("<see cref=\"{0}\"/>", this.Interface);
+	}
+}
+// mock class name
+protected string MockClass
+{	
+	get
+	{
+		return "Mock" + this.Interface.Substring(1, this.Interface.Length-1);
+	} 
+}
+// output parameters to string
+protected string MethodParameters(MethodBase mi)
+{
+	StringWriter sw = new StringWriter();
+	bool comma = false;
+	foreach(ParameterInfo pi in mi.GetParameters())
+	{
+		if (comma)
+			sw.Write(", ");
+		else
+			comma=true;
+			
+		sw.Write("{0} {1}",pi.ParameterType.Name, pi.Name);
+	}
+	return sw.ToString();
+}
+protected string PropertyParameters(PropertyInfo pi)
+{
+	if (pi.CanRead)
+	{
+		if (pi.GetGetMethod().GetParameters().Length==0)
+			return null;
+		else
+			return String.Format("[{0}]",this.MethodParameters(pi.GetGetMethod()));
+	}
+	else
+	{
+		if (pi.GetSetMethod().GetParameters().Length==0)
+			return null;
+		else
+			return String.Format("[{0}]",this.MethodParameters(pi.GetSetMethod()));
+	}
+}
+</script>