Example #1
0
 public bool Equals(NodeStep otherNodeStep)
 {
     return(nodeNamesAreEqual(otherNodeStep) &&
            parameterCountIsEqual(otherNodeStep) &&
            bothStepsHaveTablesOrDontHaveTables(otherNodeStep) &&
            parametersHaveSameType(otherNodeStep));
 }
Example #2
0
 public bool Equals(NodeStep otherNodeStep)
 {
     return nodeNamesAreEqual(otherNodeStep) &&
             parameterCountIsEqual(otherNodeStep) &&
             bothStepsHaveTablesOrDontHaveTables(otherNodeStep) &&
             parametersHaveSameType(otherNodeStep);
 }
        public void StepGeneratorCreatesOneScenarioOneStep()
        {
            IList<NodeFeature> features;
            features = new List<NodeFeature>();

            //Add step
            NodeStep step1 = new NodeStep("GivenMethod1");

            //Add scenario
            NodeScenario scenario1 = new NodeScenario("Scenario1");
            scenario1.Steps.Add(step1);

            //Add feature
            NodeFeature feature1 = new NodeFeature("Feature1");
            feature1.Scenarios.Add(scenario1);
            features.Add(feature1);

            var files = GeneratorFactory.Generate(GeneratorType.StepDefinitionGenerator, features);

            string[] stringsExpected = new string[] {
                "#include \"Feature1.h\"",
                "",
                "namespace CppUnitTest",
                "{",
                "\tvoid Feature1::GivenMethod1()",
                "\t{",
                "\t\tAssert::Fail(L\"Pending implementation...\");",
                "\t}",
                "}"
            };
            AssertExt.ContentsOfStringArray(stringsExpected, files[0]);
        }
        public static IList<NodeFeature> FeatureWithScenarioAndStep()
        {
            var features = FeatureWithScenarioAndNoStep();

            NodeStep step = new NodeStep("GivenIHaveAStep");

            features[0].Scenarios[0].Steps.Add(step);   // steps to scenario

            return features;
        }
Example #5
0
 private bool parametersHaveSameType(NodeStep otherNodeStep)
 {
     for (int i = 0; i < this.Parameters.Count; i++)
     {
         if (this.Parameters[i].Type != otherNodeStep.Parameters[i].Type)
         {
             return(false);
         }
     }
     return(true);
 }
        public void HeaderGeneratorCreatesOneFeatureWithOneTable()
        {
            IList<NodeFeature> features;
            features = new List<NodeFeature>();
            List<NodeHook> featureHooks = new List<NodeHook>();

            List<string[]> rows = new List<string[]>();

            //Create row array & add
            string[] row1 = new string[] { "a", "b", "c" };
            string[] row2 = new string[] { "1", "2", "3" };
            rows.Add(row1);
            rows.Add(row2);

            //Create step & add
            NodeStep step1 = new NodeStep("GivenStep1WithTable");
            step1.Rows = rows;

            //Create scenario & add
            NodeScenario scenario1 = new NodeScenario("MyScenario1", new List<NodeHook>() { new NodeHook("MyFeatureHook1"), new NodeHook("MyScenarioHook1") });
            scenario1.Steps.Add(step1);

            //Create feature & add
            NodeFeature feature1 = new NodeFeature("MyFeature1", new List<NodeHook>() { new NodeHook("MyFeatureHook1") });
            feature1.Scenarios.Add(scenario1);
            features.Add(feature1);

            //Call output generator
            var files = GeneratorFactory.Generate(GeneratorType.HeaderGenerator, features);

            string[] stringsExpected = new string[] {
                "#include \"CppUnitTest.h\"",
                "#include \"CppUnitTestHooks.h\"",
                "#include \"trim.hpp\"",
                "#include <vector>",
                "",
                "using namespace Microsoft::VisualStudio::CppUnitTestFramework;",
                "using namespace std;",
                "",
                "namespace CppUnitTest",
                "{",
                "\tTEST_CLASS(MyFeature1)",
                "\t{",
                "\tpublic:",
                "\t\tTEST_CLASS_HOOK_MYFEATUREHOOK1()",
                "\t\tTEST_METHOD_HOOK_MYFEATUREHOOK1_MYSCENARIOHOOK1(MyScenario1);",
                "",
                "\tprivate:",
                "\t\tvoid GivenStep1WithTable(std::vector<std::vector<std::string>> table, int rows, int cols);",
                "\t};",
                "}"
            };
            AssertExt.ContentsOfStringArray(stringsExpected, files[0]);
        }
        public void NodesWithTableArgumentsAreEqual()
        {
            NodeStep step1 = new NodeStep("my step");
            step1.Rows.Add(new string[] {
                "| a | b | c |"
            });

            NodeStep step2 = new NodeStep("my step");
            step2.Rows.Add(new string[] {
                "| a | b | c |"
            });

            Assert.IsTrue(step1.Equals(step2));
        }
        private void AddMultipleParameters(NodeStep step, string parameters)
        {
            char[] multipleParameterDelimiter = { ' ' };
            string[] arrayOfParameters = parameters.Split(multipleParameterDelimiter);
            bool foundTable = false;

            for (int i = 0; i < arrayOfParameters.Length; i += 2)
            {
                Parameter p = new Parameter();
                p.Type = arrayOfParameters[i];

                if (arrayOfParameters[i + 1].Contains(","))
                {
                    char[] commaTrim = { ',' };
                    string[] parameter = arrayOfParameters[i + 1].Split(commaTrim);
                    p.Name = parameter[0].TrimEnd();
                }
                else if (arrayOfParameters[i + 1].Contains(")"))
                {
                    char[] parenthesisTrim = { ')' };
                    string[] lastParameter = arrayOfParameters[i + 1].Split(parenthesisTrim);
                    p.Name = lastParameter[0].TrimEnd();
                }

                // don't add table parameters as step parameters
                if (p.Name == "table" || (p.Name == "rows" && p.Type == "int") || (p.Name == "cols" && p.Type == "int"))
                {
                    foundTable = true;
                }
                else
                {
                    step.Parameters.Add(p);
                }
            }

            if (foundTable)
            {
                step.Rows.Add(new string[] { string.Empty });
            }
        }
        private void BuildStepMethodCall(NodeStep step, NodeExamples examples, int exampleIndex)
        {
            // if we have rows and first time thru scenario outline
            if (step.Rows.Count > 0 && exampleIndex == 1) // TODO: remove exampleIndex == 1 if parameterizing table arguments
            {
                _tableNumberInScenario++;

                // TODO: could pass in NodeExamples examples to support parameterizing table arguments
                BuildTestDataTable(step.Rows, Contents);
            }

            Contents.Add(string.Format("\t\t{0};", LanguageConfig.StepMethod(step.Name, BuildParameterString(step.Parameters, step.Rows, examples, exampleIndex))));
        }
 private void CloseMethod(NodeStep currentStep, IList<NodeStep> steps)
 {
     Contents.Add("\t}");
     if (steps.Last() != currentStep)
     {
         Contents.Add(string.Empty);
     }
 }
        public void HeaderGeneratorCreatesOneFeatureOneScenarioAndOneStep()
        {
            IList<NodeFeature> features;
            features = new List<NodeFeature>();

            //Creates Step 1 & Adds to list
            NodeStep step1 = new NodeStep("GivenMethod1");

            //Creates Scenario 1
            NodeScenario scenario1 = new NodeScenario("TestScenario1");
            scenario1.Steps.Add(step1);

            //Creates Feature & Adds to list
            NodeFeature feature = new NodeFeature("TestFeature1");
            feature.Scenarios.Add(scenario1);
            features.Add(feature);

            var files = GeneratorFactory.Generate(GeneratorType.HeaderGenerator, features);

            string[] stringsExpected = new string[] {
                "#include \"CppUnitTest.h\"",
                "#include \"CppUnitTestHooks.h\"",
                "#include \"trim.hpp\"",
                "#include <vector>",
                "",
                "using namespace Microsoft::VisualStudio::CppUnitTestFramework;",
                "using namespace std;",
                "",
                "namespace CppUnitTest",
                "{",
                "\tTEST_CLASS(TestFeature1)",
                "\t{",
                "\tpublic:",
                "\t\tTEST_METHOD(TestScenario1);",
                "",
                "\tprivate:",
                "\t\tvoid GivenMethod1();",
                "\t};",
                "}"
            };

            AssertExt.ContentsOfStringArray(stringsExpected, files[0]);
        }
        public void HeaderGeneratorCreatesOneFeatureOneScenarioOneStepAndTwoParameters()
        {
            IList<NodeFeature> features;
            features = new List<NodeFeature>();

            //Creates Gherkin Step 1
            TokenGherkinStep tokenStep1 = new TokenGherkinStep();
            tokenStep1.MethodName = "GivenMethod1";
            List<string> tokenParameters1 = new List<string>();
            string parameter1 = "";
            tokenParameters1.Add(parameter1);
            tokenStep1.ParameterTokens = tokenParameters1;

            //Creates Parameter For Step 1
            Parameter p1 = new Parameter();
            p1.Name = "Parameter1";
            p1.Type = "string";
            p1.Value = "ValueOfParameter1";
            Parameter p2 = new Parameter();
            p2.Name = "Parameter2";
            p2.Type = "int";
            p2.Value = "2";

            //Creates Step 1 & Adds to list
            NodeStep step1 = new NodeStep("GivenMethod1");
            step1.Parameters.Add(p1);
            step1.Parameters.Add(p2);

            //Creates Scenario 1
            NodeScenario scenario1 = new NodeScenario("TestScenario1");
            scenario1.Steps.Add(step1);

            //Creates Feature & Adds to list
            NodeFeature feature = new NodeFeature("TestFeature1");
            feature.Scenarios.Add(scenario1);
            features.Add(feature);

            var files = GeneratorFactory.Generate(GeneratorType.HeaderGenerator, features);

            string[] stringsExpected = new string[] {
                "#include \"CppUnitTest.h\"",
                "#include \"CppUnitTestHooks.h\"",
                "#include \"trim.hpp\"",
                "#include <vector>",
                "",
                "using namespace Microsoft::VisualStudio::CppUnitTestFramework;",
                "using namespace std;",
                "",
                "namespace CppUnitTest",
                "{",
                "\tTEST_CLASS(TestFeature1)",
                "\t{",
                "\tpublic:",
                "\t\tTEST_METHOD(TestScenario1);",
                "",
                "\tprivate:",
                "\t\tvoid GivenMethod1(string Parameter1, int Parameter2);",
                "\t};",
                "}"
            };
            AssertExt.ContentsOfStringArray(stringsExpected, files[0]);
        }
        private void MakePreviousScenarioHookAFeatureHook()
        {
            if (hooksToAdd == null)
            {
                return;
            }
            foreach (var hook in hooksToAdd)
            {
                scenarioHooks.Remove(hook);
            }
            lastScenario = null;
            lastStep = null;

            featureHooks = new List<NodeHook>();
            scenarioHooks = new List<NodeHook>();
            AddDistinctHooksByName(featureHooks, hooksToAdd);
            AddDistinctHooksByName(scenarioHooks, hooksToAdd);
        }
        public void StepGeneratorCreatesOneScenarioOneStepOneParameterAndOneRow()
        {
            IList<NodeFeature> features;
            features = new List<NodeFeature>();

            //Add parameter
            Parameter p1 = new Parameter();
            p1.Name = "Parameter1";
            p1.Type = "string";
            p1.Value = "ValueOfParameter1";

            //Add step
            NodeStep step1 = new NodeStep("GivenMethod1");
            step1.Parameters.Add(p1);
            step1.Rows = new List<string[]>() {
                new [] { "a", "b", "c" }
            };

            //Add scenario
            NodeScenario scenario1 = new NodeScenario("Scenario1");
            scenario1.Steps.Add(step1);

            //Add feature
            NodeFeature feature1 = new NodeFeature("Feature1");
            feature1.Scenarios.Add(scenario1);
            features.Add(feature1);

            var files = GeneratorFactory.Generate(GeneratorType.StepDefinitionGenerator, features);

            string[] stringsExpected = new string[] {
                "#include \"Feature1.h\"",
                "",
                "namespace CppUnitTest",
                "{",
                "\tvoid Feature1::GivenMethod1(std::vector<std::vector<std::string>> table, int rows, int cols, string Parameter1)",
                "\t{",
                "\t\tAssert::Fail(L\"Pending implementation...\");",
                "\t}",
                "}"
            };
            AssertExt.ContentsOfStringArray(stringsExpected, files[0]);
        }
Example #15
0
 private bool parameterCountIsEqual(NodeStep otherNodeStep)
 {
     return (this.Parameters.Count == otherNodeStep.Parameters.Count);
 }
        public void StepGeneratorCreatesOneScenarioOneStepTwoParameters()
        {
            IList<NodeFeature> features;
            features = new List<NodeFeature>();

            //Add parameter 1
            Parameter p1 = new Parameter();
            p1.Name = "Parameter1";
            p1.Type = "string";
            p1.Value = "ValueOfParameter1";

            //Add parameter 2
            Parameter p2 = new Parameter();
            p2.Name = "Parameter2";
            p2.Type = "int";
            p2.Value = "2";

            //Add step
            NodeStep step1 = new NodeStep("GivenMethod1");
            step1.Parameters.Add(p1);
            step1.Parameters.Add(p2);

            //Add scenario
            NodeScenario scenario1 = new NodeScenario("Scenario1");
            scenario1.Steps.Add(step1);

            //Add feature
            NodeFeature feature1 = new NodeFeature("Feature1");
            feature1.Scenarios.Add(scenario1);
            features.Add(feature1);

            var files = GeneratorFactory.Generate(GeneratorType.StepDefinitionGenerator, features);

            string[] stringsExpected = new string[] {
                "#include \"Feature1.h\"",
                "",
                "namespace CppUnitTest",
                "{",
                "\tvoid Feature1::GivenMethod1(string Parameter1, int Parameter2)",
                "\t{",
                "\t\tAssert::Fail(L\"Pending implementation...\");",
                "\t}",
                "}"
            };
            AssertExt.ContentsOfStringArray(stringsExpected, files[0]);
        }
        public void HeaderGeneratorCreatesOneFeatureTwoFeatureHooksTwoScenarioHooksAndTwoSteps()
        {
            IList<NodeFeature> features;
            features = new List<NodeFeature>();

            List<NodeHook> featureHooks = new List<NodeHook>() {
                new NodeHook("featurehook1"),
                new NodeHook("featurehook2")
            };

            List<NodeHook> scenarioHooks = new List<NodeHook>() {
                new NodeHook("featurehook1"),
                new NodeHook("featurehook2"),
                new NodeHook("scenariohook1"),
                new NodeHook("scenariohook2")
            };

            //Creates Step 1
            NodeStep step1 = new NodeStep("GivenMethod1");

            //Creates Step 2
            NodeStep step2 = new NodeStep("GivenMethod2");

            //Creates Scenario 1
            NodeScenario scenario1 = new NodeScenario("TestScenario1", scenarioHooks);
            scenario1.Steps.Add(step1);
            scenario1.Steps.Add(step2);

            //Creates Feature 1
            NodeFeature testFeature = new NodeFeature("TestFeature1", featureHooks);
            testFeature.Scenarios.Add(scenario1);

            features.Add(testFeature);

            var files = GeneratorFactory.Generate(GeneratorType.HeaderGenerator, features);

            string[] stringsExpected = new string[] {
                "#include \"CppUnitTest.h\"",
                "#include \"CppUnitTestHooks.h\"",
                "#include \"trim.hpp\"",
                "#include <vector>",
                "",
                "using namespace Microsoft::VisualStudio::CppUnitTestFramework;",
                "using namespace std;",
                "",
                "namespace CppUnitTest",
                "{",
                "\tTEST_CLASS(TestFeature1)",
                "\t{",
                "\tpublic:",
                "\t\tTEST_CLASS_HOOK_FEATUREHOOK1()",
                "\t\tTEST_CLASS_HOOK_FEATUREHOOK2()",
                "\t\tTEST_METHOD_HOOK_FEATUREHOOK1_FEATUREHOOK2_SCENARIOHOOK1_SCENARIOHOOK2(TestScenario1);",
                "",
                "\tprivate:",
                "\t\tvoid GivenMethod1();",
                "\t\tvoid GivenMethod2();",
                "\t};",
                "}"
            };

            AssertExt.ContentsOfStringArray(stringsExpected, files[0]);
        }
        private void AddOneParameter(NodeStep step, string parameter)
        {
            char[] oneParameterDelimiter = { ' ', ')' };
            string[] oneParameter = parameter.Split(oneParameterDelimiter);

            Parameter p = new Parameter();
            p.Type = oneParameter[0];
            p.Name = oneParameter[1];
            step.Parameters.Add(p);
        }
        private void AddStep(string stepContents, List<NodeStep> steps)
        {
            NodeStep step = new NodeStep();
            string openParenthesisSplit = "(";
            string[] tokens = stepContents.Split(openParenthesisSplit.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);

            if (HasParameters(tokens[1].ToString()))
            {
                AddParameters(step, tokens[1]);
            }
            step.Name = tokens[0];
            steps.Add(step);
        }
 private void AddParameters(NodeStep step, string parameterContents)
 {
     if (parameterContents.Contains(","))
     {
         AddMultipleParameters(step, parameterContents);
     }
     else
     {
         AddOneParameter(step, parameterContents);
     }
 }
Example #21
0
 private bool bothStepsHaveTablesOrDontHaveTables(NodeStep otherNodeStep)
 {
     return(((this.Rows.Count > 0) && (otherNodeStep.Rows.Count > 0))
            ||
            ((this.Rows.Count == 0) && (otherNodeStep.Rows.Count == 0)));
 }
Example #22
0
 private bool nodeNamesAreEqual(NodeStep otherNodeStep)
 {
     return (this.Name == otherNodeStep.Name);
 }
Example #23
0
 private bool parameterCountIsEqual(NodeStep otherNodeStep)
 {
     return(this.Parameters.Count == otherNodeStep.Parameters.Count);
 }
Example #24
0
 private bool parametersHaveSameType(NodeStep otherNodeStep)
 {
     for (int i = 0; i < this.Parameters.Count; i++)
     {
         if (this.Parameters[i].Type != otherNodeStep.Parameters[i].Type)
         {
             return false;
         }
     }
     return true;
 }
Example #25
0
 private bool nodeNamesAreEqual(NodeStep otherNodeStep)
 {
     return(this.Name == otherNodeStep.Name);
 }
Example #26
0
 private bool bothStepsHaveTablesOrDontHaveTables(NodeStep otherNodeStep)
 {
     return ((this.Rows.Count > 0) && (otherNodeStep.Rows.Count > 0))
            ||
            ((this.Rows.Count == 0) && (otherNodeStep.Rows.Count == 0));
 }
 private void AddStep(string formattedLine)
 {
     var tokens = GherkinParser.ParseOutStepAndParameters(formattedLine);
     if (tokens == null) // invalid gherkin step
     {
         lastStep = null; // so that any tables don't get added to the last valid step
     }
     else
     {
         lastStep = new NodeStep(tokens);
         lastScenario.Steps.Add(lastStep);
     }
 }