Ejemplo n.º 1
0
 internal void RemovePrim(PhysxPrim prim)
 {
     _dynPrims.Remove(prim);
     _allPrims.Remove(prim);
     _collisionRepeatPrims.Remove(prim);
     _kinematicManager.KinematicRemoved(prim);
     _delayedCommands.Remove(prim);
     prim.Dispose();
 }
Ejemplo n.º 2
0
		public void CheckNestedTypes( )
		{
			string xml = String.Format(
				@"<?xml version='1.0'?>" +
				@"<Obfuscator>" +
				@"<Var name='InPath' value='{0}' />" +
				@"<Var name='OutPath' value='{1}' />" +
				@"<Module file='$(InPath)\AssemblyWithNestedTypes.dll'>" +
				@"<SkipType name='TestClasses.ClassA/NestedClassA' />" +
				@"</Module>" +
				@"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath );

			TestHelper.BuildAndObfuscate( "AssemblyWithNestedTypes", string.Empty, xml );

			C5.HashSet<string> typesToFind = new C5.HashSet<string>( );
			typesToFind.Add( "A.A" );
			typesToFind.Add( "A.A/a" );
			typesToFind.Add( "A.A/NestedClassA" );

			AssemblyHelper.CheckAssembly( "AssemblyWithNestedTypes", 3,
				delegate( TypeDefinition typeDef ) { return true; },
				delegate( TypeDefinition typeDef )
				{
					Assert.IsTrue( typesToFind.Contains( typeDef.ToString( ) ), "Type {0} not expected.", typeDef.ToString( ) );
					typesToFind.Remove( typeDef.ToString( ) );
				} );
			Assert.IsTrue( typesToFind.Count == 0, "Not all types found." );
		}
Ejemplo n.º 3
0
 /// <summary>
 ///     Unsubscribe from receiving notification when the transaction ends.
 /// </summary>
 /// <param name="subscriber">
 ///     The subscriber not to be notified when the transaction ends.
 /// </param>
 /// <returns>
 ///     <see langword="true"/> the subscriber was successfully unsubscribed
 ///     <see langword="false"/> the subscriber was not subscribed
 /// </returns>
 /// <remarks>
 ///     The subscription is OK to handle large number of subscribers.
 /// </remarks>
 public bool Unsubscribe(ITransactionNotification subscriber)
 {
     lock (_watchers)
     {
         return(_watchers.Remove(subscriber));
     }
 }
Ejemplo n.º 4
0
        public void CheckNestedTypes()
        {
            string xml = String.Format(
                @"<?xml version='1.0'?>" +
                @"<Obfuscator>" +
                @"<Var name='InPath' value='{0}' />" +
                @"<Var name='OutPath' value='{1}' />" +
                @"<Module file='$(InPath)\AssemblyWithNestedTypes.dll'>" +
                @"<SkipType name='TestClasses.ClassA/NestedClassA' />" +
                @"</Module>" +
                @"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath);

            TestHelper.BuildAndObfuscate("AssemblyWithNestedTypes", string.Empty, xml);

            C5.HashSet <string> typesToFind = new C5.HashSet <string> ();
            typesToFind.Add("A.A");
            typesToFind.Add("A.A/a");
            typesToFind.Add("A.A/NestedClassA");

            AssemblyHelper.CheckAssembly("AssemblyWithNestedTypes", 1,
                                         delegate(TypeDefinition typeDef) {
                return(true);
            },
                                         delegate(TypeDefinition typeDef) {
                Assert.IsTrue(typesToFind.Contains(typeDef.ToString()), "Type {0} not expected.", typeDef.ToString());
                typesToFind.Remove(typeDef.ToString());
            });
            Assert.IsTrue(typesToFind.Count == 0, "Not all types found.");
        }
Ejemplo n.º 5
0
        public static void CheckAssembly(string name, int expectedTypes, string[] expectedMethods, string[] notExpectedMethods,
                                         Predicate <TypeDefinition> isType, Action <TypeDefinition> checkType)
        {
            C5.HashSet <string> methodsToFind = new C5.HashSet <string>( );
            methodsToFind.AddAll(expectedMethods);
            C5.HashSet <string> methodsNotToFind = new C5.HashSet <string>( );
            methodsNotToFind.AddAll(notExpectedMethods);

            CheckAssembly(name, expectedTypes, isType,
                          delegate(TypeDefinition typeDef)
            {
                // make sure we have enough methods...
                Assert.AreEqual(expectedMethods.Length + notExpectedMethods.Length, typeDef.Methods.Count,
                                "Some of the methods for the type are missing.");

                foreach (MethodDefinition method in typeDef.Methods)
                {
                    Assert.IsFalse(methodsNotToFind.Contains(method.Name), String.Format(
                                       "Did not expect to find method '{0}'.", method.Name));

                    methodsToFind.Remove(method.Name);
                }

                if (checkType != null)
                {
                    checkType(typeDef);
                }
            });

            Assert.IsFalse(methodsToFind.Count > 0, "Failed to find all expected methods.");
        }
Ejemplo n.º 6
0
        protected void CheckEnums(string name, int expectedTypes, string[] expected, string[] notExpected)
        {
            C5.HashSet <string> valsToFind = new C5.HashSet <string>( );
            valsToFind.AddAll(expected);
            C5.HashSet <string> valsNotToFind = new C5.HashSet <string>( );
            valsNotToFind.AddAll(notExpected);

            AssemblyHelper.CheckAssembly(name, expectedTypes,
                                         delegate(TypeDefinition typeDef) { return(typeDef.BaseType.FullName == "System.Enum"); },
                                         delegate(TypeDefinition typeDef)
            {
                // num expected + num unexpected + field storage
                int totalValues = expected.Length + notExpected.Length + 1;
                Assert.AreEqual(totalValues, typeDef.Fields.Count,
                                String.Format("Type should have {0} values.", totalValues));

                foreach (FieldDefinition field in typeDef.Fields)
                {
                    Assert.IsFalse(valsNotToFind.Contains(field.Name), String.Format(
                                       "Did not expect to find event '{0}'.", field.Name));

                    valsToFind.Remove(field.Name);
                }

                Assert.IsFalse(valsToFind.Count > 0, "Failed to find all expected values.");
            });
        }
Ejemplo n.º 7
0
		protected void CheckEnums( string name, int expectedTypes, string[] expected, string[] notExpected )
		{
			C5.HashSet<string> valsToFind = new C5.HashSet<string>( );
			valsToFind.AddAll( expected );
			C5.HashSet<string> valsNotToFind = new C5.HashSet<string>( );
			valsNotToFind.AddAll( notExpected );

			AssemblyHelper.CheckAssembly( name, expectedTypes,
				delegate( TypeDefinition typeDef ) { return typeDef.BaseType.FullName == "System.Enum"; },
				delegate( TypeDefinition typeDef )
				{
					// num expected + num unexpected + field storage
					int totalValues = expected.Length + notExpected.Length + 1;
					Assert.AreEqual( totalValues, typeDef.Fields.Count,
						String.Format( "Type should have {0} values.", totalValues ) );

					foreach ( FieldDefinition field in typeDef.Fields )
					{
						Assert.IsFalse( valsNotToFind.Contains( field.Name ), String.Format(
							"Did not expect to find event '{0}'.", field.Name ) );

						valsToFind.Remove( field.Name );
					}

					Assert.IsFalse( valsToFind.Count > 0, "Failed to find all expected values." );
				} );
		}
Ejemplo n.º 8
0
		public static void CheckAssembly( string name, int expectedTypes, string[] expectedMethods, string[] notExpectedMethods,
			Predicate<TypeDefinition> isType, Action<TypeDefinition> checkType )
		{
			C5.HashSet<string> methodsToFind = new C5.HashSet<string>( );
			methodsToFind.AddAll( expectedMethods );
			C5.HashSet<string> methodsNotToFind = new C5.HashSet<string>( );
			methodsNotToFind.AddAll( notExpectedMethods );

			CheckAssembly( name, expectedTypes, isType,
				delegate( TypeDefinition typeDef )
				{
					// make sure we have enough methods...
					Assert.AreEqual( expectedMethods.Length + notExpectedMethods.Length, typeDef.Methods.Count,
						"Some of the methods for the type are missing." );

					foreach ( MethodDefinition method in typeDef.Methods )
					{
						Assert.IsFalse( methodsNotToFind.Contains( method.Name ), String.Format(
							"Did not expect to find method '{0}'.", method.Name ) );

						methodsToFind.Remove( method.Name );
					}

					if ( checkType != null )
						checkType( typeDef );
				} );

			Assert.IsFalse( methodsToFind.Count > 0, "Failed to find all expected methods." );
		}
Ejemplo n.º 9
0
 public override void RemoveAvatar(PhysicsActor actor)
 {
     BasicActor act = (BasicActor)actor;
     if (_actors.Contains(act))
     {
         _actors.Remove(act);
     }
 }
Ejemplo n.º 10
0
        public SceneObjectPart Dequeue()
        {
            SceneObjectPart part = null;

            lock (m_syncObject)
            {
                if (m_queue.Count > 0)
                {
                    part = m_queue.Dequeue();
                    m_ids.Remove(part.LocalId);
                }
            }

            return(part);
        }
Ejemplo n.º 11
0
        public bool TryEnqueue(uint ack)
        {
            lock (m_hashSet)
            {
                if (m_hashSet.Add(ack))
                {
                    m_items[m_next] = ack;
                    m_next          = (m_next + 1) % m_capacity;
                    if (m_next == m_first)
                    {
                        m_hashSet.Remove(m_items[m_first]);
                        m_first = (m_first + 1) % m_capacity;
                    }

                    return(true);
                }
            }

            return(false);
        }
Ejemplo n.º 12
0
        protected void CheckProperties(string name, int expectedTypes, string[] expected, string[] notExpected)
        {
            C5.HashSet <string> propsToFind = new C5.HashSet <string> ();
            propsToFind.AddAll(expected);
            C5.HashSet <string> propsNotToFind = new C5.HashSet <string> ();
            propsNotToFind.AddAll(notExpected);

            string[] expectedMethods = new string[expected.Length * 2];
            for (int i = 0; i < expected.Length; i++)
            {
                expectedMethods [i * 2 + 0] = "get_" + expected [i];
                expectedMethods [i * 2 + 1] = "set_" + expected [i];
            }

            string[] notExpectedMethods = new string[notExpected.Length * 2];
            for (int i = 0; i < notExpected.Length; i++)
            {
                notExpectedMethods [i * 2 + 0] = "get_" + notExpected [i];
                notExpectedMethods [i * 2 + 1] = "set_" + notExpected [i];
            }

            AssemblyHelper.CheckAssembly(name, expectedTypes, expectedMethods, notExpectedMethods,
                                         delegate(TypeDefinition typeDef) {
                return(true);
            },
                                         delegate(TypeDefinition typeDef) {
                Assert.AreEqual(expected.Length, typeDef.Properties.Count,
                                expected.Length == 1 ? "Type should have 1 property (others dropped by default)." :
                                String.Format("Type should have {0} properties (others dropped by default).", expected.Length));

                foreach (PropertyDefinition prop in typeDef.Properties)
                {
                    Assert.IsFalse(propsNotToFind.Contains(prop.Name), String.Format(
                                       "Did not expect to find property '{0}'.", prop.Name));

                    propsToFind.Remove(prop.Name);
                }

                Assert.IsFalse(propsToFind.Count > 0, "Failed to find all expected properties.");
            });
        }
Ejemplo n.º 13
0
		protected void CheckProperties( string name, int expectedTypes, string[] expected, string[] notExpected )
		{
			C5.HashSet<string> propsToFind = new C5.HashSet<string>( );
			propsToFind.AddAll( expected );
			C5.HashSet<string> propsNotToFind = new C5.HashSet<string>( );
			propsNotToFind.AddAll( notExpected );

			string[] expectedMethods = new string[expected.Length * 2];
			for ( int i = 0; i < expected.Length; i ++ )
			{
				expectedMethods[i * 2 + 0] = "get_" + expected[i];
				expectedMethods[i * 2 + 1] = "set_" + expected[i];
			}

			string[] notExpectedMethods = new string[notExpected.Length * 2];
			for ( int i = 0; i < notExpected.Length; i ++ )
			{
				notExpectedMethods[i * 2 + 0] = "get_" + notExpected[i];
				notExpectedMethods[i * 2 + 1] = "set_" + notExpected[i];
			}

			AssemblyHelper.CheckAssembly( name, expectedTypes, expectedMethods, notExpectedMethods,
				delegate( TypeDefinition typeDef ) { return true; },
				delegate( TypeDefinition typeDef )
				{
					Assert.AreEqual( expected.Length, typeDef.Properties.Count,
						expected.Length == 1 ? "Type should have 1 property (others dropped by default)." :
						String.Format( "Type should have {0} properties (others dropped by default).", expected.Length ) );

					foreach ( PropertyDefinition prop in typeDef.Properties )
					{
						Assert.IsFalse( propsNotToFind.Contains( prop.Name ), String.Format(
							"Did not expect to find property '{0}'.", prop.Name ) );

						propsToFind.Remove( prop.Name );
					}

					Assert.IsFalse( propsToFind.Count > 0, "Failed to find all expected properties." );
				} );
		}
Ejemplo n.º 14
0
 internal void RemoveCharacterSync(PhysxCharacter physxCharacter)
 {
     _charActors.Remove(physxCharacter);
 }
Ejemplo n.º 15
0
 public void Remove(T result)
 {
     _results.Remove(result);
 }
Ejemplo n.º 16
0
 internal void PrimMadeStaticKinematic(PhysxPrim actor)
 {
     _dynPrims.Remove(actor);
     _kinematicManager.KinematicChanged(actor);
 }
Ejemplo n.º 17
0
		protected void CheckEvents( string name, int expectedTypes, string[] expected, string[] notExpected )
		{
			C5.HashSet<string> eventsToFind = new C5.HashSet<string>( );
			eventsToFind.AddAll( expected );
			C5.HashSet<string> eventsNotToFind = new C5.HashSet<string>( );
			eventsNotToFind.AddAll( notExpected );

			C5.HashSet<string> methodsToFind = new C5.HashSet<string>( );
			for ( int i = 0; i < expected.Length; i++ )
			{
				methodsToFind.Add( "add_" + expected[i] );
				methodsToFind.Add( "remove_" + expected[i] );
			}

			C5.HashSet<string> methodsNotToFind = new C5.HashSet<string>( );
			for ( int i = 0; i < notExpected.Length; i++ )
			{
				methodsNotToFind.Add( "add_" + notExpected[i] );
				methodsNotToFind.Add( "remove_" + notExpected[i] );
			}

			bool foundDelType = false;

			AssemblyHelper.CheckAssembly( name, expectedTypes,
				delegate( TypeDefinition typeDef )
				{
					if ( typeDef.BaseType.FullName == "System.MulticastDelegate" )
					{
						foundDelType = true;
						return false;
					}
					else
						return true;
				},
				delegate( TypeDefinition typeDef )
				{
					// make sure we have enough methods...
					// 2 methods / event + a method to fire them
					Assert.AreEqual( methodsToFind.Count + methodsNotToFind.Count + 1, typeDef.Methods.Count,
						"Some of the methods for the type are missing." );

					foreach ( MethodDefinition method in typeDef.Methods )
					{
						Assert.IsFalse( methodsNotToFind.Contains( method.Name ), String.Format(
							"Did not expect to find method '{0}'.", method.Name ) );

						methodsToFind.Remove( method.Name );
					}

					Assert.AreEqual( expected.Length, typeDef.Events.Count,
						expected.Length == 1 ? "Type should have 1 event (others dropped by default)." :
						String.Format( "Type should have {0} events (others dropped by default).", expected.Length ) );

					foreach ( EventDefinition evt in typeDef.Events )
					{
						Assert.IsFalse( eventsNotToFind.Contains( evt.Name ), String.Format(
							"Did not expect to find event '{0}'.", evt.Name ) );

						eventsToFind.Remove( evt.Name );
					}

					Assert.IsFalse( methodsToFind.Count > 0, "Failed to find all expected methods." );
					Assert.IsFalse( eventsToFind.Count > 0, "Failed to find all expected events." );
				} );

			Assert.IsTrue( foundDelType, "Should have found the delegate type." );
		}
Ejemplo n.º 18
0
 public void Remove(string name)
 {
     names.Remove(name);
 }
Ejemplo n.º 19
0
        protected void CheckEvents(string name, int expectedTypes, string[] expected, string[] notExpected)
        {
            C5.HashSet <string> eventsToFind = new C5.HashSet <string>( );
            eventsToFind.AddAll(expected);
            C5.HashSet <string> eventsNotToFind = new C5.HashSet <string>( );
            eventsNotToFind.AddAll(notExpected);

            C5.HashSet <string> methodsToFind = new C5.HashSet <string>( );
            for (int i = 0; i < expected.Length; i++)
            {
                methodsToFind.Add("add_" + expected[i]);
                methodsToFind.Add("remove_" + expected[i]);
            }

            C5.HashSet <string> methodsNotToFind = new C5.HashSet <string>( );
            for (int i = 0; i < notExpected.Length; i++)
            {
                methodsNotToFind.Add("add_" + notExpected[i]);
                methodsNotToFind.Add("remove_" + notExpected[i]);
            }

            bool foundDelType = false;

            AssemblyHelper.CheckAssembly(name, expectedTypes,
                                         delegate(TypeDefinition typeDef)
            {
                if (typeDef.BaseType.FullName == "System.MulticastDelegate")
                {
                    foundDelType = true;
                    return(false);
                }
                else
                {
                    return(true);
                }
            },
                                         delegate(TypeDefinition typeDef)
            {
                // make sure we have enough methods...
                // 2 methods / event + a method to fire them
                Assert.AreEqual(methodsToFind.Count + methodsNotToFind.Count + 1, typeDef.Methods.Count,
                                "Some of the methods for the type are missing.");

                foreach (MethodDefinition method in typeDef.Methods)
                {
                    Assert.IsFalse(methodsNotToFind.Contains(method.Name), String.Format(
                                       "Did not expect to find method '{0}'.", method.Name));

                    methodsToFind.Remove(method.Name);
                }

                Assert.AreEqual(expected.Length, typeDef.Events.Count,
                                expected.Length == 1 ? "Type should have 1 event (others dropped by default)." :
                                String.Format("Type should have {0} events (others dropped by default).", expected.Length));

                foreach (EventDefinition evt in typeDef.Events)
                {
                    Assert.IsFalse(eventsNotToFind.Contains(evt.Name), String.Format(
                                       "Did not expect to find event '{0}'.", evt.Name));

                    eventsToFind.Remove(evt.Name);
                }

                Assert.IsFalse(methodsToFind.Count > 0, "Failed to find all expected methods.");
                Assert.IsFalse(eventsToFind.Count > 0, "Failed to find all expected events.");
            });

            Assert.IsTrue(foundDelType, "Should have found the delegate type.");
        }