ocarina/tests/core/tags/album.c

/*
 * Copyright 2014 (c) Anna Schumaker.
 */
#include <core/idle.h>
#include <core/tags/album.h>
#include <tests/test.h>

static void test_verify_empty(struct album *album)
{
	const struct db_ops *album_ops = test_album_ops();
	test_equal(album->al_name,  "");
	test_equal((void *)album->al_tokens[0], NULL);
	test_equal((void *)album->al_alts[0], NULL);
	test_equal(album->al_year,  0);
	test_str_equal(album_ops->dbe_key(&album->al_dbe), "0/");
}

static void test_verify_hyrule(struct album *album)
{
	const struct db_ops *album_ops = test_album_ops();
	test_equal(album->al_name,  "Hyrule Symphony");
	test_equal(album->al_tokens[0], "hyrule");
	test_equal(album->al_tokens[1], "symphony");
	test_equal((void *)album->al_tokens[2], NULL);
	test_equal((void *)album->al_alts[0], NULL);
	test_equal(album->al_year,  1998);
	test_str_equal(album_ops->dbe_key(&album->al_dbe), "1998/Hyrule Symphony");
}

static void test_album()
{
	const struct db_ops *album_ops = test_album_ops();
	struct album *album;
	struct file f;

	idle_init();

	album = ALBUM(album_ops->dbe_alloc("1998/Hyrule Symphony"));
	test_verify_hyrule(album);
	test_equal(album_match_token(album, "hyrule"),   (bool)true);
	test_equal(album_match_token(album, "symphony"), (bool)true);
	test_equal(album_match_token(album, "skyward"),  (bool)false);

	file_init(&f, "album_tag", 0, 0);
	file_open(&f, OPEN_WRITE);
	file_writef(&f, "0 \n");
	album_ops->dbe_write(&f, &album->al_dbe);
	file_close(&f);
	album_ops->dbe_free(&album->al_dbe);

	file_open(&f, OPEN_READ);
	album = ALBUM(album_ops->dbe_read(&f));
	test_verify_empty(album);
	album_ops->dbe_free(&album->al_dbe);

	album = ALBUM(album_ops->dbe_read(&f));
	file_close(&f);
	test_verify_hyrule(album);
	album_ops->dbe_free(&album->al_dbe);
}

static void test_album_compare()
{
	const struct db_ops *album_ops = test_album_ops();
	struct album *twilight, *skyward;

	twilight = ALBUM(album_ops->dbe_alloc("2006/Twilight Princess"));
	skyward  = ALBUM(album_ops->dbe_alloc("2011/skyward sword"));

	test_equal(album_compare(twilight, twilight), 0);
	test_equal(album_compare(twilight, skyward),  1);
	test_equal(album_compare(skyward, twilight), -1);

	test_equal(album_compare_year(twilight, twilight), 0);
	test_equal(album_compare_year(twilight, skyward), -5);
	test_equal(album_compare_year(skyward,  twilight), 5);

	skyward->al_year = 2006;
	test_equal(album_compare_year(twilight, twilight),  0);
	test_equal(album_compare_year(twilight, skyward),   1);
	test_equal(album_compare_year(skyward,  twilight), -1);

	album_ops->dbe_free(&twilight->al_dbe);
	album_ops->dbe_free(&skyward->al_dbe);
}

static void test_album_db()
{
	const struct db_ops *album_ops = test_album_ops();
	struct database album_db;
	struct album *album;

	album_db_init();
	album = album_find("Hyrule Symphony", 1998);

	test_verify_hyrule(album);

	test_equal((void *)album_find("Hyrule Symphony", 1998), (void *)album);
	test_equal((void *)album_get(0), (void *)album);
	test_equal((void *)album_get(1), (void *)NULL);

	db_init(&album_db, "album.db", false, album_ops);
	db_load(&album_db);
	test_equal(album_db.db_size, 1);

	db_deinit(&album_db);
}

static void test_album_artwork()
{
	struct album *ocarina, *majora, *wind, *ocarina_3d;
	gchar *o_path, *m_path, *w_path;
	struct artist *koji;
	const gchar *cache;

	artist_db_init();
	idle_deinit();
	idle_init();

	cache   = g_get_user_cache_dir();
	o_path  = g_build_filename(cache, "ocarina-test", "1998", "Ocarina of Time.jpg", NULL);
	m_path  = g_build_filename(cache, "ocarina-test", "2000", "Majora%27s Mask.jpg", NULL);
	w_path  = g_build_filename(cache, "ocarina-test", "0",    "Wind Waker.jpg", NULL);

	ocarina = album_find("Ocarina of Time", 1998);
	majora  = album_find("Majora's Mask",   2000);
	wind    = album_find("Wind Waker",         0);
	koji    = artist_find("Koji Kondo");
	ocarina->al_artist = koji;

	test_equal(album_artwork_exists(ocarina), (bool)false);
	test_equal(album_artwork_exists(majora),  (bool)false);
	test_equal(album_artwork_exists(wind),    (bool)false);
	test_equal((void *)album_artwork_path(ocarina), NULL);
	test_equal((void *)album_artwork_path(majora),  NULL);
	test_equal((void *)album_artwork_path(wind),    NULL);

	while (idle_run_task()) {}

	test_equal(album_artwork_exists(ocarina), (bool)true);
	test_equal(album_artwork_exists(majora),  (bool)true);
	test_equal(album_artwork_exists(wind),    (bool)true);
	test_str_equal(album_artwork_path(ocarina), o_path);
	test_str_equal(album_artwork_path(majora),  m_path);
	test_str_equal(album_artwork_path(wind),    w_path);

	/* Import the original Ocarina of Time album art. */
	ocarina_3d = album_find("Ocarina of Time 3D", 2011);
	test_equal(album_artwork_exists(ocarina_3d), (bool)false);
	album_artwork_import(ocarina_3d, NULL);
	test_equal(album_artwork_exists(ocarina_3d), (bool)false);
	album_artwork_import(ocarina_3d, o_path);
	test_equal(album_artwork_exists(ocarina_3d), (bool)true);

	g_free(o_path);
	g_free(m_path);
	g_free(w_path);
	album_db_deinit();
	artist_db_deinit();
	idle_deinit();
}

DECLARE_UNIT_TESTS(
	UNIT_TEST("Album Tag", test_album),
	UNIT_TEST("Album Comparison", test_album_compare),
	UNIT_TEST("Album Database", test_album_db),
	UNIT_TEST("Album Artwork", test_album_artwork),
);