Resources.Designer.cs

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.42000
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace MSTest.Analyzers {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class Resources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal Resources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("MSTest.Analyzers.Resources", typeof(Resources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Methods marked with &apos;[AssemblyCleanup]&apos; should follow the following layout to be valid:
        ///-it can&apos;t be declared on a generic class
        ///-it should be &apos;public&apos;
        ///-it should be &apos;static&apos;
        ///-it should not be &apos;async void&apos;
        ///-it should not be a special method (finalizer, operator...).
        ///-it should not be generic
        ///-it should either not take any parameter, or take a single parameter of type &apos;TestContext&apos;
        ///-return type should be &apos;void&apos;, &apos;Task&apos; or &apos;ValueTask&apos;
        ///
        ///The type declaring these methods should also respect the followi [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string AssemblyCleanupShouldBeValidDescription {
            get {
                return ResourceManager.GetString("AssemblyCleanupShouldBeValidDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to AssemblyCleanup method &apos;{0}&apos; signature is invalid.
        /// </summary>
        internal static string AssemblyCleanupShouldBeValidMessageFormat {
            get {
                return ResourceManager.GetString("AssemblyCleanupShouldBeValidMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to AssemblyCleanup methods should have valid layout.
        /// </summary>
        internal static string AssemblyCleanupShouldBeValidTitle {
            get {
                return ResourceManager.GetString("AssemblyCleanupShouldBeValidTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Methods marked with &apos;[AssemblyInitialize]&apos; should follow the following layout to be valid:
        ///-it can&apos;t be declared on a generic class
        ///-it should be &apos;public&apos;
        ///-it should be &apos;static&apos;
        ///-it should not be &apos;async void&apos;
        ///-it should not be a special method (finalizer, operator...).
        ///-it should not be generic
        ///-it should take one parameter of type &apos;TestContext&apos;
        ///-return type should be &apos;void&apos;, &apos;Task&apos; or &apos;ValueTask&apos;
        ///
        ///The type declaring these methods should also respect the following rules:
        ///-The type should be a cla [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string AssemblyInitializeShouldBeValidDescription {
            get {
                return ResourceManager.GetString("AssemblyInitializeShouldBeValidDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to AssemblyInitialize method &apos;{0}&apos; signature is invalid.
        /// </summary>
        internal static string AssemblyInitializeShouldBeValidMessageFormat {
            get {
                return ResourceManager.GetString("AssemblyInitializeShouldBeValidMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to AssemblyInitialize methods should have valid layout.
        /// </summary>
        internal static string AssemblyInitializeShouldBeValidTitle {
            get {
                return ResourceManager.GetString("AssemblyInitializeShouldBeValidTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Prefer adding an additional assertion that checks for null.
        /// </summary>
        internal static string AssertionArgsShouldAvoidConditionalAccessMessageFormat {
            get {
                return ResourceManager.GetString("AssertionArgsShouldAvoidConditionalAccessMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Avoid conditional access in assertions.
        /// </summary>
        internal static string AssertionArgsShouldAvoidConditionalAccessTitle {
            get {
                return ResourceManager.GetString("AssertionArgsShouldAvoidConditionalAccessTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;Assert.AreEqual&apos;, &apos;Assert.AreNotEqual&apos;, &apos;Assert.AreSame&apos; and &apos;Assert.AreNotSame&apos; expects the expected value to be passed first and the actual value to be passed as second argument..
        /// </summary>
        internal static string AssertionArgsShouldBePassedInCorrectOrderDescription {
            get {
                return ResourceManager.GetString("AssertionArgsShouldBePassedInCorrectOrderDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Assertion arguments should be passed in the correct order. &apos;actual&apos; and &apos;expected&apos;/&apos;notExpected&apos; arguments have been swapped..
        /// </summary>
        internal static string AssertionArgsShouldBePassedInCorrectOrderMessageFormat {
            get {
                return ResourceManager.GetString("AssertionArgsShouldBePassedInCorrectOrderMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Assertion arguments should be passed in the correct order.
        /// </summary>
        internal static string AssertionArgsShouldBePassedInCorrectOrderTitle {
            get {
                return ResourceManager.GetString("AssertionArgsShouldBePassedInCorrectOrderTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use &apos;Assert.AreEqual&apos;/&apos;Assert.AreNotEqual&apos; instead of &apos;Assert.AreSame&apos;/&apos;Assert.AreNotSame&apos; when comparing value types. Passing a value type to &apos;Assert.AreSame&apos;/&apos;Assert.AreNotSame&apos; will be boxed (creating a new object). Because &apos;Assert.AreSame&apos;/&apos;Assert.AreNotSame&apos; does the comparison by reference, &apos;Assert.AreSame&apos; will fail when boxing happens, and &apos;Assert.AreNotSame&apos; will always pass..
        /// </summary>
        internal static string AvoidAssertAreSameWithValueTypesDescription {
            get {
                return ResourceManager.GetString("AvoidAssertAreSameWithValueTypesDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use &apos;{0}&apos; instead of &apos;{1}&apos; when comparing value types.
        /// </summary>
        internal static string AvoidAssertAreSameWithValueTypesMessageFormat {
            get {
                return ResourceManager.GetString("AvoidAssertAreSameWithValueTypesMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Don&apos;t use &apos;Assert.AreSame&apos; or &apos;Assert.AreNotSame&apos; with value types.
        /// </summary>
        internal static string AvoidAssertAreSameWithValueTypesTitle {
            get {
                return ResourceManager.GetString("AvoidAssertAreSameWithValueTypesTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Prefer &apos;Assert.ThrowsExactly&apos; or &apos;Assert.ThrowsExactlyAsync&apos; over &apos;[ExpectedException]&apos; as it ensures that only the expected call throws the expected exception. The assert APIs also provide more flexibility and allow you to assert extra properties of the exception..
        /// </summary>
        internal static string AvoidExpectedExceptionAttributeDescription {
            get {
                return ResourceManager.GetString("AvoidExpectedExceptionAttributeDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Prefer &apos;Assert.ThrowsExactly/ThrowsExactlyAsync&apos; over &apos;[ExpectedException]&apos;.
        /// </summary>
        internal static string AvoidExpectedExceptionAttributeMessageFormat {
            get {
                return ResourceManager.GetString("AvoidExpectedExceptionAttributeMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Avoid &apos;[ExpectedException]&apos;.
        /// </summary>
        internal static string AvoidExpectedExceptionAttributeTitle {
            get {
                return ResourceManager.GetString("AvoidExpectedExceptionAttributeTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Do not assert inside &apos;async void&apos; methods, local functions, or lambdas. Exceptions that are thrown in this context will be unhandled exceptions. When using VSTest under .NET Framework, they will be silently swallowed. When using Microsoft.Testing.Platform or VSTest under modern .NET, they may crash the process..
        /// </summary>
        internal static string AvoidUsingAssertsInAsyncVoidContextDescription {
            get {
                return ResourceManager.GetString("AvoidUsingAssertsInAsyncVoidContextDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Do not assert inside &apos;async void&apos; methods, local functions, or lambdas because they may not fail the test.
        /// </summary>
        internal static string AvoidUsingAssertsInAsyncVoidContextMessageFormat {
            get {
                return ResourceManager.GetString("AvoidUsingAssertsInAsyncVoidContextMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Do not assert inside &apos;async void&apos; contexts.
        /// </summary>
        internal static string AvoidUsingAssertsInAsyncVoidContextTitle {
            get {
                return ResourceManager.GetString("AvoidUsingAssertsInAsyncVoidContextTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Methods marked with &apos;[ClassCleanup]&apos; should follow the following layout to be valid:
        ///-it can&apos;t be declared on a generic class without the &apos;InheritanceBehavior&apos; mode is set
        ///-it should be &apos;public&apos;
        ///-it should be &apos;static&apos;
        ///-it should not be &apos;async void&apos;
        ///-it should not be a special method (finalizer, operator...).
        ///-it should not be generic
        ///-it should either not take any parameter, or take a single parameter of type &apos;TestContext&apos;
        ///-return type should be &apos;void&apos;, &apos;Task&apos; or &apos;ValueTask&apos;
        ///-&apos;InheritanceBehavior.B [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string ClassCleanupShouldBeValidDescription {
            get {
                return ResourceManager.GetString("ClassCleanupShouldBeValidDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ClassCleanup method &apos;{0}&apos; signature is invalid.
        /// </summary>
        internal static string ClassCleanupShouldBeValidMessageFormat {
            get {
                return ResourceManager.GetString("ClassCleanupShouldBeValidMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ClassCleanup methods should have valid layout.
        /// </summary>
        internal static string ClassCleanupShouldBeValidTitle {
            get {
                return ResourceManager.GetString("ClassCleanupShouldBeValidTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Methods marked with &apos;[ClassInitialize]&apos; should follow the following layout to be valid:
        ///-it can&apos;t be declared on a generic class without the &apos;InheritanceBehavior&apos; mode is set
        ///-it should be &apos;public&apos;
        ///-it should be &apos;static&apos;
        ///-it should not be &apos;async void&apos;
        ///-it should not be a special method (finalizer, operator...).
        ///-it should not be generic
        ///-it should take one parameter of type &apos;TestContext&apos;
        ///-return type should be &apos;void&apos;, &apos;Task&apos; or &apos;ValueTask&apos;
        ///-&apos;InheritanceBehavior.BeforeEachDerivedClass&apos; attribute par [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string ClassInitializeShouldBeValidDescription {
            get {
                return ResourceManager.GetString("ClassInitializeShouldBeValidDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ClassInitialize method &apos;{0}&apos; signature is invalid.
        /// </summary>
        internal static string ClassInitializeShouldBeValidMessageFormat {
            get {
                return ResourceManager.GetString("ClassInitializeShouldBeValidMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ClassInitialize methods should have valid layout.
        /// </summary>
        internal static string ClassInitializeShouldBeValidTitle {
            get {
                return ResourceManager.GetString("ClassInitializeShouldBeValidTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to DataRow entry should have the following layout to be valid:
        ///- should only be set on a test method;
        ///- argument count should match method argument count;
        ///- argument type should match method argument type..
        /// </summary>
        internal static string DataRowShouldBeValidDescription {
            get {
                return ResourceManager.GetString("DataRowShouldBeValidDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to DataRow argument count should match method parameter count (constructor arguments: {0}, method parameters: {1}).
        /// </summary>
        internal static string DataRowShouldBeValidMessageFormat_ArgumentCountMismatch {
            get {
                return ResourceManager.GetString("DataRowShouldBeValidMessageFormat_ArgumentCountMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to DataRow argument type should match method parameter type. Mismatches occur at indices: {0}.
        /// </summary>
        internal static string DataRowShouldBeValidMessageFormat_ArgumentTypeMismatch {
            get {
                return ResourceManager.GetString("DataRowShouldBeValidMessageFormat_ArgumentTypeMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Found two conflicting types for generic parameter &apos;{0}&apos;. The conflicting types are &apos;{1}&apos; and &apos;{2}&apos;..
        /// </summary>
        internal static string DataRowShouldBeValidMessageFormat_GenericTypeArgumentConflictingTypes {
            get {
                return ResourceManager.GetString("DataRowShouldBeValidMessageFormat_GenericTypeArgumentConflictingTypes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type of the generic parameter &apos;{0}&apos; could not be inferred..
        /// </summary>
        internal static string DataRowShouldBeValidMessageFormat_GenericTypeArgumentNotResolved {
            get {
                return ResourceManager.GetString("DataRowShouldBeValidMessageFormat_GenericTypeArgumentNotResolved", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to DataRow should only be set on a test method.
        /// </summary>
        internal static string DataRowShouldBeValidMessageFormat_OnTestMethod {
            get {
                return ResourceManager.GetString("DataRowShouldBeValidMessageFormat_OnTestMethod", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to DataRow should be valid.
        /// </summary>
        internal static string DataRowShouldBeValidTitle {
            get {
                return ResourceManager.GetString("DataRowShouldBeValidTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Do not negate boolean assertions, instead use the opposite assertion.
        /// </summary>
        internal static string DoNotNegateBooleanAssertionMessageFormat {
            get {
                return ResourceManager.GetString("DoNotNegateBooleanAssertionMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Do not negate boolean assertions.
        /// </summary>
        internal static string DoNotNegateBooleanAssertionTitle {
            get {
                return ResourceManager.GetString("DoNotNegateBooleanAssertionTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Do not store TestContext in a static member.
        /// </summary>
        internal static string DoNotStoreStaticTestContextAnalyzerMessageFormat {
            get {
                return ResourceManager.GetString("DoNotStoreStaticTestContextAnalyzerMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Do not store TestContext in a static member.
        /// </summary>
        internal static string DoNotStoreStaticTestContextAnalyzerTitle {
            get {
                return ResourceManager.GetString("DoNotStoreStaticTestContextAnalyzerTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Shadowing test members could cause testing issues (such as NRE)..
        /// </summary>
        internal static string DoNotUseShadowingDescription {
            get {
                return ResourceManager.GetString("DoNotUseShadowingDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Member &apos;{0}&apos; already exists in the base class.
        /// </summary>
        internal static string DoNotUseShadowingMessageFormat {
            get {
                return ResourceManager.GetString("DoNotUseShadowingMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Do not use shadowing.
        /// </summary>
        internal static string DoNotUseShadowingTitle {
            get {
                return ResourceManager.GetString("DoNotUseShadowingTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;System.ComponentModel.DescriptionAttribute&apos; has no effect in the context of tests and you likely wanted to use &apos;Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute&apos; instead..
        /// </summary>
        internal static string DoNotUseSystemDescriptionAttributeDescription {
            get {
                return ResourceManager.GetString("DoNotUseSystemDescriptionAttributeDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Did you mean to be using &apos;Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute&apos;?.
        /// </summary>
        internal static string DoNotUseSystemDescriptionAttributeMessageFormat {
            get {
                return ResourceManager.GetString("DoNotUseSystemDescriptionAttributeMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;System.ComponentModel.DescriptionAttribute&apos; has no effect on test methods.
        /// </summary>
        internal static string DoNotUseSystemDescriptionAttributeTitle {
            get {
                return ResourceManager.GetString("DoNotUseSystemDescriptionAttributeTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Do not duplicate &apos;DataRow&apos; attributes. This is usually a copy/paste error. The attribute indices are &apos;{0}&apos; and &apos;{1}&apos;..
        /// </summary>
        internal static string DuplicateDataRowMessageFormat {
            get {
                return ResourceManager.GetString("DuplicateDataRowMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Avoid duplicated &apos;DataRow&apos; entries.
        /// </summary>
        internal static string DuplicateDataRowTitle {
            get {
                return ResourceManager.GetString("DuplicateDataRowTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;DynamicData&apos; entry should have the following layout to be valid:
        ///- should only be set on a test method;
        ///- member should be defined on the type specified;
        ///- member should be a method if DynamicDataSourceType.Method is specified or a property otherwise..
        /// </summary>
        internal static string DynamicDataShouldBeValidDescription {
            get {
                return ResourceManager.GetString("DynamicDataShouldBeValidDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;[DynamicData]&apos; data member &apos;{0}.{1}&apos; signature is invalid.
        /// </summary>
        internal static string DynamicDataShouldBeValidMessageFormat_DataMemberSignature {
            get {
                return ResourceManager.GetString("DynamicDataShouldBeValidMessageFormat_DataMemberSignature", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;[DynamicData]&apos; display name method &apos;{0}.{1}&apos; signature is invalid.
        /// </summary>
        internal static string DynamicDataShouldBeValidMessageFormat_DisplayMethodSignature {
            get {
                return ResourceManager.GetString("DynamicDataShouldBeValidMessageFormat_DisplayMethodSignature", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;[DynamicData]&apos; member &apos;{0}.{1}&apos; should be a method.
        /// </summary>
        internal static string DynamicDataShouldBeValidMessageFormat_MemberMethod {
            get {
                return ResourceManager.GetString("DynamicDataShouldBeValidMessageFormat_MemberMethod", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;[DynamicData]&apos; member &apos;{0}.{1}&apos; cannot be found.
        /// </summary>
        internal static string DynamicDataShouldBeValidMessageFormat_MemberNotFound {
            get {
                return ResourceManager.GetString("DynamicDataShouldBeValidMessageFormat_MemberNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;[DynamicData]&apos; referenced member &apos;{0}.{1}&apos; should return &apos;IEnumerable&lt;object[]&gt;&apos;, &apos;IEnumerable&lt;Tuple&gt;` or &apos;IEnumerable&lt;ValueTuple&gt;&apos;.
        /// </summary>
        internal static string DynamicDataShouldBeValidMessageFormat_MemberType {
            get {
                return ResourceManager.GetString("DynamicDataShouldBeValidMessageFormat_MemberType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;[DynamicData]&apos; should only be set on a test method.
        /// </summary>
        internal static string DynamicDataShouldBeValidMessageFormat_OnTestMethod {
            get {
                return ResourceManager.GetString("DynamicDataShouldBeValidMessageFormat_OnTestMethod", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;[DynamicData]&apos; member &apos;{0}.{1}&apos; is a method so you should use &apos;DynamicDataSourceType.AutoDetect&apos; or &apos;DynamicDataSourceType.Method&apos; (auto detect is the default when not specified explicitly, and is recommended).
        /// </summary>
        internal static string DynamicDataShouldBeValidMessageFormat_SourceTypeMethod {
            get {
                return ResourceManager.GetString("DynamicDataShouldBeValidMessageFormat_SourceTypeMethod", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;[DynamicData]&apos; member &apos;{0}.{1}&apos; is not a property nor a method. Only properties and methods are supported..
        /// </summary>
        internal static string DynamicDataShouldBeValidMessageFormat_SourceTypeNotPropertyOrMethod {
            get {
                return ResourceManager.GetString("DynamicDataShouldBeValidMessageFormat_SourceTypeNotPropertyOrMethod", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;[DynamicData]&apos; member &apos;{0}.{1}&apos; is a property so you should use &apos;DynamicDataSourceType.AutoDetect&apos; or &apos;DynamicDataSourceType.Property&apos; (auto detect is the default when not specified explicitly, and is recommended).
        /// </summary>
        internal static string DynamicDataShouldBeValidMessageFormat_SourceTypeProperty {
            get {
                return ResourceManager.GetString("DynamicDataShouldBeValidMessageFormat_SourceTypeProperty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;[DynamicData]&apos; member &apos;{0}.{1}&apos; is found more than once.
        /// </summary>
        internal static string DynamicDataShouldBeValidMessageFormat_TooManyMembers {
            get {
                return ResourceManager.GetString("DynamicDataShouldBeValidMessageFormat_TooManyMembers", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to DynamicData should be valid.
        /// </summary>
        internal static string DynamicDataShouldBeValidTitle {
            get {
                return ResourceManager.GetString("DynamicDataShouldBeValidTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use &apos;Assert.Fail&apos; instead of an always-failing &apos;Assert.{0}&apos; assert.
        /// </summary>
        internal static string PreferAssertFailOverAlwaysFalseConditionsMessageFormat {
            get {
                return ResourceManager.GetString("PreferAssertFailOverAlwaysFalseConditionsMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use &apos;Assert.Fail&apos; instead of an always-failing assert.
        /// </summary>
        internal static string PreferAssertFailOverAlwaysFalseConditionsTitle {
            get {
                return ResourceManager.GetString("PreferAssertFailOverAlwaysFalseConditionsTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Prefer constructors over TestInitialize methods.
        /// </summary>
        internal static string PreferConstructorOverTestInitializeMessageFormat {
            get {
                return ResourceManager.GetString("PreferConstructorOverTestInitializeMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Prefer constructors over TestInitialize methods.
        /// </summary>
        internal static string PreferConstructorOverTestInitializeTitle {
            get {
                return ResourceManager.GetString("PreferConstructorOverTestInitializeTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Prefer &apos;Dispose&apos; over TestCleanup methods.
        /// </summary>
        internal static string PreferDisposeOverTestCleanupMessageFormat {
            get {
                return ResourceManager.GetString("PreferDisposeOverTestCleanupMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Prefer &apos;Dispose&apos; over TestCleanup methods.
        /// </summary>
        internal static string PreferDisposeOverTestCleanupTitle {
            get {
                return ResourceManager.GetString("PreferDisposeOverTestCleanupTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Prefer TestCleanup over &apos;Dispose&apos; methods.
        /// </summary>
        internal static string PreferTestCleanupOverDisposeMessageFormat {
            get {
                return ResourceManager.GetString("PreferTestCleanupOverDisposeMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Prefer TestCleanup over &apos;Dispose&apos; methods.
        /// </summary>
        internal static string PreferTestCleanupOverDisposeTitle {
            get {
                return ResourceManager.GetString("PreferTestCleanupOverDisposeTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Prefer TestInitialize methods over constructors.
        /// </summary>
        internal static string PreferTestInitializeOverConstructorMessageFormat {
            get {
                return ResourceManager.GetString("PreferTestInitializeOverConstructorMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Prefer TestInitialize methods over constructors.
        /// </summary>
        internal static string PreferTestInitializeOverConstructorTitle {
            get {
                return ResourceManager.GetString("PreferTestInitializeOverConstructorTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Public methods should be test methods (marked with `[TestMethod]`)..
        /// </summary>
        internal static string PublicMethodShouldBeTestMethodAnalyzerDescription {
            get {
                return ResourceManager.GetString("PublicMethodShouldBeTestMethodAnalyzerDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Public method &apos;{0}&apos; should be a test method.
        /// </summary>
        internal static string PublicMethodShouldBeTestMethodAnalyzerFormat {
            get {
                return ResourceManager.GetString("PublicMethodShouldBeTestMethodAnalyzerFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Public methods should be test methods.
        /// </summary>
        internal static string PublicMethodShouldBeTestMethodAnalyzerTitle {
            get {
                return ResourceManager.GetString("PublicMethodShouldBeTestMethodAnalyzerTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to It&apos;s considered a good practice to have only test classes marked public in a test project..
        /// </summary>
        internal static string PublicTypeShouldBeTestClassDescription {
            get {
                return ResourceManager.GetString("PublicTypeShouldBeTestClassDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Public type &apos;{0}&apos; should be marked with &apos;[TestClass]&apos; or changed to &apos;internal&apos;.
        /// </summary>
        internal static string PublicTypeShouldBeTestClassMessageFormat {
            get {
                return ResourceManager.GetString("PublicTypeShouldBeTestClassMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Public types should be test classes.
        /// </summary>
        internal static string PublicTypeShouldBeTestClassTitle {
            get {
                return ResourceManager.GetString("PublicTypeShouldBeTestClassTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Review or remove the assertion as its condition is known to be always true.
        /// </summary>
        internal static string ReviewAlwaysTrueAssertConditionAnalyzerMessageFormat {
            get {
                return ResourceManager.GetString("ReviewAlwaysTrueAssertConditionAnalyzerMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Assertion condition is always true.
        /// </summary>
        internal static string ReviewAlwaysTrueAssertConditionAnalyzerTitle {
            get {
                return ResourceManager.GetString("ReviewAlwaysTrueAssertConditionAnalyzerTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Test classes, classes marked with the &apos;[TestClass]&apos; attribute, should respect the following layout to be considered valid by MSTest:
        ///- it should be &apos;public&apos; (or &apos;internal&apos; if &apos;[assembly: DiscoverInternals]&apos; attribute is set)
        ///- it should not be &apos;static&apos; (except if it contains only &apos;AssemblyInitialize&apos; and/or &apos;AssemblyCleanup&apos; methods)
        ///- it should not be generic..
        /// </summary>
        internal static string TestClassShouldBeValidDescription {
            get {
                return ResourceManager.GetString("TestClassShouldBeValidDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Test class &apos;{0}&apos; should be valid.
        /// </summary>
        internal static string TestClassShouldBeValidMessageFormat {
            get {
                return ResourceManager.GetString("TestClassShouldBeValidMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Test classes should have valid layout.
        /// </summary>
        internal static string TestClassShouldBeValidTitle {
            get {
                return ResourceManager.GetString("TestClassShouldBeValidTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Test class should have at least one test method or be &apos;static&apos; with method(s) marked by &apos;[AssemblyInitialize]&apos; and/or &apos;[AssemblyCleanup]&apos;..
        /// </summary>
        internal static string TestClassShouldHaveTestMethodDescription {
            get {
                return ResourceManager.GetString("TestClassShouldHaveTestMethodDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Test class &apos;{0}&apos; should have at least one test method or be &apos;static&apos; with method(s) marked by &apos;[AssemblyInitialize]&apos; and/or &apos;[AssemblyCleanup]&apos;.
        /// </summary>
        internal static string TestClassShouldHaveTestMethodMessageFormat {
            get {
                return ResourceManager.GetString("TestClassShouldHaveTestMethodMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Test class should have test method.
        /// </summary>
        internal static string TestClassShouldHaveTestMethodTitle {
            get {
                return ResourceManager.GetString("TestClassShouldHaveTestMethodTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Methods marked with &apos;[TestCleanup]&apos; should follow the following layout to be valid:
        ///-it should be &apos;public&apos;
        ///-it should not be &apos;abstract&apos;
        ///-it should not be &apos;async void&apos;
        ///-it should not be &apos;static&apos;
        ///-it should not be a special method (finalizer, operator...).
        ///-it should not be generic
        ///-it should not take any parameter
        ///-return type should be &apos;void&apos;, &apos;Task&apos; or &apos;ValueTask&apos;
        ///
        ///The type declaring these methods should also respect the following rules:
        ///-The type should be a class
        ///-The class should be &apos;public&apos; [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string TestCleanupShouldBeValidDescription {
            get {
                return ResourceManager.GetString("TestCleanupShouldBeValidDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to TestCleanup method &apos;{0}&apos; signature is invalid.
        /// </summary>
        internal static string TestCleanupShouldBeValidMessageFormat {
            get {
                return ResourceManager.GetString("TestCleanupShouldBeValidMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to TestCleanup method should have valid layout.
        /// </summary>
        internal static string TestCleanupShouldBeValidTitle {
            get {
                return ResourceManager.GetString("TestCleanupShouldBeValidTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;TestContext&apos; should be a non-static field or property assigned in constructor or for a property set by MSTest, it should follow the layout:
        ///- it should be &apos;public&apos; regardless of whether &apos;[assembly: DiscoverInternals]&apos; attribute is set or not.
        ///- it should not be &apos;static&apos;
        ///- it should have a setter..
        /// </summary>
        internal static string TestContextShouldBeValidDescription {
            get {
                return ResourceManager.GetString("TestContextShouldBeValidDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Property &apos;TestContext&apos; should be valid.
        /// </summary>
        internal static string TestContextShouldBeValidMessageFormat {
            get {
                return ResourceManager.GetString("TestContextShouldBeValidMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Test context property should have valid layout.
        /// </summary>
        internal static string TestContextShouldBeValidTitle {
            get {
                return ResourceManager.GetString("TestContextShouldBeValidTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Methods marked with &apos;[TestInitialize]&apos; should follow the following layout to be valid:
        ///-it should be &apos;public&apos;
        ///-it should not be &apos;abstract&apos;
        ///-it should not be &apos;async void&apos;
        ///-it should not be &apos;static&apos;
        ///-it should not be a special method (finalizer, operator...).
        ///-it should not be generic
        ///-it should not take any parameter
        ///-return type should be &apos;void&apos;, &apos;Task&apos; or &apos;ValueTask&apos;
        ///
        ///The type declaring these methods should also respect the following rules:
        ///-The type should be a class
        ///-The class should be &apos;publ [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string TestInitializeShouldBeValidDescription {
            get {
                return ResourceManager.GetString("TestInitializeShouldBeValidDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to TestInitialize method &apos;{0}&apos; signature is invalid.
        /// </summary>
        internal static string TestInitializeShouldBeValidMessageFormat {
            get {
                return ResourceManager.GetString("TestInitializeShouldBeValidMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to TestInitialize method should have valid layout.
        /// </summary>
        internal static string TestInitializeShouldBeValidTitle {
            get {
                return ResourceManager.GetString("TestInitializeShouldBeValidTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Test methods, methods marked with the &apos;[TestMethod]&apos; attribute, should respect the following layout to be considered valid by MSTest:
        ///- it should be &apos;public&apos; (or &apos;internal&apos; if &apos;[assembly: DiscoverInternals]&apos; attribute is set)
        ///- it should not be &apos;static&apos;
        ///- it should may be generic as long as type parameters can be inferred and argument types are compatible
        ///- it should not be &apos;abstract&apos;
        ///- return type should be &apos;void&apos;, &apos;Task&apos; or &apos;ValueTask&apos;
        ///- it should not be &apos;async void&apos;
        ///- it should not be a special me [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string TestMethodShouldBeValidDescription {
            get {
                return ResourceManager.GetString("TestMethodShouldBeValidDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Test method &apos;{0}&apos; signature is invalid.
        /// </summary>
        internal static string TestMethodShouldBeValidMessageFormat {
            get {
                return ResourceManager.GetString("TestMethodShouldBeValidMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Test methods should have valid layout.
        /// </summary>
        internal static string TestMethodShouldBeValidTitle {
            get {
                return ResourceManager.GetString("TestMethodShouldBeValidTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Test methods should not be ignored (marked with &apos;[Ignore]&apos;)..
        /// </summary>
        internal static string TestMethodShouldNotBeIgnoredAnalyzerDescription {
            get {
                return ResourceManager.GetString("TestMethodShouldNotBeIgnoredAnalyzerDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Test method &apos;{0}&apos; should not be ignored.
        /// </summary>
        internal static string TestMethodShouldNotBeIgnoredAnalyzerFormat {
            get {
                return ResourceManager.GetString("TestMethodShouldNotBeIgnoredAnalyzerFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Test method should not be ignored.
        /// </summary>
        internal static string TestMethodShouldNotBeIgnoredAnalyzerTitle {
            get {
                return ResourceManager.GetString("TestMethodShouldNotBeIgnoredAnalyzerTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type contaning &apos;[TestMethod]&apos; should be marked with &apos;[TestClass]&apos;, otherwise the test method will be silently ignored..
        /// </summary>
        internal static string TypeContainingTestMethodShouldBeATestClassDescription {
            get {
                return ResourceManager.GetString("TypeContainingTestMethodShouldBeATestClassDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Class &apos;{0}&apos; contains test methods and should be marked with &apos;[TestClass]&apos;.
        /// </summary>
        internal static string TypeContainingTestMethodShouldBeATestClassMessageFormat {
            get {
                return ResourceManager.GetString("TypeContainingTestMethodShouldBeATestClassMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type containing &apos;[TestMethod]&apos; should be marked with &apos;[TestClass]&apos;.
        /// </summary>
        internal static string TypeContainingTestMethodShouldBeATestClassTitle {
            get {
                return ResourceManager.GetString("TypeContainingTestMethodShouldBeATestClassTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Asynchronous test fixture methods do not require the &apos;Async&apos; suffix.
        /// </summary>
        internal static string UseAsyncSuffixTestFixtureMethodSuppressorJustification {
            get {
                return ResourceManager.GetString("UseAsyncSuffixTestFixtureMethodSuppressorJustification", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Asynchronous test methods do not require the &apos;Async&apos; suffix.
        /// </summary>
        internal static string UseAsyncSuffixTestMethodSuppressorJustification {
            get {
                return ResourceManager.GetString("UseAsyncSuffixTestMethodSuppressorJustification", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to [{0}] can only be set on methods marked with [TestMethod].
        /// </summary>
        internal static string UseAttributeOnTestMethodAnalyzerMessageFormat {
            get {
                return ResourceManager.GetString("UseAttributeOnTestMethodAnalyzerMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to [{0}] can only be set on methods marked with [TestMethod].
        /// </summary>
        internal static string UseAttributeOnTestMethodAnalyzerTitle {
            get {
                return ResourceManager.GetString("UseAttributeOnTestMethodAnalyzerTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Without using  &apos;ClassCleanupBehavior.EndOfClass&apos;, the &apos;[ClassCleanup]&apos; will by default be run at the end of the assembly and not at the end of the class..
        /// </summary>
        internal static string UseClassCleanupBehaviorEndOfClassDescription {
            get {
                return ResourceManager.GetString("UseClassCleanupBehaviorEndOfClassDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use &apos;ClassCleanupBehavior.EndOfClass&apos; with the &apos;[ClassCleanup]&apos;.
        /// </summary>
        internal static string UseClassCleanupBehaviorEndOfClassMessageFormat {
            get {
                return ResourceManager.GetString("UseClassCleanupBehaviorEndOfClassMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use &apos;ClassCleanupBehavior.EndOfClass&apos; with the &apos;[ClassCleanup]&apos;.
        /// </summary>
        internal static string UseClassCleanupBehaviorEndOfClassTitle {
            get {
                return ResourceManager.GetString("UseClassCleanupBehaviorEndOfClassTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The attribute &apos;{0}&apos; which derives from &apos;ConditionBaseAttribute&apos; should be used only on classes marked with `TestClassAttribute`.
        /// </summary>
        internal static string UseConditionBaseWithTestClassMessageFormat {
            get {
                return ResourceManager.GetString("UseConditionBaseWithTestClassMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use &apos;ConditionBaseAttribute&apos; on test classes.
        /// </summary>
        internal static string UseConditionBaseWithTestClassTitle {
            get {
                return ResourceManager.GetString("UseConditionBaseWithTestClassTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;[DeploymentItem]&apos; can be specified only on test class or test method.
        /// </summary>
        internal static string UseDeploymentItemWithTestMethodOrTestClassMessageFormat {
            get {
                return ResourceManager.GetString("UseDeploymentItemWithTestMethodOrTestClassMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;[DeploymentItem]&apos; can be specified only on test class or test method.
        /// </summary>
        internal static string UseDeploymentItemWithTestMethodOrTestClassTitle {
            get {
                return ResourceManager.GetString("UseDeploymentItemWithTestMethodOrTestClassTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use &apos;Assert.ThrowsExactly&apos; instead of &apos;Assert.ThrowsException&apos;.
        /// </summary>
        internal static string UseNewerAssertThrowsMessageFormat {
            get {
                return ResourceManager.GetString("UseNewerAssertThrowsMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use newer methods to assert exceptions.
        /// </summary>
        internal static string UseNewerAssertThrowsTitle {
            get {
                return ResourceManager.GetString("UseNewerAssertThrowsTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, MSTest runs tests within the same assembly sequentially, which can lead to severe performance limitations. It is recommended to enable assembly attribute &apos;[Parallelize]&apos; to run tests in parallel, or if the assembly is known to not be parallelizable, to use explicitly the assembly level attribute &apos;[DoNotParallelize]&apos;..
        /// </summary>
        internal static string UseParallelizeAttributeAnalyzerDescription {
            get {
                return ResourceManager.GetString("UseParallelizeAttributeAnalyzerDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Explicitly enable or disable tests parallelization.
        /// </summary>
        internal static string UseParallelizeAttributeAnalyzerMessageFormat {
            get {
                return ResourceManager.GetString("UseParallelizeAttributeAnalyzerMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Explicitly enable or disable tests parallelization.
        /// </summary>
        internal static string UseParallelizeAttributeAnalyzerTitle {
            get {
                return ResourceManager.GetString("UseParallelizeAttributeAnalyzerTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use &apos;Assert.{0}&apos; instead of &apos;Assert.{1}&apos;.
        /// </summary>
        internal static string UseProperAssertMethodsMessageFormat {
            get {
                return ResourceManager.GetString("UseProperAssertMethodsMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use proper &apos;Assert&apos; methods.
        /// </summary>
        internal static string UseProperAssertMethodsTitle {
            get {
                return ResourceManager.GetString("UseProperAssertMethodsTitle", resourceCulture);
            }
        }
    }
}