Bad request removed from TActionResult chaining (#13)

ivaylokenov · ivaylokenov · commit efc0e20392dd · 2015-08-30T21:55:28.000+03:00
diff --git a/MyWebApi/Builders/Actions/ShouldReturnBadRequest.cs b/MyWebApi/Builders/Actions/ShouldReturnBadRequest.cs
@@ -16,25 +16,22 @@ public partial class ActionResultTestBuilder<TActionResult>
         /// Tests whether action result is BadRequestResult, InvalidModelStateResult or BadRequestErrorMessageResult.
         /// </summary>
         /// <returns>Bad request test builder.</returns>
-        public IBadRequestTestBuilder<TActionResult> ShouldReturnBadRequest()
+        public IBadRequestTestBuilder ShouldReturnBadRequest()
         {
             if (this.ActionResult as BadRequestResult != null)
             {
-                return this.ReturnBadRequestTestBuilder<BadRequestResult>()
-                    as IBadRequestTestBuilder<TActionResult>;
+                return this.ReturnBadRequestTestBuilder<BadRequestResult>();
             }
 
             if (this.ActionResult as InvalidModelStateResult != null)
             {
-                return this.ReturnBadRequestTestBuilder<InvalidModelStateResult>()
-                    as IBadRequestTestBuilder<TActionResult>;
+                return this.ReturnBadRequestTestBuilder<InvalidModelStateResult>();
             }
 
-            return this.ReturnBadRequestTestBuilder<BadRequestErrorMessageResult>()
-                as IBadRequestTestBuilder<TActionResult>;
+            return this.ReturnBadRequestTestBuilder<BadRequestErrorMessageResult>();
         }
 
-        private IBadRequestTestBuilder<TBadRequestResult> ReturnBadRequestTestBuilder<TBadRequestResult>()
+        private IBadRequestTestBuilder ReturnBadRequestTestBuilder<TBadRequestResult>()
             where TBadRequestResult : class
         {
             var badRequestResult = this.GetReturnObject<TBadRequestResult>();
diff --git a/MyWebApi/Builders/BadRequests/BadRequestErrorMessageTestBuilder.cs b/MyWebApi/Builders/BadRequests/BadRequestErrorMessageTestBuilder.cs
@@ -1,33 +1,30 @@
 ﻿namespace MyWebApi.Builders.BadRequests
 {
     using System.Web.Http;
-    using System.Web.Http.Results;
     using Base;
     using Common.Extensions;
-    using Contracts.And;
     using Contracts.BadRequests;
     using Exceptions;
 
     /// <summary>
     /// Used for testing specific bad request error messages.
     /// </summary>
-    public class BadRequestErrorMessageTestBuilder<TBadRequestResult>
-        : BaseTestBuilderWithActionResult<TBadRequestResult>, IBadRequestErrorMessageTestBuilder<TBadRequestResult>
+    public class BadRequestErrorMessageTestBuilder
+        : BaseTestBuilder, IBadRequestErrorMessageTestBuilder
     {
         private readonly string actualMessage;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="BadRequestErrorMessageTestBuilder{TBadRequestResult}" /> class.
+        /// Initializes a new instance of the <see cref="BadRequestErrorMessageTestBuilder" /> class.
         /// </summary>
         /// <param name="controller">Controller on which the action will be tested.</param>
         /// <param name="actionName">Name of the tested action.</param>
         /// <param name="actualMessage">Actual error message received from bad request result.</param>
         public BadRequestErrorMessageTestBuilder(
             ApiController controller,
             string actionName,
-            TBadRequestResult actionResult,
             string actualMessage)
-            : base(controller, actionName, actionResult)
+            : base(controller, actionName)
         {
             this.actualMessage = actualMessage;
         }
@@ -36,64 +33,56 @@ public BadRequestErrorMessageTestBuilder(
         /// Tests whether particular error message is equal to given message.
         /// </summary>
         /// <param name="errorMessage">Expected error message for particular key.</param>
-        public IAndTestBuilder<TBadRequestResult> ThatEquals(string errorMessage)
+        public void ThatEquals(string errorMessage)
         {
             if (this.actualMessage != errorMessage)
             {
                 this.ThrowNewBadRequestResultAssertionException(
                     "When calling {0} action in {1} expected bad request error message to be '{2}', but instead found '{3}'.",
                     errorMessage);
             }
-
-            return this.NewAndTestBuilder();
         }
 
         /// <summary>
         /// Tests whether particular error message begins with given message.
         /// </summary>
         /// <param name="beginMessage">Expected beginning for particular error message.</param>
-        public IAndTestBuilder<TBadRequestResult> BeginningWith(string beginMessage)
+        public void BeginningWith(string beginMessage)
         {
             if (!this.actualMessage.StartsWith(beginMessage))
             {
                 this.ThrowNewBadRequestResultAssertionException(
                     "When calling {0} action in {1} expected bad request error message to begin with '{2}', but instead found '{3}'.",
                     beginMessage);
             }
-
-            return this.NewAndTestBuilder();
         }
 
         /// <summary>
         /// Tests whether particular error message ends with given message.
         /// </summary>
         /// <param name="endMessage">Expected ending for particular error message.</param>
-        public IAndTestBuilder<TBadRequestResult> EndingWith(string endMessage)
+        public void EndingWith(string endMessage)
         {
             if (!this.actualMessage.EndsWith(endMessage))
             {
                 this.ThrowNewBadRequestResultAssertionException(
                     "When calling {0} action in {1} expected bad request error message to end with '{2}', but instead found '{3}'.",
                     endMessage);
             }
-
-            return this.NewAndTestBuilder();
         }
 
         /// <summary>
         /// Tests whether particular error message contains given message.
         /// </summary>
         /// <param name="containsMessage">Expected containing string for particular error message.</param>
-        public IAndTestBuilder<TBadRequestResult> Containing(string containsMessage)
+        public void Containing(string containsMessage)
         {
             if (!this.actualMessage.Contains(containsMessage))
             {
                 this.ThrowNewBadRequestResultAssertionException(
                     "When calling {0} action in {1} expected bad request error message to contain '{2}', but instead found '{3}'.",
                     containsMessage);
             }
-
-            return this.NewAndTestBuilder();
         }
 
         private void ThrowNewBadRequestResultAssertionException(string messageFormat, string operation)
diff --git a/MyWebApi/Builders/BadRequests/BadRequestTestBuilder.cs b/MyWebApi/Builders/BadRequests/BadRequestTestBuilder.cs
@@ -19,7 +19,7 @@
     /// </summary>
     /// <typeparam name="TBadRequestResult">Type of bad request result - BadRequestResult, InvalidModelStateResult, BadRequestErrorMessageResult.</typeparam>
     public class BadRequestTestBuilder<TBadRequestResult> : BaseTestBuilderWithActionResult<TBadRequestResult>,
-        IBadRequestTestBuilder<TBadRequestResult>
+        IBadRequestTestBuilder
     {
         private const string ErrorMessage = "error message";
         private const string ModelStateDictionary = "model state dictionary";
@@ -42,30 +42,28 @@ public BadRequestTestBuilder(
         /// Tests bad request result with specific error message using test builder.
         /// </summary>
         /// <returns>Bad request with error message test builder.</returns>
-        public IBadRequestErrorMessageTestBuilder<TBadRequestResult> WithErrorMessage()
+        public IBadRequestErrorMessageTestBuilder WithErrorMessage()
         {
             var badRequestErrorMessageResult = this.GetBadRequestResult<BadRequestErrorMessageResult>(ErrorMessage);
-            return new BadRequestErrorMessageTestBuilder<TBadRequestResult>(this.Controller, this.ActionName, this.ActionResult, badRequestErrorMessageResult.Message);
+            return new BadRequestErrorMessageTestBuilder(this.Controller, this.ActionName, badRequestErrorMessageResult.Message);
         }
 
         /// <summary>
         /// Tests bad request result with specific error message provided by string.
         /// </summary>
         /// <param name="message">Expected error message from bad request result.</param>
-        public IAndTestBuilder<TBadRequestResult> WithErrorMessage(string message)
+        public void WithErrorMessage(string message)
         {
             var badRequestErrorMessageResult = this.GetBadRequestResult<BadRequestErrorMessageResult>(ErrorMessage);
             var actualMessage = badRequestErrorMessageResult.Message;
             this.ValidateErrorMessage(message, actualMessage);
-
-            return this.NewAndTestBuilder();
         }
 
         /// <summary>
         /// Tests bad request result with specific model state dictionary.
         /// </summary>
         /// <param name="modelState">Model state dictionary to deeply compare to the actual one.</param>
-        public IAndTestBuilder<TBadRequestResult> WithModelState(ModelStateDictionary modelState)
+        public void WithModelState(ModelStateDictionary modelState)
         {
             var invalidModelStateResult = this.GetBadRequestResult<InvalidModelStateResult>(ModelStateDictionary);
             var actualModelState = invalidModelStateResult.ModelState;
@@ -118,8 +116,6 @@ public IAndTestBuilder<TBadRequestResult> WithModelState(ModelStateDictionary mo
                     this.ValidateErrorMessage(expectedError, actualError);
                 }
             }
-
-            return this.NewAndTestBuilder();
         }
 
         /// <summary>
diff --git a/MyWebApi/Builders/Contracts/Actions/IActionResultTestBuilder.cs b/MyWebApi/Builders/Contracts/Actions/IActionResultTestBuilder.cs
@@ -58,7 +58,7 @@ public interface IActionResultTestBuilder<out TActionResult> : IBaseTestBuilderW
         /// Tests whether action result is BadRequestResult, InvalidModelStateResult or BadRequestErrorMessageResult.
         /// </summary>
         /// <returns>Bad request test builder.</returns>
-        IBadRequestTestBuilder<TActionResult> ShouldReturnBadRequest();
+        IBadRequestTestBuilder ShouldReturnBadRequest();
 
         /// <summary>
         /// Tests whether action result is UnauthorizedResult.
diff --git a/MyWebApi/Builders/Contracts/BadRequests/IBadRequestErrorMessageTestBuilder.cs b/MyWebApi/Builders/Contracts/BadRequests/IBadRequestErrorMessageTestBuilder.cs
@@ -5,30 +5,30 @@
     /// <summary>
     /// Used for testing specific bad request error messages.
     /// </summary>
-    public interface IBadRequestErrorMessageTestBuilder<out TBadRequestResult>
+    public interface IBadRequestErrorMessageTestBuilder
     {
         /// <summary>
         /// Tests whether particular error message is equal to given message.
         /// </summary>
         /// <param name="errorMessage">Expected error message for particular key.</param>
-        IAndTestBuilder<TBadRequestResult> ThatEquals(string errorMessage);
+        void ThatEquals(string errorMessage);
 
         /// <summary>
         /// Tests whether particular error message begins with given message.
         /// </summary>
         /// <param name="beginMessage">Expected beginning for particular error message.</param>
-        IAndTestBuilder<TBadRequestResult> BeginningWith(string beginMessage);
+        void BeginningWith(string beginMessage);
 
         /// <summary>
         /// Tests whether particular error message ends with given message.
         /// </summary>
         /// <param name="endMessage">Expected ending for particular error message.</param>
-        IAndTestBuilder<TBadRequestResult> EndingWith(string endMessage);
+        void EndingWith(string endMessage);
 
         /// <summary>
         /// Tests whether particular error message contains given message.
         /// </summary>
         /// <param name="containsMessage">Expected containing string for particular error message.</param>
-        IAndTestBuilder<TBadRequestResult> Containing(string containsMessage);
+        void Containing(string containsMessage);
     }
 }
diff --git a/MyWebApi/Builders/Contracts/BadRequests/IBadRequestTestBuilder.cs b/MyWebApi/Builders/Contracts/BadRequests/IBadRequestTestBuilder.cs
@@ -7,25 +7,25 @@
     /// <summary>
     /// Used for testing bad request results.
     /// </summary>
-    public interface IBadRequestTestBuilder<out TBadRequestResult>
+    public interface IBadRequestTestBuilder
     {
         /// <summary>
         /// Tests bad request result with specific error message using test builder.
         /// </summary>
         /// <returns>Bad request with error message test builder.</returns>
-        IBadRequestErrorMessageTestBuilder<TBadRequestResult> WithErrorMessage();
+        IBadRequestErrorMessageTestBuilder WithErrorMessage();
 
         /// <summary>
         /// Tests bad request result with specific error message provided by string.
         /// </summary>
         /// <param name="message">Expected error message from bad request result.</param>
-        IAndTestBuilder<TBadRequestResult> WithErrorMessage(string message);
+        void WithErrorMessage(string message);
 
         /// <summary>
         /// Tests bad request result with specific model state dictionary.
         /// </summary>
         /// <param name="modelState">Model state dictionary to deeply compare to the actual one.</param>
-        IAndTestBuilder<TBadRequestResult> WithModelState(ModelStateDictionary modelState);
+        void WithModelState(ModelStateDictionary modelState);
 
         /// <summary>
         /// Tests bad request result for model state errors using test builder.

Original file line number	Diff line number	Diff line change
`@@ -16,25 +16,22 @@ public partial class ActionResultTestBuilder<TActionResult>`
`16`	`16`	`/// Tests whether action result is BadRequestResult, InvalidModelStateResult or BadRequestErrorMessageResult.`
`17`	`17`	`/// </summary>`
`18`	`18`	`/// <returns>Bad request test builder.</returns>`
`19`		`- public IBadRequestTestBuilder<TActionResult> ShouldReturnBadRequest()`
	`19`	`+ public IBadRequestTestBuilder ShouldReturnBadRequest()`
`20`	`20`	`{`
`21`	`21`	`if (this.ActionResult as BadRequestResult != null)`
`22`	`22`	`{`
`23`		`- return this.ReturnBadRequestTestBuilder<BadRequestResult>()`
`24`		`- as IBadRequestTestBuilder<TActionResult>;`
	`23`	`+ return this.ReturnBadRequestTestBuilder<BadRequestResult>();`
`25`	`24`	`}`
`26`	`25`
`27`	`26`	`if (this.ActionResult as InvalidModelStateResult != null)`
`28`	`27`	`{`
`29`		`- return this.ReturnBadRequestTestBuilder<InvalidModelStateResult>()`
`30`		`- as IBadRequestTestBuilder<TActionResult>;`
	`28`	`+ return this.ReturnBadRequestTestBuilder<InvalidModelStateResult>();`
`31`	`29`	`}`
`32`	`30`
`33`		`- return this.ReturnBadRequestTestBuilder<BadRequestErrorMessageResult>()`
`34`		`- as IBadRequestTestBuilder<TActionResult>;`
	`31`	`+ return this.ReturnBadRequestTestBuilder<BadRequestErrorMessageResult>();`
`35`	`32`	`}`
`36`	`33`
`37`		`- private IBadRequestTestBuilder<TBadRequestResult> ReturnBadRequestTestBuilder<TBadRequestResult>()`
	`34`	`+ private IBadRequestTestBuilder ReturnBadRequestTestBuilder<TBadRequestResult>()`
`38`	`35`	`where TBadRequestResult : class`
`39`	`36`	`{`
`40`	`37`	`var badRequestResult = this.GetReturnObject<TBadRequestResult>();`
Original file line number	Diff line number	Diff line change
`@@ -1,33 +1,30 @@`
`1`	`1`	`namespace MyWebApi.Builders.BadRequests`
`2`	`2`	`{`
`3`	`3`	`using System.Web.Http;`
`4`		`- using System.Web.Http.Results;`
`5`	`4`	`using Base;`
`6`	`5`	`using Common.Extensions;`
`7`		`- using Contracts.And;`
`8`	`6`	`using Contracts.BadRequests;`
`9`	`7`	`using Exceptions;`
`10`	`8`
`11`	`9`	`/// <summary>`
`12`	`10`	`/// Used for testing specific bad request error messages.`
`13`	`11`	`/// </summary>`
`14`		`- public class BadRequestErrorMessageTestBuilder<TBadRequestResult>`
`15`		`- : BaseTestBuilderWithActionResult<TBadRequestResult>, IBadRequestErrorMessageTestBuilder<TBadRequestResult>`
	`12`	`+ public class BadRequestErrorMessageTestBuilder`
	`13`	`+ : BaseTestBuilder, IBadRequestErrorMessageTestBuilder`
`16`	`14`	`{`
`17`	`15`	`private readonly string actualMessage;`
`18`	`16`
`19`	`17`	`/// <summary>`
`20`		`- /// Initializes a new instance of the <see cref="BadRequestErrorMessageTestBuilder{TBadRequestResult}" /> class.`
	`18`	`+ /// Initializes a new instance of the <see cref="BadRequestErrorMessageTestBuilder" /> class.`
`21`	`19`	`/// </summary>`
`22`	`20`	`/// <param name="controller">Controller on which the action will be tested.</param>`
`23`	`21`	`/// <param name="actionName">Name of the tested action.</param>`
`24`	`22`	`/// <param name="actualMessage">Actual error message received from bad request result.</param>`
`25`	`23`	`public BadRequestErrorMessageTestBuilder(`
`26`	`24`	`ApiController controller,`
`27`	`25`	`string actionName,`
`28`		`- TBadRequestResult actionResult,`
`29`	`26`	`string actualMessage)`
`30`		`- : base(controller, actionName, actionResult)`
	`27`	`+ : base(controller, actionName)`
`31`	`28`	`{`
`32`	`29`	`this.actualMessage = actualMessage;`
`33`	`30`	`}`
`@@ -36,64 +33,56 @@ public BadRequestErrorMessageTestBuilder(`
`36`	`33`	`/// Tests whether particular error message is equal to given message.`
`37`	`34`	`/// </summary>`
`38`	`35`	`/// <param name="errorMessage">Expected error message for particular key.</param>`
`39`		`- public IAndTestBuilder<TBadRequestResult> ThatEquals(string errorMessage)`
	`36`	`+ public void ThatEquals(string errorMessage)`
`40`	`37`	`{`
`41`	`38`	`if (this.actualMessage != errorMessage)`
`42`	`39`	`{`
`43`	`40`	`this.ThrowNewBadRequestResultAssertionException(`
`44`	`41`	`"When calling {0} action in {1} expected bad request error message to be '{2}', but instead found '{3}'.",`
`45`	`42`	`errorMessage);`
`46`	`43`	`}`
`47`		`-`
`48`		`- return this.NewAndTestBuilder();`
`49`	`44`	`}`
`50`	`45`
`51`	`46`	`/// <summary>`
`52`	`47`	`/// Tests whether particular error message begins with given message.`
`53`	`48`	`/// </summary>`
`54`	`49`	`/// <param name="beginMessage">Expected beginning for particular error message.</param>`
`55`		`- public IAndTestBuilder<TBadRequestResult> BeginningWith(string beginMessage)`
	`50`	`+ public void BeginningWith(string beginMessage)`
`56`	`51`	`{`
`57`	`52`	`if (!this.actualMessage.StartsWith(beginMessage))`
`58`	`53`	`{`
`59`	`54`	`this.ThrowNewBadRequestResultAssertionException(`
`60`	`55`	`"When calling {0} action in {1} expected bad request error message to begin with '{2}', but instead found '{3}'.",`
`61`	`56`	`beginMessage);`
`62`	`57`	`}`
`63`		`-`
`64`		`- return this.NewAndTestBuilder();`
`65`	`58`	`}`
`66`	`59`
`67`	`60`	`/// <summary>`
`68`	`61`	`/// Tests whether particular error message ends with given message.`
`69`	`62`	`/// </summary>`
`70`	`63`	`/// <param name="endMessage">Expected ending for particular error message.</param>`
`71`		`- public IAndTestBuilder<TBadRequestResult> EndingWith(string endMessage)`
	`64`	`+ public void EndingWith(string endMessage)`
`72`	`65`	`{`
`73`	`66`	`if (!this.actualMessage.EndsWith(endMessage))`
`74`	`67`	`{`
`75`	`68`	`this.ThrowNewBadRequestResultAssertionException(`
`76`	`69`	`"When calling {0} action in {1} expected bad request error message to end with '{2}', but instead found '{3}'.",`
`77`	`70`	`endMessage);`
`78`	`71`	`}`
`79`		`-`
`80`		`- return this.NewAndTestBuilder();`
`81`	`72`	`}`
`82`	`73`
`83`	`74`	`/// <summary>`
`84`	`75`	`/// Tests whether particular error message contains given message.`
`85`	`76`	`/// </summary>`
`86`	`77`	`/// <param name="containsMessage">Expected containing string for particular error message.</param>`
`87`		`- public IAndTestBuilder<TBadRequestResult> Containing(string containsMessage)`
	`78`	`+ public void Containing(string containsMessage)`
`88`	`79`	`{`
`89`	`80`	`if (!this.actualMessage.Contains(containsMessage))`
`90`	`81`	`{`
`91`	`82`	`this.ThrowNewBadRequestResultAssertionException(`
`92`	`83`	`"When calling {0} action in {1} expected bad request error message to contain '{2}', but instead found '{3}'.",`
`93`	`84`	`containsMessage);`
`94`	`85`	`}`
`95`		`-`
`96`		`- return this.NewAndTestBuilder();`
`97`	`86`	`}`
`98`	`87`
`99`	`88`	`private void ThrowNewBadRequestResultAssertionException(string messageFormat, string operation)`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@`
`19`	`19`	`/// </summary>`
`20`	`20`	`/// <typeparam name="TBadRequestResult">Type of bad request result - BadRequestResult, InvalidModelStateResult, BadRequestErrorMessageResult.</typeparam>`
`21`	`21`	`public class BadRequestTestBuilder<TBadRequestResult> : BaseTestBuilderWithActionResult<TBadRequestResult>,`
`22`		`- IBadRequestTestBuilder<TBadRequestResult>`
	`22`	`+ IBadRequestTestBuilder`
`23`	`23`	`{`
`24`	`24`	`private const string ErrorMessage = "error message";`
`25`	`25`	`private const string ModelStateDictionary = "model state dictionary";`
`@@ -42,30 +42,28 @@ public BadRequestTestBuilder(`
`42`	`42`	`/// Tests bad request result with specific error message using test builder.`
`43`	`43`	`/// </summary>`
`44`	`44`	`/// <returns>Bad request with error message test builder.</returns>`
`45`		`- public IBadRequestErrorMessageTestBuilder<TBadRequestResult> WithErrorMessage()`
	`45`	`+ public IBadRequestErrorMessageTestBuilder WithErrorMessage()`
`46`	`46`	`{`
`47`	`47`	`var badRequestErrorMessageResult = this.GetBadRequestResult<BadRequestErrorMessageResult>(ErrorMessage);`
`48`		`- return new BadRequestErrorMessageTestBuilder<TBadRequestResult>(this.Controller, this.ActionName, this.ActionResult, badRequestErrorMessageResult.Message);`
	`48`	`+ return new BadRequestErrorMessageTestBuilder(this.Controller, this.ActionName, badRequestErrorMessageResult.Message);`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`/// <summary>`
`52`	`52`	`/// Tests bad request result with specific error message provided by string.`
`53`	`53`	`/// </summary>`
`54`	`54`	`/// <param name="message">Expected error message from bad request result.</param>`
`55`		`- public IAndTestBuilder<TBadRequestResult> WithErrorMessage(string message)`
	`55`	`+ public void WithErrorMessage(string message)`
`56`	`56`	`{`
`57`	`57`	`var badRequestErrorMessageResult = this.GetBadRequestResult<BadRequestErrorMessageResult>(ErrorMessage);`
`58`	`58`	`var actualMessage = badRequestErrorMessageResult.Message;`
`59`	`59`	`this.ValidateErrorMessage(message, actualMessage);`
`60`		`-`
`61`		`- return this.NewAndTestBuilder();`
`62`	`60`	`}`
`63`	`61`
`64`	`62`	`/// <summary>`
`65`	`63`	`/// Tests bad request result with specific model state dictionary.`
`66`	`64`	`/// </summary>`
`67`	`65`	`/// <param name="modelState">Model state dictionary to deeply compare to the actual one.</param>`
`68`		`- public IAndTestBuilder<TBadRequestResult> WithModelState(ModelStateDictionary modelState)`
	`66`	`+ public void WithModelState(ModelStateDictionary modelState)`
`69`	`67`	`{`
`70`	`68`	`var invalidModelStateResult = this.GetBadRequestResult<InvalidModelStateResult>(ModelStateDictionary);`
`71`	`69`	`var actualModelState = invalidModelStateResult.ModelState;`
`@@ -118,8 +116,6 @@ public IAndTestBuilder<TBadRequestResult> WithModelState(ModelStateDictionary mo`
`118`	`116`	`this.ValidateErrorMessage(expectedError, actualError);`
`119`	`117`	`}`
`120`	`118`	`}`
`121`		`-`
`122`		`- return this.NewAndTestBuilder();`
`123`	`119`	`}`
`124`	`120`
`125`	`121`	`/// <summary>`