From 95cf453a145b321f4b4b37aa07b846b40d66e079 Mon Sep 17 00:00:00 2001 From: tylervick Date: Sun, 10 Oct 2021 19:46:45 -0600 Subject: [PATCH 1/7] command parser --- Package.resolved | 9 + Package.swift | 23 ++- Sources/XCTestHTMLReport/Argument.swift | 74 -------- Sources/XCTestHTMLReport/Command.swift | 75 -------- .../Resources/en.lproj/Localizable.strings | 14 ++ Sources/XCTestHTMLReport/main.swift | 167 ++++++++++-------- .../Classes/Models/Summary.swift | 2 +- .../FunctionalTests.swift | 8 +- swift-format.json | 54 ++++++ 9 files changed, 196 insertions(+), 230 deletions(-) delete mode 100644 Sources/XCTestHTMLReport/Argument.swift delete mode 100644 Sources/XCTestHTMLReport/Command.swift create mode 100644 Sources/XCTestHTMLReport/Resources/en.lproj/Localizable.strings create mode 100644 swift-format.json diff --git a/Package.resolved b/Package.resolved index 25c4715d..a0ab2aee 100644 --- a/Package.resolved +++ b/Package.resolved @@ -19,6 +19,15 @@ "version": "3.1.5" } }, + { + "package": "swift-argument-parser", + "repositoryURL": "https://github.com/apple/swift-argument-parser.git", + "state": { + "branch": null, + "revision": "d2930e8fcf9c33162b9fcc1d522bc975e2d4179b", + "version": "1.0.1" + } + }, { "package": "XCResultKit", "repositoryURL": "https://github.com/davidahouse/XCResultKit.git", diff --git a/Package.swift b/Package.swift index cc6ef2e7..f260608c 100644 --- a/Package.swift +++ b/Package.swift @@ -1,12 +1,12 @@ -// swift-tools-version:5.3 -// The swift-tools-version declares the minimum version of Swift required to build this package. +// swift-tools-version:5.4 import PackageDescription let package = Package( name: "XCTestHTMLReport", + defaultLocalization: "en", platforms: [ - .macOS(.v10_15), + .macOS(.v10_15) ], products: [ .executable(name: "xchtmlreport", targets: ["XCTestHTMLReport"]), @@ -14,17 +14,26 @@ let package = Package( ], dependencies: [ .package(url: "https://github.com/onevcat/Rainbow.git", .upToNextMajor(from: "3.0.0")), - .package(url: "https://github.com/davidahouse/XCResultKit.git", .upToNextMinor(from: "0.9.2")), + .package( + url: "https://github.com/davidahouse/XCResultKit.git", .upToNextMinor(from: "0.9.2")), .package(url: "https://github.com/nacho4d/NDHpple.git", .upToNextMajor(from: "2.0.1")), + .package( + url: "https://github.com/apple/swift-argument-parser.git", .upToNextMajor(from: "1.0.0") + ), ], targets: [ - .target( + .executableTarget( name: "XCTestHTMLReport", - dependencies: ["XCTestHTMLReportCore"]), + dependencies: [ + "XCTestHTMLReportCore", + .product(name: "ArgumentParser", package: "swift-argument-parser"), + ], + resources: [.process("Resources")] + ), .target( name: "XCTestHTMLReportCore", dependencies: ["Rainbow", "XCResultKit"], - exclude: ["HTML"]), // ignore HTML directory resources. They are already imported as static strings. + exclude: ["HTML"]), // ignore HTML directory resources. They are already imported as static strings. .testTarget( name: "XCTestHTMLReportTests", dependencies: ["XCTestHTMLReport", "NDHpple"], diff --git a/Sources/XCTestHTMLReport/Argument.swift b/Sources/XCTestHTMLReport/Argument.swift deleted file mode 100644 index 29dd91de..00000000 --- a/Sources/XCTestHTMLReport/Argument.swift +++ /dev/null @@ -1,74 +0,0 @@ -// -// Arguments.swift -// XCTestHTMLReport -// -// Created by Titouan van Belle on 21.07.17. -// Copyright © 2017 Tito. All rights reserved. -// - -import Foundation - -class Argument -{ - enum ArgumentType: String { - case path = "path" - case bool = "bool" - } - - let shortFlag: String - - let optionName: String? - let helpMessage: String - let type: ArgumentType - let required: Bool - let allowsMultiple: Bool - - var usageString: String { - guard required else { - return "" - } - - var string = "-\(shortFlag)" - if let optionName = optionName { - string += " <\(optionName)>" - } - - return " \(string)" - } - - init(_ type: ArgumentType, _ shortFlag: String, _ optionName: String?, required: Bool, allowsMultiple: Bool, helpMessage: String) - { - self.shortFlag = shortFlag - self.optionName = optionName - self.helpMessage = helpMessage - self.type = type - self.required = required - self.allowsMultiple = allowsMultiple - } -} - -class ValueArgument: Argument -{ - var values = [String]() - - class func validate(_ value: String, forType type: ArgumentType) -> (Bool, String?) - { - switch type { - case .path: - return (FileManager.default.fileExists(atPath: value), "Invalid path: \(value)") - default: - return (false, "") - } - } -} - -class BlockArgument: Argument -{ - var block: () -> () - - init(_ shortFlag: String, _ optionName: String?, required: Bool, helpMessage: String, block: @escaping () -> ()) - { - self.block = block - super.init(.bool, shortFlag, optionName, required: required, allowsMultiple: false, helpMessage: helpMessage) - } -} diff --git a/Sources/XCTestHTMLReport/Command.swift b/Sources/XCTestHTMLReport/Command.swift deleted file mode 100644 index 1af01d50..00000000 --- a/Sources/XCTestHTMLReport/Command.swift +++ /dev/null @@ -1,75 +0,0 @@ -// -// Command.swift -// XCTestHTMLReport -// -// Created by Titouan van Belle on 27.07.17. -// Copyright © 2017 Tito. All rights reserved. -// - -import Foundation -import XCTestHTMLReportCore - -struct Command -{ - var arguments: [Argument]! - - var isValid: Bool { - let flagIndexes = CommandLine.arguments.enumerated().map { $0.element.first == "-" ? $0.offset : nil }.compactMap { $0 } - - for index in 0.. 0 else { - if argument.required { - Logger.error("Argument \(argWithDash) is required") - return false - } - - continue; - } - - if !argument.allowsMultiple && argIndexes.count > 1 { - argIndexes = [argIndexes.first!] - Logger.error("Found multiple occurences of \(argWithDash). Will only take the first in consideration") - } - - for argIndex in argIndexes { - if let blockArgument = argument as? BlockArgument { - blockArgument.block() - } else if let valueArgument = argument as? ValueArgument { - let valueIndex = argIndex + 1 - guard CommandLine.arguments.count != valueIndex && !flagIndexes.contains(valueIndex) else { - Logger.error("No value was passed for argument \(argWithDash)") - return false - } - - let value = CommandLine.arguments[valueIndex] - - let result = ValueArgument.validate(value, forType: valueArgument.type) - if !result.0 { - if valueArgument.required { - Logger.error("Value passed to argument \(argWithDash) is invalid. \(result.1!)") - return false - } else { - Logger.warning("value passed to argument \(argWithDash) is invalid. \(result.1!). Ignoring argument.") - continue - } - } - - valueArgument.values.append(value) - } - } - } - - return true - } - - var usage: String { - let usageString = "\nUsage: xchtmlreport" + arguments.map { $0.usageString }.joined() - let optionsString = "\n\nOptions:\n" + arguments.map { " -\($0.shortFlag) \($0.helpMessage)\n"}.joined() - return usageString + optionsString - } -} diff --git a/Sources/XCTestHTMLReport/Resources/en.lproj/Localizable.strings b/Sources/XCTestHTMLReport/Resources/en.lproj/Localizable.strings new file mode 100644 index 00000000..5f35f83d --- /dev/null +++ b/Sources/XCTestHTMLReport/Resources/en.lproj/Localizable.strings @@ -0,0 +1,14 @@ + +// MARK: Command +"results_arg_help" = "Path to one or more .xcresult bundles"; +"resultBundlePath_opt_help" = "Path to a result bundle (allows multiple)\nDEPRECATED: Result bundle paths may be passed as arguments."; +"renderingMode_opt_help" = "Render attachments inline or as linked assets"; +"output_opt_help" = "Output directory, defaults to the first provided xcresult"; +"verbose_flag_help" = "Provide additional logs"; +"junitEnabled_flag_help" = "Provide JUnit XML output"; +"downsizeImages_flag_help" = "Downsize image screenshots"; +"deleteUnattachedFiles_flag_help" = "Delete unattached files from bundle, reducing bundle size"; + +// MARK: Validation +"result_bundle_not_provided" = "Bundles must be provided either by args or the -r option"; +"result_bundle_missing" = "Bundle %@ not found"; diff --git a/Sources/XCTestHTMLReport/main.swift b/Sources/XCTestHTMLReport/main.swift index e0aeaac7..81bc7fca 100644 --- a/Sources/XCTestHTMLReport/main.swift +++ b/Sources/XCTestHTMLReport/main.swift @@ -1,89 +1,118 @@ +import ArgumentParser import Foundation import XCTestHTMLReportCore -var version = "2.1.0" -print("XCTestHTMLReport \(version)") +struct XcTestHtmlReport: ParsableCommand { + static var configuration = CommandConfiguration( + commandName: "xchtmlreport", + version: "2.1.1", + shouldDisplay: true) -var command = Command() -var help = BlockArgument("h", "", required: false, helpMessage: "Print usage and available options") { - print(command.usage) - exit(EXIT_SUCCESS) -} -var verbose = BlockArgument("v", "", required: false, helpMessage: "Provide additional logs") { - Logger.verbose = true -} -var junitEnabled = false -var junit = BlockArgument("j", "junit", required: false, helpMessage: "Provide JUnit XML output") { - junitEnabled = true -} -var result = ValueArgument(.path, "r", "resultBundlePath", required: true, allowsMultiple: true, helpMessage: "Path to a result bundle (allows multiple)") -var renderingMode = Summary.RenderingMode.linking -var inlineAssets = BlockArgument("i", "inlineAssets", required: false, helpMessage: "Inline all assets in the resulting html-file, making it heavier, but more portable") { - renderingMode = .inline -} -var downsizeImagesEnabled = false -var downsizeImages = BlockArgument("z", "downsize-images", required: false, helpMessage: "Downsize image screenshots") { - downsizeImagesEnabled = true -} -var deleteUnattachedFilesEnabled = false -var deleteUnattachedFiles = BlockArgument("d", "delete-unattached", required: false, helpMessage: "Delete unattached files from bundle, reducing bundle size") { - deleteUnattachedFilesEnabled = true -} + @Argument( + help: ArgumentHelp("results_arg_help".localized), + completion: .file(extensions: ["xcresult"])) + var results: [String] = [] + @available(*, deprecated, message: "Result bundle paths may be passed as arguments.") + @Option( + name: .shortAndLong, + help: ArgumentHelp("resultBundlePath_opt_help".localized)) + var resultBundlePath: [String] = [] -command.arguments = [help, - verbose, - junit, - downsizeImages, - deleteUnattachedFiles, - result, - inlineAssets] + @Option(help: ArgumentHelp("renderingMode_opt_help".localized)) + var renderingMode: Summary.RenderingMode = .linking -if !command.isValid { - print(command.usage) - exit(EXIT_FAILURE) -} + @Option( + name: .shortAndLong, parsing: .next, + help: ArgumentHelp("output_opt_help".localized), completion: .directory) + var output: String? -let summary = Summary(resultPaths: result.values, renderingMode: renderingMode) + @Flag(name: .shortAndLong, help: ArgumentHelp("verbose_flag_help".localized)) + var verbose = false -Logger.step("Building HTML..") -let html = summary.generatedHtmlReport() + @Flag(name: .shortAndLong, help: ArgumentHelp("junitEnabled_flag_help".localized)) + var junitEnabled = false -do { - let path = result.values.first! - .dropLastPathComponent() - .addPathComponent("index.html") - Logger.substep("Writing report to \(path)") + @Flag(name: .long, help: ArgumentHelp("downsizeImages_flag_help".localized)) + var downsizeImages = false - try html.write(toFile: path, atomically: false, encoding: .utf8) - Logger.success("\nReport successfully created at \(path)") -} -catch let e { - Logger.error("An error has occured while creating the report. Error: \(e)") -} + @Flag(name: .shortAndLong, help: ArgumentHelp("deleteUnattachedFiles_flag_help".localized)) + var deleteUnattachedFiles = false -if junitEnabled { - Logger.step("Building JUnit..") - let junitXml = summary.generatedJunitReport() - do { - let path = "\(result.values.first!)/report.junit" - Logger.substep("Writing JUnit report to \(path)") + func validate() throws { + guard !results.isEmpty || !resultBundlePath.isEmpty else { + throw ValidationError("result_bundle_not_provided".localized) + } - try junitXml.write(toFile: path, atomically: false, encoding: .utf8) - Logger.success("\nJUnit report successfully created at \(path)") + for result in (results + resultBundlePath) { + guard FileManager.default.fileExists(atPath: result) else { + throw ValidationError(String(format: "result_bundle_missing".localized, result)) + } + } } - catch let e { - Logger.error("An error has occured while creating the JUnit report. Error: \(e)") + + func run() throws { + Logger.verbose = verbose + + let completeResults = results + resultBundlePath + + guard + let path = output + ?? completeResults.first? + .dropLastPathComponent() + .addPathComponent("index.html") + else { + throw ExitCode(EXIT_FAILURE) + } + Logger.substep("Writing report to \(path)") + + let summary = Summary(resultPaths: completeResults, renderingMode: renderingMode) + + Logger.step("Building HTML..") + let html = summary.generatedHtmlReport() + + do { + try html.write(toFile: path, atomically: false, encoding: .utf8) + } catch { + Logger.error("An error has occured while creating the report.") + throw error + } + + Logger.success("\nReport successfully created at \(path)") + + if renderingMode == .linking { + if downsizeImages { + summary.reduceImageSizes() + } + + if deleteUnattachedFiles { + summary.deleteUnattachedFiles() + } + } + + if junitEnabled { + let junitXml = summary.generatedJunitReport() + let junitPath = path.dropLastPathComponent().addPathComponent("report.junit") + Logger.substep("Writing JUnit report to \(junitPath)") + + do { + try junitXml.write(toFile: junitPath, atomically: false, encoding: .utf8) + Logger.success("\nJUnit report successfully created at \(junitPath)") + } catch { + Logger.error("An error has occured while creating the JUnit report.") + throw error + } + } } } -if downsizeImagesEnabled && renderingMode == .linking { - summary.reduceImageSizes() -} +XcTestHtmlReport.main() -if deleteUnattachedFilesEnabled && renderingMode == .linking { - summary.deleteUnattachedFiles() -} +extension Summary.RenderingMode: ExpressibleByArgument {} -exit(EXIT_SUCCESS) +extension String { + fileprivate var localized: String { + NSLocalizedString(self, bundle: .module, comment: "") + } +} diff --git a/Sources/XCTestHTMLReportCore/Classes/Models/Summary.swift b/Sources/XCTestHTMLReportCore/Classes/Models/Summary.swift index b268d05d..21704ec3 100644 --- a/Sources/XCTestHTMLReportCore/Classes/Models/Summary.swift +++ b/Sources/XCTestHTMLReportCore/Classes/Models/Summary.swift @@ -13,7 +13,7 @@ public struct Summary { let runs: [Run] - public enum RenderingMode { + public enum RenderingMode: String { case inline case linking } diff --git a/Tests/XCTestHTMLReportTests/FunctionalTests.swift b/Tests/XCTestHTMLReportTests/FunctionalTests.swift index 40979134..58c8cb88 100644 --- a/Tests/XCTestHTMLReportTests/FunctionalTests.swift +++ b/Tests/XCTestHTMLReportTests/FunctionalTests.swift @@ -8,10 +8,10 @@ final class FunctionalTests: XCTestCase { let (status, maybeStdOut, maybeStdErr) = try xchtmlreportCmd(args: []) - XCTAssertEqual(status, 1) - XCTAssertEqual(maybeStdErr?.isEmpty, true) - let stdOut = try XCTUnwrap(maybeStdOut) - XCTAssertContains(stdOut, "Error: Argument -r is required") + XCTAssertEqual(status, 64) + XCTAssertEqual(maybeStdOut?.isEmpty, true) + let stdErr = try XCTUnwrap(maybeStdErr) + XCTAssertContains(stdErr, "Error: Bundles must be provided either by args or the -r option") } func testBasicFunctionality() throws { diff --git a/swift-format.json b/swift-format.json new file mode 100644 index 00000000..296e8be9 --- /dev/null +++ b/swift-format.json @@ -0,0 +1,54 @@ +{ + "fileScopedDeclarationPrivacy" : { + "accessLevel" : "private" + }, + "indentation" : { + "spaces" : 4 + }, + "indentConditionalCompilationBlocks" : true, + "indentSwitchCaseLabels" : false, + "lineBreakAroundMultilineExpressionChainComponents" : false, + "lineBreakBeforeControlFlowKeywords" : false, + "lineBreakBeforeEachArgument" : false, + "lineBreakBeforeEachGenericRequirement" : false, + "lineLength" : 100, + "maximumBlankLines" : 1, + "prioritizeKeepingFunctionOutputTogether" : false, + "respectsExistingLineBreaks" : true, + "rules" : { + "AllPublicDeclarationsHaveDocumentation" : false, + "AlwaysUseLowerCamelCase" : true, + "AmbiguousTrailingClosureOverload" : true, + "BeginDocumentationCommentWithOneLineSummary" : false, + "DoNotUseSemicolons" : true, + "DontRepeatTypeInStaticProperties" : true, + "FileScopedDeclarationPrivacy" : true, + "FullyIndirectEnum" : true, + "GroupNumericLiterals" : true, + "IdentifiersMustBeASCII" : true, + "NeverForceUnwrap" : false, + "NeverUseForceTry" : false, + "NeverUseImplicitlyUnwrappedOptionals" : false, + "NoAccessLevelOnExtensionDeclaration" : true, + "NoBlockComments" : true, + "NoCasesWithOnlyFallthrough" : true, + "NoEmptyTrailingClosureParentheses" : true, + "NoLabelsInCasePatterns" : true, + "NoLeadingUnderscores" : false, + "NoParensAroundConditions" : true, + "NoVoidReturnOnFunctionSignature" : true, + "OneCasePerLine" : true, + "OneVariableDeclarationPerLine" : true, + "OnlyOneTrailingClosureArgument" : true, + "OrderedImports" : true, + "ReturnVoidInsteadOfEmptyTuple" : true, + "UseLetInEveryBoundCaseVariable" : true, + "UseShorthandTypeNames" : true, + "UseSingleLinePropertyGetter" : true, + "UseSynthesizedInitializer" : true, + "UseTripleSlashForDocumentationComments" : true, + "ValidateDocumentationComments" : false + }, + "tabWidth" : 8, + "version" : 1 +} From 2d4a47a7581df7740b5b07ec4baeaf45f5965730 Mon Sep 17 00:00:00 2001 From: tylervick Date: Mon, 11 Oct 2021 10:37:06 -0600 Subject: [PATCH 2/7] SwiftFormat --- .swift-version | 1 + .swiftformat | 3 ++ Package.swift | 11 +++--- Sources/XCTestHTMLReport/main.swift | 37 +++++++++----------- swift-format.json | 54 ----------------------------- 5 files changed, 27 insertions(+), 79 deletions(-) create mode 100644 .swift-version create mode 100644 .swiftformat delete mode 100644 swift-format.json diff --git a/.swift-version b/.swift-version new file mode 100644 index 00000000..37c2d996 --- /dev/null +++ b/.swift-version @@ -0,0 +1 @@ +5.4 diff --git a/.swiftformat b/.swiftformat new file mode 100644 index 00000000..48782835 --- /dev/null +++ b/.swiftformat @@ -0,0 +1,3 @@ +--exclude .build + +--wraparguments afterfirst diff --git a/Package.swift b/Package.swift index f260608c..3c9bf5eb 100644 --- a/Package.swift +++ b/Package.swift @@ -6,7 +6,7 @@ let package = Package( name: "XCTestHTMLReport", defaultLocalization: "en", platforms: [ - .macOS(.v10_15) + .macOS(.v10_15), ], products: [ .executable(name: "xchtmlreport", targets: ["XCTestHTMLReport"]), @@ -15,7 +15,8 @@ let package = Package( dependencies: [ .package(url: "https://github.com/onevcat/Rainbow.git", .upToNextMajor(from: "3.0.0")), .package( - url: "https://github.com/davidahouse/XCResultKit.git", .upToNextMinor(from: "0.9.2")), + url: "https://github.com/davidahouse/XCResultKit.git", .upToNextMinor(from: "0.9.2") + ), .package(url: "https://github.com/nacho4d/NDHpple.git", .upToNextMajor(from: "2.0.1")), .package( url: "https://github.com/apple/swift-argument-parser.git", .upToNextMajor(from: "1.0.0") @@ -33,10 +34,12 @@ let package = Package( .target( name: "XCTestHTMLReportCore", dependencies: ["Rainbow", "XCResultKit"], - exclude: ["HTML"]), // ignore HTML directory resources. They are already imported as static strings. + exclude: ["HTML"] + ), // ignore HTML directory resources. They are already imported as static strings. .testTarget( name: "XCTestHTMLReportTests", dependencies: ["XCTestHTMLReport", "NDHpple"], - resources: [.copy("TestResults.xcresult")]), + resources: [.copy("TestResults.xcresult")] + ), ] ) diff --git a/Sources/XCTestHTMLReport/main.swift b/Sources/XCTestHTMLReport/main.swift index 81bc7fca..7be8e808 100644 --- a/Sources/XCTestHTMLReport/main.swift +++ b/Sources/XCTestHTMLReport/main.swift @@ -2,30 +2,25 @@ import ArgumentParser import Foundation import XCTestHTMLReportCore - struct XcTestHtmlReport: ParsableCommand { - static var configuration = CommandConfiguration( - commandName: "xchtmlreport", - version: "2.1.1", - shouldDisplay: true) - - @Argument( - help: ArgumentHelp("results_arg_help".localized), - completion: .file(extensions: ["xcresult"])) + static var configuration = CommandConfiguration(commandName: "xchtmlreport", + version: "2.1.1", + shouldDisplay: true) + + @Argument(help: ArgumentHelp("results_arg_help".localized), + completion: .file(extensions: ["xcresult"])) var results: [String] = [] @available(*, deprecated, message: "Result bundle paths may be passed as arguments.") - @Option( - name: .shortAndLong, - help: ArgumentHelp("resultBundlePath_opt_help".localized)) + @Option(name: .shortAndLong, + help: ArgumentHelp("resultBundlePath_opt_help".localized)) var resultBundlePath: [String] = [] @Option(help: ArgumentHelp("renderingMode_opt_help".localized)) var renderingMode: Summary.RenderingMode = .linking - @Option( - name: .shortAndLong, parsing: .next, - help: ArgumentHelp("output_opt_help".localized), completion: .directory) + @Option(name: .shortAndLong, parsing: .next, + help: ArgumentHelp("output_opt_help".localized), completion: .directory) var output: String? @Flag(name: .shortAndLong, help: ArgumentHelp("verbose_flag_help".localized)) @@ -45,7 +40,7 @@ struct XcTestHtmlReport: ParsableCommand { throw ValidationError("result_bundle_not_provided".localized) } - for result in (results + resultBundlePath) { + for result in results + resultBundlePath { guard FileManager.default.fileExists(atPath: result) else { throw ValidationError(String(format: "result_bundle_missing".localized, result)) } @@ -59,9 +54,9 @@ struct XcTestHtmlReport: ParsableCommand { guard let path = output - ?? completeResults.first? - .dropLastPathComponent() - .addPathComponent("index.html") + ?? completeResults.first? + .dropLastPathComponent() + .addPathComponent("index.html") else { throw ExitCode(EXIT_FAILURE) } @@ -111,8 +106,8 @@ XcTestHtmlReport.main() extension Summary.RenderingMode: ExpressibleByArgument {} -extension String { - fileprivate var localized: String { +private extension String { + var localized: String { NSLocalizedString(self, bundle: .module, comment: "") } } diff --git a/swift-format.json b/swift-format.json deleted file mode 100644 index 296e8be9..00000000 --- a/swift-format.json +++ /dev/null @@ -1,54 +0,0 @@ -{ - "fileScopedDeclarationPrivacy" : { - "accessLevel" : "private" - }, - "indentation" : { - "spaces" : 4 - }, - "indentConditionalCompilationBlocks" : true, - "indentSwitchCaseLabels" : false, - "lineBreakAroundMultilineExpressionChainComponents" : false, - "lineBreakBeforeControlFlowKeywords" : false, - "lineBreakBeforeEachArgument" : false, - "lineBreakBeforeEachGenericRequirement" : false, - "lineLength" : 100, - "maximumBlankLines" : 1, - "prioritizeKeepingFunctionOutputTogether" : false, - "respectsExistingLineBreaks" : true, - "rules" : { - "AllPublicDeclarationsHaveDocumentation" : false, - "AlwaysUseLowerCamelCase" : true, - "AmbiguousTrailingClosureOverload" : true, - "BeginDocumentationCommentWithOneLineSummary" : false, - "DoNotUseSemicolons" : true, - "DontRepeatTypeInStaticProperties" : true, - "FileScopedDeclarationPrivacy" : true, - "FullyIndirectEnum" : true, - "GroupNumericLiterals" : true, - "IdentifiersMustBeASCII" : true, - "NeverForceUnwrap" : false, - "NeverUseForceTry" : false, - "NeverUseImplicitlyUnwrappedOptionals" : false, - "NoAccessLevelOnExtensionDeclaration" : true, - "NoBlockComments" : true, - "NoCasesWithOnlyFallthrough" : true, - "NoEmptyTrailingClosureParentheses" : true, - "NoLabelsInCasePatterns" : true, - "NoLeadingUnderscores" : false, - "NoParensAroundConditions" : true, - "NoVoidReturnOnFunctionSignature" : true, - "OneCasePerLine" : true, - "OneVariableDeclarationPerLine" : true, - "OnlyOneTrailingClosureArgument" : true, - "OrderedImports" : true, - "ReturnVoidInsteadOfEmptyTuple" : true, - "UseLetInEveryBoundCaseVariable" : true, - "UseShorthandTypeNames" : true, - "UseSingleLinePropertyGetter" : true, - "UseSynthesizedInitializer" : true, - "UseTripleSlashForDocumentationComments" : true, - "ValidateDocumentationComments" : false - }, - "tabWidth" : 8, - "version" : 1 -} From 03050113118acd6647f2638a05f36bfb97871db2 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 22 Dec 2021 18:41:07 -0700 Subject: [PATCH 3/7] indent nested logs (#243) (#244) Co-authored-by: Tyler Vick <1395852+tylervick@users.noreply.github.com> --- .../Classes/Models/ResultFile.swift | 4 +- .../Classes/Protocols/EmittableOutput.swift | 39 ++++++++++--------- 2 files changed, 23 insertions(+), 20 deletions(-) diff --git a/Sources/XCTestHTMLReportCore/Classes/Models/ResultFile.swift b/Sources/XCTestHTMLReportCore/Classes/Models/ResultFile.swift index ec407aa8..8f7f4964 100644 --- a/Sources/XCTestHTMLReportCore/Classes/Models/ResultFile.swift +++ b/Sources/XCTestHTMLReportCore/Classes/Models/ResultFile.swift @@ -78,7 +78,7 @@ class ResultFile { let fileManager = FileManager.default do { try? fileManager.removeItem(at: url) - try logSection.emittedOutput?.write(to: url, atomically: true, encoding: .utf8) + try logSection.formatEmittedOutput().write(to: url, atomically: true, encoding: .utf8) return relativeUrl.appendingPathComponent(fileName) } catch { Logger.warning("Can't write output to \(url). \(error.localizedDescription)") @@ -91,7 +91,7 @@ class ResultFile { Logger.warning("Can't get logss with id \(id)") return nil } - return logSection.emittedOutput?.data(using: .utf8) + return logSection.formatEmittedOutput().data(using: .utf8) } } diff --git a/Sources/XCTestHTMLReportCore/Classes/Protocols/EmittableOutput.swift b/Sources/XCTestHTMLReportCore/Classes/Protocols/EmittableOutput.swift index 538d2b65..8648f1c0 100644 --- a/Sources/XCTestHTMLReportCore/Classes/Protocols/EmittableOutput.swift +++ b/Sources/XCTestHTMLReportCore/Classes/Protocols/EmittableOutput.swift @@ -9,30 +9,33 @@ import Foundation import XCResultKit protocol EmittableOutput { - var emittedOutput: String? { get } + func formatEmittedOutput() -> String } -extension ActivityLogUnitTestSection: EmittableOutput {} +extension ActivityLogUnitTestSection: EmittableOutput { + + // Recursively collect emitted output from each subsection, adding an additional indent to each nested log + // This is how test steps are formatted in Xcode, including the repeated log lines + func formatEmittedOutput() -> String { + "-------- \(title) --------\n" + + (emittedOutput ?? "") + + unitTestSubsections + .compactMap { + "\t" + $0.formatEmittedOutput() + .split(separator: "\n") + .joined(separator: "\n\t") + } + .joined(separator: "\n") + } +} extension ActivityLogSection: EmittableOutput { - var emittedOutput: String? { - return "\(title)\n\n" - + subsections - .compactMap { $0.emittedOutput } - .joined(separator: "\n") + func formatEmittedOutput() -> String { + "\(title)\n\n" + unitTestSubsections + .compactMap { $0.formatEmittedOutput() } + .joined(separator: "\n") } -} -extension ActivityLogMajorSection: EmittableOutput { - - var emittedOutput: String? { - let t = [title, subtitle].compactMap { $0 }.joined(separator: " - ") - return "\(t)\n\n" - + unitTestSubsections - .compactMap { $0.emittedOutput } - .joined(separator: "\n") - } } - From 0cfa3703c47b158293dd4cc0670dca7996226b93 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Fri, 7 Jan 2022 12:25:28 -0700 Subject: [PATCH 4/7] sync: main to next (#251) * indent nested logs (#243) * Update actions, remove xc 12.5 (#250) * update actions, remove xc 12.5 * Update cd.yml Co-authored-by: Tyler Vick <1395852+tylervick@users.noreply.github.com> --- .github/workflows/cd.yml | 12 +++++++----- .github/workflows/ci.yml | 16 +++++++++++----- .github/workflows/sync-next.yml | 2 +- 3 files changed, 19 insertions(+), 11 deletions(-) diff --git a/.github/workflows/cd.yml b/.github/workflows/cd.yml index a7427b20..1c0354c0 100644 --- a/.github/workflows/cd.yml +++ b/.github/workflows/cd.yml @@ -10,6 +10,8 @@ jobs: build: strategy: fail-fast: true + matrix: + arch: [ "arm64-apple-macosx", "x86_64-apple-macosx" ] runs-on: macos-11 steps: @@ -31,25 +33,25 @@ jobs: run: | [[ "$GITHUB_REF" =~ refs/tags ]] && VERSION=${GITHUB_REF/refs\/tags\//} || exit echo ::set-output name=version::${VERSION} - echo ::set-output name=archive_name::xchtmlreport-${VERSION}.zip + echo ::set-output name=archive_name::xchtmlreport-${VERSION}-${{ matrix.arch }}.zip - name: Build - run: swift build -v -c release + run: swift build -v -c release --triple ${{ matrix.arch }} - name: Sign run: | codesign --verbose --verify --options=runtime -f \ -s "Developer ID Application: Tyler Vick (${{ secrets.AC_TEAM_ID }})" \ - .build/x86_64-apple-macosx/release/xchtmlreport + .build/${{ matrix.arch }}/release/xchtmlreport - name: Verify run: | - codesign -vvv --deep --strict .build/x86_64-apple-macosx/release/xchtmlreport + codesign -vvv --deep --strict .build/${{ matrix.arch }}/release/xchtmlreport - name: Package run: | ditto -c -k \ - --keepParent ".build/x86_64-apple-macosx/release/xchtmlreport" \ + --keepParent ".build/${{ matrix.arch }}/release/xchtmlreport" \ ${{ steps.metadata.outputs.archive_name }} - name: Notarize diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 9531dda5..2f634525 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -1,4 +1,4 @@ -name: CD +name: CI on: push: @@ -11,9 +11,9 @@ jobs: strategy: fail-fast: true matrix: - xcode_version: [12.5, 13.0] + xcode_version: [ 13.0 ] runs-on: macos-11 - + steps: - uses: actions/checkout@v2 @@ -23,9 +23,15 @@ jobs: version: ${{ matrix.xcode_version }} - name: Build - run: swift build -v -c release + run: swift build -v -c release --arch arm64 --arch x86_64 + + - uses: ruby/setup-ruby@v1 + with: + ruby-version: 2.7 + bundler-cache: true + - run: gem install xcpretty - name: Test run: | ./prepareTestResults.sh - swift test -v + swift test -c release 2>&1 | xcpretty diff --git a/.github/workflows/sync-next.yml b/.github/workflows/sync-next.yml index fc18489a..5f67086d 100644 --- a/.github/workflows/sync-next.yml +++ b/.github/workflows/sync-next.yml @@ -1,4 +1,4 @@ -name: Sync \"next\" branch +name: Sync "next" branch on: push: From 10271840f5852ddbfe77e4ef84484728e9e5c530 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Fri, 7 Jan 2022 14:47:36 -0700 Subject: [PATCH 5/7] sync: main to next (#252) * indent nested logs (#243) * Tvick/mixed test status (#7) * add mixed result support * update html templates -S * gate retry test data to xcode 13 * properly gate... * skip test on xcode 12 * fix tests with new retry logic * NOT debug * hardcoded version bump * update actions, remove xc 12.5 * Update ci.yml * Update actions, remove xc 12.5 (#250) * update actions, remove xc 12.5 * Update cd.yml Co-authored-by: Tyler Vick <1395852+tylervick@users.noreply.github.com> Co-authored-by: tylervick --- .github/workflows/ci.yml | 4 +- .gitignore | 1 + Package.resolved | 4 +- Package.swift | 11 +- Sources/XCTestHTMLReport/main.swift | 2 +- .../Extensions/TimeInterval+Time.swift | 21 +- .../Classes/HTMLTemplates.swift | 102 ++++++-- .../Classes/Helpers/AttachmentHelpers.swift | 61 ----- .../Classes/Models/Activity.swift | 48 ++-- .../Classes/Models/Iteration.swift | 63 +++++ .../Classes/Models/JUnitReport.swift | 77 +++--- .../Classes/Models/Run.swift | 67 +++-- .../Classes/Models/RunDestination.swift | 11 +- .../Classes/Models/Summary.swift | 31 +-- .../Classes/Models/Test.swift | 228 +++++++++++++----- .../Classes/Models/TestSummary.swift | 41 ++-- .../Protocols/ContainingAttachment.swift | 12 + .../Classes/Protocols/HTML.swift | 26 +- .../Classes/Protocols/TestConforming.swift | 17 ++ Sources/XCTestHTMLReportCore/HTML/index.html | 50 +++- .../XCTestHTMLReportCore/HTML/iteration.html | 12 + Sources/XCTestHTMLReportCore/HTML/run.html | 1 + Sources/XCTestHTMLReportCore/HTML/test.html | 14 -- .../XCTestHTMLReportCore/HTML/testGroup.html | 9 + .../XCTestHTMLReportCore/HTML/test_case.html | 13 + .../HTML/test_case_with_iterations.html | 11 + .../FunctionalTests.swift | 2 + .../XCTestHTMLReportTests/SummaryTests.swift | 16 ++ .../SampleApp.xcodeproj/project.pbxproj | 6 + .../SampleAppUITests/RetryTests.swift | 43 ++++ createTemplates.sh | 21 +- prepareTestResults.sh | 28 ++- 32 files changed, 733 insertions(+), 320 deletions(-) delete mode 100644 Sources/XCTestHTMLReportCore/Classes/Helpers/AttachmentHelpers.swift create mode 100644 Sources/XCTestHTMLReportCore/Classes/Models/Iteration.swift create mode 100644 Sources/XCTestHTMLReportCore/Classes/Protocols/ContainingAttachment.swift create mode 100644 Sources/XCTestHTMLReportCore/Classes/Protocols/TestConforming.swift create mode 100644 Sources/XCTestHTMLReportCore/HTML/iteration.html delete mode 100644 Sources/XCTestHTMLReportCore/HTML/test.html create mode 100644 Sources/XCTestHTMLReportCore/HTML/testGroup.html create mode 100644 Sources/XCTestHTMLReportCore/HTML/test_case.html create mode 100644 Sources/XCTestHTMLReportCore/HTML/test_case_with_iterations.html create mode 100644 XCTestHTMLReportSampleApp/SampleAppUITests/RetryTests.swift diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 2f634525..e462ea7d 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -32,6 +32,8 @@ jobs: - run: gem install xcpretty - name: Test + env: + XCODE_VERSION: ${{ matrix.xcode_version }} run: | - ./prepareTestResults.sh + ./prepareTestResults.sh 2>&1 | xcpretty swift test -c release 2>&1 | xcpretty diff --git a/.gitignore b/.gitignore index b35b241b..a613528c 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,5 @@ TestResults* +RetryResults* .DS_Store /.build /Packages diff --git a/Package.resolved b/Package.resolved index a0ab2aee..56aa6a56 100644 --- a/Package.resolved +++ b/Package.resolved @@ -33,8 +33,8 @@ "repositoryURL": "https://github.com/davidahouse/XCResultKit.git", "state": { "branch": null, - "revision": "49eec74ea00687dccb55903c717905b822923172", - "version": "0.9.2" + "revision": "2fe24c2675432c4b8c8d7ab0364e2760190b6fea", + "version": "0.9.3" } } ] diff --git a/Package.swift b/Package.swift index 3c9bf5eb..60236e03 100644 --- a/Package.swift +++ b/Package.swift @@ -14,9 +14,7 @@ let package = Package( ], dependencies: [ .package(url: "https://github.com/onevcat/Rainbow.git", .upToNextMajor(from: "3.0.0")), - .package( - url: "https://github.com/davidahouse/XCResultKit.git", .upToNextMinor(from: "0.9.2") - ), + .package(url: "https://github.com/davidahouse/XCResultKit.git", .upToNextMinor(from: "0.9.3")), .package(url: "https://github.com/nacho4d/NDHpple.git", .upToNextMajor(from: "2.0.1")), .package( url: "https://github.com/apple/swift-argument-parser.git", .upToNextMajor(from: "1.0.0") @@ -39,7 +37,10 @@ let package = Package( .testTarget( name: "XCTestHTMLReportTests", dependencies: ["XCTestHTMLReport", "NDHpple"], - resources: [.copy("TestResults.xcresult")] - ), + resources: [ + .copy("TestResults.xcresult"), + .copy("RetryResults.xcresult"), + ] + ) ] ) diff --git a/Sources/XCTestHTMLReport/main.swift b/Sources/XCTestHTMLReport/main.swift index 7be8e808..eb5c92f4 100644 --- a/Sources/XCTestHTMLReport/main.swift +++ b/Sources/XCTestHTMLReport/main.swift @@ -4,7 +4,7 @@ import XCTestHTMLReportCore struct XcTestHtmlReport: ParsableCommand { static var configuration = CommandConfiguration(commandName: "xchtmlreport", - version: "2.1.1", + version: "2.2.1", shouldDisplay: true) @Argument(help: ArgumentHelp("results_arg_help".localized), diff --git a/Sources/XCTestHTMLReportCore/Classes/Extensions/TimeInterval+Time.swift b/Sources/XCTestHTMLReportCore/Classes/Extensions/TimeInterval+Time.swift index 825c7943..96cb0c20 100644 --- a/Sources/XCTestHTMLReportCore/Classes/Extensions/TimeInterval+Time.swift +++ b/Sources/XCTestHTMLReportCore/Classes/Extensions/TimeInterval+Time.swift @@ -8,23 +8,8 @@ import Foundation -extension TimeInterval -{ - var timeString: String - { - let ti = Int(self) - - let seconds = ti % 60 - let minutes = (ti / 60) % 60 - let hours = (ti / 3600) - - if hours > 0 { - return String(format: "%dh%0.2dm%0.2ds", hours, minutes, seconds) - } else if minutes > 0 { - return String(format: "%dm%0.2ds", minutes, seconds) - } - - return String(format: "%ds", seconds) +extension TimeInterval { + var formattedSeconds: String { + String(format: "%.2fs", self) } } - diff --git a/Sources/XCTestHTMLReportCore/Classes/HTMLTemplates.swift b/Sources/XCTestHTMLReportCore/Classes/HTMLTemplates.swift index 63218e35..30f282c8 100644 --- a/Sources/XCTestHTMLReportCore/Classes/HTMLTemplates.swift +++ b/Sources/XCTestHTMLReportCore/Classes/HTMLTemplates.swift @@ -265,23 +265,29 @@ struct HTMLTemplates .test-summary.succeeded .test-result-icon, .test-summary.skipped .test-result-icon, - .test-summary.failed .test-result-icon { + .test-summary.failed .test-result-icon, + .iteration.succeeded .test-result-icon, + .iteration.skipped .test-result-icon, + .iteration.failed .test-result-icon { margin-left: 28px; display: block; } .test-summary.succeeded .test-result-icon, + .iteration.succeeded .test-result-icon, .success { background-image: url('data:image/png;base64,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'); } .test-summary.skipped .test-result-icon, + .iteration.skipped .test-result-icon, .skip { background-image: url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAqgAAAKoCAYAAAC7uA1cAAAABGdBTUEAALGPC/xhBQAAADhlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAAqACAAQAAAABAAACqKADAAQAAAABAAACqAAAAAAaWPVkAABAAElEQVR4Ae3decyl1Z0f+IdaoDAUUFCYYjc7tsEr3tmKxet42p5MWwZjW0qnJ4qUP/qP6W4lPYmsREkUJ9Lkj0hR1OlI2CwW7R53D9PesF1eaBu38dpeWQ2YxTZQbIZiK+acF27x3rfe5S7PcpbPlUp3e55zfufzu1V8ee69z20aFwIECBCYSeC5557b5xOf+MQBO3bs2DTTAHYiQIAAgWUF9ln2UQ8SIECgYoFrrrlm32eeeebE8OeUEEJP2WeffU4JHCeHP4eF+weG683hsXh9QAyp4boJ958NV4+F+4+F60fD/Xh9X/hzc7h98+7du2/esGHDzZdeeuld4f7u8LgLAQIECKwgIKCuAONhAgTqEbjyyiuPf/bZZ88NKz4v/DknhMwYRtd1JPBkCKj/EP58PYz/tf322+/6D3zgAw92NJdhCRAgkKWAgJpl2xRNgMA8AldcccVB4Yjm74UxLg5/zg2B9Ph5xptn3xBUw/TP/UMY4+vr16//7NFHH33d9u3bn5lnTPsSIEAgdwEBNfcOqp8AgYkE4udE77rrrneHjS8NgfA94TrJz42GwHp/qO0vw/XVl1122fUxwE60QBsRIECgIAEBtaBmWgoBAnsLfPKTn4xv2f/j8Mz/Fq4P2nuLpB+5a926dZ/auHHjf//gBz94a9KVKo4AAQItCgioLWIaigCBNARCEI3frv9fw9HHPw2335JGVXNVEb9U9enwJauPf+hDH/ruXCPZmQABAhkICKgZNEmJBAhMJhC/ff/EE09cFrb+4/Dn9Mn2ym6rL4ejqv/xwx/+8HXZVa5gAgQITCggoE4IZTMCBNIViEdMw1v5Hw3X/y5UeVS6lbZa2XfDEeI/+shHPnJ9q6MajAABAgkICKgJNEEJBAjMLhDeyj8r7P1fQzh90+yj5LtnCKlXhs+o/skll1xyT76rUDkBAgTGBQTUcQ/3CBDIROCqq67a+vTTT/+HUG78AlRX5yzNQiOE1PijAP9206ZN/yWcU/WpLIpWJAECBFYREFBXwfEUAQJpCoS38/9JOGL68fBnS5oVDlNVCKo3hZn/wNv+w/iblQCB9gQE1PYsjUSAQMcC4UtQB+/atevPQzD9/Y6nynb4EFLjT65+LHyJ6t+H235SNdtOKpxA3QICat39t3oC2QiEz5rGz5heHcLpCdkUPWChIZx+Jfy5LATVewcsw9QECBCYSaDqz23NJGYnAgR6FQiBdJ/LL7/8j8P1N4TTyemD1QXh51x/GH7W9V2T72VLAgQIpCHgCGoafVAFAQLLCFx77bUv2blz56dC2HrvMk97aAKBcBQ18D33bz760Y9+bILNbUKAAIEkBATUJNqgCAIElgqEo6aHhcf+v/DnzUufc396gRBU/zx8y/+fhW/5x8+ouhAgQCBpAW/xJ90exRGoUyB83vS4sPJ4AnrhtKWXQDiK+ofhC2af3rFjx6aWhjQMAQIEOhNwBLUzWgMTIDCLQAinZ4Qw9fmw79Gz7G+f1QXCkdTrN2/e/N73v//9D62+pWcJECAwnICAOpy9mQkQWCIQwunZIZxeGx4+ZMlT7rYoEELqj8OvT73Dr0+1iGooAgRaFRBQW+U0GAECswqEk++fE8Lp58KfA2Ydw36TC4SQelMIqduF1MnNbEmAQH8CAmp/1mYiQGAFAeF0BZiOHxZSOwY2PAECMwsIqDPT2ZEAgTYEhNM2FGcfQ0id3c6eBAh0JyCgdmdrZAIE1hAQTtcA6ulpIbUnaNMQIDCxgIA6MZUNCRBoU0A4bVNz/rGE1PkNjUCAQHsCAmp7lkYiQGBCAeF0QqieNxNSewY3HQECKwoIqCvSeIIAgS4EhNMuVNsbU0htz9JIBAjMLiCgzm5nTwIEphQQTqcEG2hzIXUgeNMSILBHQEDdQ+EGAQJdCginXeq2P7aQ2r6pEQkQmFxAQJ3cypYECMwoIJzOCDfwbkLqwA0wPYGKBQTUiptv6QT6EBBO+1Dubg4htTtbIxMgsLKAgLqyjWcIEJhTQDidEzCR3YXURBqhDAIVCQioFTXbUgn0KSCc9qnd/VxCavfGZiBA4EUBAfVFC7cIEGhJQDhtCTKxYYTUxBqiHAIFCwioBTfX0ggMISCcDqHe35xCan/WZiJQs4CAWnP3rZ1AywLCacugiQ4npCbaGGURKEhAQC2omZZCYEgB4XRI/f7nFlL7NzcjgZoEBNSaum2tBDoSEE47gk18WCE18QYpj0DGAgJqxs1TOoEUBITTFLowXA1C6nD2ZiZQsoCAWnJ3rY1AxwLCacfAmQwvpGbSKGUSyEhAQM2oWUolkJKAcJpSN4avRUgdvgcqIFCSgIBaUjethUBPAsJpT9CZTSOkZtYw5RJIWEBATbg5SiOQooBwmmJX0qlJSE2nFyohkLOAgJpz99ROoGcB4bRn8EynE1IzbZyyCSQkIKAm1AylEEhZQDhNuTvp1SakptcTFRHISUBAzalbaiUwkIBwOhB85tMKqZk3UPkEBhQQUAfENzWBHASE0xy6lG6NQmq6vVEZgZQFBNSUu6M2AgMLCKcDN6CQ6YXUQhppGQR6FBBQe8Q2FYGcBITTnLqVfq1Cavo9UiGBlAQE1JS6oRYCiQgIp4k0orAyhNTCGmo5BDoUEFA7xDU0gRwFhNMcu5ZPzUJqPr1SKYEhBQTUIfXNTSAxAeE0sYYUWo6QWmhjLYtAiwICaouYhiKQs4BwmnP38qtdSM2vZyom0KeAgNqntrkIJCognCbamMLLElILb7DlEZhDQECdA8+uBEoQEE5L6GK+axBS8+2dygl0KSCgdqlrbAKJCwiniTeokvKE1EoabZkEphAQUKfAsimBkgSE05K6mf9ahNT8e2gFBNoUEFDb1DQWgUwEhNNMGlVZmUJqZQ23XAKrCAioq+B4ikCJAsJpiV0tZ01Cajm9tBIC8wgIqPPo2ZdAZgLCaWYNq7RcIbXSxls2gUUCAuoiDDcJlCwgnJbc3fLWJqSW11MrIjCNgIA6jZZtCWQqIJxm2rjKyxZSK38BWH7VAgJq1e23+BoEhNMaulzuGoXUcntrZQRWExBQV9PxHIHMBYTTzBuo/AUBIdULgUB9AgJqfT234koEhNNKGl3JMoXUShptmQReEBBQvRQIFCggnBbYVEtqhFQvAgL1CAio9fTaSisREE4raXSlyxRSK228ZVcnIKBW13ILLllAOC25u9Y2EhBSRxKuCZQrIKCW21srq0xAOK2s4ZUvV0it/AVg+cULCKjFt9gCaxAQTmvosjUuFRBSl4q4T6AcAQG1nF5aSaUCwmmljbfsBQEh1QuBQJkCAmqZfbWqSgSE00oabZmrCgipq/J4kkCWAgJqlm1TNIGmEU69Cgi8KCCkvmjhFoESBATUErpoDdUJCKfVtdyCJxAQUidAsgmBTAQE1EwapUwCIwHhdCThmsDeAkLq3iYeIZCjgICaY9fUXK2AcFpt6y18CgEhdQosmxJIVEBATbQxyiKwVEA4XSriPoGVBYTUlW08QyAHAQE1hy6psXoB4bT6lwCAGQSE1BnQ7EIgEQEBNZFGKIPASgLC6UoyHiewtoCQuraRLQikKCCgptgVNRF4QUA49VIgML+AkDq/oREI9C0goPYtbj4CEwoIpxNC2YzABAJC6gRINiGQkICAmlAzlEJgJCCcjiRcE2hPQEhtz9JIBLoWEFC7FjY+gSkFhNMpwWxOYAoBIXUKLJsSGFBAQB0Q39QElgoIp0tF3CfQvoCQ2r6pEQm0LSCgti1qPAIzCginM8LZjcAMAkLqDGh2IdCjgIDaI7apCKwkIJyuJONxAt0JCKnd2RqZwLwCAuq8gvYnMKeAcDonoN0JzCEgpM6BZ1cCHQoIqB3iGprAWgLC6VpCnifQvYCQ2r2xGQhMKyCgTitmewItCQinLUEahkALAkJqC4iGINCigIDaIqahCEwqIJxOKmU7Av0JCKn9WZuJwFoCAupaQp4n0LKAcNoyqOEItCggpLaIaSgCcwgIqHPg2ZXAtALC6bRitifQv4CQ2r+5GQksFRBQl4q4T6AjAeG0I1jDEuhAQEjtANWQBKYQEFCnwLIpgVkFhNNZ5exHYDgBIXU4ezMTEFC9Bgh0LCCcdgxseAIdCgipHeIamsAqAgLqKjieIjCvgHA6r6D9CQwvIKQO3wMV1CcgoNbXcyvuSUA47QnaNAR6EBBSe0A2BYFFAgLqIgw3CbQlIJy2JWkcAukICKnp9EIl5QsIqOX32Ap7FhBOewY3HYEeBYTUHrFNVbWAgFp1+y2+bQHhtG1R4xFIT0BITa8nKipPQEAtr6dWNJCAcDoQvGkJDCAgpA6AbsqqBATUqtptsV0JCKddyRqXQLoCQmq6vVFZ/gICav49tIKBBYTTgRtgegIDCgipA+KbumgBAbXo9lpc1wLCadfCxieQvoCQmn6PVJifgICaX89UnIiAcJpII5RBIAEBITWBJiihKAEBtah2WkxfAsJpX9LmIZCPgJCaT69Umr6AgJp+j1SYmIBwmlhDlEMgIQEhNaFmKCVrAQE16/Ypvm8B4bRvcfMRyE9ASM2vZypOT0BATa8nKkpUQDhNtDHKIpCggJCaYFOUlJWAgJpVuxQ7lIBwOpS8eQnkKyCk5ts7lQ8vIKAO3wMVJC4gnCbeIOURSFhASE24OUpLWkBATbo9ihtaQDgdugPmJ5C/gJCafw+toH8BAbV/czNmIiCcZtIoZRLIQEBIzaBJSkxKQEBNqh2KSUVAOE2lE+ogUI6AkFpOL62kewEBtXtjM2QmIJxm1jDlEshIQEjNqFlKHVRAQB2U3+SpCQinqXVEPQTKExBSy+upFbUvIKC2b2rETAWE00wbp2wCGQoIqRk2Tcm9CgiovXKbLFUB4TTVzqiLQLkCQmq5vbWy+QUE1PkNjZC5gHCaeQOVTyBjASE14+YpvVMBAbVTXoOnLiCcpt4h9REoX0BILb/HVji9gIA6vZk9ChEQTgtppGUQKEBASC2giZbQqoCA2iqnwXIREE5z6ZQ6CdQjIKTW02srXVtAQF3byBaFCQinhTXUcggUJCCkFtRMS5lLQECdi8/OuQkIp7l1TL0E6hMQUuvruRXvLSCg7m3ikUIFhNNCG2tZBAoUEFILbKolTSUgoE7FZeNcBYTTXDunbgL1Cgip9fbeyptGQPUqKF5AOC2+xRZIoFgBIbXY1lrYGgIC6hpAns5bQDjNu3+qJ0AgHEnaZ5+bNm7cuP2SSy65hweBWgQE1Fo6XeE6hdMKm27JBAoVEFILbaxlrSggoK5I44mcBYTTnLundgIElhMQUpdT8VipAgJqqZ2teF3CacXNt3QChQsIqYU32PL2CAioeyjcKEFAOC2hi9ZAgMBqAkLqajqeK0VAQC2lk9bRCKdeBAQI1CIgpNbS6XrXKaDW2/uiVi6cFtVOiyFAYAIBIXUCJJtkKyCgZts6hY8EhNORhGsCBGoTEFJr63g96xVQ6+l1kSsVTotsq0URIDCFgJA6BZZNsxEQULNplUKXCginS0XcJ0CgVgEhtdbOl7tuAbXc3ha9MuG06PZaHAECMwgIqTOg2SVZAQE12dYobCUB4XQlGY8TIFC7gJBa+yugnPULqOX0soqVCKdVtNkiCRCYQ0BInQPPrskICKjJtEIhawkIp2sJeZ4AAQLPCwipXgm5CwiouXewkvqF00oabZkECLQmIKS2RmmgAQQE1AHQTTmdgHA6nZetCRAgMBIQUkcSrnMTEFBz61hl9QqnlTXccgkQaF1ASG2d1IA9CAioPSCbYjYB4XQ2N3sRIEBgqYCQulTE/dQFBNTUO1RpfcJppY23bAIEOhMQUjujNXAHAgJqB6iGnE9AOJ3Pz94ECBBYSUBIXUnG46kJCKipdaTyeoTTyl8Alk+AQOcCQmrnxCZoQUBAbQHREO0ICKftOBqFAAECawkIqWsJeX5oAQF16A6Yf0FAOPVCIECAQL8CQmq/3mabTkBAnc7L1h0ICKcdoBqSAAECEwgIqRMg2WQQAQF1EHaTjgSE05GEawIECAwjIKQO427W1QUE1NV9PNuhgHDaIa6hCRAgMIWAkDoFlk17ERBQe2E2yVIB4XSpiPsECBAYVkBIHdbf7OMCAuq4h3s9CAinPSCbggABAjMICKkzoNmlEwEBtRNWg64kIJyuJONxAgQIpCEgpKbRh9qrEFBrfwX0uH7htEdsUxEgQGAOASF1Djy7tiIgoLbCaJC1BITTtYQ8T4AAgbQEhNS0+lFbNQJqbR0fYL3C6QDopiRAgEALAkJqC4iGmElAQJ2JzU6TCgink0rZjgABAmkKCKlp9qX0qgTU0js84PqE0wHxTU2AAIEWBYTUFjENNZGAgDoRk42mFRBOpxWzPQECBNIWEFLT7k9p1QmopXU0gfUIpwk0QQkECBDoQEBI7QDVkMsKCKjLsnhwVgHhdFY5+xEgQCAPASE1jz7lXqWAmnsHE6pfOE2oGUohQIBAhwJCaoe4hl4QEFC9EFoREE5bYTQIAQIEshEQUrNpVZaFCqhZti2tooXTtPqhGgIECPQlIKT2JV3fPAJqfT1vdcXCaaucBiNAgEB2AkJqdi3LomABNYs2pVmkcJpmX1RFgACBvgWE1L7Fy59PQC2/x52sUDjthNWgBAgQyFZASM22dUkWLqAm2Za0ixJO0+6P6ggQIDCUgJA6lHx58wqo5fW00xUJp53yGpwAAQLZCwip2bcwiQUIqEm0IY8ihNM8+qRKAgQIDC0gpA7dgfznF1Dz72EvKxBOe2E2CQECBIoREFKLaeUgCxFQB2HPa1LhNK9+qZYAAQKpCAipqXQivzoE1Px61mvFwmmv3CYjQIBAcQJCanEt7WVBAmovzHlOIpzm2TdVEyBAIDUBITW1jqRfj4Cafo8GqVA4HYTdpAQIEChWQEgttrWdLExA7YQ170GF07z7p3oCBAikKiCkptqZ9OoSUNPryaAVCaeD8pucAAECxQsIqcW3uJUFCqitMJYxiHBaRh+tggABAqkLCKmpd2j4+gTU4XuQRAXCaRJtUAQBAgSqERBSq2n1TAsVUGdiK2sn4bSsfloNAQIEchEQUnPpVP91Cqj9myc1o3CaVDsUQ4AAgeoEhNTqWj7RggXUiZjK3Eg4LbOvVkWAAIHcBITU3DrWfb0CavfGSc4gnCbZFkURIECgWgEhtdrWL7twAXVZlrIfFE7L7q/VESBAIFcBITXXzrVft4DavmnSIwqnSbdHcQQIEKheQEit/iWwACCgVvQ6EE4raralEiBAIGMBITXj5rVUuoDaEmTqwwinqXdIfQQIECCwWEBIXaxR320BtYKeC6cVNNkSCRAgUKCAkFpgUydckoA6IVSumwmnuXZO3QQIECAQBYTUOl8HAmrBfRdOC26upREgQKAiASG1oma/sFQBtdCeC6eFNtayCBAgUKmAkFpX4wXUAvstnBbYVEsiQIAAAW/3V/QaEFALa7ZwWlhDLYcAAQIExgQcSR3jKPaOgFpQa4XTgpppKQQIECCwooCQuiJNMU8IqIW0UjgtpJGWQYAAAQITCQipEzFlu5GAmm3rXixcOH3Rwi0CBAgQqEdASC231wJq5r0VTjNvoPIJECBAYC4BIXUuvmR3FlCTbc3ahQmnaxvZggABAgTKFxBSy+uxgJppT4XTTBunbAIECBDoREBI7YR1sEEF1MHoZ59YOJ3dzp4ECBAgUK6AkFpObwXUzHopnGbWMOUSIECAQK8CQmqv3J1NJqB2Rtv+wMJp+6ZGJECAAIHyBITU/HsqoGbSQ+E0k0YpkwABAgSSEBBSk2jDzEUIqDPT9bejcNqftZkIECBAoBwBITXfXgqoifdOOE28QcojQIAAgaQFhNSk27NicQLqijTDPyGcDt8DFRAgQIBA/gJCan49FFAT7ZlwmmhjlEWAAAECWQoIqXm1TUBNsF/CaYJNURIBAgQIZC8gpObTQgE1sV4Jp4k1RDkECBAgUJSAkJpHOwXUhPoknCbUDKUQIECAQLECQmr6rRVQE+mRcJpII5RBgAABAlUICKlpt1lATaA/wmkCTVACAQIECFQnIKSm23IBdeDeCKcDN8D0BAgQIFC1gJCaZvsF1AH7IpwOiG9qAgQIECDwgoCQmt5LQUAdqCfC6UDwpiVAgAABAssICKnLoAz4kIA6AL5wOgC6KQkQIECAwBoCQuoaQD0+LaD2iB2nEk57BjcdAQIECBCYQkBInQKrw00F1A5xlw4tnC4VcZ8AAQIECKQnIKQO3xMBtaceCKc9QZuGAAECBAi0ICCktoA4xxAC6hx4k+4qnE4qZTsCBAgQIJCOgJA6XC8E1I7thdOOgQ1PgAABAgQ6FBBSO8RdZWgBdRWceZ8STucVtD8BAgQIEBheQEjtvwcCakfmwmlHsIYlQIAAAQIDCAip/aILqB14C6cdoBqSAAECBAgMLCCk9tcAAbVla+G0ZVDDEehZIPwHqHnpS1/aHHXUUc2hhx7aHHjggc3GjRub9evXN+vWrVuoZvfu3c2zzz7bPPXUU81jjz3W7Ny5s7nnnnua3/zmN81zzz3Xc8WmK1lgw4YNzZYtW5qDDz64Oeigg5oDDjhg4fU4ek3G1+HTTz+98Od3v/td88gjjzQPP/zwwmvymWeeKZlmsLUJqf3QC6gtOgunLWIaikCPAvE//K985SsXQulLXvKSJobUWS4xnD7++OMLYfXHP/5x8+ijj84yjH0qFzj88MObo48+utm2bVuzdevWPf9jNA1L/J+o+++/v7nvvvuau+++u/ntb387ze62XUNASF0DqIWnZ/tXuIWJSxtCOC2to9ZTukA8MnXGGWc0p5xySrP//vt3stwnnniiufnmm5sYVh3N6oS4mEHj/xidfPLJzYknnrhwpLTthcUjq7fddltzyy23LPxPVNvj1ziekNpt1wXUFnyF0xYQDUGgJ4H99tuvef3rX78QBEZv2Xc9dXwb9vbbb2+++93vNk8++WTX0xk/I4H4EZL4P0onnXTSwsdIui49vhZvvfXWhf9pih9PcZlPQEidz2+1vQXU1XQmeE44nQDJJgQSEIhv27/mNa9ZeCu/r2C6dNnxbdd4NPWHP/yhz6ouxansfvwM6Wtf+9rm1FNPnekt/Hm54mvxpptuar7//e8vfH513vFq3l9I7ab7AuocrsLpHHh2JdCjwBFHHNGcd955zaZNm3qcdeWpdu3a1Xz1q19d+FLVylt5plSBE044oTnrrLM6+2jJNG7xYyg33njjwhH+afaz7biAkDru0cY9AXVGReF0Rji7EehZIL6d/4pXvGLmLz51VW78QtVPf/rThbf9u5rDuGkJxM89v/nNb174eElalTULn0+94YYbfFZ6jsYIqXPgLbOrgLoMyloPCadrCXmewPAC8bOmF1988cKpooavZuUKHnjggea6665bOGXVylt5JneBeJqo888/f+F0UamuJZ6eKh7Zj9cuswkIqbO5LbeXgLqcyiqPCaer4HiKQCIC8RvR7373u5t4ncMlnr/yc5/7nG9X59CsGWqMp4264IILmvg/Talf4pf4vvKVrzgt1RyNElLnwFu0q4C6CGOtm8LpWkKeJzC8QDyn6bve9a4swsBirXjS/89+9rMLJ1pf/LjbeQvEH3yIR07j2/u5XOIp0eKR1PjjEy6zCQips7kt3uv5n0VZ/IjbywoIp8uyeJBAUgKjI6c5HKlaCrfvvvtmddR3af3u7y0Qf5Est3AaVxHDdKw71u8ym0D4jPmp4Re+dlx99dVHzTaCvQTUCV4DwukESDYhMLBADHjvec97mnid66WENeRq33bdhxxyyMLb+jkdOV1sEOuOH0uI63CZTUBInc1ttJeAOpJY4Vo4XQHGwwQSE4jhtKtfhOpzqXENcS0u+QrEc5zGcJfz/yxF/Vh/XEdcj8tsAkLqbG5xLwF1FTvhdBUcTxFISOCiiy5qNm/enFBF85US1/L2t799vkHsPZjA2972tib+QlQJl7iOuB6X2QWE1NnsBNQV3ITTFWA8TCAxgTe+8Y1N/CJKaZdt27YJBhk29bTTTmuOO+64DCtfueS4nrgul9kFhNTp7QTUZcyE02VQPEQgQYH4G+ann356gpW1U1L8ffbXve517QxmlM4F4scz4s+XlniJ6yrhIzRD9kZInU5fQF3iJZwuAXGXQKICr3zlK6sIbzGEx1/DcklfIP58ae6fO11JOa4rrs9lPgEhdXI/AXWRlXC6CMNNAgkLxHBaU2iL633DG96QcEeUtnXr1uaEE04oGiKuL67TZT4BIXUyPwH1BSfhdLIXjK0IDC1QWzgdeb/85S8XUkcYCV6/6lWvSrCq9kuqZZ3ty42PKKSOeyx3T0ANKsLpci8NjxFIT6DWcDrqRAyp8UthLmkJbNmypTnmmGPSKqqjauI643pd5hcQUlc3rD6gCqerv0A8SyAVgdrD6agP8Uthb3nLW0Z3XScgUPIX9ZbjrW29yxm09ZiQurJk1QFVOF35heEZAikJCKfj3TjllFOE1HGSwe6tX7++Of744webf4iJ43rjul3aERBSl3esNqAKp8u/IDxKIDUB4XT5jsSQ+ta3vnX5Jz3am8Cxxx5b7Df3V0KM3+iP63ZpT0BI3duyyoAqnO79QvAIgRQFhNPVu3LyySc3Z5999uobebZTgdJOyj8pVq3rntRnlu2E1HG16gKqcDr+AnCPQKoCwulknTnxxBMXQuo+++wz2Q62alXgiCOOaHW8XAardd1d90dIfVG4qoAqnL7YeLcIpCwgnE7XHSF1Oq+2tj7kkEOq/XWl+KtScf0u7QsIqc+bVhNQhdP2/xIZkUAXAsLpbKrxJOrnnntu40jqbH6z7FX7SetrX/8sr5lJ9xFSm6aKgCqcTvpXwnYEhhUQTufzj9+uFlLnM5xm74MPPniazYvbtvb1d93Q2kNq8QFVOO36r5DxCbQjIJy24xhD6nnnndesW1f8P+/tgM0xykEHHTTH3vnvWvv6++hgzSG16H/BhNM+/vqYg8D8AsLp/IaLR4jfsBZSF4t0c3vz5s3dDJzJqLWvv6821RpSiw2owmlff3XMQ2A+AeF0Pr+V9o7nqTz//PMdSV0JqIXHN27c2MIo+Q5R+/r77FyNIbXIgCqc9vnXxlwEZhcQTme3m2TP+Lvp27dvF1InwZphm9oDWu3rn+ElM9cutYXU4gKqcDrX69/OBHoTEE77oT766KObCy64wE9TdsC9YcOGDkbNZ8ja1z9Ep2oKqUUFVOF0iL8u5iQwvYBwOr3ZPHscddRRQuo8gCvsW/sX0Wpf/wovi84friWkFhNQhdPO/06YgEArAsJpK4xTD3LkkUc2F154YeOo19R0diCQnEANIbWIgCqcJvd3R0EElhUQTpdl6e3Bbdu2Cam9aZuIQLcCpYfU7AOqcNrtXwCjE2hLQDhtS3K+ceJvqF900UWOpM7HaG8CSQiUHFKzDqjCaRJ/PxRBYE0B4XRNol43eOlLX7oQUn0Lu1d2kxHoRKDUkJptQBVOO3mdG5RA6wLCaeukrQwYQ+rFF1/cCKmtcBqEwKACJYbULAOqcDro3wOTE5hYQDidmGqQDbdu3boQUvfdd99B5jcpAQLtCZQWUrMLqMJpey9mIxHoUkA47VK3vbGF1PYsjURgaIGSQmpWAVU4Hfqlb34CkwkIp5M5pbLVYYcd1rz97W9v9ttvv1RKUgcBAjMKlBJSswmowumMr1S7EehZQDjtGbyl6Q499FAhtSVLwxAYWqCEkJpFQBVOh36pm5/AZALC6WROqW61ZcuWhZC6adOmVEtUFwECEwrkHlKTD6jC6YSvRJsRGFhAOB24AS1NL6S2BGkYAgkI5BxSkw6owmkCr24lEJhAQDidACmjTQ455JDmHe94R7P//vtnVLVSCRBYTiDXkJpsQBVOl3uZeYxAegLCaXo9aaOigw8+eOHtfiG1DU1jEBhWIMeQmmRAFU6HfSGbncCkAsLppFJ5bhdDajyS+pKXvCTPBaiaAIE9ArmF1OQCqnC657XkBoGkBYTTpNvTWnEHHXTQQkg94IADWhvTQAQIDCOQU0hNKqAKp8O8YM1KYFoB4XRasby337x5s5CadwtVT2CPQC4hNZmAKpzuee24QSBpAeE06fZ0VtyBBx64EFLjtQsBAnkL5BBSkwiowmneL3TV1yMgnNbT6+VWKqQup+IxAnkKpB5SBw+owmmeL2xV1ycgnNbX8+VWHD+L+s53vrOJb/u7ECCQt0DKIXXQgCqc5v3CVn09AsJpPb2eZKXxW/3x2/3xC1QuBAjkLZBqSB0soAqneb+gVV+PgHBaT6+nWekopMZTUbkQIJC3QIohdZCAKpzm/UJWfT0Cwmk9vZ5lpfEk/m9/+9sbIXUWPfsQSEsgtZDae0AVTtN6QaqGwEoCwulKMh5fLBBDany7P/48qgsBAnkLpBRSew2owmneL1zV1yMgnNbT6zZWumnTpoUjqVu2bGljOGMQIDCgQCohtbeAKpwO+GozNYEpBITTKbBsukcghtSLL764OfTQQ/c85gYBAnkKpBBSewmowmmeL1BV1ycgnNbX8zZXLKS2qWksAsMKDB1SOw+owumwLzCzE5hUQDidVMp2qwnst99+C2/3H3bYYatt5jkCBDIQGDKkdhpQhdMMXn1KJBAEhFMvgzYF9t1334W3+7du3drmsMYiQGAAgaFCamcBVTgd4FVkSgIzCAinM6DZZU2BGFIvuuii5vDDD19zWxsQIJC2wBAhtZOAKpym/UJTHYGRgHA6knDdhcAopL70pS/tYnhjEiDQo0DfIbX1gCqc9vhqMRWBOQSE0znw7DqxwMaNG5sLL7ywEVInJrMhgWQF+gyprQbUT3ziE2eH4j8X/hyQrK7CCBDwmVOvgV4FYkiNb/cfccQRvc5rMgIE2hfoK6S2FlBDOD0jFH2tcNr+i8GIBNoUcOS0TU1jTSqwYcOGhSOp27Ztm3QX2xEgkKhAHyG1lYAawulxodjPB0e/dZfoi0lZBKKAcOp1MKRADKkXXHBBc+SRRw5ZhrkJEGhBoOuQOndAvfzyyw8LRX4hrPXoFtZrCAIEOhIQTjuCNexUAqOQetRRR021n40JEEhPoMuQOldAvfbaa1+yzz77/G0gOz09NhURIDASEE5HEq5TEFi/fn2zffv25uijHddIoR9qIDCPQFchdeaAGgraZ+fOnZ8K12+aZ2H2JUCgWwHhtFtfo88mEEPq+eef3xxzzDGzDWAvAgSSEXghpH7hM5/5TGsf9Zw5oIbPnf6foaD3JqOjEAIE9hIQTvci8UBCAqOQeuyxxyZUlVIIEJhFIGTCMx599NFrd+zYsWmW/ZfuM1NAvfLKK98YBvp3SwdznwCBdASE03R6oZKVBdatW9ecd955zXHHHbfyRp4hQCALgRBSz77rrruuvuaaa9bPW/DUATVMevCzzz77qTDxxnkntz8BAt0ICKfduBq1G4EYUs8999zm+OOP72YCoxIg0JtACKnv27Vr13+bd8KpA2qY9M/D5CfMO7H9CRDoRkA47cbVqN0KxJB6zjnnNC972cu6ncjoBAh0LhBy4h+Gszx9bJ6Jpgqo4WdM/0mY9PfnmdC+BAh0JyCcdmdr5O4FYkg9++yzmxNOcAyke20zEOhWIJzl6V9fccUV75p1lokD6lVXXbU1hNOPzzqR/QgQ6FZAOO3W1+j9CIxC6kknndTPhGYhQKATgZAZ9wkfCb08HNyc6Zc5Jg6oTz/99H8Ik23pZBUGJUBgLgHhdC4+OycmEI68NG9961ubk08+ObHKlEOAwJQCh4fseEX4M3HeHI0/0Q7hlFJnhR3+8Wgn1wQIpCMgnPbbi3BEoN8JK50thtS3vOUtzSmnnFKpgGUTKEMghNMLwlHUfzntatYMqGHgfcKg/zX8WXPbaSe3PQEC8wkIp/P5Tbv3d7/73ebzn/9889RTT027q+1nEIgh9c1vfnNz6qmnzrC3XQgQSEjgY+Fg59nT1LNm6Ayp96MhpPq1qGlUbUugBwHhtAfkRVPEcPqTn/ykeeCBB5ovfvGLzZNPPrnoWTe7Eogh9U1velNz2mmndTWFcQkQ6Fgg5Mh4XtS/CKcq3XfSqVYNqHGgMKgT8k+qaTsCPQkIpz1BvzDNKJyOZn3wwQeb6667TkgdgXR8PQqpp59+esczGZ4Aga4EQp48NZyq9I8mHX/VgPrEE09cFgY6atLBbEeAQPcCwmn3xotnWBpOR8/FkBqPpIZ/cEcPue5Y4I1vfGPz8pe/vONZDE+AQIcC/+rqq6+eKFeuGFBD0o2fPf3jDos0NAECUwoIp1OCzbn5SuF0NOzOnTuF1BFGT9dveMMbmle84hU9zWYaAgTaFAjZ8sBwVqiJTlm6YkANJ1f9vVCU91Pa7IyxCMwhIJzOgTfDrmuF09GQDz30UPOFL3yhCe84jR5y3bHAWWed1Zxxxhkdz2J4AgS6EAgh9UOTfGFqxYC6e/fuP+2iMGMSIDC9gHA6vdk8e0waTkdzPPzwwwtHUoXUkUj316973euaM888s/uJzECAQOsCIaT+l7UGXTaghm/unxN2fPNaO3ueAIHuBYTT7o0XzzBtOB3tG0NqPJL6+OOPjx5y3bHAa1/72uZVr3pVx7MYngCBDgReH7LmxauNu2xADTv8wWo7eY4AgX4EhNN+nEezzBpOR/s/8sgjQuoIo6fr17zmNc2rX/3qnmYzDQECbQms9U79XgF1x44dm8Kh1/e3VYBxCBCYTUA4nc1t1r3mDaejeR999NGFk/n/7ne/Gz3kumOBGFDj0VQXAgSyErjwyiuvfP1KFe8VUH/1q1+9JwTUg1baweMECHQvIJx2b7x4hrbC6WjMxx57bOFIarx26Ucgfh41fi7VhQCBfATCT0ev+H2nvQJqCKeX5LM0lRIoT0A47benbYfTUfVC6kiiv+v4zf7Xv37FAzL9FWImAgQmEgiZ8x996lOfOmm5jccCaji11EFh4/cst6HHCBDoXkA47d548QxdhdPRHPFt/vjFqfi2v0s/AvHvUDwNlQsBAlkIrAvnRf2ny1U6FlBDOH1f2GjTcht6jACBbgWE0259l47edTgdzTcKqfELVC79CMQT+ccT+rsQIJC+QPiy1AdD/ow/DjV2WRpQLxp71h0CBHoREE57Yd4zSV/hdDRhPPVUPJIaT0Xl0o9A/EnUN73pTf1MZhYCBOYRODa8g3/20gHGAmp48tylG7hPgEC3AsJpt75LR+87nI7mjyfx/+IXvyikjkB6uD7ttNOaN7/ZKb17oDYFgbkEwhHUvb7/tCeghq/6Hx82OH6uGexMgMBUAsLpVFxzbzxUOB0VHkNqPJIafx7VpR+BU089tXnLW97Sz2RmIUBgVoHfD6c53bB45z0BNXzV39HTxTJuE+hYQDjtGHjJ8EOH01E5u3btWjiSunPnztFDrjsWOOWUU5q3vvWtHc9ieAIEZhUIB0i33n333WO/LLUnoIZBz5t1YPsRIDCdgHA6nde8W6cSTkfrEFJHEv1dn3zyyc3b3va2/iY0EwECUwmEA6XvXrzD4oB6zuIn3CZAoBsB4bQb15VGTS2cjup88sknF46kPvjgg6OHXHcscNJJJzVnn312s88+e31huOOZDU+AwAQCY+/kLwTUa665Zt9wePXkCXa2CQECcwgIp3PgzbBrquF0tJRRSH3ggQdGD7nuWODEE08UUjs2NjyBWQTC/zieGfLooaN9FwLqM888c2J4YPHR1NHzrgkQaElAOG0JcsJhUg+no2U89dRTzXXXXdfcf//9o4dcdyxwwgknNOecc44jqR07G57ANALhQOk+4X/a95xuahRQT5lmENsSIDCdgHA6nde8W+cSTkfrFFJHEv1dv+xlL2vOPfdcIbU/cjMRmERgz/ehFgJqSK0C6iRstiEwg4BwOgPaHLvkFk5HSw0/97dwJPU3v/nN6CHXHQscf/zxzXnnndesW+cNxI6pDU9gIoGQR/d8DnXhb2V4319AnYjORgSmExBOp/Oad+tcw+lo3TGkfulLX2qE1JFI99fHHXeckNo9sxkITCQQAuqZ4c9CNh39b6MvSE1EZyMCkwsIp5NbtbFl7uF0ZBC+E7AQUn/961+PHnLdscCxxx7bnH/++Y6kduxseAITCOx31VVXHRu3GwXUwybYySYECEwoIJxOCNXSZqWE0xFHDKlf/vKXm/vuu2/0kOuOBY455phm+/btQmrHzoYnsJZA+Pdv4V39UUDdvNYOnidAYDIB4XQyp7a2Ki2cjlxGIfXee+8dPeS6Y4Gjjz66ueCCC5r169d3PJPhCRBYSSB8JvzFgBre7z9wpQ09ToDA5ALC6eRWbWxZajgd2YRfVmm+8pWvNPfcc8/oIdcdCxx11FFCasfGhiewmkDIpC8G1PAlKQF1NS3PEZhAQDidAKnFTUoPpyOqUUgNv1M9esh1xwJHHnlkc+GFFzYbNmzoeCbDEyCwjMDzATUk1fibbwcss4GHCBCYUEA4nRCqpc1qCacjrt27dzc7duxofvWrX40ect2xwLZt24TUjo0NT2AFgW3x8XWf/OQnX/JCSF1hOw8TILCagHC6mk77z9UWTkeCMaR+9atfbe66667RQ647FjjiiCOaiy66yJHUjp0NT2CJwML3otaF02s8u+QJdwkQmFBAOJ0QqqXNag2nI74YUr/2ta81d9555+gh1x0LvPSlL10IqRs3bux4JsMTIBAFRt+LWhdOq7ErfAZVSPW6IDClgHA6Jdicm9ceTkd8o5B6xx13jB5y3bFADKkXX3xxI6R2DG14AkFg9L2o0WmmHqNCgMDkAsLp5FZtbCmcjiuGIwzN17/+9eaXv/zl+BPudSawdevWhZC67777djaHgQkQWBBY+OL+QkAN/9gJqF4VBCYUEE4nhGppM+F0ecgYUr/xjW80t99++/IbeLR1ASG1dVIDEthLIPzbtj58KXTTQkANh1MF1L2IPEBgbwHhdG+TLh8RTlfXjSH1+uuvb2677bbVN/RsawKHHXZY8/a3v73Zb7/9WhvTQAQIjAuEL4OuH73F/+j4U+4RILBUQDhdKtLtfeF0Mt9RSL311lsn28FWcwsceuihCyF17oEMQIDAXgLhoOlzH/7whx8fBVQ/+LwXkQcIvCggnL5o0cct4XR65b/7u79rbrnllul3tMdMAlu2bJlpPzsRILCmwO9iSB0F1JvX3NwGBCoVEE77bbxwOrv3N7/5zebmm/1zPrugPQkQGFogvCu08LHT0WdQ/Ys2dEfMn6SAcNpvW4TT+b2/9a1vNTfddNP8AxmBAAECwwgsfOx0IaCG8+oJqMM0wawJCwin/TZHOG3P+4Ybbmh+8YtftDegkQgQINCTwOiL+wsBdcOGDQJqT/CmyUNAOO23T8Jp+97f/va3m5///OftD2xEAgQIdCvwQBx+IaBeeuml8cedn+x2PqMTyENAOO23T8Jpd95///d/3/z0pz/tbgIjEyBAoH2BhW97jj6DujscUv2H9ucwIoG8BITTfvslnHbvfeONNzY/+clPup/IDAQIEGhBIHxJauFd/YWAGscLAfXrLYxrCALZCgin/bZOOO3PO1r/+Mc/7m9CMxEgQGBGgZBHxwNqGOdrM45lNwLZCwin/bZQOO3XO872ve99r/mHf/BGWf/yZiRAYBqB0fei9hxBDT/bdn1Irc9NM4htCZQgIJz220XhtF/vxbN9//vfb370ox8tfshtAgQIpCSwOwTUhd9u3hNQP/CBDzwY3vf3v9cptUktnQsIp50Tj00gnI5xDHLnBz/4QRP/uBAgQCA1gXCg9JaQR5+Kde0JqC8U6XOoqXVLPZ0JCKed0S47sHC6LMsgD8ajqPFoqgsBAgQSE/jGqJ6xgLp+/frPjp5wTaBkAeG03+4Kp/16TzJb/Dxq/FyqCwECBBIS2PN9qLGAevTRR18XDq/en1ChSiHQuoBw2jrpqgMKp6vyDPpk/GZ/7I8LAQIEUhAIB0r3vJM/FlC3b9/+TCjwL1MoUg0EuhAQTrtQXXlM4XRlm1SeiedI/c53vpNKOeogQKBSgXCA9I4PfehDd4yWPxZQ44Nhg6tHT7omUJKAcNpvN4XTfr3nme1nP/tZE391yoUAAQIDCuw5ehpr2CugXnbZZdeHx+NPn7oQKEZAOO23lcJpv95tzPbzn/+8+fa3v92Es7m0MZwxCBAgMK3AdYt32CughiOoz61bt+5Tizdym0DOAsJpv90TTvv1bnO2X/ziF0Jqm6DGIkBgUoFdIXv+zeKN9wqo8cmNGzf+93C1e/GGbhPIUUA47bdrwmm/3l3MdtNNNzU33HCDI6ld4BqTAIFlBcLB0b8N7+A/svjJZQPqBz/4wVvDRp9evKHbBHITEE777Zhw2q93l7PdfPPNzbe+9S0htUtkYxMgsFjgqsV34u1lA2p8IvzU1MfjtQuBHAWE0367Jpz2693HbLfcckvzzW9+U0jtA9scBCoWCEdPHzn22GP3Og//igE1fNU/nhzvyxWbWXqmAsJpv40TTvv17nO2W2+9tbn++uub3bt94qtPd3MRqEzg/wmnOd21dM0rBtS4YfjA6n9cuoP7BFIWEE777Y5w2q/3ELPdfvvtQuoQ8OYkUI/AXyy31FUD6oc//OH4lX8/M7KcnMeSExBO+22JcNqv95Cz/fKXv2y+8Y1vOJI6ZBPMTaBAgfD2/rc+8pGPxNOb7nVZNaDGrcPOf7TXXh4gkJiAcNpvQ4TTfr1TmO2OO+5ovv71rwupKTRDDQQKEQjnXV7xnfo1A2pMtiGkXlmIhWUUKCCc9ttU4bRf75Rmu/POO5uvfe1rQmpKTVELgXwFfh4y5v+7UvlrBtS4Yzgv6p+EkPrYSoN4nMBQAsJpv/LCab/eKc521113NV/96lebZ599NsXy1ESAQD4C/ylkyxV/um6igHrJJZfcE9b7b/NZs0prEBBO++2ycNqvd8qz/epXvxJSU26Q2gikL3DP/vvvf8VqZU4UUOMAmzZt+i8h6d602mCeI9CXgHDal/Tz8win/XrnMNvdd9/d7Nixw5HUHJqlRgKJCYQ8+Wcf+MAHnlqtrIkD6gsD/UEY1Ps6q4l6rnMB4bRz4rEJhNMxDncWCdxzzz3NV77yFSF1kYmbBAisLhBy5LfDWaIuX32rVX5JarkdXzgVwMeWe85jBPoQEE77UH5xDuH0RQu3lhe49957my9/+cvNM888s/wGHiVAgMCLAvFXP/55CKkrfvZ0tOnER1BHO4TU++/DwF8Z3XdNoC8B4bQv6efnEU779c55tvvuu09IzbmBaifQn8D/DAc7b5xkuqkDaginu8Ofy8Lgv51kAtsQaENAOG1DcfIxhNPJrWz5vMCvf/3r5ktf+lLz9NNPIyFAgMBeAiE77gxnhfoXez2xwgNTB9Q4TjiKeu/69es/GiZb8xDtCvN6mMDEAsLpxFStbCictsJY5SC/+c1vFo6kCqlVtt+iCawqEDLjn1x66aX3r7rRoidnCqhx/8suu+xz4RcA/s2isdwk0LqAcNo66aoDCqer8nhyAoEYUuOR1KeeWvULuhOMZBMCBAoSuCYc3Pwf06xn5oAaJ/noRz/6sZCI/3yaCW1LYFIB4XRSqXa2E07bcTRK+PzXb38rpHohECCwIBBy4u3hnKf/x7QccwXUOFk4P+o/C5P/9bQT257AagLC6Wo67T8nnLZvWvuI999/f3Pdddc5klr7C8H6axeIH0q/JJyq9OFpIeYOqGHSZ4899thLQki9ftrJbU9gOQHhdDmV7h4TTruzrX3kBx54oPniF7/YPPnkk7VTWD+BWgX+LHxr/9uzLH7ugBon3b59+67Nmze/N4TUH89ShH0IjASE05FEP9fCaT/ONc/y4IMPLhxJ3bVrV80M1k6gOoGQCa8N4fQ/z7rwVgJqnPz973//Q+H0Ae8IBfk51Fm7Ufl+wmm/LwDhtF/vmmcTUmvuvrVXKnDDli1bPhgy4cxne2otoMYGXHLJJfeEkLpdSK305TjHsoXTOfBm2FU4nQHNLnMJ7Ny5c+HtfkdS52K0M4EcBH4eivxf3vve9z4+T7GtBtRYiJA6Tzvq3Fc47bfvwmm/3mZ7UeChhx5qvvCFLzRPPPHEiw+6RYBASQJ3h4OU7whneXpg3kW1HlBjQULqvG2pZ/+Xv/zlzetf//p6FjzwSoXTgRtg+ubhhx9eOJIqpHoxEChO4KEQTt8ZPnd6Zxsr6ySgxsKE1DbaU/YYJ5xwQnPWWWeVvciEViecJtSMykuJITUeSX388bneAaxc0fIJpCMQgunvwp/3hnDa2pflOwuokU1ITefFk1olRx55ZPO2t72tCS/o1Eorsh7htMi2Zr2oRx55REjNuoOKJ/C8wAvh9F0hnLZ6utENXQPHkHr11VdvD7/NvCP8NOqpXc9n/PQFXvKSlzTnnntus25dp/9/lD5ETxUKpz1BzzHNIYcc0mzdurU5+OCDm4MOOqgJp+1rwhdOF/5s2LDB35U5bO1KgEB3AqNwGn7G9Bttz9J5QI0FC6ltty3f8eIR03POOafZb7/98l1ERpULp2k2a/369U34gZOFP9u2bWvCzwCmWaiqCBAgsIJAl+E0TtlLQI0TCalRweWMM85ojjjiCBA9CAinPSBPOUU4L2Bz+umnN8cff3yz7777Trm3zQkQIJCGQNfhNK6yt4AaJxNSo0K9lwMOOKA588wz6wXoceXCaY/YE0wV376Pr/141NSFAAECOQv0EU6jT+8fAowh1cn8c35pzl57/MZ+/DydS7cCwmm3vtOMHt+6jx9pefe73y2cTgNnWwIEkhToK5zGxfceUOOkQmpUqOty+OGHL7ytWdeq+1+tcNq/+Uoznnbaac3v/d7vNfF0ai4ECBDIXaDPcBqtBgmocWIhNSrUc4mfPXXpVkA47dZ30tHjt+/PP//85k1vepPPmU6KZjsCBJIW6DucRozBAmqcXEiNCuVf4qlzjjnmmPIXOuAKhdMB8RdNHU8XFX5/ujnuuOMWPeomAQIE8hUYIpxGrUEDaixASI0KZV/iW53hBV72IgdcnXA6IP6iqePHWN7xjnc0Bx544KJH3SRAgEC+AkOF0yg2eECNRQipUaHMSwym8ZQ6Lt0ICKfduE476lFHHdVcfPHFzu87LZztCRBIVmDIcBpRkgiosRAhNSqUd3ES8u56Kpx2ZzvNyPEUUvEzp85QMY2abQkQSFlg6HAabZIJqLEYITUqlHVx3sdu+imcduM67ajxZ0kvvPBC4XRaONsTIJCsQArhNOIkFVBjQUJqVCjn4lej2u+lcNq+6SwjxiOm27dv97b+LHj2IUAgSYFUwmnESS6gxqKE1KiQ/yX+lGP8VrNLewLCaXuW844UTyMVz1DhQoAAgRIEUgqn0TPJgBoLE1KjQt6Xww47zLf3W2yhcNoi5pxDxZPvn3TSSXOOYncCBAikIZBaOI0qyQbUWJyQGhXyvcTP57m0IyCctuPYxijxRPzxZ3tdCBAgUIJAiuE0uiYdUGOBQmpUyPOyefPmPAtPrGrhNK2GvPa1r23233//tIpSDQECBGYQSDWcxqUkH1BjkUJqVMjvcsABB+RXdGIVC6dpNSSehP/UU09NqyjVECBAYAaBlMNpXE4WATUWKqRGhbwuzgs5X7+E0/n8utj7jDPOaNaty+afzS4IjEmAQAECqYfTSJzVv7RCal5/K+Jn9VxmExBOZ3Prcq/4tr4vRnUpbGwCBPoQyCGcRoesAmosWEiNCnlcHGmarU/C6WxuXe91yimnNOvXr+96GuMTIECgM4FcwmkEyC6gxqKF1KiQ/uWZZ55Jv8jEKhROE2vIonJOPPHERffcJECAQF4COYXT+MmL1gAAIYtJREFUKJtlQI2FC6lRIe3L008/nXaBiVUnnCbWkEXlbN26tXHatEUgbhIgkJVAbuE04mYbUGPxQmpUSPcioE7eG+F0cqshtjzmmGOGmNacBAgQmFsgx3AaF511QI0LEFKjQpqXRx99NM3CEqtKOE2sIcuUs23btmUe9RABAgTSFsg1nEbV7ANqXISQGhXSuzzyyCPpFZVYRcJpYg1Zppx4urT4Fr8LAQIEchLIOZxG5yICalyIkBoV0ro8/PDDaRWUWDXCaWINWaGcLVu2OPfpCjYeJkAgTYHcw2lULSagxsUIqVEhncvOnTsbn0Ndvh/C6fIuKT7qy1EpdkVNBAisJFBCOI1rKyqgxgUJqVEhjctzzz3X/Pa3v02jmISqEE4TasYEpRx88METbGUTAgQIDC9QSjiNksUF1LgoITUqpHG577770igkkSqE00QaMUUZBxxwwBRb25QAAQLDCJQUTqNgkQE1LkxIjQrDX+64447hi0ikAuE0kUZMWYaf7J0SzOYECPQuUFo4jYDFBtS4OCE1Kgx7iaeauv/++4ctIoHZhdMEmjBjCQLqjHB2I0CgF4ESw2mEKzqgxgUKqVFh2Mttt902bAEDzy6cDtyAOadfv379nCPYnUCZAvF7Bi7DCpQaTqNq8QE1LlJIjQrDXW655ZbmySefHK6AAWcWTgfEb2nqZ599tqWRDEOgLAEBddh+lhxOo2wVATUuVEiNCsNcnnnmmeYXv/jFMJMPOKtwOiB+i1M7VVqLmIYqSmD37t1FrSenxZQeTmMvqgmocbFCalQY5vKzn/2sqnOiCqfDvM66mFVA7ULVmCUICKjDdLGGcBplqwqoccFCalTo/xLf4v/hD3/Y/8QDzCicDoDe4ZS/+93vOhzd0ATyFdi1a1e+xWdaeS3hNLanuoAaFy2kRoX+L/Eoauk/fyqc9v+66nrG0l+zXfsZv1yBeJYWl/4EagqnUbXKgBoXLqRGhX4v8QP13/rWt5pS3xYSTvt9PfU12yOPPNLXVOYhkJXAgw8+mFW9ORdbWziNvao2oMbFC6lRod/Lb37zm+ZHP/pRv5P2MJtw2gPyQFPs3Lmz2P+pGojUtIUI3HnnnYWsJO1l1BhOY0eqDqgRQEiNCv1eYkC99957+520w9mE0w5xExg6noXCj00k0AglJCUQT7/2wAMPJFVTicXUGk5jL6sPqBFBSI0K/V6+9rWvNQ899FC/k3Ywm3DaAWqCQ953330JVqUkAsMJ+Pxp9/Y1h9OoK6C+8BoTUrv/y7Z4hqeeeqr50pe+1OT8DWnhdHFHy779q1/9quwFWh2BKQVuv/32Kfew+TQCtYfTaCWgLnrFCKmLMHq4+fjjjzfXXXdddiE1ftnrO9/5TvOTn/ykByVTpCAQ3+L3ZakUOqGGFATiv4E//elPUyilyBqE0+fbKqAueXkLqUtAOr4b/6P/uc99Lpu3++MZCK6//vomnjLLpS6B2267ra4FWy2BFQTit/f9BPAKOHM+LJy+CCigvmix55aQuoeilxvxSOrnP//55L84FX9s4Mtf/nLjra1eXhbJTXLzzTf7j3JyXVHQEALf+973hpi2+DmF0/EWC6jjHnvuCal7KHq5ET+TGt/u/8EPfpDkKX1+/etfN9dee23yIbqXZlU6yRNPPNHceuutla7esgk8L/DYY4/5d7CDF4NwujeqgLq3yZ5HhNQ9FL3diKeg+uIXv5jML07FUwx9//vfX6gpHul1qVvgxz/+cZL/A1V3V6y+T4H4+XuXdgWE0+U991n+YY8uFrj66quPevrpp3eED4afuvhxt7sTCH9hm5e//OXNq1/96mbjxo3dTbTKyHfccUdz4403ZvclrlWW5KkWBN74xjc2p59+egsjGYJAXgLxOwN//dd/nVfRiVcrnK7cIAF1ZZuxZ4TUMY7e7uy3334LQfW0005r4u2uL/HbqfGUQvFI2W9/+9uupzN+hgLxf5je9773Nfvvv3+G1SuZwGwC8d/Gv/mbv3E2i9n4lt1LOF2WZc+DAuoeirVvCKlrG3W1xYYNG5qTTz65OfHEE5utW7e2Pk38fGE8YvqLX/wimY8XtL5IA7YmcMIJJzTnnHNOa+MZiEDqArfcckvzzW9+M/Uys6lPOF27VQLq2kZjWwipYxyD3Nm8eXNz/PHHN9u2bWsOP/zwmT4CEI8GxF+yil9+uuuuu5r4S0HxMRcCkwq87W1va0466aRJN7cdgWwF4g+q/NVf/VW29adWuHA6WUcE1MmcxrYSUsc4Br0T/qI3W7ZsaQ4++ODmoIMOamJ4jW/Bxj/xqGs8b2n4/HATv+wU/5GNP88XP0cVf0M6njnAhcCsAvH19Z73vGfhtTfrGPYjkLpA/Df005/+dLNr167US82iPuF08jYJqJNbjW0ppI5xuEOgSoH4P0Xvete7evl8dJXAFj2oQHxXaceOHQufyx+0kEImF06na6TTTE3ntWdrp6DaQ+EGgWoF4tH4+OMN8Qi9C4GSBGI4veGGG4TTlpoqnE4PKaBOb7ZnDyF1D4UbBKoVuP/++5uvfvWrQmq1r4DyFh7DaTz/c/z1NJf5BYTT2Qy9xT+b29he3u4f43CHQJUC8Qt7F1xwgbf7q+x+OYseHTkVTtvpqXA6u6OAOrvd2J5C6hiHOwSqFDjkkEMWQuqBBx5Y5fotOm+B+IWo+G5APBe0y/wCwul8hgLqfH5jewupYxzuEKhSIJ5BIp6C6rjjjqty/Radp0A8y8lnP/vZJp4T2mV+AeG0BcP5hzDCYgEhdbGG2wTqFYi/fvba17622XfffetFsPLkBeJb+rfeequT8LfYKeG0HUxHUNtxHBtFSB3jcIdAtQLx51DPOuusJv7ylAuB1ARGZ6GI54d2aUdAOG3HMY4ioLZnOTaSkDrG4Q6BqgXiz/OeeeaZzbHHHlu1g8WnIfDYY481N954Y3PnnXemUVAhVQin7TZSQG3Xc2w0IXWMwx0C1QvEXz07/fTTF36q11v/1b8cegWIb+U/+OCDzfe+973m3nvv7XXuGiYTTtvvsoDavunYiELqGIc7BAgEgfXr1y8cTY1HVLdt29bEjwK4EGhbIH4rP76N/8tf/rL5yU9+0jz77LNtT2G8ICCcdvMyEFC7cR0bVUgd43CHAIElAvH0VPFjAAcffHATfz518+bNTTwbQPyzYcOGZt06v6myhMzdIBCPisY/MYjGP7t27Wri50njkdL49v0DDzzAqWMB4bQ7YAG1O9uxkYXUMQ53CBAgQIBA1gLCabftE1C79R0bXUgd43CHAAECBAhkKSCcdt82AbV747EZhNQxDncIECBAgEBWAsJpP+0SUPtxHptFSB3jcIcAAQIECGQhIJz21yYBtT/rsZmE1DEOdwgQIECAQNICwmm/7RFQ+/Uem01IHeNwhwABAgQIJCkgnPbfFgG1f/OxGYXUMQ53CBAgQIBAUgLC6TDtEFCHcR+bVUgd43CHAAECBAgkISCcDtcGAXU4+7GZhdQxDncIECBAgMCgAsLpoPyNgDqs/9jsQuoYhzsECBAgQGAQAeF0EPaxSQXUMY7h7wipw/dABQQIECBQr4BwmkbvBdQ0+jBWhZA6xuEOAQIECBDoRUA47YV5okkE1ImY+t9ISO3f3IwECBAgUK+AcJpW7wXUtPoxVo2QOsbhDgECBAgQ6ERAOO2Eda5BBdS5+LrfWUjt3tgMBAgQIFCvgHCaZu8F1DT7MlaVkDrG4Q4BAgQIEGhFQDhthbGTQQTUTljbH1RIbd/UiAQIECBQr4BwmnbvBdS0+zNWnZA6xuEOAQIECBCYSUA4nYmt150E1F65559MSJ3f0AgECBAgUK+AcJpH7wXUPPo0VqWQOsbhDgECBAgQmEhAOJ2IKYmNBNQk2jB9EULq9Gb2IECAAIF6BYTTvHovoObVr7FqhdQxDncIECBAgMCyAsLpsixJPyigJt2etYsTUtc2sgUBAgQI1CsgnObZewE1z76NVS2kjnG4Q4AAAQIEFgSE03xfCAJqvr0bq1xIHeNwhwABAgQqFxBO834BCKh592+seiF1jMMdAgQIEKhUQDjNv/ECav49HFuBkDrG4Q4BAgQIVCYgnJbRcAG1jD6OrUJIHeNwhwABAgQqERBOy2m0gFpOL8dWIqSOcbhDgAABAoULCKdlNVhALaufY6sRUsc43CFAgACBQgWE0/IaK6CW19OxFQmpYxzuECBAgEBhAsJpYQ19YTkCapl9HVuVkDrG4Q4BAgQIFCIgnBbSyGWWIaAug1LiQ0JqiV21JgIECNQrIJyW3XsBtez+jq1OSB3jcIcAAQIEMhUQTjNt3BRlC6hTYJWwqZBaQhetgQABAvUKCKd19F5AraPPY6sUUsc43CFAgACBTASE00wa1UKZAmoLiDkOIaTm2DU1EyBAoF4B4bSu3guodfV7bLVC6hiHOwQIECCQqIBwmmhjOixLQO0QN4ehhdQcuqRGAgQI1CsgnNbZewG1zr6PrVpIHeNwhwABAgQSERBOE2nEAGUIqAOgpzilkJpiV9REgACBegWE03p7H1cuoNbd/7HVC6ljHO4QIECAwEACwulA8AlNK6Am1IwUShFSU+iCGggQIFCvgHBab+8Xr1xAXazh9oKAkOqFQIAAAQJDCAinQ6inOaeAmmZfBq9KSB28BQogQIBAVQLCaVXtXnOxAuqaRPVuIKTW23srJ0CAQJ8Cwmmf2nnMJaDm0afBqhRSB6M3MQECBKoQEE6raPPUixRQpyarbwchtb6eWzEBAgT6EBBO+1DOcw4BNc++9V61kNo7uQkJECBQtIBwWnR7516cgDo3YT0DCKn19NpKCRAg0KWAcNqlbhljC6hl9LG3VQipvVGbiAABAkUKCKdFtrX1RQmorZOWP6CQWn6PrZAAAQJdCAinXaiWOaaAWmZfO1+VkNo5sQkIECBQlIBwWlQ7O1+MgNo5cbkTCKnl9tbKCBAg0KaAcNqmZh1jCah19LmzVQqpndEamAABAkUICKdFtLH3RQiovZOXN6GQWl5PrYgAAQJtCAinbSjWOYaAWmffW1+1kNo6qQEJECCQtYBwmnX7Bi9eQB28BeUUIKSW00srIUCAwDwCwuk8evaNAgKq10GrAkJqq5wGI0CAQHYCwml2LUuyYAE1ybbkXZSQmnf/VE+AAIFZBYTTWeXst1RAQF0q4n4rAkJqK4wGIUCAQDYCwmk2rcqiUAE1izblWaSQmmffVE2AAIFpBYTTacVsv5aAgLqWkOfnEhBS5+KzMwECBJIXEE6Tb1GWBQqoWbYtr6KF1Lz6pVoCBAhMKiCcTiplu2kFBNRpxWw/k4CQOhObnQgQIJCsgHCabGuKKExALaKNeSxCSM2jT6okQIDAWgLC6VpCnp9XQECdV9D+UwkIqVNx2ZgAAQLJCQinybWkyIIE1CLbmvaihNS0+6M6AgQIrCQgnK4k4/G2BQTUtkWNN5GAkDoRk40IECCQjIBwmkwrqihEQK2izWkuUkhNsy+qIkCAwFIB4XSpiPtdCwioXQsbf1UBIXVVHk8SIEBgcAHhdPAWVFmAgFpl29NatJCaVj9UQ4AAgZGAcDqScN23gIDat7j5lhUQUpdl8SABAgQGExBOB6M3cRAQUL0MkhEQUpNphUIIEKhcQDit/AWQwPIF1ASaoIQXBYTUFy3cIkCAwBACwukQ6uZcKiCgLhVxf3ABIXXwFiiAAIFKBYTTShuf4LIF1ASboqSmEVK9CggQINCvgHDar7fZVhcQUFf38eyAAkLqgPimJkCgKgHhtKp2Z7FYATWLNtVbpJBab++tnACBfgSE036czTKdgIA6nZetBxAQUgdANyUBAlUICKdVtDnLRQqoWbatvqKF1Pp6bsUECHQrIJx262v0+QQE1Pn87N2jgJDaI7apCBAoWkA4Lbq9RSxOQC2ijfUsQkitp9dWSoBANwLCaTeuRm1XQEBt19NoPQgIqT0gm4IAgSIFhNMi21rkogTUItta/qKE1PJ7bIUECLQrIJy262m0bgUE1G59jd6hgJDaIa6hCRAoSkA4LaqdVSxGQK2izeUuUkgtt7dWRoBAOwLCaTuORulXQEDt19tsHQgIqR2gGpIAgSIEhNMi2ljlIgTUKtte3qKF1PJ6akUECMwnIJzO52fvYQUE1GH9zd6igJDaIqahCBDIWkA4zbp9ig8CAqqXQVECQmpR7bQYAgRmEBBOZ0CzS3ICAmpyLVHQvAJC6ryC9idAIFcB4TTXzql7qYCAulTE/SIEhNQi2mgRBAhMISCcToFl0+QFBNTkW6TAWQWE1Fnl7EeAQG4CwmluHVPvWgIC6lpCns9aQEjNun2KJ0BgAgHhdAIkm2QnIKBm1zIFTysgpE4rZnsCBHIREE5z6ZQ6pxUQUKcVs32WAkJqlm1TNAECqwgIp6vgeCp7AQE1+xZawKQCQuqkUrYjQCB1AeE09Q6pb14BAXVeQftnJSCkZtUuxRIgsIyAcLoMioeKExBQi2upBa0lIKSuJeR5AgRSFRBOU+2MutoWEFDbFjVeFgJCahZtUiQBAosEhNNFGG4WLyCgFt9iC1xJQEhdScbjBAikJiCcptYR9XQtIKB2LWz8pAWE1KTbozgCBIKAcOplUKOAgFpj1615TEBIHeNwhwCBhASE04SaoZReBQTUXrlNlqqAkJpqZ9RFoF4B4bTe3lt5eOcAAgECzwsIqV4JBAikIiCcptIJdQwlIKAOJW/eJAWE1CTboigCVQkIp1W122JXEBBQV4DxcL0CQmq9vbdyAkMLCKdDd8D8qQgIqKl0Qh1JCQipSbVDMQSqEBBOq2izRU4oIKBOCGWz+gSE1Pp6bsUEhhIQToeSN2+qAgJqqp1RVxICQmoSbVAEgaIFhNOi22txMwoIqDPC2a0eASG1nl5bKYG+BYTTvsXNl4uAgJpLp9Q5qICQOii/yQkUKSCcFtlWi2pJQEBtCdIw5QsIqeX32AoJ9CUgnPYlbZ5cBQTUXDun7kEEhNRB2E1KoCgB4bSodlpMRwICakewhi1XQEgtt7dWRqBrAeG0a2HjlyIgoJbSSevoVUBI7ZXbZASKEBBOi2ijRfQkIKD2BG2a8gSE1PJ6akUEuhIQTruSNW6pAgJqqZ21rl4EhNRemE1CIGsB4TTr9il+IAEBdSB405YjIKSW00srIdC2gHDatqjxahEQUGvptHV2KiCkdsprcAJZCginWbZN0YkICKiJNEIZ+QsIqfn30AoItCUgnLYlaZxaBQTUWjtv3Z0ICKmdsBqUQFYCwmlW7VJsogICaqKNUVa+AkJqvr1TOYF5BYTTeQXtT+B5AQHVK4FABwJCageohiSQuIBwmniDlJeVgICaVbsUm5OAkJpTt9RKYD4B4XQ+P3sTWCogoC4VcZ9AiwJCaouYhiKQqIBwmmhjlJW1gICadfsUn4OAkJpDl9RIYDYB4XQ2N3sRWEtAQF1LyPMEWhAQUltANASBxASE08QaopyiBATUotppMSkLCKkpd0dtBKYTEE6n87I1gWkFBNRpxWxPYA4BIXUOPLsSSERAOE2kEcooWkBALbq9FpeigJCaYlfURGAyAeF0MidbEZhXQECdV9D+BGYQEFJnQLMLgYEFhNOBG2D6qgQE1KrabbEpCQipKXVDLQRWFxBOV/fxLIG2BQTUtkWNR2AKASF1CiybEhhIQDgdCN60VQsIqFW33+JTEBBSU+iCGggsLyCcLu/iUQJdCwioXQsbn8AEAkLqBEg2IdCzgHDaM7jpCCwSEFAXYbhJYEgBIXVIfXMTGBcQTsc93CPQt4CA2re4+QisIiCkroLjKQI9CQinPUGbhsAqAgLqKjieIjCEgJA6hLo5CTwvIJx6JRBIQ0BATaMPqiAwJiCkjnG4Q6AXAeG0F2aTEJhIQECdiMlGBPoXEFL7NzdjvQLCab29t/I0BQTUNPuiKgILAkKqFwKB7gWE0+6NzUBgWgEBdVox2xPoWUBI7RncdFUJCKdVtdtiMxIQUDNqllLrFRBS6+29lXcnIJx2Z2tkAvMKCKjzCtqfQE8CQmpP0KapQkA4raLNFpmxgICacfOUXp+AkFpfz624fQHhtH1TIxJoW0BAbVvUeAQ6FhBSOwY2fNECwmnR7bW4ggQE1IKaaSn1CAip9fTaStsTEE7bszQSga4FBNSuhY1PoCMBIbUjWMMWKSCcFtlWiypYQEAtuLmWVr6AkFp+j61wfgHhdH5DIxDoW0BA7VvcfARaFhBSWwY1XFECwmlR7bSYigQE1IqabanlCgip5fbWymYXEE5nt7MngaEFBNShO2B+Ai0JCKktQRqmCAHhtIg2WkTFAgJqxc239PIEhNTyempF0wsIp9Ob2YNAagICamodUQ+BOQWE1DkB7Z61gHCadfsUT2CPgIC6h8INAuUICKnl9NJKJhcQTie3siWB1AUE1NQ7pD4CMwoIqTPC2S1LAeE0y7YpmsCKAgLqijSeIJC/gJCafw+tYG0B4XRtI1sQyE1AQM2tY+olMKWAkDolmM2zEhBOs2qXYglMLCCgTkxlQwL5Cgip+fZO5SsLCKcr23iGQO4CAmruHVQ/gQkFhNQJoWyWhYBwmkWbFElgZgEBdWY6OxLIT0BIza9nKt5bQDjd28QjBEoTEFBL66j1EFhDQEhdA8jTSQsIp0m3R3EEWhMQUFujNBCBfASE1Hx6pdIXBYTTFy3cIlC6gIBaeoetj8AKAkLqCjAeTlJAOE2yLYoi0JmAgNoZrYEJpC8gpKbfIxU2jXDqVUCgPgEBtb6eWzGBMQEhdYzDncQEhNPEGqIcAj0JCKg9QZuGQMoCQmrK3am3NuG03t5bOQEB1WuAAIEFASHVCyElAeE0pW6ohUD/AgJq/+ZmJJCsgJCabGuqKkw4rardFktgWQEBdVkWDxKoV0BIrbf3KaxcOE2hC2ogMLyAgDp8D1RAIDkBITW5llRRkHBaRZstksBEAgLqREw2IlCfgJBaX8+HXLFwOqS+uQmkJyCgptcTFRFIRkBITaYVRRcinBbdXosjMJOAgDoTm50I1CMgpNbT6yFWKpwOoW5OAukLCKjp90iFBAYXEFIHb0GRBQinRbbVogi0IiCgtsJoEALlCwip5fe4zxUKp31qm4tAfgICan49UzGBwQSE1MHoi5pYOC2qnRZDoBMBAbUTVoMSKFdASC23t32sTDjtQ9kcBPIXEFDz76EVEOhdQEjtnbyICYXTItpoEQR6ERBQe2E2CYHyBITU8nra5YqE0y51jU2gPAEBtbyeWhGB3gSE1N6os55IOM26fYonMIiAgDoIu0kJlCMgpJbTyy5WIpx2oWpMAuULCKjl99gKCXQuIKR2TpzlBMJplm1TNIEkBATUJNqgCAL5Cwip+fewzRUIp21qGotAfQICan09t2ICnQkIqZ3RZjWwcJpVuxRLIEkBATXJtiiKQL4CQmq+vWujcuG0DUVjECAgoHoNECDQuoCQ2jppFgMKp1m0SZEEshAQULNokyIJ5CcgpObXs3kqFk7n0bMvAQJLBQTUpSLuEyDQmoCQ2hpl0gMJp0m3R3EEshQQULNsm6IJ5CMgpObTq1kqFU5nUbMPAQJrCQioawl5ngCBuQWE1LkJkxxAOE2yLYoiUISAgFpEGy2CQPoCQmr6PZqmQuF0Gi3bEiAwrYCAOq2Y7QkQmFlASJ2ZLqkdhdOk2qEYAkUKCKhFttWiCKQrIKSm25tJKhNOJ1GyDQEC8woIqPMK2p8AgakFhNSpyZLYQThNog2KIFCFgIBaRZstkkB6AkJqej1ZrSLhdDUdzxEg0LaAgNq2qPEIEJhYQEidmGrQDYXTQflNTqBKAQG1yrZbNIF0BITUdHqxXCXC6XIqHiNAoGsBAbVrYeMTILCmgJC6JtEgGwing7CblACBICCgehkQIJCEgJCaRBv2FCGc7qFwgwCBAQQE1AHQTUmAwPICQuryLn0/Kpz2LW4+AgSWCgioS0XcJ0BgUAEhdVD+Rjgd1t/sBAg8LyCgeiUQIJCcgJA6TEuE02HczUqAwN4CAureJh4hQCABASG13yYIp/16m40AgdUF1q3+tGcJECAwjMAll1xyz8aNG7eH4PTjYSqoataHwmrf+eEPf/gbVa3aYgkQSFbAEdRkW6MwAgSiwGc+85lDHn300Wufe+65s4l0InB3+J+Ad37kIx/xPwKd8BqUAIFZBATUWdTsQ4BArwI7duzYdNddd10dQur7ep24/Ml+HsLpO0I4vbP8pVohAQI5CXiLP6duqZVApQLbt2/ftWnTpv89hKk/r5Sgi2XfEAY9WzjtgtaYBAjMK+AI6ryC9idAoFeByy+//GMhqP7rcDTVv18zyge/a7ds2fLB9773vY/POITdCBAg0KmAf+A75TU4AQJdCFxxxRXvevbZZy8PYx/exfgFj/l0WNufhaOm/zmE1OcKXqelESCQuYCAmnkDlU+gVoFPfvKTR4ajqFeEPxfUajDNukMgvX39+vUf/NCHPvT30+xnWwIECAwhIKAOoW5OAgRaEQjhdF0Iqv8yDPaxcHt9K4MWOEgIp38ZPsP7hx/4wAceLnB5lkSAQIECAmqBTbUkArUJfOITn4inoPqLEFJPrW3tq603BNOd4c+fhPOb/o/VtvMcAQIEUhMQUFPriHoIEJhJ4Jprrtl3165dfxR2/lchqB440yDl7LQ7LOV/hh86+BeXXnrp/eUsy0oIEKhFQECtpdPWSaASgRd+IvXjIaR+qJIljy0zHDH9dnjgn4cvQt049oQ7BAgQyEhAQM2oWUolQGBygfDZ1HN27979f4c9Xj/5XllvGX8R6v8Kb+dfHq59Qz/rViqeAAEB1WuAAIGiBUJQvTgE1T8Ni7yw0IX+PKzrP+2///5XhC9BPVXoGi2LAIHKBATUyhpuuQRqFbjyyitfH86d+qfhrf9/FAyy/xW9cJT0W+HPxy+77LK/ccS01le1dRMoV0BALbe3VkaAwDICn/rUp056+umn/2k4qvrB8PSxy2yS7EMhiD4S/nwmFPgX4a38byRbqMIIECAwp4CAOieg3QkQyFMgHEndJ/wi1dnh+pKwgt8P11sTXcmuEEr/Nvy5+phjjvnb7du370q0TmURIECgNQEBtTVKAxEgkKvAjh07Ntx9990Xh48AvDus4dwQBs+MAXao9YT57whzfz1cfyn8+evwNv4jQ9ViXgIECAwhMNg/wEMs1pwECBCYRCCcU/XQJ598Mp78/7wQVM8Nf84Mt/ebZN8ZttkdQugtYb/4lv3Xws+Rfj38HGkMqC4ECBCoVkBArbb1Fk6AwKQCIaCuu+qqq4595plnTlm3bt0p4f4pYd94fWQIlweG6wPjdXgs3l74ydVwP57q6Xfh/mPh9mPh9qPhzwPhzy3hsZvDYzdv2LAh/rnNt++DigsBAgQIECBAgEA3AuHjApvCT68eEEKoAwDdEBuVAIEKBP5/KvtPm97Kp04AAAAASUVORK5CYII='); } .test-summary.failed .test-result-icon, + .iteration.failed .test-result-icon, .failure { background-image: url('data:image/png;base64,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'); } @@ -377,8 +383,12 @@ struct HTMLTemplates .tests > .summary { width: 100%; } + + .iteration { + margin-left: 10px; + } - .test-summary p, .test-summary-group p, .activity p { + .test-summary p, .test-summary-group p, .iteration p, .activity p { font-size: 12px; padding: 4px 4px 4px 52px; border-bottom: 1px solid #EEE; @@ -801,8 +811,14 @@ struct HTMLTemplates function toggle(el, id) { el.classList.toggle('dropped'); + var iterations = document.getElementById('iterations-'+id); var activities = document.getElementById('activities-'+id); var attachments = document.getElementById('attachments-'+id); + + if (iterations) { + iterations.style.display = (iterations.style.display == 'block' ? 'none' : 'block'); + } + if (activities) { activities.style.display = (activities.style.display == 'block' ? 'none' : 'block'); } @@ -894,6 +910,7 @@ struct HTMLTemplates showElementsWithSelector('.run.active .test-summary.succeeded'); showElementsWithSelector('.run.active .test-summary.skipped'); showElementsWithSelector('.run.active .test-summary.failed'); + showElementsWithSelector('.run.active .test-summary.mixed'); hideSummaryGroupsIfNeeded(); } @@ -902,6 +919,7 @@ struct HTMLTemplates showElementsWithSelector('.run.active .test-summary.succeeded'); hideElementsWithSelector('.run.active .test-summary.skipped'); hideElementsWithSelector('.run.active .test-summary.failed'); + hideElementsWithSelector('.run.active .test-summary.mixed'); hideSummaryGroupsIfNeeded(); } @@ -910,6 +928,7 @@ struct HTMLTemplates hideElementsWithSelector('.run.active .test-summary.succeeded'); showElementsWithSelector('.run.active .test-summary.skipped'); hideElementsWithSelector('.run.active .test-summary.failed'); + hideElementsWithSelector('.run.active .test-summary.mixed'); hideSummaryGroupsIfNeeded(); } @@ -918,6 +937,16 @@ struct HTMLTemplates hideElementsWithSelector('.run.active .test-summary.succeeded'); hideElementsWithSelector('.run.active .test-summary.skipped'); showElementsWithSelector('.run.active .test-summary.failed'); + hideElementsWithSelector('.run.active .test-summary.mixed'); + hideSummaryGroupsIfNeeded(); + } + + function showMixedScenariosOnly(el) { + selectedElement(el); + hideElementsWithSelector('.run.active .test-summary.succeeded'); + hideElementsWithSelector('.run.active .test-summary.skipped'); + hideElementsWithSelector('.run.active .test-summary.failed'); + showElementsWithSelector('.run.active .test-summary.mixed'); hideSummaryGroupsIfNeeded(); } @@ -977,6 +1006,7 @@ struct HTMLTemplates
  • Passed ([[N_OF_PASSED_TESTS]])
  • Skipped ([[N_OF_SKIPPED_TESTS]])
  • Failed ([[N_OF_FAILED_TESTS]])
    • +
  • Mixed ([[N_OF_MIXED_TESTS]])
    • Status
      • @@ -1001,22 +1031,62 @@ struct HTMLTemplates [[TESTS]] """ + + static let testCase = """ + [[SCREENSHOT_TAIL]] +
      + +

      + + + [[TITLE]] ([[DURATION]]) +

      +
      + [[SCREENSHOT_FLOW]] + [[ACTIVITIES]] +
      +
      + """ + + static let testCaseWithIterations = """ +
      + +

      + + + [[TITLE]] [[RESULT_STRING]] ([[DURATION]]) +

      +
      + [[ITERATIONS]] +
      +
      + """ + + static let testGroup = """ +
      + +

      + + + [[TITLE]] ([[DURATION]]) +

      + [[SUB_TESTS]] +
      + """ - static let test = """ - [[SCREENSHOT_TAIL]] -
      - -

      - - - [[NAME]] ([[TIME]]) -

      - [[SUB_TESTS]] -
      - [[SCREENSHOT_FLOW]] - [[ACTIVITIES]] + static let iteration = """ +
      + +

      + + + [[TITLE]] ([[DURATION]]) +

      +
      + [[SCREENSHOT_FLOW]] + [[ACTIVITIES]] +
      -
      """ static let activity = """ diff --git a/Sources/XCTestHTMLReportCore/Classes/Helpers/AttachmentHelpers.swift b/Sources/XCTestHTMLReportCore/Classes/Helpers/AttachmentHelpers.swift deleted file mode 100644 index 7730f0c2..00000000 --- a/Sources/XCTestHTMLReportCore/Classes/Helpers/AttachmentHelpers.swift +++ /dev/null @@ -1,61 +0,0 @@ -// -// AttachmentHelpers.swift -// XCTestHTMLReport -// - -import Foundation - -/// MARK: - Helpers -/// Helpers for location attachments from result model objects - -extension Summary { - - var allAttachments: [Attachment] { - runs.map({ $0.allAttachments }).reduce([], +) - } - -} - - -extension Run { - - var screenshotAttachments: [Attachment] { - allAttachments.filter { $0.isScreenshot } - } - - var allAttachments: [Attachment] { - allTests.map({ $0.allAttachments }).reduce([], +) - } - -} - -extension TestSummary { - - var allAttachments: [Attachment] { - tests.map({ $0.allAttachments }).reduce([], +) - } - -} - -extension Test { - - var allAttachments: [Attachment] { - activities.map({ $0.allAttachments }).reduce([], +) - } - -} - -extension Activity { - - var screenshotAttachments: [Attachment] { - return allAttachments.filter { $0.isScreenshot } - } - - var allAttachments: [Attachment] { - return attachments + subAttachments - } - - var subAttachments: [Attachment] { - return subActivities.map({ $0.allAttachments }).reduce([], +) - } -} diff --git a/Sources/XCTestHTMLReportCore/Classes/Models/Activity.swift b/Sources/XCTestHTMLReportCore/Classes/Models/Activity.swift index 6843d4cf..f177d67c 100644 --- a/Sources/XCTestHTMLReportCore/Classes/Models/Activity.swift +++ b/Sources/XCTestHTMLReportCore/Classes/Models/Activity.swift @@ -36,8 +36,7 @@ enum ActivityType: String { } } -struct Activity: HTML -{ +struct Activity: HTML { let uuid: String let padding: Int let attachments: [Attachment] @@ -50,6 +49,7 @@ struct Activity: HTML return 0.0 } + var title: String var subActivities: [Activity] var type: ActivityType? @@ -58,21 +58,25 @@ struct Activity: HTML let subActivitesHaveAttachments = subActivities.reduce(false) { $0 || $1.hasGlobalAttachment } return hasDirectAttachment || subActivitesHaveAttachments } + var hasFailingSubActivities: Bool { - return failingActivityRecursive != nil + failingActivityRecursive != nil } + var failingActivity: Activity? { - return type == .assertionFailure ? self : nil + type == .assertionFailure ? self : nil } + var failingActivityRecursive: Activity? { - return subActivities.first(where: { $0.failingActivityRecursive != nil }) ?? failingActivity + subActivities.first(where: { $0.failingActivityRecursive != nil }) ?? failingActivity } + var cssClasses: String { var cls = "" if let type = type { cls += type.cssClass - if type == .userCreated && hasFailingSubActivities { + if type == .userCreated, hasFailingSubActivities { cls += " activity-assertion-failure" } } @@ -81,15 +85,15 @@ struct Activity: HTML } init(summary: ActionTestActivitySummary, file: ResultFile, padding: Int = 0, renderingMode: Summary.RenderingMode) { - self.uuid = summary.uuid - self.startTime = summary.start?.timeIntervalSince1970 ?? 0 - self.finishTime = summary.finish?.timeIntervalSince1970 ?? 0 - self.title = summary.title - self.subActivities = summary.subactivities.map { + uuid = summary.uuid + startTime = summary.start?.timeIntervalSince1970 ?? 0 + finishTime = summary.finish?.timeIntervalSince1970 ?? 0 + title = summary.title + subActivities = summary.subactivities.map { Activity(summary: $0, file: file, padding: padding + 10, renderingMode: renderingMode) } - self.type = ActivityType(rawValue: summary.activityType) - self.attachments = summary.attachments.map { + type = ActivityType(rawValue: summary.activityType) + attachments = summary.attachments.map { Attachment(attachment: $0, file: file, padding: padding + 16, renderingMode: renderingMode) } self.padding = padding @@ -100,12 +104,12 @@ struct Activity: HTML var htmlTemplate = HTMLTemplates.activity var htmlPlaceholderValues: [String: String] { - return [ + [ "UUID": uuid, "TITLE": title.stringByEscapingXMLChars, "PAPER_CLIP_CLASS": hasGlobalAttachment ? "inline-block" : "none", "PADDING": (subActivities.isEmpty && attachments.isEmpty) ? String(padding + 18) : String(padding), - "TIME": totalTime.timeString, + "TIME": totalTime.formattedSeconds, "ACTIVITY_TYPE_CLASS": cssClasses, "HAS_SUB-ACTIVITIES_CLASS": (subActivities.isEmpty && attachments.isEmpty) ? "no-drop-down" : "", "SUB_ACTIVITY": subActivities.accumulateHTMLAsString, @@ -113,3 +117,17 @@ struct Activity: HTML ] } } + +extension Activity: ContainingAttachment { + var screenshotAttachments: [Attachment] { + allAttachments.filter(\.isScreenshot) + } + + var allAttachments: [Attachment] { + attachments + subAttachments + } + + var subAttachments: [Attachment] { + subActivities.map(\.allAttachments).reduce([], +) + } +} diff --git a/Sources/XCTestHTMLReportCore/Classes/Models/Iteration.swift b/Sources/XCTestHTMLReportCore/Classes/Models/Iteration.swift new file mode 100644 index 00000000..f3a972c4 --- /dev/null +++ b/Sources/XCTestHTMLReportCore/Classes/Models/Iteration.swift @@ -0,0 +1,63 @@ +// +// Iteration.swift +// +// +// Created by Tyler Vick on 12/27/21. +// + +import Foundation +import XCResultKit + +struct Iteration: Test { + let uuid = UUID().uuidString + let title: String + let identifier: String + let objectClass: ObjectClass = .testSummary // TODO: Modify html template + let duration: TimeInterval + let status: Status + let activities: [Activity] + let repetitionPolicy: ActionTestRepetitionPolicySummary? + + var testScreenshotFlow: TestScreenshotFlow? { + TestScreenshotFlow(activities: activities) + } + + init(metadata: ActionTestMetadata, resultFile: ResultFile, renderingMode: Summary.RenderingMode) { + title = metadata.name + identifier = metadata.identifier + status = Status(rawValue: metadata.testStatus) ?? .unknown + duration = metadata.duration ?? 0 + + if let id = metadata.summaryRef?.id, + let actionTestSummary = resultFile.getActionTestSummary(id: id) + { + activities = actionTestSummary.activitySummaries.map { + Activity(summary: $0, file: resultFile, padding: 20, renderingMode: renderingMode) + } + + repetitionPolicy = actionTestSummary.repetitionPolicySummary + } else { + activities = [] + repetitionPolicy = nil + } + } +} + +extension Iteration { + var htmlPlaceholderValues: [String: String] { [ + "UUID": uuid, + "TITLE": "Iteration \(repetitionPolicy?.iteration ?? 0)", + "DURATION": duration.formattedSeconds, + "ICON_CLASS": status.cssClass, + "SCREENSHOT_FLOW": testScreenshotFlow?.screenshots.accumulateHTMLAsString ?? "", + "ACTIVITIES": activities.accumulateHTMLAsString, + ] } + + var htmlTemplate: String { HTMLTemplates.iteration } +} + +extension Iteration: ContainingAttachment { + var allAttachments: [Attachment] { + activities.map(\.allAttachments).reduce([], +) + } +} diff --git a/Sources/XCTestHTMLReportCore/Classes/Models/JUnitReport.swift b/Sources/XCTestHTMLReportCore/Classes/Models/JUnitReport.swift index 7fe7eb7b..b341274a 100644 --- a/Sources/XCTestHTMLReportCore/Classes/Models/JUnitReport.swift +++ b/Sources/XCTestHTMLReportCore/Classes/Models/JUnitReport.swift @@ -8,23 +8,25 @@ import Foundation -struct JUnitReport -{ +struct JUnitReport { var name: String var tests: Int { - return suites.map { $0.tests }.reduce(0, { $0 + $1 }) + suites.map(\.tests).reduce(0) { $0 + $1 } } + var failures: Int { - return suites.map { $0.failures }.reduce(0, { $0 + $1 }) + suites.map(\.failures).reduce(0) { $0 + $1 } } + var suites: [TestSuite] struct TestSuite { var name: String var tests: Int var failures: Int { - return cases.filter { $0.state == .failed }.count + cases.filter { $0.state == .failed }.count } + var cases: [TestCase] } @@ -35,7 +37,9 @@ struct JUnitReport case passed case skipped case errored + case mixed } + var classname: String var name: String var time: TimeInterval @@ -50,19 +54,19 @@ struct JUnitReport case systemOut case skipped } + var title: String var state: State } } -extension JUnitReport: XMLRepresentable -{ +extension JUnitReport: XMLRepresentable { /// e.g. var xmlString: String { var xml = "\n" xml += "\n" - suites.forEach { (suite) in + suites.forEach { suite in xml += suite.xmlString } @@ -72,13 +76,12 @@ extension JUnitReport: XMLRepresentable } } -extension JUnitReport.TestSuite: XMLRepresentable -{ +extension JUnitReport.TestSuite: XMLRepresentable { /// e.g. var xmlString: String { var xml = " \n" - cases.forEach { (testcase) in + cases.forEach { testcase in xml += testcase.xmlString } @@ -88,8 +91,7 @@ extension JUnitReport.TestSuite: XMLRepresentable } } -extension JUnitReport.TestCase: XMLRepresentable -{ +extension JUnitReport.TestCase: XMLRepresentable { /// e.g. var xmlString: String { let timeString = String(format: "%.02f", time) @@ -99,15 +101,14 @@ extension JUnitReport.TestCase: XMLRepresentable xml += "/>\n" } else { xml += ">\n" - xml += results.map { $0.xmlString }.joined(separator: "\n") + xml += results.map(\.xmlString).joined(separator: "\n") xml += "\n \n" } return xml } } -extension JUnitReport.TestResult: XMLRepresentable -{ +extension JUnitReport.TestResult: XMLRepresentable { /// e.g. /// /// Some message logged to std out @@ -126,20 +127,15 @@ extension JUnitReport.TestResult: XMLRepresentable } } - -extension JUnitReport -{ - init(summary: Summary) - { +extension JUnitReport { + init(summary: Summary) { name = "All" suites = summary.runs.map { JUnitReport.TestSuite(run: $0) } } } -extension JUnitReport.TestCase -{ - init(run: Run, test: Test) - { +extension JUnitReport.TestCase { + init(run: Run, test: Test) { let components = test.identifier.components(separatedBy: "/") time = test.duration name = components.last ?? "" @@ -152,6 +148,8 @@ extension JUnitReport.TestCase state = .passed case .skipped: state = .skipped + case .mixed: + state = .mixed case .unknown: state = .unknown } @@ -161,16 +159,20 @@ extension JUnitReport.TestCase let t = activity.subActivities.flatMap { flatSubActivities(of: $0, indent: indent + 1) } return [JUnitReport.TestResult(activity: activity, indent: indent)] + t } - results = test.activities.map { - return flatSubActivities(of: $0, indent: 0) - }.flatMap { $0 } + + // TODO: Need a better way to represent multiple iterations + results = [] + if let testCase = test as? TestCase { + results = testCase.iterations + .flatMap(\.activities) + .map { flatSubActivities(of: $0, indent: 0) } + .flatMap { $0 } + } } } -extension JUnitReport.TestResult -{ - init(activity: Activity, indent: Int) - { +extension JUnitReport.TestResult { + init(activity: Activity, indent: Int) { title = String(repeating: " ", count: indent * 2) + activity.title if activity.type == .assertionFailure { state = .failed @@ -184,19 +186,16 @@ extension JUnitReport.TestResult } } -extension JUnitReport.TestSuite -{ - init(run: Run) - { +extension JUnitReport.TestSuite { + init(run: Run) { name = (run.testSummaries.first?.testName ?? "") + " - " + run.runDestination.deviceInfo tests = run.numberOfTests cases = run.allTests.map { JUnitReport.TestCase(run: run, test: $0) } } } -extension RunDestination -{ +extension RunDestination { var deviceInfo: String { - return name + " - " + targetDevice.osVersion + name + " - " + targetDevice.osVersion } } diff --git a/Sources/XCTestHTMLReportCore/Classes/Models/Run.swift b/Sources/XCTestHTMLReportCore/Classes/Models/Run.swift index ca0c050b..2cc5f505 100644 --- a/Sources/XCTestHTMLReportCore/Classes/Models/Run.swift +++ b/Sources/XCTestHTMLReportCore/Classes/Models/Run.swift @@ -9,8 +9,7 @@ import Foundation import XCResultKit -struct Run: HTML -{ +struct Run: HTML { let file: ResultFile let runDestination: RunDestination let testSummaries: [TestSummary] @@ -24,52 +23,64 @@ struct Run: HTML } return .success } + var allTests: [Test] { - let tests = testSummaries.flatMap { $0.tests } + let tests = testSummaries.flatMap(\.tests) return tests.flatMap { test -> [Test] in - return test.allSubTests.isEmpty - ? [test] - : test.allSubTests + let subTests = test.descendantSubTests + if subTests.isEmpty { + return [test] + } + return subTests } } - var numberOfTests : Int { + + var numberOfTests: Int { let a = allTests return a.count } - var numberOfPassedTests : Int { - return allTests.filter { $0.status == .success }.count + + var numberOfPassedTests: Int { + allTests.filter { $0.status == .success }.count } - var numberOfSkippedTests : Int { - return allTests.filter { $0.status == .skipped }.count + + var numberOfSkippedTests: Int { + allTests.filter { $0.status == .skipped }.count } - var numberOfFailedTests : Int { - return allTests.filter { $0.status == .failure }.count + + var numberOfFailedTests: Int { + allTests.filter { $0.status == .failure }.count + } + + var numberOfMixedTests: Int { + allTests.filter { $0.status == .mixed }.count } init?(action: ActionRecord, file: ResultFile, renderingMode: Summary.RenderingMode) { self.file = file - self.runDestination = RunDestination(record: action.runDestination) + runDestination = RunDestination(record: action.runDestination) guard let testReference = action.actionResult.testsRef, - let testPlanSummaries = file.getTestPlanRunSummaries(id: testReference.id) else { - Logger.warning("Can't find test reference for action \(action.title ?? "")") - return nil + let testPlanSummaries = file.getTestPlanRunSummaries(id: testReference.id) + else { + Logger.warning("Can't find test reference for action \(action.title ?? "")") + return nil } // TODO: (Pierre Felgines) 02/10/2019 Use only emittedOutput from logs objects // For now XCResultKit do not handle logs if let logReference = action.actionResult.logRef { - self.logContent = file.exportLogsContent( + logContent = file.exportLogsContent( id: logReference.id, renderingMode: renderingMode ) } else { Logger.warning("Can't find test reference for action \(action.title ?? "")") - self.logContent = .none + logContent = .none } - self.testSummaries = testPlanSummaries.summaries - .flatMap { $0.testableSummaries } + testSummaries = testPlanSummaries.summaries + .flatMap(\.testableSummaries) .map { TestSummary(summary: $0, file: file, renderingMode: renderingMode) } } @@ -89,15 +100,25 @@ struct Run: HTML var htmlTemplate = HTMLTemplates.run var htmlPlaceholderValues: [String: String] { - return [ + [ "DEVICE_IDENTIFIER": runDestination.targetDevice.uniqueIdentifier, "LOG_SOURCE": logSource ?? "", "N_OF_TESTS": String(numberOfTests), "N_OF_PASSED_TESTS": String(numberOfPassedTests), "N_OF_SKIPPED_TESTS": String(numberOfSkippedTests), "N_OF_FAILED_TESTS": String(numberOfFailedTests), - "TEST_SUMMARIES": testSummaries.map { $0.html }.joined() + "N_OF_MIXED_TESTS": String(numberOfMixedTests), + "TEST_SUMMARIES": testSummaries.map(\.html).joined(), ] } +} + +extension Run: ContainingAttachment { + var screenshotAttachments: [Attachment] { + allAttachments.filter(\.isScreenshot) + } + var allAttachments: [Attachment] { + allTests.map(\.allAttachments).reduce([], +) + } } diff --git a/Sources/XCTestHTMLReportCore/Classes/Models/RunDestination.swift b/Sources/XCTestHTMLReportCore/Classes/Models/RunDestination.swift index 57353815..d0d9ac4d 100644 --- a/Sources/XCTestHTMLReportCore/Classes/Models/RunDestination.swift +++ b/Sources/XCTestHTMLReportCore/Classes/Models/RunDestination.swift @@ -9,6 +9,7 @@ import Foundation import XCResultKit +// TODO: Check usages, Status already contains cssClass property private extension Status { /// e.g. var iconCssClass: String { @@ -19,6 +20,8 @@ private extension Status { return "success" case .skipped: return "skip" + case .mixed: + return "mixed" default: return "" } @@ -27,15 +30,15 @@ private extension Status { /// Only show icon for failures var iconHTML: String { guard self == .failure || - self == .success else { + self == .success + else { return "" } return "" } } -struct RunDestination : HTML -{ +struct RunDestination: HTML { let name: String let targetDevice: TargetDevice let status: Status @@ -52,7 +55,7 @@ struct RunDestination : HTML var htmlTemplate = HTMLTemplates.device var htmlPlaceholderValues: [String: String] { - return [ + [ "DEVICE_RESULT": status.iconHTML, "DEVICE_NAME": name, "DEVICE_IDENTIFIER": targetDevice.uniqueIdentifier, diff --git a/Sources/XCTestHTMLReportCore/Classes/Models/Summary.swift b/Sources/XCTestHTMLReportCore/Classes/Models/Summary.swift index 21704ec3..eeca6f5a 100644 --- a/Sources/XCTestHTMLReportCore/Classes/Models/Summary.swift +++ b/Sources/XCTestHTMLReportCore/Classes/Models/Summary.swift @@ -9,8 +9,7 @@ import Foundation import XCResultKit -public struct Summary -{ +public struct Summary { let runs: [Run] public enum RenderingMode: String { @@ -54,13 +53,13 @@ public struct Summary /// Generate HTML report /// - Returns: Generated HTML report string public func generatedHtmlReport() -> String { - return html + html } /// Generate JUnit report /// - Returns: Generated JUnit XML report string public func generatedJunitReport() -> String { - return junit.xmlString + junit.xmlString } /// Delete all unattached files in runs @@ -72,32 +71,36 @@ public struct Summary } } -extension Summary: HTML -{ +extension Summary: HTML { var htmlTemplate: String { - return HTMLTemplates.index + HTMLTemplates.index } var htmlPlaceholderValues: [String: String] { let resultClass: String - if runs.first(where: { $0.status == .failure }) != nil { + if runs.contains(where: { $0.status == .failure }) { resultClass = "failure" - } else if runs.first(where: { $0.status == .success }) != nil { + } else if runs.contains(where: { $0.status == .success }) { resultClass = "success" } else { resultClass = "skip" } return [ - "DEVICES": runs.map { $0.runDestination.html }.joined(), + "DEVICES": runs.map(\.runDestination.html).joined(), "RESULT_CLASS": resultClass, - "RUNS": runs.map { $0.html }.joined() + "RUNS": runs.map(\.html).joined(), ] } } -extension Summary: JUnitRepresentable -{ +extension Summary: JUnitRepresentable { var junit: JUnitReport { - return JUnitReport(summary: self) + JUnitReport(summary: self) + } +} + +extension Summary: ContainingAttachment { + var allAttachments: [Attachment] { + runs.map(\.allAttachments).reduce([], +) } } diff --git a/Sources/XCTestHTMLReportCore/Classes/Models/Test.swift b/Sources/XCTestHTMLReportCore/Classes/Models/Test.swift index e968e505..f59365e1 100644 --- a/Sources/XCTestHTMLReportCore/Classes/Models/Test.swift +++ b/Sources/XCTestHTMLReportCore/Classes/Models/Test.swift @@ -14,6 +14,7 @@ enum Status: String { case failure = "Failure" case success = "Success" case skipped = "Skipped" + case mixed = "Mixed" var cssClass: String { switch self { @@ -23,18 +24,21 @@ enum Status: String { return "succeeded" case .skipped: return "skipped" + case .mixed: + return "mixed" default: return "" } } } +// Will be deprecated as each case is now a unique object enum ObjectClass: String { case unknwown = "" case testableSummary = "IDESchemeActionTestableSummary" case testSummary = "IDESchemeActionTestSummary" case testSummaryGroup = "IDESchemeActionTestSummaryGroup" - + var cssClass: String { switch self { case .testSummary: @@ -49,85 +53,181 @@ enum ObjectClass: String { } } -struct Test: HTML -{ - let uuid: String +/// A grouping of test cases, typically representing a single XCTestCase class or test suite +public struct TestGroup: Test { + let uuid = UUID().uuidString + let title: String let identifier: String - let duration: Double - let name: String - let subTests: [Test] - let activities: [Activity] - let status: Status - let objectClass: ObjectClass - let testScreenshotFlow: TestScreenshotFlow? - - var allSubTests: [Test] { - return subTests.flatMap { test -> [Test] in - return test.allSubTests.isEmpty - ? [test] - : test.allSubTests + let objectClass: ObjectClass = .testSummaryGroup + let duration: TimeInterval + var status: Status { + if subTests.allSatisfy({ $0.status == .success }) { + return .success + } + + for s: Status in [.failure, .mixed, .skipped] { + if subTests.contains(where: { $0.status == s }) { + return s + } } + + return .unknown } - var amountSubTests: Int { - let a = subTests.reduce(0) { $0 + $1.amountSubTests } - return a == 0 ? subTests.count : a + let subTests: [Test] + + var descendantSubTests: [Test] { + subTests.flatMap { subTest -> [Test] in + if let testSummaryGroup = subTest as? TestGroup, + !testSummaryGroup.subTests.isEmpty + { + return testSummaryGroup.descendantSubTests + } + return [subTest] + } } - init(group: ActionTestSummaryGroup, file: ResultFile, renderingMode: Summary.RenderingMode) { - self.uuid = NSUUID().uuidString - self.identifier = group.identifier ?? "---identifier-not-found---" - self.duration = group.duration - self.name = group.name ?? "---group-name-not-found---" + init(group: ActionTestSummaryGroup, resultFile: ResultFile, renderingMode: Summary.RenderingMode) { + title = group.name ?? "---group-name-not-found---" + identifier = group.identifier ?? "---group-identifier-not-found---" + duration = group.duration + if group.subtests.isEmpty { - self.subTests = group.subtestGroups.map { Test(group: $0, file: file, renderingMode: renderingMode) } + subTests = group.subtestGroups.map { TestGroup(group: $0, resultFile: resultFile, renderingMode: renderingMode) } } else { - self.subTests = group.subtests.map { Test(metadata: $0, file: file, renderingMode: renderingMode) } + subTests = Array(group.subtests.reduce(into: Set()) { subTestSet, metadata in + let newTest = TestCase(metadata: metadata, resultFile: resultFile, renderingMode: renderingMode) + if let index = subTestSet.firstIndex(of: newTest) { + var existingTest = subTestSet[index] + existingTest.iterations.append(contentsOf: newTest.iterations) + subTestSet.update(with: existingTest) + } else { + subTestSet.insert(newTest) + } + }) } - self.objectClass = .testSummaryGroup - self.activities = [] - self.status = .unknown // ???: Usefull? - testScreenshotFlow = TestScreenshotFlow(activities: activities) + } +} + +extension TestGroup { + var htmlPlaceholderValues: [String: String] { [ + "UUID": uuid, + "TITLE": title, + "DURATION": duration.formattedSeconds, + "ICON_CLASS": status.cssClass, + "ITEM_CLASS": objectClass.cssClass, + "SUB_TESTS": subTests.reduce("") { $0 + $1.html }, + ] } + + var htmlTemplate: String { HTMLTemplates.testGroup } +} + +extension TestGroup: ContainingAttachment { + var allAttachments: [Attachment] { + subTests.map(\.allAttachments).reduce([], +) + } +} + +// MARK: TestCase + +/// Generally represents a single test method, the smallest unit of test status when considering "Mixed" results +/// Contains one or more `Iteration`s as defined by the RepetitionPolicy. When only one iteration is present, the activities will be bubbled up to `TestCase`. +struct TestCase: Test { + let uuid = UUID().uuidString + let title: String + let identifier: String + var objectClass: ObjectClass = .testSummary + var duration: TimeInterval { + iterations.reduce(0) { $0 + $1.duration } } - init(metadata: ActionTestMetadata, file: ResultFile, renderingMode: Summary.RenderingMode) { - self.uuid = NSUUID().uuidString - self.identifier = metadata.identifier - self.duration = metadata.duration ?? 0 - self.name = metadata.name - self.subTests = [] - self.status = Status(rawValue: metadata.testStatus) ?? .failure - self.objectClass = .testSummary - if let id = metadata.summaryRef?.id, - let actionTestSummary = file.getActionTestSummary(id: id) { - self.activities = actionTestSummary.activitySummaries.map { - Activity(summary: $0, file: file, padding: 20, renderingMode: renderingMode) - } - } else { - self.activities = [] + // Test case status is computed from the combined statuses of iterations. + // If all iterations have the same status, the test case will have that status, + // otherwise the status will report as "mixed". + var status: Status { + let statusCountMap = iterationStatusCount() + + if statusCountMap.count == 1, + let first = statusCountMap.first + { + return first.key + } + + return .mixed + } + + private func iterationStatusCount() -> [Status: Int] { + if iterations.isEmpty { + return [.unknown: 1] + } + + if iterations.count == 1 { + return [iterations[0].status: 1] + } + + return iterations.reduce(into: [:]) { map, i in + map[i.status] = (map[i.status] ?? 0) + 1 } - testScreenshotFlow = TestScreenshotFlow(activities: activities) } - // PRAGMA MARK: - HTML + // This should be the only mutable property + var iterations: [Iteration] - var htmlTemplate = HTMLTemplates.test + init(metadata: ActionTestMetadata, resultFile: ResultFile, renderingMode: Summary.RenderingMode) { + title = metadata.name + identifier = metadata.identifier + + iterations = [Iteration(metadata: metadata, resultFile: resultFile, renderingMode: renderingMode)] + } +} +// HTML conforming +extension TestCase { var htmlPlaceholderValues: [String: String] { - return [ - "UUID": uuid, - "NAME": name + (amountSubTests > 0 ? " - \(amountSubTests) tests" : ""), - "TIME": duration.timeString, - "SUB_TESTS": subTests.reduce("") { (accumulator: String, test: Test) -> String in - return accumulator + test.html - }, - "HAS_ACTIVITIES_CLASS": activities.isEmpty ? "no-drop-down" : "", - "ACTIVITIES": activities.accumulateHTMLAsString, - "ICON_CLASS": status.cssClass, - "ITEM_CLASS": objectClass.cssClass, - "LIST_ITEM_CLASS": objectClass == .testSummary ? (status == .failure ? "list-item list-item-failed" : "list-item") : "", - "SCREENSHOT_FLOW": testScreenshotFlow?.screenshots.accumulateHTMLAsString ?? "", - "SCREENSHOT_TAIL": testScreenshotFlow?.screenshotsTail.accumulateHTMLAsString ?? "" - ] + if iterations.count == 1 { + let iteration = iterations[0] + return [ + "UUID": uuid, + "TITLE": title, + "DURATION": duration.formattedSeconds, + "ICON_CLASS": status.cssClass, + "ITEM_CLASS": objectClass.cssClass, + "SCREENSHOT_TAIL": iteration.testScreenshotFlow?.screenshotsTail.accumulateHTMLAsString ?? "", + "SCREENSHOT_FLOW": iteration.testScreenshotFlow?.screenshots.accumulateHTMLAsString ?? "", + "ACTIVITIES": iteration.activities.accumulateHTMLAsString, + ] + } else { + return [ + "UUID": uuid, + "TITLE": title, + "DURATION": duration.formattedSeconds, + "ICON_CLASS": status.cssClass, + "ITEM_CLASS": objectClass.cssClass, + "ITERATIONS": iterations.reduce("") { $0 + $1.html }, + "RESULT_STRING": iterationStatusCount().map { "\($0.value) \($0.key.cssClass)" }.joined(separator: ", "), + // Add something for repetition policy/results breakdown + ] + } + } + + var htmlTemplate: String { + iterations.count == 1 ? HTMLTemplates.testCase : HTMLTemplates.testCaseWithIterations + } +} + +// Needed to dedupe iterations +extension TestCase: Hashable { + func hash(into hasher: inout Hasher) { + hasher.combine(identifier) + } + + static func == (lhs: Self, rhs: Self) -> Bool { + lhs.identifier == rhs.identifier + } +} + +extension TestCase: ContainingAttachment { + var allAttachments: [Attachment] { + iterations.map(\.allAttachments).reduce([], +) } } diff --git a/Sources/XCTestHTMLReportCore/Classes/Models/TestSummary.swift b/Sources/XCTestHTMLReportCore/Classes/Models/TestSummary.swift index 432f4cd1..2b3ddcaa 100644 --- a/Sources/XCTestHTMLReportCore/Classes/Models/TestSummary.swift +++ b/Sources/XCTestHTMLReportCore/Classes/Models/TestSummary.swift @@ -9,25 +9,20 @@ import Foundation import XCResultKit -struct TestSummary: HTML -{ +struct TestSummary: HTML { let uuid: String let testName: String - let tests: [Test] + let tests: [TestGroup] var status: Status { let currentTests = tests var status: Status = .unknown - - var currentSubtests: [Test] = [] - for test in currentTests { - currentSubtests += test.allTestSummaries() - } - - if currentSubtests.count == 0 { + + if currentTests.count == 0 { return .success } - status = currentSubtests.reduce(.unknown, { (accumulator: Status, test: Test) -> Status in + // TODO: Include mixed status + status = currentTests.reduce(.unknown) { (accumulator: Status, test: TestGroup) -> Status in if accumulator == .unknown { return test.status } @@ -41,15 +36,18 @@ struct TestSummary: HTML } return .unknown - }) + } return status } init(summary: ActionTestableSummary, file: ResultFile, renderingMode: Summary.RenderingMode) { - self.uuid = UUID().uuidString - self.testName = summary.targetName ?? "" - self.tests = summary.tests.map { Test(group: $0, file: file, renderingMode: renderingMode) } + uuid = UUID().uuidString + testName = summary.targetName ?? "" + // TODO: Reduce this with iterations & accum with hashmap + tests = summary.tests.map { + TestGroup(group: $0, resultFile: file, renderingMode: renderingMode) + } } // PRAGMA MARK: - HTML @@ -57,18 +55,15 @@ struct TestSummary: HTML var htmlTemplate = HTMLTemplates.testSummary var htmlPlaceholderValues: [String: String] { - return [ + [ "UUID": uuid, - "TESTS": tests.accumulateHTMLAsString + "TESTS": tests.accumulateHtml(), ] } } -extension Test { - func allTestSummaries() -> [Test] { - if self.objectClass == .testSummary { - return [self] - } - return subTests.flatMap { $0.allTestSummaries() } +extension TestSummary: ContainingAttachment { + var allAttachments: [Attachment] { + tests.map(\.allAttachments).reduce([], +) } } diff --git a/Sources/XCTestHTMLReportCore/Classes/Protocols/ContainingAttachment.swift b/Sources/XCTestHTMLReportCore/Classes/Protocols/ContainingAttachment.swift new file mode 100644 index 00000000..9ef83dd1 --- /dev/null +++ b/Sources/XCTestHTMLReportCore/Classes/Protocols/ContainingAttachment.swift @@ -0,0 +1,12 @@ +// +// ContainingAttachment.swift +// +// +// Created by Tyler Vick on 12/28/21. +// + +import Foundation + +protocol ContainingAttachment { + var allAttachments: [Attachment] { get } +} diff --git a/Sources/XCTestHTMLReportCore/Classes/Protocols/HTML.swift b/Sources/XCTestHTMLReportCore/Classes/Protocols/HTML.swift index 653ae950..45832f83 100644 --- a/Sources/XCTestHTMLReportCore/Classes/Protocols/HTML.swift +++ b/Sources/XCTestHTMLReportCore/Classes/Protocols/HTML.swift @@ -8,29 +8,31 @@ import Foundation -protocol HTML -{ +protocol HTML { var htmlTemplate: String { get } var htmlPlaceholderValues: [String: String] { get } } -extension HTML -{ +extension HTML { var html: String { - return htmlPlaceholderValues.reduce(htmlTemplate, { (accumulator: String, rel: (String, String)) -> String in - return autoreleasepool { + htmlPlaceholderValues.reduce(htmlTemplate) { (accumulator: String, rel: (String, String)) -> String in + autoreleasepool { accumulator.replacingOccurrences(of: "[[\(rel.0)]]", with: rel.1) } - }) + } } } -extension Sequence where Element : HTML { - +extension Sequence where Element: HTML { var accumulateHTMLAsString: String { - return reduce("", { (accumulator: String, element: HTML) -> String in - return accumulator + element.html - }) + reduce("") { (accumulator: String, element: HTML) -> String in + accumulator + element.html + } } +} +extension Sequence where Element: Test { + func accumulateHtml() -> String { + reduce("") { $0 + $1.html } + } } diff --git a/Sources/XCTestHTMLReportCore/Classes/Protocols/TestConforming.swift b/Sources/XCTestHTMLReportCore/Classes/Protocols/TestConforming.swift new file mode 100644 index 00000000..9896ccaa --- /dev/null +++ b/Sources/XCTestHTMLReportCore/Classes/Protocols/TestConforming.swift @@ -0,0 +1,17 @@ +// +// File.swift +// +// +// Created by Tyler Vick on 12/28/21. +// + +import Foundation + +protocol Test: HTML, ContainingAttachment { + var uuid: String { get } + var title: String { get } + var identifier: String { get } + var objectClass: ObjectClass { get } + var status: Status { get } + var duration: TimeInterval { get } +} diff --git a/Sources/XCTestHTMLReportCore/HTML/index.html b/Sources/XCTestHTMLReportCore/HTML/index.html index 63a1b5aa..6d795400 100644 --- a/Sources/XCTestHTMLReportCore/HTML/index.html +++ b/Sources/XCTestHTMLReportCore/HTML/index.html @@ -258,17 +258,29 @@ } .test-summary.succeeded .test-result-icon, - .test-summary.failed .test-result-icon { + .iteration.succeeded .test-result-icon, + .iteration.skipped .test-result-icon, + .iteration.failed .test-result-icon { margin-left: 28px; display: block; } .test-summary.succeeded .test-result-icon, + .iteration.succeeded .test-result-icon, .success { background-image: url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAqAAAAKgCAYAAABEPM/FAAAABGdBTUEAALGPC/xhBQAAQABJREFUeAHsnQecVNX1gM/MNpZdeu9IEayAqIhKsVEsMcUaewf0r0ajxhZ7JbaogInGFpPYu4gKdlEsIAoiiPTeYSu7O/N/dxVc1i1TXrn33e/llx87M/eee853HvjtvBYRNghAAAIQqJHAE088kVdUVtSjQiraSEzypULyo5FoXiQeyXMmNFKTIpFIQUxiBbF4rFAypECiUpAhGasi5ZF55513XlGNgXkTAhCAgOUEIpbXT/kQgAAE5JFHHmlUGi8dHCmL7FYRqehdIfFdI3Hp6Yhko41SWLQpXhwvdT4slrJoiWzNKJKtWcXxsiyFLjeSVdZQsssaSHZFrmTFcuJZ8SaR3EhTyWvoiOnmWCT+Q4ZEZmfEM+Y4H83KieR8cNZZZ20BOwQgAAGbCSCgNnef2iFgKYHHH3+8RcHWgiEZsYxBpbHy4Y4gdlsi60t+jK9uuFI2Za2JbJHV8c2yQQolniIj9Y9rM8mT1pHG0ireSNpKk7JukdZFnaR5A0dwf8yJZk6qiFZ8mJ+d//5pp522LsVlmAYBCEDASAIIqJFtI2kIQCBZAs63nO23lm89sSweOz0Sj/dcJOtKZsmyRnPjK6MLZY1zdD1V1UwuE0d2pau0kp0jbWO7SYctXaRFg3hE5mZK9LGcrJz/Od+OLk8uIqMhAAEImEcAATWvZ2QMAQgkSODRRx9tWry1+LgKRzrjcek7XRbFp8Z/aDhXVjqndPojnPWlGnWEdGfn+9GBkR5F/aSL+jd5emY0+nhudu4zZ5xxxsb65vM5BCAAARMJIKAmdo2cIQCBOgk8+I8H+0osclVc4kfNji8v/yQ+L/9bWSrljnbqvDnfgsru0lH2j/Qs2DXSPjMikVclGr/1/HPPn6Fz3uQGAQhAIFkCCGiyxBgPAQhoS+CBCQ8cEovJ1eXRigFvyjc5H8a+z3AuHNI237oScy5okkHRXhUjZI/SzFjGZ9Go3HLBqAsm1zWHzyAAAQiYQgABNaVT5AkBCNRKYNxD444tj8WuKYiU7PRafEb+tPiPEd2/7ay1mGofqG9F9410ix8Z6VuQH2+wwDk8f/OY88Y8W20YLyEAAQgYRQABNapdJAsBCFQlMP7h8f0qKmIPrY1v6f1i7MtGM2WJJmd2Vs3SnZ/VP9Z7Sif5XbT/lpaRRnMyMqLnjT579HR3ohMFAhCAgL8EEFB/ebMaBCDgAoGnnnqq2caCjbeVxSpOeVa+aPBJfG5Uj0uKXCiunhDqH+39IzvHjpW9S7KiGU82zW965UknnbShnml8DAEIQEArAgioVu0gGQhAoC4C8Xg8MuEfE0aVxypumyrzc16Kf9nAuSl8XVNC+5lz83v5baR/yUDpXpoZzbhy1LmjJjhPZbLFw0PbVwqDgC0EEFBbOk2dEDCcwPjx4zuUxyueXx7ZuNsT8Y/zlzm3iWcT6eDc7v7UyAEF7eNNZ2VGMv4wevToZXCBAAQgoDsBBFT3DpEfBCAgzkVGv62IxR57PT4zb5LMzORrvh13CvUP+XDZs/yIyJ6FGdHo6c5FSi/tOIJXEIAABPQigIDq1Q+ygQAEqhB45plnslevX323cyul08fHp+T9GF9T5VN+rE6gW6SVjI4cXOjcwumx1s1bX3LcccfZeX5CdTC8hgAEtCOAgGrXEhKCAAQUgYcffrhHUVnxy3NkZddH4x80NPV+nn53U50benpkUFFvabuwYVbu0WefffYPfufAehCAAATqI4CA1keIzyEAAd8JTHhkwsCysvI3npcvGr0Xm5PhewIhWHBotHfFH2TvLVlZmYePOmvU1BCURAkQgECICCCgIWompUAgDASc8z2PcG4q/7+H4u/mzxKup0mnp7s5lyidFzmowLl5/QnOeaGvpxOLuRCAAATcJBB1MxixIAABCKRDYPw/xp9eGi9/+u74m8hnOiB/nqsEXrFUTBVbF0ISAgIQgIArBDi05QpGgkAAAukSGDdh3JWF8dLb74y9kcctltKl+cv8jVIkX8vi7L2l62G/O/Lo+Ouvvf7RL5/yEwQgAIFgCHAIPhjurAoBCFQh4MjnWOdxmqPucr6t2yTFVT7hR7cINJFcuTQyosB5jOeEMaPGXOZWXOJAAAIQSIUA34CmQo05EICAawSUfK6ObR59p0zM3yIlrsUl0I4ESqVcpsmC7L7xzn2OO+r3zZxvQt/ecQSvIAABCPhHAAH1jzUrQQAC1Qhsk8+xMjGvUEqrfcpLtwmUSYV8joS6jZV4EIBACgQQ0BSgMQUCEEifAPKZPsNUIiChqVBjDgQg4DYBBNRtosSDAATqJYB81ovI0wFIqKd4CQ4BCCRAAAFNABJDIAAB9wggn+6xTCcSEpoOPeZCAALpEkBA0yXIfAhAIGECyGfCqHwZiIT6gplFIACBGgggoDVA4S0IQMB9Asin+0zdiIiEukGRGBCAQLIEENBkiTEeAhBImgDymTQyXycgob7iZjEIQMAhgICyG0AAAp4SQD49xetacCTUNZQEggAEEiCAgCYAiSEQgEBqBJDP1LgFNQsJDYo860LAPgIIqH09p2II+EIA+fQFs+uLIKGuIyUgBCBQAwEEtAYovAUBCKRHAPlMj1/Qs5HQoDvA+hAIPwEENPw9pkII+EoA+fQVt2eLIaGeoSUwBCDgEEBA2Q0gAAHXCCCfrqHUIhASqkUbSAICoSSAgIayrRQFAf8JIJ/+M/djRSTUD8qsAQH7CCCg9vWciiHgOgHk03WkWgVEQrVqB8lAIBQEENBQtJEiIBAcAeQzOPZ+royE+kmbtSAQfgIIaPh7TIUQ8IwA8ukZWi0DI6FatoWkIGAkAQTUyLaRNASCJ4B8Bt+DIDJAQoOgzpoQCB8BBDR8PaUiCHhOAPn0HLHWCyChWreH5CBgBAEE1Ig2kSQE9CGAfOrTiyAzQUKDpM/aEDCfAAJqfg+pAAK+EUA+fUNtxEJIqBFtIkkIaEkAAdWyLSQFAf0IIJ/69USHjJBQHbpADhAwjwACal7PyBgCvhNAPn1HbtSCSKhR7SJZCGhBAAHVog0kAQF9CSCf+vZGp8yQUJ26QS4Q0J8AAqp/j8gQAoERQD4DQ2/kwkiokW0jaQgEQgABDQQ7i0JAfwLIp/490jFDJFTHrpATBPQjgIDq1xMygkDgBJDPwFtgdAJIqNHtI3kI+EIAAfUFM4tAwBwCyKc5vdI5UyRU5+6QGwSCJ4CABt8DMoCANgSQT21aEYpEkNBQtJEiIOAJAQTUE6wEhYB5BJBP83pmQsZIqAldIkcI+E8AAfWfOStCQDsCyKd2LQlVQkhoqNpJMRBwhQAC6gpGgkDAXALIp7m9MylzJNSkbpErBLwngIB6z5gVIKAtAeRT29aEMjEkNJRtpSgIpEQAAU0JG5MgYD4B5NP8HppYARJqYtfIGQLuE0BA3WdKRAhoTwD51L5FoU4QCQ11eykOAgkRQEATwsQgCISHAPIZnl6aXAkSanL3yB0C6RNAQNNnSAQIGEMA+TSmVVYkioRa0WaKhECNBBDQGrHwJgTCRwD5DF9Pw1AREhqGLlIDBJIngIAmz4wZEDCOAPJpXMusShgJtardFAuBSgIIKDsCBEJOAPkMeYNDUh4SGpJGUgYEEiSAgCYIimEQMJEA8mli1+zNGQm1t/dUbh8BBNS+nlOxJQSQT0saHbIykdCQNZRyIFALAQS0FjC8DQGTCSCfJneP3JFQ9gEIhJ8AAhr+HlOhZQSQT8saHtJykdCQNpayIPAzAQSUXQECISKAfIaomZQiSCg7AQTCSwABDW9vqcwyAsinZQ23pFwk1JJGU6Z1BBBQ61pOwWEkgHyGsavUtI0AErqNBH9CIDwEENDw9JJKLCWAfFraeMvKRkItazjlhp4AAhr6FlNgmAkgn2HuLrVVJ4CEVifCawiYSwABNbd3ZG45AeTT8h3A0vKRUEsbT9mhI4CAhq6lFGQDAeTThi5TY20EkNDayPA+BMwhgICa0ysyhUAlAeSTHQECwi2a2AkgYDgBBNTwBpK+XQSQT7v6TbV1E+Cb0Lr58CkEdCaAgOrcHXKDQBUCyGcVGPwIgZ8JIKHsChAwkwACambfyNoyAsinZQ2n3KQIIKFJ4WIwBLQggIBq0QaSgEDtBJDP2tnwCQS2EUBCt5HgTwiYQQABNaNPZGkpAeTT0sZTdkoEkNCUsDEJAoEQQEADwc6iEKifAPJZPyNGQKA6ASS0OhFeQ0BPAgionn0hK8sJIJ+W7wCUnxYBJDQtfEyGgC8EEFBfMLMIBBIngHwmzoqREKiNABJaGxneh4AeBBBQPfpAFhCoJIB8siNAwD0CSKh7LIkEAbcJIKBuEyUeBFIkgHymCI5pEKiDABJaBxw+gkCABBDQAOGzNAS2EUA+t5HgTwi4TwAJdZ8pESGQLgEENF2CzIdAmgSQzzQBMh0CCRBAQhOAxBAI+EgAAfURNktBoDoB5LM6EV5DwDsCSKh3bIkMgWQJIKDJEmM8BFwigHy6BJIwEEiCABKaBCyGQsBDAgioh3AJDYHaCCCftZHhfQh4TwAJ9Z4xK0CgPgIIaH2E+BwCLhNAPl0GSjgIpEAACU0BGlMg4CIBBNRFmISCQH0EkM/6CPE5BPwjgIT6x5qVIFCdAAJanQivIeARAeTTI7CEhUAaBJDQNOAxFQJpEEBA04DHVAgkSgD5TJQU4yDgPwEk1H/mrAgBBJR9AAIeE0A+PQZMeAi4QAAJdQEiISCQBAEENAlYDIVAsgSQz2SJMR4CwRFAQoNjz8r2EUBA7es5FftEAPn0CTTLQMBFAkioizAJBYE6CCCgdcDhIwikSgD5TJUc8yAQPAEkNPgekEH4CSCg4e8xFfpMAPn0GTjLQcADAkioB1AJCYEqBBDQKjD4EQLpEkA+0yXIfAjoQwAJ1acXZBI+Agho+HpKRQERQD4DAs+yEPCQABLqIVxCW00AAbW6/RTvFgHk0y2SxIGAfgSQUP16QkbmE0BAze8hFQRMAPkMuAEsDwEfCCChPkBmCasIIKBWtZti3SaAfLpNlHgQ0JcAEqpvb8jMPAIIqHk9I2NNCCCfmjSCNCDgIwEk1EfYLBVqAghoqNtLcV4RQD69IktcCOhPAAnVv0dkqD8BBFT/HpGhZgSQT80aQjoQCIAAEhoAdJYMFQEENFTtpBivCSCfXhMmPgTMIYCEmtMrMtWPAAKqX0/ISFMCyKemjSEtCARIAAkNED5LG00AATW6fSTvFwHk0y/SrAMB8wggoeb1jIyDJ4CABt8DMtCcAPKpeYNIDwIaEEBCNWgCKRhFAAE1ql0k6zcB5NNv4qwHAXMJIKHm9o7M/SeAgPrPnBUNIYB8GtIo0oSARgSQUI2aQSpaE0BAtW4PyQVFAPkMijzrQsB8Akio+T2kAu8JIKDeM2YFwwggn4Y1jHQhoCEBJFTDppCSVgQQUK3aQTJBE0A+g+4A60MgPASQ0PD0kkrcJ4CAus+UiIYSQD4NbRxpQ0BjAkioxs0htUAJIKCB4mdxXQggn7p0gjwgED4CSGj4ekpF6RNAQNNnSATDCSCfhjeQ9CFgAAEk1IAmkaKvBBBQX3GzmG4EkE/dOkI+EAgvASQ0vL2lsuQJIKDJM2NGSAggnyFpJGVAwCACSKhBzSJVTwkgoJ7iJbiuBJBPXTtDXhAIPwEkNPw9psL6CSCg9TNiRMgIIJ8hayjlQMBAAkiogU0jZVcJIKCu4iSY7gSQT907RH4QsIcAEmpPr6n01wQQ0F8z4Z2QEkA+Q9pYyoKAwQSQUIObR+ppEUBA08LHZFMIIJ+mdIo8IWAfASTUvp5TsQgCyl4QegLIZ+hbTIEQMJ4AEmp8CykgSQIIaJLAGG4WAeTTrH6RLQRsJoCE2tx9+2pHQO3ruTUVI5/WtJpCIRAaAkhoaFpJIfUQQEDrAcTHZhJAPs3sG1lDAAIiSCh7gQ0EEFAbumxZjcinZQ2nXAiEkAASGsKmUtIOBBDQHXDwwnQCyKfpHSR/CEBgGwEkdBsJ/gwjAQQ0jF21tCbk09LGUzYEQkwACQ1xcy0vDQG1fAcIS/nIZ1g6SR0QgEB1AkhodSK8DgMBBDQMXbS8BuTT8h2A8iFgAQEk1IImW1YiAmpZw8NWLvIZto5SDwQgUBsBJLQ2MrxvIgEE1MSukXMlAeSTHQECELCNABJqW8fDWy8CGt7ehroy5DPU7aU4CECgDgJIaB1w+MgYAgioMa0i0W0EkM9tJPgTAhCwlQASamvnw1M3AhqeXlpRCfJpRZspEgIQSIAAEpoAJIZoSwAB1bY1JFadAPJZnQivIQAB2wkgobbvAebWj4Ca2zurMkc+rWo3xUIAAkkQQEKTgMVQbQggoNq0gkRqI4B81kaG9yEAAQj8RAAJZU8wjQACalrHLMsX+bSs4ZQLAQikTAAJTRkdEwMggIAGAJ0lEyOAfCbGiVEQgAAEthFAQreR4E/dCSCgunfI0vyQT0sbT9kQgEDaBJDQtBESwAcCCKgPkFkiOQLIZ3K8GA0BCECgOgEktDoRXutGAAHVrSOW54N8Wr4DUD4EIOAaASTUNZQE8oAAAuoBVEKmRgD5TI0bsyAAAQjURgAJrY0M7wdNAAENugOsX0kA+WRHgAAEIOANASTUG65ETY8AApoeP2a7QAD5dAEiISAAAQjUQQAJrQMOHwVCAAENBDuLbiOAfG4jwZ8QgAAEvCWAhHrLl+jJEUBAk+PFaBcJIJ8uwiQUBCAAgQQIIKEJQGKILwQQUF8ws0h1AshndSK8hgAEIOAPASTUH86sUjcBBLRuPnzqAQHk0wOohIQABCCQBAEkNAlYDPWEAALqCVaC1kYA+ayNDO9DAAIQ8JcAEuovb1bbkQACuiMPXnlIAPn0EC6hIQABCKRAAAlNARpTXCGAgLqCkSD1EUA+6yPE5xCAAASCIYCEBsPd9lURUNv3AB/qRz59gMwSEIAABNIggISmAY+pKRFAQFPCxqRECSCfiZJiHAQgAIFgCSChwfK3bXUE1LaO+1gv8ukjbJaCAAQg4AIBJNQFiIRIiAACmhAmBiVLAPlMlhjjIQABCOhBAAnVow9hzwIBDXuHA6gP+QwAOktCAAIQcJEAEuoiTELVSAABrRELb6ZKAPlMlRzzIAABCOhFAAnVqx9hywYBDVtHA6wH+QwQPktDAAIQ8IAAEuoBVEJWEkBA2RFcIYB8uoKRIBCAAAS0I4CEateSUCSEgIaijcEWgXwGy5/VIQABCHhNAAn1mrB98RFQ+3ruasXIp6s4CQYBCEBAWwJIqLatMTIxBNTItumRNPKpRx/IAgIQgIBfBJBQv0iHfx0ENPw99qRC5NMTrASFAAQgoD0BJFT7FhmRIAJqRJv0ShL51KsfZAMBCEDAbwJIqN/Ew7ceAhq+nnpaEfLpKV6CQwACEDCGABJqTKu0TBQB1bIteiaFfOrZF7KCAAQgEBQBJDQo8uavi4Ca30NfKkA+fcHMIhCAAASMI4CEGtcyLRJGQLVog95JIJ9694fsIAABCARNAAkNugPmrY+AmtczXzNGPn3FzWIQgAAEjCWAhBrbukASR0ADwW7GosinGX0iSwhAAAK6EEBCdemE/nkgoPr3KJAMkc9AsLMoBCAAAeMJIKHGt9CXAhBQXzCbtQjyaVa/yBYCEICAbgSQUN06ol8+CKh+PQk0I+QzUPwsDgEIQCA0BJDQ0LTSk0IQUE+wmhkU+TSzb2QNAQhAQFcCSKiunQk+LwQ0+B5okQHyqUUbSAICEIBA6AggoaFrqSsFIaCuYDQ7CPJpdv/IHgIQgIDuBJBQ3Tvkf34IqP/MtVoR+dSqHSQDAQhAILQEkNDQtjalwhDQlLCFYxLyGY4+UgUEIAABUwggoaZ0yvs8EVDvGWu5AvKpZVtICgIQgEDoCSChoW9xQgUioAlhCtcg5DNc/aQaCEAAAqYRQEJN65j7+SKg7jPVOiLyqXV7SA4CEICANQSQUGtaXWOhCGiNWML5JvIZzr5SFQQgAAFTCSChpnYu/bwR0PQZGhEB+TSiTSQJAQhAwDoCSKh1La8sGAG1oO/IpwVNpkQIQAACBhNAQg1uXoqpI6ApgjNlGvJpSqfIEwIQgIDdBJBQu/qPgIa438hniJtLaRCAAARCSAAJDWFTaykJAa0FjOlvI5+md5D8IQABCNhJAAm1o+8IaAj7jHyGsKmUBAEIQMAiAkho+JuNgIasx8hnyBpKORCAAAQsJYCEhrvxCGiI+ot8hqiZlAIBCEAAAoKEhncnQEBD0lvkMySNpAwIQAACENiBABK6A47QvEBAQ9BK5DMETaQECEAAAhColQASWisaYz9AQI1t3U+JI5+GN5D0IQABCEAgIQJIaEKYjBmEgBrTql8ninz+mgnvQAACEIBAeAkgoeHpLQJqaC+RT0MbR9oQgAAEIJAWASQ0LXzaTEZAtWlF4okgn4mzYiQEIAABCISPABJqfk8RUMN6iHwa1jDShQAEIAABTwggoZ5g9S0oAuob6vQXQj7TZ0gECEAAAhAIDwEk1NxeIqCG9A75NKRRpAkBCEAAAr4SQEJ9xe3aYgioayi9C4R8eseWyBCAAAQgYD4BJNS8HiKgmvcM+dS8QaQHAQhAAAJaEEBCtWhDwkkgoAmj8n8g8uk/c1aEAAQgAAFzCSCh5vQOAdW0V8inpo0hLQhAAAIQ0JoAEqp1e7Ynh4BuR6HPD8inPr0gEwhAAAIQMI8AEqp/zxBQzXqEfGrWENKBAAQgAAEjCSChercNAdWoP8inRs0gFQhAAAIQMJ4AEqpvCxFQTXqDfGrSCNKAAAQgAIFQEUBC9WwnAqpBX5BPDZpAChCAAAQgEFoCSKh+rUVAA+4J8hlwA1geAhCAAASsIICE6tXmqF7p2JUN8mlXv6kWAhAwj8DRXQdJZoTvaszrXM0ZF0qpjJWJeatjm0er/wbXPIp3/SDA3yo/KNewBvJZAxTeggAEIKARga6N2sq7Rz8o3Rp3kJcXfqBRZqSSDgG+CU2HnntzEVD3WCYcCflMGBUDIQABCARG4N+HXi+7Nu8mfVvuLA0ysmXysi8Cy4WF3SWAhLrLM5VoCGgq1NKYg3ymAY+pEIAABHwicHLP4XLFXqduX+3Adn1kXckmmbZ69vb3+MFsAkhosP1DQH3kj3z6CJulIAABCKRIID8zV14aeYc0zs7bIcKIzvvJ7PULZPaGhTu8zwtzCSChwfWOi5B8Yo98+gSaZSAAAQikSWDs/hdIh/zWv4oSjURFHZYf0q7frz7jDXMJcGFSML1DQH3gjnz6AJklIAABCLhAoE+LHnLOLkfXGinHORf05ZF3yh7Nu9c6hg/MI4CE+t8zBNRj5sinx4AJDwEIQMAlAhEnzkND/iIZ0brPTmuSky9vHnmPdM5v49LKhNGBABLqbxcQUA95I58ewiU0BCAAAZcJXLznCTKgzW4JRW2f18qR0HuleU7jhMYzyAwCSKh/fUJAPWKNfHoElrAQgAAEPCDQOreZ/HXvM5OKvEuzrvLq4WMlNyMnqXkM1psAEupPf+o+zuBPDqFbBfkMXUspCAIQCDmBJw65Tvq16pV0lZ2cw/DqfNBn50+WuPM/tnAQ4Op47/uIgLrMGPl0GSjhIAABCHhM4OAO/eX2/cakvEqvZl2kXcOW8uqij1KOwUT9CCCh3vYEAXWRL/LpIkxCQQACEPCBQHY0U14/4m5p0aBJWqv1b9VbopGIvLf8q7TiMFkvAkiod/1AQF1ii3y6BJIwEIAABHwkcNO+58pvdxriyopD2u8lK4rWypdrvnclHkH0IICEetMHBNQFrsinCxAJAQEIQMBnAt0bd5AnnXM/M51vQd3aDu88UL5eN0++37jYrZDE0YAAEup+E7gKPk2myGeaAJkOAQhAICAC4wZfJg0y3b2CXd1D9L+H3SgHtN0zoKpY1isCXB3vLlkENA2eyGca8JgKAQhAIEACp/c6XIZ1GuBJBrmZDSpvz7Src5smtnARQELd66d68ANbCgSQzxSgMQUCEICABgQaZzWUOSc+Le3yWnqazZKCVTLwhXNkWeEaT9chuP8E8iRHLpORha2jjcePGTXmMv8zMH9FvgFNoYfIZwrQmAIBCEBAEwJ3H3CR5/KpSlX3CH3ziHukaXa+JpWThlsE+CY0fZIIaJIMkc8kgTEcAhCAgEYE+js3mz+j95G+ZbR7i+7y8sg7JSea5duaLOQPASQ0Pc5cBZ8EP+QzCVgMhQAEIKAZgahE5BXn0ZkdnOe4+7l1adRO1GM7n5s/hWcl+Qneh7W4Oj51yAhoguyQzwRBMQwCEICApgT+3PckOc25+CiIbdfmO0mr3KbyxuJPglieNT0kgISmBhcBTYAb8pkAJIZAAAIQ0JhAu4Yt5Jlht0hORnZgWe7Telcpj5XLhyu+DiwHFvaGABKaPFcEtB5myGc9gPgYAhCAgAEEHh56lajHZQa9Hdxxb1m8ZaXMcG5WzxYuAkhocv1EQOvghXzWAYePIAABCBhC4Oiug+TmAedpk+0RXfaXr5zHdc7btESbnEjEHQJIaOIcEdBaWCGftYDhbQhAAAIGEWjgHHJXV6E3b9BYm6yjkWjl8+cnL/2ce4Rq0xX3EkFCE2PJbZhq4IR81gCFtyAAAQgYSOCmfc+V7k06apd5w6wG8trhd8nOTTpplxsJpU+AWzTVzxABrcYI+awGhJcQgAAEDCWg5O7CPY7TNvuWzlXxk468T9rmNtc2RxJLnQASWjc7BLQKH+SzCgx+hAAEIGA4gfGDL5fsDL1vAN+1cTuZeOQ9oh4PyhY+Akho7T1FQH9mg3zWvpPwCQQgAAHTCJy9y29EXXFuwta35c7y4og7JDuaaUK65JgkASS0ZmBchORwQT5r3jl4FwIQgICJBNSz118ccbvkZeUak/5OjdtLT+eUgRd+fNeYnEk0cQJcmPRrVtYLKPL5652CdyAAAQiYTGCCc+j9gHZ9jCtBPTe+iSPPk5Z8ZlzuJFw/ASR0R0ZWCyjyuePOwCsIQAACphMY4Dxt6P5Bl0okEjGylP3a7i7F5aXy8cqZRuZP0nUTQEJ/4WOtgCKfv+wE/AQBCEAgDAQynPtrvnr436RtXgujyzm04z4yf9NSmbl+vtF1kHzNBJDQn7hYeRES8lnzXwrehQAEIGAygSv6nSJ9WvY0uYTK3NW3t/866BoZ1nFf42uhgJoJcGGSiJnHKGruZ0LvIp8JYWIQBCAAAaMIdMxrJd+d+D/JD9HtjArKimToy2PkS+exnWzhJJAnOXKZjCxsHW08fsyoMZeFs8qaq7LqG1Dks+adgHchAAEImE7gvgMvCZV8qn4omX7j8Lule+MOpreH/GshYPM3odYIKPJZy97P2xCAAAQMJ/CHbkPl987/w7i1btjceVrSvdI6t1kYy6Mmh4CtEmqFgCKf/B2HAAQgEE4CuRk58reBF4azuJ+rUs+yf+OIuyU/05z7moa6IR4UZ6OEhl5AkU8P/qYQEgIQgIAmBG4dMErU4yzDvvVv1VueG36rZEWtvXlN2Fts3Tehod6Tkc/Q/32lQAhAwGICuzbrWnm1eEY09N+lVHa5h/NNaNdG7eSlBe9b3PVwl27TLZpCK6DIZ7j/klIdBCAAgeeH3yY7NWlvFQh1m6mGmQ3k7aWfW1W3TcXaIqGhFFDk06a/qtQKAQjYSGD0br+TMbv/wcbSnceM7ikbS7fIZ6tnWVm/DUXbIKGhE1Dk04a/mtQIAQjYTKB5TmN5Yfjt0jCrgbUYhnfaT+ZsWCizNiywlkHYCw+7hIbqxBnkM+x/HakPAhCAgMj9zj0/W+Y2tRqFelrSE4dcJwd36G81h7AXH+ar40MjoMhn2P8aUh8EIAABkQPa7ikn9hwGCodAdkaWvDjiDunTogc8QkwgrBIaCgFFPkP8N4/SIAABCPxMIDOSIRMGXy7q2z+2nwg0zs6TiUfc41wd3xYkISYQRgk1XkCRzxD/jaM0CEAAAlUIXLXXabJ7i+5V3uFHRaBdXkt584h7pYVzbixbeAmETUKNFlDkM7x/0agMAhCAQFUCXfLbyhX9Tqn6Fj9XIdCrWRd53XlaUsPMnCrv8mPYCIRJQo0VUOQzbH+tqAcCEIBA7QTuH3SJ1Ve9107ml08GtNlNnhl2i6hTFdjCSyAsEmrkXop8hvcvFpVBAAIQqE7ghB6HylX9T6/+Nq9rILBz087SMa+VvLLwwxo+5a2wEAjDLZqME1DkMyx/fagDAhCAQP0E8pyn/rw88k5pkp1f/2BGVBLo16qX88z4TJmy7EuIhJiA6RJqlIAinyH+m0RpEIAABGogcM/+F8mhnfat4RPeqovA4PZ9ZU3xBvl8zXd1DeMzwwmYLKHGCCjyafjfEtKHAAQgkCSBPZt3l38M/YtEI8ZerpBkxe4OH9l5oHy7br58t3GRu4GJphUBUyXUCAFFPrXa10kGAhCAgOcE1J0+1U3WuzRq5/laYV1A3S/16K6D5IMV02VxwaqwlkldDgETJVT7XyuRT/5uQQACELCPwAW7HysD2+5hX+EuV9zAuS3TKyPHyu7Nu7kcmXC6ETDt6nitHyeBfOq2e5MPBCAAAe8JtGrQVL7/49PSjBuruwZ7acFq2f+Fc2RJ4WrXYhJITwJ5kiOXycjC1tHG48eMGnOZnlmKaPsNKPKp6y5DXhCAAAS8JfDAoEuRT5cRd8xvLW8eea/DtZHLkQmnGwFTvgnVUkCRT912Z/KBAAQg4A+Boe37yXHOfT/Z3Cewa/Od5FXncHyDjGz3gxNRKwImSKh2FyEhn1rtwyQDAQhAwDcC2c69K187/C5pmdvUtzVtW6hzo7aV54M+N3+KxJ3/sYWXgO4XJmkloMhneP8iUBkEIACB+ghcv/fZ8vvuB9U3jM/TJNC7WVdpk9tcXlv0cZqRmK47AZ0lVBsBRT51343JDwIQgIB3BLo1bi9PHXq9ZDrfgrJ5T2Dv1rtIPB6X951bNLGFm4CuEqqFgCKf4d75qQ4CEIBAfQT+c+gNor6ZY/OPwEEd+suywjXy1drv/VuUlQIhoKOEBn4REvIZyL7IohCAAAS0IXByz+EywnlqD5v/BCYMvlz6O8+OZws/Ad0uTApUQJHP8O/wVAgBCECgLgKNshrKHQPPr2sIn3lIYOa6H0T9n80OAjpJaGACinzasbNTJQQgAIG6CIwdeIG0z2tV1xA+84hAcXmJnPTOdVIWq/BoBcLqSEAXCQ1EQJFPHXdJcoIABCDgL4F+LXeWs3f5jb+Lstp2Ahd9dI98t3HR9tf8YA8BHSTUdwFFPu3ZwakUAhCAQG0EohKRh4ZcIRlRLa6FrS3N0L4/cdFU+ed3r4S2Pgqrn0DQEuqrgCKf9e8QjIAABCBgA4GL9zxe9mm9qw2lalfj2uKNcua7N2uXFwn5TyBICfVNQJFP/3csVoQABCCgI4G2zk3Q/7r3WTqmZkVOZ713i6wsXm9FrRRZP4GgJNQXAUU+698BGAEBCEDAFgIPDr5MmuTk21KuVnU++M1z8srCj7TKiWSCJxCEhHouoMhn8DsWGUAAAhDQhcChHfeR33cbqks6VuUxb+MSueLTB62qmWITJ+C3hHoqoMhn4o1nJAQgAIGwE8iJZsm4QZeFvUwt6yuPlcvJk6+XQufWS2wQqI2AnxLqmYAin7W1l/chAAEI2Eng+n3Olp5NO9lZfMBVXzPtIZm2enbAWbC8CQT8ktCIFzCQTy+oEhMCEICAuQR6Nuko3xz/lORkZJtbhKGZf7Jypgx+abRUxGOGVkDaQRDIkxy5TEYWto42Hj9m1BjXD124/g0o8hnEbsKaEIAABPQmMM658Aj59L9HW7YWyimTb0A+/Udv/IpefxPqqoAin8bvbxQAAQhAwHUCZ/Q6Qg7tuK/rcQlYP4FRH9wpP25eXv9ARkCgBgJeSqhrAurI55Vr41tGjZWJeSphNghAAAIQgECT7Dy5bb8xgAiAwPPz35X/zHsrgJVZMkwEtkmocjzlem7V5oqAjv/H+NML4qXX3BV/Mx/5dKs1xIEABCBgPoG79r9Q2jRsbn4hhlWwvHCNnPv+7YZlTbq6ElBud3d8Ur5yPeV8buSZtoCOe2jcESWxsgfuik9suEmK3ciJGBCAAAQgEAIC+7TaRc7ofWQIKjGrhHg8LqdNuUnWl242K3Gy1ZrARikS5XrK+ZT7pZtsWgI64ZEJA8tjsf/dF3srb5Wwo6fbDOZDAAIQCAuBjEhUHhpyhUSdP9n8JTB2xr/lnaWf+7soq1lBQLmecj7lfsoB0yk65X8ZHn744R5lZeVvPBR/N3+hrE0nB+ZCAAIQgEDICFza54/Sr1WvkFWlfznfrpsvf532T/0TJUNjCSjnU+6nHFC5YKqFpCSgzzzzTHZRWfHLz8W/aDRLlqW6NvMgAAEIQCCEBNo3bCnX9D89hJXpXVJpxVb54zvXSWmsTO9Eyc54Asr9npcvGikXVE6YSkEpCejq9avvniMru74fn5ORyqLMgQAEIACB8BK478A/SSPn6nc2fwn8+ZP75Zv18/1dlNWsJfBebE6GckHlhKlASFpAnRNPf1ssZac/Gv+gYSoLMgcCEIAABMJL4LddB8sx3Q8Ob4GaVjbZOefzwW+f0zQ70gorAeWCygmVGyZbY1ICOn78+A4Vsdhj4+NT8pwFk12L8RCAAAQgEGICuRk5ctcBF4a4Qj1LW1+yqfKq97ie6ZFViAkoF1ROWOmGjiMmU2rCAurc1iFSHq94/rX413k/xtckswZjIQABCEDAAgI37nuOdGuc1H+DLKDifYnqaUfLnPt+skEgCALKCV+Pz8xTjqhcMdEcEj6Hs237tqOXyoaTHpePGiQanHEQgAAEIGAHgd5Nu8hjB18rGdGE/7NiBxiPq3x49sty+/QnPV6F8BCom8B8WRXtE+ncdN5Xsze8/trrX9Q9+qdPE/oG9KmnnmpWHqu47Yn4x/l8xZ8IVsZAAAIQsIvAhCGXS3ZGll1FB1ztAucZ75d88veAs2B5CIgoN1SOqFxROWMiTBIS0I0FG2+bKvNzlsmGRGIyBgIQgAAELCJwzi6/kSHt97Ko4uBLrYhVyCmTb5AtZUXBJ0MGEHAIKEdUrqicMREg9Qro+IfH9yuLVZzyUvxLDr0nQpQxEIAABCwi0CynkdwyYJRFFetR6o1f/Es+XjlTj2TIAgI/E1CuqJxRuWN9UOoV0IqK2EPPyhcNimRrfbH4HAIQgAAELCNw7wEXS6vchI64WUbGu3I/Xz1bbv3qce8WIDIEUiSgXFE5o3LH+kLUKaDOfZ2OXRvf0vuT+Nw6x9W3CJ9DAAIQgED4CAxss7ucsvPI8BWmcUVFZSVy8jvXi3PFscZZkprNBJQzrolt3kU5ZF0c6hRL52Hz17wY/7IRFx7VhZDPIAABCNhHIDOSIQ8NuUIikYTvumIfJA8qvuDDv8ncTUs8iExICLhDQDnjS/GvnAuSYtfUFbFWAX1gwgOHFERKdpoZZ0evCyCfQQACELCRwOX9TpY9WvSwsfTAan514Yfy6PevB7Y+C0MgUQIzZYkoh1QuWducWgU0FpOrX4vP4LZLtZHjfQhAAAKWEuiU11qu2us0S6sPpuxVRevlrHdvDWZxVoVAkgTUt6DKIZVL1ja1RgFVVy+VRysGTIv/yLGV2sjxPgQgAAFLCdw/6FLJy8q1tPpgyj7z3ZtlTcnGYBZnVQikQEA5pHLJB//xYN+aptcooLHy+JVvyjc55RKraQ7vQQACEICApQSO6XaQHL3TYEurD6bs+2Y+LW8snhrM4qwKgRQJKIdULimxyFU1hfiVgKo72MclftQHse8zaprAexCAAAQgYCeBhpk5ctf+F9pZfEBVz9mwUK78dHxAq7MsBNIj8KHjksopH3300abVI/1KQDcVbDp2dnx5eYmUVR/LawhAAAIQsJjArQNGS+dGbS0m4G/pZRXlcpJzy6XiilJ/F2Y1CLhEoNhxSeWUxVuLj6se8lcCWhGPnf5xfG5+9YG8hgAEIAABewns3rybnL/7H+wFEEDlV342Tr5a+30AK7MkBNwjoJxSuWX1iDsI6COPPNI+Hpe+s5wnerJBAAIQgAAEFAF1NeqEwZdLZjQTID4R+GD5dLnn6//5tBrLQMA7AsoplVsqx6y6yg7/mmwt33ridFkU5+KjqojC+fNhHfeR3k27SkFZkRSUF1f+uWWr83OZ+vnn185nRc7JGDyIIJz7AFVBIFECo3b7nRzQrk+iwxmXJoFNpQVy6uQbnUs4+Nc3TZRM14CAckrllvuWdzvRSeeubSntIKBlzlekU+M/NNz2IX+Gl8CcDYvkv4fdJC0aNKmzyLjza0thpaAWy0+C+oukbikr/JWwbpNX9ecWJbc/y+wvr4ukuLyUf1brpM6HENCHQEvn34ib9z1Pn4QsyOR852lHiwpWWlApJdpCQLllv3jX0516twvo9vt8Pv744y02F21ZdlH8qRx+67JjlxjeaYBMPOIe3x+lp6RWffNas6D+9O1rpbCqb2TLt0msEuDahLeYk/Tt2GWpMgACTx1yvfxx5+EBrGznkk9+P1FOnXKjncVTdWgJRJ0Tee6LnFTauGGjDqeddto6Vej2b0ALthYMWShrSxz5zAktAQrbgcCkJZ/J1Z9NkFv3G73D+16/UM+ObpSdV/l/t9aKxWM7fkPrfGu74ze2VYX3l1MMavqG9qf3iqWkYqtb6REHAkYSGNyuL/LpY+eWFKySCz+628cVWQoC/hBQX2wqx+y2NTLEWfEFtep2Ac2IZQyaLcsb+ZMKq+hC4I7pT8ohHfd2/r+PLimllEc0EpUmOfmV/08pQA2TKmIVO3xLm9A3tttOO6gU4F9/Y7s1Vl7DSrwFAf0IZEUzZLxz4RGbPwTUL9GnTr5BNm4t8GdBVoGAzwSUY/aMtR3kLLujgJbGyod/H1+xw1XxPufGcgEQUL+VHP/WNTLz+H9L+7xWAWSg75IZzn+Am+Y0qvy/W1mq+/ptO62g6je0V0+bIJ+umuXWMsSBQNoErtrrdNm1+U5pxyFAYgRu/+oJec+58p0NAmEloBxTuea2+irPAXUujW9UvLVkzUXxf+dUcHnINjZW/XlA2z3lvaMf5DYrAXV9WcFq2ef5M2VFUeWpMQFlwbIQ+IlAV+dm87NP+K/kZjYAiQ8EZqydKwOeP0s4QuIDbJYIjEBG5XmgJ5fmZjdoddZZZ22p/MazNF46eImsL0E+A+tL4At/vHKmXPTRPYHnYWsCHfJby0sj7pAGGdm2IqBujQg8MOjPyKdP/Shx7gpy0jvXIZ8+8WaZ4Agox1SuqZxTZVEpoJGyyG4/RtbkBpcWK+tAYNysF+SlBe/rkIqVOezbZjd5eOiVVtZO0foQOKHHoXJElwP0SSjkmfzp4/tktvO8dzYI2EBAuaZyTlVrpYBWRCp6r4xv5KsXG7pfT42nT7lJ5m9aWs8oPvaKwEk7j5Br+5/hVXjiQqBOAvmZuTJ24P/VOYYP3SPw5uKpMmH2i+4FJBIENCewMrYxWzmnSvMnAZX4rmtki+Zpk54fBDY599o8ZtJVog4LsQVD4Pp9zpajuhwYzOKsajWB2/cbIx2d00HYvCewtnijnDHlZu8XYgUIaERgTWSLOIfid1Up/XQIPi49V8c3a5QiqQRJYMa6efJ/3IsusBaoW0o9dej1slszrkAOrAkWLty3RU9Rj9xk84fAOe/dJiuL1/uzGKtAQBMCyjUjjnOqdKJPPPFEXoZkNNoghZqkRxo6EHj4u1fkoVkcGgqqF+pG/a8cPlZa5DQOKgXWtYiAuh3KhCFXiLr1GJv3BMZ/65xvv/AD7xdiBQhoRkC5pnJO5Z7RLSVbem6UwqK4ZkmSTvAELvnkPvl23fzgE7E0g26NO8hzw2+TzAhSYOku4FvZ/7fHsTLAuQiOzXsCP2xaIpdNvd/7hVgBAhoSUK6pnLOorKhH1FHR1pvixfinho0KOqUi5zzQP0y6svIZ7EHnYuv6QzvsJfcPusTW8qnbBwKtc5vJDfuc48NKLFHuPAnt5Heul8LyEmBAwFoCyjkrpKJNVGKSX+pcE28tCQqvk8Bc57f1s51zldiCIzBqt9/LRXscF1wCrBxqAvcfeImrT/sKNaw0i7vu84fls9Wz04zCdAiYTaDSOR33jDqXI+UXS1nlxUhml0T2XhF4Zv5kudN5ZjxbcAT+tv//ycEd+geXACuHkoDap45z7vvJ5j2BqSu/kTv4d9R70KygPYFK53TcM+qcdO4I6FZOMtO+ZcEmeM20h2QazyoPrAmZ0Ux5dtgt0t05L5QNAm4QyHb2qfGDL3cjFDHqIVBQViQnT75eKuKxekbyMQTCT0A5p3LPaCQeyXNeZIW/ZCpMh0BZrEKOfetq5yFam9IJw9w0CDRv0EReGTlWGmc1TCMKUyHwE4Fr+58pOzftDA4fCIz5YKz8uHm5DyuxBAT0J6CcU7lnNB6P5xfHyxBQ/XsWeIaLC1ZV/hbv7DOB52JrArs230n+c9iNzg18OW3b1n3AjbrVN+l/7vtHN0IRox4CL/z4njw59816RvExBOwhoJxTuSfnftrTc1cqnbj4U7nWORzPFhwB9Zzuu/a/MLgEWNl4AuMGXyYNMnOMr0P3ApYXrpFzuYhT9zaRX0AEopFIpCA3klUW0PosayCB2756QqYs/cLAzMOT8sV9TpBTnOfGs0EgWQJqvxnWaUCy0xifJAF1pOj0KTfJulKeMpgkOoaHnIByTuWe0ZjEChpKNgIa8oa7WV5M4nLiO38V9ds9W3AE/jn0StmPm4cH1wADV1bnD9+x3/kGZm5eynd9/R95e+nn5iVOxhDwmIByTuWe0Vg8VthAsis8Xo/wISOwuniDHP/WNaJurMwWDIGcjGx5ccQd0jGvVTAJsKpxBO4ceIG0y2tpXN6mJayeIHfttH+Yljb5QsAXAso5lXuqJyEV5EoW94bwBXu4Fvlo5Uz508f3hasow6pp27CFvDzyTsnN4Hw+w1rne7r9W/WSc3Y92vd1bVtwa0WZnPTOdVJSsdW20qkXAgkRqHROxz2jzuW0BTnxLC5rTggbg6oTeODb5+TlBR9Uf5vXPhLYq1Vveezga3xckaVMI6DumvDQkL9INMJ1p173Tj3nfeb6+V4vQ3wIGEug0jkd94xmSMaqJpFc7ulibCuDT1ydaP/j5mXBJ2JxBuppNjfyPG+L94C6S794z+Olv/OLCpu3BNTFmfd/86y3ixAdAoYTUM6p3DPaMKvhD00lryEGanhHA0x/49YCOWbSVVLKIacAuyByTf8z5Hc7DQk0BxbXj0A75zSN6/Y5W7/EQpbRBudq99Om3OhcoskGAQjURkC5ZqVzlkfmRU899dTCCqnY0kzyahvP+xCol8D0tXPlwo/urnccA7wj4NzWQp485Drp06KHd4sQ2TgCDw76szTO5t93rxs36v07ZSl3BvEaM/ENJ6Bc07kCfvN5551XVHlCUDwi81pHGhteFukHTeAfs1+Wfzr/ZwuOQF5WbuVFSa0aNA0uCVbWhsCwjvvK77oN1SafsCbyr+9elWfmTw5redQFAdcIKNeMReI/qICVApohkdmt4o1cW4BA9hK4+ON7ZNb6H+0FoEHlXRq1kxdG3C7Z0UwNsiGFoAg0cG7TpZ54xOYtgYWbVzh3A7nX20WIDoGQEFCuqZxTlfOTgMYz5rSVJtyMPiQNDrKMovLSyvNBC8qKgkzD+rUPbNdHxg++3HoONgO4bu+zpHuTjjYj8Lx2516Gcsrk62Uz/955zpoFwkFAuWaG45yqmp8OwWfFZ3WLtMYYwtHfwKuYs3GRnP3urYHnYXsCZ+5ylFzW9yTbMVhZf6+mneWSPidaWbufRd/0xb9E3Q+ZDQIQSIyAck3nzp+z1OhKAc2J5HzQSZo3cL4WTSwCoyBQD4GnnfOh7prxn3pG8bHXBG4bMFrUeYBsdhEYN+gyyc7Isqton6v9YvV3cstXj/m8KstBwFwCyjGVayrnVFVUCuhZZ521pULiP3YVHulnbmv1y/yqz8bL56tn65eYRRllOHf6fXrYzbJzk04WVW13qWf0OkIO7ri33RA8rr6orKTyaUdlMZ5i7TFqwoeIgHJM5ZrKOVVZlQKqfsiJZk7aOdKWR3IqGGyuENjqPCf+2ElXy/qSTa7EI0hqBJrmNJJXD/+bNM3OTy0As4whoHp8+35jjMnX1ETVLefmblpiavrkDYFACCjHVK65bfHtAloRrfhwN+lQaaXbPuRPCKRLYFHBSuck/RskHuf2zOmyTGf+zs45geqb0AwexZgORu3n3rX/hdK6YXPt8zQ5wdcWfiSPzHnV5BLIHQKBEFCOqVxz2+LbBTQ/O//9LtKigXpmMBsE3CTwxuKpct3n/3QzJLFSIDCs0wC574A/pTCTKSYQGNB6Vzmj95EmpGpsjquL1stZ73GBpbENJPHACCi3VI6pXHNbEtsF9LTTTlsXj0Tm7Sxtt33GnxBwjcCtXz0u7y770rV4BEqNwPl7HCNn9T4qtcnM0paA+mb7oSF/EfU0LDbvCJz57i2yuniDdwsQGQIhJaDc0nno0VzlmttK3C6g6o2sSPSxgZEe3I5pGx3+dI1AhXO/vBPfvlZWFK51LSaBUiOgbk5+YNs9U5vMLC0JXNrnj9KnZU8tcwtLUvd/84y8vviTsJRDHRDwlYByy0yJPlZ10R0ENDsz+7/9pEvEGVR1DD9DwBUCq5xvDk5wJLSCK0dd4ZlqEHV7HvWkpC75HO1IlaFO8zrmtZJr9z5Dp5RCl8v3GxbJXz4dF7q6KAgCfhBQTqncMicr539V19vBNJ1L45c7R3Bm7C48PaMqJH52j8AHK2bIpZ/83b2AREqJQKvcZvLK4WMlL7NBSvOZpA+B+w68RPKzGuqTUMgyKasol5MmXyfqKW9sEIBA8gR+dsrpyjGrzt5BQNUHzrlEj+0f6VlQdRA/Q8BNAvc5h7JeXbj9Qjg3QxMrCQJ7tughTx5yHZcdJsFMt6G/7TpYft9tqG5phSqfq6dNkC/XfB+qmigGAn4SUE6ZGY0+Xn3NXwlobnbuM7tG2mfmCk/RqA6L1+4ROHXyjbJg8w6/DLkXnEgJE/hdt6Fyq/O0JDbzCDTMzJF7DrjYvMQNyvjD5TN4optB/SJV/Qgol6x0Ssctq2f3KwE944wzNkYk8uqgaC8e8VCdFq9dI7Bxa4Ec+9ZVUlqx1bWYBEqNwF/2OlWO735IapOZFRiBG/c5V7o2bhfY+mFfePPWwsp7GMeEexiHvdfU5x0B5ZLKKZVbVl/lVwJaOSAav3WE7FHKxUjVcfHaTQLqsNbFH93rZkhipUjg0YOvkf6teqU4m2l+E9i1WVe5cI/j/F7WqvXO/2CsqAdpsEEAAqkRUA6pXDKaGbmtpgg1Cuj5554/IzOW8dm+kW786lcTNd5zjcCE2S/Kv77jqSKuAU0xUK5zMdJLI+6Utrk8RSdFhL5OmzD4CsnKyPR1TZsWe2rum/LvedufGGhT6dQKAdcIKIdULjn67NHTawpao4CqgdGo3HJkpG8BtzWuCRvvuUlAPVd59voFboYkVgoEOua3lpdG3ik5Uc7/TgGfb1PO2eU3Mqh9X9/Ws22hpQWr5YIP77KtbOqFgKsElDsqh1QuWVvgWgX0glEXTM6PN1iwp3SqbS7vQ8AVAoXlJXLMpCulsKzYlXgESZ3AgDa7yT+HXpl6AGZ6SqBFTmMuGvOQcDwel1Mn3yDqHHU2CEAgdQLKHZVDKpesLUqtAqomOJfN3/y7aP8tfAtaGz7ed4vAdxsXyTnv1XiaiFtLECdBAqf0GilX7XVagqMZ5ieBuw+4SFrmNvVzSavWumP6k/Lu8q+sqpliIeA2AeWMv43spWQokr0AAD95SURBVG69dHNdsesU0DHnjXm2ZaTRnP0jO8fqCsJnEHCDwH9/eFvu+fq/boQiRpoEbtr3XDmi8/5pRmG6mwTU41NP2XmkmyGJVYXA12vnyXWf/7PKO/wIAQikQkA5Y6to4++UQ9Y1v04BVRMzMqLnHSt7lzSU7Lri8BkEXCGgHnf3xervXIlFkNQJRCNR+c9hN4q62poteAKZkQwZP/hyiTiPqmNzn0CJ85Sjk965TrbGyt0PTkQIWERAuaJyRuWO9ZVdr4Cqq5eyohlP/jbSv6S+YHwOgXQJqP8AqPuDbijdnG4o5qdJoHF2nrwycqw0d847ZAuWwBX9TpbdW3QPNokQr64eDzxrAxdChrjFlOYTAeWKyhlru/K9ahr1Cqga3DS/6ZUDpXtpB2lWdS4/Q8ATAgu3rHQuBLhR1AUBbMES6N6kozw3/FZR38CxBUOgS35b55zc04NZ3IJVJy3+VMbPesGCSikRAt4SUI6oXFE5YyIrJfRflRdeeKHkN785alNXaTnkY5nLsfhEyDImLQJzNy2pfEb50A57pRWHyekT2Klxe2nZoIm8sfiT9IMRIWkCTx7yV779TJpaYhPWlWyS4a9dLFu4A0diwBgFgVoIqJODzo8cWtAsmveXM88488Nahu3wdkLfgKoZo84dNaF9vOms4bInJ8nsgJAXXhG46ctH5X2uSPUKb1Jxx+z+B7lg92OSmsPg9Akc0+0gOarroPQDEaFGAurOGyuK1tX4GW9CAAKJE1BuqBxRuWKisxIWUOfk97hzGO4PR0T2LOwWaZVofMZBIGUCFfGYnPDWtbKS/0CkzNDNifc4twA6qD3fSLvJtK5Yec7TqdRtl9i8IfCP2S/Jiwve9yY4USFgEQHlhMoNlSMqV0y09IQFVAUcPXr0soxo9PTRkYMLc4WnpSQKmXGpE1hZvL5SQitiFakHYaYrBDKjmfKscz5oN+eQPJv3BG4ZMEo65bfxfiELV5i/aalc+vHfLayckiHgLgHlgsoJK93QccRkoicloCqwc1+nl5wFHzsjMrgomYUYC4FUCby/YrpcNvWBVKczz0UCLZxzQdWV8Y2yGroYlVDVCezZvLuc75z2wOY+AfXL7MmTr5eCcp685j5dItpGQLmgckLlhsnWnrSAqgVaN299SW9pu3BotDdfSyVLnPEpEbh35v/ktYUfpTSXSe4S2K15N/nPoTdItPIyMXdjE00qqU4YcoXzJLpMcHhA4PovHpZPV83yIDIhIWAXAeWAygWVE6ZSeUoCetxxx21tmJV79B9k7y27SYdU1mUOBJIioE4qOXXKjbJw84qk5jHYGwJHdj1Q7hx4gTfBLY86erffy8C2e1hOwZvyP135rdz21RPeBCcqBCwioNxPOaByQeWEqZSekoCqhc4+++wfsrIyDz8vclCBc3umVNZmDgSSIrChdEvlTeq3VpQlNY/B3hC4tO8f5eSew70JbmnUVg2ays0D6n2AiKV00iu7oKyo8tC7uriRDQIQSJ2Acj7lfsoBlQumGillAVULjjpr1FTnYfMnXBQdVthGeFpKqk1gXuIEvlgzR8Z8MDbxCYz0lMA/h14pA1rv6ukaNgW/78A/STOePOVJyy/48C6ZvzmpayQ8yYOgEDCZgHI95XzK/ZQDplNLWgKqFnZOPH29QTTrgj9HRxY2kdx0cmEuBBIi8MicV+W/895KaCyDvCXQIDNHXhxxh3TI49Zs6ZIe2r6fnNhzWLphmF8DgRd/fE8e//6NGj7hLQhAIFECyvGU6ynnU+6X6LzaxqUtoCrw6HNHP5YnObdcGhlR4PxZ21q8DwHXCKgbSH+3YaFr8QiUOoF2eS3l5ZF3Sm4Gf/dTpZjtXHA0fvDlqU5nXh0EVhSuFfXvBRsEIJA6AeV2PzveLcr5Uo/0y0xXBFSFGzNqzG0tI40mXCYjC5HQXwDzkzcECstL5JhJV0ohj9DzBnCSUfu36i3/OujqJGcxfBuBK/c6TXo367rtJX+6RCAej8sZ794s60o3uxSRMBCwj4ByOuV2yvGU67lFIKFnwSe62Ouvvf72cUf9vlnfeOc+n8uC7DLhLk2JsmNc8gTWlGyURVtWyu+7DU1+MjNcJ7B7i+6VMd9fPt312GEOqG7sr25rlcVtl1xvs7p927hZL7gel4AQsIXANvlsHW083pHPy9ys21UBVYkhoW62h1j1Efhm/Xxp7ly0MaDNbvUN5XMfCAxxzmP8eu08mbNxkQ+rhWMJJZ+7NNspHMVoVMWs9T/K8W9fK+VxvgjRqC2kYhABL+VTYXDtEHxVpsqSlS1zOL4qFX72isDlzlOSvnSujmcLnoDzHGB58tDrRD3Jh61+Aif2OExGdB5Y/0BGJEVA3artpHeuk5KKlG5PmNRaDIZAGAl4LZ+KmScCqgIjoYoCmx8ESmNlcuykq2Sjc59QtuAJ5DuP6XzZeVynuqclW+0E1ONM/7b//9U+gE9SJvCXT8fJ1+tSvj1hyusyEQJhIOCHfCpOngmoCo6EKgpsfhBYsGWFnDr5RlEXHbAFT6Br43by/PDbnPMaXT/LJ/jiXMrg9v3GSHtuX+USzV/CvLvsS1HnfrJBAALJE/BLPlVmnv/XgXNCk98BmJEagbmbFktGJCrqPES24Al0adRW2jVsIa8u+ij4ZDTLYK+WveQh53nvUWd/ZXOPgDoKMuzVC2Wz89QjNghAIDkCfsqnysxzAVWLIKGKApsfBD5YMUOGtt9LujRq58dyrFEPgb2c2zNt2VooU1d9W89Iez6OSkReGnmHdMxvY0/RPlV6+pSb2Nd8Ys0y4SLgt3wqer79+s3h+HDtrLpWo57zfIJz5euqovW6pmhdXncOvEAO67iPdXXXVvAFexwj+/D40trwpPz+Y3Nel6fnT055PhMhYCuBIORTsY74DXzchHFjV8c2jx4rE/MKpdTv5VnPEgIHOd+Cvn3U3yWDcxC16Lg6NLrv82fKvE1LtcgnqCTa5jaXOSc+LU1y8oNKIZTrLnLOAd/z6ZM59B7K7lKUlwSCkk9Vky+H4KvC43B8VRr87BWBhc5/kIqcpyUN6zTAqyWImwQB9cz4YR0HyJNzJ0qpc4scW7d/HXy1qNMS2NwjEHOOehw98XLrf7lxjyiRbCEQpHwqxr4dgq/aUA7HV6XBz14RuOvr/8gbiz7xKjxxkyTQq1kXefqwmysvFEtyaiiGH+qchnBs90NCUYtORdzy5WPy4YqvdUqJXCCgPYGg5VMB8v0b0G1d4ZvQbST400sCby7+VE7ocag0zWnk5TLETpBAjyYdpWl2I3lzyacJzgjHsJxolrx++F3SokGTcBSkSRXqARSnTrlBYtx+TZOOkIYJBHSQT8UpMAFViyOhigKblwSKK0rl4xUz5bReh3M+qJegk4itHpu6eMtKmbFuXhKzzB56wz7nyG+7DTG7CM2yLyorkeGvXSSrizdqlhnpQEBfArrIpyIUqICqBJBQRYHNSwLLi9Y6V8Wvk6O6DvJyGWInQWCk8/hJdcPwJQWrkphl5tCezre+/z70esnkgjhXG3jBR3+Tt5ZMczUmwSAQZgI6yafiHMg5oNUbzDmh1Ynw2m0C//zuFfnfvLfdDku8FAlkZ2TJC86TkjpbcC/McYMvk5yM7BRJMa0mAq8v+lj+Mfvlmj7iPQhAoAYCusmnSlELAVWJIKGKApuXBM557zaZs2Ghl0sQOwkCrRs2l1ecZ8bnZTZIYpZZQ0/ZeYQc2nFfs5LWPNvVzj1+z3z3Fs2zJD0I6ENAR/lUdLQRUJUMEqoosHlFoKC8WI6ZdJWoc8fY9CDQp2VPeeKQ6/y/IbEP5TfJzpOxA//Ph5XsWuKs9251zvvcYFfRVAuBFAnoKp+qnMDPAa3OlHNCqxPhtZsE1pRsrDzv8HfdhroZllhpENilWVfn/MhMmeKcExqm7e8HXiJD2vcLU0mB1/LgN8/Jvd88HXgeJAABEwjoLJ+Kn3YCqpJCQhUFNq8IzFz3g7R0boezr3M1NpseBAa16yOzNyyo/L8eGaWXxb7OozbVuZ+RiO8Pm0svcY1nz924WI5560opi1VonCWpQUAPArrLp6KkpYCqxJBQRYHNKwJTln4hh3cZKO3yWnq1BHGTIKBE7YjOB4i6b+sK544FJm8Zkahzbuud0j6vlcllaJV7WUW5HPHGJbLIgrsmaAWeZIwkYIJ8KrBanQNavdOcE1qdCK/dIlAaK5Nj37pa1DPK2fQg0DCrgbzsiFub3GZ6JJRiFhfvebz0a9UrxdlMq4nAtZ8/JF84N51ngwAE6iZginyqKrQWUJUgEqoosHlB4MfNy+X0KTd5EZqYKRLomN9aXhxxh6gnB5m4dXC+9bxu77NMTF3bnD9yHrM5dvpT2uZHYhDQhYBJ8qmYaXsIvmpDORxflQY/u0nge+e8siznApjB7fu6GZZYaRDo5NwbtHOjNvLSgg/SiBLM1McPvlb6tNw5mMVDuOrmrYUy7LULZcPWghBWR0kQcI+AafKpKjdCQFWiSKiiwOYFgQ+Wz5CD2u8lXRq19SI8MVMgoG7PVKIeo7pyZgqzg5kysvN+cvOAUcEsHtJV1f0+P3S+AWWDAARqJ2CifKpqtD8EXxU5h+Or0uBntwiUxyvkhLevFXWDazZ9CNw6YLQc7jyy04QtNyNHHhj0ZxNSNSbHZ354R/4z7y1j8iVRCARBwFT5VKyMElCVMBKqKLC5TUA9L/7Ed/4qsXjM7dDES5FA1Lma/L+H3SS7NO2SYgT/pl23z1nSrXEH/xYM+UpLC1bLqA/uDHmVlAeB9AiYLJ+qcmMOwVdtE4fjq9LgZ7cILNiyQkrKt8phnXh0oltM042jnqE+vPMAeWruJCl2DsnruClBfvzgv0pG1Mh/TrVDGo/H5feT/iLf8dhc7XpDQvoQMF0+FUnjvgHd1n6+Cd1Ggj/dJDB2xr9l4qKpboYkVpoEejTpJM8Mu1kyI3oK3vghl0t2hplX7afZGk+mq7+DYXsqliegCGotgTDIp2qenv+iJ7hb8U1ogqAYlhSBNxdPlRN6HCZNcvKTmsdg7wiow9stchrLG05vdNrO7H2kXOjc95PNHQLqKWV/fPs6qeBUGHeAEiV0BMIin6oxRguoKgAJVRTY3CSgDvVOXfmNnNbrCOewqrEHCdxEokWsfdvsKquL12tzQ/LmjhC/NPIOycvK1YKP6UmUlJfKiNf/ZPyTsEzvA/nrSyBM8qkoGy+gqggkVFFgc5PAssI1juxskCO7HuhmWGKlSWBYxwGibpu1qGBlmpHSn/7AoEvlQOcZ9mzuEPjTx/fJa4s+dicYUSAQMgJhk0/VntB8vcM5oSH726ZBOQ/NfknUrWDY9CGQlZEpz4+4TXZq1C7QpPZvs4ec4Rx+Z3OHwNtLpsmD3z7nTjCiQCBkBMIon6pFoRFQVQwSqiiwuUng7Pduk+83LHIzJLHSJNCiQRN5ZeRYaZTVMM1IqU1XF0NNcC48ikQiqQVg1g4E1pVsqnwkbnyHd3kBAQgoAmGVT1VbqARUFYSEKgpsbhHYUlYkx7x1lRSVlbgVkjguENi9RXf59yHXO/+A+S+Bl/Y9UfZo0cOFKgihCJzr/JKn7sPLBgEI7EggzPKpKg3FOaA7toxzQqvz4HV6BNS5oOrG2L/rNiS9QMx2lUCvZl0kNzNb3ln6uatx6wrWKa+1c0uoW7jtUl2Qkvjs4dkvy50znkpiBkMhYAeBsMun6mIoBVQVxoVJigKbWwS+dm4P0zq3mezTele3QhLHBQIHOBcBzdu0RL5ZP9+FaPWHeOKQv/LtZ/2YEhrx4+Zl8tuJV8jWWHlC4xkEAVsI2CCfqpehOwRfdQflcHxVGvycLoFLP/m7zFg7N90wzHeZwCNDr5J9ffjF4Hc7DZGjdxrscvZ2hquIVcjJ71wvBeXFdgKgagjUQsAW+VTlh1pAVYFIqKLA5gaBkoqtcsykq2RTaYEb4YjhEoEGmTny4ojbpX3Dli5F/HWYhs4a9x5w8a8/4J2UCNz4xb9k6qpvU5rLJAiElYBN8ql6GHoBVUUioYoCmxsE5juHDU+fcpMboYjhIoH2ea0qbwrfwHl2vBfbjfucK50btfUitHUxP1s1S2796nHr6qZgCNRFwDb5VCxCew5o9UZzTmh1IrxOlcCcjYtEiQ43IU+VoDfzOjgS2t15ZOfzP77n6gK7N+8mjx58jUQjVvy+7iq76sEKy4pl2KsXydrSTdU/4jUErCVgo3yqZlsjoKpYJFRRYHODwPvLp8shHfrzrZgbMF2MsYdze6aKeIV8sGKGK1HVTZ5eGH6bdG3c3pV4tgcZ9f4dMmX5l7ZjoH4IbCdgq3wqANb9Ss/h+O37PT+kQaDckZzj375W1ji3aGLTi4A6XH5010GuJHXOrkeLutKeLX0CLy14Xx79/vX0AxEBAiEhYLN8qhZa9Q3otn2Wb0K3keDPdAiom9RPd66KP3nn4TwVJx2QLs9VTyg6susB8trCj0XdwzXVraXzxKWXRtzh3Gu0QaohmPczgZVF62Tk63+SovJSmEAAAg4B2+VT7QRWCqgqHAlVFNjSJfDj5uWytaJMDu24T7qhmO8igeyMLBnZeaA8Ne/NlKVnwuArZL+2u7uYlb2hjp10tcz06V6t9lKmclMIIJ8/dcq6Q/BVd1AOx1elwc+pErhj+pMyafGnqU5nnkcEujZuJ887529mRZP/PXtwu75ySq+RHmVmV9j7Zj4tby7h74ddXafa2gggn7+QSf5f5l/mhuInvgkNRRsDL2Li4qlyYs9h0iQ7P/BcSOAXAl0atZM2DZvLa4s+/uXNen5Swvra4XdJK+fJV2zpEZi9foEc99bVos6ZZoOA7QSQzx33AOsFVOFAQnfcKXiVPIHiilLnxtrfyGk7Hy4ZUasPLCQPz+MZ/Vv1lo2lW+Sz1bMSWunKfqfK8T0PS2gsg2onoE5NUed9Li1cU/sgPoGAJQSQz183GgH9mQkS+uudg3eSI6D+Q7uuZJMc0eWA5CYy2nMC6hxd9eQddc5uXVtX52bzTw+72Tlsn1nXMD5LgMAVnz4oLzpXvrNBwHYCyGfNewBf1VThwjmhVWDwY0oExs16QZ6bPyWluUzyjkCmI5TPOGLZo3HHOhd5YNCfueq9TkKJffjesq/knq//l9hgRkEgxASQz9qbi4BWY4OEVgPCy6QJnPnuLTJv45Kk5zHBWwLNchrLq4ePdc7TzatxoWO7H8y31zWSSe5NdbrDqZNvkJjEk5vIaAiEjADyWXdDEdAa+CChNUDhrYQJqPuD/mHSlVJcXpLwHAb6Q6B3s67y30Nvcp7AoZ5x9MuWn5krd+9/0S9v8FPKBMZ8MFaWFK5OeT4TIRAGAshn/V3kHNBaGHFOaC1geDshAuoG6Mucc0J/u9OQhMYzyD8CPZt2ksbZDWXSks+2Lzp24P/JYZ323f6aH1Ij8OT3E+WmLx9NbTKzIBASAshnYo1EQOvghITWAYeP6iUwY908adewhezdepd6xzLAXwID2+4hi7asENWjvi16ysNDr5RohANC6XRh8ZaV8puJl0mpc/U7GwRsJYB8Jt55BLQeVkhoPYD4uE4C7yz9XI7qcqC0dUSUTS8Ch3feX95d+qXcP+hS6dSojV7JGZZNLB6ToydeLnM3ce6zYa0jXRcJIJ/JwdzxRKjk5lo1etyEcWNXxzaPHisT8wqF5xlb1fw0i1VXXn957GPOYd+aL35JMzzT0yCweWshfUmD37apt375mFw97aFtL/kTAtYRQD6TbznfgCbIjG9CEwTFsF8RWF+6WeZuXCTH9zj0V5/xRrAEcjKyg00gBKt/tWaOnDz5eonFueo9BO2khBQIIJ8pQHOmIKBJcENCk4DF0B0IfOcIaMPMHDmgXZ8d3ucFBEwmoO70MPy1i0VddMcGARsJIJ+pd52z7pNkxy2akgTG8O0Erv7sIflk5cztr/kBAqYTuOTjv8sc55crNgjYSAD5TK/rCGgK/JDQFKAxRcrjFXLcW9fIGr4tYm8IAYE3Fn0iE2a/GIJKKAECyRNAPpNnVn0Gh+CrE0nwNYfjEwTFsB0IqJvUz1g7V07aebhEIlwDuAMcXhhDQP0SNcI59F7IwxaM6RmJukcA+XSHJQKaBkckNA14Fk/9cfNyqYhVyMEd97aYAqWbTOCP7/xVvnJ+kWKDgG0EkE/3Oo6ApskSCU0ToKXTP14xUwa23V26N+loKQHKNpXAhFkvyN1f/8/U9MkbAikTQD5TRlfjRI4B1ogl+Te5T2jyzGyf0bJBE5l+7BPSMb+17Sio3xAC8zYukX7Pnsqhd0P6RZruEUA+3WO5LRIXIW0jkeafXJiUJkALp68t2eRclHS1lFWUW1g9JZtGoDxWLie9cx3yaVrjyDdtAshn2ghrDMAh+BqxpPYmh+NT42bzrKWFq2VD6RY5vMv+NmOgdgMIXDvtH/L0/HcMyJQUIeAeAeTTPZbVIyGg1Ymk+RoJTROghdOnrZ4tezTvLrs238nC6inZBAIfr/hazn7vNok7/2ODgC0EkE9vO805oB7x5ZxQj8CGNGzjrIaVz4vv0aRTSCukLFMJbNlaKH2eOUUWbFlhagnkDYGkCSCfSSNLegLngCaNLLEJnBOaGCdG/URgs3N/0GMmXSXq0YZsENCJwPkf/g351Kkh5OI5AeTTc8SVC3AI3kPOHI73EG4IQ68qXi8ritbJ0TsNDmF1lGQigefmT5FrnHM/2SBgCwHk079OI6Aes0ZCPQYcsvDTnZt7d8hrJf1b9Q5ZZZRjGoFlBavliDculeKKUtNSJ18IpEQA+UwJW8qTOASfMrrEJ3I4PnFWjBS56KN7ZOa6H0ABgcAIxONxOW3KTbK+dHNgObAwBPwkgHz6SfuntRBQn5gjoT6BDsEy6hunYyZdKZudiz/YIBAEgbu+/o9MXvZFEEuzJgR8J4B8+o68ckEOwfvIncPxPsI2fCn1zdMPm5bIcT0OMbwS0jeNwDfOt+8nvv1XqYjHTEudfCGQNAHkM2lkrk1AQF1DmVggJDQxTowSmb1hoTRybs+0f9s9wAEBXwiUVmyVEa/9SZYXrfVlPRaBQJAEkM8g6YtwCD4A/hyODwC6oUte+dk4mbryG0OzJ23TCFw+9QH5Zv1809ImXwgkTQD5TBqZ6xMQUNeRJhYQCU2Mk+2jymIVlc+LX1u80XYU1O8xgXeWTpP7v3nW41UID4HgCSCfwfdAZcAh+AD7wOH4AOEbtLS6Sf3Xa+fJSTsPl0iEh5cZ1DpjUl1fskmGvXqxbHH2NTYIhJkA8qlPdxHQgHuBhAbcAEOWn795mahb4xzUob8hGZOmSQROnXyjfLZ6tkkpkysEkiaAfCaNzNMJCKineBMLjoQmxsn2UR+t+FoOaLeHdGvcwXYU1O8igX9996rcPv1JFyMSCgL6EUA+9esJx/M06sm4CePGro5tHj1WJuYVCk8f0ag12qTSqkFTmX7s49Ihv7U2OZGIuQQWbF4ufZ45hUPv5raQzBMggHwmACmAIVyEFAD02pbkwqTayPD+NgJrSjbK8W9fK+Wx8m1v8ScEUiJQ4VzgdvI71yOfKdFjkikEkE99O8UheM16w+F4zRqiYTpLClZVPiVpROeBGmZHSqYQuOmLf8mT8940JV3yhEDSBJDPpJH5OgEB9RV3YoshoYlxsnnUZ6tnSZ8WPWSXZl1txkDtKRKYtmqWnD7lZolJPMUITIOA3gSQT737o7LjHFCNe8Q5oRo3R4PUmmTnyZfHPCbdm3TUIBtSMIVAYVmx9Hv2VJm3aakpKZMnBJIigHwmhSuwwZwDGhj6+hfmnND6Gdk8YtPWQjlm0lVSUs4FazbvB8nWftFH9yCfyUJjvDEEkE9jWsWN6HVvFYfjde9QsPmtLF4vK4vWyW92GhRsIqxuBIFXFnwol3/6oBG5kiQEkiWAfCZLLNjxnAMaLP+EVkdCE8Jk7aDpa+dKJ+e2THu16mUtAwqvn4D6RWXk63+SovKS+gczAgKGEUA+DWuYky6H4A3pGYfjDWlUQGn+34d3yzfrfghodZY1gcCZ794s6jZebBAIGwHk08yOIqAG9Q0JNahZPqdaXFFaeT7oFue8UDYIVCdw/zfPyMTFn1Z/m9cQMJ4A8mluCzkEb1jvOBxvWMN8THdd6Wb5YfNSObb7IT6uylK6E/huw0I5dtLVUh6v0D1V8oNAUgSQz6RwaTcYAdWuJfUnhITWz8jWEbM3LBB1e6aBbfewFQF1VyFQVlFeed7nksLVVd7lRwiYTwD5NL+HHII3tIccjje0cT6kfYVzlfNnzo3G2SBw9bQJoi5SY4NAmAggn+HoJgJqcB+RUIOb52HqZc4zvo917g+6rmSTh6sQWncC7y//Su6a8R/d0yQ/CCRFAPlMCpfWgzkEr3V76k+Ow/H1M7JxxOayQpnpXBV/Us/hEonwwDPb9oFNpQUy7LWLZOPWAttKp94QE0A+w9VcBDQE/URCQ9BED0pQFySpbWiHvTyITkidCZz13i3y0cqZOqdIbhBIigDymRQuIwYjoEa0qf4kkdD6Gdk44sPlM+TAdntKt8YdbCzfypqfmvum3PDFv6ysnaLDSQD5DGdfOTYXsr6OmzBu7OrY5tFjZWJeofCM8JC1N6VyWuc2k+nHPi7t81qlNJ9J5hBYvGWl7PnMybKJ+8Ga0zQyrZMA8lknHqM/5CIko9v36+S5MOnXTGx/Z3XxBjn+rWukPFZuO4pQ1x+Lx+TUyTcin6Husl3FIZ/h7jeH4EPYXw7Hh7CpaZa0uGCVFJQVy/DO+6UZiem6Erhj+pPyyJxXdU2PvCCQFAHkMylcRg5GQI1sW/1JI6H1M7JtxKervpW+LXtK72ZdbSs99PVOX/O9nDz5eqlwvgVlg4DpBJBP0zuYWP6cA5oYJ2NHcU6osa3zJHH1lKSvnPNBuSjJE7yBBC0uL5H+z54u321cFMj6LAoBNwkgn27S1DsW54Dq3Z+0s+Oc0LQRhiqAujjlGOcm9SXlXKAWlsb++ZP7kc+wNNPyOpBPu3YADsFb0G8Ox1vQ5CRKXFm0TlYUrZWjdxqcxCyG6khg4qKpcvEn9+qYGjlBICkCyGdSuEIxGAENRRvrLwIJrZ+RTSPU88G7NW4vfZxzQtnMJLC2eKOMeO1iKSgvNrMAsobAzwSQTzt3BQ7BW9R3Dsdb1OwESh39wZ3y7br5CYxkiI4Ezn7vVllZvF7H1MgJAgkTQD4TRhW6gQho6Fpad0FIaN18bPq0yDkP9Ji3rnJuz1RkU9mhqPUfs1+Slxd+GIpaKMJeAsinvb1XlXMI3sL+czjewqbXUvK6kk3y46Zlckz3g2sZwdu6EZi3cYn8/s2/SBkPFtCtNeSTBAHkMwlYIR2KgIa0sfWVhYTWR8iez2dtWCDNchrJfm12t6doQytVT7M68o0/y8ItKwytgLQhIIJ8shcoAhyCt3g/4HC8xc2vVvrlUx+QaatmVXuXl7oRuOGLR2Ta6tm6pUU+EEiYAPKZMKrQD+RG9KFvcf0FcrP6+hnZMKJzfhuZ7tykvnmDJjaUa1yNn6ycKYNfGs3TjozrHAlvI4B8biPBn4oAh+DZD4TD8ewEioC6Sf0363+QP/YcLpEIv5vqtFdscXoz3Lnl0vrSzTqlRS4QSJgA8pkwKmsGIqDWtLruQpHQuvnY8ukPm5ZKRiQqQ9r3s6VkI+o87/075L3lXxmRK0lCoDoB5LM6EV4rAggo+8F2AkjodhRW//DBihlyYNs+spNzo3q24Ak8P/9duXrahOATIQMIpEAA+UwBmiVTOM5mSaOTKZNzQpOhFc6xbXKbOeeDPiHt8lqGs0BDqlpeuEb2ePpkDr0b0i/S3JEA8rkjD17tSICr4HfkwSuHAFfHsxusKt4gx799jajb/rAFQyAej8vpU25CPoPBz6ppEkA+0wRowXQOwVvQ5FRK5HB8KtTCNWdxwSopKi+RYZ0GhKswQ6q5d+b/ZPysFw3JljQh8AsB5PMXFvxUOwEEtHY21n+ChFq/C8inq76Vfi17Sa9mXYDhI4Fv182X49+6hlsu+cicpdwhgHy6w9GGKByCt6HLadTI4fg04IVgatyp4bQpN8qCzctDUI0ZJZRWbJWT3rlOSmNlZiRMlhD4mQDyya6QDAEENBlalo5FQi1t/M9lb9xaIMdMukqUGLF5T+DKT8fLzPXzvV+IFSDgIgHk00WYloTiELwljU63TA7Hp0vQ7PkritbJqqL1clTXQWYXonn2k5d+Lud/OFbzLEkPAjsSQD535MGrxAggoIlxYpRDAAm1ezf4au330qNJR9mzRQ+7QXhU/QbnKUfDnKcdbS4r8mgFwkLAfQLIp/tMbYnIIXhbOu1SnRyOdwmkoWFGOU/kmbX+R0Oz1ztt9bSjZc59P9kgYAoB5NOUTumZJwKqZ1+0zgoJ1bo9niZX6NyWSZ0PWsC3dK5yfmzO6/Ls/CmuxiQYBLwkgHx6SdeO2ByCt6PPrlfJ4XjXkRoTcG3Jpsqr4o/pfrAxOeucqLrDwNETL5etXPWuc5vIrQoB5LMKDH5MmQACmjI6JiKh9u4D3zqH4Vs2aCL7ttnNXgguVF4Rq5DfOPL5w+alLkQjBAS8J4B8es/YlhU4BG9Lpz2qk8PxHoE1IOyln/xdPl8924BM9U3xtq+ekI9XztQ3QTKDQBUCyGcVGPyYNoFI2hEIAAGHwLgJ48aujm0ePVYm5hVKKUwsIdAlv618dexj0tz5NpQtOQJK3vd/4Vwpj1ckN5HREAiAAPIZAPSQL8kh+JA32K/yOBzvF2m91tnk3KReXRV/Ys9hEonw+2yi3SkqK5Hhr10ka0o2JjqFcRAIjADyGRj6UC+MgIa6vf4Wh4T6y1uX1eZtWiJZ0UwZ3L6vLilpn8cFH/1N3lo6Tfs8SRACyCf7gFcEEFCvyFoaFwm1s/HvL58ug9v1k66N29kJIImqX134ofx56gNJzGAoBIIhgHwGw92WVTlmZkunfa6Tc0J9Bq7Bcm1ym8mM456Utg1baJCNnimox5nu8fRJHHrXsz1kVYUA8lkFBj96QoCr4D3BSlCujrdvH1hVvEFOeOtaUbcWYquZwJnv3ox81oyGdzUigHz+f3v3AiRVfeVx/NzumQGGGR1EEDAGJAhGg0YXkxjjJm5Wk6jJmhisuEaFxVXGslaNm3JZ15RWNFohlY2WgSEVVyXlbiRm49ZCFIyKKGgU8YHy8IEDysMBh4F5z3T33X/PxilmnMft7vv4P76TSjk9fe//f87ndFk/+/ZDo2FYXAqX4C0ebtKtcTk+6QnEv//2lj3Ske2Ss4/5XPyba77jLzc+LHdtXKZ5lZTnugDh0/VHQHz9E0Djs3ZyJ0Koe2Nfpz7X8tRxM2RGzWT3mh+k4y3763u+wpSPXBoEiD9rIUD41GIMzhTBJXhnRp1co1yOT84+iZ19tenlT/5Y6g/uTmJ77fbszmbkkj/dIu1ZPh9Xu+FQUK8A4bOXgl9iEiCAxgTt+jaEULceAfs7m+W7qxZIp7oc7/rPzS8ukQ37trrOQP8aCxA+NR6OxaVxCd7i4erWGpfjdZtItPXsbvtQ9rY3yflTvhTtRhqvvkZ9PNWVq++U/LPC/CCgowDhU8epuFETAdSNOWvTJSFUm1HEUshLe7fI9MOPkZljp8Wyn06bHOhsUd92dJ00qW+L4gcBHQUInzpOxZ2auATvzqy16ZTL8dqMIpZCrnz6Ttms3oTj2s/VzyyU/KcC8IOAjgKETx2n4lZNBFC35q1Nt4RQbUYReSGtmQ658LF/kdbu9sj30mWD3771uPznW6t0KYc6EOgjQPjsw8GNhAS4BJ8QPNuKcDnenUfBvo4DUt+8Wy6cepb1Tb/X8oGc/8cbej4P1fpmadA4AcKncSOztmACqLWjNaMxQqgZcwqjyo2N78h49XWdp40/IYzltFwj5+fk24/dKFuadmhZH0W5LUD4dHv+unXPJXjdJuJgPVyOd2foP1h7l6xv2Gxtwz975UFZrd75zg8CugkQPnWbCPV4ECCgi8CiukULG3IHaxfKo6NbhQ/t1mUuYdcxpXqCbJj9gIwZcVjYSye63iv73pTP/36edOUyidbB5gj0FyB89hfhtg4CXILXYQrU0CPA5Xg3Hgj5jyV6o/FduXja2eJ5dvw3cEems+cjl/a0N7oxRLo0RoDwacyonCuUAOrcyPVumBCq93zCqu7NA+/JyHSFfGniyWEtmeg616uXFqzYsS7RGtgcgf4ChM/+ItzWSYAAqtM0qKVHgBDqxgNh9a4N8uVJp8iU6olGN7xyx/Ny7dp/N7oHirdPgPBp30xt68iO61+2TYV+egR4Taj9D4QJo46Qly9aKhMqxxrZ7D71VaMzH7pEuPRu5PisLZrwae1orWqMd8FbNU67muHd8XbNc6Bu8sHt4sdvlmwuO9Dd2v/tH1ffQfjUfkpuFUj4dGveJnfLJXiTp+dA7VyOt3/I9c171DvHu+VvP3GaUc3+etP/yMJXHzSqZoq1W4Dwafd8beuOAGrbRC3shxBq4VD7tbR2z2sya/ynZXrNJ/vdo+fNt9WbqL6tvl6Uj1zScz4uVkX4dHHqZvfMJXiz5+dM9VyOt3vUvmrv0idule3q6zp1/8moz/n8/p9ukZaMO99tr/tMXK+P8On6I8DM/gmgZs7NyaoJoXaPfX9ns8xeeZN0Zbu1bvTH6++TPzds0rpGinNHgPDpzqxt65RL8LZN1PJ+uBxv94B3te2Txo4Dct7kM7Rs9Pk9r8vcp24TX/2PHwSSFiB8Jj0B9i9FgABaih7nJiJACE2EPbZNX9y7WWao14LOHPup2PYMslFLd5ucs/xa+bDzYJDDOQaBSAUIn5HysngMAlyCjwGZLcIX4HJ8+KY6rXjl6jtly/56nUqSf3rm5/LOwZ1a1UQxbgoQPt2cu21dE0Btm6hD/RBC7R12/g0+F65cIK3derzR57+3rZb7tq6wF5zOjBEgfBozKgodRoBL8MMAcbfeAlyO13s+pVS3t6NJdqjPCP3O1K+UskzJ5+5u3Sfnrrhe2rOdJa/FAgiUIkD4LEWPc3UTIIDqNhHqKViAEFowmTEnvNb4jvqaziN6PiM0iaJ935fvrvxXeX3/tiS2Z08EegUIn70U/GKJAJfgLRmk621wOd7eR8B1z/5CNuzdkkiDd29cJqvefyGRvdkUgY8ECJ8fSfBPmwQ8m5qhFwQW1S1a2JA7WLtQHh3dKlwyteURcWz1RNkw+wGpGVEdW0tvNG6TWQ/PlY5sV2x7shEC/QUIn/1FuG2LAJfgbZkkffQIcDnezgdCU1eLbN7/rnxv2tniedH/d3P+w/C/oV73ubN1r52gdGWEAOHTiDFRZJECBNAi4ThNXwFCqL6zKaWyrU07pLJshJwx8eRSlgl07o3P/1L+8O6aQMdyEAJRCBA+o1BlTZ0ECKA6TYNaQhMghIZGqdVCq3dukLMmnSqTqydEVteT76+X2jU/jWx9FkZgOAHC53BC3G+DQPTXsmxQogdjBXhNqLGjG7TwiZVj5eXZS+Uo9e74sH/2q285Oumh78v7XHoPm5b1AgoQPgNCcZjxArwL3vgR0sBQArw7figdM+/b3fahXPz4zZLNZUNvYP7TPyV8hq7KgkEFCJ9BpTjOBgEuwdswRXoYUoDL8UPyGHlnffNuyfhZ+eonZoVW/2+2Piq3bbg/tPVYCIFCBAifhWhxrA0CBFAbpkgPwwoQQoclMu6AZ3e/KqeNP0GOqzmm5NrrD+6Wbz36z9KZ6y55LRZAoFABwmehYhxvgwCX4G2YIj0EEuByfCAmYw7yVaWXPnFrz9d1llJ0zs+pdW6Rg91tpSzDuQgUJUD4LIqNkywQIIBaMERaCC5ACA1uZcKRjepNQ7NX3ST5z+3s/5P/Gs0gP3duWCrP7nktyKEcg0CoAoTPUDlZzDABLsEbNjDKLV2Ay/GlG+q0Qv7D4ps6m+XcyV/sLWvljudlxY518oWjPtP7t4F+Wd+wWS598lbJBQyrA63B3xAoRoDwWYwa59gkQAC1aZr0EliAEBqYyogDX2jYJJ8eM0U+c8RU+aCtUc5Zfq0sr18r3zr2zEE/rqmtu0O+tuI6aWhvMqJHirRHgPBpzyzppHgBLsEXb8eZhgtwOd7wAfYr/4qnfqK+rrO+5/WcDe37e95Q9PeP/0g6Mp39jvz/mzesu1vy367EDwJxChA+49RmL50FeAZU5+lQW+QCPBMaOXFsG3TlMpL/KKXNTdt799zb0SRNXX0vz+fvXF7/rNzw3N29x/ELAnEIED7jUGYPUwQIoKZMijojEyCERkYb+8IDfYzSi+p1nrPGHS/Taz7ZU0+DukT/9RXXS2umI/b62NBdAcKnu7On84EFuAQ/sAt/dUyAy/F2D/wfnrpd9qhvUMr/zFv9E/W6z/12N0x3WgkQPrUaB8VoIsAzoJoMgjKSF+CZ0ORnEFUFberZztcb35GDXa3yi9ceimob1kXgYwKEz4+R8AcEegQ8HBBAoK/AorpFCxtyB2sXyqOjW2XgN7D0PYNbpgikxJOcBPt8UFN6ok59BQif+s6GypIX4BnQ5GdABZoJ8EyoZgMJsRyiZ4iYLDWkAOFzSB7uREAIoDwIEBhAgBA6AAp/QgCBQAKEz0BMHOS4AAHU8QcA7Q8uQAgd3IZ7EEBgYAHC58Au/BWB/gIE0P4i3EbgEAFC6CEY/IoAAkMKED6H5OFOBPoIEED7cHADgY8LEEI/bsJfEECgrwDhs68HtxAYToAAOpwQ9yOgBAihPAwQQGAwAcLnYDL8HYHBBQigg9twDwJ9BAihfTi4gQACSoDwycMAgeIECKDFuXGWowKEUEcHT9sIDCBA+BwAhT8hEFCAABoQisMQ+EiAEPqRBP9EwF0Bwqe7s6fzcAQIoOE4sopjAoRQxwZOuwgcIkD4PASDXxEoUoAAWiQcpyFACOUxgIB7AoRP92ZOx9EIEECjcWVVRwQIoY4MmjYRUAKETx4GCIQnQAANz5KVHBUghDo6eNp2SoDw6dS4aTYGAQJoDMhsYb8AIdT+GdOhuwKET3dnT+fRCRBAo7NlZccECKGODZx2nRAgfDoxZppMQIAAmgA6W9orQAi1d7Z05p4A4dO9mdNxfAIE0Pis2ckRAUKoI4OmTasFCJ9Wj5fmNBAggGowBEqwT4AQat9M6cgdAcKnO7Om0+QECKDJ2bOz5QKEUMsHTHtWChA+rRwrTWkoQADVcCiUZI8AIdSeWdKJ/QKET/tnTIf6CBBA9ZkFlVgqQAi1dLC0ZZUA4dOqcdKMAQIEUAOGRInmCxBCzZ8hHdgrQPi0d7Z0pq8AAVTf2VCZZQKEUMsGSjtWCBA+rRgjTRgoQAA1cGiUbK4AIdTc2VG5fQKET/tmSkfmCBBAzZkVlVoiQAi1ZJC0YbQA4dPo8VG8BQIEUAuGSAvmCRBCzZsZFdsjQPi0Z5Z0Yq4AAdTc2VG54QKEUMMHSPlGChA+jRwbRVsoQAC1cKi0ZI4AIdScWVGp+QKET/NnSAf2CBBA7ZklnRgqQAg1dHCUbZQA4dOocVGsAwIEUAeGTIv6CxBC9Z8RFZorQPg0d3ZUbq8AAdTe2dKZYQKEUMMGRrlGCBA+jRgTRTooQAB1cOi0rK8AIVTf2VCZeQKET/NmRsXuCBBA3Zk1nRoiQAg1ZFCUqbUA4VPr8VAcAkIA5UGAgIYChFANh0JJxggQPo0ZFYU6LEAAdXj4tK63ACFU7/lQnZ4ChE8950JVCPQXIID2F+E2AhoJEEI1GgalaC9A+NR+RBSIQK8AAbSXgl8Q0FOAEKrnXKhKLwHCp17zoBoEhhMggA4nxP0IaCBACNVgCJSgrQDhU9vRUBgCgwoQQAel4Q4E9BIghOo1D6rRQ4DwqcccqAKBQgUIoIWKcTwCCQoQQhPEZ2vtBAif2o2EghAILEAADUzFgQjoIUAI1WMOVJGsAOEzWX92R6BUAQJoqYKcj0ACAoTQBNDZUhsBwqc2o6AQBIoWIIAWTceJCCQrQAhN1p/dkxEgfCbjzq4IhC1AAA1blPUQiFGAEBojNlslLkD4THwEFIBAaAIE0NAoWQiBZAQIocm4s2u8AoTPeL3ZDYGoBQigUQuzPgIxCBBCY0Bmi8QECJ+J0bMxApEJEEAjo2VhBOIVIITG681u8QgQPuNxZhcE4hYggMYtzn4IRChACI0Ql6VjFyB8xk7OhgjEJkAAjY2ajRCIR4AQGo8zu0QrQPiM1pfVEUhagACa9ATYH4EIBAihEaCyZGwChM/YqNkIgcQECKCJ0bMxAtEKEEKj9WX1aAQIn9G4sioCugkQQHWbCPUgEKIAITRETJaKXIDwGTkxGyCgjQABVJtRUAgC0QgQQqNxZdVwBQif4XqyGgK6CxBAdZ8Q9SEQggAhNARElohMgPAZGS0LI6CtAAFU29FQGALhChBCw/VktXAECJ/hOLIKAqYJEEBNmxj1IlCCACG0BDxODV2A8Bk6KQsiYIwAAdSYUVEoAuEIEELDcWSV0gQIn6X5cTYCpgsQQE2fIPUjUIQAIbQINE4JTYDwGRolCyFgrAAB1NjRUTgCpQkQQkvz4+ziBAifxblxFgK2CRBAbZso/SBQgAAhtAAsDi1ZgPBZMiELIGCNAAHUmlHSCALFCRBCi3PjrMIECJ+FeXE0ArYLEEBtnzD9IRBAgBAaAIlDihYgfBZNx4kIWCtAALV2tDSGQGEChNDCvDg6mADhM5gTRyHgmgAB1LWJ0y8CQwgQQofA4a6CBQifBZNxAgLOCBBAnRk1jSIQTIAQGsyJo4YWIHwO7cO9CLguQAB1/RFA/wgMIEAIHQCFPwUWIHwGpuJABJwVIIA6O3oaR2BoAULo0D7cO7AA4XNgF/6KAAJ9BQigfT24hQAChwgQQg/B4NdhBQifwxJxAAII/EWAAMpDAQEEhhQghA7Jw51/ESB88lBAAIFCBAighWhxLAKOChBCHR18wLYJnwGhOAwBBHoFCKC9FPyCAAJDCRBCh9Jx9z7Cp7uzp3MEShEggJaix7kIOCZACHVs4MO0S/gcBoi7EUBgUAEC6KA03IEAAgMJEEIHUnHvb4RP92ZOxwiEKUAADVOTtRBwRIAQ6sigB2mT8DkIDH9GAIHAAgTQwFQciAAChwoQQg/VcOd3wqc7s6ZTBKIUIIBGqcvaCFguQAi1fMD92iN89gPhJgIIFC1AAC2ajhMRQCAvQAh143FA+HRjznSJQFwCBNC4pNkHAYsFCKEWD1e1Rvi0e750h0ASAgTQJNTZEwELBQihFg5VtUT4tHOudIVA0gIE0KQnwP4IWCRACLVomKoVwqdd86QbBHQSIIDqNA1qQcACAUKoBUNULRA+7ZgjXSCgqwABVNfJUBcCBgsQQg0eniqd8Gn2/KgeARMECKAmTIkaETBQgBBq4NBUyYRPM+dG1QiYJkAANW1i1IuAQQKEUIOGpUolfJo1L6pFwGQBAqjJ06N2BAwQIIQaMCRVIuHTjDlRJQK2CBBAbZkkfSCgsQAhVOPhqNIIn3rPh+oQsFGAAGrjVOkJAQ0FCKEaDkWVRPjUcy5UhYDtAgRQ2ydMfwhoJEAI1WgYqhTCp17zoBoEXBIggLo0bXpFQAMBQqgGQ1AlED71mANVIOCqAAHU1cnTNwIJChBCE8RXWxM+k/VndwQQECGA8ihAAIFEBAihibATPpNhZ1cEEOgnQADtB8JNBBCIT4AQGp91fiee+YzXm90QQGBwAQLo4DbcgwACMQh8FEJPlcknbZDtFZ2SiWFX97Y4XEbJD71vtIxLHVZ39fyrf+ieAB0jgIBOAgRQnaZBLQg4KpAPobO/+R053Zv2hdf89ypapdNRiWjanuAdLjd657XVeJW3q/D5o2h2YVUEEEAguIAX/FCORAABBKIVWPyrxXM6ct333JVbNbpe9kW7mSOrT5Ej5drUOa0jU+XX1F5Ze78jbdMmAghoLkAA1XxAlIeAawKLliw6L5PL/XaJ/1TVG7LTtfZD7fdEOVqu8s5qKUulvnf1VVevCHVxFkMAAQRKECCAloDHqQggEI1A3b11p3d3Z/74sL+++ml/Cy8VKoL5K6njsxfKrOby8rJz58+b/1wRS3AKAgggEJkAATQyWhZGAIFSBOrq6o7r8rsf2SJ7ptznr6lsl+5SlnPm3EqpkDnemW3Hy4T6yvJRf3fFFVe87UzzNIoAAsYIEECNGRWFIuCewLJlyyoaGht+rsLnnMX+k6O3+XvdQyig46neOKn1/qZ1lJTfP/6I8T+46KKLugo4nUMRQACB2AQIoLFRsxECCBQroF4XekE2l7t/uf/q6FWyscwvdiFLz8v/i/wcmZk53zu5NZ1KzVGv93zE0lZpCwEELBEggFoySNpAwHaBxYsXH53xs7/f5TWduNRfW7VT9tvecqD+jpYxcpl3Rsskv+aNMi99YW1tLe/cCiTHQQggkKQAATRJffZGAIGCBHzf9+p+VTc/k8ve8Zy8M+IR/6WRbeLmVeb8az0v8P6q43T5VGdZKr1g/pXz6zzP48nhgh5RHIwAAkkJEECTkmdfBBAoWuDBBx8c09TSdEd3Lnvp72T9yHX+mylXklf+X9pf9KbnZsusjvJU+jc1VTULLrnkEp4OLvrRxIkIIJCEAAE0CXX2RACBUASW/MeSU9XHNdXt85uP/4P/UrX6FiWxNYjm/2V9kneMXCCn5r9Oc3M6nbqq9oral0OBZBEEEEAgZgECaMzgbIcAAuELqDcpzVYfXv9vLV7Hscv9V6pe8Ld5GcmFv1ECK5ZJSj7nTfXP9z7bUuWPfFd9qPxt6k1Gv0ugFLZEAAEEQhMggIZGyUIIIJC0wD1193w1l5ObMqns5x+TjSPW5LamOwz9/FD1UUpyZmpG9usys7Msl/5zKiW3XzP/mieSNmZ/BBBAIAwBAmgYiqyBAAJaCSz+9eJTchl/gS/+Nzf5uzJr/Td7vtZT92dF88925r8+8wxvessJ3qQyT7z/TZV5d3CpXauHF8UggEAIAgTQEBBZAgEE9BTIv1npQMuB2Vk/N8f35bMvy3b/Of/tyjdlj7pAr8erRVPiyXSZIKd709pOkcnqjezyStpL3T+qYtSyuXPnNukpS1UIIIBAaQIE0NL8OBsBBAwRuPfeeyd1Zbou7lZh1PP94+plX8cm2VW91d+d2i77JBtTIE2rwDlZjpQZ3sTcCTKpeYocOdL3vLfKVeisKKv4r3nz5u0yhJQyEUAAgaIFCKBF03EiAgiYKvDAAw+Mbelq+XI6lz6zM5f5mgqFU9+Txo5t3t5Re/ymir3SLA3+QfVR961Fx9L8v1zHyGgZ7x0m46RaJng1XVP9ce3HyBEjVdjdNiJVtjKbyj5TVVH19OWXX/6hqZbUjQACCBQjQAAtRo1zEEDAKgH17Gh1p9/51163d2LWyx6vAuIJ6iPdj0tLurpJWtsO+O1+p7pTfSd9ql260ur/5e1+d3keYZRX3j1KKvL/z6o3DuVG+OX+4d4or0ZGV2Yl2+x78pYKuJvSfnqLuuuNEd6INepZzmarAGkGAQQQKFCAAFogGIcjgIA7AkuXLh3d1t02TQXJo9SLRqvUdfqqdCpd5fneaPWtTFV5CfWizRbf81uzuWyLpKVFvY+oRQXXDyrLK9++7LLLWt3RolMEEEAguMD/AUvX0taRXmkBAAAAAElFTkSuQmCC'); } + .test-summary.skipped .test-result-icon, + .iteration.skipped .test-result-icon, + .skip { + background-image: + url('data:image/png;base64,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'); + } + + .test-summary.failed .test-result-icon, + .iteration.failed .test-result-icon, .failure { background-image: url('data:image/png;base64,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'); } @@ -363,8 +375,12 @@ .tests > .summary { width: 100%; } + + .iteration { + margin-left: 10px; + } - .test-summary p, .test-summary-group p, .activity p { + .test-summary p, .test-summary-group p, .iteration p, .activity p { font-size: 12px; padding: 4px 4px 4px 52px; border-bottom: 1px solid #EEE; @@ -763,8 +779,14 @@

      No Selected Attachment

      function toggle(el, id) { el.classList.toggle('dropped'); + var iterations = document.getElementById('iterations-'+id); var activities = document.getElementById('activities-'+id); var attachments = document.getElementById('attachments-'+id); + + if (iterations) { + iterations.style.display = (iterations.style.display == 'block' ? 'none' : 'block'); + } + if (activities) { activities.style.display = (activities.style.display == 'block' ? 'none' : 'block'); } @@ -830,6 +852,8 @@

      No Selected Attachment

      selectedElement(el); showElementsWithSelector('.run.active .test-summary.succeeded'); showElementsWithSelector('.run.active .test-summary.failed'); + showElementsWithSelector('.run.active .test-summary.skipped'); + showElementsWithSelector('.run.active .test-summary.mixed'); hideSummaryGroupsIfNeeded(); } @@ -837,13 +861,35 @@

      No Selected Attachment

      selectedElement(el); showElementsWithSelector('.run.active .test-summary.succeeded'); hideElementsWithSelector('.run.active .test-summary.failed'); + hideElementsWithSelector('.run.active .test-summary.skipped'); + hideElementsWithSelector('.run.active .test-summary.mixed'); + hideSummaryGroupsIfNeeded(); + } + + function showSkippedScenariosOnly(el) { + selectedElement(el); + hideElementsWithSelector('.run.active .test-summary.succeeded'); + hideElementsWithSelector('.run.active .test-summary.failed'); + showElementsWithSelector('.run.active .test-summary.skipped'); + hideElementsWithSelector('.run.active .test-summary.mixed'); hideSummaryGroupsIfNeeded(); } function showFailedScenariosOnly(el) { selectedElement(el); + hideElementsWithSelector('.run.active .test-summary.succeeded'); showElementsWithSelector('.run.active .test-summary.failed'); + hideElementsWithSelector('.run.active .test-summary.skipped'); + hideElementsWithSelector('.run.active .test-summary.mixed'); + hideSummaryGroupsIfNeeded(); + } + + function showMixedScenariosOnly(el) { + selectedElement(el); hideElementsWithSelector('.run.active .test-summary.succeeded'); + hideElementsWithSelector('.run.active .test-summary.skipped'); + hideElementsWithSelector('.run.active .test-summary.failed'); + showElementsWithSelector('.run.active .test-summary.mixed'); hideSummaryGroupsIfNeeded(); } diff --git a/Sources/XCTestHTMLReportCore/HTML/iteration.html b/Sources/XCTestHTMLReportCore/HTML/iteration.html new file mode 100644 index 00000000..1bc8bcf7 --- /dev/null +++ b/Sources/XCTestHTMLReportCore/HTML/iteration.html @@ -0,0 +1,12 @@ +
      + +

      + + + [[TITLE]] ([[DURATION]]) +

      +
      + [[SCREENSHOT_FLOW]] + [[ACTIVITIES]] +
      +
      diff --git a/Sources/XCTestHTMLReportCore/HTML/run.html b/Sources/XCTestHTMLReportCore/HTML/run.html index d8006c07..9b908b6c 100644 --- a/Sources/XCTestHTMLReportCore/HTML/run.html +++ b/Sources/XCTestHTMLReportCore/HTML/run.html @@ -6,6 +6,7 @@
    • Passed ([[N_OF_PASSED_TESTS]])
    • Skipped ([[N_OF_SKIPPED_TESTS]])
    • Failed ([[N_OF_FAILED_TESTS]])
      • +
    • Mixed ([[N_OF_MIXED_TESTS]])
    • Status
      • diff --git a/Sources/XCTestHTMLReportCore/HTML/test.html b/Sources/XCTestHTMLReportCore/HTML/test.html deleted file mode 100644 index c249a5a6..00000000 --- a/Sources/XCTestHTMLReportCore/HTML/test.html +++ /dev/null @@ -1,14 +0,0 @@ - [[SCREENSHOT_TAIL]] -
      - -

      - - - [[NAME]] ([[TIME]]) -

      - [[SUB_TESTS]] -
      - [[SCREENSHOT_FLOW]] - [[ACTIVITIES]] -
      -
      diff --git a/Sources/XCTestHTMLReportCore/HTML/testGroup.html b/Sources/XCTestHTMLReportCore/HTML/testGroup.html new file mode 100644 index 00000000..2135a13c --- /dev/null +++ b/Sources/XCTestHTMLReportCore/HTML/testGroup.html @@ -0,0 +1,9 @@ +
      + +

      + + + [[TITLE]] ([[DURATION]]) +

      + [[SUB_TESTS]] +
      diff --git a/Sources/XCTestHTMLReportCore/HTML/test_case.html b/Sources/XCTestHTMLReportCore/HTML/test_case.html new file mode 100644 index 00000000..751b555a --- /dev/null +++ b/Sources/XCTestHTMLReportCore/HTML/test_case.html @@ -0,0 +1,13 @@ + [[SCREENSHOT_TAIL]] +
      + +

      + + + [[TITLE]] ([[DURATION]]) +

      +
      + [[SCREENSHOT_FLOW]] + [[ACTIVITIES]] +
      +
      diff --git a/Sources/XCTestHTMLReportCore/HTML/test_case_with_iterations.html b/Sources/XCTestHTMLReportCore/HTML/test_case_with_iterations.html new file mode 100644 index 00000000..76602e90 --- /dev/null +++ b/Sources/XCTestHTMLReportCore/HTML/test_case_with_iterations.html @@ -0,0 +1,11 @@ +
      + +

      + + + [[TITLE]] [[RESULT_STRING]] ([[DURATION]]) +

      +
      + [[ITERATIONS]] +
      +
      diff --git a/Tests/XCTestHTMLReportTests/FunctionalTests.swift b/Tests/XCTestHTMLReportTests/FunctionalTests.swift index 58c8cb88..38cef8e6 100644 --- a/Tests/XCTestHTMLReportTests/FunctionalTests.swift +++ b/Tests/XCTestHTMLReportTests/FunctionalTests.swift @@ -18,7 +18,9 @@ final class FunctionalTests: XCTestCase { let testResultsUrl = try XCTUnwrap(Bundle.testBundle.url(forResource: "TestResults", withExtension: "xcresult")) let (status, maybeStdOut, maybeStdErr) = try xchtmlreportCmd(args: ["-r", testResultsUrl.path]) XCTAssertEqual(status, 0) + #if !DEBUG // XCResultKit outputs non-fatals to stderr in debug mode XCTAssertEqual((maybeStdErr ?? "").isEmpty, true) + #endif let stdOut = try XCTUnwrap(maybeStdOut) let htmlUrl = try XCTUnwrap(urlFromXCHtmlreportStdout(stdOut)) diff --git a/Tests/XCTestHTMLReportTests/SummaryTests.swift b/Tests/XCTestHTMLReportTests/SummaryTests.swift index d7011302..fb080d26 100644 --- a/Tests/XCTestHTMLReportTests/SummaryTests.swift +++ b/Tests/XCTestHTMLReportTests/SummaryTests.swift @@ -31,4 +31,20 @@ final class SummaryTests: XCTestCase { static var allTests = [ ("testBasicFunctionality", testBasicFunctionality), ] + + func testRetryFunctionality() throws { + guard let testResultsUrl = Bundle.testBundle.url(forResource: "RetryResults", withExtension: "xcresult") else { + throw XCTSkip("RetryResults.xcresult not found, this likely means Xcode < 13.0") + } + + let summary = Summary(resultPaths: [testResultsUrl.path], renderingMode: .linking) + let html = summary.html + let parser = NDHpple(htmlData: html) + + try XCTContext.runActivity(named: "blah", block: { _ in + let uls = try XCTUnwrap(parser.peekAtSearch(withQuery: "//div[@class='tests-header']/ul")) + let texts = uls.children.filter { $0.name == "li" }.compactMap { $0.text } + XCTAssertEqual(texts[0].intGroupMatch("All \\((\\d+)\\)"), 2) + }) + } } diff --git a/XCTestHTMLReportSampleApp/SampleApp.xcodeproj/project.pbxproj b/XCTestHTMLReportSampleApp/SampleApp.xcodeproj/project.pbxproj index f6cfadd1..41b93d8a 100644 --- a/XCTestHTMLReportSampleApp/SampleApp.xcodeproj/project.pbxproj +++ b/XCTestHTMLReportSampleApp/SampleApp.xcodeproj/project.pbxproj @@ -7,6 +7,7 @@ objects = { /* Begin PBXBuildFile section */ + 30EF691527712BD600F96080 /* RetryTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 30EF691427712BD600F96080 /* RetryTests.swift */; }; 77239F5820CFAD7000BAB94E /* ThirdSuite.swift in Sources */ = {isa = PBXBuildFile; fileRef = 77239F5720CFAD7000BAB94E /* ThirdSuite.swift */; }; F39729081F2471A7006B1EF3 /* SecondSuite.swift in Sources */ = {isa = PBXBuildFile; fileRef = F39729071F2471A7006B1EF3 /* SecondSuite.swift */; }; F3AB012C1F2459FA00334580 /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = F3AB012B1F2459FA00334580 /* AppDelegate.swift */; }; @@ -37,6 +38,8 @@ /* End PBXContainerItemProxy section */ /* Begin PBXFileReference section */ + 30EF691427712BD600F96080 /* RetryTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = RetryTests.swift; sourceTree = ""; }; + 30F4276027727197005E8FC8 /* TestPlan.xctestplan */ = {isa = PBXFileReference; lastKnownFileType = text; name = TestPlan.xctestplan; path = ../../../../../Desktop/TestPlan.xctestplan; sourceTree = ""; }; 77239F5720CFAD7000BAB94E /* ThirdSuite.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ThirdSuite.swift; sourceTree = ""; }; F3223CEF1F26341D00BEDA4A /* iPhone.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = iPhone.png; sourceTree = ""; }; F39729071F2471A7006B1EF3 /* SecondSuite.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SecondSuite.swift; sourceTree = ""; }; @@ -116,10 +119,12 @@ F3AB013F1F2459FA00334580 /* SampleAppUITests */ = { isa = PBXGroup; children = ( + 30F4276027727197005E8FC8 /* TestPlan.xctestplan */, F3223CEF1F26341D00BEDA4A /* iPhone.png */, F3AB01401F2459FA00334580 /* FirstSuite.swift */, F39729071F2471A7006B1EF3 /* SecondSuite.swift */, 77239F5720CFAD7000BAB94E /* ThirdSuite.swift */, + 30EF691427712BD600F96080 /* RetryTests.swift */, F3AB01421F2459FA00334580 /* Info.plist */, ); path = SampleAppUITests; @@ -281,6 +286,7 @@ files = ( F39729081F2471A7006B1EF3 /* SecondSuite.swift in Sources */, 77239F5820CFAD7000BAB94E /* ThirdSuite.swift in Sources */, + 30EF691527712BD600F96080 /* RetryTests.swift in Sources */, F3AB01411F2459FA00334580 /* FirstSuite.swift in Sources */, ); runOnlyForDeploymentPostprocessing = 0; diff --git a/XCTestHTMLReportSampleApp/SampleAppUITests/RetryTests.swift b/XCTestHTMLReportSampleApp/SampleAppUITests/RetryTests.swift new file mode 100644 index 00000000..cb4c84bb --- /dev/null +++ b/XCTestHTMLReportSampleApp/SampleAppUITests/RetryTests.swift @@ -0,0 +1,43 @@ +// +// FourthSuite.swift +// +// +// Created by Tyler Vick on 12/20/21. +// + +import XCTest +import Foundation + +class RetryTests: XCTestCase { + + private var filePath: URL { + let sharedDir = NSTemporaryDirectory() + let persistentFileName = "will_succeed" + return URL(fileURLWithPath: sharedDir).appendingPathComponent(persistentFileName) + } + + private func writeFile() throws { + FileManager.default.createFile(atPath: filePath.path, contents: Data()) + } + + private func shouldSucceed() -> Bool { + FileManager.default.fileExists(atPath: filePath.path) + } + + func testJustPass() { + XCTAssertTrue(true) + } + + // First iteration will always fail, retry will succeed + func testRetryOnFailure() throws { + try XCTContext.runActivity(named: "Retryable Activity") { _ in + if shouldSucceed() { + try FileManager.default.removeItem(at: filePath) + } else { + try writeFile() + XCTFail() + } + } + } + +} diff --git a/createTemplates.sh b/createTemplates.sh index f0e44b0a..d0cae370 100755 --- a/createTemplates.sh +++ b/createTemplates.sh @@ -4,7 +4,10 @@ index=`cat Sources/XCTestHTMLReport/HTML/index.html | sed 's,",\\\\",g'` testSummary=`cat Sources/XCTestHTMLReport/HTML/test_summary.html | sed 's,",\\\\",g'` run=`cat Sources/XCTestHTMLReport/HTML/run.html | sed 's,",\\\\",g'` device=`cat Sources/XCTestHTMLReport/HTML/device.html | sed 's,",\\\\",g'` -test=`cat Sources/XCTestHTMLReport/HTML/test.html | sed 's,",\\\\",g'` +testGroup=`cat Sources/XCTestHTMLReport/HTML/test_group.html | sed 's,",\\\\",g'` +testCase=`cat Sources/XCTestHTMLReport/HTML/test_case.html | sed 's,",\\\\",g'` +testCaseWithIterations=`cat Sources/XCTestHTMLReport/HTML/test_case_with_iterations.html | sed 's,",\\\\",g'` +iteration=`cat Sources/XCTestHTMLReport/HTML/iteration.html | sed 's,",\\\\",g'` activity=`cat Sources/XCTestHTMLReport/HTML/activity.html | sed 's,",\\\\",g'` screenshot=`cat Sources/XCTestHTMLReport/HTML/screenshot.html | sed 's,",\\\\",g'` text=`cat Sources/XCTestHTMLReport/HTML/text.html | sed 's,",\\\\",g'` @@ -30,8 +33,20 @@ $run $testSummary \"\"\" - static let test = \"\"\" -$test + static let testGroup = \"\"\" +$testGroup + \"\"\" + + static let testCase = \"\"\" +$testCase + \"\"\" + + static let testCaseWithIterations = \"\"\" +$testCaseWithIterations + \"\"\" + + static let iteration = \"\"\" +$iteration \"\"\" static let activity = \"\"\" diff --git a/prepareTestResults.sh b/prepareTestResults.sh index c1012b7c..c849628c 100755 --- a/prepareTestResults.sh +++ b/prepareTestResults.sh @@ -1,5 +1,5 @@ -#! /bin/bash -set -e +#!/bin/bash +set -ex cd XCTestHTMLReportSampleApp @@ -10,9 +10,31 @@ xcodebuild test \ -project SampleApp.xcodeproj \ -scheme MainScheme \ -destination 'platform=iOS Simulator,name=iPhone 8,OS=latest' \ + -skip-testing:SampleAppUITests/RetryTests \ -resultBundlePath "$FILENAME" || true + echo "Even if some test failed this is OK." + echo "${FILENAME} should contain succeed, failed and skipped tests for xchtmlreport functional testing" rm -rf "../Tests/XCTestHTMLReportTests/${FILENAME}" mv "$FILENAME" "../Tests/XCTestHTMLReportTests/" -echo "$(tput setaf 2)$(basename "$0") successfully finished$(tput sgr 0)" \ No newline at end of file + +if [[ $XCODE_VERSION != 12.* && $XCODE_VERSION != 11.* ]]; then + # "Mixed" test results must be run separately to use -retry-tests-on-failure + RETRY_FILENAME='RetryResults.xcresult' + rm -rf "$RETRY_FILENAME" + xcodebuild test \ + -project SampleApp.xcodeproj \ + -scheme MainScheme \ + -destination 'platform=iOS Simulator,name=iPhone 8,OS=latest' \ + -test-iterations 2 \ + -retry-tests-on-failure \ + -only-testing:SampleAppUITests/RetryTests \ + -resultBundlePath "$RETRY_FILENAME" || true + + echo "${RETRY_FILENAME} will contain mixed test results" + rm -rf "../Tests/XCTestHTMLReportTests/${RETRY_FILENAME}" + mv "$RETRY_FILENAME" "../Tests/XCTestHTMLReportTests/" +fi + +echo "$(tput setaf 2)$(basename "$0") successfully finished$(tput sgr 0)" From 33dc257e883e5e57b8d072e6e83125aa90e25339 Mon Sep 17 00:00:00 2001 From: Tyler Vick <1395852+tylervick@users.noreply.github.com> Date: Tue, 5 Jul 2022 23:38:16 -0600 Subject: [PATCH 6/7] Update next from main, resolve conflicts (#266) * sync: main to next (#6) * Create sync-next.yml * Try single reviewer for parsing Co-authored-by: Tyler Vick <1395852+tylervick@users.noreply.github.com> * resolve conflicts Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- .github/workflows/cd.yml | 16 +++ Gemfile.lock | 8 +- Package.swift | 3 +- Sources/XCTestHTMLReport/main.swift | 6 +- .../Classes/Helpers/ImageHelpers.swift | 116 ++++++++++++++---- .../Classes/Models/Activity.swift | 6 +- .../Classes/Models/Attachment.swift | 45 +++++-- .../Classes/Models/Iteration.swift | 4 +- .../Classes/Models/ResultFile.swift | 12 +- .../Classes/Models/Run.swift | 4 +- .../Classes/Models/Summary.swift | 19 +-- .../Classes/Models/Test.swift | 10 +- .../Classes/Models/TestSummary.swift | 4 +- .../XCTestHTMLReportTests/SummaryTests.swift | 4 +- 14 files changed, 173 insertions(+), 84 deletions(-) diff --git a/.github/workflows/cd.yml b/.github/workflows/cd.yml index 1c0354c0..81d5741e 100644 --- a/.github/workflows/cd.yml +++ b/.github/workflows/cd.yml @@ -85,3 +85,19 @@ jobs: application/xchtmlreport-* env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + + update_brew_formula: + runs-on: ubuntu-latest + + needs: release + + steps: + - name: Repository Dispatch + uses: peter-evans/repository-dispatch@v1 + env: + VERSION: ${GITHUB_REF/refs\/tags\//} + with: + token: ${{ secrets.DISPATCH_ACCESS_TOKEN }} + event-type: release + client-payload: '{"tag": "${{ env.VERSION }}"}' + repository: XCTestHTMLReport/homebrew-xchtmlreport diff --git a/Gemfile.lock b/Gemfile.lock index 567a8036..092e8b18 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -2,11 +2,11 @@ GEM remote: https://rubygems.org/ specs: colorize (0.8.1) - mini_portile2 (2.6.1) - nokogiri (1.12.5) - mini_portile2 (~> 2.6.1) + mini_portile2 (2.8.0) + nokogiri (1.13.6) + mini_portile2 (~> 2.8.0) racc (~> 1.4) - racc (1.5.2) + racc (1.6.0) rouge (2.0.7) thor (0.20.0) xcpretty (0.2.8) diff --git a/Package.swift b/Package.swift index 60236e03..8d3022de 100644 --- a/Package.swift +++ b/Package.swift @@ -1,4 +1,5 @@ -// swift-tools-version:5.4 +// swift-tools-version:5.5 +// The swift-tools-version declares the minimum version of Swift required to build this package. import PackageDescription diff --git a/Sources/XCTestHTMLReport/main.swift b/Sources/XCTestHTMLReport/main.swift index eb5c92f4..2ff602ab 100644 --- a/Sources/XCTestHTMLReport/main.swift +++ b/Sources/XCTestHTMLReport/main.swift @@ -62,7 +62,7 @@ struct XcTestHtmlReport: ParsableCommand { } Logger.substep("Writing report to \(path)") - let summary = Summary(resultPaths: completeResults, renderingMode: renderingMode) + let summary = Summary(resultPaths: completeResults, renderingMode: renderingMode, downsizeImagesEnabled: downsizeImages) Logger.step("Building HTML..") let html = summary.generatedHtmlReport() @@ -77,10 +77,6 @@ struct XcTestHtmlReport: ParsableCommand { Logger.success("\nReport successfully created at \(path)") if renderingMode == .linking { - if downsizeImages { - summary.reduceImageSizes() - } - if deleteUnattachedFiles { summary.deleteUnattachedFiles() } diff --git a/Sources/XCTestHTMLReportCore/Classes/Helpers/ImageHelpers.swift b/Sources/XCTestHTMLReportCore/Classes/Helpers/ImageHelpers.swift index f83bab98..9400aa21 100644 --- a/Sources/XCTestHTMLReportCore/Classes/Helpers/ImageHelpers.swift +++ b/Sources/XCTestHTMLReportCore/Classes/Helpers/ImageHelpers.swift @@ -6,8 +6,6 @@ import Foundation import Cocoa -let imageWidth: CGFloat = 200 -let imageCompression: Float = 0.8 /// Performs an image resize for the image at the provided path /// image is resized to be 200px width - aspect ratio maintaned @@ -16,33 +14,91 @@ let imageCompression: Float = 0.8 /// is not modified /// /// - Parameter path: path to an image -func resizeImage(atPath path: String) -> Bool { - guard let image = NSImage(contentsOfFile: path) else { - return false - } - let sizeRatio = imageWidth/image.size.width - guard sizeRatio<1.0 else { - return false - } - let resizedImage = resize(image: image, - w: Int(image.size.width*sizeRatio), - h: Int(image.size.height*sizeRatio)) - let destinationURL = URL(fileURLWithPath: path) - resizedImage.jpegWrite(to: destinationURL, options: .atomic, compression: imageCompression) - return true + + +enum ResizeError: Error { + case largerThanOriginal + case contentNotImage + case imageFileNotFound + case imageEncodingFailed +} + +extension RenderingContent { + static let downsizedWidth: CGFloat = 200 + static let imageCompression: Float = 0.8 + + static func downsizeFrom(_ content: RenderingContent) throws -> RenderingContent { + switch content { + case .data(let data): + return .data(try RenderingContent.resize(content: data)) + case .url(let url): + return .url(try RenderingContent.resize(content: url)) + case .none: + throw ResizeError.contentNotImage + } + } + + private static func resize(content: C) throws -> C { + let image = try content.asNSImage() + let newSize = CGSize.scaleFrom(image.size, usingMaxWidth: downsizedWidth) + let resizedImage = NSImage.from(image: image, scaledTo: newSize) + return try C.from(content: content, image: resizedImage) + } +} + +protocol NSImageResizable { + + associatedtype Format = Self + + func asNSImage() throws -> NSImage + + static func from(content: Self, image: NSImage) throws -> Self + +} + +extension Data: NSImageResizable { + static func from(content _: Data, image: NSImage) throws -> Data { + guard let data = image.jpegData(compression: RenderingContent.imageCompression) else { + throw ResizeError.imageEncodingFailed + } + return data + } + + func asNSImage() throws -> NSImage { + guard let image = NSImage(data: self) else { + throw ResizeError.contentNotImage + } + return image + } } -func resize(image: NSImage, w: Int, h: Int) -> NSImage { - let destSize = NSMakeSize(CGFloat(w), CGFloat(h)) - let newImage = NSImage(size: destSize) - newImage.lockFocus() - image.draw(in: NSMakeRect(0, 0, destSize.width, destSize.height), from: NSMakeRect(0, 0, image.size.width, image.size.height), operation: NSCompositingOperation.sourceOver, fraction: CGFloat(1)) - newImage.unlockFocus() - newImage.size = destSize - return NSImage(data: newImage.tiffRepresentation!)! +extension URL: NSImageResizable { + static func from(content url: URL, image: NSImage) throws -> URL { + try FileManager.default.removeItem(at: url) + try image.jpegData(compression: RenderingContent.imageCompression)?.write(to: url, options: .atomic) + return url + } + + func asNSImage() throws -> NSImage { + guard let image = NSImage(contentsOf: self) else { + throw ResizeError.imageFileNotFound + } + return image + } } extension NSImage { + + static func from(image: NSImage, scaledTo newSize: CGSize) -> NSImage { + let newImage = NSImage(size: newSize) + newImage.lockFocus() + image.draw(in: NSRect(origin: .zero, size: newSize), + from: NSRect(origin: .zero, size: image.size), + operation: .sourceOver, + fraction: 1) + newImage.unlockFocus() + return newImage + } func jpegData(compression: Float) -> Data? { guard let tiffRepresentation = tiffRepresentation, let bitmapImage = NSBitmapImageRep(data: tiffRepresentation) else { return nil } @@ -61,3 +117,15 @@ extension NSImage { } } + +extension CGSize: Comparable { + public static func scaleFrom(_ size: CGSize, usingMaxWidth width: CGFloat) -> CGSize { + let ratio = width / size.width + return CGSize(width: size.width * ratio, height: size.height * ratio) + } + + // Compares by area + public static func < (lhs: CGSize, rhs: CGSize) -> Bool { + return (lhs.width * lhs.height) < (rhs.width * rhs.height) + } +} diff --git a/Sources/XCTestHTMLReportCore/Classes/Models/Activity.swift b/Sources/XCTestHTMLReportCore/Classes/Models/Activity.swift index f177d67c..f0eb4187 100644 --- a/Sources/XCTestHTMLReportCore/Classes/Models/Activity.swift +++ b/Sources/XCTestHTMLReportCore/Classes/Models/Activity.swift @@ -84,17 +84,17 @@ struct Activity: HTML { return cls } - init(summary: ActionTestActivitySummary, file: ResultFile, padding: Int = 0, renderingMode: Summary.RenderingMode) { + init(summary: ActionTestActivitySummary, file: ResultFile, padding: Int = 0, renderingMode: Summary.RenderingMode, downsizeImagesEnabled: Bool) { uuid = summary.uuid startTime = summary.start?.timeIntervalSince1970 ?? 0 finishTime = summary.finish?.timeIntervalSince1970 ?? 0 title = summary.title subActivities = summary.subactivities.map { - Activity(summary: $0, file: file, padding: padding + 10, renderingMode: renderingMode) + Activity(summary: $0, file: file, padding: padding + 10, renderingMode: renderingMode, downsizeImagesEnabled: downsizeImagesEnabled) } type = ActivityType(rawValue: summary.activityType) attachments = summary.attachments.map { - Attachment(attachment: $0, file: file, padding: padding + 16, renderingMode: renderingMode) + Attachment(attachment: $0, file: file, padding: padding + 16, renderingMode: renderingMode, downsizeImagesEnabled: downsizeImagesEnabled) } self.padding = padding } diff --git a/Sources/XCTestHTMLReportCore/Classes/Models/Attachment.swift b/Sources/XCTestHTMLReportCore/Classes/Models/Attachment.swift index 07a89447..feda76fa 100644 --- a/Sources/XCTestHTMLReportCore/Classes/Models/Attachment.swift +++ b/Sources/XCTestHTMLReportCore/Classes/Models/Attachment.swift @@ -19,6 +19,18 @@ enum AttachmentType: String { case mp4 = "public.mpeg-4" case text = "public.plain-text" case log = "com.apple.log" + + var isImage: Bool { + [.jpeg, .png, .heic].contains(self) + } + + var isVideo: Bool { + [.mp4].contains(self) + } + + var isFile: Bool { + [.text, .html, .data, .log].contains(self) + } var cssClass: String { switch self { @@ -90,19 +102,33 @@ struct Attachment: HTML let type: AttachmentType let name: AttachmentName? - init(attachment: ActionTestAttachment, file: ResultFile, padding: Int = 0, renderingMode: Summary.RenderingMode) { + init(attachment: ActionTestAttachment, + file: ResultFile, + padding: Int = 0, + renderingMode: Summary.RenderingMode, + downsizeImagesEnabled: Bool + ) { self.filename = attachment.filename ?? "" self.type = AttachmentType(rawValue: attachment.uniformTypeIdentifier) ?? .unknown self.name = attachment.name.map(AttachmentName.init(rawValue:)) + self.padding = padding + var content: RenderingContent = .none if let id = attachment.payloadRef?.id { - self.content = file.exportPayloadContent( + content = file.exportPayloadContent( id: id, - renderingMode: renderingMode + renderingMode: renderingMode, + fileName: attachment.filename ) - } else { - self.content = .none + if downsizeImagesEnabled && type.isImage { + do { + content = try RenderingContent.downsizeFrom(content) + } catch { + Logger.error("Image resize failed with error: \(error.localizedDescription)") + } + } } - self.padding = padding + self.content = content + } var fallbackDisplayName: String { @@ -142,12 +168,7 @@ struct Attachment: HTML } var isScreenshot: Bool { - switch type { - case .png, .jpeg, .heic: - return true - default: - return false - } + type.isImage } // PRAGMA MARK: - HTML diff --git a/Sources/XCTestHTMLReportCore/Classes/Models/Iteration.swift b/Sources/XCTestHTMLReportCore/Classes/Models/Iteration.swift index f3a972c4..a8202f4d 100644 --- a/Sources/XCTestHTMLReportCore/Classes/Models/Iteration.swift +++ b/Sources/XCTestHTMLReportCore/Classes/Models/Iteration.swift @@ -22,7 +22,7 @@ struct Iteration: Test { TestScreenshotFlow(activities: activities) } - init(metadata: ActionTestMetadata, resultFile: ResultFile, renderingMode: Summary.RenderingMode) { + init(metadata: ActionTestMetadata, resultFile: ResultFile, renderingMode: Summary.RenderingMode, downsizeImagesEnabled: Bool) { title = metadata.name identifier = metadata.identifier status = Status(rawValue: metadata.testStatus) ?? .unknown @@ -32,7 +32,7 @@ struct Iteration: Test { let actionTestSummary = resultFile.getActionTestSummary(id: id) { activities = actionTestSummary.activitySummaries.map { - Activity(summary: $0, file: resultFile, padding: 20, renderingMode: renderingMode) + Activity(summary: $0, file: resultFile, padding: 20, renderingMode: renderingMode, downsizeImagesEnabled: downsizeImagesEnabled) } repetitionPolicy = actionTestSummary.repetitionPolicySummary diff --git a/Sources/XCTestHTMLReportCore/Classes/Models/ResultFile.swift b/Sources/XCTestHTMLReportCore/Classes/Models/ResultFile.swift index 8f7f4964..637c60fa 100644 --- a/Sources/XCTestHTMLReportCore/Classes/Models/ResultFile.swift +++ b/Sources/XCTestHTMLReportCore/Classes/Models/ResultFile.swift @@ -22,17 +22,17 @@ class ResultFile { // MARK: - Public - func exportPayload(id: String) -> URL? { + func exportPayload(id: String, fileName: String?) -> URL? { guard let savedURL = file.exportPayload(id: id) else { Logger.warning("Can't export payload with id \(id)") return nil } - let url = self.url.appendingPathComponent(id) + let url = url.appendingPathComponent(fileName ?? id) let fileManager = FileManager.default do { try? fileManager.removeItem(at: url) try fileManager.moveItem(at: savedURL, to: url) - return relativeUrl.appendingPathComponent(id) + return url } catch { Logger.warning("Can't move item from \(savedURL) to \(url). \(error.localizedDescription)") return nil @@ -98,12 +98,14 @@ class ResultFile { extension ResultFile { func exportPayloadContent(id: String, - renderingMode: Summary.RenderingMode) -> RenderingContent { + renderingMode: Summary.RenderingMode, + fileName: String? + ) -> RenderingContent { switch renderingMode { case .inline: return exportPayloadData(id: id).map(RenderingContent.data) ?? .none case .linking: - return exportPayload(id: id).map(RenderingContent.url) ?? .none + return exportPayload(id: id, fileName: fileName).map(RenderingContent.url) ?? .none } } diff --git a/Sources/XCTestHTMLReportCore/Classes/Models/Run.swift b/Sources/XCTestHTMLReportCore/Classes/Models/Run.swift index 2cc5f505..ba4303c7 100644 --- a/Sources/XCTestHTMLReportCore/Classes/Models/Run.swift +++ b/Sources/XCTestHTMLReportCore/Classes/Models/Run.swift @@ -56,7 +56,7 @@ struct Run: HTML { allTests.filter { $0.status == .mixed }.count } - init?(action: ActionRecord, file: ResultFile, renderingMode: Summary.RenderingMode) { + init?(action: ActionRecord, file: ResultFile, renderingMode: Summary.RenderingMode, downsizeImagesEnabled: Bool) { self.file = file runDestination = RunDestination(record: action.runDestination) @@ -81,7 +81,7 @@ struct Run: HTML { } testSummaries = testPlanSummaries.summaries .flatMap(\.testableSummaries) - .map { TestSummary(summary: $0, file: file, renderingMode: renderingMode) } + .map { TestSummary(summary: $0, file: file, renderingMode: renderingMode, downsizeImagesEnabled: downsizeImagesEnabled) } } private var logSource: String? { diff --git a/Sources/XCTestHTMLReportCore/Classes/Models/Summary.swift b/Sources/XCTestHTMLReportCore/Classes/Models/Summary.swift index eeca6f5a..9d7606f5 100644 --- a/Sources/XCTestHTMLReportCore/Classes/Models/Summary.swift +++ b/Sources/XCTestHTMLReportCore/Classes/Models/Summary.swift @@ -17,7 +17,7 @@ public struct Summary { case linking } - public init(resultPaths: [String], renderingMode: RenderingMode) { + public init(resultPaths: [String], renderingMode: RenderingMode, downsizeImagesEnabled: Bool) { var runs: [Run] = [] for resultPath in resultPaths { Logger.step("Parsing \(resultPath)") @@ -28,28 +28,13 @@ public struct Summary { break } let resultRuns = invocationRecord.actions.compactMap { - Run(action: $0, file: resultFile, renderingMode: renderingMode) + Run(action: $0, file: resultFile, renderingMode: renderingMode, downsizeImagesEnabled: downsizeImagesEnabled) } runs.append(contentsOf: resultRuns) } self.runs = runs } - /// Reduce size of all images in attachments - public func reduceImageSizes() { - Logger.substep("Resizing images..") - var resizedCount = 0 - for run in runs { - for screenshotAttachment in run.screenshotAttachments { - let resized = resizeImage(atPath: run.file.url.path + "/../" + (screenshotAttachment.source ?? "")) - if resized { - resizedCount += 1 - } - } - } - Logger.substep("Finished resizing \(resizedCount) images") - } - /// Generate HTML report /// - Returns: Generated HTML report string public func generatedHtmlReport() -> String { diff --git a/Sources/XCTestHTMLReportCore/Classes/Models/Test.swift b/Sources/XCTestHTMLReportCore/Classes/Models/Test.swift index f59365e1..3282997c 100644 --- a/Sources/XCTestHTMLReportCore/Classes/Models/Test.swift +++ b/Sources/XCTestHTMLReportCore/Classes/Models/Test.swift @@ -87,16 +87,16 @@ public struct TestGroup: Test { } } - init(group: ActionTestSummaryGroup, resultFile: ResultFile, renderingMode: Summary.RenderingMode) { + init(group: ActionTestSummaryGroup, resultFile: ResultFile, renderingMode: Summary.RenderingMode, downsizeImagesEnabled: Bool) { title = group.name ?? "---group-name-not-found---" identifier = group.identifier ?? "---group-identifier-not-found---" duration = group.duration if group.subtests.isEmpty { - subTests = group.subtestGroups.map { TestGroup(group: $0, resultFile: resultFile, renderingMode: renderingMode) } + subTests = group.subtestGroups.map { TestGroup(group: $0, resultFile: resultFile, renderingMode: renderingMode, downsizeImagesEnabled: downsizeImagesEnabled) } } else { subTests = Array(group.subtests.reduce(into: Set()) { subTestSet, metadata in - let newTest = TestCase(metadata: metadata, resultFile: resultFile, renderingMode: renderingMode) + let newTest = TestCase(metadata: metadata, resultFile: resultFile, renderingMode: renderingMode, downsizeImagesEnabled: downsizeImagesEnabled) if let index = subTestSet.firstIndex(of: newTest) { var existingTest = subTestSet[index] existingTest.iterations.append(contentsOf: newTest.iterations) @@ -173,11 +173,11 @@ struct TestCase: Test { // This should be the only mutable property var iterations: [Iteration] - init(metadata: ActionTestMetadata, resultFile: ResultFile, renderingMode: Summary.RenderingMode) { + init(metadata: ActionTestMetadata, resultFile: ResultFile, renderingMode: Summary.RenderingMode, downsizeImagesEnabled: Bool) { title = metadata.name identifier = metadata.identifier - iterations = [Iteration(metadata: metadata, resultFile: resultFile, renderingMode: renderingMode)] + iterations = [Iteration(metadata: metadata, resultFile: resultFile, renderingMode: renderingMode, downsizeImagesEnabled: downsizeImagesEnabled)] } } diff --git a/Sources/XCTestHTMLReportCore/Classes/Models/TestSummary.swift b/Sources/XCTestHTMLReportCore/Classes/Models/TestSummary.swift index 2b3ddcaa..3f4a0a82 100644 --- a/Sources/XCTestHTMLReportCore/Classes/Models/TestSummary.swift +++ b/Sources/XCTestHTMLReportCore/Classes/Models/TestSummary.swift @@ -41,12 +41,12 @@ struct TestSummary: HTML { return status } - init(summary: ActionTestableSummary, file: ResultFile, renderingMode: Summary.RenderingMode) { + init(summary: ActionTestableSummary, file: ResultFile, renderingMode: Summary.RenderingMode, downsizeImagesEnabled: Bool) { uuid = UUID().uuidString testName = summary.targetName ?? "" // TODO: Reduce this with iterations & accum with hashmap tests = summary.tests.map { - TestGroup(group: $0, resultFile: file, renderingMode: renderingMode) + TestGroup(group: $0, resultFile: file, renderingMode: renderingMode, downsizeImagesEnabled: downsizeImagesEnabled) } } diff --git a/Tests/XCTestHTMLReportTests/SummaryTests.swift b/Tests/XCTestHTMLReportTests/SummaryTests.swift index fb080d26..3fa32d06 100644 --- a/Tests/XCTestHTMLReportTests/SummaryTests.swift +++ b/Tests/XCTestHTMLReportTests/SummaryTests.swift @@ -14,7 +14,7 @@ final class SummaryTests: XCTestCase { func testBasicFunctionality() throws { let testResultsUrl = try XCTUnwrap(Bundle.testBundle.url(forResource: "TestResults", withExtension: "xcresult")) - let summary = Summary(resultPaths: [testResultsUrl.path], renderingMode: .linking) + let summary = Summary(resultPaths: [testResultsUrl.path], renderingMode: .linking, downsizeImagesEnabled: false) let html = summary.html let parser = NDHpple(htmlData: html) @@ -37,7 +37,7 @@ final class SummaryTests: XCTestCase { throw XCTSkip("RetryResults.xcresult not found, this likely means Xcode < 13.0") } - let summary = Summary(resultPaths: [testResultsUrl.path], renderingMode: .linking) + let summary = Summary(resultPaths: [testResultsUrl.path], renderingMode: .linking, downsizeImagesEnabled: false) let html = summary.html let parser = NDHpple(htmlData: html) From d849dfa36776cf783b7f7c4df4e2125897c42e4e Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Tue, 19 Jul 2022 13:23:35 -0600 Subject: [PATCH 7/7] sync: main to next (#270) * indent nested logs (#243) * Tvick/mixed test status (#7) * add mixed result support * update html templates -S * gate retry test data to xcode 13 * properly gate... * skip test on xcode 12 * fix tests with new retry logic * NOT debug * hardcoded version bump * update actions, remove xc 12.5 * Update ci.yml * Update actions, remove xc 12.5 (#250) * update actions, remove xc 12.5 * Update cd.yml * Run downsize during attachment creation and include inline attachments (#253) * run image downsize alongside export step, include inlined images * update swift version * Update cd.yml * Update cd.yml * Bump nokogiri from 1.12.5 to 1.13.2 (#257) Bumps [nokogiri](https://github.com/sparklemotion/nokogiri) from 1.12.5 to 1.13.2. - [Release notes](https://github.com/sparklemotion/nokogiri/releases) - [Changelog](https://github.com/sparklemotion/nokogiri/blob/main/CHANGELOG.md) - [Commits](https://github.com/sparklemotion/nokogiri/compare/v1.12.5...v1.13.2) --- updated-dependencies: - dependency-name: nokogiri dependency-type: direct:production ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> * Bump nokogiri from 1.13.2 to 1.13.4 (#260) Bumps [nokogiri](https://github.com/sparklemotion/nokogiri) from 1.13.2 to 1.13.4. - [Release notes](https://github.com/sparklemotion/nokogiri/releases) - [Changelog](https://github.com/sparklemotion/nokogiri/blob/v1.13.4/CHANGELOG.md) - [Commits](https://github.com/sparklemotion/nokogiri/compare/v1.13.2...v1.13.4) --- updated-dependencies: - dependency-name: nokogiri dependency-type: direct:production ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> * Bump nokogiri from 1.13.4 to 1.13.6 (#262) Bumps [nokogiri](https://github.com/sparklemotion/nokogiri) from 1.13.4 to 1.13.6. - [Release notes](https://github.com/sparklemotion/nokogiri/releases) - [Changelog](https://github.com/sparklemotion/nokogiri/blob/main/CHANGELOG.md) - [Commits](https://github.com/sparklemotion/nokogiri/compare/v1.13.4...v1.13.6) --- updated-dependencies: - dependency-name: nokogiri dependency-type: direct:production ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> * Update README.md (#269) Co-authored-by: Tyler Vick <1395852+tylervick@users.noreply.github.com> Co-authored-by: tylervick Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- README.md | 18 +++++++++--------- .../Classes/Models/Attachment.swift | 1 - 2 files changed, 9 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index 1322beb3..c84312d2 100644 --- a/README.md +++ b/README.md @@ -34,33 +34,33 @@ https://github.com/TitouanVanBelle/fastlane-plugin-xchtmlreport ## Installation -### Mint +### Homebrew (recommended) -[Mint](https://) is the easiest way... +Install via [Homebrew](https://brew.sh/) tap... Install latest stable version ```bash -mint install XCTestHTMLReport/XCTestHTMLReport +brew install XCTestHtmlReport/xchtmlreport/xchtmlreport ``` Install latest from `main` branch ``` -mint install XCTestHTMLReport/XCTestHTMLReport@main + +brew install XCTestHtmlReport/xchtmlreport/xchtmlreport --HEAD ``` -### Homebrew +### Mint -Install via [Homebrew](https://brew.sh/) tap... +[Mint](https://github.com/yonaskolb/Mint) is the easiest way... Install latest stable version ```bash -brew install XCTestHtmlReport/xchtmlreport/xchtmlreport +mint install XCTestHTMLReport/XCTestHTMLReport ``` Install latest from `main` branch ``` - -brew install XCTestHtmlReport/xchtmlreport/xchtmlreport --HEAD +mint install XCTestHTMLReport/XCTestHTMLReport@main ``` ## Usage diff --git a/Sources/XCTestHTMLReportCore/Classes/Models/Attachment.swift b/Sources/XCTestHTMLReportCore/Classes/Models/Attachment.swift index feda76fa..193e4525 100644 --- a/Sources/XCTestHTMLReportCore/Classes/Models/Attachment.swift +++ b/Sources/XCTestHTMLReportCore/Classes/Models/Attachment.swift @@ -128,7 +128,6 @@ struct Attachment: HTML } } self.content = content - } var fallbackDisplayName: String {