← Back to branch summary

~ubuntu-branches/debian/sid/nunit/sid

« back to all changes in this revision

Viewing changes to src/ClientUtilities/tests/CategoryParseTests.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2014-09-16 13:43:36 UTC
  • mfrom: (1.1.5)
  • Revision ID: package-import@ubuntu.com-20140916134336-kjxz48tty6lx2ja5
Tags: 2.6.3+dfsg-1
* [c7bd1b5] Imported Upstream version 2.6.3+dfsg
* [bcb4bf8] Move nunit-console-runner to GAC-installed libnunit2.6, 
  don't treat it as a private lib. This lib is signed, and treated 
  as a GAC lib by consumers such as MonoDevelop.
* [7f08e99] Bump version to 2.6.3 as required
* [84535eb] Refreshed patches
* [8479f61] Split package up into per-assembly packages. This makes 
  ABI tracking easier in the future, as we can meaningfully have GAC 
  policy for cases where ABI isn't truly bumped, and no policy for 
  cases where it is. For example, if nunit.framework bumps ABI but 
  nunit.core does not, previously we would need to rebuild everything 
  using NUnit, but under the new split packaging, that rebuild would 
  not be needed for apps only using nunit.core.
* [17a7dc7] Add missing nunit.mocks.dll to nunit.pc

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/ClientUtilities/tests/CategoryParseTests.cs
1
 
// ****************************************************************
2
 
// Copyright 2009, Charlie Poole
3
 
// This is free software licensed under the NUnit license. You may
4
 
// obtain a copy of the license at http://nunit.org
5
 
// ****************************************************************
6
 
 
7
 
using System;
8
 
using NUnit.Framework;
9
 
using NUnit.Core;
10
 
using NUnit.Core.Filters;
11
 
 
12
 
namespace NUnit.Util.Tests
13
 
{
14
 
        [TestFixture]
15
 
        public class CategoryParseTests
16
 
        {
17
 
                [Test]
18
 
                public void EmptyStringReturnsEmptyFilter()
19
 
                {
20
 
                        CategoryExpression expr = new CategoryExpression( "" );
21
 
                        Assert.That( expr.Filter.IsEmpty );
22
 
                }
23
 
 
24
 
                [Test]
25
 
                public void CanParseSimpleCategory()
26
 
                {
27
 
                        CategoryExpression expr = new CategoryExpression( "Data" );
28
 
                        CategoryFilter filter = (CategoryFilter)expr.Filter;
29
 
                        Assert.That( filter.Categories, Is.EqualTo( new string[] { "Data" } ) );
30
 
                }
31
 
 
32
 
                [Test]
33
 
                public void CanParseCompoundCategory()
34
 
                {
35
 
                        CategoryExpression expr = new CategoryExpression( "One , Two; Three,Four" );
36
 
                        CategoryFilter filter = (CategoryFilter)expr.Filter;
37
 
                        Assert.That( filter.Categories, Is.EqualTo( new string[] { "One", "Two", "Three", "Four" } ) );
38
 
                }
39
 
 
40
 
                [Test]
41
 
                public void CanParseExcludedCategories()
42
 
                {
43
 
                        CategoryExpression expr = new CategoryExpression( "-One,Two,Three" );
44
 
                        NotFilter notFilter = (NotFilter)expr.Filter;
45
 
                        CategoryFilter catFilter = (CategoryFilter)notFilter.BaseFilter;
46
 
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "One", "Two", "Three" } ) );
47
 
                }
48
 
 
49
 
                [Test]
50
 
                public void CanParseMultipleCategoriesWithAnd()
51
 
                {
52
 
                        CategoryExpression expr = new CategoryExpression( "One + Two+Three" );
53
 
                        AndFilter andFilter = (AndFilter)expr.Filter;
54
 
                        Assert.That( andFilter.Filters.Length, Is.EqualTo( 3 ) );
55
 
                        CategoryFilter catFilter = (CategoryFilter)andFilter.Filters[0];
56
 
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "One"  } ) );
57
 
                        catFilter = (CategoryFilter)andFilter.Filters[1];
58
 
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "Two"  } ) );
59
 
                        catFilter = (CategoryFilter)andFilter.Filters[2];
60
 
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "Three"  } ) );
61
 
                }
62
 
 
63
 
                [Test]
64
 
                public void CanParseMultipleAlternatives()
65
 
                {
66
 
                        CategoryExpression expr = new CategoryExpression( "One|Two|Three" );
67
 
                        OrFilter orFilter = (OrFilter)expr.Filter;
68
 
                        Assert.That( orFilter.Filters.Length, Is.EqualTo( 3 ) );
69
 
                        CategoryFilter catFilter = (CategoryFilter)orFilter.Filters[0];
70
 
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "One"  } ) );
71
 
                        catFilter = (CategoryFilter)orFilter.Filters[1];
72
 
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "Two"  } ) );
73
 
                        catFilter = (CategoryFilter)orFilter.Filters[2];
74
 
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "Three"  } ) );
75
 
                }
76
 
 
77
 
                [Test]
78
 
                public void PrecedenceTest()
79
 
                {
80
 
                        CategoryExpression expr = new CategoryExpression( "A + B | C + -D,E,F" );
81
 
                        OrFilter orFilter = (OrFilter)expr.Filter;
82
 
 
83
 
                        AndFilter andFilter = (AndFilter)orFilter.Filters[0];
84
 
                        CategoryFilter catFilter = (CategoryFilter)andFilter.Filters[0];
85
 
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "A" } ) );
86
 
                        catFilter = (CategoryFilter)andFilter.Filters[1];
87
 
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "B" } ) );
88
 
 
89
 
                        andFilter = (AndFilter)orFilter.Filters[1];
90
 
                        catFilter = (CategoryFilter)andFilter.Filters[0];
91
 
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "C" } ) );
92
 
                        NotFilter notFilter = (NotFilter)andFilter.Filters[1];
93
 
                        catFilter = (CategoryFilter)notFilter.BaseFilter;
94
 
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "D", "E", "F" } ) );
95
 
                }
96
 
 
97
 
                [Test]
98
 
                public void PrecedenceTestWithParentheses()
99
 
                {
100
 
                        CategoryExpression expr = new CategoryExpression( "A + (B | C) - D,E,F" );
101
 
                        AndFilter andFilter = (AndFilter)expr.Filter;
102
 
                        Assert.That( andFilter.Filters.Length, Is.EqualTo( 3 ) );
103
 
 
104
 
                        CategoryFilter catFilter = (CategoryFilter)andFilter.Filters[0];
105
 
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "A" } ) );
106
 
 
107
 
                        OrFilter orFilter = (OrFilter)andFilter.Filters[1];
108
 
                        catFilter = (CategoryFilter)orFilter.Filters[0];
109
 
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "B" } ) );
110
 
                        catFilter = (CategoryFilter)orFilter.Filters[1];
111
 
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "C" } ) );
112
 
 
113
 
                        NotFilter notFilter = (NotFilter)andFilter.Filters[2];
114
 
                        catFilter = (CategoryFilter)notFilter.BaseFilter;
115
 
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "D", "E", "F" } ) );
116
 
                }
117
 
 
118
 
                [Test]
119
 
                public void OrAndMinusCombined()
120
 
                {
121
 
                        CategoryExpression expr = new CategoryExpression( "A|B-C-D|E" );
122
 
                        OrFilter orFilter = (OrFilter)expr.Filter;
123
 
                        Assert.That( orFilter.Filters.Length, Is.EqualTo( 3 ) );
124
 
                        AndFilter andFilter = (AndFilter)orFilter.Filters[1];
125
 
                        Assert.That( andFilter.Filters.Length, Is.EqualTo( 3 ) );
126
 
                        Assert.That( andFilter.Filters[0], Is.TypeOf( typeof( CategoryFilter) ) );
127
 
                        Assert.That( andFilter.Filters[1], Is.TypeOf( typeof( NotFilter) ) );
128
 
                        Assert.That( andFilter.Filters[2], Is.TypeOf( typeof( NotFilter) ) );
129
 
                }
130
 
 
131
 
                [Test]
132
 
                public void PlusAndMinusCombined()
133
 
                {
134
 
                        CategoryExpression expr = new CategoryExpression( "A+B-C-D+E" );
135
 
                        AndFilter andFilter = (AndFilter)expr.Filter;
136
 
                        Assert.That( andFilter.Filters.Length, Is.EqualTo( 5 ) );
137
 
                        Assert.That( andFilter.Filters[0], Is.TypeOf( typeof( CategoryFilter) ) );
138
 
                        Assert.That( andFilter.Filters[1], Is.TypeOf( typeof( CategoryFilter) ) );
139
 
                        Assert.That( andFilter.Filters[2], Is.TypeOf( typeof( NotFilter) ) );
140
 
                        Assert.That( andFilter.Filters[3], Is.TypeOf( typeof( NotFilter) ) );
141
 
                        Assert.That( andFilter.Filters[4], Is.TypeOf( typeof( CategoryFilter) ) );
142
 
                }
143
 
        }
144
 
}
 
1
// ****************************************************************
 
2
// Copyright 2009, Charlie Poole
 
3
// This is free software licensed under the NUnit license. You may
 
4
// obtain a copy of the license at http://nunit.org
 
5
// ****************************************************************
 
6
 
 
7
using System;
 
8
using NUnit.Framework;
 
9
using NUnit.Core;
 
10
using NUnit.Core.Filters;
 
11
 
 
12
namespace NUnit.Util.Tests
 
13
{
 
14
        [TestFixture]
 
15
        public class CategoryParseTests
 
16
        {
 
17
                [Test]
 
18
                public void EmptyStringReturnsEmptyFilter()
 
19
                {
 
20
                        CategoryExpression expr = new CategoryExpression( "" );
 
21
                        Assert.That( expr.Filter.IsEmpty );
 
22
                }
 
23
 
 
24
                [Test]
 
25
                public void CanParseSimpleCategory()
 
26
                {
 
27
                        CategoryExpression expr = new CategoryExpression( "Data" );
 
28
                        CategoryFilter filter = (CategoryFilter)expr.Filter;
 
29
                        Assert.That( filter.Categories, Is.EqualTo( new string[] { "Data" } ) );
 
30
                }
 
31
 
 
32
                [Test]
 
33
                public void CanParseCompoundCategory()
 
34
                {
 
35
                        CategoryExpression expr = new CategoryExpression( "One , Two; Three,Four" );
 
36
                        CategoryFilter filter = (CategoryFilter)expr.Filter;
 
37
                        Assert.That( filter.Categories, Is.EqualTo( new string[] { "One", "Two", "Three", "Four" } ) );
 
38
                }
 
39
 
 
40
                [Test]
 
41
                public void CanParseExcludedCategories()
 
42
                {
 
43
                        CategoryExpression expr = new CategoryExpression( "-One,Two,Three" );
 
44
                        NotFilter notFilter = (NotFilter)expr.Filter;
 
45
                        CategoryFilter catFilter = (CategoryFilter)notFilter.BaseFilter;
 
46
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "One", "Two", "Three" } ) );
 
47
                }
 
48
 
 
49
                [Test]
 
50
                public void CanParseMultipleCategoriesWithAnd()
 
51
                {
 
52
                        CategoryExpression expr = new CategoryExpression( "One + Two+Three" );
 
53
                        AndFilter andFilter = (AndFilter)expr.Filter;
 
54
                        Assert.That( andFilter.Filters.Length, Is.EqualTo( 3 ) );
 
55
                        CategoryFilter catFilter = (CategoryFilter)andFilter.Filters[0];
 
56
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "One"  } ) );
 
57
                        catFilter = (CategoryFilter)andFilter.Filters[1];
 
58
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "Two"  } ) );
 
59
                        catFilter = (CategoryFilter)andFilter.Filters[2];
 
60
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "Three"  } ) );
 
61
                }
 
62
 
 
63
                [Test]
 
64
                public void CanParseMultipleAlternatives()
 
65
                {
 
66
                        CategoryExpression expr = new CategoryExpression( "One|Two|Three" );
 
67
                        OrFilter orFilter = (OrFilter)expr.Filter;
 
68
                        Assert.That( orFilter.Filters.Length, Is.EqualTo( 3 ) );
 
69
                        CategoryFilter catFilter = (CategoryFilter)orFilter.Filters[0];
 
70
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "One"  } ) );
 
71
                        catFilter = (CategoryFilter)orFilter.Filters[1];
 
72
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "Two"  } ) );
 
73
                        catFilter = (CategoryFilter)orFilter.Filters[2];
 
74
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "Three"  } ) );
 
75
                }
 
76
 
 
77
                [Test]
 
78
                public void PrecedenceTest()
 
79
                {
 
80
                        CategoryExpression expr = new CategoryExpression( "A + B | C + -D,E,F" );
 
81
                        OrFilter orFilter = (OrFilter)expr.Filter;
 
82
 
 
83
                        AndFilter andFilter = (AndFilter)orFilter.Filters[0];
 
84
                        CategoryFilter catFilter = (CategoryFilter)andFilter.Filters[0];
 
85
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "A" } ) );
 
86
                        catFilter = (CategoryFilter)andFilter.Filters[1];
 
87
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "B" } ) );
 
88
 
 
89
                        andFilter = (AndFilter)orFilter.Filters[1];
 
90
                        catFilter = (CategoryFilter)andFilter.Filters[0];
 
91
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "C" } ) );
 
92
                        NotFilter notFilter = (NotFilter)andFilter.Filters[1];
 
93
                        catFilter = (CategoryFilter)notFilter.BaseFilter;
 
94
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "D", "E", "F" } ) );
 
95
                }
 
96
 
 
97
                [Test]
 
98
                public void PrecedenceTestWithParentheses()
 
99
                {
 
100
                        CategoryExpression expr = new CategoryExpression( "A + (B | C) - D,E,F" );
 
101
                        AndFilter andFilter = (AndFilter)expr.Filter;
 
102
                        Assert.That( andFilter.Filters.Length, Is.EqualTo( 3 ) );
 
103
 
 
104
                        CategoryFilter catFilter = (CategoryFilter)andFilter.Filters[0];
 
105
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "A" } ) );
 
106
 
 
107
                        OrFilter orFilter = (OrFilter)andFilter.Filters[1];
 
108
                        catFilter = (CategoryFilter)orFilter.Filters[0];
 
109
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "B" } ) );
 
110
                        catFilter = (CategoryFilter)orFilter.Filters[1];
 
111
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "C" } ) );
 
112
 
 
113
                        NotFilter notFilter = (NotFilter)andFilter.Filters[2];
 
114
                        catFilter = (CategoryFilter)notFilter.BaseFilter;
 
115
                        Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "D", "E", "F" } ) );
 
116
                }
 
117
 
 
118
                [Test]
 
119
                public void OrAndMinusCombined()
 
120
                {
 
121
                        CategoryExpression expr = new CategoryExpression( "A|B-C-D|E" );
 
122
                        OrFilter orFilter = (OrFilter)expr.Filter;
 
123
                        Assert.That( orFilter.Filters.Length, Is.EqualTo( 3 ) );
 
124
                        AndFilter andFilter = (AndFilter)orFilter.Filters[1];
 
125
                        Assert.That( andFilter.Filters.Length, Is.EqualTo( 3 ) );
 
126
                        Assert.That( andFilter.Filters[0], Is.TypeOf( typeof( CategoryFilter) ) );
 
127
                        Assert.That( andFilter.Filters[1], Is.TypeOf( typeof( NotFilter) ) );
 
128
                        Assert.That( andFilter.Filters[2], Is.TypeOf( typeof( NotFilter) ) );
 
129
                }
 
130
 
 
131
                [Test]
 
132
                public void PlusAndMinusCombined()
 
133
                {
 
134
                        CategoryExpression expr = new CategoryExpression( "A+B-C-D+E" );
 
135
                        AndFilter andFilter = (AndFilter)expr.Filter;
 
136
                        Assert.That( andFilter.Filters.Length, Is.EqualTo( 5 ) );
 
137
                        Assert.That( andFilter.Filters[0], Is.TypeOf( typeof( CategoryFilter) ) );
 
138
                        Assert.That( andFilter.Filters[1], Is.TypeOf( typeof( CategoryFilter) ) );
 
139
                        Assert.That( andFilter.Filters[2], Is.TypeOf( typeof( NotFilter) ) );
 
140
                        Assert.That( andFilter.Filters[3], Is.TypeOf( typeof( NotFilter) ) );
 
141
                        Assert.That( andFilter.Filters[4], Is.TypeOf( typeof( CategoryFilter) ) );
 
142
                }
 
143
        }
 
144
}