public virtual void TestAdd_IAtomContainer()
        {
            var container = new ConformerContainer(confs);

            base_.Title = "junk";
            container.Add(base_);
        }
        public virtual void TestAddAll_Collection()
        {
            var container = new ConformerContainer(confs);

            Assert.AreEqual(nconfs, container.Count());
            Assert.IsTrue(container.Contains(container[3]));
        }
        public virtual void TestContains_Object()
        {
            var container = new ConformerContainer(confs);

            Assert.AreEqual(nconfs, container.Count());
            Assert.IsTrue(container.Contains(container[3]));
        }
        public virtual void TestConformerContainer_arrayIAtomContainer()
        {
            var container = new ConformerContainer(confs);

            Assert.IsNotNull(container);
            Assert.AreEqual(nconfs, container.Count());
        }
        public virtual void TestConformerContainer_IAtomContainer()
        {
            var container = new ConformerContainer(base_);

            Assert.IsNotNull(container);
            Assert.AreEqual(1, container.Count());
        }
        public virtual void TestToArray()
        {
            var container = new ConformerContainer(confs);
            var array     = (IAtomContainer[])container.ToArray();

            Assert.AreEqual(nconfs, array.Length);
        }
        public virtual void TestContains()
        {
            var container = new ConformerContainer(confs);
            var o         = container[0];

            Assert.IsTrue(container.Contains(o));
        }
        public virtual void TestClear()
        {
            var container = new ConformerContainer(confs);

            Assert.AreEqual(nconfs, container.Count());
            container.Clear();
            Assert.AreEqual(0, container.Count());
        }
        public virtual void TestSet_int_Object()
        {
            var container = new ConformerContainer(confs);
            int location  = 5;

            container.Set(location, container[location + 1]);
            Assert.AreEqual(location, container.IndexOf(container[location + 1]));
        }
        public virtual void TestIndexOf_IAtomContainer()
        {
            var container = new ConformerContainer(confs);
            var ac        = container[2];
            var index     = container.IndexOf(ac);

            Assert.AreEqual(2, index);
        }
        static PharmacophoreUtilityTest()
        {
            var filename = "NCDK.Data.MDL.pcoretest1.sdf";
            var ins      = ResourceLoader.GetAsStream(filename);
            var reader   = new EnumerableMDLConformerReader(ins, ChemObjectBuilder.Instance);

            conformers = reader.FirstOrDefault();
        }
        public virtual void TestGet2()
        {
            var container = new ConformerContainer(confs);

            for (var i = 0; i < container.Count + 1; i++)
            {
                var dummy = container[i];
            }
        }
        public virtual void TestLastIndexOf_Object()
        {
            var container = new ConformerContainer(confs);

            Assert.AreEqual(nconfs, container.Count());
            int x = container.LastIndexOf(container[3]);

            Assert.AreEqual(3, container.LastIndexOf(container[3]));
        }
        public virtual void TestAdd_Object()
        {
            var container = new ConformerContainer();

            Assert.IsNotNull(container);
            foreach (var conf in confs)
            {
                container.Add(conf);
            }
            Assert.AreEqual(nconfs, container.Count());
        }
        public virtual void TestContainsAll_Collection()
        {
            var container = new ConformerContainer(confs);

            Assert.IsNotNull(container);
            Assert.AreEqual(nconfs, container.Count());
            foreach (var e in container)
            {
                Assert.IsTrue(container.Contains(e));
            }
        }
        public virtual void TestIterator2()
        {
            var container = new ConformerContainer(confs);
            int nmol      = 0;

            foreach (var conf in container)
            {
                nmol++;
            }
            Assert.AreEqual(nconfs, nmol);
        }
        static PharmacophoreMatcherTest()
        {
            var filename = "NCDK.Data.MDL.pcoretest1.sdf";
            var ins      = ResourceLoader.GetAsStream(filename);
            var reader   = new EnumerableMDLConformerReader(ins, CDK.Builder).GetEnumerator();

            if (reader.MoveNext())
            {
                conformers = (ConformerContainer)reader.Current;
            }
        }
        public virtual void TestRemove_Object()
        {
            ConformerContainer cContainer = new ConformerContainer(confs);

            Assert.AreEqual(nconfs, cContainer.Count());
            IAtomContainer container = cContainer[3];

            Assert.IsTrue(cContainer.Contains(container));
            cContainer.Remove(container);
            Assert.AreEqual(nconfs - 1, cContainer.Count());
            Assert.IsFalse(cContainer.Contains(container));
        }
        public virtual void TestRemoveAll_Collection()
        {
            var container = new ConformerContainer(confs);

            Assert.IsNotNull(container);
            Assert.AreEqual(nconfs, container.Count());

            foreach (var e in container)
            {
                container.Remove(e);
            }
            Assert.AreEqual(0, container.Count());
        }
        public virtual void TestIndexOf_Object()
        {
            var container = new ConformerContainer(confs);

            Assert.IsNotNull(container);

            int counter = 0;

            foreach (var conf in confs)
            {
                Assert.AreEqual(counter, container.IndexOf(conf));
                counter++;
            }
        }
        public virtual void TestConformerContainer()
        {
            var container = new ConformerContainer();

            Assert.IsNotNull(container);
            base_.Title = "myMolecule";
            container.Add(base_);
            Assert.AreEqual(1, container.Count());

            foreach (var conf in confs)
            {
                container.Add(conf);
            }
            Assert.AreEqual(nconfs + 1, container.Count());
        }
        public virtual void TestRemove_int()
        {
            var container = new ConformerContainer(confs);

            container.Clear();
            Assert.AreEqual(0, container.Count());

            for (int i = 0; i < nconfs; i++)
            {
                container.Add(confs[i]);
            }
            Assert.AreEqual(nconfs, container.Count());

            container.RemoveAt(0);
            Assert.AreEqual(nconfs - 1, container.Count());
        }
        public virtual void TestAdd_int_IAtomContainer()
        {
            ConformerContainer container = new ConformerContainer(confs);

            container.Insert(5, confs[5]);
        }
        public virtual void TestGetTitle()
        {
            var container = new ConformerContainer(confs);

            Assert.AreEqual("myMolecule", container.Title);
        }
        public virtual void TestIsEmpty()
        {
            var container = new ConformerContainer(confs);

            Assert.IsTrue(!container.IsEmpty());
        }
 public virtual void TestGet_int()
 {
     var container = new ConformerContainer(confs);
     var dummy     = container[100];
 }
        public virtual void TestAdd_int_Object()
        {
            var container = new ConformerContainer(confs);

            container.Insert(5, confs[5]);
        }
        public virtual void TestSize()
        {
            ConformerContainer container = new ConformerContainer(confs);

            Assert.AreEqual(nconfs, container.Count());
        }