public void Setup()
        {
            UnityEngine.Assertions.Assert.raiseExceptions = true;

            _identity1 = new Identity()
            {
                owner = 1
            };
            _identity2 = new Identity()
            {
                owner = 2
            };
            _identity3 = new Identity()
            {
                owner = 3
            };

            _collection1 = new MockCollection()
            {
                ID = System.Guid.NewGuid(), collectionName = "Collection1", owner = _identity1
            };
            _collection2 = new MockCollection()
            {
                ID = System.Guid.NewGuid(), collectionName = "Collection2", owner = _identity1
            };
            _collection3 = new MockCollection()
            {
                ID = System.Guid.NewGuid(), collectionName = "Collection3", owner = _identity1
            };

            _permissions = new NetworkPermissionsMap <MockCollection, Identity>();
        }
        public void RemoveEventListenerTest()
        {
            int eventFireCount = 0;
            PermissionChangedResult <MockCollection, Identity> changedResult = null;

            var callback1 = new NetworkPermissionsMap <MockCollection, Identity> .OnPermissionChangedDelegate(data =>
            {
                changedResult = data;
                eventFireCount++;
            });

            _permissions.AddEventListener(_identity2, callback1);

            _permissions.SetPermission(_collection1, _identity2, ReadWritePermission.ReadWrite);

            var removed = _permissions.RemoveEventListener(_identity2, callback1);

            _permissions.SetPermission(_collection2, _identity2, ReadWritePermission.Read);
            _permissions.SetPermission(_collection1, _identity2, ReadWritePermission.None);

            Assert.AreEqual(1, eventFireCount);
            Assert.AreEqual(_identity2, changedResult.identity);
            Assert.AreEqual(_collection1, changedResult.obj);
            Assert.AreEqual(ReadWritePermission.ReadWrite, changedResult.permission);

            Assert.IsTrue(removed);
        }
        public void RemoveEventListenersTest()
        {
            var callback1 = new NetworkPermissionsMap <MockCollection, Identity> .OnPermissionChangedDelegate(data =>
                                                                                                              { });

            var removed1 = _permissions.RemoveEventListener(_identity2, null);
            var removed2 = _permissions.RemoveEventListener(_identity2, callback1);

            Assert.IsFalse(removed1);
            Assert.IsFalse(removed2);
        }
        public void RemoveEventListenerTest2()
        {
            int eventFireCount1 = 0;
            int eventFireCount2 = 0;
            int eventFireCount3 = 0;
            PermissionChangedResult <MockCollection, Identity> changedResult1 = null;
            PermissionChangedResult <MockCollection, Identity> changedResult2 = null;
            PermissionChangedResult <MockCollection, Identity> changedResult3 = null;

            var callback1 = new NetworkPermissionsMap <MockCollection, Identity> .OnPermissionChangedDelegate(data =>
            {
                changedResult1 = data;
                eventFireCount1++;
            });

            var callback2 = new NetworkPermissionsMap <MockCollection, Identity> .OnPermissionChangedDelegate(data =>
            {
                changedResult2 = data;
                eventFireCount2++;
            });

            var callback3 = new NetworkPermissionsMap <MockCollection, Identity> .OnPermissionChangedDelegate(data =>
            {
                changedResult3 = data;
                eventFireCount3++;
            });

            _permissions.AddEventListener(_identity2, callback1);
            _permissions.AddEventListener(_identity2, callback2);
            _permissions.AddEventListener(_identity2, callback3);

            _permissions.SetPermission(_collection1, _identity2, ReadWritePermission.ReadWrite);

            _permissions.RemoveEventListener(_identity2, callback1);

            _permissions.SetPermission(_collection2, _identity2, ReadWritePermission.Read);

            _permissions.RemoveEventListener(_identity2, callback2);

            _permissions.SetPermission(_collection1, _identity2, ReadWritePermission.None);

            Assert.AreEqual(1, eventFireCount1);
            Assert.AreEqual(2, eventFireCount2);
            Assert.AreEqual(3, eventFireCount3);
            Assert.AreEqual(_identity2, changedResult1.identity);
            Assert.AreEqual(_identity2, changedResult2.identity);
            Assert.AreEqual(_identity2, changedResult3.identity);
            Assert.AreEqual(_collection1, changedResult1.obj);
            Assert.AreEqual(_collection2, changedResult2.obj);
            Assert.AreEqual(_collection1, changedResult3.obj);
            Assert.AreEqual(ReadWritePermission.ReadWrite, changedResult1.permission);
            Assert.AreEqual(ReadWritePermission.Read, changedResult2.permission);
            Assert.AreEqual(ReadWritePermission.None, changedResult3.permission);
        }
        public void RemoveListenerFromNonExistingIdentityTest()
        {
            var callback1 = new NetworkPermissionsMap <MockCollection, Identity> .OnPermissionChangedDelegate(data =>
                                                                                                              { });

            _permissions.SetPermission(_collection1, _identity2, ReadWritePermission.ReadWrite);
            _permissions.SetPermission(_collection2, _identity2, ReadWritePermission.Read);
            _permissions.SetPermission(_collection1, _identity2, ReadWritePermission.None);

            var removed1 = _permissions.RemoveEventListener(_identity2, callback1);
            var removed2 = _permissions.RemoveEventListener(_identity1, callback1);

            Assert.IsFalse(removed1);
            Assert.IsFalse(removed2);
        }