252 lines
7.1 KiB
C
252 lines
7.1 KiB
C
/*
|
|
* Copyright 2013 (c) Anna Schumaker.
|
|
*/
|
|
#include <core/audio.h>
|
|
#include <core/collection.h>
|
|
#include <core/idle.h>
|
|
#include <core/playlist.h>
|
|
#include <core/tempq.h>
|
|
#include <core/core.h>
|
|
#include <tests/test.h>
|
|
|
|
static unsigned int load_count = 0;
|
|
static unsigned int state_count = 0;
|
|
static int pause_count = 0;
|
|
|
|
|
|
static bool test_audio_seek(gint64 pos)
|
|
{
|
|
bool ret = audio_seek(pos);
|
|
GstState state = audio_cur_state();
|
|
|
|
while (state != GST_STATE_PAUSED && state != GST_STATE_PLAYING)
|
|
state = audio_cur_state();
|
|
return ret;
|
|
}
|
|
|
|
static void test_send_error()
|
|
{
|
|
GstMessage *message;
|
|
GError *error;
|
|
|
|
error = g_error_new(1, G_FILE_ERROR_BADF, "Simulated Error");
|
|
message = gst_message_new_error(GST_OBJECT(test_audio_player()),
|
|
error, "Fake error for testing");
|
|
audio_error(message);
|
|
|
|
gst_message_unref(message);
|
|
g_error_free(error);
|
|
|
|
}
|
|
|
|
static void test_audio_load(struct track *track) { load_count++; }
|
|
static void test_change_state(GstState state) { state_count++; }
|
|
static void test_config_pause(int n) { pause_count = n; }
|
|
|
|
static struct audio_ops test_audio_ops = {
|
|
test_audio_load,
|
|
test_change_state,
|
|
test_config_pause,
|
|
};
|
|
|
|
static struct core_init_data test_init_data = {
|
|
.audio_ops = &test_audio_ops,
|
|
};
|
|
|
|
|
|
static void test_init()
|
|
{
|
|
test_equal((void *)test_audio_player(), NULL);
|
|
test_equal((void *)audio_cur_track(), NULL);
|
|
test_equal(audio_cur_state(), GST_STATE_NULL);
|
|
test_equal((void *)audio_next(), NULL);
|
|
|
|
core_init(NULL, NULL, &test_init_data);
|
|
|
|
test_equal(audio_load(NULL), (bool)false);
|
|
test_equal((void *)audio_next(), NULL);
|
|
test_equal((void *)audio_prev(), NULL);
|
|
test_send_error();
|
|
test_equal(audio_play(), (bool)false);
|
|
test_equal(audio_pause(), (bool)false);
|
|
test_equal(audio_seek(7), (bool)false);
|
|
test_equal(audio_position(), 0);
|
|
test_equal(audio_duration(), 0);
|
|
test_equal((void *)audio_cur_track(), NULL);
|
|
test_equal(audio_cur_state(), GST_STATE_NULL);
|
|
test_equal(load_count, 0);
|
|
test_equal(state_count, 0);
|
|
|
|
collection_add("tests/Music/Hyrule Symphony");
|
|
while (idle_run_task()) {};
|
|
|
|
test_equal((void *)audio_cur_track(), NULL);
|
|
test_not_equal((void *)test_audio_player(), NULL);
|
|
}
|
|
|
|
static void test_playback()
|
|
{
|
|
struct track *tracks[3] = { track_get(0), NULL, track_get(0) };
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
test_loop_equal(audio_load(tracks[i]), (bool)(i == 0), i);
|
|
test_loop_equal(playlist_size("History"), 1, i);
|
|
test_loop_equal(load_count, 1, i);
|
|
test_loop_equal(state_count, 1, i);
|
|
test_loop_equal(audio_cur_state(), GST_STATE_PLAYING, i);
|
|
test_loop_equal((void *)audio_cur_track(), (void *)tracks[0], i);
|
|
test_loop_equal(audio_duration(),
|
|
tracks[0]->tr_length * GST_SECOND, i);
|
|
} test_loop_passed();
|
|
|
|
test_equal(audio_pause(), (bool)true);
|
|
test_equal(audio_pause(), (bool)false);
|
|
test_equal(state_count, 2);
|
|
test_equal(audio_cur_state(), GST_STATE_PAUSED);
|
|
|
|
test_equal(test_audio_seek(5 * GST_SECOND), (bool)true);
|
|
test_equal(audio_position(), 5 * GST_SECOND);
|
|
test_equal(test_audio_seek(42 * GST_SECOND), (bool)true);
|
|
test_equal(audio_position(), 42 * GST_SECOND);
|
|
|
|
test_equal(audio_play(), (bool)true);
|
|
test_equal(audio_play(), (bool)false);
|
|
test_equal(state_count, 3);
|
|
test_equal(audio_pause(), (bool)true);
|
|
test_equal(state_count, 4);
|
|
test_equal(audio_cur_state(), GST_STATE_PAUSED);
|
|
|
|
/* Check duration again now that track is fully loaded. */
|
|
test_equal(audio_duration(), track_get(0)->tr_length * GST_SECOND);
|
|
}
|
|
|
|
static void test_next()
|
|
{
|
|
struct queue *history_q = playlist_get_queue("History");
|
|
struct queue *temp_q = tempq_alloc(0);
|
|
int i;
|
|
|
|
state_count = 0;
|
|
/* First, let's test getting tracks from a temporary queue. */
|
|
queue_add(temp_q, track_get(2));
|
|
queue_add(temp_q, track_get(1));
|
|
queue_add(temp_q, track_get(0));
|
|
|
|
for (i = 2; i >= 0; i--) {
|
|
test_loop_equal(queue_size(temp_q), i + 1, i);
|
|
if (i > 0) {
|
|
test_loop_equal(audio_next()->tr_dbe.dbe_index, i, i);
|
|
} else /* Simulate an error. */
|
|
test_send_error();
|
|
test_loop_equal((void *)queue_at(history_q, 0),
|
|
(void *)track_get(i), i);
|
|
test_loop_equal(audio_cur_state(), GST_STATE_PLAYING, i);
|
|
test_loop_equal((void *)audio_cur_track(),
|
|
(void *)track_get(i), i);
|
|
} test_loop_passed();
|
|
test_equal(state_count, 3);
|
|
test_equal((void *)tempq_get(0), NULL);
|
|
|
|
/* Tracks should now be picked from the collection. */
|
|
for (i = 1; i <= 3; i++) {
|
|
if (i < 3) {
|
|
test_loop_equal(audio_next()->tr_track, i, i);
|
|
} else /* Simulate an error. */
|
|
test_send_error();
|
|
test_loop_equal(queue_at(history_q, 0)->tr_track, i, i);
|
|
test_loop_equal(audio_cur_state(), GST_STATE_PLAYING, i);
|
|
test_loop_equal(audio_cur_track()->tr_track, i, i);
|
|
} test_loop_passed();
|
|
test_equal(state_count, 6);
|
|
}
|
|
|
|
static void test_prev()
|
|
{
|
|
struct queue *history_q = playlist_get_queue("History");
|
|
struct track *track = queue_at(history_q, 0);
|
|
|
|
state_count = 0;
|
|
test_equal(audio_prev()->tr_track, 2);
|
|
test_equal((void *)queue_at(history_q, 0), (void *)track);
|
|
test_equal(audio_cur_state(), GST_STATE_PLAYING);
|
|
test_equal(audio_cur_track()->tr_track, 2);
|
|
test_equal(state_count, 1);
|
|
|
|
test_equal(audio_prev()->tr_track, 1);
|
|
test_equal((void *)queue_at(history_q, 0), (void *)track);
|
|
test_equal(audio_cur_state(), GST_STATE_PLAYING);
|
|
test_equal(audio_cur_track()->tr_track, 1);
|
|
test_equal(state_count, 2);
|
|
|
|
test_equal(audio_pause(), (bool)true);
|
|
test_equal(audio_prev()->tr_dbe.dbe_index, 0);
|
|
test_equal((void *)queue_at(history_q, 0), (void *)track);
|
|
test_equal(audio_cur_state(), GST_STATE_PLAYING);
|
|
test_equal(audio_cur_track()->tr_dbe.dbe_index, 0);
|
|
test_equal(state_count, 4);
|
|
|
|
test_equal(audio_prev()->tr_dbe.dbe_index, 1);
|
|
test_equal((void *)queue_at(history_q, 0), (void *)track);
|
|
test_equal(audio_cur_state(), GST_STATE_PLAYING);
|
|
test_equal(audio_cur_track()->tr_dbe.dbe_index, 1);
|
|
test_equal(state_count, 5);
|
|
|
|
test_equal(audio_prev()->tr_dbe.dbe_index, 2);
|
|
test_equal((void *)queue_at(history_q, 0), (void *)track);
|
|
test_equal(audio_cur_state(), GST_STATE_PLAYING);
|
|
test_equal(audio_cur_track()->tr_dbe.dbe_index, 2);
|
|
test_equal(state_count, 6);
|
|
}
|
|
|
|
void test_autopause()
|
|
{
|
|
struct queue *history_q = playlist_get_queue("History");
|
|
int i;
|
|
|
|
audio_pause_after(3);
|
|
test_equal(pause_count, 3);
|
|
|
|
pause_count = 0;
|
|
audio_pause_after(3);
|
|
test_equal(pause_count, 0);
|
|
|
|
audio_pause_after(5);
|
|
test_equal(pause_count, 5);
|
|
|
|
state_count = 0;
|
|
for (i = 4; i > -1; i--) {
|
|
audio_eos();
|
|
test_loop_equal(pause_count, i, i);
|
|
test_loop_equal(audio_cur_state(), GST_STATE_PLAYING, i);
|
|
test_loop_equal((void *)queue_at(history_q, 0),
|
|
(void *)audio_cur_track(), i);
|
|
} test_loop_passed();
|
|
test_equal(state_count, 5);
|
|
|
|
audio_eos();
|
|
test_equal(pause_count, -1);
|
|
test_equal(audio_cur_state(), GST_STATE_PAUSED);
|
|
test_equal(state_count, 6);
|
|
|
|
test_send_error();
|
|
test_equal(audio_cur_state(), GST_STATE_PAUSED);
|
|
}
|
|
|
|
static void test_deinit()
|
|
{
|
|
core_deinit();
|
|
test_equal((void *)audio_cur_track(), NULL);
|
|
test_equal((void *)test_audio_player(), NULL);
|
|
}
|
|
|
|
|
|
DECLARE_UNIT_TESTS(
|
|
UNIT_TEST("Audio Initialization", test_init),
|
|
UNIT_TEST("Audio Playback", test_playback),
|
|
UNIT_TEST("Audio Next", test_next),
|
|
UNIT_TEST("Audio Previous", test_prev),
|
|
UNIT_TEST("Audio Automatic Pausing", test_autopause),
|
|
UNIT_TEST("Audio Deinitialization", test_deinit),
|
|
);
|