TestNotificationCenter.swift

// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//

finalclassNotificationCenterDummyObject:NSObject,Sendable{}

classTestNotificationCenter:XCTestCase{
func test_defaultCenter(){
letdefaultCenter1=NotificationCenter.default
letdefaultCenter2=NotificationCenter.default
XCTAssertEqual(defaultCenter1, defaultCenter2)
}

func removeObserver(_ observer:NSObjectProtocol, notificationCenter:NotificationCenter){
guardlet observer = observer as?NSObjectelse{
return
}

 notificationCenter.removeObserver(observer)
}

func test_postNotification(){
letnotificationCenter=NotificationCenter()
letnotificationName=Notification.Name(rawValue:"test_postNotification_name")
nonisolated(unsafe)varflag=false
letdummyObject=NotificationCenterDummyObject()
letobserver= notificationCenter.addObserver(forName: notificationName, object: dummyObject, queue:nil){ notification in
XCTAssertEqual(notificationName, notification.name)
XCTAssertTrue(dummyObject === notification.object as?NotificationCenterDummyObject)

 flag =true
}

 notificationCenter.post(name: notificationName, object: dummyObject)
XCTAssertTrue(flag)

removeObserver(observer, notificationCenter: notificationCenter)
}

func test_postNotificationForObject(){
letnotificationCenter=NotificationCenter()
letnotificationName=Notification.Name(rawValue:"test_postNotificationForObject_name")
nonisolated(unsafe)varflag=true
letdummyObject=NotificationCenterDummyObject()
letdummyObject2=NotificationCenterDummyObject()
letobserver= notificationCenter.addObserver(forName: notificationName, object: dummyObject, queue:nil){ notification in
 flag =false
}

 notificationCenter.post(name: notificationName, object: dummyObject2)
XCTAssertTrue(flag)

removeObserver(observer, notificationCenter: notificationCenter)
}

func test_postMultipleNotifications(){
letnotificationCenter=NotificationCenter()
letnotificationName=Notification.Name(rawValue:"test_postMultipleNotifications_name")
nonisolated(unsafe)varflag1=false
letobserver1= notificationCenter.addObserver(forName: notificationName, object:nil, queue:nil){ _ in
 flag1 =true
}

nonisolated(unsafe)varflag2=true
letobserver2= notificationCenter.addObserver(forName: notificationName, object:nil, queue:nil){ _ in
 flag2 =false
}

nonisolated(unsafe)varflag3=false
letobserver3= notificationCenter.addObserver(forName: notificationName, object:nil, queue:nil){ _ in
 flag3 =true
}

removeObserver(observer2, notificationCenter: notificationCenter)

 notificationCenter.post(name: notificationName, object:nil)
XCTAssertTrue(flag1)
XCTAssertTrue(flag2)
XCTAssertTrue(flag3)

removeObserver(observer1, notificationCenter: notificationCenter)
removeObserver(observer3, notificationCenter: notificationCenter)
}

func test_addObserverForNilName(){
letnotificationCenter=NotificationCenter()
letnotificationName=Notification.Name(rawValue:"test_addObserverForNilName_name")
letinvalidNotificationName=Notification.Name(rawValue:"test_addObserverForNilName_name_invalid")
nonisolated(unsafe)varflag1=false
letobserver1= notificationCenter.addObserver(forName: notificationName, object:nil, queue:nil){ _ in
 flag1 =true
}

nonisolated(unsafe)varflag2=true
letobserver2= notificationCenter.addObserver(forName: invalidNotificationName, object:nil, queue:nil){ _ in
 flag2 =false
}

nonisolated(unsafe)varflag3=false
letobserver3= notificationCenter.addObserver(forName:nil, object:nil, queue:nil){ _ in
 flag3 =true
}

 notificationCenter.post(name: notificationName, object:nil)
XCTAssertTrue(flag1)
XCTAssertTrue(flag2)
XCTAssertTrue(flag3)

removeObserver(observer1, notificationCenter: notificationCenter)
removeObserver(observer2, notificationCenter: notificationCenter)
removeObserver(observer3, notificationCenter: notificationCenter)
}

func test_removeObserver(){
letnotificationCenter=NotificationCenter()
letnotificationName=Notification.Name(rawValue:"test_removeObserver_name")
nonisolated(unsafe)varflag=true
letobserver= notificationCenter.addObserver(forName: notificationName, object:nil, queue:nil){ _ in
 flag =false
}

removeObserver(observer, notificationCenter: notificationCenter)

 notificationCenter.post(name: notificationName, object:nil)
XCTAssertTrue(flag)
}

func test_observeOnPostingQueue(){
letnotificationCenter=NotificationCenter()
letname=Notification.Name(rawValue:"\(#function)_name")
letpostingQueue=OperationQueue()
letexpectation=self.expectation(description:"Observer was not notified.")

 _ = notificationCenter.addObserver(forName: name, object:nil, queue:nil){ _ in
XCTAssertEqual(OperationQueue.current, postingQueue)
 expectation.fulfill()
}

 postingQueue.addOperation{
 notificationCenter.post(name: name, object:nil)
}

self.waitForExpectations(timeout:1)
}

func test_observeOnSpecificQueuePostFromMainQueue(){
letname=Notification.Name(rawValue:"\(#function)_name")
letnotificationCenter=NotificationCenter()
letoperationQueue=OperationQueue()
nonisolated(unsafe)varflag1=false
nonisolated(unsafe)varflag2=false

 _ = notificationCenter.addObserver(forName: name, object:nil, queue: operationQueue){ _ in
XCTAssertEqual(OperationQueue.current, operationQueue)
 flag1 =true
}

 _ = notificationCenter.addObserver(forName: name, object:nil, queue:.main){ _ in
XCTAssertEqual(OperationQueue.current,.main)
 flag2 =true
}

 notificationCenter.post(name: name, object:nil)
 // All observers should be notified synchronously regardless of the observer queue.
XCTAssertTrue(flag1)
XCTAssertTrue(flag2)
}

func test_observeOnSpecificQueuePostFromObservedQueue(){
letname=Notification.Name(rawValue:"\(#function)_name")
letnotificationCenter=NotificationCenter()
letobservingQueue=OperationQueue()
letexpectation=self.expectation(description:"Notification posting operation was not executed.")

 // Protected by the inherent ordering of notification center posts - which is the point of this test
nonisolated(unsafe)varflag1=false
nonisolated(unsafe)varflag2=false

 _ = notificationCenter.addObserver(forName: name, object:nil, queue: observingQueue){ _ in
XCTAssertEqual(OperationQueue.current, observingQueue)
 flag1 =true
}

 _ = notificationCenter.addObserver(forName: name, object:nil, queue:.main){ _ in
XCTAssertEqual(OperationQueue.current,.main)
 flag2 =true
}

 observingQueue.addOperation{
 notificationCenter.post(name: name, object:nil)
 // All observers should be notified synchronously regardless of the observer queue.
XCTAssertTrue(flag1)
XCTAssertTrue(flag2)
 expectation.fulfill()
}

self.waitForExpectations(timeout:1)
}

func test_observeOnSpecificQueuePostFromUnrelatedQueue(){
letname=Notification.Name(rawValue:"\(#function)_name")
letnotificationCenter=NotificationCenter()
letoperationQueue=OperationQueue()
letpostingQueue=OperationQueue()
letexpectation=self.expectation(description:"Notification posting operation was not executed.")

 // Protected by the inherent ordering of notification center posts - which is the point of this test
nonisolated(unsafe)varflag1=false
nonisolated(unsafe)varflag2=false

 _ = notificationCenter.addObserver(forName: name, object:nil, queue: operationQueue){ _ in
XCTAssertEqual(OperationQueue.current, operationQueue)
 flag1 =true
}

 _ = notificationCenter.addObserver(forName: name, object:nil, queue:.main){ _ in
XCTAssertEqual(OperationQueue.current,.main)
 flag2 =true
}

 postingQueue.addOperation{
 notificationCenter.post(name: name, object:nil)
 // All observers should be notified synchronously regardless of the observer queue.
XCTAssertTrue(flag1)
XCTAssertTrue(flag2)
 expectation.fulfill()
}

self.waitForExpectations(timeout:1)
}
}