private ScanResults Scan_Integration_Core(string testAppPath, int expectedErrorCount) { LaunchTestApp(testAppPath); var config = Config.Builder.ForProcessId(TestProcess.Id) .WithOutputDirectory(OutputDir) .WithOutputFileFormat(OutputFileFormat.A11yTest) .Build(); var scanner = ScannerFactory.CreateScanner(config); var output = ScanWithProvisionForBuildAgents(scanner); // Validate for consistency Assert.AreEqual(expectedErrorCount, output.ErrorCount); Assert.AreEqual(expectedErrorCount, output.Errors.Count()); if (expectedErrorCount > 0) { var regexForExpectedFile = $"{OutputDir.Replace("\\", "\\\\")}.*\\.a11ytest"; // Validate the output file exists where it is expected Assert.IsTrue(Regex.IsMatch(output.OutputFile.A11yTest, regexForExpectedFile)); Assert.IsTrue(File.Exists(output.OutputFile.A11yTest)); // Validate that we got some properties and patterns Assert.IsTrue(output.Errors.All(error => error.Element.Properties != null)); Assert.IsTrue(output.Errors.All(error => error.Element.Patterns != null)); } else { Assert.IsNull(output.OutputFile.A11yTest); } return(output); }
public void EventClear() { var factory = ScannerFactory.Create(); var aggregateInner = factory.Aggregate <string>(); var aggregateOuter = factory.Aggregate(aggregateInner); var wasPropertyChanged = false; aggregateOuter.PropertyChanged += (sender, args) => { wasPropertyChanged = true; Assert.AreEqual("Scanners", args.PropertyName); }; var wasCollectionChanged = false; aggregateOuter.CollectionChanged += (sender, args) => { wasCollectionChanged = true; Assert.AreEqual(NotifyCollectionChangedAction.Reset, args.Action); }; aggregateOuter.Scanners.Clear(); Assert.IsTrue(wasPropertyChanged, "Checking if the PropertyChanged event was raised."); Assert.IsTrue(wasCollectionChanged, "Checking if the CollectionChanged event was raised."); }
public void EventClear() { var factory = ScannerFactory.Create(); var collection = new ObservableCollection <string> { "foo" }; var scanner = factory.Observable(collection); var wasPropertyChanged = false; scanner.PropertyChanged += (sender, args) => { wasPropertyChanged = true; Assert.AreEqual("Items", args.PropertyName); }; var wasCollectionChanged = false; scanner.CollectionChanged += (sender, args) => { wasCollectionChanged = true; Assert.AreEqual(NotifyCollectionChangedAction.Reset, args.Action); }; collection.Clear(); Assert.IsTrue(wasPropertyChanged, "Checking if the PropertyChanged event was raised."); Assert.IsTrue(wasCollectionChanged, "Checking if the CollectionChanged event was raised."); }
public void EventAdd() { var factory = ScannerFactory.Create(); var aggregate = factory.Aggregate <string>(); var wasPropertyChanged = false; aggregate.PropertyChanged += (sender, args) => { wasPropertyChanged = true; Assert.AreEqual("Scanners", args.PropertyName); }; var wasCollectionChanged = false; aggregate.CollectionChanged += (sender, args) => { wasCollectionChanged = true; Assert.AreEqual(NotifyCollectionChangedAction.Reset, args.Action); }; var scannerToAdd = factory.Immutable("foo"); aggregate.Scanners.Add(scannerToAdd); Assert.IsTrue(wasPropertyChanged, "Checking if the PropertyChanged event was raised."); Assert.IsTrue(wasCollectionChanged, "Checking if the CollectionChanged event was raised."); }
public void CreateContextIsNotNull() { var factory = ScannerFactory.Create(); var context = factory.CreateContext(); Assert.IsNotNull(context); }
public void EventExclude() { var factory = ScannerFactory.Create(); var appDomain = AppDomain.CurrentDomain; var input = factory.AppDomain(appDomain).GetDefinedTypes(); IFilterScanner <TypeInfo> filter = new FilterScanner <TypeInfo>(input); // before we can exclude, we must include something first filter.Include(type => type.IsClass); var wasPropertyChanged = false; filter.PropertyChanged += (sender, args) => { wasPropertyChanged = true; Assert.AreEqual("Exclude", args.PropertyName); }; var wasCollectionChanged = false; filter.CollectionChanged += (sender, args) => { wasCollectionChanged = true; Assert.AreEqual(NotifyCollectionChangedAction.Reset, args.Action); }; filter.Exclude(type => !type.IsPublic); Assert.IsTrue(wasPropertyChanged, "Checking if the PropertyChanged event was raised."); Assert.IsTrue(wasCollectionChanged, "Checking if the CollectionChanged event was raised."); }
public void ScanAgainAfterEvent() { var factory = ScannerFactory.Create(); var context = factory.CreateContext(); var expected = Enumerable.Range(1, 5).ToArray(); var innerMock = new Mock <IScanner <int> >(MockBehavior.Strict); innerMock.SetupGet(_ => _.Factory).Returns(factory); innerMock.Setup(_ => _.Scan(context)).Returns(expected); var inner = innerMock.Object; var cache = inner.Cache(); var items1 = cache.Scan(context); var items2 = cache.Scan(context); CollectionAssert.AreEqual(expected, items1); CollectionAssert.AreEqual(expected, items2); innerMock.Verify(_ => _.Scan(context), Times.Once); innerMock.Raise(_ => _.CollectionChanged += null, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset)); var items3 = cache.Scan(context); var items4 = cache.Scan(context); CollectionAssert.AreEqual(expected, items3); CollectionAssert.AreEqual(expected, items4); innerMock.Verify(_ => _.Scan(context), Times.Exactly(2)); }
public void Scan_Integration() { var config = Config.Builder.ForProcessId(TestProcess.Id) .WithOutputDirectory(OutputDir) .WithOutputFileFormat(OutputFileFormat.A11yTest) .Build(); var scanner = ScannerFactory.CreateScanner(config); var output = scanner.Scan(); var regexForExpectedFile = $"{OutputDir.Replace("\\", "\\\\")}.*\\.a11ytest"; // Validate that we got some errors Assert.IsTrue(output.ErrorCount > 0); Assert.AreEqual(output.ErrorCount, output.Errors.Count()); // Validate that we got some properties and patterns Assert.IsTrue(output.Errors.All(error => error.Element.Properties != null)); Assert.IsTrue(output.Errors.All(error => error.Element.Patterns != null)); // Validate the output file exists where it is expected Assert.IsTrue(Regex.IsMatch(output.OutputFile.A11yTest, regexForExpectedFile)); Assert.IsTrue(File.Exists(output.OutputFile.A11yTest)); EnsureGeneratedFileIsReadableByOldVersionsOfAxeWindows(output, TestProcess.Id); }
public void FactoryParamsEmpty() { var factory = ScannerFactory.Create(); var aggregate = factory.Aggregate <IScanner <string> >(); Assert.IsNotNull(aggregate); CollectionAssert.IsEmpty(aggregate.Scanners); }
public void CurrentDomain() { var factory = ScannerFactory.Create(); var scanner = factory.CurrentDomain(); var expected = AppDomain.CurrentDomain; Assert.AreSame(expected, scanner.AppDomain); }
public void CreateContextTwiceIsDifferent() { var factory = ScannerFactory.Create(); var context1 = factory.CreateContext(); var context2 = factory.CreateContext(); Assert.AreNotSame(context1, context2); }
private static Scanner BuildScanner(GridModel grid, ScannerParameter kbScanParams) { try { return(ScannerFactory.CreateScanner(grid, kbScanParams)); } catch (Exception e) { logger.Error("Building scanner for grid '{0}' failed!\n{1}", grid.Id, e.Message); return(null); } }
public void Verify_can_get_diagnostic_after_instantiation() { var knowledgeBaseProvider = _provider.GetService <IKnowledgeBaseProvider>(); var config = _provider.GetService <HareDuConfig>(); var factory = new ScannerFactory(config, knowledgeBaseProvider); factory.TryGet <FakeSnapshot>(out _).ShouldBeFalse(); // Assert.AreEqual(typeof(DoNothingDiagnostic<ConnectionSnapshot>).FullName.GenerateIdentifier(), diagnostic.Identifier); }
public void FactoryParamsSingle() { var factory = ScannerFactory.Create(); var source1 = factory.Immutable("a"); var aggregate = factory.Aggregate(source1); Assert.IsNotNull(aggregate); CollectionAssert.Contains(aggregate.Scanners, source1); }
public void ExtensionUsingSingleParam() { var factory = ScannerFactory.Create(); var scannerToAdd = factory.Immutable(Assembly.GetExecutingAssembly()); var sourceScanner = factory.CurrentDomain(); var aggregate = sourceScanner.Aggregate(scannerToAdd); Assert.AreEqual(2, aggregate.Scanners.Count); }
/// <summary> /// This entry point does not ship, but it makes for a quick and easy way to debug through the /// automation code. One caveat--we intentionally don't build symbols for this app, so while you /// can use it to to debug the automation code, breakpoints set in this class will be ignored. /// </summary> static void Main(string[] args) { Dictionary <string, string> parameters = new Dictionary <string, string>(); string secondaryConfigFile = string.Empty; char[] delimiters = { '=' }; foreach (string arg in args) { string[] pieces = arg.Split(delimiters); if (pieces.Length == 2) { string key = pieces[0].Trim(); string value = pieces[1].Trim(); if (!string.IsNullOrWhiteSpace(key) && !string.IsNullOrWhiteSpace(value)) { // Special case for SecondaryConfigFile if (key.Equals("SecondaryConfigFile", StringComparison.OrdinalIgnoreCase)) { secondaryConfigFile = value; } else { parameters[key] = value; } continue; } } Console.WriteLine("Ignoring malformed input: {0}", arg); } ; while (true) { Console.Write("Enter process ID to capture (blank to exit): "); string input = Console.ReadLine(); if (string.IsNullOrEmpty(input)) { break; } if (!int.TryParse(input, out int processId)) { Console.WriteLine("Not a valid int: " + input); continue; } var config = Config.Builder.ForProcessId(Convert.ToInt32(input)).Build(); var scanner = ScannerFactory.CreateScanner(config); var results = scanner.Scan(); Console.WriteLine(results); } }
public Finder(ScanType scanType, FileCompareType fileCompareType, bool includeSubDirectories, string searchPattern = "*") { var scanOptions = new ScanOptions(); scanOptions.FileCompareType = fileCompareType; scanOptions.IncludeSubDirectories = includeSubDirectories; scanOptions.SearchPattern = searchPattern; var scannerFactory = new ScannerFactory(); _scanner = scannerFactory.Create(scanType, scanOptions); }
internal static void InitializeAxe() { var processes = Process.GetProcessesByName("Files"); Assert.IsTrue(processes.Length > 0); var config = Config.Builder.ForProcessId(processes[0].Id).Build(); AccessibilityScanner = ScannerFactory.CreateScanner(config); }
public void FromMultipleParams() { var factory = ScannerFactory.Create(); var context = factory.CreateContext(); var scanner = factory.Immutable("a", "b"); var items = scanner.Scan(context); var expected = new[] { "a", "b" }; CollectionAssert.AreEqual(expected, items); }
public void ExtensionUsingMultipleParams() { var factory = ScannerFactory.Create(); var scannerToAdd1 = factory.Immutable(Assembly.GetExecutingAssembly()); var scannerToAdd2 = factory.Immutable(Assembly.GetExecutingAssembly(), Assembly.GetEntryAssembly()); var sourceScanner = factory.CurrentDomain(); var aggregate = sourceScanner.Aggregate(scannerToAdd1, scannerToAdd2); Assert.AreEqual(3, aggregate.Scanners.Count); }
public void Verify_can_return_all_scanners_1() { var knowledgeBaseProvider = _provider.GetService <IKnowledgeBaseProvider>(); var config = _provider.GetService <HareDuConfig>(); var factory = new ScannerFactory(config, knowledgeBaseProvider); factory.Scanners.ShouldNotBeNull(); factory.Scanners.ShouldNotBeEmpty(); factory.Scanners.Keys.Count().ShouldBe(3); }
private static void LoadScanner() { var processes = Process.GetProcessesByName("MUXControlsTestApp"); Verify.IsTrue(processes.Length > 0); string directory = Environment.GetEnvironmentVariable("TEMP") + @"\"; // For instance C:\Users\TDPUser\AppData\Local\Temp\ var config = Config.Builder.ForProcessId(processes[0].Id).WithOutputFileFormat(OutputFileFormat.A11yTest).WithOutputDirectory(directory).Build(); scanner = ScannerFactory.CreateScanner(config); }
public void ExcludeFailsWithNoInclude() { var factory = ScannerFactory.Create(); var scanner = factory.CurrentDomain(); scanner.Exclude(asm => asm.IsDynamic); var context = factory.CreateContext(); scanner.Scan(context); }
public void IsDefined() { var factory = ScannerFactory.Create(); var appDomain = AppDomain.CurrentDomain; var input = factory.AppDomain(appDomain); var filter = input.IsDefined(typeof(GuidAttribute), false); var context = factory.CreateContext(); var items = filter.Scan(context).ToArray(); CollectionAssert.IsNotEmpty(items); }
public void DuplicateNumbers() { var duplicate = new[] { 1, 1, 2, 3, 4, 4, 4, 6 }; var expected = new[] { 1, 2, 3, 4, 6 }; var factory = ScannerFactory.Create(); var input = factory.Immutable(duplicate); var scanner = input.Distinct(); var output = scanner.Scan(); CollectionAssert.AreEqual(expected, output); }
private static async Task RunScanWith(Options opts) { if (opts.From.HasValue != opts.To.HasValue) { Log.Error("Specifying the only one From or To dates is not supported. Both values should be set or removed"); return; } else if (opts.From.HasValue && opts.From > opts.To) { Log.Error("From date should be behind To date"); return; } var today = DateTime.UtcNow.Date; var startDate = opts.From ?? today; var endDate = opts.To ?? today; if (opts.Verbose) { loggingLevelSwitch.MinimumLevel = LogEventLevel.Verbose; } var config = new ConfigurationParser(opts.ConfigPath); var factory = new ScannerFactory(config); // Az-Sk allows to use only one output folder for all concurrently running processes. // Also, user has no control over this folder structure. // Therefore it's easier to run scan sequentially. foreach (var subscription in opts.Subscriptions) { try { var scanDate = startDate; while (scanDate <= endDate) { var subscriptionScanner = new SubscriptionScanner(factory.GetScanner(), factory.GetExporter()); var result = await subscriptionScanner.Scan(subscription, scanDate); Log .ForContext <Program>() .Information("Subscription {Subscription} was scanned with result: {ScanResult} at {ScanDate}", subscription, result.ScanResult, scanDate); scanDate = scanDate.AddDays(1); } } catch (Exception ex) { Log .ForContext <Program>() .Error(ex, "A subscription {Subscription} scanning failed", subscription); } } }
static void Main(string[] args) { // TODO Testing this project var app = new CommandLineApplication { Name = "TodoTracker", Description = "Scan source code and get documentation on all of your TODOs throughout the project" }; //TODO: Testing this project app.HelpOption("-?|-h|--help"); app.VersionOption("-v|--version", () => { return(string.Format("Version {0}", Assembly.GetEntryAssembly().GetCustomAttribute <AssemblyInformationalVersionAttribute>().InformationalVersion)); }); // TODO: Testing this project var directoryOption = app.Option("-d|--directory <directory>", "The Directory to scan, defaults to the current directory if not specified", CommandOptionType.SingleValue); //TODO Testing this project app.OnExecute(() => { var directory = Directory.GetCurrentDirectory(); if (directoryOption.HasValue()) { directory = directoryOption.Value(); } var scanner = ScannerFactory.GetScanner(); var outputFileLocation = scanner.Scan(); Console.WriteLine(string.Format("Output file containing TODOs located here: {0}", outputFileLocation)); return(0); }); //todo: testing this project try { //todo testing this project app.Execute(args); } catch (CommandParsingException ex) { // todo: testing this project Console.WriteLine(ex.Message); } catch (Exception ex) { // todo testing this project Console.WriteLine("Unable to execute application: {0}", ex.Message); } }
public void Self() { var factory = ScannerFactory.Create(); var appDomain = AppDomain.CurrentDomain; var context = factory.CreateContext(); var input = factory.AppDomain(appDomain).GetDefinedTypes(); var before = input.Scan(context); var transform = input.Transform(info => info); var after = transform.Scan(context); CollectionAssert.AreEqual(before, after); }
private static IScanner BuildScanner(IOptions options) { Config.Builder builder = Config.Builder .ForProcessId(options.ProcessId) .WithOutputFileFormat(OutputFileFormat.A11yTest); if (!string.IsNullOrEmpty(options.OutputDirectory)) { builder = builder.WithOutputDirectory(options.OutputDirectory); } return(ScannerFactory.CreateScanner(builder.Build())); }
public void Verify_can_return_all_probes_2() { var knowledgeBaseProvider = _provider.GetService <IKnowledgeBaseProvider>(); var config = _provider.GetService <HareDuConfig>(); var factory = new ScannerFactory(config, knowledgeBaseProvider); bool registered = factory.TryRegisterAllProbes(); registered.ShouldBeTrue(); factory.Probes.ShouldNotBeNull(); factory.Probes.ShouldNotBeEmpty(); factory.Probes.Keys.Count().ShouldBe(21); }
public void ExtensionUsingEnumerable() { var factory = ScannerFactory.Create(); var scannerToAdd1 = factory.Immutable(Assembly.GetExecutingAssembly()); var scannerToAdd2 = factory.Immutable(Assembly.GetExecutingAssembly(), Assembly.GetEntryAssembly()); var scannersToAdd = new HashSet <IScanner <Assembly> > { scannerToAdd1, scannerToAdd2 }; var sourceScanner = factory.CurrentDomain(); var aggregate = sourceScanner.Aggregate(scannersToAdd); Assert.AreEqual(3, aggregate.Scanners.Count); }