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}");
}
