anna
/
ocarina
1
0
Fork 0
Code Issues 7 Pull Requests Releases Wiki Activity

tests: Build tags/track test with ctest 

Signed-off-by: Anna Schumaker <Anna@OcarinaProject.net>
This commit is contained in:
Anna Schumaker 2016-03-10 08:18:24 -05:00 committed by Anna Schumaker
parent 5e65414263
commit 8327d77ddd
4 changed files with 152 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
core/tags/track.c
View File

@ -57,7 +57,7 @@ struct db_entry *track_alloc(const gchar *key)
fullpath = library_file(library, path);
file = taglib_file_new(fullpath);
if (!file || !taglib_file_is_valid(file)) {
printf("WARNING: Could not read tags for: %s\n", fullpath);
g_printerr("WARNING: Could not read tags for: %s\n", fullpath);
goto out;
}

1
tests/core/tags/CMakeLists.txt
View File

@ -8,3 +8,4 @@ tag_unit_test(Artist)
tag_unit_test(Album)
tag_unit_test(Genre)
tag_unit_test(Library)
tag_unit_test(Track)

5
tests/core/tags/Sconscript
View File

@ -15,8 +15,7 @@ core_objs += [ env.Object("../../../core/tags/artist.c") ]
core_objs += [ env.Object("../../../core/tags/album.c") ]
core_objs += [ env.Object("../../../core/tags/genre.c") ]
core_objs += [ env.Object("../../../core/tags/library.c") ]
core_objs += [ env.Object("../../../core/tags/tags.c") ]
res += [ TagTest("track") ]
core_objs += [ env.Object("../../../core/tags/tags.c") ]
core_objs += [ env.Object("../../../core/tags/track.c") ]
Return("res")

274
tests/core/tags/track.c
View File

@ -12,18 +12,20 @@
static struct track *test_alloc(const gchar *key)
{
const struct db_ops *track_ops = test_track_ops();
return TRACK(track_ops->dbe_alloc(key));
struct db_entry *dbe = track_ops->dbe_alloc(key);
g_assert_nonnull(dbe);
return TRACK(dbe);
}
static void test_verify_tags(struct track *track)
{
test_equal(track->tr_album->al_name, "Hyrule Symphony");
test_equal(track->tr_album->al_year, 1998);
test_equal(track->tr_artist->ar_name, "Koji Kondo");
test_equal(track->tr_genre->ge_name, "Game");
test_equal((void *)track->tr_album->al_artist, (void *)track->tr_artist);
test_equal((void *)track->tr_album->al_genre, (void *)track->tr_genre);
test_equal(track->tr_library->li_path, "tests/Music");
g_assert_cmpstr(track->tr_album->al_name, ==, "Hyrule Symphony");
g_assert_cmpuint(track->tr_album->al_year, ==, 1998);
g_assert_cmpstr(track->tr_artist->ar_name, ==, "Koji Kondo");
g_assert_cmpstr(track->tr_genre->ge_name, ==, "Game");
g_assert(track->tr_album->al_artist == track->tr_artist);
g_assert(track->tr_album->al_genre == track->tr_genre);
g_assert_cmpstr(track->tr_library->li_path, ==, "tests/Music");
}
static void test_verify_track(struct track *track)
@ -31,20 +33,20 @@ static void test_verify_track(struct track *track)
const struct db_ops *track_ops = test_track_ops();
test_verify_tags(track);
test_equal(track->tr_title, "Title Theme");
test_equal(track->tr_tokens[0], "title");
test_equal(track->tr_tokens[1], "theme");
test_equal((void *)track->tr_tokens[2], NULL);
test_equal((void *)track->tr_alts[0], NULL);
test_equal(track_ops->dbe_key(&track->tr_dbe),
g_assert_cmpstr(track->tr_title, ==, "Title Theme");
g_assert_cmpstr(track->tr_tokens[0], ==, "title");
g_assert_cmpstr(track->tr_tokens[1], ==, "theme");
g_assert_null(track->tr_tokens[2]);
g_assert_null(track->tr_alts[0]);
g_assert_cmpstr(track_ops->dbe_key(&track->tr_dbe), ==,
"0/Hyrule Symphony/01 - Title Theme.ogg");
test_str_equal(track_path(track),
g_assert_cmpstr_free(track_path(track), ==,
"tests/Music/Hyrule Symphony/01 - Title Theme.ogg");
test_str_equal(track_last_play(track), "Never");
g_assert_cmpstr_free(track_last_play(track), ==, "Never");
test_equal(track->tr_track, 1);
test_equal(track->tr_length, 243);
test_equal(track->tr_count, 0);
g_assert_cmpuint(track->tr_track, ==, 1);
g_assert_cmpuint(track->tr_length, ==, 243);
g_assert_cmpuint(track->tr_count, ==, 0);
}
static void test_verify_notrack(struct track *track)
@ -52,18 +54,18 @@ static void test_verify_notrack(struct track *track)
const struct db_ops *track_ops = test_track_ops();
test_verify_tags(track);
test_equal(track->tr_title, "");
test_equal((void *)track->tr_tokens[0], NULL);
test_equal((void *)track->tr_alts[0], NULL);
test_equal(track_ops->dbe_key(&track->tr_dbe),
g_assert_cmpstr(track->tr_title, ==, "");
g_assert_null(track->tr_tokens[0]);
g_assert_null(track->tr_alts[0]);
g_assert_cmpstr(track_ops->dbe_key(&track->tr_dbe), ==,
"0/Hyrule Symphony/00 - No Track.ogg");
test_str_equal(track_path(track),
g_assert_cmpstr_free(track_path(track), ==,
"tests/Music/Hyrule Symphony/00 - No Track.ogg");
test_str_equal(track_last_play(track), "Never");
g_assert_cmpstr_free(track_last_play(track), ==, "Never");
test_equal(track->tr_track, 0);
test_equal(track->tr_length, 0);
test_equal(track->tr_count, 0);
g_assert_cmpuint(track->tr_track, ==, 0);
g_assert_cmpuint(track->tr_length, ==, 0);
g_assert_cmpuint(track->tr_count, ==, 0);
}
static void test_track()
@ -76,24 +78,20 @@ static void test_track()
struct file f;
gchar *date;
setlocale(LC_TIME, "C");
idle_init_sync();
tags_init();
file_init(&f, "track_tag", 0, 0);
while (idle_run_task()) {}
date = string_tm2str(now);
library = library_find("tests/Music");
track = test_alloc("0/Hyrule Symphony/01 - Title Theme.ogg");
g_assert_nonnull(track);
track->tr_dbe.dbe_index = 0;
track_ops->dbe_setup(&track->tr_dbe);
test_verify_track(track);
test_equal(library->li_size, 1);
g_assert_cmpuint(library->li_size, ==, 1);
test_equal(track_match_token(track, "title"), (bool)true);
test_equal(track_match_token(track, "theme"), (bool)true);
test_equal(track_match_token(track, "hyrule"), (bool)false);
g_assert_true( track_match_token(track, "title"));
g_assert_true( track_match_token(track, "theme"));
g_assert_false(track_match_token(track, "hyrule"));
file_open(&f, OPEN_WRITE);
file_writef(&f, "0 0 0 0 0 0 0 0 0 0 \n");
@ -103,14 +101,14 @@ static void test_track()
g_free(track->tr_path);
track_ops->dbe_free(&track->tr_dbe);
test_equal(library->li_size, 0);
g_assert_cmpuint(library->li_size, ==, 0);
file_open(&f, OPEN_READ);
track = TRACK(track_ops->dbe_read(&f));
track->tr_dbe.dbe_index = 0;
track_ops->dbe_setup(&track->tr_dbe);
test_verify_notrack(track);
test_equal(library->li_size, 1);
g_assert_cmpuint(library->li_size, ==, 1);
g_free(track->tr_path);
track_ops->dbe_free(&track->tr_dbe);
@ -119,12 +117,12 @@ static void test_track()
track->tr_dbe.dbe_index = 0;
track_ops->dbe_setup(&track->tr_dbe);
test_verify_track(track);
test_equal(library->li_size, 1);
g_assert_cmpuint(library->li_size, ==, 1);
file_close(&f);
track_played(track);
test_equal(track->tr_count, 1);
test_str_equal(track_last_play(track), date);
g_assert_cmpuint(track->tr_count, ==, 1);
g_assert_cmpstr_free(track_last_play(track), ==, date);
g_free(track->tr_path);
track_ops->dbe_free(&track->tr_dbe);
@ -135,73 +133,74 @@ static void test_track_compare()
{
const struct db_ops *track_ops = test_track_ops();
struct track *title = test_alloc("0/Hyrule Symphony/01 - Title Theme.ogg");
struct track *kokiri = test_alloc("0/Hyrule Symphony/02 - Kokiri Forest.ogg");
struct track *kokiri = test_alloc("0/Ocarina of Time/05 - Kokiri Forest.ogg");
/* Compare artists. */
title->tr_artist = artist_find("Hajime Wakai");
test_equal(track_compare(title, title, COMPARE_ARTIST), 0);
test_equal(track_compare(kokiri, title, COMPARE_ARTIST), 1);
test_equal(track_compare(title, kokiri, COMPARE_ARTIST), -1);
g_assert_cmpint(track_compare(title, title, COMPARE_ARTIST), ==, 0);
g_assert_cmpint(track_compare(kokiri, title, COMPARE_ARTIST), ==, 1);
g_assert_cmpint(track_compare(title, kokiri, COMPARE_ARTIST), ==, -1);
title->tr_artist = artist_find("Koji Kondo");
/* Compare albums. */
kokiri->tr_album = album_find("Ocarina of Time", 1996);
test_equal(track_compare(title, title, COMPARE_ALBUM), 0);
test_equal(track_compare(title, kokiri, COMPARE_ALBUM), -1);
test_equal(track_compare(kokiri, title, COMPARE_ALBUM), 1);
g_assert_cmpint(track_compare(title, title, COMPARE_ALBUM), ==, 0);
g_assert_cmpint(track_compare(title, kokiri, COMPARE_ALBUM), ==, -1);
g_assert_cmpint(track_compare(kokiri, title, COMPARE_ALBUM), ==, 1);
/* Compare play counts. */
title->tr_count = 42;
test_equal(track_compare(title, title, COMPARE_COUNT), 0);
test_equal(track_compare(title, kokiri, COMPARE_COUNT), 42);
test_equal(track_compare(kokiri, title, COMPARE_COUNT), -42);
g_assert_cmpint(track_compare(title, title, COMPARE_COUNT), ==, 0);
g_assert_cmpint(track_compare(title, kokiri, COMPARE_COUNT), ==, 42);
g_assert_cmpint(track_compare(kokiri, title, COMPARE_COUNT), ==, -42);
title->tr_count = 0;
/* Compare genres. */
kokiri->tr_genre = genre_find("Video Game");
test_equal(track_compare(title, title, COMPARE_GENRE), 0);
test_equal(track_compare(title, kokiri, COMPARE_GENRE), -1);
test_equal(track_compare(kokiri, title, COMPARE_GENRE), 1);
g_assert_cmpint(track_compare(title, title, COMPARE_GENRE), ==, 0);
g_assert_cmpint(track_compare(title, kokiri, COMPARE_GENRE), ==, -1);
g_assert_cmpint(track_compare(kokiri, title, COMPARE_GENRE), ==, 1);
/* Compare lenghts (title = 243, kokiri = 130). */
test_equal(track_compare(title, title, COMPARE_LENGTH), 0);
test_equal(track_compare(title, kokiri, COMPARE_LENGTH), 113);
test_equal(track_compare(kokiri, title, COMPARE_LENGTH), -113);
g_assert_cmpint(track_compare(title, title, COMPARE_LENGTH), ==, 0);
g_assert_cmpint(track_compare(title, kokiri, COMPARE_LENGTH), ==, 131);
g_assert_cmpint(track_compare(kokiri, title, COMPARE_LENGTH), ==, -131);
/* Compare last played dates. */
date_set(&kokiri->tr_date, 0, 0, 17);
test_equal(track_compare(title, title, COMPARE_PLAYED), 0);
test_equal(track_compare(title, kokiri, COMPARE_PLAYED), -17);
test_equal(track_compare(kokiri, title, COMPARE_PLAYED), 17);
g_assert_cmpint(track_compare(title, title, COMPARE_PLAYED), ==, 0);
g_assert_cmpint(track_compare(title, kokiri, COMPARE_PLAYED), ==, -17);
g_assert_cmpint(track_compare(kokiri, title, COMPARE_PLAYED), ==, 17);
date_set(&kokiri->tr_date, 0, 6, 17);
test_equal(track_compare(title, title, COMPARE_PLAYED), 0);
test_equal(track_compare(title, kokiri, COMPARE_PLAYED), -6);
test_equal(track_compare(kokiri, title, COMPARE_PLAYED), 6);
g_assert_cmpint(track_compare(title, title, COMPARE_PLAYED), ==, 0);
g_assert_cmpint(track_compare(title, kokiri, COMPARE_PLAYED), ==, -6);
g_assert_cmpint(track_compare(kokiri, title, COMPARE_PLAYED), ==, 6);
date_set(&kokiri->tr_date, 1988, 6, 17);
test_equal(track_compare(title, title, COMPARE_PLAYED), 0);
test_equal(track_compare(title, kokiri, COMPARE_PLAYED), -1988);
test_equal(track_compare(kokiri, title, COMPARE_PLAYED), 1988);
g_assert_cmpint(track_compare(title, title, COMPARE_PLAYED), ==, 0);
g_assert_cmpint(track_compare(title, kokiri, COMPARE_PLAYED), ==, -1988);
g_assert_cmpint(track_compare(kokiri, title, COMPARE_PLAYED), ==, 1988);
/* Compare titles. */
test_equal(track_compare(title, title, COMPARE_TITLE), 0);
test_equal(track_compare(title, kokiri, COMPARE_TITLE), 1);
test_equal(track_compare(kokiri, title, COMPARE_TITLE), -1);
g_assert_cmpint(track_compare(title, title, COMPARE_TITLE), ==, 0);
g_assert_cmpint(track_compare(title, kokiri, COMPARE_TITLE), ==, 1);
g_assert_cmpint(track_compare(kokiri, title, COMPARE_TITLE), ==, -1);
/* Compare track numbers. */
test_equal(track_compare(title, title, COMPARE_TRACK), 0);
test_equal(track_compare(title, kokiri, COMPARE_TRACK), -1);
test_equal(track_compare(kokiri, title, COMPARE_TRACK), 1);
g_assert_cmpint(track_compare(title, title, COMPARE_TRACK), ==, 0);
g_assert_cmpint(track_compare(title, kokiri, COMPARE_TRACK), ==, -4);
g_assert_cmpint(track_compare(kokiri, title, COMPARE_TRACK), ==, 4);
/* Compare years. */
test_equal(track_compare(title, title, COMPARE_YEAR), 0);
test_equal(track_compare(title, kokiri, COMPARE_YEAR), 2);
test_equal(track_compare(kokiri, title, COMPARE_YEAR), -2);
g_assert_cmpint(track_compare(title, title, COMPARE_YEAR), ==, 0);
g_assert_cmpint(track_compare(title, kokiri, COMPARE_YEAR), ==, -1);
g_assert_cmpint(track_compare(kokiri, title, COMPARE_YEAR), ==, 1);
kokiri->tr_album->al_year = title->tr_album->al_year;
test_equal(track_compare(title, title, COMPARE_YEAR), 0);
test_equal(track_compare(title, kokiri, COMPARE_YEAR), -1);
test_equal(track_compare(kokiri, title, COMPARE_YEAR), 1);
title->tr_album->al_year += 2;
g_assert_cmpint(track_compare(title, title, COMPARE_YEAR), ==, 0);
g_assert_cmpint(track_compare(title, kokiri, COMPARE_YEAR), ==, 2);
g_assert_cmpint(track_compare(kokiri, title, COMPARE_YEAR), ==, -2);
title->tr_album->al_year -= 2;
g_free(title->tr_path);
g_free(kokiri->tr_path);
@ -209,7 +208,7 @@ static void test_track_compare()
track_ops->dbe_free(&kokiri->tr_dbe);
}
static void test_track_db()
static void __test_track_db_subprocess()
{
const gchar *path = "tests/Music/Hyrule Symphony/01 - Title Theme.ogg";
struct library *library = library_find("tests/Music");
@ -217,84 +216,107 @@ static void test_track_db()
struct database track_db;
struct track *track;
test_equal(track_db_count_unplayed(), 0);
test_equal(track_db_count_plays(), 0);
test_equal(track_db_average_plays(), 0);
g_assert_cmpuint(track_db_count_unplayed(), ==, 0);
g_assert_cmpuint(track_db_count_plays(), ==, 0);
g_assert_cmpuint(track_db_average_plays(), ==, 0);
track = track_add(library, path);
test_verify_track(track);
test_equal(track_db_count_unplayed(), 1);
g_assert_cmpuint(track_db_count_unplayed(), ==, 1);
test_equal((void *)track_add(library, path), NULL);
test_equal((void *)track_get(0), (void *)track);
test_equal((void *)track_get(1), NULL);
test_equal(track_db_get()->db_size, 1);
test_equal(track_db_count_unplayed(), 1);
g_assert_null(track_add(library, path));
g_assert(track_get(0) == track);
g_assert_null(track_get(1));
g_assert_cmpuint(track_db_get()->db_size, ==, 1);
g_assert_cmpuint(track_db_count_unplayed(), ==, 1);
db_init(&track_db, "track.db", false, track_ops);
db_load(&track_db);
test_equal(track_db.db_size, 0);
g_assert_cmpuint(track_db.db_size, ==, 0);
track_db_commit();
db_load(&track_db);
test_equal(track_db.db_size, 1);
g_assert_cmpuint(track_db.db_size, ==, 1);
test_verify_track(TRACK(db_first(&track_db)));
/* Make sure our unplayed count isn't skewed */
db_deinit(&track_db);
track_remove(track);
test_equal(track_db_get()->db_size, 0);
test_equal(track_db_count_unplayed(), 0);
g_assert_cmpuint(track_db_get()->db_size, ==, 0);
g_assert_cmpuint(track_db_count_unplayed(), ==, 0);
track = track_add(library, path);
test_not_equal((void *)track, NULL);
g_assert_nonnull(track);
track = track_add(library,
"tests/Music/Hyrule Symphony/02 - Kokiri Forest.ogg");
test_not_equal((void *)track, NULL);
test_equal(track_db_get()->db_size, 2);
test_equal(track_db_count_unplayed(), 2);
g_assert_nonnull(track);
g_assert_cmpuint(track_db_get()->db_size, ==, 2);
g_assert_cmpuint(track_db_count_unplayed(), ==, 2);
test_equal(track_db_count_plays(), 0);
test_equal(track_db_average_plays(), 0);
g_assert_cmpuint(track_db_count_plays(), ==, 0);
g_assert_cmpuint(track_db_average_plays(), ==, 0);
track_played(track);
test_equal(track_db_count_unplayed(), 1);
test_equal(track_db_count_plays(), 1);
test_equal(track_db_average_plays(), 1);
g_assert_cmpuint(track_db_count_unplayed(), ==, 1);
g_assert_cmpuint(track_db_count_plays(), ==, 1);
g_assert_cmpuint(track_db_average_plays(), ==, 1);
track_played(track);
test_equal(track_db_count_unplayed(), 1);
test_equal(track_db_count_plays(), 2);
test_equal(track_db_average_plays(), 2);
g_assert_cmpuint(track_db_count_unplayed(), ==, 1);
g_assert_cmpuint(track_db_count_plays(), ==, 2);
g_assert_cmpuint(track_db_average_plays(), ==, 2);
track = track_add(library, "tests/Music/invalid_track");
test_equal((void *)track, NULL);
test_equal(track_db_get()->db_size, 2);
test_equal(track_db_count_unplayed(), 1);
g_assert_null(track);
g_assert_cmpuint(track_db_get()->db_size, ==, 2);
g_assert_cmpuint(track_db_count_unplayed(), ==, 1);
/* Reload the database */
track_db_deinit();
test_equal(track_db_count_unplayed(), 0);
test_equal(track_db_count_plays(), 0);
test_equal(track_db_get()->db_size, 0);
g_assert_cmpuint(track_db_count_unplayed(), ==, 0);
g_assert_cmpuint(track_db_count_plays(), ==, 0);
g_assert_cmpuint(track_db_get()->db_size, ==, 0);
track_db_init();
while (idle_run_task()) {};
test_equal(track_db_get()->db_size, 2);
test_equal(track_db_count_unplayed(), 1);
test_equal(track_db_count_plays(), 2);
test_equal(track_db_average_plays(), 2);
g_assert_cmpuint(track_db_get()->db_size, ==, 2);
g_assert_cmpuint(track_db_count_unplayed(), ==, 1);
g_assert_cmpuint(track_db_count_plays(), ==, 2);
g_assert_cmpuint(track_db_average_plays(), ==, 2);
track_remove(track_get(2));
test_equal(track_db_count_plays(), 0);
test_equal(track_db_average_plays(), 0);
g_assert_cmpuint(track_db_count_plays(), ==, 0);
g_assert_cmpuint(track_db_average_plays(), ==, 0);
track_remove_all(library);
test_equal(track_db_get()->db_size, 0);
g_assert_cmpuint(track_db_get()->db_size, ==, 0);
}
static void test_track_db()
{
if (g_test_subprocess()) {
__test_track_db_subprocess();
return;
}
g_test_trap_subprocess(NULL, 0, 0);
g_test_trap_assert_passed();
g_test_trap_assert_stderr("*WARNING: Could not read tags for:*");
}
int main(int argc, char **argv)
{
int ret;
setlocale(LC_TIME, "C");
idle_init_sync();
tags_init();
while (idle_run_task()) {}
g_test_init(&argc, &argv, NULL);
g_test_add_func("/Core/Tags/Track", test_track);
g_test_add_func("/Core/Tags/Track/Comparison", test_track_compare);
g_test_add_func("/Core/Tags/Track/Database", test_track_db);
ret = g_test_run();
tags_deinit();
idle_deinit();
return ret;
}
DECLARE_UNIT_TESTS(
UNIT_TEST("Track Tag", test_track),
UNIT_TEST("Track Comparison", test_track_compare),
UNIT_TEST("Track Database", test_track_db),
);