<?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="ko" original="../Resources.resx">
    <body>
      <trans-unit id="AssemblyCleanupShouldBeValidDescription">
        <source>Methods marked with '[AssemblyCleanup]' should follow the following layout to be valid:
-it can't be declared on a generic class
-it should be 'public'
-it should be 'static'
-it should not be 'async void'
-it should not be a special method (finalizer, operator...).
-it should not be generic
-it should either not take any parameter, or take a single parameter of type 'TestContext'
-return type should be 'void', 'Task' or 'ValueTask'

The type declaring these methods should also respect the following rules:
-The type should be a class
-The class should be 'public' or 'internal' (if the test project is using the '[DiscoverInternals]' attribute)
-The class shouldn't be 'static'
-The class should be marked with '[TestClass]' (or a derived attribute)
-the class should not be generic.</source>
        <target state="translated">'[AssemblyCleanup]'으로 표시된 메서드가 유효하려면 다음 레이아웃을 따라야 합니다.
- 제네릭 class에서 선언할 수 없습니다.
- 'public'이어야 합니다. 
- 'static'이어야 합니다.
- 'async void'가 아니어야 합니다.
- 특수 메서드(종료자, 연산자...)가 아니어야 합니다.
- 제네릭이 아니어야 합니다.
- 매개 변수를 사용하거나 'TestContext' 형식의 단일 매개 변수를 사용해서는 안 됩니다.
- 반환 형식은 'void', 'Task' 또는 'ValueTask'여야 합니다.

이러한 메서드를 선언하는 형식은 다음 규칙도 준수해야 합니다.
- 형식은 class여야 합니다.
- class는 'public' 또는 'internal'이어야 합니다(테스트 프로젝트에서 '[DiscoverInternals]' 특성을 사용하는 경우).
- class는 'static'이 되어서는 안 됩니다.
- class는 '[TestClass]'(또는 파생 특성)로 표시되어야 합니다.
- class는 제네릭이 아니어야 합니다.</target>
        <note>{Locked="[DiscoverInternals]"}{Locked="[AssemblyCleanup]"}{Locked="[TestClass]"}{Locked="TestContext"}{Locked="ValueTask"}{Locked="Task"}{Locked="public"}{Locked="internal"}{Locked="static"}{Locked="void"}{Locked="async void"}{Locked="async"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="AssemblyCleanupShouldBeValidMessageFormat">
        <source>AssemblyCleanup method '{0}' signature is invalid</source>
        <target state="translated">AssemblyCleanup 메서드 '{0}' 시그니처가 잘못되었습니다.</target>
        <note>{0} is the method name. {Locked="AssemblyCleanup"}</note>
      </trans-unit>
      <trans-unit id="AssemblyCleanupShouldBeValidTitle">
        <source>AssemblyCleanup methods should have valid layout</source>
        <target state="translated">AssemblyCleanup 메서드에는 올바른 레이아웃이 있어야 합니다.</target>
        <note>{Locked="AssemblyCleanup"}</note>
      </trans-unit>
      <trans-unit id="AssemblyFixtureProviderNotSupportedWithNativeAotDescription">
        <source>'[AssemblyFixtureProvider]' discovery relies on walking the runtime assembly reference graph, which is not supported when the runtime cannot generate dynamic code (for example under Native AOT or Blazor WebAssembly AOT). The attribute is ignored in such builds, so the provided assembly initialize and cleanup methods will not run. Declare the '[AssemblyInitialize]' and '[AssemblyCleanup]' methods directly in the test assembly instead.</source>
        <target state="translated">'[AssemblyFixtureProvider]' 검색은 런타임 어셈블리 참조 그래프를 따라가며 이루어지며, 런타임이 동적 코드를 생성할 수 없으면 이 기능은 지원되지 않습니다(예: Native AOT 또는 Blazor WebAssembly AOT에서). 이러한 빌드에서는 이 특성이 무시되므로 제공된 어셈블리 초기화 및 정리 메서드가 실행되지 않습니다. 대신 테스트 어셈블리에서 '[AssemblyInitialize]' 및 '[AssemblyCleanup]' 메서드를 직접 선언하세요.</target>
        <note>{Locked="[AssemblyFixtureProvider]"}{Locked="[AssemblyInitialize]"}{Locked="[AssemblyCleanup]"}{Locked="Native AOT"}{Locked="Blazor WebAssembly AOT"}</note>
      </trans-unit>
      <trans-unit id="AssemblyFixtureProviderNotSupportedWithNativeAotMessageFormat">
        <source>'[AssemblyFixtureProvider]' is not supported with ahead-of-time compilation (such as Native AOT or Blazor WebAssembly AOT) and will be ignored at run time</source>
        <target state="translated">'[AssemblyFixtureProvider]'는 AOT(Ahead-Of-Time) 컴파일(예: Native AOT 또는 Blazor WebAssembly AOT)에서 지원되지 않으며 런타임에 무시됩니다.</target>
        <note>{Locked="[AssemblyFixtureProvider]"}{Locked="Native AOT"}{Locked="Blazor WebAssembly AOT"}</note>
      </trans-unit>
      <trans-unit id="AssemblyFixtureProviderNotSupportedWithNativeAotTitle">
        <source>'[AssemblyFixtureProvider]' is not supported with ahead-of-time compilation</source>
        <target state="translated">'[AssemblyFixtureProvider]'는 AOT(Ahead-Of-Time) 컴파일에서 지원되지 않습니다.</target>
        <note>{Locked="[AssemblyFixtureProvider]"}</note>
      </trans-unit>
      <trans-unit id="AssemblyInitializeShouldBeValidDescription">
        <source>Methods marked with '[AssemblyInitialize]' should follow the following layout to be valid:
-it can't be declared on a generic class
-it should be 'public'
-it should be 'static'
-it should not be 'async void'
-it should not be a special method (finalizer, operator...).
-it should not be generic
-it should take one parameter of type 'TestContext'
-return type should be 'void', 'Task' or 'ValueTask'

The type declaring these methods should also respect the following rules:
-The type should be a class
-The class should be 'public' or 'internal' (if the test project is using the '[DiscoverInternals]' attribute)
-The class shouldn't be 'static'
-The class should be marked with '[TestClass]' (or a derived attribute)
-the class should not be generic.</source>
        <target state="translated">'[AssemblyInitialize]'로 표시된 메서드가 유효하려면 다음 레이아웃을 따라야 합니다.
-제네릭 class에서 선언할 수 없습니다.
- 'public'이어야 합니다. 
- 'static'이어야 합니다.
- 'async void'가 아니어야 합니다.
- 특수 메서드(종료자, 연산자...)가 아니어야 합니다.
- 제네릭이 아니어야 합니다.
- 'TestContext' 형식의 매개 변수를 하나 사용해야 합니다.
- 반환 형식은 'void', 'Task' 또는 'ValueTask'여야 합니다.

이러한 메서드를 선언하는 형식은 다음 규칙도 준수해야 합니다.
-형식은 class여야 합니다.
-class는 'public' 또는 'internal'이어야 합니다(테스트 프로젝트에서 '[DiscoverInternals]' 특성을 사용하는 경우).
-class는 'static'이 되어서는 안 됩니다.
-class는 '[TestClass]'(또는 파생 특성)로 표시되어야 합니다.
-class는 제네릭이 아니어야 합니다.</target>
        <note>{Locked="[AssemblyInitialize]"}{Locked="[DiscoverInternals]"}{Locked="[TestClass]"}{Locked="TestContext"}{Locked="ValueTask"}{Locked="Task"}{Locked="public"}{Locked="internal"}{Locked="static"}{Locked="void"}{Locked="async void"}{Locked="async"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="AssemblyInitializeShouldBeValidMessageFormat">
        <source>AssemblyInitialize method '{0}' signature is invalid</source>
        <target state="translated">AssemblyInitialize 메서드 '{0}' 시그니처가 잘못되었습니다.</target>
        <note>{0} is the method name. {Locked="AssemblyInitialize"}</note>
      </trans-unit>
      <trans-unit id="AssemblyInitializeShouldBeValidTitle">
        <source>AssemblyInitialize methods should have valid layout</source>
        <target state="translated">AssemblyInitialize 메서드에는 유효한 레이아웃이 있어야 합니다.</target>
        <note>{Locked="AssemblyInitialize"}</note>
      </trans-unit>
      <trans-unit id="AssertionArgsShouldAvoidConditionalAccessDescription">
        <source>Conditional access adds an implicit null branch to an assertion, which can hide whether the object was unexpectedly null. A separate null assertion makes failures identify the violated condition.</source>
        <target state="new">Conditional access adds an implicit null branch to an assertion, which can hide whether the object was unexpectedly null. A separate null assertion makes failures identify the violated condition.</target>
        <note>{Locked="null"}</note>
      </trans-unit>
      <trans-unit id="AssertionArgsShouldAvoidConditionalAccessMessageFormat">
        <source>Prefer adding an additional assertion that checks for null</source>
        <target state="translated">null을 확인하는 추가 어설션을 추가하는 것이 좋습니다.</target>
        <note>{Locked="null"}</note>
      </trans-unit>
      <trans-unit id="AssertionArgsShouldAvoidConditionalAccessTitle">
        <source>Avoid conditional access in assertions</source>
        <target state="translated">어설션에서 조건부 액세스 방지</target>
        <note />
      </trans-unit>
      <trans-unit id="AssertionArgsShouldBePassedInCorrectOrderDescription">
        <source>'Assert.AreEqual', 'Assert.AreNotEqual', 'Assert.AreSame' and 'Assert.AreNotSame' expects the expected value to be passed first and the actual value to be passed as second argument.</source>
        <target state="translated">'Assert.AreEqual', 'Assert.AreNotEqual', 'Assert.AreSame' 및 'Assert.AreNotSame'에는 expected 값이 먼저 전달되고 actual 값이 두 번째 인수로 전달되어야 합니다.</target>
        <note>{Locked="Assert.AreNotEqual"}{Locked="Assert.AreNotSame"}{Locked="Assert.AreEqual"}{Locked="Assert.AreSame"}{Locked="actual"}{Locked="expected"}</note>
      </trans-unit>
      <trans-unit id="AssertionArgsShouldBePassedInCorrectOrderMessageFormat">
        <source>Assertion arguments should be passed in the correct order. 'actual' and 'expected'/'notExpected' arguments have been swapped.</source>
        <target state="translated">어설션 인수는 올바른 순서로 전달되어야 합니다. 'actual' 및 'expected'/'notExpected' 인수가 바뀌었습니다.</target>
        <note>{Locked="actual"}{Locked="expected"}{Locked="notExpected"}</note>
      </trans-unit>
      <trans-unit id="AssertionArgsShouldBePassedInCorrectOrderTitle">
        <source>Assertion arguments should be passed in the correct order</source>
        <target state="translated">어설션 인수는 올바른 순서로 전달되어야 합니다.</target>
        <note />
      </trans-unit>
      <trans-unit id="AvoidAssertAreEqualOnCollectionsDescription">
        <source>`Assert.AreEqual` and `Assert.AreNotEqual` use `EqualityComparer&lt;T&gt;.Default`. For collection-like types this relies on the type's own equality semantics instead of comparing sequence elements, so `Assert.AreSequenceEqual`/`Assert.AreNotSequenceEqual` or `Assert.AreEquivalent`/`Assert.AreNotEquivalent` are usually the better fit.</source>
        <target state="translated">`Assert.AreEqual` 및 `Assert.AreNotEqual`은 `EqualityComparer&lt;T&gt;.Default`를 사용합니다. 컬렉션과 비슷한 형식의 경우 시퀀스 요소를 비교하는 대신 형식 자체의 동등성 의미 체계를 사용하므로, 일반적으로 `Assert.AreSequenceEqual`/`Assert.AreNotSequenceEqual` 또는 `Assert.AreEquivalent`/`Assert.AreNotEquivalent`가 더 적합합니다.</target>
        <note>{Locked="EqualityComparer&lt;T&gt;.Default"}{Locked="Assert.AreNotSequenceEqual"}{Locked="Assert.AreSequenceEqual"}{Locked="Assert.AreNotEquivalent"}{Locked="Assert.AreEquivalent"}{Locked="Assert.AreNotEqual"}{Locked="Assert.AreEqual"}</note>
      </trans-unit>
      <trans-unit id="AvoidAssertAreEqualOnCollectionsMessageFormat">
        <source>`{0}` on {1} (which implements IEnumerable&lt;T&gt;) does not perform element-wise sequence comparison. Use `Assert.AreSequenceEqual` for ordered element-wise comparison, `Assert.AreSequenceEqual(..., SequenceOrder.InAnyOrder)` for unordered, or `Assert.AreEquivalent` for deep structural comparison.</source>
        <target state="translated">IEnumerable&lt;T&gt;를 구현하는 {1}의 `{0}`은(는) 요소별 시퀀스 비교를 수행하지 않습니다. 정렬된 요소별 비교에는 `Assert.AreSequenceEqual`, 정렬되지 않은 비교에는 `Assert.AreSequenceEqual(..., SequenceOrder.InAnyOrder)`, 심층 구조 비교에는 `Assert.AreEquivalent`를 사용합니다.</target>
        <note>{0} is the current assert method call. {1} is the collection type name. {Locked="Assert.AreSequenceEqual(..., SequenceOrder.InAnyOrder)"}{Locked="Assert.AreSequenceEqual"}{Locked="Assert.AreEquivalent"}{Locked="IEnumerable&lt;T&gt;"}</note>
      </trans-unit>
      <trans-unit id="AvoidAssertAreEqualOnCollectionsTitle">
        <source>Avoid Assert.AreEqual on collection types</source>
        <target state="translated">컬렉션 형식에서 Assert.AreEqual 방지</target>
        <note>{Locked="Assert.AreEqual"}</note>
      </trans-unit>
      <trans-unit id="AvoidAssertAreSameWithValueTypesDescription">
        <source>Use 'Assert.AreEqual'/'Assert.AreNotEqual' instead of 'Assert.AreSame'/'Assert.AreNotSame' when comparing value types. Passing a value type to 'Assert.AreSame'/'Assert.AreNotSame' will be boxed (creating a new object). Because 'Assert.AreSame'/'Assert.AreNotSame' does the comparison by reference, 'Assert.AreSame' will fail when boxing happens, and 'Assert.AreNotSame' will always pass.</source>
        <target state="translated">값 형식을 비교할 때 'Assert.AreSame'/'Assert.AreNotSame' 대신 'Assert.AreEqual'/'Assert.AreNotEqual'을 사용합니다. 값 형식을 'Assert.AreSame'/'Assert.AreNotSame'에 전달하면 boxed(새 개체 만들기)됩니다. 'Assert.AreSame'/'Assert.AreNotSame'은 참조로 비교하므로 boxing이 발생할 때 'Assert.AreSame'이 실패하고 'Assert.AreNotSame'이 항상 전달됩니다.</target>
        <note>{Locked="Assert.AreNotEqual"}{Locked="Assert.AreNotSame"}{Locked="Assert.AreEqual"}{Locked="Assert.AreSame"}</note>
      </trans-unit>
      <trans-unit id="AvoidAssertAreSameWithValueTypesMessageFormat">
        <source>Use '{0}' instead of '{1}' when comparing value types</source>
        <target state="translated">값 형식을 비교할 때 '{1}' 대신 '{0}' 사용</target>
        <note>{0} is the preferred assertion method name. {1} is the current assertion method name.</note>
      </trans-unit>
      <trans-unit id="AvoidAssertAreSameWithValueTypesTitle">
        <source>Don't use 'Assert.AreSame' or 'Assert.AreNotSame' with value types</source>
        <target state="translated">값 형식에 'Assert.AreSame' 또는 'Assert.AreNotSame'을 사용하지 마세요.</target>
        <note>{Locked="Assert.AreNotSame"}{Locked="Assert.AreSame"}</note>
      </trans-unit>
      <trans-unit id="AvoidExplicitDynamicDataSourceTypeDescription">
        <source>Since MSTest 3.8, 'DynamicDataSourceType.AutoDetect' is the default and automatically identifies properties, methods, and fields, reducing verbosity and coupling to the member kind.</source>
        <target state="new">Since MSTest 3.8, 'DynamicDataSourceType.AutoDetect' is the default and automatically identifies properties, methods, and fields, reducing verbosity and coupling to the member kind.</target>
        <note>{Locked="MSTest 3.8"}{Locked="'DynamicDataSourceType.AutoDetect'"}</note>
      </trans-unit>
      <trans-unit id="AvoidExplicitDynamicDataSourceTypeMessageFormat">
        <source>Remove the 'DynamicDataSourceType' argument to use the default auto detect behavior</source>
        <target state="translated">기본 자동 검색 동작을 사용하려면 'DynamicDataSourceType' 인수를 제거합니다.</target>
        <note>{Locked="DynamicDataSourceType"}</note>
      </trans-unit>
      <trans-unit id="AvoidExplicitDynamicDataSourceTypeTitle">
        <source>Avoid passing an explicit 'DynamicDataSourceType' and use the default auto detect behavior</source>
        <target state="translated">명시적 'DynamicDataSourceType'을 전달하지 말고 기본 자동 검색 동작을 사용합니다.</target>
        <note>{Locked="DynamicDataSourceType"}</note>
      </trans-unit>
      <trans-unit id="AvoidThreadSleepAndTaskWaitInTestsDescription">
        <source>Synchronously blocking the current thread with 'Thread.Sleep', 'Task.Wait', 'Task.WaitAll', 'Task.WaitAny' or 'Task&lt;TResult&gt;.Result' inside test methods or test fixtures is a common source of flakiness and can also deadlock when the test framework runs tests on a SynchronizationContext that requires cooperative scheduling. Prefer 'await Task.Delay' for time-based waits and 'await' the task to observe its result.</source>
        <target state="translated">테스트 메서드 또는 테스트 픽스처 내에서 'Thread.Sleep', 'Task.Wait', 'Task.WaitAll', 'Task.WaitAny' 또는 'Task&lt;TResult&gt;.Result'를 사용하여 현재 스레드를 동기적으로 차단하는 것은 불안정성(flakiness)의 일반적인 원인이며, 테스트 프레임워크가 협조적 스케줄링이 필요한 SynchronizationContext에서 테스트를 실행할 때 교착 상태를 일으킬 수도 있습니다. 시간 기반 대기에는 'await Task.Delay'를 사용하고 결과를 확인하려면 작업을 'await'하세요.</target>
        <note>{Locked="Task&lt;TResult&gt;.Result"}{Locked="Thread.Sleep"}{Locked="Task.WaitAll"}{Locked="Task.WaitAny"}{Locked="Task.Delay"}{Locked="Task.Wait"}{Locked="await"}{Locked="await Task.Delay"}</note>
      </trans-unit>
      <trans-unit id="AvoidThreadSleepAndTaskWaitInTestsMessageFormat">
        <source>Avoid '{0}' in test code as it can cause test flakiness; consider an asynchronous alternative such as 'await Task.Delay' or 'await' the task</source>
        <target state="translated">테스트 코드에서 '{0}'은(는) 테스트 불안정성을 유발할 수 있으므로 사용하지 마세요. 'await Task.Delay'와 같은 비동기 대안을 고려하거나 작업을 'await'하세요</target>
        <note>{0} is the synchronous blocking call. {Locked="Task.Delay"}{Locked="await"}{Locked="await Task.Delay"}</note>
      </trans-unit>
      <trans-unit id="AvoidThreadSleepAndTaskWaitInTestsTitle">
        <source>Avoid synchronously blocking calls such as 'Thread.Sleep', 'Task.Wait', 'Task.WaitAll', 'Task.WaitAny' or 'Task&lt;TResult&gt;.Result' in test code</source>
        <target state="translated">테스트 코드에서 'Thread.Sleep', 'Task.Wait', 'Task.WaitAll', 'Task.WaitAny' 또는 'Task&lt;TResult&gt;.Result'와 같은 동기 차단 호출을 사용하지 마세요</target>
        <note>{Locked="Task&lt;TResult&gt;.Result"}{Locked="Thread.Sleep"}{Locked="Task.WaitAll"}{Locked="Task.WaitAny"}{Locked="Task.Wait"}</note>
      </trans-unit>
      <trans-unit id="AvoidUsingAssertsInAsyncVoidContextDescription">
        <source>Do not assert inside 'async void' methods, local functions, or lambdas. Exceptions that are thrown in this context will be unhandled exceptions. When using VSTest under .NET Framework, they will be silently swallowed. When using Microsoft.Testing.Platform or VSTest under modern .NET, they may crash the process.</source>
        <target state="translated">'async void' 메서드, 로컬 함수 또는 람다 내에서 어설션하지 마십시오. 이 컨텍스트에서 throw된 예외는 처리되지 않은 예외가 됩니다. .NET Framework 아래에서 VSTest를 사용하면 자동으로 무시됩니다. 최신 .NET에서 Microsoft.Testing.Platform 또는 VSTest를 사용하는 경우 프로세스가 중단될 수 있습니다.</target>
        <note>{Locked="Microsoft.Testing.Platform"}{Locked=".NET Framework"}{Locked="VSTest"}{Locked=".NET"}{Locked="async void"}{Locked="void"}{Locked="async"}</note>
      </trans-unit>
      <trans-unit id="AvoidUsingAssertsInAsyncVoidContextMessageFormat">
        <source>Do not assert inside 'async void' methods, local functions, or lambdas because they may not fail the test</source>
        <target state="translated">테스트에 실패할 수 없으므로 'async void' 메서드, 로컬 함수 또는 람다 내에서 어설션하지 마세요.</target>
        <note>{Locked="async void"}{Locked="void"}{Locked="async"}</note>
      </trans-unit>
      <trans-unit id="AvoidUsingAssertsInAsyncVoidContextTitle">
        <source>Do not assert inside 'async void' contexts</source>
        <target state="translated">'async void' 컨텍스트 내에서 어설션 안 함</target>
        <note>{Locked="async void"}{Locked="void"}{Locked="async"}</note>
      </trans-unit>
      <trans-unit id="ClassCleanupShouldBeValidDescription">
        <source>Methods marked with '[ClassCleanup]' should follow the following layout to be valid:
-it can't be declared on a generic class without the 'InheritanceBehavior' mode is set
-it should be 'public'
-it should be 'static'
-it should not be 'async void'
-it should not be a special method (finalizer, operator...).
-it should not be generic
-it should either not take any parameter, or take a single parameter of type 'TestContext'
-return type should be 'void', 'Task' or 'ValueTask'
-'InheritanceBehavior.BeforeEachDerivedClass' attribute parameter should be specified if the class is 'abstract'
-'InheritanceBehavior.BeforeEachDerivedClass' attribute parameter should not be specified if the class is 'sealed'

The type declaring these methods should also respect the following rules:
-The type should be a class
-The class should be 'public' or 'internal' (if the test project is using the '[DiscoverInternals]' attribute)
-The class shouldn't be 'static'
-If the class is 'sealed', it should be marked with '[TestClass]' (or a derived attribute)
-the class should not be generic.</source>
        <target state="translated">'[ClassCleanup]'으로 표시된 메서드가 유효하려면 다음 레이아웃을 따라야 합니다.
- 'InheritanceBehavior' 모드가 설정되지 않은 제네릭 class에서 선언할 수 없습니다.
- 'public'이어야 합니다. 
- 'static'이어야 합니다.
- 'async void'가 아니어야 합니다.
- 특수 메서드(종료자, 연산자...)가 아니어야 합니다.
- 제네릭이 아니어야 합니다.
- 매개 변수를 사용하거나 'TestContext' 형식의 단일 매개 변수를 사용해서는 안 됩니다.
- 반환 형식은 'void', 'Task' 또는 'ValueTask'여야 합니다.
- class가 'abstract'인 경우 'InheritanceBehavior.BeforeEachDerivedClass' 특성 매개 변수를 지정해야 합니다.
- class가 'sealed'인 경우 'InheritanceBehavior.BeforeEachDerivedClass' 특성 매개 변수를 지정하면 안 됩니다.

이러한 메서드를 선언하는 형식은 다음 규칙도 준수해야 합니다.
- 형식은 class여야 합니다.
- class는 'public' 또는 'internal'이어야 합니다(테스트 프로젝트에서 '[DiscoverInternals]' 특성을 사용하는 경우).
- class는 'static'이 되어서는 안 됩니다.
- class가 'sealed'인 경우 '[TestClass]'(또는 파생 특성)로 표시되어야 합니다.
- class는 제네릭이 아니어야 합니다.</target>
        <note>{Locked="InheritanceBehavior.BeforeEachDerivedClass"}{Locked="[DiscoverInternals]"}{Locked="[ClassCleanup]"}{Locked="[TestClass]"}{Locked="TestContext"}{Locked="ValueTask"}{Locked="Task"}{Locked="public"}{Locked="internal"}{Locked="static"}{Locked="void"}{Locked="async void"}{Locked="abstract"}{Locked="sealed"}{Locked="async"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="ClassCleanupShouldBeValidMessageFormat">
        <source>ClassCleanup method '{0}' signature is invalid</source>
        <target state="translated">ClassCleanup 메서드 '{0}' 시그니처가 잘못되었습니다.</target>
        <note>{0} is the method name. {Locked="ClassCleanup"}</note>
      </trans-unit>
      <trans-unit id="ClassCleanupShouldBeValidTitle">
        <source>ClassCleanup methods should have valid layout</source>
        <target state="translated">ClassCleanup 메서드에는 유효한 레이아웃이 있어야 합니다.</target>
        <note>{Locked="ClassCleanup"}</note>
      </trans-unit>
      <trans-unit id="ClassInitializeShouldBeValidDescription">
        <source>Methods marked with '[ClassInitialize]' should follow the following layout to be valid:
-it can't be declared on a generic class without the 'InheritanceBehavior' mode is set
-it should be 'public'
-it should be 'static'
-it should not be 'async void'
-it should not be a special method (finalizer, operator...).
-it should not be generic
-it should take one parameter of type 'TestContext'
-return type should be 'void', 'Task' or 'ValueTask'
-'InheritanceBehavior.BeforeEachDerivedClass' attribute parameter should be specified if the class is 'abstract'
-'InheritanceBehavior.BeforeEachDerivedClass' attribute parameter should not be specified if the class is 'sealed'

The type declaring these methods should also respect the following rules:
-The type should be a class
-The class should be 'public' or 'internal' (if the test project is using the '[DiscoverInternals]' attribute)
-The class shouldn't be 'static'
-If the class is 'sealed', it should be marked with '[TestClass]' (or a derived attribute)
-the class should not be generic.</source>
        <target state="translated">'[ClassInitialize]'로 표시된 메서드가 유효하려면 다음 레이아웃을 따라야 합니다.
-'InheritanceBehavior' 모드가 설정되지 않은 제네릭 class에서 선언할 수 없습니다.
- 'public'이어야 합니다. 
- 'static'이어야 합니다.
- 'async void'가 아니어야 합니다.
- 특수 메서드(종료자, 연산자...)가 아니어야 합니다.
- 제네릭이 아니어야 합니다.
- 'TestContext' 형식의 매개 변수를 하나 사용해야 합니다.
- 반환 형식은 'void', 'Task' 또는 'ValueTask'여야 합니다.
- class가 'abstract'인 경우 'InheritanceBehavior.BeforeEachDerivedClass' 특성 매개 변수를 지정해야 합니다.
- class가 'sealed'인 경우 'InheritanceBehavior.BeforeEachDerivedClass' 특성 매개 변수를 지정하면 안 됩니다.

이러한 메서드를 선언하는 형식은 다음 규칙도 준수해야 합니다.
-형식은 class여야 합니다.
-class는 'public' 또는 'internal'이어야 합니다(테스트 프로젝트에서 '[DiscoverInternals]' 특성을 사용하는 경우).
-class는 'static'이 되어서는 안 됩니다.
-class가 'sealed'인 경우 '[TestClass]'(또는 파생 특성)로 표시되어야 합니다.
-class는 제네릭이 아니어야 합니다.</target>
        <note>{Locked="InheritanceBehavior.BeforeEachDerivedClass"}{Locked="[DiscoverInternals]"}{Locked="[ClassInitialize]"}{Locked="[TestClass]"}{Locked="TestContext"}{Locked="ValueTask"}{Locked="Task"}{Locked="public"}{Locked="internal"}{Locked="static"}{Locked="void"}{Locked="async void"}{Locked="abstract"}{Locked="sealed"}{Locked="async"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="ClassInitializeShouldBeValidMessageFormat">
        <source>ClassInitialize method '{0}' signature is invalid</source>
        <target state="translated">ClassInitialize 메서드 '{0}' 시그니처가 잘못되었습니다.</target>
        <note>{0} is the method name. {Locked="ClassInitialize"}</note>
      </trans-unit>
      <trans-unit id="ClassInitializeShouldBeValidTitle">
        <source>ClassInitialize methods should have valid layout</source>
        <target state="translated">ClassInitialize 메서드에는 유효한 레이아웃이 있어야 합니다.</target>
        <note>{Locked="ClassInitialize"}</note>
      </trans-unit>
      <trans-unit id="CollectionAssertToAssertDescription">
        <source>'CollectionAssert' methods have equivalent 'Assert' counterparts. Using one assertion API improves consistency and discoverability.</source>
        <target state="new">'CollectionAssert' methods have equivalent 'Assert' counterparts. Using one assertion API improves consistency and discoverability.</target>
        <note>{Locked="'CollectionAssert'"}{Locked="'Assert'"}{Locked="API"}</note>
      </trans-unit>
      <trans-unit id="CollectionAssertToAssertMessageFormat">
        <source>Use 'Assert.{0}' instead of 'CollectionAssert.{1}'</source>
        <target state="translated">'CollectionAssert.{1}' 대신 'Assert.{0}'을(를) 사용하세요.</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">'CollectionAssert' 대신 'Assert'를 사용하세요.</target>
        <note>{Locked="CollectionAssert"}{Locked="Assert"}</note>
      </trans-unit>
      <trans-unit id="CultureMutationUnderParallelizationDescription">
        <source>'CultureInfo.DefaultThreadCurrentCulture' and 'DefaultThreadCurrentUICulture' set the default culture for the whole process, so every concurrently running test observes the change and formatting or parsing can be corrupted under in-assembly parallelization. The per-thread and ambient forms are intentionally not flagged: on modern .NET the 'Thread.CurrentThread.CurrentCulture' / 'CurrentUICulture' and 'CultureInfo.CurrentCulture' / 'CurrentUICulture' setters all assign an 'AsyncLocal'-backed value that flows with the execution context, so they do not corrupt sibling tests or leak onto later-pooled threads. Because the flagged setters are process-wide, restoring the previous value in a 'finally' does not help - concurrently running tests still observe the changed culture for the duration of the mutation; declare '[DoNotParallelize]' on the test, or avoid mutating process-wide culture, instead.</source>
        <target state="translated">'CultureInfo.DefaultThreadCurrentCulture'와 'DefaultThreadCurrentUICulture'는 전체 프로세스의 기본 문화권을 설정합니다. 따라서 동시에 실행되는 모든 테스트가 이 변경을 관찰하게 되고, 어셈블리 내 병렬화에서는 서식 지정이나 구문 분석이 손상될 수 있습니다. 스레드별 및 ambient 형식은 의도적으로 플래그를 지정하지 않습니다. 최신 .NET에서는 'Thread.CurrentThread.CurrentCulture' / 'CurrentUICulture'와 'CultureInfo.CurrentCulture' / 'CurrentUICulture' setter가 모두 실행 컨텍스트와 함께 흐르는 'AsyncLocal' 기반 값을 할당하므로, 다른 테스트를 손상시키거나 나중에 재사용되는 스레드로 값이 누출되지 않습니다. 플래그가 지정된 setter는 프로세스 전역이므로, 'finally'에서 이전 값을 복원해도 도움이 되지 않습니다. 변경이 진행되는 동안 동시에 실행되는 테스트는 여전히 변경된 문화권을 관찰하기 때문입니다. 테스트에는 '[DoNotParallelize]'를 선언하거나, 프로세스 전역 문화권 변경을 피하세요.</target>
        <note>{Locked="CultureInfo.DefaultThreadCurrentCulture"}{Locked="DefaultThreadCurrentUICulture"}{Locked="Thread.CurrentThread.CurrentCulture"}{Locked="CurrentUICulture"}{Locked="CultureInfo.CurrentCulture"}{Locked="AsyncLocal"}{Locked="[DoNotParallelize]"}</note>
      </trans-unit>
      <trans-unit id="CultureMutationUnderParallelizationMessageFormat">
        <source>'{0}' sets the default culture for the whole process, so every concurrently running test observes the change, which can corrupt formatting and parsing in tests running in parallel; avoid mutating it in a parallelized test suite, or declare '[DoNotParallelize]'</source>
        <target state="translated">'{0}'은(는) 전체 프로세스의 기본 문화권을 설정합니다. 따라서 동시에 실행되는 모든 테스트가 이 변경을 관찰하게 되고, 병렬로 실행되는 테스트에서 서식 지정과 구문 분석이 손상될 수 있습니다. 병렬화된 테스트 도구 모음에서는 이를 변경하지 마세요. 또는 '[DoNotParallelize]'를 선언하세요.</target>
        <note>{0} is the mutated API (for example 'CultureInfo.DefaultThreadCurrentCulture'). {Locked="[DoNotParallelize]"}</note>
      </trans-unit>
      <trans-unit id="CultureMutationUnderParallelizationTitle">
        <source>Avoid mutating process-wide culture in a parallelized test</source>
        <target state="translated">병렬로 실행되는 테스트에서는 프로세스 전반의 문화권을 변경하지 마세요.</target>
        <note />
      </trans-unit>
      <trans-unit id="CurrentDirectoryMutationUnderParallelizationDescription">
        <source>The current directory is process-global on every operating system and, unlike culture, has no thread-scoped or async-scoped equivalent. A test that changes it corrupts the working directory of every test running concurrently, and relative paths resolved elsewhere in the suite silently point at the wrong location. A '[ResourceLock]' serializes the contending tests and makes the mutation safe, but it remains a design smell in a parallel suite: prefer passing absolute paths so the current directory never needs to change.</source>
        <target state="translated">현재 디렉터리는 모든 운영 체제에서 프로세스 전역이며, 문화권과 달리 스레드 범위나 비동기 범위에 해당하는 대응 항목이 없습니다. 이를 변경하는 테스트는 동시에 실행 중인 모든 테스트의 작업 디렉터리를 손상시키고, 도구 모음의 다른 곳에서 해석되는 상대 경로가 조용히 잘못된 위치를 가리키게 됩니다. [ResourceLock]'는 충돌하는 테스트를 직렬화하고 변경을 안전하게 만들지만, 병렬 도구 모음에서는 여전히 설계상 좋지 않은 패턴입니다. 현재 디렉터리를 바꿀 필요가 없도록 절대 경로를 전달하는 것이 좋습니다.</target>
        <note>{Locked="[ResourceLock]"}</note>
      </trans-unit>
      <trans-unit id="CurrentDirectoryMutationUnderParallelizationMessageFormat">
        <source>'{0}' changes the process-global current directory, which has no per-thread equivalent and is observed by every concurrently running test; avoid mutating it in a parallelized test suite (declare '[ResourceLock(WellKnownResources.CurrentDirectory)]' to at least coordinate, or '[DoNotParallelize]')</source>
        <target state="translated">'{0}'은(는) 프로세스 전역 현재 디렉터리를 변경합니다. 이 디렉터리는 스레드별 대응 항목이 없고 동시에 실행되는 모든 테스트에서 관찰됩니다. 병렬화된 테스트 도구 모음에서는 이를 변경하지 마세요. 최소한 '[ResourceLock(WellKnownResources.CurrentDirectory)]'로 조정하거나 '[DoNotParallelize]'를 지정하세요.</target>
        <note>{0} is the mutated API (for example 'Directory.SetCurrentDirectory'). {Locked="[ResourceLock]"}{Locked="WellKnownResources"}{Locked="[DoNotParallelize]"}</note>
      </trans-unit>
      <trans-unit id="CurrentDirectoryMutationUnderParallelizationTitle">
        <source>Avoid changing the current directory in a parallelized test</source>
        <target state="translated">병렬로 실행되는 테스트에서는 현재 디렉터리를 변경하지 마세요.</target>
        <note />
      </trans-unit>
      <trans-unit id="DependsOnShouldBeValidDescription">
        <source>A '[DependsOn]' attribute references a test by name. A reference that matches no test is deliberately non-fatal at run time, so that running a subset of the suite stays possible, which means a typo or a rename silently drops the declared ordering. This analyzer reports the problems that can be decided at build time: a method that does not exist on the referenced type, a target that is not a test, a test that depends on itself, a dependency cycle visible in the compilation, a reference to a type from another assembly (dependencies are resolved within a single test source), and an attribute applied where it has no effect.</source>
        <target state="translated">'[DependsOn]' 특성은 이름으로 테스트를 참조합니다. 테스트와 일치하지 않는 참조는 런타임에서 의도적으로 치명적이지 않으므로, 테스트 모음의 일부만 실행해도 됩니다. 그 대신 오타나 이름 변경이 선언된 순서를 조용히 없앨 수 있습니다. 이 분석기는 빌드 시점에 판단할 수 있는 문제를 보고합니다. 여기에는 참조된 형식에 없는 메서드, 테스트가 아닌 대상, 자기 자신에 종속된 테스트, 컴파일에서 확인할 수 있는 종속성 순환, 다른 어셈블리의 형식에 대한 참조(종속성은 단일 테스트 소스 내에서 해결됨), 그리고 효과가 없는 위치에 적용된 특성이 포함됩니다.</target>
        <note>{Locked="[DependsOn]"}</note>
      </trans-unit>
      <trans-unit id="DependsOnShouldBeValidMessageFormat_AbstractTarget">
        <source>'[DependsOn]' references abstract type '{0}'; its tests run under each derived test class rather than under '{0}', so the dependency is ignored at run time</source>
        <target state="translated">'[DependsOn]'은 추상 형식 '{0}'을(를) 참조합니다. 해당 테스트는 '{0}' 아래가 아니라 각 파생 테스트 클래스에서 실행되므로 런타임에 종속성이 무시됩니다.</target>
        <note>{0} is the referenced type name. {Locked="[DependsOn]"}</note>
      </trans-unit>
      <trans-unit id="DependsOnShouldBeValidMessageFormat_Cycle">
        <source>'[DependsOn]' declares the dependency cycle '{0}', which fails every test in the cycle at run time</source>
        <target state="translated">'[DependsOn]'은 종속성 순환 '{0}'을(를) 선언합니다. 이 순환에 있는 모든 테스트는 런타임에 실패합니다.</target>
        <note>{0} is the cycle path, for example 'MyTests.A &gt; MyTests.B &gt; MyTests.A'. {Locked="[DependsOn]"}</note>
      </trans-unit>
      <trans-unit id="DependsOnShouldBeValidMessageFormat_MethodNotFound">
        <source>'[DependsOn]' references method '{1}', which does not exist on type '{0}'</source>
        <target state="translated">'[DependsOn]'은 형식 '{1}'에 없는 메서드 '{0}'을(를) 참조합니다.</target>
        <note>{0} is the referenced type name. {1} is the referenced method name. {Locked="[DependsOn]"}</note>
      </trans-unit>
      <trans-unit id="DependsOnShouldBeValidMessageFormat_NoEffect">
        <source>'[DependsOn]' has no effect because '{0}' is not a test method</source>
        <target state="translated">'{0}'이(가) 테스트 메서드가 아니므로 '[DependsOn]'은 효과가 없습니다.</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">검색에서 '{0}' 아래의 테스트를 실행하지 않으므로 '[DependsOn]'은 효과가 없습니다.</target>
        <note>{0} is the name of the class the attribute is applied to. {Locked="[DependsOn]"}</note>
      </trans-unit>
      <trans-unit id="DependsOnShouldBeValidMessageFormat_NotATestClass">
        <source>'[DependsOn]' references type '{0}', which is not a test class, so the dependency is ignored at run time</source>
        <target state="translated">'[DependsOn]'은 테스트 클래스가 아닌 형식 '{0}'을(를) 참조하므로 런타임에 종속성이 무시됩니다.</target>
        <note>{0} is the referenced type name. {Locked="[DependsOn]"}</note>
      </trans-unit>
      <trans-unit id="DependsOnShouldBeValidMessageFormat_NotATestMethod">
        <source>'[DependsOn]' references '{0}.{1}', which is not a test method, so the dependency is ignored at run time</source>
        <target state="translated">'[DependsOn]'은 테스트 메서드가 아닌 '{0}.{1}'을(를) 참조하므로 런타임에 종속성이 무시됩니다.</target>
        <note>{0} is the referenced type name. {1} is the referenced method name. {Locked="[DependsOn]"}</note>
      </trans-unit>
      <trans-unit id="DependsOnShouldBeValidMessageFormat_OtherAssembly">
        <source>'[DependsOn]' references type '{0}' from another assembly; dependencies are resolved within a single test source, so the dependency is ignored at run time</source>
        <target state="translated">'[DependsOn]'은 다른 어셈블리의 형식 '{0}'을(를) 참조합니다. 종속성은 단일 테스트 소스 내에서 해결되므로 런타임에 종속성이 무시됩니다.</target>
        <note>{0} is the referenced type name. {Locked="[DependsOn]"}</note>
      </trans-unit>
      <trans-unit id="DependsOnShouldBeValidMessageFormat_SelfReference">
        <source>'[DependsOn]' makes '{0}' depend on itself, which is a dependency cycle and fails the test at run time</source>
        <target state="translated">'[DependsOn]'은 '{0}'이(가) 자기 자신에 종속되도록 지정합니다. 이는 종속성 순환이며 런타임에 테스트가 실패합니다.</target>
        <note>{0} is the test method name. {Locked="[DependsOn]"}</note>
      </trans-unit>
      <trans-unit id="DependsOnShouldBeValidTitle">
        <source>'[DependsOn]' arguments should be valid</source>
        <target state="translated">'[DependsOn]' 인수는 올바른 값이어야 합니다.</target>
        <note>{Locked="[DependsOn]"}</note>
      </trans-unit>
      <trans-unit id="DoNotNegateBooleanAssertionDescription">
        <source>Using the opposite assertion directly makes the test easier to read and produces clearer failure diagnostics.</source>
        <target state="new">Using the opposite assertion directly makes the test easier to read and produces clearer failure diagnostics.</target>
        <note />
      </trans-unit>
      <trans-unit id="DoNotStoreStaticTestContextAnalyzerDescription">
        <source>The TestContext passed to assembly or class initialization is specific to that context and is not updated for each test execution. Reusing it in a 'static' member can expose stale context.</source>
        <target state="new">The TestContext passed to assembly or class initialization is specific to that context and is not updated for each test execution. Reusing it in a 'static' member can expose stale context.</target>
        <note>{Locked="TestContext"}{Locked="'static'"}</note>
      </trans-unit>
      <trans-unit id="MemberConditionShouldBeValidDescription">
        <source>The members referenced by a '[MemberCondition]' attribute must exist on the referenced type, be 'public static', return 'bool', and (for methods) be parameterless. The attribute throws at runtime when these rules are violated; this analyzer surfaces the same problems at build time so typos and refactors do not silently break test gating.</source>
        <target state="translated">'[MemberCondition]' 특성이 참조하는 멤버는 참조된 형식에 있어야 합니다. 또한 'public static'이어야 하고, 'bool'을 반환해야 하며, 메서드인 경우 매개 변수가 없어야 합니다. 이러한 규칙을 위반하면 특성은 런타임에 예외를 throw합니다. 이 분석기는 빌드 시점에 같은 문제를 알려 주므로, 오타나 리팩터링 때문에 테스트 게이팅이 조용히 깨지는 일을 막을 수 있습니다.</target>
        <note>{Locked="[MemberCondition]"}{Locked="public static"}{Locked="bool"}</note>
      </trans-unit>
      <trans-unit id="MemberConditionShouldBeValidMessageFormat_MemberNotFound">
        <source>'[MemberCondition]' member '{0}.{1}' cannot be found</source>
        <target state="translated">'[MemberCondition]' 멤버 '{0}.{1}'을(를) 찾을 수 없습니다.</target>
        <note>{0} is the containing type name. {1} is the member name. {Locked="[MemberCondition]"}</note>
      </trans-unit>
      <trans-unit id="MemberConditionShouldBeValidMessageFormat_MemberNotPublic">
        <source>'[MemberCondition]' referenced member '{0}.{1}' must be 'public'</source>
        <target state="translated">'[MemberCondition]'에서 참조된 멤버 '{0}.{1}'은(는) '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]'에서 참조된 멤버 '{0}.{1}'은(는) '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]'에서 참조된 멤버 '{0}.{1}'은(는) 속성, 필드 또는 매개 변수 없는 메서드여야 합니다.</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]'에서 참조된 멤버 '{0}.{1}'은(는) '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]'에서 참조된 메서드 '{0}.{1}'은(는) 매개 변수가 없어야 합니다.</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]'에서 참조된 속성 '{0}.{1}'에는 getter가 있어야 합니다.</target>
        <note>{0} is the containing type name. {1} is the property name. {Locked="[MemberCondition]"}</note>
      </trans-unit>
      <trans-unit id="MemberConditionShouldBeValidTitle">
        <source>'[MemberCondition]' arguments should be valid</source>
        <target state="translated">'[MemberCondition]' 인수는 올바른 값이어야 합니다.</target>
        <note>{Locked="[MemberCondition]"}</note>
      </trans-unit>
      <trans-unit id="DataRowShouldBeValidDescription">
        <source>DataRow entry should have the following layout to be valid:
- should only be set on a test method;
- argument count should match method argument count;
- argument type should match method argument type.</source>
        <target state="translated">DataRow 항목이 유효하려면 다음과 같은 레이아웃이 있어야 합니다.
- 테스트 메서드에만 설정해야 합니다.
- 인수 개수가 메서드 인수 개수와 일치해야 합니다.
- 인수 형식이 메서드 인수 형식과 일치해야 합니다.</target>
        <note>{Locked="DataRow"}</note>
      </trans-unit>
      <trans-unit id="DataRowShouldBeValidMessageFormat_ArgumentCountMismatch">
        <source>DataRow argument count should match method parameter count (constructor arguments: {0}, method parameters: {1})</source>
        <target state="translated">DataRow 인수 개수는 메서드 매개 변수 개수(생성자 인수: {0}, 메서드 매개 변수: {1})와 일치해야 합니다.</target>
        <note>{0} is the number of constructor arguments. {1} is the number of method parameters. {Locked="DataRow"}</note>
      </trans-unit>
      <trans-unit id="DataRowShouldBeValidMessageFormat_ArgumentTypeMismatch">
        <source>DataRow argument types do not match method parameter types. {0}</source>
        <target state="translated">DataRow 인수 형식이 메서드 매개 변수 형식과 일치하지 않습니다. {0}</target>
        <note>{0} is the argument type mismatch details. {Locked="DataRow"}</note>
      </trans-unit>
      <trans-unit id="DataRowShouldBeValidMessageFormat_ParameterMismatch">
        <source>Parameter '{0}' expects type '{1}', but the provided value has type '{2}'</source>
        <target state="translated">'{0}' 매개 변수에는 '{1}' 형식이 필요한데 제공된 값의 형식은 '{2}'입니다.</target>
        <note>{0} is the parameter name. {1} is the expected parameter type. {2} is the provided value type.</note>
      </trans-unit>
      <trans-unit id="DataRowShouldBeValidMessageFormat_GenericTypeArgumentConflictingTypes">
        <source>Found two conflicting types for generic parameter '{0}'. The conflicting types are '{1}' and '{2}'.</source>
        <target state="translated">제네릭 매개 변수 '{0}' 충돌하는 두 가지 형식을 찾았습니다. 충돌하는 형식은 '{1}' '{2}'.</target>
        <note>{0} is the generic type parameter name. {1} and {2} are the conflicting type names.</note>
      </trans-unit>
      <trans-unit id="DataRowShouldBeValidMessageFormat_GenericTypeArgumentNotResolved">
        <source>The type of the generic parameter '{0}' could not be inferred.</source>
        <target state="translated">제네릭 매개 변수 '{0}' 형식을 유추할 수 없습니다.</target>
        <note>{0} is the generic type parameter name.</note>
      </trans-unit>
      <trans-unit id="DataRowShouldBeValidMessageFormat_OnTestMethod">
        <source>DataRow should only be set on a test method</source>
        <target state="translated">DataRow는 테스트 메서드에서만 설정해야 함</target>
        <note>{Locked="DataRow"}</note>
      </trans-unit>
      <trans-unit id="DataRowShouldBeValidTitle">
        <source>DataRow should be valid</source>
        <target state="translated">DataRow는 유효해야 함</target>
        <note>{Locked="DataRow"}</note>
      </trans-unit>
      <trans-unit id="DoNotNegateBooleanAssertionFix">
        <source>Use 'Assert.{0}' instead</source>
        <target state="translated">대신 'Assert.{0}' 사용</target>
        <note>{0} is the assert method name. {Locked="Assert"}</note>
      </trans-unit>
      <trans-unit id="DoNotNegateBooleanAssertionFixAllTitle">
        <source>Use proper Assert methods for all negated assertions</source>
        <target state="translated">부정된 모든 어설션에 적절한 Assert 메서드 사용</target>
        <note>{Locked="Assert"}</note>
      </trans-unit>
      <trans-unit id="DoNotNegateBooleanAssertionMessageFormat">
        <source>Do not negate boolean assertions, instead use the opposite assertion</source>
        <target state="translated">부울 어설션을 부정하지 말고 반대 어설션을 사용하세요</target>
        <note />
      </trans-unit>
      <trans-unit id="DoNotNegateBooleanAssertionTitle">
        <source>Do not negate boolean assertions</source>
        <target state="translated">부울 어설션 부정하지 마세요</target>
        <note />
      </trans-unit>
      <trans-unit id="DoNotStoreStaticTestContextAnalyzerMessageFormat">
        <source>Do not store TestContext in a static member</source>
        <target state="translated">TestContext를 static 멤버에 저장하지 마세요</target>
        <note>{Locked="TestContext"}{Locked="static"}</note>
      </trans-unit>
      <trans-unit id="DoNotStoreStaticTestContextAnalyzerTitle">
        <source>Do not store TestContext in a static member</source>
        <target state="translated">TestContext를 static 멤버에 저장하지 마세요</target>
        <note>{Locked="TestContext"}{Locked="static"}</note>
      </trans-unit>
      <trans-unit id="DoNotUseShadowingDescription">
        <source>Shadowing test members could cause testing issues (such as NRE).</source>
        <target state="translated">테스트 멤버를 숨기면 테스트 문제(예: NRE)가 발생할 수 있습니다.</target>
        <note />
      </trans-unit>
      <trans-unit id="DoNotUseShadowingMessageFormat">
        <source>Member '{0}' already exists in the base class</source>
        <target state="translated">멤버 '{0}'이(가) 기본 class에 이미 있습니다.</target>
        <note>{0} is the member name. {Locked="class"}</note>
      </trans-unit>
      <trans-unit id="DoNotUseShadowingTitle">
        <source>Do not use shadowing</source>
        <target state="translated">섀도 사용 안 함</target>
        <note />
      </trans-unit>
      <trans-unit id="DoNotUseSystemDescriptionAttributeDescription">
        <source>'System.ComponentModel.DescriptionAttribute' has no effect in the context of tests and you likely wanted to use 'Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute' instead.</source>
        <target state="translated">'System.ComponentModel.DescriptionAttribute'는 테스트 컨텍스트에 영향을 주지 않으며 대신 'Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute'를 사용하려고 한 것 같습니다.</target>
        <note>{Locked="Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute"}{Locked="System.ComponentModel.DescriptionAttribute"}</note>
      </trans-unit>
      <trans-unit id="DoNotUseSystemDescriptionAttributeMessageFormat">
        <source>Did you mean to be using 'Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute'?</source>
        <target state="translated">'Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute'를 사용하려고 했나요?</target>
        <note>{Locked="Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute"}</note>
      </trans-unit>
      <trans-unit id="DoNotUseSystemDescriptionAttributeTitle">
        <source>'System.ComponentModel.DescriptionAttribute' has no effect on test methods</source>
        <target state="translated">'System.ComponentModel.DescriptionAttribute'는 테스트 메서드에 영향을 주지 않습니다.</target>
        <note>{Locked="System.ComponentModel.DescriptionAttribute"}</note>
      </trans-unit>
      <trans-unit id="DuplicateDataRowMessageFormat">
        <source>Do not duplicate 'DataRow' attributes. This is usually a copy/paste error. The attribute indices are '{0}' and '{1}'.</source>
        <target state="translated">'DataRow' 특성을 복제하지 마세요. 일반적으로 복사/붙여넣기 오류입니다. 특성 인덱스는 '{0}' 및 '{1}'입니다.</target>
        <note>{0} is the first duplicate attribute index. {1} is the second duplicate attribute index. {Locked="DataRow"}</note>
      </trans-unit>
      <trans-unit id="DuplicateDataRowTitle">
        <source>Avoid duplicated 'DataRow' entries</source>
        <target state="translated">중복된 'DataRow' 항목 방지</target>
        <note>{Locked="DataRow"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidDescription">
        <source>'DynamicData' entry should have the following layout to be valid:
- should only be set on a test method;
- member should be defined on the type specified;
- member should be a method if DynamicDataSourceType.Method is specified or a property otherwise.</source>
        <target state="translated">'DynamicData' 항목에는 다음과 같은 레이아웃이 있어야 합니다.
- 테스트 메서드에만 설정해야 합니다.
- 지정된 형식에 멤버를 정의해야 합니다.
- DynamicDataSourceType.Method가 지정된 경우 멤버가 메서드이거나, 그렇지 않으면 속성이어야 합니다.</target>
        <note>{Locked="DynamicDataSourceType.Method"}{Locked="DynamicData"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidMessageFormat_DataMemberSignature">
        <source>'[DynamicData]' data member '{0}.{1}' signature is invalid</source>
        <target state="translated">'[DynamicData]' 데이터 멤버 '{0}.{1}' 서명이 잘못되었습니다.</target>
        <note>{0} is the containing type name. {1} is the data member name. {Locked="[DynamicData]"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidMessageFormat_DisplayMethodSignature">
        <source>'[DynamicData]' display name method '{0}.{1}' signature is invalid</source>
        <target state="translated">'[DynamicData]' 표시 이름 메서드 '{0}.{1}' 서명이 잘못되었습니다.</target>
        <note>{0} is the containing type name. {1} is the display name method name. {Locked="[DynamicData]"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidMessageFormat_MemberMethod">
        <source>'[DynamicData]' member '{0}.{1}' should be a method</source>
        <target state="translated">'[DynamicData]' 멤버 '{0}.{1}'은(는) 메서드여야 합니다.</target>
        <note>{0} is the containing type name. {1} is the member name. {Locked="[DynamicData]"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidMessageFormat_MemberNotFound">
        <source>'[DynamicData]' member '{0}.{1}' cannot be found</source>
        <target state="translated">'[DynamicData]' 멤버 '{0}.{1}'을(를) 찾을 수 없습니다.</target>
        <note>{0} is the containing type name. {1} is the member name. {Locked="[DynamicData]"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidMessageFormat_MemberType">
        <source>'[DynamicData]' referenced member '{0}.{1}' should return 'IEnumerable&lt;object[]&gt;', 'IEnumerable&lt;Tuple&gt;` or 'IEnumerable&lt;ValueTuple&gt;'</source>
        <target state="translated">'[DynamicData]'이(가) '{0} 멤버를 참조했습니다.{1}'은(는) 'IEnumerable&lt;object[]&gt;', 'IEnumerable&lt;Tuple&gt;' 또는 'IEnumerable&lt;ValueTuple&gt;'을 반환해야 합니다.</target>
        <note>{0} is the containing type name. {1} is the member name. {Locked="IEnumerable&lt;ValueTuple&gt;"}{Locked="IEnumerable&lt;object[]&gt;"}{Locked="IEnumerable&lt;Tuple&gt;"}{Locked="[DynamicData]"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidMessageFormat_OnTestMethod">
        <source>'[DynamicData]' should only be set on a test method</source>
        <target state="translated">'[DynamicData]'는 테스트 메서드에서만 설정해야 합니다.</target>
        <note>{Locked="[DynamicData]"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidMessageFormat_SourceTypeField">
        <source>'[DynamicData]' member '{0}.{1}' is a field so you should use 'DynamicDataSourceType.AutoDetect' or 'DynamicDataSourceType.Field' (auto detect is the default when not specified explicitly, and is recommended)</source>
        <target state="translated">'[DynamicData]' 구성원 '{0}.{1}'은(는) 필드이므로 'DynamicDataSourceType.AutoDetect' 또는 'DynamicDataSourceType.Field'를 사용해야 합니다(명시적으로 지정하지 않은 경우 자동 검색이 기본값이며 권장됨).</target>
        <note>{0} is the containing type name. {1} is the member name. {Locked="DynamicDataSourceType.AutoDetect"}{Locked="DynamicDataSourceType.Field"}{Locked="[DynamicData]"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidMessageFormat_SourceTypeMethod">
        <source>'[DynamicData]' member '{0}.{1}' is a method so you should use 'DynamicDataSourceType.AutoDetect' or 'DynamicDataSourceType.Method' (auto detect is the default when not specified explicitly, and is recommended)</source>
        <target state="translated">'[DynamicData]' 멤버 '{0}.{1}'은(는) 'DynamicDataSourceType.AutoDetect' 또는 'DynamicDataSourceType.Method'를 사용해야 하는 메서드입니다.(명시적으로 지정하지 않은 경우 자동 검색이 기본값이며 권장)</target>
        <note>{0} is the containing type name. {1} is the member name. {Locked="DynamicDataSourceType.AutoDetect"}{Locked="DynamicDataSourceType.Method"}{Locked="[DynamicData]"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidMessageFormat_SourceTypeNotPropertyMethodOrField">
        <source>'[DynamicData]' member '{0}.{1}' is not a property, method, or field. Only properties, methods, and fields are supported.</source>
        <target state="translated">'[DynamicData]' 구성원 '{0}.{1}'은(는) 속성, 메서드 또는 필드가 아닙니다. 속성, 메서드 및 필드만 지원됩니다.</target>
        <note>{0} is the containing type name. {1} is the member name. {Locked="[DynamicData]"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidMessageFormat_SourceTypeNotPropertyOrMethod">
        <source>'[DynamicData]' member '{0}.{1}' is not a property nor a method. Only properties and methods are supported.</source>
        <target state="translated">'[DynamicData]' 멤버 '{0}.{1}'은(는) 속성이나 메서드가 아닙니다. 속성 및 메서드만 지원됩니다.</target>
        <note>{0} is the containing type name. {1} is the member name. {Locked="[DynamicData]"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidMessageFormat_SourceTypeProperty">
        <source>'[DynamicData]' member '{0}.{1}' is a property so you should use 'DynamicDataSourceType.AutoDetect' or 'DynamicDataSourceType.Property' (auto detect is the default when not specified explicitly, and is recommended)</source>
        <target state="translated">'[DynamicData]' 멤버 '{0}.{1}'은 속성이므로 'DynamicDataSourceType.AutoDetect' 또는 'DynamicDataSourceType.Property'를 사용해야 합니다(명시적으로 지정되지 않은 경우 자동 검색이 기본값이며 권장).</target>
        <note>{0} is the containing type name. {1} is the member name. {Locked="DynamicDataSourceType.AutoDetect"}{Locked="DynamicDataSourceType.Property"}{Locked="[DynamicData]"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidMessageFormat_TooManyMembers">
        <source>'[DynamicData]' member '{0}.{1}' is found more than once</source>
        <target state="translated">'[DynamicData]' 멤버 '{0}.{1}'을(를) 두 번 이상 찾았습니다.</target>
        <note>{0} is the containing type name. {1} is the member name. {Locked="[DynamicData]"}</note>
      </trans-unit>
      <trans-unit id="DynamicDataShouldBeValidTitle">
        <source>DynamicData should be valid</source>
        <target state="translated">DynamicData는 유효해야 합니다.</target>
        <note>{Locked="DynamicData"}</note>
      </trans-unit>
      <trans-unit id="FlowTestContextCancellationTokenDescription">
        <source>When calling async methods that have overloads accepting a CancellationToken parameter, prefer using the overload with TestContext.CancellationToken to enable cooperative cancellation and respect test timeouts.</source>
        <target state="translated">CancellationToken 매개변수를 허용하는 오버로드가 있는 async 메서드를 호출할 때는 협력적 취소를 활성화하고 테스트 시간 제한을 준수하기 위해 TestContext.CancellationToken이 있는 오버로드를 사용하는 것이 좋습니다.</target>
        <note>{Locked="TestContext.CancellationToken"}{Locked="CancellationToken"}{Locked="async"}</note>
      </trans-unit>
      <trans-unit id="FlowTestContextCancellationTokenMessageFormat">
        <source>Consider using the overload that accepts a CancellationToken and pass 'TestContext.CancellationToken'</source>
        <target state="translated">CancellationToken을 수락하고 'TestContext.CancellationToken'을 전달하는 오버로드를 사용하는 것이 좋습니다.</target>
        <note>{Locked="TestContext.CancellationToken"}{Locked="CancellationToken"}</note>
      </trans-unit>
      <trans-unit id="FlowTestContextCancellationTokenTitle">
        <source>Flow TestContext.CancellationToken to async operations</source>
        <target state="translated">async 작업으로 TestContext.CancellationToken 흐름</target>
        <note>{Locked="TestContext.CancellationToken"}{Locked="async"}</note>
      </trans-unit>
      <trans-unit id="GlobalTestFixtureShouldBeValidDescription">
        <source>Methods marked with '[GlobalTestInitialize]' or '[GlobalTestCleanup]' should follow the following layout to be valid:
-it can't be declared on a generic class
-it should be 'public'
-it should be 'static'
-it should not be 'async void'
-it should not be a special method (finalizer, operator...).
-it should not be generic
-it should take one parameter of type 'TestContext'
-return type should be 'void', 'Task' or 'ValueTask'

The type declaring these methods should also respect the following rules:
-The type should be a class
-The class should be 'public'
-The class should be marked with '[TestClass]' (or a derived attribute)
-the class should not be generic.</source>
        <target state="translated">'[GlobalTestInitialize]' 또는 '[GlobalTestCleanup]'으로 표시된 메서드는 다음 레이아웃을 따라야 유효합니다.
- 제네릭 class에서 선언할 수 없습니다.
- 'public'이어야 합니다. 
- 'static'이어야 합니다.
- 'async void'가 아니어야 합니다.
- 특수 메서드(종료자, 연산자...)가 아니어야 합니다.
- 제네릭이 아니어야 합니다.
- 'TestContext' 형식의 매개 변수를 하나 사용해야 합니다.
- 반환 형식은 'void', 'Task' 또는 'ValueTask'여야 합니다.

이러한 메서드를 선언하는 형식은 다음 규칙도 준수해야 합니다.
-형식은 class여야 합니다.
- class는 'public'이어야 합니다.
-class는 '[TestClass]'(또는 파생 특성)로 표시되어야 합니다.
- class는 제네릭이 아니어야 합니다.</target>
        <note>{Locked="[GlobalTestInitialize]"}{Locked="[GlobalTestCleanup]"}{Locked="[TestClass]"}{Locked="TestContext"}{Locked="ValueTask"}{Locked="Task"}{Locked="public"}{Locked="static"}{Locked="void"}{Locked="async void"}{Locked="async"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="GlobalTestFixtureShouldBeValidMessageFormat">
        <source>Global test fixture method '{0}' signature is invalid</source>
        <target state="translated">전역 테스트 fixture 메서드 '{0}' 시그니처가 잘못되었습니다.</target>
        <note>{0} is the method name.</note>
      </trans-unit>
      <trans-unit id="GlobalTestFixtureShouldBeValidTitle">
        <source>GlobalTestInitialize and GlobalTestCleanup methods should have valid layout</source>
        <target state="translated">GlobalTestInitialize 및 GlobalTestCleanup 메서드에는 유효한 레이아웃이 있어야 합니다.</target>
        <note>{Locked="GlobalTestInitialize"}{Locked="GlobalTestCleanup"}</note>
      </trans-unit>
      <trans-unit id="IgnoreShouldHaveJustificationDescription">
        <source>An '[Ignore]' attribute applied to a test method or test class should include a non-empty message explaining why the test or class is ignored. A justification message makes it easier to triage skipped tests, helps reviewers understand the intent, and prevents tests from being silently disabled forever.</source>
        <target state="translated">테스트 메서드 또는 테스트 class에 적용된 '[Ignore]' 특성에는 해당 테스트 또는 class가 무시되는 이유를 설명하는 비어 있지 않은 메시지가 포함되어야 합니다. 근거 메시지는 건너뛴 테스트를 더 쉽게 분류할 수 있게 하고, 검토자가 의도를 이해하는 데 도움이 되며, 테스트가 모르는 사이에 영구히 비활성화되는 것을 방지합니다.</target>
        <note>{Locked="[Ignore]"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="IgnoreShouldHaveJustificationMessageFormat">
        <source>'[Ignore]' should specify a message explaining why '{0}' is ignored</source>
        <target state="translated">'[Ignore]'는 '{0}'이(가) 무시되는 이유를 설명하는 메시지를 지정해야 합니다</target>
        <note>{0} is the ignored target name. {Locked="[Ignore]"}</note>
      </trans-unit>
      <trans-unit id="IgnoreShouldHaveJustificationTitle">
        <source>'[Ignore]' should specify a justification</source>
        <target state="translated">'[Ignore]'는 근거를 지정해야 합니다</target>
        <note>{Locked="[Ignore]"}</note>
      </trans-unit>
      <trans-unit id="IgnoreStringMethodReturnValueDescription">
        <source>Methods like Contains, StartsWith, and EndsWith return boolean values that indicate whether the condition was met. Ignoring these return values is likely a mistake.</source>
        <target state="translated">Contains, StartsWith 및 EndsWith와 같은 메서드는 조건이 충족되었는지 여부를 나타내는 부울 값을 반환합니다. 이 반환 값을 무시하는 것은 아마 실수일 것입니다.</target>
        <note>{Locked="StartsWith"}{Locked="Contains"}{Locked="EndsWith"}</note>
      </trans-unit>
      <trans-unit id="IgnoreStringMethodReturnValueMessageFormat">
        <source>The return value of '{0}' should not be ignored</source>
        <target state="translated">'{0}'의 반환 값은 무시하면 안 됩니다.</target>
        <note>{0} is the string method name.</note>
      </trans-unit>
      <trans-unit id="IgnoreStringMethodReturnValueTitle">
        <source>Do not ignore the return value of string methods</source>
        <target state="translated">문자열 메서드의 반환 값을 무시하지 마세요.</target>
        <note />
      </trans-unit>
      <trans-unit id="PreferAssertFailOverAlwaysFalseConditionsDescription">
        <source>'Assert.Fail' makes an intentional failure explicit and allows the failure message to document why the test cannot continue.</source>
        <target state="new">'Assert.Fail' makes an intentional failure explicit and allows the failure message to document why the test cannot continue.</target>
        <note>{Locked="'Assert.Fail'"}</note>
      </trans-unit>
      <trans-unit id="PreferAssertFailOverAlwaysFalseConditionsMessageFormat">
        <source>Use 'Assert.Fail' instead of an always-failing 'Assert.{0}' assert</source>
        <target state="translated">항상 실패하는 'Assert.{0}' 어설션 대신 'Assert.Fail'을 사용합니다.</target>
        <note>{0} is the assert method name. {Locked="Assert.Fail"}{Locked="Assert"}</note>
      </trans-unit>
      <trans-unit id="PreferAssertFailOverAlwaysFalseConditionsTitle">
        <source>Use 'Assert.Fail' instead of an always-failing assert</source>
        <target state="translated">항상 실패하는 어설션 대신 'Assert.Fail' 사용</target>
        <note>{Locked="Assert.Fail"}</note>
      </trans-unit>
      <trans-unit id="PreferAsyncAssertionDescription">
        <source>When verifying exceptions from asynchronous code, use the async assertion methods instead of blocking the asynchronous operation with GetAwaiter().GetResult().</source>
        <target state="translated">asynchronous 코드의 예외를 검증할 때 GetAwaiter().GetResult()를 사용하여 async 작업을 차단하는 대신 asynchronous 어설션 메서드를 사용합니다.</target>
        <note>{Locked="GetAwaiter().GetResult()"}{Locked="async"}</note>
      </trans-unit>
      <trans-unit id="PreferAsyncAssertionMessageFormat">
        <source>Use 'Assert.{0}' instead of blocking an async call in 'Assert.{1}'</source>
        <target state="translated">'Assert.{1}'에서 async 호출을 차단하는 대신 'Assert.{0}'을(를) 사용합니다.</target>
        <note>{0} is the async assert method name. {1} is the blocking assert method name. {Locked="Assert"}{Locked="async"}</note>
      </trans-unit>
      <trans-unit id="PreferAsyncAssertionTitle">
        <source>Prefer async assertion methods</source>
        <target state="translated">async 어설션 메서드 우선 사용</target>
        <note>{Locked="async"}</note>
      </trans-unit>
      <trans-unit id="PreferConstantForResourceLockDescription">
        <source>'[ResourceLock]' matches tests by exact string equality of the resource key. A bare string literal fails open: a typo produces a different key, so conflicting tests are no longer serialized and race silently instead of failing with an error. Referencing a shared constant makes typos a compile error and lets the compiler enforce that every test contending on the same resource uses the same key.</source>
        <target state="translated">'[ResourceLock]'은 리소스 키와 정확히 같은 문자열인 경우에만 테스트와 일치합니다. 문자열 리터럴을 그대로 쓰면 오타가 있으면 다른 키가 만들어지므로 문제가 생길 수 있습니다. 그러면 충돌하는 테스트가 더 이상 직렬화되지 않고, 오류로 실패하는 대신 자동으로 경합하게 됩니다. 공유 상수를 참조하면 오타가 컴파일 오류로 감지됩니다. 또한 컴파일러가 같은 리소스를 두고 경합하는 모든 테스트가 같은 키를 사용하도록 보장합니다.</target>
        <note>{Locked="[ResourceLock]"}</note>
      </trans-unit>
      <trans-unit id="PreferConstantForResourceLockMessageFormat">
        <source>The '[ResourceLock]' resource key '{0}' is a bare string literal; reference a shared constant (such as a 'WellKnownResources' member or your own 'const') so that typos do not silently produce a different, unshared key</source>
        <target state="new">The '[ResourceLock]' resource key '{0}' is a bare string literal; reference a shared constant (such as a 'WellKnownResources' member or your own 'const') so that typos do not silently produce a different, unshared key</target>
        <note>{0} is the resource key value. {Locked="[ResourceLock]"}{Locked="WellKnownResources"}{Locked="'const'"}</note>
      </trans-unit>
      <trans-unit id="PreferConstantForResourceLockTitle">
        <source>Prefer a named constant for the '[ResourceLock]' resource key</source>
        <target state="translated">'[ResourceLock]' 리소스 키에는 이름이 있는 상수를 사용하는 것이 좋습니다.</target>
        <note>{Locked="[ResourceLock]"}</note>
      </trans-unit>
      <trans-unit id="PreferConstructorOverTestInitializeDescription">
        <source>Constructors allow initialization through 'readonly' fields and provide stronger compiler feedback, especially with nullable reference types. This opt-in style rule is mutually exclusive with MSTEST0019.</source>
        <target state="new">Constructors allow initialization through 'readonly' fields and provide stronger compiler feedback, especially with nullable reference types. This opt-in style rule is mutually exclusive with MSTEST0019.</target>
        <note>{Locked="'readonly'"}{Locked="MSTEST0019"}</note>
      </trans-unit>
      <trans-unit id="PreferDisposeOverTestCleanupDescription">
        <source>'Dispose' and 'DisposeAsync' follow standard .NET lifetime patterns, making test cleanup consistent with production code. This opt-in style rule is mutually exclusive with MSTEST0022.</source>
        <target state="new">'Dispose' and 'DisposeAsync' follow standard .NET lifetime patterns, making test cleanup consistent with production code. This opt-in style rule is mutually exclusive with MSTEST0022.</target>
        <note>{Locked="'DisposeAsync'"}{Locked="'Dispose'"}{Locked=".NET"}{Locked="MSTEST0022"}</note>
      </trans-unit>
      <trans-unit id="PreferTestCleanupOverDisposeDescription">
        <source>'[TestCleanup]' supports asynchronous cleanup on target frameworks where 'IAsyncDisposable' is unavailable. This opt-in style rule is mutually exclusive with MSTEST0021.</source>
        <target state="new">'[TestCleanup]' supports asynchronous cleanup on target frameworks where 'IAsyncDisposable' is unavailable. This opt-in style rule is mutually exclusive with MSTEST0021.</target>
        <note>{Locked="'[TestCleanup]'"}{Locked="'IAsyncDisposable'"}{Locked="MSTEST0021"}</note>
      </trans-unit>
      <trans-unit id="PreferTestInitializeOverConstructorDescription">
        <source>'[TestInitialize]' supports both synchronous and asynchronous initialization, whereas constructors cannot be awaited. This opt-in style rule is mutually exclusive with MSTEST0020.</source>
        <target state="new">'[TestInitialize]' supports both synchronous and asynchronous initialization, whereas constructors cannot be awaited. This opt-in style rule is mutually exclusive with MSTEST0020.</target>
        <note>{Locked="'[TestInitialize]'"}{Locked="MSTEST0020"}</note>
      </trans-unit>
      <trans-unit id="PreferTestMethodOverDataTestMethodAnalyzerDescription">
        <source>'DataTestMethodAttribute' is obsolete and provides no additional functionality over 'TestMethodAttribute'. Use 'TestMethodAttribute' for all test methods, including parameterized tests.</source>
        <target state="translated">'DataTestMethodAttribute'는 더 이상 사용되지 않으며 'TestMethodAttribute'에 대한 추가 기능을 제공하지 않습니다. 매개 변수가 있는 테스트를 포함하여 모든 테스트 메서드에 'TestMethodAttribute'를 사용하세요.</target>
        <note>{Locked="DataTestMethodAttribute"}{Locked="TestMethodAttribute"}</note>
      </trans-unit>
      <trans-unit id="PreferTestMethodOverDataTestMethodAnalyzerMessageFormat">
        <source>'DataTestMethod' is obsolete. Use 'TestMethod' instead.</source>
        <target state="translated">'DataTestMethod'는 사용되지 않습니다. 대신 'TestMethod'를 사용하세요.</target>
        <note>{Locked="DataTestMethod"}{Locked="TestMethod"}</note>
      </trans-unit>
      <trans-unit id="PreferTestMethodOverDataTestMethodAnalyzerTitle">
        <source>Prefer 'TestMethod' over 'DataTestMethod'</source>
        <target state="translated">'DataTestMethod'보다 'TestMethod' 선호</target>
        <note>{Locked="DataTestMethod"}{Locked="TestMethod"}</note>
      </trans-unit>
      <trans-unit id="RedundantTestMethodDisplayNameDescription">
        <source>Setting a 'DisplayName' on a test method to a value that is identical to the method name is redundant because the method name is already used as the display name by default. The redundant 'DisplayName' can be removed without changing how the test is reported.</source>
        <target state="translated">'DisplayName'을 테스트 메서드 이름과 동일한 값으로 설정하는 것은 중복입니다. 기본적으로 메서드 이름이 이미 표시 이름으로 사용되기 때문입니다. 중복된 'DisplayName'은 테스트가 보고되는 방식을 바꾸지 않고 제거할 수 있습니다.</target>
        <note>{Locked="DisplayName"}</note>
      </trans-unit>
      <trans-unit id="RedundantTestMethodDisplayNameMessageFormat">
        <source>The 'DisplayName' is the same as the test method name '{0}' and can be removed</source>
        <target state="translated">'DisplayName'은 테스트 메서드 이름 '{0}'과(와) 같아서 제거할 수 있습니다.</target>
        <note>{0} is the test method name. {Locked="DisplayName"}</note>
      </trans-unit>
      <trans-unit id="RedundantTestMethodDisplayNameTitle">
        <source>Test method should not specify a display name equal to its name</source>
        <target state="translated">테스트 메서드의 표시 이름은 메서드 이름과 같게 지정하면 안 됩니다.</target>
        <note />
      </trans-unit>
      <trans-unit id="ReviewAlwaysTrueAssertConditionAnalyzerDescription">
        <source>An assertion that can never fail does not verify behavior and obscures the condition the test is intended to check.</source>
        <target state="new">An assertion that can never fail does not verify behavior and obscures the condition the test is intended to check.</target>
        <note />
      </trans-unit>
      <trans-unit id="ReviewAlwaysTrueAssertConditionAnalyzerMessageFormat">
        <source>Review or remove the assertion as its condition is known to be always true</source>
        <target state="translated">조건이 항상 true인 것으로 알려진 어설션 검토 또는 제거</target>
        <note>{Locked="true"}</note>
      </trans-unit>
      <trans-unit id="ReviewAlwaysTrueAssertConditionAnalyzerTitle">
        <source>Assertion condition is always true</source>
        <target state="translated">어설션 조건이 항상 true임</target>
        <note>{Locked="true"}</note>
      </trans-unit>
      <trans-unit id="PreferConstructorOverTestInitializeMessageFormat">
        <source>Prefer constructors over TestInitialize methods</source>
        <target state="translated">TestInitialize 메서드보다 생성자 선호</target>
        <note>{Locked="TestInitialize"}</note>
      </trans-unit>
      <trans-unit id="PreferConstructorOverTestInitializeTitle">
        <source>Prefer constructors over TestInitialize methods</source>
        <target state="translated">TestInitialize 메서드보다 생성자 선호</target>
        <note>{Locked="TestInitialize"}</note>
      </trans-unit>
      <trans-unit id="PreferDisposeOverTestCleanupMessageFormat">
        <source>Prefer 'Dispose' over TestCleanup methods</source>
        <target state="translated">TestCleanup 메서드보다 'Dispose' 선호</target>
        <note>{Locked="TestCleanup"}{Locked="Dispose"}</note>
      </trans-unit>
      <trans-unit id="PreferDisposeOverTestCleanupTitle">
        <source>Prefer 'Dispose' over TestCleanup methods</source>
        <target state="translated">TestCleanup 메서드보다 'Dispose' 선호</target>
        <note>{Locked="TestCleanup"}{Locked="Dispose"}</note>
      </trans-unit>
      <trans-unit id="PreferTestCleanupOverDisposeMessageFormat">
        <source>Prefer TestCleanup over 'Dispose' methods</source>
        <target state="translated">'Dispose' 메서드보다 TestCleanup 선호</target>
        <note>{Locked="TestCleanup"}{Locked="Dispose"}</note>
      </trans-unit>
      <trans-unit id="PreferTestCleanupOverDisposeTitle">
        <source>Prefer TestCleanup over 'Dispose' methods</source>
        <target state="translated">'Dispose' 메서드보다 TestCleanup 선호</target>
        <note>{Locked="TestCleanup"}{Locked="Dispose"}</note>
      </trans-unit>
      <trans-unit id="PreferTestInitializeOverConstructorMessageFormat">
        <source>Prefer TestInitialize methods over constructors</source>
        <target state="translated">생성자보다 TestInitialize 메서드 선호</target>
        <note>{Locked="TestInitialize"}</note>
      </trans-unit>
      <trans-unit id="PreferTestInitializeOverConstructorTitle">
        <source>Prefer TestInitialize methods over constructors</source>
        <target state="translated">생성자보다 TestInitialize 메서드 선호</target>
        <note>{Locked="TestInitialize"}</note>
      </trans-unit>
      <trans-unit id="PublicMethodShouldBeTestMethodAnalyzerDescription">
        <source>Public methods should be test methods (marked with `[TestMethod]`).</source>
        <target state="translated">공용 메서드는 테스트 메서드여야 합니다('[TestMethod]'로 표시됨).</target>
        <note>{Locked="[TestMethod]"}</note>
      </trans-unit>
      <trans-unit id="PublicMethodShouldBeTestMethodAnalyzerFormat">
        <source>Public method '{0}' should be a test method</source>
        <target state="translated">공용 메서드 '{0}'은(는) 테스트 메서드여야 합니다</target>
        <note>{0} is the method name.</note>
      </trans-unit>
      <trans-unit id="PublicMethodShouldBeTestMethodAnalyzerTitle">
        <source>Public methods should be test methods</source>
        <target state="translated">공용 메서드는 테스트 메서드여야 합니다</target>
        <note />
      </trans-unit>
      <trans-unit id="PublicTypeShouldBeTestClassDescription">
        <source>It's considered a good practice to have only test classes marked public in a test project.</source>
        <target state="translated">테스트 프로젝트에서는 public로 표시된 테스트 클래스만 사용하는 것이 권장됩니다.</target>
        <note>{Locked="public"}</note>
      </trans-unit>
      <trans-unit id="PublicTypeShouldBeTestClassMessageFormat">
        <source>Public type '{0}' should be marked with '[TestClass]' or changed to 'internal'</source>
        <target state="translated">공용 형식 '{0}'은(는) '[TestClass]'로 표시하거나 'internal'로 변경해야 합니다.</target>
        <note>{0} is the type name. {Locked="[TestClass]"}{Locked="internal"}</note>
      </trans-unit>
      <trans-unit id="PublicTypeShouldBeTestClassTitle">
        <source>Public types should be test classes</source>
        <target state="translated">공용 형식은 테스트 클래스여야 합니다.</target>
        <note />
      </trans-unit>
      <trans-unit id="SharedFileSystemPathInTestDescription">
        <source>Passing a hardcoded absolute path, or a relative path literal, directly to a filesystem-mutating 'File.*'/'Directory.*' method (for example 'File.WriteAllText' or 'Directory.CreateDirectory') targets a location shared by every other test in the assembly; relative paths additionally resolve against the process-global current directory. Under in-assembly parallelization two tests can then write to the same location concurrently. Only statically constant paths passed to a mutating API are flagged; reads, path construction, and paths built from variables are left to the parallel-safety audit skill. Prefer a unique per-test directory such as 'TestContext.TestTempDirectory'.</source>
        <target state="translated">하드코딩된 절대 경로나 상대 경로 리터럴을 파일 시스템을 변경하는 'File.*'/'Directory.*' 메서드(예: 'File.WriteAllText' 또는 'Directory.CreateDirectory')에 직접 전달하면, 어셈블리의 다른 모든 테스트와 공유되는 위치를 대상으로 하게 됩니다. 상대 경로는 추가로 프로세스 전역 현재 디렉터리를 기준으로 해석됩니다. 어셈블리 내 병렬화에서는 두 테스트가 같은 위치에 동시에 쓸 수 있습니다. 변경하는 API에 전달되는 정적으로 상수인 경로만 플래그가 지정됩니다. 읽기, 경로 구성, 변수로 만든 경로는 병렬 안전성 검토 대상입니다. 'TestContext.TestTempDirectory'처럼 테스트마다 고유한 디렉터리를 사용하세요.</target>
        <note>{Locked="File.*"}{Locked="Directory.*"}{Locked="TestContext.TestTempDirectory"}</note>
      </trans-unit>
      <trans-unit id="SharedFileSystemPathInTestMessageFormat">
        <source>The path '{0}' is a fixed location shared by every test in the assembly (and, when relative, resolves against the process-global current directory), so parallel tests that write to it can collide; use a unique per-test location such as 'TestContext.TestTempDirectory'</source>
        <target state="translated">'{0}' 경로는 어셈블리의 모든 테스트가 공유하는 고정 위치입니다. 상대 경로인 경우에는 프로세스 전역 현재 디렉터리를 기준으로 해석되므로, 여기에 쓰는 병렬 테스트는 충돌할 수 있습니다. 'TestContext.TestTempDirectory'처럼 테스트마다 고유한 위치를 사용하세요.</target>
        <note>{0} is the offending path literal. {Locked="TestContext.TestTempDirectory"}</note>
      </trans-unit>
      <trans-unit id="SharedFileSystemPathInTestTitle">
        <source>Avoid hardcoded or shared filesystem paths in a parallelized test</source>
        <target state="translated">병렬로 실행되는 테스트에서는 하드 코딩되었거나 공유된 파일 시스템 경로를 사용하지 마세요.</target>
        <note />
      </trans-unit>
      <trans-unit id="StringAssertToAssertDescription">
        <source>'StringAssert' methods have equivalent 'Assert' counterparts. Using one assertion API improves consistency and discoverability.</source>
        <target state="new">'StringAssert' methods have equivalent 'Assert' counterparts. Using one assertion API improves consistency and discoverability.</target>
        <note>{Locked="'StringAssert'"}{Locked="'Assert'"}{Locked="API"}</note>
      </trans-unit>
      <trans-unit id="StringAssertToAssertMessageFormat">
        <source>Use 'Assert.{0}' instead of 'StringAssert.{1}'</source>
        <target state="translated">'StringAssert.{1}' 대신 'Assert.{0}' 사용</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">'StringAssert' 대신 'Assert' 사용</target>
        <note>{Locked="StringAssert"}{Locked="Assert"}</note>
      </trans-unit>
      <trans-unit id="TestClassShouldBeValidMessageFormat">
        <source>Test class '{0}' should be valid</source>
        <target state="translated">테스트 class '{0}'은(는) 유효해야 합니다.</target>
        <note>{0} is the test class name. {Locked="class"}</note>
      </trans-unit>
      <trans-unit id="TestContextShouldBeValidMessageFormat">
        <source>Property 'TestContext' should be valid</source>
        <target state="translated">'TestContext' 속성은 유효해야 합니다.</target>
        <note>{Locked="TestContext"}</note>
      </trans-unit>
      <trans-unit id="TestFilterProviderShouldBeValidDescription">
        <source>'[assembly: TestFilterProvider(typeof(MyFilter))]' passes the filter type as a 'Type', so the compiler accepts any type at all. The adapter validates it only when it materializes the filter, and then fails the whole run. The referenced type must be non-generic and instantiable, implement 'ITestFilter' and expose a public parameterless constructor, and at most one provider may be registered per test assembly. When targeting .NET, the generic '[assembly: TestFilterProvider&lt;MyFilter&gt;]' form enforces the interface and constructor requirements through generic constraints instead.</source>
        <target state="translated">'[assembly: TestFilterProvider(typeof(MyFilter))]'는 필터 형식을 'Type'으로 전달하므로 컴파일러는 어떤 형식이든 허용합니다. 어댑터는 필터를 인스턴스화할 때만 유효성을 검사하고, 그때 전체 실행이 실패합니다. 참조된 형식은 제네릭이 아니고 인스턴스화할 수 있어야 하며, 'ITestFilter'를 구현하고, 매개 변수가 없는 public 생성자를 노출해야 합니다. 또한 테스트 어셈블리당 공급자는 하나만 등록할 수 있습니다. .NET을 대상으로 하는 경우에는 제네릭 '[assembly: TestFilterProvider&lt;MyFilter&gt;]' 형식이 대신 제네릭 제약 조건으로 인터페이스와 생성자 요구 사항을 강제합니다.</target>
        <note>{Locked="[assembly: TestFilterProvider(typeof(MyFilter))]"}{Locked="[assembly: TestFilterProvider&lt;MyFilter&gt;]"}{Locked="Type"}{Locked="ITestFilter"}</note>
      </trans-unit>
      <trans-unit id="TestFilterProviderShouldBeValidMessageFormat_Generic">
        <source>'[TestFilterProvider]' references generic type '{0}'; the test filter type must not be generic</source>
        <target state="translated">'[TestFilterProvider]'는 제네릭 형식 '{0}'을(를) 참조합니다. 테스트 필터 형식은 제네릭이면 안 됩니다.</target>
        <note>{0} is the referenced type name. {Locked="[TestFilterProvider]"}</note>
      </trans-unit>
      <trans-unit id="TestFilterProviderShouldBeValidMessageFormat_Multiple">
        <source>The assembly registers more than one '[TestFilterProvider]'; at most one is allowed per test assembly, so compose the filtering strategies inside a single 'ITestFilter' implementation</source>
        <target state="translated">어셈블리에 '[TestFilterProvider]'가 둘 이상 등록되어 있습니다. 테스트 어셈블리당 하나만 허용되므로 단일 'ITestFilter' 구현 안에 필터링 전략을 구성하세요.</target>
        <note>{Locked="[TestFilterProvider]"}{Locked="ITestFilter"}</note>
      </trans-unit>
      <trans-unit id="TestFilterProviderShouldBeValidMessageFormat_NoParameterlessConstructor">
        <source>'[TestFilterProvider]' references type '{0}', which does not declare a public parameterless constructor</source>
        <target state="translated">'[TestFilterProvider]'는 public 매개 변수가 없는 생성자를 선언하지 않는 형식 '{0}'을(를) 참조합니다.</target>
        <note>{0} is the referenced type name. {Locked="[TestFilterProvider]"}</note>
      </trans-unit>
      <trans-unit id="TestFilterProviderShouldBeValidMessageFormat_NotATestFilter">
        <source>'[TestFilterProvider]' references type '{0}', which does not implement 'ITestFilter'</source>
        <target state="translated">'[TestFilterProvider]'는 'ITestFilter'를 구현하지 않는 형식 '{0}'을(를) 참조합니다.</target>
        <note>{0} is the referenced type name. {Locked="[TestFilterProvider]"}{Locked="ITestFilter"}</note>
      </trans-unit>
      <trans-unit id="TestFilterProviderShouldBeValidMessageFormat_NotInstantiable">
        <source>'[TestFilterProvider]' references type '{0}', which cannot be instantiated</source>
        <target state="translated">'[TestFilterProvider]'는 인스턴스화할 수 없는 형식 '{0}'을(를) 참조합니다.</target>
        <note>{0} is the referenced type name. {Locked="[TestFilterProvider]"}</note>
      </trans-unit>
      <trans-unit id="TestFilterProviderShouldBeValidMessageFormat_Null">
        <source>'[TestFilterProvider]' is given a null filter type; pass the 'ITestFilter' implementation to run, for example 'typeof(MyFilter)'</source>
        <target state="translated">'[TestFilterProvider]'에 null 필터 형식이 지정되었습니다. 실행할 'ITestFilter' 구현을 전달하세요. 예를 들어 'typeof(MyFilter)'를 사용할 수 있습니다.</target>
        <note>{Locked="[TestFilterProvider]"}{Locked="ITestFilter"}{Locked="typeof(MyFilter)"}</note>
      </trans-unit>
      <trans-unit id="TestFilterProviderShouldBeValidTitle">
        <source>'[TestFilterProvider]' should reference a valid test filter type</source>
        <target state="translated">'[TestFilterProvider]'는 올바른 테스트 필터 형식을 참조해야 합니다.</target>
        <note>{Locked="[TestFilterProvider]"}</note>
      </trans-unit>
      <trans-unit id="TestMethodAttributeShouldPropagateSourceInformationDescription">
        <source>Propagating the source file and line number allows MSTest to report accurate diagnostics, test results, and Test Explorer navigation.</source>
        <target state="new">Propagating the source file and line number allows MSTest to report accurate diagnostics, test results, and Test Explorer navigation.</target>
        <note>{Locked="MSTest"}{Locked="Test Explorer"}</note>
      </trans-unit>
      <trans-unit id="TestMethodAttributeShouldPropagateSourceInformationMessageFormat">
        <source>TestMethodAttribute derived class '{0}' should add CallerFilePath and CallerLineNumber parameters to its constructor</source>
        <target state="translated">TestMethodAttribute에서 파생된 class '{0}'은(는) 생성자에 CallerFilePath와 CallerLineNumber 매개 변수를 추가해야 합니다.</target>
        <note>{0} is the derived TestMethodAttribute class name. {Locked="TestMethodAttribute"}{Locked="CallerLineNumber"}{Locked="CallerFilePath"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="TestMethodAttributeShouldPropagateSourceInformationTitle">
        <source>TestMethodAttribute derived class should propagate source information</source>
        <target state="translated">TestMethodAttribute에서 파생된 class는 소스 정보를 전파해야 합니다.</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">TestMethodAttribute에 문자열 인수를 전달하는 대신 'DisplayName' 속성을 사용하세요.</target>
        <note>{Locked="TestMethodAttribute"}{Locked="DisplayName"}</note>
      </trans-unit>
      <trans-unit id="TestMethodAttributeShouldSetDisplayNameCorrectlyTitle">
        <source>TestMethodAttribute should set DisplayName correctly</source>
        <target state="translated">TestMethodAttribute는 DisplayName을 올바르게 설정해야 합니다.</target>
        <note>{Locked="TestMethodAttribute"}{Locked="DisplayName"}</note>
      </trans-unit>
      <trans-unit id="TestMethodShouldBeValidMessageFormat">
        <source>Test method '{0}' signature is invalid</source>
        <target state="translated">테스트 메서드 '{0}' 시그니처가 잘못되었습니다.</target>
        <note>{0} is the method name.</note>
      </trans-unit>
      <trans-unit id="UndeclaredProcessGlobalStateMutationDescription">
        <source>Mutating process-global state (such as environment variables or the console redirection) from a test is unsafe once in-assembly parallelization is enabled, because a sibling test running concurrently observes the mutation. Unlike '[ResourceLock]', which fails open when a key is forgotten, this rule flags the mutation at compile time. Declare '[ResourceLock]' with the matching 'WellKnownResources' key to serialize contending tests, or '[DoNotParallelize]' to opt the test out of parallelization.</source>
        <target state="translated">환경 변수나 콘솔 리디렉션처럼 프로세스 전역 상태를 테스트에서 변경하는 것은 어셈블리 내 병렬화를 사용하면 안전하지 않습니다. 동시에 실행되는 다른 테스트가 이 변경을 관찰하기 때문입니다. 키를 빠뜨리면 실패 없이 열리는 '[ResourceLock]'과(와) 달리, 이 규칙은 컴파일 시점에 변경을 플래그 지정합니다. 충돌하는 테스트를 직렬화하려면 일치하는 'WellKnownResources' 키와 함께 '[ResourceLock]'을(를) 선언하고, 테스트를 병렬화에서 제외하려면 '[DoNotParallelize]'을(를) 선언하세요.</target>
        <note>{Locked="[ResourceLock]"}{Locked="WellKnownResources"}{Locked="[DoNotParallelize]"}</note>
      </trans-unit>
      <trans-unit id="UndeclaredProcessGlobalStateMutationMessageFormat">
        <source>'{0}' mutates process-global state and is unsafe when tests run in parallel; declare '[ResourceLock(WellKnownResources.{1})]' on the test (or '[DoNotParallelize]')</source>
        <target state="translated">'{0}'은(는) 프로세스 전역 상태를 변경하므로 테스트가 병렬로 실행될 때는 안전하지 않습니다. 테스트에 '[ResourceLock(WellKnownResources.{1})]'을(를) 선언하세요. 또는 '[DoNotParallelize]'을(를) 사용하세요.</target>
        <note>{0} is the mutated API (for example 'Environment.SetEnvironmentVariable'). {1} is a 'WellKnownResources' member name. {Locked="[ResourceLock]"}{Locked="WellKnownResources"}{Locked="[DoNotParallelize]"}</note>
      </trans-unit>
      <trans-unit id="UndeclaredProcessGlobalStateMutationTitle">
        <source>Test mutating process-global state should declare a resource lock</source>
        <target state="translated">은 프로세스 전역 상태를 변경하므로 리소스 잠금을 선언해야 합니다.</target>
        <note />
      </trans-unit>
      <trans-unit id="UseArchitectureConditionAttributeInsteadOfRuntimeCheckDescription">
        <source>Test methods that compare 'RuntimeInformation.ProcessArchitecture' and then early return or call 'Assert.Inconclusive' should use the '[ArchitectureCondition]' attribute instead. This attribute provides a more declarative and discoverable way to specify architecture-specific test requirements, and it reports the test as skipped rather than passed, which an early return does not.</source>
        <target state="translated">테스트 메서드에서 'RuntimeInformation.ProcessArchitecture'를 비교한 다음 조기에 반환하거나 'Assert.Inconclusive'를 호출한다면, 대신 '[ArchitectureCondition]' 특성을 사용하세요. 이 특성은 아키텍처별 테스트 요구 사항을 더 선언적이고 찾기 쉬운 방식으로 지정할 수 있게 해 줍니다. 또한 조기에 반환하는 경우와 달리 테스트를 통과로 표시하지 않고 건너뜀으로 보고합니다.</target>
        <note>{Locked="RuntimeInformation.ProcessArchitecture"}{Locked="Assert.Inconclusive"}{Locked="[ArchitectureCondition]"}</note>
      </trans-unit>
      <trans-unit id="UseArchitectureConditionAttributeInsteadOfRuntimeCheckMessageFormat">
        <source>Use '[ArchitectureCondition]' attribute instead of 'RuntimeInformation.ProcessArchitecture' checks with early return or 'Assert.Inconclusive'</source>
        <target state="translated">초기 반환 또는 'Assert.Inconclusive'를 사용하는 'RuntimeInformation.ProcessArchitecture' 검사 대신 '[ArchitectureCondition]' 특성을 사용합니다.</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">초기 반환 또는 'Assert.Inconclusive'를 사용하는 'RuntimeInformation.ProcessArchitecture' 검사 대신 '[ArchitectureCondition]' 특성을 사용합니다.</target>
        <note>{Locked="RuntimeInformation.ProcessArchitecture"}{Locked="Assert.Inconclusive"}{Locked="[ArchitectureCondition]"}</note>
      </trans-unit>
      <trans-unit id="UseAttributeOnTestMethodAnalyzerDescription">
        <source>MSTest ignores these attributes outside a test context.</source>
        <target state="new">MSTest ignores these attributes outside a test context.</target>
        <note>{Locked="MSTest"}</note>
      </trans-unit>
      <trans-unit id="UseCIConditionAttributeInsteadOfEnvironmentCheckDescription">
        <source>Test methods that null-check the 'CI' environment variable and then early return or call 'Assert.Inconclusive' should use the '[CICondition]' attribute instead. This attribute recognizes all the continuous integration providers MSTest knows about and parses their values, and it reports the test as skipped rather than passed, which an early return does not.</source>
        <target state="translated">테스트 메서드에서 'CI' 환경 변수가 null인지 확인한 다음 조기에 반환하거나 'Assert.Inconclusive'를 호출한다면, 대신 '[CICondition]' 특성을 사용하세요. 이 특성은 MSTest가 알고 있는 모든 지속적 통합 공급자를 인식하고 해당 값을 구문 분석합니다. 또한 조기에 반환하는 경우와 달리 테스트를 통과로 표시하지 않고 건너뜀으로 보고합니다.</target>
        <note>{Locked="CI"}{Locked="Assert.Inconclusive"}{Locked="[CICondition]"}</note>
      </trans-unit>
      <trans-unit id="UseCIConditionAttributeInsteadOfEnvironmentCheckMessageFormat">
        <source>Use '[CICondition]' attribute instead of 'Environment.GetEnvironmentVariable' checks with early return or 'Assert.Inconclusive'</source>
        <target state="translated">초기 반환 또는 'Assert.Inconclusive'를 사용하는 'Environment.GetEnvironmentVariable' 검사 대신 '[CICondition]' 특성을 사용합니다.</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">초기 반환 또는 'Assert.Inconclusive'를 사용하는 'Environment.GetEnvironmentVariable' 검사 대신 '[CICondition]' 특성을 사용합니다.</target>
        <note>{Locked="Environment.GetEnvironmentVariable"}{Locked="Assert.Inconclusive"}{Locked="[CICondition]"}</note>
      </trans-unit>
      <trans-unit id="UseCancellationTokenPropertyDescription">
        <source>TestContext.CancellationToken provides a more direct way to access the cancellation token compared to TestContext.CancellationTokenSource.Token.</source>
        <target state="translated">TestContext.CancellationToken은 TestContext.CancellationTokenSource.Token보다 취소 토큰에 더 직접적으로 액세스할 수 있는 방법을 제공합니다.</target>
        <note>{Locked="TestContext.CancellationTokenSource.Token"}{Locked="TestContext.CancellationToken"}</note>
      </trans-unit>
      <trans-unit id="UseCancellationTokenPropertyMessageFormat">
        <source>Use 'TestContext.CancellationToken' instead of 'TestContext.CancellationTokenSource.Token'</source>
        <target state="translated">'TestContext.CancellationTokenSource.Token' 대신 'TestContext.CancellationToken' 사용</target>
        <note>{Locked="TestContext.CancellationTokenSource.Token"}{Locked="TestContext.CancellationToken"}</note>
      </trans-unit>
      <trans-unit id="UseCancellationTokenPropertyTitle">
        <source>Use TestContext.CancellationToken instead of TestContext.CancellationTokenSource.Token</source>
        <target state="translated">TestContext.CancellationTokenSource.Token 대신 TestContext.CancellationToken 사용</target>
        <note>{Locked="TestContext.CancellationTokenSource.Token"}{Locked="TestContext.CancellationToken"}</note>
      </trans-unit>
      <trans-unit id="TestClassShouldBeValidDescription">
        <source>Test classes, classes marked with the '[TestClass]' attribute, should respect the following layout to be considered valid by MSTest:
- it should be 'public' (or 'internal' if '[assembly: DiscoverInternals]' attribute is set)
- it should not be 'static' (except if it contains only 'AssemblyInitialize' and/or 'AssemblyCleanup' methods)
- it should not be generic.</source>
        <target state="translated">'[TestClass]' 특성으로 표시된 클래스인 테스트 클래스는 MSTest에서 유효하다고 간주하려면 다음 레이아웃을 준수해야 합니다.
- 'public'(또는 '[assembly: DiscoverInternals]' 특성이 설정된 경우 'internal')이어야 합니다.
- 'static'이 아니어야 합니다('AssemblyInitialize' 및/또는 'AssemblyCleanup' 메서드만 포함된 경우 제외).
- 제네릭이 아니어야 합니다.</target>
        <note>{Locked="AssemblyInitialize"}{Locked="AssemblyCleanup"}{Locked="[TestClass]"}{Locked="MSTest"}{Locked="public"}{Locked="internal"}{Locked="static"}</note>
      </trans-unit>
      <trans-unit id="TestClassShouldBeValidTitle">
        <source>Test classes should have valid layout</source>
        <target state="translated">테스트 클래스에는 유효한 레이아웃이 있어야 합니다.</target>
        <note />
      </trans-unit>
      <trans-unit id="TestClassShouldHaveTestMethodDescription">
        <source>Test class should have at least one test method or be 'static' with method(s) marked by '[AssemblyInitialize]' and/or '[AssemblyCleanup]'.</source>
        <target state="translated">테스트 class에는 하나 이상의 테스트 메서드가 있거나 '[AssemblyInitialize]' 및/또는 '[AssemblyCleanup]'으로 표시된 메서드가 있는 'static'이어야 합니다.</target>
        <note>{Locked="[AssemblyInitialize]"}{Locked="[AssemblyCleanup]"}{Locked="static"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="TestClassShouldHaveTestMethodMessageFormat">
        <source>Test class '{0}' should have at least one test method or be 'static' with method(s) marked by '[AssemblyInitialize]' and/or '[AssemblyCleanup]'</source>
        <target state="translated">테스트 class '{0}'에는 하나 이상의 테스트 메서드가 있거나 '[AssemblyInitialize]' 및/또는 '[AssemblyCleanup]'으로 표시된 메서드가 있는 'static'이어야 합니다.</target>
        <note>{0} is the test class name. {Locked="[AssemblyInitialize]"}{Locked="[AssemblyCleanup]"}{Locked="static"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="TestClassShouldHaveTestMethodTitle">
        <source>Test class should have test method</source>
        <target state="translated">테스트 class에는 테스트 메서드가 있어야 합니다.</target>
        <note>{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="TestCleanupShouldBeValidDescription">
        <source>Methods marked with '[TestCleanup]' should follow the following layout to be valid:
-it should be 'public'
-it should not be 'abstract'
-it should not be 'async void'
-it should not be 'static'
-it should not be a special method (finalizer, operator...).
-it should not be generic
-it should not take any parameter
-return type should be 'void', 'Task' or 'ValueTask'

The type declaring these methods should also respect the following rules:
-The type should be a class
-The class should be 'public' or 'internal' (if the test project is using the '[DiscoverInternals]' attribute)
-The class shouldn't be 'static'
-If the class is 'sealed', it should be marked with '[TestClass]' (or a derived attribute).</source>
        <target state="translated">'[TestCleanup]'으로 표시된 메서드가 유효하려면 다음 레이아웃을 따라야 합니다.
- 'public'이어야 합니다. 
- 'abstract'가 아니어야 합니다.
- 'async void'가 아니어야 합니다.
- 'static'이 아니어야 합니다.
- 특수 메서드(종료자, 연산자...)가 아니어야 합니다.
- 제네릭이 아니어야 합니다.
- 매개 변수를 사용하지 않아야 합니다.
- 반환 형식은 'void', 'Task' 또는 'ValueTask'여야 합니다.

이러한 메서드를 선언하는 형식은 다음 규칙도 준수해야 합니다.
-형식은 class여야 합니다.
-class는 'public' 또는 'internal'이어야 합니다(테스트 프로젝트에서 '[DiscoverInternals]' 특성을 사용하는 경우).
-class는 'static'이 되어서는 안 됩니다.
-class가 'sealed'인 경우 '[TestClass]'(또는 파생 특성)로 표시되어야 합니다.</target>
        <note>{Locked="[DiscoverInternals]"}{Locked="[TestCleanup]"}{Locked="[TestClass]"}{Locked="ValueTask"}{Locked="Task"}{Locked="public"}{Locked="internal"}{Locked="static"}{Locked="void"}{Locked="async void"}{Locked="abstract"}{Locked="sealed"}{Locked="async"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="TestCleanupShouldBeValidMessageFormat">
        <source>TestCleanup method '{0}' signature is invalid</source>
        <target state="translated">TestCleanup 메서드 '{0}' 시그니처가 잘못되었습니다.</target>
        <note>{0} is the method name. {Locked="TestCleanup"}</note>
      </trans-unit>
      <trans-unit id="TestCleanupShouldBeValidTitle">
        <source>TestCleanup method should have valid layout</source>
        <target state="translated">TestCleanup 메서드에는 유효한 레이아웃이 있어야 합니다.</target>
        <note>{Locked="TestCleanup"}</note>
      </trans-unit>
      <trans-unit id="TestContextShouldBeValidDescription">
        <source>'TestContext' should be a non-static property assigned in constructor or set by MSTest. To be set by MSTest, it should follow the layout:
- it should be 'public' regardless of whether '[assembly: DiscoverInternals]' attribute is set or not.
- it should not be 'static'
- it should have a setter.</source>
        <target state="translated">'TestContext'는 static이 아닌 속성이어야 하며, 생성자에서 할당되거나 MSTest에 의해 설정되어야 합니다. MSTest에서 설정하려면 다음 레이아웃을 따라야 합니다.
- '[assembly: DiscoverInternals]' 특성이 설정되었는지 여부에 관계없이 'public'이어야 합니다.
- 'static'이 아니어야 합니다.
- setter가 있어야 합니다.</target>
        <note>{Locked="TestContext"}{Locked="MSTest"}{Locked="public"}{Locked="static"}</note>
      </trans-unit>
      <trans-unit id="TestContextShouldBeValidTitle">
        <source>Test context property should have valid layout</source>
        <target state="translated">테스트 컨텍스트 속성에 유효한 레이아웃이 있어야 합니다.</target>
        <note />
      </trans-unit>
      <trans-unit id="TestInitializeShouldBeValidDescription">
        <source>Methods marked with '[TestInitialize]' should follow the following layout to be valid:
-it should be 'public'
-it should not be 'abstract'
-it should not be 'async void'
-it should not be 'static'
-it should not be a special method (finalizer, operator...).
-it should not be generic
-it should not take any parameter
-return type should be 'void', 'Task' or 'ValueTask'

The type declaring these methods should also respect the following rules:
-The type should be a class
-The class should be 'public' or 'internal' (if the test project is using the '[DiscoverInternals]' attribute)
-The class shouldn't be 'static'
-If the class is 'sealed', it should be marked with '[TestClass]' (or a derived attribute).</source>
        <target state="translated">'[TestInitialize]'로 표시된 메서드가 유효하려면 다음 레이아웃을 따라야 합니다.
- 'public'이어야 합니다. 
- 'abstract'가 아니어야 합니다.
- 'async void'가 아니어야 합니다.
- 'static'이 아니어야 합니다.
- 특수 메서드(종료자, 연산자...)가 아니어야 합니다.
- 제네릭이 아니어야 합니다.
- 매개 변수를 사용하지 않아야 합니다.
- 반환 형식은 'void', 'Task' 또는 'ValueTask'여야 합니다.

이러한 메서드를 선언하는 형식은 다음 규칙도 준수해야 합니다.
-형식은 class여야 합니다.
-class는 'public' 또는 'internal'이어야 합니다(테스트 프로젝트에서 '[DiscoverInternals]' 특성을 사용하는 경우).
-class는 'static'이 되어서는 안 됩니다.
-class가 'sealed'인 경우 '[TestClass]'(또는 파생 특성)로 표시되어야 합니다.</target>
        <note>{Locked="[DiscoverInternals]"}{Locked="[TestInitialize]"}{Locked="[TestClass]"}{Locked="ValueTask"}{Locked="Task"}{Locked="public"}{Locked="internal"}{Locked="static"}{Locked="void"}{Locked="async void"}{Locked="abstract"}{Locked="sealed"}{Locked="async"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="TestInitializeShouldBeValidMessageFormat">
        <source>TestInitialize method '{0}' signature is invalid</source>
        <target state="translated">TestInitialize 메서드 '{0}' 시그니처가 잘못되었습니다.</target>
        <note>{0} is the method name. {Locked="TestInitialize"}</note>
      </trans-unit>
      <trans-unit id="TestInitializeShouldBeValidTitle">
        <source>TestInitialize method should have valid layout</source>
        <target state="translated">TestInitialize 메서드에는 유효한 레이아웃이 있어야 합니다.</target>
        <note>{Locked="TestInitialize"}</note>
      </trans-unit>
      <trans-unit id="TestMethodShouldBeValidDescription">
        <source>Test methods, methods marked with the '[TestMethod]' attribute, should respect the following layout to be considered valid by MSTest:
- it should be 'public' (or 'internal' if '[assembly: DiscoverInternals]' attribute is set)
- it should not be 'static'
- it should may be generic as long as type parameters can be inferred and argument types are compatible
- it should not be 'abstract'
- return type should be 'void', 'Task' or 'ValueTask'
- it should not be 'async void'
- it should not be a special method (finalizer, operator...).</source>
        <target state="translated">'[TestMethod]' 특성으로 표시된 메서드인 테스트 메서드는 MSTest에서 유효한 것으로 간주되도록 다음 레이아웃을 준수해야 합니다.
- 'public'(혹은 '[assembly: DiscoverInternals]' 특성이 설정된 경우 'internal')이어야 합니다.
- 'static'이 아니어야 합니다.
- 형식 매개 변수를 유추할 수 있고 인수 형식이 호환되는 경우 제네릭이 될 수 있습니다.
- 'abstract'가 아니어야 합니다.
- 반환 형식은 'void', 'Task' 또는 'ValueTask'여야 합니다.
- 'async void'가 아니어야 합니다.
- 특수 메서드(종료자, 연산자...)가 아니어야 합니다.</target>
        <note>{Locked="[TestMethod]"}{Locked="ValueTask"}{Locked="MSTest"}{Locked="Task"}{Locked="public"}{Locked="internal"}{Locked="static"}{Locked="void"}{Locked="async void"}{Locked="abstract"}{Locked="async"}</note>
      </trans-unit>
      <trans-unit id="TestMethodShouldBeValidTitle">
        <source>Test methods should have valid layout</source>
        <target state="translated">테스트 메서드에는 유효한 레이아웃이 있어야 합니다.</target>
        <note />
      </trans-unit>
      <trans-unit id="TestMethodShouldNotBeIgnoredAnalyzerDescription">
        <source>Test methods should not be ignored (marked with '[Ignore]').</source>
        <target state="translated">테스트 메서드는 무시하면 안 됩니다('[Ignore]'로 표시됨).</target>
        <note>{Locked="[Ignore]"}</note>
      </trans-unit>
      <trans-unit id="TestMethodShouldNotBeIgnoredAnalyzerFormat">
        <source>Test method '{0}' should not be ignored</source>
        <target state="translated">테스트 메서드 '{0}'을(를) 무시하면 안 됩니다.</target>
        <note>{0} is the method name.</note>
      </trans-unit>
      <trans-unit id="TestMethodShouldNotBeIgnoredAnalyzerTitle">
        <source>Test method should not be ignored</source>
        <target state="translated">테스트 메서드는 무시하면 안 됩니다.</target>
        <note />
      </trans-unit>
      <trans-unit id="TypeContainingTestMethodShouldBeATestClassDescription">
        <source>Type containing '[TestMethod]' should be marked with '[TestClass]', otherwise the test method will be silently ignored.</source>
        <target state="translated">'[TestMethod]'를 포함하는 유형은 '[TestClass]'로 표시되어야 합니다. 그렇지 않으면 테스트 메서드가 자동으로 무시됩니다.</target>
        <note>{Locked="[TestMethod]"}{Locked="[TestClass]"}</note>
      </trans-unit>
      <trans-unit id="TypeContainingTestMethodShouldBeATestClassMessageFormat">
        <source>Type '{0}' contains test methods and should be marked with '[TestClass]'</source>
        <target state="translated">'{0}' 유형에는 테스트 메서드가 포함되어 있으며 '[TestClass]'로 표시되어야 합니다.</target>
        <note>{0} is the type name. {Locked="[TestClass]"}</note>
      </trans-unit>
      <trans-unit id="TypeContainingTestMethodShouldBeATestClassTitle">
        <source>Type containing '[TestMethod]' should be marked with '[TestClass]'</source>
        <target state="translated">'[TestMethod]'를 포함하는 유형은 '[TestClass]'로 표시되어야 합니다.</target>
        <note>{Locked="[TestMethod]"}{Locked="[TestClass]"}</note>
      </trans-unit>
      <trans-unit id="UseAsyncSuffixTestFixtureMethodSuppressorJustification">
        <source>Asynchronous test fixture methods do not require the 'Async' suffix</source>
        <target state="translated">Asynchronous 테스트 fixture 메서드에는 'Async' 접미사가 필요하지 않습니다.</target>
        <note>{Locked="'Async'"}</note>
      </trans-unit>
      <trans-unit id="UseAsyncSuffixTestMethodSuppressorJustification">
        <source>Asynchronous test methods do not require the 'Async' suffix</source>
        <target state="translated">Asynchronous 테스트 메서드에는 'Async' 접미사가 필요하지 않습니다.</target>
        <note>{Locked="'Async'"}</note>
      </trans-unit>
      <trans-unit id="UnusedParameterSuppressorJustification">
        <source>TestContext parameter is required by MSTest for AssemblyInitialize and ClassInitialize methods</source>
        <target state="translated">AssemblyInitialize 및 ClassInitialize 메서드에 대해 MSTest에 의한 TestContext 매개 변수가 필요합니다.</target>
        <note>{Locked="AssemblyInitialize"}{Locked="ClassInitialize"}{Locked="TestContext"}{Locked="MSTest"}</note>
      </trans-unit>
      <trans-unit id="UseAttributeOnTestMethodAnalyzerMessageFormat">
        <source>[{0}] can only be set on methods marked with [TestMethod]</source>
        <target state="translated">[{0}]은(는) [TestMethod] 표시된 메서드에만 설정할 수 있습니다.</target>
        <note>{0} is the attribute name without brackets. {Locked="[TestMethod]"}</note>
      </trans-unit>
      <trans-unit id="UseAttributeOnTestMethodAnalyzerTitle">
        <source>[{0}] can only be set on methods marked with [TestMethod]</source>
        <target state="translated">[{0}]은(는) [TestMethod] 표시된 메서드에만 설정할 수 있습니다.</target>
        <note>{0} is the attribute name without brackets. {Locked="[TestMethod]"}</note>
      </trans-unit>
      <trans-unit id="UseConditionBaseWithTestClassDescription">
        <source>When applied to a class, MSTest evaluates condition attributes only if the class is a test class, so applying them to a non-test class has no effect.</source>
        <target state="new">When applied to a class, MSTest evaluates condition attributes only if the class is a test class, so applying them to a non-test class has no effect.</target>
        <note>{Locked="MSTest"}</note>
      </trans-unit>
      <trans-unit id="UseConditionBaseWithTestClassMessageFormat">
        <source>The attribute '{0}' which derives from 'ConditionBaseAttribute' should be used only on classes marked with `TestClassAttribute`</source>
        <target state="translated">'ConditionBaseAttribute'에서 파생되는 '{0}' 특성은 'TestClassAttribute'로 표시된 클래스에서만 사용해야 합니다.</target>
        <note>{0} is the attribute name. {Locked="ConditionBaseAttribute"}{Locked="TestClassAttribute"}</note>
      </trans-unit>
      <trans-unit id="UseConditionBaseWithTestClassTitle">
        <source>Use 'ConditionBaseAttribute' on test classes</source>
        <target state="translated">테스트 클래스에 'ConditionBaseAttribute' 사용</target>
        <note>{Locked="ConditionBaseAttribute"}</note>
      </trans-unit>
      <trans-unit id="UseCooperativeCancellationForTimeoutDescription">
        <source>Using '[Timeout]' without explicitly setting 'CooperativeCancellation = true' is discouraged. In a future version, cooperative cancellation will become the default behavior. Set 'CooperativeCancellation = true' to opt into the recommended behavior and avoid breaking changes.</source>
        <target state="translated">'CooperativeCancellation = true'를 명시적으로 설정하지 않고 '[Timeout]'을 사용하는 것은 권장되지 않습니다. 향후 버전에서는 협동 취소가 기본 동작으로 설정될 것입니다. 권장 동작을 선택하고 변경 사항으로 인한 문제를 피하려면 'CooperativeCancellation = true'를 설정하세요.</target>
        <note>{Locked="CooperativeCancellation = true"}{Locked="[Timeout]"}{Locked="true"}</note>
      </trans-unit>
      <trans-unit id="UseCooperativeCancellationForTimeoutMessageFormat">
        <source>Use 'CooperativeCancellation = true' with '[Timeout]' to enable cooperative cancellation behavior</source>
        <target state="translated">'[Timeout]'와 함께 'CooperativeCancellation = true'를 사용하여 협동 취소 동작을 활성화하세요.</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">'[Timeout]'와 함께 'CooperativeCancellation = true'를 사용하세요.</target>
        <note>{Locked="CooperativeCancellation = true"}{Locked="[Timeout]"}{Locked="true"}</note>
      </trans-unit>
      <trans-unit id="UseDeploymentItemWithTestMethodOrTestClassDescription">
        <source>MSTest ignores '[DeploymentItem]' when it is applied outside a test class or test method.</source>
        <target state="new">MSTest ignores '[DeploymentItem]' when it is applied outside a test class or test method.</target>
        <note>{Locked="MSTest"}{Locked="'[DeploymentItem]'"}</note>
      </trans-unit>
      <trans-unit id="UseDeploymentItemWithTestMethodOrTestClassMessageFormat">
        <source>'[DeploymentItem]' can be specified only on test class or test method</source>
        <target state="translated">'[DeploymentItem]'은(는) 테스트 class 또는 테스트 메서드에만 지정할 수 있습니다.</target>
        <note>{Locked="[DeploymentItem]"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="UseDeploymentItemWithTestMethodOrTestClassTitle">
        <source>'[DeploymentItem]' can be specified only on test class or test method</source>
        <target state="translated">'[DeploymentItem]'은(는) 테스트 class 또는 테스트 메서드에만 지정할 수 있습니다.</target>
        <note>{Locked="[DeploymentItem]"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="UseParallelizeAttributeAnalyzerDescription">
        <source>By default, MSTest runs tests within the same assembly sequentially, which can lead to severe performance limitations. It is recommended to enable assembly attribute '[Parallelize]' to run tests in parallel, or if the assembly is known to not be parallelizable, to use explicitly the assembly level attribute '[DoNotParallelize]'.</source>
        <target state="translated">기본적으로 MSTest는 동일한 어셈블리 내에서 테스트를 순차적으로 실행하므로 심각한 성능 제한이 발생할 수 있습니다. 어셈블리 특성 '[Parallelize]'가 병렬로 테스트를 실행하도록 설정하거나 어셈블리가 병렬화할 수 없는 것으로 알려진 경우 어셈블리 수준 특성 '[DoNotParallelize]'을(를) 명시적으로 사용하는 것이 좋습니다.</target>
        <note>{Locked="[DoNotParallelize]"}{Locked="[Parallelize]"}{Locked="MSTest"}</note>
      </trans-unit>
      <trans-unit id="UseParallelizeAttributeAnalyzerMessageFormat">
        <source>Explicitly enable or disable tests parallelization</source>
        <target state="translated">테스트 병렬 처리를 명시적으로 사용하거나 사용하지 않도록 설정</target>
        <note />
      </trans-unit>
      <trans-unit id="UseParallelizeAttributeAnalyzerTitle">
        <source>Explicitly enable or disable tests parallelization</source>
        <target state="translated">테스트 병렬 처리를 명시적으로 사용하거나 사용하지 않도록 설정</target>
        <note />
      </trans-unit>
      <trans-unit id="UseProperAssertMethodsDescription">
        <source>Specialized assertion methods improve readability and provide more precise failure diagnostics.</source>
        <target state="new">Specialized assertion methods improve readability and provide more precise failure diagnostics.</target>
        <note />
      </trans-unit>
      <trans-unit id="UseProperAssertMethodsMessageFormat">
        <source>Use 'Assert.{0}' instead of 'Assert.{1}'</source>
        <target state="translated">'Assert. {1}'대신 'Assert. {0}' 사용</target>
        <note>{0} is the preferred assert method name. {1} is the current assert method name. {Locked="Assert"}</note>
      </trans-unit>
      <trans-unit id="UseProperAssertMethodsTitle">
        <source>Use proper 'Assert' methods</source>
        <target state="translated">적절한 'Assert' 메서드 사용</target>
        <note>{Locked="Assert"}</note>
      </trans-unit>
      <trans-unit id="UseRetryWithTestMethodDescription">
        <source>Retry attributes have no effect on methods or classes that MSTest does not recognize as tests.</source>
        <target state="new">Retry attributes have no effect on methods or classes that MSTest does not recognize as tests.</target>
        <note>{Locked="MSTest"}</note>
      </trans-unit>
      <trans-unit id="UseRetryWithTestMethodMessageFormat">
        <source>An attribute that derives from 'RetryBaseAttribute' can be specified only on a test method or a test class</source>
        <target state="translated">'RetryBaseAttribute'에서 파생되는 특성은 테스트 메서드 또는 테스트 class에서만 지정할 수 있습니다.</target>
        <note>{Locked="RetryBaseAttribute"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="UseRetryWithTestMethodTitle">
        <source>Use retry attribute on test method or test class</source>
        <target state="translated">테스트 메서드 또는 테스트 class에서 다시 시도 특성 사용</target>
        <note>{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="TestContextPropertyUsageTitle">
        <source>TestContext property cannot be accessed in this context</source>
        <target state="translated">이 컨텍스트에서 TestContext 속성에 액세스할 수 없습니다.</target>
        <note>{Locked="TestContext"}</note>
      </trans-unit>
      <trans-unit id="TestContextPropertyUsageMessageFormat">
        <source>TestContext property '{0}' cannot be accessed in '{1}' method</source>
        <target state="translated">'{1}' 메서드에서 TestContext 속성 '{0}'에 액세스할 수 없습니다.</target>
        <note>{0} is the TestContext property name. {1} is the lifecycle method name. {Locked="TestContext"}</note>
      </trans-unit>
      <trans-unit id="TestContextPropertyUsageDescription">
        <source>Some TestContext properties are only available during test execution and cannot be accessed in assembly initialize, class initialize, class cleanup, or assembly cleanup methods.</source>
        <target state="translated">일부 TestContext 속성은 테스트 실행 중에만 사용할 수 있으며, 어셈블리 초기화, class 초기화, class 정리 또는 어셈블리 정리 메서드에서는 액세스할 수 없습니다.</target>
        <note>{Locked="TestContext"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="AssertThrowsShouldContainSingleStatementDescription">
        <source>Assert.Throws methods should contain only a single statement or expression. Multiple statements can be misleading - if the first statement throws, subsequent statements are never executed; if it doesn't throw, it should be moved outside the Assert.Throws.</source>
        <target state="translated">Assert.Throws 메서드는 단일 문 또는 식만 포함해야 합니다. 여러 문이 있을 경우 혼란을 줄 수 있습니다. 첫 번째 문이 예외를 발생시키면 후속 문은 실행되지 않으며, 예외가 발생하지 않는 경우에는 Assert.Throws 외부로 이동해야 합니다.</target>
        <note>{Locked="Assert.Throws"}</note>
      </trans-unit>
      <trans-unit id="AssertThrowsShouldContainSingleStatementMessageFormat">
        <source>Assert.Throws should contain only a single statement/expression</source>
        <target state="translated">Assert.Throws는 단일 문/식만 포함해야 합니다.</target>
        <note>{Locked="Assert.Throws"}</note>
      </trans-unit>
      <trans-unit id="AssertThrowsShouldContainSingleStatementTitle">
        <source>Assert.Throws should contain only a single statement/expression</source>
        <target state="translated">Assert.Throws는 단일 문/식만 포함해야 합니다.</target>
        <note>{Locked="Assert.Throws"}</note>
      </trans-unit>
      <trans-unit id="AvoidAssertsInCatchBlocksTitle">
        <source>Do not use asserts in catch blocks</source>
        <target state="translated">catch 블록에서 어설션 사용 안 함</target>
        <note>{Locked="catch"}</note>
      </trans-unit>
      <trans-unit id="AvoidAssertsInCatchBlocksMessageFormat">
        <source>Do not use asserts in catch blocks because they may not fail the test if no exception is thrown</source>
        <target state="translated">예외가 발생하지 않으면 테스트가 실패하지 않을 수 있으니 catch 블록에서 어설션을 사용하지 마세요.</target>
        <note>{Locked="catch"}</note>
      </trans-unit>
      <trans-unit id="AvoidAssertsInCatchBlocksDescription">
        <source>Using asserts in catch blocks is problematic because the test will pass even if no exception is thrown and the catch block is never executed. Use 'Assert.Throws', 'Assert.ThrowsExactly', 'Assert.ThrowsAsync' or 'Assert.ThrowsExactlyAsync' to verify that an exception is thrown, and then make additional assertions on the caught exception without using the try-catch block. The rule also flags 'throw new AssertFailedException(...)' and 'throw new AssertInconclusiveException(...)' (the desugared forms of 'Assert.Fail' and 'Assert.Inconclusive'). 'Assert.Inconclusive' (and 'throw new AssertInconclusiveException(...)') is exempt when used inside a filtered catch ('catch (...) when (...)'), because demoting a caught failure to an Inconclusive outcome is the only use case that cannot be expressed without a catch block. For other intentional bypasses (for example, attaching a runtime-built message to the failure), suppress the diagnostic with '#pragma warning disable MSTEST0058'.</source>
        <target state="translated">예외가 발생하지 않고 catch 블록이 실행되지 않더라도 테스트가 통과하기 때문에 catch 블록에서 어설션을 사용하는 것은 문제가 됩니다. 'Assert.Throws', 'Assert.ThrowsExactly', 'Assert.ThrowsAsync' 또는 'Assert.ThrowsExactlyAsync'를 사용하여 예외가 발생했는지 확인한 다음 try-catch 블록을 사용하지 않고 catch된 예외에 대해 추가 어설션을 만듭니다. 이 규칙은 'throw new AssertFailedException(...)'과 'throw new AssertInconclusiveException(...)'에도 플래그를 지정합니다. 이는 'Assert.Fail'과 'Assert.Inconclusive'의 구문상 풀어 쓴 형태입니다. 'Assert.Inconclusive'와 'throw new AssertInconclusiveException(...)'는 필터링된 catch('catch (...) when (...)') 안에서 사용할 때는 예외입니다. 포착한 실패를 Inconclusive 결과로 낮추는 경우는 catch 블록 없이 표현할 수 없는 유일한 사용 사례이기 때문입니다. 다른 의도적인 우회 방법이 필요한 경우에는 예를 들어 런타임에 만든 메시지를 실패에 연결하려는 경우입니다. '#pragma warning disable MSTEST0058'를 사용하여 진단을 억제하세요.</target>
        <note>{Locked="#pragma warning disable MSTEST0058"}{Locked="AssertInconclusiveException"}{Locked="Assert.ThrowsExactlyAsync"}{Locked="AssertFailedException"}{Locked="Assert.ThrowsExactly"}{Locked="Assert.Inconclusive"}{Locked="Assert.ThrowsAsync"}{Locked="Assert.Throws"}{Locked="Assert.Fail"}{Locked="throw new AssertFailedException(...)"}{Locked="throw new AssertInconclusiveException(...)"}{Locked="catch"}</note>
      </trans-unit>
      <trans-unit id="DoNotUseParallelizeAndDoNotParallelizeTogetherDescription">
        <source>An assembly should have either '[Parallelize]' or '[DoNotParallelize]' attribute, but not both. Having both attributes creates an ambiguous configuration. When both are present, '[DoNotParallelize]' takes precedence and parallelization will be disabled.</source>
        <target state="translated">어셈블리에는 '[Parallelize]' 또는 '[DoNotParallelize]' 속성 중 하나만 있어야 하며, 둘 다 있어서는 안 됩니다. 두 특성을 모두 지정하면 모호한 구성이 만들어집니다. 둘 다 있는 경우 '[DoNotParallelize]'가 우선적으로 적용되고 병렬화가 사용하지 않도록 설정됩니다.</target>
        <note>{Locked="[Parallelize]"}{Locked="[DoNotParallelize]"}</note>
      </trans-unit>
      <trans-unit id="DoNotUseParallelizeAndDoNotParallelizeTogetherMessageFormat">
        <source>Assembly has both '[Parallelize]' and '[DoNotParallelize]' attributes which creates ambiguity</source>
        <target state="translated">어셈블리에 모호성을 만드는 '[Parallelize]' 및 '[DoNotParallelize]' 특성이 모두 있습니다.</target>
        <note>{Locked="[Parallelize]"}{Locked="[DoNotParallelize]"}</note>
      </trans-unit>
      <trans-unit id="DoNotUseParallelizeAndDoNotParallelizeTogetherTitle">
        <source>Do not use both '[Parallelize]' and '[DoNotParallelize]' attributes</source>
        <target state="translated">'[Parallelize]' 및 '[DoNotParallelize]' 특성을 모두 사용하지 마세요.</target>
        <note>{Locked="[Parallelize]"}{Locked="[DoNotParallelize]"}</note>
      </trans-unit>
      <trans-unit id="UseOSConditionAttributeInsteadOfRuntimeCheckTitle">
        <source>Use '[OSCondition]' attribute instead of 'RuntimeInformation.IsOSPlatform' calls with early return or 'Assert.Inconclusive'</source>
        <target state="translated">초기 반환 또는 'Assert.Inconclusive'를 사용하여 'RuntimeInformation.IsOSPlatform' 호출 대신 '[OSCondition]' 특성을 사용합니다.</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">초기 반환 또는 'Assert.Inconclusive'를 사용하여 'RuntimeInformation.IsOSPlatform' 호출 대신 '[OSCondition]' 특성을 사용합니다.</target>
        <note>{Locked="RuntimeInformation.IsOSPlatform"}{Locked="Assert.Inconclusive"}{Locked="[OSCondition]"}</note>
      </trans-unit>
      <trans-unit id="UseOSConditionAttributeInsteadOfRuntimeCheckDescription">
        <source>Test methods that use 'RuntimeInformation.IsOSPlatform' with early return or 'Assert.Inconclusive' should use the '[OSCondition]' attribute instead. This attribute provides a more declarative and discoverable way to specify OS-specific test requirements.</source>
        <target state="translated">'RuntimeInformation.IsOSPlatform'을 조기 반환 또는 ‘Assert.Inconclusive'와 함께 사용하는 테스트 메서드는 대신 ’[OSCondition]' 속성을 사용해야 합니다. 이 특성은 OS별 테스트 요구 사항을 더 선언적이고 쉽게 찾을 수 있게 지정하는 방법입니다.</target>
        <note>{Locked="RuntimeInformation.IsOSPlatform"}{Locked="Assert.Inconclusive"}{Locked="[OSCondition]"}</note>
      </trans-unit>
      <trans-unit id="DuplicateTestMethodAttributeTitle">
        <source>Avoid duplicate test method attributes</source>
        <target state="translated">중복 테스트 메서드 특성 방지</target>
        <note />
      </trans-unit>
      <trans-unit id="DuplicateTestMethodAttributeMessageFormat">
        <source>Test method '{0}' has multiple attributes that inherit from 'TestMethodAttribute'. Only one test method attribute should be used.</source>
        <target state="translated">테스트 메서드 '{0}'에 'TestMethodAttribute'에서 상속되는 여러 특성이 있습니다. 테스트 메서드 특성은 하나만 사용해야 합니다.</target>
        <note>{0} is the test method name. {Locked="TestMethodAttribute"}</note>
      </trans-unit>
      <trans-unit id="DuplicateTestMethodAttributeDescription">
        <source>A test method should be marked with exactly one attribute that is or inherits from 'TestMethodAttribute'. When multiple such attributes are present, only the first one returned by reflection will be used.</source>
        <target state="translated">테스트 메서드는 'TestMethodAttribute'에서 상속되거나 정확히 하나의 특성으로 표시되어야 합니다. 이러한 특성이 여러 개 있는 경우 리플렉션에서 반환된 첫 번째 특성만 사용됩니다.</target>
        <note>{Locked="TestMethodAttribute"}</note>
      </trans-unit>
      <trans-unit id="AvoidOutRefTestMethodParametersTitle">
        <source>Avoid using 'out' or 'ref' parameters in test methods</source>
        <target state="translated">테스트 메서드에서는 'out'이나 'ref' 매개 변수 사용 피하기</target>
        <note>{Locked="out"}{Locked="ref"}</note>
      </trans-unit>
      <trans-unit id="AvoidOutRefTestMethodParametersMessageFormat">
        <source>Test method '{0}' has 'out' or 'ref' parameters for which support will be dropped in a future major version</source>
        <target state="translated">테스트 메서드 '{0}'에는 앞으로 주요 버전에서 지원이 중단될 'out' 또는 'ref' 매개 변수가 포함되어 있습니다.</target>
        <note>{0} is the test method name. {Locked="out"}{Locked="ref"}</note>
      </trans-unit>
      <trans-unit id="AvoidOutRefTestMethodParametersDescription">
        <source>'out' and 'ref' parameters add no value in test methods and they can safely be replaced by normal parameters.</source>
        <target state="translated">'out'과 'ref' 매개 변수는 테스트 메서드에서 별다른 가치를 제공하지 않으며 일반 매개 변수로 안전하게 대체할 수 있습니다.</target>
        <note>{Locked="out"}{Locked="ref"}</note>
      </trans-unit>
      <trans-unit id="TestClassConstructorShouldBeValidTitle">
        <source>Test classes should have valid constructors</source>
        <target state="translated">테스트 클래스에는 유효한 생성자가 있어야 합니다.</target>
        <note />
      </trans-unit>
      <trans-unit id="TestClassConstructorShouldBeValidMessageFormat">
        <source>Test class '{0}' does not have a valid constructor. Valid constructors are 'public' and either parameterless or with one parameter of type 'TestContext'.</source>
        <target state="translated">테스트 class '{0}'에 유효한 생성자가 없습니다. 유효한 생성자는 'public'이며 매개 변수가 없거나 'TestContext' 유형의 매개 변수가 하나 있습니다.</target>
        <note>{0} is the test class name. {Locked="TestContext"}{Locked="public"}{Locked="class"}</note>
      </trans-unit>
      <trans-unit id="TestClassConstructorShouldBeValidDescription">
        <source>Test classes must have a public constructor that is either parameterless or accepts a single TestContext parameter. This allows the test framework to instantiate the test class properly.</source>
        <target state="translated">테스트 class에는 매개 변수가 없거나 TestContext 매개 변수 하나를 받는 public 생성자가 있어야 합니다. 그래야 테스트 프레임워크가 테스트 class를 올바르게 생성할 수 있습니다.</target>
        <note>{Locked="TestContext"}{Locked="public"}{Locked="class"}</note>
      </trans-unit>
    </body>
  </file>
</xliff>