SEBWIN-1058: Fixed assertion paradigm changes in unit tests.

dbuechel · dbuechel · commit a4c3458e6330 · 2025-09-03T16:48:44.000+02:00
diff --git a/SafeExamBrowser.Browser.UnitTests/Filters/RequestFilterTests.cs b/SafeExamBrowser.Browser.UnitTests/Filters/RequestFilterTests.cs
@@ -102,13 +102,13 @@ public void MustReturnDefaultWithoutRules()
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(NotImplementedException))]
 		public void MustNotAllowUnsupportedResult()
 		{
 			var rule = new Mock<IRule>();
 
 			rule.SetupGet(r => r.Result).Returns((FilterResult) (-1));
-			sut.Load(rule.Object);
+
+			Assert.ThrowsExactly<NotImplementedException>(() => sut.Load(rule.Object));
 		}
 	}
 }
diff --git a/SafeExamBrowser.Browser.UnitTests/Filters/RuleFactoryTests.cs b/SafeExamBrowser.Browser.UnitTests/Filters/RuleFactoryTests.cs
@@ -33,10 +33,9 @@ public void MustCreateCorrectRules()
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(NotImplementedException))]
 		public void MustNotAllowUnsupportedFilterType()
 		{
-			sut.CreateRule((FilterRuleType) (-1));
+			Assert.ThrowsExactly<NotImplementedException>(() => sut.CreateRule((FilterRuleType) (-1)));
 		}
 	}
 }
diff --git a/SafeExamBrowser.Browser.UnitTests/Filters/Rules/RegexRuleTests.cs b/SafeExamBrowser.Browser.UnitTests/Filters/Rules/RegexRuleTests.cs
@@ -51,17 +51,15 @@ public void MustInitializeResult()
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public void MustNotAllowUndefinedExpression()
 		{
-			sut.Initialize(new FilterRuleSettings());
+			Assert.ThrowsExactly<ArgumentNullException>(() => sut.Initialize(new FilterRuleSettings()));
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentException))]
 		public void MustValidateExpression()
 		{
-			sut.Initialize(new FilterRuleSettings { Expression = "ç+\"}%&*/(+)=?{=*+¦]@#°§]`?´^¨'°[¬|¢" });
+			Assert.ThrowsExactly<ArgumentException>(() => sut.Initialize(new FilterRuleSettings { Expression = "ç+\"}%&*/(+)=?{=*+¦]@#°§]`?´^¨'°[¬|¢" }));
 		}
 	}
 }
diff --git a/SafeExamBrowser.Browser.UnitTests/Filters/Rules/SimplifiedRuleTests.cs b/SafeExamBrowser.Browser.UnitTests/Filters/Rules/SimplifiedRuleTests.cs
@@ -51,10 +51,9 @@ public void MustInitializeResult()
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public void MustNotAllowUndefinedExpression()
 		{
-			sut.Initialize(new FilterRuleSettings());
+			Assert.ThrowsExactly<ArgumentNullException>(() => sut.Initialize(new FilterRuleSettings()));
 		}
 
 		[TestMethod]
@@ -73,7 +72,7 @@ public void MustValidateExpression()
 
 			foreach (var expression in invalid)
 			{
-				Assert.ThrowsException<ArgumentException>(() => sut.Initialize(new FilterRuleSettings { Expression = expression }));
+				Assert.ThrowsExactly<ArgumentException>(() => sut.Initialize(new FilterRuleSettings { Expression = expression }));
 			}
 		}
 
diff --git a/SafeExamBrowser.Communication.UnitTests/Hosts/BaseHostTests.cs b/SafeExamBrowser.Communication.UnitTests/Hosts/BaseHostTests.cs
@@ -53,12 +53,11 @@ public void MustCorrectlyStartHost()
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(CommunicationException))]
 		public void MustCorrectlyHandleStartupException()
 		{
 			hostObject.Setup(h => h.Open()).Throws<Exception>();
 
-			sut.Start();
+			Assert.ThrowsExactly<CommunicationException>(() => sut.Start());
 		}
 
 		[TestMethod]
@@ -71,13 +70,12 @@ public void MustCorrectlyStopHost()
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(CommunicationException))]
 		public void MustCorrectlyHandleShutdownException()
 		{
 			hostObject.Setup(h => h.Close()).Throws<Exception>();
-
 			sut.Start();
-			sut.Stop();
+
+			Assert.ThrowsExactly<CommunicationException>(() => sut.Stop());
 		}
 
 		[TestMethod]
diff --git a/SafeExamBrowser.Communication.UnitTests/Proxies/BaseProxyTests.cs b/SafeExamBrowser.Communication.UnitTests/Proxies/BaseProxyTests.cs
@@ -171,14 +171,12 @@ public void MustFailToDisconnectIfChannelNotOpen()
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(InvalidOperationException))]
 		public void MustFailToSendIfNotConnected()
 		{
-			sut.Send(new Mock<Message>().Object);
+			Assert.ThrowsExactly<InvalidOperationException>(() => sut.Send(new Mock<Message>().Object));
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(InvalidOperationException))]
 		public void MustFailToSendIfChannelNotOpen()
 		{
 			var proxy = new Mock<IProxyObject>();
@@ -195,14 +193,14 @@ public void MustFailToSendIfChannelNotOpen()
 			var token = Guid.NewGuid();
 
 			sut.Connect(token);
-			sut.Send(new Mock<Message>().Object);
+
+			Assert.ThrowsExactly<InvalidOperationException>(() => sut.Send(new Mock<Message>().Object));
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public void MustNotAllowSendingNull()
 		{
-			sut.Send(null);
+			Assert.ThrowsExactly<ArgumentNullException>(() => sut.Send(null));
 		}
 
 		[TestMethod]
diff --git a/SafeExamBrowser.Configuration.UnitTests/Cryptography/KeyGeneratorTests.cs b/SafeExamBrowser.Configuration.UnitTests/Cryptography/KeyGeneratorTests.cs
@@ -36,17 +36,15 @@ public void Initialize()
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(Exception), AllowDerivedTypes = true)]
 		public void CalculateBrowserExamKeyHash_MustFailWithoutUrl()
 		{
-			sut.CalculateBrowserExamKeyHash(default, default, default);
+			Assert.Throws<Exception>(() => sut.CalculateBrowserExamKeyHash(default, default, default));
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(Exception), AllowDerivedTypes = true)]
 		public void CalculateConfigurationKeyHash_MustFailWithoutUrl()
 		{
-			sut.CalculateConfigurationKeyHash(default, default);
+			Assert.Throws<Exception>(() => sut.CalculateConfigurationKeyHash(default, default));
 		}
 
 		[TestMethod]
diff --git a/SafeExamBrowser.Configuration.UnitTests/SubStreamTests.cs b/SafeExamBrowser.Configuration.UnitTests/SubStreamTests.cs
@@ -132,56 +132,49 @@ public void MustSeekCorrectly()
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentException))]
 		public void MustNotAllowNonReadableStream()
 		{
 			stream.SetupGet(s => s.CanRead).Returns(false);
 
-			new SubStream(stream.Object, 0, 0);
+			Assert.ThrowsExactly<ArgumentException>(() => new SubStream(stream.Object, 0, 0));
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentException))]
 		public void MustNotAllowNonSeekableStream()
 		{
 			stream.SetupGet(s => s.CanSeek).Returns(false);
 
-			new SubStream(stream.Object, 0, 0);
+			Assert.ThrowsExactly<ArgumentException>(() => new SubStream(stream.Object, 0, 0));
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentOutOfRangeException))]
 		public void MustNotAllowOffsetSmallerThanZero()
 		{
-			new SubStream(stream.Object, -1, 100);
+			Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => new SubStream(stream.Object, -1, 100));
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentOutOfRangeException))]
 		public void MustNotAllowLengthSmallerThanOne()
 		{
-			new SubStream(stream.Object, 100, 0);
+			Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => new SubStream(stream.Object, 100, 0));
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(NotSupportedException))]
 		public void MustNotSupportFlushing()
 		{
-			new SubStream(stream.Object, 100, 100).Flush();
+			Assert.ThrowsExactly<NotSupportedException>(() => new SubStream(stream.Object, 100, 100).Flush());
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(NotSupportedException))]
 		public void MustNotSupportChangingLength()
 		{
-			new SubStream(stream.Object, 100, 100).SetLength(100);
+			Assert.ThrowsExactly<NotSupportedException>(() => new SubStream(stream.Object, 100, 100).SetLength(100));
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(NotSupportedException))]
 		public void MustNotSupportWriting()
 		{
-			new SubStream(stream.Object, 100, 100).Write(new byte[0], 0, 0);
+			Assert.ThrowsExactly<NotSupportedException>(() => new SubStream(stream.Object, 100, 100).Write(new byte[0], 0, 0));
 		}
 	}
 }
diff --git a/SafeExamBrowser.Core.UnitTests/Operations/LazyInitializationOperationTests.cs b/SafeExamBrowser.Core.UnitTests/Operations/LazyInitializationOperationTests.cs
@@ -36,8 +36,7 @@ IOperation initialize()
 				initialized = true;
 
 				return operationMock.Object;
-			}
-			;
+			};
 
 			var sut = new LazyInitializationOperation(initialize);
 
@@ -47,18 +46,16 @@ IOperation initialize()
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(NullReferenceException))]
 		public void MustNotInstantiateOperationOnRevert()
 		{
 			IOperation initialize()
 			{
 				return operationMock.Object;
-			}
-			;
+			};
 
 			var sut = new LazyInitializationOperation(initialize);
 
-			sut.Revert();
+			Assert.ThrowsExactly<NullReferenceException>(() => sut.Revert());
 		}
 
 		[TestMethod]
@@ -67,8 +64,7 @@ public void MustReturnCorrectOperationResult()
 			IOperation initialize()
 			{
 				return operationMock.Object;
-			}
-			;
+			};
 
 			operationMock.Setup(o => o.Perform()).Returns(OperationResult.Success);
 			operationMock.Setup(o => o.Revert()).Returns(OperationResult.Failed);
@@ -87,8 +83,7 @@ public void MustCorrectlyHandleEventSubscription()
 			IOperation initialize()
 			{
 				return operationMock.Object;
-			}
-			;
+			};
 
 			var statusChanged = 0;
 			var statusChangedHandler = new StatusChangedEventHandler(t => statusChanged++);
@@ -130,8 +125,7 @@ IOperation initialize()
 				}
 
 				return new Mock<IOperation>().Object;
-			}
-			;
+			};
 
 			var sut = new LazyInitializationOperation(initialize);
 
diff --git a/SafeExamBrowser.I18n.UnitTests/XmlTextResourceTests.cs b/SafeExamBrowser.I18n.UnitTests/XmlTextResourceTests.cs
@@ -35,15 +35,14 @@ public void MustCorrectlyLoadData()
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(XmlException))]
 		public void MustFailWithInvalidData()
 		{
 			var location = Assembly.GetAssembly(typeof(XmlTextResourceTests)).Location;
 			var path = $@"{Path.GetDirectoryName(location)}\Text_Invalid.txt";
 			var stream = new FileStream(path, FileMode.Open, FileAccess.Read);
 			var sut = new XmlTextResource(stream);
 
-			sut.LoadText();
+			Assert.ThrowsExactly<XmlException>(() => sut.LoadText());
 		}
 
 		[TestMethod]
@@ -75,10 +74,9 @@ public void MustNeverSetNullValue()
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentNullException))]
 		public void MustNotAcceptNullAsPath()
 		{
-			new XmlTextResource(null);
+			Assert.ThrowsExactly<ArgumentNullException>(() => new XmlTextResource(null));
 		}
 
 		[TestMethod]
diff --git a/SafeExamBrowser.Lockdown.UnitTests/AutoRestoreMechanismTests.cs b/SafeExamBrowser.Lockdown.UnitTests/AutoRestoreMechanismTests.cs
@@ -149,10 +149,9 @@ public void MustStop()
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentException))]
 		public void MustValidateTimeout()
 		{
-			new AutoRestoreMechanism(backup.Object, logger.Object, systemConfigurationUpdate.Object, new Random().Next(int.MinValue, -1));
+			Assert.ThrowsExactly<ArgumentException>(() => new AutoRestoreMechanism(backup.Object, logger.Object, systemConfigurationUpdate.Object, new Random().Next(int.MinValue, -1)));
 		}
 	}
 }
diff --git a/SafeExamBrowser.Lockdown.UnitTests/FeatureConfigurationMonitorTests.cs b/SafeExamBrowser.Lockdown.UnitTests/FeatureConfigurationMonitorTests.cs
@@ -187,10 +187,9 @@ public void MustRemoveConfigurationsWhenReset()
 		}
 
 		[TestMethod]
-		[ExpectedException(typeof(ArgumentException))]
 		public void MustValidateTimeout()
 		{
-			new FeatureConfigurationMonitor(logger.Object, new Random().Next(int.MinValue, -1));
+			Assert.ThrowsExactly<ArgumentException>(() => new FeatureConfigurationMonitor(logger.Object, new Random().Next(int.MinValue, -1)));
 		}
 	}
 }
diff --git a/SafeExamBrowser.Logging.UnitTests/DefaultLogFormatterTests.cs b/SafeExamBrowser.Logging.UnitTests/DefaultLogFormatterTests.cs
@@ -16,12 +16,11 @@ namespace SafeExamBrowser.Logging.UnitTests
 	public class DefaultLogFormatterTests
 	{
 		[TestMethod]
-		[ExpectedException(typeof(NotImplementedException))]
 		public void MustReportNotYetImplementedLogContent()
 		{
 			var sut = new DefaultLogFormatter();
 
-			sut.Format(new NewLogContentType());
+			Assert.ThrowsExactly<NotImplementedException>(() => sut.Format(new NewLogContentType()));
 		}
 
 		[TestMethod]
diff --git a/SafeExamBrowser.Logging.UnitTests/LoggerTests.cs b/SafeExamBrowser.Logging.UnitTests/LoggerTests.cs

Original file line number	Diff line number	Diff line change
`@@ -102,13 +102,13 @@ public void MustReturnDefaultWithoutRules()`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`[TestMethod]`
`105`		`- [ExpectedException(typeof(NotImplementedException))]`
`106`	`105`	`public void MustNotAllowUnsupportedResult()`
`107`	`106`	`{`
`108`	`107`	`var rule = new Mock<IRule>();`
`109`	`108`
`110`	`109`	`rule.SetupGet(r => r.Result).Returns((FilterResult) (-1));`
`111`		`- sut.Load(rule.Object);`
	`110`	`+`
	`111`	`+ Assert.ThrowsExactly<NotImplementedException>(() => sut.Load(rule.Object));`
`112`	`112`	`}`
`113`	`113`	`}`
`114`	`114`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,10 +33,9 @@ public void MustCreateCorrectRules()`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`[TestMethod]`
`36`		`- [ExpectedException(typeof(NotImplementedException))]`
`37`	`36`	`public void MustNotAllowUnsupportedFilterType()`
`38`	`37`	`{`
`39`		`- sut.CreateRule((FilterRuleType) (-1));`
	`38`	`+ Assert.ThrowsExactly<NotImplementedException>(() => sut.CreateRule((FilterRuleType) (-1)));`
`40`	`39`	`}`
`41`	`40`	`}`
`42`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,17 +51,15 @@ public void MustInitializeResult()`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`[TestMethod]`
`54`		`- [ExpectedException(typeof(ArgumentNullException))]`
`55`	`54`	`public void MustNotAllowUndefinedExpression()`
`56`	`55`	`{`
`57`		`- sut.Initialize(new FilterRuleSettings());`
	`56`	`+ Assert.ThrowsExactly<ArgumentNullException>(() => sut.Initialize(new FilterRuleSettings()));`
`58`	`57`	`}`
`59`	`58`
`60`	`59`	`[TestMethod]`
`61`		`- [ExpectedException(typeof(ArgumentException))]`
`62`	`60`	`public void MustValidateExpression()`
`63`	`61`	`{`
`64`		- sut.Initialize(new FilterRuleSettings { Expression = "ç+\"}%&/(+)=?{=+¦]@#°§]`?´^¨'°[¬\|¢" });
	`62`	+ Assert.ThrowsExactly<ArgumentException>(() => sut.Initialize(new FilterRuleSettings { Expression = "ç+\"}%&/(+)=?{=+¦]@#°§]`?´^¨'°[¬\|¢" }));
`65`	`63`	`}`
`66`	`64`	`}`
`67`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,10 +51,9 @@ public void MustInitializeResult()`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`[TestMethod]`
`54`		`- [ExpectedException(typeof(ArgumentNullException))]`
`55`	`54`	`public void MustNotAllowUndefinedExpression()`
`56`	`55`	`{`
`57`		`- sut.Initialize(new FilterRuleSettings());`
	`56`	`+ Assert.ThrowsExactly<ArgumentNullException>(() => sut.Initialize(new FilterRuleSettings()));`
`58`	`57`	`}`
`59`	`58`
`60`	`59`	`[TestMethod]`
`@@ -73,7 +72,7 @@ public void MustValidateExpression()`
`73`	`72`
`74`	`73`	`foreach (var expression in invalid)`
`75`	`74`	`{`
`76`		`- Assert.ThrowsException<ArgumentException>(() => sut.Initialize(new FilterRuleSettings { Expression = expression }));`
	`75`	`+ Assert.ThrowsExactly<ArgumentException>(() => sut.Initialize(new FilterRuleSettings { Expression = expression }));`
`77`	`76`	`}`
`78`	`77`	`}`
`79`	`78`
Original file line number	Diff line number	Diff line change
`@@ -53,12 +53,11 @@ public void MustCorrectlyStartHost()`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`[TestMethod]`
`56`		`- [ExpectedException(typeof(CommunicationException))]`
`57`	`56`	`public void MustCorrectlyHandleStartupException()`
`58`	`57`	`{`
`59`	`58`	`hostObject.Setup(h => h.Open()).Throws<Exception>();`
`60`	`59`
`61`		`- sut.Start();`
	`60`	`+ Assert.ThrowsExactly<CommunicationException>(() => sut.Start());`
`62`	`61`	`}`
`63`	`62`
`64`	`63`	`[TestMethod]`
`@@ -71,13 +70,12 @@ public void MustCorrectlyStopHost()`
`71`	`70`	`}`
`72`	`71`
`73`	`72`	`[TestMethod]`
`74`		`- [ExpectedException(typeof(CommunicationException))]`
`75`	`73`	`public void MustCorrectlyHandleShutdownException()`
`76`	`74`	`{`
`77`	`75`	`hostObject.Setup(h => h.Close()).Throws<Exception>();`
`78`		`-`
`79`	`76`	`sut.Start();`
`80`		`- sut.Stop();`
	`77`	`+`
	`78`	`+ Assert.ThrowsExactly<CommunicationException>(() => sut.Stop());`
`81`	`79`	`}`
`82`	`80`
`83`	`81`	`[TestMethod]`
Original file line number	Diff line number	Diff line change
`@@ -171,14 +171,12 @@ public void MustFailToDisconnectIfChannelNotOpen()`
`171`	`171`	`}`
`172`	`172`
`173`	`173`	`[TestMethod]`
`174`		`- [ExpectedException(typeof(InvalidOperationException))]`
`175`	`174`	`public void MustFailToSendIfNotConnected()`
`176`	`175`	`{`
`177`		`- sut.Send(new Mock<Message>().Object);`
	`176`	`+ Assert.ThrowsExactly<InvalidOperationException>(() => sut.Send(new Mock<Message>().Object));`
`178`	`177`	`}`
`179`	`178`
`180`	`179`	`[TestMethod]`
`181`		`- [ExpectedException(typeof(InvalidOperationException))]`
`182`	`180`	`public void MustFailToSendIfChannelNotOpen()`
`183`	`181`	`{`
`184`	`182`	`var proxy = new Mock<IProxyObject>();`
`@@ -195,14 +193,14 @@ public void MustFailToSendIfChannelNotOpen()`
`195`	`193`	`var token = Guid.NewGuid();`
`196`	`194`
`197`	`195`	`sut.Connect(token);`
`198`		`- sut.Send(new Mock<Message>().Object);`
	`196`	`+`
	`197`	`+ Assert.ThrowsExactly<InvalidOperationException>(() => sut.Send(new Mock<Message>().Object));`
`199`	`198`	`}`
`200`	`199`
`201`	`200`	`[TestMethod]`
`202`		`- [ExpectedException(typeof(ArgumentNullException))]`
`203`	`201`	`public void MustNotAllowSendingNull()`
`204`	`202`	`{`
`205`		`- sut.Send(null);`
	`203`	`+ Assert.ThrowsExactly<ArgumentNullException>(() => sut.Send(null));`
`206`	`204`	`}`
`207`	`205`
`208`	`206`	`[TestMethod]`
Original file line number	Diff line number	Diff line change
`@@ -36,17 +36,15 @@ public void Initialize()`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`[TestMethod]`
`39`		`- [ExpectedException(typeof(Exception), AllowDerivedTypes = true)]`
`40`	`39`	`public void CalculateBrowserExamKeyHash_MustFailWithoutUrl()`
`41`	`40`	`{`
`42`		`- sut.CalculateBrowserExamKeyHash(default, default, default);`
	`41`	`+ Assert.Throws<Exception>(() => sut.CalculateBrowserExamKeyHash(default, default, default));`
`43`	`42`	`}`
`44`	`43`
`45`	`44`	`[TestMethod]`
`46`		`- [ExpectedException(typeof(Exception), AllowDerivedTypes = true)]`
`47`	`45`	`public void CalculateConfigurationKeyHash_MustFailWithoutUrl()`
`48`	`46`	`{`
`49`		`- sut.CalculateConfigurationKeyHash(default, default);`
	`47`	`+ Assert.Throws<Exception>(() => sut.CalculateConfigurationKeyHash(default, default));`
`50`	`48`	`}`
`51`	`49`
`52`	`50`	`[TestMethod]`
Original file line number	Diff line number	Diff line change
`@@ -132,56 +132,49 @@ public void MustSeekCorrectly()`
`132`	`132`	`}`
`133`	`133`
`134`	`134`	`[TestMethod]`
`135`		`- [ExpectedException(typeof(ArgumentException))]`
`136`	`135`	`public void MustNotAllowNonReadableStream()`
`137`	`136`	`{`
`138`	`137`	`stream.SetupGet(s => s.CanRead).Returns(false);`
`139`	`138`
`140`		`- new SubStream(stream.Object, 0, 0);`
	`139`	`+ Assert.ThrowsExactly<ArgumentException>(() => new SubStream(stream.Object, 0, 0));`
`141`	`140`	`}`
`142`	`141`
`143`	`142`	`[TestMethod]`
`144`		`- [ExpectedException(typeof(ArgumentException))]`
`145`	`143`	`public void MustNotAllowNonSeekableStream()`
`146`	`144`	`{`
`147`	`145`	`stream.SetupGet(s => s.CanSeek).Returns(false);`
`148`	`146`
`149`		`- new SubStream(stream.Object, 0, 0);`
	`147`	`+ Assert.ThrowsExactly<ArgumentException>(() => new SubStream(stream.Object, 0, 0));`
`150`	`148`	`}`
`151`	`149`
`152`	`150`	`[TestMethod]`
`153`		`- [ExpectedException(typeof(ArgumentOutOfRangeException))]`
`154`	`151`	`public void MustNotAllowOffsetSmallerThanZero()`
`155`	`152`	`{`
`156`		`- new SubStream(stream.Object, -1, 100);`
	`153`	`+ Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => new SubStream(stream.Object, -1, 100));`
`157`	`154`	`}`
`158`	`155`
`159`	`156`	`[TestMethod]`
`160`		`- [ExpectedException(typeof(ArgumentOutOfRangeException))]`
`161`	`157`	`public void MustNotAllowLengthSmallerThanOne()`
`162`	`158`	`{`
`163`		`- new SubStream(stream.Object, 100, 0);`
	`159`	`+ Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => new SubStream(stream.Object, 100, 0));`
`164`	`160`	`}`
`165`	`161`
`166`	`162`	`[TestMethod]`
`167`		`- [ExpectedException(typeof(NotSupportedException))]`
`168`	`163`	`public void MustNotSupportFlushing()`
`169`	`164`	`{`
`170`		`- new SubStream(stream.Object, 100, 100).Flush();`
	`165`	`+ Assert.ThrowsExactly<NotSupportedException>(() => new SubStream(stream.Object, 100, 100).Flush());`
`171`	`166`	`}`
`172`	`167`
`173`	`168`	`[TestMethod]`
`174`		`- [ExpectedException(typeof(NotSupportedException))]`
`175`	`169`	`public void MustNotSupportChangingLength()`
`176`	`170`	`{`
`177`		`- new SubStream(stream.Object, 100, 100).SetLength(100);`
	`171`	`+ Assert.ThrowsExactly<NotSupportedException>(() => new SubStream(stream.Object, 100, 100).SetLength(100));`
`178`	`172`	`}`
`179`	`173`
`180`	`174`	`[TestMethod]`
`181`		`- [ExpectedException(typeof(NotSupportedException))]`
`182`	`175`	`public void MustNotSupportWriting()`
`183`	`176`	`{`
`184`		`- new SubStream(stream.Object, 100, 100).Write(new byte[0], 0, 0);`
	`177`	`+ Assert.ThrowsExactly<NotSupportedException>(() => new SubStream(stream.Object, 100, 100).Write(new byte[0], 0, 0));`
`185`	`178`	`}`
`186`	`179`	`}`
`187`	`180`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,15 +35,14 @@ public void MustCorrectlyLoadData()`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`[TestMethod]`
`38`		`- [ExpectedException(typeof(XmlException))]`
`39`	`38`	`public void MustFailWithInvalidData()`
`40`	`39`	`{`
`41`	`40`	`var location = Assembly.GetAssembly(typeof(XmlTextResourceTests)).Location;`
`42`	`41`	`var path = $@"{Path.GetDirectoryName(location)}\Text_Invalid.txt";`
`43`	`42`	`var stream = new FileStream(path, FileMode.Open, FileAccess.Read);`
`44`	`43`	`var sut = new XmlTextResource(stream);`
`45`	`44`
`46`		`- sut.LoadText();`
	`45`	`+ Assert.ThrowsExactly<XmlException>(() => sut.LoadText());`
`47`	`46`	`}`
`48`	`47`
`49`	`48`	`[TestMethod]`
`@@ -75,10 +74,9 @@ public void MustNeverSetNullValue()`
`75`	`74`	`}`
`76`	`75`
`77`	`76`	`[TestMethod]`
`78`		`- [ExpectedException(typeof(ArgumentNullException))]`
`79`	`77`	`public void MustNotAcceptNullAsPath()`
`80`	`78`	`{`
`81`		`- new XmlTextResource(null);`
	`79`	`+ Assert.ThrowsExactly<ArgumentNullException>(() => new XmlTextResource(null));`
`82`	`80`	`}`
`83`	`81`
`84`	`82`	`[TestMethod]`