public DebugResponse(string roomID, List<int> breakpoints, StepType step, bool action)
 {
     RoomID = roomID;
     Breakpoints = breakpoints;
     Step = step;
     Action = action;
 }

 public StepName(StepType stepType, string name, IEnumerable<KeyValuePair<string, object>> substitutionParameters = null)
 {
     StepType = stepType;
     SeparatorToken = GetSeparatorToken(stepType, name);
     Outline = GetOutline(stepType, name);
     PrettyName = SubstituteParameters(Outline, substitutionParameters);
 }

        private string ProcessStepLine(string stepLine, StepType stepType)
        {
            string str = stepLine;

            var stepToken = stepType.ToString();

            const string andToken = "And";
            if (str.StartsWith(andToken, StringComparison.InvariantCultureIgnoreCase))
            {
                str = str.Substring(andToken.Length);
                stepToken = andToken;
            }

            const string butToken = "But";
            if (str.StartsWith(butToken, StringComparison.InvariantCultureIgnoreCase))
            {
                str = str.Substring(butToken.Length);
                stepToken = butToken;
            }

            if (str.StartsWith(stepToken, StringComparison.InvariantCultureIgnoreCase))
            {
                str = str.Substring(stepToken.Length);
            }

            str = Sanitize(str);

            return string.Format("{0}_{1}", stepToken, str);
        }

 public static SemanticVersion Increment(this SemanticVersion target, StepType stepType)
 {
     switch (stepType)
     {
         case StepType.Major:
             return new SemanticVersion
             {
                 Major = target.Major + 1,
                 Minor = 0,
                 Patch = 0
             };
         case StepType.Minor:
             return new SemanticVersion
             {
                 Major = target.Major,
                 Minor = target.Minor + 1,
                 Patch = 0
             };
         case StepType.Patch:
             return new SemanticVersion
             {
                 Major = target.Major,
                 Minor = target.Minor,
                 Patch = target.Patch + 1
             };
         default:
             throw new Exception("Unknown StepType: " + stepType);
     }
 }

 protected BaseStep(bool runOnce, int stepOrder, StepType type, Stream sourceStream = null)
 {
     RunOnce = runOnce;
     StepOrder = stepOrder;
     Type = type;
     SourceStream = sourceStream;
 }

        void IDebuggable.Step(StepType type)
		{
            if (_selectedDebuggable == null)
            {
                SetDefaultDebuggable();
            }
            _selectedDebuggable.Step(type);
		}

            public MapReduceStep(LambdaExpression Expression, StepType type)
            {
                this.Expression = Expression;
                this.Type = type;

                Throw.If(this.InputType.GetGenericTypeDefinition() != typeof(KeyValuePair<,>), this.InputType.Name + " is not a key value pair");
                Throw.If(this.OutputType.GetGenericTypeDefinition() != typeof(KeyValuePair<,>), this.OutputType.Name + " is not a key value pair");
            }

        private void ProcessScenarioLine(ScenarioStyle style, string line, ref StepType stepType, StringBuilder builder)
        {
            if (stepType == StepType.When)
            {
                stepType = StepType.Then;
            }

            if (line.StartsWith("When"))
            {
                stepType = StepType.When;
            }

            const string tagToken = "@";
            if (line.StartsWith(tagToken))
            {
                var tags = line.Split('@');

                foreach (var tag in tags
                    .Select(t => t.Trim().Trim('@'))
                    .Where(t => !string.IsNullOrWhiteSpace(t)))
                {
                    builder.AppendLine($"   [Tag(\"{tag}\")]");
                }
                return;
            }
            const string scenarioToken = "Scenario:";
            if (line.StartsWith(scenarioToken))
            {
                if (style == ScenarioStyle.Classic) builder.AppendLine("   [Scenario(Feature.Unknown)]");
                string className = Sanitize(line.Substring(scenarioToken.Length));
                builder.AppendLine($"   public class {className} : {GetScenarioTypeName(style)}");
                builder.AppendLine("   {");

                if (style == ScenarioStyle.Fluent)
                {
                    builder.AppendLine($"      public {className}()");
                    builder.AppendLine("      {");
                    builder.AppendLine("         TODO");
                    builder.AppendLine("      }");
                    builder.AppendLine();
                }

                return;
            }

            if (line.StartsWith("-> done: "))
            {
                return;
            }

            var methodName = ProcessStepLine(line, stepType);

            if (style == ScenarioStyle.Classic) builder.AppendLine($"      [{stepType}]");
            builder.AppendLine($"      {GetAccessModifierForStep(style)}void {methodName}()");
            builder.AppendLine("      {");
            builder.AppendLine("      }");
            builder.AppendLine();
        }

 public StepMethodInvoker(StepType stepType, MethodBase method, KeyValuePair<string, object>[] supportedParameters = null)
 {
     Method = method;
     Type = stepType;
     Parameters = method.BindParameters(supportedParameters);
     Name = new StepName(Type, method.Name, supportedParameters);
     ExceptionExpected = method.AttributeOrDefault<ThrowsAttribute>() != null;
     SourceDescription = string.Format("{0}.{1}", method.DeclaringType.FullName, method.Name);
 }

 public void GetStepType(string clause, StepType expected, StepType actual)
 {
     "Given a string starts with '{0}'"
         .Given(() => clause = clause + " foo");
     "When GetStepType() is called"
         .When(() => actual = StringExtensions.GetStepType(clause));
     "Then StepType.{1} is returned"
         .Then(() => actual.Should().Be(expected));
 }

 public StepClassInvoker(StepType stepType, Type stepClass, KeyValuePair<string,object>[] supportedParameters, IExceptionHandler exceptionHandler)
 {
     if (!typeof(Step).IsAssignableFrom(stepClass))
         throw new ArgumentException("The stepClass must inherit from Step", "stepClass");
     _stepClass = stepClass;
     _exceptionHandler = exceptionHandler;
     Type = stepType;
     Name = new StepName(Type, _stepClass.Name, supportedParameters);
     Parameters = _stepClass.GetConstructors().Single().BindParameters(supportedParameters);
 }

    public BaseMovement(Transform transform, float speed, StepType step, bool terrestrial, Vector3? offset)
    {
        this.transform = transform;
        this.speed = speed;
        this.step = step;
        this.terrestrial = terrestrial;
        this.offset = offset == null ? Vector3.zero : (Vector3) offset;

        this.phase = 1; // Movement start ended
    }

        public static void GetStepType(string clause, StepType expected, StepType actual)
        {
            "Given a string starts with '{0}'"
                .Given(() => clause = clause + " foo");

            "When getting the step type"
                .When(() => actual = StringExtensions.GetStepType(clause));

            "Then the step type is '{1}'"
                .Then(() => actual.Should().Be(expected));
        }

 public bool CanStep(StepType type)
 {
     switch (type)
     {
         case StepType.Into:
         case StepType.Over:
         case StepType.Out:
             return true;
         default:
             return false;
     }
 }

 bool IDebuggable.CanStep(StepType type)
 {
     switch (type)
     {
         case StepType.Into:
         case StepType.Over:
         case StepType.Out:
             return DebuggerStep != null;
         default:
             return false;
     }
 }

 public string GetStep(StepType stepType)
 {
     switch (stepType)
     {
         case StepType.Given:
             return _settings.Given;
         case StepType.When:
             return _settings.When;
         case StepType.Then:
             return _settings.Then;
         default:
             throw new NotSupportedException(string.Format("Unknown step type: {0}", stepType));
     }
 }

		public void Step(StepType type)
		{
			switch (type)
			{
				case StepType.Into:
					StepInto();
					break;
				case StepType.Out:
					StepOut();
					break;
				case StepType.Over:
					StepOver();
					break;
			}
		}

        private string GetOutline(StepType stepType, string name)
        {
            var stepNameSansStepType = GetStepNameWithoutTypeNorSeperators(stepType, name);

            if (string.IsNullOrWhiteSpace(stepNameSansStepType))
            {
                // no conversion to _ or PascalCase necessary -- bail
                return string.Empty;
            }

            var outline = stepNameSansStepType.AsSentence();

            return outline.StartsWithMultipleUppercaseLetters()
                ? outline
                : outline.WithFirstLetterLowercase();
        }

        public ActionStepMethod(MethodInfo info, StepAttribute attribute)
        {
            if (attribute is GivenAttribute)
            {
                stepType = StepType.Given;
            }

            if (attribute is WhenAttribute)
            {
                stepType = StepType.When;
            }

            if (attribute is ThenAttribute)
            {
                stepType = StepType.Then;
            }

            text = attribute.Text;
            methodInfo = info;
        }

 public static SemanticVersion Decrement(this SemanticVersion target, StepType stepType)
 {
     switch (stepType)
     {
         case StepType.Major:
             if (target.Major == 0)
             {
                 throw new WeavingException($"Can not derive `TreatAsErrorFromVersion` from '{target}' since Major is 0.");
             }
             return new SemanticVersion
                 {
                     Major = target.Major -1,
                     Minor = 0,
                     Patch = 0
                 };
         case StepType.Minor:
             if (target.Minor == 0)
             {
                 throw new WeavingException($"Can not derive `TreatAsErrorFromVersion` from '{target}' since Minor is 0.");
             }
             return new SemanticVersion
                 {
                     Major = target.Major,
                     Minor = target.Minor - 1,
                     Patch = 0
                 };
         case StepType.Patch:
             if (target.Patch == 0)
             {
                 throw new WeavingException($"Can not derive `TreatAsErrorFromVersion` from '{target}' since Patch is 0.");
             }
             return new SemanticVersion
                 {
                     Major = target.Major,
                     Minor = target.Minor,
                     Patch = target.Patch - 1
                 };
         default:
             throw new Exception("Unknown StepType: " + stepType);
     }
 }