1 #include <cutter.h>
2
3 #include "libmp3splt/mp3splt.h"
4 #include "options.h"
5 #include "filename_regex.h"
6 #include "tags_utils.h"
7
8 #include "tests.h"
9
10 static int error = SPLT_OK;
11 static splt_state *state = NULL;
12 static splt_tags *tags = NULL;
13
14 static char *NO_DEFAULT_COMMENT = NULL;
15 static char *NO_DEFAULT_GENRE = NULL;
16
17 static void set_tags_format_options(splt_state *state, int format);
18
cut_setup()19 void cut_setup()
20 {
21 state = mp3splt_new_state(NULL);
22 error = SPLT_OK;
23 }
24
cut_teardown()25 void cut_teardown()
26 {
27 mp3splt_free_state(state);
28 splt_tu_free_one_tags(&tags);
29 tags = NULL;
30 }
31
test_all_fields_no_conversion()32 void test_all_fields_no_conversion()
33 {
34 tags = splt_fr_parse(state,
35 "artist producing Slow Rock _ album named geek by performer in 2007 with comment and track 2 of 5",
36
37 "(?<artist>.*?) producing (?<genre>.*?) _ (?<album>.*?) named (?<title>.*?) by "
38 ".*? in (?<year>.*?) with (?<comment>.*?) and track (?<tracknum>.*?) of (?<tracks>.*)",
39
40 NO_DEFAULT_COMMENT, NO_DEFAULT_GENRE, &error);
41
42 cut_assert_equal_int(SPLT_REGEX_OK, error);
43
44 char *artist = mp3splt_tags_get(tags, SPLT_TAGS_ARTIST);
45 cut_assert_equal_string("artist", artist);
46 free(artist);
47 char *title = mp3splt_tags_get(tags, SPLT_TAGS_TITLE);
48 cut_assert_equal_string("geek", title);
49 free(title);
50 char *album = mp3splt_tags_get(tags, SPLT_TAGS_ALBUM);
51 cut_assert_equal_string("album", album);
52 free(album);
53 char *comment = mp3splt_tags_get(tags, SPLT_TAGS_COMMENT);
54 cut_assert_equal_string("comment", comment);
55 free(comment);
56 char *year = mp3splt_tags_get(tags, SPLT_TAGS_YEAR);
57 cut_assert_equal_string("2007", year);
58 free(year);
59 char *track = mp3splt_tags_get(tags, SPLT_TAGS_TRACK);
60 cut_assert_equal_string("2", track);
61 free(track);
62 char *genre = mp3splt_tags_get(tags, SPLT_TAGS_GENRE);
63 cut_assert_equal_string("Slow Rock", genre);
64 free(genre);
65 }
66
test_all_fields_to_uppercase()67 void test_all_fields_to_uppercase()
68 {
69 set_tags_format_options(state, SPLT_TO_UPPERCASE);
70
71 tags = splt_fr_parse(state,
72
73 "artist producing Slow Rock _ album named geek by performer in 2007 with comment and track 2 of 5",
74
75 "(?<artist>.*?) producing (?<genre>.*?) _ (?<album>.*?) named (?<title>.*?) by "
76 ".*? in (?<year>.*?) with (?<comment>.*?) and track (?<tracknum>.*?) of (?<tracks>.*)",
77
78 NO_DEFAULT_COMMENT, NO_DEFAULT_GENRE, &error);
79
80 cut_assert_equal_int(SPLT_REGEX_OK, error);
81
82 char *artist = mp3splt_tags_get(tags, SPLT_TAGS_ARTIST);
83 cut_assert_equal_string("ARTIST", artist);
84 free(artist);
85 char *title = mp3splt_tags_get(tags, SPLT_TAGS_TITLE);
86 cut_assert_equal_string("GEEK", title);
87 free(title);
88 char *album = mp3splt_tags_get(tags, SPLT_TAGS_ALBUM);
89 cut_assert_equal_string("ALBUM", album);
90 free(album);
91 char *comment = mp3splt_tags_get(tags, SPLT_TAGS_COMMENT);
92 cut_assert_equal_string("COMMENT", comment);
93 free(comment);
94 char *year = mp3splt_tags_get(tags, SPLT_TAGS_YEAR);
95 cut_assert_equal_string("2007", year);
96 free(year);
97 char *track = mp3splt_tags_get(tags, SPLT_TAGS_TRACK);
98 cut_assert_equal_string("2", track);
99 free(track);
100 char *genre = mp3splt_tags_get(tags, SPLT_TAGS_GENRE);
101 cut_assert_equal_string("Slow Rock", genre);
102 free(genre);
103 }
104
test_all_fields_to_lowercase()105 void test_all_fields_to_lowercase()
106 {
107 set_tags_format_options(state, SPLT_TO_LOWERCASE);
108
109 tags = splt_fr_parse(state,
110 "arTist producing Slow Rock _ alBum named GEEK by PERFORMER in 2007 with coMMent and track 2 of 5",
111
112 "(?<artist>.*?) producing (?<genre>.*?) _ (?<album>.*?) named (?<title>.*?) by "
113 ".*? in (?<year>.*?) with (?<comment>.*?) and track (?<tracknum>.*?) of (?<tracks>.*)",
114
115 NO_DEFAULT_COMMENT, NO_DEFAULT_GENRE, &error);
116
117 cut_assert_equal_int(SPLT_REGEX_OK, error);
118
119 char *artist = mp3splt_tags_get(tags, SPLT_TAGS_ARTIST);
120 cut_assert_equal_string("artist", artist);
121 free(artist);
122 char *title = mp3splt_tags_get(tags, SPLT_TAGS_TITLE);
123 cut_assert_equal_string("geek", title);
124 free(title);
125 char *album = mp3splt_tags_get(tags, SPLT_TAGS_ALBUM);
126 cut_assert_equal_string("album", album);
127 free(album);
128 char *comment = mp3splt_tags_get(tags, SPLT_TAGS_COMMENT);
129 cut_assert_equal_string("comment", comment);
130 free(comment);
131 char *year = mp3splt_tags_get(tags, SPLT_TAGS_YEAR);
132 cut_assert_equal_string("2007", year);
133 free(year);
134 char *track = mp3splt_tags_get(tags, SPLT_TAGS_TRACK);
135 cut_assert_equal_string("2", track);
136 free(track);
137 char *genre = mp3splt_tags_get(tags, SPLT_TAGS_GENRE);
138 cut_assert_equal_string("Slow Rock", genre);
139 free(genre);
140 }
141
test_all_fields_to_first_uppercase()142 void test_all_fields_to_first_uppercase()
143 {
144 set_tags_format_options(state, SPLT_TO_FIRST_UPPERCASE);
145
146 tags = splt_fr_parse(state,
147 "arTist good producing Tango _ alBum named gEEK by pERFORMER in 2007 with coMMent and track 2 of 5",
148
149 "(?<artist>.*?) producing (?<genre>.*?) _ (?<album>.*?) named (?<title>.*?) by "
150 ".*? in (?<year>.*?) with (?<comment>.*?) and track (?<tracknum>.*?) of (?<tracks>.*)",
151
152 NO_DEFAULT_COMMENT, NO_DEFAULT_GENRE, &error);
153
154 cut_assert_equal_int(SPLT_REGEX_OK, error);
155
156 char *artist = mp3splt_tags_get(tags, SPLT_TAGS_ARTIST);
157 cut_assert_equal_string("ArTist good", artist);
158 free(artist);
159 char *title = mp3splt_tags_get(tags, SPLT_TAGS_TITLE);
160 cut_assert_equal_string("GEEK", title);
161 free(title);
162 char *album = mp3splt_tags_get(tags, SPLT_TAGS_ALBUM);
163 cut_assert_equal_string("AlBum", album);
164 free(album);
165 char *comment = mp3splt_tags_get(tags, SPLT_TAGS_COMMENT);
166 cut_assert_equal_string("CoMMent", comment);
167 free(comment);
168 char *year = mp3splt_tags_get(tags, SPLT_TAGS_YEAR);
169 cut_assert_equal_string("2007", year);
170 free(year);
171 char *track = mp3splt_tags_get(tags, SPLT_TAGS_TRACK);
172 cut_assert_equal_string("2", track);
173 free(track);
174 char *genre = mp3splt_tags_get(tags, SPLT_TAGS_GENRE);
175 cut_assert_equal_string("Tango", genre);
176 free(genre);
177 //tags->total_tracks
178 }
179
test_all_fields_to_word_first_uppercase()180 void test_all_fields_to_word_first_uppercase()
181 {
182 set_tags_format_options(state, SPLT_TO_WORD_FIRST_UPPERCASE);
183
184 tags = splt_fr_parse(state,
185 "arTist good producing Tango _ alBum second named gEEK y by pERFORMER me in 2007 with coMMent this and track 2 of 5",
186
187 "(?<artist>.*?) producing (?<genre>.*?) _ (?<album>.*?) named (?<title>.*?) by "
188 ".*? in (?<year>.*?) with (?<comment>.*?) and track (?<tracknum>.*?) of (?<tracks>.*)",
189
190 NO_DEFAULT_COMMENT, NO_DEFAULT_GENRE, &error);
191
192 cut_assert_equal_int(SPLT_REGEX_OK, error);
193
194 char *artist = mp3splt_tags_get(tags, SPLT_TAGS_ARTIST);
195 cut_assert_equal_string("ArTist Good", artist);
196 free(artist);
197 char *title = mp3splt_tags_get(tags, SPLT_TAGS_TITLE);
198 cut_assert_equal_string("GEEK Y", title);
199 free(title);
200 char *album = mp3splt_tags_get(tags, SPLT_TAGS_ALBUM);
201 cut_assert_equal_string("AlBum Second", album);
202 free(album);
203 char *comment = mp3splt_tags_get(tags, SPLT_TAGS_COMMENT);
204 cut_assert_equal_string("CoMMent This", comment);
205 free(comment);
206 char *year = mp3splt_tags_get(tags, SPLT_TAGS_YEAR);
207 cut_assert_equal_string("2007", year);
208 free(year);
209 char *track = mp3splt_tags_get(tags, SPLT_TAGS_TRACK);
210 cut_assert_equal_string("2", track);
211 free(track);
212 char *genre = mp3splt_tags_get(tags, SPLT_TAGS_GENRE);
213 cut_assert_equal_string("Tango", genre);
214 free(genre);
215 //tags->total_tracks
216 }
217
test_invalid_regex()218 void test_invalid_regex()
219 {
220 splt_fr_parse(state, "another one", "(?ohh my test",
221 NO_DEFAULT_COMMENT, NO_DEFAULT_GENRE, &error);
222
223 cut_assert_equal_int(SPLT_INVALID_REGEX, error);
224 mp3splt_assert_equal_error_message(state, error,
225 " regular expression error: @2: unrecognized character after (? or (?-");
226 }
227
test_no_regex_match()228 void test_no_regex_match()
229 {
230 splt_fr_parse(state, "another one", "(?<artist>.*?) one test",
231 NO_DEFAULT_COMMENT, NO_DEFAULT_GENRE, &error);
232
233 cut_assert_equal_int(SPLT_REGEX_NO_MATCH, error);
234 mp3splt_assert_equal_error_message(state, error, " regular expression error: no match");
235 }
236
test_no_title_with_total_tracks()237 void test_no_title_with_total_tracks()
238 {
239 tags = splt_fr_parse(state, "track 3 of 6",
240 "track (?<tracknum>.*?) of (?<tracks>.*)",
241 NO_DEFAULT_COMMENT, NO_DEFAULT_GENRE, &error);
242
243 cut_assert_equal_int(SPLT_REGEX_OK, error);
244
245 char *title = mp3splt_tags_get(tags, SPLT_TAGS_TITLE);
246 cut_assert_equal_string("Track 3 of 6", title);
247 free(title);
248 char *track = mp3splt_tags_get(tags, SPLT_TAGS_TRACK);
249 cut_assert_equal_string("3", track);
250 free(track);
251 }
252
test_no_title_no_total_tracks()253 void test_no_title_no_total_tracks()
254 {
255 tags = splt_fr_parse(state, "track 3", "track (?<tracknum>.*)",
256 NO_DEFAULT_COMMENT, NO_DEFAULT_GENRE, &error);
257
258 cut_assert_equal_int(SPLT_REGEX_OK, error);
259
260 char *title = mp3splt_tags_get(tags, SPLT_TAGS_TITLE);
261 cut_assert_equal_string("Track 3", title);
262 free(title);
263 char *track = mp3splt_tags_get(tags, SPLT_TAGS_TRACK);
264 cut_assert_equal_string("3", track);
265 free(track);
266 }
267
test_default_comment()268 void test_default_comment()
269 {
270 tags = splt_fr_parse(state, "track 3", "track (?<tracknum>.*)",
271 "default_comment", NO_DEFAULT_GENRE, &error);
272
273 cut_assert_equal_int(SPLT_REGEX_OK, error);
274
275 char *comment = mp3splt_tags_get(tags, SPLT_TAGS_COMMENT);
276 cut_assert_equal_string("default_comment", comment);
277 free(comment);
278 }
279
test_default_genre()280 void test_default_genre()
281 {
282 tags = splt_fr_parse(state, "track 3", "track (?<tracknum>.*)",
283 NO_DEFAULT_COMMENT, "Freestyle", &error);
284
285 cut_assert_equal_int(SPLT_REGEX_OK, error);
286
287 char *genre = mp3splt_tags_get(tags, SPLT_TAGS_GENRE);
288 cut_assert_equal_string("Freestyle", genre);
289 free(genre);
290 }
291
292
test_mixed_formats()293 void test_mixed_formats()
294 {
295 splt_o_set_int_option(state, SPLT_OPT_ARTIST_TAG_FORMAT, SPLT_TO_UPPERCASE);
296 splt_o_set_int_option(state, SPLT_OPT_ALBUM_TAG_FORMAT, SPLT_TO_FIRST_UPPERCASE);
297 splt_o_set_int_option(state, SPLT_OPT_TITLE_TAG_FORMAT, SPLT_TO_LOWERCASE);
298 splt_o_set_int_option(state, SPLT_OPT_COMMENT_TAG_FORMAT, SPLT_TO_WORD_FIRST_UPPERCASE);
299
300 tags = splt_fr_parse(state,
301 "arTist_good producing Tribal _ alBum named gEEK by pERFORMER in 2007 with coMMent kk and track 2 of 5",
302
303 "(?<artist>.*?) producing (?<genre>.*?) _ (?<album>.*?) named (?<title>.*?) by "
304 ".*? in (?<year>.*?) with (?<comment>.*?) and track (?<tracknum>.*?) of (?<tracks>.*)",
305
306 NO_DEFAULT_COMMENT, NO_DEFAULT_GENRE, &error);
307
308 cut_assert_equal_int(SPLT_REGEX_OK, error);
309
310 char *artist = mp3splt_tags_get(tags, SPLT_TAGS_ARTIST);
311 cut_assert_equal_string("ARTIST_GOOD", artist);
312 free(artist);
313 char *title = mp3splt_tags_get(tags, SPLT_TAGS_TITLE);
314 cut_assert_equal_string("geek", title);
315 free(title);
316 char *album = mp3splt_tags_get(tags, SPLT_TAGS_ALBUM);
317 cut_assert_equal_string("AlBum", album);
318 free(album);
319 char *comment = mp3splt_tags_get(tags, SPLT_TAGS_COMMENT);
320 cut_assert_equal_string("CoMMent Kk", comment);
321 free(comment);
322 char *year = mp3splt_tags_get(tags, SPLT_TAGS_YEAR);
323 cut_assert_equal_string("2007", year);
324 free(year);
325 char *track = mp3splt_tags_get(tags, SPLT_TAGS_TRACK);
326 cut_assert_equal_string("2", track);
327 free(track);
328 char *genre = mp3splt_tags_get(tags, SPLT_TAGS_GENRE);
329 cut_assert_equal_string("Tribal", genre);
330 free(genre);
331 }
332
test_with_replace_underscores()333 void test_with_replace_underscores()
334 {
335 splt_o_set_int_option(state, SPLT_OPT_ARTIST_TAG_FORMAT, SPLT_TO_UPPERCASE);
336 splt_o_set_int_option(state, SPLT_OPT_ALBUM_TAG_FORMAT, SPLT_TO_FIRST_UPPERCASE);
337 splt_o_set_int_option(state, SPLT_OPT_TITLE_TAG_FORMAT, SPLT_TO_LOWERCASE);
338 splt_o_set_int_option(state, SPLT_OPT_COMMENT_TAG_FORMAT, SPLT_TO_WORD_FIRST_UPPERCASE);
339
340 splt_o_set_int_option(state, SPLT_OPT_REPLACE_UNDERSCORES_TAG_FORMAT, SPLT_TRUE);
341
342 tags = splt_fr_parse(state,
343 "arTist_good producing Dance Hall _ alBum named gE_EK by pERFORMER in 2007 with coMMent kk and track 2 of 5",
344
345 "(?<artist>.*?) producing (?<genre>.*?) _ (?<album>.*?) named (?<title>.*?) by "
346 ".*? in (?<year>.*?) with (?<comment>.*?) and track (?<tracknum>.*?) of (?<tracks>.*)",
347
348 NO_DEFAULT_COMMENT, NO_DEFAULT_GENRE, &error);
349
350 cut_assert_equal_int(SPLT_REGEX_OK, error);
351
352 char *artist = mp3splt_tags_get(tags, SPLT_TAGS_ARTIST);
353 cut_assert_equal_string("ARTIST GOOD", artist);
354 free(artist);
355 char *title = mp3splt_tags_get(tags, SPLT_TAGS_TITLE);
356 cut_assert_equal_string("ge ek", title);
357 free(title);
358 char *album = mp3splt_tags_get(tags, SPLT_TAGS_ALBUM);
359 cut_assert_equal_string("AlBum", album);
360 free(album);
361 char *comment = mp3splt_tags_get(tags, SPLT_TAGS_COMMENT);
362 cut_assert_equal_string("CoMMent Kk", comment);
363 free(comment);
364 char *year = mp3splt_tags_get(tags, SPLT_TAGS_YEAR);
365 cut_assert_equal_string("2007", year);
366 free(year);
367 char *track = mp3splt_tags_get(tags, SPLT_TAGS_TRACK);
368 cut_assert_equal_string("2", track);
369 free(track);
370 char *genre = mp3splt_tags_get(tags, SPLT_TAGS_GENRE);
371 cut_assert_equal_string("Dance Hall", genre);
372 free(genre);
373 }
374
set_tags_format_options(splt_state * state,int format)375 static void set_tags_format_options(splt_state *state, int format)
376 {
377 splt_o_set_int_option(state, SPLT_OPT_ARTIST_TAG_FORMAT, format);
378 splt_o_set_int_option(state, SPLT_OPT_ALBUM_TAG_FORMAT, format);
379 splt_o_set_int_option(state, SPLT_OPT_TITLE_TAG_FORMAT, format);
380 splt_o_set_int_option(state, SPLT_OPT_COMMENT_TAG_FORMAT, format);
381 }
382
383