public void GenerateSuite(int seed, string suiteName, string outputPath, string[] testPaths, string[] searchPatterns, string[] hintPaths, LoadSuiteConfig config, string cachePath = null, bool legacyProject = false, string globalPackageConfig = null) { Random rand = new Random(seed); int suiteTestCount = 0; _unitTestSelector = new UnitTestSelector(); _unitTestSelector.Initialize(seed, testPaths, searchPatterns, hintPaths, cachePath); for (int iConfig = 0; iConfig < config.LoadTestConfigs.Count; iConfig++) { var loadTestConfig = config.LoadTestConfigs[iConfig]; for (int i = 0; i < loadTestConfig.TestCount; i++) { var loadTestInfo = new LoadTestInfo(globalPackageConfig) { TestName = suiteName + "_" + suiteTestCount.ToString("X4"), Duration = loadTestConfig.Duration, LoadPatternType = typeof(StaticLoadPattern), //Type.GetType(loadTestConfig.LoadPattern), TestPatternType = typeof(RandomTestPattern), //Type.GetType(loadTestConfig.TestPattern), WorkerStrategyType = typeof(DedicatedThreadWorkerStrategy), //Type.GetType(loadTestConfig.WorkerStrategy), WorkerCount = loadTestConfig.NumWorkers, SelfDestruct = loadTestConfig.SelfDestruct, EnvironmentVariables = loadTestConfig.EnvironmentVariables, SuiteConfig = config, Seed = rand.Next(), }; loadTestInfo.SourceDirectory = Path.Combine(outputPath, iConfig.ToString("00") + "_" + loadTestInfo.Duration.TotalHours.ToString("00.##") + "hr", loadTestInfo.TestName); loadTestInfo.UnitTests = _unitTestSelector.NextUnitTests(loadTestConfig.NumTests).ToArray(); //build a list of all the sources files to generate for the load test var generators = new List <ISourceFileGenerator>() { new LoadTestSourceFileGenerator(), new ProgramSourceFileGenerator(), new ExecutionFileGeneratorWindows(), new ExecutionFileGeneratorLinux(), }; //if we want to generate a legacy project file (i.e. ToF project file) use HelixToFProjectFileGenerator otherwise use LoadTestProjectFileGenerator var projectFileGenerator = legacyProject ? (ISourceFileGenerator) new HelixToFProjectFileGenerator() : (ISourceFileGenerator) new LoadTestProjectFileGenerator(); if (!legacyProject) { generators.Add(new LoadTestProjectJsonFileGenerator()); } //I believe the project file generator must be last, becuase it depends on discovering all the other source files //however the ordering beyond that should not matter generators.Add(projectFileGenerator); this.GenerateTestSources(loadTestInfo, generators); CodeGenOutput.Info($"Generated Load Test: {loadTestInfo.TestName}"); suiteTestCount++; } } }
public void DuplicateFileName() { var files = new[] { new CodeGenFile("a.txt", ""), new CodeGenFile("A.txt", "") }; Action action = () => _ = new CodeGenOutput(files, null); action.Should().Throw <ArgumentException>(); }
public override bool Execute() { if (DebugWaitForInput) { this.Log.LogMessageFromText($"PID:{Process.GetCurrentProcess().Id} Attach debugger now.", MessageImportance.High); while (DebugWaitForInput) { ; } } try { CodeGenOutput.Redirect(new TaskLogOutputWriter(this.Log)); LoadSuiteGenerator suiteGen = new LoadSuiteGenerator(); suiteGen.GenerateSuite(this.ParseSeed(), this.SuiteName, this.SuitePath, this.ParseTestPaths(), this.ParseSearchStrings(), this.ParseFrameworkPaths(), this.GetSuiteConfig(), this.DiscoveryCachePath); return(true); //return this.Log.HasLoggedErrors; } catch (Exception e) { this.Log.LogErrorFromException(e); return(false); } }
public void GenerateSuite(int seed, string suiteName, string outputPath, string[] testPaths, string[] searchPatterns, string[] hintPaths, LoadSuiteConfig config, string cachePath = null) { int suiteTestCount = 0; _unitTestSelector = new UnitTestSelector(); _unitTestSelector.Initialize(seed, testPaths, searchPatterns, hintPaths, cachePath); for (int iConfig = 0; iConfig < config.LoadTestConfigs.Count; iConfig++) { var loadTestConfig = config.LoadTestConfigs[iConfig]; for (int i = 0; i < loadTestConfig.TestCount; i++) { var loadTestInfo = new LoadTestInfo() { TestName = suiteName + "_" + suiteTestCount.ToString("X4"), Duration = loadTestConfig.Duration, LoadPatternType = typeof(StaticLoadPattern), //Type.GetType(loadTestConfig.LoadPattern), TestPatternType = typeof(RandomTestPattern), //Type.GetType(loadTestConfig.TestPattern), WorkerStrategyType = typeof(DedicatedThreadWorkerStrategy), //Type.GetType(loadTestConfig.WorkerStrategy), WorkerCount = loadTestConfig.NumWorkers, EnvironmentVariables = loadTestConfig.EnvironmentVariables, SuiteConfig = config, }; loadTestInfo.SourceDirectory = Path.Combine(outputPath, iConfig.ToString("00") + "_" + loadTestInfo.Duration.TotalHours.ToString("00.##") + "hr", loadTestInfo.TestName); loadTestInfo.UnitTests = _unitTestSelector.NextUnitTests(loadTestConfig.NumTests).ToArray(); this.GenerateTestSources(loadTestInfo); CodeGenOutput.Info($"Generated Load Test: {loadTestInfo.TestName}"); suiteTestCount++; } } }
public void WriteCacheToFile(string path) { try { File.WriteAllText(path, JsonConvert.SerializeObject(_candidates)); } catch (Exception e) { CodeGenOutput.Warning($"Unable to write test discovery cache file: {path}.\n{e.ToString()}"); } }
private UnitTestInfo[] GetTests(string path, string[] hintPaths) { List <UnitTestInfo> cachedTests; if (_candidateCache != null && _candidateCache.TryGetValue(path, out cachedTests)) { CodeGenOutput.Info($"{path}: {cachedTests.Count} tests discovered from cache"); return(cachedTests.ToArray()); } else { return(JsonConvert.DeserializeObject <UnitTestInfo[]>(FindTests(path, hintPaths))); } }
private Dictionary <string, List <UnitTestInfo> > LoadCacheFromFile(string path) { Dictionary <string, List <UnitTestInfo> > cache = null; if (File.Exists(path)) { UnitTestInfo[] cachedTests = null; try { cachedTests = ReadCacheFromFile(path); Dictionary <string, DateTime> assmTimestamp = new Dictionary <string, DateTime>(); cache = new Dictionary <string, List <UnitTestInfo> >(); foreach (var test in cachedTests) { DateTime currentAssmTimestamp; if (!assmTimestamp.TryGetValue(test.AssemblyPath, out currentAssmTimestamp)) { currentAssmTimestamp = File.Exists(test.AssemblyPath) ? File.GetLastWriteTime(test.AssemblyPath) : DateTime.MaxValue; assmTimestamp[test.AssemblyPath] = currentAssmTimestamp; } if (currentAssmTimestamp == test.AssemblyLastModified) { List <UnitTestInfo> assmTests; if (!cache.TryGetValue(test.AssemblyPath, out assmTests)) { assmTests = new List <UnitTestInfo>(); cache[test.AssemblyPath] = assmTests; } assmTests.Add(test); } } } catch (Exception e) { CodeGenOutput.Warning($"Unable to read test discovery cache file: {path}.\n{e.ToString()}"); } } return(cache); }
public void Initialize(int seed, string[] paths, string[] patterns, string[] hintPaths, string cachePath = null) { _rand = new Random(seed); if (cachePath != null) { _candidateCache = LoadCacheFromFile(cachePath); } _candidates = this.FindAllTests(paths, patterns, hintPaths).ToArray(); if (cachePath != null) { WriteCacheToFile(cachePath); } CodeGenOutput.Info($"Discovered {_candidates.Length} unit tests, across {_candidates.Select(t => t.AssemblyPath).Distinct().Count()} assemblies."); }
public void WriteCacheToFile(string path) { try { // Serialize the RunConfiguration JsonSerializer serializer = JsonSerializer.CreateDefault(); using (FileStream fs = new FileStream(path, FileMode.Create)) { using (StreamWriter writer = new StreamWriter(fs)) { serializer.Serialize(writer, _candidates); } } } catch (Exception e) { CodeGenOutput.Warning($"Unable to write test discovery cache file: {path}.\n{e.ToString()}"); } }
private UnitTestInfo[] FindTests(string path, string[] hintPaths) { var codeGenDllPath = Assembly.GetExecutingAssembly().Location; var codegenDir = Path.GetDirectoryName(codeGenDllPath); AppDomain loaderDomain = AppDomain.CreateDomain(path, AppDomain.CurrentDomain.Evidence, new AppDomainSetup() { ApplicationBase = codegenDir }); var loader = (TestAssemblyLoader)loaderDomain.CreateInstanceFromAndUnwrap(codeGenDllPath, typeof(TestAssemblyLoader).FullName); loader.InitializeLifetimeService(); HashSet <string> hints = new HashSet <string>(hintPaths) { Path.GetDirectoryName(path) }; loader.Load(path, hints.ToArray()); UnitTestInfo[] tests = loader.GetTests <XUnitTestDiscoverer>(); //if no xunit tests were discovered and the assembly is an exe treat as a standalone exe test if ((tests == null || tests.Length == 0) && Path.GetExtension(path).ToLowerInvariant() == ".exe") { tests = loader.GetTests <StandAloneTestDiscoverer>(); } AppDomain.Unload(loaderDomain); if (tests.Length > 0) { CodeGenOutput.Info($"{path}: {tests.Length} tests discovered from assembly"); } return(tests); }
public string GetTests <TDiscoverer>() where TDiscoverer : ITestDiscoverer, new() { try { var discoverer = new TDiscoverer(); var tests = discoverer.GetTests(_assembly); if (tests.Length > 0) { CodeGenOutput.Info($"{_assembly.Assembly.FullName}: {tests.Length} tests discovered from assembly"); } return(JsonConvert.SerializeObject(tests)); } catch (Exception e) { this.LoadError = (this.LoadError ?? string.Empty) + e.ToString(); } return(JsonConvert.SerializeObject(new UnitTestInfo[] { })); }
public override bool Execute() { if (DebugWaitForInput) { MessageBox.Show($"PID:{Process.GetCurrentProcess().Id} Attach debugger now.", "Debug GenerateStressSuiteTask", MessageBoxButton.OK); } try { CodeGenOutput.Redirect(new TaskLogOutputWriter(this.Log)); LoadSuiteGenerator suiteGen = new LoadSuiteGenerator(); suiteGen.GenerateSuite(this.ParseSeed(), this.SuiteName, this.SuitePath, this.ParseTestPaths(), this.ParseSearchStrings(), this.ParseFrameworkPaths(), this.GetSuiteConfig(), this.DiscoveryCachePath, this.UseLegacyProject, this.PackageConfigPath); return(true); } catch (Exception e) { this.Log.LogErrorFromException(e); return(false); } }