<?xml version="1.0" encoding="utf-8"?>
<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
  <file datatype="xml" source-language="en" target-language="ru" original="../Resources.resx">
    <body>
      <trans-unit id="AssemblyCleanupShouldBeValidDescription">
        <source>Methods marked with '[AssemblyCleanup]' should follow the following layout to be valid:
-it can't be declared on a generic class
-it should be 'public'
-it should be 'static'
-it should not be 'async void'
-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 'TestContext'
-return type should be 'void', 'Task' or 'ValueTask'

The type declaring these methods should also respect the following rules:
-The type should be a class
-The class should be 'public' or 'internal' (if the test project is using the '[DiscoverInternals]' attribute)
-The class shouldn't be 'static'
-The class should be marked with '[TestClass]' (or a derived attribute)
-the class should not be generic.</source>
        <target state="translated">Чтобы метод, помеченный "[AssemblyCleanup]", был допустимым, он должен соответствовать следующим правилам:
– не может быть объявлен для универсального class ("generic");
– должен быть общедоступным ("public");
– должен быть статическим ("static");
– не должен быть асинхронным и не возвращающим значения ("async void")
– не должен быть специальным (метод завершения, оператор…).
– не должен быть общим ("generic")
;
– не должен принимать никаких параметров или должен принимать один параметр типа TestContext
;
– должен иметь тип возвращаемого значения "void", "Task" или "ValueTask";

Тип, объявляющий такие методы, также должен соответствовать следующим правилам:
– должен быть class;
– class должен быть объявлен как "public" или "internal" (если тестовый проект использует атрибут "[DiscoverInternals]");
– class должен быть статическим ("static");
– class должен быть помечен как "[TestClass]" (или производный атрибут);
– class должен быть универсальным ("generic").</target>
        <note>{Locked="[DiscoverInternals]"}{Locked="[AssemblyCleanup]"}{Locked="[TestClass]"}{Locked="TestContext"}{Locked="ValueTask"}{Locked="Task"}{Locked="public"}{Locked="internal"}{Locked="static"}{Locked="void"}{Locked="async void"}{Locked="async"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="AssemblyCleanupShouldBeValidMessageFormat">
        <source>AssemblyCleanup method '{0}' signature is invalid</source>
        <target state="translated">Подпись метода AssemblyCleanup "{0}" недопустима</target>
        <note>{0} is the method name. {Locked="AssemblyCleanup"}</note>
      </trans-unit>
      <trans-unit id="AssemblyCleanupShouldBeValidTitle">
        <source>AssemblyCleanup methods should have valid layout</source>
        <target state="translated">Методы AssemblyCleanup должны использовать допустимый макет</target>
        <note>{Locked="AssemblyCleanup"}</note>
      </trans-unit>
      <trans-unit id="AssemblyFixtureProviderNotSupportedWithNativeAotDescription">
        <source>'[AssemblyFixtureProvider]' discovery relies on walking the runtime assembly reference graph, which is not supported when the runtime cannot generate dynamic code (for example under Native AOT or Blazor WebAssembly AOT). The attribute is ignored in such builds, so the provided assembly initialize and cleanup methods will not run. Declare the '[AssemblyInitialize]' and '[AssemblyCleanup]' methods directly in the test assembly instead.</source>
        <target state="translated">Обнаружение "[AssemblyFixtureProvider]" основано на обходе графа ссылок сборки среды выполнения, что не поддерживается, если среда выполнения не может генерировать динамический код (например, в Native AOT или Blazor WebAssembly AOT). В таких сборках этот атрибут игнорируется, поэтому указанные методы инициализации и очистки сборки выполняться не будут. Вместо этого объявите методы "[AssemblyInitialize]" и "[AssemblyCleanup]" непосредственно в тестовой сборке.</target>
        <note>{Locked="[AssemblyFixtureProvider]"}{Locked="[AssemblyInitialize]"}{Locked="[AssemblyCleanup]"}{Locked="Native AOT"}{Locked="Blazor WebAssembly AOT"}</note>
      </trans-unit>
      <trans-unit id="AssemblyFixtureProviderNotSupportedWithNativeAotMessageFormat">
        <source>'[AssemblyFixtureProvider]' is not supported with ahead-of-time compilation (such as Native AOT or Blazor WebAssembly AOT) and will be ignored at run time</source>
        <target state="translated">"[AssemblyFixtureProvider]" не поддерживается при предварительной компиляции (например, Native AOT или Blazor WebAssembly AOT) и будет проигнорировано во время выполнения</target>
        <note>{Locked="[AssemblyFixtureProvider]"}{Locked="Native AOT"}{Locked="Blazor WebAssembly AOT"}</note>
      </trans-unit>
      <trans-unit id="AssemblyFixtureProviderNotSupportedWithNativeAotTitle">
        <source>'[AssemblyFixtureProvider]' is not supported with ahead-of-time compilation</source>
        <target state="translated">"[AssemblyFixtureProvider]" не поддерживается при предварительной компиляции</target>
        <note>{Locked="[AssemblyFixtureProvider]"}</note>
      </trans-unit>
      <trans-unit id="AssemblyInitializeShouldBeValidDescription">
        <source>Methods marked with '[AssemblyInitialize]' should follow the following layout to be valid:
-it can't be declared on a generic class
-it should be 'public'
-it should be 'static'
-it should not be 'async void'
-it should not be a special method (finalizer, operator...).
-it should not be generic
-it should take one parameter of type 'TestContext'
-return type should be 'void', 'Task' or 'ValueTask'

The type declaring these methods should also respect the following rules:
-The type should be a class
-The class should be 'public' or 'internal' (if the test project is using the '[DiscoverInternals]' attribute)
-The class shouldn't be 'static'
-The class should be marked with '[TestClass]' (or a derived attribute)
-the class should not be generic.</source>
        <target state="translated">Чтобы метод, помеченный "[AssemblyInitialize]", был допустимым, он должен соответствовать следующим правилам:
– не может быть объявлен для универсального class ("generic");
– должен быть общедоступным ("public");
– должен быть статическим ("static");
– не быть асинхронным и не возвращающим значения ("async void")
– не быть специальным (метод завершения, оператор…).
– не быть общим ("generic")
;
– должен принимать один параметр типа "TestContext";
– тип возвращаемого значения должен быть "void", "Task" или "ValueTask";

Тип, объявляющий такие методы, также должен соответствовать следующим правилам:
– должен быть class;
– class должен быть объявлен как "public" или "internal" (если тестовый проект использует атрибут "[DiscoverInternals]");
– class должен быть статическим ("static");
– class должен быть помечен как "[TestClass]" (или производный атрибут);
– class должен быть универсальным ("generic").</target>
        <note>{Locked="[AssemblyInitialize]"}{Locked="[DiscoverInternals]"}{Locked="[TestClass]"}{Locked="TestContext"}{Locked="ValueTask"}{Locked="Task"}{Locked="public"}{Locked="internal"}{Locked="static"}{Locked="void"}{Locked="async void"}{Locked="async"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="AssemblyInitializeShouldBeValidMessageFormat">
        <source>AssemblyInitialize method '{0}' signature is invalid</source>
        <target state="translated">Подпись метода AssemblyInitialize "{0}" недопустима</target>
        <note>{0} is the method name. {Locked="AssemblyInitialize"}</note>
      </trans-unit>
      <trans-unit id="AssemblyInitializeShouldBeValidTitle">
        <source>AssemblyInitialize methods should have valid layout</source>
        <target state="translated">Методы AssemblyInitialize должны использовать допустимый макет</target>
        <note>{Locked="AssemblyInitialize"}</note>
      </trans-unit>
      <trans-unit id="AssertionArgsShouldAvoidConditionalAccessDescription">
        <source>Conditional access adds an implicit null branch to an assertion, which can hide whether the object was unexpectedly null. A separate null assertion makes failures identify the violated condition.</source>
        <target state="new">Conditional access adds an implicit null branch to an assertion, which can hide whether the object was unexpectedly null. A separate null assertion makes failures identify the violated condition.</target>
        <note>{Locked="null"}</note>
      </trans-unit>
      <trans-unit id="AssertionArgsShouldAvoidConditionalAccessMessageFormat">
        <source>Prefer adding an additional assertion that checks for null</source>
        <target state="translated">Предпочитайте добавление дополнительного утверждения, проверяющего наличие значения null</target>
        <note>{Locked="null"}</note>
      </trans-unit>
      <trans-unit id="AssertionArgsShouldAvoidConditionalAccessTitle">
        <source>Avoid conditional access in assertions</source>
        <target state="translated">Избегайте условного доступа в утверждениях</target>
        <note />
      </trans-unit>
      <trans-unit id="AssertionArgsShouldBePassedInCorrectOrderDescription">
        <source>'Assert.AreEqual', 'Assert.AreNotEqual', 'Assert.AreSame' and 'Assert.AreNotSame' expects the expected value to be passed first and the actual value to be passed as second argument.</source>
        <target state="translated">"Assert.AreEqual", "Assert.AreNotEqual", "Assert.AreSame" и "Assert.AreNotSame" ожидают, что сначала будет передано expected значение, а actual значение будет передано в качестве второго аргумента.</target>
        <note>{Locked="Assert.AreNotEqual"}{Locked="Assert.AreNotSame"}{Locked="Assert.AreEqual"}{Locked="Assert.AreSame"}{Locked="actual"}{Locked="expected"}</note>
      </trans-unit>
      <trans-unit id="AssertionArgsShouldBePassedInCorrectOrderMessageFormat">
        <source>Assertion arguments should be passed in the correct order. 'actual' and 'expected'/'notExpected' arguments have been swapped.</source>
        <target state="translated">Аргументы проверочных утверждений должны передаваться в правильном порядке. Аргументы "actual" и "expected"/"notExpected" были переставлены местами.</target>
        <note>{Locked="actual"}{Locked="expected"}{Locked="notExpected"}</note>
      </trans-unit>
      <trans-unit id="AssertionArgsShouldBePassedInCorrectOrderTitle">
        <source>Assertion arguments should be passed in the correct order</source>
        <target state="translated">Аргументы проверочных утверждений должны передаваться в правильном порядке</target>
        <note />
      </trans-unit>
      <trans-unit id="AvoidAssertAreEqualOnCollectionsDescription">
        <source>`Assert.AreEqual` and `Assert.AreNotEqual` use `EqualityComparer&lt;T&gt;.Default`. For collection-like types this relies on the type's own equality semantics instead of comparing sequence elements, so `Assert.AreSequenceEqual`/`Assert.AreNotSequenceEqual` or `Assert.AreEquivalent`/`Assert.AreNotEquivalent` are usually the better fit.</source>
        <target state="translated">`Assert.AreEqual` и `Assert.AreNotEqual` используют `EqualityComparer&lt;T&gt;.Default`. Для типов, похожих на коллекции, это опирается на собственную семантику равенства типа, а не на сравнение элементов последовательности, поэтому обычно лучше подходят `Assert.AreSequenceEqual`/`Assert.AreNotSequenceEqual` или `Assert.AreEquivalent`/`Assert.AreNotEquivalent`.</target>
        <note>{Locked="EqualityComparer&lt;T&gt;.Default"}{Locked="Assert.AreNotSequenceEqual"}{Locked="Assert.AreSequenceEqual"}{Locked="Assert.AreNotEquivalent"}{Locked="Assert.AreEquivalent"}{Locked="Assert.AreNotEqual"}{Locked="Assert.AreEqual"}</note>
      </trans-unit>
      <trans-unit id="AvoidAssertAreEqualOnCollectionsMessageFormat">
        <source>`{0}` on {1} (which implements IEnumerable&lt;T&gt;) does not perform element-wise sequence comparison. Use `Assert.AreSequenceEqual` for ordered element-wise comparison, `Assert.AreSequenceEqual(..., SequenceOrder.InAnyOrder)` for unordered, or `Assert.AreEquivalent` for deep structural comparison.</source>
        <target state="translated">`{0}` в {1} (который реализует IEnumerable&lt;T&gt;) не выполняет поэлементное сравнение последовательностей. Используйте `Assert.AreSequenceEqual` для упорядоченного поэлементного сравнения, `Assert.AreSequenceEqual(..., SequenceOrder.InAnyOrder)` для неупорядоченного сравнения или `Assert.AreEquivalent` для глубокого структурного сравнения.</target>
        <note>{0} is the current assert method call. {1} is the collection type name. {Locked="Assert.AreSequenceEqual(..., SequenceOrder.InAnyOrder)"}{Locked="Assert.AreSequenceEqual"}{Locked="Assert.AreEquivalent"}{Locked="IEnumerable&lt;T&gt;"}</note>
      </trans-unit>
      <trans-unit id="AvoidAssertAreEqualOnCollectionsTitle">
        <source>Avoid Assert.AreEqual on collection types</source>
        <target state="translated">Не используйте Assert.AreEqual для типов коллекций</target>
        <note>{Locked="Assert.AreEqual"}</note>
      </trans-unit>
      <trans-unit id="AvoidAssertAreSameWithValueTypesDescription">
        <source>Use 'Assert.AreEqual'/'Assert.AreNotEqual' instead of 'Assert.AreSame'/'Assert.AreNotSame' when comparing value types. Passing a value type to 'Assert.AreSame'/'Assert.AreNotSame' will be boxed (creating a new object). Because 'Assert.AreSame'/'Assert.AreNotSame' does the comparison by reference, 'Assert.AreSame' will fail when boxing happens, and 'Assert.AreNotSame' will always pass.</source>
        <target state="translated">При сравнении типов значений используйте "Assert.AreEqual"/"Assert.AreNotEqual" вместо "Assert.AreSame"/"Assert.AreNotSame". Передача типа значения в "Assert.AreSame"/"Assert.AreNotSame" будет добавлена в рамку (создание нового объекта). Поскольку "Assert.AreSame"/"Assert.AreNotSame" выполняет сравнение по ссылке, при боксе "Assert.AreSame" будет выполняться с ошибкой, а "Assert.AreNotSame" всегда будет проходить.</target>
        <note>{Locked="Assert.AreNotEqual"}{Locked="Assert.AreNotSame"}{Locked="Assert.AreEqual"}{Locked="Assert.AreSame"}</note>
      </trans-unit>
      <trans-unit id="AvoidAssertAreSameWithValueTypesMessageFormat">
        <source>Use '{0}' instead of '{1}' when comparing value types</source>
        <target state="translated">Использовать '{0}' вместо '{1}' при сравнении типов значений</target>
        <note>{0} is the preferred assertion method name. {1} is the current assertion method name.</note>
      </trans-unit>
      <trans-unit id="AvoidAssertAreSameWithValueTypesTitle">
        <source>Don't use 'Assert.AreSame' or 'Assert.AreNotSame' with value types</source>
        <target state="translated">Не используйте Assert.AreSame или Assert.AreNotSame с типами значений</target>
        <note>{Locked="Assert.AreNotSame"}{Locked="Assert.AreSame"}</note>
      </trans-unit>
      <trans-unit id="AvoidExplicitDynamicDataSourceTypeDescription">
        <source>Since MSTest 3.8, 'DynamicDataSourceType.AutoDetect' is the default and automatically identifies properties, methods, and fields, reducing verbosity and coupling to the member kind.</source>
        <target state="new">Since MSTest 3.8, 'DynamicDataSourceType.AutoDetect' is the default and automatically identifies properties, methods, and fields, reducing verbosity and coupling to the member kind.</target>
        <note>{Locked="MSTest 3.8"}{Locked="'DynamicDataSourceType.AutoDetect'"}</note>
      </trans-unit>
      <trans-unit id="AvoidExplicitDynamicDataSourceTypeMessageFormat">
        <source>Remove the 'DynamicDataSourceType' argument to use the default auto detect behavior</source>
        <target state="translated">Удалите аргумент DynamicDataSourceType, чтобы использовать поведение автоматического обнаружения по умолчанию</target>
        <note>{Locked="DynamicDataSourceType"}</note>
      </trans-unit>
      <trans-unit id="AvoidExplicitDynamicDataSourceTypeTitle">
        <source>Avoid passing an explicit 'DynamicDataSourceType' and use the default auto detect behavior</source>
        <target state="translated">Избегайте передачи явного DynamicDataSourceType и используйте поведение автоматического обнаружения по умолчанию</target>
        <note>{Locked="DynamicDataSourceType"}</note>
      </trans-unit>
      <trans-unit id="AvoidThreadSleepAndTaskWaitInTestsDescription">
        <source>Synchronously blocking the current thread with 'Thread.Sleep', 'Task.Wait', 'Task.WaitAll', 'Task.WaitAny' or 'Task&lt;TResult&gt;.Result' inside test methods or test fixtures is a common source of flakiness and can also deadlock when the test framework runs tests on a SynchronizationContext that requires cooperative scheduling. Prefer 'await Task.Delay' for time-based waits and 'await' the task to observe its result.</source>
        <target state="translated">Синхронная блокировка текущего потока с помощью Thread.Sleep, Task.Wait, Task.WaitAll, Task.WaitAny или Task&lt;TResult&gt;.Result в тестовых методах или фикстурах является частой причиной нестабильных тестов и также может приводить к взаимоблокировкам, если тестовый фреймворк выполняет тесты в SynchronizationContext, требующем кооперативного планирования. Для ожиданий, связанных со временем, предпочтительно использовать await Task.Delay и использовать await для получения результата задачи.</target>
        <note>{Locked="Task&lt;TResult&gt;.Result"}{Locked="Thread.Sleep"}{Locked="Task.WaitAll"}{Locked="Task.WaitAny"}{Locked="Task.Delay"}{Locked="Task.Wait"}{Locked="await"}{Locked="await Task.Delay"}</note>
      </trans-unit>
      <trans-unit id="AvoidThreadSleepAndTaskWaitInTestsMessageFormat">
        <source>Avoid '{0}' in test code as it can cause test flakiness; consider an asynchronous alternative such as 'await Task.Delay' or 'await' the task</source>
        <target state="translated">Избегайте использования {0} в тестовом коде, так как это может приводить к нестабильности; используйте асинхронные альтернативы, например await Task.Delay или await для выполнения задачи.</target>
        <note>{0} is the synchronous blocking call. {Locked="Task.Delay"}{Locked="await"}{Locked="await Task.Delay"}</note>
      </trans-unit>
      <trans-unit id="AvoidThreadSleepAndTaskWaitInTestsTitle">
        <source>Avoid synchronously blocking calls such as 'Thread.Sleep', 'Task.Wait', 'Task.WaitAll', 'Task.WaitAny' or 'Task&lt;TResult&gt;.Result' in test code</source>
        <target state="translated">Избегайте синхронно блокирующих вызовов, таких как Thread.Sleep, Task.Wait, Task.WaitAll, Task.WaitAny или Task&lt;TResult&gt;.Result в тестовом коде</target>
        <note>{Locked="Task&lt;TResult&gt;.Result"}{Locked="Thread.Sleep"}{Locked="Task.WaitAll"}{Locked="Task.WaitAny"}{Locked="Task.Wait"}</note>
      </trans-unit>
      <trans-unit id="AvoidUsingAssertsInAsyncVoidContextDescription">
        <source>Do not assert inside 'async void' 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.</source>
        <target state="translated">Не подтверяйте внутри методов async void, локальных функций или лямбда-выражений. Исключения, вызванные в этом контексте, будут необработанные исключения. При использовании VSTest платформа .NET Framework, они будут пропущены без уведомления. При использовании Microsoft.Testing.Platform или VSTest в современной версии .NET они могут привести к сбою процесса.</target>
        <note>{Locked="Microsoft.Testing.Platform"}{Locked=".NET Framework"}{Locked="VSTest"}{Locked=".NET"}{Locked="async void"}{Locked="void"}{Locked="async"}</note>
      </trans-unit>
      <trans-unit id="AvoidUsingAssertsInAsyncVoidContextMessageFormat">
        <source>Do not assert inside 'async void' methods, local functions, or lambdas because they may not fail the test</source>
        <target state="translated">Не подтверяйте внутри методов async void, локальных функций или лямбда-выражений, так как они не могут не пройдены</target>
        <note>{Locked="async void"}{Locked="void"}{Locked="async"}</note>
      </trans-unit>
      <trans-unit id="AvoidUsingAssertsInAsyncVoidContextTitle">
        <source>Do not assert inside 'async void' contexts</source>
        <target state="translated">Не утверждать внутри контекстов async void</target>
        <note>{Locked="async void"}{Locked="void"}{Locked="async"}</note>
      </trans-unit>
      <trans-unit id="ClassCleanupShouldBeValidDescription">
        <source>Methods marked with '[ClassCleanup]' should follow the following layout to be valid:
-it can't be declared on a generic class without the 'InheritanceBehavior' mode is set
-it should be 'public'
-it should be 'static'
-it should not be 'async void'
-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 'TestContext'
-return type should be 'void', 'Task' or 'ValueTask'
-'InheritanceBehavior.BeforeEachDerivedClass' attribute parameter should be specified if the class is 'abstract'
-'InheritanceBehavior.BeforeEachDerivedClass' attribute parameter should not be specified if the class is 'sealed'

The type declaring these methods should also respect the following rules:
-The type should be a class
-The class should be 'public' or 'internal' (if the test project is using the '[DiscoverInternals]' attribute)
-The class shouldn't be 'static'
-If the class is 'sealed', it should be marked with '[TestClass]' (or a derived attribute)
-the class should not be generic.</source>
        <target state="translated">Чтобы метод, помеченный "[ClassCleanup]", был допустимым, он должен соответствовать следующим правилам:
– не может быть объявлен для универсального class, если не установлен режим InheritanceBehavior;
– должен быть общедоступным ("public");
– должен быть статическим ("static");
– не должен быть асинхронным и не возвращающим значения ("async void")
– не должен быть специальным (метод завершения, оператор…).
– не должен быть общим ("generic")
;
– не должен принимать никаких параметров или должен принимать один параметр типа TestContext
;
– должен иметь тип возвращаемого значения "void", "Task" или "ValueTask";
– если class abstract, должен быть указан параметр атрибута "InheritanceBehavior.BeforeEachDerivedClass";
– если class sealed, не следует указывать параметр атрибута "InheritanceBehavior.BeforeEachDerivedClass";

Тип, объявляющий такие методы, также должен соответствовать следующим правилам:
– должен быть class;
– class должен быть объявлен как "public" или "internal" (если тестовый проект использует атрибут "[DiscoverInternals]");
– class должен быть объявлен как статический ("static");
– если class sealed, его следует пометить как "[TestClass]" (или производный атрибут);
– class должен быть универсальным ("generic").</target>
        <note>{Locked="InheritanceBehavior.BeforeEachDerivedClass"}{Locked="[DiscoverInternals]"}{Locked="[ClassCleanup]"}{Locked="[TestClass]"}{Locked="TestContext"}{Locked="ValueTask"}{Locked="Task"}{Locked="public"}{Locked="internal"}{Locked="static"}{Locked="void"}{Locked="async void"}{Locked="abstract"}{Locked="sealed"}{Locked="async"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="ClassCleanupShouldBeValidMessageFormat">
        <source>ClassCleanup method '{0}' signature is invalid</source>
        <target state="translated">Подпись метода ClassCleanup "{0}" недопустима</target>
        <note>{0} is the method name. {Locked="ClassCleanup"}</note>
      </trans-unit>
      <trans-unit id="ClassCleanupShouldBeValidTitle">
        <source>ClassCleanup methods should have valid layout</source>
        <target state="translated">Методы ClassCleanup должны использовать допустимый макет</target>
        <note>{Locked="ClassCleanup"}</note>
      </trans-unit>
      <trans-unit id="ClassInitializeShouldBeValidDescription">
        <source>Methods marked with '[ClassInitialize]' should follow the following layout to be valid:
-it can't be declared on a generic class without the 'InheritanceBehavior' mode is set
-it should be 'public'
-it should be 'static'
-it should not be 'async void'
-it should not be a special method (finalizer, operator...).
-it should not be generic
-it should take one parameter of type 'TestContext'
-return type should be 'void', 'Task' or 'ValueTask'
-'InheritanceBehavior.BeforeEachDerivedClass' attribute parameter should be specified if the class is 'abstract'
-'InheritanceBehavior.BeforeEachDerivedClass' attribute parameter should not be specified if the class is 'sealed'

The type declaring these methods should also respect the following rules:
-The type should be a class
-The class should be 'public' or 'internal' (if the test project is using the '[DiscoverInternals]' attribute)
-The class shouldn't be 'static'
-If the class is 'sealed', it should be marked with '[TestClass]' (or a derived attribute)
-the class should not be generic.</source>
        <target state="translated">Чтобы метод, помеченный "[ClassInitialize]", был допустимым, он должен соответствовать следующим правилам:
– не может быть объявлен для универсального class, если не установлен режим InheritanceBehavior;
– должен быть общедоступным ("public");
– должен быть статическим ("static");
– не быть асинхронным и не возвращающим значения ("async void")
– не быть специальным (метод завершения, оператор…).
– не быть общим ("generic")
;
– должен принимать один параметр типа "TestContext";
– тип возвращаемого значения должен быть "void", "Task" или "ValueTask";
– если class abstract, должен быть указан параметр атрибута "InheritanceBehavior.BeforeEachDerivedClass";
– если class sealed, не следует указывать параметр атрибута "InheritanceBehavior.BeforeEachDerivedClass";

Тип, объявляющий такие методы, также должен соответствовать следующим правилам:
– должен быть class;
– class должен быть объявлен как "public" или "internal" (если тестовый проект использует атрибут "[DiscoverInternals]");
– class должен быть объявлен как статический ("static");
– если class sealed, его следует пометить как "[TestClass]" (или производный атрибут);
– class должен быть универсальным ("generic").</target>
        <note>{Locked="InheritanceBehavior.BeforeEachDerivedClass"}{Locked="[DiscoverInternals]"}{Locked="[ClassInitialize]"}{Locked="[TestClass]"}{Locked="TestContext"}{Locked="ValueTask"}{Locked="Task"}{Locked="public"}{Locked="internal"}{Locked="static"}{Locked="void"}{Locked="async void"}{Locked="abstract"}{Locked="sealed"}{Locked="async"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="ClassInitializeShouldBeValidMessageFormat">
        <source>ClassInitialize method '{0}' signature is invalid</source>
        <target state="translated">Подпись метода ClassInitialize "{0}" недопустима</target>
        <note>{0} is the method name. {Locked="ClassInitialize"}</note>
      </trans-unit>
      <trans-unit id="ClassInitializeShouldBeValidTitle">
        <source>ClassInitialize methods should have valid layout</source>
        <target state="translated">Методы ClassInitialize должны использовать допустимый макет</target>
        <note>{Locked="ClassInitialize"}</note>
      </trans-unit>
      <trans-unit id="CollectionAssertToAssertDescription">
        <source>'CollectionAssert' methods have equivalent 'Assert' counterparts. Using one assertion API improves consistency and discoverability.</source>
        <target state="new">'CollectionAssert' methods have equivalent 'Assert' counterparts. Using one assertion API improves consistency and discoverability.</target>
        <note>{Locked="'CollectionAssert'"}{Locked="'Assert'"}{Locked="API"}</note>
      </trans-unit>
      <trans-unit id="CollectionAssertToAssertMessageFormat">
        <source>Use 'Assert.{0}' instead of 'CollectionAssert.{1}'</source>
        <target state="translated">Использовать "Assert.{0}" вместо "CollectionAssert.{1}"</target>
        <note>{0} is the preferred Assert method name. {1} is the current CollectionAssert method name. {Locked="CollectionAssert"}{Locked="Assert"}</note>
      </trans-unit>
      <trans-unit id="CollectionAssertToAssertTitle">
        <source>Use 'Assert' instead of 'CollectionAssert'</source>
        <target state="translated">Использование "Assert" вместо "CollectionAssert"</target>
        <note>{Locked="CollectionAssert"}{Locked="Assert"}</note>
      </trans-unit>
      <trans-unit id="CultureMutationUnderParallelizationDescription">
        <source>'CultureInfo.DefaultThreadCurrentCulture' and 'DefaultThreadCurrentUICulture' set the default culture for the whole process, so every concurrently running test observes the change and formatting or parsing can be corrupted under in-assembly parallelization. The per-thread and ambient forms are intentionally not flagged: on modern .NET the 'Thread.CurrentThread.CurrentCulture' / 'CurrentUICulture' and 'CultureInfo.CurrentCulture' / 'CurrentUICulture' setters all assign an 'AsyncLocal'-backed value that flows with the execution context, so they do not corrupt sibling tests or leak onto later-pooled threads. Because the flagged setters are process-wide, restoring the previous value in a 'finally' does not help - concurrently running tests still observe the changed culture for the duration of the mutation; declare '[DoNotParallelize]' on the test, or avoid mutating process-wide culture, instead.</source>
        <target state="translated">Параметры "CultureInfo.DefaultThreadCurrentCulture" и "DefaultThreadCurrentUICulture" устанавливают язык по умолчанию для всего процесса, поэтому каждый одновременно выполняющийся тест отслеживает это изменение, и форматирование или синтаксический анализ могут быть нарушены при распараллеливании на уровне сборки. Потоковые и промежуточные формы намеренно не помечаются: в современной .NET сеттеры "Thread.CurrentThread.CurrentCulture" / "CurrentUICulture" и "CultureInfo.CurrentCulture" / "CurrentUICulture" присваивают значение, поддерживаемое "AsyncLocal", которое передается вместе с контекстом выполнения, поэтому они не искажают соседние проверки и не проникают в потоки, находящиеся в пуле позже. Поскольку помеченные сеттеры применяются ко всему процессу, восстановление предыдущего значения в блоке "finally" не помогает — параллельно выполняющиеся тесты по-прежнему будут отслеживать измененную культуру на протяжении всего процесса мутации. Вместо этого следует объявить "[DoNotParallelize]" для теста или избегать изменения культуры всего процесса.</target>
        <note>{Locked="CultureInfo.DefaultThreadCurrentCulture"}{Locked="DefaultThreadCurrentUICulture"}{Locked="Thread.CurrentThread.CurrentCulture"}{Locked="CurrentUICulture"}{Locked="CultureInfo.CurrentCulture"}{Locked="AsyncLocal"}{Locked="[DoNotParallelize]"}</note>
      </trans-unit>
      <trans-unit id="CultureMutationUnderParallelizationMessageFormat">
        <source>'{0}' sets the default culture for the whole process, so every concurrently running test observes the change, which can corrupt formatting and parsing in tests running in parallel; avoid mutating it in a parallelized test suite, or declare '[DoNotParallelize]'</source>
        <target state="translated">Параметр "{0}" задает язык по умолчанию для всего процесса, поэтому каждый одновременно выполняющийся тест отслеживает это изменение, что может привести к искажению форматирования и синтаксического анализа в тестах, работающих параллельно; избегайте изменения этого параметра в параллельном наборе тестов или объявите "[DoNotParallelize]"</target>
        <note>{0} is the mutated API (for example 'CultureInfo.DefaultThreadCurrentCulture'). {Locked="[DoNotParallelize]"}</note>
      </trans-unit>
      <trans-unit id="CultureMutationUnderParallelizationTitle">
        <source>Avoid mutating process-wide culture in a parallelized test</source>
        <target state="translated">Избегайте мутаций в культуре, охватывающей весь процесс, при параллельном тестировании</target>
        <note />
      </trans-unit>
      <trans-unit id="CurrentDirectoryMutationUnderParallelizationDescription">
        <source>The current directory is process-global on every operating system and, unlike culture, has no thread-scoped or async-scoped equivalent. A test that changes it corrupts the working directory of every test running concurrently, and relative paths resolved elsewhere in the suite silently point at the wrong location. A '[ResourceLock]' serializes the contending tests and makes the mutation safe, but it remains a design smell in a parallel suite: prefer passing absolute paths so the current directory never needs to change.</source>
        <target state="translated">В параллельных тестах следует избегать жестко заданных или совместно используемых путей к файловой системе. Изменение этого параметра в тесте приводит к повреждению рабочего каталога всех одновременно выполняющихся тестов, а относительные пути, разрешаемые в других частях набора тестов, незаметно указывают на неправильное расположение. Функция "[ResourceLock]" сериализует конкурирующие тесты и делает изменение безопасным, но в параллельном наборе тестов это всё ещё считается недостатком проектирования: лучше передавать абсолютные пути, чтобы текущий каталог никогда не менялся.</target>
        <note>{Locked="[ResourceLock]"}</note>
      </trans-unit>
      <trans-unit id="CurrentDirectoryMutationUnderParallelizationMessageFormat">
        <source>'{0}' changes the process-global current directory, which has no per-thread equivalent and is observed by every concurrently running test; avoid mutating it in a parallelized test suite (declare '[ResourceLock(WellKnownResources.CurrentDirectory)]' to at least coordinate, or '[DoNotParallelize]')</source>
        <target state="translated">"{0}" изменяет глобальный текущий каталог процесса, который не имеет эквивалента для каждого потока и отслеживается каждым одновременно выполняющимся тестом; избегайте его изменения в параллельном наборе тестов (объявите "[ResourceLock(WellKnownResources.CurrentDirectory)]" для координации, или "[DoNotParallelize]")</target>
        <note>{0} is the mutated API (for example 'Directory.SetCurrentDirectory'). {Locked="[ResourceLock]"}{Locked="WellKnownResources"}{Locked="[DoNotParallelize]"}</note>
      </trans-unit>
      <trans-unit id="CurrentDirectoryMutationUnderParallelizationTitle">
        <source>Avoid changing the current directory in a parallelized test</source>
        <target state="translated">Избегайте изменения текущего каталога в параллельном тестировании</target>
        <note />
      </trans-unit>
      <trans-unit id="DependsOnShouldBeValidDescription">
        <source>A '[DependsOn]' attribute references a test by name. A reference that matches no test is deliberately non-fatal at run time, so that running a subset of the suite stays possible, which means a typo or a rename silently drops the declared ordering. This analyzer reports the problems that can be decided at build time: a method that does not exist on the referenced type, a target that is not a test, a test that depends on itself, a dependency cycle visible in the compilation, a reference to a type from another assembly (dependencies are resolved within a single test source), and an attribute applied where it has no effect.</source>
        <target state="translated">Атрибут "[DependsOn]" ссылается на тест по имени. Если ссылка не соответствует ни одному тесту, это намеренно не приводит к ошибке во время выполнения, чтобы можно было запускать только часть набора, из-за чего опечатка или переименование могут незаметно удалить объявленную последовательность. Этот анализатор сообщает о проблемах, которые можно определить во время сборки: о методе, которого нет в указанном по ссылке типе, о цели, которая не является тестом, о тесте, который зависит сам от себя, о цикле зависимостей, видимом в компиляции, о ссылке на тип из другой сборки (зависимости разрешаются в пределах одного источника тестов) и об атрибуте, примененном там, где он не действует.</target>
        <note>{Locked="[DependsOn]"}</note>
      </trans-unit>
      <trans-unit id="DependsOnShouldBeValidMessageFormat_AbstractTarget">
        <source>'[DependsOn]' references abstract type '{0}'; its tests run under each derived test class rather than under '{0}', so the dependency is ignored at run time</source>
        <target state="translated">"[DependsOn]" ссылается на абстрактный тип "{0}"; его тесты выполняются в каждом производном классе тестов, а не в "{0}", поэтому зависимость игнорируется во время выполнения</target>
        <note>{0} is the referenced type name. {Locked="[DependsOn]"}</note>
      </trans-unit>
      <trans-unit id="DependsOnShouldBeValidMessageFormat_Cycle">
        <source>'[DependsOn]' declares the dependency cycle '{0}', which fails every test in the cycle at run time</source>
        <target state="translated">"[DependsOn]" объявляет цикл зависимостей "{0}", из-за которого во время выполнения завершаются сбоем все тесты в цикле</target>
        <note>{0} is the cycle path, for example 'MyTests.A &gt; MyTests.B &gt; MyTests.A'. {Locked="[DependsOn]"}</note>
      </trans-unit>
      <trans-unit id="DependsOnShouldBeValidMessageFormat_MethodNotFound">
        <source>'[DependsOn]' references method '{1}', which does not exist on type '{0}'</source>
        <target state="translated">"[DependsOn]" ссылается на метод "{1}", который не существует в типе "{0}"</target>
        <note>{0} is the referenced type name. {1} is the referenced method name. {Locked="[DependsOn]"}</note>
      </trans-unit>
      <trans-unit id="DependsOnShouldBeValidMessageFormat_NoEffect">
        <source>'[DependsOn]' has no effect because '{0}' is not a test method</source>
        <target state="translated">"[DependsOn]" не действует, так как "{0}" не является методом теста</target>
        <note>{0} is the name of the method the attribute is applied to. {Locked="[DependsOn]"}</note>
      </trans-unit>
      <trans-unit id="DependsOnShouldBeValidMessageFormat_NoEffectOnClass">
        <source>'[DependsOn]' has no effect because discovery runs no test under '{0}'</source>
        <target state="translated">"[DependsOn]" не действует, так как обнаружение не запускает тесты в "{0}"</target>
        <note>{0} is the name of the class the attribute is applied to. {Locked="[DependsOn]"}</note>
      </trans-unit>
      <trans-unit id="DependsOnShouldBeValidMessageFormat_NotATestClass">
        <source>'[DependsOn]' references type '{0}', which is not a test class, so the dependency is ignored at run time</source>
        <target state="translated">"[DependsOn]" ссылается на тип "{0}", который не является классом теста, поэтому зависимость игнорируется во время выполнения</target>
        <note>{0} is the referenced type name. {Locked="[DependsOn]"}</note>
      </trans-unit>
      <trans-unit id="DependsOnShouldBeValidMessageFormat_NotATestMethod">
        <source>'[DependsOn]' references '{0}.{1}', which is not a test method, so the dependency is ignored at run time</source>
        <target state="translated">"[DependsOn]" ссылается на "{0}.{1}", который не является методом теста, поэтому зависимость игнорируется во время выполнения</target>
        <note>{0} is the referenced type name. {1} is the referenced method name. {Locked="[DependsOn]"}</note>
      </trans-unit>
      <trans-unit id="DependsOnShouldBeValidMessageFormat_OtherAssembly">
        <source>'[DependsOn]' references type '{0}' from another assembly; dependencies are resolved within a single test source, so the dependency is ignored at run time</source>
        <target state="translated">"[DependsOn]" ссылается на тип "{0}" из другой сборки; зависимости разрешаются в пределах одного источника тестов, поэтому зависимость игнорируется во время выполнения</target>
        <note>{0} is the referenced type name. {Locked="[DependsOn]"}</note>
      </trans-unit>
      <trans-unit id="DependsOnShouldBeValidMessageFormat_SelfReference">
        <source>'[DependsOn]' makes '{0}' depend on itself, which is a dependency cycle and fails the test at run time</source>
        <target state="translated">"[DependsOn]" делает "{0}" зависимым от самого себя, что создает цикл зависимостей и приводит к сбою теста во время выполнения</target>
        <note>{0} is the test method name. {Locked="[DependsOn]"}</note>
      </trans-unit>
      <trans-unit id="DependsOnShouldBeValidTitle">
        <source>'[DependsOn]' arguments should be valid</source>
        <target state="translated">Аргументы "[DependsOn]" должны быть допустимыми</target>
        <note>{Locked="[DependsOn]"}</note>
      </trans-unit>
      <trans-unit id="DoNotNegateBooleanAssertionDescription">
        <source>Using the opposite assertion directly makes the test easier to read and produces clearer failure diagnostics.</source>
        <target state="new">Using the opposite assertion directly makes the test easier to read and produces clearer failure diagnostics.</target>
        <note />
      </trans-unit>
      <trans-unit id="DoNotStoreStaticTestContextAnalyzerDescription">
        <source>The TestContext passed to assembly or class initialization is specific to that context and is not updated for each test execution. Reusing it in a 'static' member can expose stale context.</source>
        <target state="new">The TestContext passed to assembly or class initialization is specific to that context and is not updated for each test execution. Reusing it in a 'static' member can expose stale context.</target>
        <note>{Locked="TestContext"}{Locked="'static'"}</note>
      </trans-unit>
      <trans-unit id="MemberConditionShouldBeValidDescription">
        <source>The members referenced by a '[MemberCondition]' attribute must exist on the referenced type, be 'public static', return 'bool', and (for methods) be parameterless. The attribute throws at runtime when these rules are violated; this analyzer surfaces the same problems at build time so typos and refactors do not silently break test gating.</source>
        <target state="translated">Элементы, на которые ссылается атрибут "[MemberCondition]", должны существовать в указанном типе, быть "public static", возвращать "bool" и (для методов) не содержать параметров. Если эти правила нарушены, атрибут вызывает исключение во время выполнения. Этот анализатор выявляет те же проблемы на этапе сборки, поэтому опечатки и выполнения рефакторинга не нарушают автоматически проверку тестов.</target>
        <note>{Locked="[MemberCondition]"}{Locked="public static"}{Locked="bool"}</note>
      </trans-unit>
      <trans-unit id="MemberConditionShouldBeValidMessageFormat_MemberNotFound">
        <source>'[MemberCondition]' member '{0}.{1}' cannot be found</source>
        <target state="translated">Невозможно найти элемент "[MemberCondition]" "{0}.{1}"</target>
        <note>{0} is the containing type name. {1} is the member name. {Locked="[MemberCondition]"}</note>
      </trans-unit>
      <trans-unit id="MemberConditionShouldBeValidMessageFormat_MemberNotPublic">
        <source>'[MemberCondition]' referenced member '{0}.{1}' must be 'public'</source>
        <target state="translated">Элемент "{0}.{1}", на который ссылается "[MemberCondition]", должен быть "public"</target>
        <note>{0} is the containing type name. {1} is the member name. {Locked="[MemberCondition]"}{Locked="public"}</note>
      </trans-unit>
      <trans-unit id="MemberConditionShouldBeValidMessageFormat_MemberNotStatic">
        <source>'[MemberCondition]' referenced member '{0}.{1}' must be 'static'</source>
        <target state="translated">Элемент "{0}.{1}", на который ссылается "[MemberCondition]", должен быть "static"</target>
        <note>{0} is the containing type name. {1} is the member name. {Locked="[MemberCondition]"}{Locked="static"}</note>
      </trans-unit>
      <trans-unit id="MemberConditionShouldBeValidMessageFormat_MemberWrongKind">
        <source>'[MemberCondition]' referenced member '{0}.{1}' must be a property, field, or parameterless method</source>
        <target state="translated">Элемент "{0}.{1}", на который ссылается "[MemberCondition]", должен быть свойством, полем или методом без параметров</target>
        <note>{0} is the containing type name. {1} is the member name. {Locked="[MemberCondition]"}</note>
      </trans-unit>
      <trans-unit id="MemberConditionShouldBeValidMessageFormat_MemberWrongReturnType">
        <source>'[MemberCondition]' referenced member '{0}.{1}' must return 'bool'</source>
        <target state="translated">Элемент "{0}.{1}", на который ссылается "[MemberCondition]", должен возвращать "bool"</target>
        <note>{0} is the containing type name. {1} is the member name. {Locked="[MemberCondition]"}{Locked="bool"}</note>
      </trans-unit>
      <trans-unit id="MemberConditionShouldBeValidMessageFormat_MethodHasParameters">
        <source>'[MemberCondition]' referenced method '{0}.{1}' must be parameterless</source>
        <target state="translated">Метод "{0}.{1}", на который ссылается "[MemberCondition]", должен быть без параметров</target>
        <note>{0} is the containing type name. {1} is the method name. {Locked="[MemberCondition]"}</note>
      </trans-unit>
      <trans-unit id="MemberConditionShouldBeValidMessageFormat_PropertyNotReadable">
        <source>'[MemberCondition]' referenced property '{0}.{1}' must have a getter</source>
        <target state="translated">Свойство "{0}.{1}", на которое ссылается "[MemberCondition]", должно содержать метод получения</target>
        <note>{0} is the containing type name. {1} is the property name. {Locked="[MemberCondition]"}</note>
      </trans-unit>
      <trans-unit id="MemberConditionShouldBeValidTitle">
        <source>'[MemberCondition]' arguments should be valid</source>
        <target state="translated">Аргументы "[MemberCondition]" должны быть допустимыми</target>
        <note>{Locked="[MemberCondition]"}</note>
      </trans-unit>
      <trans-unit id="DataRowShouldBeValidDescription">
        <source>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.</source>
        <target state="translated">Действительная запись DataRow должна иметь следующую структуру:
– должна быть задана только для метода теста;
– количество аргументов должно совпадать с количеством аргументов метода;
– тип аргумента должен совпадать с типом аргумента метода.</target>
        <note>{Locked="DataRow"}</note>
      </trans-unit>
      <trans-unit id="DataRowShouldBeValidMessageFormat_ArgumentCountMismatch">
        <source>DataRow argument count should match method parameter count (constructor arguments: {0}, method parameters: {1})</source>
        <target state="translated">Количество аргументов DataRow должно соответствовать количеству параметров метода (аргументов конструктора: {0}, параметров метода: {1})</target>
        <note>{0} is the number of constructor arguments. {1} is the number of method parameters. {Locked="DataRow"}</note>
      </trans-unit>
      <trans-unit id="DataRowShouldBeValidMessageFormat_ArgumentTypeMismatch">
        <source>DataRow argument types do not match method parameter types. {0}</source>
        <target state="translated">Типы аргументов DataRow не соответствуют типам параметров метода. {0}</target>
        <note>{0} is the argument type mismatch details. {Locked="DataRow"}</note>
      </trans-unit>
      <trans-unit id="DataRowShouldBeValidMessageFormat_ParameterMismatch">
        <source>Parameter '{0}' expects type '{1}', but the provided value has type '{2}'</source>
        <target state="translated">Параметр "{0}" ожидает тип "{1}", но предоставленное значение относится к типу "{2}"</target>
        <note>{0} is the parameter name. {1} is the expected parameter type. {2} is the provided value type.</note>
      </trans-unit>
      <trans-unit id="DataRowShouldBeValidMessageFormat_GenericTypeArgumentConflictingTypes">
        <source>Found two conflicting types for generic parameter '{0}'. The conflicting types are '{1}' and '{2}'.</source>
        <target state="translated">Обнаружены два конфликтующих типа для универсального параметра '{0}'. Конфликтуют типы '{1}' и '{2}'.</target>
        <note>{0} is the generic type parameter name. {1} and {2} are the conflicting type names.</note>
      </trans-unit>
      <trans-unit id="DataRowShouldBeValidMessageFormat_GenericTypeArgumentNotResolved">
        <source>The type of the generic parameter '{0}' could not be inferred.</source>
        <target state="translated">Не удалось определить тип универсального '{0}' параметра.</target>
        <note>{0} is the generic type parameter name.</note>
      </trans-unit>
      <trans-unit id="DataRowShouldBeValidMessageFormat_OnTestMethod">
        <source>DataRow should only be set on a test method</source>
        <target state="translated">Значение DataRow следует задавать только для метода теста</target>
        <note>{Locked="DataRow"}</note>
      </trans-unit>
      <trans-unit id="DataRowShouldBeValidTitle">
        <source>DataRow should be valid</source>
        <target state="translated">Значение DataRow должно быть допустимым</target>
        <note>{Locked="DataRow"}</note>
      </trans-unit>
      <trans-unit id="DoNotNegateBooleanAssertionFix">
        <source>Use 'Assert.{0}' instead</source>
        <target state="translated">Вместо этого используйте "Assert.{0}"</target>
        <note>{0} is the assert method name. {Locked="Assert"}</note>
      </trans-unit>
      <trans-unit id="DoNotNegateBooleanAssertionFixAllTitle">
        <source>Use proper Assert methods for all negated assertions</source>
        <target state="translated">Используйте правильные методы Assert для всех отрицательных утверждений</target>
        <note>{Locked="Assert"}</note>
      </trans-unit>
      <trans-unit id="DoNotNegateBooleanAssertionMessageFormat">
        <source>Do not negate boolean assertions, instead use the opposite assertion</source>
        <target state="translated">Не отрицать логические утверждения, вместо этого использовать противоположное утверждение</target>
        <note />
      </trans-unit>
      <trans-unit id="DoNotNegateBooleanAssertionTitle">
        <source>Do not negate boolean assertions</source>
        <target state="translated">Не отрицать логические утверждения</target>
        <note />
      </trans-unit>
      <trans-unit id="DoNotStoreStaticTestContextAnalyzerMessageFormat">
        <source>Do not store TestContext in a static member</source>
        <target state="translated">Не хранить TestContext в static элементе</target>
        <note>{Locked="TestContext"}{Locked="static"}</note>
      </trans-unit>
      <trans-unit id="DoNotStoreStaticTestContextAnalyzerTitle">
        <source>Do not store TestContext in a static member</source>
        <target state="translated">Не хранить TestContext в static элементе</target>
        <note>{Locked="TestContext"}{Locked="static"}</note>
      </trans-unit>
      <trans-unit id="DoNotUseShadowingDescription">
        <source>Shadowing test members could cause testing issues (such as NRE).</source>
        <target state="translated">Удаленное управление элементами теста может вызвать проблемы с тестированием (например, NRE).</target>
        <note />
      </trans-unit>
      <trans-unit id="DoNotUseShadowingMessageFormat">
        <source>Member '{0}' already exists in the base class</source>
        <target state="translated">Элемент "{0}" уже существует в базовом class</target>
        <note>{0} is the member name. {Locked="class"}</note>
      </trans-unit>
      <trans-unit id="DoNotUseShadowingTitle">
        <source>Do not use shadowing</source>
        <target state="translated">Не используйте удаленное управление</target>
        <note />
      </trans-unit>
      <trans-unit id="DoNotUseSystemDescriptionAttributeDescription">
        <source>'System.ComponentModel.DescriptionAttribute' has no effect in the context of tests and you likely wanted to use 'Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute' instead.</source>
        <target state="translated">"System.ComponentModel.DescriptionAttribute" не действует в контексте тестов. Вероятно, вы хотели использовать "Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute".</target>
        <note>{Locked="Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute"}{Locked="System.ComponentModel.DescriptionAttribute"}</note>
      </trans-unit>
      <trans-unit id="DoNotUseSystemDescriptionAttributeMessageFormat">
        <source>Did you mean to be using 'Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute'?</source>
        <target state="translated">Вы хотели использовать "Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute"?</target>
        <note>{Locked="Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute"}</note>
      </trans-unit>
      <trans-unit id="DoNotUseSystemDescriptionAttributeTitle">
        <source>'System.ComponentModel.DescriptionAttribute' has no effect on test methods</source>
        <target state="translated">"System.ComponentModel.DescriptionAttribute" не действует на методы тестирования</target>
        <note>{Locked="System.ComponentModel.DescriptionAttribute"}</note>
      </trans-unit>
      <trans-unit id="DuplicateDataRowMessageFormat">
        <source>Do not duplicate 'DataRow' attributes. This is usually a copy/paste error. The attribute indices are '{0}' and '{1}'.</source>
        <target state="translated">Не дублируйте атрибуты "DataRow". Обычно это ошибка копирования и вставки. Индексы атрибута — "{0}" и "{1}".</target>
        <note>{0} is the first duplicate attribute index. {1} is the second duplicate attribute index. {Locked="DataRow"}</note>
      </trans-unit>
      <trans-unit id="DuplicateDataRowTitle">
        <source>Avoid duplicated 'DataRow' entries</source>
        <target state="translated">Избегайте дублирования записей "DataRow"</target>
        <note>{Locked="DataRow"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidDescription">
        <source>'DynamicData' 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.</source>
        <target state="translated">Запись "DynamicData" должна соответствовать следующему макету, чтобы быть допустимой:
– должна быть задана только для метода теста;
– элемент должен быть определен в указанном типе;
– элемент должен быть методом, если указан DynamicDataSourceType.Method, в противном случае он должен быть свойством.</target>
        <note>{Locked="DynamicDataSourceType.Method"}{Locked="DynamicData"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidMessageFormat_DataMemberSignature">
        <source>'[DynamicData]' data member '{0}.{1}' signature is invalid</source>
        <target state="translated">Подпись элемента данных "[DynamicData]" "{0}.{1}" недопустима</target>
        <note>{0} is the containing type name. {1} is the data member name. {Locked="[DynamicData]"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidMessageFormat_DisplayMethodSignature">
        <source>'[DynamicData]' display name method '{0}.{1}' signature is invalid</source>
        <target state="translated">Подпись метода отображаемого имени "[DynamicData]" "{0}.{1}" недопустима</target>
        <note>{0} is the containing type name. {1} is the display name method name. {Locked="[DynamicData]"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidMessageFormat_MemberMethod">
        <source>'[DynamicData]' member '{0}.{1}' should be a method</source>
        <target state="translated">Элемент "[DynamicData]" "{0}.{1}" должен быть методом</target>
        <note>{0} is the containing type name. {1} is the member name. {Locked="[DynamicData]"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidMessageFormat_MemberNotFound">
        <source>'[DynamicData]' member '{0}.{1}' cannot be found</source>
        <target state="translated">Невозможно найти элемент "[DynamicData]" "{0}.{1}"</target>
        <note>{0} is the containing type name. {1} is the member name. {Locked="[DynamicData]"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidMessageFormat_MemberType">
        <source>'[DynamicData]' referenced member '{0}.{1}' should return 'IEnumerable&lt;object[]&gt;', 'IEnumerable&lt;Tuple&gt;` or 'IEnumerable&lt;ValueTuple&gt;'</source>
        <target state="translated">Элемент "[DynamicData]" "{0}.{1}" должен возвращать "IEnumerable&lt;object[]&gt;", "IEnumerable&lt;Tuple&gt;" или "IEnumerable&lt;ValueTuple&gt;"</target>
        <note>{0} is the containing type name. {1} is the member name. {Locked="IEnumerable&lt;ValueTuple&gt;"}{Locked="IEnumerable&lt;object[]&gt;"}{Locked="IEnumerable&lt;Tuple&gt;"}{Locked="[DynamicData]"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidMessageFormat_OnTestMethod">
        <source>'[DynamicData]' should only be set on a test method</source>
        <target state="translated">"[DynamicData]" следует задавать только для метода теста</target>
        <note>{Locked="[DynamicData]"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidMessageFormat_SourceTypeField">
        <source>'[DynamicData]' member '{0}.{1}' is a field so you should use 'DynamicDataSourceType.AutoDetect' or 'DynamicDataSourceType.Field' (auto detect is the default when not specified explicitly, and is recommended)</source>
        <target state="translated">Элемент "[DynamicData]" "{0}.{1}" является полем, поэтому следует использовать "DynamicDataSourceType.AutoDetect" или "DynamicDataSourceType.Field" (автообнаружение используется по умолчанию, если не указано явно, и является рекомендуемым)</target>
        <note>{0} is the containing type name. {1} is the member name. {Locked="DynamicDataSourceType.AutoDetect"}{Locked="DynamicDataSourceType.Field"}{Locked="[DynamicData]"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidMessageFormat_SourceTypeMethod">
        <source>'[DynamicData]' member '{0}.{1}' is a method so you should use 'DynamicDataSourceType.AutoDetect' or 'DynamicDataSourceType.Method' (auto detect is the default when not specified explicitly, and is recommended)</source>
        <target state="translated">'[DynamicData]' "{0}.{1}" является методом, поэтому следует использовать "DynamicDataSourceType.AutoDetect" или "DynamicDataSourceType.Method" (автообнаружение используется по умолчанию, если не указано явно, и рекомендуется)</target>
        <note>{0} is the containing type name. {1} is the member name. {Locked="DynamicDataSourceType.AutoDetect"}{Locked="DynamicDataSourceType.Method"}{Locked="[DynamicData]"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidMessageFormat_SourceTypeNotPropertyMethodOrField">
        <source>'[DynamicData]' member '{0}.{1}' is not a property, method, or field. Only properties, methods, and fields are supported.</source>
        <target state="translated">Элемент "[DynamicData]" "{0}.{1}" не является свойством, методом или полем. Поддерживаются только свойства, методы и поля.</target>
        <note>{0} is the containing type name. {1} is the member name. {Locked="[DynamicData]"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidMessageFormat_SourceTypeNotPropertyOrMethod">
        <source>'[DynamicData]' member '{0}.{1}' is not a property nor a method. Only properties and methods are supported.</source>
        <target state="translated">'[DynamicData]' "{0}.{1}" не является свойством или методом. Поддерживаются только свойства и методы.</target>
        <note>{0} is the containing type name. {1} is the member name. {Locked="[DynamicData]"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidMessageFormat_SourceTypeProperty">
        <source>'[DynamicData]' member '{0}.{1}' is a property so you should use 'DynamicDataSourceType.AutoDetect' or 'DynamicDataSourceType.Property' (auto detect is the default when not specified explicitly, and is recommended)</source>
        <target state="translated">'[DynamicData]' "{0}.{1}" является свойством, поэтому следует использовать "DynamicDataSourceType.AutoDetect" или "DynamicDataSourceType.Property" (автообнаружение используется по умолчанию, если не указано явно и рекомендуется)</target>
        <note>{0} is the containing type name. {1} is the member name. {Locked="DynamicDataSourceType.AutoDetect"}{Locked="DynamicDataSourceType.Property"}{Locked="[DynamicData]"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidMessageFormat_TooManyMembers">
        <source>'[DynamicData]' member '{0}.{1}' is found more than once</source>
        <target state="translated">Элемент "[DynamicData]" "{0}.{1}" обнаружен несколько раз</target>
        <note>{0} is the containing type name. {1} is the member name. {Locked="[DynamicData]"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidTitle">
        <source>DynamicData should be valid</source>
        <target state="translated">Значение DynamicData должно быть допустимым</target>
        <note>{Locked="DynamicData"}</note>
      </trans-unit>
      <trans-unit id="FlowTestContextCancellationTokenDescription">
        <source>When calling async methods that have overloads accepting a CancellationToken parameter, prefer using the overload with TestContext.CancellationToken to enable cooperative cancellation and respect test timeouts.</source>
        <target state="translated">При вызове async методов с перегрузками, принимающими параметр CancellationToken, рекомендуется использовать перегрузку с TestContext.CancellationTokenSource.Token, чтобы обеспечить совместные действия по отмене и учитывать лимиты времени ожидания тестов.</target>
        <note>{Locked="TestContext.CancellationToken"}{Locked="CancellationToken"}{Locked="async"}</note>
      </trans-unit>
      <trans-unit id="FlowTestContextCancellationTokenMessageFormat">
        <source>Consider using the overload that accepts a CancellationToken and pass 'TestContext.CancellationToken'</source>
        <target state="translated">Рассмотрите возможность использования перегрузки, которая принимает CancellationToken, и передавайте "TestContext.CancellationToken"</target>
        <note>{Locked="TestContext.CancellationToken"}{Locked="CancellationToken"}</note>
      </trans-unit>
      <trans-unit id="FlowTestContextCancellationTokenTitle">
        <source>Flow TestContext.CancellationToken to async operations</source>
        <target state="translated">Передача TestContext.CancellationToken в async операции</target>
        <note>{Locked="TestContext.CancellationToken"}{Locked="async"}</note>
      </trans-unit>
      <trans-unit id="GlobalTestFixtureShouldBeValidDescription">
        <source>Methods marked with '[GlobalTestInitialize]' or '[GlobalTestCleanup]' should follow the following layout to be valid:
-it can't be declared on a generic class
-it should be 'public'
-it should be 'static'
-it should not be 'async void'
-it should not be a special method (finalizer, operator...).
-it should not be generic
-it should take one parameter of type 'TestContext'
-return type should be 'void', 'Task' or 'ValueTask'

The type declaring these methods should also respect the following rules:
-The type should be a class
-The class should be 'public'
-The class should be marked with '[TestClass]' (or a derived attribute)
-the class should not be generic.</source>
        <target state="translated">Чтобы метод, помеченный "[GlobalTestInitialize]" или "[GlobalTestCleanup]", был допустимым, он должен соответствовать следующей структуре:
– не может быть объявлен для универсального class
– должен быть общедоступным ("public")
– должен быть статическим ("static")
– не должен быть асинхронным и не возвращающим значения ("async void")
– не должен быть специальным (метод завершения, оператор…).
– не должен быть универсальным ("generic")
– должен принимать один параметр типа "TestContext"
– должен иметь тип возвращаемого значения "void", "Task" или "ValueTask"

Тип, объявляющий такие методы, также должен соответствовать следующим правилам:
– должен быть class
– class должен быть общедоступным ("public")
– class должен быть помечен как "[TestClass]" (или производный атрибут);
– class не должен быть универсальным.</target>
        <note>{Locked="[GlobalTestInitialize]"}{Locked="[GlobalTestCleanup]"}{Locked="[TestClass]"}{Locked="TestContext"}{Locked="ValueTask"}{Locked="Task"}{Locked="public"}{Locked="static"}{Locked="void"}{Locked="async void"}{Locked="async"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="GlobalTestFixtureShouldBeValidMessageFormat">
        <source>Global test fixture method '{0}' signature is invalid</source>
        <target state="translated">Подпись метода глобального средства тестирования "{0}" недопустима</target>
        <note>{0} is the method name.</note>
      </trans-unit>
      <trans-unit id="GlobalTestFixtureShouldBeValidTitle">
        <source>GlobalTestInitialize and GlobalTestCleanup methods should have valid layout</source>
        <target state="translated">Методы GlobalTestInitialize и GlobalTestCleanup должны использовать допустимый макет</target>
        <note>{Locked="GlobalTestInitialize"}{Locked="GlobalTestCleanup"}</note>
      </trans-unit>
      <trans-unit id="IgnoreShouldHaveJustificationDescription">
        <source>An '[Ignore]' attribute applied to a test method or test class should include a non-empty message explaining why the test or class is ignored. A justification message makes it easier to triage skipped tests, helps reviewers understand the intent, and prevents tests from being silently disabled forever.</source>
        <target state="translated">Атрибут [Ignore], применяемый к тестовому методу или тестовому class, должен содержать непустое сообщение, объясняющее, почему тест или class игнорируется. Сообщение с обоснованием упрощает рассмотрение пропущенных тестов, помогает рецензентам понять намерение и предотвращает ситуацию, когда тесты оказываются отключены без внимания на длительное время.</target>
        <note>{Locked="[Ignore]"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="IgnoreShouldHaveJustificationMessageFormat">
        <source>'[Ignore]' should specify a message explaining why '{0}' is ignored</source>
        <target state="translated">[Ignore] должен содержать сообщение с объяснением, почему {0} игнорируется</target>
        <note>{0} is the ignored target name. {Locked="[Ignore]"}</note>
      </trans-unit>
      <trans-unit id="IgnoreShouldHaveJustificationTitle">
        <source>'[Ignore]' should specify a justification</source>
        <target state="translated">[Ignore] должно содержать обоснование</target>
        <note>{Locked="[Ignore]"}</note>
      </trans-unit>
      <trans-unit id="IgnoreStringMethodReturnValueDescription">
        <source>Methods like Contains, StartsWith, and EndsWith return boolean values that indicate whether the condition was met. Ignoring these return values is likely a mistake.</source>
        <target state="translated">Такие методы, как Contains, StartsWith и EndsWith, возвращают логические значения, указывающие, выполнено ли условие. Игнорирование этих возвращаемых значений, скорее всего, является ошибкой.</target>
        <note>{Locked="StartsWith"}{Locked="Contains"}{Locked="EndsWith"}</note>
      </trans-unit>
      <trans-unit id="IgnoreStringMethodReturnValueMessageFormat">
        <source>The return value of '{0}' should not be ignored</source>
        <target state="translated">Возвращаемое значение "{0}" не должно игнорироваться</target>
        <note>{0} is the string method name.</note>
      </trans-unit>
      <trans-unit id="IgnoreStringMethodReturnValueTitle">
        <source>Do not ignore the return value of string methods</source>
        <target state="translated">Не игнорируйте возвращаемое значение строковых методов</target>
        <note />
      </trans-unit>
      <trans-unit id="PreferAssertFailOverAlwaysFalseConditionsDescription">
        <source>'Assert.Fail' makes an intentional failure explicit and allows the failure message to document why the test cannot continue.</source>
        <target state="new">'Assert.Fail' makes an intentional failure explicit and allows the failure message to document why the test cannot continue.</target>
        <note>{Locked="'Assert.Fail'"}</note>
      </trans-unit>
      <trans-unit id="PreferAssertFailOverAlwaysFalseConditionsMessageFormat">
        <source>Use 'Assert.Fail' instead of an always-failing 'Assert.{0}' assert</source>
        <target state="translated">Используйте "Assert.Fail" вместо утверждения с постоянным сбоем "Assert.{0}"</target>
        <note>{0} is the assert method name. {Locked="Assert.Fail"}{Locked="Assert"}</note>
      </trans-unit>
      <trans-unit id="PreferAssertFailOverAlwaysFalseConditionsTitle">
        <source>Use 'Assert.Fail' instead of an always-failing assert</source>
        <target state="translated">Используйте "Assert.Fail" вместо утверждения с постоянным сбоем</target>
        <note>{Locked="Assert.Fail"}</note>
      </trans-unit>
      <trans-unit id="PreferAsyncAssertionDescription">
        <source>When verifying exceptions from asynchronous code, use the async assertion methods instead of blocking the asynchronous operation with GetAwaiter().GetResult().</source>
        <target state="translated">При проверке исключений из asynchronous кода используйте методы asynchronous утверждений вместо блокировки asynchronous операции с помощью GetAwaiter().GetResult().</target>
        <note>{Locked="GetAwaiter().GetResult()"}{Locked="async"}</note>
      </trans-unit>
      <trans-unit id="PreferAsyncAssertionMessageFormat">
        <source>Use 'Assert.{0}' instead of blocking an async call in 'Assert.{1}'</source>
        <target state="translated">Используйте "Assert.{0}" вместо блокировки async вызова в "Assert.{1}"</target>
        <note>{0} is the async assert method name. {1} is the blocking assert method name. {Locked="Assert"}{Locked="async"}</note>
      </trans-unit>
      <trans-unit id="PreferAsyncAssertionTitle">
        <source>Prefer async assertion methods</source>
        <target state="translated">Предпочитайте async методы утверждения</target>
        <note>{Locked="async"}</note>
      </trans-unit>
      <trans-unit id="PreferConstantForResourceLockDescription">
        <source>'[ResourceLock]' matches tests by exact string equality of the resource key. A bare string literal fails open: a typo produces a different key, so conflicting tests are no longer serialized and race silently instead of failing with an error. Referencing a shared constant makes typos a compile error and lets the compiler enforce that every test contending on the same resource uses the same key.</source>
        <target state="translated">"[ResourceLock]" сопоставляет тесты по точному совпадению строки ключа ресурса. Открываются сбои необработанного строкового литерала: опечатка создаст другой ключ, поэтому конфликтующие тесты больше не будут сериализованными и начнут автоматически выполняться в состоянии гонки вместо того, чтобы завершаться с ошибкой. Ссылка на общую константу делает опечатки ошибкой компиляции и позволяет компилятору гарантировать, что каждый тест, конкурирующий за один и тот же ресурс, использует один и тот же ключ.</target>
        <note>{Locked="[ResourceLock]"}</note>
      </trans-unit>
      <trans-unit id="PreferConstantForResourceLockMessageFormat">
        <source>The '[ResourceLock]' resource key '{0}' is a bare string literal; reference a shared constant (such as a 'WellKnownResources' member or your own 'const') so that typos do not silently produce a different, unshared key</source>
        <target state="new">The '[ResourceLock]' resource key '{0}' is a bare string literal; reference a shared constant (such as a 'WellKnownResources' member or your own 'const') so that typos do not silently produce a different, unshared key</target>
        <note>{0} is the resource key value. {Locked="[ResourceLock]"}{Locked="WellKnownResources"}{Locked="'const'"}</note>
      </trans-unit>
      <trans-unit id="PreferConstantForResourceLockTitle">
        <source>Prefer a named constant for the '[ResourceLock]' resource key</source>
        <target state="translated">Используйте именованную константу для ключа ресурса "[ResourceLock]"</target>
        <note>{Locked="[ResourceLock]"}</note>
      </trans-unit>
      <trans-unit id="PreferConstructorOverTestInitializeDescription">
        <source>Constructors allow initialization through 'readonly' fields and provide stronger compiler feedback, especially with nullable reference types. This opt-in style rule is mutually exclusive with MSTEST0019.</source>
        <target state="new">Constructors allow initialization through 'readonly' fields and provide stronger compiler feedback, especially with nullable reference types. This opt-in style rule is mutually exclusive with MSTEST0019.</target>
        <note>{Locked="'readonly'"}{Locked="MSTEST0019"}</note>
      </trans-unit>
      <trans-unit id="PreferDisposeOverTestCleanupDescription">
        <source>'Dispose' and 'DisposeAsync' follow standard .NET lifetime patterns, making test cleanup consistent with production code. This opt-in style rule is mutually exclusive with MSTEST0022.</source>
        <target state="new">'Dispose' and 'DisposeAsync' follow standard .NET lifetime patterns, making test cleanup consistent with production code. This opt-in style rule is mutually exclusive with MSTEST0022.</target>
        <note>{Locked="'DisposeAsync'"}{Locked="'Dispose'"}{Locked=".NET"}{Locked="MSTEST0022"}</note>
      </trans-unit>
      <trans-unit id="PreferTestCleanupOverDisposeDescription">
        <source>'[TestCleanup]' supports asynchronous cleanup on target frameworks where 'IAsyncDisposable' is unavailable. This opt-in style rule is mutually exclusive with MSTEST0021.</source>
        <target state="new">'[TestCleanup]' supports asynchronous cleanup on target frameworks where 'IAsyncDisposable' is unavailable. This opt-in style rule is mutually exclusive with MSTEST0021.</target>
        <note>{Locked="'[TestCleanup]'"}{Locked="'IAsyncDisposable'"}{Locked="MSTEST0021"}</note>
      </trans-unit>
      <trans-unit id="PreferTestInitializeOverConstructorDescription">
        <source>'[TestInitialize]' supports both synchronous and asynchronous initialization, whereas constructors cannot be awaited. This opt-in style rule is mutually exclusive with MSTEST0020.</source>
        <target state="new">'[TestInitialize]' supports both synchronous and asynchronous initialization, whereas constructors cannot be awaited. This opt-in style rule is mutually exclusive with MSTEST0020.</target>
        <note>{Locked="'[TestInitialize]'"}{Locked="MSTEST0020"}</note>
      </trans-unit>
      <trans-unit id="PreferTestMethodOverDataTestMethodAnalyzerDescription">
        <source>'DataTestMethodAttribute' is obsolete and provides no additional functionality over 'TestMethodAttribute'. Use 'TestMethodAttribute' for all test methods, including parameterized tests.</source>
        <target state="translated">Атрибут "DataTestMethodAttribute" устарел и не предоставляет дополнительных функций по сравнению с "TestMethodAttribute". Используйте '"TestMethodAttribute" для всех методов тестирования, включая параметризованные тесты.</target>
        <note>{Locked="DataTestMethodAttribute"}{Locked="TestMethodAttribute"}</note>
      </trans-unit>
      <trans-unit id="PreferTestMethodOverDataTestMethodAnalyzerMessageFormat">
        <source>'DataTestMethod' is obsolete. Use 'TestMethod' instead.</source>
        <target state="translated">"DataTestMethod" устарел. Используйте вместо него "TestMethod".</target>
        <note>{Locked="DataTestMethod"}{Locked="TestMethod"}</note>
      </trans-unit>
      <trans-unit id="PreferTestMethodOverDataTestMethodAnalyzerTitle">
        <source>Prefer 'TestMethod' over 'DataTestMethod'</source>
        <target state="translated">Следует предпочитать метод "TestMethod" методу "DataTestMethod"</target>
        <note>{Locked="DataTestMethod"}{Locked="TestMethod"}</note>
      </trans-unit>
      <trans-unit id="RedundantTestMethodDisplayNameDescription">
        <source>Setting a 'DisplayName' on a test method to a value that is identical to the method name is redundant because the method name is already used as the display name by default. The redundant 'DisplayName' can be removed without changing how the test is reported.</source>
        <target state="translated">Присваивать свойству "DisplayName" тестового метода то же значение, что и имени метода, излишне, поскольку имя метода уже используется по умолчанию в качестве отображаемого имени. Избыточное значение "DisplayName" можно удалить, не меняя способ представления результатов теста.</target>
        <note>{Locked="DisplayName"}</note>
      </trans-unit>
      <trans-unit id="RedundantTestMethodDisplayNameMessageFormat">
        <source>The 'DisplayName' is the same as the test method name '{0}' and can be removed</source>
        <target state="translated">"DisplayName" совпадает с именем метода теста "{0}" и может быть удалено</target>
        <note>{0} is the test method name. {Locked="DisplayName"}</note>
      </trans-unit>
      <trans-unit id="RedundantTestMethodDisplayNameTitle">
        <source>Test method should not specify a display name equal to its name</source>
        <target state="translated">Метод теста не должен указывать отображаемое имя, равное своему имени</target>
        <note />
      </trans-unit>
      <trans-unit id="ReviewAlwaysTrueAssertConditionAnalyzerDescription">
        <source>An assertion that can never fail does not verify behavior and obscures the condition the test is intended to check.</source>
        <target state="new">An assertion that can never fail does not verify behavior and obscures the condition the test is intended to check.</target>
        <note />
      </trans-unit>
      <trans-unit id="ReviewAlwaysTrueAssertConditionAnalyzerMessageFormat">
        <source>Review or remove the assertion as its condition is known to be always true</source>
        <target state="translated">Проверьте или удалите утверждение, так как известно, что его условие всегда true</target>
        <note>{Locked="true"}</note>
      </trans-unit>
      <trans-unit id="ReviewAlwaysTrueAssertConditionAnalyzerTitle">
        <source>Assertion condition is always true</source>
        <target state="translated">Условие проверочного утверждения всегда true</target>
        <note>{Locked="true"}</note>
      </trans-unit>
      <trans-unit id="PreferConstructorOverTestInitializeMessageFormat">
        <source>Prefer constructors over TestInitialize methods</source>
        <target state="translated">Предпочитать конструкторы методам TestInitialize</target>
        <note>{Locked="TestInitialize"}</note>
      </trans-unit>
      <trans-unit id="PreferConstructorOverTestInitializeTitle">
        <source>Prefer constructors over TestInitialize methods</source>
        <target state="translated">Предпочитать конструкторы методам TestInitialize</target>
        <note>{Locked="TestInitialize"}</note>
      </trans-unit>
      <trans-unit id="PreferDisposeOverTestCleanupMessageFormat">
        <source>Prefer 'Dispose' over TestCleanup methods</source>
        <target state="translated">Предпочитать "Dispose" методам TestCleanup</target>
        <note>{Locked="TestCleanup"}{Locked="Dispose"}</note>
      </trans-unit>
      <trans-unit id="PreferDisposeOverTestCleanupTitle">
        <source>Prefer 'Dispose' over TestCleanup methods</source>
        <target state="translated">Предпочитать "Dispose" методам TestCleanup</target>
        <note>{Locked="TestCleanup"}{Locked="Dispose"}</note>
      </trans-unit>
      <trans-unit id="PreferTestCleanupOverDisposeMessageFormat">
        <source>Prefer TestCleanup over 'Dispose' methods</source>
        <target state="translated">Предпочитать TestCleanup методам "Dispose"</target>
        <note>{Locked="TestCleanup"}{Locked="Dispose"}</note>
      </trans-unit>
      <trans-unit id="PreferTestCleanupOverDisposeTitle">
        <source>Prefer TestCleanup over 'Dispose' methods</source>
        <target state="translated">Предпочитать TestCleanup методам "Dispose"</target>
        <note>{Locked="TestCleanup"}{Locked="Dispose"}</note>
      </trans-unit>
      <trans-unit id="PreferTestInitializeOverConstructorMessageFormat">
        <source>Prefer TestInitialize methods over constructors</source>
        <target state="translated">Предпочитать методы TestInitialize конструкторам</target>
        <note>{Locked="TestInitialize"}</note>
      </trans-unit>
      <trans-unit id="PreferTestInitializeOverConstructorTitle">
        <source>Prefer TestInitialize methods over constructors</source>
        <target state="translated">Предпочитать методы TestInitialize конструкторам</target>
        <note>{Locked="TestInitialize"}</note>
      </trans-unit>
      <trans-unit id="PublicMethodShouldBeTestMethodAnalyzerDescription">
        <source>Public methods should be test methods (marked with `[TestMethod]`).</source>
        <target state="translated">Общедоступные методы должны быть тестовыми методами (помеченными как "[TestMethod]").</target>
        <note>{Locked="[TestMethod]"}</note>
      </trans-unit>
      <trans-unit id="PublicMethodShouldBeTestMethodAnalyzerFormat">
        <source>Public method '{0}' should be a test method</source>
        <target state="translated">Общедоступный метод "{0}" должен быть тестовым методом.</target>
        <note>{0} is the method name.</note>
      </trans-unit>
      <trans-unit id="PublicMethodShouldBeTestMethodAnalyzerTitle">
        <source>Public methods should be test methods</source>
        <target state="translated">Общедоступные методы должны быть тестовыми методами</target>
        <note />
      </trans-unit>
      <trans-unit id="PublicTypeShouldBeTestClassDescription">
        <source>It's considered a good practice to have only test classes marked public in a test project.</source>
        <target state="translated">Рекомендуется использовать только тестовые классы, помеченные как public в тестовом проекте.</target>
        <note>{Locked="public"}</note>
      </trans-unit>
      <trans-unit id="PublicTypeShouldBeTestClassMessageFormat">
        <source>Public type '{0}' should be marked with '[TestClass]' or changed to 'internal'</source>
        <target state="translated">Общедоступный тип "{0}" должен быть помечен атрибутом "[TestClass]" или изменен на значение "internal"</target>
        <note>{0} is the type name. {Locked="[TestClass]"}{Locked="internal"}</note>
      </trans-unit>
      <trans-unit id="PublicTypeShouldBeTestClassTitle">
        <source>Public types should be test classes</source>
        <target state="translated">Общедоступные типы должны быть тестовыми классами</target>
        <note />
      </trans-unit>
      <trans-unit id="SharedFileSystemPathInTestDescription">
        <source>Passing a hardcoded absolute path, or a relative path literal, directly to a filesystem-mutating 'File.*'/'Directory.*' method (for example 'File.WriteAllText' or 'Directory.CreateDirectory') targets a location shared by every other test in the assembly; relative paths additionally resolve against the process-global current directory. Under in-assembly parallelization two tests can then write to the same location concurrently. Only statically constant paths passed to a mutating API are flagged; reads, path construction, and paths built from variables are left to the parallel-safety audit skill. Prefer a unique per-test directory such as 'TestContext.TestTempDirectory'.</source>
        <target state="translated">Передача жестко заданного абсолютного пути или относительного пути непосредственно в метод "File.*"/"Directory.*", изменяющий файловую систему (например, "File.WriteAllText" или "Directory.CreateDirectory"), указывает на расположение, общее для всех остальных тестов в сборке; относительные пути дополнительно разрешаются относительно текущего глобального каталога процесса. При внутрисборочной параллелизации два теста могут затем записывать в одно и то же место одновременно. Отмечаются только статически постоянные пути, передаваемые в изменяющий API. Операции чтения, построение путей и пути, созданные из переменных, остаются на усмотрение проверки параллельной безопасности. Предпочтительно использовать уникальный каталог для каждого теста, например, "TestContext.TestTempDirectory".</target>
        <note>{Locked="File.*"}{Locked="Directory.*"}{Locked="TestContext.TestTempDirectory"}</note>
      </trans-unit>
      <trans-unit id="SharedFileSystemPathInTestMessageFormat">
        <source>The path '{0}' is a fixed location shared by every test in the assembly (and, when relative, resolves against the process-global current directory), so parallel tests that write to it can collide; use a unique per-test location such as 'TestContext.TestTempDirectory'</source>
        <target state="translated">Путь "{0}" — это фиксированное расположение, используемое каждым тестом в сборке (и, если он относительный, разрешается относительно текущего глобального каталога процесса), поэтому параллельные тесты, записывающие в него данные, могут конфликтовать; используйте уникальное расположение для каждого теста, например, "TestContext.TestTempDirectory"</target>
        <note>{0} is the offending path literal. {Locked="TestContext.TestTempDirectory"}</note>
      </trans-unit>
      <trans-unit id="SharedFileSystemPathInTestTitle">
        <source>Avoid hardcoded or shared filesystem paths in a parallelized test</source>
        <target state="translated">В параллельных тестах следует избегать жестко заданных или совместно используемых путей к файловой системе</target>
        <note />
      </trans-unit>
      <trans-unit id="StringAssertToAssertDescription">
        <source>'StringAssert' methods have equivalent 'Assert' counterparts. Using one assertion API improves consistency and discoverability.</source>
        <target state="new">'StringAssert' methods have equivalent 'Assert' counterparts. Using one assertion API improves consistency and discoverability.</target>
        <note>{Locked="'StringAssert'"}{Locked="'Assert'"}{Locked="API"}</note>
      </trans-unit>
      <trans-unit id="StringAssertToAssertMessageFormat">
        <source>Use 'Assert.{0}' instead of 'StringAssert.{1}'</source>
        <target state="translated">Используйте "Assert.{0}" вместо "StringAssert.{1}"</target>
        <note>{0} is the preferred Assert method name. {1} is the current StringAssert method name. {Locked="StringAssert"}{Locked="Assert"}</note>
      </trans-unit>
      <trans-unit id="StringAssertToAssertTitle">
        <source>Use 'Assert' instead of 'StringAssert'</source>
        <target state="translated">Используйте "Assert" вместо "StringAssert"</target>
        <note>{Locked="StringAssert"}{Locked="Assert"}</note>
      </trans-unit>
      <trans-unit id="TestClassShouldBeValidMessageFormat">
        <source>Test class '{0}' should be valid</source>
        <target state="translated">Тестовый class "{0}" должен быть допустимым</target>
        <note>{0} is the test class name. {Locked="class"}</note>
      </trans-unit>
      <trans-unit id="TestContextShouldBeValidMessageFormat">
        <source>Property 'TestContext' should be valid</source>
        <target state="translated">Свойство "TestContext" должно быть допустимым</target>
        <note>{Locked="TestContext"}</note>
      </trans-unit>
      <trans-unit id="TestFilterProviderShouldBeValidDescription">
        <source>'[assembly: TestFilterProvider(typeof(MyFilter))]' passes the filter type as a 'Type', so the compiler accepts any type at all. The adapter validates it only when it materializes the filter, and then fails the whole run. The referenced type must be non-generic and instantiable, implement 'ITestFilter' and expose a public parameterless constructor, and at most one provider may be registered per test assembly. When targeting .NET, the generic '[assembly: TestFilterProvider&lt;MyFilter&gt;]' form enforces the interface and constructor requirements through generic constraints instead.</source>
        <target state="translated">"[assembly: TestFilterProvider(typeof(MyFilter))]" передает тип фильтра как "Type", поэтому компилятор принимает любой тип. Адаптер проверяет его только при материализации фильтра, а затем завершает сбоем весь запуск. Указанный по ссылке тип должен быть неуниверсальным, допускающим создание экземпляра, реализовывать "ITestFilter" и предоставлять общедоступный конструктор без параметров. Кроме того, для одной тестовой сборки можно зарегистрировать не более одного поставщика. При нацеливании на .NET универсальная форма "[assembly: TestFilterProvider&lt;MyFilter&gt;]" вместо этого обеспечивает соблюдение требований к интерфейсу и конструктору с помощью универсальных ограничений.</target>
        <note>{Locked="[assembly: TestFilterProvider(typeof(MyFilter))]"}{Locked="[assembly: TestFilterProvider&lt;MyFilter&gt;]"}{Locked="Type"}{Locked="ITestFilter"}</note>
      </trans-unit>
      <trans-unit id="TestFilterProviderShouldBeValidMessageFormat_Generic">
        <source>'[TestFilterProvider]' references generic type '{0}'; the test filter type must not be generic</source>
        <target state="translated">"[TestFilterProvider]" ссылается на универсальный тип "{0}"; тип фильтра тестов не должен быть универсальным</target>
        <note>{0} is the referenced type name. {Locked="[TestFilterProvider]"}</note>
      </trans-unit>
      <trans-unit id="TestFilterProviderShouldBeValidMessageFormat_Multiple">
        <source>The assembly registers more than one '[TestFilterProvider]'; at most one is allowed per test assembly, so compose the filtering strategies inside a single 'ITestFilter' implementation</source>
        <target state="translated">Сборка регистрирует более одного элемента "[TestFilterProvider]"; в каждой тестовой сборке допускается только один, поэтому разместите стратегии фильтрации в одной реализации 'ITestFilter'</target>
        <note>{Locked="[TestFilterProvider]"}{Locked="ITestFilter"}</note>
      </trans-unit>
      <trans-unit id="TestFilterProviderShouldBeValidMessageFormat_NoParameterlessConstructor">
        <source>'[TestFilterProvider]' references type '{0}', which does not declare a public parameterless constructor</source>
        <target state="translated">"[TestFilterProvider]" ссылается на тип "{0}", который не объявляет общедоступный конструктор без параметров</target>
        <note>{0} is the referenced type name. {Locked="[TestFilterProvider]"}</note>
      </trans-unit>
      <trans-unit id="TestFilterProviderShouldBeValidMessageFormat_NotATestFilter">
        <source>'[TestFilterProvider]' references type '{0}', which does not implement 'ITestFilter'</source>
        <target state="translated">"[TestFilterProvider]" ссылается на тип "{0}", который не реализует "ITestFilter"</target>
        <note>{0} is the referenced type name. {Locked="[TestFilterProvider]"}{Locked="ITestFilter"}</note>
      </trans-unit>
      <trans-unit id="TestFilterProviderShouldBeValidMessageFormat_NotInstantiable">
        <source>'[TestFilterProvider]' references type '{0}', which cannot be instantiated</source>
        <target state="translated">"[TestFilterProvider]" ссылается на тип "{0}", который невозможно создать</target>
        <note>{0} is the referenced type name. {Locked="[TestFilterProvider]"}</note>
      </trans-unit>
      <trans-unit id="TestFilterProviderShouldBeValidMessageFormat_Null">
        <source>'[TestFilterProvider]' is given a null filter type; pass the 'ITestFilter' implementation to run, for example 'typeof(MyFilter)'</source>
        <target state="translated">Для "[TestFilterProvider]" задан тип фильтра null; передайте реализацию "ITestFilter" для запуска, например "typeof(MyFilter)"</target>
        <note>{Locked="[TestFilterProvider]"}{Locked="ITestFilter"}{Locked="typeof(MyFilter)"}</note>
      </trans-unit>
      <trans-unit id="TestFilterProviderShouldBeValidTitle">
        <source>'[TestFilterProvider]' should reference a valid test filter type</source>
        <target state="translated">"[TestFilterProvider]" должен ссылаться на допустимый тип фильтра тестов</target>
        <note>{Locked="[TestFilterProvider]"}</note>
      </trans-unit>
      <trans-unit id="TestMethodAttributeShouldPropagateSourceInformationDescription">
        <source>Propagating the source file and line number allows MSTest to report accurate diagnostics, test results, and Test Explorer navigation.</source>
        <target state="new">Propagating the source file and line number allows MSTest to report accurate diagnostics, test results, and Test Explorer navigation.</target>
        <note>{Locked="MSTest"}{Locked="Test Explorer"}</note>
      </trans-unit>
      <trans-unit id="TestMethodAttributeShouldPropagateSourceInformationMessageFormat">
        <source>TestMethodAttribute derived class '{0}' should add CallerFilePath and CallerLineNumber parameters to its constructor</source>
        <target state="translated">Производный class TestMethodAttribute "{0}" должен добавить параметры CallerFilePath и CallerLineNumber в свой конструктор</target>
        <note>{0} is the derived TestMethodAttribute class name. {Locked="TestMethodAttribute"}{Locked="CallerLineNumber"}{Locked="CallerFilePath"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="TestMethodAttributeShouldPropagateSourceInformationTitle">
        <source>TestMethodAttribute derived class should propagate source information</source>
        <target state="translated">Производный class TestMethodAttribute должен распространять сведения об источнике</target>
        <note>{Locked="TestMethodAttribute"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="TestMethodAttributeShouldSetDisplayNameCorrectlyDescription">
        <source>In MSTest 4 and later, the string constructor argument represents the caller file path rather than the test display name.</source>
        <target state="new">In MSTest 4 and later, the string constructor argument represents the caller file path rather than the test display name.</target>
        <note>{Locked="MSTest 4"}</note>
      </trans-unit>
      <trans-unit id="TestMethodAttributeShouldSetDisplayNameCorrectlyMessageFormat">
        <source>Use the 'DisplayName' property instead of passing a string argument to TestMethodAttribute</source>
        <target state="translated">Используйте свойство DisplayName вместо передачи строкового аргумента в TestMethodAttribute</target>
        <note>{Locked="TestMethodAttribute"}{Locked="DisplayName"}</note>
      </trans-unit>
      <trans-unit id="TestMethodAttributeShouldSetDisplayNameCorrectlyTitle">
        <source>TestMethodAttribute should set DisplayName correctly</source>
        <target state="translated">TestMethodAttribute должен корректно задавать DisplayName</target>
        <note>{Locked="TestMethodAttribute"}{Locked="DisplayName"}</note>
      </trans-unit>
      <trans-unit id="TestMethodShouldBeValidMessageFormat">
        <source>Test method '{0}' signature is invalid</source>
        <target state="translated">Подпись тестового метода "{0}" недействительна</target>
        <note>{0} is the method name.</note>
      </trans-unit>
      <trans-unit id="UndeclaredProcessGlobalStateMutationDescription">
        <source>Mutating process-global state (such as environment variables or the console redirection) from a test is unsafe once in-assembly parallelization is enabled, because a sibling test running concurrently observes the mutation. Unlike '[ResourceLock]', which fails open when a key is forgotten, this rule flags the mutation at compile time. Declare '[ResourceLock]' with the matching 'WellKnownResources' key to serialize contending tests, or '[DoNotParallelize]' to opt the test out of parallelization.</source>
        <target state="translated">Изменение глобального состояния процесса (например, переменных окружения или перенаправления консоли) из теста небезопасно после включения параллелизации внутри сборки, поскольку параллельно выполняющийся тест отслеживает это изменение. В отличие от "[ResourceLock]", который отключает блокировку при забывании ключа, это правило помечает изменение во время компиляции. Объявите "[ResourceLock]" с соответствующим ключом "WellKnownResources" для сериализации конкурирующих тестов или "[DoNotParallelize]", чтобы исключить тест из распараллеливания.</target>
        <note>{Locked="[ResourceLock]"}{Locked="WellKnownResources"}{Locked="[DoNotParallelize]"}</note>
      </trans-unit>
      <trans-unit id="UndeclaredProcessGlobalStateMutationMessageFormat">
        <source>'{0}' mutates process-global state and is unsafe when tests run in parallel; declare '[ResourceLock(WellKnownResources.{1})]' on the test (or '[DoNotParallelize]')</source>
        <target state="translated">"{0}" изменяет глобальное состояние процесса и небезопасен при параллельном выполнении тестов; объявите "[ResourceLock(WellKnownResources.{1})]" для теста (или "[DoNotParallelize]")</target>
        <note>{0} is the mutated API (for example 'Environment.SetEnvironmentVariable'). {1} is a 'WellKnownResources' member name. {Locked="[ResourceLock]"}{Locked="WellKnownResources"}{Locked="[DoNotParallelize]"}</note>
      </trans-unit>
      <trans-unit id="UndeclaredProcessGlobalStateMutationTitle">
        <source>Test mutating process-global state should declare a resource lock</source>
        <target state="translated">Проверка изменения глобального состояния процесса должна включать объявление блокировки ресурса</target>
        <note />
      </trans-unit>
      <trans-unit id="UseArchitectureConditionAttributeInsteadOfRuntimeCheckDescription">
        <source>Test methods that compare 'RuntimeInformation.ProcessArchitecture' and then early return or call 'Assert.Inconclusive' should use the '[ArchitectureCondition]' attribute instead. This attribute provides a more declarative and discoverable way to specify architecture-specific test requirements, and it reports the test as skipped rather than passed, which an early return does not.</source>
        <target state="translated">Методы тестов, которые сравнивают "RuntimeInformation.ProcessArchitecture" и выполняют ранний возврат или вызывают "Assert.Inconclusive", должны вместо этого использовать атрибут "[ArchitectureCondition]". Этот атрибут позволяет более декларативно и наглядно указать требования к тестам для конкретной архитектуры, и он регистрирует тест как пропущенный, а не как пройденный, что не происходит при раннем возврате.</target>
        <note>{Locked="RuntimeInformation.ProcessArchitecture"}{Locked="Assert.Inconclusive"}{Locked="[ArchitectureCondition]"}</note>
      </trans-unit>
      <trans-unit id="UseArchitectureConditionAttributeInsteadOfRuntimeCheckMessageFormat">
        <source>Use '[ArchitectureCondition]' attribute instead of 'RuntimeInformation.ProcessArchitecture' checks with early return or 'Assert.Inconclusive'</source>
        <target state="translated">Используйте атрибут "[ArchitectureCondition]" вместо проверок "RuntimeInformation.ProcessArchitecture" с ранним возвратом или "Assert.Inconclusive"</target>
        <note>{Locked="RuntimeInformation.ProcessArchitecture"}{Locked="Assert.Inconclusive"}{Locked="[ArchitectureCondition]"}</note>
      </trans-unit>
      <trans-unit id="UseArchitectureConditionAttributeInsteadOfRuntimeCheckTitle">
        <source>Use '[ArchitectureCondition]' attribute instead of 'RuntimeInformation.ProcessArchitecture' checks with early return or 'Assert.Inconclusive'</source>
        <target state="translated">Используйте атрибут "[ArchitectureCondition]" вместо проверок "RuntimeInformation.ProcessArchitecture" с ранним возвратом или "Assert.Inconclusive"</target>
        <note>{Locked="RuntimeInformation.ProcessArchitecture"}{Locked="Assert.Inconclusive"}{Locked="[ArchitectureCondition]"}</note>
      </trans-unit>
      <trans-unit id="UseAttributeOnTestMethodAnalyzerDescription">
        <source>MSTest ignores these attributes outside a test context.</source>
        <target state="new">MSTest ignores these attributes outside a test context.</target>
        <note>{Locked="MSTest"}</note>
      </trans-unit>
      <trans-unit id="UseCIConditionAttributeInsteadOfEnvironmentCheckDescription">
        <source>Test methods that null-check the 'CI' environment variable and then early return or call 'Assert.Inconclusive' should use the '[CICondition]' attribute instead. This attribute recognizes all the continuous integration providers MSTest knows about and parses their values, and it reports the test as skipped rather than passed, which an early return does not.</source>
        <target state="translated">Методы тестов, которые проверяют переменную среды "CI" на наличие значения null и выполняют ранний возврат или вызывают или вызывают "Assert.Inconclusive", должны вместо этого использовать атрибут "[CICondition]". Этот атрибут распознает всех известных MSTest поставщиков непрерывной интеграции и рассматривает их значения, а также регистрирует тест как пропущенный, а не пройденный, что не происходит при раннем возврате.</target>
        <note>{Locked="CI"}{Locked="Assert.Inconclusive"}{Locked="[CICondition]"}</note>
      </trans-unit>
      <trans-unit id="UseCIConditionAttributeInsteadOfEnvironmentCheckMessageFormat">
        <source>Use '[CICondition]' attribute instead of 'Environment.GetEnvironmentVariable' checks with early return or 'Assert.Inconclusive'</source>
        <target state="translated">Используйте атрибут "[CICondition]" вместо проверок "Environment.GetEnvironmentVariable" с ранним возвратом или "Assert.Inconclusive"</target>
        <note>{Locked="Environment.GetEnvironmentVariable"}{Locked="Assert.Inconclusive"}{Locked="[CICondition]"}</note>
      </trans-unit>
      <trans-unit id="UseCIConditionAttributeInsteadOfEnvironmentCheckTitle">
        <source>Use '[CICondition]' attribute instead of 'Environment.GetEnvironmentVariable' checks with early return or 'Assert.Inconclusive'</source>
        <target state="translated">Используйте атрибут "[CICondition]" вместо проверок "Environment.GetEnvironmentVariable" с ранним возвратом или "Assert.Inconclusive"</target>
        <note>{Locked="Environment.GetEnvironmentVariable"}{Locked="Assert.Inconclusive"}{Locked="[CICondition]"}</note>
      </trans-unit>
      <trans-unit id="UseCancellationTokenPropertyDescription">
        <source>TestContext.CancellationToken provides a more direct way to access the cancellation token compared to TestContext.CancellationTokenSource.Token.</source>
        <target state="translated">TestContext.CancellationToken предоставляет более прямой доступ к маркеру отмены по сравнению с TestContext.CancellationTokenSource.Token.</target>
        <note>{Locked="TestContext.CancellationTokenSource.Token"}{Locked="TestContext.CancellationToken"}</note>
      </trans-unit>
      <trans-unit id="UseCancellationTokenPropertyMessageFormat">
        <source>Use 'TestContext.CancellationToken' instead of 'TestContext.CancellationTokenSource.Token'</source>
        <target state="translated">Используйте "TestContext.CancellationToken" вместо "TestContext.CancellationTokenSource.Token"</target>
        <note>{Locked="TestContext.CancellationTokenSource.Token"}{Locked="TestContext.CancellationToken"}</note>
      </trans-unit>
      <trans-unit id="UseCancellationTokenPropertyTitle">
        <source>Use TestContext.CancellationToken instead of TestContext.CancellationTokenSource.Token</source>
        <target state="translated">Используйте TestContext.CancellationToken вместо TestContext.CancellationTokenSource.Token</target>
        <note>{Locked="TestContext.CancellationTokenSource.Token"}{Locked="TestContext.CancellationToken"}</note>
      </trans-unit>
      <trans-unit id="TestClassShouldBeValidDescription">
        <source>Test classes, classes marked with the '[TestClass]' attribute, should respect the following layout to be considered valid by MSTest:
- it should be 'public' (or 'internal' if '[assembly: DiscoverInternals]' attribute is set)
- it should not be 'static' (except if it contains only 'AssemblyInitialize' and/or 'AssemblyCleanup' methods)
- it should not be generic.</source>
        <target state="translated">В тестовых классах (с атрибутом "[TestClass]") должна быть следующая структура, чтобы эти классы считались допустимыми для MSTest:
- у класса должно быть свойство "public" (или "internal", если задан атрибут "[assembly: DiscoverInternals]")
- у класс не должно быть свойства "static" (кроме случаев, когда класс содержит только методы "AssemblyInitialize" и "AssemblyCleanup")
- класс не должен быть универсальным.</target>
        <note>{Locked="AssemblyInitialize"}{Locked="AssemblyCleanup"}{Locked="[TestClass]"}{Locked="MSTest"}{Locked="public"}{Locked="internal"}{Locked="static"}</note>
      </trans-unit>
      <trans-unit id="TestClassShouldBeValidTitle">
        <source>Test classes should have valid layout</source>
        <target state="translated">Тестовые классы должны использовать допустимую структуру</target>
        <note />
      </trans-unit>
      <trans-unit id="TestClassShouldHaveTestMethodDescription">
        <source>Test class should have at least one test method or be 'static' with method(s) marked by '[AssemblyInitialize]' and/or '[AssemblyCleanup]'.</source>
        <target state="translated">Тестовый class должен содержать хотя бы один тестовый метод или быть "static" с методами, отмеченными "[AssemblyInitialize]" и (или) "[AssemblyCleanup]".</target>
        <note>{Locked="[AssemblyInitialize]"}{Locked="[AssemblyCleanup]"}{Locked="static"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="TestClassShouldHaveTestMethodMessageFormat">
        <source>Test class '{0}' should have at least one test method or be 'static' with method(s) marked by '[AssemblyInitialize]' and/or '[AssemblyCleanup]'</source>
        <target state="translated">Тестовый class "{0}" должен содержать хотя бы один тестовый метод или быть "static" с методами, отмеченными "[AssemblyInitialize]" и (или) "[AssemblyCleanup]"</target>
        <note>{0} is the test class name. {Locked="[AssemblyInitialize]"}{Locked="[AssemblyCleanup]"}{Locked="static"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="TestClassShouldHaveTestMethodTitle">
        <source>Test class should have test method</source>
        <target state="translated">Тестовый class должен содержать тестовый метод</target>
        <note>{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="TestCleanupShouldBeValidDescription">
        <source>Methods marked with '[TestCleanup]' should follow the following layout to be valid:
-it should be 'public'
-it should not be 'abstract'
-it should not be 'async void'
-it should not be 'static'
-it should not be a special method (finalizer, operator...).
-it should not be generic
-it should not take any parameter
-return type should be 'void', 'Task' or 'ValueTask'

The type declaring these methods should also respect the following rules:
-The type should be a class
-The class should be 'public' or 'internal' (if the test project is using the '[DiscoverInternals]' attribute)
-The class shouldn't be 'static'
-If the class is 'sealed', it should be marked with '[TestClass]' (or a derived attribute).</source>
        <target state="translated">Чтобы метод, помеченный "[TestCleanup]", был допустимым, он должен соответствовать следующим правилам:
– быть общедоступным ("public")
;
– не быть абстрактным ("abstract")
;
– не быть асинхронным и не возвращающим значения ("async void")
– не быть статическим ("static")
– не быть специальным (метод завершения, оператор…).
– не быть общим ("generic")
;
– не принимать никаких параметров;
– тип возвращаемого значения должен быть "void", "Task" или "ValueTask";

Тип, объявляющий такие методы, также должен соответствовать следующим правилам:
– должен быть class;
– class должен быть объявлен как "public" или "internal" (если тестовый проект использует атрибут "[DiscoverInternals]");
– class должен быть статическим ("static");
– если class sealed, его следует пометить как "[TestClass]" (или производный атрибут).</target>
        <note>{Locked="[DiscoverInternals]"}{Locked="[TestCleanup]"}{Locked="[TestClass]"}{Locked="ValueTask"}{Locked="Task"}{Locked="public"}{Locked="internal"}{Locked="static"}{Locked="void"}{Locked="async void"}{Locked="abstract"}{Locked="sealed"}{Locked="async"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="TestCleanupShouldBeValidMessageFormat">
        <source>TestCleanup method '{0}' signature is invalid</source>
        <target state="translated">Подпись метода TestCleanup "{0}" недопустима</target>
        <note>{0} is the method name. {Locked="TestCleanup"}</note>
      </trans-unit>
      <trans-unit id="TestCleanupShouldBeValidTitle">
        <source>TestCleanup method should have valid layout</source>
        <target state="translated">Метод TestCleanup должен использовать допустимый макет</target>
        <note>{Locked="TestCleanup"}</note>
      </trans-unit>
      <trans-unit id="TestContextShouldBeValidDescription">
        <source>'TestContext' should be a non-static property assigned in constructor or set by MSTest. To be set by MSTest, it should follow the layout:
- it should be 'public' regardless of whether '[assembly: DiscoverInternals]' attribute is set or not.
- it should not be 'static'
- it should have a setter.</source>
        <target state="translated">"TestContext" должно быть non-static свойством, инициализируемым в конструкторе или устанавливаемым MSTest. Для установки с помощью MSTest, оно должен соответствовать следующей структуре:
— оно должно быть объявлено как "public", независимо от того, задан ли атрибут "[assembly: DiscoverInternals]".
— оно не может быть объявлено как "static";
— для него должен быть определен метод задания.</target>
        <note>{Locked="TestContext"}{Locked="MSTest"}{Locked="public"}{Locked="static"}</note>
      </trans-unit>
      <trans-unit id="TestContextShouldBeValidTitle">
        <source>Test context property should have valid layout</source>
        <target state="translated">Тестовое контекстное свойство должно использовать допустимый макет</target>
        <note />
      </trans-unit>
      <trans-unit id="TestInitializeShouldBeValidDescription">
        <source>Methods marked with '[TestInitialize]' should follow the following layout to be valid:
-it should be 'public'
-it should not be 'abstract'
-it should not be 'async void'
-it should not be 'static'
-it should not be a special method (finalizer, operator...).
-it should not be generic
-it should not take any parameter
-return type should be 'void', 'Task' or 'ValueTask'

The type declaring these methods should also respect the following rules:
-The type should be a class
-The class should be 'public' or 'internal' (if the test project is using the '[DiscoverInternals]' attribute)
-The class shouldn't be 'static'
-If the class is 'sealed', it should be marked with '[TestClass]' (or a derived attribute).</source>
        <target state="translated">Чтобы метод, помеченный "[TestInitialize]", был допустимым, он должен соответствовать следующим правилам:
– быть общедоступным ("public")
;
– не быть абстрактным ("abstract")
;
– не быть асинхронным и не возвращающим значения ("async void")
– не быть статическим ("static")
– не быть специальным (метод завершения, оператор…).
– не быть общим ("generic")
;
– не принимать никаких параметров;
– тип возвращаемого значения должен быть "void", "Task" или "ValueTask";

Тип, объявляющий такие методы, также должен соответствовать следующим правилам:
– должен быть class;
– class должен быть объявлен как "public" или "internal" (если тестовый проект использует атрибут "[DiscoverInternals]");
– class должен быть статическим ("static");
– если class sealed, его следует пометить как "[TestClass]" (или производный атрибут).</target>
        <note>{Locked="[DiscoverInternals]"}{Locked="[TestInitialize]"}{Locked="[TestClass]"}{Locked="ValueTask"}{Locked="Task"}{Locked="public"}{Locked="internal"}{Locked="static"}{Locked="void"}{Locked="async void"}{Locked="abstract"}{Locked="sealed"}{Locked="async"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="TestInitializeShouldBeValidMessageFormat">
        <source>TestInitialize method '{0}' signature is invalid</source>
        <target state="translated">Подпись метода TestInitialize "{0}" недопустима</target>
        <note>{0} is the method name. {Locked="TestInitialize"}</note>
      </trans-unit>
      <trans-unit id="TestInitializeShouldBeValidTitle">
        <source>TestInitialize method should have valid layout</source>
        <target state="translated">Метод TestInitialize должен использовать допустимый макет</target>
        <note>{Locked="TestInitialize"}</note>
      </trans-unit>
      <trans-unit id="TestMethodShouldBeValidDescription">
        <source>Test methods, methods marked with the '[TestMethod]' attribute, should respect the following layout to be considered valid by MSTest:
- it should be 'public' (or 'internal' if '[assembly: DiscoverInternals]' attribute is set)
- it should not be 'static'
- it should may be generic as long as type parameters can be inferred and argument types are compatible
- it should not be 'abstract'
- return type should be 'void', 'Task' or 'ValueTask'
- it should not be 'async void'
- it should not be a special method (finalizer, operator...).</source>
        <target state="translated">Методы теста (методы, помеченные атрибутом "[TestMethod]") должны соблюдать следующую структуру, чтобы считаться допустимыми в MSTest:
– должно быть присвоено значение "public" (или "internal", если задан атрибут "[assembly: DiscoverInternals]")
– не следует присваивать значение "static"
– могут быть универсальными, если можно вывести параметры типа, а типы аргументов являются совместимыми
– не следует присваивать значение "abstract"
– возвращаемый тип должен быть "void", "Task" или "ValueTask"
– не следует присваивать значение "async void"
– это должен быть специальный метод (метод завершения, оператор...).</target>
        <note>{Locked="[TestMethod]"}{Locked="ValueTask"}{Locked="MSTest"}{Locked="Task"}{Locked="public"}{Locked="internal"}{Locked="static"}{Locked="void"}{Locked="async void"}{Locked="abstract"}{Locked="async"}</note>
      </trans-unit>
      <trans-unit id="TestMethodShouldBeValidTitle">
        <source>Test methods should have valid layout</source>
        <target state="translated">Методы теста должны использовать допустимую структуру</target>
        <note />
      </trans-unit>
      <trans-unit id="TestMethodShouldNotBeIgnoredAnalyzerDescription">
        <source>Test methods should not be ignored (marked with '[Ignore]').</source>
        <target state="translated">Методы теста не должны игнорироваться (помечаться с помощью "[Ignore]").</target>
        <note>{Locked="[Ignore]"}</note>
      </trans-unit>
      <trans-unit id="TestMethodShouldNotBeIgnoredAnalyzerFormat">
        <source>Test method '{0}' should not be ignored</source>
        <target state="translated">Метод теста "{0}" не должен игнорироваться</target>
        <note>{0} is the method name.</note>
      </trans-unit>
      <trans-unit id="TestMethodShouldNotBeIgnoredAnalyzerTitle">
        <source>Test method should not be ignored</source>
        <target state="translated">Метод теста не должен игнорироваться</target>
        <note />
      </trans-unit>
      <trans-unit id="TypeContainingTestMethodShouldBeATestClassDescription">
        <source>Type containing '[TestMethod]' should be marked with '[TestClass]', otherwise the test method will be silently ignored.</source>
        <target state="translated">У типа, содержащего "[TestMethod]", должна быть пометка "[TestClass]", иначе метод тестирования будет проигнорирован без уведомления пользователя.</target>
        <note>{Locked="[TestMethod]"}{Locked="[TestClass]"}</note>
      </trans-unit>
      <trans-unit id="TypeContainingTestMethodShouldBeATestClassMessageFormat">
        <source>Type '{0}' contains test methods and should be marked with '[TestClass]'</source>
        <target state="translated">Тип "{0}" содержит тестовые методы и должен быть помечен как "[TestClass]"</target>
        <note>{0} is the type name. {Locked="[TestClass]"}</note>
      </trans-unit>
      <trans-unit id="TypeContainingTestMethodShouldBeATestClassTitle">
        <source>Type containing '[TestMethod]' should be marked with '[TestClass]'</source>
        <target state="translated">У типа, содержащего "[TestMethod]", должна быть пометка "[TestClass]"</target>
        <note>{Locked="[TestMethod]"}{Locked="[TestClass]"}</note>
      </trans-unit>
      <trans-unit id="UseAsyncSuffixTestFixtureMethodSuppressorJustification">
        <source>Asynchronous test fixture methods do not require the 'Async' suffix</source>
        <target state="translated">Методы Asynchronous средств тестирования не требуют суффикса 'Async'</target>
        <note>{Locked="'Async'"}</note>
      </trans-unit>
      <trans-unit id="UseAsyncSuffixTestMethodSuppressorJustification">
        <source>Asynchronous test methods do not require the 'Async' suffix</source>
        <target state="translated">Asynchronous методы теста не требуют суффикса 'Async'</target>
        <note>{Locked="'Async'"}</note>
      </trans-unit>
      <trans-unit id="UnusedParameterSuppressorJustification">
        <source>TestContext parameter is required by MSTest for AssemblyInitialize and ClassInitialize methods</source>
        <target state="translated">Параметр TestContext необходим для MSTest в методах AssemblyInitialize и ClassInitialize</target>
        <note>{Locked="AssemblyInitialize"}{Locked="ClassInitialize"}{Locked="TestContext"}{Locked="MSTest"}</note>
      </trans-unit>
      <trans-unit id="UseAttributeOnTestMethodAnalyzerMessageFormat">
        <source>[{0}] can only be set on methods marked with [TestMethod]</source>
        <target state="translated">[{0}] можно задать только для методов с пометкой [TestMethod]</target>
        <note>{0} is the attribute name without brackets. {Locked="[TestMethod]"}</note>
      </trans-unit>
      <trans-unit id="UseAttributeOnTestMethodAnalyzerTitle">
        <source>[{0}] can only be set on methods marked with [TestMethod]</source>
        <target state="translated">[{0}] можно задать только для методов с пометкой [TestMethod]</target>
        <note>{0} is the attribute name without brackets. {Locked="[TestMethod]"}</note>
      </trans-unit>
      <trans-unit id="UseConditionBaseWithTestClassDescription">
        <source>When applied to a class, MSTest evaluates condition attributes only if the class is a test class, so applying them to a non-test class has no effect.</source>
        <target state="new">When applied to a class, MSTest evaluates condition attributes only if the class is a test class, so applying them to a non-test class has no effect.</target>
        <note>{Locked="MSTest"}</note>
      </trans-unit>
      <trans-unit id="UseConditionBaseWithTestClassMessageFormat">
        <source>The attribute '{0}' which derives from 'ConditionBaseAttribute' should be used only on classes marked with `TestClassAttribute`</source>
        <target state="translated">Атрибут '{0}', производный от ConditionBaseAttribute, следует использовать только для классов, помеченных атрибутом TestClassAttribute</target>
        <note>{0} is the attribute name. {Locked="ConditionBaseAttribute"}{Locked="TestClassAttribute"}</note>
      </trans-unit>
      <trans-unit id="UseConditionBaseWithTestClassTitle">
        <source>Use 'ConditionBaseAttribute' on test classes</source>
        <target state="translated">Использовать ConditionBaseAttribute для тестовых классов</target>
        <note>{Locked="ConditionBaseAttribute"}</note>
      </trans-unit>
      <trans-unit id="UseCooperativeCancellationForTimeoutDescription">
        <source>Using '[Timeout]' without explicitly setting 'CooperativeCancellation = true' is discouraged. In a future version, cooperative cancellation will become the default behavior. Set 'CooperativeCancellation = true' to opt into the recommended behavior and avoid breaking changes.</source>
        <target state="translated">Использование "[Timeout]" без явной настройки "CooperativeCancellation = true" не рекомендуется. В будущей версии кооперативная отмена станет поведением по умолчанию. Настройте "CooperativeCancellation = true", чтобы согласиться с рекомендуемым поведением и избежать критических изменений.</target>
        <note>{Locked="CooperativeCancellation = true"}{Locked="[Timeout]"}{Locked="true"}</note>
      </trans-unit>
      <trans-unit id="UseCooperativeCancellationForTimeoutMessageFormat">
        <source>Use 'CooperativeCancellation = true' with '[Timeout]' to enable cooperative cancellation behavior</source>
        <target state="translated">Используйте "CooperativeCancellation = true" с "[Timeout]", чтобы включить поведение кооперативной отмены</target>
        <note>{Locked="CooperativeCancellation = true"}{Locked="[Timeout]"}{Locked="true"}</note>
      </trans-unit>
      <trans-unit id="UseCooperativeCancellationForTimeoutTitle">
        <source>Use 'CooperativeCancellation = true' with '[Timeout]'</source>
        <target state="translated">Использовать "CooperativeCancellation = true" с "[Timeout]"</target>
        <note>{Locked="CooperativeCancellation = true"}{Locked="[Timeout]"}{Locked="true"}</note>
      </trans-unit>
      <trans-unit id="UseDeploymentItemWithTestMethodOrTestClassDescription">
        <source>MSTest ignores '[DeploymentItem]' when it is applied outside a test class or test method.</source>
        <target state="new">MSTest ignores '[DeploymentItem]' when it is applied outside a test class or test method.</target>
        <note>{Locked="MSTest"}{Locked="'[DeploymentItem]'"}</note>
      </trans-unit>
      <trans-unit id="UseDeploymentItemWithTestMethodOrTestClassMessageFormat">
        <source>'[DeploymentItem]' can be specified only on test class or test method</source>
        <target state="translated">Указать "[DeploymentItem]" можно только для тестового class или метода.</target>
        <note>{Locked="[DeploymentItem]"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="UseDeploymentItemWithTestMethodOrTestClassTitle">
        <source>'[DeploymentItem]' can be specified only on test class or test method</source>
        <target state="translated">Указать "[DeploymentItem]" можно только для тестового class или метода.</target>
        <note>{Locked="[DeploymentItem]"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="UseParallelizeAttributeAnalyzerDescription">
        <source>By default, MSTest runs tests within the same assembly sequentially, which can lead to severe performance limitations. It is recommended to enable assembly attribute '[Parallelize]' to run tests in parallel, or if the assembly is known to not be parallelizable, to use explicitly the assembly level attribute '[DoNotParallelize]'.</source>
        <target state="translated">По умолчанию MSTest выполняет тесты в одной сборке последовательно, что может привести к серьезному ограничению производительности. Рекомендуется включить атрибут сборки "[Parallelize]", чтобы выполнять тесты параллельно, или явно использовать атрибут уровня сборки "[DoNotParallelize]", если известно, что сборка не поддерживает параллелизацию.</target>
        <note>{Locked="[DoNotParallelize]"}{Locked="[Parallelize]"}{Locked="MSTest"}</note>
      </trans-unit>
      <trans-unit id="UseParallelizeAttributeAnalyzerMessageFormat">
        <source>Explicitly enable or disable tests parallelization</source>
        <target state="translated">Явное включение или отключение параллелизации тестов</target>
        <note />
      </trans-unit>
      <trans-unit id="UseParallelizeAttributeAnalyzerTitle">
        <source>Explicitly enable or disable tests parallelization</source>
        <target state="translated">Явное включение или отключение параллелизации тестов</target>
        <note />
      </trans-unit>
      <trans-unit id="UseProperAssertMethodsDescription">
        <source>Specialized assertion methods improve readability and provide more precise failure diagnostics.</source>
        <target state="new">Specialized assertion methods improve readability and provide more precise failure diagnostics.</target>
        <note />
      </trans-unit>
      <trans-unit id="UseProperAssertMethodsMessageFormat">
        <source>Use 'Assert.{0}' instead of 'Assert.{1}'</source>
        <target state="translated">Используйте "Assert.{0}" вместо "Assert.{1}"</target>
        <note>{0} is the preferred assert method name. {1} is the current assert method name. {Locked="Assert"}</note>
      </trans-unit>
      <trans-unit id="UseProperAssertMethodsTitle">
        <source>Use proper 'Assert' methods</source>
        <target state="translated">Используйте правильные методы "Assert"</target>
        <note>{Locked="Assert"}</note>
      </trans-unit>
      <trans-unit id="UseRetryWithTestMethodDescription">
        <source>Retry attributes have no effect on methods or classes that MSTest does not recognize as tests.</source>
        <target state="new">Retry attributes have no effect on methods or classes that MSTest does not recognize as tests.</target>
        <note>{Locked="MSTest"}</note>
      </trans-unit>
      <trans-unit id="UseRetryWithTestMethodMessageFormat">
        <source>An attribute that derives from 'RetryBaseAttribute' can be specified only on a test method or a test class</source>
        <target state="translated">Атрибут, наследуемый от "RetryBaseAttribute", может быть указан только для тестового метода или тестового class</target>
        <note>{Locked="RetryBaseAttribute"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="UseRetryWithTestMethodTitle">
        <source>Use retry attribute on test method or test class</source>
        <target state="translated">Используйте атрибут "retry" для тестового метода или тестового class</target>
        <note>{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="TestContextPropertyUsageTitle">
        <source>TestContext property cannot be accessed in this context</source>
        <target state="translated">Свойство TestContext недоступно в этом контексте</target>
        <note>{Locked="TestContext"}</note>
      </trans-unit>
      <trans-unit id="TestContextPropertyUsageMessageFormat">
        <source>TestContext property '{0}' cannot be accessed in '{1}' method</source>
        <target state="translated">Свойство TestContext "{0}" недоступно в методе "{1}"</target>
        <note>{0} is the TestContext property name. {1} is the lifecycle method name. {Locked="TestContext"}</note>
      </trans-unit>
      <trans-unit id="TestContextPropertyUsageDescription">
        <source>Some TestContext properties are only available during test execution and cannot be accessed in assembly initialize, class initialize, class cleanup, or assembly cleanup methods.</source>
        <target state="translated">Некоторые свойства TestContext доступны только во время выполнения теста и недоступны в методах инициализации сборки, инициализации class, очистки class или очистки сборки.</target>
        <note>{Locked="TestContext"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="AssertThrowsShouldContainSingleStatementDescription">
        <source>Assert.Throws methods should contain only a single statement or expression. Multiple statements can be misleading - if the first statement throws, subsequent statements are never executed; if it doesn't throw, it should be moved outside the Assert.Throws.</source>
        <target state="translated">Методы Assert.Throws должны содержать только одну инструкцию или выражение. Несколько инструкций могут вводить в заблуждение: если первое выражение вызывает исключение, последующие инструкции не выполняются; если исключение не возникает, его следует вынести за пределы Assert.Throws.</target>
        <note>{Locked="Assert.Throws"}</note>
      </trans-unit>
      <trans-unit id="AssertThrowsShouldContainSingleStatementMessageFormat">
        <source>Assert.Throws should contain only a single statement/expression</source>
        <target state="translated">Assert.Throws должен содержать только одну инструкцию/выражение</target>
        <note>{Locked="Assert.Throws"}</note>
      </trans-unit>
      <trans-unit id="AssertThrowsShouldContainSingleStatementTitle">
        <source>Assert.Throws should contain only a single statement/expression</source>
        <target state="translated">Assert.Throws должен содержать только одну инструкцию/выражение</target>
        <note>{Locked="Assert.Throws"}</note>
      </trans-unit>
      <trans-unit id="AvoidAssertsInCatchBlocksTitle">
        <source>Do not use asserts in catch blocks</source>
        <target state="translated">Не используйте утверждения в блоках catch</target>
        <note>{Locked="catch"}</note>
      </trans-unit>
      <trans-unit id="AvoidAssertsInCatchBlocksMessageFormat">
        <source>Do not use asserts in catch blocks because they may not fail the test if no exception is thrown</source>
        <target state="translated">Не используйте утверждения в блоках catch, так как с ними тест может не завершаться сбоем, если не возникает исключение</target>
        <note>{Locked="catch"}</note>
      </trans-unit>
      <trans-unit id="AvoidAssertsInCatchBlocksDescription">
        <source>Using asserts in catch blocks is problematic because the test will pass even if no exception is thrown and the catch block is never executed. Use 'Assert.Throws', 'Assert.ThrowsExactly', 'Assert.ThrowsAsync' or 'Assert.ThrowsExactlyAsync' to verify that an exception is thrown, and then make additional assertions on the caught exception without using the try-catch block. The rule also flags 'throw new AssertFailedException(...)' and 'throw new AssertInconclusiveException(...)' (the desugared forms of 'Assert.Fail' and 'Assert.Inconclusive'). 'Assert.Inconclusive' (and 'throw new AssertInconclusiveException(...)') is exempt when used inside a filtered catch ('catch (...) when (...)'), because demoting a caught failure to an Inconclusive outcome is the only use case that cannot be expressed without a catch block. For other intentional bypasses (for example, attaching a runtime-built message to the failure), suppress the diagnostic with '#pragma warning disable MSTEST0058'.</source>
        <target state="translated">Использование утверждений в блоках catch является проблематичным, так как тест будет пройден, даже если не возникает исключение, а блок catch не выполняется. Используйте "Assert.Throws", "Assert.ThrowsExactly", "Assert.ThrowsAsync" или "Assert.ThrowsExactlyAsync" для проверки возникновения исключения, а затем выполните дополнительные утверждения перехваченного исключения без применения блока try-catch. Это правило также помечает конструкции "throw new AssertFailedException(...)" и "throw new AssertInconclusiveException(...)" (десахаризованные формы "Assert.Fail" и "Assert.Inconclusive"). Вызов "Assert.Inconclusive" (а также "throw new AssertInconclusiveException(...)") является исключением при использовании внутри фильтрующего блока "catch" ("catch (...) when (...)"), поскольку понижение статуса перехваченного сбоя до результата "Inconclusive" — это единственный сценарий использования, который невозможно реализовать без применения блока "catch". Для других намеренных обходов (например, прикрепления сообщения, сформированного во время выполнения) подавите диагностику с помощью "#pragma warning disable MSTEST0058".</target>
        <note>{Locked="#pragma warning disable MSTEST0058"}{Locked="AssertInconclusiveException"}{Locked="Assert.ThrowsExactlyAsync"}{Locked="AssertFailedException"}{Locked="Assert.ThrowsExactly"}{Locked="Assert.Inconclusive"}{Locked="Assert.ThrowsAsync"}{Locked="Assert.Throws"}{Locked="Assert.Fail"}{Locked="throw new AssertFailedException(...)"}{Locked="throw new AssertInconclusiveException(...)"}{Locked="catch"}</note>
      </trans-unit>
      <trans-unit id="DoNotUseParallelizeAndDoNotParallelizeTogetherDescription">
        <source>An assembly should have either '[Parallelize]' or '[DoNotParallelize]' attribute, but not both. Having both attributes creates an ambiguous configuration. When both are present, '[DoNotParallelize]' takes precedence and parallelization will be disabled.</source>
        <target state="translated">Сборка должна содержать либо атрибут "[Parallelize]", либо "[DoNotParallelize]", но не оба одновременно. Наличие обоих атрибутов создает неоднозначную конфигурацию. При наличии обоих атрибутов приоритет получает "[DoNotParallelize]", и параллелизация будет отключена.</target>
        <note>{Locked="[Parallelize]"}{Locked="[DoNotParallelize]"}</note>
      </trans-unit>
      <trans-unit id="DoNotUseParallelizeAndDoNotParallelizeTogetherMessageFormat">
        <source>Assembly has both '[Parallelize]' and '[DoNotParallelize]' attributes which creates ambiguity</source>
        <target state="translated">В сборке одновременно присутствуют атрибуты "[Parallelize]" и "[DoNotParallelize]", что создает неоднозначность</target>
        <note>{Locked="[Parallelize]"}{Locked="[DoNotParallelize]"}</note>
      </trans-unit>
      <trans-unit id="DoNotUseParallelizeAndDoNotParallelizeTogetherTitle">
        <source>Do not use both '[Parallelize]' and '[DoNotParallelize]' attributes</source>
        <target state="translated">Не используйте одновременно атрибуты "[Parallelize]" и "[DoNotParallelize]"</target>
        <note>{Locked="[Parallelize]"}{Locked="[DoNotParallelize]"}</note>
      </trans-unit>
      <trans-unit id="UseOSConditionAttributeInsteadOfRuntimeCheckTitle">
        <source>Use '[OSCondition]' attribute instead of 'RuntimeInformation.IsOSPlatform' calls with early return or 'Assert.Inconclusive'</source>
        <target state="translated">Используйте атрибут "[OSCondition]" вместо вызовов "RuntimeInformation.IsOSPlatform" с ранним возвратом или "Assert.Inconclusive"</target>
        <note>{Locked="RuntimeInformation.IsOSPlatform"}{Locked="Assert.Inconclusive"}{Locked="[OSCondition]"}</note>
      </trans-unit>
      <trans-unit id="UseOSConditionAttributeInsteadOfRuntimeCheckMessageFormat">
        <source>Use '[OSCondition]' attribute instead of 'RuntimeInformation.IsOSPlatform' calls with early return or 'Assert.Inconclusive'</source>
        <target state="translated">Используйте атрибут "[OSCondition]" вместо вызовов "RuntimeInformation.IsOSPlatform" с ранним возвратом или "Assert.Inconclusive"</target>
        <note>{Locked="RuntimeInformation.IsOSPlatform"}{Locked="Assert.Inconclusive"}{Locked="[OSCondition]"}</note>
      </trans-unit>
      <trans-unit id="UseOSConditionAttributeInsteadOfRuntimeCheckDescription">
        <source>Test methods that use 'RuntimeInformation.IsOSPlatform' with early return or 'Assert.Inconclusive' should use the '[OSCondition]' attribute instead. This attribute provides a more declarative and discoverable way to specify OS-specific test requirements.</source>
        <target state="translated">Методы тестирования, использующие "RuntimeInformation.IsOSPlatform" с ранним возвратом или "Assert.Inconclusive", должны вместо этого применять атрибут "[OSCondition]". Этот атрибут обеспечивает более декларативный и удобный для обнаружения способ указания требований к тестам, зависящим от операционной системы.</target>
        <note>{Locked="RuntimeInformation.IsOSPlatform"}{Locked="Assert.Inconclusive"}{Locked="[OSCondition]"}</note>
      </trans-unit>
      <trans-unit id="DuplicateTestMethodAttributeTitle">
        <source>Avoid duplicate test method attributes</source>
        <target state="translated">Избегайте дублирования атрибутов метода тестирования</target>
        <note />
      </trans-unit>
      <trans-unit id="DuplicateTestMethodAttributeMessageFormat">
        <source>Test method '{0}' has multiple attributes that inherit from 'TestMethodAttribute'. Only one test method attribute should be used.</source>
        <target state="translated">Метод тестирования "{0}" содержит несколько атрибутов, наследуемых от "TestMethodAttribute". Следует использовать только один атрибут метода тестирования.</target>
        <note>{0} is the test method name. {Locked="TestMethodAttribute"}</note>
      </trans-unit>
      <trans-unit id="DuplicateTestMethodAttributeDescription">
        <source>A test method should be marked with exactly one attribute that is or inherits from 'TestMethodAttribute'. When multiple such attributes are present, only the first one returned by reflection will be used.</source>
        <target state="translated">Метод тестирования должен быть помечен с помощью ровно одного атрибута, который наследуется от "TestMethodAttribute" или является им. Если присутствует несколько таких атрибутов, будет использован только первый, возвращенный с помощью рефлексии.</target>
        <note>{Locked="TestMethodAttribute"}</note>
      </trans-unit>
      <trans-unit id="AvoidOutRefTestMethodParametersTitle">
        <source>Avoid using 'out' or 'ref' parameters in test methods</source>
        <target state="translated">Избегайте использования параметров "out" или "ref" в тестовых методах</target>
        <note>{Locked="out"}{Locked="ref"}</note>
      </trans-unit>
      <trans-unit id="AvoidOutRefTestMethodParametersMessageFormat">
        <source>Test method '{0}' has 'out' or 'ref' parameters for which support will be dropped in a future major version</source>
        <target state="translated">Тестовый метод "{0}" содержит параметры "out" или "ref", поддержка которых будет прекращена в будущем основном номере версии</target>
        <note>{0} is the test method name. {Locked="out"}{Locked="ref"}</note>
      </trans-unit>
      <trans-unit id="AvoidOutRefTestMethodParametersDescription">
        <source>'out' and 'ref' parameters add no value in test methods and they can safely be replaced by normal parameters.</source>
        <target state="translated">Параметры "out" и "ref" не добавляют ценности в тестовых методах и могут быть безопасно заменены обычными параметрами.</target>
        <note>{Locked="out"}{Locked="ref"}</note>
      </trans-unit>
      <trans-unit id="TestClassConstructorShouldBeValidTitle">
        <source>Test classes should have valid constructors</source>
        <target state="translated">У тестовых классов должны быть допустимые конструкторы</target>
        <note />
      </trans-unit>
      <trans-unit id="TestClassConstructorShouldBeValidMessageFormat">
        <source>Test class '{0}' does not have a valid constructor. Valid constructors are 'public' and either parameterless or with one parameter of type 'TestContext'.</source>
        <target state="translated">У тестового class "{0}" нет допустимого конструктора. Допустимые конструкторы определяются как public и либо не имеют параметров, либо имеют один параметр типа "TestContext".</target>
        <note>{0} is the test class name. {Locked="TestContext"}{Locked="public"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="TestClassConstructorShouldBeValidDescription">
        <source>Test classes must have a public constructor that is either parameterless or accepts a single TestContext parameter. This allows the test framework to instantiate the test class properly.</source>
        <target state="translated">У тестовых class должен быть public конструктор, который либо не имеет параметров, либо имеет один параметр типа "TestContext". Это позволяет платформе тестирования надлежащим образом создавать экземпляр тестового class.</target>
        <note>{Locked="TestContext"}{Locked="public"}{Locked="class"}</note>
      </trans-unit>
    </body>
  </file>
</xliff>