Modified some unit tests that were failing on Mono because Mono words some error messages differently.

Author: rstam

DriverOnlineTests/DriverOnlineTests.csproj

@@ -88,6 +88,7 @@
     <Compile Include="Core\MongoDatabaseTests.cs" />
     <Compile Include="Core\MongoServerTests.cs" />
     <Compile Include="Configuration.cs" />
+    <Compile Include="ExpectedErrorMessage.cs" />
     <Compile Include="GridFS\MongoGridFSStreamTests.cs" />
     <Compile Include="GridFS\MongoGridFSTests.cs" />
     <Compile Include="Jira\CSharp101Tests.cs" />

DriverOnlineTests/ExpectedErrorMessage.cs

@@ -0,0 +1,98 @@
+/* Copyright 2010-2012 10gen Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace MongoDB.DriverOnlineTests
+{
+    /// <summary>
+    /// A static class to hold expected error messages that differ between .NET and Mono.
+    /// </summary>
+    public static class ExpectedErrorMessage
+    {
+        // private static fields
+        private static string _firstEmptySequence;
+        private static string _lastEmptySequence;
+        private static string _singleEmptySequence;
+        private static string _singleLongSequence;
+
+        // static constructor
+        static ExpectedErrorMessage()
+        {
+            var emptySequence = new List<int>();
+            var longElementSequence = new List<int> { 1, 2, 3 };
+
+            try
+            {
+                var f = emptySequence.First();
+            }
+            catch (Exception ex)
+            {
+                _firstEmptySequence = ex.Message;
+            }
+
+            try
+            {
+                var f = emptySequence.Last();
+            }
+            catch (Exception ex)
+            {
+                _lastEmptySequence = ex.Message;
+            }
+
+            try
+            {
+                var f = emptySequence.Single();
+            }
+            catch (Exception ex)
+            {
+                _singleEmptySequence = ex.Message;
+            }
+
+            try
+            {
+                var f = longElementSequence.Single();
+            }
+            catch (Exception ex)
+            {
+                _singleLongSequence = ex.Message;
+            }
+        }
+
+        // public static properties
+        public static string FirstEmptySequence
+        {
+            get { return _firstEmptySequence; }
+        }
+
+        public static string LastEmptySequence
+        {
+            get { return _lastEmptySequence; }
+        }
+
+        public static string SingleEmptySequence
+        {
+            get { return _singleEmptySequence; }
+        }
+
+        public static string SingleLongSequence
+        {
+            get { return _singleLongSequence; }
+        }
+    }
+}

DriverOnlineTests/Linq/SelectQueryTests.cs

@@ -798,11 +798,14 @@ public void TestFirstWithPredicateAfterWhere()
         }
 
         [Test]
-        [ExpectedException(typeof(InvalidOperationException), ExpectedMessage = "Sequence contains no elements")]
         public void TestFirstWithPredicateNoMatch()
         {
-            var result = (from c in _collection.AsQueryable<C>()
-                          select c).First(c => c.X == 9);
+            var ex = Assert.Throws<InvalidOperationException>(() =>
+            {
+                var result = (from c in _collection.AsQueryable<C>()
+                              select c).First(c => c.X == 9);
+            });
+            Assert.AreEqual(ExpectedErrorMessage.FirstEmptySequence, ex.Message);
         }
 
         [Test]
@@ -1103,11 +1106,14 @@ public void TestLastWithPredicateAfterWhere()
         }
 
         [Test]
-        [ExpectedException(typeof(InvalidOperationException), ExpectedMessage = "Sequence contains no elements")]
         public void TestLastWithPredicateNoMatch()
         {
-            var result = (from c in _collection.AsQueryable<C>()
-                          select c).Last(c => c.X == 9);
+            var ex = Assert.Throws<InvalidOperationException>(() =>
+            {
+                var result = (from c in _collection.AsQueryable<C>()
+                              select c).Last(c => c.X == 9);
+            });
+            Assert.AreEqual(ExpectedErrorMessage.LastEmptySequence, ex.Message);
         }
 
         [Test]
@@ -1668,12 +1674,15 @@ public void TestSingleOrDefaultWithPredicateOneMatch()
             Assert.AreEqual(33, result.Y);
         }
 
-        [ExpectedException(typeof(InvalidOperationException), ExpectedMessage = "Sequence contains more than one element")]
         [Test]
         public void TestSingleOrDefaultWithPredicateTwoMatches()
         {
-            var result = (from c in _collection.AsQueryable<C>()
-                          select c).SingleOrDefault(c => c.Y == 11);
+            var ex = Assert.Throws<InvalidOperationException>(() =>
+            {
+                var result = (from c in _collection.AsQueryable<C>()
+                              select c).SingleOrDefault(c => c.Y == 11);
+            });
+            Assert.AreEqual(ExpectedErrorMessage.SingleLongSequence, ex.Message);
         }
 
         [Test]
@@ -1731,12 +1740,14 @@ public void TestSingleWithPredicateAfterWhere()
         }
 
         [Test]
-        [ExpectedException(typeof(InvalidOperationException), ExpectedMessage = "Sequence contains no elements")]
         public void TestSingleWithPredicateNoMatch()
         {
-            var result = (from c in _collection.AsQueryable<C>()
-                          select c).Single(c => c.X == 9);
-            Assert.IsNull(result);
+            var ex = Assert.Throws<InvalidOperationException>(() =>
+            {
+                var result = (from c in _collection.AsQueryable<C>()
+                              select c).Single(c => c.X == 9);
+            });
+            Assert.AreEqual(ExpectedErrorMessage.SingleEmptySequence, ex.Message);
         }
 
         [Test]
@@ -1749,11 +1760,14 @@ public void TestSingleWithPredicateOneMatch()
         }
 
         [Test]
-        [ExpectedException(typeof(InvalidOperationException), ExpectedMessage = "Sequence contains more than one element")]
         public void TestSingleWithPredicateTwoMatches()
         {
-            var result = (from c in _collection.AsQueryable<C>()
-                          select c).Single(c => c.Y == 11);
+            var ex = Assert.Throws<InvalidOperationException>(() =>
+            {
+                var result = (from c in _collection.AsQueryable<C>()
+                              select c).Single(c => c.Y == 11);
+            });
+            Assert.AreEqual(ExpectedErrorMessage.SingleLongSequence, ex.Message);
         }
 
         [Test]