Annotate AssertTests

Vogel612 · Vogel612 · commit fe0351d93d08 · 2017-01-16T00:43:42.000+01:00
diff --git a/RubberduckTests/UnitTesting/AssertTests.cs b/RubberduckTests/UnitTesting/AssertTests.cs
@@ -21,6 +21,7 @@ public void Cleanup()
             AssertHandler.OnAssertCompleted -= AssertHandler_OnAssertCompleted;
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void IsTrueSucceedsWithTrueExpression()
         {
@@ -30,6 +31,7 @@ public void IsTrueSucceedsWithTrueExpression()
             Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void IsTrueFailsWithFalseExpression()
         {
@@ -39,6 +41,7 @@ public void IsTrueFailsWithFalseExpression()
             Assert.AreEqual(TestOutcome.Failed, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void IsFalseSucceedsWithFalseExpression()
         {
@@ -48,6 +51,7 @@ public void IsFalseSucceedsWithFalseExpression()
             Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void IsFalseFailsWithTrueExpression()
         {
@@ -57,6 +61,7 @@ public void IsFalseFailsWithTrueExpression()
             Assert.AreEqual(TestOutcome.Failed, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void AreSameShouldSucceedWithSameReferences()
         {
@@ -68,6 +73,7 @@ public void AreSameShouldSucceedWithSameReferences()
             Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void AreSameShouldFailWithDifferentReferences()
         {
@@ -79,6 +85,7 @@ public void AreSameShouldFailWithDifferentReferences()
             Assert.AreEqual(TestOutcome.Failed, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void AreSameShouldSucceedWithTwoNullReferences()
         {
@@ -88,6 +95,7 @@ public void AreSameShouldSucceedWithTwoNullReferences()
             Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void AreSameShouldFailWithActualNullReference()
         {
@@ -97,6 +105,7 @@ public void AreSameShouldFailWithActualNullReference()
             Assert.AreEqual(TestOutcome.Failed, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void AreSameShouldFailWithExpectedNullReference()
         {
@@ -106,6 +115,7 @@ public void AreSameShouldFailWithExpectedNullReference()
             Assert.AreEqual(TestOutcome.Failed, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void AreNotSameShouldSucceedWithDifferentReferences()
         {
@@ -117,6 +127,7 @@ public void AreNotSameShouldSucceedWithDifferentReferences()
             Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void AreNotSameShouldSuccedWithOneNullReference()
         {
@@ -126,6 +137,7 @@ public void AreNotSameShouldSuccedWithOneNullReference()
             Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void AreNotSameShouldFailWithBothNullReferences()
         {
@@ -135,6 +147,7 @@ public void AreNotSameShouldFailWithBothNullReferences()
             Assert.AreEqual(TestOutcome.Failed, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void AreNotSameShouldFailWithSameReferences()
         {
@@ -146,6 +159,7 @@ public void AreNotSameShouldFailWithSameReferences()
             Assert.AreEqual(TestOutcome.Failed, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void AreEqualShouldSucceedWithSameValues()
         {
@@ -155,6 +169,7 @@ public void AreEqualShouldSucceedWithSameValues()
             Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void AreEqualShouldFailWithDifferentValues()
         {
@@ -164,6 +179,7 @@ public void AreEqualShouldFailWithDifferentValues()
             Assert.AreEqual(TestOutcome.Failed, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void AreNotEqualShouldSucceedWithDifferentValues()
         {
@@ -173,6 +189,7 @@ public void AreNotEqualShouldSucceedWithDifferentValues()
             Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void AreNotEqualShouldFailWithSameValues()
         {
@@ -182,6 +199,7 @@ public void AreNotEqualShouldFailWithSameValues()
             Assert.AreEqual(TestOutcome.Failed, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void AreNotEqualShouldBeInconclusiveWithDifferentTypes()
         {
@@ -194,6 +212,7 @@ public void AreNotEqualShouldBeInconclusiveWithDifferentTypes()
             Assert.AreEqual(TestOutcome.Inconclusive, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void IsNothingShouldSucceedWithNullValue()
         {
@@ -203,6 +222,7 @@ public void IsNothingShouldSucceedWithNullValue()
             Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void IsNothingShouldFailWithNonNullValue()
         {
@@ -212,6 +232,7 @@ public void IsNothingShouldFailWithNonNullValue()
             Assert.AreEqual(TestOutcome.Failed, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void IsNotNothingShouldFailWithNullValue()
         {
@@ -221,6 +242,7 @@ public void IsNotNothingShouldFailWithNullValue()
             Assert.AreEqual(TestOutcome.Failed, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void IsNotNothingShouldSucceedWithNonNullValue()
         {
@@ -230,6 +252,7 @@ public void IsNotNothingShouldSucceedWithNonNullValue()
             Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void FailShouldFail()
         {
@@ -239,6 +262,7 @@ public void FailShouldFail()
             Assert.AreEqual(TestOutcome.Failed, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void InconclusiveShouldBeInconclusive()
         {
@@ -253,6 +277,7 @@ private void AssertHandler_OnAssertCompleted(object sender, AssertCompletedEvent
             _args = e;
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void NullValuesAreEqual()
         {
@@ -262,6 +287,7 @@ public void NullValuesAreEqual()
             Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void NullAndEmptyStringAreEqual()
         {
@@ -271,6 +297,7 @@ public void NullAndEmptyStringAreEqual()
             Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void NullIsNotComparableWithValues()
         {
@@ -280,6 +307,7 @@ public void NullIsNotComparableWithValues()
             Assert.AreEqual(TestOutcome.Inconclusive, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void DifferentTypesEqualityIsNotConclusive()
         {
@@ -289,6 +317,7 @@ public void DifferentTypesEqualityIsNotConclusive()
             Assert.AreEqual(TestOutcome.Inconclusive, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void OnAssertSucceeded_ReturnsResultSuccess()
         {
@@ -297,6 +326,7 @@ public void OnAssertSucceeded_ReturnsResultSuccess()
             Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void OnAssertFailed_ReturnsResultFailed()
         {
@@ -305,6 +335,7 @@ public void OnAssertFailed_ReturnsResultFailed()
             Assert.AreEqual(TestOutcome.Failed, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void OnAssertInconclusive_ReturnsResultInconclusive()
         {
@@ -313,6 +344,7 @@ public void OnAssertInconclusive_ReturnsResultInconclusive()
             Assert.AreEqual(TestOutcome.Inconclusive, _args.Outcome);
         }
 
+        [TestCategory("Unit Testing")]
         [TestMethod]
         public void OnAssertIgnored_ReturnsResultIgnored()
         {

Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,7 @@ public void Cleanup()`
`21`	`21`	`AssertHandler.OnAssertCompleted -= AssertHandler_OnAssertCompleted;`
`22`	`22`	`}`
`23`	`23`
	`24`	`+ [TestCategory("Unit Testing")]`
`24`	`25`	`[TestMethod]`
`25`	`26`	`public void IsTrueSucceedsWithTrueExpression()`
`26`	`27`	`{`
`@@ -30,6 +31,7 @@ public void IsTrueSucceedsWithTrueExpression()`
`30`	`31`	`Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);`
`31`	`32`	`}`
`32`	`33`
	`34`	`+ [TestCategory("Unit Testing")]`
`33`	`35`	`[TestMethod]`
`34`	`36`	`public void IsTrueFailsWithFalseExpression()`
`35`	`37`	`{`
`@@ -39,6 +41,7 @@ public void IsTrueFailsWithFalseExpression()`
`39`	`41`	`Assert.AreEqual(TestOutcome.Failed, _args.Outcome);`
`40`	`42`	`}`
`41`	`43`
	`44`	`+ [TestCategory("Unit Testing")]`
`42`	`45`	`[TestMethod]`
`43`	`46`	`public void IsFalseSucceedsWithFalseExpression()`
`44`	`47`	`{`
`@@ -48,6 +51,7 @@ public void IsFalseSucceedsWithFalseExpression()`
`48`	`51`	`Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);`
`49`	`52`	`}`
`50`	`53`
	`54`	`+ [TestCategory("Unit Testing")]`
`51`	`55`	`[TestMethod]`
`52`	`56`	`public void IsFalseFailsWithTrueExpression()`
`53`	`57`	`{`
`@@ -57,6 +61,7 @@ public void IsFalseFailsWithTrueExpression()`
`57`	`61`	`Assert.AreEqual(TestOutcome.Failed, _args.Outcome);`
`58`	`62`	`}`
`59`	`63`
	`64`	`+ [TestCategory("Unit Testing")]`
`60`	`65`	`[TestMethod]`
`61`	`66`	`public void AreSameShouldSucceedWithSameReferences()`
`62`	`67`	`{`
`@@ -68,6 +73,7 @@ public void AreSameShouldSucceedWithSameReferences()`
`68`	`73`	`Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);`
`69`	`74`	`}`
`70`	`75`
	`76`	`+ [TestCategory("Unit Testing")]`
`71`	`77`	`[TestMethod]`
`72`	`78`	`public void AreSameShouldFailWithDifferentReferences()`
`73`	`79`	`{`
`@@ -79,6 +85,7 @@ public void AreSameShouldFailWithDifferentReferences()`
`79`	`85`	`Assert.AreEqual(TestOutcome.Failed, _args.Outcome);`
`80`	`86`	`}`
`81`	`87`
	`88`	`+ [TestCategory("Unit Testing")]`
`82`	`89`	`[TestMethod]`
`83`	`90`	`public void AreSameShouldSucceedWithTwoNullReferences()`
`84`	`91`	`{`
`@@ -88,6 +95,7 @@ public void AreSameShouldSucceedWithTwoNullReferences()`
`88`	`95`	`Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);`
`89`	`96`	`}`
`90`	`97`
	`98`	`+ [TestCategory("Unit Testing")]`
`91`	`99`	`[TestMethod]`
`92`	`100`	`public void AreSameShouldFailWithActualNullReference()`
`93`	`101`	`{`
`@@ -97,6 +105,7 @@ public void AreSameShouldFailWithActualNullReference()`
`97`	`105`	`Assert.AreEqual(TestOutcome.Failed, _args.Outcome);`
`98`	`106`	`}`
`99`	`107`
	`108`	`+ [TestCategory("Unit Testing")]`
`100`	`109`	`[TestMethod]`
`101`	`110`	`public void AreSameShouldFailWithExpectedNullReference()`
`102`	`111`	`{`
`@@ -106,6 +115,7 @@ public void AreSameShouldFailWithExpectedNullReference()`
`106`	`115`	`Assert.AreEqual(TestOutcome.Failed, _args.Outcome);`
`107`	`116`	`}`
`108`	`117`
	`118`	`+ [TestCategory("Unit Testing")]`
`109`	`119`	`[TestMethod]`
`110`	`120`	`public void AreNotSameShouldSucceedWithDifferentReferences()`
`111`	`121`	`{`
`@@ -117,6 +127,7 @@ public void AreNotSameShouldSucceedWithDifferentReferences()`
`117`	`127`	`Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);`
`118`	`128`	`}`
`119`	`129`
	`130`	`+ [TestCategory("Unit Testing")]`
`120`	`131`	`[TestMethod]`
`121`	`132`	`public void AreNotSameShouldSuccedWithOneNullReference()`
`122`	`133`	`{`
`@@ -126,6 +137,7 @@ public void AreNotSameShouldSuccedWithOneNullReference()`
`126`	`137`	`Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);`
`127`	`138`	`}`
`128`	`139`
	`140`	`+ [TestCategory("Unit Testing")]`
`129`	`141`	`[TestMethod]`
`130`	`142`	`public void AreNotSameShouldFailWithBothNullReferences()`
`131`	`143`	`{`
`@@ -135,6 +147,7 @@ public void AreNotSameShouldFailWithBothNullReferences()`
`135`	`147`	`Assert.AreEqual(TestOutcome.Failed, _args.Outcome);`
`136`	`148`	`}`
`137`	`149`
	`150`	`+ [TestCategory("Unit Testing")]`
`138`	`151`	`[TestMethod]`
`139`	`152`	`public void AreNotSameShouldFailWithSameReferences()`
`140`	`153`	`{`
`@@ -146,6 +159,7 @@ public void AreNotSameShouldFailWithSameReferences()`
`146`	`159`	`Assert.AreEqual(TestOutcome.Failed, _args.Outcome);`
`147`	`160`	`}`
`148`	`161`
	`162`	`+ [TestCategory("Unit Testing")]`
`149`	`163`	`[TestMethod]`
`150`	`164`	`public void AreEqualShouldSucceedWithSameValues()`
`151`	`165`	`{`
`@@ -155,6 +169,7 @@ public void AreEqualShouldSucceedWithSameValues()`
`155`	`169`	`Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);`
`156`	`170`	`}`
`157`	`171`
	`172`	`+ [TestCategory("Unit Testing")]`
`158`	`173`	`[TestMethod]`
`159`	`174`	`public void AreEqualShouldFailWithDifferentValues()`
`160`	`175`	`{`
`@@ -164,6 +179,7 @@ public void AreEqualShouldFailWithDifferentValues()`
`164`	`179`	`Assert.AreEqual(TestOutcome.Failed, _args.Outcome);`
`165`	`180`	`}`
`166`	`181`
	`182`	`+ [TestCategory("Unit Testing")]`
`167`	`183`	`[TestMethod]`
`168`	`184`	`public void AreNotEqualShouldSucceedWithDifferentValues()`
`169`	`185`	`{`
`@@ -173,6 +189,7 @@ public void AreNotEqualShouldSucceedWithDifferentValues()`
`173`	`189`	`Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);`
`174`	`190`	`}`
`175`	`191`
	`192`	`+ [TestCategory("Unit Testing")]`
`176`	`193`	`[TestMethod]`
`177`	`194`	`public void AreNotEqualShouldFailWithSameValues()`
`178`	`195`	`{`
`@@ -182,6 +199,7 @@ public void AreNotEqualShouldFailWithSameValues()`
`182`	`199`	`Assert.AreEqual(TestOutcome.Failed, _args.Outcome);`
`183`	`200`	`}`
`184`	`201`
	`202`	`+ [TestCategory("Unit Testing")]`
`185`	`203`	`[TestMethod]`
`186`	`204`	`public void AreNotEqualShouldBeInconclusiveWithDifferentTypes()`
`187`	`205`	`{`
`@@ -194,6 +212,7 @@ public void AreNotEqualShouldBeInconclusiveWithDifferentTypes()`
`194`	`212`	`Assert.AreEqual(TestOutcome.Inconclusive, _args.Outcome);`
`195`	`213`	`}`
`196`	`214`
	`215`	`+ [TestCategory("Unit Testing")]`
`197`	`216`	`[TestMethod]`
`198`	`217`	`public void IsNothingShouldSucceedWithNullValue()`
`199`	`218`	`{`
`@@ -203,6 +222,7 @@ public void IsNothingShouldSucceedWithNullValue()`
`203`	`222`	`Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);`
`204`	`223`	`}`
`205`	`224`
	`225`	`+ [TestCategory("Unit Testing")]`
`206`	`226`	`[TestMethod]`
`207`	`227`	`public void IsNothingShouldFailWithNonNullValue()`
`208`	`228`	`{`
`@@ -212,6 +232,7 @@ public void IsNothingShouldFailWithNonNullValue()`
`212`	`232`	`Assert.AreEqual(TestOutcome.Failed, _args.Outcome);`
`213`	`233`	`}`
`214`	`234`
	`235`	`+ [TestCategory("Unit Testing")]`
`215`	`236`	`[TestMethod]`
`216`	`237`	`public void IsNotNothingShouldFailWithNullValue()`
`217`	`238`	`{`
`@@ -221,6 +242,7 @@ public void IsNotNothingShouldFailWithNullValue()`
`221`	`242`	`Assert.AreEqual(TestOutcome.Failed, _args.Outcome);`
`222`	`243`	`}`
`223`	`244`
	`245`	`+ [TestCategory("Unit Testing")]`
`224`	`246`	`[TestMethod]`
`225`	`247`	`public void IsNotNothingShouldSucceedWithNonNullValue()`
`226`	`248`	`{`
`@@ -230,6 +252,7 @@ public void IsNotNothingShouldSucceedWithNonNullValue()`
`230`	`252`	`Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);`
`231`	`253`	`}`
`232`	`254`
	`255`	`+ [TestCategory("Unit Testing")]`
`233`	`256`	`[TestMethod]`
`234`	`257`	`public void FailShouldFail()`
`235`	`258`	`{`
`@@ -239,6 +262,7 @@ public void FailShouldFail()`
`239`	`262`	`Assert.AreEqual(TestOutcome.Failed, _args.Outcome);`
`240`	`263`	`}`
`241`	`264`
	`265`	`+ [TestCategory("Unit Testing")]`
`242`	`266`	`[TestMethod]`
`243`	`267`	`public void InconclusiveShouldBeInconclusive()`
`244`	`268`	`{`
`@@ -253,6 +277,7 @@ private void AssertHandler_OnAssertCompleted(object sender, AssertCompletedEvent`
`253`	`277`	`_args = e;`
`254`	`278`	`}`
`255`	`279`
	`280`	`+ [TestCategory("Unit Testing")]`
`256`	`281`	`[TestMethod]`
`257`	`282`	`public void NullValuesAreEqual()`
`258`	`283`	`{`
`@@ -262,6 +287,7 @@ public void NullValuesAreEqual()`
`262`	`287`	`Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);`
`263`	`288`	`}`
`264`	`289`
	`290`	`+ [TestCategory("Unit Testing")]`
`265`	`291`	`[TestMethod]`
`266`	`292`	`public void NullAndEmptyStringAreEqual()`
`267`	`293`	`{`
`@@ -271,6 +297,7 @@ public void NullAndEmptyStringAreEqual()`
`271`	`297`	`Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);`
`272`	`298`	`}`
`273`	`299`
	`300`	`+ [TestCategory("Unit Testing")]`
`274`	`301`	`[TestMethod]`
`275`	`302`	`public void NullIsNotComparableWithValues()`
`276`	`303`	`{`
`@@ -280,6 +307,7 @@ public void NullIsNotComparableWithValues()`
`280`	`307`	`Assert.AreEqual(TestOutcome.Inconclusive, _args.Outcome);`
`281`	`308`	`}`
`282`	`309`
	`310`	`+ [TestCategory("Unit Testing")]`
`283`	`311`	`[TestMethod]`
`284`	`312`	`public void DifferentTypesEqualityIsNotConclusive()`
`285`	`313`	`{`
`@@ -289,6 +317,7 @@ public void DifferentTypesEqualityIsNotConclusive()`
`289`	`317`	`Assert.AreEqual(TestOutcome.Inconclusive, _args.Outcome);`
`290`	`318`	`}`
`291`	`319`
	`320`	`+ [TestCategory("Unit Testing")]`
`292`	`321`	`[TestMethod]`
`293`	`322`	`public void OnAssertSucceeded_ReturnsResultSuccess()`
`294`	`323`	`{`
`@@ -297,6 +326,7 @@ public void OnAssertSucceeded_ReturnsResultSuccess()`
`297`	`326`	`Assert.AreEqual(TestOutcome.Succeeded, _args.Outcome);`
`298`	`327`	`}`
`299`	`328`
	`329`	`+ [TestCategory("Unit Testing")]`
`300`	`330`	`[TestMethod]`
`301`	`331`	`public void OnAssertFailed_ReturnsResultFailed()`
`302`	`332`	`{`
`@@ -305,6 +335,7 @@ public void OnAssertFailed_ReturnsResultFailed()`
`305`	`335`	`Assert.AreEqual(TestOutcome.Failed, _args.Outcome);`
`306`	`336`	`}`
`307`	`337`
	`338`	`+ [TestCategory("Unit Testing")]`
`308`	`339`	`[TestMethod]`
`309`	`340`	`public void OnAssertInconclusive_ReturnsResultInconclusive()`
`310`	`341`	`{`
`@@ -313,6 +344,7 @@ public void OnAssertInconclusive_ReturnsResultInconclusive()`
`313`	`344`	`Assert.AreEqual(TestOutcome.Inconclusive, _args.Outcome);`
`314`	`345`	`}`
`315`	`346`
	`347`	`+ [TestCategory("Unit Testing")]`
`316`	`348`	`[TestMethod]`
`317`	`349`	`public void OnAssertIgnored_ReturnsResultIgnored()`
`318`	`350`	`{`