public void WhenEqualWhitespaceEnd()
        {
            var x = @"
namespace RoslynSandbox
{
    class Foo
    {
        private readonly int _value;
    }
}

a
";

            var y = @"
namespace RoslynSandbox
{
    class Foo
    {
        private readonly int _value;
    }
}

a
";

            Assert.AreEqual(true, CodeComparer.Equals(x, y));
        }
Ejemplo n.º 2
0
        public void AnalyzersBenchmark(DiagnosticAnalyzer analyzer)
        {
            var expectedName = analyzer.GetType().Name + "Benchmarks";
            var fileName     = Path.Combine(BenchmarksDirectory, expectedName + ".cs");
            var code         = new StringBuilder().AppendLine("// ReSharper disable RedundantNameQualifier")
                               .AppendLine($"namespace {this.GetType().Namespace}")
                               .AppendLine("{")
                               .AppendLine($"    public class {expectedName}")
                               .AppendLine("    {")
                               .AppendLine($"        private static readonly Gu.Roslyn.Asserts.Benchmark Benchmark = Gu.Roslyn.Asserts.Benchmark.Create(Code.AnalyzersProject, new {analyzer.GetType().FullName}());")
                               .AppendLine()
                               .AppendLine("        [BenchmarkDotNet.Attributes.Benchmark]")
                               .AppendLine("        public void RunOnIDisposableAnalyzers()")
                               .AppendLine("        {")
                               .AppendLine("            Benchmark.Run();")
                               .AppendLine("        }")
                               .AppendLine("    }")
                               .AppendLine("}")
                               .ToString();

            if (!File.Exists(fileName) ||
                !CodeComparer.Equals(File.ReadAllText(fileName), code))
            {
                File.WriteAllText(fileName, code);
                Assert.Fail();
            }
        }
Ejemplo n.º 3
0
        public static void WhenEqualWhitespaceEnd()
        {
            var x = @"
namespace N
{
    class C
    {
        private readonly int _value;
    }
}

a
";

            var y = @"
namespace N
{
    class C
    {
        private readonly int _value;
    }
}

a
";

            Assert.AreEqual(true, CodeComparer.Equals(x, y));
        }
Ejemplo n.º 4
0
        public void CodeComparer_ThrowsOnIncompatibleCodeTypes()
        {
            var comp = new CodeComparer();

            var invalidCodeList = StringArrayFromObjects("ASM-1", "ASM-001-1", "ASM-003-30");

            Array.Sort(invalidCodeList, comp);
        }
        public void CodeComparer_ThrowsOnIncompatibleCodeTypes()
        {
            var comp = new CodeComparer();

            var invalidCodeList = StringArrayFromObjects("ASM-1", "ASM-001-1", "ASM-003-30");

            Array.Sort(invalidCodeList, comp);
        }
        void XamlIsEqual(string input1, string input2)
        {
            var diff = new StringWriter();

            if (!CodeComparer.Compare(input1, input2, diff, NormalizeLine))
            {
                Assert.Fail(diff.ToString());
            }
        }
Ejemplo n.º 7
0
        public void CodeComparer_SortsCodes()
        {
            var comp = new CodeComparer();

            var unsortedCodes = StringArrayFromObjects("ASM-1-01A", "ASM-001-1", "ASM-003-30");
            var sortedCodes   = StringArrayFromObjects("ASM-001-1", "ASM-1-01A", "ASM-003-30");

            Array.Sort(unsortedCodes, comp);

            Assert.IsTrue(unsortedCodes.SequenceEqual(sortedCodes));
        }
        public void CodeComparer_SortsCodes()
        {
            var comp = new CodeComparer();

            var unsortedCodes = StringArrayFromObjects("ASM-1-01A", "ASM-001-1", "ASM-003-30");
            var sortedCodes = StringArrayFromObjects("ASM-001-1", "ASM-1-01A", "ASM-003-30");

            Array.Sort(unsortedCodes, comp);

            Assert.IsTrue(unsortedCodes.SequenceEqual(sortedCodes));
            
        }
Ejemplo n.º 9
0
        public void AllBenchmarks()
        {
            var fileName = Path.Combine(Program.BenchmarksDirectory, "AllBenchmarks.cs");
            var builder  = new StringBuilder();

            builder.AppendLine("// ReSharper disable RedundantNameQualifier")
            .AppendLine($"namespace {this.GetType().Namespace}")
            .AppendLine("{")
            .AppendLine("    [BenchmarkDotNet.Attributes.MemoryDiagnoser]")
            .AppendLine("    public class AllBenchmarks")
            .AppendLine("    {");
            foreach (var analyzer in AllAnalyzers)
            {
                builder.AppendLine(
                    $"        private static readonly Gu.Roslyn.Asserts.Benchmark {analyzer.GetType().Name}Benchmark = Gu.Roslyn.Asserts.Benchmark.Create(Code.ValidCodeProject, new {analyzer.GetType().FullName}());")
                .AppendLine();
            }

            foreach (var analyzer in AllAnalyzers)
            {
                builder.AppendLine($"        [BenchmarkDotNet.Attributes.Benchmark]")
                .AppendLine($"        public void {analyzer.GetType().Name}()")
                .AppendLine("        {")
                .AppendLine($"            {analyzer.GetType().Name}Benchmark.Run();")
                .AppendLine("        }");
                if (!ReferenceEquals(analyzer, AllAnalyzers[AllAnalyzers.Count - 1]))
                {
                    builder.AppendLine();
                }
            }

            builder.AppendLine("    }")
            .AppendLine("}");

            var code = builder.ToString();

            if (!File.Exists(fileName) ||
                !CodeComparer.Equals(File.ReadAllText(fileName), code))
            {
                File.WriteAllText(fileName, code);
                Assert.Fail();
            }
        }
Ejemplo n.º 10
0
        public void WhenNotEqual()
        {
            var x = @"
namespace RoslynSandbox
{
    class Foo
    {
        private readonly int _value;
    }
}";

            var y = @"
namespace RoslynSandbox
{
    class Foo
    {
        private readonly int bar;
    }
}";

            Assert.AreEqual(false, CodeComparer.Equals(x, y));
        }
Ejemplo n.º 11
0
        public static void WhenNotEqual()
        {
            var x = @"
namespace N
{
    class C
    {
        private readonly int _value;
    }
}";

            var y = @"
namespace N
{
    class C
    {
        private readonly int bar;
    }
}";

            Assert.AreEqual(false, CodeComparer.Equals(x, y));
        }
Ejemplo n.º 12
0
 public void Setup()
 {
     _mind = new CodeComparer();
 }
Ejemplo n.º 13
0
 public void WhenEqualMixedNewLines(string x, string y)
 {
     Assert.AreEqual(true, CodeComparer.Equals(x, y));
 }
Ejemplo n.º 14
0
        static void Main(string[] args)
        {
            InitIO();

            var n = int.Parse(Console.ReadLine());

            Console.Error.WriteLine("Input files: {0}", n);

            var graph      = new Graph <string>();
            var comparer   = new CodeComparer(new CodeAnalyzerBuilder());
            var signatures = new Signatures();
            var files      = new string[n];

            for (var i = 0; i < n; i++)
            {
                files[i] = Console.ReadLine();

                var language = Path.GetExtension(files[i]);
                var code     = File.ReadAllText(files[i]);
                code = signatures.FormatCode(code);

                var codeAnalyzer = new SuffixTreeCodeAnalyzer(language, code);

                graph.AddVertex(files[i]);
                comparer.Register(files[i], language, code);

                if ((i + 1) % 100 == 0)
                {
                    OnProgress("Parsed: ", i + 1, n);
                }
            }

            var maximum  = (long)(n) * (long)(n - 1) / 2;
            var progress = (long)0;

            OnProgress("Compared: ", progress, maximum);
            for (var i = 0; i < n; i++)
            {
                for (var j = i + 1; j < n; j++)
                {
                    if (++progress % 10000 == 0)
                    {
                        OnProgress(progress, maximum);
                    }

                    if (files[i].Contains('-') && files[j].Contains('-'))
                    {
                        var id1 = files[i].Substring(0, files[i].IndexOf('-'));
                        var id2 = files[j].Substring(0, files[j].IndexOf('-'));

                        if (id1 == id2)
                        {
                            continue;
                        }
                    }

                    decimal compare = comparer.Compare(files[i], files[j]);


                    if (compare > 0.33M)
                    {
                        Console.Error.WriteLine("{0} | {1} -> {2:0.00}%", files[i], files[j], compare * 100);
                        graph.AddEdge(files[i], files[j]);
                    }
                }
            }

            OnProgress(progress, maximum);

            var res = from c in graph.GetConnectedComponents()
                      where c.Count >= 2
                      select c;

            Console.WriteLine(res.Count());
            Console.Error.WriteLine(res.Count());
            foreach (var g in res)
            {
                foreach (var file in g.Verticies)
                {
                    Console.Write(file + " ");
                    Console.Error.Write(file + " ");
                }
                Console.WriteLine();
                Console.Error.WriteLine();
            }
            Console.Out.Dispose();
        }