public void NestedSequencesBlank_RemovalAllExceptSequence()
        {
            var ds = new DicomDataset(
                new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "1.2.3"),
                new DicomSequence(DicomTag.RTROIObservationsSequence,
                                  new DicomDataset(new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "1.2.3"))));

            var anon = GetAnonEngine(Mode.blank);
            var th   = new TestHanlder(new Dictionary <DicomTag, AnonFunc>()
            {
                { DicomTag.RTROIObservationsSequence, (x, s, y) => { return(y); } }
            }, null);

            anon.RegisterHandler(th);

            var nds = anon.Anonymize(ds);

            // Assert no changes happened to the original object
            Assert.AreEqual("1.2.3", ds.GetSingleValue <string>(DicomTag.SOPInstanceUID));
            Assert.IsTrue(ds.Contains(DicomTag.RTROIObservationsSequence));
            Assert.AreEqual(1, ds.GetSequence(DicomTag.RTROIObservationsSequence).Items.Count);
            Assert.AreEqual("1.2.3", ds.GetSequence(DicomTag.RTROIObservationsSequence).Items[0].GetSingleValue <string>(DicomTag.SOPInstanceUID));

            Assert.IsFalse(nds.Contains(DicomTag.SOPInstanceUID));
            Assert.IsTrue(nds.Contains(DicomTag.RTROIObservationsSequence));
            Assert.AreEqual(0, nds.GetSequence(DicomTag.RTROIObservationsSequence).Items.Count);
        }
        public void ForceRegisterHandlerShouldAllowOverwriting()
        {
            var anon = GetAnonEngine(Mode.clone);
            var th   = new TestHanlder();

            // Execute the empty function
            anon.RegisterHandler(th);

            var ds = new DicomDataset(new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "1.2.3"));

            anon.Anonymize(ds);

            th = new TestHanlder(new Dictionary <DicomTag, AnonFunc>()
            {
                { DicomTag.SOPInstanceUID, (x, s, y) => { throw new Exception("Hello"); } }
            }, null);
            anon.ForceRegisterHandler(th);

            // Execute the throwing function
            try
            {
                anon.Anonymize(ds);
            }
            catch (Exception e)
            {
                Assert.AreEqual("Hello", e.Message);
            }
        }
        public void IgnoreNullReturnsInActions()
        {
            var anon = new AnonymizeEngine(Mode.inplace);
            var th   = new TestHanlder(null, null);

            anon.RegisterHandler(th);
            anon.ForceRegisterHandler(th);
        }
        public void RegisterHandlerShouldNotAllowOverwriting()
        {
            var anon = GetAnonEngine(Mode.inplace);
            var th   = new TestHanlder(new Dictionary <DicomTag, AnonFunc>()
            {
                { DicomTag.SOPInstanceUID, (x, s, y) => { return(y); } }
            }, null);

            anon.RegisterHandler(th);
            anon.RegisterHandler(th);
        }
        public void TestDescriptionIsRequired()
        {
            var      anon = new AnonymizeEngine(Mode.clone);
            AnonFunc f    = (o, s, i) => { return(null); };
            var      th   = new TestHanlder(new Dictionary <DicomTag, AnonFunc>()
            {
                { DicomTag.SOPInstanceUID, f }
            }, null);

            anon.RegisterHandler(th);
        }
        public void TestTagPath()
        {
            var ds = new DicomDataset(
                new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "1.2.3"),
                new DicomSequence(DicomTag.RTROIObservationsSequence,
                                  new DicomDataset(new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "1.2.3"),
                                                   new DicomSequence(DicomTag.ReferenceBasisCodeSequence,
                                                                     new DicomDataset(new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "1.2.3"))))));

            var anon = GetAnonEngine(Mode.inplace);

            int      d = 0;
            AnonFunc f = (o, s, i) =>
            {
                if (d == 0)
                {
                    Assert.AreEqual(0, s.Count);
                    d++;
                }
                else if (d == 1)
                {
                    Assert.AreEqual(2, s.Count);
                    Assert.AreEqual(DicomTag.RTROIObservationsSequence, s[0].Tag);
                    Assert.IsTrue(s[0].IsTag);
                    Assert.AreEqual(0, s[1].Index);
                    Assert.IsFalse(s[1].IsTag);
                    d++;
                }
                else if (d == 2)
                {
                    Assert.AreEqual(4, s.Count);
                    Assert.AreEqual(DicomTag.RTROIObservationsSequence, s[0].Tag);
                    Assert.AreEqual(DicomTag.ReferenceBasisCodeSequence, s[2].Tag);
                }
                return(i);
            };
            var th = new TestHanlder(new Dictionary <DicomTag, AnonFunc>()
            {
                { DicomTag.SOPInstanceUID, f }
            }, null);

            anon.RegisterHandler(th);

            anon.Anonymize(ds);
        }
        public void TestNextDataset()
        {
            var      ds   = new DicomDataset(new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "1.2.3"));
            var      anon = GetAnonEngine(Mode.clone);
            AnonFunc f    = (o, s, i) => { return(null); };
            var      th   = new TestHanlder(new Dictionary <DicomTag, AnonFunc>()
            {
                { DicomTag.SOPInstanceUID, f }
            }, null);

            anon.RegisterHandler(th);

            anon.Anonymize(ds);
            Assert.AreEqual(1, th.State);

            anon.Anonymize(ds);
            Assert.AreEqual(2, th.State);
        }
        public void NestedSequencesInPlace()
        {
            var ds = new DicomDataset(
                new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "1.2.3"),
                new DicomSequence(DicomTag.RTROIObservationsSequence,
                                  new DicomDataset(new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "1.2.3"))));

            var anon = GetAnonEngine(Mode.inplace);
            var th   = new TestHanlder(new Dictionary <DicomTag, AnonFunc>()
            {
                { DicomTag.SOPInstanceUID, (x, s, y) => { return(new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "3.2.1")); } }
            }, null);

            anon.RegisterHandler(th);

            anon.Anonymize(ds);

            Assert.AreEqual("3.2.1", ds.GetSingleValue <string>(DicomTag.SOPInstanceUID));
            Assert.AreEqual(1, ds.GetSequence(DicomTag.RTROIObservationsSequence).Items.Count);
            Assert.AreEqual("3.2.1", ds.GetSequence(DicomTag.RTROIObservationsSequence).Items[0].GetSingleValue <string>(DicomTag.SOPInstanceUID));
        }
        public void HandlerOverwriteReporting()
        {
            var anon = GetAnonEngine(Mode.clone);
            var th   = new TestHanlder(new Dictionary <DicomTag, AnonFunc>()
            {
                { DicomTag.RTROIObservationsSequence, (x, s, y) => { return(y); } },
                { DicomTag.SOPInstanceUID, (x, s, y) => { return(y); } }
            },
                                       new Dictionary <Regex, AnonFunc>()
            {
                { new Regex(".*"), (x, s, y) => { return(y); } },
                { new Regex(".*2"), (x, s, y) => { return(y); } },
            });

            anon.RegisterHandler(th);
            var report = anon.ForceRegisterHandler(th);

            Assert.AreEqual(4, report.Count);
            var exp = DicomTag.RTROIObservationsSequence.DictionaryEntry.Name + " " + DicomTag.RTROIObservationsSequence.ToString().ToUpper();

            Assert.AreEqual(exp, report[0]);
            Assert.AreEqual(".*", report[2]);
        }