public void ConvertMemoryLeakToVSTestResult() { LogEntryMemoryLeak leak = new LogEntryMemoryLeak(); leak.LeakLineNumber = 32; leak.LeakMemoryAllocationNumber = 836; leak.LeakLeakedDataContents = " Data: <`- Leak... > 60 2D BD 00 4C 65 61 6B 2E 2E 2E 00 CD CD CD CD "; leak.LeakSourceFilePath = @"C:\boostunittestsample.cpp"; leak.LeakSourceFileName = "boostunittestsample.cpp"; BoostTestResult testCaseResult = new BoostTestResultBuilder(). For(this.TestCase). Passed(). Duration(1000). Log(leak). Build(); VSTestResult result = testCaseResult.AsVSTestResult(this.TestCase); AssertVSTestModelProperties(result); Assert.That(result.Outcome, Is.EqualTo(TestOutcome.Passed)); Assert.That(result.Duration, Is.EqualTo(Microseconds(1000))); Assert.That(result.Messages.Count, Is.EqualTo(1)); TestResultMessage message = result.Messages.First(); Assert.That(message.Category, Is.EqualTo(TestResultMessage.StandardErrorCategory)); }
public void ConvertFailToVSTestResult() { LogEntryError error = new LogEntryError("Error: 1 != 2", new SourceFileInfo("file.cpp", 10)); BoostTestResult testCaseResult = new BoostTestResultBuilder(). For(this.TestCase). Failed(). Duration(2500). Log(error). Build(); VSTestResult result = testCaseResult.AsVSTestResult(this.TestCase); AssertVSTestModelProperties(result); Assert.That(result.Outcome, Is.EqualTo(TestOutcome.Failed)); Assert.That(result.Duration, Is.EqualTo(Microseconds(2500))); AssertVsTestModelError(result, error); Assert.That(result.Messages.Count, Is.EqualTo(1)); TestResultMessage message = result.Messages.First(); Assert.That(message.Category, Is.EqualTo(TestResultMessage.StandardErrorCategory)); }
public void ConvertExceptionToVSTestResult() { LogEntryException exception = new LogEntryException("C string: some error", new SourceFileInfo("unknown location", 0)); exception.LastCheckpoint = new SourceFileInfo("boostunittestsample.cpp", 13); exception.CheckpointDetail = "Going to throw an exception"; BoostTestResult testCaseResult = new BoostTestResultBuilder(). For(this.TestCase). Aborted(). Duration(0). Log(exception). Build(); VSTestResult result = testCaseResult.AsVSTestResult(this.TestCase); AssertVSTestModelProperties(result); Assert.That(result.Outcome, Is.EqualTo(TestOutcome.Failed)); // A 0 duration should list as 1 tick to avoid UI issues in the test adapter Assert.That(result.Duration, Is.EqualTo(TimeSpan.FromTicks(1))); AssertVsTestModelError(result, exception); Assert.That(result.Messages.Count, Is.EqualTo(1)); TestResultMessage message = result.Messages.First(); Assert.That(message.Category, Is.EqualTo(TestResultMessage.StandardErrorCategory)); }
public void DetailedVerbosityShowStdOutMessagesForPassedTests() { // Setup var loggerEvents = new InternalTestLoggerEvents(TestSessionMessageLogger.Instance); loggerEvents.EnableEvents(); var parameters = new Dictionary <string, string> { { "verbosity", "detailed" } }; this.consoleLogger.Initialize(loggerEvents, parameters); var testcase = new TestCase("TestName", new Uri("some://uri"), "TestSource"); string message = "Dummy message"; TestResultMessage testResultMessage = new TestResultMessage(TestResultMessage.StandardOutCategory, message); var testresult = new ObjectModel.TestResult(testcase) { Outcome = TestOutcome.Passed }; testresult.Messages.Add(testResultMessage); // Act. Raise an event on mock object loggerEvents.RaiseTestResult(new TestResultEventArgs(testresult)); loggerEvents.WaitForEventCompletion(); // Verify this.mockOutput.Verify(o => o.WriteLine(CommandLineResources.StdOutMessagesBanner, OutputLevel.Information), Times.Once()); this.mockOutput.Verify(o => o.WriteLine(" " + message, OutputLevel.Information), Times.Once()); }
private async Task HandleEvent(object sender, BasicDeliverEventArgs args) { _logger.LogTrace("Received event on queue"); try { using (var scope = _serviceProvider.CreateScope()) { var dbService = scope.ServiceProvider.GetRequiredService <DbService>(); string message = Encoding.UTF8.GetString(args.Body.ToArray()); TestResultMessage testMessage = JsonSerializer.Deserialize <TestResultMessage>( message, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true }); await ProcessResultMessageInsecure(testMessage, dbService); } } catch (Exception e) { _logger.LogError("Error during handling received message {message} {e}", args.Body.ToArray(), e); _logger.LogTrace("Decoded {message}", Encoding.UTF8.GetString(args.Body.ToArray())); } finally { _channel.BasicAck(args.DeliveryTag, false); } }
public void TestResultHandlerShouldNotShowAdditionalInfoBannerIfAdditionalInfoIsEmpty() { var loggerEvents = new InternalTestLoggerEvents(TestSessionMessageLogger.Instance); loggerEvents.EnableEvents(); var parameters = new Dictionary <string, string> { { "verbosity", "normal" } }; this.consoleLogger.Initialize(loggerEvents, parameters); var testcase = new TestCase("TestName", new Uri("some://uri"), "TestSource"); TestResultMessage testResultMessage = new TestResultMessage(TestResultMessage.AdditionalInfoCategory, null); var testresult = new ObjectModel.TestResult(testcase) { Outcome = TestOutcome.Failed }; testresult.Messages.Add(testResultMessage); loggerEvents.RaiseTestResult(new TestResultEventArgs(testresult)); loggerEvents.WaitForEventCompletion(); this.mockOutput.Verify(o => o.WriteLine(CommandLineResources.AddnlInfoMessagesBanner, OutputLevel.Information), Times.Never()); }
private bool InitializeForTest(ITestElement testElement, IRunContext runContext) { var runId = runContext.RunConfig.TestRun.Id; TestResultMessage failure = null; try { var vars = new TestProperties(testElement, runContext.RunConfig.TestRun.RunConfiguration); InitializeWorker(vars, runContext, testElement).GetAwaiter().GetResult(); _remote.Initialize(_runContext); AttachDebuggerIfNeeded(runContext, _ide, vars); } catch (ArgumentException ex) { failure = GetFailure(ex, runId, testElement); } catch (TimeoutException ex) { failure = GetFailure(ex, runId, testElement); } catch (InvalidOperationException ex) { failure = GetFailure(ex, runId, testElement); } catch (Exception ex) { failure = GetFailure(ex, runId, testElement); failure.SystemException = ex; } if (failure != null) { runContext.ResultSink.AddResult(failure); runContext.StopTestRun(); return(false); } return(true); }
public void TestResultHandlerShouldNotShowDbgTrcMsg() { var loggerEvents = new InternalTestLoggerEvents(TestSessionMessageLogger.Instance); loggerEvents.EnableEvents(); var parameters = new Dictionary <string, string>(); parameters.Add("verbosity", "normal"); this.consoleLogger.Initialize(loggerEvents, parameters); var testcase = new TestCase("TestName", new Uri("some://uri"), "TestSource"); string message = "Dummy message"; TestResultMessage testResultMessage = new TestResultMessage(TestResultMessage.DebugTraceCategory, message); var testresult = new ObjectModel.TestResult(testcase) { Outcome = TestOutcome.Passed }; testresult.Messages.Add(testResultMessage); loggerEvents.RaiseTestResult(new TestResultEventArgs(testresult)); loggerEvents.WaitForEventCompletion(); this.mockOutput.Verify(o => o.WriteLine(CommandLineResources.DbgTrcMessagesBanner, OutputLevel.Information), Times.Never()); this.mockOutput.Verify(o => o.WriteLine(" " + message, OutputLevel.Information), Times.Never()); }
/// <summary> /// Convert parameter unitTestResult to testResult /// </summary> /// <param name="testCase"> The test Case. </param> /// <param name="startTime"> The start Time. </param> /// <param name="endTime"> The end Time. </param> /// <param name="currentSettings">Current MSTest settings.</param> /// <returns> The <see cref="TestResult"/>. </returns> internal TestResult ToTestResult(TestCase testCase, DateTimeOffset startTime, DateTimeOffset endTime, MSTestSettings currentSettings) { Debug.Assert(testCase != null, "testCase"); var testResult = new TestResult(testCase) { DisplayName = this.DisplayName, Duration = this.Duration, ErrorMessage = this.ErrorMessage, ErrorStackTrace = this.ErrorStackTrace, Outcome = UnitTestOutcomeHelper.ToTestOutcome(this.Outcome, currentSettings), StartTime = startTime, EndTime = endTime }; testResult.SetPropertyValue <Guid>(Constants.ExecutionIdProperty, this.ExecutionId); testResult.SetPropertyValue <Guid>(Constants.ParentExecIdProperty, this.ParentExecId); testResult.SetPropertyValue <int>(Constants.InnerResultsCountProperty, this.InnerResultsCount); if (!string.IsNullOrEmpty(this.StandardOut)) { TestResultMessage message = new TestResultMessage(TestResultMessage.StandardOutCategory, this.StandardOut); testResult.Messages.Add(message); } if (!string.IsNullOrEmpty(this.StandardError)) { TestResultMessage message = new TestResultMessage(TestResultMessage.StandardErrorCategory, this.StandardError); testResult.Messages.Add(message); } if (!string.IsNullOrEmpty(this.DebugTrace)) { string debugTraceMessagesinStdOut = string.Format(CultureInfo.InvariantCulture, "\n\n{0}\n{1}", Resource.DebugTraceBanner, this.DebugTrace); TestResultMessage debugTraceMessage = new TestResultMessage(TestResultMessage.StandardOutCategory, debugTraceMessagesinStdOut); testResult.Messages.Add(debugTraceMessage); } if (!string.IsNullOrEmpty(this.TestContextMessages)) { string testContextMessagesInStdOut = string.Format(CultureInfo.InvariantCulture, "\n\n{0}\n{1}", Resource.TestContextMessageBanner, this.TestContextMessages); TestResultMessage testContextMessage = new TestResultMessage(TestResultMessage.StandardOutCategory, testContextMessagesInStdOut); testResult.Messages.Add(testContextMessage); } if (this.ResultFiles != null && this.ResultFiles.Count > 0) { AttachmentSet attachmentSet = new AttachmentSet(Constants.ExecutorUri, Resource.AttachmentSetDisplayName); foreach (var resultFile in this.ResultFiles) { string pathToResultFile = PlatformServiceProvider.Instance.FileOperations.GetFullFilePath(resultFile); UriDataAttachment attachment = new UriDataAttachment(new Uri(pathToResultFile), resultFile); attachmentSet.Attachments.Add(attachment); } testResult.Attachments.Add(attachmentSet); } return(testResult); }
public void TestResultHandlerShouldShowDbgTrcMsg() { var parameters = new Dictionary <string, string>(); parameters.Add("verbosity", "normal"); this.consoleLogger.Initialize(this.events.Object, parameters); var testcase = new TestCase("TestName", new Uri("some://uri"), "TestSource"); string message = "Dummy message"; TestResultMessage testResultMessage = new TestResultMessage(TestResultMessage.DebugTraceCategory, message); var testresult = new ObjectModel.TestResult(testcase); testresult.Outcome = TestOutcome.Passed; testresult.Messages.Add(testResultMessage); var eventArgs = new TestRunChangedEventArgs(null, new List <ObjectModel.TestResult> { testresult }, null); // Raise an event on mock object this.testRunRequest.Raise(m => m.OnRunStatsChange += null, eventArgs); this.FlushLoggerMessages(); this.mockOutput.Verify(o => o.WriteLine(CommandLineResources.DbgTrcMessagesBanner, OutputLevel.Information), Times.Once()); this.mockOutput.Verify(o => o.WriteLine(" " + message, OutputLevel.Information), Times.Once()); }
public void TestResultHandlerShouldShowStdOutMessagesBannerIfStdOutIsNotEmpty() { var count = 0; this.mockOutput.Setup(o => o.WriteLine(It.IsAny <string>(), It.IsAny <OutputLevel>())).Callback <string, OutputLevel>( (s, o) => { count++; }); var loggerEvents = new InternalTestLoggerEvents(TestSessionMessageLogger.Instance); loggerEvents.EnableEvents(); var parameters = new Dictionary <string, string> { { "verbosity", "normal" } }; this.consoleLogger.Initialize(loggerEvents, parameters); string message = "Dummy message"; var testcase = new TestCase("TestName", new Uri("some://uri"), "TestSource"); TestResultMessage testResultMessage = new TestResultMessage(TestResultMessage.StandardOutCategory, message); var testresult = new ObjectModel.TestResult(testcase) { Outcome = TestOutcome.Failed }; testresult.Messages.Add(testResultMessage); loggerEvents.RaiseTestResult(new TestResultEventArgs(testresult)); // Added this for synchronization SpinWait.SpinUntil(() => count == 2, 300); this.mockOutput.Verify(o => o.WriteLine(CommandLineResources.StdOutMessagesBanner, OutputLevel.Information), Times.Once()); this.mockOutput.Verify(o => o.WriteLine(" " + message, OutputLevel.Information), Times.Once()); }
public static Common.Models.TestResultMessage Convert(this TestResultMessage testResult) { return(new Common.Models.TestResultMessage() { Category = testResult.Category, Text = testResult.Text }); }
string GetConsoleOutput (TestResultMessage message) { if (message.Messages != null) { return String.Join (Environment.NewLine, message.Messages); } return String.Empty; }
private void NotifySubscribersOfAddedResult(TestResult result) { IMessage message = new TestResultMessage { TestResult = result }; NotifySubscribers(observer => observer.OnNext(message)); }
public TestResultMessageDrop MapToDrop(TestResultMessage testResultMessage) { return(new TestResultMessageDrop { Text = testResultMessage.Text, Category = testResultMessage.Category }); }
public void AddFailed(string testName, string errorMessage) { var currentOne = FailedTestsResults.LastOrDefault(); if (currentOne == null || currentOne.Name != testName) { Failed++; currentOne = new TestResultMessage(); currentOne.Name = testName; FailedTestsResults.Add(currentOne); } currentOne.ErrorMessages.Add(errorMessage); }
/// <summary> /// Closes the test result viewer for the specified Gallio result. /// </summary> /// <param name="result">The test result message.</param> public void CloseResultViewer(TestResultMessage result) { if (!TipShellExtension.IsInitialized) { return; } GallioTestResult gallioResult = result as GallioTestResult; if (gallioResult != null) { toolWindowManager.CloseToolWindow(GetWindowId(gallioResult)); } }
/// <summary> /// Invokes the test result viewer for the specified Gallio test. /// </summary> /// <param name="result">The result of the unit test.</param> public void InvokeResultViewer(TestResultMessage result) { if (!TipShellExtension.IsInitialized) { return; } GallioTestResult gallioResult = result as GallioTestResult; if (gallioResult != null) { TestResultWindow window = new TestResultWindow(gallioResult); toolWindowManager.OpenToolWindow(GetWindowId(gallioResult), window); } }
public async Task Run_should_notify_subscribers_of_result_on_error() { // given var httpClientMock = new Mock <IHttpClient>(); // Throw an error. httpClientMock .Setup(c => c.ExecuteRequestAsync(It.IsAny <IRestRequest>(), new HttpLogWriter())) .Throws(new InvalidOperationException("Bad")); TestFileRunner runner = new TestFileRunner(httpClientMock.Object, GetRepositoryFactory(), new JsonConfiguration(), _capturedVariableProviderFactory.Object, GetTestFileRunnerLoggerFactory()); var testFile = CreateTestFile(new[] { new Test() { Url = "foo1" }, new Test() { Url = "foo2" }, new Test() { Url = "foo3" } }); TestResultMessage capturedResult = null; runner.Subscribe(r => { var item = r as TestResultMessage; if (item != null) { capturedResult = item; } }); // when await runner.RunAsync(testFile, "development", "bob"); // then Assert.That(capturedResult, Is.Not.Null, "Should have notified of the result."); Assert.That(capturedResult.TestResult, Is.Not.Null, "Should have test result."); Assert.That(capturedResult.TestResult.ResultState, Is.EqualTo(TestResultState.Failed), "Should not have succeeded."); }
/// <summary> /// Generates a default TestResult for a general executor exception. /// </summary> /// <param name="test">The test which failed execution.</param> /// <returns>A warning TestResult related to the provided test execution exception.</returns> private static VSTestResult GenerateExecutionExceptionResult(VSTestCase test, Exception ex) { VSTestResult result = new VSTestResult(test); result.ComputerName = Environment.MachineName; // NOTE Marking test as failed in an attempt to be consistent with the // 'Boost.Test result file not found' error scenario result.Outcome = TestOutcome.Failed; result.ErrorMessage = "Test Execution Error. Refer to 'Output' for more details."; var message = new TestResultMessage(TestResultMessage.StandardErrorCategory, ex.Message); result.Messages.Add(message); return(result); }
private async Task ProcessResultMessageInsecure(TestResultMessage message, DbService dbService) { var testRun = await dbService.Tests.FirstOrDefaultAsync(test => test.Id == message.MetaData); if (testRun == null) { _logger.LogError("Cannot find testRun for results {id} {message}", message.MetaData, message); return; } _logger.LogTrace("Found matching test case"); try { using (var client = new WebClient()) { _logger.LogTrace("Processing students"); var studentData = client.DownloadData(message.Students); await _storageService.UploadResultAsync( CreateBlobName(testRun.CreatedBy, testRun.Id, TestRunConstants.FileStudents), studentData); _logger.LogTrace("Processing teachers"); var teacherData = client.DownloadData(message.Teachers); await _storageService.UploadResultAsync( CreateBlobName(testRun.CreatedBy, testRun.Id, TestRunConstants.FileTeachers), teacherData); _logger.LogTrace("Processing dump"); var zipData = client.DownloadData(message.Data); await _storageService.UploadResultAsync( CreateBlobName(testRun.CreatedBy, testRun.Id, TestRunConstants.FileZip), zipData); } testRun.Status = TestRunConstants.TestFinished; testRun.FinishedAt = DateTime.UtcNow; testRun.Message = TestRunConstants.TestMessageFinished; await dbService.SaveChangesAsync(); } catch (Exception e) { _logger.LogError("Error during processing result message contents (updating db) {e}", e); testRun.Status = TestRunConstants.TestFailed; testRun.Message = TestRunConstants.TestMessageFailed; testRun.FinishedAt = DateTime.UtcNow; await dbService.SaveChangesAsync(); throw; } }
public void ConvertsDataFromXunitToTdNetFormat() { var testCase = Mocks.TestCase<TestResultMessageExtensionsTests>("ConvertsDataFromXunitToTdNetFormat"); var message = new TestResultMessage { TestCase = testCase, TestDisplayName = "Display Name", ExecutionTime = 123.45M }; var result = message.ToTdNetTestResult(TestState.Ignored); Assert.Same(testCase.GetClass(), result.FixtureType); Assert.Same(testCase.GetMethod(), result.Method); Assert.Equal("Display Name", result.Name); Assert.Equal(TimeSpan.FromTicks(1234500), result.TimeSpan); Assert.Equal(1, result.TotalTests); }
UnitTestResult AddTestResult (TestResultMessage message) { var result = new UnitTestResult { ConsoleError = message.ErrorMessage, ConsoleOutput = GetConsoleOutput (message), Message = message.ErrorMessage, Status = ToResultStatus (message.Outcome), StackTrace = message.ErrorStackTrace, TestDate = message.StartTime.DateTime, Time = message.Duration, }; UpdateCounts (result); TestResult.Add (result); return result; }
public IDisposable Subscribe(IObserver <IMessage> observer) { // Notify of the observer of existing results. IEnumerable <TestResult> resultsCopy; lock (_currentResults) { resultsCopy = _currentResults.ToArray(); } foreach (TestResult testResult in resultsCopy) { var message = new TestResultMessage { TestResult = testResult }; observer.OnNext(message); } return(new TestSessionRunnerSubscriber(observer, _subscribers)); }
public override TestResult MergeResults(TestResult inMemory, TestResultMessage fromTheWire) { // The only type of message we should receive from the wire is a GallioTestResult. // However, we can receive multiple results in the case where the test is data-driven // so we need to merge them. GallioTestResult gallioInMemory = inMemory as GallioTestResult; if (gallioInMemory == null && inMemory != null) { gallioInMemory = new GallioTestResult(gallioInMemory); } GallioTestResult gallioFromTheWire = fromTheWire as GallioTestResult; if (gallioFromTheWire == null && fromTheWire is TestResult) { gallioFromTheWire = new GallioTestResult((TestResult)fromTheWire); } return(GallioTestResultFactory.Merge(gallioInMemory, gallioFromTheWire)); }
void OnTestResult (TestResultMessage message) { UnitTestResult result = AddTestResult (message); if (runningSingleTest) { // Ensure test error message is displayed in Test Results window. TestResult = result; return; } string testId = message.Test?.Id?.ToString (); if (currentTest == null || testId != currentTest.TestId) { currentTest = FindTest (rootTest as UnitTest, testId); } if (currentTest != null) { currentTest.RegisterResult (testContext, result); testContext.Monitor.EndTest (currentTest, result); currentTest.Status = TestStatus.Ready; UpdateParentStatus (); } }
public void ConvertPassToVSTestResult() { BoostTestResult testCaseResult = new BoostTestResultBuilder(). For(this.TestCase). Passed(). Duration(1000). Log(new LogEntryMessage("BOOST_MESSAGE output")). Build(); VSTestResult result = testCaseResult.AsVSTestResult(this.TestCase); AssertVSTestModelProperties(result); Assert.That(result.Outcome, Is.EqualTo(TestOutcome.Passed)); Assert.That(result.Duration, Is.EqualTo(Microseconds(1000))); Assert.That(result.Messages.Count, Is.EqualTo(1)); TestResultMessage message = result.Messages.First(); Assert.That(message.Category, Is.EqualTo(TestResultMessage.StandardOutCategory)); }
/// <summary> /// Helper method to send information about the test results to the server /// e.g. did the test pass/fail/etc? /// (this is called when a test completes) /// </summary> /// <param name="testName">name of test</param> /// <param name="fixtureName">name of fixture (assembly)</param> /// <param name="result">test result (<see cref="RevitTestExecutive.RunTest"/></param> /// <param name="stackTrace">stack trace of failure, if any</param> public static void SendTestResultInformation(string testName, string fixtureName, string result, string stackTrace) { TestResultMessage msg = new TestResultMessage(testName, fixtureName, result, stackTrace); SendMessage(msg); }
public TestResult MergeResults(TestResult inMemory, TestResultMessage fromTheWire) { return target.MergeResults(inMemory, fromTheWire); }
/// <summary> /// Closes the test result viewer for the specified Gallio result. /// </summary> /// <param name="result">The test result message.</param> public void CloseResultViewer(TestResultMessage result) { if (!TipShellExtension.IsInitialized) return; GallioTestResult gallioResult = result as GallioTestResult; if (gallioResult != null) { toolWindowManager.CloseToolWindow(GetWindowId(gallioResult)); } }
/// <summary> /// Invokes the test result viewer for the specified Gallio test. /// </summary> /// <param name="result">The result of the unit test.</param> public void InvokeResultViewer(TestResultMessage result) { if (!TipShellExtension.IsInitialized) return; GallioTestResult gallioResult = result as GallioTestResult; if (gallioResult != null) { TestResultWindow window = new TestResultWindow(gallioResult); toolWindowManager.OpenToolWindow(GetWindowId(gallioResult), window); } }
public TestResultMessageDrop(TestResultMessage testResultMessage) { _testResultMessage = testResultMessage; }
public static void SetOutput(this TestResultMessage message, string output) { var prop = typeof(TestResultMessage).GetProperty("Output", BindingFlags.Instance | BindingFlags.SetProperty | BindingFlags.NonPublic | BindingFlags.Public); prop.SetValue(message, output); }
public override TestResult MergeResults(TestResult inMemory, TestResultMessage fromTheWire) { // The only type of message we should receive from the wire is a GallioTestResult. // However, we can receive multiple results in the case where the test is data-driven // so we need to merge them. GallioTestResult gallioInMemory = inMemory as GallioTestResult; if (gallioInMemory == null && inMemory != null) gallioInMemory = new GallioTestResult(gallioInMemory); GallioTestResult gallioFromTheWire = fromTheWire as GallioTestResult; if (gallioFromTheWire == null && fromTheWire is TestResult) gallioFromTheWire = new GallioTestResult((TestResult)fromTheWire); return GallioTestResultFactory.Merge(gallioInMemory, gallioFromTheWire); }
public TestResult MergeResults(TestResult inMemory, TestResultMessage fromTheWire) { return(target.MergeResults(inMemory, fromTheWire)); }