Beispiel #1
0
        public void DoesOutperformDefaultUnityLogQueueing(UnityEngine.LogType unityLogType, string message, int itterations)
        {
            // Arrange
            var coreLogType = LogTypeMappings[unityLogType];

            var stopWatch = Stopwatch.StartNew();

            for (var i = 0; i < itterations; i++)
            {
                UnityEngine.Debug.unityLogger.Log(unityLogType, message);
            }
            stopWatch.Stop();
            var defaultDuration = stopWatch.ElapsedMilliseconds;

            long threadedDuration;

            using (var threadedLogger = new AsyncLogger())
            {
                // Act
                stopWatch.Restart();
                for (var i = 0; i < itterations; i++)
                {
                    threadedLogger.Log(coreLogType, message);
                }

                stopWatch.Stop();
                threadedDuration = stopWatch.ElapsedMilliseconds;
            }

            // Assert
            Assert.Less(threadedDuration, defaultDuration);
            UnityEngine.Debug.Log($"Threaded: {threadedDuration}, Default: {defaultDuration}.");
        }
        public async Task <ActionResult> AddArticleSale([FromBody] Article article)
        {
            AsyncLogger.Log(LogLevel.Info, $"Operation: {nameof(AddArticleSale)}. Input: {article}");
            await _dataStore.AddSoldArticle(article);

            return(Ok());
        }
        public void DoesFormat(LogType logType, string message)
        {
            // Arrange
            var writer    = new LogQueueWriter();
            var formatter = new TypeMessageFormatter();

            using (var logger = new AsyncLogger(writer, formatter))
            {
                // Act
                logger.Log(logType, message);

                while (!writer.Lines.Any())
                {
                }

                logger.Flush();
            }

            // Assert
            var originalLog    = writer.Lines.Single();
            var duplicateEntry = new LogEntry
            {
                LogType = logType,
                Message = message
            };
            var duplicateLog = formatter.Format(duplicateEntry);

            Assert.Equal(originalLog, duplicateLog);
        }
        public int CreateLogs()
        {
            for (var i = 0; i < 10; i++)
            {
                _logger.Log("Error", $"Message {i}");
            }

            return(GetPendingCount());
        }
        public async Task <ActionResult <IEnumerable <DailyArticleRevenue> > > GetRevenueByArticle()
        {
            AsyncLogger.Log(LogLevel.Info, $"Operation: {nameof(GetRevenueByArticle)}");
            IEnumerable <DailyArticleRevenue> result = await _dataStore.GetRevenuesByArticle(DateTime.MinValue, DateTime.Today);

            if (!result.Any())
            {
                AsyncLogger.Log(LogLevel.Warning, $"{nameof(GetRevenueByArticle)} returned no values");
                return(NoContent());
            }

            return(Ok(result));
        }
        public async Task <ActionResult <DailyRevenue> > GetRevenue(DateTime targetDay)
        {
            AsyncLogger.Log(LogLevel.Info, $"Operation: {nameof(GetRevenue)}. Input: {targetDay:s}");
            DailyRevenue result = (await _dataStore.GetRevenues(targetDay.Date, targetDay.Date)).SingleOrDefault();

            if (result == null)
            {
                AsyncLogger.Log(LogLevel.Warning, $"{nameof(GetRevenue)} returned no values");
                return(NoContent());
            }

            return(Ok(result));
        }
        public void DoesLog(LogType logType, string message)
        {
            // Arrange
            var writer    = new LogQueueWriter();
            var formatter = new LogFormatter();

            using (var logger = new AsyncLogger(writer, formatter))
            {
                // Act
                logger.Log(logType, message);

                while (!writer.Lines.Any())
                {
                }

                logger.Flush();
            }

            // Assert
            Assert.Single(writer.Lines);
        }