private void TestAddRemoveListenerImpl(Game game)
        {
            var audio = game.Audio;
            var notAddedToEntityListener = new AudioListenerComponent();
            var addedToEntityListener = new AudioListenerComponent();

            // Add a listenerComponent not present in the entity system yet and check that it is correctly added to the AudioSystem internal data structures
            Assert.DoesNotThrow(() => audio.AddListener(notAddedToEntityListener), "Adding a listener not present in the entity system failed");
            Assert.IsTrue(audio.Listeners.ContainsKey(notAddedToEntityListener), "The list of listeners of AudioSystem does not contains the notAddedToEntityListener.");

            // Add a listenerComponent already present in the entity system and check that it is correctly added to the AudioSystem internal data structures
            var entity = new Entity("Test");
            entity.Add(addedToEntityListener);
            throw new NotImplementedException("TODO: UPDATE TO USE Scene and Graphics Composer"); 
            //game.Entities.Add(entity);
            Assert.DoesNotThrow(() => audio.AddListener(addedToEntityListener), "Adding a listener present in the entity system failed");
            Assert.IsTrue(audio.Listeners.ContainsKey(addedToEntityListener), "The list of listeners of AudioSystem does not contains the addedToEntityListener.");

            // Add a listenerComponent already added to audio System and check that it does not crash
            Assert.DoesNotThrow(()=>audio.AddListener(addedToEntityListener), "Adding a listener already added to the audio system failed.");

            // Remove the listeners from the AudioSystem and check that they are removed from internal data structures.
            Assert.DoesNotThrow(() => audio.RemoveListener(notAddedToEntityListener), "Removing an listener not present in the entity system failed.");
            Assert.IsFalse(audio.Listeners.ContainsKey(notAddedToEntityListener), "The list of listeners of AudioSystem still contains the notAddedToEntityListener.");
            Assert.DoesNotThrow(() => audio.RemoveListener(addedToEntityListener), "Removing an listener present in the entity system fails");
            Assert.IsFalse(audio.Listeners.ContainsKey(addedToEntityListener), "The list of listeners of AudioSystem still contains the addedToEntityListener.");

            // Remove a listener not present in the AudioSystem anymore and check the thrown exception
            Assert.Throws<ArgumentException>(() => audio.RemoveListener(addedToEntityListener), "Removing the a non-existing listener did not throw ArgumentException.");
        }

            public void OneLoopTurnActionAftUpdate(Game game)
            {
                oneLoopTurnActionAftUpdate?.Invoke(game, loopCount, loopCountSum);

                ++loopCount;
                loopCountSum += loopCount;
            }

 static void Main(string[] args)
 {
     using (var game = new Game())
     {
         game.Run();
     }
 }

 private static void CheckTextureFormat(Game game, string textureUrl, AlphaFormat expectedFormat)
 {
     var expectedPixelFormat = PlaformAndAlphaToPixelFormats[Tuple.Create(Platform.Type, expectedFormat)];
     var texture = game.Asset.Load<Texture>(textureUrl);
     Assert.AreEqual(expectedPixelFormat, texture.Format);
     game.Asset.Unload(texture);
 }

 private static void TestScriptAudioAccessImpl(Game game)
 {
     using (var script = new ScriptClass(game.Services))
     {
         Assert.DoesNotThrow(() => script.AccessAudioService(), "Access to the audio service failed.");
         Assert.IsTrue(script.AudioServiceNotNull(), "The Audio service is null.");
     }
 }

 private void TestInitializeAudioEngine(Game game)
 {
     var audio = game.Audio;
     AudioEngine audioEngine = null;
     Assert.DoesNotThrow(()=>audioEngine = audio.AudioEngine, "Failed to get the AudioEngine");
     Assert.IsNotNull(audioEngine, "The audio engine is null");
     Assert.IsFalse(audioEngine.IsDisposed, "The audio engine is disposed");
 }

        private void EntityPositionUpdate(Game game, int loopCount, int loopCountSum)
        {
            rootSubEntity1.Transform.Position += new Vector3(loopCount, 2 * loopCount, 3 * loopCount);
            rootSubEntity2.Transform.Position += new Vector3(loopCount, 2 * loopCount, 3 * loopCount);

            listComp1Entity.Transform.Position += new Vector3(loopCount, 2 * loopCount, 3 * loopCount);
            listComp2Entity.Transform.Position -= new Vector3(loopCount, 2 * loopCount, 3 * loopCount);
        }

            public void OneLoopTurnActionAftUpdate(Game game)
            {
                if (oneLoopTurnActionAftUpdate != null)
                    oneLoopTurnActionAftUpdate(game, loopCount, loopCountSum);

                ++loopCount;
                loopCountSum += loopCount;
            }

 private static void TestSoundMusicLoadingImpl(Game game)
 {
     SoundMusic sound = null;
     Assert.DoesNotThrow(() => sound = game.Content.Load<SoundMusic>("EffectBip"), "Failed to load the SoundMusic.");
     Assert.IsNotNull(sound, "The SoundMusic loaded is null.");
     sound.Play();
     // Should hear the sound here.
 }

 static void Main(string[] args)
 {
     // Profiler.EnableAll();
     using (game = new Game())
     {
         game.GraphicsDeviceManager.DeviceCreated += GraphicsDeviceManager_DeviceCreated;
         game.Run();
     }
 }

 public LiveAssemblyReloader(Game game, AssemblyContainer assemblyContainer, List<Assembly> assembliesToUnregister, List<Assembly> assembliesToRegister)
 {
     if (game != null)
         this.entities.AddRange(game.SceneSystem.SceneInstance);
     this.game = game;
     this.assemblyContainer = assemblyContainer;
     this.assembliesToUnregister = assembliesToUnregister;
     this.assembliesToRegister = assembliesToRegister;
 }

 private static void TestSoundMusicLoadingImpl(Game game)
 {
     Sound sound = null;
     Assert.DoesNotThrow(() => sound = game.Content.Load<Sound>("EffectBip"), "Failed to load the SoundMusic.");
     Assert.IsNotNull(sound, "The SoundMusic loaded is null.");
     testInstance = sound.CreateInstance(game.Audio.AudioEngine.DefaultListener);
     testInstance.Play();
     // Should hear the sound here.
 }

 public void TestAccessToAudio()
 {
     using (var game = new Game())
     {
         AudioSystem audioInterface = null;
         Assert.DoesNotThrow(()=>audioInterface = game.Audio, "Failed to get the audio interface");
         Assert.IsNotNull(audioInterface, "The audio interface supplied is null");
     }
 }

        public override void Start()
        {
            IsRunning = true;

            UIGame = (Game)Services.GetServiceAs<IGame>();

            AdjustVirtualResolution(this, EventArgs.Empty);
            Game.Window.ClientSizeChanged += AdjustVirtualResolution;

            CreateScene();
        }

        private void TestAddAudioSysThenEntitySysSetup(Game game)
        {
            var audio = game.Audio;

            BuildEntityHierarchy();
            CreateAndComponentToEntities();

            audio.AddListener(listComp1);
            audio.AddListener(listComp2);

            listComp2Entity.Transform.RotationEulerXYZ = new Vector3((float)Math.PI/2,0,0);
        }

        public void TestAttachDetachSounds()
        {
            var testInst = new AudioEmitterComponent();
            using (var game = new Game())
            {
                Game.InitializeAssetDatabase();
                using (var audioStream1 = AssetManager.FileProvider.OpenStream("EffectToneA", VirtualFileMode.Open, VirtualFileAccess.Read))
                using (var audioStream2 = AssetManager.FileProvider.OpenStream("EffectBip", VirtualFileMode.Open, VirtualFileAccess.Read))
                using (var audioStream3 = AssetManager.FileProvider.OpenStream("EffectStereo", VirtualFileMode.Open, VirtualFileAccess.Read))
                {
                    var sound1 = SoundEffect.Load(game.Audio.AudioEngine, audioStream1);
                    var sound2 = SoundEffect.Load(game.Audio.AudioEngine, audioStream2);
                    var sound3 = SoundEffect.Load(game.Audio.AudioEngine, audioStream3);

                    // Attach two soundEffect and check that their controller are correctly created.

                    AudioEmitterSoundController soundController1 = null;
                    AudioEmitterSoundController soundController2 = null;
                    Assert.DoesNotThrow(() => testInst.AttachSoundEffect(sound1), "Adding a first soundEffect failed");
                    Assert.DoesNotThrow(() => soundController1 = testInst.SoundEffectToController[sound1], "There are no sound controller for sound1.");
                    Assert.IsNotNull(soundController1, "Sound controller for sound1 is null");

                    Assert.DoesNotThrow(() => testInst.AttachSoundEffect(sound2), "Adding a second soundEffect failed");
                    Assert.DoesNotThrow(() => soundController2 = testInst.SoundEffectToController[sound2], "There are no sound controller for sound1.");
                    Assert.IsNotNull(soundController2, "Sound controller for sound2 is null");

                    // Remove the two soundEffect and check that their controller are correctly erased.

                    Assert.DoesNotThrow(() => testInst.DetachSoundEffect(sound2), "Removing a first soundEffect failed");
                    Assert.IsFalse(testInst.SoundEffectToController.ContainsKey(sound2), "The controller for sound2 is still present in the list.");

                    Assert.DoesNotThrow(() => testInst.DetachSoundEffect(sound1), "Removing a second soundEffect failed");
                    Assert.IsFalse(testInst.SoundEffectToController.ContainsKey(sound1), "The controller for sound1 is still present in the list.");

                    Assert.IsTrue(testInst.SoundEffectToController.Keys.Count == 0, "There are some controller left in the component list.");

                    // Check the exception thrwon by attachSoundEffect.

                    Assert.Throws<ArgumentNullException>(() => testInst.AttachSoundEffect(null), "AttachSoundEffect did not throw ArgumentNullException");
                    Assert.Throws<InvalidOperationException>(() => testInst.AttachSoundEffect(sound3), "AttachSoundEffect did not throw InvalidOperationException.");

                    // Check the exception thrown by detachSoundEffect.

                    Assert.Throws<ArgumentNullException>(() => testInst.DetachSoundEffect(null), "DetachSoundEffect did not throw ArgumentNullException.");
                    Assert.Throws<ArgumentException>(() => testInst.DetachSoundEffect(sound1), "DetachSoundEffect did not throw ArgumentException ");
                }
            }
        }

        private void AddSoundEffectToEmitterComponents(Game game)
        {
            sounds = new List<SoundEffect>
                {
                    game.Content.Load<SoundEffect>("EffectBip"),
                    game.Content.Load<SoundEffect>("EffectToneA"),
                };

            emitComps[0].AttachSoundEffect(sounds[0]);
            emitComps[0].AttachSoundEffect(sounds[1]);

            soundControllers = new List<AudioEmitterSoundController>
                {
                    emitComps[0].GetSoundEffectController(sounds[0]),
                    emitComps[0].GetSoundEffectController(sounds[1]),
                };

            mainController = soundControllers[0];
        }

 /// <summary>
 /// Add all the <see cref="AudioListenerComponent"/> to the <see cref="AudioSystem"/>.
 /// </summary>
 /// <param name="game"></param>
 private void AddListenersToAudioSystem(Game game)
 {
     foreach (var t in listComps)
         game.Audio.AddListener(t);
 }

 /// <summary>
 /// Add the root entity to the entity system
 /// </summary>
 /// <param name="game"></param>
 private void AddRootEntityToEntitySystem(Game game)
 {
     throw new NotImplementedException("TODO: UPDATE TO USE Scene and Graphics Composer"); // game.Entities.Add(rootEntity);
 }

        private void TestMulteListenerUpdate(Game game, int loopCount, int loopCountSum)
        {
            throw new NotImplementedException("TODO: UPDATE TO USE Scene and Graphics Composer"); 
            //var matchingEntities = game.Entities.Processors.OfType<AudioEmitterProcessor>().First().MatchingEntitiesForDebug;

            //var dataComp1 = matchingEntities[compEntities[0]];

            //if (loopCount == 0)
            //{
            //    soundControllers[0].Play();
            //}
            //else if (loopCount < 10)
            //{
            //    // check that the two instances are correctly create and playing
            //    var tupple1 = Tuple.Create(listComps[0], soundControllers[0]);
            //    var tupple2 = Tuple.Create(listComps[1], soundControllers[0]);
                
            //    Assert.IsTrue(dataComp1.ListenerControllerToSoundInstance.ContainsKey(tupple1));
            //    Assert.IsTrue(dataComp1.ListenerControllerToSoundInstance.ContainsKey(tupple2));

            //    var instance1 = dataComp1.ListenerControllerToSoundInstance[tupple1];
            //    var instance2 = dataComp1.ListenerControllerToSoundInstance[tupple2];

            //    Assert.AreEqual(SoundPlayState.Playing, instance1.PlayState);
            //    Assert.AreEqual(SoundPlayState.Playing, instance2.PlayState);
            //}
            //else
            //{
            //    game.Exit();
            //}
        }