iOS Simulator: vad det är och hur det fungerar i Xcode

Vad är Simulator i Xcode?

Xcode Simulator — verktyg för att köra och felsöka iOS-appar direkt på Mac. Till skillnad från Android-emulatorn emulerar Apples simulator inte enhetens ARM-processor. Istället kompileras koden till värdarkitekturens maskinkod (x86_64 på Intel Mac eller arm64 på Apple Silicon).

Simulatorn använder iOS-ramverk direkt från SDK och ger tillgång till UIKit, SwiftUI, Foundation och Core Data. Enligt Apple (WWDC 2024) använder över 90% av utvecklarna simulatorn i utvecklingsfasen och ansluter fysiska enheter endast för sluttestning.

Varje Xcode-version innehåller en uppsättning simulatorer för olika enhetsmodeller och iOS-versioner. Till exempel innehåller Xcode 16 simulatorer för iPhone 16 Pro med iOS 18, iPad Pro M4 med iPadOS 18, Apple Watch Series 10 och Apple TV 4K.

Installation och start av simulatorn

Simulatorn installeras tillsammans med Xcode från Mac App Store. För att lägga till ytterligare iOS-versioner, använd menyn Settings → Platforms. Välj simulatorn i byggschemat (Scheme) och tryck på Run. Alternativt starta simulatorn via menyn Xcode → Open Developer Tool → Simulator.

// Kontroll av lägsta iOS-version för simulatorn
if #available(iOS 18.0, *) {
    print("iOS 18 API tillgängligt")
}

Skillnader mellan simulator och verklig enhet

Förståelse för skillnaderna mellan simulator och verklig enhet är avgörande för kvalitetstestning. Huvudskillnaderna ligger i processorarkitektur, hårdvarukapacitet och grafikprestanda.

Prestanda i simulatorn är vanligtvis högre än på en verklig enhet, eftersom den använder Macens kraftfulla processor. Detta skapar en falsk känsla av snabbhet. Animationer, arbete med Core Data och nätverksförfrågningar på en verklig enhet kan fungera långsammare.

När testning på enhet är obligatorisk

Kör appen obligatoriskt på en verklig enhet före release. Kritiska scenarier: kamera och AVFoundation, Bluetooth och CoreBluetooth, push-notiser via APNs, arbete med filsystem i App Sandbox, grafikprestanda i Metal och batteriförbrukning.

Kontroll av TARGET_OS_SIMULATOR i kod

För villkorlig kompilering av kod för simulatorn tillhandahåller Apple TARGET_OS_SIMULATOR i Objective-C och targetEnvironment(simulator) i Swift. Denna kontroll gör det möjligt att lägga till felsökningsloggar, mock-objekt eller inaktivera hårdvaruberoende kod.

import UIKit

class CameraViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        
        #if targetEnvironment(simulator)
        showMockCameraPreview()
        print("Simulator: vi använder mock-kamera")
        #else
        setupRealCameraSession()
        #endif
    }
}

I Objective-C fungerar direktivet #if TARGET_OS_SIMULATOR på liknande sätt. Använd det för att inaktivera kod som kräver hårdvarusensorer eller kamera. Vid kompilering för simulatorn kommer denna kod inte in i den binära filen.

#if TARGET_OS_SIMULATOR
NSLog(@"Körning i simulatorn — kamera inte tillgänglig");
self.cameraButton.hidden = YES;
#else
self.cameraButton.hidden = NO;
#endif

Typiska användningsscenarier för kontrollen

Kontrollen av TARGET_OS_SIMULATOR tillämpas i tre fall: ersätta kamera med mock-objekt vid UI-tester, inaktivera Core Bluetooth för att påskynda utveckling och logga felsökningsinformation som inte ska hamna i releaseversionen. Undvik att använda kontrollen för att ändra affärslogik — detta kan leda till buggar på en verklig enhet.

Köra tester i simulatorn

Xcode Simulator stöder hela XCTest-testsviten: enhetstester (XCTestCase), UI-tester (XCUITestCase) och prestandatester. För testning på simulatorn krävs inget signerat utvecklarcertifikat, vilket förenklar CI/CD-konfigurationen.

import XCTest

final class LoginTests: XCTestCase {
    var app: XCUIApplication!
    
    override func setUp() {
        continueAfterFailure = false
        app = XCUIApplication()
        app.launch()
    }
    
    func testLoginButtonExists() {
        XCTAssertTrue(app.buttons["loginButton"].exists)
    }
    
    func testEmptyEmailValidation() {
        app.textFields["emailField"].tap()
        app.buttons["loginButton"].tap()
        let errorLabel = app.staticTexts["errorMessage"]
        XCTAssertTrue(errorLabel.exists)
    }
}

För att köra tester från kommandoraden, använd xcodebuild test med angivande av schema och simulator. Parametern -destination bestämmer den specifika simulatorn som testerna ska köras på.

# Kör enhetstester på simulatorn iPhone 16, iOS 18
xcodebuild test \
  -scheme "MyApp" \
  -destination "platform=iOS Simulator,name=iPhone 16,OS=18.0" \
  -testPlan "AllTests"

Begränsningar och fallgropar

Trots bekvämligheten har Xcode Simulator ett antal begränsningar som kan leda till buggar på en verklig enhet. Det mest kritiska är avsaknaden av ARM-emulering: koden kompileras under värdarkitekturen och beteendet hos vissa operationer kan skilja sig.

Core Data och filsystem fungerar snabbare på simulatorn på grund av Macens SSD. På en verklig enhet med NAND-minne är läs-/skrivhastigheten lägre. Testa Core Data-prestanda på enheten före release, särskilt för stora datamängder.

Kontroll av energiförbrukning på simulatorn är omöjlig — simulatorn drivs av Macen. Bakgrundslägen, inklusive inladdning av innehåll och fetch-operationer, beter sig annorlunda på en verklig enhet på grund av batteribegränsningar och Background Task Scheduler.

Hårdvarusensorer och biometri

Simulatorn har inte tillgång till iPhones hårdvarusensorer. Face ID och Touch ID kan simuleras via simulatormenyn: Features → Face ID → Matching Face. Accelerometer, gyroskop och barometer är inte tillgängliga — kod som förlitar sig på CMDeviceMotion måste testas på enheten. För Core Location kan koordinater ställas in via Debug → Simulate Location med val av GPX-fil.

Kontroll av iCloud och StoreKit på simulatorn är också begränsad. StoreKit Test tillåter simulering av köp utan verklig App Store Connect, men kontroll av Sandbox-miljö och produktionsköp kräver en fysisk enhet. iCloud Drive och CloudKit-synkronisering i simulatorn fungerar inte korrekt — Apple rekommenderar att testa dessa scenarier endast på verkliga enheter.

Simulator på Apple Silicon Mac

På Mac med M-seriens processorer fungerar simulatorn fundamentalt annorlunda: koden kompileras till inbyggt ARM64, som på en riktig iPhone, inte till x86_64. Detta minskar avsevärt gapet mellan simulatorn och enheten. Appar som körs på Apple Silicon-simulatorn använder samma ARM-instruktioner som på en fysisk iPhone, vilket gör prestandatester mer representativa. Skillnaden i Metal och Core Animation-prestanda mellan M-seriens simulator och riktig iPhone är minimal jämfört med Intel-simulatorn.

Konfigurera simulatorn för CI

Konfiguration av simulatorn för CI kräver förskapande av önskad enhet och iOS-version. På Continuous Integration-servrar skapas simulatorer inte automatiskt — de måste läggas till via xcrun simctl create före testkörning.

# Skapa simulator för CI
xcrun simctl create \
  "iPhone 16 CI" \
  "com.apple.CoreSimulator.SimDeviceType.iPhone-16" \
  "com.apple.CoreSimulator.SimRuntime.iOS-18-0"

# Kör tester på skapad simulator
xcodebuild test \
  -workspace MyApp.xcworkspace \
  -scheme MyApp \
  -destination "id=$(xcrun simctl list devices | grep 'iPhone 16 CI' | awk -F'[][]' '{print }')"

För parallell testning på CI, konfigurera flera simulatorer med olika iOS-versioner. Xcode Cloud, GitHub Actions och Bitrise stöder parallell testkörning, vilket minskar körtiden med 2-3 gånger. Se till att alla nödvändiga iOS-simulatorer för testning är installerade på CI-servern.