public void TestEventViewer()
{
var l = new Logger("bUtilitySource");
l.Error("test logger 1");
l.Error(new Exception("an exception sample"));
}
private ErrorSuccess<IVsixPackage, string> _LoadFromFile(string file, Logger log, ErrorSuccessFactory<IVsixPackage, string> ef)
{
log.Info($"Reading {file}");
ZipArchive zipFile;
try
{
zipFile = ZipFile.OpenRead(file);
}
catch (Exception ex)
{
log.Error($"{file} is not a zip archive.", ex);
return ef.Error($"{file} is not a zip archive: {ex.Message}");
}
using (zipFile)
{
var manifestEntry = zipFile.Entries.FirstOrDefault(entry => entry.FullName == Entry.Manifest);
if (manifestEntry == null)
{
return ef.Error($"{file} does not contain a {Entry.Manifest} entry.");
}
return _CreateFromZipManifest(file, manifestEntry, log, ef);
}
}
/// <summary>
/// Build an Array of a particular type from a list of tokens.
/// The Type must be one that can be built with Convert.ChangeType.
/// There are various ways to specify how many elements to parse.
/// WARNING: This will throw an exception if any tokens cannot be
/// converted.
/// </summary>
/// <param name="tokens">The ArrayList of tokens.</param>
/// <param name="i">The starting (and ending) index. This is
/// modified, and left pointing at the last used token.</param>
/// <param name="type">The Type of the array elements.</param>
/// <param name="endToken">An optional end Token to look for.
/// Parsing stops when a token equal to this is found.
/// If this is null, then it is not used.</param>
/// <param name="maxLength">The maximum number of array elements
/// to parse. If this is negative, then it is not used.</param>
/// <param name="log">A Logger to use for messages.</param>
/// <returns>The Array, or null for error.</returns>
public static Array BuildArray(ArrayList tokens, ref int i, Type type,
Token endToken, int maxLength, Logger log)
{
int len = tokens.Count;
if (i >= len)
{
log.Error("BuildArray: Input index too large.");
return(null);
}
// put the objects into an array list first, since we don't
// know length
ArrayList list = new ArrayList();
// allow null endToken specified
if (endToken == null) endToken = new EofToken();
Token token = null;
token = (Token)tokens[i++];
int arrayLength = 0;
while ((!(token is EofToken)) && (token != endToken) && (i < len)
&& ((maxLength < 0) || (arrayLength < maxLength)))
{
Object o = token.ConvertToType(type);
list.Add(o);
arrayLength++;
token = (Token)tokens[i++];
}
i--; // went one past
return(list.ToArray(type));
}
static void Main(string[] args)
{
ILayout simpleLayout = new SimpleLayout();
IAppender consoleAppender = new ConsoleAppender(simpleLayout);
ILogger logger = new Logger(consoleAppender);
logger.Error("Error parsing JSON");
logger.Info(string.Format("User {0} successfully registered.", "Pesho"));
Console.WriteLine(new string('-', 20));
//We create a second Appender and add it to the existing ILogger object
IFileAppender fileAppender = new FileAppender(simpleLayout);
fileAppender.File = "log.txt";
logger.AddAppender(fileAppender);
logger.Fatal("mscorlib.dll does not respond");
logger.Critical("No connection string found in App.config");
Console.WriteLine(new string('-', 20));
//We set the new XML Layout on each Appender that the Logger object uses
foreach (IAppender appender in logger.Appenders)
{
appender.Layout = new XmlLayout();
}
logger.Fatal("mscorlib.dll does not respond");
logger.Critical("No connection string found in App.config");
Console.WriteLine(new string('-', 20));
//We set the Report Level Minimum at Error
foreach (IAppender appender in logger.Appenders)
{
appender.ReportLevelMinimum = Enums.ReportLevel.Error;
}
logger.Info("Everything seems fine");
logger.Warning("Warning: ping is too high - disconnect imminent");
logger.Error("Error parsing request");
logger.Critical("No connection string found in App.config");
logger.Fatal("mscorlib.dll does not respond");
Console.WriteLine(new string('-', 20));
}
private static void ExampleOne()
{
ILayout simpleLayout = new SimpleLayout();
IAppender consoleAppender =
new ConsoleAppender(simpleLayout);
ILogger logger = new Logger(consoleAppender);
logger.Error("Error parsing JSON.");
logger.Info(string.Format("User {0} successfully registered.", "Pesho"));
}
public void LoggerGenerateOutputTest()
{
Logger logger = new Logger(System.Reflection.Assembly.GetExecutingAssembly());
logger.Exception("exception #1");
logger.Exception("exception #2");
logger.Exception("exception #3");
logger.Exception("exception #4");
logger.Error("Error 1");
logger.Error("Error 2");
logger.Error("Error 3");
logger.Warn("Warn 1");
logger.Warn("Warn 2");
logger.Warn("Warn 3");
string id = logger.LogResume();
Assert.Pass(id);
}
private static void ExampleTwo()
{
var simpleLayout = new SimpleLayout();
var consoleAppender = new ConsoleAppender(simpleLayout);
var fileAppender = new FileAppender(simpleLayout);
fileAppender.File = "log.txt";
var logger = new Logger(consoleAppender, fileAppender);
logger.Error("Error parsing JSON.");
logger.Info(string.Format("User {0} successfully registered.", "Pesho"));
logger.Warn("Warning - missing files.");
}
public ErrorSuccess<IVsixPackage, string> LoadFromFile(string file, Logger log)
{
var ef = new ErrorSuccessFactory<IVsixPackage, string>();
try
{
return _LoadFromFile(file, log, ef);
}
catch (Exception ex)
{
log.Error($"An unexpected error occurred while trying to read {file} as a vsix.", ex);
return ef.Error($"An unexpected error occurred while trying to read {file} as a vsix: {ex.Message}");
}
}
private static void ExampleFour()
{
var simpleLayout = new SimpleLayout();
var consoleAppender = new ConsoleAppender(simpleLayout);
consoleAppender.ReportLevel = ReportLevel.Error;
var logger = new Logger(consoleAppender);
logger.Info("Everything seems fine");
logger.Warn("Warning: ping is too high - disconnect imminent");
logger.Error("Error parsing request");
logger.Critical("No connection string found in App.config");
logger.Fatal("mscorlib.dll does not respond");
}
public CSharpProject(ISolution solution,
Logger logger,
string folderPath,
IFileSystem fileSystem)
: base(fileSystem, logger)
{
_fileSystem = fileSystem;
_logger = logger;
_solution = solution;
Files = new List<CSharpFile>();
References = new List<IAssemblyReference>();
DirectoryInfoBase folder;
try
{
folder = _fileSystem.DirectoryInfo.FromDirectoryName(folderPath);
}
catch (DirectoryNotFoundException)
{
logger.Error("Directory not found - " + folderPath);
return;
}
var files = folder.GetFiles("*.cs", SearchOption.AllDirectories);
foreach (var file in files)
{
_logger.Debug("Loading " + file.FullName);
Files.Add(new CSharpFile(this, file.FullName));
}
this.ProjectContent = new CSharpProjectContent()
.SetAssemblyName(AssemblyName)
.AddAssemblyReferences(References)
.AddOrUpdateFiles(Files.Select(f => f.ParsedFile));
AddMsCorlib();
AddReference(LoadAssembly(FindAssembly("System.Core")));
var dlls = folder.GetFiles("*.dll", SearchOption.AllDirectories);
foreach (var dll in dlls)
{
_logger.Debug("Loading assembly " + dll.FullName);
AddReference(dll.FullName);
}
}
public void Error()
{
// arrange
var logger = new Logger();
var logs = new StringBuilder();
logger.SetWriter(new StringWriter(logs));
logger.AddCategory("error");
// act
logger.Debug("debug message");
logger.Info("info message");
logger.Error("error message");
// assert
Assert.Equal("error message", logs.ToString().Trim());
}
private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
{
try
{
Logger logger = new Logger();
Exception ex = (Exception)e.ExceptionObject;
logger.Error("Unhandled exception occured in application. " + ex.Message, ex);
Console.WriteLine("MyHandler caught : " + ex.Message);
Console.WriteLine("Runtime terminating: {0}", e.IsTerminating);
ErrorModal form = new ErrorModal(ex.Message);
form.ShowDialog();
}
catch (Exception)
{
}
}
/// <summary>
/// Costruttore senza ID del sensore, trovato automaticamente dal software
/// Prende il primo termometro che trova
/// </summary>
/// <param name="Name"></param>
/// <param name="Simulation"></param>
/// <param name="Logger"></param>
public Temperature_DS1822(string Name, bool Simulation, Logger Logger)
: base(Name, Simulation, Logger)
{
Logger.Debug("Temperature_DS1822_Constructor senza ID. SensorId automatico");
if (!Simulation)
{
// creazione del termometro; se il parametro DeviceIndex = 0 usa il primo sensore che trova
try
{
termometro = new Ds18b20Connection(0);
}
catch (Exception ex)
{
Logger.Error("Temperature_DS1822_Constructor senza ID. " + ex.Message);
return;
}
}
Initialization();
}
public void TestLogging()
{
var config = new FileConfiguration
{
CreateDateFolder = true,
DaysToKeep = 3,
Path = AppDomain.CurrentDomain.BaseDirectory
};
var target = new FileTarget("Everything", config);
target.Enqueue(new LogEntry
{
CreatedAt = DateTime.Now,
LogLevel = LogLevel.Debug,
Message = "Hello world",
LoggedType = GetType(),
MethodName = MethodBase.GetCurrentMethod().Name,
ThreadId = Thread.CurrentThread.ManagedThreadId,
UserName = Thread.CurrentPrincipal.Identity.Name
?? Environment.UserName
});
var target2 = new PaddedFileTarget("EVeryone", config);
target2.Enqueue(new LogEntry
{
CreatedAt = DateTime.Now,
LogLevel = LogLevel.Debug,
Message = "Hello world",
LoggedType = GetType(),
MethodName = MethodBase.GetCurrentMethod().Name,
ThreadId = Thread.CurrentThread.ManagedThreadId,
UserName = Thread.CurrentPrincipal.Identity.Name
?? Environment.UserName
});
var logger = new Logger(GetType(), new[] {target2, target});
logger.Info("Hello");
logger.Debug("Hello");
logger.Warning("Hello");
logger.Error("Hello");
}
public Temperature_DS1822(string Name, bool Simulation, string SensorId,Logger Logger)
: base(Name, Simulation, Logger)
{
Logger.Debug("Temperature_DS1822_Constructor con ID. SensorId: " + SensorId);
// creazione del termometro con l'Id passato
if (!Simulation)
{
try
{
termometro = new Ds18b20Connection(SensorId);
}
catch (Exception ex)
{
Logger.Error("Temperature_DS1822_Constructor con ID. SensorId" + ex.Message);
return;
}
}
IdSensor = SensorId;
Initialization();
}
public void TestLogging()
{
var config = new FileConfiguration
{
CreateDateFolder = true,
DaysToKeep = 3,
Path = @"d:\logfiles"
};
var target = new FileTarget("Everything", config);
target.Enqueue(new LogEntry
{
CreatedAt = DateTime.Now,
LogLevel = LogLevel.Debug,
Message = "Hello world",
StackFrames = new StackTrace().GetFrames(),
ThreadId = Thread.CurrentThread.ManagedThreadId,
UserName = Thread.CurrentPrincipal.Identity.Name
?? Environment.UserName
});
var target2 = new PaddedFileTarget("EVeryone", config);
target2.Enqueue(new LogEntry
{
CreatedAt = DateTime.Now,
LogLevel = LogLevel.Debug,
Message = "Hello world",
StackFrames = new StackTrace().GetFrames(),
ThreadId = Thread.CurrentThread.ManagedThreadId,
UserName = Thread.CurrentPrincipal.Identity.Name
?? Environment.UserName
});
var logger = new Logger(GetType(), new[] {target2, target});
logger.Info("Hello");
logger.Debug("Hello");
logger.Warning("Hello");
logger.Error("Hello");
}
void TryLogger(Logger logger)
{
bool thrown = false;
string message = "msg";
try
{
logger.Always(message);
logger.Debug(message);
logger.Detailed(message);
logger.Error(message);
logger.Event(message);
logger.Fatal(message);
logger.Info(message);
logger.Warning(message);
}
catch (Exception)
{
thrown = true;
}
Assert.IsFalse(thrown);
}
// ---------------------------------------------------------------------
#region TestSelf
// ---------------------------------------------------------------------
/// <summary>
/// Simple self test.
/// </summary>
/// <returns>bool - true for success, false for failure.</returns>
public static bool TestSelf()
{
Logger log = new Logger("testSelf");
log.Verbosity = VerbosityLevel.Debug;
log.Info("Starting...");
//
// try parseSpec style
//
string parseSpec = "file=s, type:s, v, d, number=s";
string[] testArgs = {"-file", "fileName", "-type", "-v", "hello",
"-number", "-3.2"};
string errorMessage = null;
Opts opts = new Opts();
opts.ParseSpec = parseSpec;
log.Info("ParseSpec:");
opts.DisplayParseSpec(" ");
if (!opts.Parse(testArgs, out errorMessage))
{
log.Error("Unable to parse test string.");
log.Error("Error message is '{0}'", errorMessage);
return(false);
}
log.Info("After parse:");
opts.Display(" ");
// check results
if (opts.Options["file"] == null)
{
log.Error("Parse didn't get -file option");
return(false);
}
log.Info("-file argument was {0}", opts.Options["file"]);
if (opts.Options.ContainsKey("v")) log.Info("-v option was found");
else
{
log.Error("Parse didn't find -v option");
return(false);
}
if (opts.Options.ContainsKey("type"))
{
log.Info("-type arg was '{0}'", opts.Options["type"]);
}
else
{
log.Error("Parse didn't find -type option");
return(false);
}
//
// try usageSpec style
//
log.Info("----------------------------------------------------------");
log.Info("UsageSpec style of use.");
string usageSpec = "cmd -file fileName -type [typeName] [-v|-d] [-number num] file ...";
log.Info("Input usage: {0}", usageSpec);
opts.UsageSpec = usageSpec;
log.Info("UsageSpec:");
opts.DisplayParseSpec(" ");
if (!opts.Parse(testArgs, out errorMessage))
{
log.Error("Unable to parse test string.");
log.Error("Error message is '{0}'", errorMessage);
return(false);
}
if (opts.Options.ContainsKey("v"))
{
log.Info("-v was specified");
}
log.Info("After parse:");
opts.Display(" ");
// done
log.Info("Done.");
return(true);
}
public virtual void Init()
{
Log = new Logger(_info.Name ?? _info.WatcherType.Substring(_info.WatcherType.LastIndexOf('.') + 1));
string basePath = AppDomain.CurrentDomain.BaseDirectory;
//Input folder must be specified - either absolute, or relative
//(in which case it becomes a subfolder of the AppDomain current folder)
//Input must exist -- we do this to avoid creating random folders on disk
//if there's a typo in the configuration
_inputFolder = MakeRootedPath(basePath, _info.InputFolder);
//All other folders are children of input folder by default
//If a folder is overriden in a config file, do any of
// a) If override is rooted, use that explicit path
// b) Else append to input folder
if (!_info.NoDefaultFolders) {
_archiveFolder = SetupConfiguredFolder(_inputFolder, _info.ArchiveFolder, "processed");
if (!_info.DeleteMeansDelete)
_deletedFolder = SetupConfiguredFolder(_inputFolder, _info.DeletedFolder, "deleted");
_errorFolder = SetupConfiguredFolder(_inputFolder, _info.ErrorFolder, "error");
}
//Some processors want a separate output folder to output transformed files
//(as opposed to 'Processed' folder that archives unchanged input files after they are processed)
_outputFolder = MakeRootedPath(basePath, _info.OutputFolder);
//Some processors will use an URI for output
_uri = _info.Url;
if (_info.WatchSubfolders && (IsSubFolderOf(_inputFolder, _archiveFolder) || IsSubFolderOf(_inputFolder, _deletedFolder) || IsSubFolderOf(_inputFolder, _errorFolder))) {
_info.WatchSubfolders = false;
Log.Error("Will not watch subfolders as some of the configured folders are subfolders of input folder");
}
if (_info.NoDefaultFolders) {
Log.Info("Registering watcher '{0}': input from '{1}{2}', leave files in place.", _info.WatcherType, _inputFolder, _info.WatchSubfolders ? "\\*" + _info.Filter : "");
} else {
Log.Info("Registering watcher '{0}': input from '{1}{3}', archive to '{2}'", _info.WatcherType, _inputFolder, _archiveFolder, _info.WatchSubfolders ? "\\*" + _info.Filter : "");
}
if (!Directory.Exists(_inputFolder)) {
Log.Error("Input folder {0} does not exist. Please create the folder and restart this service.", _inputFolder);
}
if (!string.IsNullOrWhiteSpace(_outputFolder)) {
Log.Info("Transformed output will go into '{0}'", _outputFolder);
}
_watcher = new FileSystemWatcher(_inputFolder);
_watcher.Created += new FileSystemEventHandler(FileCreated);
if (!string.IsNullOrEmpty(_info.Filter)) {
_watcher.Filter = _info.Filter;
}
_watcher.IncludeSubdirectories = _info.WatchSubfolders;
_watcher.EnableRaisingEvents = true;
SetUpTimers();
}
internal void ValidateConfiguration(Logger logger)
{
if (AreDefaults) return;
Type type = null;
try
{
type = TypeUtils.ResolveType(FullTypeName);
}
catch (Exception exception)
{
string errStr = String.Format("Unable to find grain class type {0} specified in configuration; Failing silo startup.", FullTypeName);
logger.Error(ErrorCode.Loader_TypeLoadError, errStr, exception);
throw new OrleansException(errStr, exception);
}
if (type == null)
{
string errStr = String.Format("Unable to find grain class type {0} specified in configuration; Failing silo startup.", FullTypeName);
logger.Error(ErrorCode.Loader_TypeLoadError_2, errStr);
throw new OrleansException(errStr);
}
var typeInfo = type.GetTypeInfo();
// postcondition: returned type must implement IGrain.
if (!typeof(IGrain).IsAssignableFrom(type))
{
string errStr = String.Format("Type {0} must implement IGrain to be used Application configuration context.",type.FullName);
logger.Error(ErrorCode.Loader_TypeLoadError_3, errStr);
throw new OrleansException(errStr);
}
// postcondition: returned type must either be an interface or a class.
if (!typeInfo.IsInterface && !typeInfo.IsClass)
{
string errStr = String.Format("Type {0} must either be an interface or class used Application configuration context.",type.FullName);
logger.Error(ErrorCode.Loader_TypeLoadError_4, errStr);
throw new OrleansException(errStr);
}
}
public void error_just_delegates_to_all_listeners()
{
var l1 = MockRepository.GenerateMock<ILogListener>();
var l2 = MockRepository.GenerateMock<ILogListener>();
var l3 = MockRepository.GenerateMock<ILogListener>();
var logger = new Logger(new ILogListener[] { l1, l2, l3 }, NulloModifiers);
var ex = new NotImplementedException();
logger.Error("some message", ex);
l1.AssertWasCalled(x => x.Error("some message", ex));
l2.AssertWasCalled(x => x.Error("some message", ex));
l3.AssertWasCalled(x => x.Error("some message", ex));
}
public void logger_will_not_throw_an_exception_if_one_listener_blows_chunks_for_error()
{
var l1 = MockRepository.GenerateMock<ILogListener>();
var l2 = MockRepository.GenerateMock<ILogListener>();
var l3 = MockRepository.GenerateMock<ILogListener>();
var logger = new Logger(new ILogListener[] { l1, l2, l3 }, NulloModifiers);
var ex = new NotImplementedException();
l2.Expect(x => x.Error("some message", ex)).Throw(new NotSupportedException());
logger.Error("some message", ex);
l1.AssertWasCalled(x => x.Error("some message", ex));
l2.AssertWasCalled(x => x.Error("some message", ex));
l3.AssertWasCalled(x => x.Error("some message", ex));
}
public CSharpProject(ISolution solution, Logger logger, string folderPath)
{
_logger = logger;
_solution = solution;
Files = new List<CSharpFile>();
References = new List<IAssemblyReference>();
DirectoryInfo folder;
try
{
folder = new DirectoryInfo(folderPath);
}
catch(DirectoryNotFoundException)
{
logger.Error("Directory not found - " + folderPath);
return;
}
var files = folder.EnumerateFiles("*.cs", SearchOption.AllDirectories);
foreach (var file in files)
{
_logger.Debug("Loading " + file.FullName);
Files.Add(new CSharpFile(this, file.FullName));
}
var dlls = folder.EnumerateFiles("*.dll", SearchOption.AllDirectories);
foreach (var dll in dlls)
{
Console.WriteLine(dll.FullName);
AddReference(dll.FullName);
}
AddMsCorlib();
AddReference(LoadAssembly(FindAssembly("System.Core")));
AddAllKpmPackages();
this.ProjectContent = new CSharpProjectContent()
.SetAssemblyName(AssemblyName)
.AddAssemblyReferences(References)
.AddOrUpdateFiles(Files.Select(f => f.ParsedFile));
}
public void Logger_NoRoutes()
{
const string message = "message";
ILogger logger = new Logger();
logger.Critical(message);
logger.Error(message);
logger.Warning(message);
logger.Informational(message);
logger.Debug(message);
logger.Diagnostic(message);
logger.ChangeEvent(message, message);//string is not a good example here, but the function isn't called anyway
//yes, nothing happens.
//this test is here to ensure no exceptions occur when leaving handlers unspecified for the logger
}
// ---------------------------------------------------------------------
#region TestSelf
// ---------------------------------------------------------------------
/// <summary>
/// Simple self test. See StreamTokenizerTestCase for full
/// tests.
/// </summary>
/// <returns>bool - true for success, false for failure.</returns>
public static bool TestSelf()
{
Logger log = new Logger("testSelf");
log.Verbosity = VerbosityLevel.Debug;
log.Info("Starting...");
string testString;
ArrayList tokens;
// setup tokenizer
StreamTokenizer tokenizer = new StreamTokenizer();
tokenizer.Settings.SetupForCodeParse();
tokenizer.Verbosity = VerbosityLevel.Debug;
//
// try string parse
//
log.Write("--------------------------------------------------------\n");
log.Info("string parse:");
log.Write("--------------------------------------------------------\n");
tokens = new ArrayList();
testString = "-1.2ej";
tokenizer.Settings.DoUntermCheck = false;
tokenizer.Settings.GrabWhitespace = false;
if (!tokenizer.TokenizeString(testString, tokens))
{
log.Error("Unable to parse into token vector.");
return (false);
}
foreach (Token t in tokens) log.Info("Token = '{0}'", t);
tokens = new ArrayList();
//
// try NextToken style
//
// log.Write("--------------------------------------------------------\n");
// log.Info("NextToken use");
// log.Write("--------------------------------------------------------\n");
//string fileName = "st-testSelf.tmp";
//testString = "this is a simple string";
//tokenizer.TextReader = new StringReader(testString);
//tokenizer.TextReader = File.OpenText(fileName);
//Token token;
//while (tokenizer.NextToken(out token)) log.Info("Token = '{0}'", token);
//
// try TokenizeFile
//
log.Write("--------------------------------------------------------\n");
log.Info("Tokenize missing file");
log.Write("--------------------------------------------------------\n");
string nonExistentFileName = "ThisFile better not exist";
bool caughtIt = false;
try
{
tokenizer.TokenizeFile(nonExistentFileName);
}
catch (FileNotFoundException e)
{
log.Info("Correctly caught exception: {0}: {1}", e.GetType(), e.Message);
caughtIt = true;
}
if (!caughtIt)
{
log.Error("Didn't get a file not found exception from TokenizeFile.");
return (false);
}
//
// test line numbers in tokens
//
// done
log.Info("Done.");
return (true);
}
public static void Fatal(Logger log, Exception ex)
{
Exception actualEx = null;
if (ex.InnerException != null)
{
actualEx = ex.InnerException;
while (actualEx.InnerException != null)
{
actualEx = actualEx.InnerException;
}
}
log.Error("Exception: ", ex);
if (actualEx != null)
{
log.Fatal("Inner exception: ", actualEx);
}
}
public CSharpProject(ISolution solution,
IFileSystem fileSystem,
Logger logger,
string title,
string fileName,
Guid id)
: base(fileSystem, logger)
{
_fileSystem = fileSystem;
_logger = logger;
_solution = solution;
Title = title;
if (fileSystem is FileSystem)
{
fileName = fileName.ForceNativePathSeparator();
}
FileName = fileName;
ProjectId = id;
Files = new List<CSharpFile>();
Microsoft.Build.Evaluation.Project project;
try
{
project = new Microsoft.Build.Evaluation.Project(_fileSystem, fileName);
}
catch (DirectoryNotFoundException)
{
logger.Error("Directory not found - " + FileName);
return;
}
catch (FileNotFoundException)
{
logger.Error("File not found - " + FileName);
return;
}
AssemblyName = project.GetPropertyValue("AssemblyName");
SetCompilerSettings(project);
AddCSharpFiles(project);
References = new List<IAssemblyReference>();
this.ProjectContent = new CSharpProjectContent()
.SetAssemblyName(AssemblyName)
.AddOrUpdateFiles(Files.Select(f => f.ParsedFile));
AddMsCorlib();
bool hasSystemCore = false;
foreach (var item in project.GetItems("Reference"))
{
var assemblyFileName = GetAssemblyFileNameFromHintPath(project, item);
//If there isn't a path hint or it doesn't exist, try searching
if (assemblyFileName == null)
assemblyFileName = FindAssembly(item.EvaluatedInclude);
//If it isn't in the search paths, try the GAC
if (assemblyFileName == null && PlatformService.IsWindows)
assemblyFileName = FindAssemblyInNetGac(item.EvaluatedInclude);
if (assemblyFileName != null)
{
if (_fileSystem.Path.GetFileName(assemblyFileName).Equals("System.Core.dll", StringComparison.OrdinalIgnoreCase))
hasSystemCore = true;
_logger.Debug("Loading assembly " + item.EvaluatedInclude);
try
{
AddReference(LoadAssembly(assemblyFileName));
}
catch (Exception e)
{
_logger.Error(e);
}
}
else
_logger.Error("Could not find referenced assembly " + item.EvaluatedInclude);
}
if (!hasSystemCore && FindAssembly("System.Core") != null)
AddReference(LoadAssembly(FindAssembly("System.Core")));
AddProjectReferences(project);
}
public void error_just_delegates_to_all_listeners_2()
{
var l1 = MockRepository.GenerateMock<ILogListener>();
var l2 = MockRepository.GenerateMock<ILogListener>();
var l3 = MockRepository.GenerateMock<ILogListener>();
var logger = new Logger(SystemTime.Default(), new ILogListener[] { l1, l2, l3 });
var ex = new NotImplementedException();
var correlationId = Guid.NewGuid();
logger.Error(correlationId, "some message", ex);
l1.AssertWasCalled(x => x.Error(correlationId, "some message", ex));
l2.AssertWasCalled(x => x.Error(correlationId, "some message", ex));
l3.AssertWasCalled(x => x.Error(correlationId, "some message", ex));
}
public async Task ErrorLogsWhenLogLevelAtError()
{
// Arrange
Logger logger = new Logger(_runtimeEnvironment.Object, _queue.Object, _source.Object, _extension.Object, LogLevelEnum.Error, _correlationIdProvider.Object);
// Act
await logger.Error("a message");
// Assert
_queue.Verify(x => x.EnqueueAsync(It.IsAny<LogQueueItem>()));
}
/// <summary>
/// Simple test of some ParseUtil methods.
/// </summary>
/// <returns>bool - true for all passed, false otherwise</returns>
public static bool TestSelf()
{
Logger log = new Logger("ParseUtil: TestSelf");
log.Info("Starting...");
StreamTokenizer tokenizer = new StreamTokenizer();
tokenizer.Verbosity = VerbosityLevel.Warn;
// FindMatch
ArrayList alist = new ArrayList();
tokenizer.TokenizeString("{ [ ] '}' }", alist);
foreach(Token t in alist) log.Debug("Token = {0}", t);
Token[] tarray = (Token[])alist.ToArray(typeof(Token));
int i = 0;
if (!FindMatch(tarray, ref i, '{'))
{
log.Error("FindMatch failed to match { char");
return(false);
}
if (i != 4)
{
log.Error("FindMatch got the wrong answer {0}", i);
return(false);
}
else log.Info("FindMatch worked.");
//
// try BuildArray
//
ArrayList tokens = new ArrayList();
tokenizer.TokenizeString("1 2 3 4 5", tokens);
foreach(Token t in tokens) log.Debug("Token = {0}", t);
i = 0;
Int16[] shorts = (short[])ParseUtil.BuildArray(tokens, ref i, typeof(Int16), null,
-1, log);
if (shorts == null)
{
log.Error("Unable to BuildArray of shorts.");
return(false);
}
log.Info("Parsed shorts:");
foreach(Int16 s in shorts)
{
log.Write("{0}, ", s);
}
log.WriteLine("");
//
// try BuildArray of floats, char terminated
//
tokens.Clear();
tokenizer.TokenizeString("1 2 ; 3 4", tokens);
foreach(Token t in tokens) log.Debug("Token = {0}", t);
i = 0;
Single[] floats = (float[])ParseUtil.BuildArray(tokens, ref i, typeof(Single),
new CharToken(';'), -1, log);
if (floats == null)
{
log.Error("Unable to BuildArray of floats.");
return(false);
}
log.Info("Parsed floats:");
foreach(float f in floats)
{
log.Write("{0}, ", f);
}
log.WriteLine("");
if (i != 2)
{
log.Error("BuildArray left i = {0} which is incorrect");
return(false);
}
//
// try BuildArray on high-precision floats
//
tokens.Clear();
float f1 = 1.23456f;
float f2 = 2.34567f;
tokenizer.TokenizeString(String.Format("{0:f6} {1:f6}", f1,f2), tokens);
foreach(Token t in tokens) log.Debug("Token = {0}", t);
i = 0;
floats = (float[])ParseUtil.BuildArray(tokens, ref i, typeof(Single),
null, -1, log);
if (floats == null)
{
log.Error("Unable to BuildArray of floats.");
return(false);
}
log.Info("Parsed floats:");
foreach(float f in floats)
{
log.Write("{0}, ", f);
}
log.WriteLine("");
if (floats[0] != f1)
{
log.Error("BuildArray produced float {0:f6} instead of {1:f6}",
floats[0], f1);
return(false);
}
//
// try BuildArray of chars, maxLength terminated
//
log.Info("Chars, terminated by maxLength");
tokens.Clear();
tokenizer.TokenizeString("12 2 ; 3 4", tokens);
foreach(Token t in tokens) log.Debug("Token = {0}", t);
i = 0;
char[] chars = (char[])ParseUtil.BuildArray(tokens, ref i, typeof(Char),
null, 3, log);
if (chars == null)
{
log.Error("Unable to BuildArray of chars.");
return(false);
}
log.Info("Parsed chars:");
foreach(char f in chars)
{
log.Write("{0}, ", f);
}
log.WriteLine("");
if (i != 4)
{
log.Error("BuildArray left i = {0} which is incorrect", i);
return(false);
}
//
// try BuildArray of hex numbers
//
log.Info("Hex numbers");
tokens.Clear();
tokenizer.Settings.ParseHexNumbers = true;
tokenizer.TokenizeString("0xfff, 0xffe", tokens);
foreach(Token t in tokens) log.Debug("Token = {0}", t);
i = 0;
ushort[] ushorts = (ushort[])ParseUtil.BuildArray(tokens, ref i, typeof(ushort),
null, 3, log);
if (ushorts == null)
{
log.Error("Unable to BuildArray of ushorts.");
return(false);
}
log.Info("Parsed ushorts:");
foreach(ushort us in ushorts)
{
log.Write("{0}, ", us);
}
log.WriteLine("");
// if (i != 4)
// {
// log.Error("BuildArray left i = {0} which is incorrect", i);
// return(false);
// }
log.Info("All PASSED");
return(true);
}
