ocarina/tests/core/tags/track.cpp

/**
 * Copyright 2014 (c) Anna Schumaker.
 */
extern "C" {
#include <core/string.h>
}
#include <core/filter.h>
#include <core/tags/tags.h>
#include <core/tags/track.h>
#include "../test.h"

#include <set>
#include <sstream>

static void test_verify_empty(struct track *track)
{
	const struct db_ops *track_ops = test_track_ops();
	test_equal(track->tr_album,     (struct album *)NULL);
	test_equal(track->tr_artist,   (struct artist *)NULL);
	test_equal(track->tr_genre,     (struct genre *)NULL);
	test_equal(track->tr_library, (struct library *)NULL);

	test_equal(track->tr_title,   "");
	test_equal(track->tr_lower,   "");
	test_equal(track_path(track), "");
	test_str_equal(track_ops->dbe_key(track), "");
	test_equal(track_last_play(track),   "Never");

	test_equal(track->tr_track,  0);
	test_equal(track->tr_length, 0);
	test_equal(track->tr_count,  0);
}

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(track->tr_library->li_path, "tests/Music");
}

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_lower, "title theme");
	test_str_equal(track_ops->dbe_key(track),
			"0/Hyrule Symphony/01 - Title Theme.ogg");
	test_equal(track_path(track),
			"tests/Music/Hyrule Symphony/01 - Title Theme.ogg");
	test_equal(track_last_play(track), "Never");

	test_equal(track->tr_track,  1);
	test_equal(track->tr_length, 243);
	test_equal(track->tr_count,  0);
}

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(track->tr_lower, "");
	test_str_equal(track_ops->dbe_key(track),
			"0/Hyrule Symphony/00 - No Track.ogg");
	test_equal(track_path(track),
			"tests/Music/Hyrule Symphony/00 - No Track.ogg");
	test_equal(track_last_play(track), "Never");

	test_equal(track->tr_track,  0);
	test_equal(track->tr_length, 0);
	test_equal(track->tr_count,  0);
}

static void test_track()
{
	const struct db_ops *track_ops = test_track_ops();
	time_t rawtime = time(NULL);
	struct tm *now = localtime(&rawtime);
	struct track   *track = new struct track;;
	struct library *library;
	gchar *date;
	file f;

	test_verify_empty(track);
	track_ops->dbe_free(track);

	std::setlocale(LC_TIME, "C");
	filter_init();
	tags :: init();
	file_init(&f, "track_tag", 0);
	date    = string_tm2str(now);
	library = library_find("tests/Music");

	track = new struct track("0/Hyrule Symphony/01 - Title Theme.ogg");
	track_ops->dbe_setup(track);
	test_verify_track(track);
	test_equal(library->li_size, 1);

	file_open(&f, OPEN_WRITE);
	file_writef(&f, "0 0 0 0 0 0 0 0 0 0 \n");
	file_writef(&f, "Hyrule Symphony/00 - No Track.ogg\n");
	track_ops->dbe_write(&f, track);
	file_close(&f);

	track_ops->dbe_free(track);
	test_equal(library->li_size, 0);

	file_open(&f, OPEN_READ);
	track = (struct track *)track_ops->dbe_read(&f);
	track_ops->dbe_setup(track);
	test_verify_notrack(track);
	test_equal(library->li_size, 1);
	track_ops->dbe_free(track);

	track = (struct track *)track_ops->dbe_read(&f);
	track_ops->dbe_setup(track);
	test_verify_track(track);
	test_equal(library->li_size, 1);
	file_close(&f);

	track_played(track);
	test_equal(track->tr_count, 1);
	test_equal(track_last_play(track), date);

	track_ops->dbe_free(track);
	g_free(date);
}

static void test_track_filter()
{
	struct set search = SET_INIT();

	filter :: search("Title Theme", &search);
	test_equal(set_size(&search), (size_t)1);
	test_equal(set_has(&search, 0), true);

	filter :: search("Koji Kondo", &search);
	test_equal(set_size(&search), (size_t)1);
	test_equal(set_has(&search, 0), true);

	filter :: search("Hyrule Symphony", &search);
	test_equal(set_size(&search), (size_t)1);
	test_equal(set_has(&search, 0), true);

	filter :: search("No Track", &search);
	test_equal(set_size(&search), (size_t)0);
}

static void test_track_compare()
{
	const struct db_ops *track_ops = test_track_ops();
	struct track  *title = new struct track("0/Hyrule Symphony/01 - Title Theme.ogg");
	struct track *kokiri = new struct track("0/Hyrule Symphony/02 - Kokiri Forest.ogg");

	test_equal(track_compare(title, title),   0);
	test_equal(track_compare(kokiri, title), -1);
	test_equal(track_compare(title, kokiri),  1);

	track_ops->dbe_free(title);
	track_ops->dbe_free(kokiri);
}

static void test_track_db()
{
	std::string path = "tests/Music/Hyrule Symphony/01 - Title Theme.ogg";
	struct library *library = library_find("tests/Music");
	const struct db_ops *track_ops = test_track_ops();
	struct database track_db;
	struct track *track;

	track = track_add(library, path);
	test_verify_track(track);

	test_equal(track_add(library, path), NULL);
	test_equal(track_get(0), track);
	test_equal(track_get(1), NULL);
	test_equal(track_db_get()->db_size, 1);

	db_init(&track_db, "track.db", false, track_ops);
	db_load(&track_db);
	test_equal(track_db.db_size, 0);

	track_db_commit();
	db_load(&track_db);
	test_equal(track_db.db_size, 1);
	test_verify_track(TRACK(db_first(&track_db)));

	track_remove(track);
	test_equal(track_db_get()->db_size, 0);

	track = track_add(library, path);
	test_not_equal(track, NULL);

	track = track_add(library,
			  "tests/Music/Hyrule Symphony/02 - Kokiri Forest.ogg");
	test_not_equal(track, NULL);
	test_equal(track_db_get()->db_size, 2);

	track_remove_all(library);
	test_equal(track_db_get()->db_size, 0);

	db_deinit(&track_db);
	tags :: deinit();
	filter_deinit();
}

DECLARE_UNIT_TESTS(
	UNIT_TEST("Track Tag", test_track),
	UNIT_TEST("Track Filter", test_track_filter),
	UNIT_TEST("Track Comparison", test_track_compare),
	UNIT_TEST("Track Database", test_track_db),
);