kdan_autotest_mac/KdanAutoTest/KdanAuto/Class/AutoTestCase/AutoTest.swift

//
//  AutoTest.swift
//  KdanAuto
//
//  Created by 朱东勇 on 2022/11/25.
//

import Foundation
import AppKit

let testCaseNames = [
    "PDFConvert_Font_Auto_Test",
    "PDFConvert_Color_Auto_Test",
    "PDFConvert_China_Auto_Test",
    "PDFConvert_SpecialCharacter_Auto_Test",
//    "PDFConvert_English_Auto_Test"
]

class AutoTest : NSObject, AutoTestProtocal {
    var reportString : NSMutableAttributedString? = nil
    
    public var _status :  AutoTestStatus = .Normal
    
    class func autoTestForType(_ type:NSString) -> AutoTest? {
        
        if type.isEqual(to: "PDFConvert_Font_Auto_Test") {
            return FontAutoTest.shared()
        }else if type.isEqual(to: "PDFConvert_China_Auto_Test") {
            return ChineseStringAutoTest.shared()
        }else if type.isEqual(to: "PDFConvert_Color_Auto_Test") {
            return TextColorAutoTest.shared()
        }else if type.isEqual(to: "PDFConvert_SpecialCharacter_Auto_Test") {
            return SpecialCharacterAutoTest.shared()
        }
        
        return nil
    }
    
    static var sharedInstance = AutoTest()
    class func shared() -> AutoTest? {
        return sharedInstance
    }
    
    func type() -> String {
        return "Base_Auto_Test"
    }
    
    func name() -> String {
        return "基础测试基类"
    }
    
    
    func keys() -> NSArray {
        return []
    }
    
    func selectedKeys() -> NSArray {
        let userDefaults = UserDefaults.standard
        
        let key = self.type() + ".selectedKeys"
        
        if userDefaults.value(forKey: key) != nil {
            return userDefaults.value(forKey: key) as! NSArray
        }
        
        self.setSelectedKeys(self.keys())
        
        return self.keys()
    }
    
    func setSelectedKeys(_ keys: NSArray) {
        let userDefaults = UserDefaults.standard
        
        let key = self.type() + ".selectedKeys"
        
        userDefaults.setValue(keys, forKey: key)
        userDefaults.synchronize()
    }
    
    func status() -> AutoTestStatus {
        return _status
    }
    
    func setStatus(_ status:AutoTestStatus) {
        _status = status
    }
    
    // Auto Test
    func autoTest() {
        
    }
    
    func autoCheck() {
        
    }
    
    
    func testReport() -> NSAttributedString? {
        return reportString
    }
    
    /// Path
    func originFilePath() -> String {
        return DataModel.shared.originPath().appendingFormat("/\(self.type()).pdf")
    }
    
    func resultFilePath() -> String {
        return DataModel.shared.resultPath().appendingFormat("/\(self.type()).rtf")
    }
    
    func checkFilePath() -> String {
        return DataModel.shared.checkPath().appendingFormat("/\(self.type()).rtf")
    }
    
    // check File Exist
    func isOriginFileExist() -> Bool {
        if nil != self.originFilePath() {
            return FileManager.default.fileExists(atPath: self.originFilePath())
        }
        
        return false
    }
    
    func isResultFileExist() -> Bool {
        if nil != self.resultFilePath() {
            return FileManager.default.fileExists(atPath: self.resultFilePath())
        }
        
        return false
    }
    
    func isCheckFileExist() -> Bool {
        if nil != self.checkFilePath() {
            return FileManager.default.fileExists(atPath: self.checkFilePath())
        }
        
        return false
    }
    
}


extension AutoTest {
    func stringToImage(_ string:String) ->NSImage? {
        let length = Int(string.lengthOfBytes(using: .utf8)/2)
        
        var bytes = malloc(length)!
        
        for i in 0..<length {
            let index = i
            let subString = String(NSString(string: string).substring(with: NSMakeRange(Int(index * 2), 2)))
            bytes.storeBytes(of: UInt8(hexForString(subString)), as: UInt8.self)
        }
        
        var data = Data.init(bytes: bytes, count: length)
        let image = NSImage.init(data: data)
        
        return image
    }
    
    func hexForString(_ string:String) -> UInt8 {
        let chars = string.utf8CString
        
        if (string.lengthOfBytes(using: .utf8) >= 2) {
            return UInt8(intvalueForChar(chars[0]) * 16 + intvalueForChar(chars[1]))
        }
        
        return UInt8(0)
    }
    
    func intvalueForChar(_ char:CChar) -> UInt8 {
        let iValue = char
        
        // 0 ~ 9s
        if iValue >= 48 && iValue <= 57 {
            return UInt8(iValue - 48)
        }else if iValue >= 65 && iValue <= 70 {
            return UInt8(iValue - 65 + 10)
        }else if iValue >= 97 && iValue <= 102 {
            return UInt8(iValue - 97 + 10)
        }
        
        return UInt8(0)
    }
}