public void SpecialPathCharactersAreHandledCorrectly(string original, string expected, bool normalize)
        {
            var converted = EnhancedStackTrace.TryGetFullPath(original);

            if (normalize)
            {
                converted = NormalizePath(converted);
            }

            Assert.Equal(expected, converted);
        }
Esempio n. 2
0
        /// <summary>
        /// Gets the stack trace scoped to the given invocation.
        /// </summary>
        public static string GetStackTrace(this IMethodInvocation invocation)
        {
            var allFrames       = EnhancedStackTrace.Current();
            var invocationFrame = allFrames.FirstOrDefault(x => x.GetMethod() == invocation.MethodBase);
            //if (invocationFrame == null)

            // We know that the generated proxies live in the same assembly as the tests, so we use that
            // to scope the stack trace from the current invocation method up to the top call (test method)
            var testFrame = allFrames.LastOrDefault(x => x.GetMethod().DeclaringType?.Assembly == invocation.MethodBase.DeclaringType.Assembly);

            var sb = new StringBuilder();
            // Always append if we didn't find the tip invocation frame
            var appendLine = invocationFrame == null;

            foreach (var frame in allFrames)
            {
                if (!appendLine && frame == invocationFrame)
                {
                    appendLine = true;
                }

                if (appendLine)
                {
                    sb.Append("\t");
                    var filePath = frame.GetFileName();
                    if (!string.IsNullOrEmpty(filePath))
                    {
                        sb.Append(EnhancedStackTrace.TryGetFullPath(filePath).Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar));
                        var lineNo = frame.GetFileLineNumber();
                        var colNo  = frame.GetFileColumnNumber();
                        if (lineNo != 0 && colNo != 0)
                        {
                            sb.Append("(").Append(lineNo).Append(",").Append(colNo).Append("): ");
                        }
                    }

                    sb.Append("at ");
                    sb.AppendLine(frame.ToString());

                    if (frame == testFrame)
                    {
                        break;
                    }
                }
            }

            return(sb.ToString());
        }
        private static string PrepareStackTrace()
        {
            var frames = EnhancedStackTrace.Current().ToList();
            var sb     = new StringBuilder();
            var done   = false;

            for (var fi = 0; !(sb.Length > 0 && done); fi++)
            {
                var frame          = frames[fi];
                var methodTypeName = frame.MethodInfo.DeclaringType.FullName;
                if (IgnoreNamespaces.All(x => !methodTypeName.StartsWith(x)))
                {
                    if (sb.Length > 0)
                    {
                        sb.Append(Environment.NewLine);
                    }

                    sb.Append("   at ");
                    MethodInfoAppend.Invoke(frame.MethodInfo, new[] { (object)sb });

                    var filePath = frame.GetFileName();
                    if (!string.IsNullOrEmpty(filePath))
                    {
                        sb.Append(" in ");
                        sb.Append(EnhancedStackTrace.TryGetFullPath(filePath));
                    }

                    var lineNo = frame.GetFileLineNumber();
                    if (lineNo != 0)
                    {
                        sb.Append(":line ");
                        sb.Append(lineNo);
                    }

                    continue;
                }

                done = sb.Length > 0;
            }

            return(sb.ToString());
        }
        public void RelativePathIsConvertedToAnAbsolutePath(string original, string expected)
        {
            var converted = EnhancedStackTrace.TryGetFullPath(original);

            Assert.Equal(expected, NormalizePath(converted));
        }