コード例 #1
0
        public void VerifyOptimized()
        {
            var test = new SerializableProject
            {
                Cases = new List <Case>
                {
                    new SimpleCase
                    {
                        Name       = "Simple",
                        Number     = 1,
                        ModesCount = 2,
                        Records    = new List <LoadRecord>
                        {
                            new LoadRecord
                            {
                                Description = "DO NOT WORK :("
                            }
                        }
                    },
                    new CaseCombination()
                    {
                        Number = 2,
                        Name   = "A",
                        label  = "C"
                    }
                }
            };
            var support = new ConfigurationContainer()
                          .UseOptimizedNamespaces()             //WITHOUT IT WORKS
                          .ForTesting();

            // ShouldBeEquivalentTo doesn't work
            support.Cycle(test)
            .Should().BeEquivalentTo(test, options => options.RespectingRuntimeTypes());
        }
コード例 #2
0
        public void ProjectRoundTrip()
        {
            string data       = SerializableProject.Serialize(project);
            var    newProject = SerializableProject.Deserialize(data);

            Assert.AreEqual(project.Name, newProject.Name);
            Assert.AreEqual(project.Description, newProject.Description);

            foreach (var task in project.Tasks)
            {
                var newTask = newProject.GetTaskById(task.Id);
                Assert.IsNotNull(newTask);
                Assert.AreEqual(task.Name, newTask.Name);
                Assert.AreEqual(task.Description, newTask.Description);

                // Check ancestors
                foreach (var taskAncestor in task.Ancestors)
                {
                    var newTaskAncestor = newTask.Ancestors.First(x => x.Id == taskAncestor.Id);
                    Assert.IsNotNull(newTaskAncestor);
                }

                // Check descendants
                foreach (var taskDescendant in task.Descendants)
                {
                    var newTaskDescendant = newTask.Descendants.First(x => x.Id == taskDescendant.Id);
                    Assert.IsNotNull(newTaskDescendant);
                }
            }
        }
コード例 #3
0
        private static void AddTestLibrary(RubberduckParserState state, SerializableProject deserialized)
        {
            var declarations = deserialized.Unwrap();

            foreach (var declaration in declarations)
            {
                state.AddDeclaration(declaration);
            }
        }
コード例 #4
0
        private static void AddTestLibrary(RubberduckParserState state, SerializableProject deserialized)
        {
            var declarations = deserialized.Unwrap();

            foreach (var members in declarations.Where(d => d.DeclarationType != DeclarationType.Project &&
                                                       d.ParentDeclaration.DeclarationType == DeclarationType.ClassModule &&
                                                       ProceduralTypes.Contains(d.DeclarationType))
                     .GroupBy(d => d.ParentDeclaration))
            {
                state.CoClasses.TryAdd(members.Select(m => m.IdentifierName).ToList(), members.First().ParentDeclaration);
            }

            foreach (var declaration in declarations)
            {
                state.AddDeclaration(declaration);
            }
        }