import XCTest

final class SampleTests: XCTestCase {
    func testExample() {
          //  ここにテストを書く
    }
}

import XCTest
@testable import Demo

final class SampleTests: XCTestCase {
    func testExample() {
          //  ここにテストを書く
    }
}

final class SingleExpressionAssertionTests: XCTestCase {
    func testExample() {
        let value = 5
        XCTAssert(value == 5) // 引数の式がTrueを返す時、テストが成功する
        XCTAssertTrue(value > 0) // 引数の式がTrueを返す時、テストが成功する
        XCTAssertFalse(value < 0) // 引数の式がfalseを返す時、テストが成功する
        
        let nilValue = nil as Int?
        XCTAssertNil(nilValue) // 引数の式がnilを返す時、テストが成功する
        
        let optionalValue = Optional(1)
        XCTAssertNotNil(optionalValue) //　引数の式がnilでない値を返す
    }
}

import XCTest

final class TwoExpressionAssertionTests: XCTestCase {
    func testExample() {
        XCTAssertEqual("abc", "abc") // 2つの結果が等しい
        XCTAssertEqual(0.002, 0.003, accuracy: 0.1) // 2つの差がaccuracyより小さい
        XCTAssertNotEqual("abc", "def") // 2つの結果が異なる
        XCTAssertLessThan(4, 7) // 第1引数 < 第2引数
        XCTAssertLessThanOrEqual(7, 7) // 第1引数　≦ 第2引数
        XCTAssertGreaterThan(6, 4) // 第1引数　＞　第2引数
        XCTAssertGreaterThanOrEqual(4, 4) // 第1引数 ≧ 第2引数
    }
}

final class ErrorAssertionTests: XCTestCase {
    func test() {
        XCTAssertThrowsError(
            try throwableFunction(throwsError: true)
        )
        XCTAssertNoThrow(
            try throwableFunction(throwsError: false)
        )
    }
}

import XCTest

func test() {
    let optionalValue = Optional(3)
    guard let value = optionalValue else {
        XCTFail()
        return
    }
    // Valueを使ったテストを作成
}

import XCTest

final class SetUpTests: XCTestCase {
    override class func setUp() {
        super.setUp()
        print("テストケース全体の事前処理") //1
    }
    
    override func setUp() {
        super.setUp()
        print("テストごとの事前処理") //2
    }
    
    func test1() {
        print("テスト1") //3
    }
    
    func test2() {
        print("テスト2") //4
    }
}

import XCTest

final class TearDownTests: XCTestCase {
    override class func tearDown() {
        super.tearDown()
        print("テストケース全体の事後処理")// 5
    }
    
    override func tearDown() {
        super.tearDown()
        print("テストごとの事後処理") // 2, 4
    }
    
    func test1() {
        print("テスト1") // 1
    }
    
    func test2() {
        print("テスト2") // 3
    }
}

import XCTest

final class SomeTestCase: XCTestCase {
    func testWithNil() {
        let optionalValue: Int! = nil
        XCTAssertNotNil(optionalValue)
        XCTAssertEqual(optionalValue + 7, 10)
    }
}

import XCTest

final class SomeTestCase: XCTestCase {
    func testWithNil() {
        
+        continueAfterFailure = false
        
        let optionalValue: Int! = nil
        XCTAssertNotNil(optionalValue)
        XCTAssertEqual(optionalValue + 7, 10)
    }
}

final class FailByErrorTests: XCTestCase {
    func testThrows() throws {
        let int = try throwableIntFunction(throwsError: false)
        XCTAssert(int > 0)
    }
}

import XCTest
@testable import Demo

final class GetIntAsyncTests: XCTestCase {
    func testAsync() {
        var optionalValue: Int?
        getIntAsync { value in
            optionalValue = value
        }
        
        XCTAssertEqual(optionalValue, 4)
    }
}

import XCTest
@testable import Demo

final class GetIntAsyncTests: XCTestCase {
    func testAsync() {
+        let asyncExpectation = expectation(description: "aync")
        var optionalValue: Int?
        getIntAsync { value in
            optionalValue = value
+            asyncExpectation.fulfill()
        }
        
+        wait(for: [asyncExpectation], timeout: 3)
        XCTAssertEqual(optionalValue, 4)
    }
}

class StatusFetcher {
    private let urlSession: URLSession
    init(urlSession: URLSession) {
        self.urlSession = urlSession
    }
    
    func fetchStatus(of url: URL, completion: @escaping (Result<Int, Error>) -> Void) {
        let task = urlSession.dataTask(with: url) { data, urlResponse, error in
            switch (urlResponse, data, error) {
            case (_, let urlResponse as HTTPURLResponse, _):
                completion(.success(urlResponse.statusCode))
            case (_, _, let error?):
                completion(.failure(error))
            default:
                fatalError()
            }
        }
        task.resume()
    }
}

import Foundation

extension URLSession: HTTPClient {
    public func fetchContents(of url: URL, completion: @escaping (Result<(Data, HTTPURLResponse), Error>) -> Void) {
        let task = dataTask(with: url) { data, urlResponse, error in
            switch (data, urlResponse, error) {
            case (let data?, let urlResponse as HTTPURLResponse, _):
                completion(.success((data, urlResponse)))
            case (_, _, let error?):
                completion(.failure(error))
            default:
                fatalError()
            }
        }
    }
}

import Foundation
@testable import Demo

final class StubHTTPClient: HTTPClient {
    let result: Result<(Data, HTTPURLResponse), Error>
    
    init(result: Result<(Data, HTTPURLResponse), Error>) {
        self.result = result
    }
    
    func fetchContents(of url: URL, completion: @escaping (Result<(Data, HTTPURLResponse), Error>) -> Void) {
        DispatchQueue.main.asyncAfter(deadline: .now() + 1) { [result] in
            completion(result)
        }
        
    }
}

import XCTest
@testable import Demo

final class StatusFetcherTests: XCTestCase {
    let url = URL(string: "https://example.com")!
    let data = Data()
    
    func makeStubHTTPClient(statusCode: Int) -> StubHTTPClient {
        let urlResponse = HTTPURLResponse(url: url, statusCode: statusCode, httpVersion: nil, headerFields: nil)!
        
        return StubHTTPClient(result: .success((data, urlResponse)))
    }
    
    func test200() {
        let httpClient = makeStubHTTPClient(statusCode: 200)
        let statusFetcher = StatusFetcher(httpClient: httpClient)
        let responseExpectation = expectation(description: "waiting for response")
        
        statusFetcher.fetchStatus(of: url) { result in
            switch result {
            case .success(let statusCode):
                XCTAssertEqual(statusCode, 200)
            case .failure:
                XCTFail()
            }
            responseExpectation.fulfill()
        }
        waitForExpectations(timeout: 10)
    }
}