public void logging_trace_listener_test() { var adapter = new CapturingLoggerAdapter(); LogManager.Adapter = adapter; var listener = new LoggingTraceListener(); listener.DefaultTraceEventType = (TraceEventType)0xFFFF; AssertExpectedLogLevel(listener, TraceEventType.Start, LogLevelType.Trace); AssertExpectedLogLevel(listener, TraceEventType.Stop, LogLevelType.Trace); AssertExpectedLogLevel(listener, TraceEventType.Suspend, LogLevelType.Trace); AssertExpectedLogLevel(listener, TraceEventType.Resume, LogLevelType.Trace); AssertExpectedLogLevel(listener, TraceEventType.Transfer, LogLevelType.Trace); AssertExpectedLogLevel(listener, TraceEventType.Verbose, LogLevelType.Debug); AssertExpectedLogLevel(listener, TraceEventType.Information, LogLevelType.Info); AssertExpectedLogLevel(listener, TraceEventType.Warning, LogLevelType.Warn); AssertExpectedLogLevel(listener, TraceEventType.Error, LogLevelType.Error); AssertExpectedLogLevel(listener, TraceEventType.Critical, LogLevelType.Fatal); adapter.Clear(); listener.DefaultTraceEventType = TraceEventType.Warning; listener.Write("some message", "some category"); var logName = adapter.LastEvent.Source.ArgumentEntity.LogName; logName.Should().Be(string.Format("{0}.{1}", listener.Name, "some category")); adapter.LastEvent.Level.Should().Be(LogLevelType.Warn); adapter.LastEvent.RenderedMessage.Should().Be("some message"); adapter.LastEvent.Exception.Should().BeNull(); }
public void Constructor1HappyPath3() { var logger = new MockLogger(LogLevel.Info).Object; var listener = new LoggingTraceListener(logger, null); listener.Logger.Should().BeSameAs(logger); listener.LogLevel.Should().Be(LogLevel.Info); }
public bool Execute() { try { Assembly antlrAssembly = Assembly.LoadFrom(AntlrToolPath); Type antlrToolType = antlrAssembly.GetType("Antlr3.AntlrTool"); Type errorManagerType = antlrAssembly.GetType("Antlr3.Tool.ErrorManager"); object tool = Activator.CreateInstance(antlrAssembly.GetType("Antlr3.AntlrTool"), new object[] { Path.GetDirectoryName(AntlrToolPath) }); Action process = (Action)Delegate.CreateDelegate(typeof(Action), tool, antlrToolType.GetMethod("Process")); Action <string[]> ProcessArgs = (Action <string[]>)Delegate.CreateDelegate(typeof(Action <string[]>), tool, antlrToolType.GetMethod("ProcessArgs")); Func <IList <string> > GetGeneratedFiles = (Func <IList <string> >)Delegate.CreateDelegate(typeof(Func <IList <string> >), tool, antlrToolType.GetProperty("GeneratedFiles").GetGetMethod()); Func <int> GetNumErrors = (Func <int>)Delegate.CreateDelegate(typeof(Func <int>), errorManagerType.GetMethod("GetNumErrors")); Action <TraceListener> SetTraceListener = (Action <TraceListener>)Delegate.CreateDelegate(typeof(Action <TraceListener>), errorManagerType.GetProperty("ExternalListener").GetSetMethod()); TimeSpan conversionTimeout = TimeSpan.FromSeconds(10); List <string> args = new List <string>() { "-Xconversiontimeout", ((int)conversionTimeout.TotalMilliseconds).ToString(), "-fo", OutputPath, "-message-format", "vs2005" }; if (!String.IsNullOrEmpty(LibPaths)) { args.Add("-lib"); args.Add(LibPaths); } args.AddRange(SourceCodeFiles); using (LoggingTraceListener traceListener = new LoggingTraceListener(_buildMessages)) { SetTraceListener(traceListener); ProcessArgs(args.ToArray()); process(); } _generatedCodeFiles.AddRange(GetGeneratedFiles().Where(file => Path.GetExtension(file).Equals(".cs", StringComparison.OrdinalIgnoreCase))); int errorCount = GetNumErrors(); return(errorCount == 0); } catch (Exception e) { if (e is TargetInvocationException && e.InnerException != null) { e = e.InnerException; } _buildMessages.Add(new BuildMessage(e.Message)); throw; } }
public void WriteLineHappyPath2() { var mockLogger = new MockLogger(LogLevel.Warn); var listener = new LoggingTraceListener(mockLogger.Object, LogLevel.Info); listener.WriteLine("Hello, world!"); mockLogger.VerifyInfo(Times.Never()); }
public void WriteLineHappyPath1() { var mockLogger = new MockLogger(); var listener = new LoggingTraceListener(mockLogger.Object, LogLevel.Info); listener.WriteLine("Hello, world!"); mockLogger.VerifyInfo("^Hello, world!$", Times.Once()); }
public void logging_trace_listener_processes_properties_test() { var props = new NameValueCollection(); props["Name"] = "TestName"; props["DefaultTraceEventType"] = TraceEventType.Information.ToString().ToLower(); props["LoggerNameFormat"] = "{0}-{1}"; var listener = new LoggingTraceListener(props); listener.Name.Should().Be("TestName"); listener.DefaultTraceEventType.Should().Be(TraceEventType.Information); listener.LoggerNameFormat.Should().Be("{0}-{1}"); }
private void AssertExpectedLogLevel(LoggingTraceListener listener, TraceEventType eType, LogLevelType level) { var adapter = (CapturingLoggerAdapter)LogManager.Adapter; adapter.Clear(); listener.TraceEvent(null, "sourceName " + eType, eType, -1, "format {0}", eType); var logName = adapter.LastEvent.Source.ArgumentEntity.LogName; var exceptName = string.Format("{0}.{1}", listener.Name, "sourceName " + eType); logName.Should().Be(exceptName); adapter.LastEvent.Level.Should().Be(level); adapter.LastEvent.RenderedMessage.Should().Be("format " + eType); adapter.LastEvent.Exception.Should().BeNull(); }
public void logging_not_log_below_filter_level_test() { var adapter = new CapturingLoggerAdapter(); LogManager.Adapter = adapter; var listener = new LoggingTraceListener(); listener.Filter = new EventTypeFilter(SourceLevels.Warning); adapter.Clear(); listener.TraceEvent(null, "sourceName", TraceEventType.Information, -1, "format {0}", "Information"); adapter.LastEvent.Should().BeNull(); AssertExpectedLogLevel(listener, TraceEventType.Warning, LogLevelType.Warn); AssertExpectedLogLevel(listener, TraceEventType.Error, LogLevelType.Error); }
public void logging_trace_listener_processes_initialize_data_test() { // null results in default settings var listener = new LoggingTraceListener((string)null); AssertDefaultSettings(listener); // string.Empty results in default settings listener = new LoggingTraceListener(string.Empty); AssertDefaultSettings(listener); // values are trimmed and case-insensitive, empty values ignored listener = new LoggingTraceListener("; DefaultTraceeventtype =warninG; loggernameFORMAT= {listenerName}-{sourceName}\t; Name = TestName\t; "); listener.Name.Should().Be("TestName"); listener.DefaultTraceEventType.Should().Be(TraceEventType.Warning); listener.LoggerNameFormat.Should().Be("{listenerName}-{sourceName}"); }
public void logging_trace_listener_null_category_test() { var adapter = new CapturingLoggerAdapter(); LogManager.Adapter = adapter; var listener = new LoggingTraceListener(); listener.DefaultTraceEventType = TraceEventType.Warning; listener.Write("some message", null); var logName = adapter.LastEvent.Source.ArgumentEntity.LogName; var exceptName = string.Format("{0}.{1}", listener.Name, ""); logName.Should().Be(exceptName); adapter.LastEvent.Level.Should().Be(LogLevelType.Warn); adapter.LastEvent.RenderedMessage.Should().Be("some message"); adapter.LastEvent.Exception.Should().BeNull(); }
protected async Task RunTest(BlockchainTest test, Stopwatch stopwatch = null) { LoggingTraceListener traceListener = new LoggingTraceListener(); // TODO: not supported in .NET Core, need to replace? // Debug.Listeners.Clear(); // Debug.Listeners.Add(traceListener); IDbProvider dbProvider = new MemDbProvider(_logManager); StateTree stateTree = new StateTree(dbProvider.GetOrCreateStateDb()); ISpecProvider specProvider; if (test.NetworkAfterTransition != null) { specProvider = new CustomSpecProvider( (0, Frontier.Instance), (1, test.Network), (test.TransitionBlockNumber, test.NetworkAfterTransition)); } else { specProvider = new CustomSpecProvider( (0, Frontier.Instance), // TODO: this thing took a lot of time to find after it was removed!, genesis block is always initialized with Frontier (1, test.Network)); } if (specProvider.GenesisSpec != Frontier.Instance) { Assert.Fail("Expected genesis spec to be Frontier for blockchain tests"); } IDifficultyCalculator difficultyCalculator = new DifficultyCalculator(specProvider); IRewardCalculator rewardCalculator = new RewardCalculator(specProvider); IBlockTree blockTree = new BlockTree(new MemDb(), new MemDb(), new MemDb(), specProvider, _logManager); IBlockhashProvider blockhashProvider = new BlockhashProvider(blockTree); ISignatureValidator signatureValidator = new SignatureValidator(ChainId.MainNet); ITransactionValidator transactionValidator = new TransactionValidator(signatureValidator); IHeaderValidator headerValidator = new HeaderValidator(difficultyCalculator, blockTree, SealEngine, specProvider, _logManager); IOmmersValidator ommersValidator = new OmmersValidator(blockTree, headerValidator, _logManager); IBlockValidator blockValidator = new BlockValidator(transactionValidator, headerValidator, ommersValidator, specProvider, _logManager); IStateProvider stateProvider = new StateProvider(stateTree, dbProvider.GetOrCreateCodeDb(), _logManager); IStorageProvider storageProvider = new StorageProvider(dbProvider, stateProvider, _logManager); IVirtualMachine virtualMachine = new VirtualMachine( stateProvider, storageProvider, blockhashProvider, _logManager); ISealEngine sealEngine = new EthashSealEngine(new Ethash(_logManager), _logManager); ITransactionStore transactionStore = new TransactionStore(); IEthereumSigner signer = new EthereumSigner(specProvider, _logManager); IBlockProcessor blockProcessor = new BlockProcessor( specProvider, blockValidator, rewardCalculator, new TransactionProcessor( specProvider, stateProvider, storageProvider, virtualMachine, NullTracer.Instance, _logManager), dbProvider, stateProvider, storageProvider, transactionStore, _logManager); IBlockchainProcessor blockchainProcessor = new BlockchainProcessor(blockTree, sealEngine, transactionStore, difficultyCalculator, blockProcessor, signer, _logManager); InitializeTestState(test, stateProvider, storageProvider, specProvider); List <(Block Block, string ExpectedException)> correctRlpsBlocks = new List <(Block, string)>(); for (int i = 0; i < test.Blocks.Length; i++) { try { TestBlockJson testBlockJson = test.Blocks[i]; var rlpContext = Hex.ToBytes(testBlockJson.Rlp).AsRlpContext(); Block suggestedBlock = Rlp.Decode <Block>(rlpContext); Assert.AreEqual(new Keccak(testBlockJson.BlockHeader.Hash), suggestedBlock.Header.Hash, "hash of the block"); for (int ommerIndex = 0; ommerIndex < suggestedBlock.Ommers.Length; ommerIndex++) { Assert.AreEqual(new Keccak(testBlockJson.UncleHeaders[ommerIndex].Hash), suggestedBlock.Ommers[ommerIndex].Hash, "hash of the ommer"); } correctRlpsBlocks.Add((suggestedBlock, testBlockJson.ExpectedException)); } catch (Exception e) { _logger?.Info($"Invalid RLP ({i})"); } } if (correctRlpsBlocks.Count == 0) { Assert.AreEqual(new Keccak(test.GenesisBlockHeader.Hash), test.LastBlockHash); return; } if (test.GenesisRlp == null) { test.GenesisRlp = Rlp.Encode(new Block(Convert(test.GenesisBlockHeader))); } Block genesisBlock = Rlp.Decode <Block>(test.GenesisRlp.Bytes); Assert.AreEqual(new Keccak(test.GenesisBlockHeader.Hash), genesisBlock.Header.Hash, "genesis header hash"); blockTree.NewHeadBlock += (sender, args) => { if (args.Block.Number == 0) { Assert.AreEqual(genesisBlock.Header.StateRoot, stateTree.RootHash, "genesis state root"); } }; blockchainProcessor.Start(); blockTree.SuggestBlock(genesisBlock); for (int i = 0; i < correctRlpsBlocks.Count; i++) { stopwatch?.Start(); try { if (correctRlpsBlocks[i].ExpectedException != null) { _logger.Info($"Expecting block exception: {correctRlpsBlocks[i].ExpectedException}"); } if (correctRlpsBlocks[i].Block.Hash == null) { throw new Exception($"null hash in {test.Name} block {i}"); } // TODO: mimic the actual behaviour where block goes through validating sync manager? if (blockValidator.ValidateSuggestedBlock(correctRlpsBlocks[i].Block)) { blockTree.SuggestBlock(correctRlpsBlocks[i].Block); } else { Console.WriteLine("Invalid block"); } } catch (InvalidBlockException ex) { } catch (Exception ex) { _logger?.Info(ex.ToString()); } } await blockchainProcessor.StopAsync(true); stopwatch?.Stop(); RunAssertions(test, blockTree.RetrieveHeadBlock(), storageProvider, stateProvider); }
public bool Execute() { try { Assembly antlrAssembly = Assembly.LoadFrom(AntlrToolPath); Type antlrToolType = antlrAssembly.GetType("Antlr3.AntlrTool"); Type errorManagerType = antlrAssembly.GetType("Antlr3.Tool.ErrorManager"); object tool = Activator.CreateInstance(antlrAssembly.GetType("Antlr3.AntlrTool"), new object[] { Path.GetDirectoryName(AntlrToolPath) }); Action process = (Action)Delegate.CreateDelegate(typeof(Action), tool, antlrToolType.GetMethod("Process")); Action<string[]> ProcessArgs = (Action<string[]>)Delegate.CreateDelegate(typeof(Action<string[]>), tool, antlrToolType.GetMethod("ProcessArgs")); Func<IList<string>> GetGeneratedFiles = (Func<IList<string>>)Delegate.CreateDelegate(typeof(Func<IList<string>>), tool, antlrToolType.GetProperty("GeneratedFiles").GetGetMethod()); Func<int> GetNumErrors = (Func<int>)Delegate.CreateDelegate(typeof(Func<int>), errorManagerType.GetMethod("GetNumErrors")); Action<TraceListener> SetTraceListener = (Action<TraceListener>)Delegate.CreateDelegate(typeof(Action<TraceListener>), errorManagerType.GetProperty("ExternalListener").GetSetMethod()); TimeSpan conversionTimeout = TimeSpan.FromSeconds(10); List<string> args = new List<string>() { "-Xconversiontimeout", ((int)conversionTimeout.TotalMilliseconds).ToString(), "-fo", OutputPath, "-message-format", "vs2005" }; args.AddRange(SourceCodeFiles); using (LoggingTraceListener traceListener = new LoggingTraceListener(_buildMessages)) { SetTraceListener(traceListener); ProcessArgs(args.ToArray()); process(); } _generatedCodeFiles.AddRange(GetGeneratedFiles().Where(file => Path.GetExtension(file).Equals(".cs", StringComparison.OrdinalIgnoreCase))); int errorCount = GetNumErrors(); return errorCount == 0; } catch (Exception e) { _buildMessages.Add(new BuildMessage(e.Message)); throw; } }
protected void RunTest(BlockchainTest test, Stopwatch stopwatch = null) { LoggingTraceListener traceListener = new LoggingTraceListener(_logger); // TODO: not supported in .NET Core, need to replace? // Debug.Listeners.Clear(); // Debug.Listeners.Add(traceListener); InitializeTestState(test); // TODO: transition... _stateProviders[test.Network].EthereumRelease = _protocolSpecificationProvider.GetSpec(test.Network, 0); IEthereumRelease spec = _protocolSpecificationProvider.GetSpec(test.Network, 1); IEthereumSigner signer = new EthereumSigner(spec, ChainId.MainNet); IBlockProcessor blockProcessor = new BlockProcessor( spec, _chain, _blockValidators[test.Network], new ProtocolBasedDifficultyCalculator(spec), new RewardCalculator(spec), new TransactionProcessor( spec, _stateProviders[test.Network], _storageProviders[test.Network], _virtualMachines[test.Network], signer, ShouldLog.Processing ? _logger : null), _multiDb, _stateProviders[test.Network], _storageProviders[test.Network], new TransactionStore(), ShouldLog.Processing ? _logger : null); IBlockchainProcessor blockchainProcessor = new BlockchainProcessor( test.GenesisRlp, blockProcessor, _chain, ShouldLog.Processing ? _logger : null); var rlps = test.Blocks.Select(tb => new Rlp(Hex.ToBytes(tb.Rlp))).ToArray(); for (int i = 0; i < rlps.Length; i++) { stopwatch?.Start(); try { blockchainProcessor.Process(rlps[i]); } catch (InvalidBlockException ex) { } catch (Exception ex) { _logger?.Log(ex.ToString()); } stopwatch?.Stop(); } RunAssertions(test, blockchainProcessor.HeadBlock); }
public void logging_trace_listener_default_settings_test() { var listener = new LoggingTraceListener(); AssertDefaultSettings(listener); }
private void AssertDefaultSettings(LoggingTraceListener listener) { listener.Name.Should().Be("Diagnostics"); listener.DefaultTraceEventType.Should().Be(TraceEventType.Verbose); listener.LoggerNameFormat.Should().Be("{listenerName}.{sourceName}"); }