@available(iOS 10.0, *)
public protocol UNUserNotificationCenterDelegate : NSObjectProtocol {
    @available(iOS 10.0, *)
    optional func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void)
}

@available(iOS 10.0, *)
open class UNNotificationResponse : NSObject, NSCopying, NSSecureCoding {

    
    // The notification to which the user responded.
    @NSCopying open var notification: UNNotification { get }

let response = UNNotificationResponse(coder: ???)

private final class KeyedArchiver: NSKeyedArchiver {
    override func decodeObject(forKey _: String) -> Any { "" }
    override func decodeInt64(forKey key: String) -> Int64 { 0 }
}

private extension UNNotificationResponse {
    static func with(
        userInfo: [AnyHashable: Any],
        actionIdentifier: String = UNNotificationDefaultActionIdentifier
    ) throws -> UNNotificationResponse {
        let content = UNMutableNotificationContent()
        content.userInfo = userInfo
        let request = UNNotificationRequest(
            identifier: "",
            content: content,
            trigger: nil
        )

        let notification = try XCTUnwrap(UNNotification(coder: KeyedArchiver()))
        notification.setValue(request, forKey: "request")

        let response = try XCTUnwrap(UNNotificationResponse(coder: KeyedArchiver()))
        response.setValue(notification, forKey: "notification")
        response.setValue(actionIdentifier, forKey: "actionIdentifier")
        return response
    }
}

func testResponse() throws {
    let data: [AnyHashable: Any] = [
        "data": [
            "type": "OPEN_ARTICLE",
            "articleId": "1",
            "articleType": "Fiction",
            "articleTag": "1"
        ]
    ]
    let response = try UNNotificationResponse.with(userInfo: data)
    let centerDelegate = ArticleCenterDelegate()
    centerDelegate.userNotificationCenter(
        UNUserNotificationCenter.current(),
        didReceive: response,
        withCompletionHandler: {}
    )
    XCTAssertEqual(response.notification.request.content.userInfo["type"], "OPEN_ARTICLE")
    XCTAssertEqual(centerDelegate.didOpenArticle, true)
}

private final class KeyedArchiver: NSKeyedArchiver {
    let request: UNNotificationRequest
    let actionIdentifier: String
    let notification: UNNotification

    override func decodeObject(forKey key: String) -> Any? {
        switch key {
        case "request":
            return request
        case "actionIdentifier":
            return actionIdentifier
        case "notification":
            return UNNotification(coder: self)
        default:
            return nil
        }
    }
}

let editButton = app.toolbars["EditArticle.Toolbar"].buttons["Edit"]

class ArticleCell: UICollectionViewCell {
    let authorLabel: UILabel
    let dateLabel: UILabel

    let viewLabel: UILabel
    let deleteButton: UIButton

    private func setupAccessibility() {
        contentView.isAccessibilityElement = true
        contentView.accessibilityLabel = "This article is written by Nobita on Dec 4th 2020"

        viewLabel.isAccessibilityElement = true // Default is false
        viewLabel.accessibilityTraits.insert(.button) // Treat UILabel as button to VoiceOver

        accessibilityElements = [contentView, viewLabel, deleteButton]
        isAccessibilityElement = false
    }
}

let deleteButton = cell.buttons["Delete article"]
if deleteButton.waitForExistence(timeout: 1) {
    deleteButton.tap()
} else {
    let coordinate = cell.coordinate(
        withNormalizedOffset: CGVector(dx: 0.9, dy: 0.9)
    )
    coordinate.tap()
}

import Foundation

public protocol DispatchQueueType {
    func async(execute work: @escaping @convention(block) () -> Void)
}

extension DispatchQueue: DispatchQueueType {
    public func async(execute work: @escaping @convention(block) () -> Void) {
        async(group: nil, qos: .unspecified, flags: [], execute: work)
    }
}

final class MockDispatchQueue: DispatchQueueType {
    func async(execute work: @escaping @convention(block) () -> Void) {
        work()
    }
}

import XCTest

extension XCTestCase {
    /// Asynchronously assertion
    func XCTAssertWait(
        timeout: TimeInterval = 1,
        _ expression: @escaping () -> Void,
        _: String = "",
        file _: StaticString = #file,
        line _: UInt = #line
    ) {
        let expectation = self.expectation(description: #function)
        DispatchQueue.main.asyncAfter(deadline: .now() + timeout) {
            expression()
            expectation.fulfill()
        }

        let waiter = XCTWaiter()
        XCTAssertTrue(waiter.wait(for: [expectation], timeout: timeout + 1) == .completed)
    }
}

extension XCUIElementQuery: Sequence {
    public typealias Iterator = AnyIterator<XCUIElement>
    public func makeIterator() -> Iterator {
        var index = UInt(0)
        return AnyIterator {
            guard index < self.count else { return nil }

            let element = self.element(boundBy: Int(index))
            index = index + 1
            return element
        }
    }
}

extension NSPredicate {
    static func label(contains string: String) -> NSPredicate {
        NSPredicate(format: "label CONTAINS %@", string)
    }
}

let books = app.collectionViews.cells.matching(
    NSPredicate.label(contains: "book")
)

for book in books {

}

let fromCat = app.buttons["cat1"].firstMatch
let toCat = app.buttons["cat2"]
let fromCoordinate = fromCat.coordinate(withNormalizedOffset: CGVector(dx: 0, dy: 0))
let toCoordinate = toCat.coordinate(withNormalizedOffset: CGVector(dx: 0, dy: -0.5))
fromCoordinate.press(forDuration: 1, thenDragTo: toCoordinate)

let screenshot = XCUIScreen.main.screenshot()
let attachment = XCTAttachment(screenshot: screenshot)
attachment.lifetime = .keepAlways
attachment.name = name
add(attachment)

extension UILongPressGestureRecognizer {
    @objc var uiTests_state: UIGestureRecognizer.State {
        let state = self.uiTests_state
        if state == .ended {
            return .changed
        } else {
            return state
        }
    }
}

let originalSelector = #selector(getter: UILongPressGestureRecognizer.state)
let swizzledSelector = #selector(getter: UILongPressGestureRecognizer.uiTests_state)

let originalMethod = class_getInstanceMethod(UILongPressGestureRecognizer.self, originalSelector)!
let swizzledMethod = class_getInstanceMethod(UILongPressGestureRecognizer.self, swizzledSelector)!

let didAddMethod = class_addMethod(UILongPressGestureRecognizer.self, originalSelector, method_getImplementation(swizzledMethod), method_getTypeEncoding(swizzledMethod))

if didAddMethod {
    class_replaceMethod(UILongPressGestureRecognizer.self, swizzledSelector, method_getImplementation(originalMethod), method_getTypeEncoding(originalMethod))
} else {
    method_exchangeImplementations(originalMethod, swizzledMethod)
}

open class SpekTestCase: SpekHelperTestCase {
    open class func makeDescribe() -> Describe {
        return Describe("empty")
    }

    #if canImport(SpekHelper)

    override public class func spekGenerateTestMethodNames() -> [String] {
        let describe = Self.makeDescribe()

        var names: [String] = []
        generate(describe: describe, names: &names)
        return names
    }

    private static func addInstanceMethod(name: String, closure: @escaping () -> Void) -> String {
        let block: @convention(block) (SpekTestCase) -> Void = { spekTestCase in
            let _ = spekTestCase
            closure()
        }

        let implementation = imp_implementationWithBlock(block as Any)
        let selector = NSSelectorFromString(name)
        class_addMethod(self, selector, implementation, "v@:")

        return name
    }
}

-AppleLanguages (jp) -AppleLocale (jp_JP)

app.launchArguments += ProcessInfo().arguments

ProcessInfo().environment // [String: String]

import XCTest
import SwiftMonkey

class MonkeyTests: XCTestCase {
    var app: XCUIApplication!

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

    func testMonkey() {
        let monkey = Monkey(frame: app.frame)
        monkey.addDefaultUIAutomationActions()
        monkey.addXCTestTapAlertAction(interval: 100, application: app)
        monkey.monkeyAround()
    }
}

monkey.addXCTestTapAlertAction(interval: 100, application: app)

github "hyperoslo/Sugar" ~> 1.0

github "Quick/Nimble"
github "Quick/Quick"

let base =  Date(timeIntervalSince1970: 1567756697)
XCTAssertEqual(validator.hasPassed(event: event, date: base), true)

func minuteSinceMidnight(date: Date) -> MinuteSinceMidnight {
    let calendar = Calendar.current
    let start = calendar.startOfDay(for: date)
    return Int(date.timeIntervalSince(start)) / 60
}

func minuteSinceMidnight(date: Date) -> MinuteSinceMidnight {
    let components = calendar.dateComponents([.hour, .minute], from: date)
    guard let hour = components.hour, let minute = components.minute else {
        return 0
    }

    return hour * 60 + minute
}

let formatter = ISO8601DateFormatter()
let date = formatter.date(from: "2019-07-58T12:39:00Z")
let string = formatter.string(from: Date())

var calendar = Calendar.current
calendar.timeZone = TimeZone(secondsFromGMT: 0)!

calendar.date(bySettingHour: 20, minute: 02, second: 00, of: Date()

BasketHandler.swift
BasketHandler.mock.swift
BasketHandler.test.swift

class LauncScreenTests: XCTestCase {
    func testLaunchScreen() {
        let launchScreen = UIStoryboard(name: "LaunchScreen", bundle: nil)
        let viewController = launchScreen.instantiateInitialViewController()!

        let label = viewController.view.subviews.compactMap({ $0 as? UILabel }).first!
        XCTAssertEqual(label.text, "Welcome to my app")

        let imageView = viewController.view.subviews.compactMap({ $0 as? UIImageView }).first!
        XCTAssertNotNil(imageView.image)
    }
}

sleep(10)
app.tap()
_ = checkoutButton.waitForExistence(timeout: 10)

app.launchArguments.append("--UITests")
app.launch

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
  if CommandLine.arguments.contains("--UITests") {
    UIView.setAnimationsEnabled(false)
  }
}

describe("the 'Documentation' directory") {
  it("has everything you need to get started") {
    let sections = Directory("Documentation").sections
    expect(sections).to(contain("Organized Tests with Quick Examples and Example Groups"))
    expect(sections).to(contain("Installing Quick"))
  }

  context("if it doesn't have what you're looking for") {
    it("needs to be updated") {
      let you = You(awesome: true)
      expect{you.submittedAnIssue}.toEventually(beTruthy())
    }
  }
}

import XCTest

extension XCTestCase {
  func given(_ description: String, closure: () throws -> Void) throws {
    try closure()
  }

  func when(_ description: String, closure: () throws -> Void) throws {
    try closure()
  }

  func then(_ description: String, closure: () throws -> Void) throws {
    try closure()
  }
}

func testRemoveObject() throws {
  try given("set to storage") {
    try storage.setObject(testObject, forKey: key)
  }

  try when("remove object from storage") {
    try storage.removeObject(forKey: key)
  }

  try then("there is no object in memory") {
    let memoryObject = try? storage.memoryCache.object(forKey: key) as User
    XCTAssertNil(memoryObject)
  }

  try then("there is no object on disk") {
    let diskObject = try? storage.diskCache.object(forKey: key) as User
    XCTAssertNil(diskObject)
  }
}

addUIInterruptionMonitor(withDescription: "Location permission", handler: { alert in
  alert.buttons["Allow"].tap()
  return true
})

app.tap()

func checkLocationPermission() {
  if CommandLine.arguments.contains("--UITests-mockNoLocationPermission") {
    showNoLocationPopupAndAskUserToEnableInSettings()
  }
}