diff --git a/api/lang/server.go b/api/lang/server.go index c580c8a86..6e520ee9a 100644 --- a/api/lang/server.go +++ b/api/lang/server.go @@ -223,7 +223,7 @@ func (h *LangHandler) Handle(ctx context.Context, conn jsonrpc2.JSONRPC2, req *j } return val, err case "gauge/executionStatus": - val, err := execution.ReadExecutionStatus() + val, err := execution.ReadLastExecutionResult() if err != nil { logDebug(req, err.Error()) } diff --git a/build/npm/src/index.js b/build/npm/src/index.js index b3912c00d..b03bd0d13 100644 --- a/build/npm/src/index.js +++ b/build/npm/src/index.js @@ -27,5 +27,5 @@ var downloadAndExtract = async function(version) { } install.getVersion(packageJsonPath) -.then((v) => downloadAndExtract(v)) +.then((v) => downloadAndExtract(v.split('-')[0])) .catch((e) => console.error(e)); \ No newline at end of file diff --git a/env/env.go b/env/env.go index f392ffb41..0d2430e94 100644 --- a/env/env.go +++ b/env/env.go @@ -21,6 +21,7 @@ import ( "fmt" "os" "path/filepath" + "strconv" "regexp" "strings" @@ -28,18 +29,28 @@ import ( "github.com/dmotylev/goproperties" "github.com/getgauge/common" "github.com/getgauge/gauge/config" + "github.com/getgauge/gauge/logger" ) const ( - SpecsDir = "gauge_specs_dir" - GaugeReportsDir = "gauge_reports_dir" - LogsDirectory = "logs_directory" - OverwriteReports = "overwrite_reports" + // SpecsDir holds the location of spec files + SpecsDir = "gauge_specs_dir" + // GaugeReportsDir holds the location of reports + GaugeReportsDir = "gauge_reports_dir" + // LogsDirectory holds the location of log files + LogsDirectory = "logs_directory" + // OverwriteReports = false will create a new directory for reports + // for every run. + OverwriteReports = "overwrite_reports" + // ScreenshotOnFailure indicates if failure should invoke screenshot ScreenshotOnFailure = "screenshot_on_failure" - SaveExecutionResult = "save_execution_result" // determines if last run result should be saved - CsvDelimiter = "csv_delimiter" - AllowMultilineStep = "allow_multiline_step" - useTestGA = "use_test_ga" + saveExecutionResult = "save_execution_result" + // CsvDelimiter holds delimiter used to parse csv files + CsvDelimiter = "csv_delimiter" + allowMultilineStep = "allow_multiline_step" + allowScenarioDatatable = "allow_scenario_datatable" + enableMultithreading = "enable_multithreading" + useTestGA = "use_test_ga" ) var envVars map[string]string @@ -98,9 +109,10 @@ func loadDefaultEnvVars() { addEnvVar(LogsDirectory, "logs") addEnvVar(OverwriteReports, "true") addEnvVar(ScreenshotOnFailure, "true") - addEnvVar(SaveExecutionResult, "false") + addEnvVar(saveExecutionResult, "false") addEnvVar(CsvDelimiter, ",") - addEnvVar(AllowMultilineStep, "false") + addEnvVar(allowMultilineStep, "false") + addEnvVar(allowScenarioDatatable, "false") addEnvVar(useTestGA, "false") } @@ -154,7 +166,7 @@ func substituteEnvVars() error { envKey, property := match[0], match[1] // error if env property is not found if !isPropertySet(property) { - return fmt.Errorf("'%s' env variable was not set.", property) + return fmt.Errorf("'%s' env variable was not set", property) } // get env var from system propertyValue := os.Getenv(property) @@ -199,6 +211,38 @@ func CurrentEnv() string { return currentEnv } +func convertToBool(property string, defaultValue bool) bool { + v := os.Getenv(property) + boolValue, err := strconv.ParseBool(strings.TrimSpace(v)) + if err != nil { + logger.Warningf(true, "Incorrect value for %s in property file. Cannot convert %s to boolean.", property, v) + logger.Warningf(true, "Using default value %v for property %s.", defaultValue, property) + return defaultValue + } + return boolValue +} + +// AllowScenarioDatatable -feature toggle for datatables in scenario +var AllowScenarioDatatable = func() bool { + return convertToBool(allowScenarioDatatable, false) +} + +// AllowMultiLineStep - feature toggle for newline in step text +var AllowMultiLineStep = func() bool { + return convertToBool(allowMultilineStep, false) +} + +// SaveExecutionResult determines if last run result should be saved +var SaveExecutionResult = func() bool { + return convertToBool(saveExecutionResult, false) +} + +// EnableMultiThreadedExecution determines if threads should be used instead of process +// for each parallel stream +var EnableMultiThreadedExecution = func() bool { + return convertToBool(enableMultithreading, false) +} + // UseTestGA checks if test google analytics account needs to be used var UseTestGA = func() bool { return strings.ToLower(os.Getenv(useTestGA)) == "true" diff --git a/env/env_test.go b/env/env_test.go index 44f9dfa32..a24ada17d 100644 --- a/env/env_test.go +++ b/env/env_test.go @@ -216,5 +216,5 @@ func (s *MySuite) TestLoadDefaultEnvWithSubstitutedVariables(c *C) { func (s *MySuite) TestLoadDefaultEnvWithInvalidSubstitutedVariable(c *C) { config.ProjectRoot = "_testdata/proj3" e := LoadEnv("default") - c.Assert(e, ErrorMatches, ".*env variable was not set.") + c.Assert(e, ErrorMatches, ".*env variable was not set") } diff --git a/execution/execute.go b/execution/execute.go index f7ce777bc..9820f373c 100644 --- a/execution/execute.go +++ b/execution/execute.go @@ -15,7 +15,7 @@ // You should have received a copy of the GNU General Public License // along with Gauge. If not, see . -/* +/*Package execution handles gauge's execution of spec/scenario/steps Execution can be of two types - Simple execution - Paralell execution @@ -63,7 +63,6 @@ import ( "github.com/getgauge/gauge/plugin/install" "github.com/getgauge/gauge/reporter" "github.com/getgauge/gauge/runner" - "github.com/getgauge/gauge/util" "github.com/getgauge/gauge/validation" ) @@ -148,13 +147,13 @@ var ExecuteSpecs = func(specDirs []string) int { wg := &sync.WaitGroup{} reporter.ListenExecutionEvents(wg) rerun.ListenFailedScenarios(wg, specDirs) - if util.ConvertToBool(os.Getenv(env.SaveExecutionResult), env.SaveExecutionResult, false) { + if env.SaveExecutionResult() { ListenSuiteEndAndSaveResult(wg) } defer wg.Wait() ei := newExecutionInfo(res.SpecCollection, res.Runner, nil, res.ErrMap, InParallel, 0) e := newExecution(ei) - return printExecutionStatus(e.run(), res.ParseOk) + return printExecutionResult(e.run(), res.ParseOk) } func newExecution(executionInfo *executionInfo) suiteExecutor { @@ -202,7 +201,7 @@ func statusJSON(executedSpecs, passedSpecs, failedSpecs, skippedSpecs, executedS return s } -func writeExecutionStatus(content string) { +func writeExecutionResult(content string) { executionStatusFile := filepath.Join(config.ProjectRoot, common.DotGauge, executionStatusFile) dotGaugeDir := filepath.Join(config.ProjectRoot, common.DotGauge) if err := os.MkdirAll(dotGaugeDir, common.NewDirectoryPermissions); err != nil { @@ -214,7 +213,9 @@ func writeExecutionStatus(content string) { } } -func ReadExecutionStatus() (interface{}, error) { +// ReadLastExecutionResult returns the result of previous execution in JSON format +// This is stored in $GAUGE_PROJECT_ROOT/.gauge/executionStatus.json file after every execution +func ReadLastExecutionResult() (interface{}, error) { contents, err := common.ReadFileContents(filepath.Join(config.ProjectRoot, common.DotGauge, executionStatusFile)) if err != nil { logger.Fatalf(true, "Failed to read execution status information. Reason: %s", err.Error()) @@ -227,7 +228,7 @@ func ReadExecutionStatus() (interface{}, error) { return meta, nil } -func printExecutionStatus(suiteResult *result.SuiteResult, isParsingOk bool) int { +func printExecutionResult(suiteResult *result.SuiteResult, isParsingOk bool) int { nSkippedSpecs := suiteResult.SpecsSkippedCount var nExecutedSpecs int if len(suiteResult.SpecResults) != 0 { @@ -259,7 +260,7 @@ func printExecutionStatus(suiteResult *result.SuiteResult, isParsingOk bool) int logger.Infof(true, "Specifications:\t%d executed\t%d passed\t%d failed\t%d skipped", nExecutedSpecs, nPassedSpecs, nFailedSpecs, nSkippedSpecs) logger.Infof(true, "Scenarios:\t%d executed\t%d passed\t%d failed\t%d skipped", nExecutedScenarios, nPassedScenarios, nFailedScenarios, nSkippedScenarios) logger.Infof(true, "\nTotal time taken: %s", time.Millisecond*time.Duration(suiteResult.ExecutionTime)) - writeExecutionStatus(s) + writeExecutionResult(s) if !isParsingOk { return ParseFailed @@ -275,10 +276,10 @@ func validateFlags() error { return nil } if NumberOfExecutionStreams < 1 { - return fmt.Errorf("Invalid input(%s) to --n flag.", strconv.Itoa(NumberOfExecutionStreams)) + return fmt.Errorf("invalid input(%s) to --n flag", strconv.Itoa(NumberOfExecutionStreams)) } if !isValidStrategy(Strategy) { - return fmt.Errorf("Invalid input(%s) to --strategy flag.", Strategy) + return fmt.Errorf("invalid input(%s) to --strategy flag", Strategy) } return nil } diff --git a/execution/execute_test.go b/execution/execute_test.go index 1d14ab0f3..80dc651b9 100644 --- a/execution/execute_test.go +++ b/execution/execute_test.go @@ -80,12 +80,12 @@ func (s *MySuite) TestValidateFlagsWithInvalidStrategy(c *C) { Strategy = "sdf" NumberOfExecutionStreams = 1 err := validateFlags() - c.Assert(err.Error(), Equals, "Invalid input(sdf) to --strategy flag.") + c.Assert(err.Error(), Equals, "invalid input(sdf) to --strategy flag") } func (s *MySuite) TestValidateFlagsWithInvalidStream(c *C) { InParallel = true NumberOfExecutionStreams = -1 err := validateFlags() - c.Assert(err.Error(), Equals, "Invalid input(-1) to --n flag.") + c.Assert(err.Error(), Equals, "invalid input(-1) to --n flag") } diff --git a/execution/parallelExecution.go b/execution/parallelExecution.go index 6716de2d8..1832e0a41 100644 --- a/execution/parallelExecution.go +++ b/execution/parallelExecution.go @@ -30,6 +30,7 @@ import ( "github.com/getgauge/common" "github.com/getgauge/gauge/config" "github.com/getgauge/gauge/conn" + "github.com/getgauge/gauge/env" "github.com/getgauge/gauge/execution/event" "github.com/getgauge/gauge/execution/result" "github.com/getgauge/gauge/filter" @@ -40,9 +41,9 @@ import ( "github.com/getgauge/gauge/plugin" "github.com/getgauge/gauge/reporter" "github.com/getgauge/gauge/runner" - "github.com/getgauge/gauge/util" ) +// Strategy for execution, can be either 'Eager' or 'Lazy' var Strategy string // Eager is a parallelization strategy for execution. In this case tests are distributed before execution, thus making them an equal number based distribution. @@ -50,7 +51,6 @@ const Eager string = "eager" // Lazy is a parallelization strategy for execution. In this case tests assignment will be dynamic during execution, i.e. assign the next spec in line to the stream that has completed it’s previous execution and is waiting for more work. const Lazy string = "lazy" -const enableMultithreadingEnv = "enable_multithreading" type parallelExecution struct { wg sync.WaitGroup @@ -273,8 +273,7 @@ func isValidStrategy(strategy string) bool { } func (e *parallelExecution) isMultithreaded() bool { - value := util.ConvertToBool(os.Getenv(enableMultithreadingEnv), enableMultithreadingEnv, false) - if !value { + if !env.EnableMultiThreadedExecution() { return false } if !e.runner.IsMultithreaded() { diff --git a/execution/parallelExecution_test.go b/execution/parallelExecution_test.go index be9e6f2f9..45dbe3f2d 100644 --- a/execution/parallelExecution_test.go +++ b/execution/parallelExecution_test.go @@ -21,8 +21,8 @@ import ( "testing" "net" - "os" + "github.com/getgauge/gauge/env" "github.com/getgauge/gauge/execution/result" "github.com/getgauge/gauge/gauge" "github.com/getgauge/gauge/gauge_messages" @@ -115,37 +115,25 @@ func (s *MySuite) TestAggregationOfSuiteResultWithHook(c *C) { func (s *MySuite) TestIsMultiThreadedWithEnvSetToFalse(c *C) { e := parallelExecution{errMaps: getValidationErrorMap()} - os.Setenv(enableMultithreadingEnv, "false") + env.EnableMultiThreadedExecution = func() bool { return false } - multithreaded := e.isMultithreaded() - - os.Setenv(enableMultithreadingEnv, "") - - c.Assert(false, Equals, multithreaded) + c.Assert(false, Equals, e.isMultithreaded()) } func (s *MySuite) TestIsMultiThreadedWithRunnerWhenSupportsMultithreading(c *C) { e := parallelExecution{errMaps: getValidationErrorMap(), runner: &fakeRunner{isMultiThreaded: true}} - os.Setenv(enableMultithreadingEnv, "true") - - multithreaded := e.isMultithreaded() + env.EnableMultiThreadedExecution = func() bool { return true } - os.Setenv(enableMultithreadingEnv, "") - - c.Assert(true, Equals, multithreaded) + c.Assert(true, Equals, e.isMultithreaded()) } func (s *MySuite) TestIsMultiThreadedWithRunnerWhenDoesNotSupportMultithreading(c *C) { e := parallelExecution{errMaps: getValidationErrorMap(), runner: &fakeRunner{isMultiThreaded: false}} - os.Setenv(enableMultithreadingEnv, "true") - - multithreaded := e.isMultithreaded() - - os.Setenv(enableMultithreadingEnv, "") + env.EnableMultiThreadedExecution = func() bool { return true } - c.Assert(false, Equals, multithreaded) + c.Assert(false, Equals, e.isMultithreaded()) } type fakeRunner struct { diff --git a/execution/resolve.go b/execution/resolve.go new file mode 100644 index 000000000..ed9ade4fa --- /dev/null +++ b/execution/resolve.go @@ -0,0 +1,98 @@ +// Copyright 2015 ThoughtWorks, Inc. + +// This file is part of Gauge. + +// Gauge is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// Gauge is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Gauge. If not, see . + +package execution + +import ( + "github.com/getgauge/gauge/gauge" + "github.com/getgauge/gauge/gauge_messages" + "github.com/getgauge/gauge/parser" +) + +type setSkipInfoFn func(protoStep *gauge_messages.ProtoStep, step *gauge.Step) + +func resolveItems(items []gauge.Item, lookup *gauge.ArgLookup, skipFn setSkipInfoFn) ([]*gauge_messages.ProtoItem, error) { + var protoItems []*gauge_messages.ProtoItem + for _, item := range items { + if item.Kind() != gauge.TearDownKind { + protoItem, err := resolveToProtoItem(item, lookup, skipFn) + if err != nil { + return nil, err + } + protoItems = append(protoItems, protoItem) + } + } + return protoItems, nil +} + +func resolveToProtoItem(item gauge.Item, lookup *gauge.ArgLookup, skipFn setSkipInfoFn) (*gauge_messages.ProtoItem, error) { + var protoItem *gauge_messages.ProtoItem + var err error + switch item.Kind() { + case gauge.StepKind: + if (item.(*gauge.Step)).IsConcept { + concept := item.(*gauge.Step) + protoItem, err = resolveToProtoConceptItem(*concept, lookup, skipFn) + } else { + protoItem, err = resolveToProtoStepItem(item.(*gauge.Step), lookup, skipFn) + } + break + + default: + protoItem = gauge.ConvertToProtoItem(item) + } + return protoItem, err +} + +// Not passing pointer as we cannot modify the original concept step's lookup. This has to be populated for each iteration over data table. +func resolveToProtoConceptItem(concept gauge.Step, lookup *gauge.ArgLookup, skipFn setSkipInfoFn) (*gauge_messages.ProtoItem, error) { + if err := parser.PopulateConceptDynamicParams(&concept, lookup); err != nil { + return nil, err + } + protoConceptItem := gauge.ConvertToProtoItem(&concept) + protoConceptItem.Concept.ConceptStep.StepExecutionResult = &gauge_messages.ProtoStepExecutionResult{} + for stepIndex, step := range concept.ConceptSteps { + // Need to reset parent as the step.parent is pointing to a concept whose lookup is not populated yet + if step.IsConcept { + step.Parent = &concept + protoItem, err := resolveToProtoConceptItem(*step, &concept.Lookup, skipFn) + if err != nil { + return nil, err + } + protoConceptItem.GetConcept().GetSteps()[stepIndex] = protoItem + } else { + conceptStep := protoConceptItem.Concept.Steps[stepIndex].Step + err := parser.Resolve(step, &concept, &concept.Lookup, conceptStep) + if err != nil { + return nil, err + } + skipFn(conceptStep, step) + } + } + protoConceptItem.Concept.ConceptStep.StepExecutionResult.Skipped = false + return protoConceptItem, nil +} + +func resolveToProtoStepItem(step *gauge.Step, lookup *gauge.ArgLookup, skipFn setSkipInfoFn) (*gauge_messages.ProtoItem, error) { + protoStepItem := gauge.ConvertToProtoItem(step) + err := parser.Resolve(step, nil, lookup, protoStepItem.Step) + if err != nil { + return nil, err + } + skipFn(protoStepItem.Step, step) + return protoStepItem, err +} diff --git a/execution/resolve_test.go b/execution/resolve_test.go new file mode 100644 index 000000000..0972471d1 --- /dev/null +++ b/execution/resolve_test.go @@ -0,0 +1,204 @@ +// Copyright 2015 ThoughtWorks, Inc. + +// This file is part of Gauge. + +// Gauge is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// Gauge is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Gauge. If not, see . + +package execution + +import ( + "path/filepath" + "testing" + + "github.com/getgauge/gauge/gauge" + "github.com/getgauge/gauge/gauge_messages" + "github.com/getgauge/gauge/parser" + . "gopkg.in/check.v1" +) + +func (s *MySuite) TestResolveConceptToProtoConceptItem(c *C) { + conceptDictionary := gauge.NewConceptDictionary() + + specText := newSpecBuilder().specHeading("A spec heading"). + scenarioHeading("First scenario"). + step("create user \"456\" \"foo\" and \"9900\""). + String() + path, _ := filepath.Abs(filepath.Join("testdata", "concept.cpt")) + parser.AddConcepts([]string{path}, conceptDictionary) + + spec, _, _ := new(parser.SpecParser).Parse(specText, conceptDictionary, "") + + specExecutor := newSpecExecutor(spec, nil, nil, nil, 0) + specExecutor.errMap = getValidationErrorMap() + lookup, err := specExecutor.dataTableLookup() + c.Assert(err, IsNil) + cItem, err := resolveToProtoConceptItem(*spec.Scenarios[0].Steps[0], lookup, specExecutor.setSkipInfo) + c.Assert(err, IsNil) + protoConcept := cItem.GetConcept() + + checkConceptParameterValuesInOrder(c, protoConcept, "456", "foo", "9900") + firstNestedStep := protoConcept.GetSteps()[0].GetConcept().GetSteps()[0].GetStep() + params := getParameters(firstNestedStep.GetFragments()) + c.Assert(1, Equals, len(params)) + c.Assert(params[0].GetParameterType(), Equals, gauge_messages.Parameter_Dynamic) + c.Assert(params[0].GetValue(), Equals, "456") + + secondNestedStep := protoConcept.GetSteps()[0].GetConcept().GetSteps()[1].GetStep() + params = getParameters(secondNestedStep.GetFragments()) + c.Assert(1, Equals, len(params)) + c.Assert(params[0].GetParameterType(), Equals, gauge_messages.Parameter_Dynamic) + c.Assert(params[0].GetValue(), Equals, "foo") + + secondStep := protoConcept.GetSteps()[1].GetStep() + params = getParameters(secondStep.GetFragments()) + c.Assert(1, Equals, len(params)) + c.Assert(params[0].GetParameterType(), Equals, gauge_messages.Parameter_Dynamic) + c.Assert(params[0].GetValue(), Equals, "9900") + +} + +func (s *MySuite) TestResolveNestedConceptToProtoConceptItem(c *C) { + conceptDictionary := gauge.NewConceptDictionary() + + specText := newSpecBuilder().specHeading("A spec heading"). + scenarioHeading("First scenario"). + step("create user \"456\" \"foo\" and \"9900\""). + String() + + path, _ := filepath.Abs(filepath.Join("testdata", "concept.cpt")) + parser.AddConcepts([]string{path}, conceptDictionary) + specParser := new(parser.SpecParser) + spec, _, _ := specParser.Parse(specText, conceptDictionary, "") + + specExecutor := newSpecExecutor(spec, nil, nil, nil, 0) + specExecutor.errMap = getValidationErrorMap() + lookup, err := specExecutor.dataTableLookup() + c.Assert(err, IsNil) + cItem, err := resolveToProtoConceptItem(*spec.Scenarios[0].Steps[0], lookup, specExecutor.setSkipInfo) + c.Assert(err, IsNil) + protoConcept := cItem.GetConcept() + checkConceptParameterValuesInOrder(c, protoConcept, "456", "foo", "9900") + + c.Assert(protoConcept.GetSteps()[0].GetItemType(), Equals, gauge_messages.ProtoItem_Concept) + + nestedConcept := protoConcept.GetSteps()[0].GetConcept() + checkConceptParameterValuesInOrder(c, nestedConcept, "456", "foo") + + firstNestedStep := nestedConcept.GetSteps()[0].GetStep() + params := getParameters(firstNestedStep.GetFragments()) + c.Assert(1, Equals, len(params)) + c.Assert(params[0].GetParameterType(), Equals, gauge_messages.Parameter_Dynamic) + c.Assert(params[0].GetValue(), Equals, "456") + + secondNestedStep := nestedConcept.GetSteps()[1].GetStep() + params = getParameters(secondNestedStep.GetFragments()) + c.Assert(1, Equals, len(params)) + c.Assert(params[0].GetParameterType(), Equals, gauge_messages.Parameter_Dynamic) + c.Assert(params[0].GetValue(), Equals, "foo") + + c.Assert(protoConcept.GetSteps()[1].GetItemType(), Equals, gauge_messages.ProtoItem_Step) + secondStepInConcept := protoConcept.GetSteps()[1].GetStep() + params = getParameters(secondStepInConcept.GetFragments()) + c.Assert(1, Equals, len(params)) + c.Assert(params[0].GetParameterType(), Equals, gauge_messages.Parameter_Dynamic) + c.Assert(params[0].GetValue(), Equals, "9900") +} + +func TestResolveNestedConceptAndTableParamToProtoConceptItem(t *testing.T) { + conceptDictionary := gauge.NewConceptDictionary() + + specText := newSpecBuilder().specHeading("A spec heading"). + scenarioHeading("First scenario"). + step("create user \"456\""). + String() + want := "456" + path, _ := filepath.Abs(filepath.Join("testdata", "conceptTable.cpt")) + parser.AddConcepts([]string{path}, conceptDictionary) + specParser := new(parser.SpecParser) + spec, _, _ := specParser.Parse(specText, conceptDictionary, "") + + specExecutor := newSpecExecutor(spec, nil, nil, nil, 0) + specExecutor.errMap = getValidationErrorMap() + lookup, err := specExecutor.dataTableLookup() + if err != nil { + t.Errorf("Expected no error. Got : %s", err.Error()) + } + cItem, err := resolveToProtoConceptItem(*spec.Scenarios[0].Steps[0], lookup, specExecutor.setSkipInfo) + if err != nil { + t.Errorf("Expected no error. Got : %s", err.Error()) + } + protoConcept := cItem.GetConcept() + got := getParameters(protoConcept.GetSteps()[0].GetStep().GetFragments())[0].GetTable().GetRows()[1].Cells[0] + + if want != got { + t.Errorf("Did not resolve dynamic param in table for concept. Got %s, want: %s", got, want) + } +} + +func (s *MySuite) TestResolveToProtoConceptItemWithDataTable(c *C) { + conceptDictionary := gauge.NewConceptDictionary() + + specText := newSpecBuilder().specHeading("A spec heading"). + tableHeader("id", "name", "phone"). + tableHeader("123", "foo", "8800"). + tableHeader("666", "bar", "9900"). + scenarioHeading("First scenario"). + step("create user and "). + String() + + path, _ := filepath.Abs(filepath.Join("testdata", "concept.cpt")) + parser.AddConcepts([]string{path}, conceptDictionary) + specParser := new(parser.SpecParser) + spec, _, _ := specParser.Parse(specText, conceptDictionary, "") + + specExecutor := newSpecExecutor(spec, nil, nil, nil, 0) + + specExecutor.errMap = gauge.NewBuildErrors() + lookup, err := specExecutor.dataTableLookup() + c.Assert(err, IsNil) + cItem, err := resolveToProtoConceptItem(*spec.Scenarios[0].Steps[0], lookup, specExecutor.setSkipInfo) + c.Assert(err, IsNil) + protoConcept := cItem.GetConcept() + checkConceptParameterValuesInOrder(c, protoConcept, "123", "foo", "8800") + + c.Assert(protoConcept.GetSteps()[0].GetItemType(), Equals, gauge_messages.ProtoItem_Concept) + nestedConcept := protoConcept.GetSteps()[0].GetConcept() + checkConceptParameterValuesInOrder(c, nestedConcept, "123", "foo") + firstNestedStep := nestedConcept.GetSteps()[0].GetStep() + params := getParameters(firstNestedStep.GetFragments()) + c.Assert(1, Equals, len(params)) + c.Assert(params[0].GetParameterType(), Equals, gauge_messages.Parameter_Dynamic) + c.Assert(params[0].GetValue(), Equals, "123") + + secondNestedStep := nestedConcept.GetSteps()[1].GetStep() + params = getParameters(secondNestedStep.GetFragments()) + c.Assert(1, Equals, len(params)) + c.Assert(params[0].GetParameterType(), Equals, gauge_messages.Parameter_Dynamic) + c.Assert(params[0].GetValue(), Equals, "foo") + + c.Assert(protoConcept.GetSteps()[1].GetItemType(), Equals, gauge_messages.ProtoItem_Step) + secondStepInConcept := protoConcept.GetSteps()[1].GetStep() + params = getParameters(secondStepInConcept.GetFragments()) + c.Assert(1, Equals, len(params)) + c.Assert(params[0].GetParameterType(), Equals, gauge_messages.Parameter_Dynamic) + c.Assert(params[0].GetValue(), Equals, "8800") +} + +func checkConceptParameterValuesInOrder(c *C, concept *gauge_messages.ProtoConcept, paramValues ...string) { + params := getParameters(concept.GetConceptStep().Fragments) + c.Assert(len(params), Equals, len(paramValues)) + for i, param := range params { + c.Assert(param.GetValue(), Equals, paramValues[i]) + } +} diff --git a/execution/result/scenarioResult.go b/execution/result/scenarioResult.go index c1b793875..8b158f029 100644 --- a/execution/result/scenarioResult.go +++ b/execution/result/scenarioResult.go @@ -17,10 +17,15 @@ package result -import "github.com/getgauge/gauge/gauge_messages" +import ( + "github.com/getgauge/gauge/gauge_messages" +) type ScenarioResult struct { - ProtoScenario *gauge_messages.ProtoScenario + ProtoScenario *gauge_messages.ProtoScenario + ScenarioDataTableRow *gauge_messages.ProtoTable + ScenarioDataTableRowIndex int + ScenarioDataTable *gauge_messages.ProtoTable } func NewScenarioResult(sce *gauge_messages.ProtoScenario) *ScenarioResult { @@ -28,44 +33,44 @@ func NewScenarioResult(sce *gauge_messages.ProtoScenario) *ScenarioResult { } // SetFailure sets the scenarioResult as failed -func (s *ScenarioResult) SetFailure() { +func (s ScenarioResult) SetFailure() { s.ProtoScenario.ExecutionStatus = gauge_messages.ExecutionStatus_FAILED s.ProtoScenario.Failed = true } // GetFailed returns the state of the scenario result -func (s *ScenarioResult) GetFailed() bool { +func (s ScenarioResult) GetFailed() bool { return s.ProtoScenario.GetExecutionStatus() == gauge_messages.ExecutionStatus_FAILED } -func (s *ScenarioResult) AddItems(protoItems []*gauge_messages.ProtoItem) { +func (s ScenarioResult) AddItems(protoItems []*gauge_messages.ProtoItem) { s.ProtoScenario.ScenarioItems = append(s.ProtoScenario.ScenarioItems, protoItems...) } -func (s *ScenarioResult) AddContexts(contextProtoItems []*gauge_messages.ProtoItem) { +func (s ScenarioResult) AddContexts(contextProtoItems []*gauge_messages.ProtoItem) { s.ProtoScenario.Contexts = append(s.ProtoScenario.Contexts, contextProtoItems...) } -func (s *ScenarioResult) AddTearDownSteps(tearDownProtoItems []*gauge_messages.ProtoItem) { +func (s ScenarioResult) AddTearDownSteps(tearDownProtoItems []*gauge_messages.ProtoItem) { s.ProtoScenario.TearDownSteps = append(s.ProtoScenario.TearDownSteps, tearDownProtoItems...) } -func (s *ScenarioResult) UpdateExecutionTime() { +func (s ScenarioResult) UpdateExecutionTime() { s.updateExecutionTimeFromItems(s.ProtoScenario.GetContexts()) s.updateExecutionTimeFromItems(s.ProtoScenario.GetScenarioItems()) } -func (s *ScenarioResult) AddExecTime(execTime int64) { +func (s ScenarioResult) AddExecTime(execTime int64) { currentScenarioExecTime := s.ProtoScenario.GetExecutionTime() s.ProtoScenario.ExecutionTime = currentScenarioExecTime + execTime } // ExecTime returns the time taken for scenario execution -func (s *ScenarioResult) ExecTime() int64 { +func (s ScenarioResult) ExecTime() int64 { return s.ProtoScenario.ExecutionTime } -func (s *ScenarioResult) updateExecutionTimeFromItems(protoItems []*gauge_messages.ProtoItem) { +func (s ScenarioResult) updateExecutionTimeFromItems(protoItems []*gauge_messages.ProtoItem) { for _, item := range protoItems { if item.GetItemType() == gauge_messages.ProtoItem_Step { stepExecTime := item.GetStep().GetStepExecutionResult().GetExecutionResult().GetExecutionTime() @@ -77,28 +82,28 @@ func (s *ScenarioResult) updateExecutionTimeFromItems(protoItems []*gauge_messag } } -func (s *ScenarioResult) GetPreHook() []*gauge_messages.ProtoHookFailure { +func (s ScenarioResult) GetPreHook() []*gauge_messages.ProtoHookFailure { if s.ProtoScenario.PreHookFailure == nil { return []*gauge_messages.ProtoHookFailure{} } return []*gauge_messages.ProtoHookFailure{s.ProtoScenario.PreHookFailure} } -func (s *ScenarioResult) GetPostHook() []*gauge_messages.ProtoHookFailure { +func (s ScenarioResult) GetPostHook() []*gauge_messages.ProtoHookFailure { if s.ProtoScenario.PostHookFailure == nil { return []*gauge_messages.ProtoHookFailure{} } return []*gauge_messages.ProtoHookFailure{s.ProtoScenario.PostHookFailure} } -func (s *ScenarioResult) AddPreHook(f ...*gauge_messages.ProtoHookFailure) { +func (s ScenarioResult) AddPreHook(f ...*gauge_messages.ProtoHookFailure) { s.ProtoScenario.PreHookFailure = f[0] } -func (s *ScenarioResult) AddPostHook(f ...*gauge_messages.ProtoHookFailure) { +func (s ScenarioResult) AddPostHook(f ...*gauge_messages.ProtoHookFailure) { s.ProtoScenario.PostHookFailure = f[0] } -func (s *ScenarioResult) Item() interface{} { +func (s ScenarioResult) Item() interface{} { return s.ProtoScenario } diff --git a/execution/result/specResult.go b/execution/result/specResult.go index a7ed693b1..e96510173 100644 --- a/execution/result/specResult.go +++ b/execution/result/specResult.go @@ -60,6 +60,26 @@ func (specResult *SpecResult) AddScenarioResults(scenarioResults []Result) { specResult.ScenarioCount += len(scenarioResults) } +func (specResult *SpecResult) AddTableDrivenScenarioResult(r *ScenarioResult, t *gauge_messages.ProtoTable, scenarioRowIndex int, specRowIndex int, specTableDriven bool) { + if r.GetFailed() { + specResult.IsFailed = true + specResult.ScenarioFailedCount++ + } + specResult.AddExecTime(r.ExecTime()) + pItem := &gauge_messages.ProtoItem{ + ItemType: gauge_messages.ProtoItem_TableDrivenScenario, + TableDrivenScenario: &gauge_messages.ProtoTableDrivenScenario{ + Scenario: r.Item().(*gauge_messages.ProtoScenario), + IsScenarioTableDriven: true, + ScenarioTableRowIndex: int32(scenarioRowIndex), + IsSpecTableDriven: specTableDriven, + ScenarioDataTable: t, + TableRowIndex: int32(specRowIndex), + }, + } + specResult.ProtoSpec.Items = append(specResult.ProtoSpec.Items, pItem) +} + // AddTableRelatedScenarioResult aggregates the data table driven spec results. func (specResult *SpecResult) AddTableRelatedScenarioResult(scenarioResults [][]Result, index int) { numberOfScenarios := len(scenarioResults[0]) diff --git a/execution/scenarioExecutor.go b/execution/scenarioExecutor.go index d81dae5eb..5e83f44b5 100644 --- a/execution/scenarioExecutor.go +++ b/execution/scenarioExecutor.go @@ -60,7 +60,7 @@ func (e *scenarioExecutor) execute(i gauge.Item, r result.Result) { scenarioResult := r.(*result.ScenarioResult) scenarioResult.ProtoScenario.ExecutionStatus = gauge_messages.ExecutionStatus_PASSED scenarioResult.ProtoScenario.Skipped = false - if scenario.DataTableRow.IsInitialized() && !shouldExecuteForRow(scenario.DataTableRowIndex) { + if scenario.SpecDataTableRow.IsInitialized() && !shouldExecuteForRow(scenario.SpecDataTableRowIndex) { e.errMap.ScenarioErrs[scenario] = append([]error{errors.New("skipped Reason: Doesn't satisfy --table-rows flag condition")}, e.errMap.ScenarioErrs[scenario]...) setSkipInfoInResult(scenarioResult, scenario, e.errMap) return @@ -84,8 +84,9 @@ func (e *scenarioExecutor) execute(i gauge.Item, r result.Result) { if !scenarioResult.GetFailed() { protoContexts := scenarioResult.ProtoScenario.GetContexts() protoScenItems := scenarioResult.ProtoScenario.GetScenarioItems() - e.executeItems(append(e.contexts, scenario.Steps...), append(protoContexts, protoScenItems...), scenarioResult) - e.executeItems(e.teardowns, scenarioResult.ProtoScenario.GetTearDownSteps(), scenarioResult) + e.executeSteps(append(e.contexts, scenario.Steps...), append(protoContexts, protoScenItems...), scenarioResult) + // teardowns are not appended to previous call to executeSteps to ensure they are run irrespective of context/step failures + e.executeSteps(e.teardowns, scenarioResult.ProtoScenario.GetTearDownSteps(), scenarioResult) } e.notifyAfterScenarioHook(scenarioResult) @@ -93,9 +94,9 @@ func (e *scenarioExecutor) execute(i gauge.Item, r result.Result) { } func (e *scenarioExecutor) initScenarioDataStore() *gauge_messages.ProtoExecutionResult { - initScenarioDataStoreMessage := &gauge_messages.Message{MessageType: gauge_messages.Message_ScenarioDataStoreInit, + msg := &gauge_messages.Message{MessageType: gauge_messages.Message_ScenarioDataStoreInit, ScenarioDataStoreInitRequest: &gauge_messages.ScenarioDataStoreInitRequest{}} - return e.runner.ExecuteAndGetStatus(initScenarioDataStoreMessage) + return e.runner.ExecuteAndGetStatus(msg) } func (e *scenarioExecutor) handleScenarioDataStoreFailure(scenarioResult *result.ScenarioResult, scenario *gauge.Scenario, err error) { @@ -142,12 +143,12 @@ func (e *scenarioExecutor) notifyAfterScenarioHook(scenarioResult *result.Scenar e.pluginHandler.NotifyPlugins(message) } -func (e *scenarioExecutor) executeItems(items []*gauge.Step, protoItems []*gauge_messages.ProtoItem, scenarioResult *result.ScenarioResult) { - var itemsIndex int +func (e *scenarioExecutor) executeSteps(steps []*gauge.Step, protoItems []*gauge_messages.ProtoItem, scenarioResult *result.ScenarioResult) { + var stepsIndex int for _, protoItem := range protoItems { if protoItem.GetItemType() == gauge_messages.ProtoItem_Concept || protoItem.GetItemType() == gauge_messages.ProtoItem_Step { - failed, recoverable := e.executeItem(items[itemsIndex], protoItem, scenarioResult) - itemsIndex++ + failed, recoverable := e.executeStep(steps[stepsIndex], protoItem, scenarioResult) + stepsIndex++ if failed { scenarioResult.SetFailure() if !recoverable { @@ -158,17 +159,17 @@ func (e *scenarioExecutor) executeItems(items []*gauge.Step, protoItems []*gauge } } -func (e *scenarioExecutor) executeItem(item *gauge.Step, protoItem *gauge_messages.ProtoItem, scenarioResult *result.ScenarioResult) (bool, bool) { +func (e *scenarioExecutor) executeStep(step *gauge.Step, protoItem *gauge_messages.ProtoItem, scenarioResult *result.ScenarioResult) (bool, bool) { var failed, recoverable bool if protoItem.GetItemType() == gauge_messages.ProtoItem_Concept { protoConcept := protoItem.GetConcept() - res := e.executeConcept(item, protoConcept, scenarioResult) + res := e.executeConcept(step, protoConcept, scenarioResult) failed = res.GetFailed() recoverable = res.GetRecoverable() } else if protoItem.GetItemType() == gauge_messages.ProtoItem_Step { se := &stepExecutor{runner: e.runner, pluginHandler: e.pluginHandler, currentExecutionInfo: e.currentExecutionInfo, stream: e.stream} - res := se.executeStep(item, protoItem.GetStep()) + res := se.executeStep(step, protoItem.GetStep()) protoItem.GetStep().StepExecutionResult = res.ProtoStepExecResult() failed = res.GetFailed() recoverable = res.ProtoStepExecResult().GetExecutionResult().GetRecoverableError() @@ -184,7 +185,7 @@ func (e *scenarioExecutor) executeConcept(item *gauge.Step, protoConcept *gauge_ var conceptStepIndex int for _, protoStep := range protoConcept.Steps { if protoStep.GetItemType() == gauge_messages.ProtoItem_Concept || protoStep.GetItemType() == gauge_messages.ProtoItem_Step { - failed, recoverable := e.executeItem(item.ConceptSteps[conceptStepIndex], protoStep, scenarioResult) + failed, recoverable := e.executeStep(item.ConceptSteps[conceptStepIndex], protoStep, scenarioResult) conceptStepIndex++ if failed { scenarioResult.SetFailure() diff --git a/execution/simpleExecution.go b/execution/simpleExecution.go index 31ca7be32..954b447bc 100644 --- a/execution/simpleExecution.go +++ b/execution/simpleExecution.go @@ -31,9 +31,11 @@ import ( "github.com/getgauge/gauge/runner" ) +// ExecuteTags holds the tags to filter the execution by var ExecuteTags = "" var tableRowsIndexes []int +// SetTableRows is used to limit data driven execution to specific rows func SetTableRows(tableRows string) { tableRowsIndexes = getDataTableRows(tableRows) } diff --git a/execution/specExecutor.go b/execution/specExecutor.go index 5d574ca23..da88ccc64 100644 --- a/execution/specExecutor.go +++ b/execution/specExecutor.go @@ -65,16 +65,6 @@ func newSpecExecutor(s *gauge.Specification, r runner.Runner, ph plugin.Handler, } } -func hasParseError(errs []error) bool { - for _, e := range errs { - switch e.(type) { - case parser.ParseError: - return true - } - } - return false -} - func (e *specExecutor) execute(executeBefore, execute, executeAfter bool) *result.SpecResult { e.specResult = gauge.NewSpecResult(e.specification) if errs, ok := e.errMap.SpecErrs[e.specification]; ok { @@ -83,7 +73,11 @@ func (e *specExecutor) execute(executeBefore, execute, executeAfter bool) *resul return e.specResult } } - resolvedSpecItems, err := e.resolveItems(e.specification.GetSpecItems()) + lookup, err := e.dataTableLookup() + if err != nil { + logger.Fatalf(true, "Failed to resolve Specifications : %s", err.Error()) + } + resolvedSpecItems, err := resolveItems(e.specification.GetSpecItems(), lookup, e.setSkipInfo) if err != nil { logger.Fatalf(true, "Failed to resolve Specifications : %s", err.Error()) } @@ -103,11 +97,28 @@ func (e *specExecutor) execute(executeBefore, execute, executeAfter bool) *resul } if execute && !e.specResult.GetFailed() { if e.specification.DataTable.Table.GetRowCount() == 0 { - scenarioResults, err := e.executeScenarios(e.specification.Scenarios) + others, tableDriven := parser.FilterTableRelatedScenarios(e.specification.Scenarios, func(s *gauge.Scenario) bool { + return s.ScenarioDataTableRow.IsInitialized() + }) + results, err := e.executeScenarios(others) if err != nil { logger.Fatalf(true, "Failed to resolve Specifications : %s", err.Error()) } - e.specResult.AddScenarioResults(scenarioResults) + e.specResult.AddScenarioResults(results) + scnMap := make(map[int]bool, 0) + for _, s := range tableDriven { + if _, ok := scnMap[s.Span.Start]; !ok { + scnMap[s.Span.Start] = true + } + + r, err := e.executeScenario(s) + if err != nil { + logger.Fatalf(true, "Failed to resolve Specifications : %s", err.Error()) + } + e.specResult.AddTableDrivenScenarioResult(r, gauge.ConvertToProtoTable(&s.DataTable.Table), + s.ScenarioDataTableRowIndex, s.SpecDataTableRowIndex, s.SpecDataTableRow.IsInitialized()) + } + e.specResult.ScenarioCount += len(scnMap) } else { e.executeSpec() } @@ -124,7 +135,7 @@ func (e *specExecutor) execute(executeBefore, execute, executeAfter bool) *resul func (e *specExecutor) executeTableRelatedScenarios(scenarios []*gauge.Scenario) error { if len(scenarios) > 0 { - index := e.specification.Scenarios[0].DataTableRowIndex + index := e.specification.Scenarios[0].SpecDataTableRowIndex sceRes, err := e.executeScenarios(scenarios) if err != nil { return err @@ -138,7 +149,7 @@ func (e *specExecutor) executeTableRelatedScenarios(scenarios []*gauge.Scenario) func (e *specExecutor) executeSpec() error { parser.GetResolvedDataTablerows(e.specification.DataTable.Table) nonTableRelatedScenarios, tableRelatedScenarios := parser.FilterTableRelatedScenarios(e.specification.Scenarios, func(s *gauge.Scenario) bool { - return s.DataTableRow.IsInitialized() + return s.SpecDataTableRow.IsInitialized() }) res, err := e.executeScenarios(nonTableRelatedScenarios) if err != nil { @@ -149,89 +160,6 @@ func (e *specExecutor) executeSpec() error { return nil } -func (e *specExecutor) resolveItems(items []gauge.Item) ([]*gauge_messages.ProtoItem, error) { - var protoItems []*gauge_messages.ProtoItem - for _, item := range items { - if item.Kind() != gauge.TearDownKind { - protoItem, err := e.resolveToProtoItem(item) - if err != nil { - return nil, err - } - protoItems = append(protoItems, protoItem) - } - } - return protoItems, nil -} - -func (e *specExecutor) resolveToProtoItem(item gauge.Item) (*gauge_messages.ProtoItem, error) { - var protoItem *gauge_messages.ProtoItem - var err error - switch item.Kind() { - case gauge.StepKind: - if (item.(*gauge.Step)).IsConcept { - concept := item.(*gauge.Step) - lookup, err := e.dataTableLookup() - if err != nil { - return nil, err - } - protoItem, err = e.resolveToProtoConceptItem(*concept, lookup) - } else { - protoItem, err = e.resolveToProtoStepItem(item.(*gauge.Step)) - } - break - - default: - protoItem = gauge.ConvertToProtoItem(item) - } - return protoItem, err -} - -// Not passing pointer as we cannot modify the original concept step's lookup. This has to be populated for each iteration over data table. -func (e *specExecutor) resolveToProtoConceptItem(concept gauge.Step, lookup *gauge.ArgLookup) (*gauge_messages.ProtoItem, error) { - paramResolver := new(parser.ParamResolver) - if err := parser.PopulateConceptDynamicParams(&concept, lookup); err != nil { - return nil, err - } - protoConceptItem := gauge.ConvertToProtoItem(&concept) - protoConceptItem.Concept.ConceptStep.StepExecutionResult = &gauge_messages.ProtoStepExecutionResult{} - for stepIndex, step := range concept.ConceptSteps { - // Need to reset parent as the step.parent is pointing to a concept whose lookup is not populated yet - if step.IsConcept { - step.Parent = &concept - protoItem, err := e.resolveToProtoConceptItem(*step, &concept.Lookup) - if err != nil { - return nil, err - } - protoConceptItem.GetConcept().GetSteps()[stepIndex] = protoItem - } else { - stepParameters, err := paramResolver.GetResolvedParams(step, &concept, &concept.Lookup) - if err != nil { - return nil, err - } - updateProtoStepParameters(protoConceptItem.Concept.Steps[stepIndex].Step, stepParameters) - e.setSkipInfo(protoConceptItem.Concept.Steps[stepIndex].Step, step) - } - } - protoConceptItem.Concept.ConceptStep.StepExecutionResult.Skipped = false - return protoConceptItem, nil -} - -func (e *specExecutor) resolveToProtoStepItem(step *gauge.Step) (*gauge_messages.ProtoItem, error) { - protoStepItem := gauge.ConvertToProtoItem(step) - paramResolver := new(parser.ParamResolver) - lookup, err := e.dataTableLookup() - if err != nil { - return nil, err - } - parameters, err := paramResolver.GetResolvedParams(step, nil, lookup) - if err != nil { - return nil, err - } - updateProtoStepParameters(protoStepItem.Step, parameters) - e.setSkipInfo(protoStepItem.Step, step) - return protoStepItem, err -} - func (e *specExecutor) initSpecDataStore() *gauge_messages.ProtoExecutionResult { initSpecDataStoreMessage := &gauge_messages.Message{MessageType: gauge_messages.Message_SpecDataStoreInit, SpecDataStoreInitRequest: &gauge_messages.SpecDataStoreInitRequest{}} @@ -265,12 +193,6 @@ func (e *specExecutor) notifyAfterSpecHook() { e.pluginHandler.NotifyPlugins(m) } -func executeHook(message *gauge_messages.Message, execTimeTracker result.ExecTimeTracker, r runner.Runner) *gauge_messages.ProtoExecutionResult { - executionResult := r.ExecuteAndGetStatus(message) - execTimeTracker.AddExecTime(executionResult.GetExecutionTime()) - return executionResult -} - func (e *specExecutor) skipSpecForError(err error) { logger.Errorf(true, err.Error()) validationError := validation.NewStepValidationError(&gauge.Step{LineNo: e.specification.Heading.LineNo, LineText: e.specification.Heading.Value}, @@ -324,11 +246,17 @@ func (e *specExecutor) getItemsForScenarioExecution(steps []*gauge.Step) ([]*gau for i, context := range steps { items[i] = context } - return e.resolveItems(items) + lookup, err := e.dataTableLookup() + if err != nil { + return nil, err + } + return resolveItems(items, lookup, e.setSkipInfo) } func (e *specExecutor) dataTableLookup() (*gauge.ArgLookup, error) { - return new(gauge.ArgLookup).FromDataTableRow(&e.specification.DataTable.Table, 0) + l := new(gauge.ArgLookup) + err := l.ReadDataTableRow(&e.specification.DataTable.Table, 0) + return l, err } func (e *specExecutor) executeScenarios(scenarios []*gauge.Scenario) ([]result.Result, error) { @@ -350,7 +278,12 @@ func (e *specExecutor) executeScenario(scenario *gauge.Scenario) (*result.Scenar IsFailed: false, } - scenarioResult := result.NewScenarioResult(gauge.NewProtoScenario(scenario)) + scenarioResult := &result.ScenarioResult{ + ProtoScenario: gauge.NewProtoScenario(scenario), + ScenarioDataTableRow: gauge.ConvertToProtoTable(&scenario.ScenarioDataTableRow), + ScenarioDataTableRowIndex: scenario.ScenarioDataTableRowIndex, + ScenarioDataTable: gauge.ConvertToProtoTable(&scenario.DataTable.Table), + } if err := e.addAllItemsForScenarioExecution(scenario, scenarioResult); err != nil { return nil, err } @@ -373,22 +306,21 @@ func (e *specExecutor) addAllItemsForScenarioExecution(scenario *gauge.Scenario, return err } scenarioResult.AddTearDownSteps(tearDownSteps) - items, err := e.resolveItems(scenario.Items) + lookup, err := e.dataTableLookup() if err != nil { return err } - scenarioResult.AddItems(items) - return nil -} - -func updateProtoStepParameters(protoStep *gauge_messages.ProtoStep, parameters []*gauge_messages.Parameter) { - paramIndex := 0 - for fragmentIndex, fragment := range protoStep.Fragments { - if fragment.GetFragmentType() == gauge_messages.Fragment_Parameter { - protoStep.Fragments[fragmentIndex].Parameter = parameters[paramIndex] - paramIndex++ + if scenario.ScenarioDataTableRow.IsInitialized() { + if err = lookup.ReadDataTableRow(&scenario.ScenarioDataTableRow, 0); err != nil { + return err } } + items, err := resolveItems(scenario.Items, lookup, e.setSkipInfo) + if err != nil { + return err + } + scenarioResult.AddItems(items) + return nil } func getTagValue(tags *gauge.Tags) []string { @@ -434,3 +366,18 @@ func getDataTableRows(tableRows string) (tableRowIndexes []int) { } return } + +func executeHook(message *gauge_messages.Message, execTimeTracker result.ExecTimeTracker, r runner.Runner) *gauge_messages.ProtoExecutionResult { + executionResult := r.ExecuteAndGetStatus(message) + execTimeTracker.AddExecTime(executionResult.GetExecutionTime()) + return executionResult +} + +func hasParseError(errs []error) bool { + for _, e := range errs { + if _, ok := e.(parser.ParseError); ok { + return true + } + } + return false +} diff --git a/execution/specExecutor_test.go b/execution/specExecutor_test.go index 047ee62b3..d8d8d24c3 100644 --- a/execution/specExecutor_test.go +++ b/execution/specExecutor_test.go @@ -20,7 +20,6 @@ package execution import ( "fmt" "net" - "path/filepath" "testing" "sync" @@ -38,7 +37,7 @@ type specBuilder struct { lines []string } -func SpecBuilder() *specBuilder { +func newSpecBuilder() *specBuilder { return &specBuilder{lines: make([]string, 0)} } @@ -102,182 +101,6 @@ func (specBuilder *specBuilder) text(comment string) *specBuilder { return specBuilder } -func (s *MySuite) TestResolveConceptToProtoConceptItem(c *C) { - conceptDictionary := gauge.NewConceptDictionary() - - specText := SpecBuilder().specHeading("A spec heading"). - scenarioHeading("First scenario"). - step("create user \"456\" \"foo\" and \"9900\""). - String() - path, _ := filepath.Abs(filepath.Join("testdata", "concept.cpt")) - parser.AddConcepts([]string{path}, conceptDictionary) - - spec, _, _ := new(parser.SpecParser).Parse(specText, conceptDictionary, "") - - specExecutor := newSpecExecutor(spec, nil, nil, nil, 0) - specExecutor.errMap = getValidationErrorMap() - lookup, err := specExecutor.dataTableLookup() - c.Assert(err, IsNil) - cItem, err := specExecutor.resolveToProtoConceptItem(*spec.Scenarios[0].Steps[0], lookup) - c.Assert(err, IsNil) - protoConcept := cItem.GetConcept() - - checkConceptParameterValuesInOrder(c, protoConcept, "456", "foo", "9900") - firstNestedStep := protoConcept.GetSteps()[0].GetConcept().GetSteps()[0].GetStep() - params := getParameters(firstNestedStep.GetFragments()) - c.Assert(1, Equals, len(params)) - c.Assert(params[0].GetParameterType(), Equals, gauge_messages.Parameter_Dynamic) - c.Assert(params[0].GetValue(), Equals, "456") - - secondNestedStep := protoConcept.GetSteps()[0].GetConcept().GetSteps()[1].GetStep() - params = getParameters(secondNestedStep.GetFragments()) - c.Assert(1, Equals, len(params)) - c.Assert(params[0].GetParameterType(), Equals, gauge_messages.Parameter_Dynamic) - c.Assert(params[0].GetValue(), Equals, "foo") - - secondStep := protoConcept.GetSteps()[1].GetStep() - params = getParameters(secondStep.GetFragments()) - c.Assert(1, Equals, len(params)) - c.Assert(params[0].GetParameterType(), Equals, gauge_messages.Parameter_Dynamic) - c.Assert(params[0].GetValue(), Equals, "9900") - -} - -func (s *MySuite) TestResolveNestedConceptToProtoConceptItem(c *C) { - conceptDictionary := gauge.NewConceptDictionary() - - specText := SpecBuilder().specHeading("A spec heading"). - scenarioHeading("First scenario"). - step("create user \"456\" \"foo\" and \"9900\""). - String() - - path, _ := filepath.Abs(filepath.Join("testdata", "concept.cpt")) - parser.AddConcepts([]string{path}, conceptDictionary) - specParser := new(parser.SpecParser) - spec, _, _ := specParser.Parse(specText, conceptDictionary, "") - - specExecutor := newSpecExecutor(spec, nil, nil, nil, 0) - specExecutor.errMap = getValidationErrorMap() - lookup, err := specExecutor.dataTableLookup() - c.Assert(err, IsNil) - cItem, err := specExecutor.resolveToProtoConceptItem(*spec.Scenarios[0].Steps[0], lookup) - c.Assert(err, IsNil) - protoConcept := cItem.GetConcept() - checkConceptParameterValuesInOrder(c, protoConcept, "456", "foo", "9900") - - c.Assert(protoConcept.GetSteps()[0].GetItemType(), Equals, gauge_messages.ProtoItem_Concept) - - nestedConcept := protoConcept.GetSteps()[0].GetConcept() - checkConceptParameterValuesInOrder(c, nestedConcept, "456", "foo") - - firstNestedStep := nestedConcept.GetSteps()[0].GetStep() - params := getParameters(firstNestedStep.GetFragments()) - c.Assert(1, Equals, len(params)) - c.Assert(params[0].GetParameterType(), Equals, gauge_messages.Parameter_Dynamic) - c.Assert(params[0].GetValue(), Equals, "456") - - secondNestedStep := nestedConcept.GetSteps()[1].GetStep() - params = getParameters(secondNestedStep.GetFragments()) - c.Assert(1, Equals, len(params)) - c.Assert(params[0].GetParameterType(), Equals, gauge_messages.Parameter_Dynamic) - c.Assert(params[0].GetValue(), Equals, "foo") - - c.Assert(protoConcept.GetSteps()[1].GetItemType(), Equals, gauge_messages.ProtoItem_Step) - secondStepInConcept := protoConcept.GetSteps()[1].GetStep() - params = getParameters(secondStepInConcept.GetFragments()) - c.Assert(1, Equals, len(params)) - c.Assert(params[0].GetParameterType(), Equals, gauge_messages.Parameter_Dynamic) - c.Assert(params[0].GetValue(), Equals, "9900") -} - -func TestResolveNestedConceptAndTableParamToProtoConceptItem(t *testing.T) { - conceptDictionary := gauge.NewConceptDictionary() - - specText := SpecBuilder().specHeading("A spec heading"). - scenarioHeading("First scenario"). - step("create user \"456\""). - String() - want := "456" - path, _ := filepath.Abs(filepath.Join("testdata", "conceptTable.cpt")) - parser.AddConcepts([]string{path}, conceptDictionary) - specParser := new(parser.SpecParser) - spec, _, _ := specParser.Parse(specText, conceptDictionary, "") - - specExecutor := newSpecExecutor(spec, nil, nil, nil, 0) - specExecutor.errMap = getValidationErrorMap() - lookup, err := specExecutor.dataTableLookup() - if err != nil { - t.Errorf("Expected no error. Got : %s", err.Error()) - } - cItem, err := specExecutor.resolveToProtoConceptItem(*spec.Scenarios[0].Steps[0], lookup) - if err != nil { - t.Errorf("Expected no error. Got : %s", err.Error()) - } - protoConcept := cItem.GetConcept() - got := getParameters(protoConcept.GetSteps()[0].GetStep().GetFragments())[0].GetTable().GetRows()[1].Cells[0] - - if want != got { - t.Errorf("Did not resolve dynamic param in table for concept. Got %s, want: %s", got, want) - } -} - -func (s *MySuite) TestResolveToProtoConceptItemWithDataTable(c *C) { - conceptDictionary := gauge.NewConceptDictionary() - - specText := SpecBuilder().specHeading("A spec heading"). - tableHeader("id", "name", "phone"). - tableHeader("123", "foo", "8800"). - tableHeader("666", "bar", "9900"). - scenarioHeading("First scenario"). - step("create user and "). - String() - - path, _ := filepath.Abs(filepath.Join("testdata", "concept.cpt")) - parser.AddConcepts([]string{path}, conceptDictionary) - specParser := new(parser.SpecParser) - spec, _, _ := specParser.Parse(specText, conceptDictionary, "") - - specExecutor := newSpecExecutor(spec, nil, nil, nil, 0) - - specExecutor.errMap = gauge.NewBuildErrors() - lookup, err := specExecutor.dataTableLookup() - c.Assert(err, IsNil) - cItem, err := specExecutor.resolveToProtoConceptItem(*spec.Scenarios[0].Steps[0], lookup) - c.Assert(err, IsNil) - protoConcept := cItem.GetConcept() - checkConceptParameterValuesInOrder(c, protoConcept, "123", "foo", "8800") - - c.Assert(protoConcept.GetSteps()[0].GetItemType(), Equals, gauge_messages.ProtoItem_Concept) - nestedConcept := protoConcept.GetSteps()[0].GetConcept() - checkConceptParameterValuesInOrder(c, nestedConcept, "123", "foo") - firstNestedStep := nestedConcept.GetSteps()[0].GetStep() - params := getParameters(firstNestedStep.GetFragments()) - c.Assert(1, Equals, len(params)) - c.Assert(params[0].GetParameterType(), Equals, gauge_messages.Parameter_Dynamic) - c.Assert(params[0].GetValue(), Equals, "123") - - secondNestedStep := nestedConcept.GetSteps()[1].GetStep() - params = getParameters(secondNestedStep.GetFragments()) - c.Assert(1, Equals, len(params)) - c.Assert(params[0].GetParameterType(), Equals, gauge_messages.Parameter_Dynamic) - c.Assert(params[0].GetValue(), Equals, "foo") - - c.Assert(protoConcept.GetSteps()[1].GetItemType(), Equals, gauge_messages.ProtoItem_Step) - secondStepInConcept := protoConcept.GetSteps()[1].GetStep() - params = getParameters(secondStepInConcept.GetFragments()) - c.Assert(1, Equals, len(params)) - c.Assert(params[0].GetParameterType(), Equals, gauge_messages.Parameter_Dynamic) - c.Assert(params[0].GetValue(), Equals, "8800") -} - -func checkConceptParameterValuesInOrder(c *C, concept *gauge_messages.ProtoConcept, paramValues ...string) { - params := getParameters(concept.GetConceptStep().Fragments) - c.Assert(len(params), Equals, len(paramValues)) - for i, param := range params { - c.Assert(param.GetValue(), Equals, paramValues[i]) - } -} - type tableRow struct { name string input string // input by user for data table rows @@ -325,7 +148,7 @@ func (s *MySuite) TestCreateSkippedSpecResultWithScenarios(c *C) { func anySpec() *gauge.Specification { - specText := SpecBuilder().specHeading("A spec heading"). + specText := newSpecBuilder().specHeading("A spec heading"). scenarioHeading("First scenario"). step("create user \"456\" \"foo\" and \"9900\""). String() @@ -352,7 +175,7 @@ func (s *MySuite) TestSpecIsSkippedIfDataRangeIsInvalid(c *C) { func (s *MySuite) TestDataTableRowsAreSkippedForUnimplemetedStep(c *C) { stepText := "Unimplememted step" - specText := SpecBuilder().specHeading("A spec heading"). + specText := newSpecBuilder().specHeading("A spec heading"). tableHeader("id", "name", "phone"). tableRow("123", "foo", "8800"). tableRow("666", "bar", "9900"). @@ -696,13 +519,13 @@ func TestExecuteAddsSpecHookExecutionScreenshots(t *testing.T) { mockRunner.ExecuteAndGetStatusFunc = func(m *gauge_messages.Message) *gauge_messages.ProtoExecutionResult { if m.MessageType == gauge_messages.Message_SpecExecutionEnding { return &gauge_messages.ProtoExecutionResult{ - Screenshots: [][]byte{[]byte("screenshot1"), []byte("screenshot2")}, + Screenshots: [][]byte{[]byte("screenshot1"), []byte("screenshot2")}, Failed: false, ExecutionTime: 10, } } else if m.MessageType == gauge_messages.Message_SpecExecutionStarting { return &gauge_messages.ProtoExecutionResult{ - Screenshots: [][]byte{[]byte("screenshot3"), []byte("screenshot4")}, + Screenshots: [][]byte{[]byte("screenshot3"), []byte("screenshot4")}, Failed: false, ExecutionTime: 10, } diff --git a/execution/stepExecutor_test.go b/execution/stepExecutor_test.go index 14dc4c7e6..609b6bf4a 100644 --- a/execution/stepExecutor_test.go +++ b/execution/stepExecutor_test.go @@ -117,7 +117,7 @@ func TestStepExecutionShouldGetScreenshotsBeforeStep(t *testing.T) { r.ExecuteAndGetStatusFunc = func(m *gauge_messages.Message) *gauge_messages.ProtoExecutionResult { if m.MessageType == gauge_messages.Message_StepExecutionStarting { return &gauge_messages.ProtoExecutionResult{ - Screenshots: [][]byte{[]byte("screenshot1"), []byte("screenshot2")}, + Screenshots: [][]byte{[]byte("screenshot1"), []byte("screenshot2")}, Failed: false, ExecutionTime: 10, } @@ -165,7 +165,7 @@ func TestStepExecutionShouldGetScreenshotsAfterStep(t *testing.T) { r.ExecuteAndGetStatusFunc = func(m *gauge_messages.Message) *gauge_messages.ProtoExecutionResult { if m.MessageType == gauge_messages.Message_StepExecutionEnding { return &gauge_messages.ProtoExecutionResult{ - Screenshots: [][]byte{[]byte("screenshot1"), []byte("screenshot2")}, + Screenshots: [][]byte{[]byte("screenshot1"), []byte("screenshot2")}, Failed: false, ExecutionTime: 10, } diff --git a/formatter/formatter_test.go b/formatter/formatter_test.go index b22a58172..547395857 100644 --- a/formatter/formatter_test.go +++ b/formatter/formatter_test.go @@ -20,6 +20,8 @@ package formatter import ( "testing" + "github.com/getgauge/gauge/env" + "github.com/getgauge/gauge/gauge" "github.com/getgauge/gauge/parser" . "gopkg.in/check.v1" @@ -213,19 +215,30 @@ func (s *MySuite) TestFormatStep(c *C) { func (s *MySuite) TestFormattingWithTableAsAComment(c *C) { tokens := []*parser.Token{ &parser.Token{Kind: gauge.SpecKind, Value: "My Spec Heading", LineNo: 1}, + &parser.Token{Kind: gauge.CommentKind, Value: "\n", LineNo: 2}, &parser.Token{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 3}, &parser.Token{Kind: gauge.TableHeader, Args: []string{"id", "name"}, LineText: " |id|name|"}, &parser.Token{Kind: gauge.TableRow, Args: []string{"1", "foo"}, LineText: " |1|foo|"}, &parser.Token{Kind: gauge.TableRow, Args: []string{"2", "bar"}, LineText: "|2|bar|"}, - &parser.Token{Kind: gauge.StepKind, Value: "Example step", LineNo: 5, LineText: "Example step"}, + &parser.Token{Kind: gauge.CommentKind, Value: "\n", LineNo: 7}, + &parser.Token{Kind: gauge.TableHeader, Args: []string{"id", "name"}, LineText: " |id|name1|"}, + &parser.Token{Kind: gauge.TableRow, Args: []string{"1", "foo"}, LineText: " |1|foo|"}, + &parser.Token{Kind: gauge.TableRow, Args: []string{"2", "bar"}, LineText: "|2|bar|"}, + &parser.Token{Kind: gauge.StepKind, Value: "Example step", LineNo: 11, LineText: "Example step"}, } spec, _, _ := new(parser.SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "") formatted := FormatSpecification(spec) c.Assert(formatted, Equals, `# My Spec Heading + ## Scenario Heading - |id|name| + |id|name| + |--|----| + |1 |foo | + |2 |bar | + + |id|name1| |1|foo| |2|bar| * Example step @@ -256,7 +269,7 @@ func (s *MySuite) TestFormatSpecificationWithTableContainingDynamicParameters(c |1 |f | ## Scenario Heading * Example step -* Step with inline table `+` +* Step with inline table |id|name | |--|-----| @@ -280,6 +293,7 @@ func (s *MySuite) TestFormatShouldRetainNewlines(c *C) { &parser.Token{Kind: gauge.TableRow, Args: []string{"2", "bar"}}, } + env.AllowScenarioDatatable = func() bool { return true } spec, _, _ := new(parser.SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "") formatted := FormatSpecification(spec) c.Assert(formatted, Equals, @@ -287,10 +301,11 @@ func (s *MySuite) TestFormatShouldRetainNewlines(c *C) { ## Scenario Heading - |id|name| - |1|foo| -|2|bar| -* Example step `+` + |id|name| + |--|----| + |1 |foo | + |2 |bar | +* Example step |id|name | |--|-----| @@ -343,10 +358,11 @@ func (s *MySuite) TestFormatShouldStripDuplicateNewlinesBeforeInlineTable(c *C) ## Scenario Heading - |id|name| - |1|foo| -|2|bar| -* Example step `+` + |id|name| + |--|----| + |1 |foo | + |2 |bar | +* Example step |id|name | |--|-----| @@ -384,10 +400,11 @@ func (s *MySuite) TestFormatShouldStripDuplicateNewlinesBeforeInlineTableInTeard ## Scenario Heading - |id|name| - |1|foo| -|2|bar| -* Example step `+` + |id|name| + |--|----| + |1 |foo | + |2 |bar | +* Example step |id|name | |--|-----| @@ -396,7 +413,7 @@ func (s *MySuite) TestFormatShouldStripDuplicateNewlinesBeforeInlineTableInTeard ____ -* Example step `+` +* Example step |id|name | |--|-----| diff --git a/gauge-proto b/gauge-proto index 5dc343c65..f1387de4c 160000 --- a/gauge-proto +++ b/gauge-proto @@ -1 +1 @@ -Subproject commit 5dc343c6567076292afb6ab44b35bbced2d1fff6 +Subproject commit f1387de4c907aab73db3cecf9f45ba7fd183e07d diff --git a/gauge/arg.go b/gauge/arg.go index 19234340a..6ddc5be17 100644 --- a/gauge/arg.go +++ b/gauge/arg.go @@ -76,7 +76,7 @@ func (lookup *ArgLookup) GetArg(param string) (*StepArg, error) { func (lookup *ArgLookup) GetCopy() (*ArgLookup, error) { lookupCopy := new(ArgLookup) var err error - for key, _ := range lookup.ParamIndexMap { + for key := range lookup.ParamIndexMap { lookupCopy.AddArgName(key) var arg *StepArg arg, err = lookup.GetArg(key) @@ -87,28 +87,30 @@ func (lookup *ArgLookup) GetCopy() (*ArgLookup, error) { return lookupCopy, err } -func (lookup *ArgLookup) FromDataTableRow(datatable *Table, index int) (*ArgLookup, error) { - dataTableLookup := new(ArgLookup) - var err error +func (lookup *ArgLookup) ReadDataTableRow(datatable *Table, index int) error { if !datatable.IsInitialized() { - return dataTableLookup, err + return nil } for _, header := range datatable.Headers { - dataTableLookup.AddArgName(header) + lookup.AddArgName(header) tableCells, _ := datatable.Get(header) - err = dataTableLookup.AddArgValue(header, &StepArg{Value: tableCells[index].Value, ArgType: Static}) + err := lookup.AddArgValue(header, &StepArg{Value: tableCells[index].Value, ArgType: Static}) + if err != nil { + return err + } } - return dataTableLookup, err + return nil } -//create an empty lookup with only args to resolve dynamic params for steps -func (lookup *ArgLookup) FromDataTable(datatable *Table) *ArgLookup { +//FromDataTables creates an empty lookup with only args to resolve dynamic params for steps from given list of tables +func (lookup *ArgLookup) FromDataTables(tables ...*Table) *ArgLookup { dataTableLookup := new(ArgLookup) - if !datatable.IsInitialized() { - return dataTableLookup - } - for _, header := range datatable.Headers { - dataTableLookup.AddArgName(header) + for _, table := range tables { + if table.IsInitialized() { + for _, header := range table.Headers { + dataTableLookup.AddArgName(header) + } + } } return dataTableLookup } diff --git a/gauge/arg_test.go b/gauge/arg_test.go index 3c7fd9a6e..52f6a2a9c 100644 --- a/gauge/arg_test.go +++ b/gauge/arg_test.go @@ -85,11 +85,13 @@ func (s *MySuite) TestGetLookupFromTableRow(c *C) { dataTable.AddRowValues(dataTable.CreateTableCells([]string{"1", "admin"})) dataTable.AddRowValues(dataTable.CreateTableCells([]string{"2", "root"})) - emptyLookup, err := new(ArgLookup).FromDataTableRow(new(Table), 0) + emptyLookup := new(ArgLookup) + err := emptyLookup.ReadDataTableRow(new(Table), 0) c.Assert(err, IsNil) c.Assert(emptyLookup.ParamIndexMap, IsNil) - lookup1, err := new(ArgLookup).FromDataTableRow(dataTable, 0) + lookup1 := new(ArgLookup) + err = lookup1.ReadDataTableRow(dataTable, 0) c.Assert(err, IsNil) idArg1, err := lookup1.GetArg("id") c.Assert(err, IsNil) @@ -100,7 +102,8 @@ func (s *MySuite) TestGetLookupFromTableRow(c *C) { c.Assert(nameArg1.Value, Equals, "admin") c.Assert(nameArg1.ArgType, Equals, Static) - lookup2, err := new(ArgLookup).FromDataTableRow(dataTable, 1) + lookup2 := new(ArgLookup) + err = lookup2.ReadDataTableRow(dataTable, 1) c.Assert(err, IsNil) idArg2, err := lookup2.GetArg("id") c.Assert(err, IsNil) @@ -111,3 +114,22 @@ func (s *MySuite) TestGetLookupFromTableRow(c *C) { c.Assert(nameArg2.Value, Equals, "root") c.Assert(nameArg2.ArgType, Equals, Static) } + +func (s *MySuite) TestGetLookupFromTables(c *C) { + t1 := new(Table) + t1.AddHeaders([]string{"id1", "name1"}) + t1.AddRowValues(t1.CreateTableCells([]string{"1", "admin"})) + t1.AddRowValues(t1.CreateTableCells([]string{"2", "root"})) + + t2 := new(Table) + t2.AddHeaders([]string{"id2", "name2"}) + t2.AddRowValues(t2.CreateTableCells([]string{"1", "admin"})) + t2.AddRowValues(t2.CreateTableCells([]string{"2", "root"})) + + l := new(ArgLookup).FromDataTables(t1, t2) + + c.Assert(l.ContainsArg("id1"), Equals, true) + c.Assert(l.ContainsArg("name1"), Equals, true) + c.Assert(l.ContainsArg("id2"), Equals, true) + c.Assert(l.ContainsArg("name2"), Equals, true) +} diff --git a/gauge/protoConverters.go b/gauge/protoConverters.go index 40b2fa0c4..17a85fda6 100644 --- a/gauge/protoConverters.go +++ b/gauge/protoConverters.go @@ -147,7 +147,7 @@ func convertToProtoCommentItem(comment *Comment) *gauge_messages.ProtoItem { } func convertToProtoDataTableItem(dataTable *DataTable) *gauge_messages.ProtoItem { - return &gauge_messages.ProtoItem{ItemType: gauge_messages.ProtoItem_Table, Table: convertToProtoTableParam(&dataTable.Table)} + return &gauge_messages.ProtoItem{ItemType: gauge_messages.ProtoItem_Table, Table: ConvertToProtoTable(&dataTable.Table)} } func convertToProtoParameter(arg *StepArg) *gauge_messages.Parameter { @@ -157,16 +157,16 @@ func convertToProtoParameter(arg *StepArg) *gauge_messages.Parameter { case Dynamic: return &gauge_messages.Parameter{ParameterType: gauge_messages.Parameter_Dynamic, Value: arg.Value, Name: arg.Name} case TableArg: - return &gauge_messages.Parameter{ParameterType: gauge_messages.Parameter_Table, Table: convertToProtoTableParam(&arg.Table), Name: arg.Name} + return &gauge_messages.Parameter{ParameterType: gauge_messages.Parameter_Table, Table: ConvertToProtoTable(&arg.Table), Name: arg.Name} case SpecialString: return &gauge_messages.Parameter{ParameterType: gauge_messages.Parameter_Special_String, Value: arg.Value, Name: arg.Name} case SpecialTable: - return &gauge_messages.Parameter{ParameterType: gauge_messages.Parameter_Special_Table, Table: convertToProtoTableParam(&arg.Table), Name: arg.Name} + return &gauge_messages.Parameter{ParameterType: gauge_messages.Parameter_Special_Table, Table: ConvertToProtoTable(&arg.Table), Name: arg.Name} } return nil } -func convertToProtoTableParam(table *Table) *gauge_messages.ProtoTable { +func ConvertToProtoTable(table *Table) *gauge_messages.ProtoTable { protoTableParam := &gauge_messages.ProtoTable{Rows: make([]*gauge_messages.ProtoTableRow, 0)} protoTableParam.Headers = &gauge_messages.ProtoTableRow{Cells: table.Headers} for _, row := range table.Rows() { @@ -177,20 +177,20 @@ func convertToProtoTableParam(table *Table) *gauge_messages.ProtoTable { func ConvertToProtoSuiteResult(suiteResult *result.SuiteResult) *gauge_messages.ProtoSuiteResult { protoSuiteResult := &gauge_messages.ProtoSuiteResult{ - PreHookFailure: suiteResult.PreSuite, - PostHookFailure: suiteResult.PostSuite, - Failed: suiteResult.IsFailed, - SpecsFailedCount: int32(suiteResult.SpecsFailedCount), - ExecutionTime: suiteResult.ExecutionTime, - SpecResults: convertToProtoSpecResult(suiteResult.SpecResults), - SuccessRate: getSuccessRate(len(suiteResult.SpecResults), suiteResult.SpecsFailedCount+suiteResult.SpecsSkippedCount), - Environment: suiteResult.Environment, - Tags: suiteResult.Tags, - ProjectName: suiteResult.ProjectName, - Timestamp: suiteResult.Timestamp, - SpecsSkippedCount: int32(suiteResult.SpecsSkippedCount), - PreHookMessages: suiteResult.PreHookMessages, - PostHookMessages: suiteResult.PostHookMessages, + PreHookFailure: suiteResult.PreSuite, + PostHookFailure: suiteResult.PostSuite, + Failed: suiteResult.IsFailed, + SpecsFailedCount: int32(suiteResult.SpecsFailedCount), + ExecutionTime: suiteResult.ExecutionTime, + SpecResults: convertToProtoSpecResult(suiteResult.SpecResults), + SuccessRate: getSuccessRate(len(suiteResult.SpecResults), suiteResult.SpecsFailedCount+suiteResult.SpecsSkippedCount), + Environment: suiteResult.Environment, + Tags: suiteResult.Tags, + ProjectName: suiteResult.ProjectName, + Timestamp: suiteResult.Timestamp, + SpecsSkippedCount: int32(suiteResult.SpecsSkippedCount), + PreHookMessages: suiteResult.PreHookMessages, + PostHookMessages: suiteResult.PostHookMessages, PreHookScreenshots: suiteResult.PreHookScreenshots, PostHookScreenshots: suiteResult.PostHookScreenshots, } diff --git a/gauge/scenario.go b/gauge/scenario.go index 5c3f4efd4..fb9479d32 100644 --- a/gauge/scenario.go +++ b/gauge/scenario.go @@ -22,14 +22,17 @@ import ( ) type Scenario struct { - Heading *Heading - Steps []*Step - Comments []*Comment - Tags *Tags - Items []Item - DataTableRow Table - DataTableRowIndex int - Span *Span + Heading *Heading + Steps []*Step + Comments []*Comment + Tags *Tags + Items []Item + DataTable DataTable + SpecDataTableRow Table + SpecDataTableRowIndex int + ScenarioDataTableRow Table + ScenarioDataTableRowIndex int + Span *Span } // Span represents scope of Scenario based on line number @@ -69,6 +72,11 @@ func (scenario *Scenario) AddComment(comment *Comment) { scenario.AddItem(comment) } +func (scenario *Scenario) AddDataTable(table *Table) { + scenario.DataTable.Table = *table + scenario.AddItem(&scenario.DataTable) +} + func (scenario *Scenario) InSpan(lineNumber int) bool { return scenario.Span.isInRange(lineNumber) } diff --git a/gauge_messages/api.pb.go b/gauge_messages/api.pb.go index c585c15d3..b701de47e 100644 --- a/gauge_messages/api.pb.go +++ b/gauge_messages/api.pb.go @@ -3,9 +3,11 @@ package gauge_messages -import proto "github.com/golang/protobuf/proto" -import fmt "fmt" -import math "math" +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + math "math" +) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal @@ -69,6 +71,7 @@ var APIMessage_APIMessageType_name = map[int32]string{ 20: "FormatSpecsResponse", 21: "UnsupportedApiMessageResponse", } + var APIMessage_APIMessageType_value = map[string]int32{ "GetProjectRootRequest": 0, "GetProjectRootResponse": 1, @@ -97,8 +100,9 @@ var APIMessage_APIMessageType_value = map[string]int32{ func (x APIMessage_APIMessageType) String() string { return proto.EnumName(APIMessage_APIMessageType_name, int32(x)) } + func (APIMessage_APIMessageType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{25, 0} + return fileDescriptor_00212fb1f9d3bf1c, []int{25, 0} } // / Request to get the Root Directory of the project @@ -112,16 +116,17 @@ func (m *GetProjectRootRequest) Reset() { *m = GetProjectRootRequest{} } func (m *GetProjectRootRequest) String() string { return proto.CompactTextString(m) } func (*GetProjectRootRequest) ProtoMessage() {} func (*GetProjectRootRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{0} + return fileDescriptor_00212fb1f9d3bf1c, []int{0} } + func (m *GetProjectRootRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_GetProjectRootRequest.Unmarshal(m, b) } func (m *GetProjectRootRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_GetProjectRootRequest.Marshal(b, m, deterministic) } -func (dst *GetProjectRootRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetProjectRootRequest.Merge(dst, src) +func (m *GetProjectRootRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetProjectRootRequest.Merge(m, src) } func (m *GetProjectRootRequest) XXX_Size() int { return xxx_messageInfo_GetProjectRootRequest.Size(m) @@ -145,16 +150,17 @@ func (m *GetProjectRootResponse) Reset() { *m = GetProjectRootResponse{} func (m *GetProjectRootResponse) String() string { return proto.CompactTextString(m) } func (*GetProjectRootResponse) ProtoMessage() {} func (*GetProjectRootResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{1} + return fileDescriptor_00212fb1f9d3bf1c, []int{1} } + func (m *GetProjectRootResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_GetProjectRootResponse.Unmarshal(m, b) } func (m *GetProjectRootResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_GetProjectRootResponse.Marshal(b, m, deterministic) } -func (dst *GetProjectRootResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetProjectRootResponse.Merge(dst, src) +func (m *GetProjectRootResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetProjectRootResponse.Merge(m, src) } func (m *GetProjectRootResponse) XXX_Size() int { return xxx_messageInfo_GetProjectRootResponse.Size(m) @@ -183,16 +189,17 @@ func (m *GetInstallationRootRequest) Reset() { *m = GetInstallationRootR func (m *GetInstallationRootRequest) String() string { return proto.CompactTextString(m) } func (*GetInstallationRootRequest) ProtoMessage() {} func (*GetInstallationRootRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{2} + return fileDescriptor_00212fb1f9d3bf1c, []int{2} } + func (m *GetInstallationRootRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_GetInstallationRootRequest.Unmarshal(m, b) } func (m *GetInstallationRootRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_GetInstallationRootRequest.Marshal(b, m, deterministic) } -func (dst *GetInstallationRootRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetInstallationRootRequest.Merge(dst, src) +func (m *GetInstallationRootRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetInstallationRootRequest.Merge(m, src) } func (m *GetInstallationRootRequest) XXX_Size() int { return xxx_messageInfo_GetInstallationRootRequest.Size(m) @@ -216,16 +223,17 @@ func (m *GetInstallationRootResponse) Reset() { *m = GetInstallationRoot func (m *GetInstallationRootResponse) String() string { return proto.CompactTextString(m) } func (*GetInstallationRootResponse) ProtoMessage() {} func (*GetInstallationRootResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{3} + return fileDescriptor_00212fb1f9d3bf1c, []int{3} } + func (m *GetInstallationRootResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_GetInstallationRootResponse.Unmarshal(m, b) } func (m *GetInstallationRootResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_GetInstallationRootResponse.Marshal(b, m, deterministic) } -func (dst *GetInstallationRootResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetInstallationRootResponse.Merge(dst, src) +func (m *GetInstallationRootResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetInstallationRootResponse.Merge(m, src) } func (m *GetInstallationRootResponse) XXX_Size() int { return xxx_messageInfo_GetInstallationRootResponse.Size(m) @@ -254,16 +262,17 @@ func (m *GetAllStepsRequest) Reset() { *m = GetAllStepsRequest{} } func (m *GetAllStepsRequest) String() string { return proto.CompactTextString(m) } func (*GetAllStepsRequest) ProtoMessage() {} func (*GetAllStepsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{4} + return fileDescriptor_00212fb1f9d3bf1c, []int{4} } + func (m *GetAllStepsRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_GetAllStepsRequest.Unmarshal(m, b) } func (m *GetAllStepsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_GetAllStepsRequest.Marshal(b, m, deterministic) } -func (dst *GetAllStepsRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetAllStepsRequest.Merge(dst, src) +func (m *GetAllStepsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetAllStepsRequest.Merge(m, src) } func (m *GetAllStepsRequest) XXX_Size() int { return xxx_messageInfo_GetAllStepsRequest.Size(m) @@ -287,16 +296,17 @@ func (m *GetAllStepsResponse) Reset() { *m = GetAllStepsResponse{} } func (m *GetAllStepsResponse) String() string { return proto.CompactTextString(m) } func (*GetAllStepsResponse) ProtoMessage() {} func (*GetAllStepsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{5} + return fileDescriptor_00212fb1f9d3bf1c, []int{5} } + func (m *GetAllStepsResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_GetAllStepsResponse.Unmarshal(m, b) } func (m *GetAllStepsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_GetAllStepsResponse.Marshal(b, m, deterministic) } -func (dst *GetAllStepsResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetAllStepsResponse.Merge(dst, src) +func (m *GetAllStepsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetAllStepsResponse.Merge(m, src) } func (m *GetAllStepsResponse) XXX_Size() int { return xxx_messageInfo_GetAllStepsResponse.Size(m) @@ -326,16 +336,17 @@ func (m *SpecsRequest) Reset() { *m = SpecsRequest{} } func (m *SpecsRequest) String() string { return proto.CompactTextString(m) } func (*SpecsRequest) ProtoMessage() {} func (*SpecsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{6} + return fileDescriptor_00212fb1f9d3bf1c, []int{6} } + func (m *SpecsRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SpecsRequest.Unmarshal(m, b) } func (m *SpecsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_SpecsRequest.Marshal(b, m, deterministic) } -func (dst *SpecsRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_SpecsRequest.Merge(dst, src) +func (m *SpecsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SpecsRequest.Merge(m, src) } func (m *SpecsRequest) XXX_Size() int { return xxx_messageInfo_SpecsRequest.Size(m) @@ -366,16 +377,17 @@ func (m *SpecsResponse) Reset() { *m = SpecsResponse{} } func (m *SpecsResponse) String() string { return proto.CompactTextString(m) } func (*SpecsResponse) ProtoMessage() {} func (*SpecsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{7} + return fileDescriptor_00212fb1f9d3bf1c, []int{7} } + func (m *SpecsResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SpecsResponse.Unmarshal(m, b) } func (m *SpecsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_SpecsResponse.Marshal(b, m, deterministic) } -func (dst *SpecsResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_SpecsResponse.Merge(dst, src) +func (m *SpecsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SpecsResponse.Merge(m, src) } func (m *SpecsResponse) XXX_Size() int { return xxx_messageInfo_SpecsResponse.Size(m) @@ -407,16 +419,17 @@ func (m *SpecsResponse_SpecDetail) Reset() { *m = SpecsResponse_SpecDeta func (m *SpecsResponse_SpecDetail) String() string { return proto.CompactTextString(m) } func (*SpecsResponse_SpecDetail) ProtoMessage() {} func (*SpecsResponse_SpecDetail) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{7, 0} + return fileDescriptor_00212fb1f9d3bf1c, []int{7, 0} } + func (m *SpecsResponse_SpecDetail) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SpecsResponse_SpecDetail.Unmarshal(m, b) } func (m *SpecsResponse_SpecDetail) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_SpecsResponse_SpecDetail.Marshal(b, m, deterministic) } -func (dst *SpecsResponse_SpecDetail) XXX_Merge(src proto.Message) { - xxx_messageInfo_SpecsResponse_SpecDetail.Merge(dst, src) +func (m *SpecsResponse_SpecDetail) XXX_Merge(src proto.Message) { + xxx_messageInfo_SpecsResponse_SpecDetail.Merge(m, src) } func (m *SpecsResponse_SpecDetail) XXX_Size() int { return xxx_messageInfo_SpecsResponse_SpecDetail.Size(m) @@ -452,16 +465,17 @@ func (m *GetAllConceptsRequest) Reset() { *m = GetAllConceptsRequest{} } func (m *GetAllConceptsRequest) String() string { return proto.CompactTextString(m) } func (*GetAllConceptsRequest) ProtoMessage() {} func (*GetAllConceptsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{8} + return fileDescriptor_00212fb1f9d3bf1c, []int{8} } + func (m *GetAllConceptsRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_GetAllConceptsRequest.Unmarshal(m, b) } func (m *GetAllConceptsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_GetAllConceptsRequest.Marshal(b, m, deterministic) } -func (dst *GetAllConceptsRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetAllConceptsRequest.Merge(dst, src) +func (m *GetAllConceptsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetAllConceptsRequest.Merge(m, src) } func (m *GetAllConceptsRequest) XXX_Size() int { return xxx_messageInfo_GetAllConceptsRequest.Size(m) @@ -485,16 +499,17 @@ func (m *GetAllConceptsResponse) Reset() { *m = GetAllConceptsResponse{} func (m *GetAllConceptsResponse) String() string { return proto.CompactTextString(m) } func (*GetAllConceptsResponse) ProtoMessage() {} func (*GetAllConceptsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{9} + return fileDescriptor_00212fb1f9d3bf1c, []int{9} } + func (m *GetAllConceptsResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_GetAllConceptsResponse.Unmarshal(m, b) } func (m *GetAllConceptsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_GetAllConceptsResponse.Marshal(b, m, deterministic) } -func (dst *GetAllConceptsResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetAllConceptsResponse.Merge(dst, src) +func (m *GetAllConceptsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetAllConceptsResponse.Merge(m, src) } func (m *GetAllConceptsResponse) XXX_Size() int { return xxx_messageInfo_GetAllConceptsResponse.Size(m) @@ -529,16 +544,17 @@ func (m *ConceptInfo) Reset() { *m = ConceptInfo{} } func (m *ConceptInfo) String() string { return proto.CompactTextString(m) } func (*ConceptInfo) ProtoMessage() {} func (*ConceptInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{10} + return fileDescriptor_00212fb1f9d3bf1c, []int{10} } + func (m *ConceptInfo) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ConceptInfo.Unmarshal(m, b) } func (m *ConceptInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ConceptInfo.Marshal(b, m, deterministic) } -func (dst *ConceptInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_ConceptInfo.Merge(dst, src) +func (m *ConceptInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_ConceptInfo.Merge(m, src) } func (m *ConceptInfo) XXX_Size() int { return xxx_messageInfo_ConceptInfo.Size(m) @@ -585,16 +601,17 @@ func (m *GetStepValueRequest) Reset() { *m = GetStepValueRequest{} } func (m *GetStepValueRequest) String() string { return proto.CompactTextString(m) } func (*GetStepValueRequest) ProtoMessage() {} func (*GetStepValueRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{11} + return fileDescriptor_00212fb1f9d3bf1c, []int{11} } + func (m *GetStepValueRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_GetStepValueRequest.Unmarshal(m, b) } func (m *GetStepValueRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_GetStepValueRequest.Marshal(b, m, deterministic) } -func (dst *GetStepValueRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetStepValueRequest.Merge(dst, src) +func (m *GetStepValueRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetStepValueRequest.Merge(m, src) } func (m *GetStepValueRequest) XXX_Size() int { return xxx_messageInfo_GetStepValueRequest.Size(m) @@ -632,16 +649,17 @@ func (m *GetStepValueResponse) Reset() { *m = GetStepValueResponse{} } func (m *GetStepValueResponse) String() string { return proto.CompactTextString(m) } func (*GetStepValueResponse) ProtoMessage() {} func (*GetStepValueResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{12} + return fileDescriptor_00212fb1f9d3bf1c, []int{12} } + func (m *GetStepValueResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_GetStepValueResponse.Unmarshal(m, b) } func (m *GetStepValueResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_GetStepValueResponse.Marshal(b, m, deterministic) } -func (dst *GetStepValueResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetStepValueResponse.Merge(dst, src) +func (m *GetStepValueResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetStepValueResponse.Merge(m, src) } func (m *GetStepValueResponse) XXX_Size() int { return xxx_messageInfo_GetStepValueResponse.Size(m) @@ -672,16 +690,17 @@ func (m *GetLanguagePluginLibPathRequest) Reset() { *m = GetLanguagePlug func (m *GetLanguagePluginLibPathRequest) String() string { return proto.CompactTextString(m) } func (*GetLanguagePluginLibPathRequest) ProtoMessage() {} func (*GetLanguagePluginLibPathRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{13} + return fileDescriptor_00212fb1f9d3bf1c, []int{13} } + func (m *GetLanguagePluginLibPathRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_GetLanguagePluginLibPathRequest.Unmarshal(m, b) } func (m *GetLanguagePluginLibPathRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_GetLanguagePluginLibPathRequest.Marshal(b, m, deterministic) } -func (dst *GetLanguagePluginLibPathRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetLanguagePluginLibPathRequest.Merge(dst, src) +func (m *GetLanguagePluginLibPathRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetLanguagePluginLibPathRequest.Merge(m, src) } func (m *GetLanguagePluginLibPathRequest) XXX_Size() int { return xxx_messageInfo_GetLanguagePluginLibPathRequest.Size(m) @@ -712,16 +731,17 @@ func (m *GetLanguagePluginLibPathResponse) Reset() { *m = GetLanguagePlu func (m *GetLanguagePluginLibPathResponse) String() string { return proto.CompactTextString(m) } func (*GetLanguagePluginLibPathResponse) ProtoMessage() {} func (*GetLanguagePluginLibPathResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{14} + return fileDescriptor_00212fb1f9d3bf1c, []int{14} } + func (m *GetLanguagePluginLibPathResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_GetLanguagePluginLibPathResponse.Unmarshal(m, b) } func (m *GetLanguagePluginLibPathResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_GetLanguagePluginLibPathResponse.Marshal(b, m, deterministic) } -func (dst *GetLanguagePluginLibPathResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetLanguagePluginLibPathResponse.Merge(dst, src) +func (m *GetLanguagePluginLibPathResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetLanguagePluginLibPathResponse.Merge(m, src) } func (m *GetLanguagePluginLibPathResponse) XXX_Size() int { return xxx_messageInfo_GetLanguagePluginLibPathResponse.Size(m) @@ -752,16 +772,17 @@ func (m *ErrorResponse) Reset() { *m = ErrorResponse{} } func (m *ErrorResponse) String() string { return proto.CompactTextString(m) } func (*ErrorResponse) ProtoMessage() {} func (*ErrorResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{15} + return fileDescriptor_00212fb1f9d3bf1c, []int{15} } + func (m *ErrorResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ErrorResponse.Unmarshal(m, b) } func (m *ErrorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ErrorResponse.Marshal(b, m, deterministic) } -func (dst *ErrorResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_ErrorResponse.Merge(dst, src) +func (m *ErrorResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ErrorResponse.Merge(m, src) } func (m *ErrorResponse) XXX_Size() int { return xxx_messageInfo_ErrorResponse.Size(m) @@ -794,16 +815,17 @@ func (m *PerformRefactoringRequest) Reset() { *m = PerformRefactoringReq func (m *PerformRefactoringRequest) String() string { return proto.CompactTextString(m) } func (*PerformRefactoringRequest) ProtoMessage() {} func (*PerformRefactoringRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{16} + return fileDescriptor_00212fb1f9d3bf1c, []int{16} } + func (m *PerformRefactoringRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_PerformRefactoringRequest.Unmarshal(m, b) } func (m *PerformRefactoringRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_PerformRefactoringRequest.Marshal(b, m, deterministic) } -func (dst *PerformRefactoringRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_PerformRefactoringRequest.Merge(dst, src) +func (m *PerformRefactoringRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_PerformRefactoringRequest.Merge(m, src) } func (m *PerformRefactoringRequest) XXX_Size() int { return xxx_messageInfo_PerformRefactoringRequest.Size(m) @@ -845,16 +867,17 @@ func (m *PerformRefactoringResponse) Reset() { *m = PerformRefactoringRe func (m *PerformRefactoringResponse) String() string { return proto.CompactTextString(m) } func (*PerformRefactoringResponse) ProtoMessage() {} func (*PerformRefactoringResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{17} + return fileDescriptor_00212fb1f9d3bf1c, []int{17} } + func (m *PerformRefactoringResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_PerformRefactoringResponse.Unmarshal(m, b) } func (m *PerformRefactoringResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_PerformRefactoringResponse.Marshal(b, m, deterministic) } -func (dst *PerformRefactoringResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_PerformRefactoringResponse.Merge(dst, src) +func (m *PerformRefactoringResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_PerformRefactoringResponse.Merge(m, src) } func (m *PerformRefactoringResponse) XXX_Size() int { return xxx_messageInfo_PerformRefactoringResponse.Size(m) @@ -907,16 +930,17 @@ func (m *ExtractConceptRequest) Reset() { *m = ExtractConceptRequest{} } func (m *ExtractConceptRequest) String() string { return proto.CompactTextString(m) } func (*ExtractConceptRequest) ProtoMessage() {} func (*ExtractConceptRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{18} + return fileDescriptor_00212fb1f9d3bf1c, []int{18} } + func (m *ExtractConceptRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ExtractConceptRequest.Unmarshal(m, b) } func (m *ExtractConceptRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ExtractConceptRequest.Marshal(b, m, deterministic) } -func (dst *ExtractConceptRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_ExtractConceptRequest.Merge(dst, src) +func (m *ExtractConceptRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExtractConceptRequest.Merge(m, src) } func (m *ExtractConceptRequest) XXX_Size() int { return xxx_messageInfo_ExtractConceptRequest.Size(m) @@ -977,16 +1001,17 @@ func (m *TextInfo) Reset() { *m = TextInfo{} } func (m *TextInfo) String() string { return proto.CompactTextString(m) } func (*TextInfo) ProtoMessage() {} func (*TextInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{19} + return fileDescriptor_00212fb1f9d3bf1c, []int{19} } + func (m *TextInfo) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_TextInfo.Unmarshal(m, b) } func (m *TextInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_TextInfo.Marshal(b, m, deterministic) } -func (dst *TextInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_TextInfo.Merge(dst, src) +func (m *TextInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_TextInfo.Merge(m, src) } func (m *TextInfo) XXX_Size() int { return xxx_messageInfo_TextInfo.Size(m) @@ -1034,16 +1059,17 @@ func (m *Step) Reset() { *m = Step{} } func (m *Step) String() string { return proto.CompactTextString(m) } func (*Step) ProtoMessage() {} func (*Step) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{20} + return fileDescriptor_00212fb1f9d3bf1c, []int{20} } + func (m *Step) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Step.Unmarshal(m, b) } func (m *Step) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_Step.Marshal(b, m, deterministic) } -func (dst *Step) XXX_Merge(src proto.Message) { - xxx_messageInfo_Step.Merge(dst, src) +func (m *Step) XXX_Merge(src proto.Message) { + xxx_messageInfo_Step.Merge(m, src) } func (m *Step) XXX_Size() int { return xxx_messageInfo_Step.Size(m) @@ -1092,16 +1118,17 @@ func (m *ExtractConceptResponse) Reset() { *m = ExtractConceptResponse{} func (m *ExtractConceptResponse) String() string { return proto.CompactTextString(m) } func (*ExtractConceptResponse) ProtoMessage() {} func (*ExtractConceptResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{21} + return fileDescriptor_00212fb1f9d3bf1c, []int{21} } + func (m *ExtractConceptResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ExtractConceptResponse.Unmarshal(m, b) } func (m *ExtractConceptResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ExtractConceptResponse.Marshal(b, m, deterministic) } -func (dst *ExtractConceptResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_ExtractConceptResponse.Merge(dst, src) +func (m *ExtractConceptResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExtractConceptResponse.Merge(m, src) } func (m *ExtractConceptResponse) XXX_Size() int { return xxx_messageInfo_ExtractConceptResponse.Size(m) @@ -1146,16 +1173,17 @@ func (m *FormatSpecsRequest) Reset() { *m = FormatSpecsRequest{} } func (m *FormatSpecsRequest) String() string { return proto.CompactTextString(m) } func (*FormatSpecsRequest) ProtoMessage() {} func (*FormatSpecsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{22} + return fileDescriptor_00212fb1f9d3bf1c, []int{22} } + func (m *FormatSpecsRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_FormatSpecsRequest.Unmarshal(m, b) } func (m *FormatSpecsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_FormatSpecsRequest.Marshal(b, m, deterministic) } -func (dst *FormatSpecsRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_FormatSpecsRequest.Merge(dst, src) +func (m *FormatSpecsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_FormatSpecsRequest.Merge(m, src) } func (m *FormatSpecsRequest) XXX_Size() int { return xxx_messageInfo_FormatSpecsRequest.Size(m) @@ -1188,16 +1216,17 @@ func (m *FormatSpecsResponse) Reset() { *m = FormatSpecsResponse{} } func (m *FormatSpecsResponse) String() string { return proto.CompactTextString(m) } func (*FormatSpecsResponse) ProtoMessage() {} func (*FormatSpecsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{23} + return fileDescriptor_00212fb1f9d3bf1c, []int{23} } + func (m *FormatSpecsResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_FormatSpecsResponse.Unmarshal(m, b) } func (m *FormatSpecsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_FormatSpecsResponse.Marshal(b, m, deterministic) } -func (dst *FormatSpecsResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_FormatSpecsResponse.Merge(dst, src) +func (m *FormatSpecsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_FormatSpecsResponse.Merge(m, src) } func (m *FormatSpecsResponse) XXX_Size() int { return xxx_messageInfo_FormatSpecsResponse.Size(m) @@ -1233,16 +1262,17 @@ func (m *UnsupportedApiMessageResponse) Reset() { *m = UnsupportedApiMes func (m *UnsupportedApiMessageResponse) String() string { return proto.CompactTextString(m) } func (*UnsupportedApiMessageResponse) ProtoMessage() {} func (*UnsupportedApiMessageResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{24} + return fileDescriptor_00212fb1f9d3bf1c, []int{24} } + func (m *UnsupportedApiMessageResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_UnsupportedApiMessageResponse.Unmarshal(m, b) } func (m *UnsupportedApiMessageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_UnsupportedApiMessageResponse.Marshal(b, m, deterministic) } -func (dst *UnsupportedApiMessageResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_UnsupportedApiMessageResponse.Merge(dst, src) +func (m *UnsupportedApiMessageResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_UnsupportedApiMessageResponse.Merge(m, src) } func (m *UnsupportedApiMessageResponse) XXX_Size() int { return xxx_messageInfo_UnsupportedApiMessageResponse.Size(m) @@ -1314,16 +1344,17 @@ func (m *APIMessage) Reset() { *m = APIMessage{} } func (m *APIMessage) String() string { return proto.CompactTextString(m) } func (*APIMessage) ProtoMessage() {} func (*APIMessage) Descriptor() ([]byte, []int) { - return fileDescriptor_api_61c330053bee9dde, []int{25} + return fileDescriptor_00212fb1f9d3bf1c, []int{25} } + func (m *APIMessage) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_APIMessage.Unmarshal(m, b) } func (m *APIMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_APIMessage.Marshal(b, m, deterministic) } -func (dst *APIMessage) XXX_Merge(src proto.Message) { - xxx_messageInfo_APIMessage.Merge(dst, src) +func (m *APIMessage) XXX_Merge(src proto.Message) { + xxx_messageInfo_APIMessage.Merge(m, src) } func (m *APIMessage) XXX_Size() int { return xxx_messageInfo_APIMessage.Size(m) @@ -1503,6 +1534,7 @@ func (m *APIMessage) GetUnsupportedApiMessageResponse() *UnsupportedApiMessageRe } func init() { + proto.RegisterEnum("gauge.messages.APIMessage_APIMessageType", APIMessage_APIMessageType_name, APIMessage_APIMessageType_value) proto.RegisterType((*GetProjectRootRequest)(nil), "gauge.messages.GetProjectRootRequest") proto.RegisterType((*GetProjectRootResponse)(nil), "gauge.messages.GetProjectRootResponse") proto.RegisterType((*GetInstallationRootRequest)(nil), "gauge.messages.GetInstallationRootRequest") @@ -1530,12 +1562,11 @@ func init() { proto.RegisterType((*FormatSpecsResponse)(nil), "gauge.messages.FormatSpecsResponse") proto.RegisterType((*UnsupportedApiMessageResponse)(nil), "gauge.messages.UnsupportedApiMessageResponse") proto.RegisterType((*APIMessage)(nil), "gauge.messages.APIMessage") - proto.RegisterEnum("gauge.messages.APIMessage_APIMessageType", APIMessage_APIMessageType_name, APIMessage_APIMessageType_value) } -func init() { proto.RegisterFile("api.proto", fileDescriptor_api_61c330053bee9dde) } +func init() { proto.RegisterFile("api.proto", fileDescriptor_00212fb1f9d3bf1c) } -var fileDescriptor_api_61c330053bee9dde = []byte{ +var fileDescriptor_00212fb1f9d3bf1c = []byte{ // 1444 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x58, 0xdd, 0x6e, 0xdc, 0xb6, 0x12, 0x3e, 0xeb, 0xdf, 0xdd, 0x59, 0x7b, 0x2d, 0x8f, 0xed, 0x35, 0xbd, 0xb1, 0x13, 0x1f, 0xe5, diff --git a/gauge_messages/lsp.pb.go b/gauge_messages/lsp.pb.go index 4791c4b02..40c549c06 100644 --- a/gauge_messages/lsp.pb.go +++ b/gauge_messages/lsp.pb.go @@ -3,9 +3,11 @@ package gauge_messages -import proto "github.com/golang/protobuf/proto" -import fmt "fmt" -import math "math" +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + math "math" +) import ( context "golang.org/x/net/context" @@ -34,16 +36,17 @@ func (m *Empty) Reset() { *m = Empty{} } func (m *Empty) String() string { return proto.CompactTextString(m) } func (*Empty) ProtoMessage() {} func (*Empty) Descriptor() ([]byte, []int) { - return fileDescriptor_lsp_d53682f2da872e6a, []int{0} + return fileDescriptor_ba9c4f454d309be8, []int{0} } + func (m *Empty) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Empty.Unmarshal(m, b) } func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_Empty.Marshal(b, m, deterministic) } -func (dst *Empty) XXX_Merge(src proto.Message) { - xxx_messageInfo_Empty.Merge(dst, src) +func (m *Empty) XXX_Merge(src proto.Message) { + xxx_messageInfo_Empty.Merge(m, src) } func (m *Empty) XXX_Size() int { return xxx_messageInfo_Empty.Size(m) @@ -427,9 +430,9 @@ var _LspService_serviceDesc = grpc.ServiceDesc{ Metadata: "lsp.proto", } -func init() { proto.RegisterFile("lsp.proto", fileDescriptor_lsp_d53682f2da872e6a) } +func init() { proto.RegisterFile("lsp.proto", fileDescriptor_ba9c4f454d309be8) } -var fileDescriptor_lsp_d53682f2da872e6a = []byte{ +var fileDescriptor_ba9c4f454d309be8 = []byte{ // 380 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x93, 0xcd, 0x6e, 0xda, 0x40, 0x14, 0x85, 0xa5, 0x4a, 0xa5, 0x65, 0xa0, 0xb4, 0x1a, 0xa9, 0xa8, 0x62, 0x53, 0x4a, 0xe9, 0xa2, diff --git a/gauge_messages/messages.pb.go b/gauge_messages/messages.pb.go index 12f07ab7a..237f7f189 100644 --- a/gauge_messages/messages.pb.go +++ b/gauge_messages/messages.pb.go @@ -3,9 +3,11 @@ package gauge_messages -import proto "github.com/golang/protobuf/proto" -import fmt "fmt" -import math "math" +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + math "math" +) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal @@ -29,6 +31,7 @@ var StepValidateResponse_ErrorType_name = map[int32]string{ 0: "STEP_IMPLEMENTATION_NOT_FOUND", 1: "DUPLICATE_STEP_IMPLEMENTATION", } + var StepValidateResponse_ErrorType_value = map[string]int32{ "STEP_IMPLEMENTATION_NOT_FOUND": 0, "DUPLICATE_STEP_IMPLEMENTATION": 1, @@ -37,8 +40,9 @@ var StepValidateResponse_ErrorType_value = map[string]int32{ func (x StepValidateResponse_ErrorType) String() string { return proto.EnumName(StepValidateResponse_ErrorType_name, int32(x)) } + func (StepValidateResponse_ErrorType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{16, 0} + return fileDescriptor_4dc296cbfe5ffcd5, []int{16, 0} } type CacheFileRequest_FileStatus int32 @@ -63,6 +67,7 @@ var CacheFileRequest_FileStatus_name = map[int32]string{ 3: "DELETED", 4: "OPENED", } + var CacheFileRequest_FileStatus_value = map[string]int32{ "CHANGED": 0, "CLOSED": 1, @@ -74,8 +79,9 @@ var CacheFileRequest_FileStatus_value = map[string]int32{ func (x CacheFileRequest_FileStatus) String() string { return proto.EnumName(CacheFileRequest_FileStatus_name, int32(x)) } + func (CacheFileRequest_FileStatus) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{30, 0} + return fileDescriptor_4dc296cbfe5ffcd5, []int{30, 0} } type Message_MessageType int32 @@ -151,6 +157,7 @@ var Message_MessageType_name = map[int32]string{ 31: "ImplementationFileGlobPatternRequest", 32: "ImplementationFileGlobPatternResponse", } + var Message_MessageType_value = map[string]int32{ "ExecutionStarting": 0, "SpecExecutionStarting": 1, @@ -190,8 +197,9 @@ var Message_MessageType_value = map[string]int32{ func (x Message_MessageType) String() string { return proto.EnumName(Message_MessageType_name, int32(x)) } + func (Message_MessageType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{40, 0} + return fileDescriptor_4dc296cbfe5ffcd5, []int{40, 0} } // / Default request. Tells the runner to shutdown. @@ -205,16 +213,17 @@ func (m *KillProcessRequest) Reset() { *m = KillProcessRequest{} } func (m *KillProcessRequest) String() string { return proto.CompactTextString(m) } func (*KillProcessRequest) ProtoMessage() {} func (*KillProcessRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{0} + return fileDescriptor_4dc296cbfe5ffcd5, []int{0} } + func (m *KillProcessRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_KillProcessRequest.Unmarshal(m, b) } func (m *KillProcessRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_KillProcessRequest.Marshal(b, m, deterministic) } -func (dst *KillProcessRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_KillProcessRequest.Merge(dst, src) +func (m *KillProcessRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_KillProcessRequest.Merge(m, src) } func (m *KillProcessRequest) XXX_Size() int { return xxx_messageInfo_KillProcessRequest.Size(m) @@ -238,16 +247,17 @@ func (m *ExecutionStatusResponse) Reset() { *m = ExecutionStatusResponse func (m *ExecutionStatusResponse) String() string { return proto.CompactTextString(m) } func (*ExecutionStatusResponse) ProtoMessage() {} func (*ExecutionStatusResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{1} + return fileDescriptor_4dc296cbfe5ffcd5, []int{1} } + func (m *ExecutionStatusResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ExecutionStatusResponse.Unmarshal(m, b) } func (m *ExecutionStatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ExecutionStatusResponse.Marshal(b, m, deterministic) } -func (dst *ExecutionStatusResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_ExecutionStatusResponse.Merge(dst, src) +func (m *ExecutionStatusResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExecutionStatusResponse.Merge(m, src) } func (m *ExecutionStatusResponse) XXX_Size() int { return xxx_messageInfo_ExecutionStatusResponse.Size(m) @@ -277,16 +287,17 @@ func (m *ExecutionStartingRequest) Reset() { *m = ExecutionStartingReque func (m *ExecutionStartingRequest) String() string { return proto.CompactTextString(m) } func (*ExecutionStartingRequest) ProtoMessage() {} func (*ExecutionStartingRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{2} + return fileDescriptor_4dc296cbfe5ffcd5, []int{2} } + func (m *ExecutionStartingRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ExecutionStartingRequest.Unmarshal(m, b) } func (m *ExecutionStartingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ExecutionStartingRequest.Marshal(b, m, deterministic) } -func (dst *ExecutionStartingRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_ExecutionStartingRequest.Merge(dst, src) +func (m *ExecutionStartingRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExecutionStartingRequest.Merge(m, src) } func (m *ExecutionStartingRequest) XXX_Size() int { return xxx_messageInfo_ExecutionStartingRequest.Size(m) @@ -316,16 +327,17 @@ func (m *ExecutionEndingRequest) Reset() { *m = ExecutionEndingRequest{} func (m *ExecutionEndingRequest) String() string { return proto.CompactTextString(m) } func (*ExecutionEndingRequest) ProtoMessage() {} func (*ExecutionEndingRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{3} + return fileDescriptor_4dc296cbfe5ffcd5, []int{3} } + func (m *ExecutionEndingRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ExecutionEndingRequest.Unmarshal(m, b) } func (m *ExecutionEndingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ExecutionEndingRequest.Marshal(b, m, deterministic) } -func (dst *ExecutionEndingRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_ExecutionEndingRequest.Merge(dst, src) +func (m *ExecutionEndingRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExecutionEndingRequest.Merge(m, src) } func (m *ExecutionEndingRequest) XXX_Size() int { return xxx_messageInfo_ExecutionEndingRequest.Size(m) @@ -355,16 +367,17 @@ func (m *SpecExecutionStartingRequest) Reset() { *m = SpecExecutionStart func (m *SpecExecutionStartingRequest) String() string { return proto.CompactTextString(m) } func (*SpecExecutionStartingRequest) ProtoMessage() {} func (*SpecExecutionStartingRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{4} + return fileDescriptor_4dc296cbfe5ffcd5, []int{4} } + func (m *SpecExecutionStartingRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SpecExecutionStartingRequest.Unmarshal(m, b) } func (m *SpecExecutionStartingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_SpecExecutionStartingRequest.Marshal(b, m, deterministic) } -func (dst *SpecExecutionStartingRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_SpecExecutionStartingRequest.Merge(dst, src) +func (m *SpecExecutionStartingRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SpecExecutionStartingRequest.Merge(m, src) } func (m *SpecExecutionStartingRequest) XXX_Size() int { return xxx_messageInfo_SpecExecutionStartingRequest.Size(m) @@ -394,16 +407,17 @@ func (m *SpecExecutionEndingRequest) Reset() { *m = SpecExecutionEndingR func (m *SpecExecutionEndingRequest) String() string { return proto.CompactTextString(m) } func (*SpecExecutionEndingRequest) ProtoMessage() {} func (*SpecExecutionEndingRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{5} + return fileDescriptor_4dc296cbfe5ffcd5, []int{5} } + func (m *SpecExecutionEndingRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SpecExecutionEndingRequest.Unmarshal(m, b) } func (m *SpecExecutionEndingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_SpecExecutionEndingRequest.Marshal(b, m, deterministic) } -func (dst *SpecExecutionEndingRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_SpecExecutionEndingRequest.Merge(dst, src) +func (m *SpecExecutionEndingRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SpecExecutionEndingRequest.Merge(m, src) } func (m *SpecExecutionEndingRequest) XXX_Size() int { return xxx_messageInfo_SpecExecutionEndingRequest.Size(m) @@ -433,16 +447,17 @@ func (m *ScenarioExecutionStartingRequest) Reset() { *m = ScenarioExecut func (m *ScenarioExecutionStartingRequest) String() string { return proto.CompactTextString(m) } func (*ScenarioExecutionStartingRequest) ProtoMessage() {} func (*ScenarioExecutionStartingRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{6} + return fileDescriptor_4dc296cbfe5ffcd5, []int{6} } + func (m *ScenarioExecutionStartingRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ScenarioExecutionStartingRequest.Unmarshal(m, b) } func (m *ScenarioExecutionStartingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ScenarioExecutionStartingRequest.Marshal(b, m, deterministic) } -func (dst *ScenarioExecutionStartingRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_ScenarioExecutionStartingRequest.Merge(dst, src) +func (m *ScenarioExecutionStartingRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ScenarioExecutionStartingRequest.Merge(m, src) } func (m *ScenarioExecutionStartingRequest) XXX_Size() int { return xxx_messageInfo_ScenarioExecutionStartingRequest.Size(m) @@ -472,16 +487,17 @@ func (m *ScenarioExecutionEndingRequest) Reset() { *m = ScenarioExecutio func (m *ScenarioExecutionEndingRequest) String() string { return proto.CompactTextString(m) } func (*ScenarioExecutionEndingRequest) ProtoMessage() {} func (*ScenarioExecutionEndingRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{7} + return fileDescriptor_4dc296cbfe5ffcd5, []int{7} } + func (m *ScenarioExecutionEndingRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ScenarioExecutionEndingRequest.Unmarshal(m, b) } func (m *ScenarioExecutionEndingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ScenarioExecutionEndingRequest.Marshal(b, m, deterministic) } -func (dst *ScenarioExecutionEndingRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_ScenarioExecutionEndingRequest.Merge(dst, src) +func (m *ScenarioExecutionEndingRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ScenarioExecutionEndingRequest.Merge(m, src) } func (m *ScenarioExecutionEndingRequest) XXX_Size() int { return xxx_messageInfo_ScenarioExecutionEndingRequest.Size(m) @@ -511,16 +527,17 @@ func (m *StepExecutionStartingRequest) Reset() { *m = StepExecutionStart func (m *StepExecutionStartingRequest) String() string { return proto.CompactTextString(m) } func (*StepExecutionStartingRequest) ProtoMessage() {} func (*StepExecutionStartingRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{8} + return fileDescriptor_4dc296cbfe5ffcd5, []int{8} } + func (m *StepExecutionStartingRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_StepExecutionStartingRequest.Unmarshal(m, b) } func (m *StepExecutionStartingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_StepExecutionStartingRequest.Marshal(b, m, deterministic) } -func (dst *StepExecutionStartingRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_StepExecutionStartingRequest.Merge(dst, src) +func (m *StepExecutionStartingRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_StepExecutionStartingRequest.Merge(m, src) } func (m *StepExecutionStartingRequest) XXX_Size() int { return xxx_messageInfo_StepExecutionStartingRequest.Size(m) @@ -550,16 +567,17 @@ func (m *StepExecutionEndingRequest) Reset() { *m = StepExecutionEndingR func (m *StepExecutionEndingRequest) String() string { return proto.CompactTextString(m) } func (*StepExecutionEndingRequest) ProtoMessage() {} func (*StepExecutionEndingRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{9} + return fileDescriptor_4dc296cbfe5ffcd5, []int{9} } + func (m *StepExecutionEndingRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_StepExecutionEndingRequest.Unmarshal(m, b) } func (m *StepExecutionEndingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_StepExecutionEndingRequest.Marshal(b, m, deterministic) } -func (dst *StepExecutionEndingRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_StepExecutionEndingRequest.Merge(dst, src) +func (m *StepExecutionEndingRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_StepExecutionEndingRequest.Merge(m, src) } func (m *StepExecutionEndingRequest) XXX_Size() int { return xxx_messageInfo_StepExecutionEndingRequest.Size(m) @@ -597,16 +615,17 @@ func (m *ExecutionInfo) Reset() { *m = ExecutionInfo{} } func (m *ExecutionInfo) String() string { return proto.CompactTextString(m) } func (*ExecutionInfo) ProtoMessage() {} func (*ExecutionInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{10} + return fileDescriptor_4dc296cbfe5ffcd5, []int{10} } + func (m *ExecutionInfo) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ExecutionInfo.Unmarshal(m, b) } func (m *ExecutionInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ExecutionInfo.Marshal(b, m, deterministic) } -func (dst *ExecutionInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_ExecutionInfo.Merge(dst, src) +func (m *ExecutionInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExecutionInfo.Merge(m, src) } func (m *ExecutionInfo) XXX_Size() int { return xxx_messageInfo_ExecutionInfo.Size(m) @@ -664,16 +683,17 @@ func (m *SpecInfo) Reset() { *m = SpecInfo{} } func (m *SpecInfo) String() string { return proto.CompactTextString(m) } func (*SpecInfo) ProtoMessage() {} func (*SpecInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{11} + return fileDescriptor_4dc296cbfe5ffcd5, []int{11} } + func (m *SpecInfo) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SpecInfo.Unmarshal(m, b) } func (m *SpecInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_SpecInfo.Marshal(b, m, deterministic) } -func (dst *SpecInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_SpecInfo.Merge(dst, src) +func (m *SpecInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_SpecInfo.Merge(m, src) } func (m *SpecInfo) XXX_Size() int { return xxx_messageInfo_SpecInfo.Size(m) @@ -729,16 +749,17 @@ func (m *ScenarioInfo) Reset() { *m = ScenarioInfo{} } func (m *ScenarioInfo) String() string { return proto.CompactTextString(m) } func (*ScenarioInfo) ProtoMessage() {} func (*ScenarioInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{12} + return fileDescriptor_4dc296cbfe5ffcd5, []int{12} } + func (m *ScenarioInfo) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ScenarioInfo.Unmarshal(m, b) } func (m *ScenarioInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ScenarioInfo.Marshal(b, m, deterministic) } -func (dst *ScenarioInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_ScenarioInfo.Merge(dst, src) +func (m *ScenarioInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_ScenarioInfo.Merge(m, src) } func (m *ScenarioInfo) XXX_Size() int { return xxx_messageInfo_ScenarioInfo.Size(m) @@ -789,16 +810,17 @@ func (m *StepInfo) Reset() { *m = StepInfo{} } func (m *StepInfo) String() string { return proto.CompactTextString(m) } func (*StepInfo) ProtoMessage() {} func (*StepInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{13} + return fileDescriptor_4dc296cbfe5ffcd5, []int{13} } + func (m *StepInfo) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_StepInfo.Unmarshal(m, b) } func (m *StepInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_StepInfo.Marshal(b, m, deterministic) } -func (dst *StepInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_StepInfo.Merge(dst, src) +func (m *StepInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_StepInfo.Merge(m, src) } func (m *StepInfo) XXX_Size() int { return xxx_messageInfo_StepInfo.Size(m) @@ -858,16 +880,17 @@ func (m *ExecuteStepRequest) Reset() { *m = ExecuteStepRequest{} } func (m *ExecuteStepRequest) String() string { return proto.CompactTextString(m) } func (*ExecuteStepRequest) ProtoMessage() {} func (*ExecuteStepRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{14} + return fileDescriptor_4dc296cbfe5ffcd5, []int{14} } + func (m *ExecuteStepRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ExecuteStepRequest.Unmarshal(m, b) } func (m *ExecuteStepRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ExecuteStepRequest.Marshal(b, m, deterministic) } -func (dst *ExecuteStepRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_ExecuteStepRequest.Merge(dst, src) +func (m *ExecuteStepRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExecuteStepRequest.Merge(m, src) } func (m *ExecuteStepRequest) XXX_Size() int { return xxx_messageInfo_ExecuteStepRequest.Size(m) @@ -924,16 +947,17 @@ func (m *StepValidateRequest) Reset() { *m = StepValidateRequest{} } func (m *StepValidateRequest) String() string { return proto.CompactTextString(m) } func (*StepValidateRequest) ProtoMessage() {} func (*StepValidateRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{15} + return fileDescriptor_4dc296cbfe5ffcd5, []int{15} } + func (m *StepValidateRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_StepValidateRequest.Unmarshal(m, b) } func (m *StepValidateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_StepValidateRequest.Marshal(b, m, deterministic) } -func (dst *StepValidateRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_StepValidateRequest.Merge(dst, src) +func (m *StepValidateRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_StepValidateRequest.Merge(m, src) } func (m *StepValidateRequest) XXX_Size() int { return xxx_messageInfo_StepValidateRequest.Size(m) @@ -983,16 +1007,17 @@ func (m *StepValidateResponse) Reset() { *m = StepValidateResponse{} } func (m *StepValidateResponse) String() string { return proto.CompactTextString(m) } func (*StepValidateResponse) ProtoMessage() {} func (*StepValidateResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{16} + return fileDescriptor_4dc296cbfe5ffcd5, []int{16} } + func (m *StepValidateResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_StepValidateResponse.Unmarshal(m, b) } func (m *StepValidateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_StepValidateResponse.Marshal(b, m, deterministic) } -func (dst *StepValidateResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_StepValidateResponse.Merge(dst, src) +func (m *StepValidateResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_StepValidateResponse.Merge(m, src) } func (m *StepValidateResponse) XXX_Size() int { return xxx_messageInfo_StepValidateResponse.Size(m) @@ -1043,16 +1068,17 @@ func (m *SuiteExecutionResult) Reset() { *m = SuiteExecutionResult{} } func (m *SuiteExecutionResult) String() string { return proto.CompactTextString(m) } func (*SuiteExecutionResult) ProtoMessage() {} func (*SuiteExecutionResult) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{17} + return fileDescriptor_4dc296cbfe5ffcd5, []int{17} } + func (m *SuiteExecutionResult) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SuiteExecutionResult.Unmarshal(m, b) } func (m *SuiteExecutionResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_SuiteExecutionResult.Marshal(b, m, deterministic) } -func (dst *SuiteExecutionResult) XXX_Merge(src proto.Message) { - xxx_messageInfo_SuiteExecutionResult.Merge(dst, src) +func (m *SuiteExecutionResult) XXX_Merge(src proto.Message) { + xxx_messageInfo_SuiteExecutionResult.Merge(m, src) } func (m *SuiteExecutionResult) XXX_Size() int { return xxx_messageInfo_SuiteExecutionResult.Size(m) @@ -1081,16 +1107,17 @@ func (m *StepNamesRequest) Reset() { *m = StepNamesRequest{} } func (m *StepNamesRequest) String() string { return proto.CompactTextString(m) } func (*StepNamesRequest) ProtoMessage() {} func (*StepNamesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{18} + return fileDescriptor_4dc296cbfe5ffcd5, []int{18} } + func (m *StepNamesRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_StepNamesRequest.Unmarshal(m, b) } func (m *StepNamesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_StepNamesRequest.Marshal(b, m, deterministic) } -func (dst *StepNamesRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_StepNamesRequest.Merge(dst, src) +func (m *StepNamesRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_StepNamesRequest.Merge(m, src) } func (m *StepNamesRequest) XXX_Size() int { return xxx_messageInfo_StepNamesRequest.Size(m) @@ -1114,16 +1141,17 @@ func (m *StepNamesResponse) Reset() { *m = StepNamesResponse{} } func (m *StepNamesResponse) String() string { return proto.CompactTextString(m) } func (*StepNamesResponse) ProtoMessage() {} func (*StepNamesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{19} + return fileDescriptor_4dc296cbfe5ffcd5, []int{19} } + func (m *StepNamesResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_StepNamesResponse.Unmarshal(m, b) } func (m *StepNamesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_StepNamesResponse.Marshal(b, m, deterministic) } -func (dst *StepNamesResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_StepNamesResponse.Merge(dst, src) +func (m *StepNamesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_StepNamesResponse.Merge(m, src) } func (m *StepNamesResponse) XXX_Size() int { return xxx_messageInfo_StepNamesResponse.Size(m) @@ -1153,16 +1181,17 @@ func (m *ScenarioDataStoreInitRequest) Reset() { *m = ScenarioDataStoreI func (m *ScenarioDataStoreInitRequest) String() string { return proto.CompactTextString(m) } func (*ScenarioDataStoreInitRequest) ProtoMessage() {} func (*ScenarioDataStoreInitRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{20} + return fileDescriptor_4dc296cbfe5ffcd5, []int{20} } + func (m *ScenarioDataStoreInitRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ScenarioDataStoreInitRequest.Unmarshal(m, b) } func (m *ScenarioDataStoreInitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ScenarioDataStoreInitRequest.Marshal(b, m, deterministic) } -func (dst *ScenarioDataStoreInitRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_ScenarioDataStoreInitRequest.Merge(dst, src) +func (m *ScenarioDataStoreInitRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ScenarioDataStoreInitRequest.Merge(m, src) } func (m *ScenarioDataStoreInitRequest) XXX_Size() int { return xxx_messageInfo_ScenarioDataStoreInitRequest.Size(m) @@ -1185,16 +1214,17 @@ func (m *SpecDataStoreInitRequest) Reset() { *m = SpecDataStoreInitReque func (m *SpecDataStoreInitRequest) String() string { return proto.CompactTextString(m) } func (*SpecDataStoreInitRequest) ProtoMessage() {} func (*SpecDataStoreInitRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{21} + return fileDescriptor_4dc296cbfe5ffcd5, []int{21} } + func (m *SpecDataStoreInitRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SpecDataStoreInitRequest.Unmarshal(m, b) } func (m *SpecDataStoreInitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_SpecDataStoreInitRequest.Marshal(b, m, deterministic) } -func (dst *SpecDataStoreInitRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_SpecDataStoreInitRequest.Merge(dst, src) +func (m *SpecDataStoreInitRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SpecDataStoreInitRequest.Merge(m, src) } func (m *SpecDataStoreInitRequest) XXX_Size() int { return xxx_messageInfo_SpecDataStoreInitRequest.Size(m) @@ -1217,16 +1247,17 @@ func (m *SuiteDataStoreInitRequest) Reset() { *m = SuiteDataStoreInitReq func (m *SuiteDataStoreInitRequest) String() string { return proto.CompactTextString(m) } func (*SuiteDataStoreInitRequest) ProtoMessage() {} func (*SuiteDataStoreInitRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{22} + return fileDescriptor_4dc296cbfe5ffcd5, []int{22} } + func (m *SuiteDataStoreInitRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SuiteDataStoreInitRequest.Unmarshal(m, b) } func (m *SuiteDataStoreInitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_SuiteDataStoreInitRequest.Marshal(b, m, deterministic) } -func (dst *SuiteDataStoreInitRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_SuiteDataStoreInitRequest.Merge(dst, src) +func (m *SuiteDataStoreInitRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SuiteDataStoreInitRequest.Merge(m, src) } func (m *SuiteDataStoreInitRequest) XXX_Size() int { return xxx_messageInfo_SuiteDataStoreInitRequest.Size(m) @@ -1251,16 +1282,17 @@ func (m *ParameterPosition) Reset() { *m = ParameterPosition{} } func (m *ParameterPosition) String() string { return proto.CompactTextString(m) } func (*ParameterPosition) ProtoMessage() {} func (*ParameterPosition) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{23} + return fileDescriptor_4dc296cbfe5ffcd5, []int{23} } + func (m *ParameterPosition) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ParameterPosition.Unmarshal(m, b) } func (m *ParameterPosition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ParameterPosition.Marshal(b, m, deterministic) } -func (dst *ParameterPosition) XXX_Merge(src proto.Message) { - xxx_messageInfo_ParameterPosition.Merge(dst, src) +func (m *ParameterPosition) XXX_Merge(src proto.Message) { + xxx_messageInfo_ParameterPosition.Merge(m, src) } func (m *ParameterPosition) XXX_Size() int { return xxx_messageInfo_ParameterPosition.Size(m) @@ -1304,16 +1336,17 @@ func (m *RefactorRequest) Reset() { *m = RefactorRequest{} } func (m *RefactorRequest) String() string { return proto.CompactTextString(m) } func (*RefactorRequest) ProtoMessage() {} func (*RefactorRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{24} + return fileDescriptor_4dc296cbfe5ffcd5, []int{24} } + func (m *RefactorRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_RefactorRequest.Unmarshal(m, b) } func (m *RefactorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_RefactorRequest.Marshal(b, m, deterministic) } -func (dst *RefactorRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_RefactorRequest.Merge(dst, src) +func (m *RefactorRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_RefactorRequest.Merge(m, src) } func (m *RefactorRequest) XXX_Size() int { return xxx_messageInfo_RefactorRequest.Size(m) @@ -1366,16 +1399,17 @@ func (m *FileChanges) Reset() { *m = FileChanges{} } func (m *FileChanges) String() string { return proto.CompactTextString(m) } func (*FileChanges) ProtoMessage() {} func (*FileChanges) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{25} + return fileDescriptor_4dc296cbfe5ffcd5, []int{25} } + func (m *FileChanges) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_FileChanges.Unmarshal(m, b) } func (m *FileChanges) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_FileChanges.Marshal(b, m, deterministic) } -func (dst *FileChanges) XXX_Merge(src proto.Message) { - xxx_messageInfo_FileChanges.Merge(dst, src) +func (m *FileChanges) XXX_Merge(src proto.Message) { + xxx_messageInfo_FileChanges.Merge(m, src) } func (m *FileChanges) XXX_Size() int { return xxx_messageInfo_FileChanges.Size(m) @@ -1427,16 +1461,17 @@ func (m *RefactorResponse) Reset() { *m = RefactorResponse{} } func (m *RefactorResponse) String() string { return proto.CompactTextString(m) } func (*RefactorResponse) ProtoMessage() {} func (*RefactorResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{26} + return fileDescriptor_4dc296cbfe5ffcd5, []int{26} } + func (m *RefactorResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_RefactorResponse.Unmarshal(m, b) } func (m *RefactorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_RefactorResponse.Marshal(b, m, deterministic) } -func (dst *RefactorResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_RefactorResponse.Merge(dst, src) +func (m *RefactorResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RefactorResponse.Merge(m, src) } func (m *RefactorResponse) XXX_Size() int { return xxx_messageInfo_RefactorResponse.Size(m) @@ -1489,16 +1524,17 @@ func (m *StepNameRequest) Reset() { *m = StepNameRequest{} } func (m *StepNameRequest) String() string { return proto.CompactTextString(m) } func (*StepNameRequest) ProtoMessage() {} func (*StepNameRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{27} + return fileDescriptor_4dc296cbfe5ffcd5, []int{27} } + func (m *StepNameRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_StepNameRequest.Unmarshal(m, b) } func (m *StepNameRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_StepNameRequest.Marshal(b, m, deterministic) } -func (dst *StepNameRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_StepNameRequest.Merge(dst, src) +func (m *StepNameRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_StepNameRequest.Merge(m, src) } func (m *StepNameRequest) XXX_Size() int { return xxx_messageInfo_StepNameRequest.Size(m) @@ -1537,16 +1573,17 @@ func (m *StepNameResponse) Reset() { *m = StepNameResponse{} } func (m *StepNameResponse) String() string { return proto.CompactTextString(m) } func (*StepNameResponse) ProtoMessage() {} func (*StepNameResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{28} + return fileDescriptor_4dc296cbfe5ffcd5, []int{28} } + func (m *StepNameResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_StepNameResponse.Unmarshal(m, b) } func (m *StepNameResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_StepNameResponse.Marshal(b, m, deterministic) } -func (dst *StepNameResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_StepNameResponse.Merge(dst, src) +func (m *StepNameResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_StepNameResponse.Merge(m, src) } func (m *StepNameResponse) XXX_Size() int { return xxx_messageInfo_StepNameResponse.Size(m) @@ -1604,16 +1641,17 @@ func (m *UnsupportedMessageResponse) Reset() { *m = UnsupportedMessageRe func (m *UnsupportedMessageResponse) String() string { return proto.CompactTextString(m) } func (*UnsupportedMessageResponse) ProtoMessage() {} func (*UnsupportedMessageResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{29} + return fileDescriptor_4dc296cbfe5ffcd5, []int{29} } + func (m *UnsupportedMessageResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_UnsupportedMessageResponse.Unmarshal(m, b) } func (m *UnsupportedMessageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_UnsupportedMessageResponse.Marshal(b, m, deterministic) } -func (dst *UnsupportedMessageResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_UnsupportedMessageResponse.Merge(dst, src) +func (m *UnsupportedMessageResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_UnsupportedMessageResponse.Merge(m, src) } func (m *UnsupportedMessageResponse) XXX_Size() int { return xxx_messageInfo_UnsupportedMessageResponse.Size(m) @@ -1652,16 +1690,17 @@ func (m *CacheFileRequest) Reset() { *m = CacheFileRequest{} } func (m *CacheFileRequest) String() string { return proto.CompactTextString(m) } func (*CacheFileRequest) ProtoMessage() {} func (*CacheFileRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{30} + return fileDescriptor_4dc296cbfe5ffcd5, []int{30} } + func (m *CacheFileRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_CacheFileRequest.Unmarshal(m, b) } func (m *CacheFileRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_CacheFileRequest.Marshal(b, m, deterministic) } -func (dst *CacheFileRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_CacheFileRequest.Merge(dst, src) +func (m *CacheFileRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_CacheFileRequest.Merge(m, src) } func (m *CacheFileRequest) XXX_Size() int { return xxx_messageInfo_CacheFileRequest.Size(m) @@ -1713,16 +1752,17 @@ func (m *StepPositionsRequest) Reset() { *m = StepPositionsRequest{} } func (m *StepPositionsRequest) String() string { return proto.CompactTextString(m) } func (*StepPositionsRequest) ProtoMessage() {} func (*StepPositionsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{31} + return fileDescriptor_4dc296cbfe5ffcd5, []int{31} } + func (m *StepPositionsRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_StepPositionsRequest.Unmarshal(m, b) } func (m *StepPositionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_StepPositionsRequest.Marshal(b, m, deterministic) } -func (dst *StepPositionsRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_StepPositionsRequest.Merge(dst, src) +func (m *StepPositionsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_StepPositionsRequest.Merge(m, src) } func (m *StepPositionsRequest) XXX_Size() int { return xxx_messageInfo_StepPositionsRequest.Size(m) @@ -1755,16 +1795,17 @@ func (m *StepPositionsResponse) Reset() { *m = StepPositionsResponse{} } func (m *StepPositionsResponse) String() string { return proto.CompactTextString(m) } func (*StepPositionsResponse) ProtoMessage() {} func (*StepPositionsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{32} + return fileDescriptor_4dc296cbfe5ffcd5, []int{32} } + func (m *StepPositionsResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_StepPositionsResponse.Unmarshal(m, b) } func (m *StepPositionsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_StepPositionsResponse.Marshal(b, m, deterministic) } -func (dst *StepPositionsResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_StepPositionsResponse.Merge(dst, src) +func (m *StepPositionsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_StepPositionsResponse.Merge(m, src) } func (m *StepPositionsResponse) XXX_Size() int { return xxx_messageInfo_StepPositionsResponse.Size(m) @@ -1804,16 +1845,17 @@ func (m *StepPositionsResponse_StepPosition) Reset() { *m = StepPosition func (m *StepPositionsResponse_StepPosition) String() string { return proto.CompactTextString(m) } func (*StepPositionsResponse_StepPosition) ProtoMessage() {} func (*StepPositionsResponse_StepPosition) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{32, 0} + return fileDescriptor_4dc296cbfe5ffcd5, []int{32, 0} } + func (m *StepPositionsResponse_StepPosition) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_StepPositionsResponse_StepPosition.Unmarshal(m, b) } func (m *StepPositionsResponse_StepPosition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_StepPositionsResponse_StepPosition.Marshal(b, m, deterministic) } -func (dst *StepPositionsResponse_StepPosition) XXX_Merge(src proto.Message) { - xxx_messageInfo_StepPositionsResponse_StepPosition.Merge(dst, src) +func (m *StepPositionsResponse_StepPosition) XXX_Merge(src proto.Message) { + xxx_messageInfo_StepPositionsResponse_StepPosition.Merge(m, src) } func (m *StepPositionsResponse_StepPosition) XXX_Size() int { return xxx_messageInfo_StepPositionsResponse_StepPosition.Size(m) @@ -1849,16 +1891,17 @@ func (m *ImplementationFileGlobPatternRequest) Reset() { *m = Implementa func (m *ImplementationFileGlobPatternRequest) String() string { return proto.CompactTextString(m) } func (*ImplementationFileGlobPatternRequest) ProtoMessage() {} func (*ImplementationFileGlobPatternRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{33} + return fileDescriptor_4dc296cbfe5ffcd5, []int{33} } + func (m *ImplementationFileGlobPatternRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ImplementationFileGlobPatternRequest.Unmarshal(m, b) } func (m *ImplementationFileGlobPatternRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ImplementationFileGlobPatternRequest.Marshal(b, m, deterministic) } -func (dst *ImplementationFileGlobPatternRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_ImplementationFileGlobPatternRequest.Merge(dst, src) +func (m *ImplementationFileGlobPatternRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ImplementationFileGlobPatternRequest.Merge(m, src) } func (m *ImplementationFileGlobPatternRequest) XXX_Size() int { return xxx_messageInfo_ImplementationFileGlobPatternRequest.Size(m) @@ -1882,16 +1925,17 @@ func (m *ImplementationFileGlobPatternResponse) Reset() { *m = Implement func (m *ImplementationFileGlobPatternResponse) String() string { return proto.CompactTextString(m) } func (*ImplementationFileGlobPatternResponse) ProtoMessage() {} func (*ImplementationFileGlobPatternResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{34} + return fileDescriptor_4dc296cbfe5ffcd5, []int{34} } + func (m *ImplementationFileGlobPatternResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ImplementationFileGlobPatternResponse.Unmarshal(m, b) } func (m *ImplementationFileGlobPatternResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ImplementationFileGlobPatternResponse.Marshal(b, m, deterministic) } -func (dst *ImplementationFileGlobPatternResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_ImplementationFileGlobPatternResponse.Merge(dst, src) +func (m *ImplementationFileGlobPatternResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ImplementationFileGlobPatternResponse.Merge(m, src) } func (m *ImplementationFileGlobPatternResponse) XXX_Size() int { return xxx_messageInfo_ImplementationFileGlobPatternResponse.Size(m) @@ -1920,16 +1964,17 @@ func (m *ImplementationFileListRequest) Reset() { *m = ImplementationFil func (m *ImplementationFileListRequest) String() string { return proto.CompactTextString(m) } func (*ImplementationFileListRequest) ProtoMessage() {} func (*ImplementationFileListRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{35} + return fileDescriptor_4dc296cbfe5ffcd5, []int{35} } + func (m *ImplementationFileListRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ImplementationFileListRequest.Unmarshal(m, b) } func (m *ImplementationFileListRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ImplementationFileListRequest.Marshal(b, m, deterministic) } -func (dst *ImplementationFileListRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_ImplementationFileListRequest.Merge(dst, src) +func (m *ImplementationFileListRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ImplementationFileListRequest.Merge(m, src) } func (m *ImplementationFileListRequest) XXX_Size() int { return xxx_messageInfo_ImplementationFileListRequest.Size(m) @@ -1953,16 +1998,17 @@ func (m *ImplementationFileListResponse) Reset() { *m = ImplementationFi func (m *ImplementationFileListResponse) String() string { return proto.CompactTextString(m) } func (*ImplementationFileListResponse) ProtoMessage() {} func (*ImplementationFileListResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{36} + return fileDescriptor_4dc296cbfe5ffcd5, []int{36} } + func (m *ImplementationFileListResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ImplementationFileListResponse.Unmarshal(m, b) } func (m *ImplementationFileListResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ImplementationFileListResponse.Marshal(b, m, deterministic) } -func (dst *ImplementationFileListResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_ImplementationFileListResponse.Merge(dst, src) +func (m *ImplementationFileListResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ImplementationFileListResponse.Merge(m, src) } func (m *ImplementationFileListResponse) XXX_Size() int { return xxx_messageInfo_ImplementationFileListResponse.Size(m) @@ -1995,16 +2041,17 @@ func (m *StubImplementationCodeRequest) Reset() { *m = StubImplementatio func (m *StubImplementationCodeRequest) String() string { return proto.CompactTextString(m) } func (*StubImplementationCodeRequest) ProtoMessage() {} func (*StubImplementationCodeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{37} + return fileDescriptor_4dc296cbfe5ffcd5, []int{37} } + func (m *StubImplementationCodeRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_StubImplementationCodeRequest.Unmarshal(m, b) } func (m *StubImplementationCodeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_StubImplementationCodeRequest.Marshal(b, m, deterministic) } -func (dst *StubImplementationCodeRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_StubImplementationCodeRequest.Merge(dst, src) +func (m *StubImplementationCodeRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_StubImplementationCodeRequest.Merge(m, src) } func (m *StubImplementationCodeRequest) XXX_Size() int { return xxx_messageInfo_StubImplementationCodeRequest.Size(m) @@ -2044,16 +2091,17 @@ func (m *TextDiff) Reset() { *m = TextDiff{} } func (m *TextDiff) String() string { return proto.CompactTextString(m) } func (*TextDiff) ProtoMessage() {} func (*TextDiff) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{38} + return fileDescriptor_4dc296cbfe5ffcd5, []int{38} } + func (m *TextDiff) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_TextDiff.Unmarshal(m, b) } func (m *TextDiff) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_TextDiff.Marshal(b, m, deterministic) } -func (dst *TextDiff) XXX_Merge(src proto.Message) { - xxx_messageInfo_TextDiff.Merge(dst, src) +func (m *TextDiff) XXX_Merge(src proto.Message) { + xxx_messageInfo_TextDiff.Merge(m, src) } func (m *TextDiff) XXX_Size() int { return xxx_messageInfo_TextDiff.Size(m) @@ -2093,16 +2141,17 @@ func (m *FileDiff) Reset() { *m = FileDiff{} } func (m *FileDiff) String() string { return proto.CompactTextString(m) } func (*FileDiff) ProtoMessage() {} func (*FileDiff) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{39} + return fileDescriptor_4dc296cbfe5ffcd5, []int{39} } + func (m *FileDiff) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_FileDiff.Unmarshal(m, b) } func (m *FileDiff) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_FileDiff.Marshal(b, m, deterministic) } -func (dst *FileDiff) XXX_Merge(src proto.Message) { - xxx_messageInfo_FileDiff.Merge(dst, src) +func (m *FileDiff) XXX_Merge(src proto.Message) { + xxx_messageInfo_FileDiff.Merge(m, src) } func (m *FileDiff) XXX_Size() int { return xxx_messageInfo_FileDiff.Size(m) @@ -2210,16 +2259,17 @@ func (m *Message) Reset() { *m = Message{} } func (m *Message) String() string { return proto.CompactTextString(m) } func (*Message) ProtoMessage() {} func (*Message) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_465b4dd22c0ba0e1, []int{40} + return fileDescriptor_4dc296cbfe5ffcd5, []int{40} } + func (m *Message) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Message.Unmarshal(m, b) } func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_Message.Marshal(b, m, deterministic) } -func (dst *Message) XXX_Merge(src proto.Message) { - xxx_messageInfo_Message.Merge(dst, src) +func (m *Message) XXX_Merge(src proto.Message) { + xxx_messageInfo_Message.Merge(m, src) } func (m *Message) XXX_Size() int { return xxx_messageInfo_Message.Size(m) @@ -2476,6 +2526,9 @@ func (m *Message) GetImplementationFileGlobPatternResponse() *ImplementationFile } func init() { + proto.RegisterEnum("gauge.messages.StepValidateResponse_ErrorType", StepValidateResponse_ErrorType_name, StepValidateResponse_ErrorType_value) + proto.RegisterEnum("gauge.messages.CacheFileRequest_FileStatus", CacheFileRequest_FileStatus_name, CacheFileRequest_FileStatus_value) + proto.RegisterEnum("gauge.messages.Message_MessageType", Message_MessageType_name, Message_MessageType_value) proto.RegisterType((*KillProcessRequest)(nil), "gauge.messages.KillProcessRequest") proto.RegisterType((*ExecutionStatusResponse)(nil), "gauge.messages.ExecutionStatusResponse") proto.RegisterType((*ExecutionStartingRequest)(nil), "gauge.messages.ExecutionStartingRequest") @@ -2518,14 +2571,11 @@ func init() { proto.RegisterType((*TextDiff)(nil), "gauge.messages.TextDiff") proto.RegisterType((*FileDiff)(nil), "gauge.messages.FileDiff") proto.RegisterType((*Message)(nil), "gauge.messages.Message") - proto.RegisterEnum("gauge.messages.StepValidateResponse_ErrorType", StepValidateResponse_ErrorType_name, StepValidateResponse_ErrorType_value) - proto.RegisterEnum("gauge.messages.CacheFileRequest_FileStatus", CacheFileRequest_FileStatus_name, CacheFileRequest_FileStatus_value) - proto.RegisterEnum("gauge.messages.Message_MessageType", Message_MessageType_name, Message_MessageType_value) } -func init() { proto.RegisterFile("messages.proto", fileDescriptor_messages_465b4dd22c0ba0e1) } +func init() { proto.RegisterFile("messages.proto", fileDescriptor_4dc296cbfe5ffcd5) } -var fileDescriptor_messages_465b4dd22c0ba0e1 = []byte{ +var fileDescriptor_4dc296cbfe5ffcd5 = []byte{ // 2252 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x5a, 0xcd, 0x6e, 0x1b, 0xc9, 0x11, 0xde, 0xa1, 0xfe, 0xa8, 0xa2, 0x2c, 0xb6, 0x5a, 0x94, 0xd4, 0xa2, 0x7e, 0x2c, 0x8d, 0x65, diff --git a/gauge_messages/spec.pb.go b/gauge_messages/spec.pb.go index 56290ff39..50dddd13c 100644 --- a/gauge_messages/spec.pb.go +++ b/gauge_messages/spec.pb.go @@ -3,9 +3,11 @@ package gauge_messages -import proto "github.com/golang/protobuf/proto" -import fmt "fmt" -import math "math" +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + math "math" +) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal @@ -34,6 +36,7 @@ var ExecutionStatus_name = map[int32]string{ 2: "FAILED", 3: "SKIPPED", } + var ExecutionStatus_value = map[string]int32{ "NOTEXECUTED": 0, "PASSED": 1, @@ -44,8 +47,9 @@ var ExecutionStatus_value = map[string]int32{ func (x ExecutionStatus) String() string { return proto.EnumName(ExecutionStatus_name, int32(x)) } + func (ExecutionStatus) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{0} + return fileDescriptor_423806180556987f, []int{0} } // / Enumerates various item types that the proto item can contain. Valid types are: Step, Comment, Concept, Scenario, TableDrivenScenario, Table, Tags @@ -70,6 +74,7 @@ var ProtoItem_ItemType_name = map[int32]string{ 5: "Table", 6: "Tags", } + var ProtoItem_ItemType_value = map[string]int32{ "Step": 0, "Comment": 1, @@ -83,8 +88,9 @@ var ProtoItem_ItemType_value = map[string]int32{ func (x ProtoItem_ItemType) String() string { return proto.EnumName(ProtoItem_ItemType_name, int32(x)) } + func (ProtoItem_ItemType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{1, 0} + return fileDescriptor_423806180556987f, []int{1, 0} } // / Enum representing the types of Fragment @@ -99,6 +105,7 @@ var Fragment_FragmentType_name = map[int32]string{ 0: "Text", 1: "Parameter", } + var Fragment_FragmentType_value = map[string]int32{ "Text": 0, "Parameter": 1, @@ -107,8 +114,9 @@ var Fragment_FragmentType_value = map[string]int32{ func (x Fragment_FragmentType) String() string { return proto.EnumName(Fragment_FragmentType_name, int32(x)) } + func (Fragment_FragmentType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{8, 0} + return fileDescriptor_423806180556987f, []int{8, 0} } // / Enum representing types of Parameter. @@ -129,6 +137,7 @@ var Parameter_ParameterType_name = map[int32]string{ 3: "Special_Table", 4: "Table", } + var Parameter_ParameterType_value = map[string]int32{ "Static": 0, "Dynamic": 1, @@ -140,8 +149,9 @@ var Parameter_ParameterType_value = map[string]int32{ func (x Parameter_ParameterType) String() string { return proto.EnumName(Parameter_ParameterType_name, int32(x)) } + func (Parameter_ParameterType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{9, 0} + return fileDescriptor_423806180556987f, []int{9, 0} } type ProtoExecutionResult_ErrorType int32 @@ -155,6 +165,7 @@ var ProtoExecutionResult_ErrorType_name = map[int32]string{ 0: "ASSERTION", 1: "VERIFICATION", } + var ProtoExecutionResult_ErrorType_value = map[string]int32{ "ASSERTION": 0, "VERIFICATION": 1, @@ -163,8 +174,9 @@ var ProtoExecutionResult_ErrorType_value = map[string]int32{ func (x ProtoExecutionResult_ErrorType) String() string { return proto.EnumName(ProtoExecutionResult_ErrorType_name, int32(x)) } + func (ProtoExecutionResult_ErrorType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{14, 0} + return fileDescriptor_423806180556987f, []int{14, 0} } type Error_ErrorType int32 @@ -178,6 +190,7 @@ var Error_ErrorType_name = map[int32]string{ 0: "PARSE_ERROR", 1: "VALIDATION_ERROR", } + var Error_ErrorType_value = map[string]int32{ "PARSE_ERROR": 0, "VALIDATION_ERROR": 1, @@ -186,8 +199,9 @@ var Error_ErrorType_value = map[string]int32{ func (x Error_ErrorType) String() string { return proto.EnumName(Error_ErrorType_name, int32(x)) } + func (Error_ErrorType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{18, 0} + return fileDescriptor_423806180556987f, []int{18, 0} } // / A proto object representing a Specification @@ -228,16 +242,17 @@ func (m *ProtoSpec) Reset() { *m = ProtoSpec{} } func (m *ProtoSpec) String() string { return proto.CompactTextString(m) } func (*ProtoSpec) ProtoMessage() {} func (*ProtoSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{0} + return fileDescriptor_423806180556987f, []int{0} } + func (m *ProtoSpec) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ProtoSpec.Unmarshal(m, b) } func (m *ProtoSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ProtoSpec.Marshal(b, m, deterministic) } -func (dst *ProtoSpec) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProtoSpec.Merge(dst, src) +func (m *ProtoSpec) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProtoSpec.Merge(m, src) } func (m *ProtoSpec) XXX_Size() int { return xxx_messageInfo_ProtoSpec.Size(m) @@ -368,16 +383,17 @@ func (m *ProtoItem) Reset() { *m = ProtoItem{} } func (m *ProtoItem) String() string { return proto.CompactTextString(m) } func (*ProtoItem) ProtoMessage() {} func (*ProtoItem) Descriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{1} + return fileDescriptor_423806180556987f, []int{1} } + func (m *ProtoItem) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ProtoItem.Unmarshal(m, b) } func (m *ProtoItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ProtoItem.Marshal(b, m, deterministic) } -func (dst *ProtoItem) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProtoItem.Merge(dst, src) +func (m *ProtoItem) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProtoItem.Merge(m, src) } func (m *ProtoItem) XXX_Size() int { return xxx_messageInfo_ProtoItem.Size(m) @@ -495,16 +511,17 @@ func (m *ProtoScenario) Reset() { *m = ProtoScenario{} } func (m *ProtoScenario) String() string { return proto.CompactTextString(m) } func (*ProtoScenario) ProtoMessage() {} func (*ProtoScenario) Descriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{2} + return fileDescriptor_423806180556987f, []int{2} } + func (m *ProtoScenario) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ProtoScenario.Unmarshal(m, b) } func (m *ProtoScenario) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ProtoScenario.Marshal(b, m, deterministic) } -func (dst *ProtoScenario) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProtoScenario.Merge(dst, src) +func (m *ProtoScenario) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProtoScenario.Merge(m, src) } func (m *ProtoScenario) XXX_Size() int { return xxx_messageInfo_ProtoScenario.Size(m) @@ -674,16 +691,17 @@ func (m *Span) Reset() { *m = Span{} } func (m *Span) String() string { return proto.CompactTextString(m) } func (*Span) ProtoMessage() {} func (*Span) Descriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{3} + return fileDescriptor_423806180556987f, []int{3} } + func (m *Span) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Span.Unmarshal(m, b) } func (m *Span) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_Span.Marshal(b, m, deterministic) } -func (dst *Span) XXX_Merge(src proto.Message) { - xxx_messageInfo_Span.Merge(dst, src) +func (m *Span) XXX_Merge(src proto.Message) { + xxx_messageInfo_Span.Merge(m, src) } func (m *Span) XXX_Size() int { return xxx_messageInfo_Span.Size(m) @@ -727,26 +745,35 @@ type ProtoTableDrivenScenario struct { // / Scenario under Table driven execution Scenario *ProtoScenario `protobuf:"bytes,1,opt,name=scenario,proto3" json:"scenario,omitempty"` // / Row Index of data table against which the current scenario is executed - TableRowIndex int32 `protobuf:"varint,2,opt,name=tableRowIndex,proto3" json:"tableRowIndex,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + TableRowIndex int32 `protobuf:"varint,2,opt,name=tableRowIndex,proto3" json:"tableRowIndex,omitempty"` + // / Row Index of scenario data table against which the current scenario is executed + ScenarioTableRowIndex int32 `protobuf:"varint,3,opt,name=scenarioTableRowIndex,proto3" json:"scenarioTableRowIndex,omitempty"` + // / Executed against a spec data table + IsSpecTableDriven bool `protobuf:"varint,4,opt,name=isSpecTableDriven,proto3" json:"isSpecTableDriven,omitempty"` + // / Executed against a scenario data table + IsScenarioTableDriven bool `protobuf:"varint,5,opt,name=isScenarioTableDriven,proto3" json:"isScenarioTableDriven,omitempty"` + // / Holds the scenario data table + ScenarioDataTable *ProtoTable `protobuf:"bytes,6,opt,name=scenarioDataTable,proto3" json:"scenarioDataTable,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *ProtoTableDrivenScenario) Reset() { *m = ProtoTableDrivenScenario{} } func (m *ProtoTableDrivenScenario) String() string { return proto.CompactTextString(m) } func (*ProtoTableDrivenScenario) ProtoMessage() {} func (*ProtoTableDrivenScenario) Descriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{4} + return fileDescriptor_423806180556987f, []int{4} } + func (m *ProtoTableDrivenScenario) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ProtoTableDrivenScenario.Unmarshal(m, b) } func (m *ProtoTableDrivenScenario) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ProtoTableDrivenScenario.Marshal(b, m, deterministic) } -func (dst *ProtoTableDrivenScenario) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProtoTableDrivenScenario.Merge(dst, src) +func (m *ProtoTableDrivenScenario) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProtoTableDrivenScenario.Merge(m, src) } func (m *ProtoTableDrivenScenario) XXX_Size() int { return xxx_messageInfo_ProtoTableDrivenScenario.Size(m) @@ -771,6 +798,34 @@ func (m *ProtoTableDrivenScenario) GetTableRowIndex() int32 { return 0 } +func (m *ProtoTableDrivenScenario) GetScenarioTableRowIndex() int32 { + if m != nil { + return m.ScenarioTableRowIndex + } + return 0 +} + +func (m *ProtoTableDrivenScenario) GetIsSpecTableDriven() bool { + if m != nil { + return m.IsSpecTableDriven + } + return false +} + +func (m *ProtoTableDrivenScenario) GetIsScenarioTableDriven() bool { + if m != nil { + return m.IsScenarioTableDriven + } + return false +} + +func (m *ProtoTableDrivenScenario) GetScenarioDataTable() *ProtoTable { + if m != nil { + return m.ScenarioDataTable + } + return nil +} + // / A proto object representing a Step type ProtoStep struct { // / Holds the raw text of the Step as defined in the spec file. This contains the actual parameter values. @@ -798,16 +853,17 @@ func (m *ProtoStep) Reset() { *m = ProtoStep{} } func (m *ProtoStep) String() string { return proto.CompactTextString(m) } func (*ProtoStep) ProtoMessage() {} func (*ProtoStep) Descriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{5} + return fileDescriptor_423806180556987f, []int{5} } + func (m *ProtoStep) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ProtoStep.Unmarshal(m, b) } func (m *ProtoStep) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ProtoStep.Marshal(b, m, deterministic) } -func (dst *ProtoStep) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProtoStep.Merge(dst, src) +func (m *ProtoStep) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProtoStep.Merge(m, src) } func (m *ProtoStep) XXX_Size() int { return xxx_messageInfo_ProtoStep.Size(m) @@ -893,16 +949,17 @@ func (m *ProtoConcept) Reset() { *m = ProtoConcept{} } func (m *ProtoConcept) String() string { return proto.CompactTextString(m) } func (*ProtoConcept) ProtoMessage() {} func (*ProtoConcept) Descriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{6} + return fileDescriptor_423806180556987f, []int{6} } + func (m *ProtoConcept) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ProtoConcept.Unmarshal(m, b) } func (m *ProtoConcept) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ProtoConcept.Marshal(b, m, deterministic) } -func (dst *ProtoConcept) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProtoConcept.Merge(dst, src) +func (m *ProtoConcept) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProtoConcept.Merge(m, src) } func (m *ProtoConcept) XXX_Size() int { return xxx_messageInfo_ProtoConcept.Size(m) @@ -947,16 +1004,17 @@ func (m *ProtoTags) Reset() { *m = ProtoTags{} } func (m *ProtoTags) String() string { return proto.CompactTextString(m) } func (*ProtoTags) ProtoMessage() {} func (*ProtoTags) Descriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{7} + return fileDescriptor_423806180556987f, []int{7} } + func (m *ProtoTags) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ProtoTags.Unmarshal(m, b) } func (m *ProtoTags) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ProtoTags.Marshal(b, m, deterministic) } -func (dst *ProtoTags) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProtoTags.Merge(dst, src) +func (m *ProtoTags) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProtoTags.Merge(m, src) } func (m *ProtoTags) XXX_Size() int { return xxx_messageInfo_ProtoTags.Size(m) @@ -992,16 +1050,17 @@ func (m *Fragment) Reset() { *m = Fragment{} } func (m *Fragment) String() string { return proto.CompactTextString(m) } func (*Fragment) ProtoMessage() {} func (*Fragment) Descriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{8} + return fileDescriptor_423806180556987f, []int{8} } + func (m *Fragment) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Fragment.Unmarshal(m, b) } func (m *Fragment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_Fragment.Marshal(b, m, deterministic) } -func (dst *Fragment) XXX_Merge(src proto.Message) { - xxx_messageInfo_Fragment.Merge(dst, src) +func (m *Fragment) XXX_Merge(src proto.Message) { + xxx_messageInfo_Fragment.Merge(m, src) } func (m *Fragment) XXX_Size() int { return xxx_messageInfo_Fragment.Size(m) @@ -1052,16 +1111,17 @@ func (m *Parameter) Reset() { *m = Parameter{} } func (m *Parameter) String() string { return proto.CompactTextString(m) } func (*Parameter) ProtoMessage() {} func (*Parameter) Descriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{9} + return fileDescriptor_423806180556987f, []int{9} } + func (m *Parameter) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Parameter.Unmarshal(m, b) } func (m *Parameter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_Parameter.Marshal(b, m, deterministic) } -func (dst *Parameter) XXX_Merge(src proto.Message) { - xxx_messageInfo_Parameter.Merge(dst, src) +func (m *Parameter) XXX_Merge(src proto.Message) { + xxx_messageInfo_Parameter.Merge(m, src) } func (m *Parameter) XXX_Size() int { return xxx_messageInfo_Parameter.Size(m) @@ -1113,16 +1173,17 @@ func (m *ProtoComment) Reset() { *m = ProtoComment{} } func (m *ProtoComment) String() string { return proto.CompactTextString(m) } func (*ProtoComment) ProtoMessage() {} func (*ProtoComment) Descriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{10} + return fileDescriptor_423806180556987f, []int{10} } + func (m *ProtoComment) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ProtoComment.Unmarshal(m, b) } func (m *ProtoComment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ProtoComment.Marshal(b, m, deterministic) } -func (dst *ProtoComment) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProtoComment.Merge(dst, src) +func (m *ProtoComment) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProtoComment.Merge(m, src) } func (m *ProtoComment) XXX_Size() int { return xxx_messageInfo_ProtoComment.Size(m) @@ -1155,16 +1216,17 @@ func (m *ProtoTable) Reset() { *m = ProtoTable{} } func (m *ProtoTable) String() string { return proto.CompactTextString(m) } func (*ProtoTable) ProtoMessage() {} func (*ProtoTable) Descriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{11} + return fileDescriptor_423806180556987f, []int{11} } + func (m *ProtoTable) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ProtoTable.Unmarshal(m, b) } func (m *ProtoTable) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ProtoTable.Marshal(b, m, deterministic) } -func (dst *ProtoTable) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProtoTable.Merge(dst, src) +func (m *ProtoTable) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProtoTable.Merge(m, src) } func (m *ProtoTable) XXX_Size() int { return xxx_messageInfo_ProtoTable.Size(m) @@ -1202,16 +1264,17 @@ func (m *ProtoTableRow) Reset() { *m = ProtoTableRow{} } func (m *ProtoTableRow) String() string { return proto.CompactTextString(m) } func (*ProtoTableRow) ProtoMessage() {} func (*ProtoTableRow) Descriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{12} + return fileDescriptor_423806180556987f, []int{12} } + func (m *ProtoTableRow) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ProtoTableRow.Unmarshal(m, b) } func (m *ProtoTableRow) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ProtoTableRow.Marshal(b, m, deterministic) } -func (dst *ProtoTableRow) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProtoTableRow.Merge(dst, src) +func (m *ProtoTableRow) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProtoTableRow.Merge(m, src) } func (m *ProtoTableRow) XXX_Size() int { return xxx_messageInfo_ProtoTableRow.Size(m) @@ -1248,16 +1311,17 @@ func (m *ProtoStepExecutionResult) Reset() { *m = ProtoStepExecutionResu func (m *ProtoStepExecutionResult) String() string { return proto.CompactTextString(m) } func (*ProtoStepExecutionResult) ProtoMessage() {} func (*ProtoStepExecutionResult) Descriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{13} + return fileDescriptor_423806180556987f, []int{13} } + func (m *ProtoStepExecutionResult) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ProtoStepExecutionResult.Unmarshal(m, b) } func (m *ProtoStepExecutionResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ProtoStepExecutionResult.Marshal(b, m, deterministic) } -func (dst *ProtoStepExecutionResult) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProtoStepExecutionResult.Merge(dst, src) +func (m *ProtoStepExecutionResult) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProtoStepExecutionResult.Merge(m, src) } func (m *ProtoStepExecutionResult) XXX_Size() int { return xxx_messageInfo_ProtoStepExecutionResult.Size(m) @@ -1334,16 +1398,17 @@ func (m *ProtoExecutionResult) Reset() { *m = ProtoExecutionResult{} } func (m *ProtoExecutionResult) String() string { return proto.CompactTextString(m) } func (*ProtoExecutionResult) ProtoMessage() {} func (*ProtoExecutionResult) Descriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{14} + return fileDescriptor_423806180556987f, []int{14} } + func (m *ProtoExecutionResult) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ProtoExecutionResult.Unmarshal(m, b) } func (m *ProtoExecutionResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ProtoExecutionResult.Marshal(b, m, deterministic) } -func (dst *ProtoExecutionResult) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProtoExecutionResult.Merge(dst, src) +func (m *ProtoExecutionResult) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProtoExecutionResult.Merge(m, src) } func (m *ProtoExecutionResult) XXX_Size() int { return xxx_messageInfo_ProtoExecutionResult.Size(m) @@ -1447,16 +1512,17 @@ func (m *ProtoHookFailure) Reset() { *m = ProtoHookFailure{} } func (m *ProtoHookFailure) String() string { return proto.CompactTextString(m) } func (*ProtoHookFailure) ProtoMessage() {} func (*ProtoHookFailure) Descriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{15} + return fileDescriptor_423806180556987f, []int{15} } + func (m *ProtoHookFailure) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ProtoHookFailure.Unmarshal(m, b) } func (m *ProtoHookFailure) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ProtoHookFailure.Marshal(b, m, deterministic) } -func (dst *ProtoHookFailure) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProtoHookFailure.Merge(dst, src) +func (m *ProtoHookFailure) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProtoHookFailure.Merge(m, src) } func (m *ProtoHookFailure) XXX_Size() int { return xxx_messageInfo_ProtoHookFailure.Size(m) @@ -1549,16 +1615,17 @@ func (m *ProtoSuiteResult) Reset() { *m = ProtoSuiteResult{} } func (m *ProtoSuiteResult) String() string { return proto.CompactTextString(m) } func (*ProtoSuiteResult) ProtoMessage() {} func (*ProtoSuiteResult) Descriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{16} + return fileDescriptor_423806180556987f, []int{16} } + func (m *ProtoSuiteResult) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ProtoSuiteResult.Unmarshal(m, b) } func (m *ProtoSuiteResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ProtoSuiteResult.Marshal(b, m, deterministic) } -func (dst *ProtoSuiteResult) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProtoSuiteResult.Merge(dst, src) +func (m *ProtoSuiteResult) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProtoSuiteResult.Merge(m, src) } func (m *ProtoSuiteResult) XXX_Size() int { return xxx_messageInfo_ProtoSuiteResult.Size(m) @@ -1728,16 +1795,17 @@ func (m *ProtoSpecResult) Reset() { *m = ProtoSpecResult{} } func (m *ProtoSpecResult) String() string { return proto.CompactTextString(m) } func (*ProtoSpecResult) ProtoMessage() {} func (*ProtoSpecResult) Descriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{17} + return fileDescriptor_423806180556987f, []int{17} } + func (m *ProtoSpecResult) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ProtoSpecResult.Unmarshal(m, b) } func (m *ProtoSpecResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ProtoSpecResult.Marshal(b, m, deterministic) } -func (dst *ProtoSpecResult) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProtoSpecResult.Merge(dst, src) +func (m *ProtoSpecResult) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProtoSpecResult.Merge(m, src) } func (m *ProtoSpecResult) XXX_Size() int { return xxx_messageInfo_ProtoSpecResult.Size(m) @@ -1837,16 +1905,17 @@ func (m *Error) Reset() { *m = Error{} } func (m *Error) String() string { return proto.CompactTextString(m) } func (*Error) ProtoMessage() {} func (*Error) Descriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{18} + return fileDescriptor_423806180556987f, []int{18} } + func (m *Error) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Error.Unmarshal(m, b) } func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_Error.Marshal(b, m, deterministic) } -func (dst *Error) XXX_Merge(src proto.Message) { - xxx_messageInfo_Error.Merge(dst, src) +func (m *Error) XXX_Merge(src proto.Message) { + xxx_messageInfo_Error.Merge(m, src) } func (m *Error) XXX_Size() int { return xxx_messageInfo_Error.Size(m) @@ -1902,16 +1971,17 @@ func (m *ProtoStepValue) Reset() { *m = ProtoStepValue{} } func (m *ProtoStepValue) String() string { return proto.CompactTextString(m) } func (*ProtoStepValue) ProtoMessage() {} func (*ProtoStepValue) Descriptor() ([]byte, []int) { - return fileDescriptor_spec_17d5ce73e0227e31, []int{19} + return fileDescriptor_423806180556987f, []int{19} } + func (m *ProtoStepValue) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ProtoStepValue.Unmarshal(m, b) } func (m *ProtoStepValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_ProtoStepValue.Marshal(b, m, deterministic) } -func (dst *ProtoStepValue) XXX_Merge(src proto.Message) { - xxx_messageInfo_ProtoStepValue.Merge(dst, src) +func (m *ProtoStepValue) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProtoStepValue.Merge(m, src) } func (m *ProtoStepValue) XXX_Size() int { return xxx_messageInfo_ProtoStepValue.Size(m) @@ -1944,6 +2014,12 @@ func (m *ProtoStepValue) GetParameters() []string { } func init() { + proto.RegisterEnum("gauge.messages.ExecutionStatus", ExecutionStatus_name, ExecutionStatus_value) + proto.RegisterEnum("gauge.messages.ProtoItem_ItemType", ProtoItem_ItemType_name, ProtoItem_ItemType_value) + proto.RegisterEnum("gauge.messages.Fragment_FragmentType", Fragment_FragmentType_name, Fragment_FragmentType_value) + proto.RegisterEnum("gauge.messages.Parameter_ParameterType", Parameter_ParameterType_name, Parameter_ParameterType_value) + proto.RegisterEnum("gauge.messages.ProtoExecutionResult_ErrorType", ProtoExecutionResult_ErrorType_name, ProtoExecutionResult_ErrorType_value) + proto.RegisterEnum("gauge.messages.Error_ErrorType", Error_ErrorType_name, Error_ErrorType_value) proto.RegisterType((*ProtoSpec)(nil), "gauge.messages.ProtoSpec") proto.RegisterType((*ProtoItem)(nil), "gauge.messages.ProtoItem") proto.RegisterType((*ProtoScenario)(nil), "gauge.messages.ProtoScenario") @@ -1964,137 +2040,135 @@ func init() { proto.RegisterType((*ProtoSpecResult)(nil), "gauge.messages.ProtoSpecResult") proto.RegisterType((*Error)(nil), "gauge.messages.Error") proto.RegisterType((*ProtoStepValue)(nil), "gauge.messages.ProtoStepValue") - proto.RegisterEnum("gauge.messages.ExecutionStatus", ExecutionStatus_name, ExecutionStatus_value) - proto.RegisterEnum("gauge.messages.ProtoItem_ItemType", ProtoItem_ItemType_name, ProtoItem_ItemType_value) - proto.RegisterEnum("gauge.messages.Fragment_FragmentType", Fragment_FragmentType_name, Fragment_FragmentType_value) - proto.RegisterEnum("gauge.messages.Parameter_ParameterType", Parameter_ParameterType_name, Parameter_ParameterType_value) - proto.RegisterEnum("gauge.messages.ProtoExecutionResult_ErrorType", ProtoExecutionResult_ErrorType_name, ProtoExecutionResult_ErrorType_value) - proto.RegisterEnum("gauge.messages.Error_ErrorType", Error_ErrorType_name, Error_ErrorType_value) } -func init() { proto.RegisterFile("spec.proto", fileDescriptor_spec_17d5ce73e0227e31) } - -var fileDescriptor_spec_17d5ce73e0227e31 = []byte{ - // 1935 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xdd, 0x8e, 0x1b, 0x49, - 0x15, 0x9e, 0x76, 0xb7, 0xff, 0x8e, 0x7f, 0xa6, 0x53, 0x33, 0x84, 0x26, 0x0a, 0x89, 0xd5, 0x9a, - 0xd5, 0x9a, 0x28, 0x6b, 0xc2, 0xac, 0xc8, 0x0a, 0x21, 0x81, 0x66, 0xc7, 0x9e, 0x8d, 0x21, 0x3b, - 0x19, 0x95, 0x4d, 0x84, 0xf6, 0x66, 0xe9, 0xf4, 0xd4, 0x78, 0x7a, 0x63, 0x77, 0x5b, 0xdd, 0xe5, - 0x64, 0x16, 0xee, 0x79, 0x00, 0x6e, 0x78, 0x07, 0x24, 0xae, 0x78, 0x01, 0x24, 0x24, 0x6e, 0x90, - 0xf2, 0x08, 0x88, 0x47, 0x41, 0x75, 0xaa, 0xfa, 0xd7, 0xed, 0x19, 0x1b, 0x71, 0xb1, 0x77, 0x55, - 0xe7, 0xa7, 0x7e, 0x4e, 0x7d, 0x75, 0xce, 0x57, 0x05, 0x10, 0x2d, 0x99, 0x3b, 0x58, 0x86, 0x01, - 0x0f, 0x48, 0x77, 0xe6, 0xac, 0x66, 0x6c, 0xb0, 0x60, 0x51, 0xe4, 0xcc, 0x58, 0x64, 0xff, 0xc7, - 0x80, 0xe6, 0x85, 0xd0, 0x4c, 0x96, 0xcc, 0x25, 0x3d, 0x68, 0x09, 0xdb, 0x17, 0xcc, 0xb9, 0xf4, - 0xfc, 0x99, 0xa5, 0xf5, 0xb4, 0x7e, 0x93, 0x66, 0x45, 0xe4, 0xc7, 0x50, 0xf5, 0x38, 0x5b, 0x44, - 0x56, 0xa5, 0xa7, 0xf7, 0x5b, 0xc7, 0x3f, 0x18, 0xe4, 0xc7, 0x1b, 0xe0, 0x58, 0x63, 0xce, 0x16, - 0x54, 0xda, 0x91, 0x23, 0xe8, 0x78, 0xd1, 0xd4, 0x79, 0x33, 0x67, 0xc3, 0xd0, 0x7b, 0xc7, 0x7c, - 0x4b, 0xef, 0x69, 0xfd, 0x06, 0xcd, 0x0b, 0xc9, 0xaf, 0x60, 0x7f, 0x19, 0xb2, 0x17, 0x41, 0xf0, - 0xf6, 0xcc, 0xf1, 0xe6, 0xab, 0x90, 0x45, 0x96, 0x81, 0x13, 0xf4, 0x4a, 0x27, 0xc8, 0x18, 0xd2, - 0xa2, 0x23, 0x79, 0x09, 0xe6, 0x32, 0x88, 0x78, 0x6e, 0xb0, 0xea, 0x96, 0x83, 0xad, 0x79, 0x92, - 0x07, 0xd0, 0xb8, 0xf2, 0xe6, 0xec, 0xdc, 0x59, 0x30, 0xab, 0x86, 0xf1, 0x48, 0xfa, 0x84, 0x80, - 0xc1, 0x9d, 0x59, 0x64, 0xd5, 0x7b, 0x7a, 0xbf, 0x49, 0xb1, 0x4d, 0xfa, 0xc9, 0x4e, 0xbe, 0x54, - 0xb3, 0x58, 0x0d, 0x54, 0x17, 0xc5, 0xe4, 0x49, 0xba, 0xce, 0xc4, 0xb4, 0x89, 0xa6, 0x6b, 0x72, - 0xf2, 0x04, 0xba, 0x79, 0x77, 0x0b, 0x84, 0xe5, 0xe7, 0x15, 0x4b, 0xa3, 0x05, 0x0d, 0x79, 0x0a, - 0xfb, 0x05, 0x7f, 0xab, 0x95, 0x18, 0x17, 0x55, 0x64, 0x00, 0x44, 0xf9, 0x4f, 0xdc, 0x90, 0x31, - 0x3f, 0xba, 0x0e, 0x78, 0x64, 0xb5, 0x7b, 0x7a, 0xbf, 0x4d, 0x4b, 0x34, 0xe4, 0x19, 0x1c, 0xc4, - 0x43, 0x64, 0x1d, 0x3a, 0xe8, 0x50, 0xa6, 0xb2, 0x3f, 0xc4, 0x10, 0x13, 0xb0, 0x20, 0xbf, 0x80, - 0x86, 0x00, 0xc6, 0xf4, 0xdb, 0x25, 0x43, 0x7c, 0x75, 0x8f, 0xed, 0x8d, 0x18, 0x1a, 0x8c, 0x95, - 0x25, 0x4d, 0x7c, 0xc8, 0x27, 0x60, 0x44, 0x9c, 0x2d, 0xad, 0x4a, 0x4f, 0xdb, 0x88, 0xbf, 0x09, - 0x67, 0x4b, 0x8a, 0x66, 0xe4, 0x39, 0xd4, 0xdd, 0xc0, 0x77, 0xd9, 0x92, 0x23, 0xf0, 0x5a, 0xc7, - 0x0f, 0x4b, 0x3d, 0x4e, 0xa5, 0x0d, 0x8d, 0x8d, 0xc9, 0xcf, 0xa0, 0x11, 0xb9, 0xcc, 0x77, 0x42, - 0x2f, 0xb0, 0x0c, 0x74, 0xfc, 0x61, 0xf9, 0x54, 0xca, 0x88, 0x26, 0xe6, 0xe4, 0x2b, 0x38, 0xe0, - 0x29, 0xb4, 0x63, 0x03, 0xab, 0x8a, 0xa3, 0xf4, 0x4b, 0x47, 0x99, 0xae, 0xdb, 0xd3, 0xb2, 0x41, - 0xe4, 0x76, 0x16, 0x0b, 0xe6, 0x73, 0x04, 0xe3, 0xe6, 0xed, 0xa0, 0x0d, 0x8d, 0x8d, 0xc9, 0x33, - 0xa8, 0xe2, 0x70, 0x56, 0x1d, 0xbd, 0x1e, 0x6c, 0x5e, 0x05, 0x95, 0x86, 0x22, 0xce, 0x88, 0xed, - 0xc6, 0x2d, 0x71, 0x9e, 0x3a, 0xb3, 0x48, 0xc2, 0xde, 0xfe, 0x06, 0x1a, 0xf1, 0x61, 0x91, 0x06, - 0x18, 0xe2, 0x04, 0xcc, 0x3d, 0xd2, 0x82, 0xba, 0x5a, 0x8a, 0xa9, 0xc9, 0x0e, 0x46, 0xd7, 0xac, - 0x90, 0x36, 0x34, 0xe2, 0x4d, 0x99, 0x3a, 0xf9, 0x3e, 0x1c, 0x94, 0x84, 0xc0, 0x34, 0x48, 0x13, - 0xaa, 0xa8, 0x30, 0xab, 0x62, 0x54, 0x31, 0x9f, 0x59, 0xb3, 0xff, 0x56, 0x87, 0x4e, 0x2e, 0xf8, - 0xe2, 0xd2, 0xc5, 0xe1, 0xcf, 0xe7, 0xae, 0xa2, 0x98, 0x3c, 0x80, 0xda, 0x95, 0xe3, 0xcd, 0xd9, - 0x25, 0x02, 0xa8, 0x81, 0x77, 0x42, 0x49, 0xc8, 0x4f, 0xa1, 0xe1, 0x06, 0x3e, 0x67, 0x37, 0x3c, - 0xb2, 0xf4, 0xbb, 0xd2, 0x5b, 0x62, 0x4a, 0x7e, 0x09, 0x9d, 0x78, 0x96, 0x31, 0xa6, 0x46, 0xe3, - 0x2e, 0xdf, 0xbc, 0x3d, 0x79, 0x91, 0x5c, 0x6e, 0x95, 0x75, 0x14, 0x56, 0xee, 0x4e, 0x57, 0x05, - 0x3f, 0x4c, 0xa3, 0xf9, 0x04, 0xa6, 0x60, 0xb2, 0x4d, 0x1a, 0xcd, 0x3b, 0x96, 0x26, 0xb7, 0x23, - 0xe8, 0xb0, 0x1b, 0xe6, 0xae, 0xb8, 0x17, 0xf8, 0x53, 0x6f, 0xc1, 0x10, 0x1d, 0x3a, 0xcd, 0x0b, - 0xc9, 0x43, 0xa8, 0x47, 0x6f, 0xbd, 0xe5, 0x92, 0x5d, 0x5a, 0xcd, 0x24, 0xc8, 0xb1, 0x88, 0x3c, - 0x02, 0x10, 0xcd, 0x51, 0x18, 0x06, 0x61, 0x24, 0xd3, 0x18, 0xcd, 0x48, 0x48, 0x17, 0x2a, 0xe3, - 0xa1, 0xd5, 0xc2, 0xe3, 0xab, 0x8c, 0x87, 0x22, 0xbc, 0x9c, 0x39, 0xe1, 0x30, 0x78, 0xef, 0x0b, - 0x54, 0xc9, 0xdc, 0x74, 0x7b, 0x78, 0x73, 0xf6, 0xa4, 0x0f, 0x46, 0xb4, 0x74, 0x7c, 0xab, 0x83, - 0x91, 0x38, 0x2c, 0xfa, 0x4d, 0x96, 0x8e, 0x4f, 0xd1, 0x82, 0x8c, 0x61, 0x3f, 0xd9, 0xc9, 0x84, - 0x3b, 0x7c, 0x15, 0x59, 0x5d, 0x4c, 0x51, 0x8f, 0x8b, 0x4e, 0xa3, 0xbc, 0x19, 0x2d, 0xfa, 0x95, - 0x95, 0x81, 0xfd, 0xed, 0xcb, 0x80, 0xb9, 0x75, 0x19, 0xb8, 0xb7, 0x4b, 0x19, 0x20, 0xbb, 0x96, - 0x81, 0x83, 0x5d, 0xcb, 0xc0, 0xe1, 0xe6, 0x32, 0x70, 0x05, 0x86, 0x08, 0x35, 0x39, 0x84, 0x6a, - 0xc4, 0x9d, 0x90, 0xe3, 0x0d, 0xd5, 0xa9, 0xec, 0x10, 0x13, 0x74, 0xe6, 0xcb, 0x4b, 0xa9, 0x53, - 0xd1, 0x24, 0x0f, 0xa1, 0x89, 0xaa, 0xd3, 0x6b, 0x27, 0xc4, 0xdc, 0xad, 0xd3, 0x54, 0x40, 0x2c, - 0xa8, 0x33, 0xff, 0x12, 0x75, 0x06, 0xea, 0xe2, 0xae, 0xfd, 0x07, 0xb0, 0x36, 0xe5, 0xd4, 0x5c, - 0x56, 0xd7, 0x76, 0xcb, 0xea, 0x47, 0xd0, 0xc1, 0xc4, 0x48, 0x83, 0xf7, 0x63, 0xff, 0x92, 0xdd, - 0xe0, 0x52, 0xab, 0x34, 0x2f, 0xb4, 0xff, 0xac, 0xc7, 0x74, 0x4a, 0x14, 0x9f, 0x47, 0x00, 0x8e, - 0xcb, 0x57, 0xce, 0x7c, 0xca, 0x6e, 0xb8, 0xca, 0x48, 0x19, 0x89, 0xd0, 0x2f, 0x9d, 0x30, 0x62, - 0x97, 0xa8, 0xaf, 0x48, 0x7d, 0x2a, 0x21, 0xcf, 0xa1, 0x79, 0x15, 0x3a, 0x33, 0x91, 0x3f, 0xe3, - 0x8c, 0x64, 0x15, 0xd7, 0x7b, 0xa6, 0x0c, 0x68, 0x6a, 0x2a, 0x2a, 0x90, 0x28, 0x7e, 0x09, 0x48, - 0x29, 0x8b, 0x56, 0x73, 0xae, 0xea, 0x58, 0x7f, 0x63, 0xc9, 0x2c, 0xd8, 0xd3, 0xb2, 0x41, 0xca, - 0x80, 0x5d, 0xdd, 0x1e, 0xd8, 0xb5, 0x0d, 0xc0, 0x2e, 0x87, 0x5f, 0x7d, 0x57, 0xf8, 0x35, 0x36, - 0xc3, 0xef, 0xdf, 0x1a, 0xb4, 0xb3, 0xa5, 0x9e, 0xfc, 0x1c, 0x5a, 0xaa, 0xd8, 0x8b, 0xbd, 0x2b, - 0x38, 0xdc, 0xc2, 0x27, 0xb2, 0xd6, 0x82, 0x06, 0x47, 0x98, 0x8c, 0xee, 0xa6, 0xc1, 0x68, 0x47, - 0x7e, 0x07, 0xf7, 0x95, 0x7f, 0xf1, 0x54, 0xf4, 0x1d, 0x4f, 0x65, 0xc3, 0x38, 0xf6, 0x63, 0x85, - 0x3c, 0x51, 0x24, 0x93, 0xe4, 0xad, 0xa5, 0xc9, 0xdb, 0xfe, 0x97, 0x06, 0x8d, 0x18, 0x2d, 0x64, - 0x0c, 0xed, 0x18, 0x2f, 0x19, 0x2a, 0xf6, 0xd1, 0x26, 0x74, 0x25, 0x0d, 0x64, 0x63, 0x39, 0x57, - 0x9c, 0x2b, 0xc5, 0x2f, 0xb6, 0xc9, 0x67, 0xd0, 0x5c, 0x3a, 0xa1, 0xb3, 0x60, 0x9c, 0x85, 0x6a, - 0x87, 0xeb, 0x31, 0x8a, 0x0d, 0x68, 0x6a, 0x6b, 0x7f, 0x0c, 0xed, 0xec, 0x54, 0x58, 0xf5, 0xd9, - 0x0d, 0x37, 0xf7, 0x48, 0x07, 0x9a, 0x89, 0x87, 0xa9, 0xd9, 0x7f, 0xaa, 0x64, 0xfa, 0xe4, 0x4b, - 0xe8, 0x24, 0x63, 0x64, 0xf6, 0xf3, 0xf1, 0xc6, 0x39, 0xd3, 0x16, 0xee, 0x28, 0xef, 0x2d, 0x72, - 0xd4, 0x3b, 0x67, 0xbe, 0x62, 0x6a, 0x4f, 0xb2, 0x23, 0x36, 0xea, 0x8b, 0x67, 0x80, 0x2e, 0x37, - 0x2a, 0xda, 0x29, 0xb1, 0x32, 0xb6, 0x24, 0x56, 0xf6, 0x57, 0xd0, 0xc9, 0xcd, 0x4d, 0x00, 0x6a, - 0xa2, 0x68, 0x78, 0xae, 0x24, 0x4c, 0xc3, 0x6f, 0x7d, 0x67, 0xe1, 0xb9, 0xa6, 0x46, 0x08, 0x74, - 0xc5, 0xab, 0xcc, 0x73, 0xe6, 0x5f, 0x4f, 0x78, 0xe8, 0xf9, 0x33, 0xb3, 0x42, 0xee, 0x41, 0x27, - 0x96, 0x49, 0x62, 0xa4, 0xa7, 0x1c, 0xc9, 0xb0, 0xed, 0x04, 0xe3, 0x92, 0xf6, 0xc5, 0x47, 0xa3, - 0xa5, 0x47, 0x63, 0xdf, 0x00, 0xa4, 0x8b, 0x22, 0x9f, 0x41, 0xfd, 0x9a, 0x39, 0x97, 0x2c, 0x8c, - 0x6e, 0x4d, 0x88, 0x53, 0x95, 0xe5, 0x68, 0x6c, 0x4d, 0x7e, 0x02, 0x46, 0x18, 0xbc, 0x8f, 0x2f, - 0xc0, 0x1d, 0x5e, 0x68, 0x6a, 0x7f, 0xa4, 0x68, 0x5b, 0x2c, 0x16, 0x61, 0x76, 0xd9, 0x7c, 0x1e, - 0xc3, 0x54, 0x76, 0xec, 0xbf, 0x57, 0x54, 0x06, 0x2f, 0x41, 0x3f, 0x39, 0xcf, 0x94, 0x68, 0x75, - 0x81, 0xe4, 0xba, 0x8f, 0x4a, 0x57, 0x50, 0xbc, 0x3c, 0x45, 0xe7, 0x12, 0xee, 0x55, 0xf9, 0xff, - 0x71, 0x2f, 0xfd, 0x7f, 0xe5, 0x5e, 0x56, 0xca, 0xa0, 0x0c, 0x7c, 0x2e, 0x27, 0xec, 0xe9, 0x08, - 0x3a, 0xaa, 0x49, 0x99, 0x13, 0x05, 0x3e, 0x52, 0xc5, 0x26, 0xcd, 0x0b, 0xed, 0x0f, 0x3a, 0x1c, - 0x96, 0xed, 0x9f, 0xdc, 0x4f, 0xe8, 0xaf, 0x86, 0xe3, 0xc6, 0xd4, 0xf7, 0x09, 0x98, 0x21, 0x73, - 0x83, 0x77, 0x2c, 0x14, 0x67, 0x83, 0x4c, 0x4c, 0x12, 0x64, 0xba, 0x26, 0x27, 0x36, 0xb4, 0x99, - 0x68, 0xc4, 0xac, 0x42, 0x5e, 0x87, 0x9c, 0x0c, 0x49, 0x1e, 0x77, 0xdc, 0xb7, 0xd3, 0xd0, 0x71, - 0xe5, 0xdd, 0x10, 0x24, 0x2f, 0x91, 0x10, 0x1b, 0x20, 0xc2, 0xe4, 0x3c, 0xb9, 0x0e, 0x38, 0xee, - 0xa1, 0x8d, 0xbc, 0x24, 0x23, 0x5d, 0x27, 0x9b, 0xb5, 0x32, 0xb2, 0x69, 0x41, 0x5d, 0x05, 0x56, - 0x31, 0xd5, 0xb8, 0x4b, 0x5e, 0x42, 0x13, 0xd7, 0x84, 0xf9, 0xa0, 0x81, 0xf9, 0x60, 0xb0, 0x0d, - 0x48, 0x06, 0xa3, 0xd8, 0x8b, 0xa6, 0x03, 0x90, 0xa7, 0x70, 0xef, 0x4a, 0x9e, 0x4e, 0x5a, 0x55, - 0x90, 0xde, 0xb6, 0xe9, 0xba, 0x02, 0x3f, 0x52, 0x32, 0x75, 0x09, 0xb0, 0x2e, 0x65, 0x45, 0xf6, - 0x53, 0x68, 0x26, 0xf3, 0x88, 0xdc, 0x76, 0x32, 0x99, 0x8c, 0xe8, 0x74, 0xfc, 0xea, 0xdc, 0xdc, - 0x23, 0x26, 0xb4, 0x5f, 0x8f, 0xe8, 0xf8, 0x6c, 0x7c, 0x7a, 0x82, 0x12, 0xcd, 0xfe, 0xa0, 0x81, - 0x59, 0x84, 0x4d, 0x21, 0xc8, 0x5a, 0x49, 0x90, 0xf3, 0x07, 0x55, 0x29, 0x39, 0xa8, 0xfc, 0x41, - 0xe8, 0x9b, 0x0e, 0x22, 0x4f, 0x7d, 0x8c, 0x12, 0xea, 0x53, 0x1e, 0xa0, 0xea, 0x86, 0x00, 0xd9, - 0x7f, 0xad, 0xa9, 0x0d, 0x4d, 0x56, 0x1e, 0x67, 0x0a, 0x9d, 0x27, 0xf2, 0xfb, 0x49, 0xf6, 0x64, - 0x56, 0x68, 0xad, 0x73, 0xef, 0xe4, 0xbb, 0x4a, 0xdd, 0xe9, 0xac, 0xcf, 0x77, 0xf4, 0x3e, 0xa7, - 0xd7, 0xce, 0x28, 0x5e, 0x3b, 0xb1, 0xf8, 0xe8, 0x0c, 0xbb, 0xa7, 0xc1, 0xca, 0x97, 0x21, 0xab, - 0xd2, 0x35, 0xf9, 0x96, 0xd7, 0x41, 0x00, 0x6f, 0xe5, 0xba, 0x2c, 0x8a, 0xa8, 0xc3, 0xe5, 0x73, - 0xbf, 0x42, 0xb3, 0x22, 0x61, 0xc1, 0xfc, 0x77, 0x5e, 0x18, 0xf8, 0xf8, 0x8d, 0xd0, 0x90, 0x7f, - 0x7c, 0x19, 0x51, 0x42, 0x1e, 0x9a, 0xaa, 0x6a, 0x08, 0x42, 0xd1, 0x83, 0xd6, 0x32, 0x0c, 0xbe, - 0x61, 0x2e, 0xc7, 0x9f, 0x30, 0x90, 0x5e, 0x19, 0x91, 0xe0, 0xeb, 0xdc, 0x5b, 0xb0, 0x88, 0x3b, - 0x8b, 0xa5, 0x7a, 0xbe, 0xa5, 0x02, 0x81, 0x0e, 0xdc, 0xd1, 0x44, 0xe6, 0x29, 0xb9, 0xd5, 0x36, - 0x6e, 0x75, 0x5d, 0x51, 0x46, 0x32, 0x3b, 0xdb, 0x93, 0xcc, 0xee, 0xd6, 0xaf, 0xa7, 0xfd, 0x5d, - 0x5e, 0x4f, 0xe6, 0xae, 0xaf, 0xa7, 0x7b, 0xbb, 0xd2, 0x57, 0xb2, 0x99, 0xbe, 0xfe, 0x43, 0x87, - 0xfd, 0x02, 0xf0, 0x91, 0x64, 0xc5, 0xa2, 0xdb, 0xf9, 0xab, 0xf0, 0x49, 0x6d, 0xb1, 0x88, 0xa8, - 0x77, 0x8d, 0x3c, 0x08, 0xf5, 0x96, 0xc9, 0x09, 0xc5, 0x22, 0x63, 0x41, 0x16, 0x9f, 0x3a, 0xda, - 0x96, 0xa9, 0x36, 0xc2, 0xfc, 0x19, 0x1c, 0xc8, 0xd6, 0xd0, 0xe1, 0x4e, 0x5c, 0xfd, 0xe5, 0xbb, - 0xa1, 0x4a, 0xcb, 0x54, 0xdb, 0xe7, 0xfe, 0xb8, 0x4c, 0xd6, 0xf3, 0x65, 0xf2, 0x18, 0x0e, 0xe3, - 0x05, 0xe6, 0x10, 0xd7, 0xc0, 0xc5, 0x97, 0xea, 0xd0, 0x47, 0xf6, 0xf3, 0xcb, 0x6c, 0xe2, 0x32, - 0x4b, 0x75, 0xe4, 0x13, 0xa8, 0xb1, 0xf4, 0x23, 0xa3, 0x75, 0xfc, 0xbd, 0xb5, 0x8f, 0x02, 0xa1, - 0xa5, 0xca, 0xc8, 0xfe, 0xa7, 0x06, 0x55, 0x59, 0x44, 0x3f, 0x05, 0x83, 0xa7, 0x3c, 0xf5, 0x71, - 0xa9, 0x5b, 0xa6, 0x10, 0xa1, 0x71, 0xfc, 0x17, 0x8d, 0x24, 0xb4, 0x92, 0xfe, 0x45, 0x23, 0x11, - 0x7d, 0x04, 0x30, 0xf7, 0x7c, 0x76, 0xbe, 0x5a, 0xbc, 0x51, 0x94, 0xbb, 0x4a, 0x33, 0x92, 0x6c, - 0x9d, 0x94, 0xe5, 0x38, 0xee, 0xda, 0xc7, 0xd9, 0x4a, 0xb4, 0x0f, 0xad, 0x8b, 0x13, 0x3a, 0x19, - 0x7d, 0x3d, 0xa2, 0xf4, 0x15, 0x35, 0xf7, 0xc8, 0x21, 0x98, 0xaf, 0x4f, 0x5e, 0x8e, 0x87, 0x58, - 0x89, 0x94, 0x54, 0xb3, 0xff, 0xa8, 0x41, 0x37, 0xe1, 0x68, 0xaf, 0x91, 0x1d, 0xe3, 0x7b, 0x5d, - 0x75, 0x54, 0x31, 0x4a, 0x05, 0xe4, 0x39, 0xdc, 0x4f, 0x28, 0xb6, 0xf7, 0x7b, 0x76, 0x99, 0xf8, - 0xa9, 0x8d, 0x6c, 0xd0, 0xaa, 0x27, 0xb2, 0xd4, 0xc8, 0x37, 0xb0, 0x7c, 0x22, 0x2b, 0xc9, 0x93, - 0x2f, 0x60, 0xbf, 0xf0, 0x17, 0x23, 0xb6, 0x70, 0xfe, 0x6a, 0x3a, 0xfa, 0xed, 0xe8, 0xf4, 0x37, - 0xd3, 0xd1, 0xd0, 0xdc, 0x13, 0x04, 0xfb, 0x42, 0x94, 0xd7, 0xa1, 0xa9, 0x89, 0xf6, 0xd9, 0xc9, - 0xf8, 0xe5, 0x68, 0x68, 0x56, 0x04, 0xd9, 0x9e, 0xfc, 0x7a, 0x7c, 0x71, 0x31, 0x1a, 0x9a, 0xfa, - 0xe7, 0x3f, 0x12, 0x0f, 0xb4, 0xc5, 0x80, 0x5f, 0x07, 0xab, 0xd9, 0x35, 0x7f, 0x1f, 0x84, 0x6f, - 0x23, 0x79, 0x28, 0x7f, 0xa9, 0x74, 0xbf, 0xc0, 0xc3, 0x89, 0xf3, 0xc8, 0x9b, 0x1a, 0xde, 0xa4, - 0x4f, 0xff, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x06, 0x49, 0x75, 0x8d, 0x58, 0x19, 0x00, 0x00, +func init() { proto.RegisterFile("spec.proto", fileDescriptor_423806180556987f) } + +var fileDescriptor_423806180556987f = []byte{ + // 1991 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xdd, 0x6e, 0x1b, 0xb9, + 0x15, 0xf6, 0x68, 0x46, 0x96, 0x74, 0x24, 0xd9, 0x63, 0xda, 0x9b, 0x4e, 0x83, 0x34, 0x31, 0x06, + 0x5e, 0xac, 0x1b, 0x64, 0xdd, 0xd4, 0xdb, 0x66, 0x51, 0x14, 0x68, 0xe1, 0xb5, 0xe4, 0x8d, 0xda, + 0xac, 0x63, 0x50, 0x6a, 0x50, 0xec, 0xcd, 0x76, 0x32, 0xa6, 0xe5, 0xd9, 0x48, 0x33, 0xc2, 0x0c, + 0x95, 0x38, 0x7d, 0x80, 0x3e, 0x40, 0x6f, 0xfa, 0x0e, 0x05, 0x7a, 0xd5, 0x17, 0x28, 0x50, 0xa0, + 0x37, 0x05, 0xf2, 0x08, 0x6d, 0x1f, 0xa5, 0xe0, 0x21, 0x39, 0x7f, 0x1a, 0xd9, 0x52, 0xd1, 0x8b, + 0xbd, 0x23, 0xcf, 0x0f, 0xc9, 0x73, 0x78, 0x7e, 0x3e, 0x12, 0x20, 0x99, 0x31, 0xff, 0x68, 0x16, + 0x47, 0x3c, 0x22, 0x5b, 0x63, 0x6f, 0x3e, 0x66, 0x47, 0x53, 0x96, 0x24, 0xde, 0x98, 0x25, 0xee, + 0x7f, 0x2c, 0x68, 0x5d, 0x08, 0xce, 0x70, 0xc6, 0x7c, 0xb2, 0x0f, 0x6d, 0x21, 0xfb, 0x9c, 0x79, + 0x97, 0x41, 0x38, 0x76, 0x8c, 0x7d, 0xe3, 0xb0, 0x45, 0xf3, 0x24, 0xf2, 0x23, 0xa8, 0x07, 0x9c, + 0x4d, 0x13, 0xa7, 0xb6, 0x6f, 0x1e, 0xb6, 0x8f, 0xbf, 0x7f, 0x54, 0x5c, 0xef, 0x08, 0xd7, 0x1a, + 0x70, 0x36, 0xa5, 0x52, 0x8e, 0x1c, 0x40, 0x37, 0x48, 0x46, 0xde, 0xeb, 0x09, 0xeb, 0xc5, 0xc1, + 0x5b, 0x16, 0x3a, 0xe6, 0xbe, 0x71, 0xd8, 0xa4, 0x45, 0x22, 0xf9, 0x15, 0x6c, 0xcf, 0x62, 0xf6, + 0x3c, 0x8a, 0xde, 0x9c, 0x79, 0xc1, 0x64, 0x1e, 0xb3, 0xc4, 0xb1, 0x70, 0x83, 0xfd, 0xca, 0x0d, + 0x72, 0x82, 0xb4, 0xac, 0x48, 0x5e, 0x80, 0x3d, 0x8b, 0x12, 0x5e, 0x58, 0xac, 0xbe, 0xe2, 0x62, + 0x0b, 0x9a, 0xe4, 0x3e, 0x34, 0xaf, 0x82, 0x09, 0x3b, 0xf7, 0xa6, 0xcc, 0xd9, 0x44, 0x7f, 0xa4, + 0x73, 0x42, 0xc0, 0xe2, 0xde, 0x38, 0x71, 0x1a, 0xfb, 0xe6, 0x61, 0x8b, 0xe2, 0x98, 0x1c, 0xa6, + 0x96, 0x7c, 0xa5, 0x76, 0x71, 0x9a, 0xc8, 0x2e, 0x93, 0xc9, 0xe3, 0xec, 0x9c, 0xa9, 0x68, 0x0b, + 0x45, 0x17, 0xe8, 0xe4, 0x31, 0x6c, 0x15, 0xd5, 0x1d, 0x10, 0x92, 0x5f, 0xd4, 0x1c, 0x83, 0x96, + 0x38, 0xe4, 0x09, 0x6c, 0x97, 0xf4, 0x9d, 0x76, 0x2a, 0x5c, 0x66, 0x91, 0x23, 0x20, 0x4a, 0x7f, + 0xe8, 0xc7, 0x8c, 0x85, 0xc9, 0x75, 0xc4, 0x13, 0xa7, 0xb3, 0x6f, 0x1e, 0x76, 0x68, 0x05, 0x87, + 0x3c, 0x85, 0x5d, 0xbd, 0x44, 0x5e, 0xa1, 0x8b, 0x0a, 0x55, 0x2c, 0xf7, 0x83, 0x0e, 0x31, 0x11, + 0x16, 0xe4, 0x17, 0xd0, 0x14, 0x81, 0x31, 0x7a, 0x3f, 0x63, 0x18, 0x5f, 0x5b, 0xc7, 0xee, 0xd2, + 0x18, 0x3a, 0x1a, 0x28, 0x49, 0x9a, 0xea, 0x90, 0x4f, 0xc1, 0x4a, 0x38, 0x9b, 0x39, 0xb5, 0x7d, + 0x63, 0x69, 0xfc, 0x0d, 0x39, 0x9b, 0x51, 0x14, 0x23, 0xcf, 0xa0, 0xe1, 0x47, 0xa1, 0xcf, 0x66, + 0x1c, 0x03, 0xaf, 0x7d, 0xfc, 0xa0, 0x52, 0xe3, 0x54, 0xca, 0x50, 0x2d, 0x4c, 0x7e, 0x06, 0xcd, + 0xc4, 0x67, 0xa1, 0x17, 0x07, 0x91, 0x63, 0xa1, 0xe2, 0x0f, 0xaa, 0xb7, 0x52, 0x42, 0x34, 0x15, + 0x27, 0x5f, 0xc3, 0x2e, 0xcf, 0x42, 0x5b, 0x0b, 0x38, 0x75, 0x5c, 0xe5, 0xb0, 0x72, 0x95, 0xd1, + 0xa2, 0x3c, 0xad, 0x5a, 0x44, 0x9a, 0x33, 0x9d, 0xb2, 0x90, 0x63, 0x30, 0x2e, 0x37, 0x07, 0x65, + 0xa8, 0x16, 0x26, 0x4f, 0xa1, 0x8e, 0xcb, 0x39, 0x0d, 0xd4, 0xba, 0xbf, 0xfc, 0x14, 0x54, 0x0a, + 0x0a, 0x3f, 0x63, 0x6c, 0x37, 0x6f, 0xf1, 0xf3, 0xc8, 0x1b, 0x27, 0x32, 0xec, 0xdd, 0x6f, 0xa1, + 0xa9, 0x2f, 0x8b, 0x34, 0xc1, 0x12, 0x37, 0x60, 0x6f, 0x90, 0x36, 0x34, 0xd4, 0x51, 0x6c, 0x43, + 0x4e, 0xd0, 0xbb, 0x76, 0x8d, 0x74, 0xa0, 0xa9, 0x8d, 0xb2, 0x4d, 0xf2, 0x3d, 0xd8, 0xad, 0x70, + 0x81, 0x6d, 0x91, 0x16, 0xd4, 0x91, 0x61, 0xd7, 0xc5, 0xaa, 0x62, 0x3f, 0x7b, 0xd3, 0xfd, 0x6b, + 0x03, 0xba, 0x05, 0xe7, 0x8b, 0xa4, 0xd3, 0xee, 0x2f, 0xd6, 0xae, 0x32, 0x99, 0xdc, 0x87, 0xcd, + 0x2b, 0x2f, 0x98, 0xb0, 0x4b, 0x0c, 0xa0, 0x26, 0xe6, 0x84, 0xa2, 0x90, 0x9f, 0x42, 0xd3, 0x8f, + 0x42, 0xce, 0x6e, 0x78, 0xe2, 0x98, 0x77, 0x95, 0xb7, 0x54, 0x94, 0xfc, 0x12, 0xba, 0x7a, 0x97, + 0x01, 0x96, 0x46, 0xeb, 0x2e, 0xdd, 0xa2, 0x3c, 0x79, 0x9e, 0x26, 0xb7, 0xaa, 0x3a, 0x2a, 0x56, + 0xee, 0x2e, 0x57, 0x25, 0x3d, 0x2c, 0xa3, 0xc5, 0x02, 0xa6, 0xc2, 0x64, 0x95, 0x32, 0x5a, 0x54, + 0xac, 0x2c, 0x6e, 0x07, 0xd0, 0x65, 0x37, 0xcc, 0x9f, 0xf3, 0x20, 0x0a, 0x47, 0xc1, 0x94, 0x61, + 0x74, 0x98, 0xb4, 0x48, 0x24, 0x0f, 0xa0, 0x91, 0xbc, 0x09, 0x66, 0x33, 0x76, 0xe9, 0xb4, 0x52, + 0x27, 0x6b, 0x12, 0x79, 0x08, 0x20, 0x86, 0xfd, 0x38, 0x8e, 0xe2, 0x44, 0x96, 0x31, 0x9a, 0xa3, + 0x90, 0x2d, 0xa8, 0x0d, 0x7a, 0x4e, 0x1b, 0xaf, 0xaf, 0x36, 0xe8, 0x09, 0xf7, 0x72, 0xe6, 0xc5, + 0xbd, 0xe8, 0x5d, 0x28, 0xa2, 0x4a, 0xd6, 0xa6, 0xdb, 0xdd, 0x5b, 0x90, 0x27, 0x87, 0x60, 0x25, + 0x33, 0x2f, 0x74, 0xba, 0xe8, 0x89, 0xbd, 0xb2, 0xde, 0x70, 0xe6, 0x85, 0x14, 0x25, 0xc8, 0x00, + 0xb6, 0x53, 0x4b, 0x86, 0xdc, 0xe3, 0xf3, 0xc4, 0xd9, 0xc2, 0x12, 0xf5, 0xa8, 0xac, 0xd4, 0x2f, + 0x8a, 0xd1, 0xb2, 0x5e, 0x55, 0x1b, 0xd8, 0x5e, 0xbd, 0x0d, 0xd8, 0x2b, 0xb7, 0x81, 0x9d, 0x75, + 0xda, 0x00, 0x59, 0xb7, 0x0d, 0xec, 0xae, 0xdb, 0x06, 0xf6, 0x96, 0xb7, 0x81, 0x2b, 0xb0, 0x84, + 0xab, 0xc9, 0x1e, 0xd4, 0x13, 0xee, 0xc5, 0x1c, 0x33, 0xd4, 0xa4, 0x72, 0x42, 0x6c, 0x30, 0x59, + 0x28, 0x93, 0xd2, 0xa4, 0x62, 0x48, 0x1e, 0x40, 0x0b, 0x59, 0xa7, 0xd7, 0x5e, 0x8c, 0xb5, 0xdb, + 0xa4, 0x19, 0x81, 0x38, 0xd0, 0x60, 0xe1, 0x25, 0xf2, 0x2c, 0xe4, 0xe9, 0xa9, 0xfb, 0xef, 0x1a, + 0x38, 0xcb, 0x8a, 0x6a, 0xa1, 0xac, 0x1b, 0xeb, 0x95, 0xf5, 0x03, 0xe8, 0x62, 0x65, 0xa4, 0xd1, + 0xbb, 0x41, 0x78, 0xc9, 0x6e, 0xf0, 0xac, 0x75, 0x5a, 0x24, 0x92, 0x9f, 0xc0, 0x47, 0x5a, 0x63, + 0x54, 0x90, 0x36, 0x51, 0xba, 0x9a, 0x49, 0x9e, 0xc0, 0x4e, 0x90, 0x08, 0x04, 0x96, 0x07, 0x4a, + 0x16, 0x02, 0xa5, 0x45, 0x86, 0xd8, 0x23, 0x48, 0x86, 0xf9, 0x85, 0x94, 0x46, 0x1d, 0x35, 0xaa, + 0x99, 0xe4, 0x39, 0xec, 0xe8, 0xcd, 0x7b, 0x1e, 0xf7, 0x90, 0xa5, 0xaa, 0xc3, 0x6d, 0xed, 0x60, + 0x51, 0xc9, 0xfd, 0x93, 0xa9, 0x31, 0xa3, 0xe8, 0xb0, 0x0f, 0x01, 0x3c, 0x9f, 0xcf, 0xbd, 0xc9, + 0x88, 0xdd, 0x70, 0x55, 0x76, 0x73, 0x14, 0xc1, 0x9f, 0x79, 0x71, 0xc2, 0x2e, 0x91, 0x5f, 0x93, + 0xfc, 0x8c, 0x42, 0x9e, 0x41, 0xeb, 0x2a, 0xf6, 0xc6, 0xa2, 0x49, 0xe8, 0xb2, 0xeb, 0x94, 0xcf, + 0x73, 0xa6, 0x04, 0x68, 0x26, 0x2a, 0xda, 0xac, 0xe8, 0xf0, 0x69, 0x26, 0x52, 0x96, 0xcc, 0x27, + 0x5c, 0x35, 0xeb, 0xc3, 0xa5, 0xb8, 0xa0, 0x24, 0x4f, 0xab, 0x16, 0xa9, 0xca, 0xde, 0xfa, 0xea, + 0xd9, 0xbb, 0xb9, 0x24, 0x7b, 0xab, 0x73, 0xac, 0xb1, 0x6e, 0x8e, 0x35, 0x97, 0xe7, 0xd8, 0xbf, + 0x0c, 0xe8, 0xe4, 0xf1, 0x0c, 0xf9, 0x39, 0xb4, 0x15, 0xa2, 0x11, 0xb6, 0xab, 0x90, 0xbf, 0x05, + 0x34, 0xe5, 0xa5, 0x05, 0xd6, 0x4f, 0xb0, 0xe2, 0xde, 0x8d, 0xf5, 0x51, 0x8e, 0xfc, 0x0e, 0xee, + 0x29, 0xfd, 0xf2, 0xad, 0x98, 0x6b, 0xde, 0xca, 0x92, 0x75, 0xdc, 0x47, 0x2a, 0xf2, 0x04, 0x12, + 0x48, 0x3b, 0x94, 0x91, 0x75, 0x28, 0xf7, 0x9f, 0x06, 0x34, 0x75, 0xb4, 0x90, 0x01, 0x74, 0x74, + 0xbc, 0xe4, 0xf0, 0xe6, 0xc7, 0xcb, 0xa2, 0x2b, 0x1d, 0x20, 0xe4, 0x2c, 0xa8, 0xe2, 0x5e, 0x59, + 0xfc, 0xe2, 0x98, 0x7c, 0x0e, 0xad, 0x99, 0x17, 0x7b, 0x53, 0xc6, 0x59, 0xac, 0x2c, 0x5c, 0xf4, + 0x91, 0x16, 0xa0, 0x99, 0xac, 0xfb, 0x09, 0x74, 0xf2, 0x5b, 0x21, 0xb4, 0x61, 0x37, 0xdc, 0xde, + 0x20, 0x5d, 0x68, 0xa5, 0x1a, 0xb6, 0xe1, 0xfe, 0xb1, 0x96, 0x9b, 0x93, 0xaf, 0xa0, 0x9b, 0xae, + 0x91, 0xb3, 0xe7, 0x93, 0xa5, 0x7b, 0x66, 0x23, 0xb4, 0xa8, 0xa8, 0x2d, 0x0a, 0xf1, 0x5b, 0x6f, + 0x32, 0x67, 0xca, 0x26, 0x39, 0x11, 0x86, 0x86, 0xe2, 0xad, 0x63, 0x4a, 0x43, 0xc5, 0x38, 0x43, + 0x8f, 0xd6, 0x8a, 0xe8, 0xd1, 0xfd, 0x1a, 0xba, 0x85, 0xbd, 0x09, 0xc0, 0xa6, 0xe8, 0x8c, 0x81, + 0x2f, 0x51, 0x61, 0xef, 0x7d, 0xe8, 0x4d, 0x03, 0xdf, 0x36, 0x08, 0x81, 0x2d, 0x51, 0xdf, 0x02, + 0x6f, 0xf2, 0xcd, 0x90, 0xc7, 0x41, 0x38, 0xb6, 0x6b, 0x64, 0x07, 0xba, 0x9a, 0x26, 0xd1, 0x9f, + 0x99, 0x01, 0x41, 0xcb, 0x75, 0xd3, 0x18, 0x97, 0xd8, 0x56, 0x5f, 0x8d, 0x91, 0x5d, 0x8d, 0x7b, + 0x03, 0x90, 0x1d, 0x8a, 0x7c, 0x0e, 0x8d, 0x6b, 0xe6, 0x5d, 0xb2, 0x38, 0xb9, 0xb5, 0xe8, 0xeb, + 0x9a, 0x4c, 0xb5, 0x34, 0xf9, 0x31, 0x58, 0x71, 0xf4, 0x4e, 0x27, 0xc0, 0x1d, 0x5a, 0x28, 0xea, + 0x7e, 0xac, 0xb0, 0xa9, 0x26, 0x0b, 0x37, 0xfb, 0x6c, 0x32, 0xd1, 0x61, 0x2a, 0x27, 0xee, 0xdf, + 0x74, 0x97, 0xaa, 0x88, 0x7e, 0x72, 0x9e, 0xc3, 0x21, 0x2a, 0x81, 0xe4, 0xb9, 0x0f, 0x2a, 0x4f, + 0x50, 0x4e, 0x9e, 0xb2, 0x72, 0x05, 0xc0, 0xac, 0xfd, 0xff, 0x00, 0xa6, 0xf9, 0xbf, 0x02, 0x4c, + 0x27, 0x83, 0x89, 0xb2, 0xd5, 0xa5, 0x10, 0xf1, 0x00, 0xba, 0x6a, 0x48, 0x99, 0x97, 0x44, 0xb2, + 0xb1, 0xb5, 0x68, 0x91, 0xe8, 0x7e, 0x30, 0x61, 0xaf, 0xca, 0x7e, 0x72, 0x2f, 0xc5, 0xf8, 0x06, + 0xae, 0xab, 0xf1, 0xfd, 0x63, 0xb0, 0x63, 0xe6, 0x47, 0x6f, 0x59, 0x2c, 0xee, 0x06, 0xe1, 0xa6, + 0x7c, 0x05, 0xd0, 0x05, 0x3a, 0x71, 0xa1, 0xc3, 0xc4, 0x40, 0x43, 0x27, 0x99, 0x0e, 0x05, 0x1a, + 0x22, 0x59, 0xee, 0xf9, 0x6f, 0x46, 0xb1, 0xe7, 0xcb, 0xdc, 0x10, 0x48, 0x36, 0xa5, 0x10, 0x17, + 0x20, 0xc1, 0xe2, 0x3c, 0xbc, 0x8e, 0x38, 0xda, 0xd0, 0x41, 0xf0, 0x95, 0xa3, 0x2e, 0x22, 0xea, + 0xcd, 0x2a, 0x44, 0xed, 0x40, 0x43, 0x39, 0x56, 0xc1, 0x71, 0x3d, 0x25, 0x2f, 0xa0, 0x85, 0x67, + 0xc2, 0x7a, 0xd0, 0xc4, 0x7a, 0x70, 0xb4, 0x4a, 0x90, 0x1c, 0xf5, 0xb5, 0x16, 0xcd, 0x16, 0x10, + 0x38, 0xe4, 0x4a, 0xde, 0x4e, 0xd6, 0x55, 0x10, 0xc3, 0x77, 0xe8, 0x22, 0x03, 0x7f, 0x8b, 0x72, + 0x7d, 0x09, 0xb0, 0x2f, 0xe5, 0x49, 0xee, 0x13, 0x68, 0xa5, 0xfb, 0x88, 0xda, 0x76, 0x32, 0x1c, + 0xf6, 0xe9, 0x68, 0xf0, 0xf2, 0xdc, 0xde, 0x20, 0x36, 0x74, 0x5e, 0xf5, 0xe9, 0xe0, 0x6c, 0x70, + 0x7a, 0x82, 0x14, 0xc3, 0xfd, 0x60, 0x80, 0x5d, 0x0e, 0x9b, 0x92, 0x93, 0x8d, 0x0a, 0x27, 0x17, + 0x2f, 0xaa, 0x56, 0x71, 0x51, 0xc5, 0x8b, 0x30, 0x97, 0x5d, 0x44, 0x11, 0xde, 0x59, 0x55, 0xf0, + 0xae, 0xd2, 0x41, 0xf5, 0x25, 0x0e, 0x72, 0xff, 0xb2, 0xa9, 0x0c, 0x1a, 0xce, 0x03, 0xce, 0x54, + 0x74, 0x9e, 0xc8, 0x3f, 0x36, 0x39, 0x93, 0x55, 0xa1, 0xbd, 0xf8, 0xc0, 0x48, 0xff, 0xe4, 0x54, + 0x4e, 0xe7, 0x75, 0xbe, 0xa3, 0xf9, 0x9c, 0xa5, 0x9d, 0x55, 0x4e, 0x3b, 0x71, 0xf8, 0xe4, 0x0c, + 0xa7, 0xa7, 0xd1, 0x3c, 0x94, 0x2e, 0xab, 0xd3, 0x05, 0xfa, 0x8a, 0xe9, 0x20, 0x02, 0x6f, 0xee, + 0xfb, 0x2c, 0x49, 0xa8, 0xc7, 0xe5, 0x9f, 0x46, 0x8d, 0xe6, 0x49, 0x42, 0x82, 0x85, 0x6f, 0x83, + 0x38, 0x0a, 0xf1, 0xaf, 0xa4, 0x29, 0x3f, 0x32, 0x73, 0xa4, 0x14, 0x3c, 0xb4, 0x54, 0xd7, 0x10, + 0x80, 0x62, 0x1f, 0xda, 0xb3, 0x38, 0xfa, 0x96, 0xf9, 0x1c, 0xbf, 0xfb, 0x40, 0x6a, 0xe5, 0x48, + 0xe2, 0x51, 0xc2, 0x83, 0x29, 0x4b, 0xb8, 0x37, 0x9d, 0xa9, 0x37, 0x6a, 0x46, 0x10, 0xd1, 0x81, + 0x16, 0x0d, 0x65, 0x9d, 0x92, 0xa6, 0x76, 0xd0, 0xd4, 0x45, 0x46, 0x15, 0xc8, 0xec, 0xae, 0x0e, + 0x32, 0xb7, 0x56, 0x7e, 0x22, 0x6e, 0xaf, 0xf3, 0x44, 0xb4, 0xd7, 0x7d, 0x22, 0xee, 0xac, 0x0b, + 0x5f, 0xc9, 0x72, 0xf8, 0xfa, 0x77, 0x13, 0xb6, 0x4b, 0x81, 0x8f, 0x20, 0x4b, 0x93, 0x6e, 0xc7, + 0xaf, 0x42, 0x27, 0x93, 0xc5, 0x26, 0xa2, 0x9e, 0x2e, 0xf2, 0x22, 0xd4, 0x7b, 0xad, 0x40, 0x14, + 0x87, 0xd4, 0x84, 0x7c, 0x7c, 0xca, 0xd7, 0x5a, 0x15, 0x6b, 0x69, 0x98, 0x3f, 0x85, 0x5d, 0x39, + 0x4a, 0x1f, 0x4a, 0x54, 0x40, 0x07, 0xf1, 0x6e, 0xa8, 0xd3, 0x2a, 0xd6, 0xea, 0xb5, 0x5f, 0xb7, + 0xc9, 0x46, 0xb1, 0x4d, 0x1e, 0xc3, 0x9e, 0x3e, 0x60, 0x21, 0xe2, 0x9a, 0x78, 0xf8, 0x4a, 0x1e, + 0xea, 0xc8, 0x79, 0xf1, 0x98, 0x2d, 0x3c, 0x66, 0x25, 0x8f, 0x7c, 0x0a, 0x9b, 0x2c, 0xfb, 0xad, + 0x69, 0x1f, 0x7f, 0xb4, 0xf0, 0x1b, 0x22, 0xb8, 0x54, 0x09, 0xb9, 0xff, 0x30, 0xa0, 0x2e, 0x9b, + 0xe8, 0x67, 0x60, 0xf1, 0x0c, 0xa7, 0x3e, 0xaa, 0x54, 0xcb, 0x35, 0x22, 0x14, 0xd6, 0x1f, 0xee, + 0x08, 0x42, 0x6b, 0xd9, 0x87, 0x3b, 0x02, 0xd1, 0x87, 0x00, 0x93, 0x20, 0x64, 0xe7, 0xf3, 0xe9, + 0x6b, 0x05, 0xb9, 0xeb, 0x34, 0x47, 0xc9, 0xf7, 0x49, 0xd9, 0x8e, 0xf5, 0xd4, 0x3d, 0xce, 0x77, + 0xa2, 0x6d, 0x68, 0x5f, 0x9c, 0xd0, 0x61, 0xff, 0x9b, 0x3e, 0xa5, 0x2f, 0xa9, 0xbd, 0x41, 0xf6, + 0xc0, 0x7e, 0x75, 0xf2, 0x62, 0xd0, 0xc3, 0x4e, 0xa4, 0xa8, 0x86, 0xfb, 0x07, 0x03, 0xb6, 0x52, + 0x8c, 0xf6, 0x0a, 0xd1, 0x31, 0x7e, 0x4a, 0xa8, 0x89, 0x6a, 0x46, 0x19, 0x81, 0x3c, 0x83, 0x7b, + 0x29, 0xc4, 0x0e, 0x7e, 0xcf, 0x2e, 0x53, 0x3d, 0x65, 0xc8, 0x12, 0xae, 0x7a, 0x22, 0x4b, 0x8e, + 0x7c, 0x03, 0xcb, 0x27, 0xb2, 0xa2, 0x3c, 0xfe, 0x12, 0xb6, 0x4b, 0x1f, 0x4e, 0xc2, 0x84, 0xf3, + 0x97, 0xa3, 0xfe, 0x6f, 0xfb, 0xa7, 0xbf, 0x19, 0xf5, 0x7b, 0xf6, 0x86, 0x00, 0xd8, 0x17, 0xa2, + 0xbd, 0xf6, 0x6c, 0x43, 0x8c, 0xcf, 0x4e, 0x06, 0x2f, 0xfa, 0x3d, 0xbb, 0x26, 0xc0, 0xf6, 0xf0, + 0xd7, 0x83, 0x8b, 0x8b, 0x7e, 0xcf, 0x36, 0xbf, 0xf8, 0xa1, 0x78, 0xa0, 0x4d, 0x8f, 0xf8, 0x75, + 0x34, 0x1f, 0x5f, 0xf3, 0x77, 0x51, 0xfc, 0x26, 0x91, 0x97, 0xf2, 0xe7, 0xda, 0xd6, 0x97, 0x78, + 0x39, 0xba, 0x8e, 0xbc, 0xde, 0xc4, 0x4c, 0xfa, 0xec, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xa4, + 0xd0, 0xe1, 0x52, 0x3d, 0x1a, 0x00, 0x00, } diff --git a/parser/convert.go b/parser/convert.go index ce288b61b..56090151c 100644 --- a/parser/convert.go +++ b/parser/convert.go @@ -5,6 +5,7 @@ import ( "regexp" "strings" + "github.com/getgauge/gauge/env" "github.com/getgauge/gauge/gauge" "github.com/getgauge/gauge/util" ) @@ -49,7 +50,7 @@ func (parser *SpecParser) initializeConverters() []func(*Token, *int, *gauge.Spe return token.Kind == gauge.StepKind && isInState(*state, scenarioScope) }, func(token *Token, spec *gauge.Specification, state *int) ParseResult { latestScenario := spec.LatestScenario() - stepToAdd, parseDetails := createStep(spec, token) + stepToAdd, parseDetails := createStep(spec, latestScenario, token) if stepToAdd == nil { return ParseResult{ParseErrors: parseDetails.ParseErrors, Ok: false, Warnings: parseDetails.Warnings} } @@ -68,7 +69,7 @@ func (parser *SpecParser) initializeConverters() []func(*Token, *int, *gauge.Spe contextConverter := converterFn(func(token *Token, state *int) bool { return token.Kind == gauge.StepKind && !isInState(*state, scenarioScope) && isInState(*state, specScope) && !isInState(*state, tearDownScope) }, func(token *Token, spec *gauge.Specification, state *int) ParseResult { - stepToAdd, parseDetails := createStep(spec, token) + stepToAdd, parseDetails := createStep(spec, nil, token) if stepToAdd == nil { return ParseResult{ParseErrors: parseDetails.ParseErrors, Ok: false, Warnings: parseDetails.Warnings} } @@ -97,7 +98,7 @@ func (parser *SpecParser) initializeConverters() []func(*Token, *int, *gauge.Spe tearDownStepConverter := converterFn(func(token *Token, state *int) bool { return token.Kind == gauge.StepKind && isInState(*state, tearDownScope) }, func(token *Token, spec *gauge.Specification, state *int) ParseResult { - stepToAdd, parseDetails := createStep(spec, token) + stepToAdd, parseDetails := createStep(spec, nil, token) if stepToAdd == nil { return ParseResult{ParseErrors: parseDetails.ParseErrors, Ok: false, Warnings: parseDetails.Warnings} } @@ -158,7 +159,7 @@ func (parser *SpecParser) initializeConverters() []func(*Token, *int, *gauge.Spe }) tableHeaderConverter := converterFn(func(token *Token, state *int) bool { - return token.Kind == gauge.TableHeader && isInState(*state, specScope) + return token.Kind == gauge.TableHeader && isInAnyState(*state, specScope) }, func(token *Token, spec *gauge.Specification, state *int) ParseResult { if isInState(*state, stepScope) { latestScenario := spec.LatestScenario() @@ -174,21 +175,27 @@ func (parser *SpecParser) initializeConverters() []func(*Token, *int, *gauge.Spe } else { spec.AddComment(&gauge.Comment{Value: token.LineText, LineNo: token.LineNo}) } - } else if !isInState(*state, scenarioScope) { + } else if isInState(*state, scenarioScope) { + scn := spec.LatestScenario() + if !scn.DataTable.Table.IsInitialized() && env.AllowScenarioDatatable() { + dataTable := &gauge.Table{LineNo: token.LineNo} + dataTable.AddHeaders(token.Args) + scn.AddDataTable(dataTable) + } else { + scn.AddComment(&gauge.Comment{Value: token.LineText, LineNo: token.LineNo}) + return ParseResult{Ok: false, Warnings: []*Warning{ + &Warning{spec.FileName, token.LineNo, "Multiple data table present, ignoring table"}}} + } + } else { if !spec.DataTable.Table.IsInitialized() { - dataTable := &gauge.Table{} - dataTable.LineNo = token.LineNo + dataTable := &gauge.Table{LineNo: token.LineNo} dataTable.AddHeaders(token.Args) spec.AddDataTable(dataTable) } else { - value := "Multiple data table present, ignoring table" spec.AddComment(&gauge.Comment{Value: token.LineText, LineNo: token.LineNo}) - return ParseResult{Ok: false, Warnings: []*Warning{&Warning{spec.FileName, token.LineNo, value}}} + return ParseResult{Ok: false, Warnings: []*Warning{&Warning{spec.FileName, + token.LineNo, "Multiple data table present, ignoring table"}}} } - } else { - value := "Table not associated with a step, ignoring table" - spec.LatestScenario().AddComment(&gauge.Comment{Value: token.LineText, LineNo: token.LineNo}) - return ParseResult{Ok: false, Warnings: []*Warning{&Warning{spec.FileName, token.LineNo, value}}} } retainStates(state, specScope, scenarioScope, stepScope, contextScope, tearDownScope) addStates(state, tableScope) @@ -214,23 +221,28 @@ func (parser *SpecParser) initializeConverters() []func(*Token, *int, *gauge.Spe } else if isInState(*state, stepScope) { latestScenario := spec.LatestScenario() latestStep := latestScenario.LatestStep() - result = addInlineTableRow(latestStep, token, new(gauge.ArgLookup).FromDataTable(&spec.DataTable.Table), spec.FileName) + result = addInlineTableRow(latestStep, token, new(gauge.ArgLookup).FromDataTables(&spec.DataTable.Table), spec.FileName) } else if isInState(*state, contextScope) { latestContext := spec.LatestContext() - result = addInlineTableRow(latestContext, token, new(gauge.ArgLookup).FromDataTable(&spec.DataTable.Table), spec.FileName) + result = addInlineTableRow(latestContext, token, new(gauge.ArgLookup).FromDataTables(&spec.DataTable.Table), spec.FileName) } else if isInState(*state, tearDownScope) { if len(spec.TearDownSteps) > 0 { latestTeardown := spec.LatestTeardown() - result = addInlineTableRow(latestTeardown, token, new(gauge.ArgLookup).FromDataTable(&spec.DataTable.Table), spec.FileName) + result = addInlineTableRow(latestTeardown, token, new(gauge.ArgLookup).FromDataTables(&spec.DataTable.Table), spec.FileName) } else { spec.AddComment(&gauge.Comment{Value: token.LineText, LineNo: token.LineNo}) } } else { - tableValues, warnings, err := validateTableRows(token, new(gauge.ArgLookup).FromDataTable(&spec.DataTable.Table), spec.FileName) + t := spec.DataTable + if isInState(*state, scenarioScope) && env.AllowScenarioDatatable() { + t = spec.LatestScenario().DataTable + } + + tableValues, warnings, err := validateTableRows(token, new(gauge.ArgLookup).FromDataTables(&t.Table), spec.FileName) if len(err) > 0 { result = ParseResult{Ok: false, Warnings: warnings, ParseErrors: err} } else { - spec.DataTable.Table.AddRowValues(tableValues) + t.Table.AddRowValues(tableValues) result = ParseResult{Ok: true, Warnings: warnings} } } diff --git a/parser/dataTableSpecs.go b/parser/dataTableSpecs.go index 8555bb753..77f6729cc 100644 --- a/parser/dataTableSpecs.go +++ b/parser/dataTableSpecs.go @@ -18,6 +18,7 @@ package parser import ( + "github.com/getgauge/gauge/env" "github.com/getgauge/gauge/gauge" ) @@ -40,6 +41,7 @@ func GetSpecsForDataTableRows(s []*gauge.Specification, errMap *gauge.BuildError } } } else { + spec.Scenarios = copyScenarios(spec.Scenarios, gauge.Table{}, 0, errMap) specs = append(specs, spec) } } @@ -81,21 +83,35 @@ func createSpec(scns []*gauge.Scenario, table *gauge.Table, spec *gauge.Specific } func copyScenarios(scenarios []*gauge.Scenario, table gauge.Table, i int, errMap *gauge.BuildErrors) (scns []*gauge.Scenario) { - for _, scn := range scenarios { + var create = func(scn *gauge.Scenario, scnTableRow gauge.Table, scnTableRowIndex int) *gauge.Scenario { newScn := &gauge.Scenario{ - Steps: scn.Steps, - Items: scn.Items, - Heading: scn.Heading, - DataTableRow: table, - DataTableRowIndex: i, - Tags: scn.Tags, - Comments: scn.Comments, - Span: scn.Span, + Steps: scn.Steps, + Items: scn.Items, + Heading: scn.Heading, + SpecDataTableRow: table, + SpecDataTableRowIndex: i, + Tags: scn.Tags, + Comments: scn.Comments, + Span: scn.Span, + } + if scnTableRow.IsInitialized() { + newScn.ScenarioDataTableRow = scnTableRow + newScn.ScenarioDataTableRowIndex = scnTableRowIndex } if len(errMap.ScenarioErrs[scn]) > 0 { errMap.ScenarioErrs[newScn] = errMap.ScenarioErrs[scn] } - scns = append(scns, newScn) + return newScn + } + for _, scn := range scenarios { + if scn.DataTable.IsInitialized() && env.AllowScenarioDatatable() { + for i := range scn.DataTable.Table.Rows() { + t := getTableWithOneRow(scn.DataTable.Table, i) + scns = append(scns, create(scn, *t, i)) + } + } else { + scns = append(scns, create(scn, gauge.Table{}, 0)) + } } return } diff --git a/parser/dataTableSpecs_test.go b/parser/dataTableSpecs_test.go index 4d9581488..aa79f39f7 100644 --- a/parser/dataTableSpecs_test.go +++ b/parser/dataTableSpecs_test.go @@ -147,9 +147,9 @@ func TestCreateSpecsForTableRows(t *testing.T) { want := []*gauge.Specification{ { Heading: &gauge.Heading{}, - Scenarios: []*gauge.Scenario{{Steps: []*gauge.Step{{Args: []*gauge.StepArg{{Value: "header", ArgType: gauge.Dynamic, Name: "header"}}}}, DataTableRow: *gauge.NewTable([]string{"header"}, [][]gauge.TableCell{ + Scenarios: []*gauge.Scenario{{Steps: []*gauge.Step{{Args: []*gauge.StepArg{{Value: "header", ArgType: gauge.Dynamic, Name: "header"}}}}, SpecDataTableRow: *gauge.NewTable([]string{"header"}, [][]gauge.TableCell{ {{Value: "row1", CellType: gauge.Static}}, - }, 0), DataTableRowIndex: 0}}, + }, 0), SpecDataTableRowIndex: 0}}, DataTable: gauge.DataTable{Table: *gauge.NewTable([]string{"header"}, [][]gauge.TableCell{ {{Value: "row1", CellType: gauge.Static}}, }, 0)}, @@ -158,17 +158,17 @@ func TestCreateSpecsForTableRows(t *testing.T) { &gauge.DataTable{Table: *gauge.NewTable([]string{"header"}, [][]gauge.TableCell{ {{Value: "row1", CellType: gauge.Static}}, }, 0)}, - &gauge.Scenario{Steps: []*gauge.Step{{Args: []*gauge.StepArg{{Value: "header", ArgType: gauge.Dynamic, Name: "header"}}}}, DataTableRow: *gauge.NewTable([]string{"header"}, [][]gauge.TableCell{ + &gauge.Scenario{Steps: []*gauge.Step{{Args: []*gauge.StepArg{{Value: "header", ArgType: gauge.Dynamic, Name: "header"}}}}, SpecDataTableRow: *gauge.NewTable([]string{"header"}, [][]gauge.TableCell{ {{Value: "row1", CellType: gauge.Static}}, - }, 0), DataTableRowIndex: 0}, + }, 0), SpecDataTableRowIndex: 0}, }, TearDownSteps: []*gauge.Step{{Args: []*gauge.StepArg{{Value: "abc", ArgType: gauge.Static}}}}, }, { Heading: &gauge.Heading{}, - Scenarios: []*gauge.Scenario{{Steps: []*gauge.Step{{Args: []*gauge.StepArg{{Value: "header", ArgType: gauge.Dynamic, Name: "header"}}}}, DataTableRow: *gauge.NewTable([]string{"header"}, [][]gauge.TableCell{ + Scenarios: []*gauge.Scenario{{Steps: []*gauge.Step{{Args: []*gauge.StepArg{{Value: "header", ArgType: gauge.Dynamic, Name: "header"}}}}, SpecDataTableRow: *gauge.NewTable([]string{"header"}, [][]gauge.TableCell{ {{Value: "row2", CellType: gauge.Static}}, - }, 0), DataTableRowIndex: 1}}, + }, 0), SpecDataTableRowIndex: 1}}, DataTable: gauge.DataTable{Table: *gauge.NewTable([]string{"header"}, [][]gauge.TableCell{ {{Value: "row2", CellType: gauge.Static}}, }, 0)}, @@ -177,9 +177,9 @@ func TestCreateSpecsForTableRows(t *testing.T) { &gauge.DataTable{Table: *gauge.NewTable([]string{"header"}, [][]gauge.TableCell{ {{Value: "row2", CellType: gauge.Static}}, }, 0)}, - &gauge.Scenario{Steps: []*gauge.Step{{Args: []*gauge.StepArg{{Value: "header", ArgType: gauge.Dynamic, Name: "header"}}}}, DataTableRow: *gauge.NewTable([]string{"header"}, [][]gauge.TableCell{ + &gauge.Scenario{Steps: []*gauge.Step{{Args: []*gauge.StepArg{{Value: "header", ArgType: gauge.Dynamic, Name: "header"}}}}, SpecDataTableRow: *gauge.NewTable([]string{"header"}, [][]gauge.TableCell{ {{Value: "row2", CellType: gauge.Static}}, - }, 0), DataTableRowIndex: 1}, + }, 0), SpecDataTableRowIndex: 1}, }, TearDownSteps: []*gauge.Step{{Args: []*gauge.StepArg{{Value: "abc", ArgType: gauge.Static}}}}, }, diff --git a/parser/lex.go b/parser/lex.go index b23cd2e8d..8a3ffaf38 100644 --- a/parser/lex.go +++ b/parser/lex.go @@ -20,14 +20,12 @@ package parser import ( "bufio" "fmt" - "os" "regexp" "strings" "github.com/getgauge/common" "github.com/getgauge/gauge/env" "github.com/getgauge/gauge/gauge" - "github.com/getgauge/gauge/util" ) const ( @@ -70,7 +68,7 @@ func (parser *SpecParser) initialize() { parser.processors[gauge.TearDownKind] = processTearDown } -// GenerateTokens generates tokens based on the parsed line. +// GenerateTokens gets tokens based on the parsed line. func (parser *SpecParser) GenerateTokens(specText, fileName string) ([]*Token, []ParseError) { parser.initialize() parser.scanner = bufio.NewScanner(strings.NewReader(specText)) @@ -130,7 +128,7 @@ func (parser *SpecParser) GenerateTokens(specText, fileName string) ([]*Token, [ newToken = &Token{Kind: gauge.DataTableKind, LineNo: parser.lineNo, LineText: line, Value: value} } else if parser.isTearDown(trimmedLine) { newToken = &Token{Kind: gauge.TearDownKind, LineNo: parser.lineNo, LineText: line, Value: trimmedLine} - } else if shouldAllowMultiLineStep() && newToken != nil && newToken.Kind == gauge.StepKind && !isInState(parser.currentState, newLineScope) { + } else if env.AllowMultiLineStep() && newToken != nil && newToken.Kind == gauge.StepKind && !isInState(parser.currentState, newLineScope) { v := fmt.Sprintf("%s %s", newToken.LineText, trimmedLine) newToken = &Token{Kind: gauge.StepKind, LineNo: newToken.LineNo, LineText: strings.TrimSpace(v), Value: strings.TrimSpace(v)} errors = errors[:lastTokenErrorCount] @@ -145,10 +143,6 @@ func (parser *SpecParser) GenerateTokens(specText, fileName string) ([]*Token, [ return parser.tokens, errors } -func shouldAllowMultiLineStep() bool { - return util.ConvertToBool(os.Getenv(env.AllowMultilineStep), env.AllowMultilineStep, false) -} - func (parser *SpecParser) tokenKindBasedOnCurrentState(state int, matchingToken gauge.TokenKind, alternateToken gauge.TokenKind) gauge.TokenKind { if isInState(parser.currentState, state) { return matchingToken diff --git a/parser/lex_test.go b/parser/lex_test.go index b6045ffc6..8e220b9ae 100644 --- a/parser/lex_test.go +++ b/parser/lex_test.go @@ -1,8 +1,6 @@ package parser import ( - "os" - "github.com/getgauge/gauge/env" "github.com/getgauge/gauge/gauge" . "gopkg.in/check.v1" @@ -508,6 +506,41 @@ func (s *MySuite) TestParsingSpecWithMultipleLines(c *C) { } +func (s *MySuite) TestParsingSimpleScenarioDataTable(c *C) { + parser := new(SpecParser) + specText := newSpecBuilder().specHeading("Spec heading"). + scenarioHeading("Scenario Heading"). + text("|name|id|"). + text("|---|---|"). + text("|john|123|"). + text("|james|007|").String() + + tokens, err := parser.GenerateTokens(specText, "") + c.Assert(err, IsNil) + c.Assert(len(tokens), Equals, 6) + + c.Assert(tokens[2].Kind, Equals, gauge.TableHeader) + c.Assert(len(tokens[2].Args), Equals, 2) + c.Assert(tokens[2].Args[0], Equals, "name") + c.Assert(tokens[2].Args[1], Equals, "id") + + c.Assert(tokens[3].Kind, Equals, gauge.TableRow) + c.Assert(len(tokens[3].Args), Equals, 2) + c.Assert(tokens[3].Args[0], Equals, "---") + c.Assert(tokens[3].Args[1], Equals, "---") + + c.Assert(tokens[4].Kind, Equals, gauge.TableRow) + c.Assert(len(tokens[4].Args), Equals, 2) + c.Assert(tokens[4].Args[0], Equals, "john") + c.Assert(tokens[4].Args[1], Equals, "123") + + c.Assert(tokens[5].Kind, Equals, gauge.TableRow) + c.Assert(len(tokens[5].Args), Equals, 2) + c.Assert(tokens[5].Args[0], Equals, "james") + c.Assert(tokens[5].Args[1], Equals, "007") + +} + func (s *MySuite) TestParsingStepWIthNewlineAndTableParam(c *C) { parser := new(SpecParser) specText := newSpecBuilder(). @@ -527,7 +560,7 @@ func (s *MySuite) TestParsingStepWIthNewlineAndTableParam(c *C) { } func (s *MySuite) TestParsingMultilineStep(c *C) { - os.Setenv(env.AllowMultilineStep, "true") + env.AllowMultiLineStep = func() bool { return true } parser := new(SpecParser) specText := newSpecBuilder(). step("step1"). @@ -539,11 +572,10 @@ func (s *MySuite) TestParsingMultilineStep(c *C) { c.Assert(tokens[0].Kind, Equals, gauge.StepKind) c.Assert(tokens[0].Value, Equals, "step1 second line") - os.Setenv(env.AllowMultilineStep, "false") } func (s *MySuite) TestParsingMultilineStepWithParams(c *C) { - os.Setenv(env.AllowMultilineStep, "true") + env.AllowMultiLineStep = func() bool { return true } parser := new(SpecParser) specText := newSpecBuilder(). step("step1"). @@ -557,11 +589,10 @@ func (s *MySuite) TestParsingMultilineStepWithParams(c *C) { c.Assert(tokens[0].Kind, Equals, gauge.StepKind) c.Assert(tokens[0].Value, Equals, "step1 second line {static} third line {dynamic}") c.Assert(len(tokens[0].Args), Equals, 2) - os.Setenv(env.AllowMultilineStep, "false") } func (s *MySuite) TestParsingMultilineStepWithTableParam(c *C) { - os.Setenv(env.AllowMultilineStep, "true") + env.AllowMultiLineStep = func() bool { return true } parser := new(SpecParser) specText := newSpecBuilder(). step("step1"). @@ -577,12 +608,10 @@ func (s *MySuite) TestParsingMultilineStepWithTableParam(c *C) { c.Assert(tokens[0].Kind, Equals, gauge.StepKind) c.Assert(tokens[1].Kind, Equals, gauge.TableHeader) c.Assert(tokens[2].Kind, Equals, gauge.TableRow) - - os.Setenv(env.AllowMultilineStep, "false") } func (s *MySuite) TestParsingMultilineStepScenarioNext(c *C) { - os.Setenv(env.AllowMultilineStep, "true") + env.AllowMultiLineStep = func() bool { return true } parser := new(SpecParser) specText := newSpecBuilder(). step("step1"). @@ -596,12 +625,10 @@ func (s *MySuite) TestParsingMultilineStepScenarioNext(c *C) { c.Assert(tokens[0].Kind, Equals, gauge.StepKind) c.Assert(tokens[0].Value, Equals, "step1 Scenario1") c.Assert(tokens[1].Kind, Equals, gauge.CommentKind) - - os.Setenv(env.AllowMultilineStep, "false") } func (s *MySuite) TestParsingMultilineStepWithSpecNext(c *C) { - os.Setenv(env.AllowMultilineStep, "true") + env.AllowMultiLineStep = func() bool { return true } parser := new(SpecParser) specText := newSpecBuilder(). step("step1"). @@ -616,7 +643,6 @@ func (s *MySuite) TestParsingMultilineStepWithSpecNext(c *C) { c.Assert(tokens[0].Value, Equals, "step1 Concept1") c.Assert(tokens[1].Kind, Equals, gauge.CommentKind) - os.Setenv(env.AllowMultilineStep, "false") } func (s *MySuite) TestParsingSpecWithTearDownSteps(c *C) { diff --git a/parser/resolver.go b/parser/resolver.go index 5023e7714..495be64c3 100644 --- a/parser/resolver.go +++ b/parser/resolver.go @@ -36,16 +36,28 @@ type specialTypeResolver struct { predefinedResolvers map[string]resolverFn } -// ParamResolver resolves dynamic parameters -type ParamResolver struct { -} - func (invalidSpecialParamError invalidSpecialParamError) Error() string { return invalidSpecialParamError.message } -// GetResolvedParams based on the arg type(static, dynamic, table, special_string, special_table) resolves the parameter of a step. -func (paramResolver *ParamResolver) GetResolvedParams(step *gauge.Step, parent *gauge.Step, lookup *gauge.ArgLookup) ([]*gauge_messages.Parameter, error) { +//Resolve takes a step, a lookup and updates the target after reconciling the dynamic paramters from the given lookup +func Resolve(step *gauge.Step, parent *gauge.Step, lookup *gauge.ArgLookup, target *gauge_messages.ProtoStep) error { + stepParameters, err := getResolvedParams(step, parent, lookup) + if err != nil { + return err + } + paramIndex := 0 + for fragmentIndex, fragment := range target.Fragments { + if fragment.GetFragmentType() == gauge_messages.Fragment_Parameter { + target.Fragments[fragmentIndex].Parameter = stepParameters[paramIndex] + paramIndex++ + } + } + return nil +} + +// getResolvedParams based on the arg type(static, dynamic, table, special_string, special_table) resolves the parameter of a step. +func getResolvedParams(step *gauge.Step, parent *gauge.Step, lookup *gauge.ArgLookup) ([]*gauge_messages.Parameter, error) { parameters := make([]*gauge_messages.Parameter, 0) for _, arg := range step.Args { parameter := new(gauge_messages.Parameter) @@ -68,7 +80,7 @@ func (paramResolver *ParamResolver) GetResolvedParams(step *gauge.Step, parent * parameter.Name = resolvedArg.Name if resolvedArg.Table.IsInitialized() { parameter.ParameterType = gauge_messages.Parameter_Special_Table - table, err := paramResolver.createProtoStepTable(&resolvedArg.Table, lookup) + table, err := createProtoStepTable(&resolvedArg.Table, lookup) if err != nil { return nil, err } @@ -82,14 +94,14 @@ func (paramResolver *ParamResolver) GetResolvedParams(step *gauge.Step, parent * parameter.Value = arg.Value } else if arg.ArgType == gauge.SpecialTable { parameter.ParameterType = gauge_messages.Parameter_Special_Table - table, err := paramResolver.createProtoStepTable(&arg.Table, lookup) + table, err := createProtoStepTable(&arg.Table, lookup) if err != nil { return nil, err } parameter.Table = table } else { parameter.ParameterType = gauge_messages.Parameter_Table - table, err := paramResolver.createProtoStepTable(&arg.Table, lookup) + table, err := createProtoStepTable(&arg.Table, lookup) if err != nil { return nil, err } @@ -101,7 +113,7 @@ func (paramResolver *ParamResolver) GetResolvedParams(step *gauge.Step, parent * return parameters, nil } -func (paramResolver *ParamResolver) createProtoStepTable(table *gauge.Table, lookup *gauge.ArgLookup) (*gauge_messages.ProtoTable, error) { +func createProtoStepTable(table *gauge.Table, lookup *gauge.ArgLookup) (*gauge_messages.ProtoTable, error) { protoTable := new(gauge_messages.ProtoTable) protoTable.Headers = &gauge_messages.ProtoTableRow{Cells: table.Headers} tableRows := make([]*gauge_messages.ProtoTableRow, 0) diff --git a/parser/resolver_test.go b/parser/resolver_test.go index 87858e397..0c4f94b2f 100644 --- a/parser/resolver_test.go +++ b/parser/resolver_test.go @@ -99,7 +99,8 @@ func (s *MySuite) TestPopulatingConceptLookup(c *C) { spec, _, _ := parser.Parse(specText, conceptDictionary, "") concept := spec.Scenarios[0].Steps[0] - dataTableLookup, _ := new(gauge.ArgLookup).FromDataTableRow(&spec.DataTable.Table, 0) + dataTableLookup := new(gauge.ArgLookup) + dataTableLookup.ReadDataTableRow(&spec.DataTable.Table, 0) err := PopulateConceptDynamicParams(concept, dataTableLookup) c.Assert(err, IsNil) useridArg, _ := concept.GetArg("user-id") @@ -127,7 +128,8 @@ func (s *MySuite) TestPopulatingNestedConceptLookup(c *C) { spec, _, _ := parser.Parse(specText, conceptDictionary, "") concept1 := spec.Scenarios[0].Steps[0] - dataTableLookup, _ := new(gauge.ArgLookup).FromDataTableRow(&spec.DataTable.Table, 0) + dataTableLookup := new(gauge.ArgLookup) + dataTableLookup.ReadDataTableRow(&spec.DataTable.Table, 0) err := PopulateConceptDynamicParams(concept1, dataTableLookup) c.Assert(err, IsNil) @@ -173,7 +175,8 @@ func (s *MySuite) TestPopulatingNestedConceptsWithStaticParametersLookup(c *C) { spec, _, _ := parser.Parse(specText, conceptDictionary, "") concept1 := spec.Scenarios[0].Steps[0] - dataTableLookup, _ := new(gauge.ArgLookup).FromDataTableRow(&spec.DataTable.Table, 0) + dataTableLookup := new(gauge.ArgLookup) + dataTableLookup.ReadDataTableRow(&spec.DataTable.Table, 0) err := PopulateConceptDynamicParams(concept1, dataTableLookup) c.Assert(err, IsNil) useridArg1, _ := concept1.GetArg("user-id") @@ -223,9 +226,8 @@ func (s *MySuite) TestGetResolveParameterFromTable(c *C) { specs, _ := parser.ParseSpecText(specText, "") step := specs.Steps()[0] - paramResolver := new(ParamResolver) - parameters, err := paramResolver.GetResolvedParams(step, nil, nil) + parameters, err := getResolvedParams(step, nil, nil) c.Assert(len(parameters), Equals, 1) c.Assert(parameters[0].Table.Rows[0].GetCells()[0], Equals, "john") diff --git a/parser/specparser.go b/parser/specparser.go index 88ad44dc2..e652d9786 100644 --- a/parser/specparser.go +++ b/parser/specparser.go @@ -132,8 +132,12 @@ func (parser *SpecParser) validateSpec(specification *gauge.Specification) error return nil } -func createStep(spec *gauge.Specification, stepToken *Token) (*gauge.Step, *ParseResult) { - dataTableLookup := new(gauge.ArgLookup).FromDataTable(&spec.DataTable.Table) +func createStep(spec *gauge.Specification, scn *gauge.Scenario, stepToken *Token) (*gauge.Step, *ParseResult) { + tables := []*gauge.Table{&spec.DataTable.Table} + if scn != nil { + tables = append(tables, &scn.DataTable.Table) + } + dataTableLookup := new(gauge.ArgLookup).FromDataTables(tables...) stepToAdd, parseDetails := CreateStepUsingLookup(stepToken, dataTableLookup, spec.FileName) if stepToAdd != nil { stepToAdd.Suffix = stepToken.Suffix diff --git a/parser/specparser_test.go b/parser/specparser_test.go index eb999f056..c608713e0 100644 --- a/parser/specparser_test.go +++ b/parser/specparser_test.go @@ -19,8 +19,10 @@ package parser import ( "path/filepath" + "strings" "testing" + "github.com/getgauge/gauge/env" "github.com/getgauge/gauge/gauge" . "gopkg.in/check.v1" @@ -351,6 +353,73 @@ func (s *MySuite) TestSpecWithDataTable(c *C) { c.Assert(nameCells[1].CellType, Equals, gauge.Static) } +func TestScenarioWithDataTable(t *testing.T) { + var subject = func() *gauge.Scenario { + tokens := []*Token{ + &Token{Kind: gauge.SpecKind, Value: "Spec Heading"}, + &Token{Kind: gauge.CommentKind, Value: "Comment before data table"}, + &Token{Kind: gauge.ScenarioKind, Value: "Scenario heading"}, + &Token{Kind: gauge.CommentKind, Value: "Comment before data table"}, + &Token{Kind: gauge.TableHeader, Args: []string{"id", "name"}}, + &Token{Kind: gauge.TableRow, Args: []string{"1", "foo"}}, + &Token{Kind: gauge.TableRow, Args: []string{"2", "bar"}}, + &Token{Kind: gauge.StepKind, Value: "my step"}, + } + spec, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "") + if err != nil { + t.Error(err) + } + v := len(spec.Items) + if v != 2 { + t.Errorf("expected spec to have 2 items. got %d", v) + } + if !result.Ok { + t.Errorf("parse failed, err %s", strings.Join(result.Errors(), ",")) + } + + return spec.Scenarios[0] + } + + t.Run("Scenario with datatable when AllowScenarioDatatable=True", func(t *testing.T) { + env.AllowScenarioDatatable = func() bool { return true } + s := subject() + if &s.DataTable.Table == nil { + t.Error("expected scenario datatable to be not nil") + } + v := len(s.Items) + if v != 3 { + t.Errorf("expected scenario to have 3 items, got %d", v) + } + + idCells, _ := s.DataTable.Table.Get("id") + nameCells, _ := s.DataTable.Table.Get("name") + + var assertEqual = func(e, a interface{}) { + if e != a { + t.Errorf("expected %v got %v", e, a) + } + } + assertEqual(len(idCells), 2) + assertEqual(len(nameCells), 2) + assertEqual(idCells[0].Value, "1") + assertEqual(idCells[0].CellType, gauge.Static) + assertEqual(idCells[1].Value, "2") + assertEqual(idCells[1].CellType, gauge.Static) + assertEqual(nameCells[0].Value, "foo") + assertEqual(nameCells[0].CellType, gauge.Static) + assertEqual(nameCells[1].Value, "bar") + assertEqual(nameCells[1].CellType, gauge.Static) + }) + t.Run("Parse Scenario with datatable when AllowScenarioDatatable=False", func(t *testing.T) { + env.AllowScenarioDatatable = func() bool { return false } + s := subject() + if s.DataTable.Table.IsInitialized() { + t.Error("expected scenario to have no datatable, got one") + } + }) + +} + func (s *MySuite) TestSpecWithDataTableHavingEmptyRowAndNoSeparator(c *C) { tokens := []*Token{ &Token{Kind: gauge.SpecKind, Value: "Spec Heading"}, @@ -590,29 +659,6 @@ func (s *MySuite) TestParseErrorWhenCouldNotResolveExternalDataTable(c *C) { } -func (s *MySuite) TestWarningWhenParsingTableOccursWithoutStep(c *C) { - tokens := []*Token{ - &Token{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1}, - &Token{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 2}, - &Token{Kind: gauge.TableHeader, Args: []string{"id", "name"}, LineNo: 3}, - &Token{Kind: gauge.TableRow, Args: []string{"1", "foo"}, LineNo: 4}, - &Token{Kind: gauge.TableRow, Args: []string{"2", "bar"}, LineNo: 5}, - &Token{Kind: gauge.StepKind, Value: "Step", LineNo: 6}, - &Token{Kind: gauge.CommentKind, Value: "comment in between", LineNo: 7}, - &Token{Kind: gauge.TableHeader, Args: []string{"phone"}, LineNo: 8}, - &Token{Kind: gauge.TableRow, Args: []string{"1"}}, - &Token{Kind: gauge.TableRow, Args: []string{"2"}}, - } - - _, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "foo.spec") - c.Assert(err, IsNil) - c.Assert(result.Ok, Equals, true) - c.Assert(len(result.Warnings), Equals, 2) - c.Assert(result.Warnings[0].String(), Equals, "foo.spec:3 Table not associated with a step, ignoring table") - c.Assert(result.Warnings[1].String(), Equals, "foo.spec:8 Table not associated with a step, ignoring table") - -} - func (s *MySuite) TestAddSpecTags(c *C) { tokens := []*Token{ &Token{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1}, @@ -665,7 +711,6 @@ func (s *MySuite) TestErrorOnAddingDynamicParamterWithoutADataTable(c *C) { c.Assert(result.Ok, Equals, false) c.Assert(result.ParseErrors[0].Message, Equals, "Dynamic parameter could not be resolved") c.Assert(result.ParseErrors[0].LineNo, Equals, 3) - } func (s *MySuite) TestErrorOnAddingDynamicParamterWithoutDataTableHeaderValue(c *C) { @@ -683,7 +728,22 @@ func (s *MySuite) TestErrorOnAddingDynamicParamterWithoutDataTableHeaderValue(c c.Assert(result.Ok, Equals, false) c.Assert(result.ParseErrors[0].Message, Equals, "Dynamic parameter could not be resolved") c.Assert(result.ParseErrors[0].LineNo, Equals, 5) +} + +func (s *MySuite) TestResolveScenarioDataTableAsDynamicParams(c *C) { + env.AllowScenarioDatatable = func() bool { return true } + tokens := []*Token{ + &Token{Kind: gauge.SpecKind, Value: "Spec Heading", LineNo: 1}, + &Token{Kind: gauge.ScenarioKind, Value: "Scenario Heading", LineNo: 4}, + &Token{Kind: gauge.TableHeader, Args: []string{"id", "name"}, LineNo: 2}, + &Token{Kind: gauge.TableRow, Args: []string{"123", "hello"}, LineNo: 3}, + &Token{Kind: gauge.StepKind, Value: "Step with a {dynamic}", Args: []string{"id"}, LineNo: 5, LineText: "*Step with a "}, + &Token{Kind: gauge.StepKind, Value: "Step"}, + } + _, result, err := new(SpecParser).CreateSpecification(tokens, gauge.NewConceptDictionary(), "") + c.Assert(err, IsNil) + c.Assert(result.Ok, Equals, true) } func (s *MySuite) TestCreateStepFromSimpleConcept(c *C) { @@ -1032,6 +1092,56 @@ comment3 c.Assert(spec.Scenarios[2].Span.End, Equals, 17) } +func TestParseScenarioWithDataTable(t *testing.T) { + p := new(SpecParser) + var subject = func() *gauge.Scenario { + spec, _, err := p.Parse(`Specification Heading + ===================== + * Vowels in English language are "aeiou". + + Vowel counts in single word + --------------------------- + + |Word |Vowel Count| + |------|-----------| + |Gauge |3 | + |Mingle|2 | + |Snap |1 | + |GoCD |1 | + |Rhythm|0 | + + * The word has vowels. + + `, gauge.NewConceptDictionary(), "") + if err != nil { + t.Error(err) + } + return spec.Scenarios[0] + } + + t.Run("Parse Scenario with datatable when AllowScenarioDatatable=True", func(t *testing.T) { + env.AllowScenarioDatatable = func() bool { return true } + s := subject() + v := len(s.DataTable.Table.Rows()) + if v != 5 { + t.Errorf("expected scenario to have 5 rows, got %d", v) + } + v = len(s.DataTable.Table.Columns) + if v != 2 { + t.Errorf("expected scenario to have 2 columns, got %d", v) + } + }) + + t.Run("Parse Scenario with datatable when AllowScenarioDatatable=False", func(t *testing.T) { + env.AllowScenarioDatatable = func() bool { return false } + s := subject() + v := len(s.DataTable.Table.Rows()) + if v != 0 { + t.Errorf("expected scenario to have no rows, got %d", v) + } + }) +} + func (s *MySuite) TestParsingWhenTearDownHAsOnlyTable(c *C) { p := new(SpecParser) diff --git a/reporter/jsonConsole.go b/reporter/jsonConsole.go index 7ec5f64f0..4d5860cdd 100644 --- a/reporter/jsonConsole.go +++ b/reporter/jsonConsole.go @@ -159,7 +159,7 @@ func (c *jsonConsole) SpecEnd(spec *gauge.Specification, res result.Result) { func (c *jsonConsole) ScenarioStart(scenario *gauge.Scenario, i gm.ExecutionInfo, res result.Result) { c.Lock() defer c.Unlock() - addRow := c.isParallel && scenario.DataTableRow.IsInitialized() + addRow := c.isParallel && scenario.SpecDataTableRow.IsInitialized() parentID := getIDWithRow(i.CurrentSpec.FileName, []*gauge.Scenario{scenario}, addRow) e := executionEvent{ EventType: scenarioStart, @@ -177,7 +177,7 @@ func (c *jsonConsole) ScenarioStart(scenario *gauge.Scenario, i gm.ExecutionInfo func (c *jsonConsole) ScenarioEnd(scenario *gauge.Scenario, res result.Result, i gm.ExecutionInfo) { c.Lock() defer c.Unlock() - addRow := c.isParallel && scenario.DataTableRow.IsInitialized() + addRow := c.isParallel && scenario.SpecDataTableRow.IsInitialized() parentID := getIDWithRow(i.CurrentSpec.FileName, []*gauge.Scenario{scenario}, addRow) e := executionEvent{ EventType: scenarioEnd, @@ -252,7 +252,7 @@ func getIDWithRow(name string, scenarios []*gauge.Scenario, isDataTable bool) st if !isDataTable || len(scenarios) < 1 { return name } - return name + ":" + strconv.Itoa(scenarios[0].DataTableRowIndex) + return name + ":" + strconv.Itoa(scenarios[0].SpecDataTableRowIndex) } func getScenarioStatus(result *result.ScenarioResult) status { @@ -325,10 +325,10 @@ func getLineNo(stepCache map[*gm.ScenarioInfo][]*stepInfo, step *gm.ProtoStep, i } func getTable(scenario *gauge.Scenario) *tableInfo { - if scenario.DataTableRow.IsInitialized() { + if scenario.SpecDataTableRow.IsInitialized() { return &tableInfo{ - Text: formatter.FormatTable(&scenario.DataTableRow), - Row: scenario.DataTableRowIndex, + Text: formatter.FormatTable(&scenario.SpecDataTableRow), + Row: scenario.SpecDataTableRowIndex, } } return nil diff --git a/reporter/reporter.go b/reporter/reporter.go index 95cdd0fbf..de8b7a600 100644 --- a/reporter/reporter.go +++ b/reporter/reporter.go @@ -148,8 +148,13 @@ func ListenExecutionEvents(wg *sync.WaitGroup) { skipped := e.Result.(*result.ScenarioResult).ProtoScenario.GetExecutionStatus() == gauge_messages.ExecutionStatus_SKIPPED sce := e.Item.(*gauge.Scenario) // if it is datatable driven execution - if !skipped && sce.DataTableRow.GetRowCount() != 0 { - r.DataTable(formatter.FormatTable(&sce.DataTableRow)) + if !skipped { + if sce.SpecDataTableRow.GetRowCount() != 0 { + r.DataTable(formatter.FormatTable(&sce.SpecDataTableRow)) + } + if sce.ScenarioDataTableRow.GetRowCount() != 0 { + r.DataTable(formatter.FormatTable(&sce.ScenarioDataTableRow)) + } } r.ScenarioStart(sce, e.ExecutionInfo, e.Result) case event.ConceptStart: diff --git a/reporter/reporter_test.go b/reporter/reporter_test.go index d2748ee52..49d001b16 100644 --- a/reporter/reporter_test.go +++ b/reporter/reporter_test.go @@ -91,7 +91,7 @@ func (s *MySuite) TestSubscribeScenarioStartWithDataTable(c *C) { Value: "foo", ArgType: gauge.Dynamic}}, } - sce := &gauge.Scenario{Heading: &gauge.Heading{Value: sceHeading}, DataTableRow: dataTable, Steps: []*gauge.Step{step}} + sce := &gauge.Scenario{Heading: &gauge.Heading{Value: sceHeading}, SpecDataTableRow: dataTable, Steps: []*gauge.Step{step}} sceRes := result.NewScenarioResult(&gauge_messages.ProtoScenario{ScenarioHeading: sceHeading}) ListenExecutionEvents(&sync.WaitGroup{}) diff --git a/util/util.go b/util/util.go index 8ace5030f..3391e38c6 100644 --- a/util/util.go +++ b/util/util.go @@ -24,7 +24,6 @@ import ( "runtime" "syscall" - "strconv" "strings" "github.com/getgauge/common" @@ -109,16 +108,6 @@ func SetWorkingDir(workingDir string) { } } -func ConvertToBool(value, property string, defaultValue bool) bool { - boolValue, err := strconv.ParseBool(strings.TrimSpace(value)) - if err != nil { - logger.Warningf(true, "Incorrect value for %s in property file. Cannot convert %s to boolean.", property, value) - logger.Warningf(true, "Using default value %v for property %s.", defaultValue, property) - return defaultValue - } - return boolValue -} - // GetSpecDirs returns the specification directory. // It checks whether the environment variable for gauge_specs_dir is set. // It returns 'specs' otherwise