You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
609 lines
29 KiB
609 lines
29 KiB
package device.cdPlayer;
|
|
|
|
import device.Device;
|
|
import device.cdPlayer.exceptions.*;
|
|
import org.junit.jupiter.api.Test;
|
|
import org.junit.jupiter.api.extension.ExtendWith;
|
|
import org.junit.jupiter.params.ParameterizedTest;
|
|
import org.junit.jupiter.params.provider.Arguments;
|
|
import org.junit.jupiter.params.provider.MethodSource;
|
|
import org.mockito.Mockito;
|
|
import org.mockito.junit.jupiter.MockitoExtension;
|
|
|
|
import java.lang.reflect.Method;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.List;
|
|
import java.util.stream.Stream;
|
|
|
|
import static org.assertj.core.api.Assertions.assertThat;
|
|
import static org.junit.jupiter.api.Assertions.*;
|
|
import static org.mockito.Mockito.when;
|
|
|
|
@ExtendWith(MockitoExtension.class)
|
|
class CDPlayerTest {
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("playTestData")
|
|
void play(String testName, CDPlayer _cdPlayer,Exception exception , String expectedResult) {
|
|
if(exception!=null){
|
|
Exception newException=assertThrows(exception.getClass(),()->_cdPlayer.play());
|
|
assertEquals(expectedResult, newException.getMessage());
|
|
}else{
|
|
_cdPlayer.play();
|
|
assertThat(_cdPlayer.getStatus()).describedAs(testName).isEqualTo(expectedResult);
|
|
}
|
|
}
|
|
static Stream<Arguments> playTestData () {
|
|
//some PlayLists
|
|
String[] videoPlayList=new String[]{"Video 01","Video 02","Video 03","Video 04","Video 05"};
|
|
String[] audioPlayList=new String[]{"Audio 01","Audio 02","Audio 03","Audio 04","Audio 05"};
|
|
//some CDs
|
|
CD videoCD1=new CD("DVD",videoPlayList);
|
|
CD videoCD2=new CD("Blue-ray",videoPlayList);
|
|
CD audioCD1=new CD("Audio",audioPlayList);
|
|
CD audioCD2=new CD("MP3",audioPlayList);
|
|
CD audioCD3=new CD("WMA",audioPlayList);
|
|
CD audioCD4=new CD("AAC",audioPlayList);
|
|
|
|
//some CDPlayers
|
|
CDPlayer cdPlayer1=new CDPlayer();
|
|
|
|
CDPlayer cdPlayer2=new CDPlayer();
|
|
cdPlayer2.tapOnCdFlap();
|
|
cdPlayer2.tapOnCdFlap();
|
|
|
|
CDPlayer cdPlayer3=new CDPlayer();
|
|
cdPlayer3.tapOnCdFlap();
|
|
|
|
CDPlayer cdPlayer4=new CDPlayer();
|
|
cdPlayer4.tapOnCdFlap();
|
|
cdPlayer4.setCD(videoCD1);
|
|
|
|
//===================================
|
|
CDPlayer cdPlayer5=new CDPlayer();
|
|
cdPlayer5.tapOnCdFlap();
|
|
cdPlayer5.setCD(videoCD1);
|
|
cdPlayer5.tapOnCdFlap();
|
|
|
|
CDPlayer cdPlayer6=new CDPlayer();
|
|
cdPlayer6.tapOnCdFlap();
|
|
cdPlayer6.setCD(videoCD2);
|
|
cdPlayer6.tapOnCdFlap();
|
|
//===================================
|
|
|
|
CDPlayer cdPlayer7=new CDPlayer();
|
|
cdPlayer7.tapOnCdFlap();
|
|
cdPlayer7.setCD(audioCD1);
|
|
cdPlayer7.tapOnCdFlap();
|
|
|
|
CDPlayer cdPlayer8=new CDPlayer();
|
|
cdPlayer8.tapOnCdFlap();
|
|
cdPlayer8.setCD(audioCD2);
|
|
cdPlayer8.tapOnCdFlap();
|
|
|
|
CDPlayer cdPlayer9=new CDPlayer();
|
|
cdPlayer9.tapOnCdFlap();
|
|
cdPlayer9.setCD(audioCD3);
|
|
cdPlayer9.tapOnCdFlap();
|
|
|
|
CDPlayer cdPlayer10=new CDPlayer();
|
|
cdPlayer10.tapOnCdFlap();
|
|
cdPlayer10.setCD(audioCD4);
|
|
cdPlayer10.tapOnCdFlap();
|
|
|
|
return Stream.of(
|
|
Arguments.of("[CdFlap=isClosed , CdDriveContent=>isEmpty] => NoCD", cdPlayer1, new NoCDException(), "CD must be set."),
|
|
Arguments.of("[CdFlap has been Opened and Closed, CdDriveContent=>isEmpty] => NoCD", cdPlayer2,new NoCDException(),"CD must be set."),
|
|
Arguments.of("[CdFlap=isOpen , CdDriveContent=>isEmpty] => CdFlapIsOpen", cdPlayer3,new CdFlapIsOpenException(),"Cd Flap must be closed."),
|
|
Arguments.of("[CdFlap=isOpen , CdDriveContent=>isSet] => CdFlapIsOpen", cdPlayer4,new CdFlapIsOpenException(),"Cd Flap must be closed."),
|
|
Arguments.of("[CdFlap=isClosed , CdDriveContent=>isSet, CdFormat=>DVD] => FormatNotSupported",cdPlayer5,new FormatNotSupportedException(),"Cd-Format not supported."),
|
|
Arguments.of("[CdFlap=isClosed , CdDriveContent=>isSet, CdFormat=>Blue-ray] => FormatNotSupported",cdPlayer6, new FormatNotSupportedException(),"Cd-Format not supported."),
|
|
Arguments.of("[CdFlap=isClosed , CdDriveContent=>isSet, CdFormat=>Audio] => AllConditionsForPlayMet", cdPlayer7,null,"AllConditionsForPlayMet"),
|
|
Arguments.of("[CdFlap=isClosed , CdDriveContent=>isSet, CdFormat=>MP3] => AllConditionsForPlayMet", cdPlayer8,null,"AllConditionsForPlayMet"),
|
|
Arguments.of("[CdFlap=isClosed , CdDriveContent=>isSet, CdFormat=>WMA] => AllConditionsForPlayMet", cdPlayer9,null,"AllConditionsForPlayMet"),
|
|
Arguments.of("[CdFlap=isClosed , CdDriveContent=>isSet, CdFormat=>AAC] => AllConditionsForPlayMet", cdPlayer10,null,"AllConditionsForPlayMet")
|
|
);
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("louderTestData")
|
|
void louderTest(String testName,String testDirection, CDPlayer _cdPlayer,int anzClicks, int expectedResult) {
|
|
for (int i = 0; i < anzClicks; i++) {
|
|
_cdPlayer.louder();
|
|
}
|
|
if(testDirection.equals("VolumeIncreased")){
|
|
assertThat(_cdPlayer.getVolume()).describedAs(testName).isEqualTo(expectedResult);
|
|
}
|
|
if(testDirection.equals("VolumeHasChanged")){
|
|
assertThat(_cdPlayer.getVolume()).describedAs(testName).isNotEqualTo(expectedResult);
|
|
}if(testDirection.equals("VolumeNotDecreased")){
|
|
assertThat(_cdPlayer.getVolume()).describedAs(testName).isNotEqualTo(expectedResult);
|
|
}
|
|
}
|
|
static Stream<Arguments> louderTestData () {
|
|
CDPlayer cdPlayer=new CDPlayer();
|
|
return Stream.of(
|
|
Arguments.of("[getVolume() after 20x louder() ] => VolumeIncreased","VolumeIncreased", cdPlayer, 20, 20),
|
|
Arguments.of("[getVolume() after 2x louder() ] => VolumeHasChanged","VolumeHasChanged" ,cdPlayer,2,0),
|
|
Arguments.of("[getVolume() after 5x louder() ] => VolumeDecreased","VolumeNotDecreased", cdPlayer,5,-5)
|
|
);
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("quieterTestData")
|
|
void quieterTest(String testName,String testDirection, CDPlayer _cdPlayer,int anzClicks, int expectedResult) {
|
|
for (int i = 0; i < anzClicks; i++) {
|
|
_cdPlayer.quieter();
|
|
}
|
|
|
|
if(testDirection.equals("VolumeDecreased")){
|
|
for (int i = 0; i < 20; i++) {
|
|
_cdPlayer.louder();
|
|
}
|
|
for (int i = 0; i < anzClicks; i++) {
|
|
_cdPlayer.quieter();
|
|
}
|
|
assertThat(_cdPlayer.getVolume()).describedAs(testName).isEqualTo(expectedResult);
|
|
}
|
|
if(testDirection.equals("VolumeHasNotChanged")){
|
|
assertThat(_cdPlayer.getVolume()).describedAs(testName).isEqualTo(expectedResult);
|
|
}if(testDirection.equals("VolumeNotIncreased")){
|
|
|
|
assertThat(_cdPlayer.getVolume()).describedAs(testName).isNotEqualTo(expectedResult);
|
|
}
|
|
}
|
|
|
|
static Stream<Arguments> quieterTestData () {
|
|
CDPlayer cdPlayer=new CDPlayer();
|
|
return Stream.of(
|
|
Arguments.of("[getVolume() after 20x quieter() starting by 20] => VolumeHasDecreased","VolumeDecreased", cdPlayer, 19, 1),
|
|
Arguments.of("[getVolume() after 20x quieter() starting by 0] => VolumeHasNotChanged","VolumeHasNotChanged" ,cdPlayer,20,0),
|
|
Arguments.of("[getVolume() after 5x quieter() starting by 0] => VolumeNotIncreased","VolumeNotIncreased", cdPlayer,5,5)
|
|
);
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("nextTestData")
|
|
void nextTest(String testName,String testDirection, CDPlayer _cdPlayer,int anzClicks, String expectedResult){
|
|
|
|
if(testDirection.equals("SecondSongSelected")|| testDirection.equals("ThirdSongSelected")){
|
|
for (int i = 0; i < anzClicks; i++) {
|
|
_cdPlayer.next();
|
|
}
|
|
assertThat(_cdPlayer.getActualPlayTrack()).describedAs(testName).isEqualTo(expectedResult);
|
|
}
|
|
if(testDirection.equals("FirstSongSelected")){
|
|
for (int i = 0; i <anzClicks; i++) {
|
|
_cdPlayer.next();
|
|
}
|
|
assertThat(_cdPlayer.getActualPlayTrack()).describedAs(testName).isEqualTo(expectedResult);
|
|
}
|
|
}
|
|
static Stream<Arguments> nextTestData () {
|
|
|
|
String[] audioPlayList=new String[]{"Audio 01","Audio 02","Audio 03","Audio 04","Audio 05"};
|
|
CD audioCD=new CD("Audio",audioPlayList);
|
|
|
|
CDPlayer cdPlayer1=new CDPlayer();
|
|
cdPlayer1.tapOnCdFlap();
|
|
cdPlayer1.setCD(audioCD);
|
|
cdPlayer1.tapOnCdFlap();
|
|
|
|
CDPlayer cdPlayer2=new CDPlayer();
|
|
cdPlayer2.tapOnCdFlap();
|
|
cdPlayer2.setCD(audioCD);
|
|
cdPlayer2.tapOnCdFlap();
|
|
|
|
CDPlayer cdPlayer3=new CDPlayer();
|
|
cdPlayer3.tapOnCdFlap();
|
|
cdPlayer3.setCD(audioCD);
|
|
cdPlayer3.tapOnCdFlap();
|
|
|
|
return Stream.of(
|
|
Arguments.of("[getActualPlayTrack() after 1x next() starting by firstSong] => SecondSongSelected","SecondSongSelected", cdPlayer1, 1, cdPlayer1.getSongByNumber(1)),
|
|
Arguments.of("[getActualPlayTrack() after 2x next() starting by firstSong] => ThirdSongSelected","ThirdSongSelected" ,cdPlayer2,2,cdPlayer2.getSongByNumber(2)),
|
|
Arguments.of("[getActualPlayTrack() after 1x next() starting by lastSong] => FirstSongSelected","FirstSongSelected", cdPlayer3,cdPlayer3.getItemList().length,cdPlayer3.getSongByNumber(0))
|
|
);
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("prevTestData")
|
|
void prevTest(String testName,String testDirection, CDPlayer _cdPlayer,int anzClicks, String expectedResult){
|
|
if(testDirection.equals("StartingBySecondSong")) {
|
|
_cdPlayer.next();
|
|
}
|
|
if(testDirection.equals("StartingByThirdSong")) {
|
|
_cdPlayer.next();
|
|
_cdPlayer.next();
|
|
}
|
|
for (int i = 0; i < anzClicks; i++) {
|
|
_cdPlayer.prev();
|
|
}
|
|
assertThat(_cdPlayer.getActualPlayTrack()).describedAs(testName).isEqualTo(expectedResult);
|
|
}
|
|
static Stream<Arguments> prevTestData () {
|
|
|
|
String[] audioPlayList = new String[]{"Audio 01", "Audio 02", "Audio 03", "Audio 04", "Audio 05"};
|
|
CD audioCD = new CD("Audio", audioPlayList);
|
|
|
|
CDPlayer cdPlayer1 = new CDPlayer();
|
|
cdPlayer1.tapOnCdFlap();
|
|
cdPlayer1.setCD(audioCD);
|
|
cdPlayer1.tapOnCdFlap();
|
|
|
|
return Stream.of(
|
|
Arguments.of("[getActualPlayTrack() after 1x prev() starting by secondSong] => FirstSongSelected", "StartingBySecondSong", cdPlayer1, 1, cdPlayer1.getSongByNumber(0)),
|
|
Arguments.of("[getActualPlayTrack() after 2x prev() starting by thirdSong] => FirstSongSelected", "StartingByThirdSong", cdPlayer1, 2, cdPlayer1.getSongByNumber(0)),
|
|
Arguments.of("[getActualPlayTrack() after 1x prev() starting by firstSong] => FirstSongSelected", "StartingByFirstSong", cdPlayer1, 1, cdPlayer1.getSongByNumber(0))
|
|
);
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("getOptionsTestData")
|
|
void getOptionsTest(String testName,String testDirection, CDPlayer _cdPlayer){
|
|
if(testDirection.equals("ReturnValueNotNull")) {
|
|
assertThat(_cdPlayer.getOptions()).describedAs(testName).isNotEqualTo(null);
|
|
}
|
|
if(testDirection.equals("ArrayLengthGreaterThen0")) {
|
|
assertThat(_cdPlayer.getOptions().length).describedAs(testName).isNotEqualTo(0);
|
|
}
|
|
if(testDirection.equals("ArrayContainsInterfaceMethods")) {
|
|
Method[]interfaceMethods=Device.class.getDeclaredMethods();
|
|
List<String> deviceMethods = new ArrayList<String>(Arrays.asList(_cdPlayer.getOptions()));
|
|
for (int i = 0; i < interfaceMethods.length; i++) {
|
|
assertThat(deviceMethods.contains(interfaceMethods[i].getName())).describedAs(testName).isEqualTo(true);
|
|
}
|
|
}
|
|
}
|
|
static Stream<Arguments> getOptionsTestData () {
|
|
CDPlayer cdPlayer1 = new CDPlayer();
|
|
return Stream.of(
|
|
Arguments.of("[getOptions(): shouldNotReturnNull] => ReturnValueNotNull", "ReturnValueNotNull", cdPlayer1),
|
|
Arguments.of("[getOptions(): shouldReturnAnArrayWithLengthGreaterThen0] => ArrayLengthGreaterThen0", "ArrayLengthGreaterThen0", cdPlayer1),
|
|
Arguments.of("[getOptions(): shouldReturnAnArrayWithInAllInterfaceMethods] => ArrayContainsInterfaceMethods", "ArrayContainsInterfaceMethods", cdPlayer1)
|
|
);
|
|
}
|
|
|
|
@Test
|
|
void getVolumeReturnValueBetween0And100(){
|
|
CDPlayer cdPlayer1 = new CDPlayer();
|
|
boolean volumeIstInValueRange=false;
|
|
int volume=cdPlayer1.getVolume();
|
|
if(volume>=0 && volume <=100){
|
|
volumeIstInValueRange=true;
|
|
}
|
|
assertThat(volumeIstInValueRange).isEqualTo(true);
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("getInfoTestData")
|
|
void getInfoTest(String testName,String cases, CDPlayer _cdPlayer,Exception exception , String expectedResult){
|
|
|
|
if(cases.equals("Case1")) {
|
|
Exception newException = assertThrows(exception.getClass(), () -> _cdPlayer.getInfoText());
|
|
assertEquals(ReturnValueNullException.class, newException.getClass());
|
|
}
|
|
if(cases.equals("Case2")) {
|
|
Exception newException = assertThrows(exception.getClass(), () -> _cdPlayer.getInfoText());
|
|
assertThat(newException.getMessage()).describedAs(testName).isEqualTo(expectedResult);
|
|
}
|
|
if(cases.equals("Case3")) {
|
|
String[] album= _cdPlayer.getItemList();
|
|
boolean containsInfoOfActualPlayTrack=false;
|
|
for (int i = 0; i < album.length; i++) {
|
|
if(_cdPlayer.getInfoText().contains(expectedResult))
|
|
containsInfoOfActualPlayTrack=true;
|
|
}
|
|
assertThat(containsInfoOfActualPlayTrack).describedAs(testName).isEqualTo(true);
|
|
}
|
|
if(cases.equals("Case4")) {
|
|
String albumName= _cdPlayer.getCD().getAlbumName();
|
|
assertThat(_cdPlayer.getInfoText().contains(albumName)).describedAs(testName).isEqualTo(true);
|
|
}
|
|
if(cases.equals("Case5")) {
|
|
assertThat(_cdPlayer.getInfoText().contains("CDPlayer")).describedAs(testName).isEqualTo(true);
|
|
}
|
|
|
|
}
|
|
static Stream<Arguments> getInfoTestData () {
|
|
CDPlayer cdPlayer1 = new CDPlayer();
|
|
|
|
String[] audioPlayList=new String[]{"Audio 01","Audio 02","Audio 03","Audio 04","Audio 05"};
|
|
//some CDs
|
|
CD audioCD1=new CD("Audio",audioPlayList);
|
|
audioCD1.setAlbumName("Love Songs");
|
|
CDPlayer cdPlayer2 = new CDPlayer();
|
|
cdPlayer2.tapOnCdFlap();
|
|
cdPlayer2.setCD(audioCD1);
|
|
cdPlayer2.tapOnCdFlap();
|
|
cdPlayer2.setInfoText();
|
|
|
|
return Stream.of(
|
|
Arguments.of("[getInfoText() by infoText=null ] => shouldThrowReturnValueNullException","Case1", cdPlayer1,new ReturnValueNullException(),""),
|
|
Arguments.of("[getInfoText() by infoText=null ] => ExceptionShouldReturnAMessage","Case2",cdPlayer1,new ReturnValueNullException(),"Method should not return a Null-Value."),
|
|
Arguments.of("[getInfoText() by infoText=Message ] => MessageShouldContainInfoOfActualPlayTrack","Case3",cdPlayer2,null,""),
|
|
Arguments.of("[getInfoText() by infoText=Message ] => MessageShouldContainInfoAboutAlbum","Case4",cdPlayer2,null,""),
|
|
Arguments.of("[getInfoText() by infoText=Message ] => MessageShouldContainInfoAboutDevice","Case5",cdPlayer2,null,"")
|
|
);
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("chooseItemTestData")
|
|
void chooseItemTest(String testName,String cases, CDPlayer _cdPlayer,Exception exception ) {
|
|
if(cases.equals("Case1")) {
|
|
Exception newException = assertThrows(exception.getClass(), () -> _cdPlayer.chooseItem(1));
|
|
assertEquals(ReturnValueNullException.class, newException.getClass());
|
|
}
|
|
if(cases.equals("Case2")) {
|
|
Exception newException = assertThrows(exception.getClass(), () -> _cdPlayer.chooseItem(200));
|
|
assertEquals(ItemNumberNotFoundException.class, newException.getClass());
|
|
}
|
|
if(cases.equals("Case3")) {
|
|
Exception newException = assertThrows(exception.getClass(), () -> _cdPlayer.chooseItem(-1));
|
|
assertEquals(NegativeInputException.class, newException.getClass());
|
|
}
|
|
if(cases.equals("Case4")) {
|
|
assertThat(_cdPlayer.chooseItem(1).contains("2")).describedAs(testName).isEqualTo(true);
|
|
}
|
|
}
|
|
static Stream<Arguments> chooseItemTestData () {
|
|
CDPlayer cdPlayer1 = new CDPlayer();
|
|
|
|
String[] audioPlayList=new String[]{"Audio 01","Audio 02","Audio 03","Audio 04","Audio 05"};
|
|
CD audioCD1=new CD("Audio",audioPlayList);
|
|
CDPlayer cdPlayer2 = new CDPlayer();
|
|
cdPlayer2.tapOnCdFlap();
|
|
cdPlayer2.setCD(audioCD1);
|
|
cdPlayer2.tapOnCdFlap();
|
|
|
|
return Stream.of(
|
|
Arguments.of("[chooseItem() by notSetCD ] => shouldThrowReturnValueNullException","Case1", cdPlayer1,new ReturnValueNullException()),
|
|
Arguments.of("[chooseItem() by invalidInput ] => shouldThrowItemNumberNotFoundException","Case2", cdPlayer2,new ItemNumberNotFoundException()),
|
|
Arguments.of("[chooseItem() by invalidInput:negativeNumber] => shouldThrowItemNumberNotFoundException","Case3", cdPlayer2,new NegativeInputException()),
|
|
Arguments.of("[chooseItem() by validInput] => shouldReturnMsgWithinTheItemNr","Case4", cdPlayer2,null)
|
|
);
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("changePlaySourceData")
|
|
void changePlaySourceTest(String testName,String cases, CDPlayer _cdPlayer) {
|
|
|
|
if(cases.equals("Case1")) {
|
|
String returnVal = _cdPlayer.changePlaySource();
|
|
assertThat(returnVal).describedAs(testName).isEqualTo("CDWechseler");
|
|
}
|
|
if(cases.equals("Case2")) {
|
|
String returnVal = _cdPlayer.changePlaySource();
|
|
assertThat(returnVal).describedAs(testName).isEqualTo("CDDrive");
|
|
}
|
|
}
|
|
static Stream<Arguments> changePlaySourceData () {
|
|
CDPlayer cdPlayer1 = new CDPlayer();
|
|
|
|
CDPlayer cdPlayer2 = new CDPlayer();
|
|
cdPlayer2.changePlaySource();
|
|
|
|
return Stream.of(
|
|
Arguments.of("[changePlaySource() by activeSource=CDDrive ] => shouldReturnCDWechseler","Case1", cdPlayer1),
|
|
Arguments.of("[changePlaySource() by activeSource=CDWechseler ] => shouldReturnCDDrive","Case2", cdPlayer2)
|
|
);
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("loadCDWechselerData")
|
|
void loadCDWechselerTest(String testName,String cases, CDPlayer _cdPlayer,CD cd,Exception exception) {
|
|
if(cases.equals("Case1")) {
|
|
Exception newException = assertThrows(exception.getClass(), () -> _cdPlayer.loadCDWechseler(cd,0));
|
|
assertEquals(CDWechselerNotRunningException.class, newException.getClass());
|
|
}
|
|
if(cases.equals("Case2")) {
|
|
_cdPlayer.changePlaySource();
|
|
Exception newException = assertThrows(exception.getClass(), () -> _cdPlayer.loadCDWechseler(cd,0));
|
|
assertEquals(FormatNotSupportedException.class, newException.getClass());
|
|
}
|
|
if(cases.equals("Case3")) {
|
|
_cdPlayer.changePlaySource();
|
|
_cdPlayer.loadCDWechseler(cd,0);
|
|
CD firstCD=_cdPlayer.getCdWechseler().getCDList().get(0);
|
|
assertThat(firstCD).describedAs(testName).isNotEqualTo(null);
|
|
}
|
|
if(cases.equals("Case4")) {
|
|
_cdPlayer.changePlaySource();
|
|
Exception newException=assertThrows(exception.getClass(), () -> _cdPlayer.loadCDWechseler(cd, 12));
|
|
assertEquals(MaxCapacityExceededException.class, newException.getClass());
|
|
}
|
|
}
|
|
static Stream<Arguments> loadCDWechselerData () {
|
|
CDPlayer cdPlayer1 = new CDPlayer();
|
|
String[] videoPlayList=new String[]{"Video 01","Video 02","Video 03","Video 04","Video 05"};
|
|
String[] audioPlayList=new String[]{"Audio 01","Audio 02","Audio 03","Audio 04","Audio 05"};
|
|
|
|
CD audioCD1=new CD("Audio",audioPlayList);
|
|
CD DVD=new CD("DVD",videoPlayList);
|
|
return Stream.of(
|
|
Arguments.of("[loadCDWechseler() by notRunning=CDWechseler ] => shouldThrowAnException", "Case1", cdPlayer1,audioCD1,new CDWechselerNotRunningException()),
|
|
Arguments.of("[loadCDWechseler() by WrongCDFormat ] => shouldThrowAnException", "Case2", cdPlayer1,DVD,new FormatNotSupportedException()),
|
|
Arguments.of("[loadCDWechseler() by leadingFirstCD ] => CDListOfCDWechselerShouldHaveLength1", "Case3", cdPlayer1,audioCD1,null),
|
|
Arguments.of("[loadCDWechseler() by MaxCapacityExceeded:Max=10 ] => shouldThrowAnException", "Case4", cdPlayer1,audioCD1,new MaxCapacityExceededException())
|
|
);
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("changeToNextCDData")
|
|
void changeToNextCDTest(String testName,String cases, CDPlayer _cdPlayer,Exception exception) {
|
|
if(cases.equals("Case1")) {
|
|
Exception newException = assertThrows(exception.getClass(), () -> _cdPlayer.changeToNextCD());
|
|
assertEquals(ChangeCDOnlyOnCDWechselerException.class, newException.getClass());
|
|
}
|
|
if(cases.equals("Case2")) {
|
|
CD actualCD=_cdPlayer.getCD();
|
|
_cdPlayer.changeToNextCD();
|
|
CD nextCD=_cdPlayer.getCD();
|
|
assertThat(nextCD).describedAs(testName).isNotEqualTo(null);
|
|
}
|
|
if(cases.equals("Case3")) {
|
|
CD actualCD=_cdPlayer.getCD();
|
|
_cdPlayer.changeToNextCD();
|
|
CD nextCD=_cdPlayer.getCD();
|
|
assertThat(nextCD.getId()==actualCD.getId()).describedAs(testName).isNotEqualTo(true);
|
|
}
|
|
if(cases.equals("Case4")) {
|
|
CD actualCdBefore=_cdPlayer.getCD();
|
|
for (int i = 0; i <3 ; i++) {
|
|
_cdPlayer.changeToNextCD();
|
|
}
|
|
CD actualCdAfter=_cdPlayer.getCD();
|
|
assertThat(actualCdBefore.getId()==actualCdAfter.getId()).describedAs(testName).isEqualTo(true);
|
|
}
|
|
}
|
|
static Stream<Arguments> changeToNextCDData () {
|
|
String[] audioPlayList=new String[]{"Audio 01","Audio 02","Audio 03","Audio 04","Audio 05"};
|
|
CD audioCD1=new CD("Audio","PopMusic",audioPlayList,"XAc20044");
|
|
CD audioCD2=new CD("Audio","RockMusic",audioPlayList,"BLXPP78");
|
|
CD audioCD3=new CD("Audio","SalsaMusic",audioPlayList,"KKRP118");
|
|
|
|
CDPlayer cdPlayer1 = new CDPlayer();
|
|
|
|
CDPlayer cdPlayer2 = new CDPlayer();
|
|
cdPlayer2.changePlaySource();
|
|
cdPlayer2.loadCDWechseler(audioCD1,0);
|
|
cdPlayer2.loadCDWechseler(audioCD2,1);
|
|
cdPlayer2.loadCDWechseler(audioCD3,2);
|
|
|
|
|
|
CDPlayer cdPlayer3 = new CDPlayer();
|
|
cdPlayer3.changePlaySource();
|
|
cdPlayer3.loadCDWechseler(audioCD1,0);
|
|
cdPlayer3.loadCDWechseler(audioCD2,1);
|
|
cdPlayer3.loadCDWechseler(audioCD3,2);
|
|
|
|
CDPlayer cdPlayer4 = new CDPlayer();
|
|
cdPlayer4.changePlaySource();
|
|
cdPlayer4.loadCDWechseler(audioCD1,0);
|
|
cdPlayer4.loadCDWechseler(audioCD2,1);
|
|
cdPlayer4.loadCDWechseler(audioCD3,2);
|
|
|
|
return Stream.of(
|
|
Arguments.of("[changeToNextCD() by CDWechselerNotSelected ] => shouldThrowAnException", "Case1", cdPlayer1,new ChangeCDOnlyOnCDWechselerException()),
|
|
Arguments.of("[changeToNextCD() checking the effect ] => loadedCDShouldNotReturnNull", "Case2", cdPlayer2,null),
|
|
Arguments.of("[changeToNextCD() checking the effect 2 ] => loadedCDShouldNotHaveTheSameIdAsPrev", "Case3", cdPlayer3,null),
|
|
Arguments.of("[3x changeToNextCD() changing from last to first CD] => FirstCDShouldBeTaken", "Case4", cdPlayer4,null)
|
|
);
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("addToFavoriteSongsData")
|
|
void addToFavoriteSongsTest(String testName,String cases, CDPlayer _cdPlayer,Exception exception) {
|
|
if(cases.equals("Case1")) {
|
|
String myFavoriteSong = _cdPlayer.getCD().getPlayList()[0];
|
|
_cdPlayer.addToFavoriteSongs(myFavoriteSong);
|
|
assertThat(_cdPlayer.getFavoriteSongs().get(0)).describedAs(testName).isEqualTo(myFavoriteSong);
|
|
}
|
|
if(cases.equals("Case2")) {
|
|
String myFavoriteSong1 = _cdPlayer.getCD().getPlayList()[0];
|
|
String myFavoriteSong2 = _cdPlayer.getCD().getPlayList()[0];
|
|
_cdPlayer.addToFavoriteSongs(myFavoriteSong1);
|
|
_cdPlayer.addToFavoriteSongs(myFavoriteSong2);
|
|
assertThat(_cdPlayer.getFavoriteSongs().size()>1).describedAs(testName).isNotEqualTo(true);
|
|
}
|
|
if(cases.equals("Case3")) {
|
|
String myFavoriteSong1 = _cdPlayer.getCD().getPlayList()[0];
|
|
Exception newException = assertThrows(exception.getClass(), () -> _cdPlayer.addToFavoriteSongs(myFavoriteSong1));
|
|
assertEquals(CDWechselerNotRunningException.class, newException.getClass());
|
|
}
|
|
}
|
|
static Stream<Arguments> addToFavoriteSongsData () {
|
|
String[] audioPlayList = new String[]{"Audio 01", "Audio 02", "Audio 03", "Audio 04", "Audio 05"};
|
|
CD audioCD1 = new CD("Audio", "PopMusic", audioPlayList, "XAc20044");
|
|
CD audioCD2=new CD("Audio","RockMusic",audioPlayList,"BLXPP78");
|
|
|
|
CDPlayer cdPlayer1 = new CDPlayer();
|
|
cdPlayer1.changePlaySource();
|
|
cdPlayer1.loadCDWechseler(audioCD1, 0);
|
|
cdPlayer1.loadCDWechseler(audioCD2, 1);
|
|
|
|
CDPlayer cdPlayer2 = new CDPlayer();
|
|
cdPlayer2.setCD(audioCD2);
|
|
return Stream.of(
|
|
Arguments.of("[addToFavoriteSongs() by addingOneSong] => favoriteSongsShouldReturnsThatAddedSong", "Case1", cdPlayer1, null),
|
|
Arguments.of("[addToFavoriteSongs() by addingDuplicatedSong] => SongShouldNotBeAdded", "Case2", cdPlayer1, null),
|
|
Arguments.of("[addToFavoriteSongs() by NotSelectingCDWechseler] => shouldThrowAnException", "Case3", cdPlayer2, new CDWechselerNotRunningException())
|
|
);
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("muteTestData")
|
|
void muteTest(String testName,String cases, CDPlayer _cdPlayer,String expectedResult) {
|
|
if(cases.equals("Case1")) {
|
|
assertThat(_cdPlayer.mute()).describedAs(testName).isEqualTo(expectedResult);
|
|
}
|
|
if(cases.equals("Case2")) {
|
|
_cdPlayer.mute();
|
|
assertThat(_cdPlayer.isMuted()).describedAs(testName).isEqualTo(true);
|
|
}
|
|
if(cases.equals("Case3")) {
|
|
_cdPlayer.louder();
|
|
_cdPlayer.louder();
|
|
_cdPlayer.mute();
|
|
assertThat(_cdPlayer.getVolume()).describedAs(testName).isEqualTo(0);
|
|
}
|
|
if(cases.equals("Case4")) {
|
|
for (int i = 0; i < 5; i++) {
|
|
_cdPlayer.louder();
|
|
}
|
|
_cdPlayer.mute();
|
|
assertThat(_cdPlayer.getOldVolume()).describedAs(testName).isEqualTo(5);
|
|
}
|
|
}
|
|
static Stream<Arguments> muteTestData () {
|
|
CDPlayer cdPlayer1 = new CDPlayer();
|
|
return Stream.of(
|
|
Arguments.of("[mute() by checkingTheReturnValue ] => ShouldReturnAString", "Case1", cdPlayer1, "Volume muted."),
|
|
Arguments.of("[mute() by checkingTheEffectAfterRun ] => VariableMutedShouldBeTrue", "Case2", cdPlayer1, "Volume muted."),
|
|
Arguments.of("[mute() after 2x louder() by checkingTheVolume] => VolumeShouldBeSetTo0", "Case3", cdPlayer1, "Volume muted."),
|
|
Arguments.of("[mute() after 5x louder() by checkingTheSavedOldVolume] => getOldVolumeShouldReturns_5", "Case4", cdPlayer1, "Volume muted.")
|
|
);
|
|
}
|
|
|
|
@ParameterizedTest
|
|
@MethodSource("unmuteTestData")
|
|
void unmuteTest(String testName,String cases, CDPlayer _cdPlayer,String expectedResult) {
|
|
if(cases.equals("Case1")) {
|
|
assertThat(_cdPlayer.unmute()).describedAs(testName).isEqualTo(expectedResult);
|
|
}
|
|
if(cases.equals("Case2")) {
|
|
_cdPlayer.unmute();
|
|
assertThat(_cdPlayer.isMuted()).describedAs(testName).isEqualTo(false);
|
|
}
|
|
if(cases.equals("Case3")) {
|
|
for (int i = 0; i < 5; i++) {
|
|
_cdPlayer.louder();
|
|
}
|
|
_cdPlayer.mute();
|
|
_cdPlayer.unmute();
|
|
assertThat(_cdPlayer.isMuted()).describedAs(testName).isEqualTo(false);
|
|
assertThat(_cdPlayer.getVolume()).describedAs(testName).isEqualTo(5);
|
|
}
|
|
if(cases.equals("Case4")) {
|
|
for (int i = 0; i < 6; i++) {
|
|
_cdPlayer.louder();
|
|
}
|
|
_cdPlayer.mute();
|
|
_cdPlayer.unmute();
|
|
assertThat(_cdPlayer.isMuted()).describedAs(testName).isEqualTo(false);
|
|
assertThat(_cdPlayer.getOldVolume()).describedAs(testName).isEqualTo(0);
|
|
}
|
|
}
|
|
static Stream<Arguments> unmuteTestData () {
|
|
CDPlayer cdPlayer1 = new CDPlayer();
|
|
return Stream.of(
|
|
Arguments.of("[unmute() by checkingTheReturnValue ] => ShouldReturnAString", "Case1", cdPlayer1, "Volume unmute."),
|
|
Arguments.of("[unmute() by checkingTheEffectAfterRun ] => VariableMutedShouldBeFalse", "Case2", cdPlayer1, "Volume unmute."),
|
|
Arguments.of("[unmute() by 5x louder()-> mute()] => getVolumeShouldReturn_5", "Case3", cdPlayer1, "Volume unmute."),
|
|
Arguments.of("[unmute() by 6x louder()-> mute()] => getOldVolumeShouldReturn_0", "Case4", cdPlayer1, "Volume unmute.")
|
|
);
|
|
}
|
|
|
|
|
|
}
|