internal IPromise <Nothing> ExpelPlayer(PlayerHandle player, UserRoom userRoom, TimeSpan duration)
{
lock (this.server)
{
this.expelRecordsFor(player.User.Id).Add(new ExpelRecord
{
UserId = player.User.Id,
UserRoom = userRoom,
UntilDate = DateTime.Now + duration,
});
}
lock (this.server)
{
if (player.CurrentLobby != null && player.CurrentLobby.Identifier == userRoom.Identifier)
{
var lobby = player.CurrentLobby;
player.CurrentLobby = null;
lobby.RemovePlayer(player);
return(this.lobbyService.NotifyLobbyAboutLeavingPlayer(player, lobby)
.Then((a) => player.Stream.Write(Responses.UserRoomClosed(userRoom))));
}
else
{
Log.Debug("Player {name} is not currently in the target lobby ({identifier}), only timer added", player.Digest, userRoom.Identifier);
}
}
return(Nothing.Resolved());
}
internal override IPromise <Nothing> Dispatch(PlayerHandle sender, CommandDomain domain, string tag, IEnumerable <string> arguments)
{
if (arguments.Count() != 1)
{
return(this.dispatcher.InvalidUsage(domain));
}
var name = arguments.First().Trim();
lock (this.manager)
{
var player = this.manager.World.FindPlayer(name);
if (player != null)
{
return(sender.Stream.Write(Responses.PrivateChatMessage(player, Strings.PLAYER_IS_ONLINE_YOU_CAN_MESSAGE_HIM)));
}
else
{
try
{
var character = this.characterService.Find(name);
return(sender.Stream.Write(Responses.ServerPrivateChatMessage(character.Name, character.Id, Strings.PLAYER_IS_OFFLINE_MESSAGES_WILL_BE_DELIVERED)));
}
catch (CharacterService.NotFoundException)
{
return(this.dispatcher.Error(domain, Strings.PLAYER_NOT_FOUND, name));
}
}
}
}
internal IPromise <Nothing> Join(PlayerHandle player, Lobby lobby)
{
PlayerHandle[] otherPlayers = null;
lock (this.manager)
{
otherPlayers = lobby.Players.ToArray();
if (player.CurrentLobby != null)
{
player.CurrentLobby.RemovePlayer(player);
}
lobby.AddPlayer(player);
player.CurrentLobby = lobby;
}
var notifyExistingAboutNew = otherPlayers.Select(a => a.Stream.Write(Responses.NewPlayer(player)));
var notifyNewAboutExisting = otherPlayers.Select(a => player.Stream.Write(Responses.NewPlayer(a)));
Log.Information("Player {sender} joined lobby {id}, total {total} players.", player.Digest, lobby.Identifier, otherPlayers.Count());
this.manager.DispatchEvent(new PlayerJoinedLobbyEvent {
Handle = player, Lobby = lobby
});
return(player.Stream.Write(Responses.JoinedRoom(lobby))
.Then(a => new CombinedPromise <Nothing>(notifyExistingAboutNew))
.Then(a => new CombinedPromise <Nothing>(notifyNewAboutExisting))
as IPromise <Nothing>);
}
private void CheckScore(PlayerHandle handle)
{
if (playerScores[handle] >= rules.scoreLimit)
{
//OnPlayerWin?.Invoke(handle);
//OnPlayerWin = null;
GameEndStatus endStatus = new GameEndStatus
{
playerScores = playerScores,
winnerHandle = handle
};
foreach (PlayerController player in playerControllers)
{
player.OnDie -= OnPlayerDie;
player.OnChangeHealth -= OnHealthChange;
player.OnAreaScore -= OnAreaScore;
}
callback(endStatus);
callback = null;
}
foreach (PlayerController player in playerControllers)
{
player.hud.SetScore(playerScores[player.handle]);
}
}
private bool checkIfPoseIsForbiddenInLobby(PlayerHandle sender, Command command)
{
if (sender.CurrentLobby != null && sender.CurrentLobby.IsUserRoom && !sender.CurrentLobby.UserRoom.IsSexAllowed)
{
string poseIdentifier = null;
switch (command.Name)
{
case "askForPose":
poseIdentifier = command.Arguments.ElementAtOrDefault(1);
break;
case "useSexPose":
poseIdentifier = command.Arguments.ElementAtOrDefault(command.Arguments.Length - 2);
foreach (var arg in command.Arguments.Skip(3).Take(3))
{
var components = arg.Split('=');
if (components.Count() > 1 && components.Last() != poseIdentifier)
{
return(true);
}
}
break;
}
return(!this.safePoses.Contains(poseIdentifier));
}
return(false);
}
internal IPromise <Nothing> Dispatch(PlayerHandle client, Message eventMsg)
{
ARequest request = ARequest.Parse(client, this.server, eventMsg);
if (request == null)
{
Log.Warning("Failed to parse request from {name}/{hash}/{address}: {msg_name} \"{msg_data}\"",
client.Name,
client.Stream.ConnectionHash,
client.Stream.ConnectionEndpoint,
eventMsg.name,
eventMsg.DebugDescription());
return(Nothing.Resolved());
}
if (!request.Validate(client, this.server))
{
Log.Warning("Failed to validate request from {name}/{hash}/{address}: {msg_name} \"{msg_data}\"",
client.Name,
client.Stream.ConnectionHash,
client.Stream.ConnectionEndpoint,
eventMsg.name,
eventMsg.DebugDescription());
return(Nothing.Resolved());
}
Log.Verbose("<= {player}@{lobby} {event_description}",
client.Digest,
client.CurrentLobbyIdentifier,
request.DebugDescription());
return(request.Process(client, this.server));
}
internal override IPromise <Nothing> Dispatch(PlayerHandle sender, CommandDomain domain, string tag, IEnumerable <string> arguments)
{
if (domain.IsWorld && (!this.manager.CheckWorldMessagePermission(sender) || !this.lobbyService.CheckSlowmodeTimerInWorld(sender)))
{
return(Nothing.Resolved());
}
if (domain.IsLocal && sender.CurrentLobby != null && !this.lobbyService.CheckSlowmodeTimer(sender.CurrentLobby, sender))
{
return(Nothing.Resolved());
}
var contents = tag + " " + String.Join(" ", arguments);
var messageToSend = "";
var components = contents.Split(new char[] { '\\', '/', ';' }).Select(s => s.Trim()).Where(s => s.Any());
var selfSufficient = contents.StartsWith("/me") && components.Count() == 1;
foreach (var substring in components)
{
if (substring.StartsWith("me"))
{
messageToSend += substring.Substring(2);
}
else if (substring.StartsWith("я"))
{
messageToSend += substring.Substring(1);
}
else
{
messageToSend += String.Format(" \"{0}\"", substring);
}
}
messageToSend = messageToSend.Trim();
var text = String.Format("{0}/me {1}", domain.Identifier, messageToSend);
var commands = domain.Recipients.Select(r => r.Stream.Write(Responses.Message(sender, text))).ToList();
if (!selfSufficient)
{
if (domain.IsPrivate)
{
if (domain.Recipients.Count() > 0)
{
var recipient = domain.Recipients.First();
var selfText = String.Format("{0}/me {1} {2} {3}", domain.Identifier, this.manager.Monogram, sender.Name, messageToSend);
commands.Add(sender.Stream.Write(Responses.Message(recipient, selfText)));
}
}
else
{
var selfText = String.Format("{0}/me {1} {2}", domain.Identifier, sender.Name, messageToSend);
commands.Add(sender.Stream.Write(Responses.ServerMessage(this.manager, selfText)));
}
}
return(new CombinedPromise <Nothing>(commands));
}
internal override IPromise <Nothing> Dispatch(PlayerHandle sender, CommandDomain domain, string tag, IEnumerable <string> arguments)
{
var hoursOnline = TimeSpan.FromSeconds(sender.User.TotalSecondsOnline).TotalHours;
var message = String.Format(Strings.YOU_HAVE_BEEN_ONLINE_FOR_HOURS, hoursOnline < 1 ? "< 1" : Convert.ToUInt32(hoursOnline).ToString());
return(this.dispatcher.Output(domain, message));
}
public void AmpachePlayerNextNotShufflingPlayingRollsToStartTest()
{
var model = new AmpacheModel();
var mock = new PlayerHandle(model);
mock.SetPauseState(false);
var first = new AmpacheSong();
var second = new AmpacheSong();
model.Playlist = new List<AmpacheSong>{ first, second };
model.PlayingSong = second;
model.IsPlaying = true;
model.PercentPlayed = 90;
model.PercentDownloaded = 100;
model.NextRequested = true;
System.Threading.Thread.Sleep(100);
Assert.That(model.PlayPauseRequested, Is.False);
Assert.That(model.PercentPlayed, Is.EqualTo(0));
Assert.That(model.PercentDownloaded, Is.EqualTo(0));
Assert.That(mock.PauseCalls, Is.EqualTo(0));
Assert.That(mock.UnpauseCalls, Is.EqualTo(0));
Assert.That(mock.PlaySongCalls, Is.EqualTo(1));
Assert.That(mock.StopCalls, Is.EqualTo(0));
Assert.That(mock.SeekToCalls, Is.EqualTo(0));
Assert.That(mock.GetPauseState(), Is.False);
Assert.That(model.IsPlaying, Is.True);
Assert.That(model.PlayingSong, Is.SameAs(first));
Assert.That(mock.LastStartedSong, Is.SameAs(first));
}
private void HandleKeyReturn()
{
if (_isAlertShown)
{
DllImports.HideAlert();
_isAlertShown = false;
}
else if (_isMenuShown)
{
if (_selectedTile >= _resourceLoader.TilesCount)
{
return;
}
ShowMenu(false);
HandlePlaybackStart();
}
else if (_progressBarShown && !_options.Visible)
{
switch (PlayerHandle.State)
{
case PlayerState.Playing:
PlayerHandle?.Pause();
break;
case PlayerState.Paused:
PlayerHandle?.Start();
break;
}
}
else if (_options.Visible && _options.ProperSelection())
{
_options.ControlSelect(PlayerHandle);
_options.Hide();
}
}
public void InstantiatePlayerHandler(int index, bool isLocalClient)
{
PlayerHandle playerHandle = Instantiate(prefabPlayer);
playerHandle.SetPlayerHandle(index, isLocalClient);
playersList.Add(index, playerHandle);
}
public async Task <GameList> GetGamesForPlayerAsync(
PlayerHandle player,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
return(await _provider.GetGamesForPlayerAsync(player, cancellationToken));
}
private void ClosePlayer()
{
Logger?.Info("Closing player");
PlayerHandle?.Stop();
PlayerHandle?.Dispose();
PlayerHandle = null;
}
internal override IEnumerable <PlayerHandle> Recipients(PlayerHandle sender, ChatManager server)
{
lock (server)
{
return(sender.CurrentLobby.Players.Except(new PlayerHandle[] { sender }).ToList());
}
}
internal override IPromise <Nothing> Dispatch(PlayerHandle sender, CommandDomain domain, string tag, IEnumerable <string> arguments)
{
var name = arguments.FirstOrDefault() ?? ".";
var command = "info";
if (arguments.Count() > 1)
{
command = arguments.ElementAt(1).Trim();
}
if (command.Equals("info"))
{
return(this.showInfo(sender, domain, name));
}
else if (command.Equals("setstatus"))
{
string status = null;
if (arguments.Count() > 2)
{
status = arguments.ElementAt(2).Trim();
}
return(this.status(sender, domain, name, status));
}
else
{
return(this.dispatcher.Error(domain, Strings.UNKNOWN_COMMAND, command));
}
}
internal IPromise <Nothing> QueueMessage(PlayerHandle sender, string recipientName, string messageText)
{
try
{
Log.Debug("Offline message queue: from {sender} to {recipientName}", sender.Digest, recipientName);
var recipient = this.characterService.Find(recipientName);
var dateString = DateTime.Now.ToShortDateString();
var timeString = DateTime.Now.ToShortTimeString();
var message = new OfflineMessage
{
SenderId = sender.Id,
RecepientId = recipient.Id,
Message = String.Format("{0} {1}: {2}", dateString, timeString, messageText),
};
this.db.Write((c) => c.OfflineMessageInsert(message));
return(sender.Stream.Write(Responses.ServerPrivateChatMessage(
recipient.Name,
recipient.Id,
Strings.PLAYER_IS_OFFLINE_MESSAGES_WILL_BE_DELIVERED
)));
}
catch (Database.NotFoundException)
{
Log.Warning("Failed to queue offline message from {sender} - {recipientName} not found!", sender.Digest, recipientName);
return(Nothing.Resolved());
}
}
internal bool CheckSlowmodeTimer(Lobby lobby, PlayerHandle handle)
{
var canModerate = handle.AdminOptions.HasFlag(AdminFlags.ChatManagement);
if (lobby.IsUserRoom && this.userRoomService.PlayerCanModerateRoom(handle, lobby.UserRoom))
{
canModerate = true;
}
if (canModerate)
{
return(true);
}
if (lobby.IsUserRoom && lobby.UserRoom.IsMuted)
{
this.manager.Sink(handle.Stream.Write(Responses.ServerLocalMessage(this.manager, Strings.SORRY_CHAT_IS_MUTED)));
return(false);
}
var interval = lobby.UserRoom?.SlowmodeInterval ?? this.LobbyChatIntermessageInterval;
if (this.checkSlowmodeTimer(lobby.Identifier, handle, interval))
{
return(true);
}
else
{
this.manager.Sink(handle.Stream.Write(Responses.ServerLocalMessage(this.manager, String.Format(Strings.TOO_FAST_CHAT_IS_IN_SLOWMODE, interval.TotalSeconds))));
return(false);
}
}
public async Task <IImmutableList <GameId> > GetSimulationsAsync(
PlayerHandle player,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
IEnumerable <GameId> gameIds;
using (var connection = await _connectionFactory.CreateAndOpenAsync(cancellationToken))
{
var commandText = @"
SELECT g.game_id
FROM public.simulation AS s
INNER JOIN public.game AS g
ON g.id = s.game_id
WHERE s.created_by = @player;";
var parameters = new { player };
var command = new CommandDefinition(
commandText,
parameters,
cancellationToken: cancellationToken);
gameIds = await connection.QueryAsync <GameId>(command);
}
return(gameIds.ToImmutableList());
}
internal void ResetGroup(PlayerHandle sender)
{
var group = new Group(this.NextGroupIdentifier());
group.AddPlayer(sender);
sender.CurrentGroup = group;
}
public Task <IImmutableList <GameId> > GetSimulationsAsync(
PlayerHandle player,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
return(_store.GetSimulationsAsync(player, cancellationToken));
}
internal override bool Validate(PlayerHandle sender, ChatManager server)
{
if (!base.Validate(sender, server))
{
return(false);
}
return(sender.CurrentGroup != null);
}
internal PlayerHandle ConnectPlayer(CIOSocket socket)
{
var handle = new PlayerHandle(new EventStream(socket));
Log.Information("Connecting player {hash}/{endpoint}", handle.Stream.ConnectionHash, handle.Stream.ConnectionEndpoint);
this.Sink(handle.Stream.Write(Responses.Connected()));
return(handle);
}
void Start()
{
paused = false;
playerHandle = player.GetComponent <PlayerHandle>();
playerAnim = player.GetComponent <Animator>();
arrows = GameObject.FindGameObjectsWithTag("Arrow");
//arrowMovement = arrows.GetComponent <ProjectileMovement>();
}
internal override bool Validate(PlayerHandle sender, ChatManager server)
{
if (!base.Validate(sender, server))
{
return(false);
}
return(true);
}
protected Player(IntPtr handle, Action <int, string> errorHandler)
{
// This constructor is to support TV product player.
// Be careful with 'handle'. It must be wrapped in safe handle, first.
_handle = handle != IntPtr.Zero ? new PlayerHandle(handle) :
throw new ArgumentException("Handle is invalid.", nameof(handle));
_errorHandler = errorHandler;
}
public void Assign()
{
player.assignments.Add(this);
device.SetAssignment(this);
if (PlayerHandle.onChanged != null)
{
PlayerHandle.onChanged();
}
}
public void Unassign()
{
player.assignments.Remove(this);
device.SetAssignment(null);
if (PlayerHandle.onChanged != null)
{
PlayerHandle.onChanged();
}
}
public void Start()
{
// Create a global player handle that listen to all relevant devices not already used
// by other player handles.
globalHandle = PlayerHandleManager.GetNewPlayerHandle();
globalHandle.global = true;
playerPrefab.SetPlayerHandleMaps(globalHandle);
joinAction.Bind(globalHandle);
leaveAction.Bind(globalHandle);
}
internal IPromise <Nothing> Dispatch(PlayerHandle sender, IEnumerable <PlayerHandle> recipients, ChatManager manager, string text)
{
if (recipients.Count() < 1)
{
Log.Debug("Failed to dispatch message from {sender} - no recipients", sender.Digest);
return(Nothing.Resolved());
}
return(sender.Stream.Write(Responses.CharacterAppearance(recipients.First())));
}
protected override void OnPause()
{
if (PlayerHandle == null || PlayerHandle.State != PlayerState.Playing)
{
return;
}
_appPaused = true;
PlayerHandle.Pause();
}
internal IPromise <Nothing> Dispatch(PlayerHandle sender, ChatManager manager, IEnumerable <PlayerHandle> recipients, string text)
{
var prefix = "~action2/";
var query = text.Substring(prefix.Length).Split('|');
Lobby lobby = sender.CurrentLobby;
if (lobby == null)
{
Log.Debug("Player {player} requested radio get/set command when he wasn't in the lobby!", sender.Digest);
return(Nothing.Resolved());
}
var lobbyOwnerName = lobby.IsUserRoom ? lobby.UserRoom.OwnerName : lobby.Identifier.Substring(0, lobby.Identifier.Length - "_lobby".Length + 1);
if (query.First() == "getRadioID")
{
var value = lobby.RadioURL ?? "no";
Log.Debug("Player {sender} requested radio stream of lobby {identifier}, returning {value}", sender.Digest, lobby.Identifier, value);
return(sender.Stream.Write(Responses.RunRadio(manager, lobbyOwnerName, value)));
}
else if (query.First() == "runRadio")
{
var url = query.ElementAt(1).Trim();
if (lobbyOwnerName == sender.Name || sender.AdminOptions.HasFlag(AdminFlags.RoomManagement))
{
Log.Debug("Player {sender} setting radio URL for lobby {identifier} to {url}", sender.Digest, lobby.Identifier, url);
lobby.RadioURL = url;
if (lobby.IsUserRoom)
{
lobby.UserRoom.RadioURL = url;
}
if (recipients.Count() > 0)
{
return(new CombinedPromise <Nothing>(recipients.Select(p => p.Stream.Write(Responses.RunRadio(manager, lobbyOwnerName, url)))));
}
else
{
return(Nothing.Resolved());
}
}
else
{
Log.Warning("Player {sender} attempted to run radio stream in lobby {identifier}, which is not his room!", sender.Digest, lobby.Identifier);
return(Nothing.Resolved());
}
}
else
{
Debug.Assert(false, "invalid request");
return(Nothing.Resolved());
}
}
public void AmpachePlayerPlayPauseResumesPlaybackWhenPasusedTest()
{
var model = new AmpacheModel();
var mock = new PlayerHandle(model);
mock.SetPauseState(true);
model.PlayPauseRequested = true;
System.Threading.Thread.Sleep(100);
Assert.That(model.PlayPauseRequested, Is.False);
Assert.That(mock.UnpauseCalls, Is.EqualTo(1));
Assert.That(mock.PauseCalls, Is.EqualTo(0));
Assert.That(mock.StopCalls, Is.EqualTo(0));
Assert.That(mock.SeekToCalls, Is.EqualTo(0));
Assert.That(mock.PlaySongCalls, Is.EqualTo(0));
Assert.That(mock.GetPauseState(), Is.False);
}
public void AmpachePlayerNextShufflingTest()
{
var model = new AmpacheModel();
var mock = new PlayerHandle(model);
mock.SetPauseState(false);
var first = new AmpacheSong();
var second = new AmpacheSong();
model.Playlist = new List<AmpacheSong>{ first, second };
model.PlayingSong = first;
model.IsPlaying = true;
model.Shuffling = true;
model.NextRequested = true;
System.Threading.Thread.Sleep(100);
Assert.That(model.PlayPauseRequested, Is.False);
Assert.That(mock.PauseCalls, Is.EqualTo(0));
Assert.That(mock.UnpauseCalls, Is.EqualTo(0));
Assert.That(mock.PlaySongCalls, Is.EqualTo(1));
Assert.That(mock.StopCalls, Is.EqualTo(0));
Assert.That(mock.SeekToCalls, Is.EqualTo(0));
Assert.That(mock.GetPauseState(), Is.False);
Assert.That(model.IsPlaying, Is.True);
// TODO: find a way to test randomized shuffeling
}
public void AmpachePlayerSettingPlayerPositionMilliSecondUpdatesPercentPlayedOnModelTest()
{
var model = new AmpacheModel();
var mock = new PlayerHandle(model);
var song = new AmpacheSong();
song.TrackLength = TimeSpan.FromSeconds(60);
model.PlayingSong = song;
mock.SetPlayerPositionMilliSecond(15000);
Assert.That(model.PercentPlayed, Is.EqualTo(25));
}
public void AmpachePlayerSeekingTest()
{
var model = new AmpacheModel();
var mock = new PlayerHandle(model);
mock.SetPauseState(false);
var first = new AmpacheSong();
var second = new AmpacheSong();
second.TrackLength = TimeSpan.FromMinutes(1);
model.Playlist = new List<AmpacheSong>{ first, second };
model.PlayingSong = second;
model.IsPlaying = true;
model.Configuration = new UserConfiguration();
model.Configuration.AllowSeeking = true;
model.RequestedSeekToPercentage = 50;
System.Threading.Thread.Sleep(100);
Assert.That(model.PlayPauseRequested, Is.False);
Assert.That(mock.PauseCalls, Is.EqualTo(0));
Assert.That(mock.UnpauseCalls, Is.EqualTo(0));
Assert.That(mock.PlaySongCalls, Is.EqualTo(0));
Assert.That(mock.StopCalls, Is.EqualTo(0));
Assert.That(mock.SeekToCalls, Is.EqualTo(1));
Assert.That(mock.GetPauseState(), Is.False);
Assert.That(model.IsPlaying, Is.True);
Assert.That(model.PlayingSong, Is.SameAs(second));
}
public void AmpachePlayerPreviousAfterSomePlayTest()
{
var model = new AmpacheModel();
var mock = new PlayerHandle(model);
mock.SetPauseState(false);
var first = new AmpacheSong();
var second = new AmpacheSong();
model.Playlist = new List<AmpacheSong>{ first, second };
model.PlayingSong = second;
mock.SetPlayerPositionMilliSecond(10000);
model.IsPlaying = true;
model.PreviousRequested = true;
System.Threading.Thread.Sleep(100);
Assert.That(model.PlayPauseRequested, Is.False);
Assert.That(mock.PauseCalls, Is.EqualTo(0));
Assert.That(mock.UnpauseCalls, Is.EqualTo(0));
Assert.That(mock.PlaySongCalls, Is.EqualTo(1));
Assert.That(mock.StopCalls, Is.EqualTo(0));
Assert.That(mock.SeekToCalls, Is.EqualTo(0));
Assert.That(mock.GetPauseState(), Is.False);
Assert.That(model.IsPlaying, Is.True);
Assert.That(model.PlayingSong, Is.SameAs(second));
Assert.That(mock.LastStartedSong, Is.SameAs(second));
}
public void AmpachePlayerPlayPauseStartsPlaybackAtFirstSongTest()
{
var model = new AmpacheModel();
var mock = new PlayerHandle(model);
mock.SetPauseState(false);
var first = new AmpacheSong();
var second = new AmpacheSong();
model.Playlist = new List<AmpacheSong>{ first, second };
model.PlayPauseRequested = true;
System.Threading.Thread.Sleep(100);
Assert.That(model.PlayPauseRequested, Is.False);
Assert.That(mock.PauseCalls, Is.EqualTo(0));
Assert.That(mock.UnpauseCalls, Is.EqualTo(0));
Assert.That(mock.PlaySongCalls, Is.EqualTo(1));
Assert.That(mock.StopCalls, Is.EqualTo(0));
Assert.That(mock.SeekToCalls, Is.EqualTo(0));
Assert.That(mock.GetPauseState(), Is.False);
Assert.That(model.IsPlaying, Is.True);
Assert.That(model.PlayingSong, Is.SameAs(first));
Assert.That(mock.LastStartedSong, Is.SameAs(first));
}
public void AmpachePlayerStopWhilePlayTest()
{
var model = new AmpacheModel();
var mock = new PlayerHandle(model);
mock.SetPauseState(false);
var first = new AmpacheSong();
var second = new AmpacheSong();
model.Playlist = new List<AmpacheSong>{ first, second };
model.PlayingSong = second;
model.IsPlaying = true;
model.StopRequested = true;
System.Threading.Thread.Sleep(100);
Assert.That(model.PlayPauseRequested, Is.False);
Assert.That(mock.PauseCalls, Is.EqualTo(0));
Assert.That(mock.UnpauseCalls, Is.EqualTo(0));
Assert.That(mock.PlaySongCalls, Is.EqualTo(0));
Assert.That(mock.StopCalls, Is.EqualTo(1));
Assert.That(mock.SeekToCalls, Is.EqualTo(0));
Assert.That(mock.GetPauseState(), Is.False);
Assert.That(model.IsPlaying, Is.False);
Assert.That(model.PlayingSong, Is.Null);
}
public void AmpachePlayerPlayPauseHasNoEffectWithoutPlaylistTest()
{
var model = new AmpacheModel();
var mock = new PlayerHandle(model);
model.Playlist = null;
model.PlayPauseRequested = true;
System.Threading.Thread.Sleep(100);
Assert.That(model.PlayPauseRequested, Is.False);
Assert.That(model.PlayingSong, Is.Null);
}
