Esempio n. 1
0
 public LinkPair(T view, T real)
 {
     ViewValidation.VerifyLinkedNotNull(view);
     ViewValidation.VerifyNotLinkedNotNull(real);
     this.View = view;
     this.Real = real;
 }
            public void ResetBeforeTests()
            {
                this.Group.ClearAllRemotes();

                var projView = this.Local.GetLoadedProjects(this.BigFile).FirstOrDefault();

                Assert.NotNull(projView);
                Assert.NotSame(projView, this.View);
                this.View = projView;

                ViewValidation.VerifyLinkedNotNull(this.View);
            }
            public ROTestCollectionGroup()
                : base(1, 0)
            {
                this.BigFile = this.ImmutableDisk.WriteProjectFile($"Big.proj", TestCollectionGroup.BigProjectFile);
                var projReal = this.Remote[0].LoadProjectWithSettings(this.BigFile, ProjectLoadSettings.IgnoreMissingImports | ProjectLoadSettings.RecordDuplicateButNotCircularImports);

                this.Local.Importing = true;
                Assert.NotNull(projReal);
                this.Real = projReal;
                Assert.NotNull(this.Real);
                var projView = this.Local.GetLoadedProjects(this.BigFile).FirstOrDefault();

                Assert.NotNull(projView);
                this.View = projView;

                ViewValidation.VerifyNotLinkedNotNull(this.Real);
                ViewValidation.VerifyLinkedNotNull(this.View);
            }
            public ROTestCollectionGroup()
                : base(1, 0)
            {
                this.BigFile = this.ImmutableDisk.WriteProjectFile($"Big.proj", TestCollectionGroup.BigProjectFile);
                var projReal = this.Remote[0].LoadProjectIgnoreMissingImports(this.BigFile);

                this.Local.Importing = true;
                Assert.NotNull(projReal);
                this.RealXml = projReal.Xml;
                Assert.NotNull(this.RealXml);
                var projView = this.Local.GetLoadedProjects(this.BigFile).FirstOrDefault();

                Assert.NotNull(projView);
                this.ViewXml = projView.Xml;

                ViewValidation.VerifyNotLinkedNotNull(this.RealXml);
                ViewValidation.VerifyLinkedNotNull(this.ViewXml);
            }
        public void EnumerationBasic()
        {
            var pcLocal  = this.StdGroup.Local;
            var pcRemote = this.StdGroup.Remote[0];

            var proj1Path = this.StdGroup.StdProjectFiles[0];
            var proj2Path = this.StdGroup.StdProjectFiles[1];

            var proj1 = pcLocal.LoadProject(proj1Path);
            var proj2 = pcRemote.LoadProject(proj2Path);

            ViewValidation.VerifyNotLinkedNotNull(proj1);
            ViewValidation.VerifyNotLinkedNotNull(proj2);

            var loadedLocal  = pcLocal.Collection.LoadedProjects;
            var loadedRemote = pcRemote.Collection.LoadedProjects;

            Assert.Equal(1, loadedLocal.Count);
            Assert.Equal(1, loadedRemote.Count);
            Assert.Same(proj1, loadedLocal.FirstOrDefault());
            Assert.Same(proj2, loadedRemote.FirstOrDefault());

            pcLocal.Importing = true;

            loadedLocal = pcLocal.Collection.LoadedProjects;
            Assert.Equal(2, loadedLocal.Count);

            // still can find it's own projects and it is the same object
            var localProj = pcLocal.Collection.GetLoadedProjects(proj1Path).FirstOrDefault();

            Assert.Same(localProj, proj1);

            var remoteProj = pcLocal.Collection.GetLoadedProjects(proj2Path).FirstOrDefault();

            Assert.NotSame(remoteProj, proj2);
            ViewValidation.VerifyLinkedNotNull(remoteProj);
        }
        public void EnumerationMultiple()
        {
            var pcLocal   = this.StdGroup.Local;
            var pcRemote0 = this.StdGroup.Remote[0];
            var pcRemote1 = this.StdGroup.Remote[1];

            var proj0Path = this.StdGroup.StdProjectFiles[0];
            var proj1Path = this.StdGroup.StdProjectFiles[1];
            var proj2Path = this.StdGroup.StdProjectFiles[2];
            var proj3Path = this.StdGroup.StdProjectFiles[3];

            var proj0local = pcLocal.LoadProject(proj0Path);
            var proj1local = pcLocal.LoadProject(proj1Path);

            var proj1remote0 = pcRemote0.LoadProject(proj1Path);
            var proj2remote0 = pcRemote0.LoadProject(proj2Path);

            var proj2remote1 = pcRemote1.LoadProject(proj2Path);
            var proj3remote1 = pcRemote1.LoadProject(proj3Path);

            var loadedLocal   = pcLocal.Collection.LoadedProjects;
            var loadedRemote0 = pcRemote0.Collection.LoadedProjects;
            var loadedRemote1 = pcRemote1.Collection.LoadedProjects;

            Assert.Equal(2, loadedLocal.Count);
            Assert.Equal(2, loadedRemote0.Count);
            Assert.Equal(2, loadedRemote1.Count);

            pcLocal.Importing = true;

            var loadedWithExternal = pcLocal.Collection.LoadedProjects;

            Assert.Equal(6, loadedWithExternal.Count);

            var prj0Coll = pcLocal.Collection.GetLoadedProjects(proj0Path);

            Assert.Equal(1, prj0Coll.Count);
            Assert.Same(proj0local, prj0Coll.First());

            var prj1Coll = pcLocal.Collection.GetLoadedProjects(proj1Path);

            Assert.Equal(2, prj1Coll.Count);
            Assert.True(prj1Coll.Contains(proj1local));
            Assert.False(prj1Coll.Contains(proj1remote0));

            var prj2Coll = pcLocal.Collection.GetLoadedProjects(proj2Path);

            Assert.Equal(2, prj2Coll.Count);
            Assert.False(prj2Coll.Contains(proj2remote0));
            Assert.False(prj2Coll.Contains(proj2remote1));
            foreach (var p in prj2Coll)
            {
                ViewValidation.VerifyLinkedNotNull(p);
            }

            var prj3Coll = pcLocal.Collection.GetLoadedProjects(proj3Path);

            Assert.Equal(1, prj3Coll.Count);
            Assert.False(prj2Coll.Contains(proj3remote1));
            ViewValidation.VerifyLinkedNotNull(prj3Coll.FirstOrDefault());
        }