← Back to branch summary

~nunit-core/nunitv2/2.5

« back to all changes in this revision

Viewing changes to src/NUnitFramework/tests/Syntax/CollectionTests.cs

  • Committer: Charlie Poole
  • Date: 2010-11-15 20:25:50 UTC
  • Revision ID: charlie@nunit.org-20101115202550-udc7za787ueel5so
https://launchpad.net/bugs/674860
Make 'Using' work with CollectionContainsConstraint

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/NUnitFramework/tests/Syntax/CollectionTests.cs
9
9
#if NET_2_0
10
10
using System.Collections.Generic;
11
11
#endif
 
12
using NUnit.Framework.Tests;
12
13
 
13
14
namespace NUnit.Framework.Syntax
14
15
{
134
135
        }
135
136
    }
136
137
 
 
138
    public class CollectionContainsTest_String : SyntaxTest
 
139
    {
 
140
        [SetUp]
 
141
        public void SetUp()
 
142
        {
 
143
            parseTree = "<contains \"abc\">";
 
144
            staticSyntax = Contains.Item("abc");
 
145
            inheritedSyntax = Helper().Contains("abc");
 
146
            builderSyntax = Builder().Contains("abc");
 
147
        }
 
148
    }
 
149
 
 
150
    public class CollectionContainsTest_Comparer : SyntaxTest
 
151
    {
 
152
        [SetUp]
 
153
        public void SetUp()
 
154
        {
 
155
            parseTree = "<contains 42>";
 
156
            staticSyntax = Contains.Item(42).Using(Comparer.Default);
 
157
            inheritedSyntax = Helper().Contains(42).Using(Comparer.Default);
 
158
            builderSyntax = Builder().Contains(42).Using(Comparer.Default);
 
159
        }
 
160
 
 
161
                [Test]
 
162
                public void ComparerIsCalled()
 
163
                {
 
164
                        TestComparer comparer = new TestComparer();
 
165
            Assert.That(new int[] { 1, 2, 3 }, 
 
166
                Contains.Item(2).Using(comparer));
 
167
                        Assert.That(comparer.Called, "Comparer was not called");
 
168
                }
 
169
 
 
170
                [Test]
 
171
                public void ComparerIsCalledInExpression()
 
172
                {
 
173
                        TestComparer comparer = new TestComparer();
 
174
            Assert.That(new int[] { 1, 2, 3 }, 
 
175
                Has.Length.EqualTo(3).And.Contains(2).Using(comparer));
 
176
                        Assert.That(comparer.Called, "Comparer was not called");
 
177
                }
 
178
        }
 
179
 
 
180
    public class CollectionContainsTest_Comparer_String : SyntaxTest
 
181
    {
 
182
        [SetUp]
 
183
        public void SetUp()
 
184
        {
 
185
            parseTree = "<contains \"abc\">";
 
186
            staticSyntax = Contains.Item("abc").Using(Comparer.Default);
 
187
            inheritedSyntax = Helper().Contains("abc").Using(Comparer.Default);
 
188
            builderSyntax = Builder().Contains("abc").Using(Comparer.Default);
 
189
        }
 
190
                
 
191
                [Test]
 
192
                public void ComparerIsCalled()
 
193
                {
 
194
                        TestComparer comparer = new TestComparer();
 
195
            Assert.That(new string[] { "Hello", "World" }, 
 
196
                Contains.Item("World").Using(comparer));
 
197
                        Assert.That(comparer.Called, "Comparer was not called");
 
198
                }
 
199
 
 
200
                [Test]
 
201
                public void ComparerIsCalledInExpression()
 
202
                {
 
203
                        TestComparer comparer = new TestComparer();
 
204
            Assert.That(new string[] { "Hello", "World" }, 
 
205
                Has.Length.EqualTo(2).And.Contains("World").Using(comparer));
 
206
                        Assert.That(comparer.Called, "Comparer was not called");
 
207
                }
 
208
    }
 
209
 
137
210
    public class CollectionMemberTest : SyntaxTest
138
211
    {
139
212
        [SetUp]
146
219
        }
147
220
    }
148
221
 
 
222
    public class CollectionMemberTest_Comparer : SyntaxTest
 
223
    {
 
224
        [SetUp]
 
225
        public void SetUp()
 
226
        {
 
227
            parseTree = "<contains 42>";
 
228
            staticSyntax = Has.Member(42).Using(Comparer.Default);
 
229
            inheritedSyntax = Helper().Contains(42).Using(Comparer.Default);
 
230
            builderSyntax = Builder().Contains(42).Using(Comparer.Default);
 
231
        }
 
232
    }
 
233
 
149
234
    public class CollectionSubsetTest : SyntaxTest
150
235
    {
151
236
        [SetUp]