public void EqualsNull()
        {
            var comparer = new DelegatedEqualityComparer <string> ((s1, s2) => s1.Length == s2.Length, s => s.Length.GetHashCode());

            Assert.IsTrue(comparer.Equals(null, null));
            Assert.IsFalse(comparer.Equals("foo", null));
        }
        public void DelegatedHashCode()
        {
            var comparer = new DelegatedEqualityComparer <string, int> (s => s.Length);

            Assert.AreEqual(comparer.GetHashCode("foo"), comparer.GetHashCode("bar"));
            Assert.AreNotEqual(comparer.GetHashCode("foo"), comparer.GetHashCode("fo"));
        }
        public void Equals()
        {
            var comparer = new DelegatedEqualityComparer <string, int> (s => s.Length);

            Assert.IsTrue(comparer.Equals("foo", "bar"));
            Assert.IsFalse(comparer.Equals("foo", "fo"));
        }
        public void DelegatedHashCode()
        {
            var comparer = new DelegatedEqualityComparer <string> ((s1, s2) => s1.Length == s2.Length, s => s.Length.GetHashCode());

            Assert.AreEqual(comparer.GetHashCode("foo"), comparer.GetHashCode("bar"));
            Assert.AreNotEqual(comparer.GetHashCode("foo"), comparer.GetHashCode("fo"));
        }
        public void EqualsReference()
        {
            string str = "s";

            var comparer = new DelegatedEqualityComparer<string> ((s1, s2) => s1.Length != s2.Length, s => s.Length.GetHashCode());
            Assert.IsTrue (comparer.Equals (str, str));
            Assert.IsTrue (comparer.Equals ("sf", "s"));
        }
        public void EqualsReference()
        {
            string str = "s";

            var comparer = new DelegatedEqualityComparer <string> ((s1, s2) => s1.Length != s2.Length, s => s.Length.GetHashCode());

            Assert.IsTrue(comparer.Equals(str, str));
            Assert.IsTrue(comparer.Equals("sf", "s"));
        }
示例#7
0
        public void AddCustomValueComparer()
        {
            var comparer = new DelegatedEqualityComparer <string, int> (s => s.Length);

            var lookup = new BidirectionalLookup <string, string> (comparer, comparer);

            lookup.Add("foo", "bar1");
            lookup.Add("bar", "baz1");

            Assert.IsTrue(lookup.Contains("baz"));
            Assert.IsTrue(lookup.Inverse.Contains("foo1"));
            CollectionAssert.Contains(lookup["foo"], "bar1");
            CollectionAssert.Contains(lookup["foo"], "baz1");
            CollectionAssert.Contains(lookup["bar"], "bar1");
            CollectionAssert.Contains(lookup["bar"], "bar1");
        }
 public void EqualsNull()
 {
     var comparer = new DelegatedEqualityComparer<string> ((s1, s2) => s1.Length == s2.Length, s => s.Length.GetHashCode());
     Assert.IsTrue (comparer.Equals (null, null));
     Assert.IsFalse (comparer.Equals ("foo", null));
 }
 public void DelegatedHashCode()
 {
     var comparer = new DelegatedEqualityComparer<string> ((s1, s2) => s1.Length == s2.Length, s => s.Length.GetHashCode());
     Assert.AreEqual (comparer.GetHashCode ("foo"), comparer.GetHashCode("bar"));
     Assert.AreNotEqual (comparer.GetHashCode ("foo"), comparer.GetHashCode ("fo"));
 }
 public void Equals()
 {
     var comparer = new DelegatedEqualityComparer<string, int> (s => s.Length);
     Assert.IsTrue (comparer.Equals ("foo", "bar"));
     Assert.IsFalse (comparer.Equals ("foo", "fo"));
 }
 public void DelegatedHashCode()
 {
     var comparer = new DelegatedEqualityComparer<string, int> (s => s.Length);
     Assert.AreEqual (comparer.GetHashCode ("foo"), comparer.GetHashCode("bar"));
     Assert.AreNotEqual (comparer.GetHashCode ("foo"), comparer.GetHashCode ("fo"));
 }
示例#12
0
        protected override int ExecuteInternalWithExitCode()
        {
            var opts = this.Options;
            var relativeProjectPath = "project/views.json";

            var directory = opts.Directory;

            if (string.IsNullOrWhiteSpace(directory))
            {
                directory = Environment.CurrentDirectory;
            }

            var settings = CompilerRunner.GetBuildSettings(directory, relativeProjectPath, new SharpJsonSerializer(), true);

            var            newViewSettings = new ViewsSettings();
            IViewsSettings optsSettings    = opts;

            newViewSettings.Imports    = optsSettings.Imports.Union(settings.Imports).ToArray();
            newViewSettings.References = optsSettings.References.Union(settings.References)
                                         .Select(x => new Reference {
                HintPath = x.HintPath, Name = x.Name
            })
                                         .Distinct(DelegatedEqualityComparer.Builder <Reference>().Build(x => x.Name))
                                         .ToArray();


            newViewSettings.LinkerPath = Fold(opts, settings, x => x.LinkerPath);
            newViewSettings.OutputFile = Fold(opts, settings, x => x.OutputFile);
            newViewSettings.RelativeIntermediateDirectory = Fold(opts, settings, x => x.RelativeIntermediateDirectory);
            newViewSettings.RelativeSourceDirectory       = Fold(opts, settings, x => x.RelativeSourceDirectory);
            newViewSettings.SecondaryOutputFile           = Fold(opts, settings, x => x.SecondaryOutputFile);
            newViewSettings.SkipSecondaryOutputFile       = opts.SkipSecondaryOutputFile || settings.SkipSecondaryOutputFile;


            if (opts.SingleRun)
            {
                var logFile = new StreamWriter(File.OpenWrite(Path.Combine(directory, "Logs", DateTime.Now.ToString("dd-MM-yyyy-hh-mm-ss"))));

                var logger = opts.Verbose
                        ? (ILogger) new TextWriterLogger(Console.Out)
                        : new NullLogger();

                using (var compiler = CompilerRunner.StartWatching(directory, settings, new ConsoleMessenger(), logger))
                {
                    if (compiler.Compile() == CompileResult.Success)
                    {
                        return(-1);
                    }

                    return(-2);
                }
            }


            using (var executor = new SoufflotExecutor(directory, settings, new ConsoleMessenger(), opts.Port))
            {
                executor.Run();
            }

            return(0);
        }