ClientSuite.cpp

Go to the documentation of this file.

#include <string.h>
#include "WinampClientBase.h"
#include "ClientBinder.h"
#include "ContextInfo.h"
#include "RPCException.h"
#include "StringVectorPrinter.h"
#include "catch.hpp"

namespace WinampRemote
{
namespace UnitTest
{

struct TestContext
{
        WinampRemote::Context::ContextInfo ci;
        WinampRemote::Client::ClientBinder binder;
    // NOTA BENE: declaration order guarantees the correct initialisation order
        TestContext() : ci(), binder(ci.computername().c_str(), "\\pipe\\winampremote")
        {
        }

};

} // end namespace UnitTest
} // end namespace WinampRemote


TEST_CASE("Client/Version", "test server version")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;
        CHECK(client.winampVersion() >= 0);

}

TEST_CASE("Client/Status", "test server status")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;
        WAPlaybackStatus status = client.getPlaybackStatus();
        CHECK( ((status == WA_NOT_PLAYING) || (status == WA_PLAYING) || (status == WA_PAUSED)) );

}

TEST_CASE("Client/Play", "test play")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;
        INFO("initiate play request");
        client.playSong();
        INFO("the process is not synchronous and takes a while");
        Sleep(500);
        INFO("test playback state");
        CHECK( client.getPlaybackStatus() == WA_PLAYING );

}

TEST_CASE("Client/Pause", "test pause")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;
        INFO("initiate play request");
        client.playSong();
        INFO("the process is not synchronous and takes a while");
        Sleep(500);
        CHECK( client.getPlaybackStatus() == WA_PLAYING );
        INFO("state is playing - initiate pause request");
        client.pause();
        INFO("the process is not synchronous and takes a while");
        Sleep(500);
        INFO("test playback state");
        CHECK( client.getPlaybackStatus() == WA_PAUSED );

}

TEST_CASE("Client/Stop", "test stop")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;
        INFO("initiate play request");
        client.playSong();
        INFO("the process is not synchronous and takes a while");
        Sleep(500);
        CHECK( client.getPlaybackStatus() == WA_PLAYING );
        INFO("state is playing - initiate stop request");
        client.stopSong();
        INFO("the process is not synchronous and takes a while");
        Sleep(500);
        CHECK( client.getPlaybackStatus() == WA_NOT_PLAYING );

}

TEST_CASE("Client/PlaylistItem", "test playlist item")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        string playlistItem = client.getPlayListItem(0);
        CHECK(playlistItem == client.getPlayListItem(0));

}

TEST_CASE("Client/PlaylistCurrentItem", "test playlist current item")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        string current = client.getPlayListItem(1);
        client.setPlaylistIndex(1);
        Sleep(1000);
        int index = client.getCurrentPlayPosition();
        CHECK(index == 1);
        string playlistItem = client.getCurrentPlayListItem(index);
        CHECK(current == playlistItem);

}

TEST_CASE("Client/PlaylistSize", "test getPlaylistLength")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        vector<string>  playList ( client.getPlayList() );
        CHECK( playList.size() ==  (unsigned int) client.getPlaylistLength() );

}

TEST_CASE("Client/SendString", "test sendString")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        client.sendString();
        // this returns void: what is a valid test?
        CHECK(true);
}

TEST_CASE("Client/SongNext", "test nextSong")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        client.setShuffle(false);
        client.setPlaylistIndex(1);
        Sleep(1000);
        CHECK(client.getCurrentPlayPosition() == 1);
        client.nextSong();
        Sleep(1000);
        CHECK(client.getCurrentPlayPosition() == 2);
}

TEST_CASE("Client/SongPrevious", "test previousSong")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        client.setShuffle(false);
        client.setPlaylistIndex(2);
        Sleep(1000);
        CHECK(client.getCurrentPlayPosition() == 2);
        client.previousSong();
        Sleep(1000);
        CHECK(client.getCurrentPlayPosition() == 1);

}

TEST_CASE("Client/PlaylistStart", "test playlistStart position")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        client.setPlaylistIndex(2);
        Sleep(1000);
        CHECK(client.getCurrentPlayPosition() == 2);
        client.playlistStart();
        Sleep(1000);
        CHECK(client.getCurrentPlayPosition() == 0);
}

TEST_CASE("Client/PlaylistEnd", "test playlistEnd")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        client.playlistEnd();
        Sleep(1000);
        CHECK( client.getCurrentPlayPosition() ==  client.getPlaylistLength() - 1);
}

TEST_CASE("Client/PlaylistIndexSet", "test setPlaylistIndex")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        client.setPlaylistIndex(0);
        CHECK(client.getCurrentPlayPosition() == 0);
}

TEST_CASE("Client/PlaylistStartBegins", "test startPlaylist begins play")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        client.stopSong();
        client.startPlaylist();
        CHECK(client.getPlaybackStatus() == WA_PLAYING);
}

TEST_CASE("Client/SetPlaylist", "test setPlaylist")
{

        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        vector<string> originalPlayList (client.getPlayList(false) );

        WinampRemote::Utils::StringVectorPrinter original(originalPlayList);
        CAPTURE(original);

        client.setPlayList(originalPlayList);

        WinampRemote::Utils::StringVectorPrinter current(originalPlayList);
        CAPTURE(current);

        CHECK(original.sstr.str() == current.sstr.str());

}
TEST_CASE("Client/DeletePlaylist", "test deletePlaylist")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        vector<string> originalPlayList ( client.getPlayList() );


        CAPTURE(WinampRemote::Utils::StringVectorPrinter(originalPlayList));

        CHECK( originalPlayList.size() ==  (unsigned int) client.getPlaylistLength() );
        client.deletePlaylist();

        CHECK( 0 == client.getPlaylistLength() );

        client.setPlayList(originalPlayList);

        vector<string> playList ( client.getPlayList() );

//      CAPTURE(WinampRemote::Utils::StringVectorPrinter((playList));

        CHECK( originalPlayList.size() ==  playList.size() );
}

TEST_CASE("Client/InsertPlaylist", "test insertPlaylist")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        vector<string> originalPlayList ( client.getPlayList(false) );

        WinampRemote::Utils::StringVectorPrinter original (originalPlayList);
        CAPTURE(original);

        client.insertPlayList(originalPlayList, 10);

        vector<string> newPlayList (client.getPlayList(false) );

        WinampRemote::Utils::StringVectorPrinter current (newPlayList);
        CAPTURE(current);

        unsigned int newListLength = client.getPlaylistLength();
        client.setPlayList(originalPlayList);

        CHECK( (newPlayList.size()) == newListLength );

        CHECK( (2 * originalPlayList.size()) == newListLength );


}


TEST_CASE("Client/StopWithFade", "test stopWithFade")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        client.startPlaylist();
        client.stopWithFade();
        CHECK(client.getPlaybackStatus() == WA_PLAYING);

        int songLength = 0, songPos = 0;
        client.getTimes(songLength, songPos);
        CAPTURE(songLength);
        CAPTURE(songPos);
        client.setTime((songLength * 1000) - 500);
        CAPTURE(client.getTime());
        Sleep(1000);
        CAPTURE(client.getTime());
}

TEST_CASE("Client/StopAfterCurrent", "test stopAfterCurrent")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        client.startPlaylist();
        client.stopAfterCurrent();
        CHECK(client.getPlaybackStatus() == WA_PLAYING);

        int songLength = 0, songPos = 0;
        client.getTimes(songLength, songPos);
        CAPTURE(songLength);
        CAPTURE(songPos);
        client.setTime((songLength * 1000) - 500);
        CAPTURE(client.getTime());
        Sleep(1000);
        CAPTURE(client.getTime());

        CHECK(client.getPlaybackStatus() == WA_NOT_PLAYING);

}

TEST_CASE("Client/TimeSet", "test setTime")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        client.startPlaylist();
        client.pause();
        client.setTime(3000);
        CHECK( abs (client.getTime() - 3000 ) < 1000 );
}

TEST_CASE("Client/Forward5", "test forward5")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        client.playSong();
        client.setTime(7000);
        Sleep(50);
        client.forward5();
        Sleep(50);
        CHECK( abs ( client.getTime() - 12000) < 1000 );
}

TEST_CASE("Client/Back5", "test back5")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        client.playSong();
        Sleep(100);
        client.setTime(13000);
        Sleep(100);
        client.back5();
        Sleep(100);
        CAPTURE(client.getPlaybackStatus());
        CAPTURE(client.getTime());
        CHECK( abs ( client.getTime() - 8000) < 1000 );
}

TEST_CASE("Client/VolumeUp", "test volumeUp")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        int volume = client.getVolume();
        if (volume == 255)
        {
                client.setVolume(254);
                volume = client.getVolume();
        }
        client.volumeUp();
        CHECK(client.getVolume() == volume + 1);
}

TEST_CASE("Client/VolumeDown", "test volumeDown")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        int volume = client.getVolume();
        if (volume == 0)
        {
                client.setVolume(1);
                volume = client.getVolume();
        }
        client.volumeDown();
        CHECK(client.getVolume() == volume - 1);
}

TEST_CASE("Client/VolumeSet", "test setVolume")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        client.setVolume(50);
        CHECK(client.getVolume() == 50);
}

TEST_CASE("Client/PanningSet", "test setPanning")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        client.setPanning(0);
        CHECK(client.getPanning() == 0);
}


TEST_CASE("Client/PanningGet", "test getPanning")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        int panning = client.getPanning();
        CHECK(client.getPanning() == panning);
}

TEST_CASE("Client/ShuffleToggle", "test toggleShuffle")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        int shuffle = client.getShuffle();
        client.toggleShuffle();
        CHECK(client.getShuffle() != shuffle);
}

TEST_CASE("Client/ShuffleSet", "test setShuffle")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        client.setShuffle(0);
        CHECK(0 == client.getShuffle());
        client.setShuffle(1);
        CHECK(1 == client.getShuffle());

}

TEST_CASE("Client/ShuffleGet", "test getShuffle")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        int shuffle = client.getShuffle();
        CHECK(shuffle == client.getShuffle());
}

TEST_CASE("Client/RepeatToggle", "test toggleRepeat")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        int repeat = client.getRepeat();
        client.toggleRepeat();
        CHECK(client.getRepeat() != repeat);
}

TEST_CASE("Client/RepeatSet", "test setRepeat")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        client.setRepeat(1);
        CHECK(client.getRepeat() == 1);
        client.setRepeat(0);
        CHECK(client.getRepeat() == 0);



}

TEST_CASE("Client/RepeatGet", "test getRepeat")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        int repeat = client.getRepeat();
        CHECK(repeat == client.getRepeat());

}

TEST_CASE("Client/AutoloadToggle", "test toggleAutoload")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        int autoload = client.getAutoload();
        client.toggleAutoload();
        CHECK(client.getAutoload() != autoload);
}

TEST_CASE("Client/AutoloadSet", "test setAutoload")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        client.setAutoload(0);
        CHECK(client.getAutoload() == 0);
        client.setAutoload(1);
        CHECK(client.getAutoload() == 1);
}

TEST_CASE("Client/AutoloadGet", "test getAutoload")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        int current = client.getAutoload();
        CHECK(current == client.getAutoload());
}

TEST_CASE("Client/EQOnToggle", "test toggleEQ")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        int previous = client.getEQOn();
        client.toggleEQOn();
        CHECK(client.getEQOn() != previous);
}

TEST_CASE("Client/EQOnSet", "test setEQOn")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        client.setEQOn(0);
        CHECK(client.getEQOn() == 0);
        client.setEQOn(1);
        CHECK(client.getEQOn() == 1);
}

TEST_CASE("Client/EQOnGet", "test getAutoload")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        int current = client.getEQOn();
        CHECK(current == client.getEQOn());
}

TEST_CASE("Client/TimesGet", "test getTimes")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;

        int songLength, songPos;
        client.startPlaylist();
        client.getTimes(songLength, songPos);
        CHECK(songPos > 0);
        CHECK(songLength > 0);
}

TEST_CASE("Client/EQGet", "test getEQ")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;
        for (int eqindex = 0 ; eqindex < 11 ; eqindex++)
        {
                byte eqvalue = client.getEQData(eqindex);
                CHECK(eqvalue == (byte) client.getEQData(eqindex));
        }
}

TEST_CASE("Client/EQSet", "test setEQ")
{
        WinampRemote::UnitTest::TestContext tc;
        WinampRemote::Client::WinampClientBase client;
        int eqvalues[11] = {0};
        for (int eqindex = 0 ; eqindex < 11 ; eqindex++)
        {
                eqvalues[eqindex] = client.getEQData(eqindex);
                client.setEQData(eqindex, eqvalues[eqindex] + 1);
        }

        for (int eqindex = 0 ; eqindex < 11 ; eqindex++)
        {
                CHECK(client.getEQData(eqindex) == eqvalues[eqindex] + 1);
        }

}

TEST_CASE_NORETURN( "Exception/ERPCException", "ERPCException can be handled" )
{
        REQUIRE_THROWS_AS(throw ERPCException(RPC_S_UNKNOWN_PRINCIPAL), ERPCException);
}