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 struct artist  *artist = NULL;
static struct album   *album   = NULL;
static struct genre   *genre   = NULL;
static struct library *library = NULL;
const std::string MUSIC_DIR = "/home/Zelda/Music";


static void test_track_tag_default()
{
	struct track track;

	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,      (std::string)"");
	test_equal(track.tr_lower,      (std::string)"");
	test_equal(track.primary_key(), (std::string)"");
	test_equal(track_last_play(&track), (std::string)"Never");
	test_equal(track_path(&track),  (std::string)"");

	test_equal(track.tr_track,  (unsigned)0);
	test_equal(track.tr_length, (unsigned)0);
	test_equal(track.tr_count,  (unsigned)0);
}

static void verify_track_tag(struct track *track, unsigned int size)
{
	test_equal(track->tr_album,   album);
	test_equal(track->tr_artist,  artist);
	test_equal(track->tr_genre,   genre);
	test_equal(track->tr_library, library);

	test_equal(track->tr_title,      (std::string)"Legend of Zelda Medley");
	test_equal(track->tr_lower,      (std::string)"legend of zelda medley");
	test_equal(track_last_play(track), (std::string)"Never");
	test_equal(track_path(track),    (std::string)MUSIC_DIR + "/Hyrule Symphony/13 - Legend of Zelda Medley.mp3");
	test_equal(track->primary_key(), (std::string)"0/Hyrule Symphony/13 - Legend of Zelda Medley.mp3");

	test_equal(track->tr_track,  (unsigned)13);
	test_equal(track->tr_length, (unsigned)288);
	test_equal(track->tr_count,  (unsigned)0);
	test_equal(library->li_size, size);
}

static void test_track_tag_constructor()
{
	file f;

	filter_init();
	tags :: init();
	album   = album_find("Hyrule Symphony", 1998);
	artist  = artist_find("Koji Kondo");
	genre   = genre_find("Video Game Music");
	library = library_find(MUSIC_DIR);

	struct track a(album, artist, genre, library,
		"Hyrule Symphony/13 - Legend of Zelda Medley.mp3",
		"Legend of Zelda Medley", 288, 13);
	struct set search = SET_INIT();
	struct track b;

	verify_track_tag(&a, 1);

	file_init(&f, "track_tag", 0);
	file_open(&f, OPEN_WRITE);
	a.write(f);
	file_close(&f);

	file_open(&f, OPEN_READ);
	b.read(f);
	file_close(&f);

	verify_track_tag(&b, 2);


	filter :: search("Legend of Zelda Medley", &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);
}

static void test_track_tag_destructor()
{
	test_equal(library->li_size, (unsigned)0);
}

static void test_track_tag_load_db(unsigned int size)
{
	database<struct track> track_db;
	db_init(&track_db, "track.db", false);
	db_load(&track_db);
	test_equal(track_db.db_size, size);
	db_deinit(&track_db);
}

static void test_track_tag_lookup()
{
	unsigned int index;
	struct track *a, *b;

	a = track_add(album, artist, genre, library,
			MUSIC_DIR + "/Hyrule Symphony/13 - Legend of Zelda Medley.mp3",
			"Legend of Zelda Medley", 288, 13);
	test_not_equal(a, (struct track *)NULL);
	verify_track_tag(a, 1);

	b = track_add(album, artist, genre, library,
			MUSIC_DIR + "/Hyrule Symphony/13 - Legend of Zelda Medley.mp3",
			"Legend of Zelda Medley", 288, 13);
	test_equal(b, (struct track *)NULL);

	b = track_add(album, artist, genre, library,
			MUSIC_DIR + "/Hyrule Symphony/12 - Ocarina Medley.mp3",
			"Ocarina Medley", 232, 12);
	test_not_equal(b, a);
	test_equal(library->li_size, (unsigned)2);
	test_equal(track_db_get()->db_size, b->index() + 1);


	test_equal(track_get(a->index()), a);
	test_equal(track_get(a->index() + 1), b);
	test_equal(track_get(a->index() + 2), (struct track *)NULL);

	test_track_tag_load_db(0);
	track_db_commit();
	test_track_tag_load_db(2);


	index = a->index();
	track_remove(a);
	test_equal(track_get(index), (struct track *)NULL);
	test_track_tag_load_db(2);
	track_db_commit();
	test_track_tag_load_db(1);
	test_equal(library->li_size, (unsigned)1);
	test_equal(db_actual_size(track_db_get()), b->index() + 1);


	a = track_add(album, artist, genre, library,
			MUSIC_DIR + "/Hyrule Symphony/13 - Legend of Zelda Medley.mp3",
			"Legend of Zelda Medley", 288, 13);
	test_not_equal(a, (struct track *)NULL);
	verify_track_tag(a, 2);
	test_equal(db_actual_size(track_db_get()), a->index() + 1);

	track_remove_all(library);
	test_track_tag_load_db(0);
	test_equal(library->li_size, (unsigned)0);
}

static void test_track_tag_locale()
{
	time_t rawtime = time(NULL);
	struct tm *now = localtime(&rawtime);
	struct track *track = track_add(album, artist, genre, library,
			MUSIC_DIR + "/Hyrule Symphony/6 - Kakariko Village.mp3",
			"Kakariko Village", 186, 6);
	gchar *date;

	std::setlocale(LC_TIME, "C");
	date = string_tm2str(now);

	test_equal(track->tr_count, (unsigned)0);
	test_equal(track_last_play(track), "Never");

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

DECLARE_UNIT_TESTS(
	UNIT_TEST("Track Tag Default Constructor", test_track_tag_default),
	UNIT_TEST("Track Tag Constructor", test_track_tag_constructor),
	UNIT_TEST("Track Tag Destructor Test", test_track_tag_destructor),
	UNIT_TEST("Track Tag Lookup Test", test_track_tag_lookup),
	UNIT_TEST("Track Tag Date Test", test_track_tag_locale),
);