public void TestSoundMusicWhenEngineInvalidated() { // user should unplug the headphone before starting the test var soundMusic = SoundMusic.Load(engine, ContentManager.FileProvider.OpenStream("MusicFishLampMp3", VirtualFileMode.Open, VirtualFileAccess.Read)); // check the initial status of the engine Assert.AreEqual(AudioEngineState.Invalidated, engine.State); // check that the play state of the music is never modified when engine is invalid Assert.AreEqual(SoundPlayState.Stopped, soundMusic.PlayState); Assert.DoesNotThrow(soundMusic.Play); Assert.AreEqual(SoundPlayState.Stopped, soundMusic.PlayState); Assert.DoesNotThrow(soundMusic.Pause); Assert.AreEqual(SoundPlayState.Stopped, soundMusic.PlayState); Assert.DoesNotThrow(soundMusic.Stop); Assert.AreEqual(SoundPlayState.Stopped, soundMusic.PlayState); // check that the source characteristics can be modified Assert.DoesNotThrow(() => soundMusic.IsLooped = false); Assert.False(soundMusic.IsLooped); Assert.DoesNotThrow(() => soundMusic.IsLooped = true); Assert.True(soundMusic.IsLooped); Assert.DoesNotThrow(() => soundMusic.Volume = 0.5f); Assert.AreEqual(0.5f, soundMusic.Volume); Assert.DoesNotThrow(() => soundMusic.Volume = 0.67f); Assert.AreEqual(0.67f, soundMusic.Volume); Assert.DoesNotThrow(soundMusic.ExitLoop); Assert.DoesNotThrow(soundMusic.Dispose); Assert.IsTrue(soundMusic.IsDisposed); }
public void TestPlayState() { var state = SoundPlayState.Stopped; //////////////////////////////////////////////////////////////////////////////////////////////////// // 1. Check that get PlayState for an Disposed instance does not throw the 'ObjectDisposedException' var dispInst = SoundMusic.Load(defaultEngine, OpenDataBaseStream("EffectToneA")); dispInst.Dispose(); try { state = dispInst.PlayState; } catch (Exception e) { Assert.IsFalse(e is ObjectDisposedException, "SoundMusic.PlayState { get } did throw the 'ObjectDisposedException' when called from a disposed object."); } ////////////////////////////////////////////// // 2. Check that PlayState get does not crash Assert.DoesNotThrow(() => state = monoInstance.PlayState, "SoundMusic.PlayState { get } crashed on valid soundEffectInstance."); //////////////////////////////////////////////////////////////////// // 3. Check that PlayState default value is SoundPlayState.Stopped. var newInst = SoundMusic.Load(defaultEngine, OpenDataBaseStream("EffectBip")); Assert.AreEqual(SoundPlayState.Stopped, newInst.PlayState, "Default value of SoundMusic.PlayState is not SoundPlayState.Stopped."); ////////////////////////////////////////////////////////////////////// // 4. Check that PlayState value after Play is SoundPlayState.Playing. monoInstance.Play(); Assert.AreEqual(SoundPlayState.Playing, monoInstance.PlayState, "Value of SoundMusic.PlayState is not SoundPlayState.Playing after a call to Play"); ////////////////////////////////////////////////////////////////////// // 5. Check that PlayState value after Pause is SoundPlayState.Pause. monoInstance.Pause(); Assert.AreEqual(SoundPlayState.Paused, monoInstance.PlayState, "Value of SoundMusic.PlayState is not SoundPlayState.Pause after a call to Pause"); ////////////////////////////////////////////////////////////////////// // 6. Check that PlayState value after Stop is SoundPlayState.Stopped. monoInstance.Stop(); Assert.AreEqual(SoundPlayState.Stopped, monoInstance.PlayState, "Value of SoundMusic.PlayState is not SoundPlayState.Stopped after a call to Stop"); ////////////////////////////////////////////////////////////////////////////////////////// // 7. Check that PlayState value is SoundMusic.Stopped when the sound stops by itself. monoInstance.Play(); ActiveAudioEngineUpdate(2500); Assert.AreEqual(SoundPlayState.Stopped, monoInstance.PlayState, "Value of SoundMusic.PlayState is not SoundPlayState.Stopped when we reach the sound end"); ////////////////////////////////////////////////////////////////////////////////////////// // 8. Check that PlayState value is SoundMusic.Stopped when the sound stops by another music. mp3Instance.Play(); ActiveAudioEngineUpdate(800); monoInstance.Play(); Assert.AreEqual(SoundPlayState.Stopped, mp3Instance.PlayState, "Value of SoundMusic.PlayState is not SoundPlayState.Stopped when stopped by another music"); ActiveAudioEngineUpdate(2500); }
public void TestIsLooped() { var looped = false; ////////////////////////////////////////////////////////////////////////////////// // 1. Check that get and set IsLooped for an Disposed instance throw the 'ObjectDisposedException' var dispInst = SoundMusic.Load(defaultEngine, OpenDataBaseStream("EffectToneA")); dispInst.Dispose(); Assert.Throws <ObjectDisposedException>(() => looped = dispInst.IsLooped, "SoundMusic.IsLooped { get } did not throw the 'ObjectDisposedException' when called from a disposed object."); Assert.Throws <ObjectDisposedException>(() => dispInst.IsLooped = false, "SoundMusic.IsLooped { set } did not throw the 'ObjectDisposedException' when called from a disposed object."); ////////////////////////////////////////////////////////////////////////////////// // 2. Check that set IsLooped for a playing instance throw the 'InvalidOperationException' var loopedWavInstance = SoundMusic.Load(defaultEngine, OpenDataBaseStream("EffectBip")); loopedWavInstance.Play(); Assert.Throws <InvalidOperationException>(() => loopedWavInstance.IsLooped = true, "SoundMusic.IsLooped { set } did not throw the 'InvalidOperationException' when called from a playing sound."); ActiveAudioEngineUpdate(2000); ///////////////////////////////////////////////// // 3. Check that IsLooped default value is false Assert.IsFalse(loopedWavInstance.IsLooped, "Default looping status is not false."); ///////////////////////////////////////////////////////////// // 4. Check that IsLooped set/get do not crash on valid sound Assert.DoesNotThrow(() => looped = loopedWavInstance.IsLooped, "SoundMusic.IsLooped { get } crashed."); Assert.DoesNotThrow(() => loopedWavInstance.IsLooped = true, "SoundMusic.IsLooped { set } crashed."); ////////////////////////////////////////////////////////////// // 5. Check that sound is looping when IsLooped is set to true loopedWavInstance.IsLooped = true; loopedWavInstance.Play(); ActiveAudioEngineUpdate(3000); Assert.AreEqual(SoundPlayState.Playing, loopedWavInstance.PlayState, "Sound does not loop when Islooped is set to true."); loopedWavInstance.Stop(); ActiveAudioEngineUpdate(2000); ////////////////////////////////////////////////////////////// // 6. Check that sound is looping when IsLooped is set to true var loopedMP3Instance = SoundMusic.Load(defaultEngine, OpenDataBaseStream("MusicBipMp3")); loopedMP3Instance.IsLooped = true; loopedMP3Instance.Play(); ActiveAudioEngineUpdate(3000); Assert.AreEqual(SoundPlayState.Playing, loopedMP3Instance.PlayState, "Sound does not loop when Islooped is set to true."); loopedMP3Instance.Stop(); ActiveAudioEngineUpdate(2000); //////////////////////////////////////////////////////////////////////// // 7. Check that sound has no glitches when looped a continuous sound contInstance.IsLooped = true; contInstance.Play(); ActiveAudioEngineUpdate(3000); Assert.AreEqual(SoundPlayState.Playing, contInstance.PlayState, "Sound does not loop when Islooped is set to true."); contInstance.Stop(); }
public void TestLoadAndPlayInvalid4() { // 3.6 Other file format using (var music = SoundMusic.Load(defaultEngine, OpenDataBaseStream("MusicInvalidFile"))) { music.Play(); Assert.Throws <InvalidOperationException>(() => ActiveAudioEngineUpdate(1000), "Successive SoundMusic.Load -> SoundMusic.Play did not throw 'InvalidOperationException' when called with a unsupported txt format."); } }
public void TestLoadAndPlayInvalid1() { // 3.2 Invalid wav file format (4-channels) using (var music = SoundMusic.Load(defaultEngine, OpenDataBaseStream("Music4Channels"))) { music.Play(); Assert.Throws <InvalidOperationException>(() => ActiveAudioEngineUpdate(1000), "Successive SoundMusic.Load -> SoundMusic.Play did not throw 'InvalidOperationException' when called with an invalid 4-channels wav format."); } }
public void TestLoadAndPlayInvalid2() { // 3.3 Corrupted Header wav file using (var music = SoundMusic.Load(defaultEngine, OpenDataBaseStream("MusicHeaderCorrupted"))) { music.Play(); Assert.Throws <InvalidOperationException>(() => ActiveAudioEngineUpdate(1000), "Successive SoundMusic.Load -> SoundMusic.Play did not throw 'InvalidOperationException' when called with a corrupted wav data stream."); } }
public void TestExitLoop() { ////////////////////////////////////////////////////////////////////////////////// // 1. Check that ExitLoop an Disposed instance throw the 'ObjectDisposedException' var dispInst = SoundMusic.Load(defaultEngine, OpenDataBaseStream("EffectToneA")); dispInst.Dispose(); Assert.Throws <ObjectDisposedException>(dispInst.ExitLoop, "SoundMusic.ExitLoop did not throw the 'ObjectDisposedException' when called from a disposed object."); ////////////////////////////////////////////////////////////////////////////// // 2. Check that ExitLoop does not crash when the sound is not started/stopped Assert.DoesNotThrow(monoInstance.ExitLoop, "Call to SoundMusic.ExitLoop crashed throwing an exception with a stopped sound."); ///////////////////////////////////////////////////////////////////////////////////////////////////// // 3. Check that ExitLoop does not crash and has the correct effect when called during looped playing var loopedInst = SoundMusic.Load(defaultEngine, OpenDataBaseStream("EffectBip")); loopedInst.IsLooped = true; loopedInst.Play(); ActiveAudioEngineUpdate(1000); // Play need to be commited Assert.DoesNotThrow(loopedInst.ExitLoop, "Call to SoundMusic.ExitLoop crashed throwing an exception."); ActiveAudioEngineUpdate(1500); Assert.AreEqual(SoundPlayState.Stopped, loopedInst.PlayState, "SoundMusic.ExitLoop has not properly stopped the looping proccess"); //////////////////////////////////////////////////////////////////////////////// // 4. Check that a call to ExitLoop does not crash when the sound is not looping monoInstance.Play(); ActiveAudioEngineUpdate(100); // Play need to be commited Assert.DoesNotThrow(monoInstance.ExitLoop, "Call to SoundMusic.ExitLoop with a non-looping sound crashed throwing an exception."); ActiveAudioEngineUpdate(1250); //////////////////////////////////////////////////////////////// // 5. Check that 2 consecutive calls to ExitLoop does not crash loopedInst.Play(); ActiveAudioEngineUpdate(100); // Play need to be commited loopedInst.ExitLoop(); Assert.DoesNotThrow(loopedInst.ExitLoop, "A consecutive second call to SoundEffectInstance.ExitLoop crashed throwing an exception."); ActiveAudioEngineUpdate(1500); //////////////////////////////////////////////////////////////// // 6. Check that ExitLoop does not modify the value of IsLooped Assert.AreEqual(true, loopedInst.IsLooped, "SoundMusic.ExitLoop modified the value of IsLooped."); /////////////////////////////////////////////////////////////////////////////////////////// // 7. Check that a call to ExitLoop from another instance do not affect current instance. loopedInst.Play(); ActiveAudioEngineUpdate(100); // Play need to be commited monoInstance.ExitLoop(); ActiveAudioEngineUpdate(2000); Assert.AreEqual(SoundPlayState.Playing, loopedInst.PlayState, "Call to ExitLoop from another instance influenced current playing instance."); loopedInst.ExitLoop(); ActiveAudioEngineUpdate(1500); }
public void Initialize() { Game.InitializeAssetDatabase(); defaultEngine = AudioEngineFactory.NewAudioEngine(); monoInstance = SoundMusic.Load(defaultEngine, OpenDataBaseStream("MusicBip")); stereoInstance = SoundMusic.Load(defaultEngine, OpenDataBaseStream("MusicStereo")); contInstance = SoundMusic.Load(defaultEngine, OpenDataBaseStream("MusicToneA")); mp3Instance = SoundMusic.Load(defaultEngine, OpenDataBaseStream("MusicFishLampMp3")); wavInstance = SoundMusic.Load(defaultEngine, OpenDataBaseStream("MusicBip")); }
public void Initialize() { Game.InitializeAssetDatabase(); engine = AudioEngineFactory.NewAudioEngine(); using (var stream = ContentManager.FileProvider.OpenStream("EffectBip", VirtualFileMode.Open, VirtualFileAccess.Read)) { oneSound = SoundEffect.Load(engine, stream); } oneSound.IsLooped = true; sayuriPart = SoundMusic.Load(engine, ContentManager.FileProvider.OpenStream("MusicFishLampMp3", VirtualFileMode.Open, VirtualFileAccess.Read)); sayuriPart.IsLooped = true; }
public void TestStop() { ////////////////////////////////////////////////////////////////////////////////// // 1. Check that stopping an Disposed instance throw the 'ObjectDisposedException' var dispInst = SoundMusic.Load(defaultEngine, OpenDataBaseStream("EffectToneA")); dispInst.Dispose(); Assert.Throws <ObjectDisposedException>(dispInst.Stop, "SoundMusic.Stop did not throw the 'ObjectDisposedException' when called from a disposed object."); ////////////////////////////////////////////////////////////////////////// // 2. Check that Stop does not crash when the sound is not started/stopped Assert.DoesNotThrow(mp3Instance.Stop, "Call to SoundMusic.Stop crashed throwing an exception with a stopped sound."); ////////////////////////////////////////////////////////////////////////////////////////// // 3. Check that Stop does not crash and has the correct effect when called during playing mp3Instance.Play(); ActiveAudioEngineUpdate(2000); Assert.DoesNotThrow(mp3Instance.Stop, "Call to SoundMusic.Stop crashed throwing an exception."); ActiveAudioEngineUpdate(600); mp3Instance.Play(); ActiveAudioEngineUpdate(2000); mp3Instance.Stop(); ActiveAudioEngineUpdate(2000); /////////////////////////////////////////////////////////////////////////// // 4. Check that a call to stop does not crash when paused reset the sound mp3Instance.Play(); ActiveAudioEngineUpdate(2000); mp3Instance.Pause(); Assert.DoesNotThrow(mp3Instance.Stop, "Call to SoundMusic.Stop while paused crashed throwing an exception."); ActiveAudioEngineUpdate(600); mp3Instance.Play(); ActiveAudioEngineUpdate(2000); /////////////////////////////////////////////////////////////// // 5. Check that Pause from another instance has no influence mp3Instance.Play(); monoInstance.Stop(); ActiveAudioEngineUpdate(1000); Assert.AreEqual(SoundPlayState.Playing, mp3Instance.PlayState, "Stop from another music instance stopped current music."); ActiveAudioEngineUpdate(1000); mp3Instance.Stop(); ActiveAudioEngineUpdate(100); }
public void TestLoadAndPlayValid() { /////////////////////////// // 1. Load a valid wav file using (var music = SoundMusic.Load(defaultEngine, OpenDataBaseStream("EffectToneA"))) { music.Play(); Assert.DoesNotThrow(() => ActiveAudioEngineUpdate(1000), "Successive SoundMusic.Load -> SoundMusic.Play have thrown an exception when called with an valid wav file."); } /////////////////////////// // 2. Load a valid mp3 file using (var music = SoundMusic.Load(defaultEngine, OpenDataBaseStream("MusicFishLampMp3"))) { music.Play(); Assert.DoesNotThrow(() => ActiveAudioEngineUpdate(1000), "Successive SoundMusic.Load -> SoundMusic.Play have thrown an exception when called with an valid mp3 file."); } ActiveAudioEngineUpdate(100); }
public void TestLoad() { /////////////////////////////////////////////////////////////////////////////////////////////////////////////// // 1. Check that SoundMusic.Load throws "ArgumentNullException" when either 'engine' or 'filename' param is null // 1.1 Null engine Assert.Throws <ArgumentNullException>(() => SoundMusic.Load(null, new MemoryStream()), "SoundMusic.Load did not throw 'ArgumentNullException' when called with a null engine."); // 1.2 Null stream Assert.Throws <ArgumentNullException>(() => SoundMusic.Load(defaultEngine, null), "SoundMusic.Load did not throw 'ArgumentNullException' when called with a null stream."); /////////////////////////////////////////////////////////////////////////////////////////////////////// // 2. Check that the load function throws "ObjectDisposedException" when the audio engine is disposed. var disposedEngine = AudioEngineFactory.NewAudioEngine(); disposedEngine.Dispose(); Assert.Throws <ObjectDisposedException>(() => SoundMusic.Load(disposedEngine, OpenDataBaseStream("EffectToneA")), "SoundMusic.Load did not throw 'ObjectDisposedException' when called with a displosed audio engine."); /////////////////////////// // 4. Load a valid wav file Assert.DoesNotThrow(() => SoundMusic.Load(defaultEngine, OpenDataBaseStream("EffectToneA")), "SoundMusic.Load have thrown an exception when called with an valid wav file."); /////////////////////////// // 5. Load a valid mp3 file Assert.DoesNotThrow(() => SoundMusic.Load(defaultEngine, OpenDataBaseStream("MusicFishLampMp3")), "SoundMusic.Load have thrown an exception when called with an valid wav file."); }
public void TestDispose() { ////////////////////////////////////////////////////////////// // 1. Check the value of the IsDisposed function before Disposal var instance = SoundMusic.Load(defaultEngine, OpenDataBaseStream("MusicFishLampMp3")); Assert.IsFalse(instance.IsDisposed, "The soundEffectInstance returned by CreateInstance is already marked as disposed."); ///////////////////////////////////////// // 2. Check that dispose does not crash Assert.DoesNotThrow(instance.Dispose, "SoundEffectInstance.Dispose crashed throwing an exception"); /////////////////////////////////////////////////////////////////// // 3. Check the Disposal status of the instance after Dispose call Assert.IsTrue(instance.IsDisposed, "The soundEffectInstance is not marked as 'Disposed' after call to SoundEffectInstance.Dispose"); ///////////////////////////////////////////////////////// // 4. Check that another call to Dispose does not crash Assert.Throws <InvalidOperationException>(instance.Dispose, "Extra call to SoundEffectInstance.Dispose did not throw invalid operation exception"); ////////////////////////////////////////////////////////////////////////////////// // 5. Check that there is not crash when disposing an instance while it is playing var otherInst = SoundMusic.Load(defaultEngine, OpenDataBaseStream("MusicFishLampMp3")); otherInst.Play(); ActiveAudioEngineUpdate(1000); Assert.DoesNotThrow(otherInst.Dispose, "Call to SoundMusic.Dispose after Play crashed throwing an exception"); /////////////////////////////////////////////////////////// // 6. Check that sound is correctly stopped after dispose. ActiveAudioEngineUpdate(2000); /////////////////////////////////////////////////////////////////////////////////////////////////// // 7. Check that there is no crash if sound disposal happen before the sound is ready to be played var otherInst2 = SoundMusic.Load(defaultEngine, OpenDataBaseStream("MusicFishLampMp3")); otherInst2.Play(); defaultEngine.Update(); defaultEngine.Update(); Assert.DoesNotThrow(otherInst2.Dispose, "Call to SoundMusic.Dispose after Play and before ready-to-play state crashed throwing an exception"); ActiveAudioEngineUpdate(1000); //////////////////////////////////////////////////////////////////////////////////// // 8. Check that there is no crash if sound disposal happen before real call to Play var otherInst3 = SoundMusic.Load(defaultEngine, OpenDataBaseStream("MusicFishLampMp3")); otherInst3.Play(); otherInst3.Dispose(); Assert.DoesNotThrow(() => ActiveAudioEngineUpdate(1000), "Call to Engine.Update after commited Play/Dispose calls crashed throwing an exception"); ///////////////////////////////////////////////////////////////////////////////////// // 9. Check that there is no crash if sound disposal happen before real call to Stop var otherInst4 = SoundMusic.Load(defaultEngine, OpenDataBaseStream("MusicFishLampMp3")); otherInst4.Play(); ActiveAudioEngineUpdate(1000); otherInst4.Stop(); otherInst4.Dispose(); Assert.DoesNotThrow(() => ActiveAudioEngineUpdate(1000), "Call to Engine.Update after commited Stop/Dispose calls crashed throwing an exception"); ///////////////////////////////////////////////////////////////////////////////////// // 10. Check that there is no crash if sound disposal happen before real call to Stop var otherInst5 = SoundMusic.Load(defaultEngine, OpenDataBaseStream("MusicFishLampMp3")); otherInst5.Play(); ActiveAudioEngineUpdate(1000); otherInst5.Pause(); otherInst5.Dispose(); Assert.DoesNotThrow(() => ActiveAudioEngineUpdate(1000), "Call to Engine.Update after commited Pause/Dispose calls crashed throwing an exception"); ///////////////////////////////////////////////////////////////////////////////////// // 11. Check that there is no crash if sound disposal happen before real call to Stop var otherInst6 = SoundMusic.Load(defaultEngine, OpenDataBaseStream("MusicFishLampMp3")); otherInst6.Play(); ActiveAudioEngineUpdate(1000); otherInst6.Volume = 0.2f; otherInst6.Dispose(); Assert.DoesNotThrow(() => ActiveAudioEngineUpdate(1000), "Call to Engine.Update after commited Volume/Dispose calls crashed throwing an exception"); }
public void TestDispose() { var crossDisposedEngine = new AudioEngine(); var engine = new AudioEngine(); crossDisposedEngine.Dispose(); // Check there no Dispose problems with sereval cross-disposed instances. // Create some SoundEffects SoundEffect soundEffect; using (var wavStream = AssetManager.FileProvider.OpenStream("EffectBip", VirtualFileMode.Open, VirtualFileAccess.Read)) { soundEffect = SoundEffect.Load(engine, wavStream); } SoundEffect dispSoundEffect; using (var wavStream = AssetManager.FileProvider.OpenStream("EffectBip", VirtualFileMode.Open, VirtualFileAccess.Read)) { dispSoundEffect = SoundEffect.Load(engine, wavStream); } dispSoundEffect.Dispose(); var soundEffectInstance = soundEffect.CreateInstance(); var dispInstance = soundEffect.CreateInstance(); dispInstance.Dispose(); // Create some SoundMusics. var soundMusic1 = SoundMusic.Load(engine, AssetManager.FileProvider.OpenStream("MusicBip", VirtualFileMode.Open, VirtualFileAccess.Read)); var soundMusic2 = SoundMusic.Load(engine, AssetManager.FileProvider.OpenStream("MusicToneA", VirtualFileMode.Open, VirtualFileAccess.Read)); soundMusic2.Dispose(); // Create some dynamicSounds. var generator = new SoundGenerator(); var dynSound1 = new DynamicSoundEffectInstance(engine, 44100, AudioChannels.Mono, AudioDataEncoding.PCM_8Bits); var dynSound2 = new DynamicSoundEffectInstance(engine, 20000, AudioChannels.Mono, AudioDataEncoding.PCM_8Bits); dynSound1.Play(); dynSound1.SubmitBuffer(generator.Generate(44100, new[] { 1000f }, 1, 120000)); dynSound2.Dispose(); // Start playing some soundEffectInstance.Play(); soundMusic1.Play(); for (int i = 0; i < 10; i++) { engine.Update(); Utilities.Sleep(5); } Assert.DoesNotThrow(engine.Dispose, "AudioEngine crashed during disposal."); Assert.IsTrue(soundEffect.IsDisposed, "SoundEffect is not disposed."); Assert.Throws <InvalidOperationException>(engine.Dispose, "AudioEngine did not threw invalid operation exception."); Assert.AreEqual(SoundPlayState.Stopped, soundEffectInstance.PlayState, "SoundEffectInstance has not been stopped properly."); Assert.IsTrue(soundEffectInstance.IsDisposed, "SoundEffectInstance has not been disposed properly."); Assert.AreEqual(SoundPlayState.Stopped, soundMusic1.PlayState, "soundMusic1 has not been stopped properly."); Assert.IsTrue(soundMusic1.IsDisposed, "soundMusic1 has not been disposed properly."); //Assert.AreEqual(SoundPlayState.Stopped, dynSound1.PlayState, "The dynamic sound 1 has not been stopped correctly."); //Assert.IsTrue(dynSound1.IsDisposed, "The dynamic sound 1 has not been disposed correctly."); }
public void TestResumeAudio() { var engine = new AudioEngine(); // create a sound effect instance SoundEffect soundEffect; using (var wavStream = AssetManager.FileProvider.OpenStream("EffectBip", VirtualFileMode.Open, VirtualFileAccess.Read)) soundEffect = SoundEffect.Load(engine, wavStream); var wave1Instance = soundEffect.CreateInstance(); // create a music instance var music = SoundMusic.Load(engine, AssetManager.FileProvider.OpenStream("MusicFishLampMp3", VirtualFileMode.Open, VirtualFileAccess.Read)); // check that resume do not play stopped instances engine.PauseAudio(); engine.ResumeAudio(); Assert.AreEqual(SoundPlayState.Stopped, music.PlayState); Assert.AreEqual(SoundPlayState.Stopped, wave1Instance.PlayState); Utilities.Sleep(1000); // listen that nothing comes out // check that user paused music does not resume wave1Instance.Play(); wave1Instance.Pause(); engine.PauseAudio(); engine.ResumeAudio(); Assert.AreEqual(SoundPlayState.Paused, wave1Instance.PlayState); Utilities.Sleep(1000); // listen that nothing comes out // check that sounds paused by PauseAudio are correctly restarted wave1Instance.Play(); music.Play(); engine.PauseAudio(); engine.ResumeAudio(); Assert.AreEqual(SoundPlayState.Playing, wave1Instance.PlayState); Assert.AreEqual(SoundPlayState.Playing, music.PlayState); TestAudioUtilities.ActiveAudioEngineUpdate(engine, 3000); // listen that the sound comes out music.Stop(); TestAudioUtilities.ActiveAudioEngineUpdate(engine, 100); // stop the music // check that a sound stopped during the pause does not play during the resume wave1Instance.Play(); engine.PauseAudio(); wave1Instance.Stop(); engine.ResumeAudio(); Assert.AreEqual(SoundPlayState.Stopped, wave1Instance.PlayState); Utilities.Sleep(1000); // listen that nothing comes out // check that a sound played during the pause do not play during the resume engine.PauseAudio(); wave1Instance.Play(); engine.ResumeAudio(); Assert.AreEqual(SoundPlayState.Stopped, wave1Instance.PlayState); Utilities.Sleep(1000); // listen that nothing comes out // check that a two calls to resume do not have side effects (1) wave1Instance.Play(); engine.PauseAudio(); engine.ResumeAudio(); Assert.AreEqual(SoundPlayState.Playing, wave1Instance.PlayState); Utilities.Sleep(2000); // wait that the sound is finished engine.ResumeAudio(); Assert.AreEqual(SoundPlayState.Stopped, wave1Instance.PlayState); Utilities.Sleep(1000); // listen that nothing comes out // check that a two calls to resume do not have side effects (2) wave1Instance.Play(); engine.PauseAudio(); engine.ResumeAudio(); Assert.AreEqual(SoundPlayState.Playing, wave1Instance.PlayState); wave1Instance.Pause(); engine.ResumeAudio(); Assert.AreEqual(SoundPlayState.Paused, wave1Instance.PlayState); Utilities.Sleep(1000); // listen that nothing comes out // check that a several calls to pause/play do not have side effects wave1Instance.Play(); engine.PauseAudio(); engine.ResumeAudio(); engine.PauseAudio(); engine.ResumeAudio(); Assert.AreEqual(SoundPlayState.Playing, wave1Instance.PlayState); Utilities.Sleep(2000); // listen that the sound comes out // check that the sound is not played if disposed wave1Instance.Play(); engine.PauseAudio(); wave1Instance.Dispose(); engine.ResumeAudio(); Assert.AreEqual(SoundPlayState.Stopped, wave1Instance.PlayState); Utilities.Sleep(1000); // listen that nothing comes out music.Dispose(); soundEffect.Dispose(); }
public void TestPauseAudio() { var engine = new AudioEngine(); // create a sound effect instance SoundEffect soundEffect; using (var wavStream = AssetManager.FileProvider.OpenStream("EffectBip", VirtualFileMode.Open, VirtualFileAccess.Read)) soundEffect = SoundEffect.Load(engine, wavStream); var wave1Instance = soundEffect.CreateInstance(); // create a music instance var music = SoundMusic.Load(engine, AssetManager.FileProvider.OpenStream("MusicFishLampMp3", VirtualFileMode.Open, VirtualFileAccess.Read)); // check state engine.PauseAudio(); Assert.AreEqual(AudioEngineState.Paused, engine.State); // check that existing instance can not be played wave1Instance.Play(); Assert.AreEqual(SoundPlayState.Stopped, wave1Instance.PlayState); music.Play(); Assert.AreEqual(SoundPlayState.Stopped, music.PlayState); TestAudioUtilities.ActiveAudioEngineUpdate(engine, 1000); // listen that nothing comes out // create a new sound effect SoundEffect soundEffectStereo; using (var wavStream = AssetManager.FileProvider.OpenStream("EffectStereo", VirtualFileMode.Open, VirtualFileAccess.Read)) soundEffectStereo = SoundEffect.Load(engine, wavStream); // check that a new instance can not be played soundEffectStereo.Play(); Assert.AreEqual(SoundPlayState.Stopped, soundEffectStereo.PlayState); Utilities.Sleep(1000); // listen that nothing comes out // check that a stopped sound stay stopped engine.ResumeAudio(); soundEffectStereo.Stop(); engine.PauseAudio(); Assert.AreEqual(SoundPlayState.Stopped, soundEffectStereo.PlayState); // check that a paused sound stay paused engine.ResumeAudio(); soundEffectStereo.Play(); soundEffectStereo.Pause(); engine.PauseAudio(); Assert.AreEqual(SoundPlayState.Paused, soundEffectStereo.PlayState); // check that a playing sound is paused engine.ResumeAudio(); wave1Instance.Play(); soundEffectStereo.Play(); music.Play(); engine.PauseAudio(); Assert.AreEqual(SoundPlayState.Paused, wave1Instance.PlayState); Assert.AreEqual(SoundPlayState.Paused, soundEffectStereo.PlayState); Assert.AreEqual(SoundPlayState.Paused, music.PlayState); TestAudioUtilities.ActiveAudioEngineUpdate(engine, 1000); // listen that nothing comes out // check that stopping a sound while paused is possible engine.PauseAudio(); soundEffectStereo.Stop(); Assert.AreEqual(SoundPlayState.Stopped, soundEffectStereo.PlayState); // check that disposing a sound while paused is possible engine.PauseAudio(); music.Dispose(); Assert.IsTrue(music.IsDisposed); soundEffect.Dispose(); soundEffectStereo.Dispose(); }
public void TestVarious() { // test 0 mp3Instance.Play(); mp3Instance.Stop(); mp3Instance.Play(); mp3Instance.Stop(); mp3Instance.Play(); mp3Instance.Stop(); mp3Instance.Play(); Assert.AreEqual(SoundPlayState.Playing, mp3Instance.PlayState, "mp3Instance is not playing (test0)"); ActiveAudioEngineUpdate(2500); Assert.AreEqual(SoundPlayState.Playing, mp3Instance.PlayState, "mp3Instance is not still playing (test0)"); mp3Instance.Stop(); Assert.AreEqual(SoundPlayState.Stopped, mp3Instance.PlayState, "mp3Instance is not stopped (test0)"); //// test 1 monoInstance.Play(); monoInstance.Stop(); monoInstance.Play(); monoInstance.Stop(); monoInstance.Play(); monoInstance.Stop(); monoInstance.Play(); Assert.AreEqual(SoundPlayState.Playing, monoInstance.PlayState, "monoInstance is not playing (test1)"); ActiveAudioEngineUpdate(2500); Assert.AreEqual(SoundPlayState.Stopped, monoInstance.PlayState, "monoInstance is not stopped (test1)"); // test 2 mp3Instance.Play(); mp3Instance.Stop(); monoInstance.Play(); monoInstance.Stop(); monoInstance.Play(); ActiveAudioEngineUpdate(2500); Assert.AreEqual(SoundPlayState.Stopped, monoInstance.PlayState, "monoInstance is not stopped (test2)"); Assert.AreEqual(SoundPlayState.Stopped, mp3Instance.PlayState, "mp3Instance is not stopped (test2)"); // test 3 monoInstance.Play(); mp3Instance.Play(); monoInstance.Play(); mp3Instance.Play(); ActiveAudioEngineUpdate(2500); Assert.AreEqual(SoundPlayState.Playing, mp3Instance.PlayState, "mp3Instance is not playing (test3)"); Assert.AreEqual(SoundPlayState.Stopped, monoInstance.PlayState, "monoInstance is not stopped (test3)"); monoInstance.Play(); ActiveAudioEngineUpdate(2500); Assert.AreEqual(SoundPlayState.Stopped, mp3Instance.PlayState, "mp3Instance is not stopped (test3)"); Assert.AreEqual(SoundPlayState.Stopped, monoInstance.PlayState, "monoInstance is not playing (test3)"); // test 4 monoInstance.Play(); mp3Instance.Play(); monoInstance.Play(); Assert.AreEqual(SoundPlayState.Stopped, mp3Instance.PlayState, "mp3Instance is not stopped (test4)"); ActiveAudioEngineUpdate(2500); Assert.AreEqual(SoundPlayState.Stopped, monoInstance.PlayState, "monoInstance is not Stopped (test4)"); // test 5 monoInstance.Play(); contInstance.Play(); mp3Instance.Play(); monoInstance.Stop(); contInstance.Stop(); Assert.AreEqual(SoundPlayState.Stopped, monoInstance.PlayState, "monoInstance is not stopped (test5)"); Assert.AreEqual(SoundPlayState.Stopped, contInstance.PlayState, "contInstance is not stopped (test5)"); Assert.AreEqual(SoundPlayState.Playing, mp3Instance.PlayState, "mp3Instance is not playing (test5)"); ActiveAudioEngineUpdate(2100); Assert.AreEqual(SoundPlayState.Playing, mp3Instance.PlayState, "mp3Instance is not still playing (test5)"); // test 6: delayed Pause after several play monoInstance.Play(); monoInstance.Pause(); Assert.AreEqual(SoundPlayState.Paused, monoInstance.PlayState, "monoInstance is not Paused 1(test6)"); ActiveAudioEngineUpdate(200); Assert.AreEqual(SoundPlayState.Paused, monoInstance.PlayState, "monoInstance is not Paused 2(test6)"); monoInstance.Stop(); monoInstance.Play(); mp3Instance.Play(); mp3Instance.Pause(); Assert.AreEqual(SoundPlayState.Paused, mp3Instance.PlayState, "mp3Instance is not Paused 1(test6)"); ActiveAudioEngineUpdate(500); Assert.AreEqual(SoundPlayState.Paused, mp3Instance.PlayState, "mp3Instance is not Paused 2(test6)"); monoInstance.Play(); contInstance.Play(); mp3Instance.Play(); mp3Instance.Pause(); Assert.AreEqual(SoundPlayState.Paused, mp3Instance.PlayState, "mp3Instance is not Paused 3(test6)"); ActiveAudioEngineUpdate(500); Assert.AreEqual(SoundPlayState.Paused, mp3Instance.PlayState, "mp3Instance is not Paused 4(test6)"); // test 7 : random tests. var actionsSet = new List <TestSimpleAction> { //() => { Console.WriteLine("monoInstancePlay");monoInstance.Play(); } , //() => {Console.WriteLine("monoInstancePause");monoInstance.Pause(); } , //() => { Console.WriteLine("monoInstanceStop");monoInstance.Stop(); } , //() => { Console.WriteLine("contInstancePlay");contInstance.Play(); } , //() => { Console.WriteLine("contInstancePause");contInstance.Pause(); } , //() => { Console.WriteLine("contInstanceStop");contInstance.Stop(); } , //() => { Console.WriteLine("mp3InstancePlay"); mp3Instance.Play(); } , //() => { Console.WriteLine("mp3InstancePause");mp3Instance.Pause(); } , //() => { Console.WriteLine("mp3InstanceStop"); mp3Instance.Stop(); } , monoInstance.Play, monoInstance.Pause, monoInstance.Stop, contInstance.Play, contInstance.Pause, contInstance.Stop, mp3Instance.Play, mp3Instance.Pause, mp3Instance.Stop }; contInstance.IsLooped = false; const int NbOfRandActions = 50; for (int i = 0; i < 10; i++) { var rand1 = new Random(i); for (int j = 0; j < NbOfRandActions; j++) { actionsSet[rand1.Next(actionsSet.Count)].Invoke(); } //Console.WriteLine("monoInstancePlay"); monoInstance.Play(); Assert.AreEqual(SoundPlayState.Playing, monoInstance.PlayState, "monoInstance is not Playing 1(test7)"); Assert.AreEqual(SoundPlayState.Stopped, contInstance.PlayState, "contInstance is not Stopped 1(test7)"); Assert.AreEqual(SoundPlayState.Stopped, mp3Instance.PlayState, "mp3Instance is not Stopped 1(test7)"); ActiveAudioEngineUpdate(2500); Assert.AreEqual(SoundPlayState.Stopped, monoInstance.PlayState, "monoInstance is not Stopped 2(test7)"); //Console.WriteLine(""); //Console.WriteLine("END OF LOOP {0}", i); //Console.WriteLine(""); var rand2 = new Random(); // random seed for (int j = 0; j < NbOfRandActions; j++) { actionsSet[rand2.Next(actionsSet.Count)].Invoke(); } //Console.WriteLine("contInstancePlay"); contInstance.Play(); Assert.AreEqual(SoundPlayState.Playing, contInstance.PlayState, "contInstance is not Playing 3(test7)"); Assert.AreEqual(SoundPlayState.Stopped, monoInstance.PlayState, "monoInstance is not Stopped 3(test7)"); Assert.AreEqual(SoundPlayState.Stopped, mp3Instance.PlayState, "mp3Instance is not Stopped 3(test7)"); ActiveAudioEngineUpdate(3000); Assert.AreEqual(SoundPlayState.Stopped, contInstance.PlayState, "contInstance is not Stopped 4(test7)"); } contInstance.Stop(); contInstance.IsLooped = true; // test 8 : try to create a lot of instances { var musics = new SoundMusic[1000]; for (int i = 0; i < musics.Length; i++) { musics[i] = SoundMusic.Load(defaultEngine, OpenDataBaseStream("MusicFishLampMp3")); } musics[musics.Length - 1].Play(); ActiveAudioEngineUpdate(3000); musics[musics.Length / 2].Play(); ActiveAudioEngineUpdate(3000); foreach (var music in musics) { music.Dispose(); } } }
public void TestPlay() { ///////////////////////////////////// // 1. Check that Play does not crash Assert.DoesNotThrow(monoInstance.Play, "Call to SoundMusic.Play crashed throwing an exception."); //////////////////////////////////////////////////////////////////// // 2. Check that a second call to Play while playing does not crash Assert.DoesNotThrow(monoInstance.Play, "Second call to SoundMusic.Play while playing crashed throwing an exception."); //////////////////////////////////////////// // 3. Listen that the played sound is valid ActiveAudioEngineUpdate(1500); ////////////////////////////////////////////////////////////////// // 4. Check that there is no crash when restarting the sound Assert.DoesNotThrow(monoInstance.Play, "Restarting the audio sound after it finishes crashed throwing an exception."); ActiveAudioEngineUpdate(200); ////////////////////////////////////////////////////////////////////////////////////////////////////// // 5. Check that there is no crash when playing after pausing the sound and that play flow is correct monoInstance.Pause(); ActiveAudioEngineUpdate(200); Assert.DoesNotThrow(monoInstance.Play, "Restarting the audio sound after pausing it crashed throwing an exception."); ActiveAudioEngineUpdate(1500); ////////////////////////////////////////////////////////////////////////////////////////////////////// // 6. Check that there is no crash when playing after stopping a sound and that the play flow restart monoInstance.Play(); ActiveAudioEngineUpdate(200); monoInstance.Stop(); ActiveAudioEngineUpdate(200); Assert.DoesNotThrow(monoInstance.Play, "Restarting the audio sound after stopping it crashed throwing an exception."); int timeCount = 0; while (monoInstance.PlayState == SoundPlayState.Playing) { ActiveAudioEngineUpdate(1000); timeCount += 1000; if (timeCount > 3000) { Assert.Fail("SoundMusic.Play has not finished after 3 seconds."); } } //////////////////////////////////////////////////////////////// // 7. Play a stereo file a listen that the played sound is valid stereoInstance.Play(); ActiveAudioEngineUpdate(3000); ////////////////////////////////////////////////////////////////////////////////// // 8. Check that Playing an Disposed instance throw the 'ObjectDisposedException' var dispInstance = SoundMusic.Load(defaultEngine, OpenDataBaseStream("EffectToneA")); dispInstance.Dispose(); Assert.Throws <ObjectDisposedException>(dispInstance.Play, "SoundEffectInstance.Play did not throw the 'ObjectDisposedException' when called from a disposed object."); //////////////////////////////////////////////////////////////// // 9. Play a mp3 file and listen that the played sound is valid mp3Instance.Play(); ActiveAudioEngineUpdate(4000); ////////////////////////////////////////////////////////////////////////////// // 10. Play another music and check that the previous one is correctly stopped monoInstance.Play(); Assert.AreEqual(SoundPlayState.Playing, monoInstance.PlayState, "Mono intstance play status is not what it is supposed to be."); Assert.AreEqual(SoundPlayState.Stopped, mp3Instance.PlayState, "MP3 intstance play status is not what it is supposed to be."); ActiveAudioEngineUpdate(1500); }
public void TestVolume() { float vol = 0; ////////////////////////////////////////////////////////////////////////////////// // 1. Check that get and set Volume for an Disposed instance throw the 'ObjectDisposedException' var dispInst = SoundMusic.Load(defaultEngine, OpenDataBaseStream("EffectToneA")); dispInst.Dispose(); Assert.Throws <ObjectDisposedException>(() => vol = dispInst.Volume, "SoundMusic.Volume { get } did not throw the 'ObjectDisposedException' when called from a disposed object."); Assert.Throws <ObjectDisposedException>(() => dispInst.Volume = 0, "SoundMusic.Volume { set } did not throw the 'ObjectDisposedException' when called from a disposed object."); /////////////////////////////////////////////////////////// // 2. Check that Volume set/get do not crash on valid sound var volInst = SoundMusic.Load(defaultEngine, OpenDataBaseStream("EffectBip")); Assert.DoesNotThrow(() => vol = volInst.Volume, "SoundMusic.Volume { get } crashed."); Assert.DoesNotThrow(() => volInst.Volume = 0.5f, "SoundMusic.Volume { set } crashed."); ///////////////////////////////////////////////////// // 3. Check that Volume value is set to 1 by default Assert.AreEqual(1f, vol, "Default volume value is not 1."); ///////////////////////////////////////////////////////////////////////////////////////////////////////////////// // 4. Check that modifying the volume works and is correctly clamped (result => sound should go up and back down) volInst.IsLooped = true; volInst.Play(); var currentVol = -0.3f; var sign = 1f; while (currentVol >= -0.3f) { Assert.DoesNotThrow(() => volInst.Volume = currentVol, "SoundMusic.Volume { set } crashed."); Assert.DoesNotThrow(() => vol = volInst.Volume, "SoundMusic.Volume { get } crashed."); Assert.AreEqual(MathUtil.Clamp(currentVol, 0, 1), vol, "The volume value is not what is supposed to be."); ActiveAudioEngineUpdate(10); if (currentVol > 1.3) { sign = -1; } currentVol += sign * 0.005f; } volInst.Stop(); ActiveAudioEngineUpdate(1000); /////////////////////////////////////////////////////////////////////////////////////////// // 5. Check that modifying the volume on another instance does not affect current instance var volInst2 = SoundMusic.Load(defaultEngine, OpenDataBaseStream("EffectBip")); volInst.Play(); volInst.Volume = 1; ActiveAudioEngineUpdate(1500); volInst2.Volume = 0.2f; ActiveAudioEngineUpdate(1500); volInst.Stop(); ActiveAudioEngineUpdate(1000); ////////////////////////////////////////////////////////////////////////////////// // 6. Check that volume is correctly memorised and updated when changing music volInst2.Volume = 0.2f; volInst.Volume = 1f; volInst2.IsLooped = true; volInst.Play(); ActiveAudioEngineUpdate(1500); volInst2.Play(); ActiveAudioEngineUpdate(1500); volInst.Play(); ActiveAudioEngineUpdate(1500); volInst2.Stop(); /////////////////////////////////////////////////////////////////////////////// // 7. Check that modifying SoundMusic volume does not modify SoundEffectVolume SoundEffect soundEffect; using (var contStream = ContentManager.FileProvider.OpenStream("EffectToneA", VirtualFileMode.Open, VirtualFileAccess.Read)) { soundEffect = SoundEffect.Load(defaultEngine, contStream); } soundEffect.IsLooped = true; soundEffect.Play(); volInst.Play(); currentVol = -0.3f; sign = 1f; while (currentVol >= -0.3f) { volInst.Volume = currentVol; ActiveAudioEngineUpdate(10); if (currentVol > 1.3) { sign = -1; } currentVol += sign * 0.005f; } volInst.Stop(); soundEffect.Stop(); ActiveAudioEngineUpdate(1000); }