<?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="tr" 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]' ile işaretlenen yöntemlerin geçerli olması için aşağıdaki düzeni takip etmesi gerekir:
-genel bir class tanımlanamaz
-'public' olmalıdır
-'static' olmalıdır
-'async void' olmamalıdır
-özel bir metot (sonlandırıcı, işleç...) olmamalıdır.
- genel olmamalıdır
-herhangi bir parametre almamalı veya 'TestContext' türünde tek bir parametre almalıdır
- dönüş türü 'void', 'Task' veya 'ValueTask' olmalıdır

Bu metotları bildiren türün ayrıca aşağıdaki kurallara uyması gerekir:
-Tür bir class olmalıdır
-class 'public' veya 'internal' olmalıdır (test projesi '[DiscoverInternals]' niteliğini kullanıyorsa)
-class 'static' olmamalıdır
-class '[TestClass]' (veya türetilmiş bir öznitelik) ile işaretlenmelidir
-class genel olmamalıdır.</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 yöntemi '{0}' imzası geçersiz</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 yöntemleri geçerli bir düzene sahip olmalıdır</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]' bulma işlemi, çalışma zamanı dinamik kod oluşturamadığında desteklenmeyen çalışma zamanı derleme başvurusu grafiğinin izlenmesine dayanıyor (örneğin Native AOT veya Blazor WebAssembly AOT altında). Öznitelik bu tür derlemelerde yoksayılır, bu nedenle sağlanan derleme başlatma ve temizleme yöntemleri çalışmaz. Bunun yerine '[AssemblyInitialize]' ve '[AssemblyCleanup]' yöntemlerini doğrudan test derlemesinde bildirin.</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]' zamanından önce derleme ile desteklenmiyor (Native AOT veya Blazor WebAssembly AOT gibi) ve çalışma zamanında yoksayılacak</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]' zamanından önce derleme ile desteklenmiyor</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]' ile işaretlenen yöntemlerin geçerli olması için aşağıdaki düzeni izlemesi gerekir:
-genel bir class tanımlanamaz
-'public' olmalıdır
-'static' olmalıdır
-'async void' olmamalıdır
-özel bir yöntem (sonlandırıcı, işleç...) olmamalıdır.
- genel olmamalıdır
- 'TestContext' türünden bir parametre almalıdır
- dönüş türü 'void', 'Task' veya 'ValueTask' olmalı

Bu yöntemleri bildiren tipin ayrıca aşağıdaki kurallara uyması gerekir:
-Tür bir class olmalıdır
-class 'public' veya 'internal' olmalıdır (test projesi '[DiscoverInternals]' niteliğini kullanıyorsa)
-class 'static' olmamalıdır
-class '[TestClass]' (veya türetilmiş bir öznitelik) ile işaretlenmelidir
-class genel olmamalıdır.</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 yöntemi '{0}' imzası geçersiz</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 yöntemleri geçerli bir düzene sahip olmalıdır</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 değerini denetlerken ek bir onaylama eklemeyi tercih et</target>
        <note>{Locked="null"}</note>
      </trans-unit>
      <trans-unit id="AssertionArgsShouldAvoidConditionalAccessTitle">
        <source>Avoid conditional access in assertions</source>
        <target state="translated">Onaylamalarda koşullu erişimden kaçın</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' ve 'Assert.AreNotSame' ilk olarak expected değerin geçirilmesini ve actual değerin ikinci bağımsız değişken olarak geçirilmesini bekliyor.</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">Onay deyimi bağımsız değişkenleri doğru sıralama düzeninde geçirilmelidir. 'actual' ve 'expected'/'notExpected' bağımsız değişkenleri değiştirildi.</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">Onay deyimi bağımsız değişkenleri doğru sıralama düzeninde geçirilmelidir</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` ve `Assert.AreNotEqual`, `EqualityComparer&lt;T&gt;.Default` kullanır. Koleksiyon benzeri türlerde bu, dizi öğelerini karşılaştırmak yerine türün kendi eşitlik semantiğine dayanır. Bu nedenle genellikle `Assert.AreSequenceEqual`/`Assert.AreNotSequenceEqual` ya da `Assert.AreEquivalent`/`Assert.AreNotEquivalent` daha uygundur.</target>
        <note>{Locked="EqualityComparer&lt;T&gt;.Default"}{Locked="Assert.AreNotSequenceEqual"}{Locked="Assert.AreSequenceEqual"}{Locked="Assert.AreNotEquivalent"}{Locked="Assert.AreEquivalent"}{Locked="Assert.AreNotEqual"}{Locked="Assert.AreEqual"}</note>
      </trans-unit>
      <trans-unit id="AvoidAssertAreEqualOnCollectionsMessageFormat">
        <source>`{0}` on {1} (which implements IEnumerable&lt;T&gt;) does not perform element-wise sequence comparison. Use `Assert.AreSequenceEqual` for ordered element-wise comparison, `Assert.AreSequenceEqual(..., SequenceOrder.InAnyOrder)` for unordered, or `Assert.AreEquivalent` for deep structural comparison.</source>
        <target state="translated">`{0}` üzerinde {1} (IEnumerable&lt;T&gt; uygulayan) öğe bazında dizi karşılaştırması yapmaz. Sıralı öğe bazında karşılaştırma için `Assert.AreSequenceEqual`, sırasız karşılaştırma için `Assert.AreSequenceEqual(..., SequenceOrder.InAnyOrder)` ya da derin yapısal karşılaştırma için `Assert.AreEquivalent` kullanın.</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">Koleksiyon türleri için Assert.AreEqual kullanmaktan kaçının</target>
        <note>{Locked="Assert.AreEqual"}</note>
      </trans-unit>
      <trans-unit id="AvoidAssertAreSameWithValueTypesDescription">
        <source>Use 'Assert.AreEqual'/'Assert.AreNotEqual' instead of 'Assert.AreSame'/'Assert.AreNotSame' when comparing value types. Passing a value type to 'Assert.AreSame'/'Assert.AreNotSame' will be boxed (creating a new object). Because 'Assert.AreSame'/'Assert.AreNotSame' does the comparison by reference, 'Assert.AreSame' will fail when boxing happens, and 'Assert.AreNotSame' will always pass.</source>
        <target state="translated">Değer türlerini karşılaştırırken 'Assert.AreSame'/'Assert.AreNotSame' yerine 'Assert.AreEqual'/'Assert.AreNotEqual' kullanın. 'Assert.AreSame'/'Assert.AreNotSame' yöntemine bir değer türü geçirildiğinde kutulanır ve yeni bir nesne oluşturulur. 'Assert.AreSame'/'Assert.AreNotSame' karşılaştırmayı başvuruya göre yaptığından, kutulama olduğunda 'Assert.AreSame' başarısız olur ve 'Assert.AreNotSame' her zaman geçer.</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">Değer '{0}' karşılaştırılırken '{1}' yerine farklı bir ad kullanın</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">Değer türleriyle 'Assert.AreSame' veya 'Assert.AreNotSame' kullanma</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">Varsayılan otomatik algılama davranışını kullanmak için ‘DynamicDataSourceType’ bağımsız değişkenini kaldırın</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">Açık bir ‘DynamicDataSourceType’ geçirmeyin ve varsayılan otomatik algılama davranışını kullanın</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">Test yöntemleri veya test düzenleri içinde geçerli iş parçacığını 'Thread.Sleep', 'Task.Wait', 'Task.WaitAll', 'Task.WaitAny' ya da 'Task&lt;TResult&gt;.Result' ile eşzamanlı olarak engellemek, yaygın bir kararsızlık kaynağıdır ve test çerçevesi, ortaklaşa zamanlama gerektiren bir SynchronizationContext üzerinde testleri çalıştırdığında kilitlenmeye de neden olabilir. Zaman tabanlı beklemeler için 'await Task.Delay' seçeneğini tercih edin ve sonucunu gözlemlemek üzere görev için 'await' kullanın.</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">Test kodunda '{0}' kullanmaktan kaçının çünkü testlerde kararsızlığa neden olabilir. Bunun yerine 'await Task.Delay' gibi bir zaman uyumsuz alternatif kullanın veya görev için 'await' kullanın</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">Test kodunda 'Thread.Sleep', 'Task.Wait', 'Task.WaitAll', 'Task.WaitAny' veya 'Task&lt;TResult&gt;.Result' gibi eşzamanlı olarak engelleyen çağrılardan kaçının</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' yöntemlerinin, yerel işlevlerin veya lambda ifadelerinin içinde onaylamayın. Bu bağlamda oluşturulan özel durumlar işlenmeyen özel durumlar olur. .NET Framework altında VSTest kullanıldığında bunlar sessizce yutulur. Microsoft.Testing.Platform veya modern .NET altında VSTest kullanıldığında işlem çöker.</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' metotları, yerel işlevler veya lambdalar içinde onaylamayın çünkü test başarısız olamazlar</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' bağlamları içinde onaylama</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]' ile işaretlenen yöntemlerin geçerli olması için aşağıdaki düzeni takip etmesi gereklidir:
-'InheritanceBehavior' modu ayarlanmadan genel bir class tanımlanamaz
-'public' olmalıdır
-'static' olmalıdır
-'async void' olmamalıdır
-özel bir metot (sonlandırıcı, işleç...) olmamalıdır.
- genel olmamalıdır
-herhangi bir parametre almamalı veya 'TestContext' türünde tek bir parametre almalıdır
- dönüş türü 'void', 'Task' veya 'ValueTask' olmalıdır
-class 'abstract' ise 'InheritanceBehavior.BeforeEachDerivedClass' öznitelik parametresi belirtilmelidir
-'InheritanceBehavior.BeforeEachDerivedClass' öznitelik parametresi, class 'sealed' ise belirtilmemelidir

Bu metotları bildiren türün ayrıca aşağıdaki kurallara uyması gerekir:
-Tür bir class olmalıdır
-class 'public' veya 'internal' olmalıdır (test projesi '[DiscoverInternals]' niteliğini kullanıyorsa)
-class 'static' olmamalıdır
-class 'sealed' ise '[TestClass]' (veya türetilmiş bir öznitelik) ile işaretlenmelidir
-class genel olmamalıdır.</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 yöntemi '{0}' imzası geçersiz</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 yöntemleri geçerli bir düzene sahip olmalıdır</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]' ile işaretlenen yöntemlerin geçerli olması için aşağıdaki düzeni takip etmesi gereklidir:
-'InheritanceBehavior' modu ayarlanmadan genel bir class tanımlanamaz
-'public' olmalıdır
-'static' olmalıdır
-'async void' olmamalıdır
-özel bir yöntem (sonlandırıcı, işleç...) olmamalıdır.
- genel olmamalıdır
- 'TestContext' türünden bir parametre almalıdır
- dönüş türü 'void', 'Task' veya 'ValueTask' olmalı
-class 'abstract' ise 'InheritanceBehavior.BeforeEachDerivedClass' öznitelik parametresi belirtilmelidir.
-'InheritanceBehavior.BeforeEachDerivedClass' öznitelik parametresi, class 'sealed' ise belirtilmemelidir

Bu yöntemleri bildiren tipin ayrıca aşağıdaki kurallara uyması gerekir:
-Tür bir class olmalıdır
-class 'public' veya 'internal' olmalıdır (test projesi '[DiscoverInternals]' niteliğini kullanıyorsa)
-class 'static' olmamalıdır
-class 'sealed' ise '[TestClass]' (veya türetilmiş bir öznitelik) ile işaretlenmelidir.
-class genel olmamalıdır.</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 yöntemi '{0}' imzası geçersiz</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 yöntemleri geçerli bir düzene sahip olmalıdır</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}' yerine 'Assert.{0}' kullanın</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' yerine 'Assert' kullanın</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' ve 'DefaultThreadCurrentUICulture', tüm işlem için varsayılan kültürü ayarlar; bu nedenle eşzamanlı çalışan her test değişikliği gözlemler ve bütünleştirilmiş kod içi paralelleştirme altında biçimlendirme veya ayrıştırma bozulabilir. İş parçacığı başına ve ortam biçimleri kasıtlı olarak bayrak eklenmiş değildir: modern .NET'te 'Thread.CurrentThread.CurrentCulture' / 'CurrentUICulture' ve 'CultureInfo.CurrentCulture' / 'CurrentUICulture' ayarlayıcılarının tümü, yürütme bağlamıyla birlikte akan 'AsyncLocal' destekli bir değer atar; bu nedenle kardeş testleri bozmazlar veya daha sonra havuza alınan iş parçacıklarına sızmazlar. Bayrak eklenmiş ayarlayıcılar işlem-genel olduğundan, önceki değeri bir 'finally' içinde geri yüklemek yardımcı olmaz - eşzamanlı çalışan testler yine de değişiklik süresi boyunca değiştirilmiş kültürü gözlemler; testte '[DoNotParallelize]' bildirin ya da bunun yerine işlem-genel kültürü değiştirmekten kaçının.</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}' tüm işlem için varsayılan kültürü ayarlar; bu nedenle eşzamanlı çalışan her test değişikliği gözlemler ve bu, paralel çalışan testlerde biçimlendirme ve ayrıştırmayı bozabilir; bunu paralelleştirilmiş bir test paketinde değiştirmekten kaçının veya '[DoNotParallelize]' bildirin</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">Paralelleştirilmiş bir testte işlem-genel kültürü değiştirmekten kaçının</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">Geçerli dizin her işletim sisteminde işlem geneldir ve kültürden farklı olarak iş parçacığı kapsamlı ya da zaman uyumsuz kapsamlı bir eşdeğeri yoktur. Bir test bunu değiştirdiğinde, eşzamanlı çalışan her testin çalışma dizinini bozar ve paketin başka bir yerinde çözümlenen göreli yollar sessizce yanlış konuma işaret eder. Bir '[ResourceLock]' çakışan testleri sıralar ve değişikliği güvenli hale getirir, ancak paralel bir pakette yine de bir tasarım kokusudur: geçerli dizinin hiç değiştirilmesine gerek kalmaması için mutlak yollar geçirmeyi tercih edin.</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}' işlem-genel geçerli dizini değiştirir; bunun iş parçacığı başına bir karşılığı yoktur ve eşzamanlı çalışan her test tarafından gözlemlenir; paralelleştirilmiş bir test paketinde bunu değiştirmekten kaçının (en azından koordinasyon sağlamak için '[ResourceLock(WellKnownResources.CurrentDirectory)]' bildirin ya da '[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">Paralelleştirilmiş bir testte geçerli dizini değiştirmekten kaçının</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">Bir ‘[DependsOn]’ özniteliği, bir testi adına göre referans alır. Hiçbir testle eşleşmeyen bir referans, çalışma zamanında kasıtlı olarak hataya yol açmaz; böylece test dizisinin bir alt kümesinin çalıştırılması mümkün kalır. Bu da, bir yazım hatası veya ad değişikliğinin, bildirilen sıralamayı sessizce bozacağı anlamına gelir. Bu analiz aracı, derleme aşamasında tespit edilebilen sorunları bildirir: başvurulan türde bulunmayan bir yöntem, test olmayan bir hedef, kendisine bağımlı olan bir test, derleme sırasında görülebilen bir bağımlılık döngüsü, başka bir derlemede bulunan bir türe yapılan başvuru (bağımlılıklar tek bir test kaynağı içinde çözülür) ve hiçbir etkisi olmayacak bir yere uygulanan bir öznitelik.</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}' soyut türüne başvurur; testleri '{0}' altında değil, her bir türetilmiş test sınıfı altında çalıştırılır, bu nedenle bağımlılık çalışma zamanında göz ardı edilir</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]‘, çalışma zamanında döngü içindeki tüm testlerin başarısız olmasına neden olan ’{0}' bağımlılık döngüsünü tanımlar</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]', '{0}' türünde bulunmayan '{1}' yöntemine başvuruyor</target>
        <note>{0} is the referenced type name. {1} is the referenced method name. {Locked="[DependsOn]"}</note>
      </trans-unit>
      <trans-unit id="DependsOnShouldBeValidMessageFormat_NoEffect">
        <source>'[DependsOn]' has no effect because '{0}' is not a test method</source>
        <target state="translated">'[DependsOn]‘ herhangi bir etki yaratmaz çünkü ’{0}' bir test yöntemi değildir</target>
        <note>{0} is the name of the method the attribute is applied to. {Locked="[DependsOn]"}</note>
      </trans-unit>
      <trans-unit id="DependsOnShouldBeValidMessageFormat_NoEffectOnClass">
        <source>'[DependsOn]' has no effect because discovery runs no test under '{0}'</source>
        <target state="translated">'[DependsOn]‘ herhangi bir etkiye sahip değildir, çünkü keşif işlemi ’{0}' altında herhangi bir test yürütmez</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]‘ öğesi, bir test sınıfı olmayan ’{0}' türüne atıfta bulunuyor; bu nedenle bağımlılık çalışma zamanında göz ardı ediliyor</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]‘ öğesi, bir test yöntemi olmayan ’{0}.{1}' öğesine atıfta bulunuyor; bu nedenle bağımlılık çalışma zamanında göz ardı ediliyor</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]‘ başka bir derlemede bulunan ’{0}' türüne başvuruyor; bağımlılıklar tek bir test kaynağı içinde çözümlenir, bu nedenle bu bağımlılık çalışma zamanında göz ardı edilir</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]‘ komutu, ’{0}' öğesinin kendisine bağımlı olmasını sağlar; bu durum bir bağımlılık döngüsü oluşturur ve testin çalışma zamanında başarısız olmasına neden olur</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]' argümanları geçerli olmalıdır</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]' özniteliği tarafından başvurulan üyeler, başvurulan türde mevcut olmalı, 'public static' olmalı, 'bool' döndürmeli ve (yöntemler için) parametresiz olmalıdır. Bu kurallar ihlal edildiğinde öznitelik çalışma zamanında hata oluşturur; bu çözümleyici aynı sorunları derleme zamanında ortaya çıkarır, böylece yazım hataları ve yeniden düzenlemeler test geçişini sessizce bozmaz.</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]' üyesi '{0}.{1}' bulunamadı</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]' başvurulan özelliği '{0}.{1}' 'public' olmalıdır</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]' başvurulan üyesi '{0}.{1}' 'static' olmalıdır</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]' başvurulan üyesi '{0}.{1}' bir özellik, alan veya parametresiz yöntem olmalıdır</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]' başvurulan üyesi '{0}.{1}' 'bool' döndürmelidir</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]' başvurulan yöntemi '{0}.{1}' parametresiz olmalıdır</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]' başvurulan özelliği '{0}.{1}' bir alıcı içermelidir</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]' bağımsız değişkenleri geçerli olmalıdır</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 girdisi, geçerli olması için aşağıdaki koşulları karşılamalıdır:
- yalnızca bir test yönteminde ayarlanmalıdır; 
- bağımsız değişken sayısı yöntem bağımsız değişkeni sayısıyla eşleşmelidir;
- bağımsız değişken sayısı yöntem bağımsız değişkeni sayısıyla eşleşmelidir.</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 bağımsız değişken sayısı, yöntem parametresi sayısıyla eşleşmelidir (oluşturucu bağımsız değişkenleri: {0}, yöntem parametreleri: {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 bağımsız değişken türleri, yöntem parametre türleriyle eşleşmiyor. {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">Parametre ‘{0}’ tipi ‘{1}’ bekliyor, ancak verilen değer ‘{2}’ tipindedir</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">Genel parametre türü için iki çakışan tür '{0}'. Çakışan türler '{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">Genel parametre türü '{0}' çıkarsanamadı.</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 yalnızca bir test yönteminde ayarlanmalıdır</target>
        <note>{Locked="DataRow"}</note>
      </trans-unit>
      <trans-unit id="DataRowShouldBeValidTitle">
        <source>DataRow should be valid</source>
        <target state="translated">DataRow geçerli olmalıdır</target>
        <note>{Locked="DataRow"}</note>
      </trans-unit>
      <trans-unit id="DoNotNegateBooleanAssertionFix">
        <source>Use 'Assert.{0}' instead</source>
        <target state="translated">Bunun yerine 'Assert.{0}' kullanın</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">Tüm olumsuz doğrulamalar için uygun Assert yöntemlerini kullanın</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">Boole onay deyimlerini tersine çevirme, bunun yerine ters onay deyimini kullan</target>
        <note />
      </trans-unit>
      <trans-unit id="DoNotNegateBooleanAssertionTitle">
        <source>Do not negate boolean assertions</source>
        <target state="translated">Boole onay deyimlerini tersine çevirme</target>
        <note />
      </trans-unit>
      <trans-unit id="DoNotStoreStaticTestContextAnalyzerMessageFormat">
        <source>Do not store TestContext in a static member</source>
        <target state="translated">TestContext'i static üyede depolama</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'i static üyede depolama</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">Gölge test üyeleri test sorunlarına (NRE gibi) neden olabilir.</target>
        <note />
      </trans-unit>
      <trans-unit id="DoNotUseShadowingMessageFormat">
        <source>Member '{0}' already exists in the base class</source>
        <target state="translated">'{0}' adlı üye zaten temel class mevcut</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">Gölgeleme kullanma</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'un testler bağlamında hiçbir etkisi yoktur ve muhtemelen bunun yerine 'Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute' kullanmak istediniz.</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' kullanmayı mı düşündünüz?</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' test yöntemlerini etkilemez</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' özniteliklerini kopyalamayın. Bu genellikle kopyala-yapıştır hatasıdır. Öznitelik dizinleri '{0}' ve '{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' girdilerinin yenilenmesinden kaçının</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]' girdisinin geçerli olması için aşağıdaki koşulları karşılamalıdır:
- yalnızca bir test yönteminde ayarlanmalıdır; 
- üye belirtilen türde tanımlanmalıdır;
- DynamicDataSourceType.Method belirtilmişse üye bir yöntem olmalı, aksi takdirde bir özellik olmalıdır.</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]' veri üyesi '{0}.{1}' imzası geçersiz</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]' görünen ad yöntemi '{0}.{1}' imzası geçersiz</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]' üyesi '{0}.{1}' bir yöntem olmalıdır</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]' üyesi '{0}.{1}' bulunamıyor</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]' başvurulan üyesi '{0}.{1}' şu değerleri döndürmelidir: 'IEnumerable&lt;object[]&gt;', 'IEnumerable&lt;Tuple&gt;` veya '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]' yalnızca bir test yönteminde ayarlanmalıdır</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]’ üyesi ‘{0}.{1}’, bir alandır, bu nedenle ‘DynamicDataSourceType.AutoDetect’ veya ‘DynamicDataSourceType.Field’ kullanmalısınız (otomatik algılama, açıkça belirtilmediğinde varsayılan ayardır ve önerilir)</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]' üyesi '{0}.{1}' bir metot olduğundan 'DynamicDataSourceType.AutoDetect' veya 'DynamicDataSourceType.Method' kullanmalısınız (otomatik algılama açıkça belirtilmediğinden varsayılandır ve önerilir)</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]’ üyesi ‘{0}.{1}’, bir özellik, yöntem veya alan değildir. Yalnızca özellikler, yöntemler ve alanlar desteklenir.</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}' üyesi bir özellik veya yöntem değil. Yalnızca özellikler ve yöntemler desteklenir.</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]' üyesi '{0}.{1}' bir özelliktir, bu nedenle 'DynamicDataSourceType.AutoDetect' veya 'DynamicDataSourceType.Property' kullanmalısınız (otomatik algılama açıkça belirtilmediğinden varsayılandır ve önerilir)</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]' üyesi '{0}.{1}' birden çok kez bulundu</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 geçerli olmalıdır</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 parametresini kabul eden aşırı yüklemeleri olan async yöntemleri çağırırken, işbirliğine dayalı iptal işlemini etkinleştirmek ve test zaman aşımlarını dikkate almak için TestContext.CancellationToken ile aşırı yüklemeyi kullanmayı tercih edin.</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'ı kabul eden aşırı yüklemeyi kullanmayı düşünün ve 'TestContext.CancellationToken'i geçirin</target>
        <note>{Locked="TestContext.CancellationToken"}{Locked="CancellationToken"}</note>
      </trans-unit>
      <trans-unit id="FlowTestContextCancellationTokenTitle">
        <source>Flow TestContext.CancellationToken to async operations</source>
        <target state="translated">TestContext.CancellationToken'ı async işlemler için akışa aktarın</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]' veya '[GlobalTestCleanup]' ile işaretlenmiş yöntemlerin geçerli olabilmesi için şu düzeni izlemesi gerekir:
-genel bir class tanımlanamaz
-'public' olmalıdır
-'static' olmalıdır
-'async void' olmamalıdır
-özel bir metot (sonlandırıcı, işleç...) olmamalıdır.
- genel olmamalıdır
- 'TestContext' türünden bir parametre almalıdır
- dönüş türü 'void', 'Task' veya 'ValueTask' olmalıdır

Bu metotları bildiren türün ayrıca aşağıdaki kurallara uyması gerekir:
-Tür bir class olmalıdır
-class 'public' olmalıdır
-class '[TestClass]' (veya türetilmiş bir öznitelik) ile işaretlenmelidir
-class genel olmamalıdır.</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">Global test düzeni yöntemi ‘{0}’ imzası geçersiz</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 ve GlobalTestCleanup yöntemleri geçerli bir düzene sahip olmalıdır</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">Bir test yöntemine veya test class uygulanan '[Ignore]' özniteliği, testin ya da class neden yoksayıldığını açıklayan boş olmayan bir ileti içermelidir. Bir gerekçe iletisi, atlanan testleri önceliklendirmeyi kolaylaştırır, gözden geçirenlerin amacı anlamasına yardımcı olur ve testlerin sessizce sonsuza kadar devre dışı bırakılmasını önler.</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}' öğesinin neden yoksayıldığını açıklayan bir ileti belirtmelidir</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]' bir gerekçe belirtmelidir</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 ve EndsWith gibi yöntemler, koşulun karşılanıp karşılanmadığını belirten boole değerleri döndürür. Bu dönüş değerlerini yok saymak büyük olasılıkla bir hataya yol açar.</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}' değerinin dönüş değeri yok sayılmamalıdır</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">Dize yöntemlerinin dönüş değerini yok saymayın</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">Her zaman başarısız olan 'Assert.{0}' onaylaması yerine 'Assert.Fail' seçeneğini kullanın</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">Her zaman başarısız olan onaylama yerine 'Assert.Fail' seçeneğini kullanın</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="new">When verifying exceptions from asynchronous code, use the async assertion methods instead of blocking the asynchronous operation with GetAwaiter().GetResult().</target>
        <note>{Locked="GetAwaiter().GetResult()"}{Locked="async"}</note>
      </trans-unit>
      <trans-unit id="PreferAsyncAssertionMessageFormat">
        <source>Use 'Assert.{0}' instead of blocking an async call in 'Assert.{1}'</source>
        <target state="translated">'Assert.{0}' içinde async bir çağrıyı engellemek yerine 'Assert.{1}' kullanın</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="new">Prefer async assertion methods</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]', kaynak anahtarının tam dize eşitliğine göre testleri eşleştirir. Düz bir sabit değerli dize açık hata verir: Bir yazım hatası farklı bir anahtar oluşturur, bu nedenle çakışan testler artık serileştirilmez ve hata vermek yerine sessizce yarışır. Paylaşılan bir sabit değere başvurmak, yazım hatalarını derleme hatasına dönüştürür ve derleyicinin aynı kaynak için yarışan her testin aynı anahtarı kullanmasını zorunlu kılmasını sağlar.</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="translated">'[ResourceLock]' kaynak anahtarı '{0}', düz bir sabit değerli dizedir; yazım hatalarının sessizce farklı ve paylaşılmayan bir anahtar oluşturmasını önlemek için paylaşılan bir sabit değere (örneğin 'WellKnownResources' üyesine ya da kendi 'const' değerinize) başvurun</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]' kaynak anahtarı için adlandırılmış bir sabit değer kullanmayı tercih edin</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' artık kullanılmıyor ve 'TestMethodAttribute' üzerinde ek bir işlevsellik sunmuyor. Parametreli testler de dahil, tüm test yöntemleri için 'TestMethodAttribute' kullanın.</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' artık kullanılmıyor. Bunun yerine 'TestMethod' kullanın.</target>
        <note>{Locked="DataTestMethod"}{Locked="TestMethod"}</note>
      </trans-unit>
      <trans-unit id="PreferTestMethodOverDataTestMethodAnalyzerTitle">
        <source>Prefer 'TestMethod' over 'DataTestMethod'</source>
        <target state="translated">'DataTestMethod' yerine 'TestMethod' yöntemini tercih edin</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">Bir test yönteminde 'DisplayName' değerini yöntem adıyla aynı olacak şekilde ayarlamak gereksizdir çünkü yöntem adı zaten varsayılan olarak görünen ad olarak kullanılır. Gereksiz 'DisplayName', testin nasıl raporlandığını değiştirmeden kaldırılabilir.</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}' test yöntemi adıyla aynıdır ve kaldırılabilir</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">Test yöntemi, adıyla aynı bir görünen ad belirtmemelidir</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">Koşulu her zaman true olarak bilinen onaylamayı gözden geçirin veya kaldırın</target>
        <note>{Locked="true"}</note>
      </trans-unit>
      <trans-unit id="ReviewAlwaysTrueAssertConditionAnalyzerTitle">
        <source>Assertion condition is always true</source>
        <target state="translated">Onaylama koşulu her zaman true'dur</target>
        <note>{Locked="true"}</note>
      </trans-unit>
      <trans-unit id="PreferConstructorOverTestInitializeMessageFormat">
        <source>Prefer constructors over TestInitialize methods</source>
        <target state="translated">Oluşturucuları TestInitialize yöntemlerine tercih et</target>
        <note>{Locked="TestInitialize"}</note>
      </trans-unit>
      <trans-unit id="PreferConstructorOverTestInitializeTitle">
        <source>Prefer constructors over TestInitialize methods</source>
        <target state="translated">Oluşturucuları TestInitialize yöntemlerine tercih et</target>
        <note>{Locked="TestInitialize"}</note>
      </trans-unit>
      <trans-unit id="PreferDisposeOverTestCleanupMessageFormat">
        <source>Prefer 'Dispose' over TestCleanup methods</source>
        <target state="translated">'Dispose' yöntemlerini TestCleanup yöntemlerine tercih et</target>
        <note>{Locked="TestCleanup"}{Locked="Dispose"}</note>
      </trans-unit>
      <trans-unit id="PreferDisposeOverTestCleanupTitle">
        <source>Prefer 'Dispose' over TestCleanup methods</source>
        <target state="translated">'Dispose' yöntemlerini TestCleanup yöntemlerine tercih et</target>
        <note>{Locked="TestCleanup"}{Locked="Dispose"}</note>
      </trans-unit>
      <trans-unit id="PreferTestCleanupOverDisposeMessageFormat">
        <source>Prefer TestCleanup over 'Dispose' methods</source>
        <target state="translated">TestCleanup yöntemlerini 'Dispose' yöntemlerine tercih et</target>
        <note>{Locked="TestCleanup"}{Locked="Dispose"}</note>
      </trans-unit>
      <trans-unit id="PreferTestCleanupOverDisposeTitle">
        <source>Prefer TestCleanup over 'Dispose' methods</source>
        <target state="translated">TestCleanup yöntemlerini 'Dispose' yöntemlerine tercih et</target>
        <note>{Locked="TestCleanup"}{Locked="Dispose"}</note>
      </trans-unit>
      <trans-unit id="PreferTestInitializeOverConstructorMessageFormat">
        <source>Prefer TestInitialize methods over constructors</source>
        <target state="translated">TestInitialize yöntemlerini oluşturuculara tercih et</target>
        <note>{Locked="TestInitialize"}</note>
      </trans-unit>
      <trans-unit id="PreferTestInitializeOverConstructorTitle">
        <source>Prefer TestInitialize methods over constructors</source>
        <target state="translated">TestInitialize yöntemlerini oluşturuculara tercih et</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">Genel metotlar test metotları olmalıdır ('[TestMethod]' ile işaretlendi).</target>
        <note>{Locked="[TestMethod]"}</note>
      </trans-unit>
      <trans-unit id="PublicMethodShouldBeTestMethodAnalyzerFormat">
        <source>Public method '{0}' should be a test method</source>
        <target state="translated">Genel metot '{0}' bir test metodu olmalıdır</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">Genel metotlar test metotları olmalıdır</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">Test projesinde yalnızca public olarak işaretlenmiş test sınıflarının olması iyi bir uygulama olarak kabul edilir.</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}'' genel türü [TestClass]' ile işaretlenmeli ' veya 'internal' olarak değiştirilmelidir</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">Genel türler test sınıfları olmalıdır</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">Sabit kodlanmış mutlak bir yol ya da göreli yol değişmez değeri, doğrudan Dosya sistemini değiştiren bir 'File.*'/'Directory.*' yöntemine (örneğin 'File.WriteAllText' veya 'Directory.CreateDirectory') geçirilirse, bütünleştirilmiş kod içindeki diğer her testle paylaşılan bir konumu hedefler; göreli yollar ayrıca işlem-genel geçerli Dizine göre çözümlenir. Bütünleştirilmiş kod içi paralelleştirme altında iki test aynı konuma eşzamanlı olarak yazabilir. Yalnızca değiştiren bir API'ye geçirilen statik sabit yollar bayrak eklenmiş olarak işaretlenir; okumalar, yol oluşturma ve değişkenlerden oluşturulan yollar paralel güvenlik denetimi becerisine bırakılır. 'TestContext.TestTempDirectory' gibi her test için benzersiz bir dizini tercih edin.</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}' sabit bir konumdur ve derlemedeki her test tarafından paylaşılır (ve göreli olduğunda işlem-genel geçerli dizine göre çözümlenir); bu nedenle ona yazan paralel testler çakışabilir; bunun yerine 'TestContext.TestTempDirectory' gibi test başına benzersiz bir konum kullanın</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">Sabit kodlanmış veya paylaşılan dosya sistemi yollarını paralelleştirilmiş bir testte kullanmaktan kaçının</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}’ yerine ‘Assert.{0}’ kullanın</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’ yerine ‘Assert’ kullanın</target>
        <note>{Locked="StringAssert"}{Locked="Assert"}</note>
      </trans-unit>
      <trans-unit id="TestClassShouldBeValidMessageFormat">
        <source>Test class '{0}' should be valid</source>
        <target state="translated">'{0}' test class geçerli olmalıdır</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' özelliği geçerli olmalıdır</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))]‘ ifadesi, filtre türünü bir 'Type’ olarak geçirir; bu nedenle derleyici herhangi bir türü kabul eder. Bağdaştırıcı, yalnızca filtreyi somutlaştırdığında bunu doğrular ve ardından tüm çalıştırmayı başarısız kılar. Referans verilen tür, jenerik olmamalı ve somutlaştırılabilir olmalı, ‘ITestFilter’ arayüzünü uygulamalı ve parametresiz bir genel oluşturucu sunmalıdır; ayrıca her test derlemesi başına en fazla bir sağlayıcı kaydedilebilir. .NET'i hedef alırken, genel ‘[assembly: TestFilterProvider&lt;MyFilter&gt;]’ biçimi, arayüz ve oluşturucu gereksinimlerini genel kısıtlamalar yoluyla zorunlu kılar.</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}' jenerik türüne başvuruyor; test filtresi türü jenerik olmamalıdır</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">Derleme, birden fazla ‘[TestFilterProvider]’ kaydı içeriyor; test derlemesi başına en fazla bir tane izin verildiğinden, filtreleme stratejilerini tek bir ‘ITestFilter’ uygulaması içinde birleştirin</target>
        <note>{Locked="[TestFilterProvider]"}{Locked="ITestFilter"}</note>
      </trans-unit>
      <trans-unit id="TestFilterProviderShouldBeValidMessageFormat_NoParameterlessConstructor">
        <source>'[TestFilterProvider]' references type '{0}', which does not declare a public parameterless constructor</source>
        <target state="translated">'[TestFilterProvider]', '{0}' türüne başvurmaktadır; ancak bu türde parametresiz bir genel oluşturucu tanımlanmamıştır</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’ arayüzünü uygulamayan ‘{0}’ türüne başvuruyor</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}' türüne başvuruyor; ancak bu türün bir örneği oluşturulamaz</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]' öğesine null bir filtre türü atanmış; çalıştırmak için 'ITestFilter’ uygulamasını geçirin, örneğin '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]' geçerli bir test filtresi türüne atıfta bulunmalıdır</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 türetilmiş class '{0}', yapıcıya CallerFilePath ve CallerLineNumber parametrelerini eklemelidir</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 türetilmiş class kaynak bilgilerini yaymalıdır</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'a bir dize bağımsız değişkeni aktarmak yerine 'DisplayName' özelliğini kullanın</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'i doğru şekilde ayarlamalıdır</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}' test yöntemi imzası geçersiz</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">Testten işlem-genel durumu değiştirmek (ortam değişkenleri veya konsol yeniden yönlendirmesi gibi), derleme içi paralelleştirme etkinleştirildiğinde güvenli değildir; çünkü eşzamanlı çalışan kardeş bir test bu değişikliği gözlemler. Anahtar unutulduğunda sessizce başarısız olan '[ResourceLock]''un aksine bu kural, değişikliği derleme zamanında işaretler. Çakışan testleri sıralamak için eşleşen 'WellKnownResources' anahtarıyla '[ResourceLock]' bildirin ya da testi paralelleştirmeden çıkarmak için '[DoNotParallelize]' kullanın.</target>
        <note>{Locked="[ResourceLock]"}{Locked="WellKnownResources"}{Locked="[DoNotParallelize]"}</note>
      </trans-unit>
      <trans-unit id="UndeclaredProcessGlobalStateMutationMessageFormat">
        <source>'{0}' mutates process-global state and is unsafe when tests run in parallel; declare '[ResourceLock(WellKnownResources.{1})]' on the test (or '[DoNotParallelize]')</source>
        <target state="translated">‘{0}' işlem-genel durumu değiştirir ve testler paralel çalıştığında güvenli değildir; çakışan testte '[ResourceLock(WellKnownResources.{1})]' bildirin (veya '[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">İşlem-genel durumu değiştiren test, bir kaynak kilidi bildirmelidir</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' değerini karşılaştıran ve ardından erken dönüş yapan ya da 'Assert.Inconclusive' işlevini çağıran test yöntemleri, bunun yerine '[ArchitectureCondition]' özniteliğini kullanmalıdır. Bu özellik, mimariye özgü test gereksinimlerini belirtmek için daha açıklayıcı ve kolayca tespit edilebilir bir yol sunar; ayrıca, erken dönüşün aksine, testi “geçti” yerine “atlandı” olarak raporlar.</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">Erken dönüşlü ‘RuntimeInformation.ProcessArchitecture’ denetimleri veya ‘Assert.Inconclusive’ yerine ‘[ArchitectureCondition]’ özniteliğini kullanın</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">Erken dönüşlü ‘RuntimeInformation.ProcessArchitecture’ denetimleri veya ‘Assert.Inconclusive’ yerine ‘[ArchitectureCondition]’ özniteliğini kullanın</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' ortam değişkenini boş olup olmadığını kontrol eden ve ardından erken dönüş yapan ya da ‘Assert.Inconclusive’ işlevini çağıran test yöntemleri, bunun yerine ‘[CICondition]’ özniteliğini kullanmalıdır. Bu özellik, MSTest’in tanıdığı tüm sürekli entegrasyon sağlayıcılarını tanır ve bunların değerlerini çözümler; ayrıca, erken dönüşün aksine, testi “geçti” yerine “atlandı” olarak raporlar.</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">Erken dönüş içeren ‘Environment.GetEnvironmentVariable’ denetimleri veya ‘Assert.Inconclusive’ yerine ‘[CICondition]’ özniteliğini kullanın</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">Erken dönüş içeren ‘Environment.GetEnvironmentVariable’ denetimleri veya ‘Assert.Inconclusive’ yerine ‘[CICondition]’ özniteliğini kullanın</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'a kıyasla iptal belirtecine erişmek için daha doğrudan bir yol sağlar.</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' yerine ‘TestContext.CancellationToken’ kullanın</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 yerine TestContext.CancellationToken kullanın</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]' özniteliğiyle işaretlenen sınıflar olan test sınıfları, MSTest:
 tarafından geçerli kabul edilmeleri için aşağıdaki düzene uygum olmalıdır
- 'public' (veya '[assembly: DiscoverInternals]' özniteliği ayarlanmışsa 'internal') olmalıdır
- 'static' olmamalıdır (yalnızca 'AssemblyInitialize' ve/veya 'AssemblyCleanup' yöntemlerini içermesi hariç)
- genel olmalıdır.</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">Test sınıfları geçerli bir düzene sahip olmalıdır</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">Test class en az bir test yöntemine sahip olmalıdır veya '[AssemblyInitialize]' ve/veya '[AssemblyCleanup]' ile işaretlenen yöntemlere sahip 'static' olmalıdır.</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">'{0}' test class en az bir test yöntemine sahip olmalıdır veya '[AssemblyInitialize]' ve/veya '[AssemblyCleanup]' ile işaretlenen yöntemlere sahip 'static' olmalıdır</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">Test class test yöntemine sahip olmalıdır</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]' ile işaretlenen yöntemlerin geçerli olması için aşağıdaki düzeni takip etmesi gerekir:
-'public' olmalıdır 
- 'abstract' olmamalıdır
-'async void' olmamalıdır
-'static' olmamalıdır
-özel bir yöntem (sonlandırıcı, işleç...) olmamalıdır.
- genel olmamalıdır
- herhangi bir parametre almamalıdır
- dönüş türü 'void', 'Task' veya 'ValueTask' olmalı

Bu yöntemleri bildiren tipin ayrıca aşağıdaki kurallara uyması gerekir:
-Tür bir class olmalıdır
--class 'public' veya 'internal' olmalıdır (test projesi '[DiscoverInternals]' niteliğini kullanıyorsa)
-class 'static' olmamalıdır
-class 'sealed' ise '[TestClass]' (veya türetilmiş bir öznitelik) ile işaretlenmelidir.</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 yöntemi '{0}' imzası geçersiz</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 yöntemi geçerli bir düzene sahip olmalıdır</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' oluşturucuda atanan static olmayan bir özellik olmalıdır veya MSTest tarafından ayarlanmalıdır. MSTest tarafından ayarlanacaksa şu düzeni izlemelidir:
- '[assembly: DiscoverInternals]' özniteliğinin ayarlanıp ayarlanmadığına bakılmaksızın 'public' olmalıdır.
- 'static' olmamalıdır
- bir ayarlayıcı içermelidir.</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">Test bağlamı özelliğinin geçerli düzeni olmalıdır</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]' ile işaretlenen yöntemlerin geçerli olması için aşağıdaki düzeni izlemesi gerekir:
-'public' olmalıdır 
- 'abstract' olmamalıdır
-'async void' olmamalıdır
-'static' olmamalıdır
-özel bir yöntem (sonlandırıcı, işleç...) olmamalıdır.
- genel olmamalıdır
- herhangi bir parametre almamalıdır
- dönüş türü 'void', 'Task' veya 'ValueTask' olmalı

Bu yöntemleri bildiren tipin ayrıca aşağıdaki kurallara uyması gerekir:
-Tür bir class olmalıdır
--class 'public' veya 'internal' olmalıdır (test projesi '[DiscoverInternals]' niteliğini kullanıyorsa)
-class 'static' olmamalıdır
-class 'sealed' ise '[TestClass]' (veya türetilmiş bir öznitelik) ile işaretlenmelidir.</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 yöntemi '{0}' imzası geçersiz</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 yöntemi geçerli bir düzene sahip olmalıdır</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]' özniteliğiyle işaretlenen test yöntemleri, MSTest:
 tarafından geçerli kabul edilebilmesi için aşağıdaki düzene uygun olacak şekilde düzenlenmelidir
- 'public' (veya '[assembly: DiscoverInternals]' özniteliği ayarlanmışsa 'internal') olmalıdır
- 'static' olmamalıdır
- Tür parametreleri çıkarsandıkça ve bağımsız değişken türleri uyumlu olduğu sürece genel olmalıdır
- 'abstract' olmamalıdır
- dönüş türü 'void', 'Task' veya 'ValueTask' olmalıdır
- 'async void' olmamalıdır
- özel bir yöntem (sonlandırıcı, işleç...) olmamalıdır.</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">Test yöntemleri geçerli bir düzene sahip olmalıdır</target>
        <note />
      </trans-unit>
      <trans-unit id="TestMethodShouldNotBeIgnoredAnalyzerDescription">
        <source>Test methods should not be ignored (marked with '[Ignore]').</source>
        <target state="translated">Test metotları yoksaymamalıdır ('[Ignore]' olarak işaretli).</target>
        <note>{Locked="[Ignore]"}</note>
      </trans-unit>
      <trans-unit id="TestMethodShouldNotBeIgnoredAnalyzerFormat">
        <source>Test method '{0}' should not be ignored</source>
        <target state="translated">Test metodu '{0}' yoksayılmamalıdır</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">Test metodu yoksayılmamalıdır</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]' içeren tür '[TestClass]' ile işaretlenmeli, aksi takdirde test yöntemi sessizce yoksayılır.</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}' türü test yöntemleri içeriyor ve '[TestClass]' ile işaretlenmeli</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]' içeren tür '[TestClass]' ile işaretlenmelidir</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 test düzeni metotları için 'Async' soneki gerekmez</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">Asenkron test metotları için 'Async' soneki gerekmez</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 ve ClassInitialize yöntemleri için MSTest tarafından TestContext parametresi gereklidir.</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}] yalnızca [TestMethod] ile işaretli yöntemlerde ayarlanabilir</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}] yalnızca [TestMethod] ile işaretli yöntemlerde ayarlanabilir</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' öğesinden türetilen '{0}' özniteliği yalnızca 'TestClassAttribute' ile işaretlenmiş sınıflarda kullanılmalıdır</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">Test sınıflarda 'ConditionBaseAttribute' kullanın</target>
        <note>{Locked="ConditionBaseAttribute"}</note>
      </trans-unit>
      <trans-unit id="UseCooperativeCancellationForTimeoutDescription">
        <source>Using '[Timeout]' without explicitly setting 'CooperativeCancellation = true' is discouraged. In a future version, cooperative cancellation will become the default behavior. Set 'CooperativeCancellation = true' to opt into the recommended behavior and avoid breaking changes.</source>
        <target state="translated">'[Timeout]' ayarını 'CooperativeCancellation = true' olarak açıkça ayarlamadan kullanmak önerilmez. Gelecek bir sürümde, birlikte iptal etme varsayılan davranış haline gelecektir. Önerilen davranışı kabul etmek ve uyumsuzlukları önlemek için 'CooperativeCancellation = true' değerini ayarlayın.</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]' ile 'CooperativeCancellation = true' kullanarak birlikte iptal etme davranışını etkinleştirin</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]' ile 'CooperativeCancellation = true' kullanın</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]' yalnızca test class veya test yönteminde belirtilebilir</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]' yalnızca test class veya test yönteminde belirtilebilir</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">Varsayılan olarak, MSTest hizmeti testleri aynı derleme içinde sırayla çalıştırır ve bu durum ciddi performans sınırlamalarına yol açabilir. Testleri paralel yürütmek için '[Parallelize]' derleme özniteliğini etkinleştirmeniz önerilir veya derlemenin paralelleştirilebilir olduğu biliniyorsa, doğrudan '[DoNotParallelize]' derleme düzeyi özniteliğini kullanmanız önerilir.</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">Doğrudan test paralelleştirmeyi etkinleştirin veya devre dışı bırakın</target>
        <note />
      </trans-unit>
      <trans-unit id="UseParallelizeAttributeAnalyzerTitle">
        <source>Explicitly enable or disable tests parallelization</source>
        <target state="translated">Doğrudan test paralelleştirmeyi etkinleştirin veya devre dışı bırakın</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}' yerine 'Assert.{0}' kullan</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">Uygun 'Assert' yöntemlerini kullan</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' özniteliğinden türetilen bir öznitelik yalnızca bir test yönteminde veya test class belirtilebilir</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">Test yönteminde veya test class yeniden deneme özniteliğini kullan</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 özelliğine bu bağlamda erişilemiyor</target>
        <note>{Locked="TestContext"}</note>
      </trans-unit>
      <trans-unit id="TestContextPropertyUsageMessageFormat">
        <source>TestContext property '{0}' cannot be accessed in '{1}' method</source>
        <target state="translated">TestContext '{0}' özelliğine '{1}' yönteminde erişilemiyor</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">Bazı TestContext özellikleri yalnızca test yürütmesi sırasında kullanılabilir ve derleme başlatma, class başlatma, class temizleme veya derleme temizleme yöntemlerinde erişilemez.</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 yöntemleri yalnızca tek bir deyim veya ifade içermelidir. Birden fazla deyim yanıltıcı olabilir; eğer ilk deyim bir sonuç oluşturursa, sonraki deyimler asla çalıştırılmaz; eğer sonuç oluşturmazsa, bu deyim Assert.Throws dışına alınmalıdır.</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 yalnızca tek bir deyim/ifade içermelidir.</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 yalnızca tek bir deyim/ifade içermelidir.</target>
        <note>{Locked="Assert.Throws"}</note>
      </trans-unit>
      <trans-unit id="AvoidAssertsInCatchBlocksTitle">
        <source>Do not use asserts in catch blocks</source>
        <target state="new">Do not use asserts in catch blocks</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="new">Do not use asserts in catch blocks because they may not fail the test if no exception is thrown</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="new">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'.</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">Bir derlemede '[Parallelize]' veya '[DoNotParallelize]' özniteliği bulunmalı ancak ikisi birden bulunmamalıdır. Her iki özniteliğin de bulunması belirsiz bir yapılandırma oluşturur. Her ikisi de varsa, '[DoNotParallelize]' özniteliği öncelikli olarak uygulanır ve paralelleştirme devre dışı bırakılır.</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">Derlemede hem '[Parallelize]' hem de '[DoNotParallelize]' özniteliklerinin olması belirsizlik yaratıyor</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">Hem '[Parallelize]' hem de '[DoNotParallelize]' özniteliklerini birlikte kullanmayın</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">Erken dönüş veya 'Assert.Inconclusive' ile 'RuntimeInformation.IsOSPlatform' çağrılarını kullanmak yerine '[OSCondition]' özniteliğini kullanın</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">Erken dönüş veya 'Assert.Inconclusive' ile 'RuntimeInformation.IsOSPlatform' çağrılarını kullanmak yerine '[OSCondition]' özniteliğini kullanın</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">Erken dönüş veya 'Assert.Inconclusive' ile 'RuntimeInformation.IsOSPlatform' kullanan test yöntemleri, bunun yerine '[OSCondition]' özniteliğini kullanmalıdır. Bu öznitelik, işletim sistemine özgü test gereksinimlerini belirtmenin daha bildirime dayalı ve keşfedilebilir bir yolunu sağlar.</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">Yinelenen test yöntemi özniteliklerini önleyin</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">Test yöntemi '{0}' 'TestMethodAttribute'den devralan birden fazla özniteliğe sahiptir. Yalnızca bir test yöntemi özelliği kullanılmalıdır.</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">Bir test yöntemi, ‘TestMethodAttribute’ olan veya bundan devralan tam olarak bir öznitelikle işaretlenmelidir. Bu türden birden fazla öznitelik mevcut olduğunda, yansıma tarafından döndürülen ilk öznitelik kullanılır.</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">Test yöntemlerinde 'out' veya 'ref' parametrelerini kullanmaktan kaçının</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}' test yönteminde, gelecekteki bir ana sürümde desteği kaldırılacak olan 'out' veya 'ref' parametreleri var</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' ve 'ref' parametreleri test yöntemlerine değer katmıyor ve güvenli bir şekilde normal parametrelerle değiştirilebilir.</target>
        <note>{Locked="out"}{Locked="ref"}</note>
      </trans-unit>
      <trans-unit id="TestClassConstructorShouldBeValidTitle">
        <source>Test classes should have valid constructors</source>
        <target state="translated">Test sınıfları geçerli oluşturuculara sahip olmalıdır</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">‘{0}’ test class geçerli bir oluşturucusu yok Geçerli oluşturucular 'public' ve parametresiz veya 'TestContext' türünde tek bir parametre içeriyor.</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">Test class, parametresiz olan veya tek bir TestContext parametresini kabul eden bir public oluşturucuya sahip olmalıdır. Bu, test çerçevesinin test class örneğini doğru şekilde oluşturmasına olanak tanır.</target>
        <note>{Locked="TestContext"}{Locked="public"}{Locked="class"}</note>
      </trans-unit>
    </body>
  </file>
</xliff>