(string key, out TValue value)
+ {
+ object result;
+ if (base.TryGetValue(key, out result))
+ {
+ value = (TValue)result;
+ return true;
+ }
+
+ value = default(TValue);
+ return false;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Runtime/StepArgs.cs b/Runtime/StepArgs.cs
new file mode 100644
index 000000000..88b085011
--- /dev/null
+++ b/Runtime/StepArgs.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Linq;
+
+namespace TechTalk.SpecFlow
+{
+ internal class StepArgs
+ {
+ public StepDefinitionKeyword StepDefinitionKeyword { get; private set; }
+ public BindingType Type { get; private set; }
+ public string Text { get; private set; }
+ public string MultilineTextArgument { get; private set; }
+ public Table TableArgument { get; private set; }
+
+ public StepArgs(BindingType type, StepDefinitionKeyword stepDefinitionKeyword, string text, string multilineTextArgument, Table tableArgument)
+ {
+ Type = type;
+ StepDefinitionKeyword = stepDefinitionKeyword;
+ Text = text;
+ MultilineTextArgument = multilineTextArgument;
+ TableArgument = tableArgument;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Runtime/StepBinding.cs b/Runtime/StepBinding.cs
new file mode 100644
index 000000000..afc536959
--- /dev/null
+++ b/Runtime/StepBinding.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using System.Text.RegularExpressions;
+
+namespace TechTalk.SpecFlow
+{
+ internal class StepBinding
+ {
+ public BindingType Type { get; private set; }
+ public Regex Regex { get; private set; }
+ public Delegate BindingAction { get; private set; }
+ public Type[] ParameterTypes { get; private set; }
+ public MethodInfo MethodInfo { get; private set; }
+
+
+ public StepBinding(BindingType type, Regex regex, Delegate bindingAction, Type[] parameterTypes, MethodInfo methodInfo)
+ {
+ Type = type;
+ Regex = regex;
+ BindingAction = bindingAction;
+ ParameterTypes = parameterTypes;
+ MethodInfo = methodInfo;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Runtime/StringExtensions.cs b/Runtime/StringExtensions.cs
new file mode 100644
index 000000000..c58446dd8
--- /dev/null
+++ b/Runtime/StringExtensions.cs
@@ -0,0 +1,59 @@
+using System;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+namespace TechTalk.SpecFlow
+{
+ internal static class StringExtensions
+ {
+ public static string Indent(this string text, string indent)
+ {
+ if (text.EndsWith(Environment.NewLine))
+ {
+ return text.Remove(text.Length - Environment.NewLine.Length).Indent(indent) + Environment.NewLine;
+ }
+
+ return indent + text.Replace(Environment.NewLine, Environment.NewLine + indent);
+ }
+
+ public static string ToIdentifier(this string text)
+ {
+ Regex firstWordCharRe = new Regex(@"(?[^a-zA-Z]+)(?[a-zA-Z])");
+ text = firstWordCharRe.Replace(text, match => match.Groups["pre"].Value + match.Groups["fc"].Value.ToUpper());
+
+ Regex punctCharRe = new Regex(@"[\n\.-]+");
+ text = punctCharRe.Replace(text, "_");
+
+ Regex nonWordCharRe = new Regex(@"[^a-zA-Z0-9_]+");
+ text = nonWordCharRe.Replace(text, "");
+
+ if (text.Length > 0)
+ {
+ text = text.Substring(0, 1).ToUpper() + text.Substring(1);
+
+ if (char.IsDigit(text[0]))
+ text = "_" + text;
+ }
+
+ return text;
+ }
+
+ public static string ToIdentifierCamelCase(this string text)
+ {
+ string identifier = ToIdentifier(text);
+ if (text.Length > 0)
+ identifier = identifier.Substring(0, 1).ToLower() + identifier.Substring(1);
+
+ return identifier;
+ }
+
+ public static string TrimEllipse(this string text, int maxLength)
+ {
+ if (text == null || text.Length <= maxLength)
+ return text;
+
+ const string ellipse = "...";
+ return text.Substring(0, maxLength - ellipse.Length) + ellipse;
+ }
+ }
+}
\ No newline at end of file
diff --git a/Runtime/Table.cs b/Runtime/Table.cs
new file mode 100644
index 000000000..789461258
--- /dev/null
+++ b/Runtime/Table.cs
@@ -0,0 +1,179 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+
+namespace TechTalk.SpecFlow
+{
+ public class Table
+ {
+ private readonly string[] header;
+ private readonly TableRows rows = new TableRows();
+
+ public IEnumerable Header
+ {
+ get { return header; }
+ }
+
+ public TableRows Rows
+ {
+ get { return rows; }
+ }
+
+ public int RowCount
+ {
+ get { return rows.Count; }
+ }
+
+ public Table(params string[] header)
+ {
+ if (header == null || header.Length == 0)
+ throw new ArgumentException("invalid header count", "header");
+
+ for (int colIndex = 0; colIndex < header.Length; colIndex++)
+ header[colIndex] = header[colIndex] ?? string.Empty;
+ this.header = header;
+ }
+
+ internal int GetHeaderIndex(string column)
+ {
+ int index = Array.IndexOf(header, column);
+ if (index < 0)
+ throw new Exception("could not find column");
+ return index;
+ }
+
+ public void AddRow(params string[] cells)
+ {
+ if (cells == null || cells.Length != header.Length)
+ throw new Exception("invalid cell count");
+
+ var row = new TableRow(this, cells);
+ rows.Add(row);
+ }
+
+ public override string ToString()
+ {
+ int[] columnWidths = new int[header.Length];
+ for (int colIndex = 0; colIndex < header.Length; colIndex++)
+ columnWidths[colIndex] = header[colIndex].Length;
+
+ foreach (TableRow row in rows)
+ {
+ for (int colIndex = 0; colIndex < header.Length; colIndex++)
+ columnWidths[colIndex] = Math.Max(columnWidths[colIndex], row[colIndex].Length);
+ }
+
+ StringBuilder builder = new StringBuilder();
+ AddTableRow(builder, header, columnWidths);
+ foreach (TableRow row in rows)
+ AddTableRow(builder, row.Select(pair => pair.Value), columnWidths);
+ return builder.ToString();
+ }
+
+ private void AddTableRow(StringBuilder builder, IEnumerable cells, int[] widths)
+ {
+ const string margin = " ";
+ const string separator = "|";
+ int colIndex = 0;
+
+ builder.Append(separator);
+ foreach (string cell in cells)
+ {
+ builder.Append(margin);
+
+ builder.Append(cell);
+ builder.Append(' ', widths[colIndex] - cell.Length);
+
+ builder.Append(margin);
+ builder.Append(separator);
+
+ colIndex++;
+ }
+
+ builder.AppendLine();
+ }
+ }
+
+ public class TableRows : IEnumerable
+ {
+ private readonly List innerList = new List();
+
+ public int Count { get { return innerList.Count; } }
+
+ public TableRow this[int index]
+ {
+ get { return innerList[index]; }
+ }
+
+ public IEnumerator GetEnumerator()
+ {
+ return innerList.GetEnumerator();
+ }
+
+ IEnumerator IEnumerable.GetEnumerator()
+ {
+ return GetEnumerator();
+ }
+
+ internal void Add(TableRow row)
+ {
+ innerList.Add(row);
+ }
+ }
+
+ public class TableRow : IEnumerable>
+ {
+ private readonly Table table;
+ private readonly string[] items;
+
+ internal TableRow(Table table, string[] items)
+ {
+ for (int colIndex = 0; colIndex < items.Length; colIndex++)
+ items[colIndex] = items[colIndex] ?? string.Empty;
+
+ this.table = table;
+ this.items = items;
+ }
+
+ public string this[string header]
+ {
+ get
+ {
+ int itemIndex = table.GetHeaderIndex(header);
+ return items[itemIndex];
+ }
+ }
+
+ public string this[int index]
+ {
+ get
+ {
+ return items[index];
+ }
+ }
+
+ public int Count
+ {
+ get { return items.Length; }
+ }
+
+ public IEnumerator> GetEnumerator()
+ {
+ Debug.Assert(items.Length == table.Header.Count());
+ int itemIndex = 0;
+ foreach (string header in table.Header)
+ {
+ yield return new KeyValuePair(header, items[itemIndex]);
+ itemIndex++;
+ }
+ }
+
+ IEnumerator IEnumerable.GetEnumerator()
+ {
+ return GetEnumerator();
+ }
+ }
+}
\ No newline at end of file
diff --git a/Runtime/TechTalk.SpecFlow.csproj b/Runtime/TechTalk.SpecFlow.csproj
new file mode 100644
index 000000000..02901fe64
--- /dev/null
+++ b/Runtime/TechTalk.SpecFlow.csproj
@@ -0,0 +1,93 @@
+
+
+
+ Debug
+ AnyCPU
+ 9.0.30729
+ 2.0
+ {413EE28C-4F89-4C6F-BA1E-2CDEE4CD43B4}
+ Library
+ Properties
+ TechTalk.SpecFlow
+ TechTalk.SpecFlow
+ v3.5
+ 512
+ SAK
+ SAK
+ SAK
+ SAK
+
+
+ true
+ full
+ false
+ bin\Debug\
+ DEBUG;TRACE
+ prompt
+ 4
+
+
+ pdbonly
+ true
+ bin\Release\
+ TRACE
+ prompt
+ 4
+
+
+
+ False
+ ..\lib\nunit\nunit.framework.dll
+
+
+
+
+ 3.5
+
+
+ 3.5
+
+
+ 3.5
+
+
+
+
+
+
+ VersionInfo.cs
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/Runtime/TechTalk.SpecFlow.csproj.vspscc b/Runtime/TechTalk.SpecFlow.csproj.vspscc
new file mode 100644
index 000000000..b6d32892f
--- /dev/null
+++ b/Runtime/TechTalk.SpecFlow.csproj.vspscc
@@ -0,0 +1,10 @@
+""
+{
+"FILE_VERSION" = "9237"
+"ENLISTMENT_CHOICE" = "NEVER"
+"PROJECT_FILE_RELATIVE_PATH" = ""
+"NUMBER_OF_EXCLUDED_FILES" = "0"
+"ORIGINAL_PROJECT_FILE_PATH" = ""
+"NUMBER_OF_NESTED_PROJECTS" = "0"
+"SOURCE_CONTROL_SETTINGS_PROVIDER" = "PROVIDER"
+}
diff --git a/Runtime/TestFrameworkIntegration/ITestFrameworkIntegration.cs b/Runtime/TestFrameworkIntegration/ITestFrameworkIntegration.cs
new file mode 100644
index 000000000..5f23ad23c
--- /dev/null
+++ b/Runtime/TestFrameworkIntegration/ITestFrameworkIntegration.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace TechTalk.SpecFlow.TestFrameworkIntegration
+{
+ public interface ITestFrameworkIntegration
+ {
+ void TestInconclusive(string message);
+ void TestIgnore(string message);
+ }
+}
\ No newline at end of file
diff --git a/Runtime/TestFrameworkIntegration/NUnitIntegration.cs b/Runtime/TestFrameworkIntegration/NUnitIntegration.cs
new file mode 100644
index 000000000..8003d06a0
--- /dev/null
+++ b/Runtime/TestFrameworkIntegration/NUnitIntegration.cs
@@ -0,0 +1,19 @@
+using System;
+using System.Linq;
+using NUnit.Framework;
+
+namespace TechTalk.SpecFlow.TestFrameworkIntegration
+{
+ public class NUnitIntegration : ITestFrameworkIntegration
+ {
+ public void TestInconclusive(string message)
+ {
+ Assert.Inconclusive(message);
+ }
+
+ public void TestIgnore(string message)
+ {
+ Assert.Ignore(message);
+ }
+ }
+}
\ No newline at end of file
diff --git a/Runtime/TestRunner.cs b/Runtime/TestRunner.cs
new file mode 100644
index 000000000..999de8fb9
--- /dev/null
+++ b/Runtime/TestRunner.cs
@@ -0,0 +1,417 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+using System.Text.RegularExpressions;
+
+namespace TechTalk.SpecFlow
+{
+ public class TestRunner : ITestRunner
+ {
+ private BindingRegistry bindingRegistry = null;
+
+ public virtual void InitializeTestRunner(Assembly[] bindingAssemblies)
+ {
+ bindingRegistry = new BindingRegistry();
+ foreach (Assembly assembly in bindingAssemblies)
+ {
+ bindingRegistry.BuildBindingsFromAssembly(assembly);
+ }
+
+ OnTestRunnerStart();
+ AppDomain.CurrentDomain.DomainUnload +=
+ delegate
+ {
+ OnTestRunnerEnd();
+ };
+ }
+
+ protected virtual void OnTestRunnerStart()
+ {
+ FireEvents(BindingEvent.TestRunStart, null);
+ }
+
+ protected virtual void OnTestRunnerEnd()
+ {
+ FireEvents(BindingEvent.TestRunEnd, null);
+ }
+
+ public void OnFeatureStart(FeatureInfo featureInfo)
+ {
+ ObjectContainer.FeatureContext = new FeatureContext(featureInfo);
+ FireEvents(BindingEvent.FeatureStart, ObjectContainer.FeatureContext.FeatureInfo.Tags);
+ }
+
+ public void OnFeatureEnd()
+ {
+ FireEvents(BindingEvent.FeatureEnd, ObjectContainer.FeatureContext.FeatureInfo.Tags);
+
+ if (Configuration.Current.TraceTimings)
+ {
+ ObjectContainer.FeatureContext.Stopwatch.Stop();
+ var duration = ObjectContainer.FeatureContext.Stopwatch.Elapsed;
+ ObjectContainer.TestTracer.TraceDuration(duration, "Feature: " + ObjectContainer.FeatureContext.FeatureInfo.Title);
+ }
+
+ ObjectContainer.FeatureContext = null;
+ }
+
+ public void OnScenarioStart(ScenarioInfo scenarioInfo)
+ {
+ ObjectContainer.ScenarioContext = new ScenarioContext(scenarioInfo);
+ FireScenarioEvents(BindingEvent.ScenarioStart);
+ }
+
+ public void CollectScenarioErrors()
+ {
+ if (Configuration.Current.TraceTimings)
+ {
+ ObjectContainer.ScenarioContext.Stopwatch.Stop();
+ var duration = ObjectContainer.ScenarioContext.Stopwatch.Elapsed;
+ ObjectContainer.TestTracer.TraceDuration(duration, "Scenario: " + ObjectContainer.ScenarioContext.ScenarioInfo.Title);
+ }
+
+ if (ObjectContainer.ScenarioContext.TestStatus == TestStatus.OK)
+ return;
+
+ if (ObjectContainer.ScenarioContext.TestStatus == TestStatus.StepDefinitionPending)
+ {
+ var pendingSteps = ObjectContainer.ScenarioContext.PendingSteps.Distinct().OrderBy(s => s);
+ ObjectContainer.TestFrameworkIntegration.TestInconclusive(string.Format("{0}{2} {1}",
+ GetPendingStepDefinitionError().Message,
+ string.Join(Environment.NewLine + " ", pendingSteps.ToArray()),
+ Environment.NewLine));
+ return;
+ }
+
+ if (ObjectContainer.ScenarioContext.TestStatus == TestStatus.MissingStepDefinition)
+ {
+ var missingSteps = ObjectContainer.ScenarioContext.MissingSteps.Distinct().OrderBy(s => s);
+ string bindingSkeleton =
+ ObjectContainer.TestTracer.GetBindingClassSkeleton(
+ string.Join(Environment.NewLine, missingSteps.ToArray()));
+ ObjectContainer.TestFrameworkIntegration.TestInconclusive(string.Format("{0}{2}{1}",
+ GetMissingStepDefinitionError().Message,
+ bindingSkeleton,
+ Environment.NewLine));
+ return;
+ }
+
+ if (ObjectContainer.ScenarioContext.TestError == null)
+ throw new InvalidOperationException("test failed with an unknown error");
+
+ PreserveStackTrace(ObjectContainer.ScenarioContext.TestError);
+ throw ObjectContainer.ScenarioContext.TestError;
+ }
+
+ public void OnScenarioEnd()
+ {
+ HandleBlockSwitch(ScenarioBlock.None);
+
+ FireScenarioEvents(BindingEvent.ScenarioEnd);
+ ObjectContainer.ScenarioContext = null;
+ }
+
+ protected virtual void OnBlockStart(ScenarioBlock block)
+ {
+ if (block == ScenarioBlock.None)
+ return;
+
+ FireScenarioEvents(BindingEvent.BlockStart);
+ }
+
+ protected virtual void OnBlockEnd(ScenarioBlock block)
+ {
+ if (block == ScenarioBlock.None)
+ return;
+
+ FireScenarioEvents(BindingEvent.BlockEnd);
+ }
+
+ protected virtual void OnStepStart()
+ {
+ FireScenarioEvents(BindingEvent.StepStart);
+ }
+
+ protected virtual void OnStepEnd()
+ {
+ FireScenarioEvents(BindingEvent.StepEnd);
+ }
+
+ #region Step/event execution
+ private readonly string[] emptyTagList = new string[0];
+
+ private void FireScenarioEvents(BindingEvent bindingEvent)
+ {
+ var tags = (ObjectContainer.FeatureContext.FeatureInfo.Tags ?? emptyTagList).Concat(
+ ObjectContainer.ScenarioContext.ScenarioInfo.Tags ?? emptyTagList);
+ FireEvents(bindingEvent, tags);
+ }
+
+ private void FireEvents(BindingEvent bindingEvent, IEnumerable tags)
+ {
+ foreach (EventBinding eventBinding in bindingRegistry.GetEvents(bindingEvent))
+ {
+ if (IsTagNeeded(eventBinding.Tags, tags))
+ {
+ InvokeAction(eventBinding.BindingAction, null, eventBinding.MethodInfo);
+ }
+ }
+ }
+
+ private bool IsEmptyTagList(IEnumerable tags)
+ {
+ return tags == null || !tags.Any();
+ }
+
+ private bool IsTagNeeded(IEnumerable filterTags, IEnumerable currentTags)
+ {
+ if (IsEmptyTagList(filterTags))
+ return true;
+
+ if (currentTags == null)
+ return false;
+
+ return filterTags.Intersect(currentTags).Any();
+ }
+
+ private BindingMatch Match(StepBinding stepBinding, StepArgs stepArgs)
+ {
+ Match match = stepBinding.Regex.Match(stepArgs.Text);
+ if (!match.Success)
+ return null;
+
+ object[] extraArgs = null;
+ if (stepArgs.MultilineTextArgument != null || stepArgs.TableArgument != null)
+ {
+ List