public KuduXunitTheoryTestCase(IMessageSink diagnosticMessageSink, TestMethodDisplay defaultMethodDisplay, ITestMethod testMethod, IAttributeInfo testAttribute) : base(diagnosticMessageSink, defaultMethodDisplay, testMethod) { }
public KuduXunitTestFrameworkDiscoverer(IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceProvider, IMessageSink diagnosticMessageSink, IXunitTestCollectionFactory collectionFactory = null) : base(assemblyInfo, sourceProvider, diagnosticMessageSink, collectionFactory) { }
/// <summary> /// Initializes a new instance of the <see cref="XunitFrontController"/> class. /// </summary> /// <param name="assemblyFileName">The test assembly.</param> /// <param name="configFileName">The test assembly configuration file.</param> /// <param name="shadowCopy">If set to <c>true</c>, runs tests in a shadow copied app domain, which allows /// <param name="shadowCopyFolder">The path on disk to use for shadow copying; if <c>null</c>, a folder /// will be automatically (randomly) generated</param> /// <param name="sourceInformationProvider">The source information provider. If <c>null</c>, uses the default (<see cref="T:Xunit.VisualStudioSourceInformationProvider"/>).</param> /// tests to be discovered and run without locking assembly files on disk.</param> /// <param name="diagnosticMessageSink">The message sink which received <see cref="IDiagnosticMessage"/> messages.</param> public XunitFrontController(string assemblyFileName, string configFileName = null, bool shadowCopy = true, string shadowCopyFolder = null, ISourceInformationProvider sourceInformationProvider = null, IMessageSink diagnosticMessageSink = null) { this.assemblyFileName = assemblyFileName; this.configFileName = configFileName; this.shadowCopy = shadowCopy; this.shadowCopyFolder = shadowCopyFolder; this.sourceInformationProvider = sourceInformationProvider; this.diagnosticMessageSink = diagnosticMessageSink ?? new NullMessageSink(); Guard.FileExists("assemblyFileName", assemblyFileName); if (this.sourceInformationProvider == null) { #if !XAMARIN && !WINDOWS_PHONE_APP && !WINDOWS_PHONE && !ASPNET50 && !ASPNETCORE50 this.sourceInformationProvider = new VisualStudioSourceInformationProvider(assemblyFileName); #else this.sourceInformationProvider = new NullSourceInformationProvider(); #endif toDispose.Push(this.sourceInformationProvider); } }
public XunitTestAssemblyRunnerWithAssemblyFixture(ITestAssembly testAssembly, IEnumerable<IXunitTestCase> testCases, IMessageSink diagnosticMessageSink, IMessageSink executionMessageSink, ITestFrameworkExecutionOptions executionOptions) : base(testAssembly, testCases, diagnosticMessageSink, executionMessageSink, executionOptions) { }
static Type GetTestFrameworkType(IAssemblyInfo testAssembly, IMessageSink diagnosticMessageSink) { try { var testFrameworkAttr = testAssembly.GetCustomAttributes(typeof(ITestFrameworkAttribute)).FirstOrDefault(); if (testFrameworkAttr != null) { var discovererAttr = testFrameworkAttr.GetCustomAttributes(typeof(TestFrameworkDiscovererAttribute)).FirstOrDefault(); if (discovererAttr != null) { var discoverer = ExtensibilityPointFactory.GetTestFrameworkTypeDiscoverer(diagnosticMessageSink, discovererAttr); if (discoverer != null) return discoverer.GetTestFrameworkType(testFrameworkAttr); var ctorArgs = discovererAttr.GetConstructorArguments().ToArray(); diagnosticMessageSink.OnMessage(new DiagnosticMessage($"Unable to create custom test framework discoverer type '{ctorArgs[1]}, {ctorArgs[0]}'")); } else { diagnosticMessageSink.OnMessage(new DiagnosticMessage("Assembly-level test framework attribute was not decorated with [TestFrameworkDiscoverer]")); } } } catch (Exception ex) { diagnosticMessageSink.OnMessage(new DiagnosticMessage($"Exception thrown during test framework discoverer construction: {ex.Unwrap()}")); } return typeof(XunitTestFramework); }
public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink) { var methodCallMessage = (IMethodCallMessage)msg; try { ITransportHeaders requestHeaders; Stream requestStream; SerializeRequestMessage(methodCallMessage, out requestHeaders, out requestStream); var sinkStack = new ClientChannelSinkStack(replySink); sinkStack.Push(this, methodCallMessage); this._nextChannelSink.AsyncProcessRequest(sinkStack, methodCallMessage, requestHeaders, requestStream); } catch (Exception ex) { var errorMessage = new ReturnMessage(ex, methodCallMessage); if (replySink != null) { replySink.SyncProcessMessage(errorMessage); } } return null; }
public static LNode concat_id(LNode node, IMessageSink sink) { var args = node.Args; if (args.Count == 0) return null; if (args.Slice(0, args.Count - 1).Any(n => n.IsCall)) return Reject(sink, node, "All arguments to ##() or concat() must be identifiers or literals (except the last one)"); RVList<LNode> attrs = node.Attrs; LNode arg = null; StringBuilder sb = new StringBuilder(); for (int i = 0; i < args.Count; i++) { arg = args[i]; attrs.AddRange(arg.Attrs); if (arg.IsLiteral) sb.Append(arg.Value ?? "null"); else if (arg.IsId) sb.Append(arg.Name); else { // call if (i + 1 != args.Count || !arg.HasSimpleHead()) return Reject(sink, arg, "Expected simple identifier or literal"); sb.Append(arg.Name); } } Symbol combined = GSymbol.Get(sb.ToString()); LNode result; if (arg.IsCall) result = arg.WithTarget(combined); else result = LNode.Id(combined, node); return result.WithAttrs(attrs); }
public MethodCallContext(IMethodCallMessage mcm, IMessageSink nextSink) { mcm.ThrowIfNullArgument(nameof(mcm)); nextSink.ThrowIfNullArgument(nameof(nextSink)); _mcm = mcm; _nextSink = nextSink; }
public virtual IMessageCtrl AsyncProcessMessage(IMessage reqMsg, IMessageSink replySink) { WorkItem work = new WorkItem(reqMsg, this._nextSink, replySink); work.SetAsync(); this._property.HandleWorkRequest(work); return null; }
Xunit2Discoverer(ISourceInformationProvider sourceInformationProvider, IAssemblyInfo assemblyInfo, string assemblyFileName, string xunitExecutionAssemblyPath, string configFileName, bool shadowCopy, string shadowCopyFolder, IMessageSink diagnosticMessageSink) { Guard.ArgumentNotNull("assemblyInfo", (object)assemblyInfo ?? assemblyFileName); Guard.FileExists("xunitExecutionAssemblyPath", xunitExecutionAssemblyPath); DiagnosticMessageSink = diagnosticMessageSink ?? new NullMessageSink(); appDomain = new RemoteAppDomainManager(assemblyFileName ?? xunitExecutionAssemblyPath, configFileName, shadowCopy, shadowCopyFolder); var testFrameworkAssemblyName = GetTestFrameworkAssemblyName(xunitExecutionAssemblyPath); // If we didn't get an assemblyInfo object, we can leverage the reflection-based IAssemblyInfo wrapper if (assemblyInfo == null) assemblyInfo = appDomain.CreateObject<IAssemblyInfo>(testFrameworkAssemblyName, "Xunit.Sdk.ReflectionAssemblyInfo", assemblyFileName); framework = appDomain.CreateObject<ITestFramework>(testFrameworkAssemblyName, "Xunit.Sdk.TestFrameworkProxy", assemblyInfo, sourceInformationProvider, DiagnosticMessageSink); discoverer = Framework.GetDiscoverer(assemblyInfo); }
/// <summary/> public MessageBus(IMessageSink messageSink) { this.messageSink = messageSink; reporterThread = new Thread(ReporterWorker); reporterThread.Start(); }
public CustomProxy( String uri, Type type ) : base( type ) { // store uri of remote service m_uri = uri; // pass through registered chanels foreach( IChannel channel in ChannelServices.RegisteredChannels ) { // and try to find chanel, that can be used to // create message sink for given uri IChannelSender sender = (IChannelSender) channel; if( sender != null ) { // check for messaging protocol if( sender.ChannelName == "tcp" ) { // try to create message sink for specified uri string objectUri = string.Empty; m_messageSink = sender.CreateMessageSink( m_uri, null, out objectUri ); // all right, can return if( m_messageSink != null ) break; } } } if( m_messageSink == null ) throw new Exception( "No channel found for " + m_uri ); // create a unique identifier m_clientID = "/310001/" + Guid.NewGuid().ToString(); }
// Used by Xunit2 when initializing for both discovery and execution. internal Xunit2Discoverer(ISourceInformationProvider sourceInformationProvider, string assemblyFileName, string configFileName, bool shadowCopy, string shadowCopyFolder = null, IMessageSink diagnosticMessageSink = null) : this(sourceInformationProvider, null, assemblyFileName, GetXunitExecutionAssemblyPath(assemblyFileName), configFileName, shadowCopy, shadowCopyFolder, diagnosticMessageSink) { }
public static LNode ForwardProperty(LNode prop, IMessageSink sink) { LNode name, fwd, body; if (prop.ArgCount != 3) return null; LNode target = GetForwardingTarget(fwd = prop.Args[2], name = prop.Args[1]); if (target != null) { body = F.Braces(new RVList<LNode>( F.Call(S.get, F.Braces(F.Call(S.Return, target))), F.Call(S.set, F.Braces(F.Call(S.Assign, target, F.Id(S.value)))))); return prop.WithArgChanged(2, body); } else if ((body = fwd).Calls(S.Braces)) { var body2 = body.WithArgs(stmt => { if (stmt.Calls(S.get, 1) && (target = GetForwardingTarget(stmt.Args[0], name)) != null) return stmt.WithArgs(new RVList<LNode>(F.Braces(F.Call(S.Return, target)))); if (stmt.Calls(S.set, 1) && (target = GetForwardingTarget(stmt.Args[0], name)) != null) return stmt.WithArgs(new RVList<LNode>(F.Braces(F.Call(S.Assign, target, F.Id(S.value))))); return stmt; }); if (body2 != body) return prop.WithArgChanged(2, body2); } return null; }
protected RemoteToInternalSpecificationRunListenerAdapter(object listener, string runOptionsXml) { _listener = (IMessageSink)listener; this.RunOptions = RunOptions.Parse(runOptionsXml); this.Runner = new DefaultRunner(this, RunOptions); }
public IListSource<LNode> Parse(IListSource<Token> input, ISourceFile file, IMessageSink msgs, Symbol inputType = null) { // For efficiency we'd prefer to re-use our _parser object, but // when parsing lazily, we can't re-use it because another parsing // operation could start before this one is finished. To force // greedy parsing, we can call ParseStmtsGreedy(), but the caller may // prefer lazy parsing, especially if the input is large. As a // compromise I'll check if the source file is larger than a // certain arbitrary size. Also, ParseExprs() is always greedy // so we can always re-use _parser in that case. bool exprMode = inputType == ParsingService.Exprs; char _ = '\0'; if (inputType == ParsingService.Exprs || file.Text.TryGet(255, ref _)) { EcsParser parser = _parser; if (parser == null) _parser = parser = new EcsParser(input, file, msgs); else { parser.ErrorSink = msgs ?? MessageSink.Current; parser.Reset(input, file); } if (inputType == ParsingService.Exprs) return parser.ParseExprs(); else return parser.ParseStmtsGreedy(); } else { var parser = new EcsParser(input, file, msgs); return parser.ParseStmtsLazy().Buffered(); } }
public static LNode ForwardMethod(LNode fn, IMessageSink sink) { LNode args, fwd, body; if (fn.ArgCount != 4 || !(fwd = fn.Args[3]).Calls(S.Forward, 1) || !(args = fn.Args[2]).Calls(S.List)) return null; RVList<LNode> formalArgs = args.Args; RVList<LNode> argList = RVList<LNode>.Empty; foreach (var formalArg in formalArgs) { if (!formalArg.Calls(S.Var, 2)) return Reject(sink, formalArg, "'==>' expected a variable declaration here"); LNode argName = formalArg.Args[1]; if (argName.Calls(S.Assign, 2)) argName = argName.Args[0]; LNode @ref = formalArg.AttrNamed(S.Ref) ?? formalArg.AttrNamed(S.Out); if (@ref != null) argName = argName.PlusAttr(@ref); argList.Add(argName); } LNode target = GetForwardingTarget(fwd, fn.Args[1]); LNode call = F.Call(target, argList); bool isVoidFn = fn.Args[0].IsIdNamed(S.Void); body = F.Braces(isVoidFn ? call : F.Call(S.Return, call)); return fn.WithArgChanged(3, body); }
Xunit2Discoverer(AppDomainSupport appDomainSupport, ISourceInformationProvider sourceInformationProvider, IAssemblyInfo assemblyInfo, string assemblyFileName, string xunitExecutionAssemblyPath, string configFileName, bool shadowCopy, string shadowCopyFolder, IMessageSink diagnosticMessageSink, bool verifyAssembliesOnDisk) { Guard.ArgumentNotNull("assemblyInfo", (object)assemblyInfo ?? assemblyFileName); if (verifyAssembliesOnDisk) Guard.FileExists("xunitExecutionAssemblyPath", xunitExecutionAssemblyPath); #if PLATFORM_DOTNET CanUseAppDomains = false; #else CanUseAppDomains = !IsDotNet(xunitExecutionAssemblyPath); #endif DiagnosticMessageSink = diagnosticMessageSink ?? new NullMessageSink(); var appDomainAssembly = assemblyFileName ?? xunitExecutionAssemblyPath; appDomain = AppDomainManagerFactory.Create(appDomainSupport != AppDomainSupport.Denied && CanUseAppDomains, appDomainAssembly, configFileName, shadowCopy, shadowCopyFolder); var testFrameworkAssemblyName = GetTestFrameworkAssemblyName(xunitExecutionAssemblyPath); // If we didn't get an assemblyInfo object, we can leverage the reflection-based IAssemblyInfo wrapper if (assemblyInfo == null) assemblyInfo = appDomain.CreateObject<IAssemblyInfo>(testFrameworkAssemblyName, "Xunit.Sdk.ReflectionAssemblyInfo", assemblyFileName); framework = appDomain.CreateObject<ITestFramework>(testFrameworkAssemblyName, "Xunit.Sdk.TestFrameworkProxy", assemblyInfo, sourceInformationProvider, DiagnosticMessageSink); discoverer = Framework.GetDiscoverer(assemblyInfo); }
public static LNode BackingField(LNode prop, IMessageSink sink) { LNode type, name, body; if (prop.ArgCount != 3 || !(body = prop.Args[2]).Calls(S.Braces)) return null; LNode fieldAttr = null, fieldVarAttr = null; LNode fieldName; bool autoType = false; int i; for (i = 0; i < prop.Attrs.Count; i++) { LNode attr = prop.Attrs[i]; if (attr.IsIdNamed(_field) || attr.Calls(S.Var, 2) && ((autoType = attr.Args[0].IsIdNamed(_field)) || (fieldVarAttr = attr.AttrNamed(_field)) != null && fieldVarAttr.IsId)) { fieldAttr = attr; break; } } if (fieldAttr == null) return null; LNode field = fieldAttr; type = prop.Args[0]; if (field.IsId) { name = prop.Args[1]; fieldName = F.Id(ChooseFieldName(Ecs.EcsNodePrinter.KeyNameComponentOf(name))); field = F.Call(S.Var, type, fieldName).WithAttrs(fieldAttr.Attrs); } else { fieldName = field.Args[1]; if (fieldName.Calls(S.Assign, 2)) fieldName = fieldName.Args[0]; } if (autoType) field = field.WithArgChanged(0, type); if (fieldVarAttr != null) field = field.WithoutAttrNamed(_field); LNode newBody = body.WithArgs(body.Args.SmartSelect(stmt => { var attrs = stmt.Attrs; if (stmt.IsIdNamed(S.get)) { stmt = F.Call(stmt.WithoutAttrs(), F.Braces(F.Call(S.Return, fieldName))).WithAttrs(attrs); stmt.BaseStyle = NodeStyle.Special; } if (stmt.IsIdNamed(S.set)) { stmt = F.Call(stmt.WithoutAttrs(), F.Braces(F.Call(S.Assign, fieldName, F.Id(S.value)))).WithAttrs(attrs); stmt.BaseStyle = NodeStyle.Special; } return stmt; })); if (newBody == body) sink.Write(Severity.Warning, fieldAttr, "The body of the property does not contain a 'get;' or 'set;' statement without a body, so no code was generated to get or set the backing field."); prop = prop.WithAttrs(prop.Attrs.RemoveAt(i)).WithArgChanged(2, newBody); return F.Call(S.Splice, new RVList<LNode>(field, prop)); }
public ContextClientSink(object next) { if (!typeof(IMessageSink).IsInstanceOfType(next)) throw new ArgumentOutOfRangeException("next"); _nextSink = (IMessageSink)next; }
/// <summary> /// Initializes a new instance of the <see cref="T:Xunit.Sdk.XunitTestFrameworkExecutor"/> class. /// </summary> /// <param name="assemblyName">Name of the test assembly.</param><param name="sourceInformationProvider">The source line number information provider.</param><param name="diagnosticMessageSink">The message sink to report diagnostic messages to.</param> public BrowserTestFrameworkExecutor( AssemblyName assemblyName, ISourceInformationProvider sourceInformationProvider, IMessageSink diagnosticMessageSink) : base(assemblyName, sourceInformationProvider, diagnosticMessageSink) { }
/// <summary> /// Initializes a new instance of the <see cref="AOPSinkProcessor" /> class. /// </summary> /// <param name="sender">The sender.</param> /// <param name="nextSink">The next sink.</param> /// <param name="messageDelegates">The message delegates.</param> public AOPSinkProcessor(MarshalByRefObject sender, IMessageSink nextSink, MessageProcessDelegates messageDelegates) { this.NextSink = nextSink; this.Sender = sender; this.messageDelegates = messageDelegates; }
/// <inheritdoc/> public void Run(IEnumerable<ITestCase> testMethods, IMessageSink messageSink) { bool cancelled = false; var totalSummary = new RunSummary(); string currentDirectory = Directory.GetCurrentDirectory(); try { Directory.SetCurrentDirectory(Path.GetDirectoryName(assemblyInfo.AssemblyPath)); if (messageSink.OnMessage(new TestAssemblyStarting())) { var classGroups = testMethods.Cast<XunitTestCase>().GroupBy(tc => tc.Class).ToList(); if (classGroups.Count > 0) { var collectionSummary = new RunSummary(); if (messageSink.OnMessage(new TestCollectionStarting())) { foreach (var group in classGroups) { var classSummary = new RunSummary(); if (!messageSink.OnMessage(new TestClassStarting { ClassName = group.Key.Name })) cancelled = true; else { cancelled = RunTestClass(messageSink, group, classSummary); collectionSummary.Aggregate(classSummary); } if (!messageSink.OnMessage(new TestClassFinished { Assembly = assemblyInfo, ClassName = group.Key.Name, TestsRun = classSummary.Total })) cancelled = true; if (cancelled) break; } } messageSink.OnMessage(new TestCollectionFinished { Assembly = assemblyInfo, TestsRun = collectionSummary.Total }); totalSummary.Aggregate(collectionSummary); } } messageSink.OnMessage(new TestAssemblyFinished { Assembly = assemblyInfo, TestsRun = totalSummary.Total, TestsFailed = totalSummary.Failed, TestsSkipped = totalSummary.Skipped, ExecutionTime = totalSummary.Time }); } finally { Directory.SetCurrentDirectory(currentDirectory); } }
public InterceptSink(IMessageSink nextSink) { lock (SyncRoot) { _nextSink = nextSink; } }
public BenchmarkTestCase( int iterations, int warmupIterations, string variation, IMessageSink diagnosticMessageSink, ITestMethod testMethod, object[] testMethodArguments) : base(diagnosticMessageSink, Xunit.Sdk.TestMethodDisplay.Method, testMethod, null) { // Override display name to avoid getting info about TestMethodArguments in the // name (this is covered by the concept of Variation for benchmarks) var suppliedDisplayName = TestMethod.Method.GetCustomAttributes(typeof(FactAttribute)) .First() .GetNamedArgument<string>("DisplayName"); _diagnosticMessageSink = diagnosticMessageSink; DisplayName = suppliedDisplayName ?? BaseDisplayName; Variation = variation; Iterations = iterations; WarmupIterations = warmupIterations; var methodArguments = new List<object> { MetricCollector }; if (testMethodArguments != null) { methodArguments.AddRange(testMethodArguments); } TestMethodArguments = methodArguments.ToArray(); }
protected override void RunTestCases(IEnumerable<IXunitTestCase> testCases, IMessageSink messageSink, ITestFrameworkOptions executionOptions) { var cases = testCases.Where(t => t.Class.GetCustomAttributes(typeof(RunIfConfiguredAttribute)) == null || TestConfig.Instance.IsConfigured); base.RunTestCases(cases, messageSink, executionOptions); }
public ScenarioOutlineRunner( IMessageSink diagnosticMessageSink, IXunitTestCase scenarioOutline, string displayName, string skipReason, object[] constructorArguments, IMessageBus messageBus, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource) : base( scenarioOutline, displayName, skipReason, constructorArguments, noArguments, messageBus, aggregator, cancellationTokenSource) { this.diagnosticMessageSink = diagnosticMessageSink; this.scenarioRunnerFactory = new ScenarioRunnerFactory( this.TestCase, this.DisplayName, this.MessageBus, this.TestClass, this.ConstructorArguments, this.SkipReason, this.BeforeAfterAttributes, this.Aggregator, this.CancellationTokenSource); }
/// <summary> /// Initializes a new instance of the <see cref="CollectionPerAssemblyTestCollectionFactory" /> class. /// </summary> /// <param name="testAssembly">The assembly.</param> /// <param name="diagnosticMessageSink">The message sink used to send diagnostic messages</param> public CollectionPerAssemblyTestCollectionFactory(ITestAssembly testAssembly, IMessageSink diagnosticMessageSink) { this.testAssembly = testAssembly; defaultCollection = new TestCollection(testAssembly, null, "Test collection for " + Path.GetFileName(testAssembly.Assembly.AssemblyPath)); collectionDefinitions = TestCollectionFactoryHelper.GetTestCollectionDefinitions(testAssembly.Assembly, diagnosticMessageSink); }
internal static IMessageCtrl DoAsyncDispatch(IMessage reqMsg, IMessageSink replySink) { object[] args = new object[4]; ServerIdentity serverIdentity = InternalSink.GetServerIdentity(reqMsg); if (RemotingServices.CORProfilerTrackRemotingAsync()) { Guid empty = Guid.Empty; if (RemotingServices.CORProfilerTrackRemotingCookie()) { object obj2 = reqMsg.Properties["CORProfilerCookie"]; if (obj2 != null) { empty = (Guid) obj2; } } RemotingServices.CORProfilerRemotingServerReceivingMessage(empty, true); if (replySink != null) { IMessageSink sink = new ServerAsyncReplyTerminatorSink(replySink); replySink = sink; } } Context serverContext = serverIdentity.ServerContext; args[0] = reqMsg; args[1] = replySink; args[2] = Thread.CurrentContext; args[3] = serverContext; InternalCrossContextDelegate ftnToCall = new InternalCrossContextDelegate(CrossContextChannel.DoAsyncDispatchCallback); return (IMessageCtrl) Thread.CurrentThread.InternalCrossContextCallback(serverContext, ftnToCall, args); }
internal WcfTestCase(IXunitTestCase testCase, string skippedReason = null, bool isTheory = false, IMessageSink diagnosticMessageSink = null) { _testCase = testCase; _skippedReason = skippedReason; _isTheory = isTheory; _diagnosticMessageSink = diagnosticMessageSink; }
public static LNode ParseTokenTree(TokenTree tokens, IMessageSink sink) { return(StageOneParser.Parse(tokens, tokens.File, sink)); }
IMessageSink IContributeServerContextSink.GetServerContextSink(IMessageSink next) { CallSeq.Add("IContributeServerContextSink(" + id + ").GetServerContextSink"); return(new GenericMessageSink(null, next, "ServerContextSink(" + id + ")")); }
IMessageSink IContributeObjectSink.GetObjectSink(MarshalByRefObject o, IMessageSink next) { CallSeq.Add("IContributeObjectSink(" + id + ").GetObjectSink"); return(new GenericMessageSink(o, next, "ObjectSink(" + id + ")")); }
public GenericMessageSink(MarshalByRefObject obj, IMessageSink nextSink, string type) { _type = type; _next = nextSink; }
public SharedHomeDirectory(IMessageSink messageSink) { Log = new SharedTestOutputHelper(messageSink); Initialize(); }
public SpecFlowTestFramework(IMessageSink diagnosticMessageSink) : base(diagnosticMessageSink) { }
internal StageOneParser(IList <Token> tokens, ISourceFile file, IMessageSink messageSink) : base(ReclassifyTokens(tokens), default(Token), file) { ErrorSink = messageSink; }
public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink) { throw new NotSupportedException(); }
public SkippableFactDiscoverer(IMessageSink diagnosticMessageSink) : base(diagnosticMessageSink) { _diagnosticMessageSink = diagnosticMessageSink; }
public ClientChannelSinkStack(IMessageSink replySink) { this._replySink = replySink; }
public MessageSinkLogger(IMessageSink messageSink) { this.messageSink = messageSink; }
public ContextRestoreSink(IMessageSink next, Context context, IMessage call) { this._next = next; this._context = context; this._call = call; }
public FusonicTestAssemblyRunner(ITestAssembly testAssembly, IEnumerable <IXunitTestCase> testCases, IMessageSink diagnosticMessageSink, IMessageSink executionMessageSink, ITestFrameworkExecutionOptions executionOptions) : base(testAssembly, testCases, diagnosticMessageSink, executionMessageSink, executionOptions) { }
/// <inheritdoc cref="XunitTestCase"/> /// <remarks> /// This method is called by the xUnit test framework classes to run the test case. We will do the /// loop here, forwarding on to the implementation in XunitTestCase to do the heavy lifting.We will /// continue to re-run the test until the aggregator has an error(meaning that some internal error /// condition happened), or the test runs without failure, or we've hit the maximum number of tries. /// </remarks> public override async Task <RunSummary> RunAsync( IMessageSink diagnosticMessageSink, IMessageBus messageBus, object[] constructorArguments, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource ) { int runCount = 0; while (true) { // This is really the only tricky bit: we need to capture and delay messages (since those will // contain run status) until we know we've decided to accept the final result; var delayedMessageBus = new DelayedMessageBus(messageBus); string testName = DisplayName; if (runCount > 0) { testName += $"\n\nRETRY:{runCount}"; } // Do not throw any exceptions here if can't send test case notification because // xunit do not expects any exceptions here and so it crashes the process. // Notification sending fails probably because of rate limiting by Telegram. for (int i = 0; i < 2; i++) { try { await TestsFixture.Instance.SendTestCaseNotificationAsync(testName); break; } catch (Exception) { // Log any exceptions here so we could at least know if notification // sending failed var waitTimeout = 30; var message = new DiagnosticMessage( "Couldn't send test name notification for test '{0}', " + "will try one more in {1} seconds.", DisplayName, waitTimeout ); diagnosticMessageSink.OnMessage(message); await Task.Delay(TimeSpan.FromSeconds(waitTimeout)); } } // await Policy // .Handle<TaskCanceledException>() // .Or<HttpRequestException>() // .Or<ApiRequestException>() // .WaitAndRetry(1, i => TimeSpan.FromSeconds(30)) // .Execute(() => // TestsFixture.Instance.SendTestCaseNotificationAsync(testName) // ); var summary = await base.RunAsync( diagnosticMessageSink, delayedMessageBus, constructorArguments, aggregator, cancellationTokenSource ); runCount += 1; var testRunHasUnexpectedErrors = aggregator.HasExceptions || summary.Failed == 0; var retryExceeded = runCount > _maxRetries; var testRunHasExpectedException = summary.Failed == 1 && !delayedMessageBus .ContainsException(_exceptionTypeFullName); var testCaseRunShouldReturn = testRunHasUnexpectedErrors || retryExceeded || testRunHasExpectedException; if (testCaseRunShouldReturn) { delayedMessageBus.Dispose(); // Sends all the delayed messages return(summary); } diagnosticMessageSink.OnMessage(new DiagnosticMessage( "Execution of '{0}' failed (attempt #{1}), retrying in {2} seconds...", DisplayName, runCount, _delaySeconds )); await Task.Delay(_delaySeconds * 1_000); } }
public SkippableFactTestCase(IMessageSink diagnosticMessageSink, TestMethodDisplay defaultMethodDisplay, ITestMethod testMethod, object[] testMethodArguments = null) : base(diagnosticMessageSink, defaultMethodDisplay, testMethod, testMethodArguments) { }
/// <summary> /// Initializes a new instance of the <see cref="StaFactDiscoverer"/> class. /// </summary> /// <param name="diagnosticMessageSink">The diagnostic message sink.</param> public StaFactDiscoverer(IMessageSink diagnosticMessageSink) : base(diagnosticMessageSink) { this.diagnosticMessageSink = diagnosticMessageSink; }
public SkippedTestCase(string skipReason, IMessageSink diagnosticMessageSink, TestMethodDisplay defaultMethodDisplay, ITestMethod testMethod, object[] testMethodArguments = null) : base(diagnosticMessageSink, defaultMethodDisplay, testMethod, testMethodArguments) { _skipReason = skipReason; }
public ConditionalFactDiscoverer(IMessageSink diagnosticMessageSink) : base(diagnosticMessageSink) { }
public InterceptSink(MarshalByRefObject interceptedObject, IMessageSink nextSink) { m_NextSink = nextSink; m_InterceptedObject = interceptedObject; m_WeaveManager = WeaveManagerFactory.Create(); }
public virtual IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink) { IMethodCallMessage mcm1 = (IMethodCallMessage)msg; IMessageCtrl messageCtrl = (IMessageCtrl)null; IMessage msg1 = (IMessage)null; LogicalCallContext callCtx1 = (LogicalCallContext)null; bool flag = false; try { try { LogicalCallContext logicalCallContext1 = (LogicalCallContext)mcm1.Properties[(object)Message.CallContextKey]; object server = this._server; StackBuilderSink.VerifyIsOkToCallMethod(server, (IMethodMessage)mcm1); callCtx1 = CallContext.SetLogicalCallContext(logicalCallContext1); flag = true; IMessage msg2 = msg; logicalCallContext1.PropagateIncomingHeadersToCallContext(msg2); LogicalCallContext threadCallContext = callCtx1; StackBuilderSink.PreserveThreadPrincipalIfNecessary(logicalCallContext1, threadCallContext); ServerChannelSinkStack channelSinkStack = msg.Properties[(object)"__SinkStack"] as ServerChannelSinkStack; if (channelSinkStack != null) { channelSinkStack.ServerObject = server; } MethodBase methodBase = StackBuilderSink.GetMethodBase((IMethodMessage)mcm1); object[] outArgs1 = (object[])null; RemotingMethodCachedData reflectionCachedData = InternalRemotingServices.GetReflectionCachedData(methodBase); object[] args = Message.CoerceArgs((IMethodMessage)mcm1, reflectionCachedData.Parameters); object obj = this.PrivateProcessMessage(methodBase.MethodHandle, args, server, out outArgs1); this.CopyNonByrefOutArgsFromOriginalArgs(reflectionCachedData, args, ref outArgs1); if (replySink != null) { LogicalCallContext logicalCallContext2 = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext; if (logicalCallContext2 != null) { logicalCallContext2.RemovePrincipalIfNotSerializable(); } object ret = obj; object[] outArgs2 = outArgs1; int outArgsCount = outArgs2 == null ? 0 : outArgs1.Length; LogicalCallContext callCtx2 = logicalCallContext2; IMethodCallMessage mcm2 = mcm1; msg1 = (IMessage) new ReturnMessage(ret, outArgs2, outArgsCount, callCtx2, mcm2); logicalCallContext2.PropagateOutgoingHeadersToMessage(msg1); } } catch (Exception ex) { if (replySink != null) { msg1 = (IMessage) new ReturnMessage(ex, mcm1); ((ReturnMessage)msg1).SetLogicalCallContext((LogicalCallContext)mcm1.Properties[(object)Message.CallContextKey]); } } finally { if (replySink != null) { replySink.SyncProcessMessage(msg1); } } } finally { if (flag) { CallContext.SetLogicalCallContext(callCtx1); } } return(messageCtrl); }
public TheoryDiscoverer(IMessageSink diagnosticMessageSink) { _diagnosticMessageSink = diagnosticMessageSink; }
public SkipOnAppVeyorTestDiscoverer(IMessageSink diagnosticMessageSink) { _diagnosticMessageSink = diagnosticMessageSink; }
public void OnConnected(IMessageSink sink) { Sink = sink; _onConnectedEvent.Set(); }
public AssemblyRunner(ITestAssembly testAssembly, IEnumerable <IXunitTestCase> testCases, IMessageSink diagnosticMessageSink, IMessageSink executionMessageSink, ITestFrameworkExecutionOptions executionOptions, XunitTestEnvironment testEnvironment) : base(testAssembly, testCases, diagnosticMessageSink, executionMessageSink, executionOptions) { _testEnvironment = testEnvironment; }
public SkippableTheoryTestCase(IMessageSink diagnosticMessageSink, Xunit.Sdk.TestMethodDisplay defaultMethodDisplay, ITestMethod testMethod) : base(diagnosticMessageSink, defaultMethodDisplay, testMethod) { }
public NLogThrowExceptionsDefault(IMessageSink messageSink) : base(messageSink) { // Place initialization code here }
/// <summary> /// Microsoft ILogger implementation, which can be used in XUnit tests as stub for real logger. /// Writes messages to Output stream and also stores in internal property <seealso cref="LoggedMessages" /> so they can be asserted. /// </summary> /// <param name="output">Accepting MessageSink as output from Fixtures.</param> public XUnitLogger(IMessageSink output) => _messageSink = output;
public SkippableFactDiscoverer(IMessageSink diagnosticMessageSink) { this.diagnosticMessageSink = diagnosticMessageSink; }
public TestFrameworkExecutor(AssemblyName assemblyName, ISourceInformationProvider sourceInformationProvider, IMessageSink diagnosticMessageSink) : base(assemblyName, sourceInformationProvider, diagnosticMessageSink) { }
internal RetryHttpMessageHandler(int retryCount, IMessageSink diagnosticMessageSink) { _retryCount = retryCount; _diagnosticMessageSink = diagnosticMessageSink; }