Bordcomputer/src/test/java/device/usbPlayer/UsbPlayerTest.java

package device.usbPlayer;

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;

import java.util.stream.Stream;
import java.util.ArrayList;

import static org.assertj.core.api.Assertions.assertThat;

class UsbPlayerTest {

    //UsbPlayer up = new UsbPlayer();

    @ParameterizedTest
    @MethodSource("PlayOptions")
    void playTest(String testName, UsbPlayer inputPlay, String expectedResult) {
        String playState = inputPlay.play();
        assertThat(playState).describedAs(testName).isEqualTo(expectedResult);
    }

    static Stream<Arguments> PlayOptions() {
        USB_Stick USBDrive = new USB_Stick();
        UsbPlayer up1 = new UsbPlayer(USBDrive);
        UsbPlayer up8 = new UsbPlayer(USBDrive);
        up8.setPlayTrack("");
        UsbPlayer up2 = new UsbPlayer(USBDrive);
        ArrayList<String> l = new ArrayList<String>();
        l.add("a.mp3");
        l.add("b.mp3");
        l.add("c.gif");
        up2.setPlaylist(l);
        UsbPlayer up3 = new UsbPlayer(USBDrive);
        ArrayList<String> Pl = new ArrayList<String>();
        up3.setPlaylist(Pl);
        UsbPlayer up6 = new UsbPlayer(USBDrive);
        up6.setDefect(true);
        UsbPlayer up7 = new UsbPlayer(USBDrive);
        up7.setConnected(false);


        return Stream.of(
                Arguments.of("All right : ", up1, "USB : connected,working,have a list,Audio,point to a track."),
                Arguments.of("No first Track : ", up8, "USB : connected,working,have a list,Audio,doesn't point to a track."),
                Arguments.of("No Audio Files : ", up2, "USB : connected,working,have a list,not Audio."),
                Arguments.of("No list of tracks : ", up3, "USB : connected,working,have no list."),
                Arguments.of("connected , not working : ", up6, "USB : connected,not working."),
                Arguments.of("not connected : ", up7, "not connected."));
    }


    @ParameterizedTest
    @MethodSource("louderOptions")
    void louderTest(String testName, UsbPlayer inputPlay, int expectedResult) {
        int volumeNum = inputPlay.getLautstaerke();
        assertThat(volumeNum).describedAs(testName).isEqualTo(expectedResult);
    }

    static Stream<Arguments> louderOptions() {
        USB_Stick USBDrive = new USB_Stick();
        UsbPlayer up11 = new UsbPlayer(USBDrive);
        up11.louder();
        UsbPlayer up22 = new UsbPlayer(USBDrive);
        up22.setLautstaerke(100);
        up22.louder();
        return Stream.of(
                Arguments.of("Volume is : 1 ", up11, 1),
                Arguments.of("Volume is : 100 ", up22, 100)
        );
    }

    @ParameterizedTest
    @MethodSource("quieterOptions")
    void quieterTest(String testName, UsbPlayer inputPlay, int expectedResult) {
        int volumeNum = inputPlay.getLautstaerke();
        assertThat(volumeNum).describedAs(testName).isEqualTo(expectedResult);
    }

    static Stream<Arguments> quieterOptions() {
        USB_Stick USBDrive = new USB_Stick();
        UsbPlayer up1 = new UsbPlayer(USBDrive);
        up1.quieter();
        UsbPlayer up2 = new UsbPlayer(USBDrive);
        up2.setLautstaerke(10);
        up2.quieter();
        return Stream.of(
                Arguments.of("Volume must stay 0 ", up1, 0),
                Arguments.of("Volume must be 9 ", up2, 9)
        );
    }


    @ParameterizedTest
    @MethodSource("NextOptions")
    void NextTest(String testName, UsbPlayer inputPlay, String expectedResult) {
        String current_Track = inputPlay.getPlayTrack();
        assertThat(current_Track).describedAs(testName).isEqualTo(expectedResult);
    }

    static Stream<Arguments> NextOptions() {
        USB_Stick USBDrive = new USB_Stick();
        UsbPlayer up1 = new UsbPlayer(USBDrive);
        up1.next();
        UsbPlayer up2 = new UsbPlayer(USBDrive);
        for (int i = 1; i < up2.getPlaylist().size(); i++) {
            up2.next();
        }
        UsbPlayer up3 = new UsbPlayer(USBDrive);
        for (int i = 1; i < up3.getPlaylist().size(); i++) {
            up3.next();
        }
        up3.next();
        return Stream.of(
                Arguments.of("Second-Song : Musik 02.mp3 ", up1, "Musik 02.mp3"),
                Arguments.of("Last-Song : Musik 03.mp3  ", up2, "Musik 03.mp3"),
                Arguments.of("From last to first Song : Musik 01.mp3  ", up3, "Musik 01.mp3")

        );
    }

    @ParameterizedTest
    @MethodSource("PrevOptions")
    void PrevTest(String testName, UsbPlayer inputPlay, String expectedResult) {
        String current_Track = inputPlay.getPlayTrack();
        assertThat(current_Track).describedAs(testName).isEqualTo(expectedResult);
    }

    static Stream<Arguments> PrevOptions() {
        USB_Stick USBDrive = new USB_Stick();
        UsbPlayer up1 = new UsbPlayer(USBDrive);
        up1.prev();
        UsbPlayer up2 = new UsbPlayer(USBDrive);
        for (int i = 1; i < up2.getPlaylist().size(); i++) {//3
            up2.prev();
        }


        return Stream.of(
                Arguments.of("From first-Song to last-Song : Musik 03.mp3 ", up1, "Musik 03.mp3"),
                Arguments.of("From first-Song to second-Song(Backward) : Musik 02.mp3 ", up2, "Musik 02.mp3")
        );
    }

    @ParameterizedTest
    @MethodSource("louder_10_Options")
    void louder_10_Test(String testName, UsbPlayer inputPlay, int expectedResult) {
        int volumeNum = inputPlay.getLautstaerke();
        assertThat(volumeNum).describedAs(testName).isEqualTo(expectedResult);
    }

    static Stream<Arguments> louder_10_Options() {
        USB_Stick USBDrive = new USB_Stick();
        UsbPlayer up1 = new UsbPlayer(USBDrive);
        up1.Louder_10();

        UsbPlayer up2 = new UsbPlayer(USBDrive);
        for (int i = 0; i <= 3; i++) {
            up2.Louder_10();
        }
        up2.quieter_10();

        UsbPlayer up3 = new UsbPlayer(USBDrive);
        up3.setLautstaerke(100);
        up3.Louder_10();
        return Stream.of(
                Arguments.of("Volume was 0, should be 10 ", up1, 10),
                Arguments.of("Volume was 0, should be 30 ", up2, 30),
                Arguments.of("Volume was 100, should stay 100 ", up3, 100)
        );
    }

    @ParameterizedTest
    @MethodSource("quieter_10_Options")
    void quieter_10_Test(String testName, UsbPlayer inputPlay, int expectedResult) {
        int volumeNum = inputPlay.getLautstaerke();
        assertThat(volumeNum).describedAs(testName).isEqualTo(expectedResult);
    }

    static Stream<Arguments> quieter_10_Options() {
        USB_Stick USBDrive = new USB_Stick();
        UsbPlayer up1 = new UsbPlayer(USBDrive);
        up1.setLautstaerke(10);
        up1.quieter_10();

        UsbPlayer up2 = new UsbPlayer(USBDrive);
        up2.setLautstaerke(50);
        for (int i = 0; i < 3; i++) {
            up2.quieter_10();
        }

        UsbPlayer up3 = new UsbPlayer(USBDrive);
        up3.quieter_10();

        return Stream.of(
                Arguments.of("Volume was 10, should be 0 ", up1, 0),
                Arguments.of("Volume was 50, should be 20 ", up2, 20),
                Arguments.of("Volume was 0, should stay 0 ", up3, 0)
        );
    }

    @ParameterizedTest
    @MethodSource("FindSongOptions")
    void findSongTest(String testName, int inputPlay, int expectedResult) {
        //first case: the song is not in the Album
        // int songLoc1 = inputPlay.findSong("song 4");
        assertThat(inputPlay).describedAs(testName).isEqualTo(expectedResult);
        //Second Case: the song is in the album
        // int songLoc2 = inputPlay.findSong("Musik 02");
        assertThat(inputPlay).describedAs(testName).isEqualTo(expectedResult);

    }

    static Stream<Arguments> FindSongOptions() {
        USB_Stick USBDrive = new USB_Stick();
        UsbPlayer up1 = new UsbPlayer(USBDrive);
        return Stream.of(
                Arguments.of("The song is not in the Album", up1.findSong("song 4"), -1),
                Arguments.of("The song is in the Album", up1.findSong("Musik 02"), 1),
                Arguments.of("Name of the Song is in lower case :", up1.findSong("musik 02"), 1),
                Arguments.of("Name of the Song is in upper case :", up1.findSong("MUSIK 02"), 1)
        );
    }

    @ParameterizedTest
    @MethodSource("GoToOptions")
    void GoToTest(String testName, UsbPlayer inputPlay, String expectedResult) {
        String current_Track = inputPlay.getPlayTrack();
        assertThat(current_Track).describedAs(testName).isEqualTo(expectedResult);
    }

    static Stream<Arguments> GoToOptions() {
        USB_Stick USBDrive = new USB_Stick();
        UsbPlayer up1 = new UsbPlayer(USBDrive);
        up1.GoTo("Musik 03.mp3");

        UsbPlayer up2 = new UsbPlayer(USBDrive);
        up2.GoTo("Musik 04.mp3");

        UsbPlayer up3 = new UsbPlayer(USBDrive);
        up3.GoTo("Musik 02");

        UsbPlayer up4 = new UsbPlayer(USBDrive);
        up4.next();
        up4.GoTo("Musik");

        return Stream.of(
                Arguments.of("Go to Song : Musik 03.mp3 ", up1, "Musik 03.mp3"),
                Arguments.of("Go to Song that is not in the Album: Musik 04.mp3 ", up2, "Musik 01.mp3"),
                Arguments.of("Go to Song without writing the full Name : Musik 02 ", up3, "Musik 02.mp3"),
                Arguments.of("Go to Song and write a Name that many songs starts with : Musik", up4, "Musik 01.mp3")

        );
    }

    @ParameterizedTest
    @MethodSource("isAllAudioOptions")
    void isAllAudioTest(String testName, boolean inputTestResult, boolean expectedResult) {
        // String current_Track = inputPlay.getPlayTrack();
        assertThat(inputTestResult).describedAs(testName).isEqualTo(expectedResult);
    }

    static Stream<Arguments> isAllAudioOptions() {
        USB_Stick USBDrive = new USB_Stick();
        //mp3
        UsbPlayer up1 = new UsbPlayer(USBDrive);
        //mp4
        UsbPlayer up2 = new UsbPlayer(USBDrive);
        ArrayList<String> Pl = new ArrayList<String>();
        Pl.add("Musik 01.mp4");
        Pl.add("Musik 02.mp4");
        Pl.add("Musik 03.mp4");
        up2.setPlaylist(Pl);
        //m4a
        UsbPlayer up3 = new UsbPlayer(USBDrive);
        ArrayList<String> Pl1 = new ArrayList<String>();
        Pl1.add("Musik 01.m4a");
        Pl1.add("Musik 02.m4a");
        Pl1.add("Musik 03.m4a");
        up3.setPlaylist(Pl1);
        //wav
        UsbPlayer up4 = new UsbPlayer(USBDrive);
        ArrayList<String> Pl2 = new ArrayList<String>();
        Pl2.add("Musik 01.wav");
        Pl2.add("Musik 02.wav");
        Pl2.add("Musik 03.wav");
        up4.setPlaylist(Pl2);
        //wma
        UsbPlayer up5 = new UsbPlayer(USBDrive);
        ArrayList<String> Pl3 = new ArrayList<String>();
        Pl3.add("Musik 01.wma");
        Pl3.add("Musik 02.wma");
        Pl3.add("Musik 03.wma");
        up5.setPlaylist(Pl3);
        //aac
        UsbPlayer up6 = new UsbPlayer(USBDrive);
        ArrayList<String> Pl4 = new ArrayList<String>();
        Pl4.add("Musik 01.aac");
        Pl4.add("Musik 02.aac");
        Pl4.add("Musik 03.aac");
        up6.setPlaylist(Pl4);
        //mixed Audio and text Files in the Album
        UsbPlayer up7 = new UsbPlayer(USBDrive);
        ArrayList<String> Pl5 = new ArrayList<String>();
        Pl5.add("Musik 01.aac");
        Pl5.add("Musik 02.txt");
        Pl5.add("Musik 03.aac");
        up7.setPlaylist(Pl5);

        return Stream.of(
                Arguments.of("Check if the Files are .mp3 ", up1.isAllAudio(), true),
                Arguments.of("Check if the Files are .mp4 ", up2.isAllAudio(), true),
                Arguments.of("Check if the Files are .m4a ", up3.isAllAudio(), true),
                Arguments.of("Check if the Files are .wav ", up4.isAllAudio(), true),
                Arguments.of("Check if the Files are .wma ", up5.isAllAudio(), true),
                Arguments.of("Check if the Files are .aac ", up6.isAllAudio(), true),
                Arguments.of("Check case of mixed Files", up7.isAllAudio(), false)

        );
    }

    //GoToFirst()
    @ParameterizedTest
    @MethodSource("GoToFirstOptions")
    void GoToFirstTest(String testName, UsbPlayer inputUSB, String expectedResult) {
        String firstSong = inputUSB.getPlayTrack();
        assertThat(firstSong ).describedAs(testName).isEqualTo(expectedResult);
    }

    static Stream<Arguments> GoToFirstOptions() {
        USB_Stick USBDrive = new USB_Stick();
        UsbPlayer up1 = new UsbPlayer(USBDrive);
        up1.GoToFirst();

        UsbPlayer up2 = new UsbPlayer(USBDrive);
        up2.GoToFirst();
        up2.GoToFirst();

        UsbPlayer up3 = new UsbPlayer(USBDrive);
        up3.next();
        up3.GoToFirst();

        return Stream.of(
                Arguments.of("It should go to the first Song ", up1,up1.getPlaylist().get(0)),
                Arguments.of("Call the function twice and it stills go to the first Song ", up2,up2.getPlaylist().get(0)),
                Arguments.of("go to the next Song then back to first Song ", up3,up3.getPlaylist().get(0))
        );
    }

    @ParameterizedTest
    @MethodSource("GoToLastOptions")
    void GoToLastTest(String testName, UsbPlayer inputUSB, String expectedResult) {
        String firstSong = inputUSB.getPlayTrack();
        assertThat(firstSong ).describedAs(testName).isEqualTo(expectedResult);
    }

    static Stream<Arguments> GoToLastOptions() {
        USB_Stick USBDrive = new USB_Stick();
        //first case
        UsbPlayer up1 = new UsbPlayer(USBDrive);
        up1.GoToLast();

        UsbPlayer up2 = new UsbPlayer(USBDrive);
        up2.GoToLast();
        up2.GoToLast();

        UsbPlayer up3 = new UsbPlayer(USBDrive);
        up3.next();
        up3.GoToLast();


        return Stream.of(
                Arguments.of("It should go to the Last Song ", up1,up1.getPlaylist().get(up1.getPlaylist().size()-1)),
                Arguments.of("It should go to the Last Song even after calling the function twice ", up2,up2.getPlaylist().get(up2.getPlaylist().size()-1)),
                Arguments.of("It should go to the Last Song even changing the current song ", up3,up3.getPlaylist().get(up3.getPlaylist().size()-1))
        );
    }

    @ParameterizedTest
    @MethodSource("setPlayTrackOptions")
    void setPlayTrackTest(String testName, UsbPlayer inputUSB, String expectedResult) {
        String firstSong = inputUSB.getPlayTrack();
        assertThat(firstSong ).describedAs(testName).isEqualTo(expectedResult);
    }

    static Stream<Arguments> setPlayTrackOptions() {
        USB_Stick USBDrive = new USB_Stick();
        //first case
        UsbPlayer up1 = new UsbPlayer(USBDrive);
        up1.setPlayTrack("Musik 02.mp3");

        //Second Case
        UsbPlayer up2 = new UsbPlayer(USBDrive);
        up2.setPlayTrack("Musik 02.mp3");

        //Third Case
        UsbPlayer up3 = new UsbPlayer(USBDrive);
        up3.setPlayTrack("Musik 04.mp3");

        return Stream.of(
                Arguments.of("It should change the current Song ", up1,"Musik 02.mp3"),
                Arguments.of("It should change the current Song if it is in the Albume", up2,"Musik 02.mp3"),
                Arguments.of("Tried to change the Song,but the Song name does not exist in the Album(No change)", up3,"Musik 01.mp3")
        );
    }////

    @ParameterizedTest
    @MethodSource("getInfoTextOptions")
    void getInfoTextTest(String testName, UsbPlayer inputUSB, String expectedResult) {
        String infotxt = inputUSB.getInfoText();
        assertThat(infotxt ).describedAs(testName).isEqualTo(expectedResult);
    }

    static Stream<Arguments> getInfoTextOptions() {
        USB_Stick USBDrive = new USB_Stick();
        ArrayList<String> Fileslist = new ArrayList<String>();
        Fileslist.add("file 01.txt");
        Fileslist.add("file 02.txt");
        Fileslist.add("file 03.txt");
        USB_Stick USBwithTXT = new USB_Stick(Fileslist);
        //USB_Stick emptyUSB = new USB_Stick("");
        //first case
        UsbPlayer up1 = new UsbPlayer(USBDrive);

        //Second case
        UsbPlayer up2 = new UsbPlayer(USBwithTXT);

        return Stream.of(
                Arguments.of("USB Player with Albums ", up1,"USB Player is on : "+up1.getPlayTrack()),
                Arguments.of("USB Player with no Albums ", up2,"USB Player with no Albums")
        );
    }//"muted"

    @ParameterizedTest
    @MethodSource("muteOptions")
    void muteTest(String testName, UsbPlayer inputUSB, String expectedResult,String testName2,String testName3) {
        int prevSound = inputUSB.getLautstaerke();
        String isMuted = inputUSB.mute();
        assertThat(isMuted).describedAs(testName).isEqualTo(expectedResult);
        //Second case
        assertThat(inputUSB.getLautstaerke()).describedAs(testName2).isEqualTo(0);
        //third case
        assertThat(inputUSB.soundWas).describedAs(testName3).isEqualTo(prevSound);

    }

    static Stream<Arguments> muteOptions() {
        USB_Stick USBDrive = new USB_Stick();

        //first case
        UsbPlayer up1 = new UsbPlayer(USBDrive);
        up1.mute();


        return Stream.of(
                Arguments.of("The Sound is muted ", up1,"muted","Sound level is 0","previous sound level is saved ")

        );
    }

}