Exemplo n.º 1
0
        public static void AreEqual(this Assert assert, ImageMoniker expected, ExportableImageMoniker?actual)
        {
            if (actual == null)
            {
                throw new AssertFailedException($"ImageMoniker did not match.{Environment.NewLine}Expected: {S(expected)}{Environment.NewLine}Actual: null");
            }

            var actualMoniker = ToImageMoniker(actual.Value);

            if (expected.Id != actualMoniker.Id || expected.Guid != actualMoniker.Guid)
            {
                throw new AssertFailedException($"ImageMoniker did not match.{Environment.NewLine}Expected: {S(expected)}{Environment.NewLine}Actual: {S(actualMoniker)}");
            }

            string S(ImageMoniker a) => ManagedImageMonikers.ImageMonikerDebugDisplay(a);
        }
Exemplo n.º 2
0
 static string S(ImageMoniker a) => ManagedImageMonikers.ImageMonikerDebugDisplay(a);
        private void VerifyDependenciesNode(SolutionExplorerItemTestExtension actualDependencies, Node[] nodes)
        {
            var expectDependencies = new Node("Dependencies", ManagedImageMonikers.ReferenceGroup)
            {
                Children = new List <Node>(nodes)
            };

            var expectOutput = new StringBuilder();
            var actualOutput = new StringBuilder();

            var same = true;

            VerifyNode(expectDependencies, actualDependencies);

            if (!same)
            {
                Assert.Fail($"Incorrect Dependencies tree.\n\nExpected:\n\n{expectOutput}\nActual:\n\n{actualOutput}");
            }

            return;

            void VerifyNode(Node?expect, SolutionExplorerItemTestExtension?actual, int depth = 0)
            {
                Assert.IsTrue(expect != null || actual != null);

                var thisSame = true;

                if (actual != null && expect?.Text != null && expect.Text != actual.Name)
                {
                    same     = false;
                    thisSame = false;
                }

                if (actual != null && expect?.Icon != null && !AssertExtensions.AreEqual(expect.Icon.Value, actual.ExpandedIconMoniker))
                {
                    same     = false;
                    thisSame = false;
                }

                var actualIcon = actual?.ExpandedIconMoniker == null
                    ? "null"
                    : ManagedImageMonikers.ImageMonikerDebugDisplay(actual.ExpandedIconMoniker.Value.ToImageMoniker());

                if (expect != null)
                {
                    expectOutput
                    .Append(' ', depth * 4)
                    .Append(expect.Text ?? actual !.Name)
                    .Append(' ')
                    .Append(expect.Icon != null
                            ? ManagedImageMonikers.ImageMonikerDebugDisplay(expect.Icon.Value)
                            : actualIcon)
                    .AppendLine();
                }

                if (actual != null)
                {
                    actualOutput
                    .Append(' ', depth * 4)
                    .Append(actual.Name)
                    .Append(' ')
                    .Append(actualIcon)
                    .Append(thisSame ? "" : " 🐛")
                    .AppendLine();
                }

                if (expect?.Children != null)
                {
                    if (actual != null && !actual.IsExpanded && expect.Children != null && expect.Children.Count != 0)
                    {
                        actual.Expand();
                    }

                    var actualChildren = actual?.Items.ToList() ?? new List <SolutionExplorerItemTestExtension>();

                    if (actualChildren.Count != expect.Children !.Count)
                    {
                        same = false;
                    }

                    var max = Math.Max(actualChildren.Count, expect.Children.Count);

                    for (int i = 0; i < max; i++)
                    {
                        var expectChild = expect.Children.Count > i ? expect.Children[i] : null;
                        var actualChild = actualChildren.Count > i ? actualChildren[i] : null;

                        VerifyNode(
                            expectChild,
                            actualChild,
                            depth + 1);
                    }
                }
            }
        }