public void Init()
        {
            FileInfo logFile = new System.IO.FileInfo("Log4Net.config");
            if (logFile.Exists)
            {
                // Log4Net is configured using a DOMConfigurator.
                log4net.Config.XmlConfigurator.Configure(logFile);
            }
            else
            {
                // Set up a simple configuration that logs on the console.
                log4net.Config.BasicConfigurator.Configure();
            }

            // Log an baseInfo level message
            if (log.IsDebugEnabled)
            {
                if (string.IsNullOrEmpty(System.Threading.Thread.CurrentThread.Name))
                    System.Threading.Thread.CurrentThread.Name = "Main(" + System.Threading.Thread.CurrentThread.ManagedThreadId + ")";
                log.Debug("Interaction Tests Start");
            }

            ObjectManager objectManager = new ObjectManager();
            Sxta.Rti1516.HLAAttributes.HLAobjectRoot.AddIHLAobjectRootCreationListener(objectManager);
        }

 private static bool Bug() {
 ObjectManager objmgr1;
 StreamingContext sc1;
 ObjectIDGenerator objid1;
 TestFixup tstfxp1;
 Int64 iRootID;
 Int64 iChildID;
 String strValue;
 MemberInfo[] members;
 Boolean fFirstTime;
 sc1 = new StreamingContext(StreamingContextStates.All);
 tstfxp1 = new TestFixup();
 strValue = "Hello World";
 objid1 = new ObjectIDGenerator();
 iRootID = objid1.GetId(tstfxp1, out fFirstTime);
 iChildID = objid1.GetId(strValue, out fFirstTime);
 members = FormatterServices.GetSerializableMembers(tstfxp1.GetType()); 
 objmgr1 = new ObjectManager(null, sc1);
 objmgr1.RecordFixup(iRootID, members[0], iChildID);
 try {
 objmgr1.RegisterObject(strValue, iChildID);	
 return true;
 } catch(Exception ex){
 Console.WriteLine("Bug:Exception thrown, " + ex);
 return false;
 }
 }

		/// <summary>Creates a mirrored copy of the prototype object (Animated objects)</summary>
		/// <param name="Prototype">The prototype</param>
		/// <returns>The mirrored copy</returns>
		private static ObjectManager.UnifiedObject GetMirroredObject(ObjectManager.UnifiedObject Prototype)
		{
			if (Prototype is ObjectManager.StaticObject)
			{
				ObjectManager.StaticObject s = (ObjectManager.StaticObject)Prototype;
				return GetMirroredStaticObject(s);
			}
			else if (Prototype is ObjectManager.AnimatedObjectCollection)
			{
				ObjectManager.AnimatedObjectCollection a = (ObjectManager.AnimatedObjectCollection)Prototype;
				ObjectManager.AnimatedObjectCollection Result = new ObjectManager.AnimatedObjectCollection();
				Result.Objects = new ObjectManager.AnimatedObject[a.Objects.Length];
				for (int i = 0; i < a.Objects.Length; i++)
				{
					Result.Objects[i] = a.Objects[i].Clone();
					for (int j = 0; j < a.Objects[i].States.Length; j++)
					{
						Result.Objects[i].States[j].Object = GetMirroredStaticObject(a.Objects[i].States[j].Object);
					}
					Result.Objects[i].TranslateXDirection.X *= -1.0;
					Result.Objects[i].TranslateYDirection.X *= -1.0;
					Result.Objects[i].TranslateZDirection.X *= -1.0;
					Result.Objects[i].RotateXDirection.X *= -1.0;
					Result.Objects[i].RotateYDirection.X *= -1.0;
					Result.Objects[i].RotateZDirection.X *= -1.0;
				}
				return Result;
			}
			else
			{
				return null;
			}
		}

 void Start()
 {
     _gameManager = GameManager.Instance;
     _objectManager = _gameManager.getObjectManager();
     _audioManager = _gameManager.getAudioManager();
     Random.seed = (int)System.DateTime.Now.Ticks;
 }

 // Use this for initialization
 void Start()
 {
     animator = GetComponent<Animator>();
     objectManager = ObjectManager.GetInstance();
     objectManager.AudioManager.Talking += Talk;
     objectManager.gameState.Damaged += FeelPain;
 }

 public override void DriverSetup()
 {
     _mngObject = gobSystemManager.GetComponent<ObjectManager>();
     transMyTransform = gameObject.transform;
     _mngObject.RegisterObject(gameObject, this);
     AdditionalSetup();
 }

 public SpawnManager(Game game, SpriteBatch batch)
 {
     this.game = game;
     spriteBatch = batch;
     objectManager = (ObjectManager) game.Services.GetService((typeof(ObjectManager)));
     collisionManager = (IManageCollisionsService)game.Services.GetService((typeof(IManageCollisionsService)));
     nextTime = random.Next(0, 10);
 }

 public void TableDelete() {
     var result = new ObjectManager<Favorite>( new[] { new Favorite() } );
     result.Delete( result.First() );
     Assert.AreEqual( 0, result.Count() );
     Assert.AreEqual( 0, result.Inserted.Count() );
     Assert.AreEqual( 0, result.Updated.Count() );
     Assert.AreEqual( 1, result.Deleted.Count() );
 }

    void Start()
    {
        _ObjectManager = ObjectManager.GetInstance();
        destinationNode = GetNodeFromLocation(destinationTransform.position);
        enemySpawnNode = GetNodeFromLocation(enemySpawnTransform.position);

        CreateEnemies();
    }

 public static void InitializeManager()
 {
     CharacterMgr = CharacterStore.GetInstance();
     ObjectMgr = ObjectManager.GetInstance();
     SkillMgr = SkillManager.GetInstance();
     SpellMgr = SpellManager.GetInstance();
     WorldMgr = WorldManager.GetInstance();
 }

 public void LoadContent()
 {
     Art = game.Content.Load<Texture2D>(@"Pictures/beam_wall");
     collisionBox.Width = (int)_size.X;
     collisionBox.Height = (int)_size.Y;
     _sourceRectangle = new Rectangle(0, 0, 80, 1024);
     objectManager = (ObjectManager)game.Services.GetService(typeof(ObjectManager));
     collisionManager = (IManageCollisionsService)game.Services.GetService((typeof(IManageCollisionsService)));
 }

 public static void InitializeManager()
 {
     DataMgr = DataManager.GetInstance();
     ObjectMgr = ObjectManager.GetInstance();
     SkillMgr = SkillManager.GetInstance();
     SpawnMgr = SpawnManager.GetInstance();
     SpellMgr = SpellManager.GetInstance();
     WorldMgr = WorldManager.GetInstance();
 }

 public void Init()
 {
     objectHistory = InfiniteObjectHistory.instance;
     objectManager = ObjectManager.instance;
     moveDirection = Vector3.up;
     slotCount = objectManager.slotCount;
     spawnDirection = Vector3.up;
     activeSlots = GetStartingSlot();
 }

 void Start()
 {
     ladderLayer = LayerMask.NameToLayer("Ladder");
     gameManager = GameManager.instance ;
     objectGenerator = ObjectGenerator.instance;
     objectManager = ObjectManager.instance;
     targetSlot = objectManager.GetStartingSlot();
     targetPosition = new Vector2(objectGenerator.IndexToGlobalPosition(targetSlot).x, -objectGenerator.horizon/2);
     transform.position = targetPosition;
 }

 void Start()
 {
     if (instance == null){
         instance = this;
     }else {
         Destroy(this.gameObject);
         Debug.Error("core", "Second ObjectManager detected. Deleting gameOject.");
         return;
     }
 }

        public static ObjectManager Get(Game aGame)
        {
            if (null == Instance)
            {
                Instance = new ObjectManager(aGame);

            }

            return Instance;
        }

    public ObjectManager()
    {
        _Map = GameObject.Find("Map").GetComponent<Map>();
        _EventHandler = GameObject.Find("Map").GetComponent<_EventHandler>();
        _ObjectManager = this;
        _Map.nodeSize = new LinkedListNode[_Map.size_x, _Map.size_z];

        SetPositions();
        BuildNodes();
        ConnectNodes();
    }

        //Level Level1;
        public Game()
        {
            Graphics = new GraphicsDeviceManager(this);
            Graphics.PreferredBackBufferWidth   = 1280;
            Graphics.PreferredBackBufferHeight  = 720;

            Camera = new Point(0, 0);
            ObjectManager = new Engine.ObjectManager(this);

            Content.RootDirectory = "Content";
        }

 public void TableUpdate() {
 	var result = new ObjectManager<Favorite>( new[] { new Favorite{ Name ="zhang san" }} );
     result.First().Url = "AAA";
     
     var updated = result.Updated.ToArray();
     Assert.AreEqual( 1, result.Count() );
     Assert.AreEqual( 0, result.Inserted.Count() );
     Assert.AreEqual( 1, updated.Length );
     Assert.AreEqual( 1, updated[0].Length );
     Assert.AreEqual( 0, result.Deleted.Count() );
 }

        public void ObjectManagerShouldCreateObject()
        {
            var objectManager = new ObjectManager<Guid, NonSharedObject>();

            var key = Guid.NewGuid();
            var obj = objectManager.GetObject(key);
            Assert.IsNotNull(obj);

            obj = objectManager.TryGetObject(key);
            Assert.IsNotNull(obj);
        }