public void Test_Common()
        {
            using (GDMGroupRecord grpRec = new GDMGroupRecord(fContext.Tree)) {
                Assert.IsNotNull(grpRec);

                grpRec.ResetOwner(fContext.Tree);
                Assert.AreEqual(fContext.Tree, grpRec.GetTree());
            }

            using (GDMGroupRecord groupRec = fContext.Tree.CreateGroup()) {
                GDMIndividualRecord member = fContext.Tree.XRefIndex_Find("I1") as GDMIndividualRecord;

                groupRec.GroupName = "Test Group";
                Assert.AreEqual("Test Group", groupRec.GroupName);

                using (GDMGroupRecord group3 = fContext.Tree.CreateGroup()) {
                    var matchParams = new MatchParams();
                    matchParams.NamesIndistinctThreshold = 100.0f;

                    Assert.AreEqual(0.0f, groupRec.IsMatch(null, matchParams));

                    group3.GroupName = "Test group";
                    Assert.AreEqual(100.0f, groupRec.IsMatch(group3, matchParams));

                    group3.GroupName = "test";
                    Assert.AreEqual(0.0f, groupRec.IsMatch(group3, matchParams));
                }

                bool res = groupRec.AddMember(null);
                Assert.IsFalse(res);

                res = groupRec.RemoveMember(null);
                Assert.IsFalse(res);

                Assert.AreEqual(-1, groupRec.IndexOfMember(null));

                groupRec.AddMember(member);
                Assert.AreEqual(0, groupRec.IndexOfMember(member));

                using (var group2 = fContext.Tree.CreateGroup()) {
                    Assert.Throws(typeof(ArgumentException), () => {
                        group2.Assign(null);
                    });

                    group2.Assign(groupRec);

                    string buf = TestUtils.GetTagStreamText(group2, 0);
                    Assert.AreEqual("0 @G4@ _GROUP\r\n" +
                                    "1 NAME Test Group\r\n" +
                                    "1 _MEMBER @I1@\r\n", buf);
                }

                groupRec.RemoveMember(member);
                Assert.AreEqual(-1, groupRec.IndexOfMember(member));

                groupRec.ReplaceXRefs(new GDMXRefReplacer());

                Assert.IsFalse(groupRec.IsEmpty());
                groupRec.Clear();
                Assert.IsTrue(groupRec.IsEmpty());
            }
        }
Exemple #2
0
        public void Test_Common()
        {
            GDMTree tree = new GDMTree();

            Assert.IsNotNull(tree);

            Assert.IsNotNull(tree.GetSubmitter());

            // Tests of event handlers
            tree.OnChange   += OnTreeChange;
            tree.OnChanging += OnTreeChanging;
            tree.OnProgress += OnTreeProgress;

            tree.BeginUpdate();
            Assert.IsTrue(tree.IsUpdated());

            GDMRecord rec;

            GDMIndividualRecord iRec = tree.CreateIndividual();

            Assert.IsNotNull(iRec, "CreateIndividual() != null");

            string xref = iRec.XRef;

            rec = tree.XRefIndex_Find(xref);
            Assert.IsNotNull(rec);
            Assert.AreEqual(xref, rec.XRef);

            string uid = iRec.UID;

            rec = tree.FindUID(uid);
            Assert.IsNotNull(rec);
            Assert.AreEqual(uid, rec.UID);
            Assert.IsNull(tree.FindUID(""));

            //
            GDMFamilyRecord famRec = tree.CreateFamily();

            Assert.IsNotNull(famRec, "CreateFamily() != null");

            //
            GDMNoteRecord noteRec = tree.CreateNote();

            Assert.IsNotNull(noteRec, "CreateNote() != null");

            //
            GDMRepositoryRecord repRec = tree.CreateRepository();

            Assert.IsNotNull(repRec, "CreateRepository() != null");

            //
            GDMSourceRecord srcRec = tree.CreateSource();

            Assert.IsNotNull(srcRec, "CreateSource() != null");

            //
            GDMMultimediaRecord mmRec = tree.CreateMultimedia();

            Assert.IsNotNull(mmRec, "CreateMultimedia() != null");

            //

            GDMRecord sbmrRec = tree.AddRecord(new GDMSubmitterRecord(tree));

            Assert.IsNotNull(sbmrRec, "sbmrRec != null");
            sbmrRec.InitNew();
            string submXRef = sbmrRec.XRef;

            //

            GDMSubmissionRecord submRec = tree.AddRecord(new GDMSubmissionRecord(tree)) as GDMSubmissionRecord;

            Assert.IsNotNull(submRec, "rec1 != null");
            submRec.InitNew();

            //
            GDMGroupRecord groupRec = tree.CreateGroup();

            Assert.IsNotNull(groupRec, "CreateGroup() != null");

            //
            GDMTaskRecord taskRec = tree.CreateTask();

            Assert.IsNotNull(taskRec, "CreateTask() != null");

            //
            GDMCommunicationRecord commRec = tree.CreateCommunication();

            Assert.IsNotNull(commRec, "CreateCommunication() != null");

            //
            GDMResearchRecord resRec = tree.CreateResearch();

            Assert.IsNotNull(resRec, "CreateResearch() != null");

            //
            GDMLocationRecord locRec = tree.CreateLocation();

            Assert.IsNotNull(locRec, "CreateLocation() != null");

            tree.EndUpdate();
            Assert.IsFalse(tree.IsUpdated());

            tree.OnChange   -= OnTreeChange;
            tree.OnChanging -= OnTreeChanging;
            tree.OnProgress -= OnTreeProgress;

            int       size  = 0;
            var       enum1 = tree.GetEnumerator(GDMRecordType.rtNone);
            GDMRecord rec1;

            enum1.Reset();
            while (enum1.MoveNext(out rec1))
            {
                size++;
            }
            Assert.AreEqual(14, size);

            for (int i = 0; i < tree.RecordsCount; i++)
            {
                GDMRecord rec2 = tree[i];
                Assert.IsNotNull(rec2);

                string    xref2 = rec2.XRef;
                GDMRecord rec3  = tree.XRefIndex_Find(xref2);
                Assert.IsNotNull(rec3);
                Assert.AreEqual(rec2, rec3);

                /*string uid = rec2.UID;
                 * GEDCOMRecord rec4 = tree.FindUID(uid);
                 * Assert.IsNotNull(rec4);
                 * Assert.AreEqual(rec2, rec4);*/

                int idx = tree.IndexOf(rec2);
                Assert.AreEqual(i, idx);
            }

            var recordsX = tree.GetRecords <GDMIndividualRecord>();

            Assert.IsNotNull(recordsX);
            Assert.AreEqual(1, recordsX.Count);

            int[] stats = tree.GetRecordStats();
            Assert.IsNotNull(stats);
            Assert.AreEqual(14, stats.Length);

            Assert.IsFalse(tree.IsEmpty);

            Assert.IsFalse(tree.DeleteFamilyRecord(null));
            Assert.IsTrue(tree.DeleteFamilyRecord(famRec));

            Assert.IsFalse(tree.DeleteNoteRecord(null));
            Assert.IsTrue(tree.DeleteNoteRecord(noteRec));

            Assert.IsFalse(tree.DeleteSourceRecord(null));
            Assert.IsTrue(tree.DeleteSourceRecord(srcRec));

            Assert.IsFalse(tree.DeleteGroupRecord(null));
            Assert.IsTrue(tree.DeleteGroupRecord(groupRec));

            Assert.IsFalse(tree.DeleteLocationRecord(null));
            Assert.IsTrue(tree.DeleteLocationRecord(locRec));

            Assert.IsFalse(tree.DeleteResearchRecord(null));
            Assert.IsTrue(tree.DeleteResearchRecord(resRec));

            Assert.IsFalse(tree.DeleteCommunicationRecord(null));
            Assert.IsTrue(tree.DeleteCommunicationRecord(commRec));

            Assert.IsFalse(tree.DeleteTaskRecord(null));
            Assert.IsTrue(tree.DeleteTaskRecord(taskRec));

            Assert.IsFalse(tree.DeleteMediaRecord(null));
            Assert.IsTrue(tree.DeleteMediaRecord(mmRec));

            Assert.IsFalse(tree.DeleteIndividualRecord(null));
            Assert.IsTrue(tree.DeleteIndividualRecord(iRec));

            Assert.IsFalse(tree.DeleteRepositoryRecord(null));
            Assert.IsTrue(tree.DeleteRepositoryRecord(repRec));

            tree.Clear();
            Assert.AreEqual(0, tree.RecordsCount);
            Assert.IsTrue(tree.IsEmpty);

            tree.State = GDMTreeState.osReady;
            Assert.AreEqual(GDMTreeState.osReady, tree.State);


            // Tests of GEDCOMTree.Extract()
            using (GDMTree tree2 = new GDMTree()) {
                GDMIndividualRecord iRec2 = tree.AddRecord(new GDMIndividualRecord(tree2)) as GDMIndividualRecord;
                Assert.IsNotNull(iRec2);
                iRec2.InitNew();

                tree2.AddRecord(iRec2);
                int rIdx = tree2.IndexOf(iRec2);
                Assert.IsTrue(rIdx >= 0);
                GDMRecord extractedRec = tree2.Extract(rIdx);
                Assert.AreEqual(iRec2, extractedRec);
                Assert.IsTrue(tree2.IndexOf(iRec2) < 0);
            }
        }
        public void Test_GEDCOMResearchRecord()
        {
            GDMCommunicationRecord commRec = fContext.Tree.CreateCommunication();

            Assert.IsNotNull(commRec);

            GDMTaskRecord taskRec = fContext.Tree.CreateTask();

            Assert.IsNotNull(taskRec);

            GDMGroupRecord groupRec = fContext.Tree.CreateGroup();

            Assert.IsNotNull(groupRec);

            using (GDMResearchRecord resRec = fContext.Tree.CreateResearch()) {
                resRec.ResetTree(fContext.Tree);

                Assert.IsNotNull(resRec.Communications);
                Assert.IsNotNull(resRec.Groups);
                Assert.IsNotNull(resRec.Tasks);

                resRec.ResearchName = "Test Research";
                Assert.AreEqual("Test Research", resRec.ResearchName);

                resRec.Priority = GDMResearchPriority.rpNormal;
                Assert.AreEqual(GDMResearchPriority.rpNormal, resRec.Priority);

                resRec.Status = GDMResearchStatus.rsOnHold;
                Assert.AreEqual(GDMResearchStatus.rsOnHold, resRec.Status);

                resRec.StartDate.Date = TestUtils.ParseDT("20.01.2013");
                Assert.AreEqual(TestUtils.ParseDT("20.01.2013"), resRec.StartDate.Date);

                resRec.StopDate.Date = TestUtils.ParseDT("21.01.2013");
                Assert.AreEqual(TestUtils.ParseDT("21.01.2013"), resRec.StopDate.Date);

                resRec.Percent = 33;
                Assert.AreEqual(33, resRec.Percent);

                Assert.Throws(typeof(ArgumentException), () => {
                    resRec.Assign(null);
                });

                string buf = TestUtils.GetTagStreamText(resRec, 0);
                Assert.AreEqual("0 @RS2@ _RESEARCH\r\n" +
                                "1 _STARTDATE 20 JAN 2013\r\n" +
                                "1 _STOPDATE 21 JAN 2013\r\n" +
                                "1 NAME Test Research\r\n" +
                                "1 _PRIORITY normal\r\n" +
                                "1 _STATUS onhold\r\n" +
                                "1 _PERCENT 33\r\n", buf);

                Assert.AreEqual(-1, resRec.IndexOfCommunication(null));
                resRec.AddCommunication(commRec);
                resRec.RemoveCommunication(commRec);
                resRec.RemoveCommunication(null);

                Assert.AreEqual(-1, resRec.IndexOfTask(null));
                resRec.AddTask(taskRec);
                resRec.RemoveTask(taskRec);
                resRec.RemoveTask(null);

                Assert.AreEqual(-1, resRec.IndexOfGroup(null));
                resRec.AddGroup(groupRec);
                resRec.RemoveGroup(groupRec);
                resRec.RemoveGroup(null);

                resRec.ReplaceXRefs(new GDMXRefReplacer());

                Assert.IsFalse(resRec.IsEmpty());
                resRec.Clear();
                Assert.IsTrue(resRec.IsEmpty());
            }
        }