public void LogLineShouldAppendLineAtTheEnd()
{
const string Message = "test";
ILogger logger = new MemoryLogger();
logger.LogLine(Message);
Assert.AreEqual(Message + Environment.NewLine, logger.ToString());
}
public void LogShouldAppendTheTextWhenCalledTwoTimesInARow()
{
ILogger logger = new MemoryLogger();
logger.Log("test");
logger.Log("тест");
Assert.AreEqual("testтест", logger.ToString());
}
public void LogLineShouldAppendLineBetweenTwoLogCalls()
{
const string FirstMessage = "test";
const string SecondMessage = "тест";
ILogger logger = new MemoryLogger();
logger.LogLine(FirstMessage);
logger.Log(SecondMessage);
Assert.AreEqual(FirstMessage + Environment.NewLine + SecondMessage, logger.ToString());
}
public void EndRoundShouldAddToLoggerAndCallBaseMethod()
{
var logger = new MemoryLogger();
var playerMock = new Mock<IPlayer>();
var playerWithLogger = new PlayerWithLoggerDecorator(playerMock.Object, logger);
playerWithLogger.EndRound();
Assert.IsTrue(logger.ToString().Length > 0);
playerMock.Verify(x => x.EndRound(), Times.Once());
}
public void AddCardShouldAddToLoggerAndCallBaseMethod()
{
var logger = new MemoryLogger();
var playerMock = new Mock<IPlayer>();
var playerWithLogger = new PlayerWithLoggerDecorator(playerMock.Object, logger);
playerWithLogger.AddCard(new Card(CardSuit.Club, CardType.Ace));
Assert.IsTrue(logger.ToString().Length > 0);
playerMock.Verify(x => x.AddCard(It.IsAny<Card>()), Times.Once());
}
public void GetTurnShouldAddToLoggerAndCallBaseMethod()
{
var logger = new MemoryLogger();
var playerMock = new Mock<IPlayer>();
var playerWithLogger = new PlayerWithLoggerDecorator(playerMock.Object, logger);
playerWithLogger.GetTurn(
new PlayerTurnContext(
new StartRoundState(new StateManager()),
new Card(CardSuit.Club, CardType.Ace),
0,
0,
0));
Assert.IsTrue(logger.ToString().Length > 0);
playerMock.Verify(x => x.GetTurn(It.IsAny<PlayerTurnContext>()), Times.Once());
}
public void Lox_AddLogger()
{
UT_INIT();
// twice
{
ConsoleLogger con= new ConsoleLogger();
Log.SetVerbosity( con, Verbosity.Verbose, ALox.InternalDomains );
MemoryLogger checkCnt= new MemoryLogger( "CHECK");
Log.SetVerbosity( checkCnt, Verbosity.Warning, ALox.InternalDomains );
MemoryLogger mem1= new MemoryLogger( "MEM" );
MemoryLogger mem2= new MemoryLogger( "MEM" );
Log.SetVerbosity( mem1, Verbosity.Info ); UT_EQ( 0, checkCnt.CntLogs );
Log.SetVerbosity( mem2, Verbosity.Info ); UT_EQ( 1, checkCnt.CntLogs );
Log.SetVerbosity( "XYZ", Verbosity.Info ); UT_EQ( 2, checkCnt.CntLogs );
Log.RemoveLogger( mem2 ); UT_EQ( 3, checkCnt.CntLogs );
Log.RemoveLogger( mem1 ); UT_EQ( 3, checkCnt.CntLogs );
Log.RemoveLogger( mem1 ); UT_EQ( 4, checkCnt.CntLogs );
Log.RemoveLogger( "XYZ" ); UT_EQ( 5, checkCnt.CntLogs );
Log.RemoveLogger( con ); UT_EQ( 5, checkCnt.CntLogs );
Log.RemoveLogger( con ); UT_EQ( 6, checkCnt.CntLogs );
Log.RemoveLogger( checkCnt ); UT_EQ( 6, checkCnt.CntLogs );
}
// one logger in two loxes
{
Log.AddDebugLogger();
Lox lox= new Lox( "ReleaseLox" );
UT_TRUE( Log.DebugLogger.GetSafeness() == Safeness.Unsafe );
lox.SetVerbosity( Log.DebugLogger , Verbosity.Verbose );
UT_TRUE( Log.DebugLogger.GetSafeness() == Safeness.Safe );
lox.RemoveLogger( Log.DebugLogger );
UT_TRUE( Log.DebugLogger.GetSafeness() == Safeness.Unsafe );
Log.RemoveDebugLogger();
}
}
public void Should_continue_observable_after_many_exceptions()
{
var logger = MemoryLogger.Serilog();
var subject = new Subject <int>();
var s = "";
subject.Subscribe(x =>
logger.instance.Swallow(() =>
{
s += x;
throw new ArgumentException();
}));
subject.OnNext(1);
subject.OnNext(2);
s.Should().Be("12");
logger.messages.Count.Should().Be(2);
}
public void ShouldNotIdleWhenWorkerDoesntExists()
{
MemoryLogger logger;
IdlerModule module;
IWorkerModule workerModule;
ITaskModule taskModule;
workerModule = new MockedWorkerModule(false, new Worker()
{
WorkerID = 1, PlanetID = 1
});
taskModule = new MockedTaskModule(false);
logger = new MemoryLogger();
module = new IdlerModule(logger, taskModule, workerModule);
Assert.ThrowsException <PIONotFoundException>(() => module.BeginIdle(2, 10));
Assert.IsNotNull(logger.Logs.FirstOrDefault(item => (item.Level == LogLevels.Warning) && (item.ComponentName == module.ModuleName)));
}
public void ShouldNotTakeWhenWorkerIsAlreadyCarryingItem()
{
MemoryLogger logger;
TakerModule module;
IWorkerModule workerModule;
ITaskModule taskModule;
workerModule = new MockedWorkerModule(false, new Worker()
{
WorkerID = 1, PlanetID = 1, ResourceTypeID = ResourceTypeIDs.Wood
});
taskModule = new MockedTaskModule(false);
logger = new MemoryLogger();
module = new TakerModule(logger, taskModule, workerModule, null, null);
Assert.ThrowsException <PIOInvalidOperationException>(() => module.BeginTake(1, ResourceTypeIDs.Coal));
Assert.IsNotNull(logger.Logs.FirstOrDefault(item => (item.Level == LogLevels.Warning) && (item.ComponentName == module.ModuleName)));
}
public App()
{
NotifyIcon = new AppNotifyIcon(new System.ComponentModel.Container());
var notifier = new GuiNotifier(SynchronizationContext.Current);
notifier.ErrorNotified += (sender, error) =>
{
NotifyIcon.NotifyError(error);
};
var logger = new MemoryLogger();
AppMain = AppMain.Load(notifier, logger);
ScheduleListWindowContainer =
new ScheduleListWindowContainer(() =>
ScheduleListView.Load(AppMain.SchedulerTask.Result, notifier, logger)
);
}
public void ShouldNotEndTaskWhenSubModuleFails()
{
MemoryLogger logger;
IdlerModule module;
IWorkerModule workerModule;
ITaskModule taskModule;
logger = new MemoryLogger();
workerModule = new MockedWorkerModule(true, new Worker()
{
WorkerID = 1, PlanetID = 1
});
taskModule = new MockedTaskModule(false);
module = new IdlerModule(logger, taskModule, workerModule);
Assert.ThrowsException <PIOInternalErrorException>(() => module.BeginIdle(1, 10));
Assert.IsNotNull(logger.Logs.FirstOrDefault(item => (item.Level == LogLevels.Error) && (item.ComponentName == module.ModuleName)));
}
public RedisRedlockIntegrationTests(RedisFixture redis, ITestOutputHelper console) : base(redis)
{
_console = console;
_log = new MemoryLogger();
_5Inst = new IRedlockInstance[]
{
new RedisRedlockInstance(() => Redis.Redis1.GetDatabase(), s => s, "1", 0.1f, _log),
new RedisRedlockInstance(() => Redis.Redis2.GetDatabase(), s => s, "2", 0.1f, _log),
new RedisRedlockInstance(() => Redis.Redis3.GetDatabase(), s => s, "3", 0.1f, _log),
new RedisRedlockInstance(() => Redis.Redis4.GetDatabase(), s => s, "4", 0.1f, _log),
new RedisRedlockInstance(() => Redis.Redis5.GetDatabase(), s => s, "5", 0.1f, _log),
}.ToImmutableArray();
_noQuorum = new IRedlockInstance[]
{
new RedisRedlockInstance(() => Redis.Redis1.GetDatabase(), s => s, "1", 0.1f, _log),
new RedisRedlockInstance(() => Redis.Redis2.GetDatabase(), s => s, "2", 0.1f, _log),
new RedisRedlockInstance(() => Redis.Unreachable1.GetDatabase(), s => s, "u1", 0.1f, _log),
new RedisRedlockInstance(() => Redis.Unreachable2.GetDatabase(), s => s, "u2", 0.1f, _log),
}.ToImmutableArray();
}
public void BasicTextWriting()
{
LogManager.Start();
MemoryLogger memoryLog = LogManager.CreateMemoryLogger();
memoryLog.SubscribeToEvents(TestLogger.Write, EventLevel.Verbose);
TestLogger.Write.String("first message");
TestLogger.Write.String("second\nmessage");
// we used to test passing \0 characters here -- EventSource in .NET 4.5.1 correctly treats these as string
// terminators, however in 4.5 it does not. We need to operate in both worlds for now, so we'll ignore this
// for the time being.
memoryLog.Disabled = true;
memoryLog.Stream.Seek(0, SeekOrigin.Begin);
using (var reader = new StreamReader(memoryLog.Stream))
{
string line;
int lines = 0;
while ((line = reader.ReadLine()) != null)
{
++lines;
var expectedMetaData = string.Format("[{0}/{1}/v:TestLogger String]", Process.GetCurrentProcess().Id,
NativeMethods.GetCurrentWin32ThreadId());
Assert.IsTrue(line.Contains(expectedMetaData));
// this is the pretty name of the event we should have deduced.
switch (lines)
{
case 1:
Assert.IsTrue(line.EndsWith(" message=\"first message\""));
break;
case 2:
Assert.IsTrue(line.EndsWith(" message=\"second\\nmessage\""));
break;
}
}
Assert.AreEqual(2, lines);
}
memoryLog.Dispose();
LogManager.Shutdown();
}
public void ShouldNotEndTaskWhenSubModuleFails()
{
MemoryLogger logger;
StorerModule module;
IBuildingModule buildingModule;
IWorkerModule workerModule;
IStackModule stackModule;
ITaskModule taskModule;
MockedSchedulerModule schedulerModule;
buildingModule = new MockedBuildingModule(false, new Building()
{
BuildingID = 2, X = 0, Y = 0
});
workerModule = new MockedWorkerModule(false, new Worker()
{
WorkerID = 1, PlanetID = 1
});
stackModule = new MockedStackModule(true);
taskModule = new MockedTaskModule(false);
logger = new MemoryLogger();
module = new StorerModule(logger, taskModule, workerModule, buildingModule, stackModule);
schedulerModule = new MockedSchedulerModule(false, module);
Assert.ThrowsException <PIOInternalErrorException>(() => module.EndStore(1, ResourceTypeIDs.Wood));
Assert.IsNotNull(logger.Logs.FirstOrDefault(item => (item.Level == LogLevels.Error) && (item.ComponentName == module.ModuleName)));
workerModule = new MockedWorkerModule(true, new Worker()
{
WorkerID = 1, PlanetID = 1
});
stackModule = new MockedStackModule(false);
taskModule = new MockedTaskModule(false);
logger = new MemoryLogger();
module = new StorerModule(logger, taskModule, workerModule, buildingModule, stackModule);
schedulerModule = new MockedSchedulerModule(false, module);
Assert.ThrowsException <PIOInternalErrorException>(() => module.EndStore(1, ResourceTypeIDs.Wood));
Assert.IsNotNull(logger.Logs.FirstOrDefault(item => (item.Level == LogLevels.Error) && (item.ComponentName == module.ModuleName)));
}
public void ShouldNotEndCreateBuildingTaskWhenWorkerDoesntExists()
{
MemoryLogger logger;
BuilderModule module;
IWorkerModule workerModule;
ITaskModule taskModule;
IBuildingModule buildingModule;
IStackModule stackModule;
IMaterialModule materialModule;
IBuildingTypeModule buildingTypeModule;
logger = new MemoryLogger();
workerModule = new MockedWorkerModule(false, new Worker()
{
WorkerID = 1, PlanetID = 1
});
taskModule = new MockedTaskModule(false);
buildingModule = new MockedBuildingModule(false);
buildingTypeModule = new MockedBuildingTypeModule(false, new BuildingType()
{
BuildingTypeID = BuildingTypeIDs.Sawmill
});
stackModule = new MockedStackModule(false, new Stack()
{
Quantity = 10, ResourceTypeID = ResourceTypeIDs.Wood, StackID = 1
}, new Stack()
{
Quantity = 10, ResourceTypeID = ResourceTypeIDs.Stone, StackID = 1
});
materialModule = new MockedMaterialModule(false, new Material()
{
Quantity = 1, ResourceTypeID = ResourceTypeIDs.Wood, BuildingTypeID = BuildingTypeIDs.Sawmill
}, new Material()
{
Quantity = 2, ResourceTypeID = ResourceTypeIDs.Stone, BuildingTypeID = BuildingTypeIDs.Sawmill
});
module = new BuilderModule(logger, taskModule, workerModule, buildingModule, buildingTypeModule, stackModule, materialModule);
Assert.ThrowsException <PIONotFoundException>(() => module.EndCreateBuilding(999, BuildingTypeIDs.Sawmill));
Assert.IsNotNull(logger.Logs.FirstOrDefault(item => (item.Level == LogLevels.Warning) && (item.ComponentName == module.ModuleName)));
}
public ActionResponse Execute()
{
var logger = new MemoryLogger();
var code = 200;
var message = "Ok";
foreach (var script in _context.Process.Scripts.Where(s => !s.Global))
{
if (script.File != string.Empty)
{
script.Content = _reader.Read(script.File, new Dictionary <string, string>(), logger);
if (logger.Errors().Any())
{
code = 500;
foreach (var error in logger.Errors())
{
message += error + " ";
}
break;
}
foreach (var entity in _context.Process.Entities)
{
if (entity.Script == script.Name && entity.Query == string.Empty && script.Content != string.Empty)
{
entity.Query = script.Content;
}
}
}
}
return(new ActionResponse(code, message)
{
Action = new Transformalize.Configuration.Action {
Before = true,
After = false,
Type = "internal",
ErrorMode = "abort",
Description = "load script"
}
});
}
public void ShouldNotProduceWhenBuildingIsNotFinished()
{
MemoryLogger logger;
ProducerModule module;
IBuildingModule buildingModule;
IBuildingTypeModule buildingTypeModule;
IWorkerModule workerModule;
IStackModule stackModule;
IIngredientModule ingredientModule;
IProductModule productModule;
ITaskModule taskModule;
MockedSchedulerModule schedulerModule;
buildingModule = new MockedBuildingModule(false, new Building()
{
BuildingID = 1, BuildingTypeID = BuildingTypeIDs.Sawmill, RemainingBuildSteps = 10
});
buildingTypeModule = new MockedBuildingTypeModule(false, new BuildingType()
{
BuildingTypeID = BuildingTypeIDs.Sawmill, IsFactory = true
});
workerModule = new MockedWorkerModule(false, new Worker()
{
WorkerID = 1, PlanetID = 1
});
stackModule = new MockedStackModule(false);
ingredientModule = new MockedIngredientModule(false);
productModule = new MockedProductModule(false, new Product()
{
ProductID = 1, BuildingTypeID = BuildingTypeIDs.Sawmill, Duration = 4, Quantity = 2
});
taskModule = new MockedTaskModule(false);
logger = new MemoryLogger();
module = new ProducerModule(logger, taskModule, workerModule, buildingModule, buildingTypeModule, stackModule, ingredientModule, productModule);
schedulerModule = new MockedSchedulerModule(false, module);
Assert.ThrowsException <PIOInvalidOperationException>(() => module.BeginProduce(1));
Assert.IsNotNull(logger.Logs.FirstOrDefault(item => (item.Level == LogLevels.Warning) && (item.ComponentName == module.ModuleName)));
Assert.AreEqual(0, schedulerModule.Count);
}
public async Task LogEntryIsRecorded()
{
var logger = new MemoryLogger <SimpleDependencyInjection.Function>();
var function = new SimpleDependencyInjection.Function(logger);
// Constructing the function does not create any log entries.
Assert.Empty(logger.ListLogEntries());
// Make a request to the function.
var context = new DefaultHttpContext
{
Request = { Path = "/sample-path" }
};
await function.HandleAsync(context);
var logs = logger.ListLogEntries();
var entry = Assert.Single(logs);
Assert.Equal(LogLevel.Information, entry.Level);
Assert.Equal("Function called with path /sample-path", entry.Message);
}
public void TestPerformanceCounterSourceSafeStop()
{
var logger = new MemoryLogger(nameof(TestPerformanceCounterSourceSafeStop));
var config = TestUtility.GetConfig("Sources", "PerformanceCounter");
var mockCounterSource = new Mock <PerformanceCounterSource>(MockBehavior.Strict, new PluginContext(config, logger, null));
// in real deployment, RefreshInstances() might take a long time if there are a lot of counter instances.
// so we mock this method to simulate the situation
mockCounterSource.Setup(s => s.RefreshCounters()).Callback(() => Thread.Sleep(1000));
var source = mockCounterSource.Object;
source.Start();
var queryTask = Task.Run(() => source.Query(null));
Thread.Sleep(500);
source.Stop();
queryTask.Wait();
// assert that no error log message was written
Assert.Empty(logger.LogLevels.Where(l => l == LogLevel.Error));
}
public async Task FileNameIsLogged()
{
// Prepare the inputs
var cloudEvent = new CloudEvent(StorageObjectData.FinalizedCloudEventType, new Uri("//storage.googleapis.com"));
var data = new StorageObjectData {
Name = "new-file.txt"
};
CloudEventConverters.PopulateCloudEvent(cloudEvent, data);
var logger = new MemoryLogger <HelloGcs.Function>();
// Execute the function
var function = new HelloGcs.Function(logger);
await function.HandleAsync(cloudEvent, data, CancellationToken.None);
// Check the log results
var logEntry = Assert.Single(logger.ListLogEntries());
Assert.Equal("File new-file.txt uploaded", logEntry.Message);
Assert.Equal(LogLevel.Information, logEntry.Level);
}
public void Tut_Exception()
{
#if ALOX_DBG_LOG || ALOX_REL_LOG
UT_INIT();
Log.SetVerbosity(tutLog = new MemoryLogger("Tutlog"), Verbosity.Warning, "/");
#if ALOX_DBG_LOG
((TextLogger)Log.GetLogger("Tutlog")).MultiLineMsgMode = 4;
#endif
//! [Tut_Exceptions]
Exception testException = new Exception("TestException Message",
new Exception("InnerException Message",
new Exception("Inner, inner Exception")));
LogTools.Exception("MYDOM", Verbosity.Warning, testException, "Logging an exception: ");
//! [Tut_Exceptions]
tutLog.MemoryLog.SearchAndReplace("Tutlog", "CONSOLE");
SaveTutorialOutput("Tut_Exceptions.txt", tutLog.MemoryLog);
#endif
}
public void Tut_Hello_ALox()
{
UT_INIT();
//! [Tut_ALox_Logger_1]
Log.AddDebugLogger();
//! [Tut_ALox_Logger_1]
Log.RemoveDebugLogger();
Log.SetVerbosity(tutLog = new MemoryLogger("Tutlog"), Verbosity.Verbose);
//! [Tut_ALox_Logger_2]
Log.AddDebugLogger();
Log.Info("Hello ALox");
//! [Tut_ALox_Logger_2]
#if (ALOX_DBG_LOG || ALOX_REL_LOG)
SaveTutorialOutput("Tut_ALox_Logger.txt", tutLog.MemoryLog);
#endif
}
public void Log_RelativeDomains()
{
UT_INIT();
Lox lox = new Lox("ReleaseLox");
MemoryLogger ml = new MemoryLogger();
lox.SetVerbosity(ml, Verbosity.Verbose);
ml.MetaInfo.Format._()._("@%D#");
lox.SetDomain("/D1/D2/D3", Scope.Method);
lox.Info("D4", ""); UT_EQ("@/D1/D2/D3/D4#", ml.MemoryLog); ml.MemoryLog._(); ml.AutoSizes.Reset();
lox.Info("./D4", ""); UT_EQ("@/D1/D2/D3/D4#", ml.MemoryLog); ml.MemoryLog._(); ml.AutoSizes.Reset();
lox.Info("../D4", ""); UT_EQ("@/D1/D2/D4#", ml.MemoryLog); ml.MemoryLog._(); ml.AutoSizes.Reset();
lox.Info(".././.././D4", ""); UT_EQ("@/D1/D4#", ml.MemoryLog); ml.MemoryLog._(); ml.AutoSizes.Reset();
lox.Info("../../../../../D4", ""); UT_EQ("@/D4#", ml.MemoryLog); ml.MemoryLog._(); ml.AutoSizes.Reset();
lox.Info("../D4/../D5", ""); UT_EQ("@/D1/D2/D5#", ml.MemoryLog); ml.MemoryLog._(); ml.AutoSizes.Reset();
lox.RemoveLogger(ml);
}
public void WorkerIsInBuildingShouldThrowExceptionAndLogErrorWhenWorkerDoesntExists()
{
MemoryLogger logger;
LocationCheckerModule module;
IWorkerModule workerModule;
IBuildingModule buildingModule;
workerModule = new MockedWorkerModule(false, new Worker()
{
WorkerID = 10, PlanetID = 5, X = 10, Y = 10
});
buildingModule = new MockedBuildingModule(false, new Building()
{
BuildingID = 3, PlanetID = 5, X = 10, Y = 10
});
logger = new MemoryLogger();
module = new LocationCheckerModule(logger, workerModule, buildingModule);
Assert.ThrowsException <PIONotFoundException>(() => module.WorkerIsInBuilding(1, 2));
Assert.IsNotNull(logger.Logs.FirstOrDefault(item => (item.Level == LogLevels.Warning) && (item.ComponentName == module.ModuleName)));
}
public void ShouldNotDeleteBotWhenDoesntExistAndLogErrors()
{
MemoryLogger logger;
BotSchedulerModule scheduler;
IBotModule botModule;
IOrderManagerModule orderManagerModule;
PIO.ClientLib.PIOServiceReference.IPIOService client;
botModule = Substitute.For <IBotModule>();
botModule.GetBot(Arg.Any <int>()).Returns((x) => null);
botModule.When(x => x.DeleteBot(Arg.Any <int>())).Do(x => { });
orderManagerModule = Substitute.For <IOrderManagerModule>();
client = Substitute.For <PIO.ClientLib.PIOServiceReference.IPIOService>();
logger = new MemoryLogger();
scheduler = new BotSchedulerModule(logger, client, botModule, orderManagerModule, 1);
Assert.ThrowsException <PIONotFoundException>(() => scheduler.DeleteBot(1));
Assert.IsNotNull(logger.Logs.FirstOrDefault(item => (item.Level == LogLevels.Warning) && (item.ComponentName == scheduler.ModuleName)));
}
protected override SettingsRegistrationService Given()
{
_logger = new MemoryLogger();
_typeProvider = new StubTypeProvider(typeof(SensitiveAndSanitized));
var settingsReader = new StubSettingsReader(new Dictionary <string, string>
{
{ typeof(SensitiveAndSanitized).Name, SensitiveAndSanitized.OriginalValueRepresentation },
{ typeof(SensitiveAndUnsanitized).Name, SensitiveAndUnsanitized.OriginalValueRepresentation }
});
return(new SettingsRegistrationService(_logger,
_typeProvider,
SettingKeyConventions.BuiltInConventions.ToArray(),
settingsReader,
new NoOpSettingsOverrider(),
new SettingValueConverter(),
true,
setting => { }
));
}
public void Tut_Instance()
{
#if ALOX_DBG_LOG || ALOX_REL_LOG
UT_INIT();
Log.SetVerbosity(new ConsoleLogger(), Verbosity.Verbose, "/");
Log.SetVerbosity(tutLog = new MemoryLogger("Tutlog"), Verbosity.Verbose, "/");
tutLog.MultiLineMsgMode = 4;
//! [Tut_Instance]
// Log multi-lines without meta info
#if ALOX_DBG_LOG
((TextLogger)Log.GetLogger("Console")).MultiLineMsgMode = 4;
#endif
// Log current thread instance
LogTools.Instance("MYDOM", Verbosity.Info, Thread.CurrentThread, 2, "Actual Thread: ");
//! [Tut_Instance]
// cut the output to 30 lines
int lines = 32;
int idx = 0;
while (lines-- != 0)
{
idx = tutLog.MemoryLog.IndexOf(Environment.NewLine, idx + Environment.NewLine.Length);
if (idx < 0)
{
break;
}
}
if (idx > 0)
{
tutLog.MemoryLog.SetLength(idx + Environment.NewLine.Length);
}
tutLog.MemoryLog._("...")._(Environment.NewLine);
tutLog.MemoryLog._("...")._(Environment.NewLine);
tutLog.MemoryLog._("...")._(Environment.NewLine);
SaveTutorialOutput("Tut_Instance.txt", tutLog.MemoryLog);
#endif
}
public void ShouldNotHarvesteWhenWorkerDoesntExists()
{
MemoryLogger logger;
HarvesterModule module;
IBuildingModule buildingModule;
IBuildingTypeModule buildingTypeModule;
IWorkerModule workerModule;
IStackModule stackModule;
IProductModule productModule;
ITaskModule taskModule;
MockedSchedulerModule schedulerModule;
buildingModule = new MockedBuildingModule(false, new Building()
{
BuildingID = 1, BuildingTypeID = BuildingTypeIDs.Sawmill
});
buildingTypeModule = new MockedBuildingTypeModule(false, new BuildingType()
{
BuildingTypeID = BuildingTypeIDs.Sawmill, IsFarm = true
});
workerModule = new MockedWorkerModule(false, new Worker()
{
WorkerID = 1, PlanetID = 1
});
stackModule = new MockedStackModule(false);
productModule = new MockedProductModule(false, new Product()
{
ProductID = 1, BuildingTypeID = BuildingTypeIDs.Sawmill, Duration = 4, Quantity = 2
});
taskModule = new MockedTaskModule(false);
logger = new MemoryLogger();
module = new HarvesterModule(logger, taskModule, workerModule, buildingModule, buildingTypeModule, stackModule, productModule);
schedulerModule = new MockedSchedulerModule(false, module);
Assert.ThrowsException <PIONotFoundException>(() => module.BeginHarvest(2));
Assert.IsNotNull(logger.Logs.FirstOrDefault(item => (item.Level == LogLevels.Warning) && (item.ComponentName == module.ModuleName)));
Assert.AreEqual(0, schedulerModule.Count);
}
public void Log_IllegalDomainNames()
{
UT_INIT();
Log.AddDebugLogger();
MemoryLogger ml = new MemoryLogger();
Log.SetVerbosity(ml, Verbosity.Verbose);
ml.MetaInfo.Format._()._("<%D>");
Log.SetVerbosity(Log.DebugLogger, Verbosity.Verbose, ALox.InternalDomains);
LOG_CHECK("", "</>", ml, Log.LOX);
LOG_CHECK("LOC", "</LOC>", ml, Log.LOX);
LOG_CHECK("%", "</#>", ml, Log.LOX);
LOG_CHECK("\x03", "</#>", ml, Log.LOX);
LOG_CHECK("<", "</#>", ml, Log.LOX);
LOG_CHECK(">", "</#>", ml, Log.LOX);
LOG_CHECK("?", "</#>", ml, Log.LOX);
LOG_CHECK(",", "</#>", ml, Log.LOX);
LOG_CHECK("-", "</->", ml, Log.LOX);
LOG_CHECK("_", "</_>", ml, Log.LOX);
LOG_CHECK("@", "</@>", ml, Log.LOX);
LOG_CHECK(".", "</>", ml, Log.LOX);
LOG_CHECK("..", "</>", ml, Log.LOX);
LOG_CHECK("CU..", "</CU##>", ml, Log.LOX);
LOG_CHECK("$%! ", "</####>", ml, Log.LOX);
Log.SetDomain("METH", Scope.Filename);
LOG_CHECK("$%! ", "</METH/####>", ml, Log.LOX);
Log.SetDomain("A\"C", Scope.Filename);
LOG_CHECK("", "</A#C>", ml, Log.LOX);
LOG_CHECK("LOC", "</A#C/LOC>", ml, Log.LOX);
LOG_CHECK("*X*", "</A#C/#X#>", ml, Log.LOX);
Log.RemoveLogger(ml);
}
public void Log_IllegalDomainNames()
{
UT_INIT();
Log.AddDebugLogger();
MemoryLogger ml= new MemoryLogger();
Log.SetVerbosity ( ml, Verbosity.Verbose );
ml.MetaInfo.Format._()._("<%D>");
Log.SetVerbosity(Log.DebugLogger, Verbosity.Verbose, ALox.InternalDomains );
LOG_CHECK( "" , "</>" , ml,Log.LOX);
LOG_CHECK( "LOC" , "</LOC>" , ml,Log.LOX);
LOG_CHECK( "%" , "</#>" , ml,Log.LOX);
LOG_CHECK( "\x03" , "</#>" , ml,Log.LOX);
LOG_CHECK( "<" , "</#>" , ml,Log.LOX);
LOG_CHECK( ">" , "</#>" , ml,Log.LOX);
LOG_CHECK( "?" , "</#>" , ml,Log.LOX);
LOG_CHECK( "," , "</#>" , ml,Log.LOX);
LOG_CHECK( "-" , "</->" , ml,Log.LOX);
LOG_CHECK( "_" , "</_>" , ml,Log.LOX);
LOG_CHECK( "@" , "</@>" , ml,Log.LOX);
LOG_CHECK( "." , "</>" , ml,Log.LOX);
LOG_CHECK( ".." , "</>" , ml,Log.LOX);
LOG_CHECK( "CU.." , "</CU##>" , ml,Log.LOX);
LOG_CHECK( "$%! " , "</####>" , ml,Log.LOX);
Log.SetDomain( "METH", Scope.Filename );
LOG_CHECK( "$%! " , "</METH/####>" , ml,Log.LOX);
Log.SetDomain( "A\"C" , Scope.Filename );
LOG_CHECK( "" , "</A#C>" , ml,Log.LOX);
LOG_CHECK( "LOC" , "</A#C/LOC>" , ml,Log.LOX);
LOG_CHECK( "*X*" , "</A#C/#X#>" , ml,Log.LOX);
Log.RemoveLogger( ml );
}
static CDRLogger()
{
string IniPath = CDR.DB_Helper.FingerprintIniFile;
if (System.IO.File.Exists(IniPath))
{
try
{
CDR.Ini.IniFile ini = new CDR.Ini.IniFile(IniPath);
EMail_Automatisering = ini.IniReadValue("Mail", "EMail", EMail_Automatisering);
SMTPServer = ini.IniReadValue("Mail", "SMTPServer", SMTPServer);
}
catch { }
}
// Gebruik eigen formatter
BitFactory.Logging.Logger.DefaultFormatterClass = typeof(LogEntryCDRFormatter);
// We gebruiken de application naam als filename voor het log bestand.
filename = String.Format(".\\{0}.log", System.Reflection.Assembly.GetExecutingAssembly().GetName().Name);
if (File.Exists(filename))
{
// We voegen info toe om te vertellen dat dit een nieuwe restart is van de applicatie
using (StreamWriter w = File.AppendText(filename))
{
w.WriteLine();
w.WriteLine(String.Format("Application started at {0:yyyy-MM-dd HH:mm:ss.fff}", DateTime.Now));
w.WriteLine();
} //using
} //if file exists
Logger = new CompositeLogger();
// voeg altijd memory logger toe
memoryLogger = new MemoryLogger(1000); // capacity van 1000 regels maximaal daarna worden de oude overschreven
Logger.AddLogger("MemoryLogger", memoryLogger);
fileLogger = new FileLogger(filename);
Logger.AddLogger("FileLogger", fileLogger);
}
public VelocityTransform(IContext context, IReader reader) : base(context, context.Field.Type)
{
VelocityInitializer.Init();
var fileBasedTemplate = context.Process.Templates.FirstOrDefault(t => t.Name == context.Transform.Template);
if (fileBasedTemplate != null)
{
var memoryLogger = new MemoryLogger();
context.Transform.Template = reader.Read(fileBasedTemplate.File, null, memoryLogger);
if (memoryLogger.Errors().Any())
{
foreach (var error in memoryLogger.Errors())
{
context.Error(error);
}
}
}
_input = MultipleInput();
_templateName = Context.Field.Alias + " Template";
}
public void ShouldNotMoveWhenWorkerIsAlreadyWorking()
{
MemoryLogger logger;
MoverModule module;
IWorkerModule workerModule;
ITaskModule taskModule;
workerModule = new MockedWorkerModule(false, new Worker()
{
WorkerID = 1, PlanetID = 1
});
taskModule = new MockedTaskModule(false, new Task()
{
WorkerID = 1
});
logger = new MemoryLogger();
module = new MoverModule(logger, taskModule, workerModule, null);
Assert.ThrowsException <PIOInvalidOperationException>(() => module.BeginMoveTo(1, 1, 1));
Assert.IsNotNull(logger.Logs.FirstOrDefault(item => (item.Level == LogLevels.Warning) && (item.ComponentName == module.ModuleName)));
}
public void Tut_HierDom()
{
UT_INIT();
Log.SetVerbosity(tutLog = new MemoryLogger("Tutlog"), Verbosity.Verbose);
//! [Tut_DomainsHierarchical]
Log.AddDebugLogger();
Log.SetVerbosity(Log.DebugLogger, Verbosity.Verbose); // the default anyhow
//...
Log.Info("UI/MOUSE", "A mouse click");
//...
Log.Verbose("UI/MOUSE", "Somebody moved the mouse!");
//...
//...
Log.Info("UI/DLG", "About dialog opend");
//...
Log.Verbose("UI/DLG", "About dialog, link to product page pressed.");
//...
//! [Tut_DomainsHierarchical]
#if (ALOX_DBG_LOG || ALOX_REL_LOG)
SaveTutorialOutput("Tut_DomainsHierarchical.txt", tutLog.MemoryLog);
tutLog.MemoryLog.Clear(); tutLog.CntLogs = 0;
Log.RemoveDebugLogger();
#endif
//! [Tut_DomainsHierarchical_2]
Log.SetVerbosity(Log.DebugLogger, Verbosity.Warning, "UI"); // Always sets all sub-domains!
//! [Tut_DomainsHierarchical_2]
//! [Tut_DomainsHierarchical_3]
Log.SetVerbosity(Log.DebugLogger, Verbosity.Warning, "UI"); // First set parent...
Log.SetVerbosity(Log.DebugLogger, Verbosity.Verbose, "UI/MOUSE"); // ...then children!
//! [Tut_DomainsHierarchical_3]
Log.RemoveLogger(tutLog);
}
public void TestPlace()
{
var logger = new MemoryLogger(LogLevel.Debug);
var process = GetTestProcess("google-place");
if (process.Errors().Any())
{
foreach (var error in process.Errors())
{
Console.WriteLine(error);
}
throw new Exception("The configuration has errors");
}
var input = new MasterRow(process.GetAllFields().Count());
var address = process.Entities.First().Fields.First(f => f.Name == "Address");
var latitude = process.Entities.First().CalculatedFields.First(f => f.Name == "Latitude");
var longitude = process.Entities.First().CalculatedFields.First(f => f.Name == "Longitude");
var formattedAddress = process.Entities.First().CalculatedFields.First(f => f.Name == "FormattedAddress");
var place = process.Entities.First().CalculatedFields.First(f => f.Name == "PlaceId");
input[address] = "1009 Broad St Joseph Michigan 49085";
input[latitude] = null;
input[longitude] = null;
input[formattedAddress] = null;
var context = new PipelineContext(logger, process, process.Entities.First(), address, address.Transforms.First());
using (var gt = new PlaceTransform(context)) {
var output = gt.Operate(input);
Assert.AreEqual("1009 Broad St Joseph 49085", output[address]);
Assert.AreEqual("ChIJsxyoG5_GEIgRMN8IWvngddA", output[place]);
Assert.IsNotNull(output[latitude]);
Assert.IsNotNull(output[longitude]);
Assert.IsNotNull(output[formattedAddress]);
}
}
public void ShouldNotifySubscribers()
{
MemoryLogger logger;
TaskCallbackService module;
MockedCallback callback;
MockedSchedulerModule mockedSchedulerModule;
logger = new MemoryLogger();
mockedSchedulerModule = new MockedSchedulerModule(false);
callback = new MockedCallback(false);
module = new TaskCallbackService(logger, mockedSchedulerModule);
Assert.IsTrue(module.Subscribe(callback));
Assert.AreEqual(0, callback.StartedCount);
mockedSchedulerModule.InvokeTaskStarted();
Assert.AreEqual(1, callback.StartedCount);
Assert.AreEqual(0, callback.EndedCount);
mockedSchedulerModule.InvokeTaskEnded();
Assert.AreEqual(1, callback.EndedCount);
}
public void ShouldNotEndTaskWhenWorkerDoesntExists()
{
MemoryLogger logger;
MoverModule module;
IBuildingModule buildingModule;
IWorkerModule workerModule;
ITaskModule taskModule;
logger = new MemoryLogger();
buildingModule = new MockedBuildingModule(false, new Building()
{
BuildingID = 3, X = 1, Y = 1
});
workerModule = new MockedWorkerModule(false, new Worker()
{
WorkerID = 1, PlanetID = 1
});
taskModule = new MockedTaskModule(false);
module = new MoverModule(logger, taskModule, workerModule, buildingModule);
Assert.ThrowsException <PIONotFoundException>(() => module.BeginMoveTo(2, 2, 2));
Assert.IsNotNull(logger.Logs.FirstOrDefault(item => (item.Level == LogLevels.Warning) && (item.ComponentName == module.ModuleName)));
}
/** ********************************************************************************************
* Log_TextLogger_FormatConfig
**********************************************************************************************/
void testFormatConfig( String testFormat,
String expFmt,
String expFmtError = null,
String expFmtWarning = null,
String expFmtInfo = null,
String expFmtVerbose = null
)
{
Variable var= new Variable();
var.Define(ALox.ConfigCategoryName, "TESTML_FORMAT", ',').Store( testFormat );
Lox lox= new Lox("TEST");
MemoryLogger ml= new MemoryLogger("TESTML");
lox.SetVerbosity( ml, Verbosity.Info );
lox.RemoveLogger( ml );
ALox.Register( lox, ContainerOp.Remove );
UT_EQ( expFmt , ml.MetaInfo.Format );
if( expFmtError != null ) { UT_EQ( expFmtError , ml.MetaInfo.VerbosityError ); }
if( expFmtWarning!= null ) { UT_EQ( expFmtWarning, ml.MetaInfo.VerbosityWarning ); }
if( expFmtInfo != null ) { UT_EQ( expFmtInfo , ml.MetaInfo.VerbosityInfo ); }
if( expFmtVerbose!= null ) { UT_EQ( expFmtVerbose, ml.MetaInfo.VerbosityVerbose ); }
}
public void Log_ColorsAndStyles()
{
UT_INIT();
Log.AddDebugLogger();
Log.SetDomain( "COLORS", Scope.Method );
#if ALOX_DBG_LOG
MemoryLogger ml= new MemoryLogger();
Log.SetVerbosity( ml, Verbosity.Verbose, "/" );
#endif
Log.SetVerbosity( Log.DebugLogger, Verbosity.Verbose, "/" );
Log.Info ( "Playing with colors. Depending on the test environment, the colors might "
+"be visible or not" );
Log.Info ( "In the memory logger, all color/style codes have to disappear (by default)" );
Log.Verbose( "A verbose message" );
Log.Info ( "An info message" );
Log.Warning( "A warning message" );
Log.Error ( "An error message" );
#if ALOX_DBG_LOG
int mlPos= ml.MemoryLog.IndexOf("/COLORS" );
UT_TRUE( mlPos > 0 );
mlPos+= 8;
#endif
Log.Info( "FG Colors: "
+ ">>>" + ESC.RED + "RED" + ESC.FG_RESET + "<<<"
+ ">>>" + ESC.GREEN + "GREEN" + ESC.FG_RESET + "<<<"
+ ">>>" + ESC.BLUE + "BLUE" + ESC.FG_RESET + "<<<"
+ ">>>" + ESC.CYAN + "CYAN" + ESC.FG_RESET + "<<<"
+ ">>>" + ESC.MAGENTA + "MAGENTA" + ESC.FG_RESET + "<<<"
+ ">>>" + ESC.YELLOW + "YELLOW" + ESC.FG_RESET + "<<<"
+ ">>>" + ESC.GRAY + "GRAY" + ESC.FG_RESET + "<<<"
+ ">>>" + ESC.WHITE + "WHITE" + ESC.FG_RESET + "<<<"
+ ">>>" + ESC.BLACK + "BLACK" + ESC.FG_RESET + "<<<"
);
#if ALOX_DBG_LOG
UT_TRUE( ml.MemoryLog.IndexOf("\x1B") < 0 ); ml.MemoryLog.Clear();
#endif
Log.Info( "BG Colors: "
+ ">>>" + ESC.BG_RED + "RED" + ESC.BG_RESET + "<<<"
+ ">>>" + ESC.BG_GREEN + "GREEN" + ESC.BG_RESET + "<<<"
+ ">>>" + ESC.BG_BLUE + "BLUE" + ESC.BG_RESET + "<<<"
+ ">>>" + ESC.BG_CYAN + "CYAN" + ESC.BG_RESET + "<<<"
+ ">>>" + ESC.BG_MAGENTA + "MAGENTA" + ESC.BG_RESET + "<<<"
+ ">>>" + ESC.BG_YELLOW + "YELLOW" + ESC.BG_RESET + "<<<"
+ ">>>" + ESC.BG_GRAY + "GRAY" + ESC.BG_RESET + "<<<"
+ ">>>" + ESC.BG_WHITE + "WHITE" + ESC.BG_RESET + "<<<"
+ ">>>" + ESC.BG_BLACK + "BLACK" + ESC.BG_RESET + "<<<"
);
#if ALOX_DBG_LOG
UT_TRUE( ml.MemoryLog.IndexOf("\x1B") < 0 ); ml.MemoryLog.Clear();
#endif
Log.Info( "FG/BG same: "
+ ">>>" + ESC.RED + ESC.BG_RED + "RED" + ESC.RESET + "<<<"
+ ">>>" + ESC.GREEN + ESC.BG_GREEN + "GREEN" + ESC.RESET + "<<<"
+ ">>>" + ESC.BLUE + ESC.BG_BLUE + "BLUE" + ESC.RESET + "<<<"
+ ">>>" + ESC.CYAN + ESC.BG_CYAN + "CYAN" + ESC.RESET + "<<<"
+ ">>>" + ESC.MAGENTA + ESC.BG_MAGENTA + "MAGENTA" + ESC.RESET + "<<<"
+ ">>>" + ESC.YELLOW + ESC.BG_YELLOW + "YELLOW" + ESC.RESET + "<<<"
+ ">>>" + ESC.GRAY + ESC.BG_GRAY + "GRAY" + ESC.RESET + "<<<"
+ ">>>" + ESC.WHITE + ESC.BG_WHITE + "WHITE" + ESC.RESET + "<<<"
+ ">>>" + ESC.BLACK + ESC.BG_BLACK + "BLACK" + ESC.RESET + "<<<"
);
#if ALOX_DBG_LOG
AnsiConsoleLogger acl= (AnsiConsoleLogger) Log.GetLogger( "ANSI_CONSOLE" );
ColorConsoleLogger ccl= (ColorConsoleLogger) Log.GetLogger( "COLORCONSOLE" );
if ( acl!=null ) acl.IsBackgroundLight= !acl.IsBackgroundLight;
if ( ccl!=null ) ccl.IsBackgroundLight= !ccl.IsBackgroundLight;
#endif
Log.Info( "Same rev.: "
+ ">>>" + ESC.RED + ESC.BG_RED + "RED" + ESC.RESET + "<<<"
+ ">>>" + ESC.GREEN + ESC.BG_GREEN + "GREEN" + ESC.RESET + "<<<"
+ ">>>" + ESC.BLUE + ESC.BG_BLUE + "BLUE" + ESC.RESET + "<<<"
+ ">>>" + ESC.CYAN + ESC.BG_CYAN + "CYAN" + ESC.RESET + "<<<"
+ ">>>" + ESC.MAGENTA + ESC.BG_MAGENTA + "MAGENTA" + ESC.RESET + "<<<"
+ ">>>" + ESC.YELLOW + ESC.BG_YELLOW + "YELLOW" + ESC.RESET + "<<<"
+ ">>>" + ESC.GRAY + ESC.BG_GRAY + "GRAY" + ESC.RESET + "<<<"
+ ">>>" + ESC.WHITE + ESC.BG_WHITE + "WHITE" + ESC.RESET + "<<<"
+ ">>>" + ESC.BLACK + ESC.BG_BLACK + "BLACK" + ESC.RESET + "<<<"
);
#if ALOX_DBG_LOG
if ( acl!=null ) acl.IsBackgroundLight= !acl.IsBackgroundLight;
if ( ccl!=null ) ccl.IsBackgroundLight= !ccl.IsBackgroundLight;
#endif
#if ALOX_DBG_LOG
Log.Verbose( ml.MemoryLog.ToString( mlPos ) );
UT_TRUE( ml.MemoryLog.IndexOf("\x1B") < 0 ); ml.MemoryLog.Clear();
#endif
Log.Info( "Reset FG/BG: "
+ ESC.BG_RED + "BG RED"
+ ESC.GREEN + "FG REEN"
+ ESC.FG_RESET + "FG Reset"
+ ESC.BG_RESET + "BG Reset"
);
#if ALOX_DBG_LOG
Log.Verbose( ml.MemoryLog.ToString( mlPos ) );
UT_TRUE( ml.MemoryLog.IndexOf("\x1B") < 0 ); ml.MemoryLog.Clear();
#endif
Log.Info( "Reset FG/BG: "
+ ESC.BG_RED + "BG RED"
+ ESC.GREEN + "FG REEN"
+ ESC.BG_RESET + "BG Reset"
+ ESC.FG_RESET + "FG Reset"
);
#if ALOX_DBG_LOG
Log.Verbose( ml.MemoryLog.ToString( mlPos ) );
UT_TRUE( ml.MemoryLog.IndexOf("\x1B") < 0 ); ml.MemoryLog.Clear();
#endif
Log.Info( "Reset FG/BG: "
+ ESC.BG_RED + "BG RED"
+ ESC.GREEN + "FG REEN"
+ ESC.RESET + "All Reset"
);
#if ALOX_DBG_LOG
Log.Verbose( ml.MemoryLog.ToString( mlPos ) );
UT_TRUE( ml.MemoryLog.IndexOf("\x1B") < 0 ); ml.MemoryLog.Clear();
#endif
Log.Info( "Styles: "
+ ">>>" + ESC.BOLD + "Bold" + ESC.STYLE_RESET + "<<<"
+ ">>>" + ESC.ITALICS + "Italics" + ESC.STYLE_RESET + "<<<"
+ ">>>" + ESC.BOLD
+ ">>>" + ESC.ITALICS + "Bold/Italics" + ESC.STYLE_RESET + "+< Styles do not work in Windows consoles"
);
#if ALOX_DBG_LOG
Log.Verbose( ml.MemoryLog.ToString( mlPos ) );
UT_TRUE( ml.MemoryLog.IndexOf("\x1B") < 0 ); ml.MemoryLog.Clear();
#endif
Log.Info( "Reset Style/FG/BG: "
+ ESC.BOLD + "Bold"
+ ESC.BG_RED + "BG RED"
+ ESC.GREEN + "FG REEN"
+ ESC.BG_RESET + "BG Reset"
+ ESC.FG_RESET + "FG Reset"
+ ESC.STYLE_RESET + "Style Reset"
);
#if ALOX_DBG_LOG
Log.Verbose( ml.MemoryLog.ToString( mlPos ) );
UT_TRUE( ml.MemoryLog.IndexOf("\x1B") < 0 ); ml.MemoryLog.Clear();
#endif
Log.Info( "Reset Style/FG/BG: "
+ ESC.BOLD + "Bold"
+ ESC.BG_RED + "BG RED"
+ ESC.GREEN + "FG REEN"
+ ESC.RESET + "Reset All"
);
#if ALOX_DBG_LOG
Log.Verbose( ml.MemoryLog.ToString( mlPos ) );
UT_TRUE( ml.MemoryLog.IndexOf("\x1B") < 0 ); ml.MemoryLog.Clear();
#endif
Log.Info( "Reset Style/FG/BG: "
+ ESC.BOLD + "Bold"
+ ESC.BG_RED + "BG RED"
+ ESC.GREEN + "FG REEN"
+ ESC.STYLE_RESET + "Style Reset"
+ ESC.BG_RESET + "BG Reset"
+ ESC.FG_RESET + "FG Reset"
+ " +< This does not work on ANSI terminals: Styl reset, resets ALL here"
);
#if ALOX_DBG_LOG
Log.Verbose( ml.MemoryLog.ToString( mlPos ) );
UT_TRUE( ml.MemoryLog.IndexOf("\x1B") < 0 ); ml.MemoryLog.Clear();
#endif
Log.Info( "An URL: "
+ ESC.URL_START + "www.darwin.heaven"
+ ESC.URL_END + ", your resource for happyness!"
);
#if ALOX_DBG_LOG
Log.Verbose( ml.MemoryLog.ToString( mlPos ) );
UT_TRUE( ml.MemoryLog.IndexOf("\x1B") < 0 ); ml.MemoryLog.Clear();
#endif
}
public void Tut_LogData()
{
UT_INIT();
Log.AddDebugLogger();
Log.SetVerbosity( tutLog= new MemoryLogger( "Tutlog" ), Verbosity.Verbose );
Log.SetVerbosity( Log.DebugLogger, Verbosity.Verbose, ALox.InternalDomains );
// access without prior setting
{
Log.Info( "Working on file version " + Log.Retrieve( "FILE_VERSION" ).IntegerValue );
SaveTutorialOutput( "Tut_LogData2.txt", tutLog.MemoryLog );
tutLog.MemoryLog.Clear();
}
FileIO fileIo = new FileIO();
fileIo.Read( "myfile.dat" );
//! [Tut_LogData_2]
Log.Info( "Working on file version " + Log.Retrieve( "FILE_VERSION" ).IntegerValue );
//! [Tut_LogData_2]
SaveTutorialOutput( "Tut_LogData.txt", tutLog.MemoryLog );
Log.RemoveDebugLogger();
Log.RemoveLogger( "MEMORY" );
}
public void Tut_UsingLogBuffer()
{
#if ALOX_DBG_LOG || ALOX_REL_LOG
UT_INIT();
Log.SetVerbosity( tutLog= new MemoryLogger( "Tutlog" ), Verbosity.Verbose );
//! [Tut_UsingLogBuffer1]
// Create logger and register domain LOGBUF
Log.AddDebugLogger();
Log.SetDomain( "LOGBUF", Scope.Method );
// Let's do some logging using the internal buffer singleton;
Log.Info( Log.Buf()._( "Hello Buf!. This is only one string. Not useful to use the buf, however..." ) );
Log.Info( Log.Buf()._( "This is a 5-digtit rep of 42: " )._( 42, 5 ) );
Log.Info( Log.Buf()._( "***All upper case and stars replaced by dollar signs ***" )
.ToUpper()
.SearchAndReplaceAll( "*", "$" )
);
//! [Tut_UsingLogBuffer1]
//! [Tut_UsingLogBuffer2]
// using the log buf outside of the <em>Log Statement</em>
#if ALOX_DBG_LOG
AString logBuf= Log.Buf();
logBuf._( "Lets see if school math is correct: " );
int a= 4;
int b= 2;
if( a/b == 3)
{
// shout it out loud!
logBuf._( "They taught me wrong in school!" );
Log.Error( logBuf );
}
else
{
// we better say nothing
Log.BufAbort();
}
#endif
//! [Tut_UsingLogBuffer2]
Report.GetDefault().PushHaltFlags( false, false );
//! [Tut_UsingLogBuffer3]
// causing trouble
Log.Info( "Let's create an internal error by accessing the buffer twice:" );
Log.Buf();
Log.Buf();
//! [Tut_UsingLogBuffer3]
Report.GetDefault().PopHaltFlags();
tutLog.MemoryLog.SearchAndReplace( "Tutlog", "CONSOLE" );
SaveTutorialOutput( "Tut_UsingLogBuffer.txt", tutLog.MemoryLog );
#endif
}
public void Log_ObjectConverter()
{
UT_INIT();
Log.AddDebugLogger();
Log.SetDomain( "OBJECT_CONV", Scope.Method );
MemoryLogger ml= new MemoryLogger();
ml.MetaInfo.Format._();
Log.SetVerbosity( ml, Verbosity.Verbose );
StringConverter mainConverter= (StringConverter) ml.ObjectConverters[0];
// test without my converter
MyType mytype= new MyType();
Log.Info( "Test" ); UT_TRUE( ml.MemoryLog.IndexOf( "Test" ) >= 0 ); ml.MemoryLog._();
Log.Info( null ); UT_TRUE( ml.MemoryLog.IndexOf( mainConverter.FmtNullObject ) >= 0 ); ml.MemoryLog._();
Log.Info( mytype ); UT_EQ ( mytype.ToString(), ml.MemoryLog ); ml.MemoryLog._();
Log.Info( null ); UT_EQ ( mainConverter.FmtNullObject, ml.MemoryLog ); ml.MemoryLog._();
// test without my converter
ml.ObjectConverters.Add( new MyObjectConverter() );
Log.DebugLogger.ObjectConverters.Add( new MyObjectConverter() );
Log.Info( "Test" ); UT_TRUE( ml.MemoryLog.IndexOf( "Test" ) >= 0 ); ml.MemoryLog._();
Log.Info( null ); UT_EQ ( "MyObjectConverter: null" , ml.MemoryLog ); ml.MemoryLog._();
Log.Info( mytype ); UT_EQ( "my type" , ml.MemoryLog ); ml.MemoryLog._();
// cleanup
Log.RemoveLogger( ml );
Log.RemoveDebugLogger();
}
public void Tut_Prefix()
{
UT_INIT();
Log.SetVerbosity( tutLog= new MemoryLogger( "Tutlog" ), Verbosity.Verbose );
Log.AddDebugLogger();
//! [Tut_Prefix]
Log.SetPrefix( "ALOX TUTORIAL: ", Scope.Method );
Log.Info( "Well, just a sample" );
//! [Tut_Prefix]
#if (ALOX_DBG_LOG || ALOX_REL_LOG)
SaveTutorialOutput( "Tut_Prefix.txt", tutLog.MemoryLog );
#endif
//! [Tut_Prefix_2]
Log.SetPrefix( ESC.BG_MAGENTA, Scope.Filename );
//! [Tut_Prefix_2]
Log.Warning( "magenta" );
Log.RemoveLogger( tutLog );
}
public void Log_Multiline()
{
#if ALOX_DBG_LOG || ALOX_REL_LOG
UT_INIT();
Log.AddDebugLogger();
MemoryLogger ml= new MemoryLogger();
Log.SetDomain( "/MLine", Scope.Method );
Log.SetVerbosity( Log.DebugLogger, Verbosity.Verbose, "/MLine" );
Log.SetVerbosity( ml, Verbosity.Verbose, "/MLine" );
Log.DebugLogger.MultiLineMsgMode= 0;
Log.Info( "" );
Log.Info( "-------- ML Mode = 0 (single line) --------" );
Log.State( "MLine", Verbosity.Info, "Our Log configuration is:" );
Log.DebugLogger.MultiLineMsgMode= 0;
Log.DebugLogger.MultiLineDelimiterRepl= "~|~";
Log.Info( "" );
Log.Info( "-------- ML Mode = 0 (single line) with delimiter replacement set to ~|~ --------" );
Log.State( "MLine", Verbosity.Info, "Our Log configuration is:" );
Log.DebugLogger.MultiLineMsgMode= 0;
Log.DebugLogger.MultiLineDelimiter= "";
Log.Info( "" );
Log.Info( "-------- ML Mode = 0 (single line) with delimiter set to \"\" (stops multi line processing) --------" );
Log.State( "MLine", Verbosity.Info, "Our Log configuration is:" );
Log.DebugLogger.MultiLineMsgMode= 1;
Log.Info( "" );
Log.Info( "-------- ML Mode = 1 (multi line, all meta info per line) --------" );
Log.State( "MLine", Verbosity.Info, "Our Log configuration is:" );
Log.DebugLogger.MultiLineMsgMode= 2;
Log.Info( "" );
Log.Info( "-------- ML Mode = 2 (multi line, meta info blanked) --------" );
Log.State( "MLine", Verbosity.Info, "Our Log configuration is:" );
Log.DebugLogger.MultiLineMsgMode= 3;
Log.Info( "" );
Log.Info( "-------- ML Mode = 3 (multi line, print headline with info, text starts at pos 0) --------" );
Log.State( "MLine", Verbosity.Info, "Our Log configuration is:" );
Log.DebugLogger.MultiLineMsgMode= 4;
Log.Info( "" );
Log.Info( "-------- ML Mode = 4 (pure multi line, no meta info, no headline, starts at pos 0)) --------" );
Log.State( "MLine", Verbosity.Info, "Our Log configuration is:" );
#endif
}
public void NameShouldReturnBaseName()
{
const string PlayerName = "тест";
var logger = new MemoryLogger();
var playerMock = new Mock<IPlayer>();
playerMock.SetupGet(x => x.Name).Returns(PlayerName);
var playerWithLogger = new PlayerWithLoggerDecorator(playerMock.Object, logger);
Assert.AreEqual(PlayerName, playerWithLogger.Name);
}
static CS_Manual()
{
CS_Manual.memLog = new MemoryLogger();
memLog.MetaInfo.Format._()._( "%SF(%SL):%SM()%A3%V[%D]: " );
}
public void Tut_Verbosity()
{
UT_INIT();
Log.SetVerbosity( tutLog= new MemoryLogger( "Tutlog" ), Verbosity.Verbose );
//! [Tut_Verbosity]
Log.AddDebugLogger();
Log.Error ( "A severe error happened :-(" );
Log.Warning( "This is a warning :-/ Maybe an error follows?" );
Log.Info ( "Just for your further information!" );
Log.Verbose( "Today, I am in the mood to talk..." );
//! [Tut_Verbosity]
//! [Tut_Verbosity_SetVerbosity]
Log.SetVerbosity( Log.DebugLogger, Verbosity.Warning );
//! [Tut_Verbosity_SetVerbosity]
//! [Tut_Verbosity_SetVerbosity_2]
Log.SetVerbosity( "DEBUG_LOGGER", Verbosity.Warning );
//! [Tut_Verbosity_SetVerbosity_2]
#if (ALOX_DBG_LOG || ALOX_REL_LOG)
SaveTutorialOutput( "Tut_Verbosity.txt", tutLog.MemoryLog );
tutLog.MemoryLog.Clear(); tutLog.CntLogs= 0;
Log.SetVerbosity( tutLog, Verbosity.Warning);
#endif
Log.RemoveDebugLogger();
//! [Tut_Verbosity_2]
Log.AddDebugLogger();
Log.SetVerbosity( Log.DebugLogger, Verbosity.Warning );
Log.Error ( "A severe error happened :-(" );
Log.Warning( "This is a warning :-/ Maybe an error follows?" );
Log.Info ( "Just for your further information!" );
Log.Verbose( "Today, I am in the mood to talk..." );
//! [Tut_Verbosity_2]
#if (ALOX_DBG_LOG || ALOX_REL_LOG)
SaveTutorialOutput( "Tut_Verbosity_2.txt", tutLog.MemoryLog );
#endif
Log.RemoveLogger( tutLog );
}
public void Tut_Hello_ALox()
{
UT_INIT();
//! [Tut_ALox_Logger_1]
Log.AddDebugLogger();
//! [Tut_ALox_Logger_1]
Log.RemoveDebugLogger();
Log.SetVerbosity( tutLog= new MemoryLogger( "Tutlog" ), Verbosity.Verbose );
//! [Tut_ALox_Logger_2]
Log.AddDebugLogger();
Log.Info( "Hello ALox" );
//! [Tut_ALox_Logger_2]
#if (ALOX_DBG_LOG || ALOX_REL_LOG)
SaveTutorialOutput( "Tut_ALox_Logger.txt", tutLog.MemoryLog );
#endif
}
public void StartRoundShouldAddToLoggerAndCallBaseMethod()
{
var logger = new MemoryLogger();
var playerMock = new Mock<IPlayer>();
var playerWithLogger = new PlayerWithLoggerDecorator(playerMock.Object, logger);
var card = new Card(CardSuit.Diamond, CardType.King);
var cards = new List<Card> { card };
var trumpCard = new Card(CardSuit.Club, CardType.Ace);
playerWithLogger.StartRound(cards, trumpCard, 1, 4);
Assert.IsTrue(logger.ToString().Length > 0);
Assert.IsTrue(logger.ToString().Contains(card.ToString()));
Assert.IsTrue(logger.ToString().Contains(trumpCard.ToString()));
playerMock.Verify(x => x.StartRound(cards, trumpCard, 1, 4), Times.Once());
}
public static void PerformanceTestRL()
{
// create a lox for release logging
Lox lox= new Lox( "ReleaseLox" );
TextLogger relLogger= Lox.CreateConsoleLogger();
MemoryLogger ml = new MemoryLogger();
lox.SetVerbosity( relLogger, Verbosity.Verbose, "/CON" );
lox.SetVerbosity( ml , Verbosity.Verbose, "/MEM" );
lox.Info( "/CON", "Logging simple info lines into a memory logger" );
AString msgBuf= new AString( );
long fastest= long.MaxValue;
Ticks timer= new Ticks();
int qtyLines= 100;
int qtyLoops= 1000;
if( System.Diagnostics.Debugger.IsAttached )
qtyLines= qtyLoops= 10;
for ( int i= 0 ; i < qtyLoops ; i++ )
{
#if ALOX_DBG_LOG || ALOX_REL_LOG
ml.MemoryLog.Clear();
#endif
timer.Set();
for ( int ii= 0 ; ii < qtyLines ; ii++ )
{
lox.Info( "/MEM", "Test Line" );
if( i== 0 && ii == 0) Console.WriteLine( ml.MemoryLog.ToString() );
}
long t= timer.Age().Raw();
if ( fastest > t )
{
fastest= t;
lox.Info( "/CON", msgBuf.Clear()._( "Pass " )._( i, 3)._( " is new fastest: ")
._( (int) (new Ticks( fastest)).InMicros(), 0)
._( " micros per ")._(qtyLines)._(" logs.") );
}
}
double microsPerLog= ( (double) (new Ticks(fastest)).InMicros() ) / qtyLines;
int logsPerSecond= (int)( 1000000.0 / microsPerLog);
lox.Info( "/CON", msgBuf._()._( " " )._( ESC.MAGENTA )._( "Fastest Release Logging: " )
._( microsPerLog )._( " micros per log (resp " )
._( logsPerSecond )._( " logs per second) " ) );
lox.RemoveLogger( ml );
lox.RemoveLogger( relLogger );
}
public void Tut_Instance()
{
#if ALOX_DBG_LOG || ALOX_REL_LOG
UT_INIT();
Log.SetVerbosity( new ConsoleLogger(), Verbosity.Verbose, "/" );
Log.SetVerbosity( tutLog= new MemoryLogger( "Tutlog" ), Verbosity.Verbose, "/" );
tutLog.MultiLineMsgMode= 4;
//! [Tut_Instance]
// Log multi-lines without meta info
#if ALOX_DBG_LOG
((TextLogger) Log.GetLogger( "Console" )).MultiLineMsgMode= 4;
#endif
// Log current thread instance
LogTools.Instance( "MYDOM", Verbosity.Info, Thread.CurrentThread, 2, "Actual Thread: " );
//! [Tut_Instance]
// cut the output to 30 lines
int lines= 32;
int idx= 0;
while (lines-- != 0)
{
idx= tutLog.MemoryLog.IndexOf( Environment.NewLine, idx + Environment.NewLine.Length );
if ( idx < 0 )
break;
}
if (idx > 0)
tutLog.MemoryLog.SetLength( idx + Environment.NewLine.Length );
tutLog.MemoryLog._( "..." )._( Environment.NewLine );
tutLog.MemoryLog._( "..." )._( Environment.NewLine );
tutLog.MemoryLog._( "..." )._( Environment.NewLine );
SaveTutorialOutput( "Tut_Instance.txt", tutLog.MemoryLog );
#endif
}
public void StartGameShouldAddToLoggerAndCallBaseMethod()
{
const string OtherPlayerIdentifier = "тест";
var logger = new MemoryLogger();
var playerMock = new Mock<IPlayer>();
var playerWithLogger = new PlayerWithLoggerDecorator(playerMock.Object, logger);
playerWithLogger.StartGame(OtherPlayerIdentifier);
Assert.IsTrue(logger.ToString().Length > 0);
Assert.IsTrue(logger.ToString().Contains(OtherPlayerIdentifier));
playerMock.Verify(x => x.StartGame(It.IsAny<string>()), Times.Once());
}
public void Tut_Exception()
{
#if ALOX_DBG_LOG || ALOX_REL_LOG
UT_INIT();
Log.SetVerbosity( tutLog= new MemoryLogger( "Tutlog" ), Verbosity.Warning, "/" );
#if ALOX_DBG_LOG
((TextLogger) Log.GetLogger( "Tutlog" )).MultiLineMsgMode= 4;
#endif
//! [Tut_Exceptions]
Exception testException= new Exception( "TestException Message",
new Exception ( "InnerException Message",
new Exception("Inner, inner Exception") ) );
LogTools.Exception( "MYDOM", Verbosity.Warning, testException, "Logging an exception: " );
//! [Tut_Exceptions]
tutLog.MemoryLog.SearchAndReplace( "Tutlog", "CONSOLE" );
SaveTutorialOutput( "Tut_Exceptions.txt", tutLog.MemoryLog );
#endif
}
public void Tut_Domains()
{
UT_INIT();
Log.SetVerbosity( tutLog= new MemoryLogger( "Tutlog" ), Verbosity.Verbose );
//! [Tut_Domains]
Log.AddDebugLogger();
Log.SetVerbosity( Log.DebugLogger, Verbosity.Verbose ); // the default anyhow
//...
Log.Verbose( "HTTP", "Connected" );
//...
//...
//...
Log.Verbose( "UI", "Somebody moved the mouse!" );
//...
//! [Tut_Domains]
#if (ALOX_DBG_LOG || ALOX_REL_LOG)
SaveTutorialOutput( "Tut_Domains.txt", tutLog.MemoryLog );
tutLog.MemoryLog.Clear(); tutLog.CntLogs= 0;
Log.RemoveDebugLogger();
#endif
Log.SetVerbosity( tutLog, Verbosity.Verbose, "HTTP" ); // our interest
Log.SetVerbosity( tutLog, Verbosity.Error, "UI" ); // only if ouch!
//! [Tut_Domains_2]
Log.AddDebugLogger();
Log.SetVerbosity( Log.DebugLogger, Verbosity.Verbose, "HTTP" ); // our interest
Log.SetVerbosity( Log.DebugLogger, Verbosity.Error, "UI" ); // only if ouch!
//...
Log.Verbose( "HTTP", "Connected" );
//...
//...
//...
Log.Verbose( "UI", "Somebody moved the mouse!" );
//...
//! [Tut_Domains_2]
#if (ALOX_DBG_LOG || ALOX_REL_LOG)
SaveTutorialOutput( "Tut_Domains_2.txt", tutLog.MemoryLog );
#endif
Log.RemoveLogger( tutLog );
}
public void Tut_XML()
{
#if ALOX_DBG_LOG || ALOX_REL_LOG
UT_INIT();
Log.SetVerbosity( tutLog= new MemoryLogger( "Tutlog" ), Verbosity.Verbose, "/" );
tutLog.MultiLineMsgMode= 4;
//! [Tut_XML]
String xmltext= "<MainTag>"
+"<SubTag>Hello ALox XML</SubTag>"
+"<SubTag2>"
+"<SubsubTag>A sub tags' string</SubsubTag>"
+"</SubTag2>"
+"</MainTag>";
XDocument xdoc= XDocument.Parse( xmltext );
LogTools.XML("MYDOM", Verbosity.Info, xdoc, "Logging an xml document: " );
//! [Tut_XML]
tutLog.MemoryLog.SearchAndReplace( "Tutlog", "CONSOLE" );
SaveTutorialOutput( "Tut_XML.txt", tutLog.MemoryLog );
#endif
}
void LOG_CHECK( String dom, String exp, MemoryLogger ml, Lox lox )
{
ml.MemoryLog._(); ml.AutoSizes.Reset();
lox.Info( dom, "" );
UT_EQ( exp , ml.MemoryLog );
}
public void Tut_HierDom()
{
UT_INIT();
Log.SetVerbosity( tutLog= new MemoryLogger( "Tutlog" ), Verbosity.Verbose );
//! [Tut_DomainsHierarchical]
Log.AddDebugLogger();
Log.SetVerbosity( Log.DebugLogger, Verbosity.Verbose ); // the default anyhow
//...
Log.Info ( "UI/MOUSE", "A mouse click" );
//...
Log.Verbose( "UI/MOUSE", "Somebody moved the mouse!" );
//...
//...
Log.Info ( "UI/DLG", "About dialog opend" );
//...
Log.Verbose( "UI/DLG", "About dialog, link to product page pressed." );
//...
//! [Tut_DomainsHierarchical]
#if (ALOX_DBG_LOG || ALOX_REL_LOG)
SaveTutorialOutput( "Tut_DomainsHierarchical.txt", tutLog.MemoryLog );
tutLog.MemoryLog.Clear(); tutLog.CntLogs= 0;
Log.RemoveDebugLogger();
#endif
//! [Tut_DomainsHierarchical_2]
Log.SetVerbosity( Log.DebugLogger, Verbosity.Warning, "UI" ); // Always sets all sub-domains!
//! [Tut_DomainsHierarchical_2]
//! [Tut_DomainsHierarchical_3]
Log.SetVerbosity( Log.DebugLogger, Verbosity.Warning, "UI" ); // First set parent...
Log.SetVerbosity( Log.DebugLogger, Verbosity.Verbose, "UI/MOUSE" ); // ...then children!
//! [Tut_DomainsHierarchical_3]
Log.RemoveLogger( tutLog );
}
public void Tut_ScopeDomains()
{
UT_INIT();
Log.SetVerbosity( tutLog= new MemoryLogger( "Tutlog" ), Verbosity.Verbose );
Log.AddDebugLogger();
TutScopeDom tsd= new TutScopeDom();
tsd.Extract( "myfile.zip", null );
#if (ALOX_DBG_LOG || ALOX_REL_LOG)
SaveTutorialOutput( "Tut_ScopeDomains.txt", tutLog.MemoryLog );
tutLog.MemoryLog.Clear(); tutLog.CntLogs= 0;
#endif
// do it once to set the tab positions of the meta info...
{
Zipper zip= new Zipper();
zip.Compress( "myfile.zip", null );
zip.Extract( "myfile.zip", null );
#if (ALOX_DBG_LOG || ALOX_REL_LOG)
tutLog.MemoryLog.Clear(); tutLog.CntLogs= 0;
#endif
}
// ...and again
{
Zipper zip= new Zipper();
zip.Compress( "myfile.zip", null );
zip.Extract( "myfile.zip", null );
}
#if (ALOX_DBG_LOG || ALOX_REL_LOG)
SaveTutorialOutput( "Tut_ScopeDomains_Zipper.txt", tutLog.MemoryLog );
#endif
//---------- with scope path ---------------
//! [Tut_ScopeDomains_Path]
Log.SetDomain( "UTIL", Scope.Path );
//! [Tut_ScopeDomains_Path]
#if (ALOX_DBG_LOG || ALOX_REL_LOG)
tutLog.MemoryLog.Clear(); tutLog.CntLogs= 0;
#endif
// do it once to set the tab positions of the meta info...
{
Zipper zip= new Zipper();
zip.Compress( "myfile.zip", null );
zip.Extract( "myfile.zip", null );
#if (ALOX_DBG_LOG || ALOX_REL_LOG)
tutLog.MemoryLog.Clear(); tutLog.CntLogs= 0; tutLog.CntLogs= 0;
#endif
}
// ...and again
{
Zipper zip= new Zipper();
zip.Compress( "myfile.zip", null );
zip.Extract( "myfile.zip", null );
}
#if (ALOX_DBG_LOG || ALOX_REL_LOG)
SaveTutorialOutput( "Tut_ScopeDomains_Zipper_Path.txt", tutLog.MemoryLog );
tutLog.MemoryLog.Clear(); tutLog.CntLogs= 0;
#endif
Log.SetDomain( null, Scope.Path );
Log.SetDomain( null, Scope.Filename );
//! [Tut_ScopeDomains_ParamDom]
Log.SetDomain( "METHOD", Scope.Method );
Log.Info( "No domain parameter given" );
Log.Info( "PARAM", "Domain parameter \"PARAM\" given" );
//! [Tut_ScopeDomains_ParamDom]
// clear autosizes, repeat it twice
#if (ALOX_DBG_LOG || ALOX_REL_LOG)
tutLog.AutoSizes.Reset();
#endif
Log.Info( "No domain parameter given" );
Log.Info( "PARAM", "Domain parameter \"PARAM\" given" );
tutLog.MemoryLog.Clear(); tutLog.CntLogs= 0;
Log.Info( "No domain parameter given" );
Log.Info( "PARAM", "Domain parameter \"PARAM\" given" );
#if (ALOX_DBG_LOG || ALOX_REL_LOG)
SaveTutorialOutput( "Tut_ScopeDomains_ParamDom.txt", tutLog.MemoryLog );
tutLog.MemoryLog.Clear(); tutLog.CntLogs= 0;
#endif
//! [Tut_ScopeDomains_ParamDom_2]
Log.SetDomain( "READ", Scope.Method );
Log.Info( "Reading file" );
//...
//...
Log.Info( "/CONFIG", "Path not found." );
//...
//! [Tut_ScopeDomains_ParamDom_2]
#if (ALOX_DBG_LOG || ALOX_REL_LOG)
SaveTutorialOutput( "Tut_ScopeDomains_ParamDom_2.txt", tutLog.MemoryLog );
#endif
Log.RemoveLogger( tutLog );
}
public void Log_LineFormat()
{
#if ALOX_DBG_LOG || ALOX_REL_LOG
UT_INIT();
Log.AddDebugLogger();
MemoryLogger testML= new MemoryLogger();
Log.SetDomain( "/FMT", Scope.Method );
Log.SetVerbosity( Log.DebugLogger, Verbosity.Verbose, "/FMT");
Log.SetVerbosity( testML, Verbosity.Verbose, "/FMT");
Log.Info( "This is the default ConsoleLogger log line" );
AString lf;
lf= new AString( "%SF(%SL):%SM()%A3[%D][%TD][%TC +%TL][%tN]%V[%D]<%#>: "); Log.DebugLogger.MetaInfo.Format= lf; Log.Info( "LineFormat set to= \"" + lf + "\"" );
lf= new AString( "%SF(%SL):%A3[%D][%TD][%TC +%TL][%tN]%V[%D]<%#>: "); Log.DebugLogger.MetaInfo.Format= lf; Log.Info( "LineFormat set to= \"" + lf + "\"" );
lf= new AString( "%SF(%SL):%A3[%TD][%TC +%TL][%tN]%V[%D]<%#>: "); Log.DebugLogger.MetaInfo.Format= lf; Log.Info( "LineFormat set to= \"" + lf + "\"" );
lf= new AString( "%SF(%SL):%A3[%TC +%TL][%tN]%V[%D]<%#>: "); Log.DebugLogger.MetaInfo.Format= lf; Log.Info( "LineFormat set to= \"" + lf + "\"" );
lf= new AString( "%SF(%SL):%A3[+%TL][%tN]%V[%D]<%#>: "); Log.DebugLogger.MetaInfo.Format= lf; Log.Info( "LineFormat set to= \"" + lf + "\"" );
lf= new AString( "%SF(%SL):%A3[%tN]%V[%D]<%#>: "); Log.DebugLogger.MetaInfo.Format= lf; Log.Info( "LineFormat set to= \"" + lf + "\"" );
lf= new AString( "%SF(%SL):%A3 %V[%D]<%#>: "); Log.DebugLogger.MetaInfo.Format= lf; Log.Info( "LineFormat set to= \"" + lf + "\"" );
lf= new AString( "%SF(%SL):%A3[%D]<%#>: "); Log.DebugLogger.MetaInfo.Format= lf; Log.Info( "LineFormat set to= \"" + lf + "\"" );
lf= new AString( "%SF(%SL):%A3[%D]: "); Log.DebugLogger.MetaInfo.Format= lf; Log.Info( "LineFormat set to= \"" + lf + "\"" );
lf= new AString( "%SF:%A3[%D]: "); Log.DebugLogger.MetaInfo.Format= lf; Log.Info( "LineFormat set to= \"" + lf + "\"" );
lf= new AString( "[%D]: "); Log.DebugLogger.MetaInfo.Format= lf; Log.Info( "LineFormat set to= \"" + lf + "\"" );
lf= new AString( ""); Log.DebugLogger.MetaInfo.Format= lf; Log.Info( "LineFormat set to= \"" + lf + "\"" );
Log.DebugLogger.MetaInfo.Format._()._( "%TD@" );
testML.MetaInfo.Format._()._( "%TD@" );
String df;
df= ">yy-MM-dd<"; Log.DebugLogger.MetaInfo.DateFormat= df; Log.Info( "Date test. Format: \""+ df + '\"' );
testML.MemoryLog.Clear();
df= ">yyyy/dd/MM<"; Log.DebugLogger.MetaInfo.DateFormat= df; testML.MetaInfo.DateFormat= df; Log.Info( "FMT", "Date test. Format: \""+ df + '\"' );
UT_TRUE( testML.MemoryLog.SearchAndReplace( "/", "@") == 4 );
Log.DebugLogger.MetaInfo.Format._()._( "%TT@" );
testML.MetaInfo.Format._()._( "%TT@" );
df= ">HH:mm:ss<"; Log.DebugLogger.MetaInfo.TimeOfDayFormat= df; Log.Info( "FMT", "Time of day test Format: \""+ df + '\"' );
testML.MemoryLog.Clear();
df= ">HH-mm-ss<"; Log.DebugLogger.MetaInfo.TimeOfDayFormat= df; testML.MetaInfo.TimeOfDayFormat= df; Log.Info( "FMT", "Time of day test. Format: \"" + df + '\"' );
UT_TRUE( testML.MemoryLog.SearchAndReplace( "-", "@") == 4 );
Log.DebugLogger.MetaInfo.Format._()._( "%P" );
testML.MetaInfo.Format._()._( "%P" );
testML.MemoryLog.Clear(); testML.AutoSizes.Reset(); Log.Info(""); UT_TRUE( testML.MemoryLog.IndexOf( ".Net45-NUnit" ) >= 0
|| testML.MemoryLog.IndexOf( "UnitTestAdapter" ) >= 0 );
Log.DebugLogger.MetaInfo.Format._()._( "%LX" );
testML.MetaInfo.Format._()._( "%LX" );
testML.MemoryLog.Clear(); testML.AutoSizes.Reset(); Log.Info(""); UT_EQ( "LOG" ,testML.MemoryLog );
Log.DebugLogger.MetaInfo.Format._()._( "%LG" );
testML.MetaInfo.Format._()._( "%LG" );
testML.MemoryLog.Clear(); testML.AutoSizes.Reset(); Log.Info(""); UT_EQ( "MEMORY" , testML.MemoryLog );
#endif
}
