Testing iOS Applications

import XCTest

class CalculatorTests: XCTestCase {
    func testAddition() {
        let calculator = Calculator()
        XCTAssertEqual(calculator.add(2, 3), 5)
    }
}

func testAsyncOperationWithExpectation() {
    let expectation = XCTestExpectation(description: "Async operation completes")
    
    DispatchQueue.global().async {
        // Simulate async work
        Thread.sleep(forTimeInterval: 1.0)
        expectation.fulfill()
    }
    
    wait(for: [expectation], timeout: 2.0)
}

func testAsyncOperationWithAsyncAwait() async {
    // Simulate an async operation
    await Task.sleep(1_000_000_000) // 1 second
    
    XCTAssertTrue(true, "Async operation completed")
}

import XCTest

protocol NetworkService {
    func fetchData(completion: (Result<Data, Error>) -> Void)
}

class MockNetworkService: NetworkService {
    var fetchDataCalled = false
    var mockData: Data?
    var mockError: Error?

    func fetchData(completion: (Result<Data, Error>) -> Void) {
        fetchDataCalled = true
        if let error = mockError {
            completion(.failure(error))
        } else if let data = mockData {
            completion(.success(data))
        }
    }
}

class APIClientTests: XCTestCase {
    func testFetchDataCallsNetworkService() {
        let mockService = MockNetworkService()
        mockService.mockData = Data()
        
        let client = APIClient(networkService: mockService)
        client.fetchData()
        
        XCTAssertTrue(mockService.fetchDataCalled)
    }
}

import XCTest

class StubNetworkService: NetworkService {
    func fetchData(completion: (Result<Data, Error>) -> Void) {
        let mockResponse = "Stubbed Data".data(using: .utf8)!
        completion(.success(mockResponse))
    }
}

class APIClientTests: XCTestCase {
    func testFetchDataReturnsStubbedData() {
        let stubService = StubNetworkService()
        let client = APIClient(networkService: stubService)
        
        let expectation = XCTestExpectation(description: "Data fetched")
        client.fetchData { result in
            if case .success(let data) = result {
                XCTAssertEqual(String(data: data, encoding: .utf8), "Stubbed Data")
                expectation.fulfill()
            }
        }
        
        wait(for: [expectation], timeout: 1.0)
    }
}

import XCTest

class MyAppUITests: XCTestCase {
    let app = XCUIApplication()

    override func setUp() {
        super.setUp()
        continueAfterFailure = false
        app.launch()
    }

    func testExample() {
        XCTAssertTrue(app.exists)
    }
}

func testButtonTap() {
    let button = app.buttons["submitButton"]
    button.tap()
    
    let alert = app.alerts["successAlert"]
    XCTAssertTrue(alert.exists)
}

func testSwipeGesture() {
    let scrollView = app.scrollViews["mainScrollView"]
    let startCoordinate = scrollView.coordinate(withNormalizedOffset: CGVector(dx: 0.5, dy: 0.5))
    let endCoordinate = startCoordinate.withOffset(CGVector(dx: -0.5, dy: 0))
    
    startCoordinate.tap()
    endCoordinate.tap()
}

import XCTest

class MyAppUITests: XCTestCase {
    func testExample() {
        let app = XCUIApplication()
        app.launch()
        
        // Recorded actions appear here
        app.buttons["Start"].tap()
        app.textFields["username"].typeText("user123")
        app.textFields["password"].typeText("pass456")
        app.buttons["Login"].tap()
    }
}

let button = UIButton()
button.accessibilityLabel = "Submit Form"
button.accessibilityHint = "Taps to submit the form and navigate to next screen"
button.accessibilityTraits = .button
button.isAccessibilityElement = true

import XCTest

class PerformanceTests: XCTestCase {
    func testMethodPerformance() {
        measure {
            // Code to be measured
            someHeavyComputation()
        }
    }
}

import XCTest

class UIPerformanceTests: XCTestCase {
    func testTableViewScrollingPerformance() {
        measure(metrics: [XCTClockMetric(), XCTCPUMetric()]) {
            // Simulate scrolling through a table view
            app.tables.firstMatch.swipeUp()
        }
    }
}

class MockURLProtocol: URLProtocol {
    static var requestHandler: ((URLRequest) -> (URLResponse?, Data?))?

    override class func canInit(with request: URLRequest) -> Bool {
        return true
    }

    override class func canonicalRequest(for request: URLRequest) -> URLRequest {
        return request
    }

    override func startLoading() {
        guard let handler = MockURLProtocol.requestHandler else { return }
        let (response, data) = handler(request)
        if let response = response {
            client?.urlProtocol(self, didReceive: response, cachePolicy: .notAllowed)
        }
        if let data = data {
            client?.urlProtocol(self, didLoad: data)
        }
        client?.urlProtocolDidFinishLoading(self)
    }

    override func stopLoading() {}
}

// Usage in tests
MockURLProtocol.requestHandler = { request in
    let response = HTTPURLResponse(url: URL(string: "https://api.example.com")!, statusCode: 200, httpVersion: nil, headerFields: [:])
    let data = "{"message": "Hello, World!"}".data(using: .utf8)!
    return (response, data)
}

// Enable code coverage in your test target
// Go to Build Settings → Coverage → Generate Coverage Data = Yes

// Example of a test that covers a function
func testCalculateTotal() {
    let cart = ShoppingCart()
    cart.addItem(Item(name: "iPhone", price: 999.0))
    cart.addItem(Item(name: "Case", price: 29.99))
    
    XCTAssertEqual(cart.calculateTotal(), 1028.99)
}

import XCTest

class MyTests: XCTestCase {
    func testExample() {
        // Test logic here
        XCTAssertTrue(true)
    }
}