Esempio n. 1
0
        public void ShouldThrowExceptionWhenTryingToInsertItemOfExistingType()
        {
            var set = new TypedSet <FooBase>();

            set.Insert(new Foo1());
            set.Insert(new Foo2());
            Assert.Throws(typeof(Exception), () =>
            {
                set.Insert(new Foo1());
            }, $"Collection already contains an item of type {new Foo1().GetType()}");
        }
Esempio n. 2
0
        public void ShouldReturnNullIfEmpty()
        {
            //arrange
            var set = new TypedSet <FooBase>();

            //act
            var returnedItem = set.Get <Foo1>();

            //assert
            Assert.AreEqual(null, returnedItem);
        }
Esempio n. 3
0
        public void ShouldAllowToInsertItemsOfDifferentType()
        {
            //arrange
            var set = new TypedSet <FooBase>();

            //act
            set.Insert(new Foo1());
            set.Insert(new Foo2());
            set.Insert(new Foo3());

            //assert
            Assert.AreEqual(3, set.Count());
        }
Esempio n. 4
0
        public void ShouldReturnNullIfDoesNotContain()
        {
            //arrange
            var set = new TypedSet <FooBase>();

            set.Insert(new Foo1());
            set.Insert(new Foo2());

            //act
            var returnedItem = set.Get <Foo3>();

            //assert
            Assert.AreEqual(null, returnedItem);
        }
Esempio n. 5
0
        public void ShouldTellFalseIfContainsItemOfDesiredType()
        {
            //arrange
            var set = new TypedSet <FooBase>();

            set.Insert(new Foo1());
            set.Insert(new Foo2());

            //act
            var result = set.Contains <Foo3>();

            //assert
            Assert.IsFalse(result);
        }
Esempio n. 6
0
        public void ShouldReturnItemOfDesiredTypeIfContains()
        {
            //arrange
            var set         = new TypedSet <FooBase>();
            var desiredItem = new Foo3();

            set.Insert(new Foo1());
            set.Insert(new Foo2());
            set.Insert(desiredItem);

            //act
            var returnedItem = set.Get <Foo3>();

            //assert
            Assert.AreEqual(desiredItem, returnedItem);
        }
Esempio n. 7
0
        public void ShouldDoNothingIfItemOfDesiredTypeDoesNotExistInSet()
        {
            //arrange
            var set          = new TypedSet <FooBase>();
            var itemToRemove = new Foo3();

            set.Insert(new Foo1());
            set.Insert(new Foo2());

            //act
            set.Remove(itemToRemove);
            var containsResult = set.Contains <Foo2>();

            //assert
            Assert.AreEqual(true, containsResult);
            Assert.AreEqual(2, set.Count());
        }
Esempio n. 8
0
        public void ShouldRemoveItemOfDesiredTypeIfExistsInSet()
        {
            //arrange
            var set          = new TypedSet <FooBase>();
            var itemToRemove = new Foo2();

            set.Insert(new Foo1());
            set.Insert(itemToRemove);

            //act
            set.Remove(itemToRemove);
            var containsResult = set.Contains <Foo2>();

            //assert
            Assert.AreEqual(false, containsResult);
            Assert.AreEqual(1, set.Count());
        }
 /**
  * Returns a typed set backed by the given set.
  * <p>
  * Only objects of the specified type can be added to the set.
  *
  * @param set  the set to limit to a specific type, must not be null
  * @param type  the type of objects which may be added to the set
  * @return a typed set backed by the specified set
  */
 public static java.util.Set <Object> typedSet(java.util.Set <Object> set, java.lang.Class type)
 {
     return(TypedSet.decorate(set, type));
 }