TestRemoveDuplicates.swift

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

import XCTest
import AsyncAlgorithms

finalclassTestRemoveDuplicates:XCTestCase{
func test_removeDuplicates()async{
letsource=[1,2,2,2,3,4,5,6,5,5]
letexpected=[1,2,3,4,5,6,5]
letsequence= source.async.removeDuplicates()
varactual=[Int]()
forawaititemin sequence {
 actual.append(item)
}
XCTAssertEqual(actual, expected)
}

func test_removeDuplicates_with_closure()async{
letsource=[1,2.001,2.005,2.011,3,4,5,6,5,5]
letexpected=[1,2.001,2.011,3,4,5,6,5]
letsequence= source.async.removeDuplicates{abs($0 - $1)<0.01}
varactual=[Double]()
forawaititemin sequence {
 actual.append(item)
}
XCTAssertEqual(actual, expected)
}

func test_removeDuplicates_with_throwing_closure()async{
letsource=[1,2,2,2,3,-1,5,6,5,5]
letexpected=[1,2,3]
varactual=[Int]()
letsequence= source.async.removeDuplicates{ prev, next in
letnext=trythrowOn(-1, next)
return prev == next
}

do{
fortryawaititemin sequence {
 actual.append(item)
}
XCTFail()
}catch{
XCTAssertEqual(Failure(), error as?Failure)
}
XCTAssertEqual(actual, expected)
}

func test_removeDuplicates_with_throwing_upstream()async{
letsource=[1,2,2,2,3,-1,5,6,5,5]
letexpected=[1,2,3]
varactual=[Int]()
letthrowingSequence= source.async.map(
{
if $0 <0{
throwNSError(domain: NSCocoaErrorDomain, code:-1, userInfo:nil)
}
return $0
}as@Sendable(Int)throws->Int
)

do{
fortryawaititemin throwingSequence.removeDuplicates(){
 actual.append(item)
}
XCTFail()
}catch{
XCTAssertEqual((error asNSError).code,-1)
}
XCTAssertEqual(actual, expected)
}

func test_removeDuplicates_cancellation()async{
letsource=Indefinite(value:"test")
letsequence= source.async.removeDuplicates()
letfinished=expectation(description:"finished")
letiterated=expectation(description:"iterated")
lettask=Task{
varfirstIteration=false
forawait_in sequence {
if !firstIteration {
 firstIteration =true
 iterated.fulfill()
}else{
XCTFail("This sequence should only ever emit a single value")
}
}
 finished.fulfill()
}
 // ensure the other task actually starts
awaitfulfillment(of:[iterated], timeout:1.0)
 // cancellation should ensure the loop finishes
 // without regards to the remaining underlying sequence
 task.cancel()
awaitfulfillment(of:[finished], timeout:1.0)
}
}