How to use TestToFilterSpecsByWrongTagExpression method of filter Package

...315	c.Assert(len(specs[0].Scenarios), Equals, 2)316	c.Assert(specs[0].Scenarios[0], Equals, scenario3)317	c.Assert(specs[0].Scenarios[1], Equals, scenario4)318}319func (s *MySuite) TestToFilterSpecsByWrongTagExpression(c *C) {320	myTags := []string{"tag1", "tag2"}321	scenario1 := &gauge.Scenario{322		Heading: &gauge.Heading{Value: "First Scenario"},323		Span:    &gauge.Span{Start: 1, End: 3},324	}325	scenario2 := &gauge.Scenario{326		Heading: &gauge.Heading{Value: "Second Scenario"},327		Span:    &gauge.Span{Start: 4, End: 6},328	}329	spec1 := &gauge.Specification{330		Items:     []gauge.Item{scenario1, scenario2},331		Scenarios: []*gauge.Scenario{scenario1, scenario2},332		Tags:      &gauge.Tags{Values: myTags},333	}...

1import (2func main() {3	filter := testrunner.NewFilter([]string{"@wrongTag"})4	runner := testrunner.NewTestRunner(os.Stdout, os.Stderr, config.DefaultReporterConfigType, filter)5	specs := []*types.SpecSummary{6		{7			ComponentTexts: []string{"1"},8			Tags:           []string{"@tag1"},9		},10		{11			ComponentTexts: []string{"2"},12			Tags:           []string{"@tag2"},13		},14	}15	runner.RunSpecs(specs, gexec.NewPrefixedWriter("[o] ", os.Stdout), gexec.NewPrefixedWriter("[e] ", os.Stderr))16}

1import (2func TestToFilterSpecsByWrongTagExpression(t *testing.T) {3	filter = &types.Filter{4		TagExpressions: []string{"@tag1", "@tag2"},5	}6	if filter != nil {7		t.Error("Filter is not nil")8	}9}10import (11func TestToFilterSpecsByWrongTagExpression(t *testing.T) {12	filter = &Filter{13		TagExpressions: []string{"@tag1", "@tag2"},14	}15	if filter != nil {16		t.Error("Filter is not nil")17	}18}19import (20func TestToFilterSpecsByWrongTagExpression(t *testing.T) {

1import (2var _ = Describe("Filter", func() {3	var (4	BeforeEach(func() {5		filter = NewFilter()6	})7	Describe("TestToFilterSpecsByWrongTagExpression", func() {8		Context("When tag expression is wrong", func() {9			It("should return an error", func() {10				_, err := filter.ToFilterSpecsByTagExpression("wrong expression")11				Expect(err).To(HaveOccurred())12			})13		})14	})15})16import (17var _ = Describe("Filter", func() {18	var (19	BeforeEach(func() {20		filter = NewFilter()21	})22	Describe("TestToFilterSpecsByTagExpression", func() {23		Context("When tag expression is valid", func() {24			It("should return a list of specs", func() {25				specs := []*types.SpecSummary{26					{27						ComponentTexts: []string{"Component1", "Component2"},28						ComponentCodeLocations: []types.CodeLocation{29							{30							},31						},32						Tags: []string{"tag1", "tag2"},33					},34					{35						ComponentTexts: []string{"Component3", "Component4"},36						ComponentCodeLocations: []types.CodeLocation{37							{38							},39						},40						Tags: []string{"tag3", "tag4"},

1func TestToFilterSpecsByWrongTagExpression(t *testing.T) {2    filter := new(Filter)3    specs, err := filter.ToFilterSpecs()4    if err == nil {5        t.Error("Expected error but got nil")6    }7    if specs != nil {8        t.Error("Expected nil but got", specs)9    }10}11func (f *Filter) ToFilterSpecs() ([]*gauge_messages.ProtoItem, error) {12    if f.TagExpression != "" {13        specs, err := filterSpecsByTag(f.TagExpression)14        if err != nil {15        }16    }17}18func filterSpecsByTag(tagExpression string) ([]*gauge_messages.ProtoItem, error) {19    for _, spec := range gauge.GetSpecs() {20        if spec.Tags != nil && len(spec.Tags) > 0 {21            if tagMatches(spec.Tags, tagExpression) {22                specs = append(specs, &gauge_messages.ProtoItem{ItemType: gauge_messages.ProtoItem_Specification, Item: spec})23            }24        }25    }26    if len(specs) == 0 {27        return nil, fmt.Errorf("No specs found with tag: %s", tagExpression)28    }29}30func tagMatches(tags []string, tagExpression string) bool {31    for _, tag := range tags {32        if tag == tagExpression {33        }34    }35}36func GetSpecs() []*gauge.Specification {37}38type Specification struct {

1import (2func main() {3	filter.TestToFilterSpecsByWrongTagExpression()4}5import (6func TestToFilterSpecsByWrongTagExpression() {7	filter := Filter{}8	spec := Spec{}9	spec1 := Spec{}10	spec2 := Spec{}11	spec3 := Spec{}12	spec4 := Spec{}13	spec5 := Spec{}14	spec6 := Spec{}15	spec7 := Spec{}16	spec8 := Spec{}17	spec9 := Spec{}18	spec10 := Spec{}19	spec11 := Spec{}20	spec12 := Spec{}21	spec13 := Spec{}22	spec14 := Spec{}23	spec15 := Spec{}24	spec16 := Spec{}25	spec17 := Spec{}26	spec18 := Spec{}27	spec19 := Spec{}28	spec20 := Spec{}29	spec21 := Spec{}30	spec22 := Spec{}31	spec23 := Spec{}32	spec24 := Spec{}33	spec25 := Spec{}34	spec26 := Spec{}35	spec27 := Spec{}

1func TestToFilterSpecsByWrongTagExpression(t *testing.T) {2	filter := &Filter{Tags: []string{"tag1"}}3	specs := []*gauge.Specification{4		&gauge.Specification{5			Tags: &gauge.Tags{6				Values: []string{"tag1"},7			},8		},9	}10	specs = filter.ApplyTagsFilter(specs)11	if len(specs) != 0 {12		t.Errorf("Expected 0 specs, got %d", len(specs))13	}14}15func TestToFilterSpecsByWrongTagExpression(t *testing.T) {16	filter := &Filter{Tags: []string{"tag1"}}17	specs := []*gauge.Specification{18		&gauge.Specification{19			Tags: &gauge.Tags{20				Values: []string{"tag1"},21			},22		},23	}24	specs = filter.ApplyTagsFilter(specs)25	if len(specs) != 0 {26		t.Errorf("Expected 0 specs, got %d", len(specs))27	}28}29func TestToFilterSpecsByWrongTagExpression(t *testing.T) {30	filter := &Filter{Tags: []string{"tag1"}}31	specs := []*gauge.Specification{32		&gauge.Specification{33			Tags: &gauge.Tags{34				Values: []string{"tag1"},35			},36		},37	}38	specs = filter.ApplyTagsFilter(specs)39	if len(specs) != 0 {40		t.Errorf("Expected 0 specs, got %d", len(specs))41	}42}43func TestToFilterSpecsByWrongTagExpression(t *testing.T) {44	filter := &Filter{Tags: []string{"tag1"}}45	specs := []*gauge.Specification{46		&gauge.Specification{47			Tags: &gauge.Tags{48				Values: []string{"tag1"},49			},50		},51	}52	specs = filter.ApplyTagsFilter(specs)53	if len(specs

1func TestToFilterSpecsByWrongTagExpression(t *testing.T) {2	filter := new(Filter)3	filter.Scenarios = []*gauge_messages.ProtoItem{{ItemType: gauge_messages.ProtoItem_Scenario, Scenario: &gauge_messages.ProtoScenario{}}}4	filter.Scenarios[0].Scenario.Tags = []string{"tag1"}5	filter.ToFilterSpecsByWrongTagExpression()6	assert.Equal(t, 0, len(filter.Scenarios))7}8func (f *Filter) ToFilterSpecsByWrongTagExpression() {9	for _, scenario := range f.Scenarios {10		if !f.isScenarioMatchingTagExpression(scenario) {11			filteredScenarios = append(filteredScenarios, scenario)12		}13	}14}15func (f *Filter) isScenarioMatchingTagExpression(scenario *gauge_messages.ProtoItem) bool {16	if len(f.TagsExpression) == 0 {17	}18	for _, tag := range scenario.Scenario.Tags {19		if f.isTagMatchingTagExpression(tag) {20		}21	}22}23func (f *Filter) isTagMatchingTagExpression(tag string) bool {24	for _, tagExpression := range f.Tags {25		if tagExpression.Matches(tag) {26		}27	}28}29func (f *Filter) ToFilterSpecsByWrongTagExpression() {30	for _, scenario := range f.Scenarios {31		if !f.isScenarioMatchingTagExpression(scenario) {32			filteredScenarios = append(filteredScenarios, scenario)33		}34	}35}36func (f *Filter) isScenario

1func TestToFilterSpecsByWrongTagExpression(t *testing.T) {2    specs, err := filter.ToFilterSpecsByTagExpression([]string{"tag1", "tag2"}, "tag3")3    if err == nil {4        t.Errorf("Expected error to be thrown for invalid tag expression")5    }6    if len(specs) != 0 {7        t.Errorf("Expected no specs to be returned for invalid tag expression")8    }9}10func (f *Filter) ToFilterSpecsByTagExpression(specs []string, tagExpression string) ([]string, error) {11    if tagExpression == "" {12    }13    tagExpression = strings.Replace(tagExpression, "and", "&&", -1)14    tagExpression = strings.Replace(tagExpression, "or", "||", -1)15    for _, spec := range specs {16        if f.matchesTagExpression(spec, tagExpression) {17            filteredSpecs = append(filteredSpecs, spec)18        }19    }20}21func (f *Filter) matchesTagExpression(spec string, tagExpression string) bool {22    tags := f.getTags(spec)23    tagExpression = strings.Replace(tagExpression, "not", "!", -1)24    tagExpression = strings.Replace(tagExpression, "@", "tags[\"", -1)25    tagExpression = strings.Replace(tagExpression, "]", "\"]", -1)26    tagExpression = strings.Replace(tagExpression, "(", "[\"", -1)27    tagExpression = strings.Replace(tagExpression, ")", "\"]", -1)28    for _, tag := range tags {29        if expression != "" {30        }31    }32    if expression != "" {33    }34    result, err := govaluate.NewEvaluableExpression(tagExpression)35    if err != nil {36    }37    value, err := result.Evaluate(map[string]interface{}{"tags": tags})38    if err != nil {

1func TestToFilterSpecsByWrongTagExpression(t *testing.T) {2        var filter = Filter{}3        var specs = []string{"a", "b", "c"}4        var tags = []string{"d"}5        var result = filter.ToFilterSpecsByTagExpression(specs, tags)6        if len(result) != 0 {7                t.Errorf("expected %v, got %v", 0, len(result))8        }9}10func TestToFilterSpecsByCorrectTagExpression(t *testing.T) {11        var filter = Filter{}12        var specs = []string{"a", "b", "c"}13        var tags = []string{"c"}14        var result = filter.ToFilterSpecsByTagExpression(specs, tags)15        if len(result) != 1 {16                t.Errorf("expected %v, got %v", 1, len(result))17        }18}19func TestToFilterSpecsByCorrectTagExpression(t *testing.T) {20        var filter = Filter{}21        var specs = []string{"a", "b", "c"}22        var tags = []string{"c"}23        var result = filter.ToFilterSpecsByTagExpression(specs, tags)24        if len(result) != 1 {25                t.Errorf("expected %v, got %v", 1, len(result))26        }27}28func TestToFilterSpecsByCorrectTagExpression(t *testing.T) {29        var filter = Filter{}30        var specs = []string{"a", "b", "c"}31        var tags = []string{"c"}32        var result = filter.ToFilterSpecsByTagExpression(specs, tags)33        if len(result) != 1 {34                t.Errorf("expected %v, got %v", 1, len(result))35        }36}37func TestToFilterSpecsByCorrectTagExpression(t *testing.T) {38        var filter = Filter{}

1func TestToFilterSpecsByWrongTagExpression(t *testing.T) {2    filter := filter.NewFilter()3    specs := []string{"@tag1", "@tag2"}4    tags := []string{"tag1", "tag2"}5    filter.ToFilterSpecsByWrongTagExpression(specs, tags)6}7func (f *Filter) ToFilterSpecsByWrongTagExpression(specs, tags []string) {8    specs = []string{}9    tags = []string{}10    f.ToFilterSpecsByWrongTagExpression(specs, tags)11}12func (f *Filter) ToFilterSpecsByWrongTagExpression(specs, tags []string) {13    specs = []string{}14    tags = []string{}15    f.ToFilterSpecsByWrongTagExpression(specs, tags)16}17func (f *Filter) ToFilterSpecsByWrongTagExpression(specs, tags []string) {18    specs = []string{}19    tags = []string{}20    f.ToFilterSpecsByWrongTagExpression(specs, tags)21}22func (f *Filter) ToFilterSpecsByWrongTagExpression(specs, tags []string) {23    specs = []string{}24    tags = []string{}