C# IStep类代码示例

		public void onStepLoad(IStep step, Assembly assembly)
		{
			var assemblyInvoke = (ascx_AssemblyInvoke)step.FirstControl;
			assemblyInvoke.loadAssembly(assembly);
			assemblyInvoke.setExecuteMethodOnDoubleClick(true);
			//PublicDI.log.error("type:{0}:", assemblyInvoke.GetType().FullName);
		}

 void ITestStream.Do(DoGrammarStructure structure, IStep step)
 {
     _paragraphResults.ForExceptionText(text =>
     {
         _document.Add(new ExceptionTag(text));
     });
 }

 public ProgressDialog(string title,IStep step)
     : base(Font.MediumFont, title)
 {
     this.step = step;
     progressLine = 1;
     CreateProcessThread ();
 }

 public void ReadExpected(ITestContext context, IStep step, SetRow row)
 {
     Cell.ReadArgument(context, step, x =>
     {
         row.Values[Cell.Key] = x;
     });
 }

        protected override void execute(IWebElement element, IDictionary<string, object> cellValues, IStep step, ITestContext context)
        {
            assertCondition(element.Enabled, DisabledElementMessage);
            assertCondition(element.Displayed, HiddenElementMessage);

            element.Click();
        }

        protected override void execute(IWebElement element, IDictionary<string, object> cellValues, IStep step, ITestContext context)
        {
            // TODO -- StoryTeller needs to pull this all inside the Cell
            if (!cellValues.ContainsKey(_cell.Key))
            {
                // already caught as a syntax error
                return;
            }

            var handler = ElementHandlers.FindHandler(element);
            var expectedValue = cellValues[_cell.Key];

            var matchingHandler = handler as IMatchingHandler ?? new BasicMatchingHandler(handler, context);

            if (matchingHandler.MatchesData(element, expectedValue))
            {
                context.IncrementRights();
            }
            else
            {
                context.ResultsFor(step).MarkFailure(_cell.Key);
                context.IncrementWrongs();
            }

            context.ResultsFor(step).SetActual(_cell.Key, handler.GetData(CurrentContext, element));
        }

 public SentenceTag(Sentence sentence, IStep step)
     : base("div")
 {
     _sentence = sentence;
     _step = step;
     this.AddSafeClassName(sentence.Name);
     AddClass("sentence");
 }

        public void Execute(IStep containerStep, ITestContext context)
        {
            context.PerformAction(containerStep, _before);

            containerStep.LeafFor(_leafName).AllSteps().Each(step => { context.RunStep(InnerGrammar, step); });

            context.PerformAction(containerStep, _after);
        }

        private void SetStep(IStep step)
        {
            TopMost = step.TopMost;
            _steps.Push(step);
            step.Initialize(_state);

            SetUI(step);
        }

 public void AddStepBefore(Type target, IStep step)
 {
     for (int i = 0; i < _steps.Count; i++) {
         if (_steps [i].GetType () == target) {
             _steps.Insert (i, step);
             return;
         }
     }
 }

        public void Parse(string template, IStep step, IEnumerable<Cell> cells)
        {
            MatchCollection matches = Regex.Matches(template, @"\{(\w+)\}");

            List<string> keys = getKeys(matches);
            validate(template, cells, keys);

            parse(template, matches, cells, step);
        }

        public void step2_loadFiles(IStep step)
        {
        	O2Thread.mtaThread(
        		() => 	{				        	
				        	var testFiles = Files.getFilesFromDir_returnFullPath(PublicDI.config.O2TempDir,"*.cs", true);
				        	var searchTargets = (ascx_SearchTargets)step.Controller.steps[2].FirstControl;
				        	searchTargets.loadFiles(testFiles);
				        });
        }

 public void InvokefMethod(IStep step, string clause)
 {
     "Given a string"
         .Given(() => clause = "Given foo");
     "When the do extension method is invoked"
         .When(() => step = clause.f(() => { }));
     "Then a step is returned"
         .Then(() => step.Should().NotBeNull());
 }

        public CellTag(Cell cell, IStep step)
            : base("span")
        {
            if (step == null) throw new ArgumentNullException("step");

            _cell = cell;
            _step = step;

            AddClass(HtmlClasses.INPUT);
        }

		public void AddStepBefore (Type target, IStep step)
		{
			for (int i = 0; i < _steps.Count; i++) {
				if (target.IsInstanceOfType (_steps [i])) {
					_steps.Insert (i, step);
					return;
				}
			}
			string msg = String.Format ("Step {0} could not be inserted before (not found) {1}", step, target);
			throw new InvalidOperationException (msg);
		}