From a70002b5448518e77174a13b68e98364fdd02033 Mon Sep 17 00:00:00 2001 From: hp Date: Sun, 25 Nov 2012 14:02:06 +0200 Subject: [PATCH] first commit --- .gitignore | 88 ++ HpToolsLauncher/ConsoleWriter.cs | 80 ++ HpToolsLauncher/ExportOptions.cs | 31 + HpToolsLauncher/Helper.cs | 651 ++++++++++ HpToolsLauncher/HpToolsLauncher.csproj | 142 +++ HpToolsLauncher/HpToolsLauncher.sln | 32 + HpToolsLauncher/IniManager.cs | 148 +++ HpToolsLauncher/Interfaces/IAssetRunner.cs | 14 + .../Interfaces/IFileSysTestRunner.cs | 16 + HpToolsLauncher/Interfaces/IMtbManager.cs | 37 + HpToolsLauncher/Interfaces/IXmlBuilder.cs | 18 + HpToolsLauncher/JavaProperties/JavaIniFile.cs | 85 ++ .../JavaProperties/JavaProperties.cs | 603 +++++++++ HpToolsLauncher/JunitXml/JunitXmlBuilder.cs | 92 ++ HpToolsLauncher/JunitXml/junit.cs | 801 ++++++++++++ HpToolsLauncher/JunitXml/junit.xsd | 94 ++ HpToolsLauncher/Launcher.cs | 400 ++++++ HpToolsLauncher/MtbManager.cs | 122 ++ HpToolsLauncher/Program.cs | 93 ++ HpToolsLauncher/Properties/AssemblyInfo.cs | 41 + .../Properties/Resources.Designer.cs | 181 +++ HpToolsLauncher/Properties/Resources.resx | 160 +++ HpToolsLauncher/Runners/AlmTestSetsRunner.cs | 1095 +++++++++++++++++ .../Runners/FileSystemTestsRunner.cs | 361 ++++++ HpToolsLauncher/Runners/RunnerBase.cs | 33 + HpToolsLauncher/TestRunResults.cs | 50 + HpToolsLauncher/TestRunners/ApiTestRunner.cs | 289 +++++ HpToolsLauncher/TestRunners/GuiTestRunner.cs | 540 ++++++++ HpToolsLauncher/TestSuiteRunResults.cs | 63 + HpToolsLauncher/app.config | 3 + .../externals/QTObjectModelLib.dll | Bin 0 -> 77824 bytes .../externals/interop.OTAClient.dll | Bin 0 -> 1272912 bytes pom.xml | 29 + .../automation/tools/AlmToolsUtils.java | 59 + .../automation/tools/EncryptionUtils.java | 53 + .../tools/model/AlmServerSettingsModel.java | 49 + .../tools/model/EnumDescription.java | 25 + .../tools/model/ResultsPublisherModel.java | 42 + .../tools/model/RunFromAlmModel.java | 162 +++ .../tools/model/RunFromFileSystemModel.java | 76 ++ .../automation/tools/model/RunMode.java | 25 + .../tools/results/RunResultRecorder.java | 412 +++++++ .../automation/tools/run/AlmRunTypes.java | 13 + .../tools/run/RunFromAlmBuilder.java | 302 +++++ .../tools/run/RunFromFileBuilder.java | 216 ++++ .../settings/AlmServerSettingsBuilder.java | 171 +++ src/main/resources/HpToolsLauncher.exe | Bin 0 -> 108032 bytes .../results/RunResultRecorder/config.jelly | 22 + .../help-archiveTestResultsMode.html | 5 + .../tools/run/RunFromAlmBuilder/config.jelly | 74 ++ .../run/RunFromAlmBuilder/config.properties | 5 + .../RunFromAlmBuilder/help-AlmRunHost.html | 3 + .../RunFromAlmBuilder/help-AlmRunMode.html | 8 + .../RunFromAlmBuilder/help-AlmTestSets.html | 4 + .../RunFromAlmBuilder/help-AlmTimeout.html | 3 + .../tools/run/RunFromFileBuilder/config.jelly | 26 + .../run/RunFromFileBuilder/config.properties | 3 + .../run/RunFromFileBuilder/help-FsTests.html | 3 + .../RunFromFileBuilder/help-FsTimeout.html | 3 + .../AlmServerSettingsBuilder/global.jelly | 39 + .../help-almServerName.html | 3 + .../help-almServerUrl.html | 3 + .../help-almServerVersion.html | 3 + src/main/resources/index.jelly | 6 + 64 files changed, 8210 insertions(+) create mode 100644 .gitignore create mode 100644 HpToolsLauncher/ConsoleWriter.cs create mode 100644 HpToolsLauncher/ExportOptions.cs create mode 100644 HpToolsLauncher/Helper.cs create mode 100644 HpToolsLauncher/HpToolsLauncher.csproj create mode 100644 HpToolsLauncher/HpToolsLauncher.sln create mode 100644 HpToolsLauncher/IniManager.cs create mode 100644 HpToolsLauncher/Interfaces/IAssetRunner.cs create mode 100644 HpToolsLauncher/Interfaces/IFileSysTestRunner.cs create mode 100644 HpToolsLauncher/Interfaces/IMtbManager.cs create mode 100644 HpToolsLauncher/Interfaces/IXmlBuilder.cs create mode 100644 HpToolsLauncher/JavaProperties/JavaIniFile.cs create mode 100644 HpToolsLauncher/JavaProperties/JavaProperties.cs create mode 100644 HpToolsLauncher/JunitXml/JunitXmlBuilder.cs create mode 100644 HpToolsLauncher/JunitXml/junit.cs create mode 100644 HpToolsLauncher/JunitXml/junit.xsd create mode 100644 HpToolsLauncher/Launcher.cs create mode 100644 HpToolsLauncher/MtbManager.cs create mode 100644 HpToolsLauncher/Program.cs create mode 100644 HpToolsLauncher/Properties/AssemblyInfo.cs create mode 100644 HpToolsLauncher/Properties/Resources.Designer.cs create mode 100644 HpToolsLauncher/Properties/Resources.resx create mode 100644 HpToolsLauncher/Runners/AlmTestSetsRunner.cs create mode 100644 HpToolsLauncher/Runners/FileSystemTestsRunner.cs create mode 100644 HpToolsLauncher/Runners/RunnerBase.cs create mode 100644 HpToolsLauncher/TestRunResults.cs create mode 100644 HpToolsLauncher/TestRunners/ApiTestRunner.cs create mode 100644 HpToolsLauncher/TestRunners/GuiTestRunner.cs create mode 100644 HpToolsLauncher/TestSuiteRunResults.cs create mode 100644 HpToolsLauncher/app.config create mode 100644 HpToolsLauncher/externals/QTObjectModelLib.dll create mode 100644 HpToolsLauncher/externals/interop.OTAClient.dll create mode 100644 pom.xml create mode 100644 src/main/java/com/hp/application/automation/tools/AlmToolsUtils.java create mode 100644 src/main/java/com/hp/application/automation/tools/EncryptionUtils.java create mode 100644 src/main/java/com/hp/application/automation/tools/model/AlmServerSettingsModel.java create mode 100644 src/main/java/com/hp/application/automation/tools/model/EnumDescription.java create mode 100644 src/main/java/com/hp/application/automation/tools/model/ResultsPublisherModel.java create mode 100644 src/main/java/com/hp/application/automation/tools/model/RunFromAlmModel.java create mode 100644 src/main/java/com/hp/application/automation/tools/model/RunFromFileSystemModel.java create mode 100644 src/main/java/com/hp/application/automation/tools/model/RunMode.java create mode 100644 src/main/java/com/hp/application/automation/tools/results/RunResultRecorder.java create mode 100644 src/main/java/com/hp/application/automation/tools/run/AlmRunTypes.java create mode 100644 src/main/java/com/hp/application/automation/tools/run/RunFromAlmBuilder.java create mode 100644 src/main/java/com/hp/application/automation/tools/run/RunFromFileBuilder.java create mode 100644 src/main/java/com/hp/application/automation/tools/settings/AlmServerSettingsBuilder.java create mode 100644 src/main/resources/HpToolsLauncher.exe create mode 100644 src/main/resources/com/hp/application/automation/tools/results/RunResultRecorder/config.jelly create mode 100644 src/main/resources/com/hp/application/automation/tools/results/RunResultRecorder/help-archiveTestResultsMode.html create mode 100644 src/main/resources/com/hp/application/automation/tools/run/RunFromAlmBuilder/config.jelly create mode 100644 src/main/resources/com/hp/application/automation/tools/run/RunFromAlmBuilder/config.properties create mode 100644 src/main/resources/com/hp/application/automation/tools/run/RunFromAlmBuilder/help-AlmRunHost.html create mode 100644 src/main/resources/com/hp/application/automation/tools/run/RunFromAlmBuilder/help-AlmRunMode.html create mode 100644 src/main/resources/com/hp/application/automation/tools/run/RunFromAlmBuilder/help-AlmTestSets.html create mode 100644 src/main/resources/com/hp/application/automation/tools/run/RunFromAlmBuilder/help-AlmTimeout.html create mode 100644 src/main/resources/com/hp/application/automation/tools/run/RunFromFileBuilder/config.jelly create mode 100644 src/main/resources/com/hp/application/automation/tools/run/RunFromFileBuilder/config.properties create mode 100644 src/main/resources/com/hp/application/automation/tools/run/RunFromFileBuilder/help-FsTests.html create mode 100644 src/main/resources/com/hp/application/automation/tools/run/RunFromFileBuilder/help-FsTimeout.html create mode 100644 src/main/resources/com/hp/application/automation/tools/settings/AlmServerSettingsBuilder/global.jelly create mode 100644 src/main/resources/com/hp/application/automation/tools/settings/AlmServerSettingsBuilder/help-almServerName.html create mode 100644 src/main/resources/com/hp/application/automation/tools/settings/AlmServerSettingsBuilder/help-almServerUrl.html create mode 100644 src/main/resources/com/hp/application/automation/tools/settings/AlmServerSettingsBuilder/help-almServerVersion.html create mode 100644 src/main/resources/index.jelly diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000000..f479bdf93c --- /dev/null +++ b/.gitignore @@ -0,0 +1,88 @@ +#OS junk files +[Tt]humbs.db +*.DS_Store + +#Visual Studio files +*.[Oo]bj +*.user +*.aps +*.pch +*.vspscc +*.vssscc +*_i.c +*_p.c +*.ncb +*.suo +*.tlb +*.tlh +*.bak +*.[Cc]ache +*.ilk +*.log +*.lib +*.sbr +*.sdf +*.opensdf +*.unsuccessfulbuild +ipch/ +obj/ +[Bb]in +[Dd]ebug*/ +[Rr]elease*/ +Ankh.NoLoad + +#MonoDevelop +*.pidb +*.userprefs + +#Tooling +_ReSharper*/ +*.resharper +[Tt]est[Rr]esult* +*.sass-cache + +#Project files +[Bb]uild/ + +#Subversion files +.svn + +# Office Temp Files +~$* + +#NuGet +packages/ + +#ncrunch +*ncrunch* + +#Eclipse files +*.pydevproject +.project +.metadata +bin/** +tmp/** +tmp/**/* +*.tmp +*.bak +*.swp +*~.nib +local.properties +.classpath +.settings/ +.loadpath + +# External tool builders +.externalToolBuilders/ + +# Locally stored "Eclipse launch configurations" +*.launch + +# CDT-specific +.cproject + +# PDT-specific +.buildpath + +/target/** +/work/** diff --git a/HpToolsLauncher/ConsoleWriter.cs b/HpToolsLauncher/ConsoleWriter.cs new file mode 100644 index 0000000000..094c08e127 --- /dev/null +++ b/HpToolsLauncher/ConsoleWriter.cs @@ -0,0 +1,80 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.IO; +using System.Text.RegularExpressions; +namespace HpToolsLauncher +{ + public static class ConsoleWriter + { + static TestRunResults activeTestRun = null; + + public static TestRunResults ActiveTestRun + { + get { return activeTestRun; } + set { activeTestRun = value; } + } + + public static void WriteException(string message, Exception ex) + { + Console.Out.WriteLine(message); + Console.Out.WriteLine(ex.Message); + Console.Out.WriteLine(ex.StackTrace); + if (activeTestRun != null) + activeTestRun.ConsoleErr += message + "\n" + ex.Message + "\n" + ex.StackTrace + "\n"; + } + + + public static void WriteErrLine(string message) + { + string errMessage = "Error: " + message; + WriteLine(errMessage); + + if (activeTestRun != null) + { + activeTestRun.ConsoleErr += errMessage + "\n"; + } + } + private static Regex _badXmlCharsReg = new Regex(@"[\u0000-\u0008]|[\u000B-\u000C]|[\u000E-\u001F]|[\uD800-\uDFFF]", RegexOptions.Singleline | RegexOptions.IgnoreCase | RegexOptions.Compiled); + + /// + /// filters out any bad characters that may affect xml generation/parsing + /// + /// + /// + public static string FilterXmlProblematicChars(string subjectString) + { + //allowed chars: #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF] + return _badXmlCharsReg.Replace(subjectString, "?"); + } + + public static void WriteLine(string[] messages) + { + foreach (string message in messages) + { + + WriteLine(message); + if (activeTestRun != null) + { + activeTestRun.ConsoleOut += message + "\n"; + } + } + } + + public static void WriteLine(string message) + { + message = FilterXmlProblematicChars(message); + //File.AppendAllText("c:\\stam11.stam", message); + Console.Out.WriteLine(message); + if (activeTestRun != null) + activeTestRun.ConsoleOut += message + "\n"; + } + + } +} diff --git a/HpToolsLauncher/ExportOptions.cs b/HpToolsLauncher/ExportOptions.cs new file mode 100644 index 0000000000..ace8c7f1b2 --- /dev/null +++ b/HpToolsLauncher/ExportOptions.cs @@ -0,0 +1,31 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +namespace HpToolsLauncher +{ + enum ExportTypeSuffixEnum + { + ExportTypeSuffix_SD, //step details + ExportTypeSuffix_DT, //data table + ExportTypeSuffix_SM, //system monitor + ExportTypeSuffix_SR, //screen recorder + ExportTypeSuffix_LT //log tracking + } + + public class ExportOptions + { + public const string ExportDataTable = "ExportDataTable"; + public const string ExportForFailed = "ExportForFailed"; + public const string ExportLogTracking = "ExportLogTracking"; + public const string ExportScreenRecorder = "ExportScreenRecorder"; + public const string ExportStepDetails = "ExportStepDetails"; + public const string ExportSystemMonitor = "ExportSystemMonitor"; + public const string ExportLocation = "ExportLocation"; + public const string XslPath = "XSLPath"; + public const string ExportFormat = "ExportFormat"; + public const string ExportType = "ExportType"; + + } +} \ No newline at end of file diff --git a/HpToolsLauncher/Helper.cs b/HpToolsLauncher/Helper.cs new file mode 100644 index 0000000000..9480ac36db --- /dev/null +++ b/HpToolsLauncher/Helper.cs @@ -0,0 +1,651 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Text; +using System.Web.UI; +using System.Xml; +using System.Xml.XPath; +using System.Xml.Xsl; +using Microsoft.Win32; +using System.Xml.Linq; +using System.Collections.Specialized; +using HpToolsLauncher.Properties; +using System.Runtime.InteropServices; + +namespace HpToolsLauncher +{ + public enum TestType + { + QTP, + ST, + } + + public enum TestState + { + Waiting, + Running, + NoRun, + Passed, + Failed, + Error, + Warning, + Unknown, + } + + public enum TestResult + { + Passed, + Failed, + Done, + } + + public static class Helper + { + #region Constants + public const string FT_REG_ROOT = @"SOFTWARE\Mercury Interactive\QuickTest Professional\CurrentVersion"; + internal const string FT_REG_ROOT_64_BIT = @"SOFTWARE\Wow6432Node\Mercury Interactive\QuickTest Professional\CurrentVersion"; + public const string FT_ROOT_PATH_KEY = "QuickTest Professional"; + private const string QTP_ROOT_ENV_VAR_NAME = "QTP_TESTS_ROOT"; + + + public const string ServiceTestRegistryKey = @"SOFTWARE\Hewlett-Packard\HP Service Test"; + public const string ServiceTesCurrentVersionRegistryKey = ServiceTestRegistryKey + @"\CurrentVersion"; + + public const string ServiceTesWOW64RegistryKey = @"SOFTWARE\Wow6432Node\Hewlett-Packard\HP Service Test"; + public const string ServiceTesCurrentVersionWOW64RegistryKey = ServiceTesWOW64RegistryKey + @"\CurrentVersion"; + + public const string LoadRunnerRegistryKey = @"SOFTWARE\Mercury Interactive\LoadRunner"; + public const string LoadRunner64RegisryKey = @"SOFTWARE\Wo6432Node\Mercury Interactive\LoadRunner"; + + public const string LoadRunnerControllerRegistryKey = @"\CustComponent\Controller\CurrentVersion"; + + public const string LoadRunnerControllerDirRegistryKey = @"\CurrentVersion"; + + public const string LoadRunnerControllerDirRegistryValue = @"\Controller"; + + + public const string InstalltionFolderValue = "LOCAL_MLROOT"; + + public const string UftViewerInstalltionFolderRegistryKey = + @"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\{E86D56AE-6660-4357-890F-8B79AB7A8F7B}"; + public const string UftViewerInstalltionFolderRegistryKey64Bit = + @"SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\{E86D56AE-6660-4357-890F-8B79AB7A8F7B}"; + + + public const string ResultsFileName = "Results.xml"; + public const string QTPReportProcessPath = @"bin\reportviewer.exe"; + + #endregion + public static string GetRootDirectoryPath() + { + String directoryPath; + RegistryKey regkey = Registry.LocalMachine.OpenSubKey(FT_REG_ROOT); + + if (regkey != null) + directoryPath = (string)regkey.GetValue(FT_ROOT_PATH_KEY); + else + {//TRY 64 bit REG path + regkey = Registry.LocalMachine.OpenSubKey(FT_REG_ROOT_64_BIT); + if (regkey != null) + directoryPath = (string)regkey.GetValue(FT_ROOT_PATH_KEY); + else + directoryPath = GetRootFromEnvironment(); + } + + return directoryPath; + } + public static bool IsTestingToolsInstalled(TestStorageType type) + { + //we want to check if we have Service Test, QTP installed on a machine + RegistryKey regkey; + string value = null; + switch (type) + { + + case TestStorageType.FileSystem: + //search for QTP + if (IsQtpInstalled()) return true; + + //search for Service Test + if (IsServiceTestInstalled()) return true; + break; + case TestStorageType.LoadRunner: + + //search for LoadRunner + regkey = Registry.LocalMachine.OpenSubKey(LoadRunnerRegistryKey); + if (regkey == null) + { + //try 64 bit + regkey = Registry.LocalMachine.OpenSubKey(LoadRunner64RegisryKey); + } + + if (regkey != null) + { + //LoadRunner Exist. + //check if Controller is installed (not SA version) + value = (string)regkey.GetValue(LoadRunnerControllerRegistryKey); + if (!string.IsNullOrEmpty(value)) + { + return true; + } + } + break; + + default: + return false; + + } + return false; + + } + + public static bool IsQtpInstalled() + { + RegistryKey regkey; + string value; + regkey = Registry.LocalMachine.OpenSubKey(FT_REG_ROOT); + if (regkey == null) + { + //try 64 bit + regkey = Registry.LocalMachine.OpenSubKey(FT_REG_ROOT_64_BIT); + } + + if (regkey != null) + { + value = (string)regkey.GetValue(FT_ROOT_PATH_KEY); + if (!string.IsNullOrEmpty(value)) + { + return true; + } + } + return false; + } + + public static bool IsServiceTestInstalled() + { + RegistryKey regkey; + string value; + regkey = Registry.LocalMachine.OpenSubKey(ServiceTesCurrentVersionRegistryKey); + if (regkey == null) + { + //try 64 bit + regkey = Registry.LocalMachine.OpenSubKey(ServiceTesCurrentVersionWOW64RegistryKey); + } + + if (regkey != null) + { + value = (string)regkey.GetValue(InstalltionFolderValue); + if (!string.IsNullOrEmpty(value)) + { + return true; + } + } + return false; + } + + private static string GetRootFromEnvironment() + { + string qtpRoot = Environment.GetEnvironmentVariable(QTP_ROOT_ENV_VAR_NAME, EnvironmentVariableTarget.Process); + + if (string.IsNullOrEmpty(qtpRoot)) + { + qtpRoot = Environment.GetEnvironmentVariable(QTP_ROOT_ENV_VAR_NAME, EnvironmentVariableTarget.User); + + if (string.IsNullOrEmpty(qtpRoot)) + { + qtpRoot = Environment.GetEnvironmentVariable(QTP_ROOT_ENV_VAR_NAME, EnvironmentVariableTarget.Machine); + + if (string.IsNullOrEmpty(qtpRoot)) + { + qtpRoot = Environment.CurrentDirectory; + } + } + } + + return qtpRoot; + } + + public static string GetInstallPath() + { + string ret = String.Empty; + var regKey = Registry.LocalMachine.OpenSubKey(ServiceTesCurrentVersionRegistryKey); + if (regKey != null) + { + var val = regKey.GetValue(InstalltionFolderValue); + if (null != val) + { + ret = val.ToString(); + } + } + else + { + regKey = Registry.LocalMachine.OpenSubKey(ServiceTesCurrentVersionWOW64RegistryKey); + if (regKey != null) + { + var val = regKey.GetValue(InstalltionFolderValue); + if (null != val) + { + ret = val.ToString(); + } + } + else + { + ret = GetRootDirectoryPath() ?? string.Empty; + } + } + + if (!String.IsNullOrEmpty(ret)) + { + ret = ret.EndsWith("\\") ? ret : (ret + "\\"); + if (ret.EndsWith("\\bin\\")) + { + int endIndex = ret.LastIndexOf("\\bin\\"); + if (endIndex != -1) + { + ret = ret.Substring(0, endIndex) + "\\"; + } + } + } + + return ret; + } + + public static List GetTestsLocations(string baseDir) + { + var testsLocations = new List(); + if (string.IsNullOrEmpty(baseDir) || !Directory.Exists(baseDir)) + { + return testsLocations; + } + + WalkDirectoryTree(new DirectoryInfo(baseDir), ref testsLocations); + return testsLocations; + } + + public static TestType GetTestType(string path) + { + var stFiles = Directory.GetFiles(path, + @"*.st?", + SearchOption.TopDirectoryOnly); + + return (stFiles.Count() > 0) ? TestType.ST : TestType.QTP; + } + + public static bool IsDirectory(string path) + { + var fa = File.GetAttributes(path); + var isDirectory = false; + if ((fa & FileAttributes.Directory) != 0) + { + isDirectory = true; + } + return isDirectory; + } + + static void WalkDirectoryTree(System.IO.DirectoryInfo root, ref List results) + { + System.IO.FileInfo[] files = null; + System.IO.DirectoryInfo[] subDirs = null; + + // First, process all the files directly under this folder + try + { + files = root.GetFiles("*.st"); + files = files.Union(root.GetFiles("*.tsp")).ToArray(); + } + catch (Exception e) + { + // This code just writes out the message and continues to recurse. + // You may decide to do something different here. For example, you + // can try to elevate your privileges and access the file again. + //log.Add(e.Message); + } + + if (files != null) + { + foreach (System.IO.FileInfo fi in files) + { + results.Add(fi.Directory.FullName); + // In this example, we only access the existing FileInfo object. If we + // want to open, delete or modify the file, then + // a try-catch block is required here to handle the case + // where the file has been deleted since the call to TraverseTree(). + } + + // Now find all the subdirectories under this directory. + subDirs = root.GetDirectories(); + + foreach (System.IO.DirectoryInfo dirInfo in subDirs) + { + // Resursive call for each subdirectory. + WalkDirectoryTree(dirInfo, ref results); + } + } + } + + public static string GetTempDir() + { + string baseTemp = Path.GetTempPath(); + + string dirName = Guid.NewGuid().ToString().Replace("-", string.Empty).Substring(0, 6); + string tempDirPath = Path.Combine(baseTemp, dirName); + + return tempDirPath; + } + + public static string CreateTempDir() + { + string tempDirPath = GetTempDir(); + + Directory.CreateDirectory(tempDirPath); + + return tempDirPath; + } + + public static bool IsNetworkPath(String path) + { + if (path.StartsWith(@"\\")) + return true; + var dir = new DirectoryInfo(path); + var drive = new DriveInfo(dir.Root.ToString()); + return drive.DriveType == DriveType.Network; + } + + + #region Report Related + + public static string GetUftViewerInstallPath() + { + string ret = String.Empty; + var regKey = Registry.LocalMachine.OpenSubKey(UftViewerInstalltionFolderRegistryKey) ?? + Registry.LocalMachine.OpenSubKey(UftViewerInstalltionFolderRegistryKey64Bit); + + if (regKey != null) + { + var val = regKey.GetValue("InstallLocation"); + if (null != val) + { + ret = val.ToString(); + } + } + + if (!String.IsNullOrEmpty(ret)) + { + ret = ret.EndsWith("\\") ? ret : (ret + "\\"); + } + + return ret; + } + + public static string GetLastRunFromReport(string reportPath) + { + if (!Directory.Exists(reportPath)) + return null; + string resultsFileFullPath = reportPath + @"\" + ResultsFileName; + if (!File.Exists(resultsFileFullPath)) + return null; + try + { + var root = XElement.Load(resultsFileFullPath); + + var element = root.XPathSelectElement("//Doc/Summary"); + var lastStartRun = element.Attribute("sTime"); + return lastStartRun.Value.Split(new char[] { ' ' })[0]; + + } + catch (Exception) + { + return null; + } + } + + public static TestState GetTestStateFromReport(TestRunResults runDesc) + { + try + { + if (!Directory.Exists(runDesc.ReportLocation)) + { + runDesc.ErrorDesc = string.Format(Resources.DirectoryNotExistError, runDesc.ReportLocation); + + runDesc.TestState = TestState.Error; + return runDesc.TestState; + } + + string[] resultFiles = Directory.GetFiles(runDesc.ReportLocation, "Results.xml", SearchOption.AllDirectories); + TestState finalState = TestState.Unknown; + + if (resultFiles == null || resultFiles.Length == 0) + { + runDesc.ErrorDesc = string.Format("no results file found for " + runDesc.TestName); + runDesc.TestState = TestState.Error; + return runDesc.TestState; + } + + foreach (string resultsFileFullPath in resultFiles) + { + finalState = TestState.Unknown; + string desc = ""; + TestState state = GetStateFromResultsFile(resultsFileFullPath, out desc); + if (finalState == TestState.Unknown || finalState == TestState.Passed) + { + finalState = state; + if (!string.IsNullOrWhiteSpace(desc)) + { + if (finalState == TestState.Error) + { + runDesc.ErrorDesc = desc; + } + if (finalState == TestState.Failed) + { + runDesc.FailureDesc = desc; + } + } + } + } + + if (finalState == TestState.Unknown) + finalState = TestState.Passed; + + if (finalState == TestState.Failed && string.IsNullOrWhiteSpace(runDesc.FailureDesc)) + runDesc.FailureDesc = "Test failed"; + + runDesc.TestState = finalState; + + return runDesc.TestState; + } + catch (Exception e) + { + return TestState.Unknown; + } + + } + + private static TestState GetStateFromResultsFile(string resultsFileFullPath, out string desc) + { + TestState finalState = TestState.Unknown; + desc = ""; + + var doc = new XmlDocument { PreserveWhitespace = true }; + doc.Load(resultsFileFullPath); + var testStatusPathNode = doc.SelectSingleNode("//Report/Doc/NodeArgs"); + if (testStatusPathNode == null) + { + desc = string.Format(Resources.XmlNodeNotExistError, "//Report/Doc/NodeArgs"); + finalState = TestState.Error; + } + + if (!testStatusPathNode.Attributes["status"].Specified) + finalState = TestState.Unknown; + + var status = testStatusPathNode.Attributes["status"].Value; + + var result = (TestResult)Enum.Parse(typeof(TestResult), status); + if (result == TestResult.Passed || result == TestResult.Done) + { + finalState = TestState.Passed; + //return runDesc.TestState; + } + else + finalState = TestState.Failed; + + return finalState; + } + + public static string GetUnknownStateReason(string reportPath) + { + if (!Directory.Exists(reportPath)) + { + return string.Format("Directory '{0}' doesn't exist", reportPath); + } + string resultsFileFullPath = reportPath + @"\" + ResultsFileName; + if (!File.Exists(resultsFileFullPath)) + { + return string.Format("Could not find results file '{0}'", resultsFileFullPath); + } + + var doc = new XmlDocument { PreserveWhitespace = true }; + doc.Load(resultsFileFullPath); + var testStatusPathNode = doc.SelectSingleNode("//Report/Doc/NodeArgs"); + if (testStatusPathNode == null) + { + return string.Format("XML node '{0}' could not be found", "//Report/Doc/NodeArgs"); + } + return string.Empty; + } + + public static void OpenReport(string reportDirectory, ref string optionalReportViewerPath) + { + Process p = null; + try + { + string viewerPath = optionalReportViewerPath; + string reportPath = reportDirectory; + string resultsFilePath = reportPath + "\\" + ResultsFileName; + + if (!File.Exists(resultsFilePath)) + { + return; + } + + var si = new ProcessStartInfo(); + if (string.IsNullOrEmpty(viewerPath)) + { + viewerPath = GetUftViewerInstallPath(); + optionalReportViewerPath = viewerPath; + } + si.Arguments = " -r \"" + reportPath + "\""; + + si.FileName = Path.Combine(viewerPath, QTPReportProcessPath); + si.WorkingDirectory = Path.Combine(viewerPath, @"bin" + @"\"); + + p = Process.Start(si); + if (p != null) + { + } + return; + } + catch (Exception ex) + { + } + finally + { + if (p != null) + { + p.Close(); + } + } + return; + } + + #endregion + + #region Export Related + + /// + /// Copy directories from source to target + /// + /// full path source directory + /// full path target directory + /// if true, all subdirectories and contents will be copied + /// if true, the source directory will be created too + public static void CopyDirectories(string sourceDir, string targetDir, + bool includeSubDirectories = false, bool includeRoot = false) + { + var source = new DirectoryInfo(sourceDir); + var target = new DirectoryInfo(targetDir); + DirectoryInfo workingTarget = target; + + if (includeRoot) + workingTarget = Directory.CreateDirectory(target.FullName); + + CopyContents(source, workingTarget, includeSubDirectories); + } + + private static void CopyContents(DirectoryInfo source, DirectoryInfo target, bool includeSubDirectories) + { + if (!Directory.Exists(target.FullName)) + { + Directory.CreateDirectory(target.FullName); + } + + + foreach (FileInfo fi in source.GetFiles()) + { + string targetFile = Path.Combine(target.ToString(), fi.Name); + + fi.CopyTo(targetFile, true); + } + + if (includeSubDirectories) + { + DirectoryInfo[] subDirectories = source.GetDirectories(); + foreach (DirectoryInfo diSourceSubDir in subDirectories) + { + DirectoryInfo nextTargetSubDir = + target.CreateSubdirectory(diSourceSubDir.Name); + CopyContents(diSourceSubDir, nextTargetSubDir, true); + } + } + } + + public static void CopyFilesFromFolder(string sourceFolder, IEnumerable fileNames, string targetFolder) + { + foreach (var fileName in fileNames) + { + var sourceFullPath = Path.Combine(sourceFolder, fileName); + var targetFullPath = Path.Combine(targetFolder, fileName); + File.Copy(sourceFullPath, targetFullPath, true); + } + } + + /// + /// Create html file according to a matching xml + /// + /// the values xml + /// the xml transformation file + /// the full file name - where to save the product + public static void CreateHtmlFromXslt(string xmlPath, string xslPath, string targetFile) + { + var xslTransform = new XslCompiledTransform(); + //xslTransform.Load(xslPath); + xslTransform.Load(xslPath, new XsltSettings(false, true), null); + + var sb = new StringBuilder(); + var sw = new StringWriter(sb); + var xmlWriter = new XhtmlTextWriter(sw); + xslTransform.Transform(xmlPath, null, xmlWriter); + + + File.WriteAllText(targetFile, sb.ToString()); + } + + #endregion + } +} diff --git a/HpToolsLauncher/HpToolsLauncher.csproj b/HpToolsLauncher/HpToolsLauncher.csproj new file mode 100644 index 0000000000..274dcc5238 --- /dev/null +++ b/HpToolsLauncher/HpToolsLauncher.csproj @@ -0,0 +1,142 @@ + + + + Debug + x86 + 8.0.30703 + 2.0 + {11BC441C-87A6-41B9-82AE-1F2F606AF45E} + Exe + Properties + HpToolsLauncher + HpToolsLauncher + v4.0 + + + 512 + + + x86 + true + full + false + bin\debug\ + DEBUG;TRACE + prompt + 4 + + + x86 + pdbonly + true + bin\release\ + TRACE + prompt + 4 + + + true + + + + externals\interop.OTAClient.dll + True + + + externals\QTObjectModelLib.dll + True + + + + + False + + + + + False + + + + + + + + + + + + + + + + + + + junit.xsd + code + + + + + + + + + True + True + Resources.resx + + + + + + + + + + + + + + + + + + Designer + + + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + + + {F645BD06-E1B4-4E6A-82FB-E97D027FD456} + 1 + 0 + 0 + tlbimp + False + True + + + + + copy $(TargetFileName) ..\..\..\src\main\resources\$(TargetFileName) + + + + + + + \ No newline at end of file diff --git a/HpToolsLauncher/HpToolsLauncher.sln b/HpToolsLauncher/HpToolsLauncher.sln new file mode 100644 index 0000000000..78dd0251de --- /dev/null +++ b/HpToolsLauncher/HpToolsLauncher.sln @@ -0,0 +1,32 @@ + +Microsoft Visual Studio Solution File, Format Version 11.00 +# Visual Studio 2010 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HpToolsLauncher", "HpToolsLauncher.csproj", "{11BC441C-87A6-41B9-82AE-1F2F606AF45E}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{9E444876-1EC1-4EC2-B91F-187FF7FBC0D1}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Debug|Mixed Platforms = Debug|Mixed Platforms + Debug|x86 = Debug|x86 + Release|Any CPU = Release|Any CPU + Release|Mixed Platforms = Release|Mixed Platforms + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {11BC441C-87A6-41B9-82AE-1F2F606AF45E}.Debug|Any CPU.ActiveCfg = Debug|x86 + {11BC441C-87A6-41B9-82AE-1F2F606AF45E}.Debug|Mixed Platforms.ActiveCfg = Debug|x86 + {11BC441C-87A6-41B9-82AE-1F2F606AF45E}.Debug|Mixed Platforms.Build.0 = Debug|x86 + {11BC441C-87A6-41B9-82AE-1F2F606AF45E}.Debug|x86.ActiveCfg = Debug|x86 + {11BC441C-87A6-41B9-82AE-1F2F606AF45E}.Debug|x86.Build.0 = Debug|x86 + {11BC441C-87A6-41B9-82AE-1F2F606AF45E}.Release|Any CPU.ActiveCfg = Release|x86 + {11BC441C-87A6-41B9-82AE-1F2F606AF45E}.Release|Mixed Platforms.ActiveCfg = Release|x86 + {11BC441C-87A6-41B9-82AE-1F2F606AF45E}.Release|Mixed Platforms.Build.0 = Release|x86 + {11BC441C-87A6-41B9-82AE-1F2F606AF45E}.Release|x86.ActiveCfg = Release|x86 + {11BC441C-87A6-41B9-82AE-1F2F606AF45E}.Release|x86.Build.0 = Release|x86 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/HpToolsLauncher/IniManager.cs b/HpToolsLauncher/IniManager.cs new file mode 100644 index 0000000000..9fb7ffa294 --- /dev/null +++ b/HpToolsLauncher/IniManager.cs @@ -0,0 +1,148 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +using System.Runtime.InteropServices; +using System.Text; +using System.Collections.Generic; + +namespace HpToolsLauncher +{ + /// + /// The .mtb file format originally used in QTP batch tool + /// has the .INI format. For backward compatibility, we maintain the exact format. + /// This class calls some methods from Kernel32 to read and write .INI file + /// + public class IniManager + { + private string _IniPath; + + [DllImport("kernel32")] + private static extern long WritePrivateProfileString(string section, + string key, string val, string filePath); + + [DllImport("kernel32")] + private static extern int GetPrivateProfileString(string section, + string key, string def, StringBuilder retVal, + int size, string filePath); + + [DllImport("kernel32")] + static extern int GetPrivateProfileString(string Section, int Key, + string Value, [MarshalAs(UnmanagedType.LPArray)] byte[] Result, + int Size, string FileName); + + [DllImport("kernel32")] + static extern int GetPrivateProfileString(int Section, string Key, + string Value, [MarshalAs(UnmanagedType.LPArray)] byte[] Result, + int Size, string FileName); + + public IniManager(string iniIniPath) + { + _IniPath = iniIniPath; + } + + public void WriteValue(string section, string key, string value) + { + WritePrivateProfileString(section, key, value, _IniPath); + } + + public string ReadValue(string section, string key) + { + var buffer = new StringBuilder(255); + GetPrivateProfileString(section, key, "", buffer, 255, _IniPath); + return buffer.ToString(); + } + + /// + /// The Function called to obtain the SectionHeaders, and returns them in an Dynamic Array. + /// + /// + public HashSet GetSectionNames() + { + // Sets the maxsize buffer to 500, if the more + // is required then doubles the size each time. + for (int maxsize = 500; true; maxsize *= 2) + { + // Obtains the information in bytes and stores + // them in the maxsize buffer (Bytes array) + byte[] bytes = new byte[maxsize]; + int size = GetPrivateProfileString(0, "", "", bytes, maxsize, _IniPath); + + // Check the information obtained is not bigger + // than the allocated maxsize buffer - 2 bytes. + // if it is, then skip over the next section + // so that the maxsize buffer can be doubled. + if (size < maxsize - 2) + { + // Converts the bytes value into an UTF8 char. This is one long string. + string Selected = Encoding.UTF8.GetString(bytes, 0, + size - (size > 0 ? 1 : 0)); + // Splits the Long string into an array based on the "\0" + // or null (Newline) value and returns the value(s) in an array + string[] sections = Selected.Split(new char[] { '\0' }); + HashSet sects = new HashSet(sections); + return sects; + } + } + } + + /// + /// The Function called to obtain the EntryKey's from the given SectionHeader string passed and returns them in an Dynamic Array + /// + /// + /// + public HashSet GetEntryNames(string section) + { + // Sets the maxsize buffer to 500, if the more + // is required then doubles the size each time. + for (int maxsize = 500; true; maxsize *= 2) + { + // Obtains the EntryKey information in bytes + // and stores them in the maxsize buffer (Bytes array). + // Note that the SectionHeader value has been passed. + byte[] bytes = new byte[maxsize]; + int size = GetPrivateProfileString(section, 0, "", bytes, maxsize, _IniPath); + + // Check the information obtained is not bigger + // than the allocated maxsize buffer - 2 bytes. + // if it is, then skip over the next section + // so that the maxsize buffer can be doubled. + if (size < maxsize - 2) + { + // Converts the bytes value into an UTF8 char. + // This is one long string. + string entries = Encoding.Default.GetString(bytes, 0, + size - (size > 0 ? 1 : 0)); + // Splits the Long string into an array based on the "\0" + // or null (Newline) value and returns the value(s) in an array + string[] ents1 = entries.Split(new char[] { '\0' }); + HashSet hashEnts = new HashSet(ents1); + return hashEnts; + } + } + } + + public Dictionary GetSectionAsDictionary(string section) + { + Dictionary retval = new Dictionary(); + HashSet entries = GetEntryNames(section); + foreach (string ent in entries) + { + retval.Add(ent, ReadValue(section, ent)); + } + return retval; + } + + public static Dictionary> LoadIniFileAsDictionary(string strFileName) + { + Dictionary> retVal = new Dictionary>(); + IniManager man = new IniManager(strFileName); + foreach (string sect in man.GetSectionNames()) + { + retVal.Add(sect, man.GetSectionAsDictionary(sect)); + } + return retVal; + } + } +} diff --git a/HpToolsLauncher/Interfaces/IAssetRunner.cs b/HpToolsLauncher/Interfaces/IAssetRunner.cs new file mode 100644 index 0000000000..d817698883 --- /dev/null +++ b/HpToolsLauncher/Interfaces/IAssetRunner.cs @@ -0,0 +1,14 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +using System; +namespace HpToolsLauncher +{ + public interface IAssetRunner : IDisposable + { + TestSuiteRunResults Run(); + bool RunWasCancelled {get;set;} + } +} \ No newline at end of file diff --git a/HpToolsLauncher/Interfaces/IFileSysTestRunner.cs b/HpToolsLauncher/Interfaces/IFileSysTestRunner.cs new file mode 100644 index 0000000000..db67ccbf81 --- /dev/null +++ b/HpToolsLauncher/Interfaces/IFileSysTestRunner.cs @@ -0,0 +1,16 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +using System; +namespace HpToolsLauncher +{ + public delegate bool RunCancelledDelegate(); + public interface IFileSysTestRunner + { + + TestRunResults RunTest(string fileName, ref string errorReason, RunCancelledDelegate runCancelled); + void CleanUp(); + } +} \ No newline at end of file diff --git a/HpToolsLauncher/Interfaces/IMtbManager.cs b/HpToolsLauncher/Interfaces/IMtbManager.cs new file mode 100644 index 0000000000..50b1ba5236 --- /dev/null +++ b/HpToolsLauncher/Interfaces/IMtbManager.cs @@ -0,0 +1,37 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; + +namespace HpToolsLauncher +{ + public interface IMtbManager + { + + string MtbName { get;} + + string MtbFileName { get;} + + bool IsDirty { get; set; } + + string DefaultFileExtension { get; } + + void New(); + + List Open(); + + List Parse(string fileName); + + /// + /// Save the contents to a file in the file system + /// + /// + /// + void Save(IEnumerable paths); + + void InitializeContext(string mtbName="Untitled", string mtbFileName=null); + + } +} \ No newline at end of file diff --git a/HpToolsLauncher/Interfaces/IXmlBuilder.cs b/HpToolsLauncher/Interfaces/IXmlBuilder.cs new file mode 100644 index 0000000000..37c0335d5b --- /dev/null +++ b/HpToolsLauncher/Interfaces/IXmlBuilder.cs @@ -0,0 +1,18 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace HpToolsLauncher +{ + public interface IXmlBuilder + { + string XmlName { get; set; } + void CreateXmlFromRunResults(TestSuiteRunResults results); + } +} diff --git a/HpToolsLauncher/JavaProperties/JavaIniFile.cs b/HpToolsLauncher/JavaProperties/JavaIniFile.cs new file mode 100644 index 0000000000..47a1b87e69 --- /dev/null +++ b/HpToolsLauncher/JavaProperties/JavaIniFile.cs @@ -0,0 +1,85 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.IO; +using System.Text.RegularExpressions; + +namespace HpToolsLauncher +{ + public class JavaIniFile : Dictionary + { + Regex reg = new Regex(@"\[(?
.*?)\]", RegexOptions.Compiled); + public void Load(string filename) + { + this.Clear(); + //Dictionary + StringBuilder sb = new StringBuilder(); + //Dictionary retVal = new Dictionary(); + + string[] fileLines = File.ReadAllLines(filename, Encoding.Default); + int i = 0; + string currentSectionName = null; + foreach (string line in fileLines) + { + Match match = reg.Match(line); + if (match.Success) + { + //get the new section name + string sectName = match.Groups["section"].Value; + if (currentSectionName != null) + { + //load the previous section to a properties object + JavaProperties props = new JavaProperties(); + MemoryStream s = new MemoryStream(Encoding.Default.GetBytes(sb.ToString())); + props.Load(s); + + //add to the dictionary + this.Add(currentSectionName, props); + } + //the current section becomes the new section + currentSectionName = sectName; + //clear the old section from the builder + sb.Clear(); + } + else + { + sb.AppendLine(line); + } + ++i; + } + + if (currentSectionName != null) + { + //load the last section to a properties object + JavaProperties props1 = new JavaProperties(); + MemoryStream s1 = new MemoryStream(Encoding.Default.GetBytes(sb.ToString())); + props1.Load(s1); + + //add to the dictionary + this.Add(currentSectionName, props1); + } + } + + public void Save(string fileName) + { + StringBuilder sb = new StringBuilder(); + foreach (string sect in this.Keys) + { + sb.AppendLine("[" + sect + "]"); + JavaProperties props = this[sect]; + using (MemoryStream s = new MemoryStream()) + { + props.Save(s, null); + sb.AppendLine(s.ToString()); + } + } + File.WriteAllText(fileName,sb.ToString()); + } + } +} diff --git a/HpToolsLauncher/JavaProperties/JavaProperties.cs b/HpToolsLauncher/JavaProperties/JavaProperties.cs new file mode 100644 index 0000000000..c7de5e21c3 --- /dev/null +++ b/HpToolsLauncher/JavaProperties/JavaProperties.cs @@ -0,0 +1,603 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.IO; +using System.Collections; + +namespace HpToolsLauncher +{ + + /// + /// This class is a direct port to C# of the java properties class + /// + public class JavaProperties : Dictionary + { + + protected JavaProperties defaults; + + /// + /// Creates an empty property list with no default values. + /// + public JavaProperties() + : this(null) + { + + } + + /// + /// Creates an empty property list with the specified defaults. + /// + /// + public JavaProperties(JavaProperties defaults) + { + this.defaults = defaults; + } + + + + /// + /// loads properties + /// + /// + public void Load(TextReader reader) + { + LoadInternal(new LineReader(reader)); + } + + + /// + /// loads properties from a file + /// + /// + public void Load(string fullpath) + { + using (FileStream s = File.OpenRead(fullpath)) + { + LoadInternal(new LineReader(s)); + } + } + + /// + /// loads properties from stream + /// + /// + public void Load(Stream inStream) + { + LoadInternal(new LineReader(inStream)); + } + + private void LoadInternal(LineReader lr) + { + char[] convtBuf = new char[1024]; + int limit; + int keyLen; + int valueStart; + char c; + bool hasSep; + bool precedingBackslash; + + while ((limit = lr.readLine()) >= 0) + { + c = '\0'; + keyLen = 0; + valueStart = limit; + hasSep = false; + + //System.out.println("line=<" + new String(lineBuf, 0, limit) + ">"); + precedingBackslash = false; + while (keyLen < limit) + { + c = lr.lineBuf[keyLen]; + //need check if escaped. + if ((c == '=' || c == ':') && !precedingBackslash) + { + valueStart = keyLen + 1; + hasSep = true; + break; + } + else if ((c == ' ' || c == '\t' || c == '\f') && !precedingBackslash) + { + valueStart = keyLen + 1; + break; + } + if (c == '\\') + { + precedingBackslash = !precedingBackslash; + } + else + { + precedingBackslash = false; + } + keyLen++; + } + while (valueStart < limit) + { + c = lr.lineBuf[valueStart]; + if (c != ' ' && c != '\t' && c != '\f') + { + if (!hasSep && (c == '=' || c == ':')) + { + hasSep = true; + } + else + { + break; + } + } + valueStart++; + } + String key = LoadConvert(lr.lineBuf, 0, keyLen, convtBuf); + String value = LoadConvert(lr.lineBuf, valueStart, limit - valueStart, convtBuf); + this[key] = value; + } + } + + class LineReader + { + public LineReader(Stream inStream) + { + this.inStream = inStream; + inByteBuf = new byte[8192]; + } + + public LineReader(TextReader reader) + { + this.reader = reader; + inCharBuf = new char[8192]; + } + + byte[] inByteBuf; + char[] inCharBuf; + internal char[] lineBuf = new char[1024]; + int inLimit = 0; + int inOff = 0; + Stream inStream; + TextReader reader; + + public int readLine() + { + int len = 0; + char c = '\0'; + + bool skipWhiteSpace = true; + bool isCommentLine = false; + bool isNewLine = true; + bool appendedLineBegin = false; + bool precedingBackslash = false; + bool skipLF = false; + + while (true) + { + if (inOff >= inLimit) + { + inLimit = (inStream == null) ? reader.Read(inCharBuf, 0, inCharBuf.Length) + : inStream.Read(inByteBuf, 0, inByteBuf.Length); + inOff = 0; + if (inLimit <= 0) + { + if (len == 0 || isCommentLine) + { + return -1; + } + return len; + } + } + if (inStream != null) + { + //The line below is equivalent to calling a + //ISO8859-1 decoder. + c = (char)(0xff & inByteBuf[inOff++]); + } + else + { + c = inCharBuf[inOff++]; + } + if (skipLF) + { + skipLF = false; + if (c == '\n') + { + continue; + } + } + if (skipWhiteSpace) + { + if (c == ' ' || c == '\t' || c == '\f') + { + continue; + } + if (!appendedLineBegin && (c == '\r' || c == '\n')) + { + continue; + } + skipWhiteSpace = false; + appendedLineBegin = false; + } + if (isNewLine) + { + isNewLine = false; + if (c == '#' || c == '!') + { + isCommentLine = true; + continue; + } + } + + if (c != '\n' && c != '\r') + { + lineBuf[len++] = c; + if (len == lineBuf.Length) + { + int newLength = lineBuf.Length * 2; + if (newLength < 0) + { + newLength = Int32.MaxValue; + } + char[] buf = new char[newLength]; + Array.Copy(lineBuf, 0, buf, 0, lineBuf.Length); + lineBuf = buf; + } + //flip the preceding backslash flag + if (c == '\\') + { + precedingBackslash = !precedingBackslash; + } + else + { + precedingBackslash = false; + } + } + else + { + // reached EOL + if (isCommentLine || len == 0) + { + isCommentLine = false; + isNewLine = true; + skipWhiteSpace = true; + len = 0; + continue; + } + if (inOff >= inLimit) + { + inLimit = (inStream == null) + ? reader.Read(inCharBuf, 0, inCharBuf.Length) + : inStream.Read(inByteBuf, 0, inByteBuf.Length); + inOff = 0; + if (inLimit <= 0) + { + return len; + } + } + if (precedingBackslash) + { + len -= 1; + //skip the leading whitespace characters in following line + skipWhiteSpace = true; + appendedLineBegin = true; + precedingBackslash = false; + if (c == '\r') + { + skipLF = true; + } + } + else + { + return len; + } + } + } + } + } + + + /// + /// Converts encoded \uxxxx to unicode chars and changes special saved chars to their original forms + /// + /// + /// + /// + /// + /// + private String LoadConvert(char[] in1, int off, int len, char[] convtBuf) + { + if (convtBuf.Length < len) + { + int newLen = len * 2; + if (newLen < 0) + { + newLen = Int32.MaxValue; + } + convtBuf = new char[newLen]; + } + char aChar; + char[] out1 = convtBuf; + int outLen = 0; + int end = off + len; + + while (off < end) + { + aChar = in1[off++]; + if (aChar == '\\') + { + aChar = in1[off++]; + if (aChar == 'u') + { + // Read the xxxx + int value = 0; + for (int i = 0; i < 4; i++) + { + aChar = in1[off++]; + switch (aChar) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + value = (value << 4) + aChar - '0'; + break; + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + case 'f': + value = (value << 4) + 10 + aChar - 'a'; + break; + case 'A': + case 'B': + case 'C': + case 'D': + case 'E': + case 'F': + value = (value << 4) + 10 + aChar - 'A'; + break; + default: + throw new ArgumentException( + "Malformed \\uxxxx encoding."); + } + } + out1[outLen++] = (char)value; + } + else + { + if (aChar == 't') aChar = '\t'; + else if (aChar == 'r') aChar = '\r'; + else if (aChar == 'n') aChar = '\n'; + else if (aChar == 'f') aChar = '\f'; + out1[outLen++] = aChar; + } + } + else + { + out1[outLen++] = aChar; + } + } + return new String(out1, 0, outLen); + } + + + /// + /// Converts unicodes to encoded \uxxxx and escapes special characters with a preceding slash + /// + /// + /// + /// + /// + private String SaveConvert(String theString, + bool escapeSpace, + bool escapeUnicode) + { + int len = theString.Length; + int bufLen = len * 2; + if (bufLen < 0) + { + bufLen = Int32.MaxValue; + } + StringBuilder outBuffer = new StringBuilder(bufLen); + + for (int x = 0; x < len; x++) + { + char aChar = theString[x]; + // Handle common case first, selecting largest block that + // avoids the specials below + if ((aChar > 61) && (aChar < 127)) + { + if (aChar == '\\') + { + outBuffer.Append('\\'); outBuffer.Append('\\'); + continue; + } + outBuffer.Append(aChar); + continue; + } + switch (aChar) + { + case ' ': + if (x == 0 || escapeSpace) + outBuffer.Append('\\'); + outBuffer.Append(' '); + break; + case '\t': outBuffer.Append('\\'); outBuffer.Append('t'); + break; + case '\n': outBuffer.Append('\\'); outBuffer.Append('n'); + break; + case '\r': outBuffer.Append('\\'); outBuffer.Append('r'); + break; + case '\f': outBuffer.Append('\\'); outBuffer.Append('f'); + break; + case '=': // Fall through + case ':': // Fall through + case '#': // Fall through + case '!': + outBuffer.Append('\\'); outBuffer.Append(aChar); + break; + default: + if (((aChar < 0x0020) || (aChar > 0x007e)) & escapeUnicode) + { + outBuffer.Append('\\'); + outBuffer.Append('u'); + outBuffer.Append(ToHex((aChar >> 12) & 0xF)); + outBuffer.Append(ToHex((aChar >> 8) & 0xF)); + outBuffer.Append(ToHex((aChar >> 4) & 0xF)); + outBuffer.Append(ToHex(aChar & 0xF)); + } + else + { + outBuffer.Append(aChar); + } + break; + } + } + return outBuffer.ToString(); + } + + private static void WriteComments(System.IO.TextWriter bw, String comments) + { + bw.Write("#"); + int len = comments.Length; + int current = 0; + int last = 0; + char[] uu = new char[6]; + uu[0] = '\\'; + uu[1] = 'u'; + while (current < len) + { + char c = comments[current]; + if (c > '\u00ff' || c == '\n' || c == '\r') + { + if (last != current) + bw.Write(comments.Substring(last, current)); + if (c > '\u00ff') + { + uu[2] = ToHex((c >> 12) & 0xf); + uu[3] = ToHex((c >> 8) & 0xf); + uu[4] = ToHex((c >> 4) & 0xf); + uu[5] = ToHex(c & 0xf); + bw.Write(new String(uu)); + } + else + { + bw.Write(bw.NewLine); + if (c == '\r' && + current != len - 1 && + comments[current + 1] == '\n') + { + current++; + } + if (current == len - 1 || + (comments[current + 1] != '#' && + comments[current + 1] != '!')) + bw.Write("#"); + } + last = current + 1; + } + current++; + } + if (last != current) + bw.Write(comments.Substring(last, current) + bw.NewLine); + + } + + //@Deprecated + public void Save(Stream out1, String comments) + { + try + { + Store(out1, comments); + } + catch (IOException e) + { + } + } + + public void Save(String fileName, String comments) + { + Store(fileName, comments); + } + + /// + /// saves the properties + /// + /// + /// + public void Store(TextWriter writer, String comments) + { + StoreInternal(writer, comments, false); + } + + /// + /// saves the properties to stream + /// + /// + /// + public void Store(Stream out1, String comments) + { + TextWriter t = new StreamWriter(out1, Encoding.GetEncoding("ISO-8859-1")); + StoreInternal(t, comments, true); + } + + /// + /// saves the properties to file + /// + /// + /// + public void Store(string fullpath, String comments) + { + using (StreamWriter wr = new StreamWriter(fullpath, false, Encoding.GetEncoding("ISO-8859-1"))) + { + StoreInternal(wr, comments, true); + } + } + private void StoreInternal(TextWriter bw, String comments, bool escUnicode) + { + if (comments != null) + { + WriteComments(bw, comments); + } + bw.Write("#" + DateTime.Now.ToString() + bw.NewLine); + { + foreach (string key in Keys) + { + String val = (string)this[key]; + string key1 = SaveConvert(key, true, escUnicode); + /* No need to escape embedded and trailing spaces for value, hence + * pass false to flag. + */ + val = SaveConvert(val, false, escUnicode); + bw.Write(key1 + "=" + val + bw.NewLine); + } + } + bw.Flush(); + } + + /// + /// Convert a nibble to a hex character + /// + /// nibble to convert + /// + private static char ToHex(int nibble) + { + return hexDigit[(nibble & 0xF)]; + } + + private static char[] hexDigit = { + '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F' + }; + } + +} + + diff --git a/HpToolsLauncher/JunitXml/JunitXmlBuilder.cs b/HpToolsLauncher/JunitXml/JunitXmlBuilder.cs new file mode 100644 index 0000000000..a0b72c84ab --- /dev/null +++ b/HpToolsLauncher/JunitXml/JunitXmlBuilder.cs @@ -0,0 +1,92 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +using System; +using System.Xml.Linq; +using System.Xml.Serialization; +using System.IO; + +namespace HpToolsLauncher +{ + public class JunitXmlBuilder : IXmlBuilder + { + private string _xmlName = "APIResults.xml"; + + public string XmlName + { + get { return _xmlName; } + set { _xmlName = value; } + } + public const string ClassName = "uftRunner"; + public const string RootName = "uftRunnerRoot"; + + XmlSerializer _serializer = new XmlSerializer(typeof(testsuites)); + + testsuites _testSuites = new testsuites(); + + + public JunitXmlBuilder() + { + _testSuites.name = RootName; + } + + /// + /// converts all data from the test resutls in to the Junit xml format and writes the xml file to disk. + /// + /// + public void CreateXmlFromRunResults(TestSuiteRunResults results) + { + _testSuites = new testsuites(); + + testsuite ts = new testsuite { errors = results.NumErrors.ToString(), tests = results.NumTests.ToString(), failures = results.NumFailures.ToString(), name = results.SuiteName, package = ClassName }; + foreach (TestRunResults testRes in results.TestRuns) + { + testcase tc = new testcase + { + systemout = testRes.ConsoleOut, + systemerr = testRes.ConsoleErr, + report = testRes.ReportLocation, + classname = "All-Tests." + ((testRes.TestGroup == null) ? "" : testRes.TestGroup.Replace(".", "_")), + name = testRes.TestPath, + type = testRes.TestType, + time = testRes.Runtime.TotalSeconds.ToString() + }; + + if (!string.IsNullOrWhiteSpace(testRes.FailureDesc)) + tc.AddFailure(new failure { message = testRes.FailureDesc }); + switch (testRes.TestState) + { + case TestState.Passed: + tc.status = "pass"; + break; + case TestState.Failed: + tc.status = "fail"; + break; + case TestState.Error: + tc.status = "error"; + break; + default: + tc.status = "pass"; + break; + } + if (!string.IsNullOrWhiteSpace(testRes.ErrorDesc)) + tc.AddError(new error { message = testRes.ErrorDesc }); + + ts.AddTestCase(tc); + } + _testSuites.AddTestsuite(ts); + + if (File.Exists(XmlName)) + File.Delete(XmlName); + + using (Stream s = File.OpenWrite(XmlName)) + { + _serializer.Serialize(s, _testSuites); + } + } + + + } +} diff --git a/HpToolsLauncher/JunitXml/junit.cs b/HpToolsLauncher/JunitXml/junit.cs new file mode 100644 index 0000000000..2df6283412 --- /dev/null +++ b/HpToolsLauncher/JunitXml/junit.cs @@ -0,0 +1,801 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.530 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +using System.Xml.Serialization; +using System.Collections.Generic; + +// +// This source code was auto-generated by xsd, Version=4.0.30319.1. +// + + +/// +[System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.0.30319.1")] +[System.SerializableAttribute()] +[System.Diagnostics.DebuggerStepThroughAttribute()] +[System.ComponentModel.DesignerCategoryAttribute("code")] +[System.Xml.Serialization.XmlTypeAttribute(AnonymousType = true)] +[System.Xml.Serialization.XmlRootAttribute(Namespace = "", IsNullable = false)] +public partial class failure +{ + + private string typeField; + + private string messageField; + + private string[] textField; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string type + { + get + { + return this.typeField; + } + set + { + this.typeField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + [System.Xml.Serialization.XmlTextAttribute()] + public string[] Text + { + get + { + return this.textField; + } + set + { + this.textField = value; + } + } +} + +/// +[System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.0.30319.1")] +[System.SerializableAttribute()] +[System.Diagnostics.DebuggerStepThroughAttribute()] +[System.ComponentModel.DesignerCategoryAttribute("code")] +[System.Xml.Serialization.XmlTypeAttribute(AnonymousType = true)] +[System.Xml.Serialization.XmlRootAttribute(Namespace = "", IsNullable = false)] +public partial class error +{ + + private string typeField; + + private string messageField; + + private string[] textField; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string type + { + get + { + return this.typeField; + } + set + { + this.typeField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + [System.Xml.Serialization.XmlTextAttribute()] + public string[] Text + { + get + { + return this.textField; + } + set + { + this.textField = value; + } + } +} + +/// +[System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.0.30319.1")] +[System.SerializableAttribute()] +[System.Diagnostics.DebuggerStepThroughAttribute()] +[System.ComponentModel.DesignerCategoryAttribute("code")] +[System.Xml.Serialization.XmlTypeAttribute(AnonymousType = true)] +[System.Xml.Serialization.XmlRootAttribute(Namespace = "", IsNullable = false)] +public partial class properties +{ + + private property[] propertyField; + + /// + [System.Xml.Serialization.XmlElementAttribute("property")] + public property[] property + { + get + { + return this.propertyField; + } + set + { + this.propertyField = value; + } + } +} + +/// +[System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.0.30319.1")] +[System.SerializableAttribute()] +[System.Diagnostics.DebuggerStepThroughAttribute()] +[System.ComponentModel.DesignerCategoryAttribute("code")] +[System.Xml.Serialization.XmlTypeAttribute(AnonymousType = true)] +[System.Xml.Serialization.XmlRootAttribute(Namespace = "", IsNullable = false)] +public partial class property +{ + + private string nameField; + + private string valueField; + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string name + { + get + { + return this.nameField; + } + set + { + this.nameField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string value + { + get + { + return this.valueField; + } + set + { + this.valueField = value; + } + } +} + +/// +[System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.0.30319.1")] +[System.SerializableAttribute()] +[System.Diagnostics.DebuggerStepThroughAttribute()] +[System.ComponentModel.DesignerCategoryAttribute("code")] +[System.Xml.Serialization.XmlTypeAttribute(AnonymousType = true)] +[System.Xml.Serialization.XmlRootAttribute(Namespace = "", IsNullable = false)] +public partial class testcase +{ + + private string skippedField; + + private List errorField = new List(); + + private List failureField = new List(); + + private string systemoutField; + + private string systemerrField; + + private string nameField; + + private string assertionsField; + + private string timeField; + + private string classnameField; + + private string statusField; + + /// + public string skipped + { + get + { + return this.skippedField; + } + set + { + this.skippedField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("error")] + public error[] error + { + get + { + return this.errorField.ToArray(); + } + set + { + this.errorField.Clear(); + this.errorField.AddRange(value); + } + } + + + public void AddError(error f) + { + errorField.Add(f); + } + + public void AddFailure(failure f) + { + failureField.Add(f); + } + + /// + [System.Xml.Serialization.XmlElementAttribute("failure")] + public failure[] failure + { + get + { + return this.failureField.ToArray(); + } + set + { + this.failureField.Clear(); + this.failureField.AddRange(value); + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("system-out")] + public string systemout + { + get + { + return this.systemoutField; + } + set + { + this.systemoutField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("system-err")] + public string systemerr + { + get + { + return this.systemerrField; + } + set + { + this.systemerrField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string name + { + get + { + return this.nameField; + } + set + { + this.nameField = value; + } + } + + + /// + /// special field added for tests + /// + [System.Xml.Serialization.XmlAttributeAttribute("type")] + public string type { get; set; } + + /// + /// special field added for tests + /// + [System.Xml.Serialization.XmlAttributeAttribute("report")] + public string report { get; set; } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string assertions + { + get + { + return this.assertionsField; + } + set + { + this.assertionsField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string time + { + get + { + return this.timeField; + } + set + { + this.timeField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string classname + { + get + { + return this.classnameField; + } + set + { + this.classnameField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string status + { + get + { + return this.statusField; + } + set + { + this.statusField = value; + } + } +} + +/// +[System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.0.30319.1")] +[System.SerializableAttribute()] +[System.Diagnostics.DebuggerStepThroughAttribute()] +[System.ComponentModel.DesignerCategoryAttribute("code")] +[System.Xml.Serialization.XmlTypeAttribute(AnonymousType = true)] +[System.Xml.Serialization.XmlRootAttribute(Namespace = "", IsNullable = false)] +public partial class testsuite +{ + + private property[] propertiesField; + + private List testcaseField = new List(); + + private string systemoutField; + + private string systemerrField; + + private string nameField; + + private string testsField; + + private string failuresField; + + private string errorsField; + + private string timeField; + + private string disabledField; + + private string skippedField; + + private string timestampField; + + private string hostnameField; + + private string idField; + + private string packageField; + + /// + [System.Xml.Serialization.XmlArrayItemAttribute("property", IsNullable = false)] + public property[] properties + { + get + { + return this.propertiesField; + } + set + { + this.propertiesField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("testcase")] + public testcase[] testcase + { + get + { + return this.testcaseField.ToArray(); + } + set + { + testcaseField.Clear(); + testcaseField.AddRange(value); + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("system-out")] + public string systemout + { + get + { + return this.systemoutField; + } + set + { + this.systemoutField = value; + } + } + + /// + [System.Xml.Serialization.XmlElementAttribute("system-err")] + public string systemerr + { + get + { + return this.systemerrField; + } + set + { + this.systemerrField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string name + { + get + { + return this.nameField; + } + set + { + this.nameField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string tests + { + get + { + return this.testsField; + } + set + { + this.testsField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string failures + { + get + { + return this.failuresField; + } + set + { + this.failuresField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string errors + { + get + { + return this.errorsField; + } + set + { + this.errorsField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string time + { + get + { + return this.timeField; + } + set + { + this.timeField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string disabled + { + get + { + return this.disabledField; + } + set + { + this.disabledField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string skipped + { + get + { + return this.skippedField; + } + set + { + this.skippedField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string timestamp + { + get + { + return this.timestampField; + } + set + { + this.timestampField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string hostname + { + get + { + return this.hostnameField; + } + set + { + this.hostnameField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string id + { + get + { + return this.idField; + } + set + { + this.idField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string package + { + get + { + return this.packageField; + } + set + { + this.packageField = value; + } + } + + internal void AddTestCase(testcase theTestCase) + { + testcaseField.Add(theTestCase); + } +} + +/// +[System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.0.30319.1")] +[System.SerializableAttribute()] +[System.Diagnostics.DebuggerStepThroughAttribute()] +[System.ComponentModel.DesignerCategoryAttribute("code")] +[System.Xml.Serialization.XmlTypeAttribute(AnonymousType = true)] +[System.Xml.Serialization.XmlRootAttribute(Namespace = "", IsNullable = false)] +public partial class testsuites +{ + private List testsuiteField = new List(); + + public void AddTestsuite(testsuite ts) + { + testsuiteField.Add(ts); + } + + private string nameField; + + private string timeField; + + private string testsField; + + private string failuresField; + + private string disabledField; + + private string errorsField; + + /// + [System.Xml.Serialization.XmlElementAttribute("testsuite")] + public testsuite[] testsuite + { + get + { + return this.testsuiteField.ToArray(); + } + set + { + this.testsuiteField.Clear(); + if (value != null) + this.testsuiteField.AddRange(value); + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string name + { + get + { + return this.nameField; + } + set + { + this.nameField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string time + { + get + { + return this.timeField; + } + set + { + this.timeField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string tests + { + get + { + return this.testsField; + } + set + { + this.testsField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string failures + { + get + { + return this.failuresField; + } + set + { + this.failuresField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string disabled + { + get + { + return this.disabledField; + } + set + { + this.disabledField = value; + } + } + + /// + [System.Xml.Serialization.XmlAttributeAttribute()] + public string errors + { + get + { + return this.errorsField; + } + set + { + this.errorsField = value; + } + } + + internal void RemoveTestSuite(string name) + { + testsuite foundSuite = null; + foreach (testsuite s in testsuiteField) + if (s.name == name) + { + foundSuite = s; + break; + } + + if (foundSuite != null) + testsuiteField.Remove(foundSuite); + } +} diff --git a/HpToolsLauncher/JunitXml/junit.xsd b/HpToolsLauncher/JunitXml/junit.xsd new file mode 100644 index 0000000000..1346313f4b --- /dev/null +++ b/HpToolsLauncher/JunitXml/junit.xsd @@ -0,0 +1,94 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/HpToolsLauncher/Launcher.cs b/HpToolsLauncher/Launcher.cs new file mode 100644 index 0000000000..4187c10289 --- /dev/null +++ b/HpToolsLauncher/Launcher.cs @@ -0,0 +1,400 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +using System; +using System.IO; +using System.Linq; +using System.Threading; +using System.Xml.Linq; +using System.Xml.XPath; +using System.Xml; +using HpToolsLauncher; +using System.Collections.Generic; +using System.Security.Cryptography; +using System.Text; + +namespace HpToolsLauncher +{ + public enum CIName + { + Hudson, + Jenkins, + TFS, + CCNET, + } + + public class Launcher + { + private IXmlBuilder _xmlBuilder; + private bool _ciRun = false; + private readonly string _paramFileName = null; + private JavaProperties _ciParams = new JavaProperties(); + private TestStorageType _runtype = TestStorageType.Unknown; + private readonly string _failOnUftTestFailed; + private static ExitCodeEnum _exitCode = ExitCodeEnum.Passed; + private static string _dateFormat = "dd/MM/yyyy HH:mm:ss"; + + public static string DateFormat + { + get { return Launcher._dateFormat; } + set { Launcher._dateFormat = value; } + } + + /// + /// if running an alm job theses strings are mandatory: + /// + private string[] requiredParamsForQcRun = { "almServerURL", + "almUserName", + "almPassword", + "almDomain", + "almProject", + "almRunMode", + "almTimeout", + "almRunHost"}; + + /// + /// a place to save the unique timestamp which shows up in properties/results/abort file names + /// this timestamp per job run. + /// + public static string UniqueTimeStamp { get; set; } + + public enum ExitCodeEnum + { + Passed = 0, + Failed = 1, + Unstable = 2, + Aborted = 3 + + } + /// + /// saves the exit code in case we want to run all tests but fail at the end since a file wasn't found + /// + public static ExitCodeEnum ExitCode + { + get { return Launcher._exitCode; } + set { Launcher._exitCode = value; } + } + + + /// + /// constructor + /// + /// + /// + /// + public Launcher(string failOnTestFailed, string paramFileName, TestStorageType runtype) + { + _runtype = runtype; + if (paramFileName != null) + _ciParams.Load(paramFileName); + _paramFileName = paramFileName; + + _failOnUftTestFailed = string.IsNullOrEmpty(failOnTestFailed) ? "N" : failOnTestFailed; + } + + static String secretkey = "EncriptionPass4Java"; + + /// + /// decrypts strings which were encrypted by Encrypt (in the c# or java code, mainly for qc passwords) + /// + /// + /// + /// + string Decrypt(string textToDecrypt, string key) + { + RijndaelManaged rijndaelCipher = new RijndaelManaged(); + rijndaelCipher.Mode = CipherMode.CBC; + rijndaelCipher.Padding = PaddingMode.PKCS7; + + rijndaelCipher.KeySize = 0x80; + rijndaelCipher.BlockSize = 0x80; + byte[] encryptedData = Convert.FromBase64String(textToDecrypt); + byte[] pwdBytes = Encoding.UTF8.GetBytes(key); + byte[] keyBytes = new byte[0x10]; + int len = pwdBytes.Length; + if (len > keyBytes.Length) + { + len = keyBytes.Length; + } + Array.Copy(pwdBytes, keyBytes, len); + rijndaelCipher.Key = keyBytes; + rijndaelCipher.IV = keyBytes; + byte[] plainText = rijndaelCipher.CreateDecryptor().TransformFinalBlock(encryptedData, 0, encryptedData.Length); + return Encoding.UTF8.GetString(plainText); + } + + /// + /// encrypts strings to be decrypted by decrypt function(in the c# or java code, mainly for qc passwords) + /// + /// + /// + /// + string Encrypt(string textToEncrypt, string key) + { + RijndaelManaged rijndaelCipher = new RijndaelManaged(); + rijndaelCipher.Mode = CipherMode.CBC; + rijndaelCipher.Padding = PaddingMode.PKCS7; + + rijndaelCipher.KeySize = 0x80; + rijndaelCipher.BlockSize = 0x80; + byte[] pwdBytes = Encoding.UTF8.GetBytes(key); + byte[] keyBytes = new byte[0x10]; + int len = pwdBytes.Length; + if (len > keyBytes.Length) + { + len = keyBytes.Length; + } + Array.Copy(pwdBytes, keyBytes, len); + rijndaelCipher.Key = keyBytes; + rijndaelCipher.IV = keyBytes; + ICryptoTransform transform = rijndaelCipher.CreateEncryptor(); + byte[] plainText = Encoding.UTF8.GetBytes(textToEncrypt); + return Convert.ToBase64String(transform.TransformFinalBlock(plainText, 0, plainText.Length)); + } + + /// + /// writes to console using the ConsolWriter class + /// + /// + private static void WriteToConsole(string message) + { + ConsoleWriter.WriteLine(message); + } + + /// + /// analyzes and runs the tests given in the param file. + /// + public void Run() + { + _ciRun = true; + if (_runtype == TestStorageType.Unknown) + Enum.TryParse(_ciParams["runType"], true, out _runtype); + if (_runtype == TestStorageType.Unknown) + { + WriteToConsole(string.Format("no runType parameter provided, please state runType= in param file")); + return; + } + + if (!_ciParams.ContainsKey("resultsFilename")) + { + WriteToConsole(string.Format("no resultsFilename parameter provided, please add 'resultsFilename=' to param file")); + return; + } + string resultsFilename = _ciParams["resultsFilename"]; + + if (_ciParams.ContainsKey("uniqueTimeStamp")) + { + UniqueTimeStamp = _ciParams["uniqueTimeStamp"]; + } + else + { + UniqueTimeStamp = resultsFilename.ToLower().Replace("results", "").Replace(".xml", ""); + } + + //create the runner according to type + IAssetRunner runner = CreateRunner(_runtype, _ciParams); + + //runner instansiation failed (no tests to run or other problem) + if (runner == null) + { + Environment.Exit((int)Launcher.ExitCodeEnum.Failed); + } + + //run the tests! + RunTests(runner, resultsFilename); + + + if (Launcher.ExitCode != ExitCodeEnum.Passed) + Environment.Exit((int)Launcher.ExitCode); + } + + /// + /// creates the correct runner according to the given type + /// + /// + /// + IAssetRunner CreateRunner(TestStorageType runType, JavaProperties ciParams) + { + IAssetRunner runner = null; + switch (runType) + { + case TestStorageType.Alm: + //check that all required parameters exist + foreach (string param1 in requiredParamsForQcRun) + { + if (!_ciParams.ContainsKey(param1)) + { + ConsoleWriter.WriteLine("the parameter '" + param1 + "' is required to run a test from QC"); + return null; + } + } + + //parse params that need parsing + double dblQcTimeout = int.MaxValue; + if (!double.TryParse(_ciParams["almTimeout"], out dblQcTimeout)) + { + ConsoleWriter.WriteLine("the parameter 'almTimeout' should be an integer!"); + dblQcTimeout = int.MaxValue; + } + + ConsoleWriter.WriteLine("Timeout is set to: " + dblQcTimeout); + + QcRunMode enmQcRunMode = QcRunMode.RUN_LOCAL; + if (!Enum.TryParse(_ciParams["almRunMode"], true, out enmQcRunMode)) + { + ConsoleWriter.WriteLine("the parameter 'runMode' should be: RUN_LOCAL | RUN_REMOTE | RUN_PLANNED_HOST"); + enmQcRunMode = QcRunMode.RUN_LOCAL; + } + ConsoleWriter.WriteLine("Run mode is set to: " + enmQcRunMode.ToString()); + + //go over testsets in the parameters, and collect them + List sets = GetParamsWithPrefix("TestSet"); + + if (sets.Count == 0) + { + ConsoleWriter.WriteLine("No test sets found, please add some test sets or folders"); + return null; + } + + //create an Alm runner + runner = new AlmTestSetsRunner(_ciParams["almServerURL"], + _ciParams["almUserName"], + Decrypt(_ciParams["almPassword"], secretkey), + _ciParams["almDomain"], + _ciParams["almProject"], + dblQcTimeout, + enmQcRunMode, + _ciParams["almRunHost"], + sets); + break; + case TestStorageType.FileSystem: + + //get the tests + IEnumerable tests = GetParamsWithPrefix("Test"); + + //parse the timeout into a TimeSpan + TimeSpan timeout = TimeSpan.MaxValue; + if (_ciParams.ContainsKey("fsTimeout")) + { + string strTimoutInMinutes = _ciParams["fsTimeout"]; + if (strTimoutInMinutes.Trim() != "-1") + { + int intTimoutInMinutes = 0; + int.TryParse(strTimoutInMinutes, out intTimoutInMinutes); + timeout = TimeSpan.FromMinutes(intTimoutInMinutes); + } + } + + if (tests == null || tests.Count() == 0) + { + WriteToConsole("No tests were found, please add tests or folders containing tests"); + } + + List validTests = new List(); + foreach (string test in tests) + { + if (!File.Exists(test) && !Directory.Exists(test)) + { + ConsoleWriter.WriteLine(string.Format(">>>> File/Folder not found: '{0}'", test)); + Launcher.ExitCode = Launcher.ExitCodeEnum.Failed; + } + else + { + validTests.Add(test); + } + } + + if (tests != null && tests.Count() > 0 && validTests.Count == 0) + { + ConsoleWriter.WriteLine("No valid tests were found, please correct test paths."); + return null; + } + + runner = new FileSystemTestsRunner(validTests, timeout); + + break; + case TestStorageType.LoadRunner: + break; + default: + runner = null; + break; + } + return runner; + } + + private List GetParamsWithPrefix(string prefix) + { + int idx = 1; + List parameters = new List(); + while (_ciParams.ContainsKey(prefix + idx)) + { + string set = _ciParams[prefix + idx]; + if (set.StartsWith("Root\\")) + set = set.Substring(5); + set = set.TrimEnd("\\".ToCharArray()); + parameters.Add(set.TrimEnd()); + ++idx; + } + return parameters; + } + + /// + /// used by the run fuction to run the tests + /// + /// + /// + private void RunTests(IAssetRunner runner, string resultsFile) + { + try + { + if (_ciRun) + { + _xmlBuilder = new JunitXmlBuilder(); + _xmlBuilder.XmlName = resultsFile; + } + + TestSuiteRunResults results = runner.Run(); + + if (results == null) + Environment.Exit((int)Launcher.ExitCodeEnum.Failed); + + _xmlBuilder.CreateXmlFromRunResults(results); + + //if there is an error + if (results.TestRuns.Any(tr => tr.TestState == TestState.Failed || tr.TestState == TestState.Error)) + { + Launcher.ExitCode = Launcher.ExitCodeEnum.Failed; + } + + //this is the total run summary + ConsoleWriter.ActiveTestRun = null; + string runStatus = (Launcher.ExitCode == ExitCodeEnum.Passed || Launcher.ExitCode == ExitCodeEnum.Unstable) ? "Job succeeded" : "Job failed"; + int numFailures = results.TestRuns.Count(t => t.TestState == TestState.Failed); + int numSuccess = results.TestRuns.Count(t => t.TestState == TestState.Passed); + int numErrors = results.TestRuns.Count(t => t.TestState == TestState.Error); + ConsoleWriter.WriteLine("================================================"); + ConsoleWriter.WriteLine("Run status: " + runStatus + ", total tests:" + results.TestRuns.Count + ", succeeded: " + numSuccess + ", failures: " + numFailures + ", errors: " + numErrors); + + if (!runner.RunWasCancelled) + results.TestRuns.ForEach(tr => ConsoleWriter.WriteLine(((tr.HasWarnings) ? "Warning".PadLeft(7) : tr.TestState.ToString().PadRight(7)) + ": " + tr.TestPath)); + + //ConsoleWriter.WriteLine("Returning " + runStatus + "."); + } + finally + { + try + { + runner.Dispose(); + } + catch (Exception ex) + { + ConsoleWriter.WriteLine("got an error while disposing runner: " + ex.Message); + }; + } + + } + + } +} diff --git a/HpToolsLauncher/MtbManager.cs b/HpToolsLauncher/MtbManager.cs new file mode 100644 index 0000000000..2562d5721f --- /dev/null +++ b/HpToolsLauncher/MtbManager.cs @@ -0,0 +1,122 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; +using HpToolsLauncher.Properties; +using System.IO; +//using UFT.Runner.Properties; + +namespace HpToolsLauncher +{ + public class MtbManager : IMtbManager + { + public delegate IEnumerable GetContentDelegate(); + + private string _mtbName = Resources.DefaultName; + private string _mtbFileName; + + private const string DefaultFileExt = ".mtb"; + private const string MtbSectionKey = "Files"; + private const string MtbNumFilesKey = "NumberOfFiles"; + + private static List GetPathsFromFile(string fileName) + { + var paths = new List(); + try + { + var iniManager = new IniManager(fileName); + var count = Convert.ToInt32(iniManager.ReadValue(MtbSectionKey, MtbNumFilesKey)); + for (int i = 1; i <= count; i++) + { + var key = string.Format("File{0}", i); + var path = iniManager.ReadValue(MtbSectionKey, key); + + string testFileName = path.Split(';')[0]; + + if (!Directory.Exists(testFileName)) + { + ConsoleWriter.WriteErrLine(string.Format("File/Folder not found: '{0}'", testFileName)); + Launcher.ExitCode = Launcher.ExitCodeEnum.Failed; + } + else + { + paths.Add(testFileName); + } + } + } + //The given file is not a valid mtb file + catch{} + + return paths; + } + + #region IMtbManager implementation + + public void New() + { + _mtbName = Resources.DefaultName; + _mtbFileName = string.Empty; + IsDirty = false; + } + + public List Open() + { + return GetPathsFromFile(_mtbFileName); + } + + /// + /// Save the contents to a file in the file system + /// + /// + public void Save(IEnumerable paths) + { + var count = paths.Count(); + var iniManager = new IniManager(_mtbFileName); + iniManager.WriteValue(MtbSectionKey, MtbNumFilesKey, count.ToString()); + + int i = 1; + foreach (var path in paths) + { + var key = string.Format("File{0}", i++); + var value = string.Format("{0};1", path); + iniManager.WriteValue(MtbSectionKey, key, value); + } + } + + public List Parse(string fileName) + { + return GetPathsFromFile(fileName); + } + + public void InitializeContext(string mtbName, string mtbFileName) + { + _mtbName = mtbName; + _mtbFileName = mtbFileName; + } + + public string MtbName + { + get { return _mtbName; } + } + + public string MtbFileName + { + get { return _mtbFileName; } + } + + public string DefaultFileExtension + { + get { return DefaultFileExt; } + } + + public bool IsDirty { get; set; } + + + #endregion + + } +} diff --git a/HpToolsLauncher/Program.cs b/HpToolsLauncher/Program.cs new file mode 100644 index 0000000000..ddad6c2e8d --- /dev/null +++ b/HpToolsLauncher/Program.cs @@ -0,0 +1,93 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Diagnostics; + +namespace HpToolsLauncher +{ + public enum TestStorageType + { + Alm, + FileSystem, + LoadRunner, + Unknown + } + + class Program + { + private static readonly Dictionary argsDictionary = new Dictionary(); + + static void Main(string[] args) + { + ConsoleWriter.WriteLine("started!"); + + if (args.Count() == 0 || args.Contains("/?")) + { + ShowHelp(); + return; + } + for (int i = 0; i < args.Count(); i = i + 2) + { + string key = args[i].StartsWith("-") ? args[i].Substring(1) : args[i]; + string val = i + 1 < args.Count() ? args[i + 1].Trim() : String.Empty; + argsDictionary[key] = val; + } + string paramFileName, runtype; + string failOnTestFailed = "N"; + argsDictionary.TryGetValue("runtype", out runtype); + argsDictionary.TryGetValue("paramfile", out paramFileName); + TestStorageType enmRuntype = TestStorageType.Unknown; + + if (!Enum.TryParse(runtype, true, out enmRuntype)) + enmRuntype = TestStorageType.Unknown; + + if (string.IsNullOrEmpty(paramFileName)) + { + ShowHelp(); + return; + } + var apiRunner = new Launcher(failOnTestFailed, paramFileName, enmRuntype); + + apiRunner.Run(); + } + + private static void ShowHelp() + { + Console.WriteLine("HP Unified Functional Testing Command Line Executer"); + Console.WriteLine(); + Console.Write("Usage: HpToolsLauncher.exe"); + //Console.Write("\t\t\t\t-mtb "); + //Console.ForegroundColor = ConsoleColor.Cyan; + //Console.Write("\t "); + //Console.ResetColor(); + //Console.WriteLine(); + Console.Write(" -paramfile "); + Console.ForegroundColor = ConsoleColor.Cyan; + Console.Write(" "); + Console.ResetColor(); + Console.WriteLine(); + Console.WriteLine(); + Console.WriteLine("-paramfile is required in for the program to run"); + Console.WriteLine("the parameter file may contain the following fields:"); + Console.WriteLine("\trunType="); + Console.WriteLine("\talmServerURL=http://:/qcbin"); + Console.WriteLine("\talmUserName="); + Console.WriteLine("\talmPassword="); + Console.WriteLine("\talmDomain="); + Console.WriteLine("\talmProject="); + Console.WriteLine("\talmRunMode="); + Console.WriteLine("\talmTimeout=<-1>/"); + Console.WriteLine("\talmRunHost="); + Console.WriteLine("\tTestSet=/"); + Console.WriteLine("\tTest=//"); + Console.WriteLine("* the last two fields may recur more than once with different index numbers"); + Environment.Exit((int)Launcher.ExitCodeEnum.Failed); + } + } +} diff --git a/HpToolsLauncher/Properties/AssemblyInfo.cs b/HpToolsLauncher/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..e5e26aed36 --- /dev/null +++ b/HpToolsLauncher/Properties/AssemblyInfo.cs @@ -0,0 +1,41 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("HpToolsLauncher")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("Hewlett-Packard Company")] +[assembly: AssemblyProduct("HpToolsLauncher")] +[assembly: AssemblyCopyright("Copyright © Hewlett-Packard Company 2012")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("7e493d6c-8738-4f9d-b2b7-290feb7c719b")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/HpToolsLauncher/Properties/Resources.Designer.cs b/HpToolsLauncher/Properties/Resources.Designer.cs new file mode 100644 index 0000000000..d1d084edb1 --- /dev/null +++ b/HpToolsLauncher/Properties/Resources.Designer.cs @@ -0,0 +1,181 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.296 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace HpToolsLauncher.Properties { + using System; + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("HpToolsLauncher.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + + /// + /// Looks up a localized string similar to Untitled. + /// + internal static string DefaultName { + get { + return ResourceManager.GetString("DefaultName", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Directory '{0}' doesn't exist.. + /// + internal static string DirectoryNotExistError { + get { + return ResourceManager.GetString("DirectoryNotExistError", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Exception was thrown from external process.. + /// + internal static string ExceptionExternalProcess { + get { + return ResourceManager.GetString("ExceptionExternalProcess", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Run cancelled by user.. + /// + internal static string ExceptionUserCancelled { + get { + return ResourceManager.GetString("ExceptionUserCancelled", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to No HP testing tool is installed on . + /// + internal static string FileSystemTestsRunner_No_HP_testing_tool_is_installed_on { + get { + return ResourceManager.GetString("FileSystemTestsRunner_No_HP_testing_tool_is_installed_on", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to "QTPActivity.TestCleanup - exception {0}". + /// + internal static string QtpCleanupError { + get { + return ResourceManager.GetString("QtpCleanupError", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to QTP is not launched.. + /// + internal static string QtpNotLaunchedError { + get { + return ResourceManager.GetString("QtpNotLaunchedError", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to QTP could not handle output arguments.. + /// + internal static string QtpOutputError { + get { + return ResourceManager.GetString("QtpOutputError", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to QTP could not run.. + /// + internal static string QtpRunError { + get { + return ResourceManager.GetString("QtpRunError", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Test execution stopped due to unsaved changes in QuickTest. + ///Save the test in QuickTest and then run it again.. + /// + internal static string QtpUnsavedError { + get { + return ResourceManager.GetString("QtpUnsavedError", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Could not find results file '{0}'.. + /// + internal static string ResultFileNotExistError { + get { + return ResourceManager.GetString("ResultFileNotExistError", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to HP Testing Tool is missing : HP Service Test/HP Unified Function Testing. + /// + internal static string STExecuterNotFound { + get { + return ResourceManager.GetString("STExecuterNotFound", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to XML node '{0}' could not be found.. + /// + internal static string XmlNodeNotExistError { + get { + return ResourceManager.GetString("XmlNodeNotExistError", resourceCulture); + } + } + } +} diff --git a/HpToolsLauncher/Properties/Resources.resx b/HpToolsLauncher/Properties/Resources.resx new file mode 100644 index 0000000000..bd7913c192 --- /dev/null +++ b/HpToolsLauncher/Properties/Resources.resx @@ -0,0 +1,160 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Untitled + + + Directory '{0}' doesn't exist. + + + Exception was thrown from external process. + + + Run cancelled by user. + + + "QTPActivity.TestCleanup - exception {0}" + + + QTP is not launched. + + + QTP could not handle output arguments. + + + QTP could not run. + + + Test execution stopped due to unsaved changes in QuickTest. +Save the test in QuickTest and then run it again. + + + Could not find results file '{0}'. + + + HP Testing Tool is missing : HP Service Test/HP Unified Function Testing + + + XML node '{0}' could not be found. + + + + + \ No newline at end of file diff --git a/HpToolsLauncher/Runners/AlmTestSetsRunner.cs b/HpToolsLauncher/Runners/AlmTestSetsRunner.cs new file mode 100644 index 0000000000..33244d1664 --- /dev/null +++ b/HpToolsLauncher/Runners/AlmTestSetsRunner.cs @@ -0,0 +1,1095 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Runtime.InteropServices; +using System.Threading; +using System.Diagnostics; +using Mercury.TD.Client.Ota.QC9; +using System.Reflection; +using System.IO; + +//using Mercury.TD.Client.Ota.Api; + +namespace HpToolsLauncher +{ + public class AlmTestSetsRunner : RunnerBase, IDisposable + { + QcRunMode m_runMode = QcRunMode.RUN_LOCAL; + double m_timeout = -1; + bool m_blnConnected = false; + ITDConnection2 tdConnection = null; + List colTestSets = new List(); + string m_runHost = null; + string m_qcServer = null; + string m_qcUser = null; + string m_qcProject = null; + string m_qcDomain = null; + + public bool Connected + { + get { return m_blnConnected; } + set { m_blnConnected = value; } + } + + public List TestSets + { + get { return colTestSets; } + set { colTestSets = value; } + } + + public QcRunMode RunMode + { + get { return m_runMode; } + set { m_runMode = value; } + } + + public double Timeout + { + get { return m_timeout; } + set { m_timeout = value; } + } + + public string RunHost + { + get { return m_runHost; } + set { m_runHost = value; } + } + + public ITDConnection2 TdConnection + { + get + { + if (tdConnection == null) + CreateTdConnection(); + + return tdConnection; + } + set { tdConnection = value; } + } + + + /// + /// constructor + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + public AlmTestSetsRunner(string qcServer, + string qcUser, + string qcPassword, + string qcDomain, + string qcProject, + double intQcTimeout, + QcRunMode enmQcRunMode, + string runHost, + List qcTestSets) + { + Timeout = intQcTimeout; + RunMode = enmQcRunMode; + RunHost = runHost; + + m_qcServer = qcServer; + m_qcUser = qcUser; + m_qcProject = qcProject; + m_qcDomain = qcDomain; + + Connected = ConnectToProject(qcServer, qcUser, qcPassword, qcDomain, qcProject); + TestSets = qcTestSets; + if (!Connected) + { + //ConsoleWriter.WriteLine("connection error, stopping."); + Environment.Exit((int)Launcher.ExitCodeEnum.Failed); + } + } + + /// + /// destructor - ensures dispose of connection + /// + ~AlmTestSetsRunner() + { + Dispose(false); + } + + + /// + /// runs the tests given to the object. + /// + /// + public override TestSuiteRunResults Run() + { + if (!Connected) + return null; + TestSuiteRunResults activeRunDesc = new TestSuiteRunResults(); + //find all the testSets under if given some folders in our list + try + { + FindAllTestSetsUnderFolders(); + } + catch (Exception ex) + { + ConsoleWriter.WriteErrLine("please check that your QC client is installed properly\n" + ex.Message + "\n" + ex.StackTrace); + return null; + } + + //run all the TestSets + foreach (string testset in TestSets) + { + string testset1 = testset.TrimEnd("\\".ToCharArray()); + + int pos = testset1.LastIndexOf('\\'); + string tsDir = ""; + string tsName = testset1; + if (pos != -1) + { + tsDir = testset1.Substring(0, pos).Trim("\\".ToCharArray()); + tsName = testset1.Substring(pos, testset1.Length - pos).Trim("\\".ToCharArray()); + } + + TestSuiteRunResults desc = RunTestSet(tsDir, tsName, Timeout, RunMode, RunHost); + if (desc != null) + activeRunDesc.AppendResults(desc); + } + + return activeRunDesc; + } + + /// + /// creats a connection to Qc + /// + private void CreateTdConnection() + { + + Type type = Type.GetTypeFromProgID("TDApiOle80.TDConnection"); + + if (type == null) + { + ConsoleWriter.WriteLine(GetAlmNotInstalledError()); + Environment.Exit((int)Launcher.ExitCodeEnum.Failed); + } + + try + { + object conn = Activator.CreateInstance(type); + this.tdConnection = conn as ITDConnection2; + + } + catch (FileNotFoundException ex) + { + ConsoleWriter.WriteLine(GetAlmNotInstalledError()); + Environment.Exit((int)Launcher.ExitCodeEnum.Failed); + } + } + + /// + /// finds all folders in the TestSet list, scans their tree and adds all sets under the given folders + /// updates the TestSets by expanding the folders, and removing them, so only Test sets remain in the collection + /// + private void FindAllTestSetsUnderFolders() + { + List extraSetsList = new List(); + List removeSetsList = new List(); + var tsTreeManager = (ITestSetTreeManager)tdConnection.TestSetTreeManager; + + //go over all the testsets / testSetFolders and check which is which + foreach (string testsetOrFolder in TestSets) + { + //try getting the folder + ITestSetFolder tsFolder = GetFolder("Root\\" + testsetOrFolder.TrimEnd("\\".ToCharArray())); + + //if it exists it's a folder and should be traversed to find all sets + if (tsFolder != null) + { + removeSetsList.Add(testsetOrFolder); + + List setList = GetAllTestSetsFromDirTree(tsFolder); + extraSetsList.AddRange(setList); + } + + } + + TestSets.RemoveAll((a) => removeSetsList.Contains(a)); + TestSets.AddRange(extraSetsList); + } + + /// + /// recursively find all testsets in the qc directory tree, starting from a given folder + /// + /// + /// + /// + private List GetAllTestSetsFromDirTree(ITestSetFolder tsFolder) + { + List retVal = new List(); + List children = tsFolder.FindChildren(""); + List testSets = tsFolder.FindTestSets(""); + + if (testSets != null) + { + foreach (ITestSet childSet in testSets) + { + string tsPath = childSet.TestSetFolder.Path; + tsPath = tsPath.Substring(5).Trim("\\".ToCharArray()); + string tsFullPath = tsPath + "\\" + childSet.Name; + retVal.Add(tsFullPath.TrimEnd()); + } + } + + if (children != null) + { + foreach (ITestSetFolder childFolder in children) + { + GetAllTestSetsFromDirTree(childFolder); + } + } + return retVal; + } + + + /// + /// get a QC folder + /// + /// + /// the folder object + private ITestSetFolder GetFolder(string testset) + { + var tsTreeManager = (ITestSetTreeManager)tdConnection.TestSetTreeManager; + ITestSetFolder tsFolder = null; + try + { + tsFolder = (ITestSetFolder)tsTreeManager.get_NodeByPath(testset); + } + catch (Exception ex) + { + return null; + } + return tsFolder; + } + + /// + /// gets test index given it's name + /// + /// + /// + /// + public int GetIdxByTestName(string strName, TestSuiteRunResults results) + { + TestRunResults res = null; + int retVal = -1; + + for (int i = 0; i < results.TestRuns.Count(); ++i) + { + res = results.TestRuns[i]; + + if (res != null && res.TestName == strName) + { + retVal = i; + break; + } + } + return retVal; + } + + /// + /// returns a description of the failure + /// + /// + /// + private string GenerateFailedLog(IRun p_Test) + { + try + { + StepFactory sf = p_Test.StepFactory as StepFactory; + if (sf == null) + return ""; + IList stepList = sf.NewList("") as IList; + if (stepList == null) + return ""; + + //var stList = p_Test.StepFactory.NewList(""); + //string l_szReturn = ""; + string l_szFailedMessage = ""; + + //' loop on each step in the steps + foreach (IStep s in stepList) + { + if (s.Status == "Failed") + l_szFailedMessage += s["ST_DESCRIPTION"] + "'\n\r"; + } + return l_szFailedMessage; + } + catch + { + return ""; + } + } + + + /// + /// writes a summary of the test run after it's over + /// + /// + private string GetTestInstancesString(ITestSet set) + { + string retVal = ""; + try + { + TSTestFactory factory = set.TSTestFactory; + List list = factory.NewList(""); + + if (list == null) + return ""; + + foreach (ITSTest testInstance in list) + { + retVal += testInstance.ID + ","; + } + retVal.TrimEnd(", \n".ToCharArray()); + } + catch (Exception ex) + { } + return retVal; + } + + /// + /// runs a test set with given parameters (and a valid connection to the QC server) + /// + /// testSet folder name + /// testSet name + /// -1 for unlimited, or number of miliseconds + /// run on LocalMachine or remote + /// if run on remote machine - remote machine name + /// + public TestSuiteRunResults RunTestSet(string tsFolderName, string tsName, double timeout, QcRunMode runMode, string runHost) + { + string currentTestSetInstances = ""; + TestSuiteRunResults runDesc = new TestSuiteRunResults(); + TestRunResults activeTestDesc = null; + + var tsFactory = tdConnection.TestSetFactory; + var tsTreeManager = (ITestSetTreeManager)tdConnection.TestSetTreeManager; + List tsList = null; + string tsPath = "Root\\" + tsFolderName; + ITestSetFolder tsFolder = null; + + try + { + tsFolder = (ITestSetFolder)tsTreeManager.get_NodeByPath(tsPath); + } + catch (COMException ex) + { + //not found + tsFolder = null; + } + + if (tsFolder == null) + { + //node wasn't found, folder = null + ConsoleWriter.WriteErrLine("folder " + tsFolder + " cannot be found in ALM"); + + //this will make sure run will fail at the end. (since there was an error) + Launcher.ExitCode = Launcher.ExitCodeEnum.Failed; + return null; + } + else + { + tsList = tsFolder.FindTestSets(tsName); + } + if (tsList == null) + { + ConsoleWriter.WriteLine("Could not find TestSet " + tsName); + + //this will make sure run will fail at the end. (since there was an error) + Launcher.ExitCode = Launcher.ExitCodeEnum.Failed; + return null; + } + ITestSet targetTestSet = null; + foreach (ITestSet ts in tsList) + { + if (ts.Name.Equals(tsName, StringComparison.InvariantCultureIgnoreCase)) + { + targetTestSet = ts; + break; + } + } + + if (targetTestSet == null) + { + ConsoleWriter.WriteLine("Could not find TestSet " + tsName); + + //this will make sure run will fail at the end. (since there was an error) + Launcher.ExitCode = Launcher.ExitCodeEnum.Failed; + return null; + } + + + ConsoleWriter.WriteLine("============================================================================"); + ConsoleWriter.WriteLine("Starting test set execution"); + ConsoleWriter.WriteLine("Test set name: " + tsName + " Test set id: " + targetTestSet.ID); + + ITSScheduler Scheduler = null; + try + { + //need to run this to install everyhting needed http://AlmServer:8080/qcbin/start_a.jsp?common=true + //start the scheduler + Scheduler = targetTestSet.StartExecution(""); + + + } + catch (Exception ex) + { + Scheduler = null; + } + try + { + + currentTestSetInstances = GetTestInstancesString(targetTestSet); + } + catch (Exception ex) + { + } + + if (Scheduler == null) + { + Console.WriteLine(GetAlmNotInstalledError()); + + //proceeding with program execution is tasteless, since nothing will run without a properly installed QC. + Environment.Exit((int)Launcher.ExitCodeEnum.Failed); + } + + TSTestFactory tsTestFactory = targetTestSet.TSTestFactory; + ITDFilter2 tdFilter = tsTestFactory.Filter; + tdFilter["TC_CYCLE_ID"] = targetTestSet.ID.ToString(); + + IList tList = tsTestFactory.NewList(tdFilter.Text); + try + { + //set up for the run depending on where the test instances are to execute + switch (runMode) + { + case QcRunMode.RUN_LOCAL: + // run all tests on the local machine + Scheduler.RunAllLocally = true; + break; + case QcRunMode.RUN_REMOTE: + // run tests on a specified remote machine + Scheduler.TdHostName = runHost; + break; + // RunAllLocally must not be set for remote invocation of tests. As such, do not do this: Scheduler.RunAllLocally = False + case QcRunMode.RUN_PLANNED_HOST: + // run on the hosts as planned in the test set + Scheduler.RunAllLocally = false; + break; + } + } + catch (Exception ex) + { + ConsoleWriter.WriteLine("problem while setting remote host: " + ex.Message); + } + + ConsoleWriter.WriteLine("Number of tests in set: " + tList.Count); + + int i = 1; + foreach (ITSTest3 test in tList) + { + string runOnHost = runHost; + if (runMode == QcRunMode.RUN_PLANNED_HOST) + runOnHost = test.HostName; + + //if host isn't taken from QC (PLANNED) and not from the test definition (REMOTE), take it from LOCAL (machineName) + string hostName = runOnHost; + if (runMode == QcRunMode.RUN_LOCAL) + { + hostName = Environment.MachineName; + } + ConsoleWriter.WriteLine("Test" + i + ": " + test.Name + " will run on host: " + hostName); + + Scheduler.RunOnHost[test.ID] = runOnHost; + + var testResults = new TestRunResults(); + testResults.TestName = test.Name; + runDesc.TestRuns.Add(testResults); + + i = i + 1; + } + + Stopwatch sw = Stopwatch.StartNew(); + Stopwatch testSw = null; + try + { + //tests are actually run + Scheduler.Run(); + } + catch (Exception ex) + { + ConsoleWriter.WriteLine("problem while running testSet: " + ex.Message); + } + + ConsoleWriter.WriteLine("Scheduler started at: " + DateTime.Now.ToString(Launcher.DateFormat)); + ConsoleWriter.WriteLine("-------------------------------------------------------------------------------------------------------"); + IExecutionStatus executionStatus = Scheduler.ExecutionStatus; + bool tsExecutionFinished = false; + ITSTest prevTest = null; + ITSTest currentTest = null; + //wait for the tests to end ("normally" or because of the timeout) + while ((tsExecutionFinished == false) && (timeout == -1 || sw.Elapsed.TotalMinutes < timeout)) + { + executionStatus.RefreshExecStatusInfo("all", true); + tsExecutionFinished = executionStatus.Finished; + + for (int j = 1; j <= executionStatus.Count; ++j) + { + TestExecStatus testExecStatusObj = executionStatus[j]; + + activeTestDesc = UpdateTestStatus(runDesc, targetTestSet, testExecStatusObj, true); + + if (activeTestDesc.PrevTestState != activeTestDesc.TestState) + { + TestState tstate = activeTestDesc.TestState; + if (tstate == TestState.Running) + { + currentTest = targetTestSet.TSTestFactory[testExecStatusObj.TSTestId]; + int testIndex = GetIdxByTestName(currentTest.Name, runDesc); + + int prevRunId = GetTestRunId(currentTest); + runDesc.TestRuns[testIndex].PrevRunId = prevRunId; + + //closing previous test + if (prevTest != null) + { + WriteTestRunSummary(prevTest); + } + + //starting new test + prevTest = currentTest; + + //assign the new test the consol writer so it will gather the output + + ConsoleWriter.ActiveTestRun = runDesc.TestRuns[testIndex]; + + ConsoleWriter.WriteLine(DateTime.Now.ToString(Launcher.DateFormat) + " Running: " + currentTest.Name); + + //tell user that the test is running + ConsoleWriter.WriteLine(DateTime.Now.ToString(Launcher.DateFormat) + " Running test: " + activeTestDesc.TestName + ", Test id: " + testExecStatusObj.TestId + ", Test instance id: " + testExecStatusObj.TSTestId); + + //start timing the new test run + string foldername = ""; + testSw = Stopwatch.StartNew(); + ITestSetFolder folder = targetTestSet.TestSetFolder as ITestSetFolder; + + if (folder != null) + foldername = folder.Name.Replace(".", "_"); + + //the test group is it's test set. (dots are problematic since jenkins parses them as seperators between packadge and class) + activeTestDesc.TestGroup = foldername + "\\" + targetTestSet.Name; + activeTestDesc.TestGroup = activeTestDesc.TestGroup.Replace(".", "_"); + } + + TestState enmState = GetTsStateFromQcState(testExecStatusObj.Status as string); + string statusString = enmState.ToString(); + + if (enmState == TestState.Running) + { + ConsoleWriter.WriteLine("Test: " + activeTestDesc.TestName + ", Id: " + testExecStatusObj.TSTestId + ", Execution status: " + statusString); + } + else if (enmState != TestState.Waiting) + { + ConsoleWriter.WriteLine("Test: " + activeTestDesc.TestName + ", Id: " + testExecStatusObj.TSTestId + ", Execution status: " + statusString + ", Message: " + testExecStatusObj.Message); + } + } + } + + //wait 0.2 seconds + Thread.Sleep(200); + + string abortFilename = System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\stop" + Launcher.UniqueTimeStamp + ".txt"; + + //check for abortion + if (System.IO.File.Exists(abortFilename)) + { + _blnRunCancelled = true; + + ConsoleWriter.WriteLine("Test run Was aborted by user, stopping all tests."); + + //remove the file (got the message) + System.IO.File.Delete(abortFilename); + + //stop all test instances in this testSet. + Scheduler.Stop(currentTestSetInstances); + + //stop working + Environment.Exit((int)Launcher.ExitCodeEnum.Aborted); + } + } + + //check status for each test + if (timeout == -1 || sw.Elapsed.TotalSeconds < timeout) + { + //close last test + if (prevTest != null) + { + WriteTestRunSummary(prevTest); + } + + //done with all tests, stop collecting output in the testRun object. + ConsoleWriter.ActiveTestRun = null; + for (int k = 1; k <= executionStatus.Count; ++k) + { + TestExecStatus testExecStatusObj = executionStatus[k]; + activeTestDesc = UpdateTestStatus(runDesc, targetTestSet, testExecStatusObj, false); + + UpdateCounters(activeTestDesc, runDesc); + + currentTest = targetTestSet.TSTestFactory[testExecStatusObj.TSTestId]; + + string testPath = "Root\\" + tsFolderName + "\\" + tsName + "\\" + activeTestDesc.TestName; + + activeTestDesc.TestPath = testPath; + activeTestDesc.Runtime = testSw.Elapsed; + } + + //update the total runtime + runDesc.TotalRunTime = sw.Elapsed; + + ConsoleWriter.WriteLine("Test set: " + tsName + ", finished at " + DateTime.Now.ToString(Launcher.DateFormat)); + } + else + { + _blnRunCancelled = true; + ConsoleWriter.WriteLine("==============\nJob timed out!\n=============="); + Launcher.ExitCode = Launcher.ExitCodeEnum.Aborted; + } + + return runDesc; + } + + /// + /// writes a summary of the test run after it's over + /// + /// + private void WriteTestRunSummary(ITSTest prevTest) + { + int prevRunId = ConsoleWriter.ActiveTestRun.PrevRunId; + + int runid = GetTestRunId(prevTest); + if (runid > prevRunId) + { + string stepsString = GetTestStepsDescFromQc(prevTest); + + if (string.IsNullOrWhiteSpace(stepsString) && ConsoleWriter.ActiveTestRun.TestState != TestState.Error) + stepsString = GetTestRunLog(prevTest); + + if (!string.IsNullOrWhiteSpace(stepsString)) + ConsoleWriter.WriteLine(stepsString); + + string linkStr = GetTestRunLink(prevTest, runid); + + ConsoleWriter.WriteLine("\nLink: " + linkStr); + } + ConsoleWriter.WriteLine(DateTime.Now.ToString(Launcher.DateFormat) + " Test complete: " + prevTest.Name + + ((runid > prevRunId) ? ", Run id: " + runid : "") + + "\n-------------------------------------------------------------------------------------------------------"); + } + + /// + /// gets a link string for the test run in Qc + /// + /// + /// + /// + private string GetTestRunLink(ITSTest prevTest, int runid) + { + bool oldQc = CheckIsOldQc(); + ITestSet set = prevTest.TestSet; + string testRunLink = "td://" + m_qcProject + "." + m_qcDomain + "." + m_qcServer.Replace("http://", "") + "/TestLabModule-000000003649890581?EntityType=IRun&EntityID=" + runid; + string testRunLinkQc10 = "td://" + m_qcProject + "." + m_qcDomain + "." + m_qcServer.Replace("http://", "") + "/Test%20Lab?Action=FindRun&TestSetID=" + set.ID + "&TestInstanceID=" + prevTest.ID + "&RunID=" + runid; + string linkStr = (oldQc ? testRunLinkQc10 : testRunLink); + return linkStr; + } + + private string GetAlmNotInstalledError() + { + return "Could not create scheduler, please verify ALM client installation on run machine by downloading and in installing the add-in form: " + GetQcCommonInstallationURl(m_qcServer); + } + + /// + /// summerizes test steps after test has run + /// + /// + /// a string containing descriptions of step states and messags + string GetTestStepsDescFromQc(ITSTest test) + { + StringBuilder sb = new StringBuilder(); + try + { + //get runs for the test + RunFactory rfactory = test.RunFactory; + List runs = rfactory.NewList(""); + if (runs.Count == 0) + return ""; + + //get steps from run + StepFactory stepFact = runs[runs.Count].StepFactory; + List steps = stepFact.NewList(""); + if (steps.Count == 0) + return ""; + + //go over steps and format a string + foreach (IStep step in steps) + { + sb.Append("Step: " + step.Name); + + if (!string.IsNullOrWhiteSpace(step.Status)) + sb.Append(", Status: " + step.Status); + + string desc = step["ST_DESCRIPTION"] as string; + desc = "\n\t" + desc.Trim().Replace("\n", "\t").Replace("\r", ""); + if (!string.IsNullOrWhiteSpace(desc)) + sb.AppendLine(desc); + + //step["ST_EXPECTED"]; + //step["ST_ACTUAL"]; + } + } + catch (Exception ex) + { + sb.AppendLine("Exception while reading step data: " + ex.Message); + } + return sb.ToString().TrimEnd(); + } + + private void UpdateCounters(TestRunResults test, TestSuiteRunResults testSuite) + { + if (test.TestState != TestState.Running && + test.TestState != TestState.Waiting && + test.TestState != TestState.Unknown) + ++testSuite.NumTests; + + if (test.TestState == TestState.Failed) + ++testSuite.NumFailures; + + if (test.TestState == TestState.Error) + ++testSuite.NumErrors; + } + + /// + /// translate the qc states into a state enum + /// + /// + /// + private TestState GetTsStateFromQcState(string qcTestStatus) + { + if (qcTestStatus == null) + return TestState.Unknown; + switch (qcTestStatus) + { + case "Waiting": + return TestState.Waiting; + case "Error": + return TestState.Error; + case "No Run": + return TestState.NoRun; + case "Running": + case "Connecting": + return TestState.Running; + case "Success": + case "Finished": + case "FinishedPassed": + return TestState.Passed; + case "FinishedFailed": + return TestState.Failed; + } + return TestState.Unknown; + } + + /// + /// updates the test status in our list of tests + /// + /// + /// + private TestRunResults UpdateTestStatus(TestSuiteRunResults runResults, ITestSet targetTestSet, TestExecStatus testExecStatusObj, bool onlyUpdateState) + { + TestRunResults qTest = null; + ITSTest currentTest = null; + try + { + //find the test for the given status object + currentTest = targetTestSet.TSTestFactory[testExecStatusObj.TSTestId]; + + //find the test in our list + int testIndex = GetIdxByTestName(currentTest.Name, runResults); + qTest = runResults.TestRuns[testIndex]; + + if (qTest.TestType == null) + { + qTest.TestType = GetTestType(currentTest); + } + + //update the state + qTest.PrevTestState = qTest.TestState; + qTest.TestState = GetTsStateFromQcState(testExecStatusObj.Status); + + if (!onlyUpdateState) + { + try + { + //duration and status are updated according to the run + qTest.Runtime = TimeSpan.FromSeconds(currentTest.LastRun.Field("RN_DURATION")); + } + catch + { + //a problem getting duration, maybe the test isn't done yet - don't stop the flow.. + } + + switch (qTest.TestState) + { + case TestState.Failed: + qTest.FailureDesc = GenerateFailedLog(currentTest.LastRun); + + if (string.IsNullOrWhiteSpace(qTest.FailureDesc)) + qTest.FailureDesc = testExecStatusObj.Status + " : " + testExecStatusObj.Message; + break; + case TestState.Error: + qTest.ErrorDesc = testExecStatusObj.Status + " : " + testExecStatusObj.Message; + break; + default: + break; + } + + //check qc version for link type + bool oldQc = CheckIsOldQc(); + + //string testLink = " Alm link"; + string serverURl = m_qcServer.TrimEnd("/".ToCharArray()); + if (serverURl.ToLower().StartsWith("http://")) + serverURl = serverURl.Substring(7); + + //string testLinkInLabQc10 = "td://" + m_qcProject + "." + m_qcDomain + "." + m_qcServer.Replace("http://", "") + "/Test%20Lab?Action=FindTestInstance&TestSetID=" + targetTestSet.ID + "&TestInstanceID=" + testExecStatusObj.TSTestId; + //string testLinkInLab = "td://" + m_qcProject + "." + m_qcDomain + "." + m_qcServer.Replace("http://", "") + "/TestLabModule-000000003649890581?EntityType=ITestInstance&EntityID=" + testExecStatusObj.TSTestId; + + int runid = GetTestRunId(currentTest); + string linkStr = GetTestRunLink(currentTest, runid); + + string statusString = GetTsStateFromQcState(testExecStatusObj.Status as string).ToString(); + ConsoleWriter.WriteLine("Test: " + currentTest.Name + ", Status: " + statusString + ", Message: " + testExecStatusObj.Message + "\nLink: " + linkStr + "\n"); + runResults.TestRuns[testIndex] = qTest; + } + } + catch (Exception ex) + { + ConsoleWriter.WriteLine("Problem on updating tests status for test: " + currentTest.Name + "\n " + ex.Message); + } + + return qTest; + } + + /// + /// gets the runId for the given test + /// + /// a test instance + /// the run id + private static int GetTestRunId(ITSTest currentTest) + { + int runid = -1; + IRun lastrun = currentTest.LastRun as IRun; + if (lastrun != null) + runid = lastrun.ID; + return runid; + } + + /// + /// retrieves the run logs for the test when the steps are not reported to Qc (like in ST) + /// + /// + /// the test run log + private string GetTestRunLog(ITSTest currentTest) + { + string TestLog = "log\\vtd_user.log"; + + IRun lastrun = currentTest.LastRun as IRun; + string retVal = ""; + if (lastrun != null) + { + try + { + IExtendedStorage storage = lastrun.ExtendedStorage as IExtendedStorage; + + List list; + bool wasFatalError; + var path = storage.LoadEx(TestLog, true, out list, out wasFatalError); + string logPath = Path.Combine(path, TestLog); + + if (File.Exists(logPath)) + { + retVal = File.ReadAllText(logPath).TrimEnd(); + } + } + catch + { + retVal = ""; + } + } + retVal = ConsoleWriter.FilterXmlProblematicChars(retVal); + return retVal; + } + + /// + /// checks Qc version (used for link format, 10 and smaller is old) + /// + /// true if this QC is an old one + private bool CheckIsOldQc() + { + string ver = null; + int intver = -1; + string build = null; + TdConnection.GetTDVersion(out ver, out build); + bool oldQc = false; + if (ver != null) + { + int.TryParse(ver, out intver); + if (intver <= 10) + oldQc = true; + } + else + { + oldQc = true; + } + return oldQc; + } + + /// + /// gets the type for a QC test + /// + /// + /// + private string GetTestType(dynamic currentTest) + { + string ttype = currentTest.Test.Type; + if (ttype.ToUpper() == "SERVICE-TEST") + { + ttype = TestType.ST.ToString(); + } + else + { + ttype = TestType.QTP.ToString(); + } + return ttype; + } + + /// + /// connects to QC and logs in + /// + /// + /// + /// + /// + /// + /// + public bool ConnectToProject(string QCServerURL, string QCLogin, string QCPass, string QCDomain, string QCProject) + { + if (string.IsNullOrWhiteSpace(QCServerURL) + || string.IsNullOrWhiteSpace(QCLogin) + || string.IsNullOrWhiteSpace(QCDomain) + || string.IsNullOrWhiteSpace(QCProject)) + { + ConsoleWriter.WriteLine("One or more of the required connection parameters is empty"); + return false; + } + + try + { + TdConnection.InitConnectionEx(QCServerURL); + } + catch (Exception ex) + { + ConsoleWriter.WriteLine(ex.Message); + } + + if (!TdConnection.Connected) + { + ConsoleWriter.WriteErrLine(string.Format("ALM server {0} unreachable, check that server Url is correct", QCServerURL)); + return false; + } + try + { + TdConnection.Login(QCLogin, QCPass); + } + catch (Exception ex) + { + ConsoleWriter.WriteLine(ex.Message); + } + + if (!TdConnection.LoggedIn) + { + ConsoleWriter.WriteErrLine("Cannot Login to QC: Authorization failed"); + return false; + } + + try + { + TdConnection.Connect(QCDomain, QCProject); + } + catch (Exception ex) + { + //ConsoleWriter.WriteErrLine(ex.Message); + } + + if (!TdConnection.ProjectConnected) + { + ConsoleWriter.WriteErrLine("Cannot connect to QC: Project / Domain doesn't exist"); + return false; + } + return true; + } + + private string GetQcCommonInstallationURl(string QCServerURL) + { + return QCServerURL + "/TDConnectivity_index.html"; + } + + #region IDisposable Members + + public void Dispose(bool managed) + { + if (Connected) + { + tdConnection.Disconnect(); + Marshal.ReleaseComObject(tdConnection); + } + } + + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + #endregion + + + } + + public class QCFailure + { + public string Name { get; set; } + public string Desc { get; set; } + } + + public enum QcRunMode + { + RUN_LOCAL, + RUN_REMOTE, + RUN_PLANNED_HOST + } +} diff --git a/HpToolsLauncher/Runners/FileSystemTestsRunner.cs b/HpToolsLauncher/Runners/FileSystemTestsRunner.cs new file mode 100644 index 0000000000..8deb2f490a --- /dev/null +++ b/HpToolsLauncher/Runners/FileSystemTestsRunner.cs @@ -0,0 +1,361 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Diagnostics; +using HpToolsLauncher.Properties; + +namespace HpToolsLauncher +{ + public class FileSystemTestsRunner : RunnerBase, IDisposable + { + #region Members + + + private List _tests; + private static string _uftViewerPath; + private int _errors, _fail; + private bool _useUFTLicense; + private TimeSpan _timeout = TimeSpan.MaxValue; + private Stopwatch _stopwatch = null; + private string _abortFilename = System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\stop" + Launcher.UniqueTimeStamp + ".txt"; + + //saves runners for cleaning up at the end. + private Dictionary _colRunnersForCleanup = new Dictionary(); + + + public const string UftJUnitRportName = "uftRunnerRoot"; + + #endregion + + /// + /// creates instance of the runner given a source. + /// + /// + /// + /// + /// + public FileSystemTestsRunner(List sources, + TimeSpan timeout, + bool useUFTLicense = false + ) + { + + //search if we have any testing tools installed + if (!Helper.IsTestingToolsInstalled(TestStorageType.FileSystem)) + { + ConsoleWriter.WriteErrLine(Resources.FileSystemTestsRunner_No_HP_testing_tool_is_installed_on + System.Environment.MachineName); + Environment.Exit((int)Launcher.ExitCodeEnum.Failed); + } + + _timeout = timeout; + _stopwatch = Stopwatch.StartNew(); + + _useUFTLicense = useUFTLicense; + _tests = new List(); + + List testGroup; + + //go over all sources, and create a list of all tests + foreach (string source in sources) + { + + try + { + //--handle directories which contain test subdirs (recursively) + if (Helper.IsDirectory(source)) + { + + testGroup = Helper.GetTestsLocations(source); + } + //--handle mtb files (which contain links to tests) + else + { + testGroup = new List(); + if (source.TrimEnd().EndsWith(".mtb", StringComparison.CurrentCultureIgnoreCase)) + { + IMtbManager manager = new MtbManager(); + testGroup = manager.Parse(source); + } + } + } + catch (Exception) + { + testGroup = new List(); + } + + //add all tests in group, with the root directory as a group + if (testGroup.Count > 1) + { + testGroup.ForEach(t => + { + _tests.Add(new TestInstance(t, source.TrimEnd("\\/".ToCharArray()).Replace(".", "_"))); + }); + } + + //--handle single test dir, add it with no group + else if (testGroup.Count == 1) + { + _tests.Add(new TestInstance(testGroup[0], "")); + } + } + + if (_tests == null || _tests.Count == 0) + { + ConsoleWriter.WriteLine("===============================\nThere are no valid tests to run!\n==============================="); + Environment.Exit((int)Launcher.ExitCodeEnum.Failed); + } + + ConsoleWriter.WriteLine(_tests.Count + " tests found:"); + _tests.ForEach(t => ConsoleWriter.WriteLine("" + t.TestName)); + ConsoleWriter.WriteLine("================================================"); + } + + /// + /// runs all tests given to this runner and returns a suite of run resutls + /// + /// The rest run results for each test + public override TestSuiteRunResults Run() + { + //create a new Run Results object + TestSuiteRunResults activeRunDesc = new TestSuiteRunResults(); + + double totalTime = 0; + try + { + var start = DateTime.Now; + foreach (var test in _tests) + { + if (RunCancelled()) break; + + var testStart = DateTime.Now; + + string errorReason = string.Empty; + TestRunResults runResult = null; + try + { + runResult = RunUftTest(test.TestName, ref errorReason); + } + catch (Exception ex) + { + runResult = new TestRunResults(); + runResult.TestState = TestState.Error; + runResult.ErrorDesc = ex.Message; + runResult.TestName = test.TestName; + } + + //get the original source for this test, for grouping tests under test classes + runResult.TestGroup = test.TestSource; + + activeRunDesc.TestRuns.Add(runResult); + + //if fail was dtermind before this step, continue + if (runResult.TestState != TestState.Failed) + { + if (runResult.TestState != TestState.Error) + { + Helper.GetTestStateFromReport(runResult); + } + else + { + if (string.IsNullOrEmpty(runResult.ErrorDesc)) + { + if (RunCancelled()) + { + runResult.ErrorDesc = HpToolsLauncher.Properties.Resources.ExceptionUserCancelled; + } + else + { + runResult.ErrorDesc = HpToolsLauncher.Properties.Resources.ExceptionExternalProcess; + } + } + runResult.ReportLocation = null; + runResult.TestState = TestState.Error; + } + } + + if (runResult.TestState == TestState.Passed && runResult.HasWarnings) + { + ConsoleWriter.WriteLine("Test result: Succeeded with Warnings"); + } + else + { + ConsoleWriter.WriteLine("Test result: " + runResult.TestState); + } + + ConsoleWriter.WriteLine(DateTime.Now.ToString(Launcher.DateFormat) + " Test complete: " + runResult.TestPath + "\n-------------------------------------------------------------------------------------------------------"); + + UpdateCounters(runResult.TestState); + var testTotalTime = (DateTime.Now - testStart).TotalSeconds; + } + totalTime = (DateTime.Now - start).TotalSeconds; + } + finally + { + activeRunDesc.NumTests = _tests.Count; + activeRunDesc.NumErrors = _errors; + activeRunDesc.TotalRunTime = TimeSpan.FromSeconds(totalTime); + activeRunDesc.NumFailures = _fail; + + foreach (IFileSysTestRunner cleanupRunner in _colRunnersForCleanup.Values) + { + cleanupRunner.CleanUp(); + } + } + + return activeRunDesc; + } + + /// + /// checks if timeout has expired + /// + /// + private bool CheckTimeout() + { + TimeSpan timeleft = _timeout - _stopwatch.Elapsed; + return (timeleft > TimeSpan.Zero); + } + + /// + /// creates a correct type of runner and runs a single test. + /// + /// + /// + /// + private TestRunResults RunUftTest(string testPath, ref string errorReason) + { + var type = Helper.GetTestType(testPath); + IFileSysTestRunner runner = null; + switch (type) + { + case TestType.ST: + runner = new ApiTestRunner(this, _timeout - _stopwatch.Elapsed); + break; + case TestType.QTP: + runner = new GuiTestRunner(this, _useUFTLicense, _timeout - _stopwatch.Elapsed); + break; + } + + + if (runner != null) + { + if (!_colRunnersForCleanup.ContainsKey(type)) + _colRunnersForCleanup.Add(type, runner); + + Stopwatch s = Stopwatch.StartNew(); + var results = runner.RunTest(testPath, ref errorReason, RunCancelled); + results.Runtime = s.Elapsed; + + + return results; + } + + //check for abortion + if (System.IO.File.Exists(_abortFilename)) + { + + ConsoleWriter.WriteLine("Test run Was aborted by user, stopping all tests."); + + //remove the file (got the message) + System.IO.File.Delete(_abortFilename); + + //stop working + Environment.Exit((int)Launcher.ExitCodeEnum.Aborted); + } + + return new TestRunResults { ErrorDesc = "Unknown TestType", TestState = TestState.Error }; + } + + + /// + /// checks if run was cancelled/aborted + /// + /// + public bool RunCancelled() + { + //if timeout has passed + if (_stopwatch.Elapsed > _timeout) + { + if (!_blnRunCancelled) + { + ConsoleWriter.WriteLine("==============\nJob timed out!\n=============="); + + Launcher.ExitCode = Launcher.ExitCodeEnum.Aborted; + _blnRunCancelled = true; + } + } + + if (System.IO.File.Exists(_abortFilename)) + { + if (!_blnRunCancelled) + { + ConsoleWriter.WriteLine("========================\nJob was aborted by user!\n========================"); + Launcher.ExitCode = Launcher.ExitCodeEnum.Aborted; + _blnRunCancelled = true; + } + } + return _blnRunCancelled; + } + + /// + /// sums errors and failed tests + /// + /// + private void UpdateCounters(TestState testState) + { + switch (testState) + { + case TestState.Error: + _errors += 1; + break; + case TestState.Failed: + _fail += 1; + break; + } + } + + + /// + /// Opens the report viewer for the given report directory + /// + /// + public static void OpenReport(string reportDirectory) + { + Helper.OpenReport(reportDirectory, ref _uftViewerPath); + } + + /// + /// an internall class which holds info about the test instance before it's run, mainly used for describing it's group + /// + private class TestInstance + { + string m_testName; + + public string TestName + { + get { return m_testName; } + set { m_testName = value; } + } + string m_testSource; + + public string TestSource + { + get { return m_testSource; } + set { m_testSource = value; } + } + + public TestInstance(string testName, string source) + { + TestName = testName; + m_testSource = source; + } + } + } +} diff --git a/HpToolsLauncher/Runners/RunnerBase.cs b/HpToolsLauncher/Runners/RunnerBase.cs new file mode 100644 index 0000000000..7029dc0a25 --- /dev/null +++ b/HpToolsLauncher/Runners/RunnerBase.cs @@ -0,0 +1,33 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace HpToolsLauncher +{ + public class RunnerBase: IAssetRunner + { + + public void Dispose() + { + } + protected bool _blnRunCancelled = false; + + public bool RunWasCancelled + { + get { return _blnRunCancelled; } + set { _blnRunCancelled = value; } + } + + public virtual TestSuiteRunResults Run() + { + throw new NotImplementedException(); + } + + } +} diff --git a/HpToolsLauncher/TestRunResults.cs b/HpToolsLauncher/TestRunResults.cs new file mode 100644 index 0000000000..8323f062c7 --- /dev/null +++ b/HpToolsLauncher/TestRunResults.cs @@ -0,0 +1,50 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace HpToolsLauncher +{ + public class TestRunResults + { + private TestState m_enmTestState = TestState.Unknown; + private TestState m_enmPrevTestState = TestState.Unknown; + private bool m_hasWarnings = false; + + public bool HasWarnings + { + get { return m_hasWarnings; } + set { m_hasWarnings = value; } + } + + public string TestPath { get; set; } + public string TestName { get; set; } + public string TestGroup { get; set; } + public string ErrorDesc { get; set; } + public string FailureDesc { get; set; } + public string ConsoleOut { get; set; } + public string ConsoleErr { get; set; } + public TimeSpan Runtime { get; set; } + public string TestType { get; set; } + public string ReportLocation { get; set; } + + public TestState TestState + { + get { return m_enmTestState; } + set { m_enmTestState = value; } + } + + public TestState PrevTestState + { + get { return m_enmPrevTestState; } + set { m_enmPrevTestState = value; } + } + + public int PrevRunId { get; set; } + } +} diff --git a/HpToolsLauncher/TestRunners/ApiTestRunner.cs b/HpToolsLauncher/TestRunners/ApiTestRunner.cs new file mode 100644 index 0000000000..d548ba83b5 --- /dev/null +++ b/HpToolsLauncher/TestRunners/ApiTestRunner.cs @@ -0,0 +1,289 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +using System; +using System.Diagnostics; +using System.IO; +using HpToolsLauncher.Properties; + +namespace HpToolsLauncher +{ + public class ApiTestRunner : IFileSysTestRunner + { + public const string STRunnerName = "ServiceTestExecuter.exe"; + public const string STRunnerTestArg = @"-test"; + public const string STRunnerReportArg = @"-report"; + + private const int PollingTimeMs = 500; + private bool _stCanRun; + private string _stExecuterPath = Directory.GetCurrentDirectory(); + private readonly IAssetRunner _runner; + private TimeSpan _timeout = TimeSpan.MaxValue; + private Stopwatch _stopwatch = null; + private RunCancelledDelegate _runCancelled; + + /// + /// constructor + /// + /// parent runner + /// the global timout + public ApiTestRunner(IAssetRunner runner, TimeSpan timeout) + { + _stopwatch = Stopwatch.StartNew(); + _timeout = timeout; + _stCanRun = TrySetSTRunner(); + _runner = runner; + } + + /// + /// Search ServiceTestExecuter.exe in the current running process directory, + /// and if not found, in the installation folder (taken from registry) + /// + /// + public bool TrySetSTRunner() + { + if (File.Exists(STRunnerName)) + return true; + _stExecuterPath = Helper.GetInstallPath(); + if ((!String.IsNullOrEmpty(_stExecuterPath))) + { + _stExecuterPath += "bin"; + return true; + } + _stCanRun = false; + return false; + } + + /// + /// runs the given test + /// + /// + /// + /// cancellation delegate, holds the function that checks cancellation + /// + public TestRunResults RunTest(string testPath, ref string errorReason, RunCancelledDelegate runCancelled) + { + + + TestRunResults runDesc = new TestRunResults(); + ConsoleWriter.ActiveTestRun = runDesc; + ConsoleWriter.WriteLine(DateTime.Now.ToString(Launcher.DateFormat) + " Running: " + testPath); + + + + runDesc.ReportLocation = Helper.CreateTempDir(); + runDesc.ErrorDesc = errorReason; + runDesc.TestPath = testPath; + runDesc.TestState = TestState.Unknown; + if (!Helper.IsServiceTestInstalled()) + { + runDesc.TestState = TestState.Error; + runDesc.ErrorDesc = "Service Test is not installed on " + System.Environment.MachineName; + ConsoleWriter.WriteErrLine(runDesc.ErrorDesc); + Environment.ExitCode = (int)Launcher.ExitCodeEnum.Failed; + return runDesc; + } + + _runCancelled = runCancelled; + if (!_stCanRun) + { + runDesc.TestState = TestState.Error; + runDesc.ErrorDesc = Resources.STExecuterNotFound; + return runDesc; + } + string fileName = Path.Combine(_stExecuterPath, STRunnerName); + + if (!File.Exists(fileName)) + { + runDesc.TestState = TestState.Error; + runDesc.ErrorDesc = Resources.STExecuterNotFound; + ConsoleWriter.WriteErrLine(Resources.STExecuterNotFound); + return runDesc; + } + + Stopwatch s = Stopwatch.StartNew(); + runDesc.TestState = TestState.Running; + if (!ExecuteProcess(fileName, + String.Format("{0} \"{1}\" {2} \"{3}\" ", STRunnerTestArg, testPath, STRunnerReportArg, runDesc.ReportLocation), + ref errorReason)) + { + runDesc.TestState = TestState.Error; + runDesc.ErrorDesc = errorReason; + runDesc.Runtime = s.Elapsed; + return runDesc; + } + else + { + runDesc.ReportLocation = Path.Combine(runDesc.ReportLocation, "Report"); + } + + runDesc.Runtime = s.Elapsed; + return runDesc; + } + + /// + /// performs global cleanup code for this type of runner + /// + public void CleanUp() + { + } + + #region Process + + /// + /// executes the run of the test by using the Init and RunProcss routines + /// + /// + /// + /// + /// + private bool ExecuteProcess(string fileName, string arguments, ref string failureReason) + { + Process proc = null; + try + { + using (proc = new Process()) + { + InitProcess(proc, fileName, arguments, true); + RunProcess(proc, true); + + //it could be that the process already existed + //before we could handle the cancel request + if (_runCancelled()) + { + failureReason = "Process was stopped since job has timed out!"; + ConsoleWriter.WriteLine(failureReason); + + if (!proc.HasExited) + { + + proc.OutputDataReceived -= OnOutputDataReceived; + proc.ErrorDataReceived -= OnErrorDataReceived; + proc.Kill(); + return false; + } + } + if (proc.ExitCode != 0) + { + failureReason = "The Api test runner's exit code was: " + proc.ExitCode; + ConsoleWriter.WriteLine(failureReason); + return false; + } + } + } + catch (Exception e) + { + failureReason = e.Message; + return false; + } + finally + { + if (proc != null) + { + proc.Close(); + } + } + + return true; + } + + /// + /// initializes the ServiceTestExecuter process + /// + /// + /// + /// + /// + private void InitProcess(Process proc, string fileName, string arguments, bool enableRedirection) + { + var processStartInfo = new ProcessStartInfo + { + FileName = fileName, + Arguments = arguments, + WorkingDirectory = Directory.GetCurrentDirectory() + }; + + if (!enableRedirection) return; + + processStartInfo.ErrorDialog = false; + processStartInfo.UseShellExecute = false; + processStartInfo.RedirectStandardOutput = true; + processStartInfo.RedirectStandardError = true; + + proc.StartInfo = processStartInfo; + + proc.EnableRaisingEvents = true; + proc.StartInfo.CreateNoWindow = true; + + proc.OutputDataReceived += OnOutputDataReceived; + proc.ErrorDataReceived += OnErrorDataReceived; + } + + /// + /// runs the ServiceTestExecuter process after initialization + /// + /// + /// + private void RunProcess(Process proc, bool enableRedirection) + { + proc.Start(); + if (enableRedirection) + { + proc.BeginOutputReadLine(); + proc.BeginErrorReadLine(); + } + proc.WaitForExit(PollingTimeMs); + while (!_runCancelled() && !proc.HasExited) + { + proc.WaitForExit(PollingTimeMs); + } + } + + /// + /// callback function for spawnd process errors + /// + /// + /// + private void OnErrorDataReceived(object sender, DataReceivedEventArgs e) + { + var p = sender as Process; + + if (p == null) return; + try + { + if (!p.HasExited || p.ExitCode == 0) return; + } + catch { return; } + string format = String.Format("{0} {1}: ", DateTime.Now.ToShortDateString(), + DateTime.Now.ToLongTimeString()); + string errorData = e.Data; + + if (String.IsNullOrEmpty(errorData)) + { + errorData = String.Format("External process has exited with code {0}", p.ExitCode); + + } + + ConsoleWriter.WriteErrLine(errorData); + } + + /// + /// callback function for spawnd process output + /// + /// + /// + private void OnOutputDataReceived(object sender, DataReceivedEventArgs e) + { + if (!String.IsNullOrEmpty(e.Data)) + { + string data = e.Data; + ConsoleWriter.WriteLine(data); + } + } + + #endregion + + } +} \ No newline at end of file diff --git a/HpToolsLauncher/TestRunners/GuiTestRunner.cs b/HpToolsLauncher/TestRunners/GuiTestRunner.cs new file mode 100644 index 0000000000..6fae1374fa --- /dev/null +++ b/HpToolsLauncher/TestRunners/GuiTestRunner.cs @@ -0,0 +1,540 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +using System; +using System.Linq; +using System.IO; +using System.Xml; +using QTObjectModelLib; +using Resources = HpToolsLauncher.Properties.Resources; +using System.Threading; +using System.Diagnostics; +using System.Collections.Generic; + +namespace HpToolsLauncher +{ + public class GuiTestRunner : IFileSysTestRunner + { + private readonly IAssetRunner _runNotifier; + private readonly object _lockObject = new object(); + private TimeSpan _timeLeftUntilTimeout = TimeSpan.MaxValue; + private Stopwatch _stopwatch = null; + private Application _qtpApplication; + private ParameterDefinitions _qtpParamDefs; + private Parameters _qtpParameters; + private bool _useUFTLicense; + private RunCancelledDelegate _runCancelled; + + /// + /// constructor + /// + /// + /// + /// + public GuiTestRunner(IAssetRunner runNotifier, bool useUftLicense, TimeSpan timeLeftUntilTimeout) + { + _timeLeftUntilTimeout = timeLeftUntilTimeout; + _stopwatch = Stopwatch.StartNew(); + _runNotifier = runNotifier; + _useUFTLicense = useUftLicense; + } + + #region QTP + + /// + /// runs the given test and returns resutls + /// + /// + /// + /// + /// + public TestRunResults RunTest(string testPath, ref string errorReason, RunCancelledDelegate runCanclled) + { + + TestRunResults runDesc = new TestRunResults(); + ConsoleWriter.ActiveTestRun = runDesc; + ConsoleWriter.WriteLine(DateTime.Now.ToString(Launcher.DateFormat) + " Running: " + testPath); + runDesc.ReportLocation = Helper.CreateTempDir(); + runDesc.TestPath = testPath; + runDesc.TestState = TestState.Unknown; + + _runCancelled = runCanclled; + + if (!Helper.IsQtpInstalled()) + { + runDesc.TestState = TestState.Error; + runDesc.ErrorDesc = "QTP is not installed on " + System.Environment.MachineName; + ConsoleWriter.WriteErrLine(runDesc.ErrorDesc); + Environment.ExitCode = (int)Launcher.ExitCodeEnum.Failed; + return runDesc; + } + + try + { + var type = Type.GetTypeFromProgID("Quicktest.Application"); + + lock (_lockObject) + { + _qtpApplication = Activator.CreateInstance(type) as Application; + + // Check for required Addins + LoadNeededAddins(testPath); + + if (!_qtpApplication.Launched) + { + if (_runCancelled()) + { + QTPTestCleanup(); + runDesc.TestState = TestState.Error; + return runDesc; + } + // Launch application after set Addins + _qtpApplication.Launch(); + _qtpApplication.Visible = false; + + } + } + } + catch (Exception e) + { + errorReason = Resources.QtpNotLaunchedError; + runDesc.TestState = TestState.Error; + runDesc.ReportLocation = ""; + runDesc.ErrorDesc = errorReason; + return runDesc; + } + + if (_qtpApplication.Test != null && _qtpApplication.Test.Modified) + { + var message = Resources.QtpNotLaunchedError; + errorReason = message; + runDesc.TestState = TestState.Error; + runDesc.ErrorDesc = errorReason; + return runDesc; + } + + _qtpApplication.UseLicenseOfType(_useUFTLicense + ? tagUnifiedLicenseType.qtUnifiedFunctionalTesting + : tagUnifiedLicenseType.qtNonUnified); + + if (!HandleInputParameters(testPath, ref errorReason)) + { + runDesc.TestState = TestState.Error; + runDesc.ErrorDesc = errorReason; + return runDesc; + } + + GuiTestRunResult guiTestRunResult = ExecuteQTPRun(runDesc); + runDesc.ReportLocation = guiTestRunResult.ReportPath; + + if (!guiTestRunResult.IsSuccess) + { + runDesc.TestState = TestState.Error; + return runDesc; + } + + if (!HandleOutputArguments(ref errorReason)) + { + runDesc.TestState = TestState.Error; + runDesc.ErrorDesc = errorReason; + return runDesc; + } + + QTPTestCleanup(); + + + return runDesc; + } + + /// + /// performs global cleanup code for this type of runner + /// + public void CleanUp() + { + try + { + //if we don't have a qtp instance, create one + if (_qtpApplication == null) + { + var type = Type.GetTypeFromProgID("Quicktest.Application"); + _qtpApplication = Activator.CreateInstance(type) as Application; + } + + //if the app is running, close it. + if (_qtpApplication.Launched) + _qtpApplication.Quit(); + } + catch + { + //nothing to do. (cleanup code should not throw exceptions, and there is no need to log this as an error in the test) + } + } + + static HashSet _colLoadedAddinNames = null; + /// + /// Set the test Addins + /// + private void LoadNeededAddins(string fileName) + { + bool blnNeedToLoadAddins = false; + + //if not launched, we have no addins. + if (!_qtpApplication.Launched) + _colLoadedAddinNames = null; + + try + { + HashSet colCurrentTestAddins = new HashSet(); + + object erroDescription; + var testAddinsObj = _qtpApplication.GetAssociatedAddinsForTest(fileName); + object[] testAddins = (object[])testAddinsObj; + + foreach (string addin in testAddins) + { + colCurrentTestAddins.Add(addin); + } + + if (_colLoadedAddinNames != null) + { + //check if we have a missing addin (and need to quit Qtp, and reload with new addins) + foreach (string addin in testAddins) + { + if (!_colLoadedAddinNames.Contains(addin)) + { + blnNeedToLoadAddins = true; + break; + } + } + + //check if there is no extra addins that need to be removed + if (_colLoadedAddinNames.Count != colCurrentTestAddins.Count) + { + blnNeedToLoadAddins = true; + } + } + else + { + //first time = load addins. + blnNeedToLoadAddins = true; + } + + _colLoadedAddinNames = colCurrentTestAddins; + + //the addins need to be refreshed, load new addins + if (blnNeedToLoadAddins) + { + if (_qtpApplication.Launched) + _qtpApplication.Quit(); + _qtpApplication.SetActiveAddins(ref testAddinsObj, out erroDescription); + } + + } + catch (Exception) + { + // Try anyway to run the test + } + } + + + /// + /// Activate all Installed Addins + /// + private void ActivateAllAddins() + { + try + { + // Get Addins collection + Addins qtInstalledAddins = _qtpApplication.Addins; + + if (qtInstalledAddins.Count > 0) + { + string[] qtAddins = new string[qtInstalledAddins.Count]; + + // Addins Object is 1 base order + for (int idx = 1; idx <= qtInstalledAddins.Count; ++idx) + { + // Our list is 0 base order + qtAddins[idx - 1] = qtInstalledAddins[idx].Name; + } + + object erroDescription; + var addinNames = (object)qtAddins; + + _qtpApplication.SetActiveAddins(ref addinNames, out erroDescription); + } + } + catch (Exception) + { + // Try anyway to run the test + } + } + + /// + /// runs the given test QTP and returns results + /// + /// the test results object containing test info and also receiving run results + /// + private GuiTestRunResult ExecuteQTPRun(TestRunResults testResults) + { + GuiTestRunResult result = new GuiTestRunResult { IsSuccess = true }; + try + { + if (Directory.Exists(testResults.ReportLocation)) + { + try + { + Directory.Delete(testResults.ReportLocation, true); + } + catch (Exception) + { + Console.WriteLine("Unable to delete report folder " + testResults.ReportLocation); + } + } + if (!Directory.Exists(testResults.ReportLocation)) Directory.CreateDirectory(testResults.ReportLocation); + Type runResultsOptionstype = Type.GetTypeFromProgID("QuickTest.RunResultsOptions"); + var options = (RunResultsOptions)Activator.CreateInstance(runResultsOptionstype); + options.ResultsLocation = testResults.ReportLocation; + _qtpApplication.Options.Run.RunMode = "Fast"; + + //Check for cancel before executing + if (_runCancelled()) + { + testResults.TestState = TestState.Error; + testResults.ErrorDesc = "Test run was Canceled"; + ConsoleWriter.WriteLine("Test run was Canceled"); + result.IsSuccess = false; + return result; + } + ConsoleWriter.WriteLine("Running Test: " + testResults.TestPath); + + _qtpApplication.Test.Run(options, false, _qtpParameters); + + result.ReportPath = Path.Combine(testResults.ReportLocation, "Report"); + int slept = 0; + while (slept < 20000 && _qtpApplication.GetStatus().Equals("Ready")) + { + Thread.Sleep(50); + slept += 50; + } + + + while (!_runCancelled() && (_qtpApplication.GetStatus().Equals("Running") || _qtpApplication.GetStatus().Equals("Busy"))) + { + Thread.Sleep(200); + if (_timeLeftUntilTimeout - _stopwatch.Elapsed <= TimeSpan.Zero) + { + _qtpApplication.Test.Stop(); + testResults.TestState = TestState.Error; + testResults.ErrorDesc = "Timeout has expired."; + ConsoleWriter.WriteLine("Timeout has expired."); + + result.IsSuccess = false; + return result; + } + } + + if (_runCancelled()) + { + QTPTestCleanup(); + testResults.TestState = TestState.Error; + testResults.ErrorDesc = "Test run was Canceled"; + ConsoleWriter.WriteLine("Test run was Canceled"); + Launcher.ExitCode = Launcher.ExitCodeEnum.Aborted; + result.IsSuccess = false; + return result; + } + string lastError = _qtpApplication.Test.LastRunResults.LastError; + + //read the lastError + if (!String.IsNullOrEmpty(lastError)) + { + testResults.TestState = TestState.Error; + testResults.ErrorDesc = lastError; + } + + // the way to check the logical success of the target QTP test is: app.Test.LastRunResults.Status == "Passed". + if (_qtpApplication.Test.LastRunResults.Status.Equals("Passed")) + { + testResults.TestState = TestState.Passed; + + } + else if (_qtpApplication.Test.LastRunResults.Status.Equals("Warning")) + { + testResults.TestState = TestState.Passed; + testResults.HasWarnings = true; + + if (Launcher.ExitCode != Launcher.ExitCodeEnum.Failed && Launcher.ExitCode != Launcher.ExitCodeEnum.Aborted) + Launcher.ExitCode = Launcher.ExitCodeEnum.Unstable; + } + else + { + testResults.TestState = TestState.Failed; + testResults.FailureDesc = "Test failed"; + + Launcher.ExitCode = Launcher.ExitCodeEnum.Failed; + } + } + catch (NullReferenceException e) + { + ConsoleWriter.WriteLine("Error: " + e.Message + "\n" + e.StackTrace); + testResults.TestState = TestState.Error; + testResults.ErrorDesc = Resources.QtpRunError; + + result.IsSuccess = false; + return result; + } + catch (SystemException e) + { + KillQtp(); + ConsoleWriter.WriteLine("Error: " + e.Message + "\n" + e.StackTrace); + testResults.TestState = TestState.Error; + testResults.ErrorDesc = Resources.QtpRunError; + + result.IsSuccess = false; + return result; + } + catch (Exception e2) + { + + ConsoleWriter.WriteLine("Error: " + e2.Message + "\n" + e2.StackTrace); + testResults.TestState = TestState.Error; + testResults.ErrorDesc = Resources.QtpRunError; + + result.IsSuccess = false; + return result; + } + + + return result; + } + + private void KillQtp() + { + //error during run, process may have crashed (need to cleanup, close QTP and qtpRemote for next test to run correctly) + CleanUp(); + + //kill the qtp automation, to make sure it will run correctly next time + Process[] processes = Process.GetProcessesByName("qtpAutomationAgent"); + Process qtpAuto = processes.Where(p => p.SessionId == Process.GetCurrentProcess().SessionId).FirstOrDefault(); + if (qtpAuto != null) + qtpAuto.Kill(); + } + + private bool HandleOutputArguments(ref string errorReason) + { + try + { + var outputArguments = new XmlDocument { PreserveWhitespace = true }; + outputArguments.LoadXml(""); + + for (int i = 0; i < _qtpParamDefs.Count; ++i) + { + var pd = _qtpParamDefs[i]; + if (pd.InOut == qtParameterDirection.qtParamDirOut) + { + var node = outputArguments.CreateElement(pd.Name); + var value = _qtpParameters[pd.Name].Value; + if (value != null) + node.InnerText = value.ToString(); + + outputArguments.DocumentElement.AppendChild(node); + } + } + } + catch (Exception e) + { + errorReason = Resources.QtpNotLaunchedError; + return false; + } + return true; + } + + private bool HandleInputParameters(string fileName, ref string errorReason) + { + try + { + string path = fileName; + + if (_runCancelled()) + { + QTPTestCleanup(); + return false; + } + + _qtpApplication.Open(path, true, false); + _qtpParamDefs = _qtpApplication.Test.ParameterDefinitions; + _qtpParameters = _qtpParamDefs.GetParameters(); + } + catch (Exception e) + { + errorReason = Resources.QtpRunError; + return false; + } + return true; + + } + + /// + /// stops and closes qtp test, to make sure nothing is left floating after run. + /// + private void QTPTestCleanup() + { + try + { + lock (_lockObject) + { + if (_qtpApplication == null) + { + return; + } + + var qtpTest = _qtpApplication.Test; + if (qtpTest != null) + { + if (_qtpApplication.GetStatus().Equals("Running") || _qtpApplication.GetStatus().Equals("Busy")) + { + try + { + _qtpApplication.Test.Stop(); + } + catch (Exception e) + { + } + finally + { + + } + } + } + } + } + catch (Exception ex) + { + } + + _qtpParameters = null; + _qtpParamDefs = null; + _qtpApplication = null; + } + + #endregion + + + /// + /// holds the resutls for a GUI test + /// + private class GuiTestRunResult + { + public GuiTestRunResult() + { + ReportPath = ""; + } + + public bool IsSuccess { get; set; } + public string ReportPath { get; set; } + } + } +} diff --git a/HpToolsLauncher/TestSuiteRunResults.cs b/HpToolsLauncher/TestSuiteRunResults.cs new file mode 100644 index 0000000000..f953bcfe33 --- /dev/null +++ b/HpToolsLauncher/TestSuiteRunResults.cs @@ -0,0 +1,63 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace HpToolsLauncher +{ + public class TestSuiteRunResults + { + private List m_testRuns = new List(); + private int m_numErrors = 0; + private int m_numFailures = 0; + private int m_numTests = 0; + private TimeSpan m_totalRunTime = TimeSpan.Zero; + + public string SuiteName { get; set; } + + public int NumFailures + { + get { return m_numFailures; } + set { m_numFailures = value; } + } + + public int NumTests + { + get { return m_numTests; } + set { m_numTests = value; } + } + + public TimeSpan TotalRunTime + { + get { return m_totalRunTime; } + set { m_totalRunTime = value; } + } + + public List TestRuns + { + get { return m_testRuns; } + set { m_testRuns = value; } + } + + public int NumErrors + { + get { return m_numErrors; } + set { m_numErrors = value; } + } + + + internal void AppendResults(TestSuiteRunResults desc) + { + this.TestRuns.AddRange(desc.TestRuns); + this.TotalRunTime += desc.TotalRunTime; + this.NumErrors += desc.NumErrors; + this.NumFailures += desc.NumFailures; + this.NumTests += desc.NumTests; + } + } +} diff --git a/HpToolsLauncher/app.config b/HpToolsLauncher/app.config new file mode 100644 index 0000000000..e365603337 --- /dev/null +++ b/HpToolsLauncher/app.config @@ -0,0 +1,3 @@ + + + diff --git a/HpToolsLauncher/externals/QTObjectModelLib.dll b/HpToolsLauncher/externals/QTObjectModelLib.dll new file mode 100644 index 0000000000000000000000000000000000000000..6acbfdab00561a8ccb479f089e2feea90cbf9017 GIT binary patch literal 77824 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%0Dm(m7PjyOVjSGL~S!dLYaA8_`7lkK! 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 yEeV{}XMu1eVfvd&U@C#B1f~+0N?J#?1 zBg)#lT&heI6;z>rqINh?w>uGHbkHlxxM_>W4~%A0JL$(Su0r$bbS@L(G4d7!{`vHP zDp5adQNQzXAi~elRidN!A~LK>R6c0`6D)`#nt}b4A>PAS6g8VVYWh^-T`TLn3S`{Q zf+-GbHhIeAlSt&T(HJqes0E?>=|rP%HhI*^g=FNh(wNx?zxyFyXGj0u{QC&}eFXkK z0)HQYzmLG*N8s-x@b?k;`w0Af1pYn(e;T3EyZJHIOqqS5+Hhr;jl*?-T zpF>HX9n(MEs?s7IHKW#46jl12I+-~jCo0vpE-A)-&rK1@qJP=+uT)fcb}Gtg(j3l?Gv=UPmusFjOpM74EU46}g5Xx3nkiK42rFbC*W zXUQ0_g&uXxX_{;n&9`dV0#xT0)u!o}FTWwCveY?s6KYqE`B4HUGH?L2Jn zl^U2g;8)nQs()lj?PLmX!g)I664;vSuC57>PLmPB}Gsc6S+CHbz z+;3qG>Y{7`Nl`ieZ%(^AX`6=!cj>}C$uM<7I?5_vhCkd@51l~<*~U0|{Dn2iRY1Q_ zi-vM9haQ*gggy%VNt=l&mzjx=S|J_LvN;9#q_l4x+-Pn@pQo}7FoLRfz^n4XZiCZR znnMPbE1lEvxZS&VXC4f?8pH9}_HleX{x6)LaBY;J^MfIU^Am0#|IeNuxd+lMx#V0w z7*aSt;TB!;&rg*Wr6T-lm@ZYhpM>WIU;cFEr)J@X*`yXd3$G<#@%s)g>$YRUMUM0F z2lt&ezTMw<>|W_^9PTdg4BZ9HA~%n1c!o6CM*oS5-5>fyDNKg$mow%@Is4G)aqm3$ zV!2mTX^|BnLkM#%oKE*^^xmir-IbcqGrLsO(6!Gz5mU40E|@)cJL0*UkC;?M(bnh8 zp@_k~jE4w^*b`*1uH!A&-xve@PZZgvVJp;`Dl3Un1h95QrO4(&&ZF)Bx1lU zrthEaXKW${%wqc4ezGF^48_NC9AfYZ;`0TDn8NMXg!v4v|^G+dFgh3ieWa5c#mt`*smD*>_c`No!fYOy7s zMQq8Z3|sP^JX{+rmTfwWQNcvnE{kpY2M^ZQRp%$@*H8Gpb_qH^7*aStVX3C1ou9w#_d8*=p#+^D3@MzS zupCy>&d*VQ)%`830hOThgCT|U6P6uI+WDFCSDl}*GFO7m4~7)ZPgvS5Y3JuJ`~5*! zFD*gm2SWyl6HP3|5fKFyjxI$&JTtZ&QEwn zq@)_Y{1jiG`w!l�w|(Ze{WJHt-rm{B9-A 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¬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

DLd+ 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

JG#RTT#Cexx_${?>BGe*Q1* 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 o2 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%0DRe42u?8; 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

bPj*+ip7s#(j_f>^A<4-Q_GHewUmf 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�uvbRyxnI%6Wm+&P%LuUSX~C8ta@lSns^W2In0% zI`6T``GC#NM{IFEVbJ*l+ng`h?i78F6FQtB*y#+#F6S%kc7|b(GaP%J5!mO9!hUBo z4me|Q&>4$E&WGqYVc7YIBhDurbw1;m^99G9qF>^K31a1$&QaWUj^U1T z9Cw`)xaXY2ediP&IH&Q@IfF;eSv+>m;TPvTo;Vlqt8)>*IoI&Ja~)5e8<8?$@bl?s znb7(95W7AfVfW`_?D_l!dq1CG-{-H`|M?pZeEyCdpAT^8^A8;U{1Zn$pW*1|a~%78 zf#aVqapLn8PJX_|sn0h!{rMJWKHuT&=X;#{{DAYHA93OH6E1#!#--0Mxcph)MP|3G1$NmrB@hUErqc61QAexb3>e9oG%+ zx^8jLb%*<|dpvMG;Gydgk6cf9?0Uv8t`|IUi3(K0S62vrbA{q}*DE}Ah2alZIR11+ z;2CSs3iSnHueE}?pr=49SPFX4TF{5Kf_}6Y3}Al2AUX?%&{Z&u?t&5Y6pW&`U<`c) zCg$-Mm@!ab!C-+M%M0?cqQHrj1>E^5R26XNr%+wMou5KY0e5~1wFTVyDby8|qp6^q z*%}JM88;S0U{gU9HWx%=OF;~_7Q|v(fdtzNq}Wj)!_I;V>?){yohHl_>=vX6lLcEi zRj`fI1v@xVu!*w;dpK9HkMjiwxKMD2iv>rxRB(*T1z&Kb-~?9-zT#TJH(W3HjvED= zkvieBAl9uDeilUFSwR$@7ewPlK@9#V2*;}e30@aS@uonAw*_*%D^TElff64IRQOn+ z#-{=;J{P3oOF=q{+&T<#>oL@wfv?;K40CTrz88#cliMIz+%~kj?e1*B>2{;b?Qxp~ zpSv9W?g|XJD>3M<;zi7L?k22tH)4&u0qfn(ZmZDh?!-2C7q+{*vBSN}uSSDz_3KYU zpId?bZY2)5RoLs6}+pWMIw-R^V zD%^9cao?@Q19vJOy3_H2IV@WgGvukI}T<~HJYw+T<(X8hsqjdTb<-F&)|!D7Da_~ z7*aTop@j?hs&Em*3fC~aa2+EGHzJ*avrzroDcA}XXfIS^exVAjg>rNiYSCSoik`xB z^cL#SSLi~2p&J8*9t;+GvAi&d6@}%mT|!;qXrW7}E*!#|!eOi}9Kou>L98zv!-m3f zY%H9>rou^VE}X)a!f9+RoWZujS!^$y!;Zpv>?~ZsuEIs^E?mN%!e#6&T*1D=RqQWZ z!-2xh$UEj( zRd`aU#;=8@*M-8jLNk6ZwBTu>9e)(&2in;doaVf%k<`_)r*)kA*S#R2YlTg%W%zl%mKZ!w^puhI*>;m8Sy3Je9A# zLYAk~;}z09EvWOfqTbVn8J>1DcselE(~L$>7n(fXX!i7=#nX#cPaoPmCT6pH%$V=7 zpwnYVmnR?H9w&M{F7$fb=<|5c@9|>56U3mW9LqgnSm6oBN>2nV7_9Zg zVx32V^&TlUkkKnNlFKVJk*h?Q^qhN2gh9^<4tc)fu;&|&c)sJP=M=|0KXBah6DK@p zIN=x&*d$kputlyCVVhhf!VbAggk5r#2z%rz5%$SdA{>ybL^vc@iEu=& z65*I!0pZ$n>j?-qo;%N93ZX@^qQ4X#JyH1NiN&QCDO_ebH6SKNs9ZRYm_?uon5zRun*cQ4sTs%F$U= zfv%!Tv=sT!Q&f%KqMD-rS*R;&$NHiUY$)o)#-c84D(c4Oq8@B1>c!TgK5Q%MFRB#= zi-vKiXr$<`gyo_r?_UYyMGuT8iXL&Y=n1Eao^iV91!syxoHJV#f^$WoIA8P%7mC7g zu_zpuiXw2V=$`XeilP~>7RBINQ7o<(NpPb`ikn3;+$xgec98;iij=rp)EoI%!d_7y z?icmrLD2vn77gN2(GVUN4da)h5j-gx#jizU_^oIhzZXs5Y0)J9D4N2bMbmgzG=t|w zvv^T7hnGe3cvZB3*F}qXQ?!P+MeBH1#1mx&op;FFAZWe)nCczCbnhUly?vYc$h?<}@^=di;&kDcBH?D8&Rw|5PDyzAKO-H7~aVZ(di{cB;;#8Cur=y}+hst6-s){p;|3=6vUPoi` z2AYaD(OkTRmf~%+7Vn^~co*%(dzfFmkIv!)bQK?>yZ8t_#mDF^{(`>Z6Z98<#X#{l z3>JUK^5RphDE@(!#XqsC_zbIy&#|WX0&9yev99x-|kq4)+Hi*K>1_zs(k@3E!$ z0b7e7v90(C+l!yEqxc0oi$%V_5xR;)u)8=Edx~FSZ*gzr-w1uheb`^zj|0U6I9NQ0 zL&ZZlTs({;#UnUcJc?t*V>n(sjuXWbI9WW2Q^iv_T|A95#WOftJd1P1b2wi-j|;^M zxLCZ1OT}xrT)d7e#XKQaSS^BSbqNu^d5rQcV6<-$V|+^(>s!Wf z-yBMPt0?oWq1?BQ3f~4QeVeHAZK2w?jauIhruud<-M5E2-#+Sn2bkeIM1$`LvwX*B z^nF2-?*z@huW0doL#yvQ+I**I_x-?p-%oV<&d}vMN4M_+J-$oy`p%2H1fTB${k}^K z_^vSMyT)?g4OaMWvC?;kRla+y_B~*Y?-6T#Pgv)B#(LiiHuyx$+~^CzCSNEv`(9y- zuQ#$wX!Z4Bo39_+eFNCx8^liE5O(>7vD-I-J-$)w^^IYlZyfu56FA_T#6jN_4*8~W z*f)bCzF8dg&Ec4D9>;wPIN@8wN#7by`POmTw}CT03A;J#lm5~p1WTe{_Xw#a4JAE7 zdPyVdN}5n#(u^4;Eodld#jKJxG?uiZsiXtVC7oy~aWR9n#ErHR586w-m|x;UXNezO zB>{Ao1kqDcj^2_m^p%98za#DOQ)ru%^Tp-6PbN zR4}e9seJvL&|R`q@|)08vWvYXd)Qa9kNqVFI8btkgC$2eRC0{NC0}r)+uwv$viv5jk>xjGoh-iz8)W%S*d)tu!WJoh6Shh5x59HtrT=e*`;q`Y zlmzjyq#U10D)6qvk1r)vDDqchh`$Cy{k8bYUx#7-dJOkBV1&OBqx?-6?Qg~ye+$O? zTT$X~L#e+VW&RG7`#VwL??R=&8&&?^$iEfT{yx>=|2(?<3+VPQqQ}36UjI7!{2P&j zLa%?zKPdG1x3S;9g9H9u9Q5zukbfVC{RcSWKg3c05svwfaoqm}C;YD0gTkcWjZ=OP zPW!z$;}7DjzZ~cMVL0y(#|3``F8ZTz$sdi&{uo^G$KtAAf@^*$uKQ)U;jh3=f92~x z3t^>B{N`7e{#p3$*W#%^6@U2C@uy#hXMR1N`!n#uZ@^1`7GC*{c+G16EZnf#KMS|4 z_Rqo{tNpWZ@Au(@-;a;}06ww)KMT*S|IfmU--M!4GlrB}FtpT;uS)art6#;;;iX}W zBTBw8IU0@vbfeFkAOrjw$g;{}VGzMnS6qrSGU=A&Td9(%=&=y!kdteFk z1HF-Bf-}&Eu0TJ!0|V#@45BwMgucKq`U4{v2#jJdFoxxUajXbTU}azus{&J49hkPG_*_x9oZAB+2{aBU#Bu*4s)}-ahiy=lcEr zbLr8Tc|M=_+x_v^={)a`jp)CZ9EwH7-%C!#61o)2=vI72k75PAidFP0)-a%0$6mz- z_9?z#zoInq@1+4n84fDSaY#{t!wLnCD3my=2*)u+1dc1Ba6%D-lZsfJQpDl3A|7WH z2{@}r#5qM0&MQ>7ppYXMq#Z>;&4Tnzk%!xgeB4sx;&(+M?ke8n55))EQxxI8q8JYp zC3vVP#h;2YJW`b7v7!P`6qR_YsKPTvHJ&RJc%e|@r9y>Q3K_2zYP?Z2;H^T3cM3h; zD~$M{Fyo`bf=>!7J}YeaqOjwu!hs<*P7JMap{VJLUXa3S`Z2s_03&J!F{)+=V`_#m zwq^w5YDO`>W(*T*#xb#G0+VVcF}Y?6Q);F$wPps>YGyILW)3rI<}tHo0kdirF}r37 zb86P`ZOuBqtJ#SDN6AyOQuB|Jw`LXnHES5CS;yX*4eYD=g8em{I8d{NgEil9sAe07 zYf2;kQ5vZ!!_k^@9IL6o@frnA)F^SXCLE_~B5=AU3TJ9!aJD8E=W60`z9t?QY7%g< zCJ~ovl5n|3g`aEW$Ytr7td^zSnoQ-g^rI#V_iD0nza|F{YTn{u%{%;AlZ!_+d3aot zk0&(+cv@44XEpEfyygR5)D+=mO)*~8l;CwuDc;nS;cZPh-qlp#eN81k)KuXk9bA^4 z=-{&Sy(WWCUg+Sm^hyVpr4Z#XhAKx;C`U0&IfmiNag0z-V3cwaW0X@EtDMF-a2Dl%pss$55>t z#|GsD>XehHS5Bc(IgMuJ3|f?>{MM>0LxpmfPwdJH)()itok}ITl;P-BMxaL-g0FUok_R3_k-G7-NilW<#^j62E{{H{#JU1b{n zQ1(TyN_)zF+*c0ZfpQQJl|%TGeyvJJ^lMc*reCYl3H@4?PU+XGbVk2crE~hVDqYa8 zRq2v`tx8w)YgM|YU#rp${aTf7>DQ`sN5593d-}C1J5+b|N>B7_ReGjh{~{@C zlOq2`%B*du{TC^#R)^WOdd#Uc;@es?zN@uhZmkvbYHgTbYsZ4xQhr-lTZZpz%ke{P z1s2sRu((!*pkjk;CE7@YD)Dx>9w{OLsWejs_I9f8o)5sAcm`kFhVtqQK}J) zQH^4(Y7FC4;~1}+zy#GKzSIUVNi~hhsu@gC&0?x*4%1Zgn66sD4AmlLsxChMPRdeU zVz%lEb5z&(R&|5#RJWL`y2CuxJ?5((ut4>Qg{mifuX@H0suwI$y<)K{r1E!Ci7FIJ zRRYUYVOXx}i~gNdq3Xv<)c{th2C-T-gbLL#Dpez>QjMal8bh^e92-;f7wQEi}CmGH~&B)=;0mmO(Yb*I{q zKCA9=MfHHIsz+Q?J>k0Q88=if_(k=Ko2rny9cfDyir-WMw^d=dqbiNuk-n?Sa9351 zKU5XCr>ew#RTUnns_{^zz@I859;w3dSQUXMswg~F#o(DL7SC02c%h2NOH~41sS@#8 zm4r7c72c}k$lptzx`F85OHp-8b-$Nl>XtFK?lZ>KtzdlJDkjveVPf4nCe>|Va@`k9 zsoTWVx-Cqr`-bUt+n7TF{^GDv+I6fPTd~9t=q?UbqAPRcZhj)KQX`V2n*_t zv9Rt0-`Abuhq^N?syoNxx(h6+yTsDED=e!Em47dl*9oks3&YB~aIC7k`1pINy6zGc zbyujYyGB*r4a#-5sII%ihPr#y)jgoT?h%c3PiU@tMoZlbTI*iXRu@wFd&yoGijF#g z&blyk)%B5~yRIK2>K1t_Z`~kkf87uU>V~nmZUp=4MzOzc3ZWnDZU)EdW^uf34kzm7ak6d!r|K4Qx^4+)>eg_!ZXM_9HgLW!;g{b_3w4RV>`PJd zb=|%cBi~@Ge2a1N9mdP|m>@r3qWp+S@)IV@&vgej=M0mtP;oRE`nQclJx zIR&TXRGg91a8^#oIXMI8<%^GhkQU@iT$HbHNxsHq`367Bx40tT;i`O(Yw`oG%a6Dr zKj9bo88_t@+>&4Mn;cU42WeXl#T{ATcR37q<-X`YNI&F$+>-}zUmnB*c?b{XVf-nN z;E_Cv$MP7S$m4h_PvDt6iRbbZUdYpUDbL`QJd4-z9Nx(Dcq=d9oxF(m@)ADCYxpRy zc=_j#c#$SY025iuxE- z*2ki%J`UyjcvROXU_*T(>gtnFU(Z<#lCfTnJduX$Z|YB^K>aE9)}LWt{W+f)^{vOBcA8?}n5hv@PaH{?pr|VyErv4RY>qFEh(p-Hg z&escEs1L)%`iqYz(o#JqBS_2joQxoSuIFR~X{DZ%5v0|6PDYT{>Ny!fTCeA11Zkt5 zlM$pZ^_+|#ZPs%#g0xl7$q3T7dQL`=w(B_=LE5S3WCZDZJtrebyY-xmApNN4WCUri zo)ZwH{d!J7kPhlO0YN&f=L7`lXFVq%NJsUYfFK>$Z$$sQwfYGa>St7{Ur?ofMOhtE`R|fi9f}QVfjV^<>eYRuVN~~{Sv`Oj z^&nc+LugYEqg_3M4)rKH)nn*VkE2^Xff4F4p4qFOV(nK?V?aHFz3N%)Q_o?)dL9SV z3pl7=#3A((4y)I2M7@rq>W%1g>4!Q>b1vQZtNInh~tl zl=54JrVN#ua{Qq2^SP|4WUbazVS}a`bs7cgHA*yU!qKdWK#L{{t(q9LX=2f?i9-j~ z{ZVpK-5(_v)%{U&Q{5jW57qrq@>1Qc^rTs6xRu5=B{-oe#Ys&WPHD<K>Gs+wR0?IW&gFL}Z>?G>(TuW>_rgI~0_xT(FvE$uyi(>~y~_7QiqPxxK? zjDGDmuJc3t%6d;5Qu!k7YeVrsEAUVohCj7^(J#`GwjYnR19+kx#8d4Mo@s~iTswjn z+EKjJj^UMd9Iv$#c%z-fTkRCyX{YgCJA)6}S$x#a;gfbApS274qFuyS?GlFQ)-Y7J zjzYH){VIj)l69|Agf0c6bg3AlOT$=QI>zZTFkY953A!vy)MaCmE=R|IVbJNYTBk>a z&WK8#8C5z9$~r5mbvA6!*>#a(LN|-!x)~hPjo_qi4ySbUIIUaI{Wr0sbKtVhiJx^Y zT+z98zle367uR$i+|c=T|Bu+#_2ZVV7r*KHa8no1{de(QH-NjkLHwZ`!ad!v?$_c# zcc@Dev5jNVN#a=d6q_VYbkBIId%-i^E1v5@en}D+x=_5-3B1yU;k7OtZ*&oOtBb-r zT@2pqV(~#2hmX2=eA3Nx{b$_*zUUV5Rkws8jeQu}*pH%d0K*ywF}!gIBN~S>s&NEk z8b|R+_sH|aHIB26Z=Aq{#z{Y8CO>8uN!!M27xY@YV_!r`;u~7dP;zwgD?lq?2eq%ZwG-lvo zVqv!IQ?fc-r_5&l+>_yfF_i8uRh8u>f})Q}DX+J>E2az}vM(EWTrEkC(y+8Ud zM65o5ar$12*U#{If_@eg^>dh{pT}hVm*^~Up&!R3{Znj~Sk^z|XZ;JV=wESFAM#6< zSks5%x?bRhJ`BI;!*Np|fm`}0{HBk=ZG9~6=;QFaJ|1`V^IZRjegXINi@2{}!UKID z9_st?r+xsB^n-Y;AHoy;FrMm1@Jv67=lU^R)Iai6m--3TSNci3)=%M$ej0D}GkB+; z#e4l6KIqr+QNIzLEn*Gjk=f!!pMtOYR17hsVW=S;g&_mO44D{i$ifIiHbxmrF~(4a z&-!GHGgM%_L4gSdWn_*>GHf;Gh-AYzOfhU@s$r+`ttc?$>feeCLn>w((lE=Aj@gC` z%rRu*TSFGUGh}0~AqVpeZ!zES4$}=OSZK(@_lA7@U?{*MLm?I$-eZa31C|C{S%sVuL}2I)jXQgBp#71~eP|(Qk#t z5J0P;7j1?aKDQfY(P5ZFr(qslhA+|Y#G+voy#^!t4Q31&EZA$XVxPf={RTS@7#uig zaN>}`g~J9nju<>RYVhKiVIIc~3pim|#7V;vP8s@e+R%?Ph5?*44C0(&23+J~~f?85c0zxQG$PC5$rmVT`dKV~qnCXB@U*s86 zFyEMp1;#WiG^XQwV+MXOW@3>s3yY1}SYj;2QezpG8OyQUSb-Hr1y&lBkp-gKSejoT z6vi@C8p}~-tU%dViE3jNHW;f>XH=lxs6?Ytg=V9S7NZ)i#s;(*b!a#0^9#j_@$qA! za2X$sg~DxoLXYtoy~Y>x8(%SC3^5goUSlZs83pzm!*IYDj)TSs95P1XurUTljIlUs zjKeWwJdPU^aKe~~lg1>RGA84+F$HIgsW@xA;~L(vX9~qVd*&~N%A|_?OOat}F#V;- zH0dzQq{nQN5pzstd~34cJChZ2O*YIk*)iYbzyeb#S12@<;d@g#elS&Fkx7BYCMA}b z!m-p8fn}yBEH}kqg((&*O>tOdipOeG0xC?2s5B*Ex=GDlWE0cr#g6Ie<6ns(Q@HuB z#IPv>M@&&TYKp-zQ!I{~;&8$gkCUbZoH8Ziv?&Q^OvyNFO2Ii(D$bkIaKV(0i>3@* zGG*ejDGNWFvT?7KTW(RVqTwyj3cMnYT*CJF~@HB67`E%ro0C z-)zSMvjYpwPJC~6;RmxDi_9J@HhZze%)6zc)Xcl3qRh;@rJ~%-yQQMS%)6zc(yYWP zb2wI;BT!+ELZvwdRpwZf&2gwU$76#z0d?j?)SHvgXjY-wEJyxE+?t1?eOXeb6HW%Y(a|y1POL5g)hHK_>TsK$XhPe{In5%HpT#Z|1 z1%5Ltaoc?P@i$_}e1+f5*SKrG!5`*Z+%wVCpsSkBlut*#YgiPKAFey z**t+S=1F`tPhm*YG=?_KplF)Ku%n(jBnbAE*Ems zY*V>VH_c%~(>&^$7Es@`h{mQRG&e1yrRg(Tn^w@)w2JnoHFPwUMwSa_QyIFN%F*3a zfu1G>dYhE!ZwkjiQv~)lMPXl44E8t0;y_az4mQQ(P*Va9HzndoQxc9g<>OdW0gg8n z;zUysPBsq%@Nsjy|5-p?AAH|oZLd!?7+4LT_nm*vSrXt*KD#o3r68zp& zin~o^_@k*D_nInjzo`-rnyT=ysTzMaDe$OCiN{SUJZX~gv`LL;O$~V7q{E9QJzh2$ z@v7gLh50c;9q~4^8*@*z|x;O^^88^n@=>&-mK(f+3by47G$* zeiXtIieVOk;g&Fru=G)Hl%*eIECU#88N@it5XM`EF~Kr|8%+f~Rgz_lb+Tm~Q!Eph zYMI0|%M_+trZK}ZgPE3D%(Bd3wq+i3EDQM7vWV|2OPFg}!#vA6=36$RtAxd}W~mZZ z%R1UD8)&zDL5F1%ot7-dbFEXK~}b#e)wPFFsoQ_+$y-v!xebEPeQD>Bo@f0Ss*( zMA1BiVa>xB-aLX4&6gklT0}KpVNCNi#x~zzT=Ol)H{W4G^F1auKVVYxBPKULVM_Be zrZ&G|TJtNWH-}XIwa91=#mr`bSe#|0nrE@Rc@8U@=drSR0jru9vATH)70qj? zY+grI^G38%j5QxOE5&&82~ISh;$-s~PBow7bn^wyG+*Lu^A*lDU*ml94K6g_;$m}Y zq*5$3m*H}AIeu=gz?EhNt~M)itvMXmn2oIWz@vylBe>SV|s9BDz6A9J{Yn^y#cHv{Q8=smz_}uKp zmu5e{HU}`o+KZvqJ`~n|46_bkxOEUCtV0-O9mW{z2*z4RG0r-M@z!y?Z+2p$brO@T zQ#uV!erdnq)&3gH?zT)_yFt4q%ye5X-GYSYaK;O6v$#Sx2$j zI))1CI4Z3ZsIpF?Y@I^2bs8J2GpMu9qTV`(M(aG9tqW+eE~3@Cgf{CM+O6y8ux>=F z#ky6rsKtWy!KxOE)<;~jKH;+U89!TJaK-wHtJV;{xn>Q;dFwr&Y*@osf3b$+rZob$ ztWo&QS{kVq+txDNv6ka^YX$CF75Kxd#64>`?pq`9z#4^z))@S0jm0Bt93ETa@x+>d zr`AL~vnJuWH6Jgm1$b#K#4BqNUR#Ut##(~6Ru$e^Q(Bi<@ z7Aq#TxG=fJjVUc2Ol|RET8kgkTLPHT(uu+p;jimW?+p zF*d8P+nm3$3Wv>wPMaHDHV?XO-e1{-*EV3Y3BPR+1GXXTwGCsRZ3O#mqqa6NX`8_b z+cb{brfg0zZ(G4R+h<&`t>U6>4VP@|xNO_7b&4N0|F1j6md%0RY);&^xp2qk#_u){ z?%KS#X|v;=Er9#B(#TG6U@OBzTRHx;Rp5~=8INr#cw$S%Q(GFI+0yacmVpZR)ENDWmbU5 zYh_k|$Zus#ec4(He(~t)aNtnt)raiTJHG3AbC5ai=u}zqh91ZfhF; zXidkx)(qTl&BOz`;}?f?$1i@;9ltoDJAQFYcl_dn?)b$i-SLYvy5kq;bjL3)=#F1p z(jC9JqC0+ZO?Uj_hVJ;qE#2{pJG$c+_jJcE9_Wr=JklM%c%nOg@l1F8;)U+`#Vg(M zixB%pbWnV-zuJQ$$9{uv?YH>OeuugCd(5*xV7~nk3+zu=Xn)4{_7}{yUt^Iyq%A0l z?V(s=7g%Z!!!mm~mfIt+!XAZ{_86?P$6~cT4i)xzRN50zWlu!eo`h<9GB(&#P-jm? zy*&+$_H;DcGtgqsM63PsV^G-aS7^6iqr-lKPWvso?04w4-=oL=fL{9}`t45`us>t3 z{RR8%uh?%7sSJt%dngXt1rFK6aM<2QRwMR)9JLSNn0*k(?L#s**=G#?en-|U%*xSBCgq&aNWL!8+Q5ELGi_| z#!Y(zZrOGC&9297yAgNnW-|G1x8Sbbia+e@{C4mE@AbaDitilQtMSmTz@K&{9@!`G z*glCT_9;BIPve<=2G8xYcwwKzOMAjEL2+eI{H0$^w)Ey>oNLR+`L+UFXe-3Uwjx|=E5_xv68zkjgDY)s zakcFouC?XjdRrcDw5jn+TLW&ksc@@}X$&IH@%Zs?#BrO#@i*e6O^K&%Dm-hG@w`oq z7i|rA*`~v*Ha%Xq8S$pgjJItTylb=KeVYv*+U)q)=D?>mCqB2i@TJX-uWcR-ad<#&M6ajt4wytL9hnjwjX$j%Q4CykL^!6_Xtym472r z9HE%%5SZo&!*mA|9z=$N2@fLE!Gs5qVlsK61AW9ufco1a{ zCOn982NNDdg@XwXqSC>H2T|o^hhWA>OucME?(Q>Bw#WAL7c9hu4mLym1uZ zt)md{9Pjbo@c|zkMfm6_#wSM!K08YB#ZiW@j&clXufWjuKCUd<`!TG20K?k{F`|74 zquPftrhNos+eb03eGKE<$1$OO0u$ROF{ynDliQ~;rF{ld+h;MYeGb#x=P{#w0W;ed zF{^zEv)k7&r+pnS9Piryr?9s7qpf`a?d^l;Xdgmn`!KrNN6_6qik|i{^tO+qzr8f_ ze~LhR8TPi9V_$nk{S4>Z&vBvs0vFpaajE?Z zm)o!LbNdahwBOOLRRBqldQ(Y7FmspZ)7ztw#jN-?2y&C z_)b>iVwbGO#SgL?7kgwiF80Z4TpWl!Axm0y1=OD&AhcLl8jET+>OmdE5 zvU3bmoa314oWL~aB&Iv3FvB^Gna&x^a?WD5^Z$G19Opc~buQpL=OX4hmoU${hWSqU z*MBPtoN6p|HsE`w4nH`JSma#iJH<{WB#08{B%hQzr?AX9jpfc6tZ>d^rE?CeoDS-$ zb~;hvbU8nX1)lSh@H%%``<>r0;M~Pt=MU_2?qR=k9|xQVIOsgYA?HsVb{^q~^B6~+ zCpbo8pTszceG(HS_DM{V*e5YXVxPn`iG30?B=$+nlGrCPM`EAEJc)f09_Kb!SR}De zVu{2)iDeS|BtDbaC$U0epTsJOeG+RV_DQUh*e9_;VxPnp68j`JN$iu@B9l+z8=1_A zb7w@yj5u?KlTt&(3mu zaaQ1~vl2r(sxY*p8byZ!!#b3ae{dq;-^HdPf;%bd+OeM+IheRAP2V73OqQ z{El)g=%~QLj!Jyb9sf>z;EsPMin!z7iDK?JFWmffUZ^|z zI_5<~M?dO122kHIh{lc~G<3-0>g8aYtYDKZwbWDAzxTsg4+&?uf;ijyRm{h{w5(1f1_k#D$I| zThua!;Vn=*&*<#BMc`xBDmK{M?bZkb`0QI z#~_|}4B> z#P=>2esGmWE{P&n85XsV9B@71pz9fj zTrW86dc_e}Nat_Gs4Eo5Tmr{kVL0Ks{PAJ!x*ELSNZg9qRi?gmfoO9jdyz2oM zT#vZudcq~wGcLPc@U!a`S6m^LzZI*lP+W5fTz7@xhO3X~|KjS$P1gW!xd!o@YY4Yp z!{~8c^PJyZqpWvbWB9{0j(e^N+;>glfolp6UDNo}HG@a4Sv+>l;fZS=PhAUmM&Exc z&guJa#RYx;t+=G`zZF;XeMMw-hDWZ5sLtZf6%o@}g0Y>Y7}r^b@tx(E&{=_rot2o> zS%t}+)tJ&*%5PIU%P_689Md~1Fr!m}nVm|E=q%!!*_{!rb2_8&ZD$O=>x{+R&N$5L zjK}=W1T5%G#KO)beBY_U51n%4KMQx~VDvu=Rp(siKMT2Y9@U)-*wDF%y3QrkcP^u` z^D~+|SJ2YAiq_6Gv~{kdy>kN{oqb%*+1Zb-&H+?*&hojZbBMLKa~S=dBN*r$#oo>_ z?CTuI{>}*;=$ypC&M6$~oW|kK864@H#nH|=9P6CN@y-RD=v>6f&Ly1cT*K+kb)4zk zh+Y?)owuFqVyp8GzjfZ@cIN}`bUxzu&L`aMe8wN0FSytFiu;`*?saiM+Uw$wwAaN? zy16cnNPArzllHneA?O4{q?xFPL-6^U-0 z`(H(vyAs3QRT$x}#wfP}W86xNb*nJWEn~b}jS21s6z&R4a_ceKZNwCJU-Z9SmIv7Qui8`x!1AWy%D`BEbdA7rm(uF(B_^-yL$#5?pbuY=g{SzN4I+c zJ?=&Hx|h)JRzz-!fLn>Z?r`jLM_|7@3J2UVIOvYWA$J@OyW?@hoq(h6L>zM`;ka9c z6K*;3t2m+RuVTd=()CrWxI0m*+Aha~@1{3Q9W;)vwGier-hDn7ek-CxBi$$u4RB>z>M zll)h4LGoY4CCPskS0w*cT$B7)aYOQ7#VyHy6?Y{6Ros*OSMfmdU&SNIe-%$8|5ZGb z{8#Zp^4lW6OBuN>QoE|VwnbW(0@J&cn9-%e%q|(Ty40B6)qpu&I(*xu$9G*u%)J$n*A_auzM->g8(m#H=gtRBH!sP4jx${oINLRe zb6rz7-!+X3T{F1YHH%AKbGY0!kDt31aHVSzSG$&Qt!oX}yVh}|Ya@DBoOdO8cEwp& zBA#|7;6+z5UUsG6RaYurcctM?S32HyW#C;`Cf;{t;X_w8K6d5cQ`cL3rZ2nVg)Z-k zSNgImLOc-|>WM<(iNP>WEQWjHFv1g$QJw^h@g!obCkf*`DvbBYk$a-SQ-&3u6s+{5 zVwEQit3Bzc@MNIUlZh%%7RsJ%RC`LX+>?wtPdVy66=?J*(Cks7#q%Dmo)2jAwi$0G&dSCQ=j5y#iramKTNvz|qq^DN=KXAKuT>$vFIz$MSbuMfm3 znH-1}@;MNnsrNvvkKOB-U)O#pysrOLaQSYI+r`|*HK)r|Jk$Mls6ZIa7XX-r^FVuS| zUa9v`gmh2*`lk@x$&o)rSa%ABcc)@RcN#`@r(;Za2F7-0VqA9?#&>69Lic-2?EZjB z-T9c@U4SXwg_zo1glXNynBHB28Qp5k>~4rW5;@(*=p&Kct;e_BW_;Ie!Q5^u=5^aJ zzuS%l-3~15cH;YP7k=n=V^OyUi@Uv8(mju*-3wUOy@=)AOIXpphLzpxSk=9O)zo_| zR8)E_lvI5zWa>Q@YU(`}4b*!qbkut+^wfJSjMRH9%+z}V6ry~Q@k;l z>W#%TZyct3<1xdVfSKMz%of7XSJ`#E`cH zhrOjZ;w{5bZ#j;6D{$Ofi4)#=zCY<*z$xz{PJ5Sd#=C~IUYYOAdDS@YZNLSu4i~-a z{B_B@fy>@WKKbmO!WHi{u6k#1%{zTi5?*(ppFTMXMGJN@w|0!;~g}(n3 zx8C=7=ly{9-XeVP7UQG01fRU6`0Opi7jHSfdMhx*SIQMaePt+oo`1qe9*H;<)pCZqv;*)%z9C;@!z8l}2sP_Fth3^QJzGGDR zPEhupqS|+c4Zd^K`7TiJyF{b!3eCQ2tnwYA)pv_F-yPb0_vr9Fpwst=F5eTneb4Ce zy`b0kihkea$2$@5U16{98vA@V*zdc=0pA@C`tEVa_khE`M;!4z;i&H!$9yk1?t8@v zUr6PhnDm9>luzKaFAQgVebIMf*4K}7z5$%~4dQ}t2p4_Bxa1qbW#1@%_Ko3+ZyZ;B z6S(G^#C6{kZuqA0i*E)ueY3dbo5OFudEE9b;Erz*zx$SO*SCg0eCxR9+rWKa!Y_B? zz?b;Te~DawOyqwF;aB+oON9BA817eLgkQ!ezZzrw4H)a!VVqx&@qQyF_|2H;w_uXr zipl;`u9o62!&HAcrui!{-Cv0r{wmD$S7Vl6f!Tf~=J><$tv>?a`J*t@U(MC>{IRU_ z{c%{}kH1Yr;s<{c7WwnB*k6Dp{z5GE7h##d7|Z=7SmD3;_+Jd(SFx`0%aMN) z`~Ihoe-Z=!?4Cb~L4OVo`QPHO{~eC_b8*z4hhzSH9QPOCguf6c{qJ$g{{g4{ML6Rx z##w&}&iPAm-d~0b{&HOOSKyMr5|{l|_}O2LD}Dv8`jxomSK+!}#tpw3zxW$)(|^fx zZuzh9oBtZO{WrMdzs2wVJKXi(;}8D>?)e|F-=D>A5B$%p5B)Fr)BlP`{*cN)iDQ2# zp7;fx`or+d-xvKSaqjQO3;zIK`UmmKKZMu*VZ8B=;H`fY@BCwU?;pnp{{%kzC-KQY zh0p$JeDTlVtA7?ldgd^+XC6h*0*3W0VtCIIM)a&`70@HggF{3Bpmp_Tjp2T0Cg}!IL=UEtg z7SP-h^dsfiVvx?51HFWi?qr0ax@>zI#%Fx?Wj{cqs4D?iDZ%-BW z^;Bbjj{*mJlsMQEjzc{WINTG3BRw%V+7pXoJ#jeR6OR);2{_r4h*LdDINhVhnVtrm z?NQ-ej~w}D5f`ZV^`FINPf_5{VymYZzx9;hc26np^pxTEo^ssnslXpSmAKbah5J3# zc+jK3!yYC6>`~!SkBrAXYCP#_z|$Tbp7rSQyvK+aJ!ZV@>5Klexa#T0>z)C;=^4b^ zo*}&J8OHmb5q#(w#mAm8eCip;=bj0C>6ygWo+%6oOk-$Z21Q^N!vb>{9w?^9h(HNO z1xhg{P=>LAa{SWsfhUO%RI*M8%=7)kzyc-(7BM-ngeieFOby6^>S zhXV0997w>CKq8I?l5i}b!tsEN69G<6e=`|SMoMqC193s=&1xVN*8&3917Wxk2*)ph z2;2-r;Z`69zXf7(B@lu;fq48LNWk4dBK`;@;a(sa_XB;=(wl<-=aRoU3~(;_o1X#B zC4X}i;9T-I#{te~e{&MxT=F-k0nR0Va~9xS@;B!J&Lw|y5#U_%HEd^bW?isL^q{3&va9I^Fr68H?MRp>`iJg zBN+B3EtrYv!K~n~-t-1vVt@7KZSa-#yI@G~uioSaLotv4*z>D5`N1$O2!>-}FaqBP zqwqs828)8RSR9PQl3+ZR1{1I>n26=UB&-M~V`VS}tAeRm9ZW+-Fddb_3{(X(Q4YRE zb?_ZF1anar)JOm7jXr2ZW6+G|pam^KD_Vm#v<2;G4?55hbfPopLRZj@?w|)fK`(lP zk5uXpK4BpEj5)yAR=c$^CMahK^}Kh6XPa5gxIbHO2;4-Vr(a0C~Fqqr0t!{y*OehyCHN^lZagHyN` zoW}Lw3~mHx@k?+HH-q!I6gswlA%qY@2qAJo(VU2XkMUd>C*t`3T^2au48a@=?IW zwy27+y@vP+zi`%-wZx*MI*|?(u`?4?dLp+`$WgpFemJ@Z7;mfI9~-1D-#41@Pj* ztAI}&yau>?@H$}s;0?gN1H5^X8y?`zlic_KZ=U2XAK=ZC+?4~od6IkT;0)lG4sHPa z^1+ROUpcrLaB^@f;Pl`&z}dm=fQy4W0FMst1bq77F2H9F?go7J;4#4G4j#YhKXTtZ z_`vi(a&I5}?chIhUp@Fc;MWfR0r>TUe*%8v;9r3697Ldb_uzei?;X4!@U4Tt0{^Xp z8}R$v2R8zK=ip|*?;cEV`H$T94rYMgKUe_%;NS@GhX+ps{^;Ntz#ktx3;2_R=Kz0t z@I2tp4qgEK`N4~Tzc_da@RtWK1ODpZ6~JE~ybAc6gVz9md+<8o?+)Go{Qbe3fPXl6 z3-FHzZv+16;2pp}AG{0rmxK3ixhHqqbYpr??)K@!fOkwQfOk%-fOk#nfOk(DfFGK+ z06#oE1^AKa8Nhp{j{$ykx^dGzxsOdB2E2D#0sQ#13iyfXDZu-tcr_(=|MUjH6Vn?3 zPfl+Jd|-Mj;HRgz0X{gr9q=>LI{-gBy%X@E>0N+@>D_>(>0^Lv)5mZ6pSdTdU!MNY z+~=obz;n~ffIHJGfaj-A0bZPb3Gj2%A>i)xD}ep!1aNOUo!*;UOrHZhnm!Ns^z;S5 zXQnR#K0AGB`v2u#oqh-KmFc$uUz>gx@b&5U0N5l-vI{h)= z*QP%K{QC5#fZv$@4Dg-l&jH_^{sQp5=`R7lIsFyjx2C_I-k1CH^x?z%a=)8C1o-=D z0q_sg65t=FYk+^6ZUFvv`dPrgOe=tYomK(=Hmw8xecAy0$Fv3b&*>?^e@)K-Mu(39 zzVGmH!1o`14)6nqp9j3*@EqWchdY2bAD#!i^>BL2eYx8XXMndKE&%U1JOaG)@M*xi z4xa(M`|w%74;?-S_~FCn0Y7s10^mJ|F9Lq_@Fl>H9li{B@8K(eA3uB*@Dqox0p54` zI^g|>ZvdV+d=v2G;ah+Y9KH?s>BDybA3S^)@H2<+-SWxY^ssunfZsg474Tb!w*h|p@OHrO9Nq!=?%|Dq-#feu@cV~% z1ODLfLx4X#{4n5;4nG3;@Z*5LK<%8&{SvivGWRRg z&dJ=bQ9CDdzd`Ms%>5R%b29fk)XvG=?@>D^bALeXoXq_ZwR1A}C)Cc#+@Dc9Cv$&6 z?VQa06}59R_czqe$=u&jJ12AhK<%8&{S&owGWRdk&dFRfdkgS=v$p}?KYIu81G9Gl zZ@~pe%w7ll?(7Y~@6Fx>{61>x!Q2l} zQxE2Th?;sZ_aoHQgSj80rv5AUkJ*X&f93u;I|=x&*#m&l{L_H%n?DHn{`qGBKQR9+ z;0^PK0B@WZ0B@d`0B@ad-1J|$+vX1g-afAY-Z8HN-Z?)7c-Q<4;N9~Z06#Rp5%9zF zn*l#EzZLMF`E7t7o!<`lvH2Z<_s;JG{P_GXz)#HY2E1?n7~uW$$8UNlSDn8%e<=6x z{2jo`{9V9}`8NRT^KSw+=HCKr&A$zJYW^L-GxP5PJ~saz;N$b}1AcD)1HjMEe+YPP z{=3>kxt;m%0ng9>0C;i!N5CiMe*)Z{{~549{|n&W{I7t+`QHG?^S=XLp8o^z%KV>z zPtE@Y_@#MNe<=6m`TGFBGJikdWc~rb>3n+2L%G>}2Dq3n0FUNJfKSh#27G4z4B)f# zX91s^KL_~y{CU6^<}U!gIDZlFrTI&MFV9~Fd}aO$;H&dj0biTH2Kf5?b-*{~ZvehI ze-rSn`CEW*&))|8>iiwRug%{D{QCU8TZ*}VLBqw|Pv$o+in*W8ZwCC?{8qr9&u;_# z#r$@_U(W9U{MGzUz+cbr0{qSVZouE7u8X-vfSq@dv z0eo*!1^njX6yUcOX8^ywxB>7xiyHyIySN$fdy88EzrVN*@CS?A0e`r-1Mo+SI{|-; z`igTuL4C!!pQ66v+|N*7mE7MJ^<^dZ=f%T-e_2!j|GKCG{%NrR`1eHv@E?m7;6E3q z0ROc(0~jqI1AO1|alrR4KL_}M<>vu!Se^sCak&F{^YT34t;>smw=JIlynVR~c*n92 zc;|8t@UG?bmP+pK zF9P1Td&;AfU^0)BS+7T`n6w*d>wcK}Pv zcLCRy@7?lfZoGVZ`DpI)@~ePXmR|#WYWa1*FD<_T_~qq0fL~d@3piQ62RL1R6L7Zt z7T{uuFRD=dz9tQmUQ3deaQ5A6K=oH}jqceaPk8S{b;^;=e-J_cU`$x9|?j79*I6S%?aC~$J z;N_z`0k0h01^Cp_-GE;@dJOQ(M~~n1Snh?R-FqL)y?E3IeCcQp@a3Z+;44RCz*mnh z-}`v(^`keB9?!jT^wv>3_tm4X1Agu38%O7I?;d><@V%pN9d&cxIr<*pcaOe*bTRkC zqn`l&=;)__KR)`|(fhv=MK?wN5B~qZ|Lea+QS{bbw=U>!6upn3fd3Z#-zU6a6n$oM zu(QA0{cO}K6$kx(cYE9$^ozTl(J0#N4!8G*SMO_;?kn#0y8ZEewQ=XZM~nX_YL{aC zEMEq0)aE}Ss@6BW`WKqr;pOg-i8ea@o!#zm1?_bc_WBpl511Ux(cJogHwE$K6ZE=>b&NA}MuuyW{I%#dO_kacg$RhS{mk?tb?; z;Xq65u1UB4Z}0@|b@ANV+vylVkCTzl1hM2(D`T@dgg#muluJucJl01L8)7$Nw+f7wmidqB=(8n>~ zgs7bhDYlL77x%lPaihC87>>24@CuV1UF$cyeKLQIZVj><F)lzY89JU_q-9{ufZ+&@1Es>$zGqu38U5C;Eu7(5vUKNSW~guy5#n~P#p z1$B$1?r3}1+ZzvtL}u!zIvDrPUky563YcgyqA1?#_r@*MM{|FVDkO@V-QDw~n%;J| zj$z@+!H~4pMNC4u#4UkRrtR2M(dGa-42B!s-93y2flAuNVYf5xZg%z(coJxBu)EV8 zj-qy~q7`?$ogrClv9o=#8?E(ryBy-d%Y>rX{!;Cbp^Zp_t1`@`&{15zGKO_^cbcGr z#YTy+q)Q+pma((#7<&j5he{x^RCz8G#f1*+Pom0Kf?yP%LWwaTqwV*{y>YKQQbJUV z)K77+cNNt#?t*I)mBxGu+Virb%IyrdFH&o_jPn?x$K3uY%c~aer9)nu+DVw`Rw-YP z+nf2g(ylk+S|e`7Ux{bS2V5kcHb=@by9n zTphKB-7Y2MPQwy@D)OR~XFzL{(T`1hxZ^^1D0ChIrEsxS75#Ci*B_~>^CNVTjqWa2 z`A9kk?!Z!tl73CmqM8IsS#I=T!)UF&?ar>Y1=|;*z2q_cjL`e|nW@m!+i>PSd#`fK zSExA$2-m{Zwy4S~opXU`j(svlGD=|sCK;&{$s|aY!_vonwEuo*H#${pN@Dy#A6aao z>glKUmQ)qP!LE`>52`rZqnfZLaRY~ku*4J_<;P=;Gncyk@u}^R@D5N>90sZ15;7T_ z37&u<(qHQ5wN_h$ac8$U*zb=cwE>sVLtq?}A%dA1Q$WwjqqIws6%)mo*fnb782vB| zk98~zP&9OU6qv6BVN6(pFnWj}jNT&%qmF_wR-7Cb9cchHE?90c8U@P}OVFOf>W=Eg zv@xjP3|t_yzme%+cX#mQ)}FRwnk)6cK;xU~KKZ9jZ~|+vy$&Yxw)S=Ky(;Zvw`WFU zAhH{KfX2`jQkmHYEmB-0wTwDG3v{Uq8wWZF+s;8bSwilyK^-DIavoP@@~}$W6H%#L zFIP+DY7s+ryLGl+j@s?bxKwHDpWgU<8#7n-0krSOKMPRjVd1pD`;-)*ZCfm+q`eFM z=D543!b#Pp(2>I=DWcfL(Ii0P@dNb&Kng=o;Y2EN4c>Y-|v9YGNqO?*64d&EUApqDiP0 z)l5n4{*3hscpwhe48@ojfb!iFI+F-cdZFJ9LseduD zJ-N&PM34m1>+f}*uz@khE_gIRRE&kt2Bm+c@P;=N3CdDR(52L9Hv$Hgn?n0zrBZt1 zt7PmF`P9&qi#QQcUoPbIOZs+32KiH*$%eas6TnQqHSBDM>w*N5Y$2eEIEm!SKVjO$ z1lIIL!Quy}q8_6AMQDi;%`sNDmr(oU@W9%tv#XePCEr*tx8rK7yk2fZ?X573MO3qu zN9$RS+G}y8+=@5Lnq}u)Zx?H{&CYn(yJAK{^m63a8jC2K)K@29iqY+Jq!UPr_5Ni&+rgIU!?Tcs?SZj|-cR`i8Fl$faFz0X) z7<^nnRIOy9aZ|~8_G!Zdaj7?=#k87N0t+KcV8A7biq?mny^E#p`5t^2mQ?~7#R&u$ zB{0ILu#Xk4=}eeHF-or?lRS(R7E%^YtBIfp4w_W$(y+I?TN*sc&b>$${IxxjUT3iZ z3YEhy0j1z!wS1+!-5htu`OI9vGf`lGLc8%PU~@qjW*3AZPY{MgK{ydC zvsVRu*synQe+-{TNNpN%62CRVz!C8ECeLYnf-BP|1!rVZdPXLTz{rf;)gIE>C#7cw zqfEA=kT0!dve+^{Q7XX&xx0l>3Z0QSDG;Sji{m^GDW2?G2rH0y5IU(?gU`y7*#yjK z;;_S7%P>$EnJAMNk>Zx6RGFTH@(V6Vo;2AEk&+~#789}8PM;`OB7M}NF-=#l@QDh) z1QPv1NEM0%Pth1U&Jaao5+WFEpco84q^=Am8k1n6*raJFI%yf%JSam*Uz7D+OaI2`o${i3wzKQ-`cZvGUd$_HOxq+iCI;p zF^S9!Hjq}38RAMrCX1xNLYkCV83eh>v5zc~H71dtVv`vvI+>&8AwNQG*(pv&S#4aH zga-ih^qbvrX9p|fjFd@|g#4-KKpT(LW9mb*)M26${46?)Plk9(pUowKEnuDag&oY; zS*B1EL0m>YLHu!ik71johJY`&7)r&99ph}{-_(f`F64`aaUYwl7&;o5*=NWb5+npp zLm;W2Sal6h?pLN%4TD+bTNbx3f#wu25dK&eNruA3h$GqXds$P zpp?OCSfb5>Rzf}(!+`u>Ys2og#z_E?`h(V7yd^JZ0Sa&&^mff)DQS)+kyYDD4v}u9 zCue3Uv^}ZdDB0!7Zfvbe@^wlWRur~ImSnk*M(6@HV!-XT2fb^0m>^0JNELI zI`Vy#-@ z%_d7>F^+)L<5&;@V+_G&y;dz(TkZT-t0p^F92#F>w5*JVP4kaX2BnRt8T-Xw8$wF&pu$M~Q^t476#26uf z3%ON>%>BZaKhD3`;sS&R@gABpR(NF0)g@|kiGVzwXMDmTuyEAeLBVl&_J3YbBI z5txn;t+7#sIeR#hMYC0Fv`ghmsMzwE0I!0!%Jp`!0R?(hfTm@UnsK>R+-O(Ir^*#q ztThi=KGULY(h>?&YoG`N}6%ISc%aUNx2d@VJ$X~ zEMa1XkSsod&mxv8Ytc55*RaEc0nKVAPVrgEwGndbsOKB`%|uU_jF5Z;3VmE{*I=(< z15QUtl0qFegoc=vRYsg7!YHK)!m3N)g}A)6nH-253Z_@zNQmm;zqm-96x1!5Jm{nC5b!d;Ym`!TYjv4CTj=#SQB$lxp~_eDm9x#*S^dA4K&UHmp^?W-B%OUEA(#eWzETj4%NsWcv|-yo7abwN@Ofg=|# z7DwWYPmg{{9Jp}+yI0M99J?A`^^XB0v3!IhpyN|CdR#w|(wuu2G$&1<_$J8a1@#S? z5LAqlyItVn+1T#x%4$9+Vj54bmL#p899vuF28l<=*dVE3io?NZq<%2W`P3*vB*aW0 zsyGh1LmS6@&QlVFxF}A9;p)SMrfxqxu9w6js{|c6_7f=7WD-UGMP;8p%$^=+kX(MJvu97|9Z%!3_nk&%;R3)Gr zAM&$Mx9SjH9s<(3Sd!g^qDG6;OBxNJu?p5ZtIYeGo83$2=u%G|&eEZGBF94zcN@!j z*^r-(GYz!lCG#T#enCVsfho4lkEzq?AqL0L*=>`?B8Xhlm9Nl^Iw6qX)KkbUJ2Wd3 z74z>X*1xUN*0{H;rltXS7X^!)GtO)#kR(Asg;cD3BP$1pN`6?;J)#hotVL&f3lnnCPEr5V|8t;>u;@PxRL>KUEHo?@&qIgP|!g4ER zvW6mgv?kYt5JE4E=p46~!Xbl_6IJBy-bn%%rnwO90Sn%q2htzt3Jr>Px6L(5p$<^! zXZYBmImLu+_AcEz zLnnC$rW5388$l-4AUocD+Yo27Rz^+&!@0SQt543>Z4l)$F_HZh2%5xtDGc-C)opvH zR#f6+(7$={5eGafjiz3Z?+mmCx;+(b;*v8?ulCg>Y!KJ=OpK!mWVZ1}LYKl|EQu|j z$dtx=*;!hbuSI1Gkc`e^W<ZVtuCy7B!!*{d0yO;!xuA4${WK8c4Er3a`)GE47w zP9}liTnY_qbimva*&lpV!N^$K(+M+HKe%#+KIkIu4`QrSUSF6DlYKA%X-L|8NWA0xnT{oFiIw(9O!mU=U`X5rNrQnmXVh68KbM z8cQ4!IwDID*t%h8%-PCe5Qe}FDn7=s=Lr-q_M5#i9UsCSp4ePkBOic|#wd_N(PR_{ zRz|5ybO|(#AW4+NNae&3c@MfS(+T6YyLNlXSi^pp>}tg6U;CnSVsq9Z|N4R7WNp21QjN4wA&JBq|Jl zGV+C0ef#2LCYg|4h|>5dqfkPd5fS=jQ-xJQj#r4SnqV=N#CjE_biR{Hnz&@=`K1J% zCRF9Epx4-_fXB7=FfAYZ+!IJg6!5fEhF40c)XA*lD5Phzw@|&b8D;a<94VgaW#f)j zN+lSyF6v2r6z)KzQ1%oh`cti2bFLB?Jy@ws{K45zXEfsDyaJ`!dXZrcUO|0kT1Kzz znB|}EUD)^CU#nt$eFn*b>RpxEl+BBWlL?wgS(>2z+yt{Kn;;!2-c%4DF>Lf*cY^N3K+`izJB+d+HByUK*xxS#vO306!|pKvUS=8aMo#eHtF{ z?XC@n{HP$yj0nt`bi;>|W@RTvrPb)uN(saCf(uys#aqS2R#Hz8zJHTVggA=X9FrMF19h#3KNAmT4MM#e1aEi4|z`|&?&i6k})B< zlp&xanY?6?Wx$K*fPZFGB7thj$j3~es4)C!5wl+2*Aj9Uj$-#4mF5DpV3s6JeY(!Y z1wy9KJ{MzT9ufBsNij^*O43D1#Hy_QUMCPBhzOq25*Y#%uPEJPTTn3(NyVC)NU#j9;gZNB2W^WP9Kr|vka2L2Jz&giSd4#`qQHLj|K%Q@FQ%&17x6# zpzK*OmWRCLV@$z{7%)g;J^4+-4EX~VtK+RCerXKbR%fK|e$X$pPJ#pi<{m;w{N$B^ zJ|RR@2nYrJP(+Fq;tT`M&RAEG)f96z1t; z&=+{|{Ctri4l?wqY<^itmzN&TkaDKbSPz6*t#|vdmu;nPj`z<=0n+%W*~5s~eWZI;7WkGljrT}p ziR1V>Vi$w{Y>(bL#eore?9CCU@gAv5FA_Uq7lXwRo;OKw4RK21(r5*8LWjkJJKb)A zQGgNxmq6Gsi9;F}Wx{VNwCamY#D(sI(}Up`&f_UL71H+_m?%{EzkzPI2K#ttu29Ds zsk>Y6j4uX;m&RiioTBxUi)0>6kbna?`!tj-JlYji(qNh!FbQHTw-6gJ$w-|@W;2zl z2@?p;rI0WhlF38~G#DhdL?(ywZkIM0vXmM|*^~*i=AzgjGsPuSQr6yUQ#Of*<0O7q zlLWMuC@SEvBOXN7SP39je~4dHB5^=EKf2oA798f}{5ZIKpFb;d_1oat)V6_;2bCs5 zd>M4ZJ?wvtWNWx^ns~@u#O0YQZDVAYBBC?+a;BD#cwX-Vg;?PTe>0!*Rb+8Z^Oo`@ zY8>R!#V$2%ssyGJpbTH7kO7@X3aJbp{W+{dzx;OSfOQJ(Co)-JOvaMY_Y(OS9`0>C z4fi$>WR(#SCbik|gY1FRGdMU&8lXc<#@!k8d=jPWLbII9x}=>=nCM4W5M4V*sf%mV zT~B^62`Vnlc};!7UfpMz^d+_#tsNzoEWETTiIC=m{X%#KU(Frso_he^NWY(nt-(}z%K z;b49QnIw>o+_1$Qk)FV#txw_XA$SI9VzF;#DT6H1_#j;(BX^b{$j+f{Vh<%J?dhH^ zox`UqjEVac=_r-TG0BoS6`PTHLVmbOLPZh6CgXr+O~11;_3%MDlM!By*zO+twxVe6 z+H~?(WXQ_QATv@Ao`r z#L9hbDNOG0+{^e$vL<3-;w*|38#9gMh*3iNL}Zxw(g<(s?)J__^4)+)wsNEO{oam! z{ZNtjVNx>gUFzP)??n&xn)103Jj#N@k64<~AD0GG&r`io59=3)BMLfJz#=f0^Ju~@ zp3hWncSiU&%5L{UXH3Lg?~a6n8A<6q@YoYsWm?Ag8O_2vrsuB?>LAi@57V8nkusSq%@V^?R7?U zN5mzk42)(^b%rj2-O#K_EhGI|+wI^f*-$x56O&>FBR*0~eh&S1SbfmzkE#E~#}MHC zH?n3|@O{t}F&jns;jnX+-(O7fiV9azUHa7+!;g-gb?Ey)?2qLN-NdUf7x8g`^&(%> z;TKLL>`P+KhNl$qeIG59E3YE-eHMqmj}Dba7rNuN7OT6%A(%UDWQ0hv)$Wiq?9b@n+be9KDa0P>_=2*o;p>$@yINh}A_@^pv+x!k(UUvoSgw~ue`=}CZV;!lMKE6kic()L^R?k5MSWkwVv!^LjdLmm4m10O z$S0oTg}ZF5n>=Pii0zO*1VuOQP{jUDYrub~y3L0}BK_`E)Zq^}u%SigMtD^l-(z7x zN(E*_GPqY_DHJRmn3TOxBR+#-(@>f4*sXbwhZ2&00)%~R-IP#H1X%Ue@Fj+hd|WBQ zr@`!R!^~+gh~iTy-iL~~2)!YU6t8`gLn-1n#8`C6(d18*!9B$h6N#B{Pev52k}XAj ze|Vvbej1&!+N6Ar=aFuAuY!)1bke1dM@0nWgBEnxVpQwzUS-~DNce-3i}WocuSWGs zpL}D0H5>P##Avf~h0}UA%W`%36)3!>EmC4a*TKgWU_tayB_p?R1&h8D$WD-G#FgS> z_R!lgVew*j`wN5pWGg+@>pnS3v|PN>R63WyK_!7s`E!aoKIuV-xP%VcZ;kl;2g$7p z;kpGXY;Q^<1()hqg4O`-JC8mYpMJvLEGgO31e21|4)BvDeahFC?xtw}VVDfPQg+R8Q;=lnWD1J1bANIGqmba06F&W$!Z zPYi}$nBU{BVl1WHrQvKfDyC-bT^x!H9``1McL&9nB=e>V(aX0JeA0L%4|S{W3PTiD zpuN7aBCkWH2-r6ZhMyO@J8@r3L1s~EVm``PCh4F$z=wq*D6qFf^Cta)Dl5{5l|W#R z!i}O!gd%w@&WOCbx4k>+Nyl#^p;9@$NJ$dcHwYD6lJIGQ{b7nA_2U45$<0TtqUA9( zBSE^K^o~o3_aW6R+;vnTFl^V!grsw#Mka>u9|lWu^5YB>DvT!r+Kf9b=F_AO^&$80 zgQ z_(D&(=;n~OZO5flbh`FTgl9mCO6)q>nHKKUVR9kUEY=0qu31M?pbGI-*lwGGZus9H zUxa^A@5{FaU+7BruSIf*%zH+ZvAbEsMYK1vd;_5wgWbpXBT$A+JSX73%%{%2PeelS z@MazWR#m%^JJ4!!=Yy#&E%(QMp5awoWo>z+$W!;%NIIE)_&wDM=Q0tqmjdMph442H zRbqDcrd_1O!&XA3IHL5tO> zj>)vDJMrl@##ZoHqx2kZ3mL~HhV%uYh`(tVB|aw|@w3T1X{4_=lh*{f$?}XBoVC7L zshe*Qm;0A{SjmH>e2#{fmeg+`;dyK%N6luv;nx2M$o$E!k(;BvVX?P&5soOa>=C6X z_sMCs0|6;57KOTQG#`r+jkS2k$i~0-;Q!|jUE?GcePY?1A0R6vg{Frq!lu68 znfT=L_BsB>2CKHSvx5(ao8cCpoaGvZ5SMTQD=Q{Qu!36A0jVtFsY0@tYh6V_5`#<% zWAH-knh~-{3X~O@Otv~rP>z6=5y6U<8Jo=Mm{cZ8lH_;DzG<@Tl;zLtiH&{#Z)xcO7Xe#wN%nc32@?U&%QYV-q+YwgN!xutLbK zETw?}>k%e2AWf85s!{T1|G*7?KK9_+oRbm4ld;*f1}lVOWawql4fVSCxV^7h>Tdlg zNdjY$4%o_IF+xC{NB%OrtL)~tR3X~W-ln&-B9_GqvFYh8l|dL@nf!-ChZ@=a-Fax6_oPiRrv8Q3sP0ovgX&Egy)=nrgChs{6*3>~H8nRmTH zt&ad3Cx&ZUUl=pjpcpfal!<1`DA!PG{Zu1klur>fm|EX!7`1-V_7!6++{_q!6UM%% zu_~TWk7QnrvBscj>(u;Ckc1Yznl53zs|k$(gF@{_CZ%Y0bUeffx59R>neG^qy++z& zEmcQs^cHF#4nb1@DunJ`(e&Eecv5n4P3snlZjZ>qKuu=EHy?t4rU^DG5}OgCcb*q| zn-Kbi2l)MsTMf*`+@&AOaONi+`AH|fTu?L~d%sjzHu&!Mz;mu%bMcrbT;2&ccFJ2V zhQXd{DJHp%GyS>Zt5w;IpEmS)jNHv~vw}$bS1B9MJ!*o1*GiFrTU2qOOEm2%3;3j? zbzvB~ufiE;80WjTWNvG`GAlhYS<6SAu*)(fbRU@YWMVBTE5y|5kkkO5n63disJrdEMC=qFrg;~riF2XpkooTY&b_>u~!&7PgC6go1`y*Rw5F)yaUJ(m+ znpk6FX{Rf@N!*E}6ZXyz#JDtvRa||5#om*hJ^JxU0{BiAe{i0YT)+}wOBb1TEo_}f z@yM*GBO>yGP3-8<23PO=RdlA11T!32HdAF{4b|C+*0BArMWB<(x(^gJJCIyvhLMaq zU7Mk(iuW!@kjx8`pt{nbolT1Mg2fJ2PqL$z=bhsAq5}t+{tuCu@uU^f! zm#KI>3RW<8+vVbULA%3U+>UfHOua0vws{{)-%yn=!Jf%q=|S(f&mnKR73A6ocEm5$ z&I=wJt2lKsim{=^aT&8$CYILG_wKN0%kHrIxDSOkA* zhq#4vPKG=#HP!IAeUZe>6g1+wQ4QfW5pyDb561|Q?Wcq=%sqoDm1COG>Rd@F<~!$T zNOEp$BnLL6yW>|x_(fcHPr{cd@8jZ>@7RkIA4m8hV+lp_94}6ob%xs)%}0*S*vpF? zl8*;L%qx67}H1+xp1QHc>ALCH;GtkgeNp%(6ZZg{7zh~*GCUMQ` z&#IX0`qeg=(CLb5@(Qmi8%3ANanf!_{0WJABd#^@wTE`4b~=Hn)*735zCI+|h}So` zvx4LA%9zI)_sbiXxD(-M`9=1^ze+rBH)l2yDE1IywByY;=@Vhwum&t5dKmS2)DAGj z*Gj@a2y;dy;f+P^H?MM9gD09TrIBc!K@fX`CKBowIYP3Kk|aeA#9;|cE`}A4FZl~y zGYnqAZ%o+wJGfGbHZa7gy%DbXkI@4AbODoaF!~0)lbIfEEF+ST##^&Dz$FY2>$C}j zsbhz~GRT964sFr4;tN;#n8XN8ZY;krK^;@o!snYr(c087BxeSlfkRE6Xdjc&$~37A zS5jt3vN}T)NQ=4Uhv8xfFf$%kyS)o|Z)JFKFxYA1n}mFBwO#0rlfsBnV@5`juW3Gr6{`gBpo*1;{lWBy_%;tX1c8k(k<2X zR(}^(!;Q`hQmlxFqt`tV$=VK23pnB5iW7| zU@M!Lw%}}Zu-4*$HD)P1CUDjwt*VUurEM>;J7XJL}umTxha*He~=Rh zl?`DC#YC8&@Dq6iY$^(Xh;=*0Yr*ICu_mN0lE-wWmtUj_sTRwGQ(^f<`*g&B3HcW; zmX9xTAuKD*2{6gPyrqbKn~8WbD=aZY(rTJH%L0?+m$qis>1O2e!z#9JPGiae!Cgw4 z^vlpeI&dLMwb7xo{hAQ#VT^I8cvLfsMm)6dqNH9h*#?}^A8+%%)J_s#JLM~IxI|hX zkj>PE=vQ>>^y-8kMPXSyVX2`>{lq0Sd7B$$(nf7=J*!n{?%Bnoh#;dYeFCRd%gH+zWE7nKUm!^;}RYwpWUw0T4&rM`(FF zg{%BJ0JEkP%+2FuxmXT~)UFH3FXGIt|AKw#V0>NsIBwO{F8Wc^OJ@`gj{F7Cx4{qfQ)&p~WHHJTMDa^O0QGM`wpm zfom$f21yHEoI+K^37)&i64XdQJt%UrW4bPg%|TXOuo`NTmzg4-H)#l=k<$8!A6tVL z!<6SnV|%KXf1|Opk?>TOni%WXFvHqLrN=M!o^TK+Z?!O=GVw5%+U4$Wh*v(z?PNrC zj7}I0;hecVw}WanCnKR_U;l~n24yuIc@o5BR1BBT#6n!J=t-wVOz)gZcgnosjR+Aj z_V&f!WOWUi6pjuTqsdtsUWh3I1=0f|szJ^n$W9{+TN4+AH4Bb2>>X=r8?qE5&uHyD z|0cJD+zH`pSx{}vUIe$6Uq_P>#{!AY2UyfcO1;VnVd?DFns4LX| z-}^~1G%LXQ3UyhQ3gPsmRDgGG|B~F&A##JTlSuMlH^*0T2!^65v`KFuNv3+&P6F_Z zst6LM86W+^Um4T{O)NAyIXBUr3*M|tB}AQ;M!>KztJ45Y+V$*r40Gm*vCNpMpi&qs zdpx2o5}8H`TYJ-nUL_$E&rsOKECjmg5%=Lu!D@?XY`-ETIKHEY@#B&BrJbPEsZqZ^ z99Ze)@Vk;gN4&t-pty&uI|%&TTyWjZj0;z7k+9XZ7p-2 zehu3+QWUA#pc0eS<-)eA9LlSvL={10iRy8fpb@~ax`(ZptE3;gNg=i`(8jUd8}~bp z@pP+|u$c7GalR4VHsPtgH~r`77e;L~SeZSTxj)T3__v)G(Xg+J0pg13o~5NQjZ!$d z$vG0K9RSQ05Y2pe84w^SsjhXDD~Fg3chVS>X+Vw7m$5A&eT>;Lm=mFt zwe!K^SB7wsSJulNrej}j;;UKqCafNGLm4_|bj5iXc^nb5uS=ah`allpC?Mg5B)1U6 zh>-{JvZ&yDPpJ8W7x4Nag>_A#K*d?cDp+;CuDz-=hzg%vu$){nh^6V zNho`*J2EL`K>`exSRG2P3mpmgYXW49tyR8fh3Sd>;EKd7(uDCEH+m}Es8Tv8*8ax2 zMA0;P*}(y=3#eaoxpb!7I3Ea=41)=wI`E89G=eo+&{<^CZc+7~6`Mhll|Ws<2^?J6 zqh%h9pN_qYcH~QiVSJ(rvPhtm)#*(nS5;PO6ope`N|qrWVqG<65!k9FwNTfD#iY3t zd8)|D(m5Jgny4E~+gCuQEI-Ml4i)(ssuvxK%Pb!J8rh&ag0>M?oYK*aEL2 zpuDB@$5U9XnDty?NXN--XMlP$&(`6%9O_oP@=%~p{ktXj)U`?=9FHr3q2Ll6C)SFR ztxA$C@w)Mz>2|H1ZlMRD4MZ578IAk_$Qwn#(T*Ty^spmGFi7YCfdn!*WDN`^H}niy zLjYxFy8q+5{zPwugr;Z0&#+hW+9TScTYO3VXxs7|Nw#uNv;(ubmXRM<`zL5=KrQ;; ztlfV@fKMIUfGGA@(_0~!wHj)n)aO_qgzZGo`S2%Uqp^wJhSP8qU4yz*u9vH&ax5N~5=$_!e>|9-sOyoXv<#@NtF?pL2x! zkw$y|CXXRapoy9+l8VjqDH|{`IIJL7+6{s=B<|JnWo-XpvA&ZOjA(<%jBLRczDds5 z7Bb0)!il6-K>A^YGgwSYf_#0=1Q7|Yo-m>*yDwr6A`sgArs5gJ z%*JBW^bnYi57iw9EY30D2nY3``|=tLrJ*37A%)`(3+}>IT4*)>=O%1|085puFUX_` zV4%303<@MsFCM1;dK86?%{UOHaiWouESf@^x-JFeg%Tbzn8s!%=Nzp}7H=`fN@&Rw zY)A}T5W-6j5LgzrJV7k&%Qu1LkqQ$RQc_xJns5j5&ZjLEMmv2_0R}-W0J?zJh=0lV z_be&ohsDbaKX5eAx@$Dp#T`*f<@!3k^Ful9^5GQAz;ui{4>xNr@8hJ#JdDmw3gkPY zGI;mvBu83S;_VC0;u^93%a$ZMTpLy!T=Q@X!!S&iK>+!$=1!9F(HmGY>%~Yfs$$vD zHK=|)Bq<N#LJ z0aKxpIHI%aF_|!L6M%_eX^A~a^wVcHD}IMahwNOTT(d&g;C6d$V$wtyGfrYSV_P6w zn558FU}DK>(!5E0HYBz(`9(Odu4Ko6H7Z!km&-0k(6sOHs3nZDB?ol~sO6)?E7AG5ckY&C$u+|%5x>co< zG4)~hazqOj_;2tr)u_RPdHbeVDdQ>io-dwniy*GoZ4mV;?*pXMq3Hy(_>U5uJjZ#gXgA7hq4`Q34S_=?{Avbi2tvN_S~2wxP%(7U!+7=JOMoml!Sar~ev<0&l`d-QS^r!c<>kHbqB@hBq+ zpg#%Q=w625!<9*R8^FkJy;9z9v~Km9!wN3b1cD``0r0}Gvv-lqSWj*2&~JZp)LZbd zgPcBCF9Li~mxA8D3d&~kSF9%m-NoRO+Uwr#j72I>)`?jIaKIh9B@#^Xkcs~kt&zqY zNMr*cQXMKtLHd)h@irEl^aG`bKLBG15!gU|u(wa2=@Mh+;~_W@O`qieHEt03u{8R? zUG2pi341uBMMqI_7HVA!3nL=MV{Z`hJ4J|HatonRF+mL`m>I7^V-uF=mb&(FXEIG4 z7(JpAm{KRF5EzGf=wvM&ZlRboW<;h+QB91$j^1aZg#ZgRE{~3?T|Jf_mQvdnamf2c zWd7tI`wZsl3pk$v-SSN;e%R`%F3y`s5U-J4mB+N`NeWuu;k;Z=j(e)x&Vh_H-HYSbwXf`b$;nC5X7A6g` zTdOl`r7oYx*(EGQH_(gYOrFFsyW{Bggq+yftLt=;)bOFgWkzrc{dl5QE7OK3uhfBj zWGaDLi4aqBsV`ajm?y}jR?Lofcc-Ku|1=`{k_fF~b8Si*qD($^)?yIK>;f*t(WALL z4Y*ZV$vCItsZC3)V$u~RJ=}y=YkC-IZy{rzuDfDg4>gX_v4&_*?|SHQQEx>CkQOi6 zuwl0b>iBZYYZ$$h6w{;(Gf%})6%^v)#lfiC&-X`9Vnb~(#Ig*{2VJN6q5hcFgnN<} zbmX5OjS8`AJA#30(!;^^F2yrQvcMFQgiDi!7@|R`u(ZU{0K<)tYxPy7qP$keinyi~ z5+_ptA7^DX$e;iQ=?Y*lL?#6=n4kbYa;f0ldyIh4c#Gk!b-u zZng%D&2hrc?lzCFJFe>`yv@a-1MNAq%iiIf1|5#*tOy~RTP_ah`aLsG2@(;~GW_nr zirK1Q%xRUmM@}J~h(Qic$^f0B4zo?A3Zp4?qhBhcabgLCPYMJB2PIw|OKGKdi_y?A zxQ=@2r{OcM9+D_!isW@v=oK1;mQ6_ai5uR;r%~itjT{s+0a}F=b zz)V!kBugtb7zq7}_Qrc{(i$69S?2g`l&oWOR>IUE>(@I zEL>dJ@^L7xoMaE3Kq8qpMYj2vo>_A78=!vEFsMt@xv%adQyt{B`a#;I8Dm0+lS_M- zqwRCi-u5{TNyKSd77>nqV1)>;4AD2c-7iEt_-F{c~yEhusImt`pJ-;x-Q9}A9AF@D?2!9lxly7t|&{PggYUj^mjEHugq)P(a z^U2jPrJzMT@$8I8W1Ku5o+kvci}pCDNB29ll>nM2x4EB2d0D7S7>>FTCSZVAfdL}1 z?2HZ1Q(oR-EPWnZn0E_391t90LW_4pc37|{X)fO)9y?ExliCJ(?9=-L)@i8@T&x~t zyO{@eK7JYZ;~l;$id82&$=M0q!N9Qx#b9@tdF&x5lYxLLj|Fje8EW`omIYVt8NwZ)&uRDRrxd$`787Z2ls3Pd^_?)gn3&6 z2;?Ipg}ar*`2jCJCk~$3(KP1)h&xW%_HaoDA5_97_K@CtOs6z;XcM9= zILDgs#F*1~IJkjsCe6j1@q(iH-lLfgQ1_y48{gG)0W&B%R6D>^7_{Kqi6j*Bqog<< zEkSWRiTyD(W(}8m{9#6JokGRdm&GkXO_`$6;oAn{6bsOna&lrhr#^i^;U`lBNw1O zumN7kiTEyrW9eA2z}Dq(x-;xUIx6U3G;;Kwlp-CTq7eza+-=S_SI68kX7Rh@&JK1v zuqC4R9C0g8KCctziwmwa5x>M6OFecHf*Ct3jT72Mv zYnfubAjQ%l02(52F^f&z4^uqOSx^(#M}mn#h#?w#Y(NUbl3N_45zE@|*WfSG(`#U& zA!2Z9Q!lQw2rfi%x*di(*v7?e=>bTLEIiTE3qv#?l`S|%Lh9~K9lPvCe9f0 zcX7blmW+i>AwBJTs`k|yD$uecMLD%NCHN&VvR}8{DePNV=W1vaV zWxjXI@l@{o&ZQoGSx1@(=|02|jXX5R8quFYN<5@8dJ?A#n82pCSc{SV+2m*Ai5HE$ zdZfbk>=Gu?ykC5EN5az6%Wvt<|{6|ddha~)jtr<`SI zr(d!zC*^UME6ilRESHd&0NW8>G*BPyv<-tdxv zHIY}Niyj)Y?+LKLRzsJH@eHqk_y#QjFlJ*$*>M* z8B!-KC%s{34B;3fAOkSEj3l8~@vhQMongmuk7iD*E87sPu4qG%UCA12gi0x$a!*yR zp|TYlRI17F8Wp;3t`B$`p!Q(3Kr0>kvVh)gmLO4JS%9^Tc-hQvZb_Hu3L$k$W&TAt z+FZ8doefY-{URORA!_+WIC<(+x+e2mdO?~m$wfec$hS3+pOi4}%cEcNV4ls;qKQV% zg9&r=nxsedx8I_;t z5$HOx1oZBx1ay_8wFEh^(V4(n42=v|fg(*5v(1hnK^(_S8eyzzFf|ddUKJNIUqKbH z&thwFne0rg?pM&YZP%mmx8$UMU>zjGxT(yKAku`I$8n_I?0f;^b7#1H(PGIC<;g2) zTHZ}~l1USJ*mZKH=*4&LRwA564Z>dY^V*uWC(kmtg#^{Ym~@o5x^ z#%G8187@>QQ;bSI>_mP@2+2mgdeRKL$jLF&+PjDT~)J6FKSWpMh%9kEa3 z6OfUSY0x`8n9A!9ltG>jlEK|QBV;^_Z1QmIk^#$)m1`h_6o2oW9VjUu^PB>? zm3VBE?l{li1%(4cHJ2t!Vn7Q6kjZX}EBiNB#H~oCSB6)m)M(wOz*39~phyu#o4X-| zaAL_;N-xIFO=TDqNeL;e!f17VJ0ey;lqvktk?;@3>a3CY!(;+QR5*!#9!Ic@VtIX5E%p9>eRqOC&F4x^XSJOpuAtA`w1*l=(d z<=`Pi20nnpyKDoT>aic3i_D%R)rJ1fpxVPN0Y8;UwTdV4(k;gfUX+%eIlx!Qa1H~G zJNodI4CWc=y$l@B`{<;m-Pe@;Q2E9?O%*B9luZAIk-_GmA7C=td(dQst8$iUbef)> z9AlrEPDPmz5vmYLLRL{RQE@hGE6!p}#W{p=t_Dm6Q1k1LsvQo3xVM&yGLtwE@KRc#RIOdi`@w#BfToGsIFNTX4XQcf9Gw%YzO z3~J3P9XZ(FlKDy%XDfp$O>KlbMEPy1TS8jZ8lV)WQ1)6?fY=K{KD~d%jw;9y`goh# zNBT_M0@frK%w9hXn__uIG6XEQ3HbRKoN#o?u>}=o9Mn^T{M%7#yQ9(xts;~ske>CUe3kED4~qVOsfPQMrm}} zXh&_D9m`6RQAFjI((ZHUG^56hS{4GNho47A}EyYfpUOknALBv}p2x~Jd6z}(NI&X0s# zuF3FkHZlGsvy^z$)`!uMh|FE5&is>9Pm_1uOO`)&8s^0iVKNh{qa@DdmPm{(_#Unk zV;F*8wu_6RL6F#6fyC)YL0--^d*g0a96hH@Z*z(3KOpyfkl0zFG82#$V%#T&)Mz;g zj*}>c6j$ltt2cNh?h5WT?r^S%O?+L#q|`ljY_TYV%iJjNzC9gL@eASo&JvmmFOGjb zK)}t78=%xKDcTDXeJmBvy9qckDjm`&MMOmmXv8M@R08(_es~|m&S@c8C-aH@Jf!=y z{C!>|J0(MSt6F^RvN&$2&+hz8LKkz$d2QN3&Qg3L{NZ4mX>G*CzyY4pk89KJ<@?=p|O+}AM3&c zk$84Fqn=j9tw?8Ug9Oh=YvYsYU48kfT#b2HR|Z#S$3!P`N~HEGBq8!@!s9vGYB`>t zB_nQVkOdqx>kdz2>xxbxVql=;S@@N?d-a{E4zI@Hap9iBwD19*KBT7$Inxx9axCC{ z(-(FIPqNF)jNjJ(Ob=F{@8Ck5-zg+J1luNp&LD-gCgNhm3~V@2GxVrg(z@9)yt-XQ zVrwCTK=tM6G7vliZ$K&5B28@=V*OmdTjYSTd|Yr$iPYdRNS3NLpReJAqZV}D_7WXCrHy|2gqHb+DaD!JBnO3=W}VN7 zQdAck0eI+~-p!y`;zEC!qa~-bGQV}BvLB{+ERo?R<$0|mN+F37S2<`6rnkLa$mf_! z=*WnLGih4ek)b3oGXF>*DW&*?S;dLibsWp2dDS8` zmky-jP&}oxA&tSBdQ1)Mmd=X6 zGi^|0T?rKNDED`K3NIKiOr-S4h>5;PAd?Ln;21a{AOx>vNCI+5m@vhksul1cG2Ta) zv|f-?v*n>uhF8taBUGlo`)Jy`yje>N6^#((U~Mx1j!rrY?*KvECCZn`%RZnMO1{k? zPrdY z!rFNoqXjidn2?lg32ah}F-Ol;d9?l}Nz7k zVnf`XY)A?wiRkJG|6&sUCDGshf`$(SwWmrTJCUJ9J3HP`U`9Fpi-pCsZEHn;JGNObi>aSw3K62ohdkT9!B zSZ(;;TUPm!NG^gReK}WiXBk&VYv#vG$Q=k%(s6gul{x$#t>!I{g>e#6l4-GWa#Q-0 zB#!8)4fXf=Z3xcF4=3sUI4T2fCYrD4ct0sdHo7sex&ZB0a1a~3v?b5pE&9O`GImpt zOqJh+r0uLGzMf;h=M)6Y`*J#F@(Y$cZxVziR?i+4G{lI2oVArl-ih&;pw2Z!3|z?l zsyEyCgyX3^?ordvtwJR((ywZ*)hxH7V!hGMSM!y#&Dar!NJ-Kv)hgw7t?)1s#?`nL z=PU7JVe`XyA1+307;xT6Ha6UyCbcMa7j$c|BjL=bO#bwT4NjSZq+`Hw|UA zRx02t_m)+w+-$jU2?f}UTN+y`oGLdqM5wAly9{fULmw#&8@=2;8M@y z8DLS(X1=HX_6e18hl%Z5!gJF8+zm`W+D79O)HdT ztPSJcz*kz)9w`S{c@3;3zDXH1<65XLmK;Ia_xly*W+*6mt$`V59pBI0YL*)mqQC2n+E!gNLMtdVYn3gu zQP)e5QA$ObGNIcpSDWQF-YJi*W(~4N#)c2{qK?ZAW1c3GMC2aZ@32i|LQ4kyNSW-U zjxNv`wuuqTV5{@XZK5}^R!v1x15ztw<1=OQ@DMVHBGom@k8ZghnK0;N+fDQ!`AtA0p1Nu^g;uBELybcU{vx^ZvdFy;tLp%SA@$H$j74R^tbqH=tQ zqjV^I3uOa#cG&e<(wKr}5gmFpnWjyRy zhKkTrqq(`cL|Mw!2Bk42?YO9MdCF7^qOqb_#stJ<*eEyaHEK<*{3hz#;-M|-f}#6n zZ41w-sQS?zmYb-4wooG*_ZThAg}C!UJz>^Cy)OntwA2#JMJY=KWK+Q8DHP1r85t2I zRYW_FmtIZhO6XH@t&(q14_;f7mnb)4RBdAm=8Y^&>Q*CPEa!1fhd$Pg`A{Q1(_Vu< zYzIq(Xk=(X<$R;Kfj*&BKGVkJiN9(fjL_g3XWKfVp)9Qd*TA!SmK2W$h0>a=SEVRa z^2J9m9{BwjNwA8ZT4b|a!MNh`PzADipjy^ym6G4or9j9)CYw&7G*d0sHc`b?EkVEH z&`EA#A|6jnQkTeBWMol>jhd>9P!0w!qY8`wO4R|h-K>|3@mgGL7wVXa8-Zy$)wUU# zbRcQRXwqy6O{zA3&RZrHUYVIksv3>ywt1|;ETX>El97|UY^KMDL+j}IVUXGcvTPr* zo9K4M8dqgQrb7+Fr{&H%zi!4}L!$j^nL0l;X_?-kGcC!;iH_AyN~o%A(%L4L1DH`Y zTeZ#jF;)Y-}Co6P8B>NHJI? zfg?mgH)$rE=ILlmad;UleN(bXj+hzAB0HNjC99-Zp(~|cRghw>eipK$v3uHs(Nq5% zs>q`>&DyHlB*NMQ_QMIDC3I&UOqVT9pwjG2WAuEWX_39d^( zRbrb}svW6k29~9%{y;w-p_*BW{<^H}dQ#CMvjV%}o)qS@RiOz)i$TF#9oNd&UP@1gR=tzTuAScZqn+ag&9U0v;TUTtw|G+ zb>=Hrj@fx7@y<%1)7x}{M80MoO!7roaA&Wxkqem@<_^TrU!A!ayXxn9jo z$;1XFJC4pT=W%q#;i08Fj+8W`7IF>qI8e4T*45?mwqAk&$CK79;x;VTb{k=m>Xz{#g!r{u1GDfZJrJBH7cYlS>2@Nh<4Tj;pNq)BxKw zNFt>x7W)l4P_k^d8k3Nw6fYf&@|3m%lblASW-OZrlEQXip5q99jkx*M}O2F2A=X6!vNa?uMu}J$XNw(}gq`jVqJvQEW zBw^Ko^hg0p8W;9&0xX+@U{n`D^d`w57*!4hcyTW-egX+Ay#$Q1phEU53l@u4+Iy6Mc9R=w%f?ZTTgPC!I*6HGS^$@jUF|Jd$;%H2@NK^A8YHe~MaHmLKc5D4L4MDq*Zdo;SsA$cbwT3gD|{Jg*hbrbI$p0;+r)L z97@4z%cNog$yejo8~Hk9rD-D99%e421wk8spZNA@GEPn$_I#I5vAYERe6=yGu;L1J zF+AD@EvHqIS%|AESv;2FHU9imt4;63VK#zs-8D^?Lq~fv^Hv;IPCTzi0@=LPI&CzI zU|^bt>9GV0A3lArxC9TAv@(t6#YrSIW&$Q1nj+QBs#6fM1FE~NI;(>Pm(u7g8#%Bx zH)3yJluC~67@SyubUHbdZB@)#$(?Mx4B_lQgHl%DvR91F1uSaI)pdJL!sm&d2MB_r z7>>KCJoWXU&UJ&)m?GL`jQ&FNbqjmiDo1_u)*E}4)lA4QFEb?ZH)Ge2CjgSciu4$B zG+WIlUx({nw&b#0OUBQgO+nVmBP;0`GacjURSCIW@UYEgJcfXJ8l1inKbam|klLaw zn2%49<|IZg6=W8$RJlB}Q*nG6@&J&(M5DM667RYWZ-q_!3-EKd3l%O2HwoQ>Rh^TZ zh|RCjCZ_e4>$){fO3X-Ut2rGLOLa@VDK=EFmQ?4smV_9ijc|pC&mM;>NF>wqlAy&# zt=Tl53Nsak;7w}TyupsO74IS|*JBeXqo(?g|NV5@G_F5K?4oYf$=!lBt;Q?47V4x8 z-9!Ny3>Y*ZFkwc+_?<(+HOi^*iZRVwAt1#F3P z?{vBRhz)Gksu-tC)L9HGHo%>m#FQFatX1r|QO6chm~EB2Ipc!1XlWzT2ii!C0JOBD zz0nFh@2F84DR|nWKi9CpZf>v}gQMukn+r)#f+2>Efkls;j+(_rToP(Dx#j)F-lTP@ z;H-ytA_tx_rANUGmsY%q`3tu3HHzlJ-pM##JJM3gMC-E0L-F*>3+tJ^c7hZ4yml8_ z+0n?06)|vk&MYl}>goH{nplcn}sR*r7Z&y-aj6nP8COqbFp; z!C<9@${M9K3g?YGbb`2@owtq7%-4)(#;wIouZUJ;5LB&HpH{iLi6BF%V)2d7##w4G zFh9>ac={V0_hAezg6Zg)CT5(Jk5&^tc5SPIBMY9_O$?qaRV~6&!v`bNaK+^L#D}v~ zJp$qos8Kn(p$T~H?oGp}mVLiu^O3lYe&?)F42P-13lQAt1sLl145ECdT*RR=J#Zlh z^JOy^$f#-U|8FNmmx-DnA9Ij2s9Ej9NaHe{Aa}R( z|H_UGIS6dy=k=&r0CT6p7@5(kuGiuQ1g>C~Z#>Bum#NG4QLT*_8_$9%>nC#Co4w(1 zFvOYeD1llB3ac2M^Qf%F3au3*4au_4gbFouk+cYdzR?%OINMs}l_eD!%VsiAT_}1O z`3WDhj0C)$PPJwoxMW~%g$&(dL|w;7)%37-G$L*^t5i8nPzB|nGz{{2VRgj266Po6 zgoPB=!Wc2)HH^aK%58->oMSs1Vqh_{HS0A&l947x$@A4_Hju;@AafEYgLdkGHaTok zv^)YB2C?04phK;&X%k^O2%atDWK1gJR9rrtM$$p!6qalqEd}$0RFs)UcoFD|$+HHP zVA)ud`A8*S;D9%VaJWWWAYx}k3pY0?u?A$XEHg5@`b=(TZ_NnRhVx>me@vw?5NS~J z)evhHn{ZV+-fBn~`TukFE^v}vcb#ALXf$d)+{_F%_|Yr_2#}3RzR$XKu?@OU&0tB> z(#+U~HP}5pEluN|?sj+2SmSsT8N^y3>=^sp6$MAz;D1v=fpZWPQ--{=k{d}J=C_SN)j;_xmOJXEzrs`)Apyf; zdA=65*=7~AC#vc%TzI%x!9hK0$wtm`t#{K-t%th9_WaOSn9ZeU##PUfPUMyau_xQptO7Z;@cIM1s!v0b?I5UPXW z0NCM#mG=6GDcPUMIt2dO@+cgTh=MWmviC+(GS;Z3A}*|_N+kl_>uZ?G=gan_i z4{z$CHL8lzqIh(|iOuz1=Pq&^@h$9O=v)(tgF`q|fQ=31eGC<1(ZtnJB*@fdyTDmQ z*1qY@n@&fuit=H1SI$+6hU{I!)$Wvf>oMqD(UL_Z?p#q+KA5H8S#Lj#Cw?WkqDDb> zNN^&!%&wVF@t5vxhI#INE2z$`!W+PQ(8^h2p!<@zW?pk-CHJl)>q(3?ffXV#olnKQ z@Zcrb=lG^o+6`LRO)(ICiR$jk#q&KkPvdn5`Lvc!F&-{koEQ_Y(Iuw_jDDLHFn*$i zwu_vj3yi9imte9Ibw^h;CnC(cpzUNnj+7;5)INjO|ByxT|W{;JD&c z>}%%%f2VWFiYq>rc=pEZ6%mt*oy%U4?p%6=37^!K$Gsch>pb8??2PMm=F7WxI}eQ* zz8l*EZz-a+b3+1w4Mpx;6eTvEvvDuSalupdjIcL#%|#z}u9_7&^Bp6)>oE-9RC&%S zdT%Lua#f9fmXkj#^RvZLE!FWY;pER~@@H&+R+E+ePgmLhw3Ug@W`Bff`|P;~&YA`~ z*AR5h5eB0kcCJEn%_WEH?s+kg11<||*rt2HoeKq2@>>tMVT^^NcfMXmzVe)@XF6dn zv@6pW7^0u8s3?1>UD#vW+97TFH=yp=0DZH_&6_5!SQi5F(!^E# z5Lms9A;@1Z6nB3XB76}k%!Gdu^e6NGg_S}9#iIr$E84gv8ZlbR!HxO-mxxorjQ8 zA7V4q0XHgSAGr;&EH^z*F!AMR&jg>Ny9}wpltb@!2jKa5?S8_jJx!gcKqw6uddN-4s14{k^uEGS54mZrT8G|7rNW!R248D6 zI;0VElMsU18j%zQVrwEqoY$UcNz5{no6s>kPDP2?4k4uzQ88gu>fW$&^f<0Vf0H!+u4l6CKHOy^f0<+lTP>=Hebu=CRwT`?@YYLG^flAqe`PxE8{E5 z#A1?Am=tNFM_jH~rDek2NFE6CSgq}w1TlNMLYB2_tGni4F=b9!?PP`cmhFwLQTsi; zfAY%YFTJ}Uhlz4<*`AnRqd~j0MYc1WK+zTT1UV^mqMPaY%BoJywK=RVJ^Em8+}gM$ z_vm!h(aTLkrn=AB+!+9yZo}N=gj<&~W1_N2xTVG}ZjTOqaz$MwjnKx<2A%A=i{lHr zO^Thp4GyZYhf+nBIe8Xr0ku`dyO&TlM9QXUEAKe0ir)dKAF`` zecHwC(X-@q+1s}XRu}{&ob$(knn~Zfe(n5YdSuVH!sw41BFC_Owzs#t=36o6EI(!v zzl__kH^~`euA3RM#qy^4G0syn>cC#_;`+569ksC6JAZkPEQKu8@;V94NR`LkA2N#>?*LHZd?rAI@ca>q*4fIMvf`IuOIt1%h*UOd82>GOjy#B#ed#Ll?{_3?INSnhBLzfNF(!(r7sNMLh z&TXl87wqAqkC5JooQK!UlIjjL022B|_4ec@oT`>e`L?Fk% zbZ<1cX11U9g%Y)fv0qaCR&y@rhDVxIycunsP)ld6_x-#043X9Ut7Pz%C)qlw4~9l zCcSsm7$TXD zB;FU%Feg}EzidX;jp@`9^{rci<|y;%o$l)NZ;i-#WYAp>^)RPFxFont+{`Vl6rCc^ zy+akUs$PMu*2qxuQ3_IuXzg8~TgwfMGY6jo4Q_ z2Fh{+N^h10c*PkVQkO=J>Ud3vz-S`WuzK}K<&!nGd2-<=Xh5%<;YPbqG{(9Yc*x3f$Z2{4leqR;*Iu1j7p`My!AL3nIFY zImP|5DO>q5dSYCATys=QZMzd?ZW_Fr_@QrdN5rT&YI6L;%)>dWAaiE<`V9^p*73-f z_htW~WHG3F@Md)InV`{I)T+hp&Hs@_(T_>EJ+j?x<;D^zLws+PwR~BQq@(`wry?rFnJgL+!I&bB1y5r1X7q^XsOrYS! z3szrjG2*Q2Tu^_(%z{Dl(%L)f>+7TO_hq47_scJ=O^-5B5$Id)(L<_o*;G?&qgkQL zn(6Lu-56IW%7z?Wu2wJHc|^X_Q?NyXruE&@^_D4HrYz&5jDt1ITNXRJ^tnHF+Q{_xd>!* zH72f&pP)2xM=f;EHqq1F-{$`45Djy8^s8I%;^?ZLm`J)kL2!(zR14|c*51A>2bQ*6 z+FCa`!8z`4=ANM_Qk1V-fe+HUZ*6_!HV%8MfdSVT@m;0fjw_h=_#fRDJ%G$(U$x`ksa)5) zz5!UH6?E3^A$|{TT;9byU}%ghv(~(bXfFF7ju5(95Xb#J!@tHPaLz5wAGZzms%%by z-rhwewMX}Kf4jQsm)_!y5GD5PtqV7|P?mSs+^baV^luHbgf$S;*~g@e?!htjNT*H1 zjO;1Y{!!$R(UF5a)wj*_WfONE&~XiBye_Wpz0Hk>;|ATH>Sa>4F)4`g*#UP?PBeIB zZ{MCNX9k*I2n+I-n4fCJcJqpm#WZEcz_!<;K{K4)q3gVL`qAzPSaX=`(dcC|@#y16 zjD92%TfT39B08E`Q+s~=+)((Rrp1ZYIxWq%0@LR#Bq!LYS@|-oWkyKf4tLe1$2NBN_T6QA zfI|*X_4xPXV1S(RFt70?R^ETixTiYrv2T`>&RU<%%hkw*H(00Q`7M!#@c{SEjmuLO z$jInt>**Q_0~b3v~j z+xVt#cr)L0$GpE|`Z@>MxO0KAWKFe&Xg|I^bJtMp?jstgnTzUdm)mq77~KQ83ARx^J$+-mzNhb40@J-}$D>1R4!G$T+2rs&a3DE2;PKHaKj7Z%y6aY& ze8qT?O$^%PAdLoPJP5NNJ+?-7&|!7~OdVdoh2CWrQLteio|q|i;fmdd{evC4sWu)RGnHPqY~Fn(wC}tUnZL$VY+k3k<`b@1y>mQujwk$; za8%;ngat^gSRePqWphdQbnMLLs#PEKo2>pg>yZ?0V7HbL!*pYR^?<8l274PQ;x|W9 z!TJ5whY4Zov|zBnHhkEf_WI_gTU@)od5+*B71dHtnx2fe!cT6OS|3dXk8P}RbQIdGy>2zTN7vu(?V4T>&`H|6 z`-Ci68)9!~$KSD!bRtb`#}B=YlD4`w)-Q;!+1CM^9J4w3;JHb>3!TDxK;LW+%pq?Z zYyQ2qvFgDKFd%*WgG3?dAUB7+d%c+pHm(74xP8<-HQA+hW6Md#vo|@B%e~qlz|Og? zE9+165WsHmbr_1@;`E`({<&W~tUj(>zf9bbDOxSjEC4H5ZsIsGKh4LOgH=a&?K!LF zr)#3~c;}|WImB|crbEpQTCCpK-rd+=_cr1+5zfgwOqi~zC+-C*!nSqBsM_!x+?kOX zL^BGi<;%0w-&E;5d2mfr>j72;cuk1g+U9lU@!Zx5Mt8#be4NI{mhG6ie12>5rqQ%C z@CQCedlz@t*Ue(@lqIa}`5O&xo>4s4#f^PFRo`Pv`e?IcjKRWQ8~>(B(-HZVS9UjU zfa0bbqfQ-sSB>h9qZ?B}k$U;mB|Y#cfn>U+zxr*xi{_Fm>gw5b>8s|dE9&YSH?9!Y zsi$qpz1%(LD%xABUTzY)v9b-0-gF_KdUW>c&gFA^<|=xtp6fnht|Ku@w>57*^yZF& zDor)DA?x+UZE)Noob)^q@72c*%Nm{IICb5sg{BjRK)R?tNm$pdAy*G{Z%wq+z0ql^ zxWXar3V_u??XDTlT9qx>#z^*N$K=q@?0nc%=S^3puDM=xJLW#-zz>AW3oQ-|eX|LU5p#;D7VXg}NF<2%>w$C+Vnus-1Uc2}kznXEop6~`p304tS0znSrM zR}5pc5iOPySzTU?ZsMvO%S_AUMfKcpIMf3vVUFY~)I@7?@?wW$PE@vyh-yyO*Y%N7 z(rw*5uuc$(4YHePOpB&Hc-eG(Akzw^# z?@({MzfBviZuh#{F`SriZaw46y6)Zm21Bs5n%IaDhnTovV`BZK-ma@`)B+#UIl61k z+U)r^jo#w#n>XnFkfYu0w{i5Wepo(#1w$!J#Te23UHfiPbaS(J-Ivtz=0q39l`P6w z30QGHws~R|d-e^r{X6>Fv34g*|AX6)kM4ATcguEUH$Xn5Zobx+%=PW9$2K1Kj;4v4 zUWAiZxKrl>!N=$|{_gq5kf^S2?26D*QPBxKu|=-7+q>PGFvo*$n1Nx;k8b#!^JL3) zYCPmb3_yR^CGS?78$0Fp>Mju>v$c$`b$eVzALNvb3NDCH@Mm_R+WL-aOVOFK0~?}k zuJi0{Tq?)+9(-M0Go-oOwCLWw5g4>(>4|t~WCOjxS9`p_-5M zqV@EvN0znG<1Suzl7(nc+>Hqv+ssoF=HE3(LsqX`;ehG$sM!V+Wg|3uMt0W~;C0}w zsYeu53Fgi|;BFk$dgq#})xnp}42+GJqpz8rxXDR7Xkrc;;R8qaz>z(4R3}ZB>jw9C z%qF5vRxPtRkrNzsSjsp9m$|CsBnMqrvg3yhbJoVIju33+355?@43?myUqaN2R}~Vp zdTCDtNw+61Fud%ZA?#@l;yVg&z$J>IgGM+*+!xQ)I;7gSJkiLQuN!K#Yc_~c*G5m$ z&)t20ggXR81nYonvV3l=zhm;2n+*4qZP>CyX}=S#OjPxaP4>)De^2h!!`?o4t$4o4 zni3Bts(D&vh^J*D6ZbbIVW>gFOsz%3_PX0t5AU%e56oK)T5P{VF(S5Rrx(6$FB(Df zZJnu4fFNr*9(?ZszgKViA-40GX_&fh_oW(~ae7b%V|d(K6VC0quqcB?lfT?&3B9DU zjMi1Ru@MXKA7?J8hWf*27-ikx9KCw{B7e&~*L_B9jD}Es82uO(x*cJh%{p)&$xq)h zMO8E+vQy$^!0Y}NGqut)70kQ37feq^7e-$^e#l%J|D=uakI{Ir=HR}gpGK_PGR|sm zebReG&^%cly=mrRr>&WL1-ass6@kssI=fsusm(@nf8FFoId3x6^!zoG4uiec=C411 z$Bf!p_^st(do8M-L)| z#~83Bv|~wF@2Lv0z3UjWSuuM%Nc2WJovCJ}9@h*ObF|)T3J;S;(P`}p+qbsgwjoh& zV;}m*KG%(Rt{ZQ{_MTqHHHewSOT%?+mU0y5p%^-UP*-fVT#U*E*m z<1@Wv^OkM@@H-5KTgRPlkDfc|7Os#r*XsjcIlh0uTgNvKdGWZyLGOl;@tm~eiQaN~ z=9(%fbmQO~#vnJ*#swScq3TBSoxXYSjR)pE#m$4CGT3ua-z-|qblK?f)OQw+iLRM@ z2i>rvkK6!4Z>)pR6OS>vWfcLk-rcgvZc{`-^Wp8xyG)%TwN;cx%=xj=7|M|Il;hC5ub6M^6?_ z7jD-z%I3$i-frHyuyFe1t@P{kiw%6KfqXqz&KP*Nf%h1AuYrMqiGf1{Uu)p~2G$0i zHSj?LR}8#p;F}D5vw?3l@T!5E2JRTRZ{WKagoV>jK573vb;}}iv&h^mGB=B6ZWhff z9ADJ(;FN8Lr${h{YHRm(2}GF*&_2F?87Lm7wV#WTl`F|Q|=&A2Tu zF+9{+X6TtKUDxypENiAu7kX;ZJiExNxylTj;NsHKG1H)hnv*4=!R>18*h%K+&NIiU zqtZ#C#Io8vVG-$srgwR1i5a@%%xx4vrDMnLI&-_OEiNwe!(KPV7oE9->&M)UJI^fY z0rP|_n_5d}?$mW(jlL}}t5;^=%)oxvzQxByaPAhpTwlr%2|E}T{h_mZWXb*oE-k<4 z3?HrcEuDIIqDPjO?lky!`rS1ZG$hM_6J|D+j-6OMeu9buLn`x ze!csXiy$Savan##VnN7YpXW&$JU9Cpw(0>UkO_n5{| zbmiDFOC`8)yM|ihws5)-=`pCfxF`f&7J`eA2qQezQ463vFHqB`!jlFKPK8=946Ewu zTSQ+zW8m|A_NnhaqZ^C%Be|jF_B=EF-Dd>u=DiCi086xf%QF4dTpv5Rd{X#Em&_kV zjBYM1ozzWHL(}VHB8m$Or$V)FDgrgtW{lN?r#^Xy#k%)xQWv_*f3$k?*4t0sekX-f zPkrk4lc%2gH2tLf=~Ijl&rs4u{ky|d`ZT56?MFZL8OS7aL$zZk?l^Yh&SNJ)-`n|= zr#>z4*;`JWO7A#xtEPs*7$Gc}WKe00NyjWM8{E-n>4`<&r_Kwl?ZT!FJu2j4W<74X zRc{gRmM&yWxP-p-ZxZSoknu6FqWL$QdXdW;+E-OP?gM`gyyP`+i2r;tsz znRI?Eo&KI$&wkIFRAS0bIG$pcvf*Whys{y^YU0z$~AKO^v2fj<=ZoWK_Zv<9F4D}lcTytgNCTtKw= zy>|(m6nL?~O9hq%v})gbx4=CD_X-38iNH|cwF37G)B5W5 zDzGeYM&NFNdj#$k2m}&=p}=be?iZ*9&I&vzup)3#;7tN=7I>?`6@jY)n*uum`vOl0 zyi4Fofu{tX7Wh7aX9S)V_)&rP3w%J}g91M*@N)tm7I;qJmjym1@M{7e7x;w0?+JWT z;12{oCGcs1&j@^0;12~pC-4P<=LP;s;I9Gys3&k-U{T;Mfs+C+7I>+^vcMUEy9MqM zxK|($NCbvvg)LelViuwp5`=B}wnfVp?y{5+VhFtz?^`y^1kpi)x8ZIqEdCn0a|_}S z>`sJ`|Eu~*RvZft`nV)k1H(GGNZa-=_fLhVLK@O-!xy0`W+hwB1^G3?_3YW&Yt|7Xt}8iq^{su0}bt`uC4@{7+V**ZYFLKzH(f&SXAB!bI8#8 zDQO!rdlK2__`<1FCBDXpNY8vg;*zFV9|mz<7FaZDmB=nKKV#_T(TZV^eozBaZP?4R z_u4;!{gX&eIQ4A32;*QBtB}1Y!@*wFyRY}E-a_xVG~?q7fQ7$1{&)O${1#ofRp1W5v0m?v zkh=EYz2|$Ed*9hx@2&OrduMu8ZTLg{^+$wNF;5Grqtato& zfjb256u3*^MFL9#Um|c);FQ2=fiD$!vB2-Y0q{Qvd{W>$zX9+zflYyH0#^lIqRL+; z@Z|z86?mDz%LQH`uq^Nu0^h|X9sheOeWkz|fv*zyYJsm2xLe?B1-?$;>jmx+c%{Ir z1nw2+3*0C0YJor?6&MH%1#*FJ6nKrmg8~l;JS=ctU`5~&fky={2)seyjRJ2H_*Q`@ z1>P<2T>>Au4X~ll|D;N{Edmw=?h;rM_z8iZ7Wf%~4+?z#PQd9ifNy;T;M)ZLzQCIW zzFpuu1l}U>R)JN4%K~cx9}_sU4EQR6uNL?kfx89juLLv#t-u2UX9d1R;GDqg1s)W5 zNZ?_C4+;FI0{>Ltl=^o~U`t?IU`OEX0=oix0{a5j1#SquL*RCSI|N=Nuq5y=1^!2Y zpI7rA7Wf5$UljNyf#(E1BJj@zJ}U6b0>2{gs{+|q0dj#-pb}^VzVJ1GKNa{hfj<{` zUf|ye{Dr_@3Vh~1!2d4re+c}a0-qIljavD=R|5W(z-I*hNZ@&azZJN6H{g=M8w8&I zQos)jykFoa1U@J5#{z#M@OgnR2>hwQ%8LQtCU8Yy=gR?a7uXfp6L_b3Emae?0w_>{os1pZjyPXu~eY6}9#1a1)!jXZvp z0v7}>3S1I+gTNaF-Xw5EU|rxbfyV`&5V$GuPJ!?*A#kri zU*JB0Kp+%|1Y&_iAQc!0WCHgKTokw@a8=-40{=kZNr7hsen{Yl1%6E6#|7Rm@IiqO z2`q{jeWSppz)uSNqQEZ+JSXtm0>2~h34z}gNQ5u1)FKJ510sP~AQ4CfKKKZruYvei zD!u170Z$8j;7b5MCGgV%KO^v7q5Ss>+^J>%KYuIWe-Zd!1wJkCuLXYU+W^1z?SNkw z_zi*I6!^HnZwdUi!0!mWO8xr_aeI0TZ&V4I3I`M5J36It)kh2y<5fWJ|%{uZ$C zr3F3Mh#uL}>|J{##-RIB${wtpQ`CESfH=cRwU%ukz zpT6wFcWi(3C*ODDZ+id!)!+B7x4rDnAAWiH(mTKM|GMMNZ$0&sKlD$Y-Fo+}FTeEu zfAilx+}`%;554YJ{-tGEt>VKb;RdcV*U zF7ZdWb}N(L>s?;xef>l0yX308dEdqQKI_N1j~!O`JyPZOajY3d<2l{yrC(gVx0vd9 zsLa+fUa`5*yLaxR-kas#^NlZ{^32QLxzLN}KJT2&HWp!h*S)iN;m^#xS`(30aWcsA zw4XOs!fe!0zo@IKpAUj2iNc^P+o0DA7JA=s_zO99cI3vcHdhG>)RgJJMd6z(2ouef zTYN$E#9V>A*@6g(xgug>3ZgWoAj)D2(lks#s9_2sHKrhPW8Qr~e|Wbjk12@yn1b-g z6hw+lLFC93M3PKFWXTjnnoL3D$rMDQOhIJI6hx{_LFCF5M6yf)$_yXjR|G3rn1*9;0 z<<-8xT-z(5FGRi&`$FOisV@wCfi=s2ykh7Jxi5U9FTBPVUh505^M!Bng>UwS`+cGC zh0+%)U#NYd@rBkG9`J>;zHrVLUhfMJ`ocrL@USnO_k|T-fCuv*ANZ&*T=0d9zHrGG z-rx&w^o2M10$iB?Xa`Pg3xD4i-s}r7U;d-cclg3veBrIWu<8q!ePPWPuK2>bFFfW8 zkNd(^U)b=4@AQSY`NF0zT=Ru3U)c7A9bb66FYNjP#DM?!iW|Q04qte}7jF8(JAL6l z@P&8z!awkZ|IioyBVTyZ7vAj)-{lM6?F&!&!uR;XKlFw7_`=h^@Lpf|USIe}zVLm% z@cq8<1HSNszVM7M{E#pFurK_GFNistVR@e~{KvlVkA2}sec?axg&*^UANPg#`@&E7 z!cY3bKk0)l(gM|Y+1Or|< z+3ShLCvDyac~JBRVK(e1RXXe!dE4~kxDJvGK`V=LTQdrqqAcR3KWq`ml0gyn%cP3> zVUp*=DzA${mf4zhI*5ZL%KJ%>XUK0=+%MB%*pG@JtOj|W*LCgQ-o$kg)m1;pg0`PD z88w?h(vO-vEQVE))$P#oY}eho9Ar%}tovD8&~#l?{b5#?G@T+ewrvvxJfIJ2v$(3N ztn3GATlAB*&gghi(37}ssTlEEv&PH>i3Uk|>Gf{Ml&Kgi-%47fO)=<~Wl;B%FmL;L z8Rz|`4WgtO#%a;gir!boaUQnApdSwhVLuG(xL>pduMYog9Uyd36mWc9O&@!F+5LD8hlVb!mjj5Z^_4J;`7 zdBJx_4B;@hW47W3D-7yvkSBb7lF{8^kkj1;ECPX>Vbqi~?~q~Pt)_r%NbQx@ zsOYyv9rlwr9rW`!$@&p`NR;Q%Fsa<9#^@|*Ri*tZ4jI0>sQX2l)nH&Ttivb>nwf=SKFkTqD;K^z518oH&#x(UL#Dp*P(1T|0Fe#wIC*TXW)gRreiO~2kA zfXYP^H2pNp7`A%IQ0L$cuc-2NFaW7yL!qSA>4ByMu_7?9PMKu}y#~KorEQdf>|u~b zkz4t7kcKRzra#CB;9%6oUY5I|9~7W8Jaq5kq3nSwk=rXcT;eO=oI;V=S4 z>L}n#K&O6LiI&0&hb*XQFmQv!un)=xCdvX-O);DTe2j+;pFWJUB1mkTMNslxS=-Ns z0Rx{zns$~%2H$GZdJyCs!z_aTV%LeFgxZH`*l&UaJc*&Z`LJa6qauz&entbnnFoID zqi6zk=$(M}DDu|gZ(WL13>h2-H(_>JbD@wU3I|P{rA&aW*`(>94YR7>2qBZA z%yWFGpw63ih8~K7J9Edd?A(BAD>)z2Gf$k00CmyFSCj-MHJ~56_{K!VO!?m zFpOg_nhdZcNouLv93&2~ZIofcs56mG5(f;4tJ&7!0P%y7s99%84lRYB7kwtNig<<| zLr>;YE5DI;w#QJws;(foDPzHigP_AGFZvM-Buo%CD$ncUHVB~Btg|Ad9}WB~=X?5t zB4~R6 zpAUOV+6LhyOQU|Iwco}`L(9Ehgk9qB&-34AHgnu`^!Sd2-mP}OrKO!!o5^k{X+aZ@ zOqfS;*^i^TE%G1>Q`r;^GDU5as|#7w!a5_?L7t~oKdvEXX`AqwUa-OpR#z<)vy~VU z@`0sDO$r_lgFy=McH>c3brfcZgn8L8d?lg>jScz?1mf2)0Z(1c5*fIzg=e)S;$kRC z1(MI33Zys|RmON&^2*Yzs-Qn;YY;=&Q4FA=Z5Rxirm4X!FV-b>6~<}aADC~C`1UeG zz^hsaYtmFz6njD(4JA9F4X_?Xl$e*I$|anHP>eKaTKD!Usas_6f=?(CiJyE?m{N-C zB;}LxG#3u4Ud)|g#!gD{6og<+rdFE%SVC$H6^l#fDiFTA3Ike?2V7*VO&e2s|to4lxTg)5Sm_=P=_#SgEU2E0O9S#oa1^mdYwLwrK-mrpL3Dk_i zc7!%2PO@|!rf9ZD^;Wrq9$MAe1iNlJUbN6#^cjWRd-8CA@)Y-@K|0c6y+;aVY|!SBAd%%7MvzfV!BzWpF(eR~B!c!O)MUAf zE1z1+64vBo^sE1=@8UhhBikrjmpaHiQy+ zirP6u6WKTnsjsy$l!7SKMD1>qfY)UqYY6$5XDY;&G-IIZxI%|usD^VLNg99$S1(Uw z`RWV>+D0N3whw6#OGh#(?doi?RlHXg~~fl7ey0QS-c|3S$NK7w8X?F2juUi*{Keb~2|? z6y!zhFtUI`LA=r4Vy8}sS9>qf`8AwzTbN5W zfVm9N*vc?x`rxK0k0`*Q)6?oYt(zR2C2G@zEEW)12DBdph`2RV8LMlv)$ zk()woVxQ~>^52#Lf{&&_!y32f(J||~8pymQ!305#QO4SfrYPF##Ipf3Ck|2N2T`J_ zMefU`S=N%Cq4a2sN6JNxeN2r2Hak8B`5)$_1&dXaKA@GQby-(s6qeqw!4cw^ACSun z#7C$y9WBCAv=rkJx;54e#%eybJG(&$$L`wIn=Zx8RAE! z-UKtGY%^GbTuo>v1I>5j7_6~IA`*(wCM7y`+YB(wIs|ONKagVBkE#|{htk0s1Ox#q z4Qm0yv_mWGsu+a_)MV*NC5K|j?t)fQM=|EAwsj;f3fdSOEG!#yKW$1gODZ%Tt|qXr z6oalq)f)L*LShta@)NA&IdmU}PzBgd1{LO}Uhf+gdS7?=+Pher5$`NN)Z97?q<~i% zC&(Nq1*xmxRv9uea*E?CA<}Ho@DXvQZ%Sh%%OR>=-0jmhriKG&3gbq_-8qUy0Es#+3jecJp7SP{vj|cni89aj3U+ z9{Hsz&_=N{yP8lN%yBTG8Z(NhyJi*kS`85!b68*)Fan_AEk=B&K&%z`Na0prAi&#U zXo!=ij*!T3hk#8j4HXH}0=9Y-L)3prwfz>OyjyYv4g_oe+w|xkzupZwD-V0+J0CCD{(Bw{@z#fXp zs2pPQrwdwX5Hbw98LBdB7q>luM(>YhN6_Z+5azPny zn)LW#jr=}rVh91uFAH5wnYn_7p)8QIz)zMi1RBFm8nj?+nkC-G5jG%4izy-tvBx94 zvy#NrV2o{46dB*?<_HwRmLaRJ?4M{;Vm`zHrA1!C=i@Z53-Vp z(s<6-u{ckO(_Jobz~TWqR*o8ocAyUv{-cBrV?(RqI@nBtIPuyZ2svyJzR`k3cV);6 zP%%);syH8DDNeDW%-4s;J?W51$?wAeDFr(LU68JsH;{geXXt%FhKtO}2@zGXmEh38 z0ZSLaYEX(bF@zuFvLoaS#(bd~GjHeJ_@MDx;+2s1SW6W`fRO;Y0prLJ#G2YoS%hUd z3otBWR$|IPYRC}64+;|UGL~`(_K_^Ynvgp0hv(zKMto}V%&1jxfHjZB6cwE1A*+E! z85}R*iAWx9V~|TV1JMKQEH#euwyHcc<56tD^2&lJNcNBlmI@Z&AVSVVK_GdTkZrsjM0=Jeyf}mN zC(iPlVv#H&WV5)GmW^EmnjV9M1v)OS%oNUi)RfYN&XD37Xz?6D#!{TI3BF`m1@r<8 zzf}~4{NH|ljL#U$fhZ+Z58Ovg43IrhqC!aOfKEE;gvASQAsQe>9}piy`$S$w0f}(f zA|#iw(^D}&H@LRieh`WClo+h?3^xG&loI1#j_$&Q&eu{7Ua62-79N}m%}7xa1O((M zCXW#LJkCIUoYP0igyqU1Z6k-37)a4;@%H1AU;^-1Kt>UgBHXt{>!dHdh_5f{!(6S8fnX9F!51k2vPnU}S=tJ{iZSb8wY9$^Vm<1#br95 zu)NpnFZAv?T(TT>q%&xUgdjA|t_nR}#Cr%f$f$>=0=}W+Uy5kXpE32I^KvNt0PP8{D5K1xg&<-pLJh{Hlnt?1VyQX`6)#>e#xa{( zxzjd^M~$OX!9oL3L_D5woe=v#)S#h8=(Em1Cu*3me*4fmh86=jv=ah8Xo(=k^H-s9 z_Ij^c=zZ3M40%6)P=6!9*md%gDnlm=2WSWc*kICZ z9EZj2So0)Z$7W5};o2B~v9c8et|zY;^KvWO74+F3Laf-hcZ8pc3~QK`YU#!8$YbR_jz zuK&(jtQ6)(I7A<_8(l?e4{R!M@*vF9#w~$bp@&2=AbBfv!RX`+50o4Ik;y=b z_m;_^WX+?R;5lKEQ=}c{RURjz71|;pHpQU>+7>Jmbip~n`i_w(SpJxkLE%9iAV^f6 zZ-8O}W(S!!p)RaAiN{2^;nBx3)K;-9K=XqHM&_uQkqrq7LAEc1wlLC|5~KxGNBX0W zLx`QzkBNHtulZ}w<)Q7&ELJ^`jS0wDRnR%eW`TCZ ziVotE08DI7PTnAx4(}vLNFWuoGm~(DhYy#KR4VlGMxI;IP9){1#2?&8JfWtdM2S3+ z6_4lx+RKO~IEpE`p4xTP>2FyTn5tk!F_=a#uu|qR`Y*B4e)fBH0B0j{oaF~e3!8g!IoP#Uy4?IyRa%iD2)S-;<5%@J`7yuwegU?G18P8Zt_nI2|y{ zD_pP@VOJQDMHCS4E7@F-@d8557iW~Av(wFp@YM#UCeJI>qn5>FIK)T{Er$!D zMwAZ6lDw2f8Wdo~vKpEK^uk&nG(p)a*fADKoG;z$<+HQZ;&#F!f>W@9C?sLU7s(jQ zpb=q;LzU|m&r_xk!%&7zP0R;A&9}3O3Z{iZ19iu8bQEPEZ0F+c>Y6{6qB9mO7SrU9XQxPEaV$^MK)1OG&EqO-(b5tdZ?8N$TRw8N4J ziKI=%8x02--0;mJV^@#>g_!H@3Egbbg8PX0;Hd;MA~zry_y$9nf-zs(niZ~RI45`- z38NK|NN^jzsFc8LMIm6mu{9N9ZWQY*q&gx!@&8D>{iciuc$%@5W$ugc^5gJTV4o}@ z1dFj|OO&es+TJ2g*4W!!oA?uPS;$^0M`(>Ok7`B~LxXlf^!^}j-4_wAKO|}$5iQ0~ zL|+(LdFP?QaO!TnkqwN8YaJOFFDEa-R}$Qf=Rt309ruw|D@@@;$(GFfe2NNo&XNgS zySPS>G7wW>+&MAc7}TNhxRzj1c=5dH9YZ8cgjIwQo8^h!1*HRXK8B^5cq$3sPVx+K zctLug%{V4tZj=a_g8&b~Kw%}}ly*>u2%<=j4N51%0&yb{sUedOqSjf14+|3JYJyx9 z91eG~+}{N5W3GlmL<6`^oW>9kCVg?h;@EiZt4;L0liv zq!uR#2P_qC#{kP@fp7-K$x@hH?ebo#fkL`;!bciXn`fq z5m*E;?C*u5*`ON8U~oe4m~fZGuSjjaJ9!z-{yV_IQP z#;{B)EY9B8*J5bIMF$H+gpw|W0)hn*wPP3)(aWw5MK>Gaw82`S5O^X%AV(ONX;YR* z2riN7X*2KvVG-LaD(s*v0EGc4A_YSS0TBtJCaMepZA|KX*YAaOd7;nm2(!8&1|i7P z$|Q+LkG2aaV=mVz_Sv>di<&JaZv9s9G3X!Di1iIJPqv(|kh~*ke=0|i!E`jvps)3K; zCPK4gdgre+b>X^3;(|GUt&$6RYQ5gaQb11K;py7V?vn-0%m0Aqr1(F;m(om%rAkjNaZrvv&>j@ zSWB_VA+Qj=$DR=j~xyH5Eh8d z0AU`1geAy^mOQOtx2{bD>jHl@`@j(U2-w9Bp)FN7Yw04p$qG2ggwx1}5feCSZb%M+8M;{wxsxaIw>AxCplM61QN6p{;P#oJeyv>Y)Fi z>@W~eSJV^)>jv8$yc6NZa|q;Ac4IL{C~|ZfVNV)%BA++`P$}LoFNqL=LGS`C!C{$N zm@AcFEl5WQY!!N*_DgDNF~SgzBEef)HP&X37TrPKlQ_!;xQFC4%@%sm;aq2SAi9)# z5F=PA$^o?i{H@V5KoFEXq73mmvPIM{_5n5z!X=T_3G!kp5aICT5cyDIiARtiw8ZsV z3xL`Y5;&2xre=XWjS-VM4{;9QfqOyIr|_n3r=f*X)R{Sn+r(0U$81JISSJ9Nz+h~l zj=`gu#7O5Ti^L9Ut)s(AK|o$b?L_2bDII0|m>9sRNGpOoFb-lcLVRUKX*V7LzU)G3 zU~}xBU}zn!WIeHQ6vY6$Cq2PKh#JST!r2fK_J^0pM<_)ohba<>B8SmZa`6Bthzt+R zJqsa}SdcIDk}q=7)#s@Qb2iW++Gvv+)*?m_b%@vuMMGjJ!!U;W>)g@dkgdJ)D-qxZ zvJSy*EaVuLiEM#G7Y&C>wjf5u91T_@w zw*4W*SzE1z8;bjgW%qCR$<8F)W;i05vloQ0>Q5J8*&;?1NP?Fm1|Sb%L}2$Z$`x`R zz8&oEAZ)SFd+itb!FHbzwy@oe%h&fO-i2vBfbjCM#CR|buqAA6=#qrvuydm#P|C@Q zRZ46PMhK(}?VgZ+%k~tcv=r(~%p{S3h$Z(g^j`D-uU8!osilDRn=MGC!XMBAu%bXg zB2*bR@@Nl{6W*%;Te_mdux^7zHO6&xsY(kBtsbR^h|;4Zv5PvT!$l-=P)?^Gvg8xQ z0}nzZlU~nEW2a}m@*mQmq7p1lL_~!XmR4XjRYaLQ#_FZw7U}_l5c{N&7v_g)PEZc^ zvh0HvozAdl3?~^91AB(V5YbZ*(hwWM3Ks(tN9ddF453bgD#cI)zmWn4alp@yZyXZ` z<`ZyP!3!^-GqTG~c7{z-$b3*rlps2TjSKcA&nsJe(2kK*Do0ZZ3`06l1f`*Q7?IJe z6hw=2W`G-?odiyX!LEXtP26HAH2_~DG7Nefn`hb2jnxJloclnm=%E}X7~82S_vNrg z=7iT{y+@9R|Jj-YJS`PFB5`Ff9@t5-Hp?`iZH35@=rMttK?Ha#Q4DHpwnjHH9z{@@ zoQ>rO|44tb3(Z&fCuZ=`@?vN9P$?TIi-ZOfpR6#}lu$H!idh-eEef4bPqZ?w9E3hb zmM+WfhBpMIlSP64NAQ?e_|Y>6IYo2DZNsRs*8dD63POJDuVPSr8*?k zH6nseTZd5?;R7WNr_+pA0i-FMukLii4Y_V@2o$9>acfvS9r+=Pj;2z z^@Db?d=cKX=LQD?@i8H;Ivg`c`TyKONL{J`LbDE$4YUg#JXO?TjrfUvgXf&Ff<)W# zU=)(JOfj(wlF1-g$mJz&q03h9uEvt_|~<{1X{{Y4P;0O z76h`gi$L2aD<=B|;MCas)$I_wPob3b&BrrUL8 zD5%Ke0CB<$k3mkaVSTa{f-ngT(*%Fot}84U&WJXE%8op)z3V235l;#6*K%Dty9Vxy z6n6#8OW``0ps|Lx1lF^f5tRwsK{;|u3)gYp@`2vKY z@ke&3RZFfD6mV3kNUk>o8&oO=6>|v7pDkIauC70@M$|IJv1y}Br0{GJZEax{*4B79 z-9!!v?7$BR0Y;X?LyG)>oQ;HA;=00BL^=mIZiEb(y~u1fVT7^zV!MNCM&urVe=(R9 zQ$F7XIYCDBjh(NeBbsUFAD(1J(y1}9B0dKr z$&frm)Fe<6;hSfOykIK}qKI}Vy#T3~Z z{1ZlI+hof-K0bV-Y+HmB)KU4m`)0~&w{X|wDJCYkh9N8Vu zCnEj8H&D^Bgc5uVOO=YQPs9-)u{(jd9K!LKZRQBc5BZKbTPgH@9_MFvTG5ZH)>B+GTY zgdm7E7QO&={q-y7ru9d5l929%?_~!m0-NGEKn27^_Q>JICWzc8aKg%tw^c!yY{ArM zDnbeg9UH3>MIn0BOxX*-N!OdsqSHnt77>Q9AyIV1&w&u^*<#NaChn4`XSlPSFeTJs zt;5Th@+|5oQ&ju zWPE8|U0wCzctT*b2nF6s%2MnA3J9tzJOkSp`(231BdW!|9s?7CE;ei2P?{x#O19P! z-iqjh41)qDW9SPQ5+XjfNTP+#@hIf1gE=8Qk?>?#oc7GareVG@43bP1lIr6WRm9-~ z;Q_LlA_ZZtMg|0pF?bT33n62Z0Sg|1;RTo`Ci~Q#CkzvLpbg>ZgJ49>=NGcRWkb|Z zgbJ|Qt#kr4iIl;60-@48VcTLRC3Ns4p3}^v2|B_#Q=5~{b&hU#U~u!Yau6B_Jd=29 z+)r3ySX}H%AyVBdWVpMbD(Dfd;$To!kj}Kf9uZE)bew$3MR$b!a&>j<@pVi{yEhMT z{1YEWhJvKuV0*Cw5*t<7*qsq-T(hT)SQ$G_8**038#=P_#&jG|XOU^iaqe!O}-9OZ$DDPs8+0 z@DB1`Srdbku=x*3m3SD|r{)zIDFm@efpwZ4vs%Y&b}dxXQ)inhlpO|RraKu3WJ zDbipRaRd#;jw2h2oZIjoOEPF9p&y|v0_S=URi(|mOv9k zh8?FOx{dik?Kr9z#WfB@*xbCncXoB}YG=hDcb4SJRFFDaG}#$Y3ka2ismd0NtjKz> z(*d?(WX7yZ?o)c9U37#HARi9#o*>3Et#G;dbkXIHP!`utA5gwAaUt<)dlD#tYC`-h z${s#?0vVC-eEwR6Sujf&RU&0%R1Q+|LD3sF_hBa`a58X0H7ZhoCV?4~O=FCiA|bVZ zhtOGeI}=vS*8HPPYUGzFu3X#b1{dL73z1xK2DSKIh!2B!R`depL_q^XY-&!6Qoc_3 zEcdyNP(XkS;lwpogam^;n_JTYHZp&wxrzR;N0oP%5ZkE9`hl>A-4dM$hqR1jH5=Oq z;U=6D`sG$Jr!^4UiYbGgwoqAQeAXEzZbDQ^{zdwyN?z>wLi`ASU6k0&f<}%*O@TD9 z=>j|^3XS9^_|%n_iT!LO!gE6sGa{^MSOdOU<{39(PDjXS%w{;HCL^)&QPR(-H;-ce zUESS3q*EB{*orQTR&31aqBjLmahUrFzaa#Mts@StNp?%TDe*Zx( zLOtjdVUHMPvA&eV>k^xM)H-)vu?d4ZYYbGysKvr&F+ua>z+`_iJ_|lQ8j^04s7~7p z!sH0fCc=!!4^e)IJ|V%NxFX)d7(pp^+KqOYB6bkuR47IQI|LCk^p^z-t7ShnVL-M` z939|Vu8kVfm=sTl!pUkRCaT6!#W=e*5ftMJ<0E8QCI?I%a`TB7A|XR?mCB{pD;IjN zJ6vOOV<1#9flKxbjw!~BEOODwB4`Tuc4Upf>dc$?V(hixCE+~;Es`rFa5@FKd&t5j z7b^LYp(+dzRtU`IY(8S?Aw(;<>;>o)hZ@4k5rrnDaF<$%A{b8XuV+;e(uF-LZ-~>d zV@r5FB$$;#+L3Zrg!taGtq3NaVJTS+qy9L6F`*cxUU*a=EXN&;6$=ZIX)NHYV{##+b9KEsYtC0E4-Llh347O;Ij z={Ikm4Gbeotv7`rs$+1{cRu+I?l5e8b83;!_<5+2yN zf!*^P$JPt`8_4(SBe6 zMkI+(Xb3}zoS0fL8{yExYhydm68@axeEOw=_Hg{UeV zQr`bh6d)Tz*-)r7&fqmGMw`LWAE1&%YH3U7QPI%KpnpXnUuG}vL^tqINHK!CLOPTt zgB|-AdZ5Py$zxykv9jzzCp4B&39uVU%(&CA5y(PMxFen?He?(%FW4M*wzt-|rgF%V zaOqo+CM>3q{)PYwg|=a>hMpiHu^FFkL7$bm5>u0twb*2jG7V`a(+E>Za#TDwMBKGH z3m}s}!+XGxyD)!aghz^k@&s^T8SIG@z<38z5wqY(DXFlu?~q;TIQ@ium=7?sD+Hw? z+YRnfWg|bryD|F8LsE+(n-Kj5=8--D$wM+Fp}*3T2kfjt$6=R^9Smt&h;on))+se{ z>l2TUbV=rN5SHCViZq?SFMBlTooUAr7^8O}5t*dxM51F%lLMABJ=l1UXUF?Su|AQT z$7}=9K5Y3@acm%2ar_0zuyGe;Flx0J{H@d}S;ctN0D&|sdFw)xDAtWkV znfWm&lWqqrL5^0?yEIQmkEAr9^^wbXaz;A?nc^`<1;T}HvO^)w;nXD-MW?Z_e!w!H zCD!a?YgjPkVvv!KF(Usknhf?UGByz1DJS#%-2~r;FKb7LRYV>lIjc;*GAxmN13D%HL~s&Wp-IVW zYhtA&^$3iF(0phBR0>SgE+j}Z8@q61r%q>KzXC}o@arpDQYem8z+O5X&O+K70zbfs zqjcvH;uIiJK8uQS~>AjWEWD{;C%a1xib33&gW?xAN%HDlUT{=GzLv$w86j`v8S9o zb)I3$*vURlY#FUQ!$z!<{S^Zhq5G@^Ho4gEg0c?@l85<;6cgMy!Ui@n zvcWBcRUo!H`G_3`xC0g9iN`_w5vvPoDm}#^ju@`M?W4yPlO3n4PR84@b4^;8y!dhj z$_t2ntUwYacAU)yI%~l876SsQj|mvVw2!!|C?n)0qNwoVv)Ne7(DgQFrAjyGla+*3 zhsuJZmwgJDK8d2jmJfYCDr~4+8TIy%b=R^B3n!+c{DsDlQFH?(Jiy372o`_*&OhQV z8Fk5WIvRjfz|dY2MS&okGNpu{Sgend8K(QwnQ(1Ts$_d6<01rrn0eyiwX8FCO|pRs zvg8RD`ywNKy#nh$e3|XxFd`jn zkSohA8}kq@30lCcXs3|_Udeud;gN)TLM1r`S{SeV_0T0e7ur5NKVwky#Lo7FUQMtv z$vYHlicAmFCBg$^C3F^xF#ERgSBSD1hd@Cn9wDgXl3gA3 z`g4eH6R(%I57Ph(N!!M>UnI57qg7(y?hl4J-XU>~+>?8K_cN0W>dQCs^A zAdr~wl-vPQj7x&E)W|o_JRQM)R}M?j0sq5b4pxC@V1eRdb&45MBq5nPNr+`>r-98x zY{ABgjCqd{BZmm<22f&b!GKRJ`q8AXTruH_ot1z|qF}2PXBsG_FCo_uEX6#rSC}m% z?6M$@jKe}QcdbsWhW*>32uG%XRwlw(k4dhV7eRRQ3{w3O@adHbk2rO z;UXy(8;8)y(VD=qBLYpltR)B7EYl}G9#1dk8y&U+i8C8HwLz3@-00GH5WGA}N^WwI z!3fDR1=$>+VDp7!=j6x@*&D>Wjxq?37@|7U9dFPjLU7P&X%d8FYan7-Mj)aZ2{=ca zI?C={u8drKv!6+XmArfCAz&~xpW{LbobSqaN!TzJVb+?RP;yRaJ3jHScmScXU>!#y z!LEtF%Ww^mE=f>p@vLi7!`NS`^3pbdl#CBTTJ zv!g)h^+ZpwlMWjKrX-=?d^bQx`j{OK9Y%o;%t3sF2|;DCZW92mG11vD9DsxW$PNd| zmQZ5g>MSQ_hP_tM2Euspf|2|cg$Zl((Ons_zyrF1;zaT+;xfT!jW_mgB`hG)oQ)b7 zX-AoD7&~Yn%9{c?SZWxUQA`;hQi%}cL?=VI-~4UN<;o#U82ydy-%ws$42+2K6G<2V zy9u1ZPz()l!WOn=WE-W=ZREznr~#KGfJVN4bOiX54zilh`!Hc#xxThP<%GqSMfwKF zJxU~fAZM{PGht6+`>f&+ygd~mQGu;&VV2nqZ=-A}ik-lfM53t(s|LNDPkjxs+1Pq~ z(#9m(&U~Q55DCOqI@$9;KN=<^haHrP#)R=Z>Kl{!kPr>Leaa$icGqKz6N(^%lfHy# z8L(r%aoP7{$`8vqD|lG&-x1ABCzS7mkN}nhnh_(RASGvGK+42}i5vp8f&_E?JA2IF zoDgKiu@Ew+{l4>8OL3hvdp1+lEQ*pQV?cmCwnXie!l?-2vC$5XC!SCAH1hVk@d$|6 zAiuF9ucb#BzJV)|SgcTI)*-_C{0XdNf{3yFuw4xCL3U|HTfpW>ox%EJQw`F~e9~?@ z?LsRKh%!PiCfWt{g)AkY6HF5WDwBgfwj#AUo@<|AlVpSe5xT_dkSQ7_z~G4>gZ!Yg zcB!Gy9%U9Wozb4K4#gu7k^@#`4a*c&z-gAyF=ZYj7ouWdINQ#ta^MNudf~9h84R(B zN>jvB!7g{5aDrh9gr2{sI&;|R1G{|?)Rkvk`HY|%%1?k&Lkc(yEW`#eg-(>HNz}xS z%|7ND7PeAFAOxa^5)Di)ddQyeXnuUf#FTV;flx;*5zH0qIU}J=7^EjbsU=etmIVe{ z4tOm-^3uTcF_B@`W+Ymi0P^NxLV#-!xrBd*n)8=-XC&&$kXy7w%$!UumI#Dq1ZZ>( z&<|Q2E4GS5W8p6V+F;#fP%c}N$Kd_O!ax%A zqY%PwBAwlrsAv@>H9^jiK%(;rFmGYs0oO76aXxM0XbJ)t;ms0@mvxpJCJLg;AbaGvmqbe^WH^L7z$BF01s>^^8b)~% zEr5S$GKg75hrtF%vAS;qC9OWoE z$aiLSZGU^@&%xf=>-~T2oe6kUWwQQHCjkP4HDTXcWKocCI(v{Ubixin5&=PhBs8JT zY8Dn*6BR^2Km~+R3<9FarhpEcjEEvAAc80gA|ogx2%;e1c;Wu)ETNMQ-OSwo{GaFE zCpt1D>2!bRTk5NN>#escjMP7c`Nv)Z(s0MIK_#_9u7H%SD5Ox=P35J5l2FA>H%Jg+ z;87Wcc9n5mBdS59fDkG~X#G8b{%KJsk`PjQNC+V)Go}t^7h75K2;weyhTjuXva%he zd zke;()#UpTEL^;ePJm_X%7s_W8HyG791T%5$J-iu;jm=X+%@lY)wK6Dga;kxr*#9xC zIfdC=6_l{C+@3ur`-GJAGF1Nvk8ykCu94(0oMA#zfkoLHE3^xEQYczt zd4S#_bQ2xG2qMjlHoDnBmrEaJ35glm zIf%+3MJEn_~zq{9Fj56szOn zdCQC_RbU)&E5O;7y@{)j#~@(|Q3!U5Oo1^95CH0j zAQMms!Ox}rGb933tzhI}+PKPv=Ir^dEinrBDS;tH?_?rYszC9^$yX6EN;;e8aKzMyCrl^ymu3yXt<#14az44t$HA}LNB1JLbRnUuk}>=CN3QRX5hLhy{`0AIuX zl^SOJOXL{f2$|NIf-}Gf$vnXjBgkh>L|qSv6}lDP3YLw}_Uxrc@bmLT|1{;+Pyq?if<{ zr9%eDAtZd*{*-BmV++7VDI{?)7bxX#6y2E~4}#o$M^XU-Ltx9`-yl$dhrv`(&`z$) z>)9F(u4f*z;eYAaO9l*%Qcw^JAB!P~5m115S(;zaphiG45fEmZz$h?wD11j~Byi?Y z2xHt@KP4_JAWmw_!PEfsyhYA~lX5aaf=Z16O=m)1IEJL+@s;Sng3Hf##5aaiL<|Jq zRv!ZuOYkUR_R&09qI=>l%pjvBZB2<6X&E`(o{wx_XEN>fCfu&MC?fJEuRV`gT7@gq5-P#MtxU=1aaL0}!G}dfScZXOGMNDpuY5~i$tTb)oMb5A9p@J3$`m0IUNjJo)-Q#{qpXJ$#I*vZLf>gtomteE z8Cg*}@DNL(fsM1tOEH0@T8RpPmx(b@$M&Xd&<)Td9g5GutgNzT4n-H39PBarJFz)A z*A#=`=i8AkmtrHTBJ{C97eQ1>#1un;tBC6WYEk=uQch_eWf|a=Y&p--n(J6xrVb~9 z&a zcxJFiVASEJO5@%;Ta8jk0-zps^N(CNHow!r6o+u?ii_F4tl`#B;DdtYyUa6_)}6bNU`v>ls5D^ZWHgjmte?+9mrN=V?fI5vf6C-~MtL^;#lB2Z+2#ygLQm&3-BxSi;jzY(iL z7K1h`tL{1BTk6xlp{)tNj--6?93b3a8>6U(#mzL9hV?_ShE&vKAUw@^Yx|vu&2Ci+%W+Q=tyU3;@eIt@P_>U%|3@OtPs(pmq zKqWLkHwR z2>RF<(1ci@1+6D^lJ#bc9C2CGl(>6DH(Rg{_Ipy3Yr>911kprQjqIL-44QqXS>X>QQ?H z&dROgS)f^t-R(Chw+OjsZDW8o(bEsd81+i<1xV27=~KIlRrO4@x95W(XBfKWx8(cE zcpND5pm3aARGrzm%$$g2;`)(>C+J6w!B}3}S`s0_C__CCtEWlHv53;>0pAzuGu{%4i?fuzh*7n+995fY$UOuM1B(g;M#G6aaR)OGB(m%e3)hzIWRCUh2F=#2YVlX zN*E{)y*T785KVCH(W@2;OxVtHk?xYv+0 z0>A)_!j+U#ZK4J|OLT%HHjU{n@yi|C3DSzAovHb51p@FHNYhcf6Rs8T;N)}r5j90p zgw0f;q7uykvRjnSw@*pA?9~z<=8S5yLK5${ib5 znBt&-F1w4`Ui1&R8&GwXTLfAHPa_tVK90aV^j!T{CQW~T_s77+f`ZS{02|_p5?nyo zP-8;)&S6p-%JEELiFC@RD&_~b|;6r>tsBoay=z~i~LH&3F0-&ZR-T9~s z=ap=3j=WY`3>yW!9u}E5$fJAG*sL64Y?lFmsz53hu@9-)Bes*R0PX?d1bHMP4&65oux3Z-=H1{ffFOgG>jrfV?U!51K)V zVTBG!^Exhnsa8XUj^w)6_^^25Zd3P(N6xD8ruY_O|D-%eimJG<;gPHK92P>bObTEt z8DWA*yAUmO^X+^5TwC{E%KVX_fy|H7j`j#A8bpocus5S#Vl3Jcxg0T89UWt$NaW40-lv1KxRVifLE0)_;U9G4tlnd2-fQXC@gV45_N<)%%9nVmtTDh9d& zvw>5}U;xc2ECdNgys8_Lzi7yMb+U^G<8D^i9_%=2jRHe}B2Q7$l8lb1DZ?SN!yMEP zGQ}{o+>lJ9Fs32o@=Ck}rjLJ-+l02xLH1lvUTPff(*oN#oX(Ljc+jiD=;K@wCduJO z{{~!8Ixy(N!ExXk0*J@hFkIju!fHSZpeiV5(z7>$`^obyUpySyDW!}H1L3MEU$7UX#05^ydlL&26q4HbP@PzN5&^GX`R6tRxnlpJR^#7dWQ4@DAW zi(8(K7Hn~lR4gMO0vtn>B|LLeMO(7BR4&7`4Z%YJ9{}zk#Sbr(#E4zWp(JkboU}AX zQcA&{JSs41=OdTA%|eQ%b@^Qq7^4wvnokQg_mNkzQE~LRusj ziW~@KtnSB!bP??>un(Ag#*dOZh1s~fg4#hY)OvsEGfudy(%6kGoU|z*qbLm^+i4(C;y-v?OM=$<|4M4oHG{NstrC6!V~-vHIeN)L1<3Ps;Nk zoJPDO`odUBDXo`oXLuQGTG&%iMvT2h%nAvEdks{VlK_eeuF58->;=t5!U0K$dv;Ju zj>hFtX%eb600tZ+Vg*l;)Cd5$oqDP6c>PGem@XlGY{-`Yr4Z^fDRLNuW+NGB97kM~ zC_Es~xvB^3rlN++5V(Y*;S#|qrU4B*m2E{{kQ+e}2zVZ^ z=0+kQpwA0!4MIsMbA@@cW49j5eVq{4Ft^%ih02CDX(Kn2udhiMMIgQX#^jrr4z@`GfYx?Anp?br-3>!rdw8k@i04Z zV@V{ly`%v>0$@f^%gCXN5&nv712`7jlO#V5FTnvx7gV~1A??|{jLFS)P_L#d{kv>F zCK!4a>y3%$81j}vuOJNIEE32{k(YT4$qu2Yjl2&uLk@u?*XS8d<^?PUx_>xT6#D$p zKTNt%(Z7TAA~!inFp{OX0JQ$4T^I^w()-f${KZm$lIIwu4O^%*?(?T9@nJ1xV`BiN zaW(J)?k-tutOZ;)GwZ?0fUiM-!)+!;mB*9v9$3$mhm(0E`@+h5-dLr_<1&TFEyuBj zlI<1N7;rqd6KUBf0_Yg(&xNOq#lvtS>kc2O92WeyNy{z z^Im@?9WGIjV-ZnOBpZ4_GWJ*AcdrPIZ)7ac({D zrs73(9|*<;Iv7noV4Sg*NZNs!GnPsey`;f@%K(XfJ)1ZVQNtGN35jZ++XSui_S%w;SBsd&`R^T^u737sb ziX=ou&5o)na*x!jh&J^-7Uk~SL#ByIxoIwYo9@Bnw_sAi;+BX?Qnr$-2B84-rNcOT zT%QlrX!T~wRKH<%FqVQffoqA#AH@$8bMfJx{b2cU_X(i3i@vU8QFwGvMWS48XkuS5 zNHPq_(?M%C#=s-voijX<2Ifj7kwCF}yEsZ(LXn$8rkC^OnLa6F=$n=5G6#?eq!$_& zlC}Ww4TKa)DFSkwTnDsoFdOl4(78RZZR}C*P-?)~#%!iY*oQ(>p{F4pyJug?`1~@a zfsRwK12j4$s|&%JX@DxjA*Oq9IQ?JDrC>&VIpX#Pwj=07`%q zMZw3$8leUZNr(gD*=&>;h5M99H#t~BP`ia8z|O~-k>wL27(G4UpdxUj4~C=46-2xb zw#u-n$mCMQObu0M)Qo!zZwKaQmNg?ZNC0Od!-5hhces!^;J8A==4xX`grj53 z2uKOHr67vZZ3VRu4ij36cs8<+VkE9)xSox=>mb}GgtLZp9XKLmVdaI4qbZQUy$}&B z8b+Av^a5+qZw6mRhCv9$-?{-nP^*PWk6;^zvO1mv=v%X4NP)T>8ghJ4xNvIhb_vi$ z6&ocOsMn%mNPGJbTJPyg1M>*i9fwcmY@sZOiItu(?Cs0WYIlCA#NinV`^yW zBAzVkF8oxXqtUPjz#Eqyg%~EkIFC;~mZ;2pnI5Ek(TITjPf}1&1rjyr_aTde)~-$TUbkcl~oFAFt$u2L1q+Y0D;-4 z?jorShC^)crR__J9GkIN?o&j>L+2L`Yn)Kj(NB_{DxeBC2l_e@V)BhaA>sol0MjQ< z+VjwvhLZ#m40|4Tny?jOkT*QKha(f?l41-aAum7KWq!DH024Xc6s@p*Br}IY2T~6H z4SSH*2ND>1VW~JlG#q^#6Lg|V$q!(EA~Ht28BPg17n`0_5*jUv>tJ<&mKX%j)+wR* z19ZxNsb`>Ym6ngfqvF(K7;rVU#=3;{a1zm{Bl7e146%-EN9HIBPRe`+DNI5lfW$vm zL|2@nY)~*U_(9Q7s-(!m^E2G~fU=)~5D}9Jtu;o%Bw$N93z&&G>1N373pw1|jb1osuUv6pKw$Kfbz>LY0V1A%&K_uxaGp96g(bnLTO731j8OAiDCc2504@jZV)R z=W^gfU~9vaK^3Lbbqx06Bo5 z2#Ok}69G`^a>;wrmY17_eM?O+*$1e}lpIl#Be8;KBhqaE`EW=2fTX-J?gmqI{Dgu? zSSHR;D3>U3F(YTtwCkZggGmPkyv0|QG_P>&^jb}@pOWiKC$* z3`WKPPRL#XCB@$t>=!qU(iXZSnMidgg$H!Lgm6L^G)7DP8Ds$>mhRM}K!8B;hT|r& z4UHI>dmLv7i@YcE2#X4rh6#({5+&Om$I0<*Sd7u?$s_lv6W<;7GvlCG5bscYF@R6{ zev{0B!@_hKVLN!U_^hlqvgPuCAT?UOm|Yq}gB+1n_I8X*48~>hq{ALWI<8dwQ64l* z81O_curg2?vm=TZXVmQ>IEs2cuaus6ypnAMh=JS0KUy5Tdd3Np1QRrvhWf&wc z(cTsymI1L*g&4~91Y{%4!nyL;B>Kt#Uvx)=7FZ779?Kvh9!YX!CjcLbfk}iJ7$g}! z8e>5xh|<~^$mXD!huE+iG$5#$0NqTm=UB)Xu**oPf2I*V-Wl;956|@v!Y`08*b)dR z9)fBdQ`#Xyxx;q?$^)0NGqv;rkTeYx81xlTO!SIk8=oJS?vR>G_f1687jROk8K49R z3(wsF=Z)J5myv!jM#-)0Xo51b4}{Jz;w2F##BJe?(wrC>92mevGk3Ur#%Nq71&Rhj zJdnG2diFBC9+?jk(A0F|(h`y)-K{SlIddX%&2M6GG2$* zUDVf^Sw@@;kD8<&m??BXtWgB97D`u=Oyl4PmP>W0K8$EOI1mNmzA=65H}*dA*QBtd z5>C>T+&*`(H)I$t(?FIREK_!bM$xB&A4G&y4YL0T`cv6Q8e0E+B4KK$nE~QrCM-(W z23np)q~xfmMof-~-pk%hNF3NN$yJpQzl1b1y8#|LM~PGho-2e6$S$Nm0n>O;MHy>R zY`2F$M#T1t$(@jyqTiO}+NQe>(OcPtdbHxAZ}nxVz2oABN87P zV1OB5mjDDat+c_XKA|ppD~-t>@T~Fk!z?P=mChH1Wl8G+hTSIW43={xS5fMsTgk1OdWI(D!`am|s7D%7~lj$R&T?>^j+^mQd zaT}AmW-=uGj@SdLfvC8KV8A@nzQ9KSy4~2M@CjmQF^2C){U%NX_z%=6RK$p&04xzr zGHG8Z9FS3w-Jq!{Qb`4_PmCh{T+oza2a3Dl`7F5(!hJ%x{iv}fcMKrO9gZ%Ah$=lpc|e1_boJM@6)_jBQI;F6WAT41<&MC6P~tYAuW=ZZb%C5)E^>r30#FGO0LI7`YU3o0=u{Y>pKz=e*ExiN?fXro6*(2y)KzTMc7_=PR7V{^f-XK;`*5Kol z+SDg17LE(WZQ?ab;7QsGcZ)wjl|_`DDtW0#@(fax8i)I|kgq_Ah}!~JNa78_g*kbg zZ#4fXrGe;Z#ye2;=?Fyc5z6CvC3~EKbDbg_gm4DDEfMPRTyC#9Z6%XGp;Y=x%WL@A zqPa!`FLEi;kCRjm_d2n0j1eJ1L_^O{e18>?NxHmaw1|2Da6!8XUMZdQwl3xX+$VyH z9@y?k4D+c>1Z|q6fRYrC2wRePBV}v2RaDDBb4T@2=VXRM(FA70N^q%BB?FaLpi|F@ zIN)mvVDm(W!DVm2qDPGpWCm}LF+>W|0aVA@Bkw@PKdWxsSX zL4O_kzz1nY zo|s#NSWT+Q@I9k!01(2z5f6c2geXROj)B{-i8(4LH;|!1tqBcrbfAT$?HN}sV`wFC zRk*c$B3B9(sLZc0_0hWEa=~Yaqco6qZicf71DY%$j(<3Yl-&Re3}lVaiOU#E8;dha zx+2!%DHtweGzRIZL?kK?FU4q3!A0_yOg8)zpdogqbY})u=4^+W#)JrjdUTL1nuPF5 zk;){u0VTms;j34Dlt;H7#ZnDizW^d z{Dzl+3JV@M2Zqu_mM)Is6htH`FbCg(Yk>BbXg7NHiQUH}PK#rdb}c&{xdTfqB+8J` zA@N{Tih{V`KsShxsq#eWhU#`~vl%VZOfeL=Rwf8nOv6FC0li6}8;(|mlpwMJds~#a z+j}rx$5vX3Vl>ix$)iAN9kyilnIj?zq;GU`J4bZnD26_I6c>S_)U+s76Ju!w7~eOJ z1cjmmSQHBogZWR*kU;aVO0fLhTKr{+zgS&fr~hDtJu4?RJ)QounMy`(N*1}5;8E%6 z+7EBGRIFV~{C@ct*OUK-bPZHgU-?S^NA(5#PzEUp$_W09QwH+4UP`>upRarIXLtTC z|LpL)ctaslt*lg4YP7Cg{Qq6FpDKzU|LZGKN?B~SaEOvaGzG7@=a z{U=#UHoqOOBq}jHQ#$XhKN0mT+Bp02b*lE;^2FK71Z||L${2p%^?7c+PM`Tv{9XpX zm!qUYe_6FsDl+Qr<43y76`3#iLK=}-m&p`PM zl+Qr<43y8ne{u%YK%y2!=}Mx%{Gaj}D4&7y87QBD@);RBMg^gn>R&F!B=k%-9ER}qU3LA&;tzaLE#a30VT(Lsi>b^b= zD=6xiidEWHwD?&HBYiA>MMKpgYN*S1YN#!JElQE~)uz)LlMa=C<4KU_l4_MCy(Dxy z%fISfF7N3Vv@{^A!;AZ(3tO#v`>5aZ)wk^2bfTcBu-->%q3`2rp-*y=uaCvYr)E^k zFaNlfw0`O3c|W$=e01m+YPI4KTPiTN1Z}9k5BgOM^m#DBR!^-{kuRzQRv&~MR)RA% z^FC{@%#>hTTlHS~fp1`Q^9R;MXNJQ{;X+0>?Z2%?ud-Y#S`JO?RZ}BX`f7+chpG;( zS4|ocQiei-YWnLY&t z%I?j-4y?2N>FFcyt=oH8`#$s2X3YOBJaI_)PlqCgC-)opK-gouCXQ}0^Wzh3c0XF> z_sC-}=FR{8xpf;hk6n1_jovA7J%ZD!KG(lb+u0X}^qzI3(&>ixT`OEYx6ew+%?=*RQsnZ0!6{i8Y5+6RB+z2H z>E{E>B2>O==69dkM!lz~RZ)xS&5d77$w@Eqd+qabbK9jP1@nEiuKZFso&7i4}orEn5wyRoem;6BCdS3vr!gwvun51wz4xeLik6 z?d0idEp~m|@U3M&%U&yN7w|-#g2*a`)$iLdv|iHYuPWSl`kPDh=WiU;uCmL1&dvnl9c;-0$8r#*aqLgz3#NB_az*d-0Al=9sU~sg0eEB$`g-VAD(cz{>H&IvOoCem9-0ss@MB=cim|t_tt2e zIoC`sS1B%pp@|f0K41Vrh+?ht7}xb=+%HvO4a3etosAV=kw^uy4n} zc5n9Vbmg5d9vRWd=aoO&r!`%1b@`Il8h-3^YHHts-&Y@bzH8$tTdIBAWzVLQGj@!4 z{83x5@8W{M*LzqG*mA24ZnuAYSm=V`NMsC~7+I^zbVeCS98RX0m1Om3~#f{jB+**B9(x_w?9x7q(XW?R39mMgJUAv@YoW zjWgcgW>}1G)Pk@6O^YFWN4FUMYDG@Bk3~^qsGPH zXjVjaYLk|pOo*i-Hcc}j?93Gn)OzOr_6-ccgh|M7M2CdK^L=D?48j}1Sut?g5tH^033 z*r~xc-`n)zlq&}Vmj1HnM%%;p4{X#Zs`b?_z12d$&-gFeIL9pm&VHvR1;5gE=G6-Q zCSCilQX^JJxEy0ow`imq&V+D6gSA3tYp7MPIkyhTab_gtOelF`tugs|W2F7q1nove z#en59k0yE!sF0XPvtZvHj=(SiRRinZx>9pc!?X5xnnT8qXYYVKKE?)1N{!obWYrp{rkq_we!B2_(-2YhZpXwGj7?2%dfWl zb$#RKQtO|&T+#31ye+4d(*bCYzMFL}a@P6FU#|J}_g^}#KaoE_v_X@` zT|dcd(crGfn)`i_ z|CBRbUdjDyXqAJHbP1cW@ROO-7`(9`_=UentIr=YS)SL+kR0i|7MT=!)JXc)%qFc8(9MUlGG8)9w{28KBNv- zAFNxMQ;_OtpXwZqx7$puWcbj2L37U>Za96-oM+QMI5_RmBR%WiH?cvm+OqE5#*?LI zrDl~J#@Jl#d-6{Io}blOrl6&toLIw6^R*QJ&8PTpz7;EvoZizi{aQCaOT{YsU*jzP zmQof%Y+9htiEC%4E58oCcFh{_(9_A44jj1J|N6Fvmc4l9RMd(7+egjxdT?rmwCQ|Y_|<2I-5h;z!1|9e2G40Q{@pFF9vb{pvn74jZ{7QB?I|DaxTzLaSb|L} zG;CVz_LQGqp8C%0?Z;|1i*CFuuGEOtf=&OgOv?RgG?R(d3rTe3WaL`2Mr$S`DNoy& zW$vP!>?AAp$EMnX)%)a^eFIy%*%Uikm{#%pCH@FO(#D8Au#6&zYFbJga@IDgkoDN3 z;6%yCs;dUc`}+r0>z9<9o0KvJYnGRnYpbcb!}wg4VlqdGNU_bTImCWdg6j2jjH4q( zUb_KFDQR?Rvub_fGbh+Os~zZU#@VD!WJ5IegV)n|}ZC-tH&3=E&!eQqtotWs@ z(0Ka#htBM)RjpIq11Bn2{nWSroNasNgGZh3%(^eNsQ!VchO9o@v-0Uy??0OwxZ=b3 z5ALsfv+-xqH{a{jyODBlz^2F@i(Y!|*=K(`*=@!H4TFad{PfC^4k4K@<*Yc~Bx6uy zgRsVnMtnLy?E9g8Cq~~03)}GLqJg8%=j`0J^8M|R){UD-AAarU6ZLai9Ix?Bc*_N! zj?egP^7W;^HTc}m~vL~Q2B0tisYOK72)vuE(2cW8H8!FZFy<=m_G0-A{Qht`N`j}~e zh#ehj${ogz_nW_^`jqiBNzSB_Hq_;5964$;d78WZ>Z^691sz=c#!nMlUGB5@*|}f- zQlZtw?>}GlvRbRy6f!6xNWYpynzxXTMt++6smK*o5`@qq$Fl)*&K)@V^|7xf?bu^$ z`FiAUEoxj{yJY*=yscrDt;26Fs=Z>vglchVmgRmwf3@27>16Bs6`$@i`r_#^Uw?Uh zalp2BK1<8^;IC(z^?lj5U|_+9(6dZh7+4h-#+_7Sw6|m$jQ~I^L<0G3(gu zhyPjNyYJ_(Be(7CI_1XI^>56W7V-F)OTYZXXL#Mo`_?#iji~-b$lc5Og`ZBajGnS= z<(82xEJM3rx#y*Nh12%#_+fX`E{7+7)qC(yzVqH)f8)aZ$#It|MYmdexZ>I4>ZKmJ zxj`LT4R3xit81!SSg{J$`B%d_4^+;qZaL`BhSPsuxc5k(&^@K5O#MIQ@PQX0`hq@o zvCYQs3~}*p|94(R-u&1rclQ~-^2=woh5X~l;Hwu;?`bt`LqK?JcWDt(u+k za=qpLE8pDk&;5@k7xw+)uCE&%yY&5&_dnAn{;6T}Eb)6+jjcJgweO_&)=ioG{)y`q zwm0helJm#Et?1Y>M(KQV;h7Ilzwp@62Q7P)R=vA++`O#S8v&~_rae2a<-~(KyEH!6 ze&HWyW{mr2^PsmMzdun;Xmm0;>}JzLmxn%o&r@gm*6TlI*nh2fe(}_k`!BA@zj(3E z?>&CJ)*$Dr;IM|TZCcfL%8qUE0i6b4QjfkC@$AuQW4~+=ymJ4Puy!*|Q+xwc{D%f{ zlnzs~bqnfLQ&mSv3p(gua7WviX3xh*ZQAhmuB%wv61M=J@c(yTRl9WBsoI}?xat8Zn3N#^!lh8$7avpz3tP0Gix6& zYCiR3kEq`5(hp62tl^~d*>Ak{OZ@2?0SSN98Ga-0#a=C*DrnVseo&7MeN$#{TNZZY zqqwuxo@$lr``H__M`av;?71J}DvYf2&;!wb4hc%Tab(5M6Vm(xVsd_rY+kYQdw2h% zOYD-S|44fI)3@e5{AZ`n=d9`0$q{j6Q>U)?%>7HvgLk+3w2$?ZdCeY~-8XDs$FI&r z9?e>5-4S-K)v{d zIqapi^Z!`$^YdFD`S`AcU4;oL>uXmVFr!wZPKg5-K6Bqoot|sxzobI&p66HgoPXF> z==%dW;@^EN7PVmS|59Jvr>0wsaVslQl&#iu@eTrP0%tcUPEJ(zwFS8R*iUWj@>Nw^ zb#U-ou05~)!zAw^Wo~lRz$W5D{{R;ff@Y@Ey~archCPb z=18Dp-oeq6&wqdDYWm}IpFKMN{L5!Q+BP6zRob+nkNPfI{=wGVmA`#l`<;}}p00hQ zb5Pi`)(-ElsBw8}yGi>ZvWt8>BrPl4c0Aa>Wrkm^52_5`Gyb6&@$-X*wLHCdWUnsQ zMlO8vSpRi5d-nQ!|JrS5EdF|NzbC>kP0QFaDdNq3DGxVT{$$$qxd$wTj?jrA+1Fke z(Bi{skG8IUq1plG!+*a1WboAQ?i%~fiNr^jzx#8LeMFnocm9$ybyvWI&oAFx_t2ap zM?)_EynpJtCPC3fRlcqtUiFE^ue_0!pLf9iO#9Afo*w_e>$S&jYuKVvi(}s&e*d#i za@IULXI<>n2H#qqiVoPA{_ceaZ!asfOvU(4yfu3jZH1O}zBNX6Uh01&Jyb?g%4J(T zqSn7P8ed!0;x8&$*aK#^t#Soh4K1q_77~tXE-e~|y6u63M=MX*oayXm@7XeYQQl|s zZZ1E5p!6OnnAU1%%+?wWj;wyH%dpM`XMV4BBy4=oRryVu74*;FJnX1q`FZA=`xkun zO0Ov&{r*zV_1m9&ZDX@z_RM#>v^{5f=WkmW0D z&y{J|3P*tXzsyUV8@uH-yYG3}?7U6L=3jd?Kn%(x>*+UL)Fid5o% E18i!n)Bpeg literal 0 HcmV?d00001 diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000000..37f5f8f6ad --- /dev/null +++ b/pom.xml @@ -0,0 +1,29 @@ + + 4.0.0 + + org.jenkins-ci.plugins + plugin + 1.466 + + + hp-application-automation-tools-plugin + hp-application-automation-tools-plugin + 1.5 + hpi + HP Application Automation Tools + + + + + repo.jenkins-ci.org + http://repo.jenkins-ci.org/public/ + + + + + + repo.jenkins-ci.org + http://repo.jenkins-ci.org/public/ + + + diff --git a/src/main/java/com/hp/application/automation/tools/AlmToolsUtils.java b/src/main/java/com/hp/application/automation/tools/AlmToolsUtils.java new file mode 100644 index 0000000000..2f0a9f8d8c --- /dev/null +++ b/src/main/java/com/hp/application/automation/tools/AlmToolsUtils.java @@ -0,0 +1,59 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +package com.hp.application.automation.tools; + +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.OutputStreamWriter; +import java.io.PrintStream; + +import sun.util.logging.resources.logging; +import hudson.AbortException; +import hudson.EnvVars; +import hudson.FilePath; +import hudson.Launcher; +import hudson.model.BuildListener; +import hudson.model.AbstractBuild; +import hudson.model.Result; +import hudson.util.ArgumentListBuilder; +import hudson.util.IOUtils; + +public class AlmToolsUtils { + + public static String runOnBuildEnv(AbstractBuild build, Launcher launcher, BuildListener listener, + FilePath file, String paramFileName) throws IOException, InterruptedException { + ArgumentListBuilder args = new ArgumentListBuilder(); + EnvVars env = build.getEnvironment(listener); + + PrintStream out = listener.getLogger(); + + // Use script to run the cmdLine and get the console output + args.add(file); + args.add("-paramfile"); + args.add(paramFileName); + + // Run the script on node + // Execution result should be 0 + int returnCode = launcher.launch().cmds(args).stdout(out).pwd(file.getParent()).join(); + + if (returnCode != 0) { + + if (returnCode == 1) { + build.setResult(Result.FAILURE); + } + if (returnCode == 2) { + build.setResult(Result.UNSTABLE); + } + if (returnCode == 3) { + build.setResult(Result.ABORTED); + } + } + + return ""; + } +} diff --git a/src/main/java/com/hp/application/automation/tools/EncryptionUtils.java b/src/main/java/com/hp/application/automation/tools/EncryptionUtils.java new file mode 100644 index 0000000000..6d3f4f32ce --- /dev/null +++ b/src/main/java/com/hp/application/automation/tools/EncryptionUtils.java @@ -0,0 +1,53 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +package com.hp.application.automation.tools; + +import javax.crypto.Cipher; +import javax.crypto.spec.IvParameterSpec; +import javax.crypto.spec.SecretKeySpec; +import org.apache.commons.codec.binary.Base64; + +public class EncryptionUtils { + + static String secretkey = "EncriptionPass4Java"; + + public static String Decrypt(String text, String key) throws Exception { + Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding"); + byte[] keyBytes = new byte[16]; + byte[] b = key.getBytes("UTF-8"); + int len = b.length; + if (len > keyBytes.length) + len = keyBytes.length; + System.arraycopy(b, 0, keyBytes, 0, len); + SecretKeySpec keySpec = new SecretKeySpec(keyBytes, "AES"); + IvParameterSpec ivSpec = new IvParameterSpec(keyBytes); + cipher.init(Cipher.DECRYPT_MODE, keySpec, ivSpec); + + byte[] results = cipher.doFinal(Base64.decodeBase64(text)); + return new String(results, "UTF-8"); + } + + public static String Encrypt(String text, String key) throws Exception { + Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding"); + byte[] keyBytes = new byte[16]; + byte[] b = key.getBytes("UTF-8"); + int len = b.length; + if (len > keyBytes.length) + len = keyBytes.length; + System.arraycopy(b, 0, keyBytes, 0, len); + SecretKeySpec keySpec = new SecretKeySpec(keyBytes, "AES"); + IvParameterSpec ivSpec = new IvParameterSpec(keyBytes); + cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivSpec); + + byte[] results = cipher.doFinal(text.getBytes("UTF-8")); + // BASE64Encoder encoder = new BASE64Encoder(); + return Base64.encodeBase64String(results); + } + + public static String getSecretKey() { + return secretkey; + } +} diff --git a/src/main/java/com/hp/application/automation/tools/model/AlmServerSettingsModel.java b/src/main/java/com/hp/application/automation/tools/model/AlmServerSettingsModel.java new file mode 100644 index 0000000000..143cc9a8d4 --- /dev/null +++ b/src/main/java/com/hp/application/automation/tools/model/AlmServerSettingsModel.java @@ -0,0 +1,49 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +package com.hp.application.automation.tools.model; + +import java.util.Properties; + +import org.apache.commons.lang.StringUtils; +import org.kohsuke.stapler.DataBoundConstructor; + +public class AlmServerSettingsModel { + + private final String almServerName; + private final String almServerURL; + + @DataBoundConstructor + public AlmServerSettingsModel(String almServerName, String almServerURL) { + this.almServerName = almServerName; + this.almServerURL = almServerURL; + } + + /** + * @return the almServerName + */ + public String getAlmServerName() { + return almServerName; + } + + /** + * @return the almServerURL + */ + public String getAlmServerURL() { + return almServerURL; + } + + public Properties getProperties() { + Properties prop = new Properties(); + + if (!StringUtils.isEmpty(almServerURL)) { + prop.put("almServerURL", almServerURL); + } else { + prop.put("almServerURL", ""); + } + + return prop; + } +} diff --git a/src/main/java/com/hp/application/automation/tools/model/EnumDescription.java b/src/main/java/com/hp/application/automation/tools/model/EnumDescription.java new file mode 100644 index 0000000000..b79e7da23e --- /dev/null +++ b/src/main/java/com/hp/application/automation/tools/model/EnumDescription.java @@ -0,0 +1,25 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +package com.hp.application.automation.tools.model; + +public class EnumDescription { + + public EnumDescription(String value, String description) { + this.value = value; + this.description = description; + } + + private String description; + private String value; + + public String getDescription() { + return description; + } + + public String getValue() { + return value; + } +} diff --git a/src/main/java/com/hp/application/automation/tools/model/ResultsPublisherModel.java b/src/main/java/com/hp/application/automation/tools/model/ResultsPublisherModel.java new file mode 100644 index 0000000000..a5e06b511d --- /dev/null +++ b/src/main/java/com/hp/application/automation/tools/model/ResultsPublisherModel.java @@ -0,0 +1,42 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +package com.hp.application.automation.tools.model; + +import java.io.Serializable; +import java.util.Arrays; +import java.util.List; + +import org.kohsuke.stapler.DataBoundConstructor; + +public class ResultsPublisherModel implements Serializable { + + private static final long serialVersionUID = 1L; + + public final static EnumDescription dontArchiveResults = new EnumDescription("DONT_ARCHIVE_TEST_REPORT", "Do not archive HP test reports"); + public final static EnumDescription alwaysArchiveResults = new EnumDescription("ALWAYS_ARCHIVE_TEST_REPORT", "Always archive HP test reports"); + public final static EnumDescription ArchiveFailedTestsResults = new EnumDescription("ONLY_ARCHIVE_FAILED_TESTS_REPORT", "Archive HP test report for failed tests "); + public final static List archiveModes = Arrays.asList(ArchiveFailedTestsResults,alwaysArchiveResults,dontArchiveResults); + + private String archiveTestResultsMode; + + @DataBoundConstructor + public ResultsPublisherModel(String archiveTestResultsMode) { + + this.archiveTestResultsMode=archiveTestResultsMode; + + if (this.archiveTestResultsMode.isEmpty()){ + this.archiveTestResultsMode=dontArchiveResults.getValue(); + } + } + + public String getArchiveTestResultsMode() { + return archiveTestResultsMode; + } + +} + + + diff --git a/src/main/java/com/hp/application/automation/tools/model/RunFromAlmModel.java b/src/main/java/com/hp/application/automation/tools/model/RunFromAlmModel.java new file mode 100644 index 0000000000..1c4b74b7f3 --- /dev/null +++ b/src/main/java/com/hp/application/automation/tools/model/RunFromAlmModel.java @@ -0,0 +1,162 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +package com.hp.application.automation.tools.model; + +import hudson.EnvVars; +import hudson.Util; +import hudson.util.VariableResolver; +import java.util.Arrays; +import java.util.List; +import hudson.util.Secret; +import java.util.Properties; +import org.apache.commons.lang.StringUtils; +import org.kohsuke.stapler.DataBoundConstructor; + +public class RunFromAlmModel { + + public final static EnumDescription runModeLocal = new EnumDescription( + "RUN_LOCAL", "Run locally"); + public final static EnumDescription runModePlannedHost = new EnumDescription( + "RUN_PLANNED_HOST", "Run on planned host"); + public final static EnumDescription runModeRemote = new EnumDescription( + "RUN_REMOTE", "Run remotely"); + public final static List runModes = Arrays.asList( + runModeLocal, runModePlannedHost, runModeRemote); + public final static int DEFAULT_TIMEOUT = 36000; // 10 hrs + public final static String ALM_PASSWORD_KEY = "almPassword"; + + private String almServerName; + private String almUserName; + private Secret almPassword; + private String almDomain; + private String almProject; + private String almTestSets; + private String almTimeout; + private String almRunMode; + private String almRunHost; + + @DataBoundConstructor + public RunFromAlmModel(String almServerName, String almUserName, + String almPassword, String almDomain, String almProject, + String almTestSets, String almRunResultsMode, String almTimeout, + String almRunMode, String almRunHost) { + + this.almServerName = almServerName; + this.almUserName = almUserName; + this.almPassword = Secret.fromString(almPassword); + this.almDomain = almDomain; + this.almProject = almProject; + this.almTestSets = almTestSets; + + if (!this.almTestSets.contains("\n")) { + this.almTestSets += "\n"; + } + + this.almTimeout=almTimeout; + this.almRunMode = almRunMode; + + if (this.almRunMode.equals(runModeRemote.getValue())) { + this.almRunHost = almRunHost; + } else { + this.almRunHost = ""; + } + + if (almRunHost == null) { + this.almRunHost = ""; + } + } + + public String getAlmUserName() { + return almUserName; + } + + public String getAlmDomain() { + return almDomain; + } + + public String getAlmPassword() { + return almPassword.getPlainText(); + } + + public String getAlmProject() { + return almProject; + } + + public String getAlmTestSets() { + return almTestSets; + } + + public String getAlmTimeout() { + return almTimeout; + } + + public String getAlmRunHost() { + return almRunHost; + } + + public String getAlmRunMode() { + return almRunMode; + } + + public String getAlmServerName() { + return almServerName; + } + + public Properties getProperties(EnvVars envVars, + VariableResolver varResolver) { + return CreateProperties(envVars, varResolver); + } + + public Properties getProperties() { + return CreateProperties(null, null); + } + + private Properties CreateProperties(EnvVars envVars, + VariableResolver varResolver) { + Properties props = new Properties(); + + if (envVars == null) { + props.put("almUserName", almUserName); + props.put(ALM_PASSWORD_KEY, almPassword); + props.put("almDomain", almDomain); + props.put("almProject", almProject); + } else { + props.put("almUserName", + Util.replaceMacro(envVars.expand(almUserName), varResolver)); + props.put(ALM_PASSWORD_KEY, almPassword); + props.put("almDomain", + Util.replaceMacro(envVars.expand(almDomain), varResolver)); + props.put("almProject", + Util.replaceMacro(envVars.expand(almProject), varResolver)); + } + + if (!StringUtils.isEmpty(this.almTestSets)) { + + String[] testSetsArr = this.almTestSets.replaceAll("\r", "").split( + "\n"); + + int i = 1; + + for (String testSet : testSetsArr) { + props.put("TestSet" + i, testSet); + i++; + } + } else { + props.put("almTestSets", ""); + } + + if (StringUtils.isEmpty(almTimeout)) { + props.put("almTimeout", "-1"); + } else { + props.put("almTimeout", almTimeout); + } + + props.put("almRunMode", almRunMode); + props.put("almRunHost", almRunHost); + + return props; + } +} diff --git a/src/main/java/com/hp/application/automation/tools/model/RunFromFileSystemModel.java b/src/main/java/com/hp/application/automation/tools/model/RunFromFileSystemModel.java new file mode 100644 index 0000000000..094b4669b2 --- /dev/null +++ b/src/main/java/com/hp/application/automation/tools/model/RunFromFileSystemModel.java @@ -0,0 +1,76 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +package com.hp.application.automation.tools.model; + +import hudson.EnvVars; +import hudson.util.VariableResolver; +import java.util.Properties; +import org.apache.commons.lang.StringUtils; +import org.kohsuke.stapler.DataBoundConstructor; + +public class RunFromFileSystemModel { + + private String fsTests; + private String fsTimeout; + + @DataBoundConstructor + public RunFromFileSystemModel(String fsTests, String fsTimeout) { + + this.fsTests = fsTests; + + if (!this.fsTests.contains("\n")) { + this.fsTests += "\n"; + } + + this.fsTimeout = fsTimeout; + } + + public String getFsTests() { + return fsTests; + } + + public String getFsTimeout() { + return fsTimeout; + } + + public Properties getProperties(EnvVars envVars, + VariableResolver varResolver) { + return CreateProperties(envVars, varResolver); + } + + public Properties getProperties() { + return CreateProperties(null, null); + } + + private Properties CreateProperties(EnvVars envVars, + VariableResolver varResolver) { + Properties props = new Properties(); + + if (!StringUtils.isEmpty(this.fsTests)) { + + String[] testsArr = this.fsTests.replaceAll("\r", "").split("\n"); + + int i = 1; + + for (String test : testsArr) { + props.put("Test" + i, test); + i++; + } + } else { + props.put("fsTests", ""); + } + + + if (StringUtils.isEmpty(fsTimeout)){ + props.put("fsTimeout", "-1"); + } + else{ + props.put("fsTimeout", "" + fsTimeout); + } + + return props; + } +} diff --git a/src/main/java/com/hp/application/automation/tools/model/RunMode.java b/src/main/java/com/hp/application/automation/tools/model/RunMode.java new file mode 100644 index 0000000000..1a6d66fdee --- /dev/null +++ b/src/main/java/com/hp/application/automation/tools/model/RunMode.java @@ -0,0 +1,25 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +package com.hp.application.automation.tools.model; + +public class RunMode { + + public RunMode(String value, String description) { + this.value = value; + this.description = description; + } + + private String description; + private String value; + + public String getDescription() { + return description; + } + + public String getValue() { + return value; + } +} diff --git a/src/main/java/com/hp/application/automation/tools/results/RunResultRecorder.java b/src/main/java/com/hp/application/automation/tools/results/RunResultRecorder.java new file mode 100644 index 0000000000..7b467c650a --- /dev/null +++ b/src/main/java/com/hp/application/automation/tools/results/RunResultRecorder.java @@ -0,0 +1,412 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +package com.hp.application.automation.tools.results; + +import hudson.Extension; +import hudson.FilePath; +import hudson.FilePath.FileCallable; +import hudson.Launcher; +import hudson.AbortException; +import hudson.matrix.MatrixAggregatable; +import hudson.matrix.MatrixAggregator; +import hudson.matrix.MatrixBuild; +import hudson.model.AbstractBuild; +import hudson.model.AbstractProject; +import hudson.model.Action; +import hudson.model.BuildListener; +import hudson.model.Project; +import hudson.model.Result; +import hudson.remoting.VirtualChannel; +import hudson.tasks.BuildStepDescriptor; +import hudson.tasks.BuildStepMonitor; +import hudson.tasks.Builder; +import hudson.tasks.Publisher; +import hudson.tasks.Recorder; +import hudson.tasks.junit.TestResult; +import hudson.tasks.junit.TestResultAction; +import hudson.tasks.test.TestResultAggregator; +import hudson.tasks.test.TestResultProjectAction; +import org.apache.tools.ant.DirectoryScanner; +import org.kohsuke.stapler.DataBoundConstructor; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.IOException; +import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; +import javax.xml.parsers.DocumentBuilderFactory; +import javax.xml.parsers.DocumentBuilder; +import javax.xml.parsers.ParserConfigurationException; +import org.w3c.dom.Document; +import org.w3c.dom.NodeList; +import org.w3c.dom.Node; +import org.w3c.dom.Element; +import org.xml.sax.SAXException; +import com.hp.application.automation.tools.model.EnumDescription; +import com.hp.application.automation.tools.model.ResultsPublisherModel; +import com.hp.application.automation.tools.run.*; + +/** + * This class is adapted from {@link JunitResultArchiver}; Only the + * {@code perform()} method slightly differs. + * + * @author Thomas Maurel + */ +public class RunResultRecorder extends Recorder implements Serializable, + MatrixAggregatable { + + /** + * + */ + private static final long serialVersionUID = 1L; + private ResultsPublisherModel resultsPublisherModel; + + @DataBoundConstructor + public RunResultRecorder(boolean publishResults, + String archiveTestResultsMode) { + resultsPublisherModel = new ResultsPublisherModel( + archiveTestResultsMode); + } + + @Override + public DescriptorImpl getDescriptor() { + return (DescriptorImpl) super.getDescriptor(); + } + + @Override + public boolean perform(AbstractBuild build, Launcher launcher, + BuildListener listener) throws InterruptedException, IOException { + TestResultAction action; + List builders = ((Project) build.getProject()).getBuilders(); + + final List almResultNames = new ArrayList(); + final List fileSystemResultNames = new ArrayList(); + final List mergedResultNames = new ArrayList(); + + // Get the TestSet report files names of the current build + for (Builder builder : builders) { + if (builder instanceof RunFromAlmBuilder) { + almResultNames.add(((RunFromAlmBuilder) builder) + .getRunResultsFileName()); + } + if (builder instanceof RunFromFileBuilder) { + fileSystemResultNames.add(((RunFromFileBuilder) builder) + .getRunResultsFileName()); + } + // names.add("APIResults.xml"); + } + + mergedResultNames.addAll(almResultNames); + mergedResultNames.addAll(fileSystemResultNames); + + // Has any QualityCenter builder been set up? + if (mergedResultNames.isEmpty()) { + listener.getLogger().println( + "RunResultRecorder: no results xml File provided"); + return true; + } + + try { + final long buildTime = build.getTimestamp().getTimeInMillis(); + final long nowMaster = System.currentTimeMillis(); + + TestResult result = build.getWorkspace().act( + new FileCallable() { + private static final long serialVersionUID = 1L; + + public TestResult invoke(File ws, VirtualChannel channel) + throws IOException { + final long nowSlave = System.currentTimeMillis(); + List files = new ArrayList(); + DirectoryScanner ds = new DirectoryScanner(); + ds.setBasedir(ws); + + // Transform the report file names list to a + // File + // Array, + // and add it to the DirectoryScanner includes + // set + for (String name : mergedResultNames) { + File file = new File(ws, name); + if (file.exists()) { + files.add(file.getName()); + } + } + + Object[] objectArray = new String[files.size()]; + files.toArray(objectArray); + ds.setIncludes((String[]) objectArray); + ds.scan(); + if (ds.getIncludedFilesCount() == 0) { + // no test result. Most likely a + // configuration + // error or + // fatal problem + throw new AbortException("Report not found"); + } + + return new TestResult(buildTime + + (nowSlave - nowMaster), ds, true); + } + }); + + action = new TestResultAction(build, result, listener); + if (result.getPassCount() == 0 && result.getFailCount() == 0) { + throw new AbortException("Result is empty"); + } + } catch (AbortException e) { + if (build.getResult() == Result.FAILURE) { + // most likely a build failed before it gets to the test + // phase. + // don't report confusing error message. + return true; + } + + listener.getLogger().println(e.getMessage()); + build.setResult(Result.FAILURE); + return true; + } catch (IOException e) { + e.printStackTrace(listener.error("Failed to archive testing tool reports")); + build.setResult(Result.FAILURE); + return true; + } + + build.getActions().add(action); + + try { + ArchiveTestsReport(build, listener, fileSystemResultNames); + } catch (ParserConfigurationException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (SAXException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + return true; + } + + @SuppressWarnings("unused") + private void ArchiveTestsReport(AbstractBuild build, + BuildListener listener, List resultFiles) + throws ParserConfigurationException, SAXException, IOException, + InterruptedException { + + if ((resultFiles == null) || (resultFiles.size() == 0)) { + return; + } + + ArrayList zipFileNames = new ArrayList(); + ArrayList reportFolders = new ArrayList(); + + listener.getLogger().println( + "Report archiving mode is set to: " + + resultsPublisherModel.getArchiveTestResultsMode()); + + // if we dont want to archive any results + /*if (resultsPublisherModel.getArchiveTestResultsMode().equals( + ResultsPublisherModel.dontArchiveResults.getValue())) { + + deleteReportsFolder(reportFolders,listener); + return; + }*/ + + FilePath projectWS = build.getWorkspace(); + + // get the artifacts directory where we will upload the zipped report + // folder + File artifactsDir = build.getArtifactsDir(); + artifactsDir.mkdirs(); + + // read each result.xml + /* + * The structure of the result file is: + * + * + * + * + * + */ + + for (String resultsFilePath : resultFiles) { + FilePath resultsFile = projectWS.child(resultsFilePath); + + DocumentBuilderFactory dbFactory = DocumentBuilderFactory + .newInstance(); + DocumentBuilder dBuilder = dbFactory.newDocumentBuilder(); + + Document doc = dBuilder.parse(resultsFile.read()); + doc.getDocumentElement().normalize(); + + Node testSuiteNode = doc.getElementsByTagName("testsuite").item(0); + NodeList testCasesNodes = ((Element) testSuiteNode) + .getElementsByTagName("testcase"); + + for (int i = 0; i < testCasesNodes.getLength(); i++) { + + Node nNode = testCasesNodes.item(i); + + if (nNode.getNodeType() == Node.ELEMENT_NODE) { + + Element eElement = (Element) nNode; + + if (!eElement.hasAttribute("report")) { + continue; + } + + String reportFolderPath = eElement.getAttribute("report"); + String testFolderPath = eElement.getAttribute("name"); + String testStatus = eElement.getAttribute("status"); + + FilePath reportFolder = new FilePath( + projectWS.getChannel(), reportFolderPath); + + reportFolders.add(reportFolder); + + String archiveTestResultMode = resultsPublisherModel + .getArchiveTestResultsMode(); + boolean archiveTestResult = false; + + if (archiveTestResultMode + .equals(ResultsPublisherModel.alwaysArchiveResults + .getValue())) { + archiveTestResult = true; + } else if (archiveTestResultMode.equals(ResultsPublisherModel.ArchiveFailedTestsResults.getValue())) { + if (testStatus.equals("fail")) { + archiveTestResult = true; + } + else if (archiveTestResultMode.equals(ResultsPublisherModel.dontArchiveResults.getValue())){ + archiveTestResult = false; + } + } + + if (archiveTestResult) { + + if (reportFolder.exists()) { + + FilePath testFolder = new FilePath( + projectWS.getChannel(), testFolderPath); + + String zipFileName = GetUniqueZipFileNameInFolder( + zipFileNames, testFolder.getName()); + zipFileNames.add(zipFileName); + + listener.getLogger().println( + "Zipping report folder: " + + reportFolderPath); + + ByteArrayOutputStream outstr = new ByteArrayOutputStream(); + reportFolder.zip(outstr); + + /* + * I did't use copyRecursiveTo or copyFrom due to + * bug in + * jekins:https://issues.jenkins-ci.org/browse + * /JENKINS-9189 //(which is cleaimed to have been + * fixed, but not. So I zip the folder to stream and + * copy it to the master. + */ + + ByteArrayInputStream instr = new ByteArrayInputStream( + outstr.toByteArray()); + + FilePath archivedFile = new FilePath(new FilePath( + artifactsDir), zipFileName); + archivedFile.copyFrom(instr); + + outstr.close(); + instr.close(); + + } else { + listener.getLogger().println( + "No report folder was found in: " + + reportFolderPath); + } + } + } + } + } + + deleteReportsFolder(reportFolders,listener); + } + + + private void deleteReportsFolder(ArrayList reportFolders,BuildListener listener){ + if (reportFolders.size() > 0) { + listener.getLogger().println("Starting to delete reports folder: " + reportFolders.size() + " were found"); + + for (FilePath reportPath : reportFolders) { + try { + reportPath.deleteRecursive(); + + } catch (Exception e) { + // TODO: handle exception + } + } + + listener.getLogger().println("Finished deleting reports folder"); + } + } + + + /* + * if we have a directory with file name "file.zip" we will return + * "file_1.zip"; + */ + private String GetUniqueZipFileNameInFolder(ArrayList names, + String fileName) throws IOException, InterruptedException { + + String result = fileName + "_Report.zip"; + + int index = 0; + + while (names.indexOf(result) > -1) { + result = fileName + "_" + (++index) + "_Report.zip"; + } + + return result; + } + + @Override + public Action getProjectAction(AbstractProject project) { + return new TestResultProjectAction(project); + } + + public MatrixAggregator createAggregator(MatrixBuild build, + Launcher launcher, BuildListener listener) { + return new TestResultAggregator(build, launcher, listener); + } + + public BuildStepMonitor getRequiredMonitorService() { + return BuildStepMonitor.BUILD; + } + + public ResultsPublisherModel getResultsPublisherModel() { + return resultsPublisherModel; + } + + @Extension + public static class DescriptorImpl extends BuildStepDescriptor { + + public DescriptorImpl() { + load(); + } + + public String getDisplayName() { + return "Publish HP tests result"; + } + + public boolean isApplicable(Class jobType) { + return true; + } + + public List getReportArchiveModes() { + return ResultsPublisherModel.archiveModes; + } + + } +} diff --git a/src/main/java/com/hp/application/automation/tools/run/AlmRunTypes.java b/src/main/java/com/hp/application/automation/tools/run/AlmRunTypes.java new file mode 100644 index 0000000000..75b4f4a7c4 --- /dev/null +++ b/src/main/java/com/hp/application/automation/tools/run/AlmRunTypes.java @@ -0,0 +1,13 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +package com.hp.application.automation.tools.run; +public class AlmRunTypes { + + public enum RunType { + Alm, FileSystem, LoadRunner + } + +} diff --git a/src/main/java/com/hp/application/automation/tools/run/RunFromAlmBuilder.java b/src/main/java/com/hp/application/automation/tools/run/RunFromAlmBuilder.java new file mode 100644 index 0000000000..5c8057efd5 --- /dev/null +++ b/src/main/java/com/hp/application/automation/tools/run/RunFromAlmBuilder.java @@ -0,0 +1,302 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +package com.hp.application.automation.tools.run; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.PrintStream; +import java.net.URL; +import java.text.Format; +import java.text.SimpleDateFormat; +import java.util.Date; +import java.util.List; +import java.util.Properties; +import org.apache.commons.lang.StringUtils; +import org.kohsuke.stapler.DataBoundConstructor; +import org.kohsuke.stapler.QueryParameter; + +import com.hp.application.automation.tools.model.AlmServerSettingsModel; +import com.hp.application.automation.tools.model.EnumDescription; +import com.hp.application.automation.tools.model.RunFromAlmModel; +import com.hp.application.automation.tools.run.AlmRunTypes.RunType; +import com.hp.application.automation.tools.settings.AlmServerSettingsBuilder; +import com.hp.application.automation.tools.AlmToolsUtils; +import com.hp.application.automation.tools.EncryptionUtils; + +import hudson.EnvVars; +import hudson.Extension; +import hudson.FilePath; +import hudson.Launcher; +import hudson.Util; +import hudson.model.BuildListener; +import hudson.model.AbstractBuild; +import hudson.model.AbstractProject; +import hudson.model.Hudson; +import hudson.model.Result; +import hudson.tasks.BuildStepDescriptor; +import hudson.tasks.Builder; +import hudson.util.FormValidation; +import hudson.util.IOUtils; +import hudson.util.VariableResolver; + +public class RunFromAlmBuilder extends Builder { + + private RunFromAlmModel runFromAlmModel; + private final static String HpToolsLauncher_SCRIPT_NAME = "HpToolsLauncher.exe"; + private String ResultFilename = "ApiResults.xml"; + private String ParamFileName = "ApiRun.txt"; + private String KillFileName = ""; + + @DataBoundConstructor + public RunFromAlmBuilder(String almServerName, String almUserName, String almPassword, String almDomain, + String almProject, String almTestSets, String almRunResultsMode, String almTimeout, String almRunMode, + String almRunHost) { + + runFromAlmModel = new RunFromAlmModel(almServerName, almUserName, almPassword, almDomain, almProject, + almTestSets, almRunResultsMode, almTimeout, almRunMode, almRunHost); + } + + @Override + public DescriptorImpl getDescriptor() { + return (DescriptorImpl) super.getDescriptor(); + } + + @Override + public boolean perform(AbstractBuild build, Launcher launcher, BuildListener listener) + throws InterruptedException, IOException { + + // get the alm server settings + AlmServerSettingsModel almServerSettingsModel = getAlmServerSettingsModel(); + + if (almServerSettingsModel==null){ + listener.fatalError("An ALM server is not defined. Go to Manage Jenkins->Configure System and define your ALM server under Application Lifecycle Management"); + return false; + } + + EnvVars env = null; + try { + env = build.getEnvironment(listener); + } catch (IOException e2) { + // TODO Auto-generated catch block + e2.printStackTrace(); + } + VariableResolver varResolver = build.getBuildVariableResolver(); + + // now merge them into one list + Properties mergedProperties = new Properties(); + + mergedProperties.putAll(almServerSettingsModel.getProperties()); + mergedProperties.putAll(runFromAlmModel.getProperties(env, varResolver)); + + String encAlmPass = ""; + try { + + encAlmPass = EncryptionUtils.Encrypt(runFromAlmModel.getAlmPassword(), EncryptionUtils.getSecretKey()); + + mergedProperties.remove(RunFromAlmModel.ALM_PASSWORD_KEY); + mergedProperties.put(RunFromAlmModel.ALM_PASSWORD_KEY, encAlmPass); + + } catch (Exception e) { + build.setResult(Result.FAILURE); + listener.fatalError("problem in qcPassword encription"); + } + + Date now = new Date(); + Format formatter = new SimpleDateFormat("ddMMyyyyHHmmssSSS"); + String time = formatter.format(now); + + // get a unique filename for the params file + ParamFileName = "props" + time + ".txt"; + ResultFilename = "Results" + time + ".xml"; + KillFileName = "stop" + time + ".txt"; + + mergedProperties.put("runType", RunType.Alm.toString()); + mergedProperties.put("resultsFilename", ResultFilename); + + // get properties serialized into a stream + ByteArrayOutputStream stream = new ByteArrayOutputStream(); + try { + mergedProperties.store(stream, ""); + } catch (IOException e) { + build.setResult(Result.FAILURE); + // TODO Auto-generated catch block + e.printStackTrace(); + } + String propsSerialization = stream.toString(); + InputStream propsStream = IOUtils.toInputStream(propsSerialization); + + // get the remote workspace filesys + FilePath projectWS = build.getWorkspace(); + + // Get the URL to the Script used to run the test, which is bundled + // in the plugin + URL cmdExeUrl = Hudson.getInstance().pluginManager.uberClassLoader.getResource(HpToolsLauncher_SCRIPT_NAME); + if (cmdExeUrl == null) { + listener.fatalError(HpToolsLauncher_SCRIPT_NAME + " not found in resources"); + return false; + } + + FilePath propsFileName = projectWS.child(ParamFileName); + FilePath CmdLineExe = projectWS.child(HpToolsLauncher_SCRIPT_NAME); + + try { + // create a file for the properties file, and save the properties + propsFileName.copyFrom(propsStream); + + // Copy the script to the project workspace + CmdLineExe.copyFrom(cmdExeUrl); + } catch (IOException e1) { + build.setResult(Result.FAILURE); + // TODO Auto-generated catch block + e1.printStackTrace(); + } + + try { + // Run the HpToolsLauncher.exe + String logFile = AlmToolsUtils.runOnBuildEnv(build, launcher, listener, CmdLineExe, ParamFileName); + // Has the report been successfuly generated? + if (!projectWS.child(logFile).exists()) { + listener.fatalError("Report could not be generated"); + return false; + } + } catch (IOException ioe) { + Util.displayIOException(ioe, listener); + build.setResult(Result.FAILURE); + return false; + } catch (InterruptedException e) { + build.setResult(Result.FAILURE); + PrintStream out = listener.getLogger(); + // kill processes + FilePath killFile = projectWS.child(KillFileName); + try { + killFile.write("\n", "UTF-8"); + } catch (IOException e1) { + build.setResult(Result.FAILURE); + // TODO Auto-generated catch block + e1.printStackTrace(); + } catch (InterruptedException e1) { + build.setResult(Result.FAILURE); + // TODO Auto-generated catch block + e1.printStackTrace(); + } + + out.println("Operation Was aborted by user."); + build.setResult(Result.FAILURE); + } + return true; + + } + + public AlmServerSettingsModel getAlmServerSettingsModel() { + for (AlmServerSettingsModel almServer : getDescriptor().getAlmServers()) { + if (this.runFromAlmModel != null && runFromAlmModel.getAlmServerName().equals(almServer.getAlmServerName())) { + return almServer; + } + } + return null; + } + + public RunFromAlmModel getRunFromAlmModel() { + return runFromAlmModel; + } + + @Extension + // This indicates to Jenkins that this is an implementation of an extension + // point. + public static final class DescriptorImpl extends BuildStepDescriptor { + + public DescriptorImpl() { + load(); + } + + @Override + public boolean isApplicable(Class jobType) { + return true; + } + + @Override + public String getDisplayName() { + return "Execute HP tests from HP ALM"; + } + + public boolean hasAlmServers() { + return Hudson.getInstance().getDescriptorByType(AlmServerSettingsBuilder.DescriptorImpl.class) + .hasAlmServers(); + } + + public AlmServerSettingsModel[] getAlmServers() { + return Hudson.getInstance().getDescriptorByType(AlmServerSettingsBuilder.DescriptorImpl.class) + .getInstallations(); + } + + public FormValidation doCheckAlmUserName(@QueryParameter String value) { + if (StringUtils.isBlank(value)) { + return FormValidation.error("User name must be set"); + } + + return FormValidation.ok(); + } + + public FormValidation doCheckAlmTimeout(@QueryParameter String value) { + + if (StringUtils.isEmpty(value)){ + return FormValidation.ok(); + } + + String val1 = value.trim(); + + if (val1.length()>0 && val1.charAt(0) == '-') + val1=val1.substring(1); + + if (!StringUtils.isNumeric(val1) && val1 !="") + { + return FormValidation.error("Timeout name must be a number"); + } + return FormValidation.ok(); + } + + public FormValidation doCheckAlmPassword(@QueryParameter String value) { + // if (StringUtils.isBlank(value)) { + // return FormValidation.error("Password must be set"); + // } + + return FormValidation.ok(); + } + + public FormValidation doCheckAlmDomain(@QueryParameter String value) { + if (StringUtils.isBlank(value)) { + return FormValidation.error("Domain must be set"); + } + + return FormValidation.ok(); + } + + public FormValidation doCheckAlmProject(@QueryParameter String value) { + if (StringUtils.isBlank(value)) { + return FormValidation.error("Project must be set"); + } + + return FormValidation.ok(); + } + + public FormValidation doCheckAlmTestSets(@QueryParameter String value) { + if (StringUtils.isBlank(value)) { + return FormValidation.error("Testsets are missing"); + } + + return FormValidation.ok(); + } + + public List getAlmRunModes() { + return RunFromAlmModel.runModes; + } + } + + public String getRunResultsFileName() { + return ResultFilename; + } +} diff --git a/src/main/java/com/hp/application/automation/tools/run/RunFromFileBuilder.java b/src/main/java/com/hp/application/automation/tools/run/RunFromFileBuilder.java new file mode 100644 index 0000000000..a8159b649f --- /dev/null +++ b/src/main/java/com/hp/application/automation/tools/run/RunFromFileBuilder.java @@ -0,0 +1,216 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +package com.hp.application.automation.tools.run; + +import org.apache.commons.lang.StringUtils; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.PrintStream; +import java.net.URL; +import java.text.Format; +import java.text.SimpleDateFormat; +import java.util.Date; +import java.util.Properties; +import org.kohsuke.stapler.DataBoundConstructor; +import org.kohsuke.stapler.QueryParameter; +import com.hp.application.automation.tools.model.RunFromFileSystemModel; +import com.hp.application.automation.tools.run.AlmRunTypes.RunType; +import com.hp.application.automation.tools.AlmToolsUtils; +import hudson.EnvVars; +import hudson.Extension; +import hudson.FilePath; +import hudson.Launcher; +import hudson.Util; +import hudson.model.BuildListener; +import hudson.model.AbstractBuild; +import hudson.model.AbstractProject; +import hudson.model.Hudson; +import hudson.model.Result; +import hudson.tasks.BuildStepDescriptor; +import hudson.tasks.Builder; +import hudson.util.FormValidation; +import hudson.util.IOUtils; +import hudson.util.VariableResolver; + +public class RunFromFileBuilder extends Builder { + + private RunFromFileSystemModel runFromFileModel; + private final static String HpToolsLauncher_SCRIPT_NAME = "HpToolsLauncher.exe"; + private String ResultFilename = "ApiResults.xml"; + private String KillFileName = ""; + private String ParamFileName = "ApiRun.txt"; + + @DataBoundConstructor + public RunFromFileBuilder(String fsTests, String fsTimeout) { + + runFromFileModel = new RunFromFileSystemModel(fsTests, fsTimeout); + } + + @Override + public DescriptorImpl getDescriptor() { + return (DescriptorImpl) super.getDescriptor(); + } + + @Override + public boolean perform(AbstractBuild build, Launcher launcher, BuildListener listener) { + + EnvVars env = null; + try { + env = build.getEnvironment(listener); + } catch (IOException e2) { + // TODO Auto-generated catch block + e2.printStackTrace(); + } catch (InterruptedException e2) { + // TODO Auto-generated catch block + e2.printStackTrace(); + } + VariableResolver varResolver = build.getBuildVariableResolver(); + + // now merge them into one list + Properties mergedProperties = new Properties(); + + mergedProperties.putAll(runFromFileModel.getProperties(env, varResolver)); + + Date now = new Date(); + Format formatter = new SimpleDateFormat("ddMMyyyyHHmmssSSS"); + String time = formatter.format(now); + + // get a unique filename for the params file + ParamFileName = "props" + time + ".txt"; + ResultFilename = "Results" + time + ".xml"; + KillFileName = "stop" + time + ".txt"; + + mergedProperties.put("runType", RunType.FileSystem.toString()); + mergedProperties.put("resultsFilename", ResultFilename); + + // get properties serialized into a stream + ByteArrayOutputStream stream = new ByteArrayOutputStream(); + try { + mergedProperties.store(stream, ""); + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + build.setResult(Result.FAILURE); + } + String propsSerialization = stream.toString(); + InputStream propsStream = IOUtils.toInputStream(propsSerialization); + + // get the remote workspace filesys + FilePath projectWS = build.getWorkspace(); + + // Get the URL to the Script used to run the test, which is bundled + // in the plugin + URL cmdExeUrl = Hudson.getInstance().pluginManager.uberClassLoader.getResource(HpToolsLauncher_SCRIPT_NAME); + if (cmdExeUrl == null) { + listener.fatalError(HpToolsLauncher_SCRIPT_NAME + " not found in resources"); + return false; + } + + FilePath propsFileName = projectWS.child(ParamFileName); + FilePath CmdLineExe = projectWS.child(HpToolsLauncher_SCRIPT_NAME); + + try { + // create a file for the properties file, and save the properties + propsFileName.copyFrom(propsStream); + + // Copy the script to the project workspace + CmdLineExe.copyFrom(cmdExeUrl); + } catch (IOException e1) { + build.setResult(Result.FAILURE); + // TODO Auto-generated catch block + e1.printStackTrace(); + } catch (InterruptedException e1) { + build.setResult(Result.FAILURE); + // TODO Auto-generated catch block + e1.printStackTrace(); + } + + try { + // Run the HpToolsLauncher.exe + String logFile = AlmToolsUtils.runOnBuildEnv(build, launcher, listener, CmdLineExe, ParamFileName); + // Has the report been successfuly generated? + if (!projectWS.child(logFile).exists()) { + listener.fatalError("Report could not be generated"); + return false; + } + } catch (IOException ioe) { + Util.displayIOException(ioe, listener); + build.setResult(Result.FAILURE); + return false; + } catch (InterruptedException e) { + build.setResult(Result.FAILURE); + PrintStream out = listener.getLogger(); + // kill processes + FilePath killFile = projectWS.child(KillFileName); + try { + killFile.write("\n", "UTF-8"); + } catch (IOException e1) { + // TODO Auto-generated catch block + e1.printStackTrace(); + } catch (InterruptedException e1) { + // TODO Auto-generated catch block + e1.printStackTrace(); + } + + out.println("Operation Was aborted by user."); + } + + return true; + + } + + public RunFromFileSystemModel getRunFromFileModel() { + return runFromFileModel; + } + + @Extension + // This indicates to Jenkins that this is an implementation of an extension + // point. + public static final class DescriptorImpl extends BuildStepDescriptor { + + public DescriptorImpl() { + load(); + } + + @Override + public boolean isApplicable(Class jobType) { + return true; + } + + @Override + public String getDisplayName() { + return "Execute HP tests from file system"; + } + + public FormValidation doCheckFsTests(@QueryParameter String value) + { + return FormValidation.ok(); + } + + public FormValidation doCheckFsTimeout(@QueryParameter String value) + { + if (StringUtils.isEmpty(value)){ + return FormValidation.ok(); + } + + String val1 = value.trim(); + if (val1.length()>0 && val1.charAt(0) == '-') + val1=val1.substring(1); + + if (!StringUtils.isNumeric(val1) && val1 !="") + { + return FormValidation.error("Timeout name must be a number"); + } + return FormValidation.ok(); + } + + } + + public String getRunResultsFileName() { + return ResultFilename; + } +} diff --git a/src/main/java/com/hp/application/automation/tools/settings/AlmServerSettingsBuilder.java b/src/main/java/com/hp/application/automation/tools/settings/AlmServerSettingsBuilder.java new file mode 100644 index 0000000000..1e90bc8a9e --- /dev/null +++ b/src/main/java/com/hp/application/automation/tools/settings/AlmServerSettingsBuilder.java @@ -0,0 +1,171 @@ +// (c) Copyright 2012 Hewlett-Packard Development Company, L.P. +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +package com.hp.application.automation.tools.settings; + + +import hudson.CopyOnWrite; +import hudson.Launcher; +import hudson.Extension; +import hudson.util.FormValidation; +import hudson.model.AbstractBuild; +import hudson.model.BuildListener; +import hudson.model.AbstractProject; +import hudson.tasks.Builder; +import hudson.tasks.BuildStepDescriptor; +import net.sf.json.JSONObject; +import org.apache.commons.lang.StringUtils; +import org.kohsuke.stapler.StaplerRequest; +import org.kohsuke.stapler.QueryParameter; +import com.hp.application.automation.tools.model.AlmServerSettingsModel; +import java.io.IOException; +import java.net.HttpURLConnection; +import java.net.MalformedURLException; +import java.net.URL; + +/** + * Sample {@link Builder}. + * + *

+ * When the user configures the project and enables this builder, + * {@link DescriptorImpl#newInstance(StaplerRequest)} is invoked and a new + * {@link AlmServerSettingsBuilder} is created. The created instance is + * persisted to the project configuration XML by using XStream, so this allows + * you to use instance fields (like {@link #name}) to remember the + * configuration. + * + *

+ * When a build is performed, the + * {@link #perform(AbstractBuild, Launcher, BuildListener)} method will be + * invoked. + * + * @author Kohsuke Kawaguchi + */ +public class AlmServerSettingsBuilder extends Builder { + + @Override + public DescriptorImpl getDescriptor() { + return (DescriptorImpl) super.getDescriptor(); + } + + /** + * Descriptor for {@link AlmServerSettingsBuilder}. Used as a singleton. The + * class is marked as public so that it can be accessed from views. + * + *

+ * See + * src/main/resources/hudson/plugins/hello_world/HelloWorldBuilder/*.jelly + * for the actual HTML fragment for the configuration screen. + */ + @Extension + // This indicates to Jenkins that this is an implementation of an extension + // point. + public static final class DescriptorImpl extends BuildStepDescriptor { + + public boolean isApplicable(Class aClass) { + // Indicates that this builder can be used with all kinds of project + // types + return true; + } + + /** + * This human readable name is used in the configuration screen. + */ + public String getDisplayName() { + return ""; + } + + public DescriptorImpl() { + load(); + } + + @Override + public boolean configure(StaplerRequest req, JSONObject formData) throws FormException { + // To persist global configuration information, + // set that to properties and call save(). + // useFrench = formData.getBoolean("useFrench"); + // ^Can also use req.bindJSON(this, formData); + // (easier when there are many fields; need set* methods for this, + // like setUseFrench) + // req.bindParameters(this, "locks."); + + setInstallations(req.bindParametersToList(AlmServerSettingsModel.class, "alm.").toArray( + new AlmServerSettingsModel[0])); + + save(); + + return super.configure(req, formData); + } + + public FormValidation doCheckAlmServerURL(@QueryParameter String value) { + return checkQcServerURL(value, false); + } + + @CopyOnWrite + private AlmServerSettingsModel[] installations = new AlmServerSettingsModel[0]; + + public AlmServerSettingsModel[] getInstallations() { + return installations; + } + + public void setInstallations(AlmServerSettingsModel... installations) { + this.installations = installations; + } + + public FormValidation doCheckAlmServerName(@QueryParameter String value) { + if (StringUtils.isBlank(value)) { + return FormValidation.error("ALM server name cannot be empty"); + } + + return FormValidation.ok(); + } + + private FormValidation checkQcServerURL(String value, Boolean acceptEmpty) { + String url; + // Path to the page to check if the server is alive + String page = "servlet/tdservlet/TDAPI_GeneralWebTreatment"; + + // Do will allow empty value? + if (StringUtils.isBlank(value)) { + if (!acceptEmpty) { + return FormValidation.error("ALM server must be defined"); + } else { + return FormValidation.ok(); + } + } + + // Does the URL ends with a "/" ? if not, add it + if (value.lastIndexOf("/") == value.length() - 1) { + url = value + page; + } else { + url = value + "/" + page; + } + + // Open the connection and perform a HEAD request + HttpURLConnection connection; + try { + connection = (HttpURLConnection) new URL(url).openConnection(); + connection.setRequestMethod("HEAD"); + + // Check the response code + if (connection.getResponseCode() != HttpURLConnection.HTTP_OK) { + return FormValidation.error(connection.getResponseMessage()); + } + } catch (MalformedURLException ex) { + // This is not a valid URL + return FormValidation.error("ALM server URL is malformed."); + } catch (IOException ex) { + // Cant open connection to the server + return FormValidation.error("Error openning a connection to the ALM server"); + } + + return FormValidation.ok(); + } + + public Boolean hasAlmServers() { + return installations.length > 0; + } + } +} diff --git a/src/main/resources/HpToolsLauncher.exe b/src/main/resources/HpToolsLauncher.exe new file mode 100644 index 0000000000000000000000000000000000000000..687ecff5794433ba9b6a457197b13133f5f74f0a GIT binary patch literal 108032 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 + + + + + + + + diff --git a/src/main/resources/com/hp/application/automation/tools/results/RunResultRecorder/help-archiveTestResultsMode.html b/src/main/resources/com/hp/application/automation/tools/results/RunResultRecorder/help-archiveTestResultsMode.html new file mode 100644 index 0000000000..e27d7819fd --- /dev/null +++ b/src/main/resources/com/hp/application/automation/tools/results/RunResultRecorder/help-archiveTestResultsMode.html @@ -0,0 +1,5 @@ +

+ To view the report result, go to the Build Artifacts, download the zipped report, and unzip it. + In the HP Run Results Viewer select File > Open. Select "Results XML file" and navigate to the Results.xml file in the folder that you unzipped. + This is only valid when using the "Execute HP test from file system" build step. +
diff --git a/src/main/resources/com/hp/application/automation/tools/run/RunFromAlmBuilder/config.jelly b/src/main/resources/com/hp/application/automation/tools/run/RunFromAlmBuilder/config.jelly new file mode 100644 index 0000000000..0c162395f8 --- /dev/null +++ b/src/main/resources/com/hp/application/automation/tools/run/RunFromAlmBuilder/config.jelly @@ -0,0 +1,74 @@ + + + + + + + + +
+ ${%AlmServersAreNotDefined} +
+ + + + + + + + +
+ ${%DontForgetThePublisher} +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/main/resources/com/hp/application/automation/tools/run/RunFromAlmBuilder/config.properties b/src/main/resources/com/hp/application/automation/tools/run/RunFromAlmBuilder/config.properties new file mode 100644 index 0000000000..da813a9bdd --- /dev/null +++ b/src/main/resources/com/hp/application/automation/tools/run/RunFromAlmBuilder/config.properties @@ -0,0 +1,5 @@ +DontForgetThePublisher=Don''t forget to enable the Publish HP \ + tests result option in the Post-build \ + Actions section so that the tests results are published. + +AlmServersAreNotDefined=HP ALM servers are not defined. To use this build step, goto Manage Jenkins->Configure System->Application Lifecycle Management->Add ALM server \ No newline at end of file diff --git a/src/main/resources/com/hp/application/automation/tools/run/RunFromAlmBuilder/help-AlmRunHost.html b/src/main/resources/com/hp/application/automation/tools/run/RunFromAlmBuilder/help-AlmRunHost.html new file mode 100644 index 0000000000..7c3782d972 --- /dev/null +++ b/src/main/resources/com/hp/application/automation/tools/run/RunFromAlmBuilder/help-AlmRunHost.html @@ -0,0 +1,3 @@ +
+If the Run mode field is set to Run remotely, use this field to specify the name of the host that runs the test set. +
\ No newline at end of file diff --git a/src/main/resources/com/hp/application/automation/tools/run/RunFromAlmBuilder/help-AlmRunMode.html b/src/main/resources/com/hp/application/automation/tools/run/RunFromAlmBuilder/help-AlmRunMode.html new file mode 100644 index 0000000000..b4bffb4ff7 --- /dev/null +++ b/src/main/resources/com/hp/application/automation/tools/run/RunFromAlmBuilder/help-AlmRunMode.html @@ -0,0 +1,8 @@ +
+Defines how the test set is executed: +
    +
  • Run locally: The test set is run on the machine that performs the build.
    • +
  • Run remotely: The test set is run on the host defined in the Testing Tool host field.
    • +
  • Run on planned host: The test set is run on the host defined in ALM.
    • +
+
\ No newline at end of file diff --git a/src/main/resources/com/hp/application/automation/tools/run/RunFromAlmBuilder/help-AlmTestSets.html b/src/main/resources/com/hp/application/automation/tools/run/RunFromAlmBuilder/help-AlmTestSets.html new file mode 100644 index 0000000000..c447b8c757 --- /dev/null +++ b/src/main/resources/com/hp/application/automation/tools/run/RunFromAlmBuilder/help-AlmTestSets.html @@ -0,0 +1,4 @@ +
+List of test sets to run. Each line contains a path to a test set or a test set folder.
+For example: Root\subFolder1\subFolder2\testSetToRun +
diff --git a/src/main/resources/com/hp/application/automation/tools/run/RunFromAlmBuilder/help-AlmTimeout.html b/src/main/resources/com/hp/application/automation/tools/run/RunFromAlmBuilder/help-AlmTimeout.html new file mode 100644 index 0000000000..71e7fa982d --- /dev/null +++ b/src/main/resources/com/hp/application/automation/tools/run/RunFromAlmBuilder/help-AlmTimeout.html @@ -0,0 +1,3 @@ +
+ Number of minutes before timeout. If left empty timeout is unlimited. +
diff --git a/src/main/resources/com/hp/application/automation/tools/run/RunFromFileBuilder/config.jelly b/src/main/resources/com/hp/application/automation/tools/run/RunFromFileBuilder/config.jelly new file mode 100644 index 0000000000..306db2d237 --- /dev/null +++ b/src/main/resources/com/hp/application/automation/tools/run/RunFromFileBuilder/config.jelly @@ -0,0 +1,26 @@ + + + + + + +
+ ${%DontForgetThePublisher} +
+ + + + + + + + + + diff --git a/src/main/resources/com/hp/application/automation/tools/run/RunFromFileBuilder/config.properties b/src/main/resources/com/hp/application/automation/tools/run/RunFromFileBuilder/config.properties new file mode 100644 index 0000000000..fe6b5092a7 --- /dev/null +++ b/src/main/resources/com/hp/application/automation/tools/run/RunFromFileBuilder/config.properties @@ -0,0 +1,3 @@ +DontForgetThePublisher=Don''t forget to enable the Publish HP \ + tests result option in the Post-build \ + Actions section so that the tests results are published. \ No newline at end of file diff --git a/src/main/resources/com/hp/application/automation/tools/run/RunFromFileBuilder/help-FsTests.html b/src/main/resources/com/hp/application/automation/tools/run/RunFromFileBuilder/help-FsTests.html new file mode 100644 index 0000000000..47a478366d --- /dev/null +++ b/src/main/resources/com/hp/application/automation/tools/run/RunFromFileBuilder/help-FsTests.html @@ -0,0 +1,3 @@ +
+List of tests to run, or folders that contain tests to run. Each line contains a single test, folder, or MTB file. +
diff --git a/src/main/resources/com/hp/application/automation/tools/run/RunFromFileBuilder/help-FsTimeout.html b/src/main/resources/com/hp/application/automation/tools/run/RunFromFileBuilder/help-FsTimeout.html new file mode 100644 index 0000000000..71e7fa982d --- /dev/null +++ b/src/main/resources/com/hp/application/automation/tools/run/RunFromFileBuilder/help-FsTimeout.html @@ -0,0 +1,3 @@ +
+ Number of minutes before timeout. If left empty timeout is unlimited. +
diff --git a/src/main/resources/com/hp/application/automation/tools/settings/AlmServerSettingsBuilder/global.jelly b/src/main/resources/com/hp/application/automation/tools/settings/AlmServerSettingsBuilder/global.jelly new file mode 100644 index 0000000000..3e4f9bf1cc --- /dev/null +++ b/src/main/resources/com/hp/application/automation/tools/settings/AlmServerSettingsBuilder/global.jelly @@ -0,0 +1,39 @@ + + + + + + + + + + + + + + + + +
+ +
+ +
+ + + + + + + diff --git a/src/main/resources/com/hp/application/automation/tools/settings/AlmServerSettingsBuilder/help-almServerName.html b/src/main/resources/com/hp/application/automation/tools/settings/AlmServerSettingsBuilder/help-almServerName.html new file mode 100644 index 0000000000..bea532a6b8 --- /dev/null +++ b/src/main/resources/com/hp/application/automation/tools/settings/AlmServerSettingsBuilder/help-almServerName.html @@ -0,0 +1,3 @@ +
+ The name of the ALM Server. This will be used in the "Execute HP test from ALM" build step configuration. +
diff --git a/src/main/resources/com/hp/application/automation/tools/settings/AlmServerSettingsBuilder/help-almServerUrl.html b/src/main/resources/com/hp/application/automation/tools/settings/AlmServerSettingsBuilder/help-almServerUrl.html new file mode 100644 index 0000000000..709f70945e --- /dev/null +++ b/src/main/resources/com/hp/application/automation/tools/settings/AlmServerSettingsBuilder/help-almServerUrl.html @@ -0,0 +1,3 @@ +
+ The name of the URL of the ALM Server: http://myalmserver:8080/qcbin +
diff --git a/src/main/resources/com/hp/application/automation/tools/settings/AlmServerSettingsBuilder/help-almServerVersion.html b/src/main/resources/com/hp/application/automation/tools/settings/AlmServerSettingsBuilder/help-almServerVersion.html new file mode 100644 index 0000000000..af27a5a3d6 --- /dev/null +++ b/src/main/resources/com/hp/application/automation/tools/settings/AlmServerSettingsBuilder/help-almServerVersion.html @@ -0,0 +1,3 @@ +
+ The version of the ALM server:10.0, 11.0, 11.5 +
diff --git a/src/main/resources/index.jelly b/src/main/resources/index.jelly new file mode 100644 index 0000000000..a3fcf2d926 --- /dev/null +++ b/src/main/resources/index.jelly @@ -0,0 +1,6 @@ + +
+ This plugin allows integration with HP ALM and HP Unified Functional Testing. +