mirror of
https://gitlab.linphone.org/BC/public/linphone-iphone.git
synced 2026-01-17 11:08:06 +00:00
778 lines
30 KiB
Swift
778 lines
30 KiB
Swift
import SwiftUI
|
|
import XCTest
|
|
|
|
extension XCUIElement {
|
|
private static var _representation = [String:UITestsScreenshots]()
|
|
|
|
// hack to add variable in extensions
|
|
var representation: UITestsScreenshots {
|
|
get {
|
|
let tmpAddress = String(format: "%p", unsafeBitCast(self, to: Int.self))
|
|
if (XCUIElement._representation[tmpAddress] == nil) {
|
|
XCUIElement._representation[tmpAddress] = UITestsScreenshots(element: self)
|
|
}
|
|
return XCUIElement._representation[tmpAddress]!
|
|
}
|
|
}
|
|
}
|
|
|
|
extension XCUIApplication {
|
|
private static var _representationWithElement = UITestsAppRepresentation()
|
|
|
|
var representationWithElements: UITestsAppRepresentation {
|
|
get {
|
|
return XCUIApplication._representationWithElement
|
|
}
|
|
}
|
|
}
|
|
|
|
class UITestsAppRepresentation : UITestsScreenshots {
|
|
|
|
var mainView: XCUIElement
|
|
var otherElement: XCUIElement?
|
|
private let statusBar: XCUIElement
|
|
private let tabBar: XCUIElement
|
|
private let app = XCUIApplication()
|
|
|
|
private(set) var allVariations = [[String](),[String](),[String](),[String]()]
|
|
|
|
private static var backup: [String:(XCUIElement,XCUIElement?,[[String]])] = [:]
|
|
|
|
private var elementsDescription = ""
|
|
override var description: String {
|
|
get {
|
|
let description = super.description + " (definition = " + elementsDescription + ")"
|
|
elementsDescription = ""
|
|
return description
|
|
}
|
|
}
|
|
|
|
init() {
|
|
self.mainView = app.dialerView
|
|
self.statusBar = app.statusBar
|
|
self.tabBar = app.tabBar
|
|
super.init(element: app)
|
|
}
|
|
|
|
func withElementVariations(mainView: [String], statusBar: [String], tabBar: [String], other: [String] = []) -> UITestsAppRepresentation {
|
|
allVariations = [mainView, statusBar, tabBar, other]
|
|
return self
|
|
}
|
|
|
|
func updateElementVariations(mainView: [String], statusBar: [String], tabBar: [String], other: [String] = []) -> UITestsAppRepresentation {
|
|
allVariations[0] += mainView
|
|
allVariations[1] += statusBar
|
|
allVariations[2] += tabBar
|
|
allVariations[3] += other
|
|
return self
|
|
}
|
|
|
|
override func convertForComparaison(screenshot: UIImage) -> UIImage {
|
|
let elements = getElements()
|
|
if (svgManager.rects["mask"] == nil) {_=svgManager.parse()}
|
|
_=elements.map{
|
|
if ($0 != nil) {
|
|
if ($0!.representation.svgManager.rects["mask"] == nil) {_=$0!.representation.svgManager.parse()}
|
|
svgManager.rects["mask"]! += $0!.representation.svgManager.rects["mask"]!
|
|
}
|
|
}
|
|
return super.convertForComparaison(screenshot: screenshot)
|
|
}
|
|
|
|
override func getReference() -> UIImage? {
|
|
UIGraphicsBeginImageContextWithOptions(UITestsScreenshots.screenSize, false, 1)
|
|
guard (super.getReference()?.draw(at: CGPoint(x: 0, y: 0)) != nil) else {return nil}
|
|
let elements = getElements()
|
|
for i in 0..<elements.count {
|
|
if (elements[i] != nil) {
|
|
elements[i]!.representation.withVariations(named: allVariations[i]).getReference()?.draw(at: CGPoint(x: 0, y: 0))
|
|
elementsDescription += elements[i]!.representation.description + " + "
|
|
}
|
|
}
|
|
let reference = UIGraphicsGetImageFromCurrentImageContext()!
|
|
UIGraphicsEndImageContext()
|
|
return reference
|
|
}
|
|
|
|
func getElements() -> [XCUIElement?]{
|
|
return [mainView,statusBar,tabBar,otherElement].map {($0 != nil && self.element.frame.contains($0!.frame)) ? $0! : nil}
|
|
}
|
|
|
|
func makeBackup(named: String) {
|
|
UITestsAppRepresentation.backup[named] = (mainView,otherElement,allVariations)
|
|
}
|
|
|
|
func reloadBackup(named: String) -> UITestsAppRepresentation {
|
|
if let backup = UITestsAppRepresentation.backup[named] {
|
|
mainView = backup.0
|
|
allVariations = backup.2
|
|
otherElement = backup.1
|
|
UITestsAppRepresentation.backup.removeValue(forKey: named)
|
|
} else {
|
|
XCTFail("unable to find an app representation backup named \"\(named)\"")
|
|
}
|
|
return self
|
|
}
|
|
|
|
}
|
|
|
|
class UITestsScreenshots {
|
|
|
|
static let screenshotDelay: TimeInterval = 0.5
|
|
static let pixelTreshold: Int = 3
|
|
static let colorTreshold: Int = 3
|
|
static let screenSize: CGSize = {
|
|
var size = XCUIApplication().frame.size
|
|
let scaleFactor = 3.0
|
|
size.width.scale(by: scaleFactor)
|
|
size.height.scale(by: scaleFactor)
|
|
return size
|
|
}()
|
|
static let defaultPath: String = {
|
|
let path = #filePath
|
|
return String(path.prefix(path.distance(from: path.startIndex, to: path.range(of: "UITests")!.lowerBound) + "UITests/".count)) + "Screenshots/"
|
|
}()
|
|
internal var description: String {
|
|
get {
|
|
return viewName + (variations.isEmpty ? "" : "||\(variations.joined(separator: ","))")
|
|
}
|
|
}
|
|
private(set) var debugHistory: String = ""
|
|
|
|
internal let element: XCUIElement
|
|
private var _svgManager: SVGManager?
|
|
internal var svgManager: SVGManager {
|
|
get{
|
|
if (_svgManager == nil) {_svgManager = SVGManager(path: "\(UITestsScreenshots.defaultPath + viewName).svg")}
|
|
return _svgManager!
|
|
}
|
|
}
|
|
internal var _viewName: String?
|
|
var viewName: String {
|
|
get {
|
|
if (_viewName == nil) {
|
|
_viewName = element.identifier
|
|
if (_viewName!.isEmpty) {_viewName = element.label} //for elements wich don't have identifier
|
|
debugHistory = "UITestsScreenshots : \(_viewName!) : "
|
|
}
|
|
return _viewName!
|
|
}
|
|
}
|
|
private(set) var variations = [String]()
|
|
|
|
init(element: XCUIElement) {
|
|
self.element = element
|
|
}
|
|
|
|
// public functions
|
|
|
|
func withVariations(named: [String]) -> UITestsScreenshots {
|
|
variations = named
|
|
debugHistory += " with varitions named \"\(named.joined(separator: "\", \""))\" -> "
|
|
return self
|
|
}
|
|
|
|
func make(after time: TimeInterval = screenshotDelay) {
|
|
XCTContext.runActivity(named: "Make \"\(viewName)\" reference screenshot") { context in
|
|
debugHistory += "make reference -> "
|
|
guard checkVariationNonDefinition(), referenceExist(expectedValue: false), var screenshot = takeScreenshot(after: time) else {return}
|
|
saveImage(image: screenshot, path: getPath(name: viewName))
|
|
svgManager.createFile(referenceName: viewName, referenceArea: getElementArea(), svgSize: UITestsScreenshots.screenSize)
|
|
screenshot = UITestsScreenshots.imageInScreenAcrea(image: screenshot, area: getElementArea())
|
|
let preview = UITestsScreenshots.createPreview(title: "Reference", image: screenshot)
|
|
context.add(UITestsScreenshots.createAttachement(image: preview, name: description))
|
|
debugHistory += "done."
|
|
}
|
|
}
|
|
|
|
func reMake(after time: TimeInterval = screenshotDelay) {
|
|
XCTContext.runActivity(named: "Remake \"\(viewName)\" reference screenshot") { context in
|
|
debugHistory += "re make reference -> "
|
|
guard referenceImagesExist(names: [viewName]+variations, expectedValue: true), var screenshot = takeScreenshot(after: time) else {return}
|
|
_ = (variations.isEmpty ? [viewName] : variations).map{
|
|
saveImage(image: screenshot, path: getPath(name: $0))
|
|
_ = svgManager.updateImage(name: $0, area: getElementArea())
|
|
}
|
|
screenshot = UITestsScreenshots.imageInScreenAcrea(image: screenshot, area: getElementArea())
|
|
let preview = UITestsScreenshots.createPreview(title: "Reference", image: screenshot)
|
|
context.add(UITestsScreenshots.createAttachement(image: preview, name: description))
|
|
debugHistory += "done."
|
|
XCTFail("\"\(#function)\" is a temporary function, you can't succeed a test with it\nafter remaking a reference you have to use \"check()\" if you want to compare")
|
|
}
|
|
}
|
|
|
|
func check(after time: TimeInterval = screenshotDelay) {
|
|
XCTContext.runActivity(named: "Check \"\(viewName)\" screenshot with his reference") { context in
|
|
debugHistory += "compare screenshot to reference -> "
|
|
guard var screenshot = takeScreenshot(after: time), let reference = getReference() else {return}
|
|
screenshot = convertForComparaison(screenshot: screenshot)
|
|
guard let variances = UITestsScreenshots.getVarianceAreas(reference, screenshot) else {return}
|
|
if (!variances.areas.isEmpty) {
|
|
let errorMsg = "variances found with the reference view in \(variances.areas.count) areas."
|
|
debugHistory += errorMsg
|
|
XCTFail(errorMsg)
|
|
} else {
|
|
debugHistory += "done."
|
|
}
|
|
let preview = UITestsScreenshots.comparativePreview(reference: reference, screenshot: screenshot, difference: variances.image, areas: variances.areas)
|
|
context.add(UITestsScreenshots.createAttachement(image: preview, name: description))
|
|
|
|
}
|
|
}
|
|
|
|
func addNewVariation(named name: String, after time: TimeInterval = screenshotDelay) {
|
|
XCTContext.runActivity(named: "Add \"\(viewName)\" reference screenshot new varation named \(name)") { context in
|
|
debugHistory += "add variances to a new variation named \(name) -> "
|
|
guard referenceImagesExist(names: [name], expectedValue: false), let screenshot = takeScreenshot(after: time), let reference = getReference() else {return}
|
|
guard let variances = UITestsScreenshots.getVarianceAreas(reference, convertForComparaison(screenshot: screenshot)) else {return}
|
|
guard !variances.areas.isEmpty else {
|
|
XCTFail(debugHistory + "error! : no variances found with the reference view")
|
|
return
|
|
}
|
|
saveImage(image: screenshot, path: getPath(name: name))
|
|
_ = svgManager.addVariation(referenceName: viewName, name: name, area: getElementArea(), rects: variances.areas)
|
|
let preview = UITestsScreenshots.variationPreview(reference: reference, areas: variances.areas)
|
|
context.add(UITestsScreenshots.createAttachement(image: preview, name: description))
|
|
debugHistory += "done."
|
|
}
|
|
}
|
|
|
|
func addNewFilterVariation(named name: String, color: UIColor, areas: [CGRect]) {
|
|
XCTContext.runActivity(named: "Add \"\(viewName)\" reference screenshot new filter varation named \(name)") { context in
|
|
let size = UITestsScreenshots.screenSize
|
|
UIGraphicsBeginImageContextWithOptions(size, false, 1)
|
|
color.setFill()
|
|
UIRectFillUsingBlendMode(CGRect(x: 0, y: 0, width: size.width, height: size.height), .normal)
|
|
let image = UIGraphicsGetImageFromCurrentImageContext()!
|
|
UIGraphicsEndImageContext()
|
|
saveImage(image: image, path: getPath(name: name))
|
|
_ = svgManager.addVariation(referenceName: viewName, name: name, area: getElementArea(), rects: areas)
|
|
context.add(UITestsScreenshots.createAttachement(image: image, name: description))
|
|
debugHistory += "done."
|
|
}
|
|
}
|
|
|
|
func addToMask(after time: TimeInterval = screenshotDelay) {
|
|
XCTContext.runActivity(named: "Add new areas to \"\(viewName)\" mask") { context in
|
|
debugHistory += "add variances to mask -> "
|
|
guard let screenshot = takeScreenshot(after: time), let reference = getReference() else {return}
|
|
guard let variances = UITestsScreenshots.getVarianceAreas(reference, convertForComparaison(screenshot: screenshot)) else {return}
|
|
guard !variances.areas.isEmpty else {
|
|
XCTFail(debugHistory + "error! : no variances found with the reference view")
|
|
return
|
|
}
|
|
_ = svgManager.addToMask(rects: variances.areas)
|
|
let preview = UITestsScreenshots.variationPreview(reference: reference, areas: variances.areas)
|
|
context.add(UITestsScreenshots.createAttachement(image: preview, name: description))
|
|
debugHistory += "done."
|
|
}
|
|
}
|
|
|
|
func isAnimated(timeInterval: TimeInterval) {
|
|
XCTContext.runActivity(named: "Check \"\(viewName)\" animation") { context in
|
|
debugHistory += "check if element is animated -> "
|
|
if (takeScreenshot(after: UITestsScreenshots.screenshotDelay)?.pngData() == takeScreenshot(after: timeInterval)?.pngData()) {
|
|
XCTFail("no animation detected for \"\(viewName)\"")
|
|
}
|
|
debugHistory += "done."
|
|
}
|
|
}
|
|
|
|
func takeScreenshot(after time: TimeInterval) -> UIImage? {
|
|
XCTContext.runActivity(named: "take screenshot") { context in
|
|
debugHistory += "take screenshot -> "
|
|
_=XCTWaiter.wait(for: [XCTestExpectation()], timeout: time)
|
|
return UIImage(data: element.screenshot().pngRepresentation)
|
|
}
|
|
}
|
|
|
|
func getReference() -> UIImage? {
|
|
debugHistory += "get reference -> "
|
|
guard svgManager.parse(withVariations: variations), referenceImagesExist(names: [viewName]+variations, expectedValue: true) == true else {return nil}
|
|
let filePaths = [getPath(name: viewName)]+variations.map{getPath(name: $0)}
|
|
let imagesName = [viewName] + variations.map{viewName+"_"+$0}
|
|
var images = [UIImage]()
|
|
for i in 0...imagesName.count-1 {
|
|
let image = getImage(path: filePaths[i])!
|
|
let area = svgManager.images[imagesName[i]]!.area
|
|
var clip = [CGRect]()
|
|
if (i>0) {clip = svgManager.rects[variations[i-1]]!}
|
|
images.append(UITestsScreenshots.imageInScreenAcrea(image: image, area: area, clip: clip))
|
|
|
|
}
|
|
|
|
UIGraphicsBeginImageContextWithOptions(UITestsScreenshots.screenSize, false, 1)
|
|
_ = images.map{$0.draw(at: CGPoint(x: 0,y: 0))}
|
|
let reference = UIGraphicsGetImageFromCurrentImageContext()!
|
|
UIGraphicsEndImageContext()
|
|
return imageWithMask(image: reference, mask: svgManager.rects["mask"]!)
|
|
}
|
|
|
|
//create attachement to return when calling public functions
|
|
|
|
static func createAttachement(image: UIImage, name: String, lifetime: XCTAttachment.Lifetime = .deleteOnSuccess) -> XCTAttachment {
|
|
let attachment = XCTAttachment(image: image)
|
|
attachment.lifetime = lifetime
|
|
attachment.name = name
|
|
return attachment
|
|
}
|
|
|
|
//image operations to prepare comparison
|
|
|
|
static func imageInScreenAcrea(image: UIImage, area: CGRect, clip: [CGRect] = []) -> UIImage {
|
|
UIGraphicsBeginImageContextWithOptions(UITestsScreenshots.screenSize, false, 1)
|
|
if (!clip.isEmpty) {UIGraphicsGetCurrentContext()!.clip(to: clip)}
|
|
image.draw(at: CGPoint(x: area.minX, y: area.minY))
|
|
let screenImage = UIGraphicsGetImageFromCurrentImageContext()!
|
|
UIGraphicsEndImageContext()
|
|
return screenImage
|
|
}
|
|
|
|
static func setBackground(image: UIImage, color: UIColor) -> UIImage {
|
|
let size = UITestsScreenshots.screenSize
|
|
UIGraphicsBeginImageContextWithOptions(size, false, 1)
|
|
color.setFill()
|
|
UIRectFill(CGRect(x: 0, y: 0, width: size.width, height: size.height))
|
|
image.draw(at: CGPoint(x: 0,y: 0))
|
|
let newImage = UIGraphicsGetImageFromCurrentImageContext()!
|
|
UIGraphicsEndImageContext()
|
|
return newImage
|
|
}
|
|
|
|
internal func imageWithMask(image: UIImage, mask: [CGRect]) -> UIImage {
|
|
UIGraphicsBeginImageContextWithOptions(UITestsScreenshots.screenSize, false, 1)
|
|
image.draw(at: CGPoint(x: 0, y: 0))
|
|
_ = mask.map{UIRectFill($0)}
|
|
let maskedImage = UIGraphicsGetImageFromCurrentImageContext()!
|
|
UIGraphicsEndImageContext()
|
|
return maskedImage
|
|
}
|
|
|
|
func convertForComparaison(screenshot: UIImage) -> UIImage {
|
|
var area = getElementArea()
|
|
if (svgManager.rects["mask"] == nil) {_=svgManager.parse()}
|
|
var image = UITestsScreenshots.imageInScreenAcrea(image: screenshot, area: area)
|
|
image = imageWithMask(image: image, mask: svgManager.rects["mask"]!)
|
|
return image
|
|
}
|
|
|
|
func getElementArea() -> CGRect {
|
|
XCTContext.runActivity(named: "get element coordinates") { _ in
|
|
let area = element.frame
|
|
let rect = CGRect(x: area.minX*3, y: area.minY*3, width: area.width*3, height: area.height*3)
|
|
return rect
|
|
}
|
|
}
|
|
|
|
//comparison functions
|
|
static func getVarianceAreas(_ image1: UIImage, _ image2: UIImage) -> (image: UIImage, areas: [CGRect])? {
|
|
|
|
let margin: CGFloat = 20
|
|
let replacementColor: UInt8 = 255
|
|
var areas = [CGRect]()
|
|
|
|
//compare images
|
|
UIGraphicsBeginImageContextWithOptions(image1.size, false, 1)
|
|
setBackground(image: image1, color: UIColor.black).draw(at: CGPoint(x: 0, y: 0))
|
|
setBackground(image: image2, color: UIColor.black).draw(at: CGPoint(x: 0, y: 0), blendMode: .difference, alpha: 1)
|
|
let image = UIGraphicsGetImageFromCurrentImageContext()!
|
|
UIGraphicsEndImageContext()
|
|
|
|
//findRects
|
|
let exeptMsg = "error! : unexpected error during image conversion for comparison"
|
|
guard let inputCGImage = image.cgImage else {
|
|
XCTFail(exeptMsg)
|
|
return nil
|
|
}
|
|
|
|
let colorSpace = CGColorSpaceCreateDeviceGray()
|
|
let width = inputCGImage.width
|
|
let height = inputCGImage.height
|
|
let bytesPerPixel = 1
|
|
let bitsPerComponent = 8
|
|
let bytesPerRow = bytesPerPixel * width
|
|
let bitmapInfo = CGImageAlphaInfo.none.rawValue
|
|
|
|
guard let context = CGContext(data: nil, width: width, height: height, bitsPerComponent: bitsPerComponent, bytesPerRow: bytesPerRow, space: colorSpace, bitmapInfo: bitmapInfo) else {
|
|
XCTFail(exeptMsg)
|
|
return nil
|
|
}
|
|
context.draw(inputCGImage, in: CGRect(x: 0, y: 0, width: width, height: height))
|
|
|
|
guard let buffer = context.data else {
|
|
XCTFail(exeptMsg)
|
|
return nil
|
|
}
|
|
|
|
let pixelBuffer = buffer.bindMemory(to: UInt8.self, capacity: width * height)
|
|
|
|
var rects: [Int:[CGRect]] = [:]
|
|
|
|
for row in 0 ..< Int(height) {
|
|
for column in 0 ..< Int(width) {
|
|
let offset = row * width + column
|
|
if (pixelBuffer[offset] > UInt8(colorTreshold)) {
|
|
pixelBuffer[offset] = replacementColor
|
|
let point = CGPoint(x: column, y: row)
|
|
|
|
var rect = CGRect(x: point.x, y: point.y, width: 1, height: 1)
|
|
for i in 0...1 {
|
|
if let prevRects = rects[row-i] {
|
|
for j in 0..<prevRects.count {
|
|
if (rect.insetBy(dx: -1, dy: -1).intersects(prevRects[j])) {
|
|
rect = prevRects[j].union(rect)
|
|
rects[row-i]!.remove(at: j)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (rects[row] == nil) {rects[row] = []}
|
|
rects[row]!.append(rect)
|
|
if (rect.width >= CGFloat(pixelTreshold) && rect.height >= CGFloat(pixelTreshold)) {
|
|
areas.append(rect)
|
|
}
|
|
mergeCloseAreas(&areas, withMargin: margin)
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
let diff = UIImage(cgImage: (CGContext(data: pixelBuffer, width: width, height: height, bitsPerComponent: bitsPerComponent, bytesPerRow: bytesPerRow, space: colorSpace, bitmapInfo: bitmapInfo)?.makeImage())!)
|
|
return (diff,areas)
|
|
}
|
|
|
|
private static func mergeCloseAreas(_ areas: inout [CGRect], withMargin margin: CGFloat) {
|
|
guard (areas.count >= 1) else {return}
|
|
let areaSize = areas.count
|
|
for i in 1...areaSize {
|
|
if (i != 1 && areas.last!.intersects(areas[areaSize-i].insetBy(dx: -margin, dy: -margin))) {
|
|
areas[areas.count-1] = areas.last!.union(areas[areaSize-i])
|
|
areas.remove(at: areaSize-i)
|
|
mergeCloseAreas(&areas, withMargin: margin)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
//preview functions
|
|
|
|
static func comparativePreview(reference: UIImage, screenshot: UIImage, difference: UIImage, areas: [CGRect]) -> UIImage {
|
|
let realPreview = createPreview(title: "Real", image: screenshot, areas: areas, strokeColor: UIColor.red)
|
|
let refPreview = createPreview(title: "Reference", image: reference, areas: areas, strokeColor: UIColor.red)
|
|
let difPreview = createPreview(title: "Difference", image: difference)
|
|
return createPreviewTable(images: refPreview,realPreview,difPreview)
|
|
}
|
|
|
|
static func variationPreview(reference: UIImage, areas: [CGRect]) -> UIImage {
|
|
let variationPreview = createPreview(title: "Reference", image: reference, areas: areas, fillColor: UIColor.blue.withAlphaComponent(0.3),strokeColor: UIColor.blue)
|
|
return variationPreview
|
|
}
|
|
|
|
static func createPreviewTable(images: UIImage...) -> UIImage {
|
|
let sideMargin: CGFloat = 6
|
|
let imageSize = images.first!.size
|
|
let globalSize = CGSize(width: (imageSize.width+sideMargin)*CGFloat(images.count), height: imageSize.height+sideMargin)
|
|
UIGraphicsBeginImageContextWithOptions(globalSize, false, 1)
|
|
|
|
for i in 0...images.count-1 {
|
|
images[i].draw(at: CGPoint(x: CGFloat(i)*(imageSize.width+sideMargin), y: sideMargin))
|
|
}
|
|
|
|
let tableImage = UIGraphicsGetImageFromCurrentImageContext()!
|
|
UIGraphicsEndImageContext()
|
|
return tableImage
|
|
}
|
|
|
|
static func createPreview(title: String, image: UIImage, areas: [CGRect] = [], fillColor: UIColor? = nil, strokeColor: UIColor? = nil) -> UIImage {
|
|
let lineWidth: CGFloat = 3
|
|
let bottomMargin = image.size.height*0.05
|
|
let allSize = CGSize(width: image.size.width + lineWidth*2, height: image.size.height + bottomMargin + lineWidth*2)
|
|
|
|
UIGraphicsBeginImageContextWithOptions(allSize, false, 1)
|
|
|
|
//image
|
|
image.draw(at: CGPoint(x: lineWidth, y: lineWidth), blendMode: .normal, alpha: 1)
|
|
|
|
//rects
|
|
UIGraphicsGetCurrentContext()?.setLineWidth(lineWidth)
|
|
for area in areas {
|
|
let newArea = area.offsetBy(dx: lineWidth, dy: lineWidth)
|
|
if (fillColor != nil) {
|
|
fillColor?.setFill()
|
|
UIRectFillUsingBlendMode(newArea,.normal)
|
|
}
|
|
if (strokeColor != nil) {
|
|
strokeColor?.setStroke()
|
|
UIRectFrameUsingBlendMode(newArea.insetBy(dx: -3, dy: -3),.normal)
|
|
}
|
|
}
|
|
|
|
//title
|
|
let textFont = UIFont(name: "Helvetica Bold", size: bottomMargin/2) ?? UIFont()
|
|
let textStyle=NSMutableParagraphStyle()
|
|
textStyle.alignment=NSTextAlignment.center
|
|
let textColor = UIColor.black
|
|
let textAttributes = [NSAttributedString.Key.font: textFont, NSAttributedString.Key.paragraphStyle: textStyle, NSAttributedString.Key.foregroundColor: textColor] as [NSAttributedString.Key : Any]
|
|
let text_h = textFont.lineHeight
|
|
let text_y = allSize.height-bottomMargin + (bottomMargin-text_h)/2
|
|
let text_rect = CGRect(x: 0, y: text_y, width: allSize.width, height: bottomMargin)
|
|
title.draw(in: text_rect, withAttributes: textAttributes)
|
|
|
|
let preview = UIGraphicsGetImageFromCurrentImageContext()!
|
|
UIGraphicsEndImageContext()
|
|
return preview
|
|
}
|
|
|
|
//util functions
|
|
|
|
private func referenceExist(expectedValue: Bool) -> Bool {
|
|
guard (FileManager.default.fileExists(atPath: svgManager.path) == expectedValue) else {
|
|
XCTFail(debugHistory + "error! : \(svgManager.path+(expectedValue ? " does not" : " already")) exist")
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
private func referenceImagesExist(names: [String], expectedValue: Bool) -> Bool {
|
|
guard svgManager.parse() else {return false}
|
|
for name in names {
|
|
let realName = viewName + (name != viewName ? "_"+name : "")
|
|
if ((svgManager.images[realName] == nil) == expectedValue) {
|
|
XCTFail(debugHistory + "error! : \(realName) image \(expectedValue ? "does not" : "already") exist")
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
private func checkVariationNonDefinition(caller: String = #function) -> Bool {
|
|
guard variations.isEmpty else {
|
|
XCTFail(debugHistory + "error : \"\(caller)\" function works only for views, not for views variations")
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
//disk operation functions
|
|
|
|
private func getPath(name: String) -> String{
|
|
return "\(UITestsScreenshots.defaultPath)images/\(viewName+((name != viewName) ? "_"+name : "")).png"
|
|
}
|
|
|
|
private func saveImage(image: UIImage, path: String) {
|
|
guard let data = image.pngData() else {
|
|
XCTFail("error != unable to save image at \(path)")
|
|
return
|
|
}
|
|
do {
|
|
try data.write(to: URL(fileURLWithPath: path))
|
|
} catch {
|
|
NSLog(error.localizedDescription)
|
|
XCTFail(debugHistory + "error != unable to save image at \(path)")
|
|
}
|
|
}
|
|
|
|
private func getImage(path: String) -> UIImage? {
|
|
guard let image = UIImage(contentsOfFile: path) else {
|
|
XCTFail(debugHistory + "error != unable to get image at \(path)")
|
|
return nil
|
|
}
|
|
return image
|
|
}
|
|
|
|
}
|
|
|
|
|
|
class SVGManager : NSObject {
|
|
var path: String
|
|
var parentPath: String
|
|
var rects: [String : [CGRect]] = [:]
|
|
var images: [String : (area: CGRect, line: Int)] = [:]
|
|
private var parser: XMLParser?
|
|
private var current: String?
|
|
|
|
private var defaultMask = [CGRect(x: 376, y: 2492, width: 418, height: 16)]
|
|
|
|
private var referenceStart: Int?
|
|
private var maskStart: Int?
|
|
private var clipPathStart: Int?
|
|
private var variationsStart: Int?
|
|
private var selectedVariationStarts: [String : Int]?
|
|
|
|
init(path: String) {
|
|
self.path = path
|
|
let index = path.lastIndex(of: "/")
|
|
self.parentPath = (index != nil) ? String(path.prefix(path.distance(from: path.startIndex, to: index!)+1)) : ""
|
|
|
|
}
|
|
|
|
func svgRect(_ rect: CGRect, lock: Bool) -> String {
|
|
return "<rect x=\"\(rect.minX)\" y=\"\(rect.minY)\" width=\"\(rect.width)\" height=\"\(rect.height)\"\(lock ? " sodipodi:insensitive=\"true\"":"")/>"
|
|
}
|
|
|
|
func svgImage(name: String, area: CGRect, lock: Bool) -> String {
|
|
return "<image id=\"\(name)\" x=\"\(area.minX)\" y=\"\(area.minY)\" width=\"\(area.width)\" height=\"\(area.height)\" preserveAspectRatio=\"none\" xlink:href=\"images/\(name).png\"\(lock ? " sodipodi:insensitive=\"true\"":"")/>"
|
|
}
|
|
|
|
func createFile(referenceName name: String, referenceArea area: CGRect, svgSize: CGSize) {
|
|
let width = svgSize.width
|
|
let height = svgSize.height
|
|
var content = [String]()
|
|
content.append("<svg width=\"\(width)\" height=\"\(height)\" version=\"1.1\" viewBox=\"0 0 \(width) \(height)\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" xmlns:sodipodi=\"http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd\">")
|
|
content.append("<g id=\"reference\" sodipodi:insensitive=\"true\">")
|
|
content.append(" \(svgImage(name: name, area: area, lock: true))")
|
|
content.append("</g>")
|
|
content.append("<defs>\n <clipPath id=\"clipPath\"/>\n</defs>")
|
|
content.append("<g id=\"variations\" clip-path=\"url(#clipPath)\"/>")
|
|
content.append("<g id=\"mask\" opacity=\"0.4\" fill=\"#000\" stroke=\"none\">")
|
|
_ = defaultMask.map{content.append(" \(svgRect($0, lock: true))")}
|
|
content.append("</g>")
|
|
content.append("</svg>")
|
|
let svg = content.joined(separator: "\n")
|
|
try! svg.write(toFile: path, atomically: true, encoding: String.Encoding.utf8)
|
|
}
|
|
|
|
func updateImage(name: String, area: CGRect) -> Bool {
|
|
guard parse(), images[name] != nil else {return false}
|
|
|
|
var svgData = try! String(contentsOf: URL(fileURLWithPath: path)).split(separator: "\n")
|
|
var lineIndex = images[name]!.line-1
|
|
var line = svgData[lineIndex]
|
|
while line.firstIndex(of: "<") == nil {
|
|
svgData.remove(at: lineIndex)
|
|
lineIndex += -1
|
|
line = svgData[lineIndex]
|
|
}
|
|
svgData[lineIndex] = line.prefix(line.distance(from: line.startIndex, to: line.firstIndex(of: "<")!)) + Substring(svgImage(name: name, area: area, lock: true))
|
|
try! String(svgData.joined(separator: "\n")).write(toFile: path, atomically: true, encoding: String.Encoding.utf8)
|
|
return true
|
|
}
|
|
|
|
func addToMask(rects: [CGRect]) -> Bool {
|
|
guard parse() else {return false}
|
|
var content = ""
|
|
for rect in rects {
|
|
content += "\(svgRect(rect, lock: false))\n"
|
|
}
|
|
svgInsert(content, at: maskStart!)
|
|
return true
|
|
}
|
|
|
|
func addVariation(referenceName: String, name: String, area: CGRect, rects: [CGRect]) -> Bool {
|
|
guard parse() else {return false}
|
|
|
|
var content = "<g id=\"\(name)\" display=\"none\" fill=\"none\" stroke=\"#00f\" stroke-width=\"3\">\n"
|
|
content += " \(svgImage(name: "\(referenceName)_\(name)", area: area, lock: true))\n"
|
|
for rect in rects {
|
|
content += " \(svgRect(rect, lock: false))\n"
|
|
}
|
|
content += "</g>\n"
|
|
svgInsert(content, at: variationsStart!)
|
|
|
|
content = "<use xlink:href=\"#\(name)\"/>"
|
|
svgInsert(content, at: clipPathStart!, parentElement: "clipPath")
|
|
return true
|
|
}
|
|
|
|
//if some variations are delete with a svg editor like Inkscape, this variations are copied in the clipPath wich break some functionalities.
|
|
//this function is called at eeach parse to clean the clipPath if needed.
|
|
func removeClipPathAnomalies() {
|
|
guard (clipPathStart ?? 0 < (variationsStart ?? 0 )-2) else {return}
|
|
var svgData = try! String(contentsOf: URL(fileURLWithPath: path)).split(separator: "\n")
|
|
var index = clipPathStart!
|
|
var use = false
|
|
var line = svgData[index]
|
|
while !line.contains("</clipPath>") && !line.contains("</defs>") {
|
|
if (use == true) {
|
|
if (line.contains("/>")) {use = false}
|
|
} else {
|
|
if (line.range(of: "<use") != nil) {use = true}
|
|
else {
|
|
svgData.remove(at: index)
|
|
index += -1
|
|
}
|
|
}
|
|
index += 1
|
|
line = svgData[index]
|
|
}
|
|
try! String(svgData.joined(separator: "\n")).write(toFile: path, atomically: true, encoding: String.Encoding.utf8)
|
|
}
|
|
|
|
func parse(withVariations headers: [String] = []) -> Bool {
|
|
rects["mask"] = []
|
|
_ = headers.map{rects[$0] = []}
|
|
parser = XMLParser(contentsOf: URL(fileURLWithPath: path))
|
|
guard (parser != nil) else {return false}
|
|
parser!.delegate = self
|
|
parser!.parse()
|
|
removeClipPathAnomalies()
|
|
return true
|
|
}
|
|
|
|
func svgInsert(_ content: String, at index: Int, parentElement: String = "g") {
|
|
var svgData = try! String(contentsOf: URL(fileURLWithPath: path)).split(separator: "\n")
|
|
let line = svgData[index-1]
|
|
let prefix = line.prefix(line.distance(from: line.startIndex, to: line.firstIndex(of: "<") ?? line.startIndex))
|
|
if (line.suffix(2) == "/>") {
|
|
svgData[index-1] = line.prefix(line.count-2)+">"
|
|
svgData.insert(prefix+"</\(parentElement)>", at: index)
|
|
}
|
|
svgData.insert(prefix+Substring(" "+content), at: index)
|
|
|
|
try! String(svgData.joined(separator: "\n")).write(toFile: path, atomically: true, encoding: String.Encoding.utf8)
|
|
}
|
|
}
|
|
|
|
extension SVGManager : XMLParserDelegate {
|
|
|
|
func parser(_ parser: XMLParser, didStartElement elementName: String, namespaceURI: String?, qualifiedName qName: String?, attributes attributeDict: [String : String] = [:]) {
|
|
|
|
if (elementName == "g") {
|
|
if (rects[attributeDict["id"] ?? ""] != nil) {
|
|
current = attributeDict["id"]
|
|
}
|
|
if (attributeDict["id"] == "reference") {
|
|
referenceStart = parser.lineNumber
|
|
} else if (attributeDict["id"] == "mask") {
|
|
maskStart = parser.lineNumber
|
|
} else if (attributeDict["id"] == "variations") {
|
|
variationsStart = parser.lineNumber
|
|
}
|
|
}
|
|
|
|
if (elementName == "clipPath" && attributeDict["id"] == "clipPath") {
|
|
clipPathStart = parser.lineNumber
|
|
}
|
|
|
|
if (elementName == "rect" && current != nil) {
|
|
if current != nil { rects[current!]?.append(getRect(attributes: attributeDict))}
|
|
}
|
|
|
|
if (elementName == "image") {
|
|
guard var imageName = attributeDict["xlink:href"] else {return}
|
|
guard FileManager.default.fileExists(atPath: imageName) || FileManager.default.fileExists(atPath: parentPath+imageName) else {
|
|
return
|
|
}
|
|
imageName = String(imageName.suffix(imageName.distance(from: imageName.lastIndex(of: "/") ?? imageName.startIndex, to: imageName.endIndex)-1))
|
|
imageName = String(imageName.prefix(imageName.distance(from: imageName.startIndex, to: imageName.lastIndex(of: ".") ?? imageName.endIndex)))
|
|
images[imageName] = (getRect(attributes: attributeDict),parser.lineNumber)
|
|
}
|
|
}
|
|
|
|
func parser(_ parser: XMLParser, didEndElement elementName: String, namespaceURI: String?, qualifiedName qName: String?) {
|
|
if (elementName == "g") {
|
|
current = nil
|
|
}
|
|
}
|
|
|
|
private func getRect(attributes: [String:String]) -> CGRect {
|
|
var values = [Int]()
|
|
for header in ["x","y","width","height"] {
|
|
if let val = NumberFormatter().number(from: attributes[header] ?? "0") {
|
|
values.append(Int(truncating: val))
|
|
}
|
|
}
|
|
return CGRect(x: values[0], y: values[1], width: values[2], height: values[3])
|
|
}
|
|
}
|