326 lines
13 KiB
Swift
326 lines
13 KiB
Swift
import Foundation
|
|
#if canImport(XCTest)
|
|
import XCTest
|
|
#endif
|
|
@testable import TargetPrint
|
|
|
|
#if canImport(XCTest)
|
|
final class PPDOptionsTests: XCTestCase {
|
|
|
|
func testDecodePPDString() {
|
|
XCTAssertEqual(CUPSManager.decodePPDString("plain"), "plain")
|
|
XCTAssertEqual(CUPSManager.decodePPDString("CD<2F>DVD"), "CD/DVD")
|
|
XCTAssertEqual(CUPSManager.decodePPDString("Photo<20>Paper<2E> Glossy"), "Photo Paper. Glossy")
|
|
XCTAssertEqual(CUPSManager.decodePPDString("Colon<3A>Test"), "Colon:Test")
|
|
XCTAssertEqual(CUPSManager.decodePPDString("Unclosed<2F"), "Unclosed<2F")
|
|
XCTAssertEqual(CUPSManager.decodePPDString("Invalid<ZZ>"), "Invalid<ZZ>")
|
|
}
|
|
|
|
func testStandardPPDMediaTypeAndTray() {
|
|
let ppd = """
|
|
*OpenUI *PageSize/Media Size: PickOne
|
|
*PageSize A4/A4: ""
|
|
*PageSize Letter/US Letter: ""
|
|
*CloseUI: *PageSize
|
|
*OpenUI *MediaType/Media Type: PickOne
|
|
*MediaType Plain/Plain Paper: ""
|
|
*MediaType Glossy/Photo Glossy: ""
|
|
*CloseUI: *MediaType
|
|
*OpenUI *InputSlot/Paper Source: PickOne
|
|
*InputSlot Auto/Automatic Selection: ""
|
|
*InputSlot Upper/Upper Cassette: ""
|
|
*CloseUI: *InputSlot
|
|
"""
|
|
let options = CUPSManager.discoverPPDOptions(ppd)
|
|
XCTAssertEqual(options.pageSizes, ["A4", "Letter"])
|
|
XCTAssertEqual(options.mediaTypeKeyword, "MediaType")
|
|
XCTAssertEqual(options.mediaTypeChoices, [
|
|
PPDChoice(name: "Plain", title: "Plain Paper"),
|
|
PPDChoice(name: "Glossy", title: "Photo Glossy")
|
|
])
|
|
XCTAssertEqual(options.mediaTypes, ["Plain Paper", "Photo Glossy"])
|
|
|
|
XCTAssertEqual(options.trayKeyword, "InputSlot")
|
|
XCTAssertEqual(options.trayChoices, [
|
|
PPDChoice(name: "Auto", title: "Automatic Selection"),
|
|
PPDChoice(name: "Upper", title: "Upper Cassette")
|
|
])
|
|
XCTAssertEqual(options.trays, ["Automatic Selection", "Upper Cassette"])
|
|
}
|
|
|
|
func testEpsonPPDMediaTypeAndTray() {
|
|
let ppd = """
|
|
*OpenUI *MediaType/Media Type: PickOne
|
|
*MediaType 0/plain papers: ""
|
|
*MediaType 13/Epson Premium Glossy: ""
|
|
*MediaType 26/CD<2F>DVD: ""
|
|
*CloseUI: *MediaType
|
|
*OpenUI *EPIJ_FdSo/Paper Source: PickOne
|
|
*EPIJ_FdSo 2/Cassette 1: ""
|
|
*EPIJ_FdSo 3/Cassette 2: ""
|
|
*EPIJ_FdSo 12/Rear Paper Feed Slot: ""
|
|
*CloseUI: *EPIJ_FdSo
|
|
"""
|
|
let options = CUPSManager.discoverPPDOptions(ppd)
|
|
XCTAssertEqual(options.mediaTypeKeyword, "MediaType")
|
|
XCTAssertEqual(options.mediaTypeChoices, [
|
|
PPDChoice(name: "0", title: "plain papers"),
|
|
PPDChoice(name: "13", title: "Epson Premium Glossy"),
|
|
PPDChoice(name: "26", title: "CD/DVD")
|
|
])
|
|
XCTAssertEqual(options.mediaTypes, ["plain papers", "Epson Premium Glossy", "CD/DVD"])
|
|
|
|
XCTAssertEqual(options.trayKeyword, "EPIJ_FdSo")
|
|
XCTAssertEqual(options.trayChoices, [
|
|
PPDChoice(name: "2", title: "Cassette 1"),
|
|
PPDChoice(name: "3", title: "Cassette 2"),
|
|
PPDChoice(name: "12", title: "Rear Paper Feed Slot")
|
|
])
|
|
XCTAssertEqual(options.trays, ["Cassette 1", "Cassette 2", "Rear Paper Feed Slot"])
|
|
}
|
|
|
|
func testCanonPPDMediaTypeAndTray() {
|
|
let ppd = """
|
|
*OpenUI *CNIJMediaType/Media Type: PickOne
|
|
*CNIJMediaType 0/Plain Paper: ""
|
|
*CNIJMediaType 92/Photo Paper Plus Glossy II: ""
|
|
*CloseUI: *CNIJMediaType
|
|
*OpenUI *CNIJMediaSupply/Paper Source: PickOne
|
|
*CNIJMediaSupply 7/Rear Tray: ""
|
|
*CNIJMediaSupply 33/Manual Feed: ""
|
|
*CloseUI: *CNIJMediaSupply
|
|
"""
|
|
let options = CUPSManager.discoverPPDOptions(ppd)
|
|
XCTAssertEqual(options.mediaTypeKeyword, "CNIJMediaType")
|
|
XCTAssertEqual(options.mediaTypeChoices, [
|
|
PPDChoice(name: "0", title: "Plain Paper"),
|
|
PPDChoice(name: "92", title: "Photo Paper Plus Glossy II")
|
|
])
|
|
XCTAssertEqual(options.mediaTypes, ["Plain Paper", "Photo Paper Plus Glossy II"])
|
|
|
|
XCTAssertEqual(options.trayKeyword, "CNIJMediaSupply")
|
|
XCTAssertEqual(options.trayChoices, [
|
|
PPDChoice(name: "7", title: "Rear Tray"),
|
|
PPDChoice(name: "33", title: "Manual Feed")
|
|
])
|
|
XCTAssertEqual(options.trays, ["Rear Tray", "Manual Feed"])
|
|
}
|
|
|
|
func testEmptyPPDYieldsNilKeywordsAndEmptyChoices() {
|
|
let options = CUPSManager.discoverPPDOptions("")
|
|
XCTAssertNil(options.mediaTypeKeyword)
|
|
XCTAssertTrue(options.mediaTypeChoices.isEmpty)
|
|
XCTAssertTrue(options.mediaTypes.isEmpty)
|
|
XCTAssertNil(options.trayKeyword)
|
|
XCTAssertTrue(options.trayChoices.isEmpty)
|
|
XCTAssertTrue(options.trays.isEmpty)
|
|
}
|
|
|
|
func testQuotesStrippedFromTranslation() {
|
|
let ppd = """
|
|
*OpenUI *MediaType/Media Type: PickOne
|
|
*MediaType Custom/"My Custom Paper": ""
|
|
*CloseUI: *MediaType
|
|
"""
|
|
let options = CUPSManager.discoverPPDOptions(ppd)
|
|
XCTAssertEqual(options.mediaTypeChoices, [
|
|
PPDChoice(name: "Custom", title: "My Custom Paper")
|
|
])
|
|
}
|
|
|
|
func testChoiceWithoutTranslationDefaultsTitleToName() {
|
|
let ppd = """
|
|
*MediaType Plain: ""
|
|
"""
|
|
let choices = CUPSManager.optionDetails(in: ppd, keyword: "MediaType")
|
|
XCTAssertEqual(choices, [
|
|
PPDChoice(name: "Plain", title: "Plain")
|
|
])
|
|
}
|
|
|
|
func testPrintEngineDynamicPPDKeysAndResolution() {
|
|
let epsonPPD = """
|
|
*OpenUI *MediaType/Media Type: PickOne
|
|
*MediaType 0/plain papers: ""
|
|
*MediaType 13/Epson Premium Glossy: ""
|
|
*CloseUI: *MediaType
|
|
*OpenUI *EPIJ_FdSo/Paper Source: PickOne
|
|
*EPIJ_FdSo 2/Cassette 1: ""
|
|
*EPIJ_FdSo 12/Rear Paper Feed Slot: ""
|
|
*CloseUI: *EPIJ_FdSo
|
|
"""
|
|
let options = CUPSManager.discoverPPDOptions(epsonPPD)
|
|
let queue = PrinterQueue(
|
|
name: "TestEpson",
|
|
displayName: "Test Epson",
|
|
uri: "usb://epson",
|
|
make: "Epson",
|
|
model: "XP-55",
|
|
isAirPrint: false,
|
|
mediaSizes: ["A4"],
|
|
mediaTypes: options.mediaTypes,
|
|
mediaTypeChoices: options.mediaTypeChoices,
|
|
mediaTypeKeyword: options.mediaTypeKeyword,
|
|
trays: options.trays,
|
|
trayChoices: options.trayChoices,
|
|
trayKeyword: options.trayKeyword,
|
|
resolutions: [],
|
|
ppdText: epsonPPD
|
|
)
|
|
|
|
let engine = PrintEngine()
|
|
engine.mediaType = "Epson Premium Glossy" // passed by human display title
|
|
engine.paperSource = "Cassette 1" // passed by human display title
|
|
|
|
let printInfo = NSPrintInfo()
|
|
engine.applyOptionalPPDKeys(to: printInfo, queue: queue)
|
|
|
|
let dict = printInfo.dictionary()
|
|
let settingsKey = NSPrintInfo.AttributeKey(rawValue: "com.apple.print.printSettings")
|
|
let settings = dict[settingsKey] as? NSDictionary
|
|
|
|
XCTAssertEqual(settings?["MediaType"] as? String, "13")
|
|
XCTAssertEqual(settings?["EPIJ_FdSo"] as? String, "2")
|
|
|
|
// Canon test
|
|
let canonPPD = """
|
|
*OpenUI *CNIJMediaType/Media Type: PickOne
|
|
*CNIJMediaType 92/Photo Paper Plus Glossy II: ""
|
|
*CloseUI: *CNIJMediaType
|
|
*OpenUI *CNIJMediaSupply/Paper Source: PickOne
|
|
*CNIJMediaSupply 7/Rear Tray: ""
|
|
*CloseUI: *CNIJMediaSupply
|
|
"""
|
|
let canonOpts = CUPSManager.discoverPPDOptions(canonPPD)
|
|
let canonQueue = PrinterQueue(
|
|
name: "TestCanon",
|
|
displayName: "Test Canon",
|
|
uri: "usb://canon",
|
|
make: "Canon",
|
|
model: "Pro9500",
|
|
isAirPrint: false,
|
|
mediaSizes: ["A4"],
|
|
mediaTypes: canonOpts.mediaTypes,
|
|
mediaTypeChoices: canonOpts.mediaTypeChoices,
|
|
mediaTypeKeyword: canonOpts.mediaTypeKeyword,
|
|
trays: canonOpts.trays,
|
|
trayChoices: canonOpts.trayChoices,
|
|
trayKeyword: canonOpts.trayKeyword,
|
|
resolutions: [],
|
|
ppdText: canonPPD
|
|
)
|
|
|
|
let canonEngine = PrintEngine()
|
|
canonEngine.mediaType = "Photo Paper Plus Glossy II"
|
|
canonEngine.paperSource = "Rear Tray"
|
|
|
|
let canonPrintInfo = NSPrintInfo()
|
|
canonEngine.applyOptionalPPDKeys(to: canonPrintInfo, queue: canonQueue)
|
|
|
|
let canonSettings = canonPrintInfo.dictionary()[settingsKey] as? NSDictionary
|
|
XCTAssertEqual(canonSettings?["CNIJMediaType"] as? String, "92")
|
|
XCTAssertEqual(canonSettings?["CNIJMediaSupply"] as? String, "7")
|
|
|
|
// Canon 5-notch Custom quality tests
|
|
let canonQualityPPD = """
|
|
*OpenUI *CNIJPrintQuality/Print Quality: PickOne
|
|
*CNIJPrintQuality 0/Super Fine: ""
|
|
*CNIJPrintQuality 5/Fine: ""
|
|
*CNIJPrintQuality 10/Normal(Fine): ""
|
|
*CNIJPrintQuality 15/Normal(Fast): ""
|
|
*CNIJPrintQuality 20/Fast: ""
|
|
*CloseUI: *CNIJPrintQuality
|
|
"""
|
|
let canonQOpts = CUPSManager.discoverPPDOptions(canonQualityPPD)
|
|
XCTAssertEqual(canonQOpts.qualityKeyword, "CNIJPrintQuality")
|
|
XCTAssertEqual(canonQOpts.qualityChoices, [
|
|
PPDChoice(name: "0", title: "Super Fine"),
|
|
PPDChoice(name: "5", title: "Fine"),
|
|
PPDChoice(name: "10", title: "Normal(Fine)"),
|
|
PPDChoice(name: "15", title: "Normal(Fast)"),
|
|
PPDChoice(name: "20", title: "Fast")
|
|
])
|
|
|
|
let canonQQueue = PrinterQueue(
|
|
name: "TestCanonQ",
|
|
displayName: "Test Canon Quality",
|
|
uri: "usb://canon",
|
|
make: "Canon",
|
|
model: "Pro9500",
|
|
isAirPrint: false,
|
|
mediaSizes: ["A4"],
|
|
mediaTypes: [],
|
|
mediaTypeChoices: [],
|
|
mediaTypeKeyword: nil,
|
|
trays: [],
|
|
trayChoices: [],
|
|
trayKeyword: nil,
|
|
qualityChoices: canonQOpts.qualityChoices,
|
|
qualityKeyword: canonQOpts.qualityKeyword,
|
|
resolutions: [],
|
|
ppdText: canonQualityPPD
|
|
)
|
|
|
|
// Super Fine: custom mode 5, slider notch 5, quality 0
|
|
let superFineEngine = PrintEngine()
|
|
superFineEngine.printQuality = "Super Fine"
|
|
let superFineInfo = NSPrintInfo()
|
|
superFineEngine.applyOptionalPPDKeys(to: superFineInfo, queue: canonQQueue)
|
|
let superFineSettings = superFineInfo.dictionary()[settingsKey] as? NSDictionary
|
|
XCTAssertEqual(superFineSettings?["CNIJPrintQuality"] as? String, "0")
|
|
XCTAssertEqual(superFineSettings?["CNIJPrintMode2"] as? String, "5")
|
|
XCTAssertEqual(superFineSettings?["CNIJPQualitySlider"] as? String, "5")
|
|
|
|
// Fine: preset mode 1, slider notch 4, quality 5
|
|
let fineEngine = PrintEngine()
|
|
fineEngine.printQuality = "Fine"
|
|
let fineInfo = NSPrintInfo()
|
|
fineEngine.applyOptionalPPDKeys(to: fineInfo, queue: canonQQueue)
|
|
let fineSettings = fineInfo.dictionary()[settingsKey] as? NSDictionary
|
|
XCTAssertEqual(fineSettings?["CNIJPrintQuality"] as? String, "5")
|
|
XCTAssertEqual(fineSettings?["CNIJPrintMode2"] as? String, "1")
|
|
XCTAssertEqual(fineSettings?["CNIJPQualitySlider"] as? String, "4")
|
|
|
|
// Epson quality test
|
|
let epsonQualityPPD = """
|
|
*OpenUI *EPIJ_Qual/Quality: PickOne
|
|
*EPIJ_Qual 307/Best Quality: ""
|
|
*EPIJ_Qual 305/Quality: ""
|
|
*EPIJ_Qual 304/Fine: ""
|
|
*CloseUI: *EPIJ_Qual
|
|
"""
|
|
let epsonQOpts = CUPSManager.discoverPPDOptions(epsonQualityPPD)
|
|
XCTAssertEqual(epsonQOpts.qualityKeyword, "EPIJ_Qual")
|
|
XCTAssertEqual(epsonQOpts.qualityChoices.count, 3)
|
|
XCTAssertEqual(epsonQOpts.qualityChoices.first?.name, "307")
|
|
XCTAssertEqual(epsonQOpts.qualityChoices.first?.title, "Best Quality")
|
|
|
|
let epsonQQueue = PrinterQueue(
|
|
name: "TestEpsonQ",
|
|
displayName: "Test Epson Quality",
|
|
uri: "usb://epson",
|
|
make: "Epson",
|
|
model: "XP-55",
|
|
isAirPrint: false,
|
|
mediaSizes: ["A4"],
|
|
mediaTypes: [],
|
|
mediaTypeChoices: [],
|
|
mediaTypeKeyword: nil,
|
|
trays: [],
|
|
trayChoices: [],
|
|
trayKeyword: nil,
|
|
qualityChoices: epsonQOpts.qualityChoices,
|
|
qualityKeyword: epsonQOpts.qualityKeyword,
|
|
resolutions: [],
|
|
ppdText: epsonQualityPPD
|
|
)
|
|
let epsonQEngine = PrintEngine()
|
|
epsonQEngine.printQuality = "Best Quality"
|
|
let epsonQInfo = NSPrintInfo()
|
|
epsonQEngine.applyOptionalPPDKeys(to: epsonQInfo, queue: epsonQQueue)
|
|
let epsonQSettings = epsonQInfo.dictionary()[settingsKey] as? NSDictionary
|
|
XCTAssertEqual(epsonQSettings?["EPIJ_Qual"] as? String, "307")
|
|
}
|
|
}
|
|
#endif
|