<?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="es" 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">Los métodos marcados con '[AssemblyCleanup]' deben seguir el siguiente diseño para ser válidos:
-no se puede declarar en una class genérica
- debería ser 'public' 
- debería estar 'static'
-no debe ser 'async void'
-no debe ser un método especial (finalizador, operador...).
-no debe ser genérico
-no debe tomar ningún parámetro o tomar un único parámetro de tipo 'TestContext'
- El tipo de valor devuelto debe ser 'void', 'Task' o 'ValueTask'

El tipo que declara estos métodos también debe respetar las reglas siguientes:
-El tipo debe ser una class
-La class debe ser 'public' o 'internal' (si el proyecto de prueba usa el atributo '[DiscoverInternals]')
-La class no debe ser 'static'
-La class debe marcarse con '[TestClass]' (o un atributo derivado)
-la class no debe ser genérica.</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">La signatura "{0}" del método AssemblyCleanup no es válida</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">Los métodos AssemblyCleanup deben tener un diseño válido</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">La detección de "[AssemblyFixtureProvider]" se basa en recorrer el gráfico de referencia del ensamblado en tiempo de ejecución, que no se admite cuando el tiempo de ejecución no puede generar código dinámico (por ejemplo, en Native AOT o Blazor WebAssembly AOT). El atributo se omite en estas compilaciones, por lo que no se ejecutarán los métodos de inicialización y limpieza del ensamblado proporcionados. Declare los métodos "[AssemblyInitialize]" y "[AssemblyCleanup]" directamente en el ensamblado de prueba en su lugar.</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]" no se admite con la compilación anticipada (como Native AOT o Blazor WebAssembly AOT) y se omitirá en tiempo de ejecución</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]" no se admite con la compilación anticipada</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">Los métodos marcados con [AssemblyInitialize] deberían seguir el siguiente diseño para ser válidos:
-no se puede declarar en una class genérica
- debería ser 'public' 
- debería estar 'static'
- no debería ser 'async void'
-no debe ser un método especial (finalizador, operador...).
-no debe ser genérico
-debe tomar un parámetro de tipo 'TestContext'
- El tipo de valor devuelto debe ser 'void', 'Task' o 'ValueTask'

El tipo que declara estos métodos también debe respetar las reglas siguientes:
-El tipo debe ser una class
-La class debe ser 'public' o 'internal' (si el proyecto de prueba usa el atributo '[DiscoverInternals]')
-La class no debe ser 'static'
-La class debe marcarse con '[TestClass]' (o un atributo derivado)
-la class no debe ser genérica.</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">La signatura "{0}" del método AssemblyInitialize no es válida</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">Los métodos AssemblyInitialize deben tener un diseño válido</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">Preferir agregar una aserción adicional que compruebe si hay valores null</target>
        <note>{Locked="null"}</note>
      </trans-unit>
      <trans-unit id="AssertionArgsShouldAvoidConditionalAccessTitle">
        <source>Avoid conditional access in assertions</source>
        <target state="translated">Evitar el acceso condicional en las aserciones</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" y "Assert.AreNotSame" esperan que el valor expected se pase primero y que el valor actual se pase como segundo argumento.</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">Los argumentos de aserción deben pasarse en el orden correcto. Se han intercambiado los argumentos "actual" y "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">Los argumentos de aserción deben pasarse en el orden correcto</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` and `Assert.AreNotEqual` use `EqualityComparer&lt;T&gt;.Default`. En el caso de los tipos similares a la colección, esto se basa en la semántica de igualdad del tipo en lugar de comparar elementos de secuencia, por lo que `Assert.AreSequenceEqual`/`Assert.AreNotSequenceEqual` o `Assert.AreEquivalent`/`Assert.AreNotEquivalent` suelen ser la mejor opción.</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}` en {1} (que implementa IEnumerable&lt;T&gt;) no realiza una comparación elemento a elemento de la secuencia. Use `Assert.AreSequenceEqual` para la comparación ordenada por elementos, `Assert.AreSequenceEqual(..., SequenceOrder.InAnyOrder)` para la comparación no ordenada o `Assert.AreEquivalent` para la comparación estructural profunda.</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">Evitar Assert.AreEqual en los tipos de colección</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">Use 'Assert.AreEqual'/'Assert.AreNotEqual' en lugar de 'Assert.AreSame'/'Assert.AreNotSame' al comparar tipos de valor. Al pasar un tipo de valor a 'Assert.AreSame'/'Assert.AreNotSame', se aplicará la conversión boxing (creando un nuevo objeto). Dado que 'Assert.AreSame'/'Assert.AreNotSame' realiza la comparación por referencia, 'Assert.AreSame' producirá un error cuando se produzca una conversión boxing y 'Assert.AreNotSame' pasará siempre.</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">Usar '{0}' en lugar de '{1}' al comparar tipos de valor</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">No use "Assert.AreSame" o "Assert.AreNotSame" con tipos de valor</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">Elimine el argumento 'DynamicDataSourceType' para utilizar el comportamiento de detección automática predeterminado</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">Evite pasar un 'DynamicDataSourceType' explícito y utilice el comportamiento de detección automática predeterminado</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">Bloquear de forma sincrónica el subproceso actual con "Thread.Sleep", "Task.Wait", "Task.WaitAll", "Task.WaitAny" o "Task&lt;TResult&gt;.Result" dentro de métodos o componentes de prueba es una fuente común de inestabilidad y también puede provocar interbloqueos cuando el marco de pruebas ejecuta pruebas en un SynchronizationContext que requiere planificación cooperativa. Se prefiere "await Task.Delay" para las esperas basadas en tiempo y "await" a la tarea para observar su resultado.</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">Evite "{0}" en el código de prueba, ya que puede provocar una flakiness de prueba; considere una alternativa asincrónica como "await Task.Delay" o "await" para la tarea</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">Evite bloquear sincrónicamente llamadas como "Thread.Sleep", "Task.Wait", "Task.WaitAll", "Task.WaitAny" o "Task&lt;TResult&gt;.Result" en el código de prueba</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">No realice ninguna aserción dentro de métodos 'async void', funciones locales o expresiones lambda. Las excepciones que se inicien en este contexto serán excepciones no controladas. Al usar VSTest en .NET Framework, se ingerirán silenciosamente. Cuando se usa Microsoft.Testing.Platform o VSTest en .NET moderno, es posible que se bloquee el proceso.</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">No realizar aserciones dentro de métodos 'async void', funciones locales o expresiones lambda porque no pueden generar errores en la prueba</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">No declarar dentro de contextos '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">Los métodos marcados con '[ClassCleanup]' deben seguir el siguiente diseño para ser válidos:
-no se puede declarar en una class genérica sin el modo 'InheritanceBehavior' establecido
- debería ser 'public' 
- debería estar 'static'
-no debe ser 'async void'
-no debe ser un método especial (finalizador, operador...).
-no debe ser genérico
-no debe tomar ningún parámetro o tomar un único parámetro de tipo 'TestContext'
- El tipo de valor devuelto debe ser 'void', 'Task' o 'ValueTask'
Se debe especificar el parámetro de atributo -'InheritanceBehavior.BeforeEachDerivedClass' si la class es 'abstract'
No se debe especificar el parámetro de atributo -'InheritanceBehavior.BeforeEachDerivedClass' si la class es 'sealed'

El tipo que declara estos métodos también debe respetar las reglas siguientes:
-El tipo debe ser una class
-La class debe ser 'public' o 'internal' (si el proyecto de prueba usa el atributo '[DiscoverInternals]')
-La class no debe ser 'static'
-Si la class es 'sealed', debe marcarse con '[TestClass]' (o un atributo derivado)
-la class no debe ser genérica.</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">La signatura "{0}" del método ClassCleanup no es válida</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">Los métodos ClassCleanup deben tener un diseño válido</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">Los métodos marcados con '[ClassInitialize]' deben seguir el siguiente diseño para ser válidos:
-no se puede declarar en una class genérica sin el modo 'InheritanceBehavior' establecido
- debería ser 'public' 
- debería estar 'static'
- no debería ser 'async void'
-no debe ser un método especial (finalizador, operador...).
-no debe ser genérico
-debe tomar un parámetro de tipo 'TestContext'
- El tipo de valor devuelto debe ser 'void', 'Task' o 'ValueTask'
Se debe especificar el parámetro de atributo -'InheritanceBehavior.BeforeEachDerivedClass' si la class es 'abstract'
- No se debe especificar el parámetro del atributo 'InheritanceBehavior.BeforeEachDerivedClass' si la class es 'sealed'

El tipo que declara estos métodos también debe respetar las reglas siguientes:
-El tipo debe ser una class
-La class debe ser 'public' o 'internal' (si el proyecto de prueba usa el atributo '[DiscoverInternals]')
-La class no debe ser 'static'
-Si la class es 'sealed', debe marcarse con '[TestClass]' (o un atributo derivado)
-la class no debe ser genérica.</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">La signatura "{0}" del método ClassInitialize no es válida</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">Los métodos ClassInitialize deben tener un diseño válido</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">Usar "Assert.{0}" en lugar de "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">Usar "Assert" en lugar de "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" y "DefaultThreadCurrentUICulture" establecen la referencia cultural predeterminada para todo el proceso, por lo que cada prueba que se ejecuta simultáneamente observa el cambio y el formato o el análisis se pueden dañar en la paralelización en el ensamblado. Los formularios por subproceso y ambiente no se marcan intencionadamente: en .NET moderno, los setters "Thread.CurrentThread.CurrentCulture" / "CurrentUICulture" y "CultureInfo.CurrentCulture" / "CurrentUICulture" asignan un valor respaldado por "AsyncLocal" que fluye con el contexto de ejecución, por lo que no dañan las pruebas del mismo nivel ni se filtran en subprocesos agrupados posteriormente. Dado que los setters marcados son de todo el proceso, la restauración del valor anterior en "finally" no ayuda: la ejecución simultánea de pruebas sigue observando la referencia cultural modificada durante la mutación; declare "[DoNotParallelize]" en la prueba o evite mutar en su lugar la referencia cultural de todo el proceso.</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}" establece la referencia cultural predeterminada para todo el proceso, por lo que cada prueba que se ejecuta simultáneamente observa el cambio, lo que puede dañar el formato y el análisis en las pruebas que se ejecutan en paralelo; evitar su mutación en un conjunto de pruebas paralelizado o declarar "[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">Evitar la mutación de la referencia cultural de todo el proceso en una prueba paralelizada</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">El directorio actual es global para el proceso en todos los sistemas operativos y, a diferencia de la referencia cultural, no tiene ningún equivalente con ámbito de hilo ni de asíncrono. Una prueba que la cambia daña el directorio de trabajo de todas las pruebas que se ejecutan simultáneamente y las rutas de acceso relativas resueltas en otra parte del conjunto apuntan silenciosamente a la ubicación incorrecta. "[ResourceLock]" serializa las pruebas contendientes y hace que la mutación sea segura, pero sigue siendo un defecto de diseño en un conjunto paralelo: prefiere pasar rutas de acceso absolutas para que el directorio actual nunca tenga que cambiar.</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}" cambia el directorio actual global del proceso, que no tiene equivalente por subproceso y se observa en todas las pruebas en ejecución simultáneas; evite mutarlo en un conjunto de pruebas paralelizado (declare "[ResourceLock(WellKnownResources.CurrentDirectory)]" al menos como coordenada o "[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">Evite cambiar el directorio actual en una prueba paralelizada</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">Un atributo "[DependsOn]" hace referencia a una prueba por nombre. Una referencia que coincide con ninguna prueba no es deliberadamente irrecuperable en tiempo de ejecución, por lo que la ejecución de un subconjunto del conjunto sigue siendo posible, lo que significa que un error tipográfico o un cambio de nombre quita silenciosamente la ordenación declarada. Este analizador notifica los problemas que se pueden decidir en tiempo de compilación: un método que no existe en el tipo al que se hace referencia, un destino que no es una prueba, una prueba que depende de sí misma, un ciclo de dependencia visible en la compilación, una referencia a un tipo de otro ensamblado (las dependencias se resuelven dentro de un único origen de prueba), y un atributo aplicado donde no tiene ningún efecto.</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]" hace referencia al tipo abstracto "{0}"; sus pruebas se ejecutan en cada clase de prueba derivada en lugar de en ''{0}", por lo que la dependencia se omite en tiempo de ejecución</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]" declara el ciclo de dependencia ''{0}", que produce un error en todas las pruebas del ciclo en tiempo de ejecución</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]" hace referencia al método "{1}", que no existe en el tipo "{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]" no tiene ningún efecto porque "{0}" no es un método de prueba</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]" no tiene ningún efecto porque la detección no ejecuta ninguna prueba en "{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]" hace referencia al tipo ''{0}", que no es una clase de prueba, por lo que la dependencia se omite en tiempo de ejecución</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]" hace referencia a "{0}.{1}", que no es un método de prueba, por lo que la dependencia se omite en tiempo de ejecución</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]" hace referencia al tipo "{0}" de otro ensamblado; las dependencias se resuelven dentro de un único origen de prueba, por lo que la dependencia se omite en tiempo de ejecución</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]" hace que "{0}" dependa de sí mismo, que es un ciclo de dependencia y produce un error en la prueba en tiempo de ejecución</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">Los argumentos "[DependsOn]" deben ser válidos</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">Los miembros a los que hace referencia un atributo "[MemberCondition]" deben existir en el tipo al que se hace referencia, ser "public static", devolver "bool" y (para métodos) no tener parámetros. El atributo se produce en tiempo de ejecución cuando se infringen estas reglas; este analizador muestra los mismos problemas en tiempo de compilación, por lo que los errores tipográficos y las refactorizaciones no interrumpen silenciosamente el acceso a las pruebas.</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">No se encuentra el miembro "{0}.{1}" de "[MemberCondition]"</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">"[MemberCondition]" miembro al que se hace referencia "{0}.{1}" debe ser "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">"[MemberCondition]" miembro al que se hace referencia "{0}.{1}" debe ser "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">"[MemberCondition]" miembro al que se hace referencia "{0}.{1}" debe ser una propiedad, un campo o un método sin parámetros</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">"[MemberCondition]" miembro al que se hace referencia "{0}.{1}" debe devolver "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">"[MemberCondition]" el método "{0}.{1}" al que se hace referencia no debe tener parámetros</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">"[MemberCondition]" propiedad "{0}.{1}" a la que se hace referencia debe tener un captador</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">Los argumentos "[MemberCondition]" deben ser válidos</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">La entrada DataRow debe tener el siguiente diseño para que sea válido:
: solo se debe establecer en un método de prueba;
- el recuento de argumentos debe coincidir con el recuento de argumentos del método;
: el tipo de argumento debe coincidir con el tipo de argumento de método.</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">El recuento de argumentos de DataRow debe coincidir con el recuento de parámetros del método (argumentos de constructor: {0}, parámetros de método: {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">Los tipos de argumentos DataRow no coinciden con los tipos de parámetro de método. {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">El parámetro '{0}' espera el tipo '{1}', pero el valor proporcionado tiene el tipo '{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">Se encontraron dos tipos en conflicto para el parámetro genérico '{0}'. Los tipos en conflicto son '{1}' y '{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">No se pudo inferir el tipo del parámetro genérico '{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 solo debe establecerse en un método de prueba</target>
        <note>{Locked="DataRow"}</note>
      </trans-unit>
      <trans-unit id="DataRowShouldBeValidTitle">
        <source>DataRow should be valid</source>
        <target state="translated">DataRow debe ser válido</target>
        <note>{Locked="DataRow"}</note>
      </trans-unit>
      <trans-unit id="DoNotNegateBooleanAssertionFix">
        <source>Use 'Assert.{0}' instead</source>
        <target state="translated">Usa ''Assert.{0}'' en su lugar</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">Usar métodos Assert adecuados para todas las aserciones negadas</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">No negar las aserciones booleanas, usar en su lugar la aserción opuesta</target>
        <note />
      </trans-unit>
      <trans-unit id="DoNotNegateBooleanAssertionTitle">
        <source>Do not negate boolean assertions</source>
        <target state="translated">No negar las aserciones booleanas</target>
        <note />
      </trans-unit>
      <trans-unit id="DoNotStoreStaticTestContextAnalyzerMessageFormat">
        <source>Do not store TestContext in a static member</source>
        <target state="translated">No almacenar TestContext en un miembro 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">No almacenar TestContext en un miembro 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">La creación de instantáneas de miembros de prueba podría causar problemas de prueba (por ejemplo, NRE).</target>
        <note />
      </trans-unit>
      <trans-unit id="DoNotUseShadowingMessageFormat">
        <source>Member '{0}' already exists in the base class</source>
        <target state="translated">El miembro "{0}" ya existe en la class base</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">No usar sesión concurrente</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" no tiene ningún efecto en el contexto de las pruebas y es probable que quiera usar "Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute" en su lugar.</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">¿Quería usar "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" no tiene ningún efecto en los métodos de prueba</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">No duplicar los atributos "DataRow". Suele ser un error de copiar y pegar. Los índices de los atributos son "{0}" y "{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">Evitar entradas duplicadas de "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">La entrada de 'DynamicData' debe tener el siguiente diseño para que sea válida:
: solo se debe establecer en un método de prueba;
- el miembro debe definirse en el tipo especificado;
- el miembro debe ser un método si se especifica DynamicDataSourceType.Method o una propiedad en caso contrario.</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">La firma del miembro de datos '{0}.{1}' de '[DynamicData]' no es válida</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">La firma del método de nombre para mostrar '{0}.{1}' de '[DynamicData]' no es válida</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">El miembro '{0}.{1}' de '[DynamicData]' debe ser un método</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">No se puede encontrar el miembro '{0}.{1}' de '[DynamicData]'</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">El miembro '{0}.{1}' de '[DynamicData]' al que se hace referencia debe devolver 'IEnumerable&lt;object[]&gt;', 'IEnumerable&lt;Tuple&gt;' o '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]' solo debe establecerse en un método de prueba</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">El miembro '{0}.{1}' de '[DynamicData]' es un campo, por lo que debe usar 'DynamicDataSourceType.AutoDetect' o 'DynamicDataSourceType.Field' (la detección automática es el valor predeterminado cuando no se especifica explícitamente y se recomienda)</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]' miembro '{0}.{1}' es un método, por lo que debe usar 'DynamicDataSourceType.AutoDetect' o 'DynamicDataSourceType.Method' (la detección automática es el valor predeterminado cuando no se especifica explícitamente y se recomienda)</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">El miembro '{0}.{1}' de '[DynamicData]' no es una propiedad, un método o un campo. Solo se admiten propiedades, métodos y campos.</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]' miembro '{0}.{1}' no es una propiedad ni un método. Solo se admiten propiedades y métodos.</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]' miembro '{0}.{1}' es una propiedad, por lo que debe usar 'DynamicDataSourceType.AutoDetect' o 'DynamicDataSourceType.Property' (la detección automática es el valor predeterminado cuando no se especifica explícitamente y se recomienda)</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]' miembro '{0}.{1}' se encuentra más de una vez</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 debe ser válido</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">Al llamar a métodos async que tienen sobrecargas que aceptan un parámetro CancellationToken, es preferible utilizar la sobrecarga con TestContext.CancellationToken para habilitar la cancelación cooperativa y respetar los tiempos de espera de las pruebas.</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">Considere utilizar la sobrecarga que acepta un CancellationToken y pase '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">Flujo de TestContext.CancellationToken a operaciones 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">Los métodos marcados con "[GlobalTestInitialize]" o "[GlobalTestCleanup]" deben seguir el siguiente diseño para ser válidos:
-no se puede declarar en una class genérica
- debería ser "public" 
- debería estar "static"
-no debe ser "async void"
-no debe ser un método especial (finalizador, operador...).
-no debe ser genérico
-debe tomar un parámetro de tipo "TestContext"
- El tipo de valor devuelto debe ser "void", "Task" o "ValueTask"

El tipo que declara estos métodos también debe respetar las reglas siguientes:
-El tipo debe ser una class
-La class debe ser "publico"
-La class debe marcarse con "[TestClass]" (o un atributo derivado)
-la class no debe ser genérica.</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">La firma del método del accesorio de pruebas global '{0}' no es válida</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">Los métodos GlobalTestInitialize y GlobalTestCleanup deben tener un diseño válido</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">Un atributo "[Ignore]" aplicado a un método de prueba o class de prueba debe incluir un mensaje no vacío que explique por qué se omite la prueba o class. Un mensaje de justificación facilita la clasificación de las pruebas omitidas, ayuda a quienes revisan a entender la intención y evita que las pruebas se deshabiliten en silencio para siempre.</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]" debe especificar un mensaje que explique por qué se omite "{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]" debe especificar una justificación</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">Los métodos como Contains, StartsWith y EndsWith devuelven valores booleanos que indican si se cumplió la condición. Ignorar estos valores devueltos probablemente sea un error.</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">No se debe ignorar el valor devuelto de '{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">No ignore el valor devuelto de los métodos de cadena</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">Usar "Assert.Fail" en lugar de una aserción 'Assert.{0}' que siempre tiene errores</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">Usar "Assert.Fail" en lugar de una aserción que siempre tiene errores</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">Al comprobar las excepciones del código asincrónico, use los métodos de asynchronous async en lugar de bloquear la operación asynchronous con 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">Use "Assert{0}" en lugar de bloquear una llamada async en "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">Preferir métodos de aserción 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]" coincide con las pruebas según la igualdad exacta de cadena de la clave de recurso. Un literal de cadena suelto no falla con error: un error tipográfico genera una clave distinta, por lo que las pruebas en conflicto ya no se serializan y compiten entre sí sin dar un error. Al hacer referencia a una constante compartida, los errores tipográficos se convierten en un error de compilación y el compilador puede exigir que todas las pruebas que contienden por el mismo recurso usen la misma clave.</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">Preferir una constante con nombre para la clave de recurso "[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" está obsoleto y no proporciona ninguna funcionalidad adicional sobre "TestMethodAttribute". Use "TestMethodAttribute" para todos los métodos de prueba, incluidas las pruebas parametrizadas.</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" está obsoleto. Use "TestMethod" en su lugar.</target>
        <note>{Locked="DataTestMethod"}{Locked="TestMethod"}</note>
      </trans-unit>
      <trans-unit id="PreferTestMethodOverDataTestMethodAnalyzerTitle">
        <source>Prefer 'TestMethod' over 'DataTestMethod'</source>
        <target state="translated">Preferir "TestMethod" a "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">Establecer un "DisplayName" en un método de prueba en un valor idéntico al nombre del método es redundante porque el nombre del método ya se usa como nombre para mostrar de forma predeterminada. El elemento "DisplayName" redundante se puede quitar sin cambiar el modo en que se notifica la prueba.</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">El valor de "DisplayName" es el mismo que el nombre del método de prueba "{0}" y se puede quitar</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">El método de prueba no debe especificar un nombre para mostrar igual a su nombre</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">Revise o quite la aserción porque se sabe que su condición siempre es true</target>
        <note>{Locked="true"}</note>
      </trans-unit>
      <trans-unit id="ReviewAlwaysTrueAssertConditionAnalyzerTitle">
        <source>Assertion condition is always true</source>
        <target state="translated">La condición de aserción siempre es true</target>
        <note>{Locked="true"}</note>
      </trans-unit>
      <trans-unit id="PreferConstructorOverTestInitializeMessageFormat">
        <source>Prefer constructors over TestInitialize methods</source>
        <target state="translated">Preferir constructores en lugar de métodos TestInitialize</target>
        <note>{Locked="TestInitialize"}</note>
      </trans-unit>
      <trans-unit id="PreferConstructorOverTestInitializeTitle">
        <source>Prefer constructors over TestInitialize methods</source>
        <target state="translated">Preferir constructores en lugar de métodos TestInitialize</target>
        <note>{Locked="TestInitialize"}</note>
      </trans-unit>
      <trans-unit id="PreferDisposeOverTestCleanupMessageFormat">
        <source>Prefer 'Dispose' over TestCleanup methods</source>
        <target state="translated">Preferir "Dispose" sobre los métodos TestCleanup</target>
        <note>{Locked="TestCleanup"}{Locked="Dispose"}</note>
      </trans-unit>
      <trans-unit id="PreferDisposeOverTestCleanupTitle">
        <source>Prefer 'Dispose' over TestCleanup methods</source>
        <target state="translated">Preferir "Dispose" sobre los métodos TestCleanup</target>
        <note>{Locked="TestCleanup"}{Locked="Dispose"}</note>
      </trans-unit>
      <trans-unit id="PreferTestCleanupOverDisposeMessageFormat">
        <source>Prefer TestCleanup over 'Dispose' methods</source>
        <target state="translated">Preferir TestCleanup en lugar de métodos "Dispose"</target>
        <note>{Locked="TestCleanup"}{Locked="Dispose"}</note>
      </trans-unit>
      <trans-unit id="PreferTestCleanupOverDisposeTitle">
        <source>Prefer TestCleanup over 'Dispose' methods</source>
        <target state="translated">Preferir TestCleanup en lugar de métodos "Dispose"</target>
        <note>{Locked="TestCleanup"}{Locked="Dispose"}</note>
      </trans-unit>
      <trans-unit id="PreferTestInitializeOverConstructorMessageFormat">
        <source>Prefer TestInitialize methods over constructors</source>
        <target state="translated">Preferir métodos TestInitialize en lugar de constructores</target>
        <note>{Locked="TestInitialize"}</note>
      </trans-unit>
      <trans-unit id="PreferTestInitializeOverConstructorTitle">
        <source>Prefer TestInitialize methods over constructors</source>
        <target state="translated">Preferir métodos TestInitialize en lugar de constructores</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">Los métodos públicos deben ser métodos de prueba (marcados con `[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">El método público "{0}" debe ser un método de prueba</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">Los métodos públicos deben ser métodos de prueba</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">Se considera una buena práctica tener solo clases de prueba marcadas como public en un proyecto de prueba.</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">El tipo público '{0}' debe marcarse con '[TestClass]' o cambiarse a '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">Los tipos públicos deben ser clases de prueba</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">Pasar una ruta de acceso absoluta codificada de forma rígida, o un literal de ruta de acceso relativa, directamente a un método "File.*"/'Directory.*" que muta el sistema de archivos (por ejemplo, "File.WriteAllText" o "Directory.CreateDirectory") tiene como destino una ubicación compartida por todas las demás pruebas del ensamblado; además, las rutas de acceso relativas se resuelven en el directorio actual global del proceso. En la paralelización en ensamblado, dos pruebas pueden escribir simultáneamente en la misma ubicación. Solo se marcan las rutas de acceso constantes estáticas que se pasan a una API de mutación; Las lecturas, la construcción de rutas de acceso y las rutas de acceso compiladas a partir de variables se dejan a la aptitud de auditoría de seguridad en paralelo. Prefiere un directorio único por prueba, como "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">La ruta de acceso "{0}" es una ubicación fija compartida por cada prueba del ensamblado (y, cuando es relativa, se resuelve en el directorio actual global del proceso), por lo que las pruebas paralelas que escriben en él pueden colisionar; use una ubicación única por prueba, como "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">Evitar rutas de acceso codificadas de forma rígida o compartidas en una prueba en paralelo</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">Use 'Assert'{0}. en lugar de '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">Usar 'Assert' en lugar de '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">La class de prueba '{0}' debe ser válida</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">La propiedad 'TestContext' debe ser válida</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))]" pasa el tipo de filtro como 'Type', por lo que el compilador acepta cualquier tipo. El adaptador solo lo valida cuando materializa el filtro y, a continuación, produce un error en toda la ejecución. El tipo al que se hace referencia debe ser no genérico y crear instancias, implementar "ITestFilter" y exponer un constructor público sin parámetros y, como máximo, se puede registrar un proveedor por ensamblado de prueba. Cuando el destino es .NET, el formulario genérico "[assembly: TestFilterProvider&lt;MyFilter&gt;]" aplica los requisitos de interfaz y constructor a través de restricciones genéricas en su lugar.</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]" hace referencia al tipo genérico "{0}"; el tipo de filtro de prueba no debe ser genérico</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">El ensamblado registra más de un "[TestFilterProvider]"; se permite como máximo uno por ensamblado de prueba, así que redacte las estrategias de filtrado dentro de una única implementación de "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]" hace referencia al tipo "{0}", que no declara un constructor público sin parámetros</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]" hace referencia al tipo "{0}", que no implementa "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]" hace referencia al tipo "{0}", del que no se pueden crear instancias</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]" tiene un tipo de filtro nulo; pase la implementación "ITestFilter" para ejecutar, por ejemplo "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]" debe hacer referencia a un tipo de filtro de prueba válido</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">La class derivada TestMethodAttribute "{0}" debe agregar los parámetros CallerFilePath y CallerLineNumber a su constructor</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">La class derivada TestMethodAttribute debe propagar la información de origen</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">Usar la propiedad "DisplayName" en lugar de pasar un argumento de cadena a 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 debe establecer DisplayName correctamente</target>
        <note>{Locked="TestMethodAttribute"}{Locked="DisplayName"}</note>
      </trans-unit>
      <trans-unit id="TestMethodShouldBeValidMessageFormat">
        <source>Test method '{0}' signature is invalid</source>
        <target state="translated">La firma del método de prueba '{0}' no es válida</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">La mutación del estado global del proceso (como las variables de entorno o el redireccionamiento de la consola) de una prueba no es segura una vez habilitada la paralelización en el ensamblado, ya que una prueba del mismo nivel que se ejecuta simultáneamente observa la mutación. A diferencia de "[ResourceLock]", que no se abre cuando se olvida una clave, esta regla marca la mutación en tiempo de compilación. Declare "[ResourceLock]" con la clave "WellKnownResources" coincidente para serializar las pruebas contendientes, o "[DoNotParallelize]" para dejar la prueba fuera de la paralelización.</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}" muta el estado global del proceso y no es seguro cuando las pruebas se ejecutan en paralelo; declare "[ResourceLock(WellKnownResources.{1})]" en la prueba (o "[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">La mutación de prueba del estado global del proceso debe declarar un bloqueo de recursos</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">Los métodos de prueba que comparan "RuntimeInformation.ProcessArchitecture" y, a continuación, devuelven o llaman a "Assert.Inconclusive" en su lugar deben usar el atributo "[ArchitectureCondition]". Este atributo proporciona una manera más declarativa y reconocible de especificar los requisitos de prueba específicos de la arquitectura, y notifica la prueba como omitida en lugar de superada, lo que no ocurre con una devolución temprana.</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">Use el atributo "[ArchitectureCondition]" en lugar de las comprobaciones "RuntimeInformation.ProcessArchitecture" con la devolución temprana o "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">Use el atributo "[ArchitectureCondition]" en lugar de las comprobaciones "RuntimeInformation.ProcessArchitecture" con la devolución temprana o "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">Los métodos de prueba que comprueban con null la variable de entorno "CI" y, a continuación, devuelven o llaman a "Assert.Inconclusive" en su lugar deben usar el atributo "[CICondition]". Este atributo reconoce todos los proveedores de integración continua que conoce MSTest y analiza sus valores, e informa de la prueba como omitida en lugar de superada, algo que no hace una devolución anticipada.</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">Use el atributo "[CICondition]" en lugar de las comprobaciones "Environment.GetEnvironmentVariable" con la devolución anticipada o "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">Use el atributo "[CICondition]" en lugar de las comprobaciones "Environment.GetEnvironmentVariable" con la devolución anticipada o "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 proporciona una manera más directa de acceder al token de cancelación en comparación con 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">Use 'TestContext.CancellationToken' en lugar de '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">Use TestContext.CancellationToken en lugar de 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">Las clases de prueba, las clases marcadas con el atributo '[TestClass]', deben respetar el siguiente diseño para que MSTest lo considere válido:
- debe ser 'public' (o 'internal' si se establece el atributo '[assembly: DiscoverInternals]')
- no debe ser "static" (excepto si contiene solo los métodos "AssemblyInitialize" o "AssemblyCleanup")
: no debe ser genérico.</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">Las clases de prueba deben tener un diseño válido</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">La class de prueba debe tener al menos un método de prueba o ser "static" con métodos marcados por "[AssemblyInitialize]" o "[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">La class de prueba "{0}" debe tener al menos un método de prueba o ser "static" con métodos marcados por "[AssemblyInitialize]" o "[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">La class de prueba debe tener un método de prueba</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">Los métodos marcados con '[TestCleanup]' deben seguir el siguiente diseño para ser válidos:
- debería ser 'public' 
-no debe ser 'abstract'
- no debería ser 'async void'
-no debe ser 'static'
-no debe ser un método especial (finalizador, operador...).
-no debe ser genérico
-no debe tomar ningún parámetro
- El tipo de valor devuelto debe ser 'void', 'Task' o 'ValueTask'

El tipo que declara estos métodos también debe respetar las reglas siguientes:
-El tipo debe ser una class
-La class debe ser 'public' o 'internal' (si el proyecto de prueba usa el atributo '[DiscoverInternals]')
-La class no debe ser 'static'
-Si la class es 'sealed', debe marcarse con '[TestClass]' (o un atributo derivado).</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">La signatura "{0}" del método TestCleanup no es válida</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">El método TestCleanup debería tener un diseño válido</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" debe ser una propiedad no static asignada en el constructor o establecida por MSTest. Para que MSTest lo establezca, debe seguir el diseño:
- debe ser "public" independientemente de si el atributo "[assembly: DiscoverInternals]" está establecido o no.
- no debe ser "static"
- debe tener un establecedor.</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">La propiedad de contexto de prueba debe tener un diseño válido</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">Los métodos marcados con '[TestInitialize]' deben seguir el siguiente diseño para ser válidos:
- debería ser 'public' 
-no debe ser 'abstract'
- no debería ser 'async void'
-no debe ser 'static'
-no debe ser un método especial (finalizador, operador...).
-no debe ser genérico
-no debe tomar ningún parámetro
- El tipo de valor devuelto debe ser 'void', 'Task' o 'ValueTask'

El tipo que declara estos métodos también debe respetar las reglas siguientes:
-El tipo debe ser una class
-La class debe ser 'public' o 'internal' (si el proyecto de prueba usa el atributo '[DiscoverInternals]')
-La class no debe ser 'static'
-Si la class es 'sealed', debe marcarse con '[TestClass]' (o un atributo derivado).</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">La signatura "{0}" del método TestInitialize no es válida</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">El método TestInitialize debería tener un diseño válido</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">Los métodos de prueba, los métodos marcados con el atributo '[TestMethod]', deben respetar el siguiente diseño para que MSTest lo considere válido:
- debe ser 'public' (o 'internal' si se establece el atributo '[assembly: DiscoverInternals]')
- no debe ser 'static'
- puede ser genérico siempre y cuando se puedan inferir parámetros de tipo y los tipos de argumento sean compatibles
- no debe ser 'abstract'
- el tipo de valor devuelto debe ser 'void', 'Task' o 'ValueTask'
- no debe ser 'async void'
- no debe ser un método especial (finalizador, operador...).</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">Los métodos de prueba deben tener un diseño válido</target>
        <note />
      </trans-unit>
      <trans-unit id="TestMethodShouldNotBeIgnoredAnalyzerDescription">
        <source>Test methods should not be ignored (marked with '[Ignore]').</source>
        <target state="translated">Los métodos de prueba no deberían ignorarse (marcarse con '[Ignore]').</target>
        <note>{Locked="[Ignore]"}</note>
      </trans-unit>
      <trans-unit id="TestMethodShouldNotBeIgnoredAnalyzerFormat">
        <source>Test method '{0}' should not be ignored</source>
        <target state="translated">El método de prueba '{0}' no debería ignorarse</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">El método de prueba no debería ignorarse</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">El tipo que contiene '[TestMethod]' debe marcarse con '[TestClass]'; de lo contrario, el método de prueba se omitirá de forma silenciosa.</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">El tipo '{0}' contiene métodos de prueba y debe marcarse con '[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">El tipo que contiene "[TestMethod]" debe marcarse con "[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">Los métodos Asynchronous de accesorio de prueba no requieren el sufijo '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">Los métodos de prueba Asynchronous no requieren el sufijo '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">MSTest requiere el parámetro TestContext para los métodos AssemblyInitialize y 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}] solo se puede establecer en métodos marcados con [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}] solo se puede establecer en métodos marcados con [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">El atributo '{0}' que deriva de 'ConditionBaseAttribute' solo se debe usar en clases marcadas con '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">Usar 'ConditionBaseAttribute' en clases de prueba</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">No se recomienda usar "[Timeout]" sin establecer explícitamente "CooperativeCancellation = true". En una versión futura, la cancelación cooperativa se convertirá en el comportamiento predeterminado. Establece "CooperativeCancellation = true" para participar en el comportamiento recomendado y evitar cambios importantes.</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">Usa "CooperativeCancellation = true" con "[Timeout]" para habilitar el comportamiento de cancelación cooperativa.</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">Usa "CooperativeCancellation = true" con "[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]' solo se puede especificar en la class de prueba o el método de prueba</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]' solo se puede especificar en la class de prueba o el método de prueba</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">De forma predeterminada, MSTest ejecuta pruebas en el mismo ensamblado secuencialmente, lo que puede provocar limitaciones de rendimiento graves. Se recomienda habilitar el atributo de ensamblado ''[Parallelize]'' o, si se sabe que el ensamblado no se puede paralelizar, usar explícitamente el atributo de nivel de ensamblado ''[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">Habilitar o deshabilitar explícitamente la paralelización de pruebas</target>
        <note />
      </trans-unit>
      <trans-unit id="UseParallelizeAttributeAnalyzerTitle">
        <source>Explicitly enable or disable tests parallelization</source>
        <target state="translated">Habilitar o deshabilitar explícitamente la paralelización de pruebas</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">Usar "Assert.{0}" en lugar de "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">Usar métodos "Assert" adecuados</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">Un atributo que deriva de "RetryBaseAttribute" solo se puede especificar en un método de prueba o una class de prueba</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">Usar el atributo de reintento en el método de prueba o class de prueba</target>
        <note>{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="TestContextPropertyUsageTitle">
        <source>TestContext property cannot be accessed in this context</source>
        <target state="translated">No se puede tener acceso a la propiedad TestContext en este contexto</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">No se puede tener acceso a la propiedad TestContext "{0}" en el método "{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">Algunas propiedades de TestContext solo están disponibles durante la ejecución de la prueba y no se puede acceder a ellas en los métodos assembly initialize, class initialize, class cleanup o assembly cleanup.</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">Los métodos Assert.Throws solo deben contener una sola instrucción o expresión. Varias instrucciones pueden ser engañosas: si se lanza la primera instrucción, las instrucciones posteriores nunca se ejecutan; si no se lanza, se debe mover fuera de 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 debe contener solo una única instrucción o expresión</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 debe contener solo una única instrucción o expresión</target>
        <note>{Locked="Assert.Throws"}</note>
      </trans-unit>
      <trans-unit id="AvoidAssertsInCatchBlocksTitle">
        <source>Do not use asserts in catch blocks</source>
        <target state="translated">No use aserciones en bloques 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">No use aserciones en bloques catch porque es posible que no produzcan un error en la prueba si no se produce ninguna excepción</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">El uso de aserciones en bloques catch es problemático porque la prueba se superará incluso aunque no se produzca ninguna excepción y el bloque catch nunca se ejecuta. Use "Assert.Throws", "Assert.ThrowsExactly", "Assert.ThrowsAsync" o "Assert.ThrowsExactlyAsync" para comprobar que se produce una excepción y, a continuación, realice aserciones adicionales en la excepción detectada sin usar el bloque try-catch. La regla también marca "throw new AssertFailedException(...)" y "throw new AssertInconclusiveException(...)". (las formas desenredadas de "Assert.Fail" y "Assert.Inconclusive"). 'Assert.Inconclusive' (y 'throw new AssertInconclusiveException(...)') está exento cuando se usa dentro de un catch filtrado ('catch (...) when (...)'), porque degradar un error detectado a un resultado no concluyente es el único caso de uso que no se puede expresar sin un bloque catch. Para otras omisiones intencionadas (por ejemplo, adjuntar a un mensaje generado en tiempo de ejecución al error), suprime el diagnóstico con "#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">Un ensamblado debe tener el atributo '[Parallelize]' o '[DoNotParallelize]', pero no ambos. Tener ambos atributos crea una configuración ambigua. Cuando ambos están presentes, '[DoNotParallelize]' tiene prioridad y se deshabilitará la paralelización.</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">El ensamblado tiene los atributos '[Parallelize]' y '[DoNotParallelize]', lo que crea ambigüedad</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">No use los atributos '[Parallelize]' y '[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">Use el atributo "[OSCondition]" en lugar de las llamadas a "RuntimeInformation.IsOSPlatform" con la devolución temprana o "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">Use el atributo "[OSCondition]" en lugar de las llamadas a "RuntimeInformation.IsOSPlatform" con la devolución temprana o "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">Los métodos de prueba que usan "RuntimeInformation.IsOSPlatform" con la devolución temprana o "Assert.Inconclusive" deben usar el atributo "[OSCondition]" en su lugar. Este atributo proporciona una manera más declarativa y reconocible de especificar requisitos de prueba específicos del sistema operativo.</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">Evitar atributos de método de prueba duplicados</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">El método de prueba '{0}' tiene varios atributos que heredan de 'TestMethodAttribute'. Solo se debe usar un atributo de método de prueba.</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">Un método de prueba debería marcarse exactamente con un atributo que sea o herede de 'TestMethodAttribute'. Cuando haya varios atributos de este tipo, solo se usará el primero devuelto por la reflexión.</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">Evitar el uso de parámetros "out" o "ref" en los métodos de prueba</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">El método de prueba ''{0}'' tiene parámetros "out" o "ref" para los que se quitará la compatibilidad en una versión principal futura</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">Los parámetros "out" y "ref" no agregan ningún valor en los métodos de prueba y se pueden reemplazar de forma segura por parámetros normales.</target>
        <note>{Locked="out"}{Locked="ref"}</note>
      </trans-unit>
      <trans-unit id="TestClassConstructorShouldBeValidTitle">
        <source>Test classes should have valid constructors</source>
        <target state="translated">Las clases de prueba deben tener constructores válidos</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">La class de prueba ''{0}'' no tiene un constructor válido. Los constructores válidos son ''public'' y sin parámetros o con un parámetro de tipo ''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">Las class de prueba deben tener un constructor public que no tenga parámetros o acepte un único parámetro TestContext. Esto permite que el marco de pruebas cree instancias de la class de prueba correctamente.</target>
        <note>{Locked="TestContext"}{Locked="public"}{Locked="class"}</note>
      </trans-unit>
    </body>
  </file>
</xliff>