<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Ayse Beyza GUR on Medium]]></title>
        <description><![CDATA[Stories by Ayse Beyza GUR on Medium]]></description>
        <link>https://medium.com/@beyyzgur?source=rss-19a7667f033b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*dZL4tjdfEHdqjY9AvzC-RA@2x.jpeg</url>
            <title>Stories by Ayse Beyza GUR on Medium</title>
            <link>https://medium.com/@beyyzgur?source=rss-19a7667f033b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 03:02:59 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@beyyzgur/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[15 dk’da Unit Test-Swift Testing]]></title>
            <link>https://medium.com/@beyyzgur/15-dkda-unit-test-swift-testing-b1568e840239?source=rss-19a7667f033b------2</link>
            <guid isPermaLink="false">https://medium.com/p/b1568e840239</guid>
            <category><![CDATA[swiftui]]></category>
            <category><![CDATA[unit-testing]]></category>
            <category><![CDATA[swift-testing]]></category>
            <category><![CDATA[ios]]></category>
            <dc:creator><![CDATA[Ayse Beyza GUR]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 16:25:55 GMT</pubDate>
            <atom:updated>2026-11-18T16:16:21.751Z</atom:updated>
            <content:encoded><![CDATA[<h3>15 dk’da Unit Test: Swift Testing</h3><p>Herkese selam! Bir süredir kendi müzik uygulamam üzerinde çalışıyor ve bu uygulamaya unit test yazıyordum. Bu yazıda öğrendiklerimi, hem kendime not bırakmak hem de yeni başlayanlara kendi bakış açımla yardımcı olmak için bir araya getirdim. Örneklerin hepsi kendi projemden, keyifli okumalar dilerim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CVg1a8Xdtrnn0wvgJT48BA.png" /></figure><h3>Unit Test Nedir, Neden Yazarız?</h3><p>Unit test, projemizin küçük bir parçasının (bir manager veya viewmodel gibi logic içeren bir class veya struct’ın) beklediğimiz gibi çalıştığını otomatik olarak kontrol eden koddur.</p><p>Neden yazarız?</p><ul><li>Değişiklik yaparken korkmamak için: Kodu düzenlediğimizde bir şeyi bozup bozmadığımızı saniyeler içinde görebilmeliyiz.</li><li>Hataları erken yakalamak için: Kodlarken bir hata yaptığımızda veya yanlışlıkla değişmemesi gereken bir kodu değiştirdiğimizde bunu erken fark edebilmeliyiz.</li><li>Kodun ne yaptığını anlatmak için: İyi isimlendirilmiş test fonksiyonları sınıfın ne yaptığını herhangi bir yorum satırından daha net anlatmalı.</li><li>Tasarım geri bildirimi için: Test yazmakta zorlanıyorsak veya yazdığımız bazı şeyler mantıksız geliyorsa kodun tasarımını gözden geçirmeliyiz. (Bunu aşağıda kendi projemde yaşadım, anlatacağım.)</li></ul><h4>İyi Bir Unit Testin Özellikleri</h4><p>İyi bir testin sahip olması gereken genel özellikler aşağıdaki gibi sıralanabilir (bunu FIRST kelimesi ile aklımızda tutabiliriz):</p><ol><li>Fast (Hızlı): Testler hızlı çalışmalı. Gerçek bir ağ isteği saniyeler sürebilirken test fonksiyonu ise milisaniyeler içinde bitmeli.</li><li>Independent (Bağımsız): Her test tek başına çalışabilmeli ve başka bir testin bıraktığı duruma bağlı olmamalı.</li><li>Repeatable (Tekrarlanabilir): Bir testi 1000 kere çalıştırdığımızda 1000 kere aynı sonucu almalıyız.</li><li>Self-validating (Kendi kendini doğrulayan): Testin sonucu ya geçti ya kaldı olmalı. Sonucu anlamak için konsola bakıp yorum yapmamız gerekmemeli.</li><li>Timely (Zamanında): Test, kod yazılırken ya da hemen sonrasında yazılmalı, aylar sonra değil.</li></ol><p>Bu maddelerin çoğu, bizlere testlerin dış bağımlılıklardan uzak durması gerektiğini belirtir. Sunucular, veritabanları, dosya sistemi ve sistem servisleri her zaman aynı sonucu döndürmeyebilir. İnternet yavaşlayabilir, sunucu çökebilir, veri değişebilir. Bizim amacımız dış servisleri değil, kendi kodumuzu test etmek olmalı. Bu yüzden testte gerçek servis yerine onun sahtesini kullanmalıyız.</p><h4>Test Edeceğimiz Kod</h4><p>Yazı boyunca uygulamamdaki CatalogDownloadManager sınıfını test edeceğiz. Bu sınıf, kullanıcı katalogdan bir şarkıya dokunduğunda şarkıyı YouTube&#39;da arar, indirir ve cihaza kaydeder:</p><pre>func download(_ track: DetailTrack,<br>              fallbackArtworkURL: URL?,<br>              context: ModelContext) async throws -&gt; MusicItem? {<br>    guard !downloadingTrackIDs.contains(track.id) else { return nil }<br>    downloadingTrackIDs.insert(track.id)<br>    defer { downloadingTrackIDs.remove(track.id) }<br><br>    let result = try await youtubeApiManager.searchAndDownload(query: &quot;\(track.title) \(track.artistName)&quot;)<br>    let song: MusicItem<br><br>    if let existing = songLibraryService.existingSong(videoId: result.video.videoId, context: context) {<br>        song = existing<br>    } else {<br>        song = try await songLibraryService.saveDownloadedSong(from: result.video,<br>                                                               mp3Data: result.download,<br>                                                               context: context)<br>        song.title = track.title<br>        song.artistName = track.artistName<br>        if let artwork = track.largeArtworkURL ?? fallbackArtworkURL {<br>            song.coverURLString = artwork.absoluteString<br>        }<br>    }<br>    song.catalogID = track.id<br>    return song<br>}</pre><p>Bu fonksiyonun içinde test edilmesi gereken birçok davranış var. Şarkı zaten iniyorsa ikinci isteği yok sayar (ve defer hiç çalışmaz). İndirme ister başarılı olsun ister hata versin, bittiğinde şarkıyı “iniyor” listesinden çıkarır. Arama sorgusunu şarkı adı ve sanatçı adından oluşturur. Şarkı daha önce indirildiyse onu tekrar kullanır. Kapak görseli için önce şarkının kendi görseline, o yoksa yedek görsele bakar. Bu davranışların her biri için ayrı bir test yazmalıyız.</p><h4>Modüller ve @testable import</h4><p>Swift’te her target ayrı bir modüldür. Uygulamamız bir modül, test target’ımız başka bir modüldür. Modül sınırları da erişim seviyelerini etkiler. Kısaca hatırlayalım:</p><pre>Erişim Seviyesi     Kim görebilir?<br>---------------     --------------<br>private             Sadece tanımlandığı scope (ve aynı dosyadaki extension&#39;ları)<br>fileprivate         Sadece aynı dosya<br>internal (default)  Aynı modüldeki herkes<br>public              Başka modüller de kullanabilir<br>open                Başka modüller ayrıca subclass/override edebilir</pre><p>Uygulamamızdaki tiplerin çoğu internal olduğu için test modülü normalde onları göremez. Bu noktada @testable import kullanabiliriz:</p><pre>@testable import MusicApp</pre><p>Bu satır derleyiciye bir test modülü olduğunu, MusicApp’in internal olan her şeyine erişebileceğini gösterir.<em> </em>Böylece testlerimiz uygulamadaki internal tipleri hem okuyabilir hem de setter&#39;ı internal olan değerleri değiştirebilir.</p><blockquote>❕ @testable bile private olanı açamaz. Bu yüzden bir değerin dışarıdan değiştirilmesini istemiyorsak private(set) kullanırız.</blockquote><h3>SUT ve Bağımlılıkları Soyutlamak</h3><p>SUT (System Under Test), testte test ettiğimiz sınıfa denir. Bizim örneğimizde SUT, CatalogDownloadManager.</p><p>Bir unit testte gerçek olan tek şey SUT olmalı. Etrafındaki her şey ya sahte ya da tamamen bizim kontrolümüzde olmalı. Her test suite’inin de tek bir SUT’u olması gerekir.</p><p>Gerçek YouTube servisinin yerine sahtesini koyabilmek için SOLID’in D’si olan Dependency Inversion Principle’dan yararlanabiliriz. Bu prensibe göre üst seviye modüller, alt seviye modüllere değil soyutlamalara (protokollere) bağımlı olmalı. Böylece alt seviyedeki detaylar değiştirilebilir. Testte gerçek detayın yerine sahtesini kullanabilmemiz de bu prensibin en büyük faydalarından biri.</p><pre>final class CatalogDownloadManager {<br>    private let youtubeApiManager: YouTubeAPIManagerProtocol<br>    private let songLibraryService: SongLibraryServiceProtocol<br><br>    init(youtubeApiManager: YouTubeAPIManagerProtocol = YouTubeAPIManager(),<br>         songLibraryService: SongLibraryServiceProtocol = SongLibraryService()) {<br>        self.youtubeApiManager = youtubeApiManager<br>        self.songLibraryService = songLibraryService<br>    }<br>}</pre><p>Bağımlılıkları init üzerinden almaya dependency injection denir. Varsayılan değerler sayesinde uygulama tarafında hiçbir şey değişmez, test tarafında ise istediğimiz mock’u verebiliriz.</p><h3>Test Double’lar: Stub ve Spy</h3><p>Testte gerçek nesnenin yerine geçen sahte nesnelere genel olarak test double denir. Günlük kullanımda hepsine mock dense de aslında farklı görevleri vardır. Bizim için en önemli ikisi stub ve spy:</p><ul><li>Stub: Testin önceden belirlediği cevabı döner.</li><li>Spy: Kendisine ne yapıldığını kaydeder.</li></ul><p>İlk yazdığım mock şöyleydi:</p><pre>@MainActor<br>private final class MockYouTubeAPIManager: YouTubeAPIManagerProtocol {<br>    var result: Result&lt;YouTubeSearchDownloadData, Error&gt; = .failure(URLError(.unknown))  // ① STUB<br>    private(set) var queries: [String] = []                                              // ② SPY<br><br>    func searchAndDownload(query: String) async throws -&gt; YouTubeSearchDownloadData {<br>        queries.append(query)          // ② kaydet<br>        return try result.get()        // ① ezberlenmiş cevabı ver<br>    }<br><br>    func search(query: String) async throws -&gt; YouTubeSearchData {<br>        fatalError(&quot;Not used by CatalogDownloadManager&quot;)    // ③<br>    }<br><br>    func fetchMP3(url: String) async throws -&gt; YouTubeMP3Data {<br>        fatalError(&quot;Not used by CatalogDownloadManager&quot;)    // ③<br>    }<br>}</pre><p>Adı Mock olsa da bu sınıf aslında Stub + Spy.</p><p><strong>① Stub kısmı: result</strong><br>Test, SUT’u çağırmadan önce mock’un ne döneceğini ayarlar:</p><pre>youtubeApiManager.result = .success(.stub())                        // &quot;başarılı ol&quot;<br>youtubeApiManager.result = .failure(URLError(.badServerResponse))   // &quot;hata ver&quot;</pre><p>Result tipi iki durumdan birini tutar: .success(değer) ya da .failure(hata). try result.get() ise başarılıysa değeri döner, başarısızsa hatayı fırlatır. Böylece tek bir property ile hem başarı hem de hata senaryosunu kontrol edebiliriz. Gerçek YouTube’u hata vermeye zorlamak neredeyse imkânsızken mock’a tek satırla hata verdirebiliriz.</p><p>Varsayılan değerin .failure(...) olmasının da bir sebebi var. Test result&#39;ı ayarlamayı unutursa hata alır ve sessizce yanlış bir sonuçla geçmez.</p><p><strong>② Spy kısmı: queries</strong><br>queries, SUT&#39;un mock&#39;u hangi sorguyla çağırdığını kaydeder. Böylece arama sorgusunun şarkı adı ve sanatçı adından oluşup oluşmadığını test edebiliriz.</p><p>private(set) sayesinde test bu kaydı okuyabilir ama değiştiremez. Kayıtları sadece SUT’un davranışı oluşturabilir, test yanlışlıkla queries&#39;e bir şey yazıp kendi kendini kandıramaz.</p><h4>Stub ve Spy farkı</h4><pre>             Stub (result, existingSong)    Spy (queries, saveCallCount)<br>             ---------------------------    ----------------------------<br>Kim yazar?   Test                           SUT&#39;un davranışı<br>Kim okur?    Mock                           Test<br>Tanım        var                            private(set) var</pre><blockquote>⚠ private(set) zorunlu değil. Düz var ile de kod derlenir ve testler çalışır. Ama hatayı baştan imkânsız hale getirdiği için kullanmak iyi bir alışkanlıktır.</blockquote><p><strong>③ </strong><strong>fatalError satırları neden var?</strong><br>Protokol bir sözleşmedir. YouTubeAPIManagerProtocol 3 fonksiyon istiyor ve mock&#39;un derlenebilmesi için üçünü de yazması gerekiyor. Ama CatalogDownloadManager sadece searchAndDownload&#39;u kullanıyor.</p><p>Kullanılmayan fonksiyonların içine fatalError yazdım, çünkü test sırasında bu fonksiyonlara hiç girilmemesi gerekiyor. Girilirse test hemen çöksün istedim. Böylece ileride biri SUT&#39;u değiştirip search(...)&#39;i de kullanmaya başlarsa test çöker ve hata mesajı sorunun nerede olduğunu gösterir. Boş bir cevap dönseydi bu hata fark edilmeden kalabilirdi.</p><p>Bu fatalError&#39;lar aslında tasarımdaki bir sorunu da gösteriyordu, ona aşağıda değineceğim.</p><h3>İlk Testimiz: Arrange, Act, Assert</h3><p>Bir test genelde üç bölümden oluşur ve buna AAA denir:</p><ul><li>Arrange (Hazırla): Ortamı kurulur. Mock’ların ne cevap vereceği ayarlanır, girdileri hazırlanır.</li><li>Act (Çalıştır): SUT’un test edilen fonksiyonu çağrılır. Bu kısım genelde tek satırdır.</li><li>Assert (Doğrula): Sonucun beklenen gibi olup olmadığı kontrol edilir.</li></ul><pre>@Test func usesFallbackArtworkWhenTrackHasNone() async throws {<br>    // Arrange<br>    youtubeApiManager.result = .success(.stub())<br>    let fallbackArtwork = try #require(URL(string: &quot;https://example.com/fallback.jpg&quot;))<br>    let track = DetailTrack.stub(largeArtworkURL: nil)<br><br>    // Act<br>    let song = try #require(try await sut.download(track,<br>                                                   fallbackArtworkURL: fallbackArtwork,<br>                                                   context: context))<br><br>    // Assert<br>    #expect(song.coverURLString == fallbackArtwork.absoluteString)<br>}</pre><p>Bölümler arasında boş satır bırakmak, yorum yazmasak bile yapıyı okunur hale getirir.</p><h4>Test isimleri bir cümle olmalı</h4><p>testDownload1 gibi bir isim, test kırıldığında bize hiçbir şey anlatmaz. İsimleri SUT&#39;un ne yaptığını anlatan bir cümle olarak yazmak, hem bize hem de kodu sonradan okuyacak kişiye kolaylık sağlar:</p><pre>downloadingNewSongSavesItWithTrackInfo<br>searchesWithTrackTitleAndArtistName<br>usesTrackArtworkWhenAvailable<br>usesFallbackArtworkWhenTrackHasNone<br>reusesAlreadyDownloadedSong<br>rethrowsDownloadErrorAndClearsDownloadingState</pre><p>Ayrıca Test Navigator’da bu listeye bakan biri, kodu açmadan sınıfın ne yaptığını anlayabilir.</p><h4>Stub Factory</h4><p>Yukarıdaki DetailTrack.stub(largeArtworkURL: nil) satırında bir stub factory kullandım. Test dosyasının sonuna şöyle küçük yardımcılar ekledim:</p><pre>private extension DetailTrack {<br>    static func stub(id: String = &quot;track-id&quot;,<br>                     title: String = &quot;Title&quot;,<br>                     artistName: String = &quot;Artist&quot;,<br>                     largeArtworkURL: URL? = nil) -&gt; DetailTrack {<br>        DetailTrack(id: id,<br>                    title: title,<br>                    artistName: artistName,<br>                    artworkURL: nil,<br>                    largeArtworkURL: largeArtworkURL,<br>                    duration: nil)<br>    }<br>}</pre><p>Her parametrenin bir varsayılan değeri var. Böylece her test sadece kendisi için önemli olan değeri yazar. usesFallbackArtworkWhenTrackHasNone testinde sadece largeArtworkURL: nil yazmamızın sebebi, test edilen şeyin o olması. Okuyan kişi neden-sonuç ilişkisini tek bakışta görebilir. DetailTrack&#39;e ileride yeni bir parametre eklenirse de testleri tek tek düzeltmek yerine sadece bu fonksiyonu güncellemek yeterli olur.</p><h3>#expect ve #require</h3><h4>#expect</h4><p>#expect, içine yazılan koşulun true olup olmadığını kontrol eden bir makrodur. Koşul false ise testi başarısız olarak işaretler ama test çalışmaya devam eder.</p><ul><li>Testte asıl kontrol etmek istediğimiz sonuçlar #expect ile yazılır.</li><li>Başarısız olduğunda sonraki satırlar yine çalışır. Bir testte 4 kontrol varsa ve 2&#39;si yanlışsa, ikisi de aynı anda görülür.</li><li>Başarısız olduğunda Xcode iki tarafın gerçek değerini gösterir, bu da hatayı bulmayı kolaylaştırır.</li></ul><blockquote># ile başlayanlar Swift&#39;te makrodur. Derleme sırasında arka planda daha uzun bir koda dönüşürler. #expect&#39;in hata anında değerleri gösterebilmesinin sebebi de budur.</blockquote><h4>#require</h4><p>#require da #expect gibi bir kontrol yapar, ama koşul sağlanmazsa testi orada durdurur (hata fırlatır). Bu yüzden önüne try yazmak gerekir. Koşul sağlanmadığında testin devam etmesinin bir anlamı olmayan durumlarda #require kullanılmalı. Apple&#39;ın dokümantasyonu da iki makroyu bu farka göre ayırır.</p><p>#require&#39;ın çok işe yarayan bir özelliği de optional bir değeri açıp geri vermesidir. Değer nil ise test orada durur.</p><pre>let song = try #require(try await sut.download(...))   // song: MusicItem ✅<br>let song = #expect(try await sut.download(...))        // ❌ derlenmez</pre><p>İkinci satır derlenmez, çünkü #expect içine sadece Bool alır ve geriye bir şey döndürmez. #require ise MusicItem? alıp MusicItem döndürür. Yani bu satırda #require&#39;ı kontrol için değil, song&#39;u elde etmek için kullanıyoruz. Bir sonraki satırın song.coverURLString&#39;e bakabilmesi için elimizde song olmalı.</p><p>Son satırda da #require kullanmak yanlış olmazdı ama gereksiz olurdu. #require&#39;ın testi durdurması, ancak sonraki satırlar o koşula muhtaçsa işe yarar. Son satırdan sonra korunacak bir şey kalmıyor.</p><p>Kısaca:</p><blockquote>Sonraki satırlar bu koşula muhtaç mı?<br> Evet → #require<br> Hayır → #expect</blockquote><h3>Hata fırlatmayı test etmek: #expect(throws:)</h3><p>SUT’un hatayı yutmayıp dışarı fırlattığını da test etmeliyiz:</p><pre>@Test func rethrowsDownloadErrorAndClearsDownloadingState() async throws {<br>    youtubeApiManager.result = .failure(URLError(.badServerResponse))<br>    let track = DetailTrack.stub()<br><br>    await #expect(throws: URLError.self) {<br>        _ = try await sut.download(track, fallbackArtworkURL: nil, context: context)<br>    }<br><br>    #expect(sut.downloadingTrackIDs.isEmpty)<br>    #expect(songLibraryService.saveCallCount == 0)<br>}</pre><p>Swift’te tek satırlık closure’lar o satırın sonucunu otomatik olarak döndürür. _ = yazılmazsa closure MusicItem? döndürmeye çalışır. MusicItem bir SwiftData modeli olduğu için Sendable değildir ve Swift 6 onu closure&#39;ın dışına güvenle taşıyamayacağı için hata verir. Sonuçla zaten ilgilenmediğimiz için değeri _ = ile atabiliriz.</p><h3>Test Suite’inin Kurulumu</h3><h4>Test Suite</h4><p>Suite, birbiriyle ilgili testleri bir arada tutan gruptur. Swift Testing’de içinde @Test fonksiyonları bulunan bir struct ya da class otomatik olarak bir suite olur. Apple&#39;ın dokümantasyonuna göre @Suite attribute&#39;u zorunlu değildir, suite&#39;in Xcode&#39;da nasıl görüneceğini özelleştirmek için eklenebilir. Xcode&#39;un Test Navigator&#39;ında (⌘6) suite bir klasör gibi görünür ve yanındaki ◇&#39;ye basıldığında içindeki bütün testler birlikte çalışır.</p><pre>import Foundation<br>import SwiftData<br>import Testing<br>@testable import MusicApp<br><br>@MainActor<br>struct CatalogDownloadManagerTests {<br>    private let youtubeApiManager = MockYouTubeAPIManager()<br>    private let songLibraryService = MockSongLibraryService()<br>    private let sut: CatalogDownloadManager<br>    private let container: ModelContainer<br><br>    private var context: ModelContext {<br>        container.mainContext<br>    }<br><br>    init() throws {<br>        sut = CatalogDownloadManager(youtubeApiManager: youtubeApiManager,<br>                                     songLibraryService: songLibraryService)<br>        container = try ModelContainer(for: MusicItem.self,<br>                                       configurations: ModelConfiguration(isStoredInMemoryOnly: true))<br>    }<br>}</pre><p>Burada dikkat edilecek birkaç şey var:</p><ul><li>Property’lerin tipi somut mock’lar: SUT protokole bağımlıdır, ama test elinde somut mock’u tutar. Çünkü testin mock’a stub yazabilmesi (result = ...) ve spy&#39;ı okuyabilmesi (queries) gerekir. Protokol tipinde tutsaydık bu property&#39;lere erişemezdik.</li><li>isStoredInMemoryOnly: true: SUT’un bir SwiftData ModelContext&#39;e ihtiyacı vardır. Diske yazan gerçek bir veritabanı hem yavaş olur hem de testler arasında veri taşıyabilir. Bellekte tutulan bir veritabanı ise test bitince yok olur.</li><li>@MainActor: 👇🏻</li></ul><h4>Suite neden @MainActor?</h4><p>Xcode 26 ile açılan yeni projelerde uygulama target’ının Default Actor Isolation ayarı MainActor olarak gelir. Yani uygulamadaki her tip, biz bir şey yazmasak da @MainActor kabul edilir. CatalogDownloadManager, protokolleri ve onlara uyan mock&#39;larımız da bu yüzden MainActor&#39;a aittir.</p><p>Test target’ında ise bu ayar yoktur ve oradaki kod varsayılan olarak hiçbir actor’a bağlı değildir (nonisolated). Apple&#39;ın dokümantasyonunda da Swift Testing&#39;in test fonksiyonlarını herhangi bir task üzerinde çalıştırdığı, ana thread&#39;de çalışması gereken testlerin @MainActor ile işaretlenmesi gerektiği anlatılır. Suite&#39;in başındaki @MainActor silindiğinde Xcode şu hataları verir:</p><pre>main actor-isolated default value in a nonisolated context<br>main actor-isolated property &#39;mainContext&#39; can not be referenced from a nonisolated context</pre><p>İlk hata mock’un oluşturulduğu satırda, ikincisi SwiftData’nın mainContext&#39;inde çıkar. mainContext, Apple&#39;ın kendi API&#39;sinde zaten @MainActor olarak tanımlıdır. Yani proje ayarımız farklı olsaydı bile bu testin MainActor&#39;da çalışması gerekirdi.</p><p>Başka hangi yollar vardı?</p><ul><li>Her @Test fonksiyonuna ayrı ayrı @MainActor yazılabilirdi. Ama bu hem tekrar demek (DRY&#39;a aykırı) hem de init ve property&#39;lerin varsayılan değerleri yine nonisolated kalacağı için hatalar gitmezdi.</li><li>Test target’ının Default Actor Isolation ayarı da MainActor yapılabilirdi. Bu çalışır, ama bilgi build ayarlarında saklı kalır ve dosyayı okuyan kişi testlerin neden MainActor&#39;da çalıştığını göremez. İleride MainActor&#39;a bağlı olmayan bir kod test edilmek istendiğinde de o testler gereksiz yere MainActor&#39;a bağlanmış olur.</li><li>SUT nonisolated yapılabilirdi. Ama bu, test için production kodunu değiştirmek anlamına gelir ve doğru bir yaklaşım olmaz.</li></ul><p>Ben suite’e tek bir @MainActor yazmayı seçtim. Tek satır, açık ve dosyayı okuyan herkes görebilir.</p><h3>Test İzolasyonu</h3><p>Her test diğer testlerden tamamen bağımsız çalışmalı. Hiçbir test başka bir testin bıraktığı duruma bağlı olmamalı ve başka bir testi etkilememeli.</p><p>Swift Testing bunu her @Test fonksiyonu için suite&#39;in ayrı bir kopyasını oluşturarak sağlar. Apple&#39;ın dokümantasyonunda da bir suite&#39;teki her test fonksiyonunun, tipin farklı bir instance&#39;ı üzerinde çağrıldığı yazar. Yani 8 test varsa init 8 kez çalışır:</p><pre>Test 1 için: yeni struct → yeni mock&#39;lar → yeni SUT → yeni DB → test 1 çalışır → hepsi çöpe<br>Test 2 için: yeni struct → yeni mock&#39;lar → yeni SUT → yeni DB → test 2 çalışır → hepsi çöpe<br>.<br>.<br>.</pre><p>Neden bu kadar önemli?</p><ul><li>Swift Testing testleri varsayılan olarak paralel çalıştırır, yani hangi testin önce biteceği belli değildir. İzolasyon olmasaydı testler birbirinin verisini bozabilirdi.</li><li>Bir test kırıldığında sebep o testin içindedir, başka bir testin bir şeyi bozup bozmadığını araştırmak gerekmez.</li></ul><blockquote>Bazen geçen, bazen kırılan testlere flaky test (güvenilmez test) denir. Paylaşılan durum, flaky testlerin en yaygın sebebidir. Apple da global değişkenler gibi paylaşılan bir durum kullanan testlerin, paralel çalıştığında güvenilmez sonuçlar verebileceği konusunda uyarır.</blockquote><h3>Testler Tasarım Hakkında Konuşur</h3><p>Şimdi o fatalError&#39;lara dönelim.</p><p>Mock’umda 3 fonksiyon vardı ve bunların 2&#39;si fatalError&#39;dı. Yani CatalogDownloadManager, kullanmadığı iki fonksiyona sahip bir protokole bağımlıydı.</p><blockquote>SOLID‘in I’sı Interface Segregation Principle (ISP) der ki: <em>Bir sınıf, kullanmadığı metotlara bağımlı olmaya zorlanmamalı.</em></blockquote><p>Bunu öğrendiğimde ilk düşündüğüm, kodu yazarken bunu önceden nasıl tahmin edebileceğimdi. Bazen her şeyi önceden tahmin edemeyiz, bunu bana test gösterdi. Mock’ta fatalError yazmak zorunda kaldığım her fonksiyon, bağımlılığın gereğinden geniş olduğunun bir işaretiydi. Bence bu, test yazmanın tasarım hakkında geri bildirim vermesinin güzel örneklerinden biri.</p><p>Çözüm için sadece ihtiyaç duyulan fonksiyonu içeren küçük bir protokol çıkardım:</p><pre>protocol YouTubeSearchDownloading {<br>    func searchAndDownload(query: String) async throws -&gt; YouTubeSearchDownloadData<br>}<br><br>protocol YouTubeAPIManagerProtocol: YouTubeSearchDownloading {<br>    func search(query: String) async throws -&gt; YouTubeSearchData<br>    func fetchMP3(url: String) async throws -&gt; YouTubeMP3Data<br>}</pre><p>Burada büyük protokol, küçüğünden miras alır. Bu sayede büyük protokolü kullanan diğer sınıflarda hiçbir şeyi değiştirmek gerekmez. CatalogDownloadManager ise artık sadece ihtiyacı olan protokole bağımlıdır:</p><pre>init(youtubeApiManager: YouTubeSearchDownloading = YouTubeAPIManager(),<br>     songLibraryService: DownloadedSongStoring = SongLibraryService())</pre><p>Aynısını SongLibraryService için de yaptım (DownloadedSongStoring). Mock&#39;lar da sadeleşti, fatalError&#39;ların hepsi gitti:</p><pre>@MainActor<br>private final class MockYouTubeAPIManager: YouTubeSearchDownloading {<br>    var result: Result&lt;YouTubeSearchDownloadData, Error&gt; = .failure(URLError(.unknown))<br>    private(set) var queries: [String] = []<br><br>    func searchAndDownload(query: String) async throws -&gt; YouTubeSearchDownloadData {<br>        queries.append(query)<br>        return try result.get()<br>    }<br>}</pre><h3>Zamanı Kontrol Etmek</h3><p>Buraya kadar hep CatalogDownloadManager&#39;ı test ettik. Bu bölümde ikinci bir sınıfa geçiyorum, çünkü burada karşımıza farklı bir problem çıkıyor.</p><p>Uygulamamda albüm ve şarkı kapaklarını ArtworkView adında ortak bir bileşenle gösteriyorum. Kapaklar internetten AsyncImage ile yükleniyor ve bağlantı zayıfken bazen yüklenemiyor. Kullanıcı boş bir kutu görmesin diye, yükleme başarısız olunca 1 saniye bekleyip en fazla 3 kez tekrar denemek istedim.</p><p>Bu mantık ilk başta doğrudan View’un içindeydi. View’un içindeki kodu unit test ile test etmek zor olduğu için onu ArtworkViewModel adında ayrı bir sınıfa taşıdım. View artık sadece ViewModel&#39;i kullanıyor:</p><pre>AsyncImage(url: url) { phase in<br>    switch phase {<br>    case .success(let image):<br>        image.resizable().scaledToFill()<br>    case .failure:<br>        placeholderColor<br>            .task { await viewModel.retryAfterDelay() }<br>    default:<br>        placeholderColor<br>    }<br>}<br>.id(viewModel.retryCount)</pre><p>Yükleme başarısız olunca retryAfterDelay() çağrılıyor. retryCount her arttığında .id değiştiği için SwiftUI AsyncImage&#39;ı baştan oluşturuyor ve görsel yeniden yükleniyor. ViewModel ise şöyle:</p><pre>@Observable<br>final class ArtworkViewModel {<br>    private(set) var retryCount = 0<br>    private let maxRetryCount: Int<br>    private let retryDelay: Duration<br><br>    init(maxRetryCount: Int = 3, retryDelay: Duration = .seconds(1)) {<br>        self.maxRetryCount = maxRetryCount<br>        self.retryDelay = retryDelay<br>    }<br><br>    func retryAfterDelay() async {<br>        guard retryCount &lt; maxRetryCount else { return }<br>        try? await Task.sleep(for: retryDelay)<br>        guard !Task.isCancelled else { return }<br>        retryCount += 1<br>    }<br>}</pre><p>Bu sınıfın dış bağımlılığı olmadığı için mock’a da ihtiyaç yok. Ama gizli bir bağımlılığı var: <em>zaman</em>. Bekleme süresi kodun içine 1 saniye olarak gömülü olsaydı her test gerçekten 1 saniye beklerdi ve FIRST’teki F’ye uymamış olurduk.</p><p>Bunun çözümü, zamanı da bir bağımlılık gibi init&#39;ten almak olabilir. Uygulama varsayılan değeri kullanır, test ise .zero verir:</p><pre>@Test func stopsRetryingAfterMaxRetryCount() async {<br>    let sut = ArtworkViewModel(maxRetryCount: 2, retryDelay: .zero)<br><br>    for _ in 1...3 {<br>        await sut.retryAfterDelay()<br>    }<br><br>    #expect(sut.retryCount == 2)<br>}</pre><p>Maksimum değer 2 olduğu halde fonksiyonu 3 kez çağırıyoruz. 2 kez çağırsaydık, guard retryCount &lt; maxRetryCount satırı silinse bile test geçerdi. Bu yüzden bir sınırı test ederken o sınırın bir adım ötesine geçilmeli.</p><h3>Async Testler ve False Positive</h3><p>View ekrandan kalktığında SwiftUI .task&#39;ı iptal eder ve bu durumda sayaç artmamalı. Bunu test edebilmek için önce iptalin nasıl çalıştığını anlamak gerekiyor.</p><blockquote>Task.cancel() bir Task&#39;ı zorla durdurmaz. Sadece Task&#39;a iptal edildiğini bildiren bir sinyal gönderir. Task&#39;ın içindeki kod bu sinyale Task.isCancelled ile ya da Task.sleep gibi iptali kontrol eden fonksiyonlar aracılığıyla kendisi tepki verir.</blockquote><pre>@Test func doesNotIncrementRetryCountWhenCancelled() async {<br>    let sut = ArtworkViewModel(retryDelay: .zero)<br><br>    let task = Task { await sut.retryAfterDelay() }<br>    task.cancel()<br>    await task.value<br><br>    #expect(sut.retryCount == 0)<br>}</pre><p>Bu testteki en önemli satır await task.value.</p><p>Task { } işi hemen çalıştırmaz, MainActor&#39;ın kuyruğuna koyar. MainActor aynı anda tek iş yapar ve o an testi çalıştırıyor. await task.value olmasaydı test hiç beklemeden #expect satırına gelirdi. O anda retryAfterDelay() daha bir kez bile çalışmamış olurdu ve retryCount zaten 0 olurdu.</p><p>Yani guard !Task.isCancelled satırını silsek bile test geçerdi. Kod bozukken yeşil yanan bu tür testlere false positive deniyor. Kırmızı yanamayan bir test hiçbir şeyi korumaz!!.</p><p>Bu sebeple her yeni testten sonra küçük bir kontrol yapmalı;</p><blockquote>Testin koruduğu satırı geçici olarak bozabilir ve testin kırmızı yandığını görebiliriz, sonrasında da satırı geri alırız. Test kırmızı yanmıyorsa aslında hiçbir şeyi kontrol etmiyor demektir.</blockquote><h4>await task.value mı, try await task.value mı?</h4><p>Bu testte await task.value yazdık, bir sonraki testte ise try await firstDownload.value yazacağız. Aradaki fark Task’ın tipinden gelir.</p><p>Task aslında iki tip parametresi alan generic bir tip: Task&lt;Success, Failure&gt;.</p><ul><li>Success, Task&#39;ın iş bitince döndürdüğü değerin tipi.</li><li>Failure, Task&#39;ın fırlatabileceği hatanın tipi.</li></ul><p>Bu iki tipi biz yazmayız, Swift Task { ... } içine yazdığımız closure&#39;a bakarak kendisi bulur. Failure için baktığı şey, closure&#39;ın içinde try olup olmadığıdır.</p><p>Closure’ın içinde try yoksa Task hiçbir zaman hata fırlatamaz. Swift bunu Failure yerine Never yazarak ifade eder. Never, hiçbir değeri olmayan özel bir tiptir. Yani Failure == Never, bu Task&#39;tan hata çıkmasının imkânsız olduğu anlamına gelir. Bu durumda task.value hata fırlatamayacağı için başına try yazmak gerekmez:</p><pre>let task = Task { await sut.retryAfterDelay() }<br>// Task&lt;Void, Never&gt;: Void döner, hata fırlatamaz<br><br>await task.value</pre><p>Closure’ın içinde try varsa Task hata fırlatabilir ve Failure tipi Error olur. task.value da Task&#39;ın içinde fırlatılan hatayı dışarıya taşıdığı için başına try yazmak gerekir:</p><pre>let firstDownload = Task {<br>    _ = try await sut.download(track, fallbackArtworkURL: nil, context: context)<br>}<br>// Task&lt;Void, Error&gt;: Void döner, hata fırlatabilir<br><br>try await firstDownload.value</pre><p>İki örnekte de Success tipi Void, çünkü closure&#39;lar bir değer döndürmüyor. İkinci örnekte _ = yazmamızın sebebi de bu. download bir MusicItem? döndürür ve _ = olmasaydı Swift Success tipini MusicItem? yapmaya çalışırdı. Task&#39;ın döndürdüğü değer Sendable olmak zorundadır ama MusicItem Sendable değildir. Bu değere zaten ihtiyacımız olmadığı için _ = ile atabiliriz.</p><p>Bu kısım biraz detay oldu ama olsun, biz devam edelim. Bu arada Xcode’da task değişkeninin üzerine ⌥ (Option) tuşuna basılı tutarak tıklarsanız Swift&#39;in bulduğu tipi görebilirsiniz.</p><h3>Yarıda Kalan İşleri Test Etmek: CheckedContinuation</h3><p>Son test: download fonksiyonunun ilk satırı.</p><pre>guard !downloadingTrackIDs.contains(track.id) else { return nil }</pre><p>Kullanıcı aynı şarkıya hızlıca iki kez dokunursa şarkı iki kez inmemeli. Bunu test etmek için ilk indirme yarıdayken ikinci isteği göndermemiz gerekir. Ama mock anında cevap verdiği için “yarıda” diye bir an hiç olmaz.</p><blockquote>CheckedContinuation, bir async fonksiyonu elle durdurup elle devam ettirmeye yarar ve bir kapı gibi düşünülebilir. withCheckedContinuation kapıyı kapatır ve fonksiyon orada bekler. continuation.resume() çağrıldığında kapı açılır ve fonksiyon kaldığı yerden devam eder.</blockquote><p>Mock’a bir kapı ekleyelim:</p><pre>var suspendsNextCall = false // kapıyı kapatıp kapatmayacağımıza karar veren anahtar<br>private var pendingContinuation: CheckedContinuation&lt;Void, Never&gt;? // kapı gibi kapımız burada hehe:D<br><br>func searchAndDownload(query: String) async throws -&gt; YouTubeSearchDownloadData {<br>    queries.append(query)<br>    if suspendsNextCall { // anahtar açık mı? <br>        suspendsNextCall = false // anahtarı kapat                             <br>        await withCheckedContinuation { pendingContinuation = $0 } // kapı kapandı, burada bekle<br>    }<br>    return try result.get()<br>}<br><br>func resume() {<br>    pendingContinuation?.resume()   // kapıyı aç<br>    pendingContinuation = nil<br>}</pre><p>Ve test:</p><pre>@Test func ignoresDuplicateDownloadWhileTrackIsDownloading() async throws {<br>    // Arrange: &quot;bir indirme yarıda&quot; durumunu ayarlayacağımız yer<br>    youtubeApiManager.result = .success(.stub())<br>    youtubeApiManager.suspendsNextCall = true<br>    let track = DetailTrack.stub()<br>    let firstDownload = Task {<br>        _ = try await sut.download(track, fallbackArtworkURL: nil, context: context)<br>    }<br>    await Task.yield()<br>    try #require(sut.downloadingTrackIDs.contains(track.id))<br><br>    // Act: aynı şarkıyı tekrar iste<br>    let secondResult = try await sut.download(track, fallbackArtworkURL: nil, context: context)<br><br>    // Assert<br>    #expect(secondResult == nil)<br>    #expect(youtubeApiManager.queries.count == 1)<br><br>    // Cleanup: kapıyı aç, ilk indirmeyi bitir<br>    youtubeApiManager.resume()<br>    try await firstDownload.value<br>}</pre><p>Testte neler olduğuna bakalım:</p><ul><li>Task { ... } ilk indirmeyi başlatır. Test ettiğimiz davranış ikinci çağrı olduğu için ilk indirme de Arrange&#39;ın bir parçasıdır.</li><li>await Task.yield() MainActor&#39;ı bir anlığına bırakır. Böylece kuyruktaki ilk indirme çalışır, mock&#39;taki kapıya kadar gelir ve orada bekler. Önceki testte Task&#39;ın çalışmadan iptal edilmesini istiyorduk, burada ise çalışmasını istiyoruz.</li><li>try #require(...) ilk indirmenin gerçekten yarıda olduğunu kontrol eder. Değilse test burada durur ve yanıltıcı bir sonuç vermez.</li><li>secondResult == nil ve queries.count == 1, ikinci isteğin yok sayıldığını ve YouTube&#39;a hiç gitmediğini gösterir. İkinci istek guard&#39;dan erken döndüğü için defer satırına hiç ulaşmaz. defer bloğu ancak akış o satıra ulaştığında kaydedildiği için ikinci istek, ilk indirmenin ID&#39;sini listeden silmez.</li><li>Cleanup: AAA&#39;ya dördüncü bir adım ekledik. Test kendi kapattığı kapıyı açmak zorundadır, resume() çağrılmazsa ilk Task sonsuza kadar asılı kalır. (Apple&#39;ın dokümantasyonuna göre suite class ya da actor olarak tanımlanırsa temizlik deinit içinde de yapılabilir. Burada temizlik sadece bu teste özel olduğu için testin içinde yaptım.)</li></ul><h4>Anahtar neden hemen kapanıyor?</h4><p>İlk versiyonda suspendsNextCall = false satırı yoktu, yani kapı her çağrıda kapanıyordu. Testin kırmızı yanıp yanmadığını görmek için guard satırını sildiğimde, ikinci çağrının da mock&#39;a girip kapıda beklediğini fark ettim. Onu açacak resume() ise assert&#39;lerden sonra geldiği için test kırmızı yanmadı, sonsuza kadar asılı kaldı.</p><p>Anahtarı ilk çağrıda kapatınca, guard silindiğinde ikinci çağrı kapıya takılmadan geçti, şarkıyı kaydetti ve iki #expect birden kırmızı yandı. Bir testin düzgün şekilde kırılabilmesi, en az geçmesi kadar önemlidir.</p><h3>Unit Testlerin Yakalayamadıkları</h3><p>Son olarak, retry mantığını ArtworkViewModel&#39;e taşırken @Observable eklemeyi unutmuşum. Testlerin hepsi yeşildi, çünkü retryCount gerçekten artıyordu. Ama uygulamada görsel hiçbir zaman tekrar yüklenmiyordu. View, ViewModel&#39;i gözlemlemediği için sayaç değişince ekran yeniden çizilmiyordu.</p><p>Unit testler mantığı test eder, View ile ViewModel arasındaki bağlantıyı değil. Yeşil testler her şeyin çalıştığını değil, test edilen davranışların çalıştığını gösterir. Bu sebeple uygulamayı çalıştırıp gözle kontrol etmek çok değerli.</p><h3>Özet Notlar</h3><ul><li>Her davranışın kendi testi olmalı ve test isimleri bir cümle gibi okunmalı.</li><li>Testte gerçek olan tek şey SUT olmalı. Bağımlılıklar protokolle soyutlanmalı ve init&#39;ten verilmeli.</li><li>Stub sadece cevap vermeli, spy sadece kayıt tutmalı. Spy’lar private(set) ile korunmalı.</li><li>Her test AAA ile yazılmalı: Arrange, Act, Assert (gerekirse Cleanup).</li><li>Sonraki satırlar bir koşula muhtaçsa #require, değilse #expect kullanılmalı.</li><li>Mock’ta fatalError yazmak gerekiyorsa, bağımlılık küçük bir protokole bölünmeli (ISP).</li><li>Zaman da bir bağımlılık gibi dışarıdan verilmeli ve testte .zero kullanılmalı (FIRST&#39;ün F&#39;si).</li><li>Her yeni testin koruduğu satır geçici olarak bozulmalı ve testin kırmızı yandığı görülmeli.</li><li>Testler yeşil olsa bile uygulama çalıştırılıp gözle kontrol edilmeli.</li></ul><p>Okuduğunuz için teşekkürler! Umarım faydalı olmuştur. Sorularınız ya da eklemek istedikleriniz olursa geri dönüşlerinizi bekliyor olacağım. 🙌</p><p>🔗 İletişim Adreslerim:</p><p><a href="https://www.linkedin.com/in/beyyzgur/">https://www.linkedin.com/in/beyyzgur/</a><br>beyyzgur@gmail.com<br><a href="https://beyzagur.dev/">https://beyzagur.dev/</a></p><p>🔗 Geliştirdiğim uygulamanın tanıtım videosu:</p><p><a href="https://www.linkedin.com/posts/beyyzgur_iphoneduo-foldabledesign-uidesign-activity-7519779921724977152-22NN?utm_source=share&amp;utm_medium=member_ios&amp;rcm=ACoAAD4d704BFxCoVduN6efxNcJZB_Ytgg-sLWw">#iphoneduo #foldabledesign #uidesign #iosdevelopment #swiftui | Ayşe Beyza GÜR | 12 comments</a></p><h3>Kaynaklar</h3><ul><li>Apple Developer Documentation, <em>Swift Testing</em>: <a href="https://developer.apple.com/documentation/testing">https://developer.apple.com/documentation/testing</a></li><li>Apple Developer Documentation, <em>Organizing test functions with suite types</em>: <a href="https://developer.apple.com/documentation/testing/organizingtests">https://developer.apple.com/documentation/testing/organizingtests</a></li><li>Apple Developer Documentation, <em>Expectations and confirmations</em>: <a href="https://developer.apple.com/documentation/testing/expectations">https://developer.apple.com/documentation/testing/expectations</a></li><li>Apple Developer Documentation, <em>Running tests serially or in parallel</em>: <a href="https://developer.apple.com/documentation/testing/parallelization">https://developer.apple.com/documentation/testing/parallelization</a></li><li>Apple Developer Documentation, <em>Migrating a test from XCTest</em>: <a href="https://developer.apple.com/documentation/testing/migratingfromxctest">https://developer.apple.com/documentation/testing/migratingfromxctest</a></li><li>WWDC24, <em>Meet Swift Testing</em>: <a href="https://developer.apple.com/videos/play/wwdc2024/10179/">https://developer.apple.com/videos/play/wwdc2024/10179/</a></li><li>WWDC24, <em>Go further with Swift Testing</em>: <a href="https://developer.apple.com/videos/play/wwdc2024/10195/">https://developer.apple.com/videos/play/wwdc2024/10195/</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b1568e840239" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Swift’te Bellek Yönetimi — Memory Leak — ARC]]></title>
            <link>https://medium.com/@beyyzgur/swiftte-bellek-y%C3%B6netimi-memory-leak-arc-63a77f23f738?source=rss-19a7667f033b------2</link>
            <guid isPermaLink="false">https://medium.com/p/63a77f23f738</guid>
            <category><![CDATA[swiftui]]></category>
            <category><![CDATA[uikit]]></category>
            <category><![CDATA[memory-leak]]></category>
            <category><![CDATA[swift]]></category>
            <dc:creator><![CDATA[Ayse Beyza GUR]]></dc:creator>
            <pubDate>Tue, 16 Sep 2025 15:58:32 GMT</pubDate>
            <atom:updated>2025-09-16T15:58:32.096Z</atom:updated>
            <content:encoded><![CDATA[<h3>Swift’te Bellek Yönetimi — Memory Leak — ARC</h3><p>Öncelikle herkese merhaba, bugün sizlere Swift’te bellek yönetimi ve ARC (Automatic Reference Counting) konularından bahsetmeye çalışacağım.</p><p>iOS geliştirme yaparken karşımıza en sık çıkan problemlerden biri <strong>memory leak</strong> yani bellek sızıntılarıdır. Özellikle closure’lar ile çalışırken farkında olmadan referans döngüleri oluşturmak çok kolaydır. Bu da uygulamanın performansını olumsuz etkileyebilir. Peki bu sorun nasıl ortaya çıkıyor? Closure’ların çalışma mantığına biraz daha yakından bakalım.</p><h3>1. Swift’te bellek yönetimi: ARC</h3><p>Swift, <strong>Automatic Reference Counting (ARC)</strong> kullanır. ARC, her nesneye kaç tane güçlü referans (<strong>strong reference</strong>) olduğunu takip eder. Eğer bir nesnenin referans sayısı sıfıra düşerse, o nesne bellekte tutulmaz ve <strong>deinit</strong> edilerek serbest bırakılır.</p><p>Bu mekanizma sayesinde çoğu durumda bellek yönetimini manuel olarak düşünmek zorunda kalmayız. Ancak bazı durumlarda, özellikle closure’lar ile birlikte kullanıldığında, ARC tek başına yeterli olmayabilir.</p><h3>2. Closure’lar ve self</h3><p>Bir <strong>closure</strong>, tanımlandığı yerden bağımsız olarak çalışabilen bir yapıdır. Swift’te closure içinde self kullandığında, Swift otomatik olarak self’i <strong>capture</strong> eder.</p><p>Closure içinde <strong>self&#39;i güçlü referansla (</strong><strong>strong reference)</strong> yakalarsan ve o closure da sınıfın bir özelliği olarak saklanırsa, <strong>&quot;strong reference cycle&quot;</strong> (güçlü referans döngüsü) oluşur. Bu döngü kırılmazsa <strong>memory leak</strong> oluşur: yani nesneler bellekte kalır ama artık kullanılmaz.</p><h3>3. Reference Cycle (Referans Döngüsü)</h3><p>Aşağıdaki örneğe bakalım:</p><pre>class MyClass {<br> var value = 0<br>var closure: (() -&gt; Void)?<br>func setupClosure() {<br> closure = {<br> print(self.value) // self burada closure tarafından güçlü şekilde yakalanıyor<br>     }<br>   }<br>}</pre><ul><li>MyClass içinde bir closure tanımladık ve bu closure self.value kullanıyor.</li><li>Bu closure, self&#39;i <strong>güçlü şekilde</strong> yakalıyor.</li><li>Ama closure, aynı zamanda MyClass nesnesinin içinde saklanıyor (self.closure = { ... }).</li><li>Yani:</li><li>self → closure’a sahip.</li><li>closure → self&#39;i güçlü olarak tutuyor.</li><li>Böylece <strong>referans döngüsü</strong> oluşuyor, ARC bu nesnelerin hiçbirini serbest bırakamıyor → <strong>Memory Leak.</strong></li></ul><h3>Çözüm: [weak self] veya [unowned self]</h3><p>Bu döngüyü kırmak için capture list kullanmalısın:</p><pre>closure = { [weak self] in<br>    print(self?.value)<br>}<br><br>/// ya da<br><br>closure = { [unowned self] in<br>    print(self.value)<br>}</pre><h3>self. yazmak neden önemli?</h3><p>Closure içinde açıkça self. yazman:</p><ul><li>Swift’e: “Ben burada self kullanıyorum, dikkat et” demen olur.</li><li>Derleyici, <strong>seni referans döngülerine karşı uyarmaya başlar</strong>.</li><li>Böylece yanlışlıkla güçlü referans döngüsü oluşturduğunda, Swift bunu senin adına yakalayabilir veya sen weak self kullanmayı hatırlarsın.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=63a77f23f738" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[iOS - View Controller Yaşam Döngüleri (Life Cycle)]]></title>
            <link>https://medium.com/@beyyzgur/ios-view-controller-ya%C5%9Fam-d%C3%B6ng%C3%BCleri-life-cycle-67df1533d09d?source=rss-19a7667f033b------2</link>
            <guid isPermaLink="false">https://medium.com/p/67df1533d09d</guid>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[uikit]]></category>
            <category><![CDATA[life-cycle-method]]></category>
            <category><![CDATA[uiviewcontroller]]></category>
            <category><![CDATA[swift]]></category>
            <dc:creator><![CDATA[Ayse Beyza GUR]]></dc:creator>
            <pubDate>Wed, 23 Apr 2025 19:47:34 GMT</pubDate>
            <atom:updated>2025-04-23T19:47:34.423Z</atom:updated>
            <content:encoded><![CDATA[<p>Herkese merhaba, ilk Medium yazımda benim gibi iOS developer yolculuğuna çıkmış herkes için bilinmesi elzem olan bir konudan, Yaşam Döngülerinden bahsetmeye çalışacağım.</p><p>iOS’ta <strong><em>UIViewController</em></strong>, kullanıcıyla etkileşimimizi sağlayan ve ekranın yaşam döngüsünü yöneten temel yapıdır. Bu döngü, herhangi bir view controller’ın ekrana gelme ve ekrandan ayrılma süreçlerini adım adım yönetebilmemizi sağlar. Apple, bu süreçleri yönetebilmemiz için bazı yaşam döngüsü metotları sunar. Bu metotlar, uygulamanın hem performansını hem de kullanıcı deneyimini artırmak açısından oldukça önemlidir. Metotlar aşağıdaki gibidir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/489/1*cDTsSmKgJrJHJekqojpPqA@2x.png" /><figcaption>Yaşam Döngüsü Şeması</figcaption></figure><ul><li><strong><em>init():</em></strong></li></ul><p>Doğrudan bir yaşam döngüsü metodu <strong>değildir</strong> fakat döngünün başı sayılabilecek bir aşamadır. Bu metot, ViewController oluşturulurken çağırılan yapıcı (constructor) fonksiyonudur. Henüz ViewController’ın view ile bağlantısı yoktur çünkü view oluşmamıştır. Sadece bellekte nesne oluşturulur, görünümle ilgili bir şey yapılmaz.</p><ul><li><strong><em>func loadView():</em></strong></li></ul><p>ViewController’ın yönettiği view’i oluşturur. View elle oluşturulacaksa burada tanımlanır. ViewController’ın view özelliği ilk kez erişildiğinde henüz bir view yüklenmemişse sistem otomatik olarak <em>loadView()</em> methodunu çağırır. Sizin <strong>elle override etmeniz gerekmez</strong>.</p><ul><li><strong><em>func viewDidLoad():</em></strong></li></ul><p>ViewController belleğe yüklendikten hemen sonra çağırılır. Yani loadView() ile view oluşturulmuş, bellekte yerini almış fakat henüz ekranda görünmemiştir. Bu fonksiyon sadece 1 kez çalışır. Override edilebilir fakat zorunlu değildir.</p><ul><li><strong><em>func viewWillAppear(bool):</em></strong></li></ul><p>View hiyerarşisine yeni bir view ekleneceğini ViewController’a bildirir. View ekrana gelmeden hemen önce çağırılır. Bu aşamada kullanıcıya gösterilecek içerikler güncellenir.</p><ul><li><strong><em>func viewDidAppear(bool):</em></strong></li></ul><p>View hiyerarşisine yeni bir view eklendiğini ViewController’a bildirir. View ekranda göründükten hemen sonra çağırılır. Kullanıcıyla etkileşim burada başlatılır.</p><ul><li><strong><em>func viewWillDisappear(bool):</em></strong></li></ul><p>View ekranı terk etmeden hemen önce çağırılır. Yani kullanıcı başka bir sayfaya geçmeye başlarken devreye girer. Bu fonksiyonla ekrandaki değişiklikleri kaydetmek, açık formları kapamak, bilgilerini kaydetmeyen kullanıcıları uyarmak gibi işlemleri yapabilirsiniz.</p><ul><li><strong><em>func viewDidDisappear(bool):</em></strong></li></ul><p>View ekranı terk ettikten hemen sonra çağırılır. Artık kullanıcı başka bir ekrandadır. Kaybolduktan sonra arka planda çalışmasını istemediğiniz işlemler için bu fonksiyonu override edebilirsiniz. Örneğin: Video oynatmayı durdurmak, zamanlayıcıyı durdurmak vb.</p><p>Kaynakça:</p><p><a href="https://developer.apple.com/documentation/uikit/uiviewcontroller">UIViewController | Apple Developer Documentation</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=67df1533d09d" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>