← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libjaudiotagger-java/trusty

« back to all changes in this revision

Viewing changes to srctest/org/jaudiotagger/tag/id3/NewInterfaceTest.java

  • Committer: Bazaar Package Importer
  • Author(s): Damien Raude-Morvan
  • Date: 2011-04-28 23:52:43 UTC
  • mfrom: (3.1.4 sid)
  • Revision ID: james.westby@ubuntu.com-20110428235243-pzalvw6lncis3ukf
Tags: 2.0.3-1
* d/control: Drop Depends on default-jre per Debian Java Policy as its
  a library package.
* d/watch: Fix to directly monitor SVN tags.
* Switch to 3.0 (quilt) format.
* Bump Standards-Version to 3.9.2 (no changes needed).

Show diffs side-by-side

added added

removed removed

Lines of Context:
srctest/org/jaudiotagger/tag/id3/NewInterfaceTest.java
1
 
package org.jaudiotagger.tag.id3;
2
 
 
3
 
import junit.framework.Test;
4
 
import junit.framework.TestCase;
5
 
import junit.framework.TestSuite;
6
 
import org.jaudiotagger.AbstractTestCase;
7
 
import org.jaudiotagger.audio.AudioFile;
8
 
import org.jaudiotagger.audio.AudioFileIO;
9
 
import org.jaudiotagger.audio.mp3.MP3File;
10
 
import org.jaudiotagger.tag.FieldKey;
11
 
import org.jaudiotagger.tag.TagField;
12
 
import org.jaudiotagger.tag.TagOptionSingleton;
13
 
import org.jaudiotagger.tag.datatype.DataTypes;
14
 
import org.jaudiotagger.tag.id3.framebody.*;
15
 
import org.jaudiotagger.tag.id3.valuepair.TextEncoding;
16
 
 
17
 
import javax.imageio.ImageIO;
18
 
import java.awt.image.BufferedImage;
19
 
import java.io.ByteArrayInputStream;
20
 
import java.io.File;
21
 
import java.io.RandomAccessFile;
22
 
import java.util.ArrayList;
23
 
import java.util.Iterator;
24
 
import java.util.List;
25
 
import java.util.NoSuchElementException;
26
 
 
27
 
/**
28
 
 * Testing retrofitting of entagged interfaces
29
 
 */
30
 
public class NewInterfaceTest extends TestCase
31
 
{
32
 
    private static final String V1_ARTIST = "V1ARTIST";
33
 
 
34
 
    public static final String ALBUM_TEST_STRING = "mellow gold";
35
 
    public static final String ALBUM_TEST_STRING2 = "odelay";
36
 
 
37
 
 
38
 
 
39
 
        /**
40
 
         *
41
 
         */
42
 
        protected void setUp()
43
 
        {
44
 
            TagOptionSingleton.getInstance().setToDefault();
45
 
        }
46
 
 
47
 
        /**
48
 
         *
49
 
         */
50
 
        protected void tearDown()
51
 
        {
52
 
        }
53
 
 
54
 
 
55
 
    /**
56
 
     * Constructor
57
 
     *
58
 
     * @param arg0
59
 
     */
60
 
    public NewInterfaceTest(String arg0)
61
 
    {
62
 
        super(arg0);
63
 
    }
64
 
 
65
 
    /**
66
 
     * Command line entrance.
67
 
     *
68
 
     * @param args
69
 
     */
70
 
    public static void main(String[] args)
71
 
    {
72
 
        junit.textui.TestRunner.run(suite());
73
 
    }
74
 
 
75
 
    /**
76
 
     * Builds the Test Suite.
77
 
     *
78
 
     * @return the Test Suite.
79
 
     */
80
 
    public static Test suite()
81
 
    {
82
 
        return new TestSuite(NewInterfaceTest.class);
83
 
    }
84
 
 
85
 
    public void testBasicWrite()
86
 
    {
87
 
        Exception ex = null;
88
 
        try
89
 
        {
90
 
            File testFile = AbstractTestCase.copyAudioToTmp("testV1.mp3", new File("testBasicWrite.mp3"));
91
 
            org.jaudiotagger.audio.AudioFile audioFile = org.jaudiotagger.audio.AudioFileIO.read(testFile);
92
 
            org.jaudiotagger.tag.Tag newTag = audioFile.getTag();
93
 
            if (audioFile.getTag() == null)
94
 
            {
95
 
                audioFile.setTag(new ID3v23Tag());
96
 
                newTag = audioFile.getTag();
97
 
            }
98
 
 
99
 
            newTag.setField(FieldKey.ALBUM,"album");
100
 
            newTag.setField(FieldKey.ARTIST,"artist");
101
 
            newTag.setField(FieldKey.COMMENT,"comment");
102
 
            newTag.setField(FieldKey.GENRE,"Rock");
103
 
            newTag.setField(FieldKey.TITLE,"title");
104
 
            newTag.setField(FieldKey.YEAR,"year");
105
 
            newTag.setField(FieldKey.TRACK,Integer.toString(1));
106
 
 
107
 
            assertEquals("album", newTag.getFirst(FieldKey.ALBUM));
108
 
            assertEquals("artist", newTag.getFirst(FieldKey.ARTIST));
109
 
            assertEquals("comment", newTag.getFirst(FieldKey.COMMENT));
110
 
            assertEquals("Rock", newTag.getFirst(FieldKey.GENRE));
111
 
            assertEquals("title", newTag.getFirst(FieldKey.TITLE));
112
 
            assertEquals("year", newTag.getFirst(FieldKey.YEAR));
113
 
            assertEquals("1", newTag.getFirst(FieldKey.TRACK));
114
 
 
115
 
            audioFile.commit();
116
 
 
117
 
            audioFile = org.jaudiotagger.audio.AudioFileIO.read(testFile);
118
 
            newTag = audioFile.getTag();
119
 
            assertEquals("album", newTag.getFirst(FieldKey.ALBUM));
120
 
            assertEquals("artist", newTag.getFirst(FieldKey.ARTIST));
121
 
            assertEquals("comment", newTag.getFirst(FieldKey.COMMENT));
122
 
            assertEquals("Rock", newTag.getFirst(FieldKey.GENRE));
123
 
            assertEquals("title", newTag.getFirst(FieldKey.TITLE));
124
 
            assertEquals("year", newTag.getFirst(FieldKey.YEAR));
125
 
            assertEquals("1", newTag.getFirst(FieldKey.TRACK));
126
 
            AbstractTagFrameBody body = (((ID3v23Frame) newTag.getFirstField(ID3v23FieldKey.ALBUM.getFrameId())).getBody());
127
 
            assertEquals(TextEncoding.ISO_8859_1, body.getTextEncoding());
128
 
 
129
 
            TagOptionSingleton.getInstance().setId3v23DefaultTextEncoding(TextEncoding.UTF_16);
130
 
            TagOptionSingleton.getInstance().setResetTextEncodingForExistingFrames(true);
131
 
            audioFile.commit();
132
 
            audioFile = org.jaudiotagger.audio.AudioFileIO.read(testFile);
133
 
            newTag = audioFile.getTag();
134
 
            assertEquals("album", newTag.getFirst(FieldKey.ALBUM));
135
 
            assertEquals("artist", newTag.getFirst(FieldKey.ARTIST));
136
 
            assertEquals("comment", newTag.getFirst(FieldKey.COMMENT));
137
 
            assertEquals("Rock", newTag.getFirst(FieldKey.GENRE));
138
 
            assertEquals("title", newTag.getFirst(FieldKey.TITLE));
139
 
            assertEquals("year", newTag.getFirst(FieldKey.YEAR));
140
 
            assertEquals("1", newTag.getFirst(FieldKey.TRACK));
141
 
            body = (((ID3v23Frame) newTag.getFirstField(ID3v23FieldKey.ALBUM.getFrameId())).getBody());
142
 
            assertEquals(TextEncoding.UTF_16, body.getTextEncoding());
143
 
 
144
 
            TagOptionSingleton.getInstance().setId3v23DefaultTextEncoding(TextEncoding.ISO_8859_1);
145
 
            TagOptionSingleton.getInstance().setResetTextEncodingForExistingFrames(true);
146
 
            audioFile.commit();
147
 
            audioFile = org.jaudiotagger.audio.AudioFileIO.read(testFile);
148
 
            newTag = audioFile.getTag();
149
 
            body = (((ID3v23Frame) newTag.getFirstField(ID3v23FieldKey.ALBUM.getFrameId())).getBody());
150
 
            assertEquals(TextEncoding.ISO_8859_1, body.getTextEncoding());
151
 
            TagOptionSingleton.getInstance().setResetTextEncodingForExistingFrames(false);
152
 
        }
153
 
        catch (Exception e)
154
 
        {
155
 
            ex = e;
156
 
            ex.printStackTrace();
157
 
        }
158
 
        assertNull(ex);
159
 
    }
160
 
 
161
 
    public void testNewInterfaceBasicReadandWriteID3v1() throws Exception
162
 
    {
163
 
        Exception e = null;
164
 
        File testFile = AbstractTestCase.copyAudioToTmp("testV1.mp3", new File("testnewIntId3v1.mp3"));
165
 
        MP3File mp3File = new MP3File(testFile);
166
 
 
167
 
        //Has no tag at this point
168
 
        assertFalse(mp3File.hasID3v1Tag());
169
 
        assertFalse(mp3File.hasID3v2Tag());
170
 
 
171
 
        //Create v1 tag (old method)
172
 
        ID3v11Tag v1tag = new ID3v11Tag();
173
 
        v1tag.setField(FieldKey.ARTIST,V1_ARTIST);
174
 
        v1tag.setField(FieldKey.ALBUM,"V1ALBUM" + "\u01ff");         //Note always convert to single byte so will be written as FF
175
 
        v1tag.setField(v1tag.createField(FieldKey.TITLE, "title"));
176
 
        v1tag.setField(FieldKey.GENRE,"Rock");
177
 
        v1tag.setField(v1tag.createField(FieldKey.TRACK, "12"));
178
 
        mp3File.setID3v1Tag(v1tag);
179
 
        mp3File.save();
180
 
 
181
 
        //Has only v1 tag
182
 
        assertTrue(mp3File.hasID3v1Tag());
183
 
        assertFalse(mp3File.hasID3v2Tag());
184
 
 
185
 
        //Read fields
186
 
        AudioFile af = AudioFileIO.read(testFile);
187
 
        assertEquals(V1_ARTIST, af.getTag().getFirst(FieldKey.ARTIST));
188
 
        assertEquals(V1_ARTIST, af.getTag().getFirst(FieldKey.ARTIST));
189
 
        assertEquals(V1_ARTIST, af.getTag().getFirst(FieldKey.ARTIST));
190
 
        assertEquals("V1ALBUM" + "\u00ff", af.getTag().getFirst(FieldKey.ALBUM));  //Lost the 00, is that what we want
191
 
        assertEquals("title", af.getTag().getFirst(FieldKey.TITLE));
192
 
        assertEquals("title", af.getTag().getFirst(FieldKey.TITLE));
193
 
        assertEquals("Rock", af.getTag().getFirst(FieldKey.GENRE));
194
 
        assertEquals("12", af.getTag().getFirst(FieldKey.TRACK));
195
 
        assertEquals("12", af.getTag().getFirst(FieldKey.TRACK));
196
 
 
197
 
        //Delete some fields (just sets string to empty String)
198
 
        af.getTag().deleteField(FieldKey.TITLE);
199
 
        assertEquals("", af.getTag().getFirst(FieldKey.TITLE));
200
 
 
201
 
        //Modify a value
202
 
        af.getTag().setField(FieldKey.TITLE,"newtitle");
203
 
        assertEquals("newtitle", af.getTag().getFirst(FieldKey.TITLE));
204
 
 
205
 
        //Adding just replaces current value
206
 
        af.getTag().addField(FieldKey.TITLE,"newtitle2");
207
 
        assertEquals("newtitle2", af.getTag().getFirst(FieldKey.TITLE));
208
 
    }
209
 
 
210
 
    public void testNewInterfaceBasicReadandWriteID3v24() throws Exception
211
 
    {
212
 
        Exception e = null;
213
 
        File testFile = AbstractTestCase.copyAudioToTmp("testV1.mp3", new File("testnewIntId3v24.mp3"));
214
 
        MP3File mp3File = new MP3File(testFile);
215
 
 
216
 
        //Has no tag at this point
217
 
        assertFalse(mp3File.hasID3v1Tag());
218
 
        assertFalse(mp3File.hasID3v2Tag());
219
 
 
220
 
        //Create v1 tag (old method)
221
 
        ID3v11Tag v1tag = new ID3v11Tag();
222
 
        v1tag.setField(FieldKey.ARTIST,V1_ARTIST);
223
 
        v1tag.setField(FieldKey.ALBUM,"V1ALBUM");
224
 
        mp3File.setID3v1Tag(v1tag);
225
 
        mp3File.save();
226
 
 
227
 
        //Has only v1 tag at this point
228
 
        assertTrue(mp3File.hasID3v1Tag());
229
 
        assertFalse(mp3File.hasID3v2Tag());
230
 
 
231
 
        //Read back artist (new method ,v1)
232
 
        AudioFile af = AudioFileIO.read(testFile);
233
 
        assertEquals(V1_ARTIST, af.getTag().getFirst(FieldKey.ARTIST));
234
 
        assertEquals(V1_ARTIST, af.getTag().getFirst(FieldKey.ARTIST));
235
 
        assertEquals(V1_ARTIST, af.getTag().getFirst(FieldKey.ARTIST));
236
 
 
237
 
        //Add artist frame (old method)
238
 
        ID3v24Tag tag = new ID3v24Tag();
239
 
        ID3v24Frame frame = new ID3v24Frame(ID3v24Frames.FRAME_ID_ARTIST);
240
 
        ((FrameBodyTPE1) frame.getBody()).setText(FrameBodyTPE1Test.TPE1_TEST_STRING);
241
 
        tag.setFrame(frame);
242
 
        mp3File.setID3v2TagOnly(tag);
243
 
        mp3File.save();
244
 
 
245
 
        //Has v1 and v2 tag at this point
246
 
        assertTrue(mp3File.hasID3v1Tag());
247
 
        assertTrue(mp3File.hasID3v2Tag());
248
 
 
249
 
        //Read back artist (new method ,v1 value overrriden by v2 method)
250
 
        af = AudioFileIO.read(testFile);
251
 
        assertEquals(FrameBodyTPE1Test.TPE1_TEST_STRING, af.getTag().getFirst(FieldKey.ARTIST));
252
 
        assertEquals(FrameBodyTPE1Test.TPE1_TEST_STRING, af.getTag().getFirst(FieldKey.ARTIST));
253
 
        assertEquals(FrameBodyTPE1Test.TPE1_TEST_STRING, ((ID3v24Tag) af.getTag()).getFirst(ID3v24FieldKey.ARTIST));
254
 
        //.... but v1 value is still there
255
 
        assertEquals(V1_ARTIST, ((MP3File) af).getID3v1Tag().getFirst(FieldKey.ARTIST));
256
 
        //Write album ( new method)
257
 
        af.getTag().setField(FieldKey.ALBUM,ALBUM_TEST_STRING);
258
 
        af.commit();
259
 
 
260
 
        //Read back album (new method)
261
 
        af = AudioFileIO.read(testFile);
262
 
        assertEquals(ALBUM_TEST_STRING, af.getTag().getFirst(FieldKey.ALBUM));
263
 
        assertEquals(ALBUM_TEST_STRING, af.getTag().getFirst(FieldKey.ALBUM));
264
 
        assertEquals(ALBUM_TEST_STRING, ((ID3v24Tag) af.getTag()).getFirst(ID3v24FieldKey.ALBUM));
265
 
        assertEquals(1, af.getTag().getFields(FieldKey.ALBUM).size());
266
 
 
267
 
        //Read back album (old method)
268
 
        AbstractID3v2Frame checkframe = (AbstractID3v2Frame) ((MP3File) af).getID3v2Tag().getFrame(ID3v24Frames.FRAME_ID_ALBUM);
269
 
        assertEquals(ALBUM_TEST_STRING, ((FrameBodyTALB) checkframe.getBody()).getText());
270
 
 
271
 
        //Should only be allowed to addField one album, there is no multi value support for it
272
 
        af.getTag().addField(FieldKey.ALBUM,ALBUM_TEST_STRING2);
273
 
        af.commit();
274
 
        af = AudioFileIO.read(testFile);
275
 
        assertEquals(ALBUM_TEST_STRING, af.getTag().getFirst(FieldKey.ALBUM));
276
 
        assertEquals(ALBUM_TEST_STRING, af.getTag().getFirst(FieldKey.ALBUM));
277
 
        assertEquals(ALBUM_TEST_STRING, ((ID3v24Tag) af.getTag()).getFirst(ID3v24FieldKey.ALBUM));
278
 
        assertEquals(1, af.getTag().getFields(FieldKey.ALBUM).size());
279
 
 
280
 
        //But can replace existing value
281
 
        af.getTag().setField(FieldKey.ALBUM,ALBUM_TEST_STRING2);
282
 
        af.commit();
283
 
        af = AudioFileIO.read(testFile);
284
 
        assertEquals(ALBUM_TEST_STRING2, af.getTag().getFirst(FieldKey.ALBUM));
285
 
        assertEquals(ALBUM_TEST_STRING2, af.getTag().getFirst(FieldKey.ALBUM));
286
 
        assertEquals(ALBUM_TEST_STRING2, ((ID3v24Tag) af.getTag()).getFirst(ID3v24FieldKey.ALBUM));
287
 
        assertEquals(1, af.getTag().getFields(FieldKey.ALBUM).size());
288
 
 
289
 
        //and deleteField it
290
 
        af.getTag().deleteField(FieldKey.ALBUM);
291
 
        af.commit();
292
 
        af = AudioFileIO.read(testFile);
293
 
        assertEquals("", af.getTag().getFirst(FieldKey.ALBUM));
294
 
        assertEquals("", af.getTag().getFirst(FieldKey.ALBUM));
295
 
        assertEquals("", ((ID3v24Tag) af.getTag()).getFirst(ID3v24FieldKey.ALBUM));
296
 
        assertEquals(0, af.getTag().getFields(FieldKey.ALBUM).size());
297
 
 
298
 
        //Test out the other basic fields
299
 
        //Year
300
 
        af.getTag().setField(FieldKey.YEAR,"1991");
301
 
        af.commit();
302
 
        af = AudioFileIO.read(testFile);
303
 
        assertEquals("1991", af.getTag().getFirst(FieldKey.YEAR));
304
 
        assertEquals("1991", af.getTag().getFirst(FieldKey.YEAR));
305
 
        assertEquals("1991", ((ID3v24Tag) af.getTag()).getFirst(ID3v24FieldKey.YEAR));
306
 
        assertEquals(1, af.getTag().getFields(FieldKey.YEAR).size());
307
 
        assertEquals(2, af.getTag().getFieldCount());
308
 
 
309
 
        //Title
310
 
        af.getTag().setField(FieldKey.TITLE,"Title");
311
 
        af.commit();
312
 
        af = AudioFileIO.read(testFile);
313
 
        assertEquals("Title", af.getTag().getFirst(FieldKey.TITLE));
314
 
        assertEquals("Title", af.getTag().getFirst(FieldKey.TITLE));
315
 
        assertEquals("Title", ((ID3v24Tag) af.getTag()).getFirst(ID3v24FieldKey.TITLE));
316
 
        assertEquals(1, af.getTag().getFields(FieldKey.TITLE).size());
317
 
        assertEquals(3, af.getTag().getFieldCount());
318
 
 
319
 
        //Comment, trickier because uses different framebody subclass to the ones above
320
 
        af.getTag().setField(FieldKey.COMMENT,"Comment");
321
 
        af.commit();
322
 
        af = AudioFileIO.read(testFile);
323
 
        assertEquals("Comment", af.getTag().getFirst(FieldKey.COMMENT));
324
 
        assertEquals("Comment", ((ID3v24Tag) af.getTag()).getFirst(ID3v24FieldKey.COMMENT));
325
 
 
326
 
        //By default comments are created with empty description because this is what expected
327
 
        //by plyers such as iTunes.
328
 
        ID3v24Frame commentFrame = (ID3v24Frame) ((ID3v24Tag) af.getTag()).getFrame("COMM");
329
 
        FrameBodyCOMM fb = (FrameBodyCOMM) commentFrame.getBody();
330
 
        assertEquals("", fb.getDescription());
331
 
        assertEquals("Comment", fb.getText());
332
 
        //Change description, cant do this with common interface
333
 
        fb.setDescription("test");
334
 
        //Because has different description the following setField will addField another comment rather than overwriting the first one
335
 
        af.getTag().setField(FieldKey.COMMENT,"Comment2");
336
 
        assertEquals(2, af.getTag().getFields(FieldKey.COMMENT).size());
337
 
        //Add third Comment
338
 
        List<TagField> comments = af.getTag().getFields(FieldKey.COMMENT);
339
 
        ((FrameBodyCOMM) ((ID3v24Frame) comments.get(1)).getBody()).setDescription("test2");
340
 
        af.getTag().setField(FieldKey.COMMENT,"Comment3");
341
 
        af.commit();
342
 
        af = AudioFileIO.read(testFile);
343
 
        assertEquals(3, af.getTag().getFields(FieldKey.COMMENT).size());
344
 
 
345
 
        //Add fourth Comment (but duplicate key - so overwrites 3rd comment)
346
 
        af.getTag().setField(FieldKey.COMMENT,"Comment4");
347
 
        af.commit();
348
 
        af = AudioFileIO.read(testFile);
349
 
        assertEquals(3, af.getTag().getFields(FieldKey.COMMENT).size());
350
 
 
351
 
        //Remove all Comment tags
352
 
        af.getTag().deleteField(FieldKey.COMMENT);
353
 
        assertEquals(0, af.getTag().getFields(FieldKey.COMMENT).size());
354
 
 
355
 
        //Add first one back in
356
 
        af.getTag().setField(FieldKey.COMMENT,"Comment");
357
 
        af.commit();
358
 
        af = AudioFileIO.read(testFile);
359
 
        assertEquals(1, af.getTag().getFields(FieldKey.COMMENT).size());
360
 
        assertEquals(4, af.getTag().getFieldCount());
361
 
 
362
 
        //Genre
363
 
        //TODO only one genre frame allowed, but that can contain multiple GENRE values, currently
364
 
        //must parse as one genre e.g 34 67
365
 
        af.getTag().setField(FieldKey.GENRE,"CustomGenre");
366
 
        af.commit();
367
 
        af = AudioFileIO.read(testFile);
368
 
        assertEquals("CustomGenre", af.getTag().getFirst(FieldKey.GENRE));
369
 
        assertEquals("CustomGenre", af.getTag().getFirst(FieldKey.GENRE));
370
 
        assertEquals("CustomGenre", ((ID3v24Tag) af.getTag()).getFirst(ID3v24FieldKey.GENRE));
371
 
        assertEquals(1, af.getTag().getFields(FieldKey.GENRE).size());
372
 
        assertEquals(5, af.getTag().getFieldCount());
373
 
 
374
 
        //Track
375
 
        af.getTag().setField(FieldKey.TRACK,"7");
376
 
        af.getTag().setField(af.getTag().createField(FieldKey.TRACK_TOTAL, "11"));
377
 
        assertEquals("7",af.getTag().getFirst(FieldKey.TRACK));
378
 
        assertEquals("11",af.getTag().getFirst(FieldKey.TRACK_TOTAL));
379
 
        af.commit();
380
 
        af = AudioFileIO.read(testFile);
381
 
        assertEquals("7", af.getTag().getFirst(FieldKey.TRACK));
382
 
        assertEquals("7", af.getTag().getFirst(FieldKey.TRACK));
383
 
        assertEquals("7", ((ID3v24Tag) af.getTag()).getFirst(ID3v24FieldKey.TRACK));
384
 
        assertEquals("11",af.getTag().getFirst(FieldKey.TRACK_TOTAL));
385
 
        assertEquals(1, af.getTag().getFields(FieldKey.TRACK).size());
386
 
        assertEquals(6, af.getTag().getFieldCount());
387
 
 
388
 
        //AmazonId
389
 
        //This is one of many fields that uses the TXXX frame, the logic is more complicated
390
 
        af.getTag().setField(af.getTag().createField(FieldKey.AMAZON_ID, "asin123456" + "\u01ff"));
391
 
        af.commit();
392
 
        af = AudioFileIO.read(testFile);
393
 
 
394
 
         //Mood
395
 
        af.getTag().setField(af.getTag().createField(FieldKey.MOOD, "mood"));
396
 
        af.commit();
397
 
        af = AudioFileIO.read(testFile);
398
 
 
399
 
        assertEquals("asin123456" + "\u01ff", af.getTag().getFirst(FieldKey.AMAZON_ID));
400
 
        assertEquals("asin123456" + "\u01ff", ((ID3v24Tag) af.getTag()).getFirst(ID3v24FieldKey.AMAZON_ID));
401
 
        assertEquals(1, af.getTag().getFields(FieldKey.AMAZON_ID).size());
402
 
        assertEquals(8, af.getTag().getFieldCount());
403
 
 
404
 
        //Now addField another different field that also uses a TXXX frame
405
 
        af.getTag().setField(af.getTag().createField(FieldKey.MUSICIP_ID, "musicip_id"));
406
 
        af.commit();
407
 
        af = AudioFileIO.read(testFile);
408
 
        assertEquals(2, ((List) ((ID3v24Tag) af.getTag()).getFrame("TXXX")).size());
409
 
        assertEquals("musicip_id", af.getTag().getFirst(FieldKey.MUSICIP_ID));
410
 
        assertEquals("musicip_id", ((ID3v24Tag) af.getTag()).getFirst(ID3v24FieldKey.MUSICIP_ID));
411
 
        assertEquals(1, af.getTag().getFields(FieldKey.MUSICIP_ID).size());
412
 
        assertEquals("asin123456" + "\u01ff", af.getTag().getFirst(FieldKey.AMAZON_ID));
413
 
        assertEquals(9, af.getTag().getFieldCount());
414
 
 
415
 
        //Now addField yet another different field that also uses a TXXX frame
416
 
        af.getTag().setField(af.getTag().createField(FieldKey.MUSICBRAINZ_RELEASEID, "releaseid"));
417
 
        af.commit();
418
 
        af = AudioFileIO.read(testFile);
419
 
        assertEquals(3, ((List) ((ID3v24Tag) af.getTag()).getFrame("TXXX")).size());
420
 
        assertEquals("musicip_id", af.getTag().getFirst(FieldKey.MUSICIP_ID));
421
 
        assertEquals("releaseid", af.getTag().getFirst(FieldKey.MUSICBRAINZ_RELEASEID));
422
 
        assertEquals("asin123456" + "\u01ff", af.getTag().getFirst(FieldKey.AMAZON_ID));
423
 
        assertEquals(1, af.getTag().getFields(FieldKey.MUSICIP_ID).size());
424
 
        assertEquals(1, af.getTag().getFields(FieldKey.AMAZON_ID).size());
425
 
        assertEquals(1, af.getTag().getFields(FieldKey.MUSICBRAINZ_RELEASEID).size());
426
 
        assertEquals(10, af.getTag().getFieldCount());
427
 
 
428
 
        //Now deleteField field
429
 
        af.getTag().deleteField(FieldKey.MUSICBRAINZ_RELEASEID);
430
 
        af.commit();
431
 
        af = AudioFileIO.read(testFile);
432
 
        assertEquals(2, ((List) ((ID3v24Tag) af.getTag()).getFrame("TXXX")).size());
433
 
        assertEquals(1, af.getTag().getFields(FieldKey.MUSICIP_ID).size());
434
 
        assertEquals(1, af.getTag().getFields(FieldKey.AMAZON_ID).size());
435
 
        assertEquals(9, af.getTag().getFieldCount());
436
 
 
437
 
        //Cover Art:invalid way to do it
438
 
        try
439
 
        {
440
 
            af.getTag().setField(af.getTag().createField(FieldKey.COVER_ART, "coverart"));
441
 
        }
442
 
        catch (java.lang.UnsupportedOperationException uoe)
443
 
        {
444
 
            e = uoe;
445
 
        }
446
 
        assertTrue(e instanceof UnsupportedOperationException);
447
 
 
448
 
        //Add new image correctly
449
 
        RandomAccessFile imageFile = new RandomAccessFile(new File("testdata", "coverart.png"), "r");
450
 
        byte[] imagedata = new byte[(int) imageFile.length()];
451
 
        imageFile.read(imagedata);
452
 
        af.getTag().addField(tag.createArtworkField(imagedata, "image/png"));
453
 
        af.commit();
454
 
        af = AudioFileIO.read(testFile);
455
 
        assertEquals(1, ((ID3v24Tag) af.getTag()).getFields(FieldKey.COVER_ART).size());
456
 
        assertEquals(1, ((ID3v24Tag) af.getTag()).get(ID3v24FieldKey.COVER_ART.getFieldName()).size());
457
 
        //TODO This isnt very user friendly
458
 
        TagField tagField = af.getTag().getFirstField(ID3v24FieldKey.COVER_ART.getFieldName());
459
 
 
460
 
        assertTrue(tagField instanceof ID3v24Frame);
461
 
        ID3v24Frame apicFrame = (ID3v24Frame) tagField;
462
 
        assertTrue(apicFrame.getBody() instanceof FrameBodyAPIC);
463
 
        FrameBodyAPIC apicframebody = (FrameBodyAPIC) apicFrame.getBody();
464
 
        assertFalse(apicframebody.isImageUrl());
465
 
        assertEquals(10, af.getTag().getFieldCount());
466
 
 
467
 
        //Add another image correctly
468
 
        imageFile = new RandomAccessFile(new File("testdata", "coverart_small.png"), "r");
469
 
        imagedata = new byte[(int) imageFile.length()];
470
 
        imageFile.read(imagedata);
471
 
        af.getTag().addField(tag.createArtworkField(imagedata, "image/png"));
472
 
        af.commit();
473
 
        af = AudioFileIO.read(testFile);
474
 
        assertEquals(2, af.getTag().getFields(FieldKey.COVER_ART).size());
475
 
        assertEquals(11, af.getTag().getFieldCount());
476
 
 
477
 
        //Actually createField the image from the read data
478
 
        BufferedImage bi = null;
479
 
        TagField imageField = af.getTag().getFields(FieldKey.COVER_ART).get(0);
480
 
        if (imageField instanceof AbstractID3v2Frame)
481
 
        {
482
 
            FrameBodyAPIC imageFrameBody = (FrameBodyAPIC) ((AbstractID3v2Frame) imageField).getBody();
483
 
            if (!imageFrameBody.isImageUrl())
484
 
            {
485
 
                byte[] imageRawData = (byte[]) imageFrameBody.getObjectValue(DataTypes.OBJ_PICTURE_DATA);
486
 
                bi = ImageIO.read(new ByteArrayInputStream(imageRawData));
487
 
            }
488
 
        }
489
 
        assertNotNull(bi);
490
 
 
491
 
        //Add a linked Image
492
 
        af.getTag().addField(tag.createLinkedArtworkField("../testdata/coverart.jpg"));
493
 
        af.commit();
494
 
 
495
 
        af = AudioFileIO.read(testFile);
496
 
        assertEquals(3, af.getTag().getFields(FieldKey.COVER_ART).size());
497
 
        assertEquals(12, af.getTag().getFieldCount());
498
 
        List<TagField> imageFields = af.getTag().getFields(FieldKey.COVER_ART);
499
 
        tagField = imageFields.get(2);
500
 
        apicFrame = (ID3v24Frame) tagField;
501
 
        assertTrue(apicFrame.getBody() instanceof FrameBodyAPIC);
502
 
        apicframebody = (FrameBodyAPIC) apicFrame.getBody();
503
 
        assertTrue(apicframebody.isImageUrl());
504
 
        assertEquals("../testdata/coverart.jpg", apicframebody.getImageUrl());
505
 
 
506
 
 
507
 
    }
508
 
 
509
 
    /*  public void testReadUrlImage() throws Exception
510
 
       {
511
 
           Exception ex = null;
512
 
           try
513
 
           {
514
 
               File testFile = AbstractTestCase.copyAudioToTmp("testV1withurlimage.mp3");
515
 
               org.jaudiotagger.audio.AudioFile audioFile = org.jaudiotagger.audio.AudioFileIO.read(testFile);
516
 
               ID3v23Tag newTag = (ID3v23Tag)audioFile.getTag();
517
 
               assertEquals(1, newTag.getFields(FieldKey.COVER_ART).size());
518
 
               TagField tagField = newTag.getFirstField(ID3v23FieldKey.COVER_ART.getFieldName());
519
 
               assertTrue(tagField instanceof ID3v23Frame);
520
 
               ID3v23Frame apicFrame = (ID3v23Frame)tagField;
521
 
               assertTrue(apicFrame.getBody() instanceof FrameBodyAPIC);
522
 
               FrameBodyAPIC apicframebody = (FrameBodyAPIC)apicFrame.getBody();
523
 
               assertFalse(apicframebody.isImageUrl());
524
 
           }
525
 
           catch(Exception e)
526
 
           {
527
 
               ex=e;
528
 
               ex.printStackTrace();
529
 
           }
530
 
           assertNull(ex);
531
 
       }
532
 
    */
533
 
    public void testNewInterfaceBasicReadandWriteID3v23() throws Exception
534
 
    {
535
 
        Exception e = null;
536
 
        File testFile = AbstractTestCase.copyAudioToTmp("testV1.mp3", new File("testnewIntId3v23.mp3"));
537
 
        MP3File mp3File = new MP3File(testFile);
538
 
 
539
 
        //Has no tag at this point
540
 
        assertFalse(mp3File.hasID3v1Tag());
541
 
        assertFalse(mp3File.hasID3v2Tag());
542
 
 
543
 
        //Create v1 tag (old method)
544
 
        ID3v11Tag v1tag = new ID3v11Tag();
545
 
        v1tag.setField(FieldKey.ARTIST,V1_ARTIST);
546
 
        v1tag.setField(FieldKey.ALBUM,"V1ALBUM");
547
 
        mp3File.setID3v1Tag(v1tag);
548
 
        mp3File.save();
549
 
 
550
 
        //Has only v1 tag at this point
551
 
        assertTrue(mp3File.hasID3v1Tag());
552
 
        assertFalse(mp3File.hasID3v2Tag());
553
 
 
554
 
        //Read back artist (new method ,v1)
555
 
        AudioFile af = AudioFileIO.read(testFile);
556
 
        assertEquals(V1_ARTIST, af.getTag().getFirst(FieldKey.ARTIST));
557
 
        assertEquals(V1_ARTIST, af.getTag().getFirst(FieldKey.ARTIST));
558
 
        assertEquals(V1_ARTIST, af.getTag().getFirst(FieldKey.ARTIST));
559
 
 
560
 
        //Add artist frame (old method)
561
 
        ID3v23Tag tag = new ID3v23Tag();
562
 
        ID3v23Frame frame = new ID3v23Frame(ID3v23Frames.FRAME_ID_V3_ARTIST);
563
 
        ((FrameBodyTPE1) frame.getBody()).setText(FrameBodyTPE1Test.TPE1_TEST_STRING);
564
 
        tag.setFrame(frame);
565
 
        mp3File.setID3v2TagOnly(tag);
566
 
        mp3File.save();
567
 
 
568
 
        //Has v1 and v2 tag at this point
569
 
        assertTrue(mp3File.hasID3v1Tag());
570
 
        assertTrue(mp3File.hasID3v2Tag());
571
 
 
572
 
        //Read back artist (new method ,v1 value overrriden by v2 method)
573
 
        af = AudioFileIO.read(testFile);
574
 
        assertEquals(FrameBodyTPE1Test.TPE1_TEST_STRING, af.getTag().getFirst(FieldKey.ARTIST));
575
 
        assertEquals(FrameBodyTPE1Test.TPE1_TEST_STRING, af.getTag().getFirst(FieldKey.ARTIST));
576
 
        assertEquals(FrameBodyTPE1Test.TPE1_TEST_STRING, ((ID3v23Tag) af.getTag()).getFirst(ID3v23FieldKey.ARTIST));
577
 
        //.... but v1 value is still there
578
 
        assertEquals(V1_ARTIST, ((MP3File) af).getID3v1Tag().getFirst(FieldKey.ARTIST));
579
 
        //Write album ( new method)
580
 
        af.getTag().setField(FieldKey.ALBUM,ALBUM_TEST_STRING);
581
 
        af.commit();
582
 
 
583
 
        //Read back album (new method)
584
 
        af = AudioFileIO.read(testFile);
585
 
        assertEquals(ALBUM_TEST_STRING, af.getTag().getFirst(FieldKey.ALBUM));
586
 
        assertEquals(ALBUM_TEST_STRING, af.getTag().getFirst(FieldKey.ALBUM));
587
 
        assertEquals(ALBUM_TEST_STRING, ((ID3v23Tag) af.getTag()).getFirst(ID3v23FieldKey.ALBUM));
588
 
        assertEquals(1, af.getTag().getFields(FieldKey.ALBUM).size());
589
 
 
590
 
        //Read back album (old method)
591
 
        AbstractID3v2Frame checkframe = (AbstractID3v2Frame) ((MP3File) af).getID3v2Tag().getFrame(ID3v23Frames.FRAME_ID_V3_ALBUM);
592
 
        assertEquals(ALBUM_TEST_STRING, ((FrameBodyTALB) checkframe.getBody()).getText());
593
 
 
594
 
        //Should only be allowed to addField one album, there is no multi value support for it
595
 
        af.getTag().addField(FieldKey.ALBUM,ALBUM_TEST_STRING2);
596
 
        af.commit();
597
 
        af = AudioFileIO.read(testFile);
598
 
        assertEquals(ALBUM_TEST_STRING, af.getTag().getFirst(FieldKey.ALBUM));
599
 
        assertEquals(ALBUM_TEST_STRING, af.getTag().getFirst(FieldKey.ALBUM));
600
 
        assertEquals(ALBUM_TEST_STRING, ((ID3v23Tag) af.getTag()).getFirst(ID3v23FieldKey.ALBUM));
601
 
        assertEquals(1, af.getTag().getFields(FieldKey.ALBUM).size());
602
 
 
603
 
        //But can replace existing value
604
 
        af.getTag().setField(FieldKey.ALBUM,ALBUM_TEST_STRING2);
605
 
        af.commit();
606
 
        af = AudioFileIO.read(testFile);
607
 
        assertEquals(ALBUM_TEST_STRING2, af.getTag().getFirst(FieldKey.ALBUM));
608
 
        assertEquals(ALBUM_TEST_STRING2, af.getTag().getFirst(FieldKey.ALBUM));
609
 
        assertEquals(ALBUM_TEST_STRING2, ((ID3v23Tag) af.getTag()).getFirst(ID3v23FieldKey.ALBUM));
610
 
        assertEquals(1, af.getTag().getFields(FieldKey.ALBUM).size());
611
 
 
612
 
        //and deleteField it
613
 
        af.getTag().deleteField(FieldKey.ALBUM);
614
 
        af.commit();
615
 
        af = AudioFileIO.read(testFile);
616
 
        assertEquals("", af.getTag().getFirst(FieldKey.ALBUM));
617
 
        assertEquals("", af.getTag().getFirst(FieldKey.ALBUM));
618
 
        assertEquals("", ((ID3v23Tag) af.getTag()).getFirst(ID3v23FieldKey.ALBUM));
619
 
        assertEquals(0, af.getTag().getFields(FieldKey.ALBUM).size());
620
 
 
621
 
        //Test out the other basic fields
622
 
        //Year
623
 
        af.getTag().setField(FieldKey.YEAR,"1991");
624
 
        af.commit();
625
 
        af = AudioFileIO.read(testFile);
626
 
        assertEquals("1991", af.getTag().getFirst(FieldKey.YEAR));
627
 
        assertEquals("1991", af.getTag().getFirst(FieldKey.YEAR));
628
 
        assertEquals("1991", ((ID3v23Tag) af.getTag()).getFirst(ID3v23FieldKey.YEAR));
629
 
        assertEquals(1, af.getTag().getFields(FieldKey.YEAR).size());
630
 
        assertEquals(2, af.getTag().getFieldCount());
631
 
 
632
 
        //Title
633
 
        af.getTag().setField(FieldKey.TITLE,"Title");
634
 
        af.commit();
635
 
        af = AudioFileIO.read(testFile);
636
 
        assertEquals("Title", af.getTag().getFirst(FieldKey.TITLE));
637
 
        assertEquals("Title", af.getTag().getFirst(FieldKey.TITLE));
638
 
        assertEquals("Title", ((ID3v23Tag) af.getTag()).getFirst(ID3v23FieldKey.TITLE));
639
 
        assertEquals(1, af.getTag().getFields(FieldKey.TITLE).size());
640
 
        assertEquals(3, af.getTag().getFieldCount());
641
 
 
642
 
        //Comment, trickier because uses different framebody subclass to the ones above
643
 
        af.getTag().setField(FieldKey.COMMENT,"Comment");
644
 
        af.commit();
645
 
        af = AudioFileIO.read(testFile);
646
 
        assertEquals("Comment", af.getTag().getFirst(FieldKey.COMMENT));
647
 
        assertEquals("Comment", ((ID3v23Tag) af.getTag()).getFirst(ID3v23FieldKey.COMMENT));
648
 
        assertEquals(1, af.getTag().getFields(FieldKey.COMMENT).size());
649
 
        assertEquals(4, af.getTag().getFieldCount());
650
 
 
651
 
        //Genre
652
 
        //TODO only one genre frame allowed, but that can contain multiple GENRE values, currently
653
 
        //must parse as one genre e.g 34 67
654
 
        af.getTag().setField(FieldKey.GENRE,"CustomGenre");
655
 
        af.commit();
656
 
        af = AudioFileIO.read(testFile);
657
 
        assertEquals("CustomGenre", af.getTag().getFirst(FieldKey.GENRE));
658
 
        assertEquals("CustomGenre", ((ID3v23Tag) af.getTag()).getFirst(ID3v23FieldKey.GENRE));
659
 
        assertEquals(1, af.getTag().getFields(FieldKey.GENRE).size());
660
 
        assertEquals(5, af.getTag().getFieldCount());
661
 
 
662
 
 
663
 
        //Track
664
 
        af.getTag().setField(FieldKey.TRACK,"7");
665
 
        af.getTag().setField(af.getTag().createField(FieldKey.TRACK_TOTAL, "11"));
666
 
        assertEquals("7",af.getTag().getFirst(FieldKey.TRACK));
667
 
        assertEquals("11",af.getTag().getFirst(FieldKey.TRACK_TOTAL));
668
 
 
669
 
        af.commit();
670
 
        af = AudioFileIO.read(testFile);
671
 
        assertEquals("7", af.getTag().getFirst(FieldKey.TRACK));
672
 
        assertEquals("7", af.getTag().getFirst(FieldKey.TRACK));
673
 
        assertEquals("7", ((ID3v23Tag) af.getTag()).getFirst(ID3v23FieldKey.TRACK));
674
 
        assertEquals(1, af.getTag().getFields(FieldKey.TRACK).size());
675
 
        assertEquals(6, af.getTag().getFieldCount());
676
 
 
677
 
        assertEquals("7",af.getTag().getFirst(FieldKey.TRACK));
678
 
        
679
 
        //AmazonId also testing utf encoding here
680
 
        //This is one of many fields that uses the TXXX frame, the logic is more complicated
681
 
        af.getTag().setField(af.getTag().createField(FieldKey.AMAZON_ID, "asin123456" + "\u01ff"));
682
 
        af.commit();
683
 
        af = AudioFileIO.read(testFile);
684
 
        assertEquals("asin123456" + "\u01ff", af.getTag().getFirst(FieldKey.AMAZON_ID));
685
 
        assertEquals("asin123456" + "\u01ff", ((ID3v23Tag) af.getTag()).getFirst(ID3v23FieldKey.AMAZON_ID));
686
 
        assertEquals(1, af.getTag().getFields(FieldKey.AMAZON_ID).size());
687
 
        assertEquals(7, af.getTag().getFieldCount());
688
 
 
689
 
         //Mood
690
 
        af.getTag().setField(af.getTag().createField(FieldKey.MOOD, "mood"));
691
 
        af.commit();
692
 
        af = AudioFileIO.read(testFile);
693
 
        assertEquals("mood", af.getTag().getFirst(FieldKey.MOOD));
694
 
        //Now deleteField field
695
 
        af.getTag().deleteField(FieldKey.MOOD);
696
 
        af.commit();
697
 
        af = AudioFileIO.read(testFile);
698
 
 
699
 
        assertEquals("7",af.getTag().getFirst(FieldKey.TRACK));
700
 
 
701
 
        //Track Total
702
 
        af.getTag().setField(af.getTag().createField(FieldKey.TRACK_TOTAL, "11"));
703
 
        assertEquals("11",af.getTag().getFirst(FieldKey.TRACK_TOTAL));
704
 
        
705
 
        //Now addField another different field that also uses a TXXX frame
706
 
        af.getTag().setField(af.getTag().createField(FieldKey.MUSICIP_ID, "musicip_id"));
707
 
        af.commit();
708
 
        af = AudioFileIO.read(testFile);
709
 
        assertEquals(2, ((List) ((ID3v23Tag) af.getTag()).getFrame("TXXX")).size());
710
 
        assertEquals("musicip_id", af.getTag().getFirst(FieldKey.MUSICIP_ID));
711
 
        assertEquals("musicip_id", ((ID3v23Tag) af.getTag()).getFirst(ID3v23FieldKey.MUSICIP_ID));
712
 
        assertEquals(1, af.getTag().getFields(FieldKey.MUSICIP_ID).size());
713
 
        assertEquals("asin123456" + "\u01ff", af.getTag().getFirst(FieldKey.AMAZON_ID));
714
 
        assertEquals("7",af.getTag().getFirst(FieldKey.TRACK));
715
 
        assertEquals(8, af.getTag().getFieldCount());
716
 
        assertEquals("11",af.getTag().getFirst(FieldKey.TRACK_TOTAL));
717
 
        assertEquals("7",((ID3v23Tag)af.getTag()).getFirst(ID3v23FieldKey.TRACK));
718
 
        assertEquals("11",((ID3v23Tag)af.getTag()).getFirst(ID3v23FieldKey.TRACK_TOTAL));
719
 
        
720
 
        //Now addField yet another different field that also uses a TXXX frame
721
 
        af.getTag().setField(af.getTag().createField(FieldKey.MUSICBRAINZ_RELEASEID, "releaseid"));
722
 
        af.commit();
723
 
        af = AudioFileIO.read(testFile);
724
 
        assertEquals(3, ((List) ((ID3v23Tag) af.getTag()).getFrame("TXXX")).size());
725
 
        assertEquals("musicip_id", af.getTag().getFirst(FieldKey.MUSICIP_ID));
726
 
        assertEquals("releaseid", af.getTag().getFirst(FieldKey.MUSICBRAINZ_RELEASEID));
727
 
        assertEquals("asin123456" + "\u01ff", af.getTag().getFirst(FieldKey.AMAZON_ID));
728
 
        assertEquals(1, af.getTag().getFields(FieldKey.MUSICIP_ID).size());
729
 
        assertEquals(1, af.getTag().getFields(FieldKey.AMAZON_ID).size());
730
 
        assertEquals(1, af.getTag().getFields(FieldKey.MUSICBRAINZ_RELEASEID).size());
731
 
        assertEquals(9, af.getTag().getFieldCount());
732
 
 
733
 
        //Now deleteField field
734
 
        af.getTag().deleteField(FieldKey.MUSICBRAINZ_RELEASEID);
735
 
        af.commit();
736
 
        af = AudioFileIO.read(testFile);
737
 
        assertEquals(2, ((List) ((ID3v23Tag) af.getTag()).getFrame("TXXX")).size());
738
 
        assertEquals(1, af.getTag().getFields(FieldKey.MUSICIP_ID).size());
739
 
        assertEquals(1, af.getTag().getFields(FieldKey.AMAZON_ID).size());
740
 
        assertEquals(8, af.getTag().getFieldCount());
741
 
 
742
 
        //Cover Art:invalid way to do it
743
 
        try
744
 
        {
745
 
            af.getTag().setField(af.getTag().createField(FieldKey.COVER_ART, "coverart"));
746
 
        }
747
 
        catch (java.lang.UnsupportedOperationException uoe)
748
 
        {
749
 
            e = uoe;
750
 
        }
751
 
        assertTrue(e instanceof UnsupportedOperationException);
752
 
 
753
 
        //Add new image correctly
754
 
        RandomAccessFile imageFile = new RandomAccessFile(new File("testdata", "coverart.png"), "r");
755
 
        byte[] imagedata = new byte[(int) imageFile.length()];
756
 
        imageFile.read(imagedata);
757
 
        af.getTag().addField(tag.createArtworkField(imagedata, "image/png"));
758
 
        af.commit();
759
 
        af = AudioFileIO.read(testFile);
760
 
        assertEquals(1, af.getTag().getFields(FieldKey.COVER_ART).size());
761
 
        assertEquals(9, af.getTag().getFieldCount());
762
 
 
763
 
        //Add another image correctly
764
 
        imageFile = new RandomAccessFile(new File("testdata", "coverart_small.png"), "r");
765
 
        imagedata = new byte[(int) imageFile.length()];
766
 
        imageFile.read(imagedata);
767
 
        af.getTag().addField(tag.createArtworkField(imagedata, "image/png"));
768
 
        af.commit();
769
 
        af = AudioFileIO.read(testFile);
770
 
        assertEquals(2, af.getTag().getFields(FieldKey.COVER_ART).size());
771
 
        assertEquals(10, af.getTag().getFieldCount());
772
 
 
773
 
 
774
 
    }
775
 
 
776
 
    public void testNewInterfaceBasicReadandWriteID3v22() throws Exception
777
 
    {
778
 
        Exception e = null;
779
 
        File testFile = AbstractTestCase.copyAudioToTmp("testV1.mp3", new File("testnewIntId3v22.mp3"));
780
 
        MP3File mp3File = new MP3File(testFile);
781
 
 
782
 
        //Has no tag at this point
783
 
        assertFalse(mp3File.hasID3v1Tag());
784
 
        assertFalse(mp3File.hasID3v2Tag());
785
 
 
786
 
        //Create v1 tag (old method)
787
 
        ID3v11Tag v1tag = new ID3v11Tag();
788
 
        v1tag.setField(FieldKey.ARTIST,V1_ARTIST);
789
 
        v1tag.setField(FieldKey.ALBUM,"V1ALBUM");
790
 
        mp3File.setID3v1Tag(v1tag);
791
 
        mp3File.save();
792
 
 
793
 
        //Has only v1 tag at this point
794
 
        assertTrue(mp3File.hasID3v1Tag());
795
 
        assertFalse(mp3File.hasID3v2Tag());
796
 
 
797
 
        //Read back artist (new method ,v1)
798
 
        AudioFile af = AudioFileIO.read(testFile);
799
 
        assertEquals(V1_ARTIST, af.getTag().getFirst(FieldKey.ARTIST));
800
 
        assertEquals(V1_ARTIST, af.getTag().getFirst(FieldKey.ARTIST));
801
 
        assertEquals(V1_ARTIST, af.getTag().getFirst(FieldKey.ARTIST));
802
 
 
803
 
        //Add artist frame (old method)
804
 
        ID3v22Tag tag = new ID3v22Tag();
805
 
        ID3v22Frame frame = new ID3v22Frame(ID3v22Frames.FRAME_ID_V2_ARTIST);
806
 
        ((FrameBodyTPE1) frame.getBody()).setText(FrameBodyTPE1Test.TPE1_TEST_STRING);
807
 
        tag.setFrame(frame);
808
 
        mp3File.setID3v2TagOnly(tag);
809
 
        mp3File.save();
810
 
 
811
 
        //Has v1 and v2 tag at this point
812
 
        assertTrue(mp3File.hasID3v1Tag());
813
 
        assertTrue(mp3File.hasID3v2Tag());
814
 
 
815
 
        //Read back artist (new method ,v1 value overrriden by v2 method)
816
 
        af = AudioFileIO.read(testFile);
817
 
        assertEquals(FrameBodyTPE1Test.TPE1_TEST_STRING, af.getTag().getFirst(FieldKey.ARTIST));
818
 
        assertEquals(FrameBodyTPE1Test.TPE1_TEST_STRING, af.getTag().getFirst(FieldKey.ARTIST));
819
 
        assertEquals(FrameBodyTPE1Test.TPE1_TEST_STRING, ((ID3v22Tag) af.getTag()).getFirst(ID3v22FieldKey.ARTIST));
820
 
        //.... but v1 value is still there
821
 
        assertEquals(V1_ARTIST, ((MP3File) af).getID3v1Tag().getFirst(FieldKey.ARTIST));
822
 
        //Write album ( new method)
823
 
        af.getTag().setField(FieldKey.ALBUM,ALBUM_TEST_STRING);
824
 
        assertEquals(ALBUM_TEST_STRING, af.getTag().getFirst(FieldKey.ALBUM));
825
 
        assertEquals(1, af.getTag().getFields(FieldKey.ALBUM).size());
826
 
 
827
 
        af.commit();
828
 
 
829
 
        //Read back album (new method)
830
 
        af = AudioFileIO.read(testFile);
831
 
        assertEquals(ALBUM_TEST_STRING, af.getTag().getFirst(FieldKey.ALBUM));
832
 
        assertEquals(ALBUM_TEST_STRING, af.getTag().getFirst(FieldKey.ALBUM));
833
 
        assertEquals(ALBUM_TEST_STRING, ((ID3v22Tag) af.getTag()).getFirst(ID3v22FieldKey.ALBUM));
834
 
        assertEquals(1, af.getTag().getFields(FieldKey.ALBUM).size());
835
 
 
836
 
        //Read back album (old method)
837
 
        AbstractID3v2Frame checkframe = (AbstractID3v2Frame) ((MP3File) af).getID3v2Tag().getFrame(ID3v22Frames.FRAME_ID_V2_ALBUM);
838
 
        assertEquals(ALBUM_TEST_STRING, ((FrameBodyTALB) checkframe.getBody()).getText());
839
 
 
840
 
        //Should only be allowed to addField one album, there is no multi value support for it
841
 
        af.getTag().addField(FieldKey.ALBUM,ALBUM_TEST_STRING2);
842
 
        af.commit();
843
 
        af = AudioFileIO.read(testFile);
844
 
        assertEquals(ALBUM_TEST_STRING, af.getTag().getFirst(FieldKey.ALBUM));
845
 
        assertEquals(ALBUM_TEST_STRING, af.getTag().getFirst(FieldKey.ALBUM));
846
 
        assertEquals(ALBUM_TEST_STRING, ((ID3v22Tag) af.getTag()).getFirst(ID3v22FieldKey.ALBUM));
847
 
        assertEquals(1, af.getTag().getFields(FieldKey.ALBUM).size());
848
 
 
849
 
        //But can replace existing value
850
 
        af.getTag().setField(FieldKey.ALBUM,ALBUM_TEST_STRING2);
851
 
        af.commit();
852
 
        af = AudioFileIO.read(testFile);
853
 
        assertEquals(ALBUM_TEST_STRING2, af.getTag().getFirst(FieldKey.ALBUM));
854
 
        assertEquals(ALBUM_TEST_STRING2, af.getTag().getFirst(FieldKey.ALBUM));
855
 
        assertEquals(ALBUM_TEST_STRING2, ((ID3v22Tag) af.getTag()).getFirst(ID3v22FieldKey.ALBUM));
856
 
        assertEquals(1,af.getTag().getFields(FieldKey.ALBUM).size());
857
 
 
858
 
        //and deleteField it
859
 
        af.getTag().deleteField(FieldKey.ALBUM);
860
 
        af.commit();
861
 
        af = AudioFileIO.read(testFile);
862
 
        assertEquals("", af.getTag().getFirst(FieldKey.ALBUM));
863
 
        assertEquals("", af.getTag().getFirst(FieldKey.ALBUM));
864
 
        assertEquals("", ((ID3v22Tag) af.getTag()).getFirst(ID3v22FieldKey.ALBUM));
865
 
        assertEquals(0, af.getTag().getFields(FieldKey.ALBUM).size());
866
 
 
867
 
        //Test out the other basic fields
868
 
        //Year
869
 
        af.getTag().setField(FieldKey.YEAR,"1991");
870
 
        af.commit();
871
 
        af = AudioFileIO.read(testFile);
872
 
        assertEquals("1991", af.getTag().getFirst(FieldKey.YEAR));
873
 
        assertEquals("1991", af.getTag().getFirst(FieldKey.YEAR));
874
 
        assertEquals("1991", ((ID3v22Tag) af.getTag()).getFirst(ID3v22FieldKey.YEAR));
875
 
        assertEquals(1, af.getTag().getFields(FieldKey.YEAR).size());
876
 
        assertEquals(2, af.getTag().getFieldCount());
877
 
 
878
 
        //Title
879
 
        af.getTag().setField(FieldKey.TITLE,"Title");
880
 
        af.commit();
881
 
        af = AudioFileIO.read(testFile);
882
 
        assertEquals("Title", af.getTag().getFirst(FieldKey.TITLE));
883
 
        assertEquals("Title", af.getTag().getFirst(FieldKey.TITLE));
884
 
        assertEquals("Title", ((ID3v22Tag) af.getTag()).getFirst(ID3v22FieldKey.TITLE));
885
 
        assertEquals(1, af.getTag().getFields(FieldKey.TITLE).size());
886
 
        assertEquals(3, af.getTag().getFieldCount());
887
 
 
888
 
        //Comment, trickier because uses different framebody subclass to the ones above
889
 
        af.getTag().setField(FieldKey.COMMENT,"Comment");
890
 
        af.commit();
891
 
        af = AudioFileIO.read(testFile);
892
 
        assertEquals("Comment", af.getTag().getFirst(FieldKey.COMMENT));
893
 
        assertEquals("Comment", af.getTag().getFirst(FieldKey.COMMENT));
894
 
        assertEquals("Comment", ((ID3v22Tag) af.getTag()).getFirst(ID3v22FieldKey.COMMENT));
895
 
        assertEquals(1, af.getTag().getFields(FieldKey.COMMENT).size());
896
 
        assertEquals(4, af.getTag().getFieldCount());
897
 
 
898
 
        //Genre
899
 
        //TODO only one genre frame allowed, but that can contain multiple GENRE values, currently
900
 
        //must parse as one genre e.g 34 67
901
 
        af.getTag().setField(FieldKey.GENRE,"CustomGenre");
902
 
        af.commit();
903
 
        af = AudioFileIO.read(testFile);
904
 
        assertEquals("CustomGenre", af.getTag().getFirst(FieldKey.GENRE));
905
 
        assertEquals("CustomGenre", af.getTag().getFirst(FieldKey.GENRE));
906
 
        assertEquals("CustomGenre", ((ID3v22Tag) af.getTag()).getFirst(ID3v22FieldKey.GENRE));
907
 
        assertEquals(1, af.getTag().getFields(FieldKey.GENRE).size());
908
 
        assertEquals(5, af.getTag().getFieldCount());
909
 
 
910
 
        //Track
911
 
        af.getTag().setField(FieldKey.TRACK,"7");
912
 
        af.getTag().setField(af.getTag().createField(FieldKey.TRACK_TOTAL, "11"));
913
 
        assertEquals("7",af.getTag().getFirst(FieldKey.TRACK));
914
 
        assertEquals("11",af.getTag().getFirst(FieldKey.TRACK_TOTAL));
915
 
        af.commit();
916
 
        af = AudioFileIO.read(testFile);
917
 
        assertEquals("7", af.getTag().getFirst(FieldKey.TRACK));
918
 
        assertEquals("7", af.getTag().getFirst(FieldKey.TRACK));
919
 
        assertEquals("7", ((ID3v22Tag) af.getTag()).getFirst(ID3v22FieldKey.TRACK));
920
 
        assertEquals("11",af.getTag().getFirst(FieldKey.TRACK_TOTAL));
921
 
        assertEquals(1, af.getTag().getFields(FieldKey.TRACK).size());
922
 
        assertEquals(1, af.getTag().getFields(FieldKey.TRACK).size());
923
 
        assertEquals(6, af.getTag().getFieldCount());
924
 
 
925
 
        //AmazonId
926
 
        //This is one of many fields that uses the TXXX frame, the logic is more complicated
927
 
        af.getTag().setField(af.getTag().createField(FieldKey.AMAZON_ID, "asin123456" + "\u01ff"));
928
 
        af.commit();
929
 
        af = AudioFileIO.read(testFile);
930
 
 
931
 
        //Mood
932
 
        af.getTag().setField(af.getTag().createField(FieldKey.MOOD, "mood"));
933
 
        af.commit();
934
 
        af = AudioFileIO.read(testFile);
935
 
         assertEquals("mood", af.getTag().getFirst(FieldKey.MOOD));
936
 
        //Now deleteField field
937
 
        af.getTag().deleteField(FieldKey.MOOD);
938
 
        af.commit();
939
 
        af = AudioFileIO.read(testFile);
940
 
 
941
 
        assertEquals("asin123456" + "\u01ff", af.getTag().getFirst(FieldKey.AMAZON_ID));
942
 
        assertEquals("asin123456" + "\u01ff", ((ID3v22Tag) af.getTag()).getFirst(ID3v22FieldKey.AMAZON_ID));
943
 
        assertEquals(1, af.getTag().getFields(FieldKey.AMAZON_ID).size());
944
 
        assertEquals(7, af.getTag().getFieldCount());
945
 
 
946
 
        //Now addField another different field that also uses a TXX frame
947
 
        af.getTag().setField(af.getTag().createField(FieldKey.MUSICIP_ID, "musicip_id"));
948
 
        af.commit();
949
 
        af = AudioFileIO.read(testFile);
950
 
        assertEquals(2, ((List) ((ID3v22Tag) af.getTag()).getFrame("TXX")).size());
951
 
        assertEquals("musicip_id", af.getTag().getFirst(FieldKey.MUSICIP_ID));
952
 
        assertEquals("musicip_id", ((ID3v22Tag) af.getTag()).getFirst(ID3v22FieldKey.MUSICIP_ID));
953
 
        assertEquals(1, af.getTag().getFields(FieldKey.MUSICIP_ID).size());
954
 
        assertEquals("asin123456" + "\u01ff", af.getTag().getFirst(FieldKey.AMAZON_ID));
955
 
        assertEquals(8, af.getTag().getFieldCount());
956
 
 
957
 
        //Now addField yet another different field that also uses a TXX frame
958
 
        af.getTag().setField(af.getTag().createField(FieldKey.MUSICBRAINZ_RELEASEID, "releaseid"));
959
 
        af.commit();
960
 
        af = AudioFileIO.read(testFile);
961
 
        assertEquals(3, ((List) ((ID3v22Tag) af.getTag()).getFrame("TXX")).size());
962
 
        assertEquals("musicip_id", af.getTag().getFirst(FieldKey.MUSICIP_ID));
963
 
        assertEquals("releaseid", af.getTag().getFirst(FieldKey.MUSICBRAINZ_RELEASEID));
964
 
        assertEquals("asin123456" + "\u01ff", af.getTag().getFirst(FieldKey.AMAZON_ID));
965
 
        assertEquals(1, af.getTag().getFields(FieldKey.MUSICIP_ID).size());
966
 
        assertEquals(1, af.getTag().getFields(FieldKey.AMAZON_ID).size());
967
 
        assertEquals(1, af.getTag().getFields(FieldKey.MUSICBRAINZ_RELEASEID).size());
968
 
        assertEquals(9, af.getTag().getFieldCount());
969
 
 
970
 
        //Now deleteField field
971
 
        af.getTag().deleteField(FieldKey.MUSICBRAINZ_RELEASEID);
972
 
        af.commit();
973
 
        af = AudioFileIO.read(testFile);
974
 
        assertEquals(2, ((List) ((ID3v22Tag) af.getTag()).getFrame("TXX")).size());
975
 
        assertEquals(1, af.getTag().getFields(FieldKey.MUSICIP_ID).size());
976
 
        assertEquals(1, af.getTag().getFields(FieldKey.AMAZON_ID).size());
977
 
        assertEquals(8, af.getTag().getFieldCount());
978
 
 
979
 
        //Cover Art:invalid way to do it
980
 
        try
981
 
        {
982
 
            af.getTag().setField(af.getTag().createField(FieldKey.COVER_ART, "coverart"));
983
 
        }
984
 
        catch (java.lang.UnsupportedOperationException uoe)
985
 
        {
986
 
            e = uoe;
987
 
        }
988
 
        assertTrue(e instanceof UnsupportedOperationException);
989
 
 
990
 
        //Add new image correctly
991
 
        RandomAccessFile imageFile = new RandomAccessFile(new File("testdata", "coverart.png"), "r");
992
 
        byte[] imagedata = new byte[(int) imageFile.length()];
993
 
        imageFile.read(imagedata);
994
 
        af.getTag().addField(tag.createArtworkField(imagedata, "image/png"));
995
 
        af.commit();
996
 
        af = AudioFileIO.read(testFile);
997
 
        assertEquals(1, af.getTag().getFields(FieldKey.COVER_ART).size());
998
 
        assertEquals(9, af.getTag().getFieldCount());
999
 
 
1000
 
        //Add another image correctly
1001
 
        imageFile = new RandomAccessFile(new File("testdata", "coverart_small.png"), "r");
1002
 
        imagedata = new byte[(int) imageFile.length()];
1003
 
        imageFile.read(imagedata);
1004
 
        af.getTag().addField(tag.createArtworkField(imagedata, "image/png"));
1005
 
        af.commit();
1006
 
        af = AudioFileIO.read(testFile);
1007
 
        assertEquals(2, af.getTag().getFields(FieldKey.COVER_ART).size());
1008
 
        assertEquals(10, af.getTag().getFieldCount());
1009
 
    }
1010
 
 
1011
 
    /**
1012
 
     * Test how adding multiple frameswith new interface  of same type is is handled
1013
 
     *
1014
 
     * @throws Exception
1015
 
     */
1016
 
    public void testSettingMultipleFramesofSameType() throws Exception
1017
 
    {
1018
 
        Exception e = null;
1019
 
        File testFile = AbstractTestCase.copyAudioToTmp("testV1.mp3", new File("testSetMultiple.mp3"));
1020
 
        AudioFile af = AudioFileIO.read(testFile);
1021
 
        MP3File mp3File = (MP3File) af;
1022
 
        ID3v24Tag tag = new ID3v24Tag();
1023
 
        ID3v24Frame frame = new ID3v24Frame(ID3v24Frames.FRAME_ID_COMMENT);
1024
 
        ((FrameBodyCOMM) frame.getBody()).setText("Comment");
1025
 
        tag.setFrame(frame);
1026
 
        mp3File.setID3v2TagOnly(tag);
1027
 
        mp3File.save();
1028
 
        af = AudioFileIO.read(testFile);
1029
 
        mp3File = (MP3File) af;
1030
 
 
1031
 
        //COMM
1032
 
        {
1033
 
            ID3v24Frame commentFrame = (ID3v24Frame) ((ID3v24Tag) af.getTag()).getFrame("COMM");
1034
 
            FrameBodyCOMM fb = (FrameBodyCOMM) commentFrame.getBody();
1035
 
            assertEquals("", fb.getDescription());
1036
 
            assertEquals("Comment", fb.getText());
1037
 
            //Change description, cant do this with common interface
1038
 
            fb.setDescription("test");
1039
 
            //Because has different description the following setField will addField another comment rather than overwriting the first one
1040
 
            af.getTag().setField(FieldKey.COMMENT,"Comment2");
1041
 
            assertEquals(2, af.getTag().getFields(FieldKey.COMMENT).size());
1042
 
            //Add third Comment
1043
 
            List<TagField> comments = af.getTag().getFields(FieldKey.COMMENT);
1044
 
            ((FrameBodyCOMM) ((ID3v24Frame) comments.get(1)).getBody()).setDescription("test2");
1045
 
            af.getTag().setField(FieldKey.COMMENT,"Comment3");
1046
 
            af.commit();
1047
 
            af = AudioFileIO.read(testFile);
1048
 
            assertEquals(3, af.getTag().getFields(FieldKey.COMMENT).size());
1049
 
 
1050
 
            //Add fourth Comment (but duplicate key - so overwrites 3rd comment)
1051
 
            af.getTag().setField(FieldKey.COMMENT,"Comment4");
1052
 
            af.commit();
1053
 
            af = AudioFileIO.read(testFile);
1054
 
            assertEquals(3, af.getTag().getFields(FieldKey.COMMENT).size());
1055
 
 
1056
 
            //Add comment using generic call
1057
 
            af.getTag().setField(af.getTag().createField(FieldKey.COMMENT, "abcdef-ghijklmn"));
1058
 
 
1059
 
            //Remove all Comment tags
1060
 
            af.getTag().deleteField(FieldKey.COMMENT);
1061
 
            assertEquals(0, af.getTag().getFields(FieldKey.COMMENT).size());
1062
 
 
1063
 
            //Add first one back in
1064
 
            af.getTag().setField(FieldKey.COMMENT,"Comment");
1065
 
            af.commit();
1066
 
            af = AudioFileIO.read(testFile);
1067
 
            assertEquals(1, af.getTag().getFields(FieldKey.COMMENT).size());
1068
 
            assertEquals(1, af.getTag().getFieldCount());
1069
 
        }
1070
 
 
1071
 
        //TXXX
1072
 
        {
1073
 
            tag = (ID3v24Tag) af.getTag();
1074
 
            frame = new ID3v24Frame(ID3v24Frames.FRAME_ID_USER_DEFINED_INFO);
1075
 
            ((FrameBodyTXXX) frame.getBody()).setText("UserDefined");
1076
 
            tag.setFrame(frame);
1077
 
            ID3v24Frame txxxFrame = (ID3v24Frame) tag.getFrame("TXXX");
1078
 
            FrameBodyTXXX fb = (FrameBodyTXXX) txxxFrame.getBody();
1079
 
            assertEquals("", fb.getDescription());
1080
 
            assertEquals("UserDefined", fb.getText());
1081
 
            //Change description, cant do this with common interface
1082
 
            fb.setDescription("test");
1083
 
            //Because has different description the following setField will addField another txxx rather than overwriting the first one
1084
 
            af.getTag().setField(af.getTag().createField(FieldKey.MUSICBRAINZ_ARTISTID, "abcdef-ghijklmn"));
1085
 
            assertEquals(2, ((List) tag.getFrame("TXXX")).size());
1086
 
            //Now adding TXXX with same id so gets overwritten
1087
 
            af.getTag().setField(af.getTag().createField(FieldKey.MUSICBRAINZ_ARTISTID, "abcfffff"));
1088
 
            assertEquals(2, ((List) tag.getFrame("TXXX")).size());
1089
 
 
1090
 
            //Try deleting some of these
1091
 
            tag.removeFrameOfType("TXXX");
1092
 
            assertNull(tag.getFrame("TXXX"));
1093
 
 
1094
 
        }
1095
 
 
1096
 
        //UFID
1097
 
        {
1098
 
            tag = (ID3v24Tag) af.getTag();
1099
 
            frame = new ID3v24Frame(ID3v24Frames.FRAME_ID_UNIQUE_FILE_ID);
1100
 
            ((FrameBodyUFID) frame.getBody()).setOwner("owner");
1101
 
            tag.setFrame(frame);
1102
 
            ID3v24Frame ufidFrame = (ID3v24Frame) tag.getFrame("UFID");
1103
 
            FrameBodyUFID fb = (FrameBodyUFID) ufidFrame.getBody();
1104
 
            assertEquals("owner", fb.getOwner());
1105
 
 
1106
 
            //Because has different owner the following setField will addField another ufid rather than overwriting the first one
1107
 
            af.getTag().setField(af.getTag().createField(FieldKey.MUSICBRAINZ_TRACK_ID, "abcdef-ghijklmn"));
1108
 
            assertEquals(2, ((List) tag.getFrame("UFID")).size());
1109
 
            //Now adding UFID with same owner so gets overwritten
1110
 
            af.getTag().setField(af.getTag().createField(FieldKey.MUSICBRAINZ_TRACK_ID, "abcfffff"));
1111
 
            assertEquals(2, ((List) tag.getFrame("UFID")).size());
1112
 
 
1113
 
            //Try deleting some of these
1114
 
            tag.removeFrame("UFID");
1115
 
            assertNull(tag.getFrame("UFID"));
1116
 
        }
1117
 
 
1118
 
        //ULST
1119
 
        {
1120
 
            tag = (ID3v24Tag) af.getTag();
1121
 
            frame = new ID3v24Frame(ID3v24Frames.FRAME_ID_UNSYNC_LYRICS);
1122
 
            ((FrameBodyUSLT) frame.getBody()).setDescription("lyrics1");
1123
 
            tag.setFrame(frame);
1124
 
            ID3v24Frame usltFrame = (ID3v24Frame) tag.getFrame("USLT");
1125
 
            FrameBodyUSLT fb = (FrameBodyUSLT) usltFrame.getBody();
1126
 
            assertEquals("lyrics1", fb.getDescription());
1127
 
 
1128
 
            //Because has different desc the following setField will addField another uslt rather than overwriting the first one
1129
 
            af.getTag().setField(af.getTag().createField(FieldKey.LYRICS, "abcdef-ghijklmn"));
1130
 
            assertEquals(2, ((List) tag.getFrame("USLT")).size());
1131
 
            assertEquals(2, af.getTag().getFields(FieldKey.LYRICS).size());
1132
 
            frame = (ID3v24Frame) ((List) tag.getFrame("USLT")).get(1);
1133
 
            assertEquals("", ((FrameBodyUSLT) frame.getBody()).getDescription());
1134
 
            //Now adding USLT with same description so gets overwritten
1135
 
            af.getTag().setField(af.getTag().createField(FieldKey.LYRICS, "abcfffff"));
1136
 
            assertEquals(2, ((List) tag.getFrame("USLT")).size());
1137
 
            assertEquals(2, af.getTag().getFields(FieldKey.LYRICS).size());
1138
 
 
1139
 
        }
1140
 
 
1141
 
        //POPM TODO not a supported FieldKey yet
1142
 
        {
1143
 
            tag = (ID3v24Tag) af.getTag();
1144
 
            frame = new ID3v24Frame(ID3v24Frames.FRAME_ID_POPULARIMETER);
1145
 
            ((FrameBodyPOPM) frame.getBody()).setEmailToUser("paultaylor@jthink.net");
1146
 
            tag.setFrame(frame);
1147
 
            ID3v24Frame popmFrame = (ID3v24Frame) tag.getFrame("POPM");
1148
 
            FrameBodyPOPM fb = (FrameBodyPOPM) popmFrame.getBody();
1149
 
            assertEquals("paultaylor@jthink.net", fb.getEmailToUser());
1150
 
        }
1151
 
 
1152
 
    }
1153
 
 
1154
 
    /**
1155
 
     * Test code copes with reading dodgy ID3Tag , header appears ok but gap between header and tag data
1156
 
     *
1157
 
     * @throws Exception
1158
 
     */
1159
 
    public void testNewInterfaceDodgyMp3() throws Exception
1160
 
    {
1161
 
        File orig = new File("testdata", "test26.mp3");
1162
 
        if (!orig.isFile())
1163
 
        {
1164
 
            return;
1165
 
        }
1166
 
 
1167
 
        Exception e = null;
1168
 
        File testFile = AbstractTestCase.copyAudioToTmp("test26.mp3");
1169
 
        MP3File mp3File = new MP3File(testFile);
1170
 
 
1171
 
        //Has no tag at this point
1172
 
        assertTrue(mp3File.hasID3v1Tag());
1173
 
        assertTrue(mp3File.hasID3v2Tag());
1174
 
        assertEquals("Personality Goes A Long Way", mp3File.getID3v1Tag().getFirst(FieldKey.TITLE));
1175
 
        assertEquals(0, mp3File.getID3v2Tag().getFieldCount());
1176
 
        assertFalse(((ID3v23Tag) mp3File.getID3v2Tag()).compression);
1177
 
        assertFalse(((ID3v23Tag) mp3File.getID3v2Tag()).experimental);
1178
 
        assertFalse(((ID3v23Tag) mp3File.getID3v2Tag()).extended);
1179
 
        //assertEquals("Personality Goes A Long Way",mp3File.getID3v2Tag().getFirst(FieldKey.TITLE));
1180
 
    }
1181
 
 
1182
 
    public void testIterator() throws Exception
1183
 
    {
1184
 
        File orig = new File("testdata", "test26.mp3");
1185
 
        if (!orig.isFile())
1186
 
        {
1187
 
            return;
1188
 
        }
1189
 
 
1190
 
        Exception e = null;
1191
 
        File testFile = AbstractTestCase.copyAudioToTmp("test26.mp3");
1192
 
        MP3File mp3File = new MP3File(testFile);
1193
 
 
1194
 
 
1195
 
        assertEquals(0, mp3File.getID3v2Tag().getFieldCount());
1196
 
        Iterator<TagField> i = mp3File.getID3v2Tag().getFields();
1197
 
        assertFalse(i.hasNext());
1198
 
        try
1199
 
        {
1200
 
            i.next();
1201
 
        }
1202
 
        catch(Exception ex)
1203
 
        {
1204
 
            e=ex;
1205
 
        }
1206
 
        assertTrue(e instanceof NoSuchElementException);
1207
 
 
1208
 
        mp3File.getID3v2Tag().addField(FieldKey.ALBUM,"album");
1209
 
        assertEquals(1, mp3File.getID3v2Tag().getFieldCount());
1210
 
        i = mp3File.getID3v2Tag().getFields();
1211
 
 
1212
 
        //Should be able to iterate without actually having to call isNext() first
1213
 
        i.next();
1214
 
 
1215
 
        //Should be able to call hasNext() without it having any effect
1216
 
        i = mp3File.getID3v2Tag().getFields();
1217
 
        assertTrue(i.hasNext());
1218
 
        Object o = i.next();
1219
 
        assertTrue( o instanceof ID3v23Frame);
1220
 
        assertEquals("album",((AbstractFrameBodyTextInfo)(((ID3v23Frame)o).getBody())).getFirstTextValue());
1221
 
 
1222
 
        try
1223
 
        {
1224
 
            i.next();
1225
 
        }
1226
 
        catch(Exception ex)
1227
 
        {
1228
 
            e=ex;
1229
 
        }
1230
 
        assertTrue(e instanceof NoSuchElementException);
1231
 
        assertFalse(i.hasNext());
1232
 
 
1233
 
        //Empty frame map and force adding of empty list
1234
 
        mp3File.getID3v2Tag().frameMap.clear();
1235
 
        mp3File.getID3v2Tag().frameMap.put("TXXX",new ArrayList());
1236
 
        assertEquals(0,mp3File.getID3v2Tag().getFieldCount());
1237
 
 
1238
 
        //Issue #236
1239
 
        //i = mp3File.getID3v2Tag().getFields();
1240
 
        //assertFalse(i.hasNext());
1241
 
    }
1242
 
 
1243
 
    /**
1244
 
     * Currently genres are written to and from v2 tag as is, the decoding from genre number to string has to be done manually
1245
 
     */
1246
 
    public void testGenres()
1247
 
    {
1248
 
        Exception ex = null;
1249
 
        try
1250
 
        {
1251
 
            File testFile = AbstractTestCase.copyAudioToTmp("testV1.mp3", new File("testBasicWrite.mp3"));
1252
 
            org.jaudiotagger.audio.AudioFile audioFile = org.jaudiotagger.audio.AudioFileIO.read(testFile);
1253
 
            org.jaudiotagger.tag.Tag newTag = audioFile.getTag();
1254
 
            assertTrue(newTag == null);
1255
 
            if (audioFile.getTag() == null)
1256
 
            {
1257
 
                audioFile.setTag(new ID3v23Tag());
1258
 
                newTag = audioFile.getTag();
1259
 
            }
1260
 
 
1261
 
            //Write literal String
1262
 
            newTag.setField(FieldKey.GENRE,"Rock");
1263
 
            audioFile.commit();
1264
 
            audioFile = org.jaudiotagger.audio.AudioFileIO.read(testFile);
1265
 
            newTag = audioFile.getTag();
1266
 
            //..and read back
1267
 
            assertEquals("Rock", newTag.getFirst(FieldKey.GENRE));
1268
 
 
1269
 
            //Write Code
1270
 
            newTag.setField(FieldKey.GENRE,"(17)");
1271
 
            audioFile.commit();
1272
 
            audioFile = org.jaudiotagger.audio.AudioFileIO.read(testFile);
1273
 
            newTag = audioFile.getTag();
1274
 
            //..and read back
1275
 
            assertEquals("(17)", newTag.getFirst(FieldKey.GENRE));
1276
 
 
1277
 
        }
1278
 
        catch (Exception e)
1279
 
        {
1280
 
            ex = e;
1281
 
            ex.printStackTrace();
1282
 
        }
1283
 
        assertNull(ex);
1284
 
    }
1285
 
 
1286
 
    public void testRemoveFrameOfType()
1287
 
    {
1288
 
        File orig = new File("testdata", "test30.mp3");
1289
 
        if (!orig.isFile())
1290
 
        {
1291
 
            return;
1292
 
        }
1293
 
 
1294
 
        Exception exceptionCaught = null;
1295
 
        File testFile = AbstractTestCase.copyAudioToTmp("test30.mp3");
1296
 
        MP3File mp3file = null;
1297
 
        try
1298
 
        {
1299
 
            mp3file = new MP3File(testFile);
1300
 
            //deleteField multiple frames starting make change to file
1301
 
            ((ID3v24Tag) mp3file.getID3v2Tag()).removeFrameOfType("PRIV");
1302
 
 
1303
 
        }
1304
 
        catch (Exception e)
1305
 
        {
1306
 
            e.printStackTrace();
1307
 
            exceptionCaught = e;
1308
 
        }
1309
 
        assertNull(exceptionCaught);
1310
 
 
1311
 
 
1312
 
    }
1313
 
}
 
1
package org.jaudiotagger.tag.id3;
 
2
 
 
3
import junit.framework.Test;
 
4
import junit.framework.TestCase;
 
5
import junit.framework.TestSuite;
 
6
import org.jaudiotagger.AbstractTestCase;
 
7
import org.jaudiotagger.audio.AudioFile;
 
8
import org.jaudiotagger.audio.AudioFileIO;
 
9
import org.jaudiotagger.audio.mp3.MP3File;
 
10
import org.jaudiotagger.tag.FieldKey;
 
11
import org.jaudiotagger.tag.TagField;
 
12
import org.jaudiotagger.tag.TagOptionSingleton;
 
13
import org.jaudiotagger.tag.TagTextField;
 
14
import org.jaudiotagger.tag.datatype.DataTypes;
 
15
import org.jaudiotagger.tag.id3.framebody.*;
 
16
import org.jaudiotagger.tag.id3.valuepair.TextEncoding;
 
17
 
 
18
import javax.imageio.ImageIO;
 
19
import java.awt.image.BufferedImage;
 
20
import java.io.ByteArrayInputStream;
 
21
import java.io.File;
 
22
import java.io.RandomAccessFile;
 
23
import java.util.ArrayList;
 
24
import java.util.Iterator;
 
25
import java.util.List;
 
26
import java.util.NoSuchElementException;
 
27
 
 
28
/**
 
29
 * Testing retrofitting of entagged interfaces
 
30
 */
 
31
public class NewInterfaceTest extends TestCase
 
32
{
 
33
    private static final String V1_ARTIST = "V1ARTIST";
 
34
 
 
35
    public static final String ALBUM_TEST_STRING = "mellow gold";
 
36
    public static final String ALBUM_TEST_STRING2 = "odelay";
 
37
 
 
38
 
 
39
 
 
40
        /**
 
41
         *
 
42
         */
 
43
        protected void setUp()
 
44
        {
 
45
            TagOptionSingleton.getInstance().setToDefault();
 
46
        }
 
47
 
 
48
        /**
 
49
         *
 
50
         */
 
51
        protected void tearDown()
 
52
        {
 
53
        }
 
54
 
 
55
 
 
56
    /**
 
57
     * Constructor
 
58
     *
 
59
     * @param arg0
 
60
     */
 
61
    public NewInterfaceTest(String arg0)
 
62
    {
 
63
        super(arg0);
 
64
    }
 
65
 
 
66
    /**
 
67
     * Command line entrance.
 
68
     *
 
69
     * @param args
 
70
     */
 
71
    public static void main(String[] args)
 
72
    {
 
73
        junit.textui.TestRunner.run(suite());
 
74
    }
 
75
 
 
76
    /**
 
77
     * Builds the Test Suite.
 
78
     *
 
79
     * @return the Test Suite.
 
80
     */
 
81
    public static Test suite()
 
82
    {
 
83
        return new TestSuite(NewInterfaceTest.class);
 
84
    }
 
85
 
 
86
    public void testBasicWrite()
 
87
    {
 
88
        Exception ex = null;
 
89
        try
 
90
        {
 
91
            File testFile = AbstractTestCase.copyAudioToTmp("testV1.mp3", new File("testBasicWrite.mp3"));
 
92
            org.jaudiotagger.audio.AudioFile audioFile = org.jaudiotagger.audio.AudioFileIO.read(testFile);
 
93
            org.jaudiotagger.tag.Tag newTag = audioFile.getTag();
 
94
            if (audioFile.getTag() == null)
 
95
            {
 
96
                audioFile.setTag(new ID3v23Tag());
 
97
                newTag = audioFile.getTag();
 
98
            }
 
99
 
 
100
            newTag.setField(FieldKey.ALBUM,"album");
 
101
            newTag.setField(FieldKey.ARTIST,"artist");
 
102
            newTag.setField(FieldKey.COMMENT,"comment");
 
103
            newTag.setField(FieldKey.GENRE,"Rock");
 
104
            newTag.setField(FieldKey.TITLE,"title");
 
105
            newTag.setField(FieldKey.YEAR,"year");
 
106
            newTag.setField(FieldKey.TRACK,Integer.toString(1));
 
107
 
 
108
            assertEquals("album", newTag.getFirst(FieldKey.ALBUM));
 
109
            assertEquals("artist", newTag.getFirst(FieldKey.ARTIST));
 
110
            assertEquals("comment", newTag.getFirst(FieldKey.COMMENT));
 
111
            assertEquals("Rock", newTag.getFirst(FieldKey.GENRE));
 
112
            assertEquals("title", newTag.getFirst(FieldKey.TITLE));
 
113
            assertEquals("year", newTag.getFirst(FieldKey.YEAR));
 
114
            assertEquals("1", newTag.getFirst(FieldKey.TRACK));
 
115
 
 
116
            audioFile.commit();
 
117
 
 
118
            audioFile = org.jaudiotagger.audio.AudioFileIO.read(testFile);
 
119
            newTag = audioFile.getTag();
 
120
            assertEquals("album", newTag.getFirst(FieldKey.ALBUM));
 
121
            assertEquals("artist", newTag.getFirst(FieldKey.ARTIST));
 
122
            assertEquals("comment", newTag.getFirst(FieldKey.COMMENT));
 
123
            assertEquals("Rock", newTag.getFirst(FieldKey.GENRE));
 
124
            assertEquals("title", newTag.getFirst(FieldKey.TITLE));
 
125
            assertEquals("year", newTag.getFirst(FieldKey.YEAR));
 
126
            assertEquals("1", newTag.getFirst(FieldKey.TRACK));
 
127
            AbstractTagFrameBody body = (((ID3v23Frame) newTag.getFirstField(ID3v23FieldKey.ALBUM.getFrameId())).getBody());
 
128
            assertEquals(TextEncoding.ISO_8859_1, body.getTextEncoding());
 
129
 
 
130
            TagOptionSingleton.getInstance().setId3v23DefaultTextEncoding(TextEncoding.UTF_16);
 
131
            TagOptionSingleton.getInstance().setResetTextEncodingForExistingFrames(true);
 
132
            audioFile.commit();
 
133
            audioFile = org.jaudiotagger.audio.AudioFileIO.read(testFile);
 
134
            newTag = audioFile.getTag();
 
135
            assertEquals("album", newTag.getFirst(FieldKey.ALBUM));
 
136
            assertEquals("artist", newTag.getFirst(FieldKey.ARTIST));
 
137
            assertEquals("comment", newTag.getFirst(FieldKey.COMMENT));
 
138
            assertEquals("Rock", newTag.getFirst(FieldKey.GENRE));
 
139
            assertEquals("title", newTag.getFirst(FieldKey.TITLE));
 
140
            assertEquals("year", newTag.getFirst(FieldKey.YEAR));
 
141
            assertEquals("1", newTag.getFirst(FieldKey.TRACK));
 
142
            body = (((ID3v23Frame) newTag.getFirstField(ID3v23FieldKey.ALBUM.getFrameId())).getBody());
 
143
            assertEquals(TextEncoding.UTF_16, body.getTextEncoding());
 
144
 
 
145
            TagOptionSingleton.getInstance().setId3v23DefaultTextEncoding(TextEncoding.ISO_8859_1);
 
146
            TagOptionSingleton.getInstance().setResetTextEncodingForExistingFrames(true);
 
147
            audioFile.commit();
 
148
            audioFile = org.jaudiotagger.audio.AudioFileIO.read(testFile);
 
149
            newTag = audioFile.getTag();
 
150
            body = (((ID3v23Frame) newTag.getFirstField(ID3v23FieldKey.ALBUM.getFrameId())).getBody());
 
151
            assertEquals(TextEncoding.ISO_8859_1, body.getTextEncoding());
 
152
            TagOptionSingleton.getInstance().setResetTextEncodingForExistingFrames(false);
 
153
        }
 
154
        catch (Exception e)
 
155
        {
 
156
            ex = e;
 
157
            ex.printStackTrace();
 
158
        }
 
159
        assertNull(ex);
 
160
    }
 
161
 
 
162
    public void testNewInterfaceBasicReadandWriteID3v1() throws Exception
 
163
    {
 
164
        Exception e = null;
 
165
        File testFile = AbstractTestCase.copyAudioToTmp("testV1.mp3", new File("testnewIntId3v1.mp3"));
 
166
        MP3File mp3File = new MP3File(testFile);
 
167
 
 
168
        //Has no tag at this point
 
169
        assertFalse(mp3File.hasID3v1Tag());
 
170
        assertFalse(mp3File.hasID3v2Tag());
 
171
 
 
172
        //Create v1 tag (old method)
 
173
        ID3v11Tag v1tag = new ID3v11Tag();
 
174
        v1tag.setField(FieldKey.ARTIST,V1_ARTIST);
 
175
        v1tag.setField(FieldKey.ALBUM,"V1ALBUM" + "\u01ff");         //Note always convert to single byte so will be written as FF
 
176
        v1tag.setField(v1tag.createField(FieldKey.TITLE, "title"));
 
177
        v1tag.setField(FieldKey.GENRE,"Rock");
 
178
        v1tag.setField(v1tag.createField(FieldKey.TRACK, "12"));
 
179
        mp3File.setID3v1Tag(v1tag);
 
180
        mp3File.save();
 
181
 
 
182
        //Has only v1 tag
 
183
        assertTrue(mp3File.hasID3v1Tag());
 
184
        assertFalse(mp3File.hasID3v2Tag());
 
185
 
 
186
        //Read fields
 
187
        AudioFile af = AudioFileIO.read(testFile);
 
188
        assertEquals(V1_ARTIST, af.getTag().getFirst(FieldKey.ARTIST));
 
189
        assertEquals(V1_ARTIST, af.getTag().getFirst(FieldKey.ARTIST));
 
190
        assertEquals(V1_ARTIST, af.getTag().getFirst(FieldKey.ARTIST));
 
191
        assertEquals("V1ALBUM" + "\u00ff", af.getTag().getFirst(FieldKey.ALBUM));  //Lost the 00, is that what we want
 
192
        assertEquals("title", af.getTag().getFirst(FieldKey.TITLE));
 
193
        assertEquals("title", af.getTag().getFirst(FieldKey.TITLE));
 
194
        assertEquals("Rock", af.getTag().getFirst(FieldKey.GENRE));
 
195
        assertEquals("12", af.getTag().getFirst(FieldKey.TRACK));
 
196
        assertEquals("12", af.getTag().getFirst(FieldKey.TRACK));
 
197
 
 
198
        //Delete some fields (just sets string to empty String)
 
199
        af.getTag().deleteField(FieldKey.TITLE);
 
200
        assertEquals("", af.getTag().getFirst(FieldKey.TITLE));
 
201
 
 
202
        //Modify a value
 
203
        af.getTag().setField(FieldKey.TITLE,"newtitle");
 
204
        assertEquals("newtitle", af.getTag().getFirst(FieldKey.TITLE));
 
205
 
 
206
        //Adding just replaces current value
 
207
        af.getTag().addField(FieldKey.TITLE,"newtitle2");
 
208
        assertEquals("newtitle2", af.getTag().getFirst(FieldKey.TITLE));
 
209
    }
 
210
 
 
211
    public void testNewInterfaceBasicReadandWriteID3v24() throws Exception
 
212
    {
 
213
        Exception e = null;
 
214
        File testFile = AbstractTestCase.copyAudioToTmp("testV1.mp3", new File("testnewIntId3v24.mp3"));
 
215
        MP3File mp3File = new MP3File(testFile);
 
216
 
 
217
        //Has no tag at this point
 
218
        assertFalse(mp3File.hasID3v1Tag());
 
219
        assertFalse(mp3File.hasID3v2Tag());
 
220
 
 
221
        //Create v1 tag (old method)
 
222
        ID3v11Tag v1tag = new ID3v11Tag();
 
223
        v1tag.setField(FieldKey.ARTIST,V1_ARTIST);
 
224
        v1tag.setField(FieldKey.ALBUM,"V1ALBUM");
 
225
        mp3File.setID3v1Tag(v1tag);
 
226
        mp3File.save();
 
227
 
 
228
        //Has only v1 tag at this point
 
229
        assertTrue(mp3File.hasID3v1Tag());
 
230
        assertFalse(mp3File.hasID3v2Tag());
 
231
 
 
232
        //Read back artist (new method ,v1)
 
233
        AudioFile af = AudioFileIO.read(testFile);
 
234
        assertEquals(V1_ARTIST, af.getTag().getFirst(FieldKey.ARTIST));
 
235
        assertEquals(V1_ARTIST, af.getTag().getFirst(FieldKey.ARTIST));
 
236
        assertEquals(V1_ARTIST, af.getTag().getFirst(FieldKey.ARTIST));
 
237
 
 
238
        //Add artist frame (old method)
 
239
        ID3v24Tag tag = new ID3v24Tag();
 
240
        ID3v24Frame frame = new ID3v24Frame(ID3v24Frames.FRAME_ID_ARTIST);
 
241
        ((FrameBodyTPE1) frame.getBody()).setText(FrameBodyTPE1Test.TPE1_TEST_STRING);
 
242
        tag.setFrame(frame);
 
243
        mp3File.setID3v2TagOnly(tag);
 
244
        mp3File.save();
 
245
 
 
246
        //Has v1 and v2 tag at this point
 
247
        assertTrue(mp3File.hasID3v1Tag());
 
248
        assertTrue(mp3File.hasID3v2Tag());
 
249
 
 
250
        //Read back artist (new method ,v1 value overridden by v2 method)
 
251
        af = AudioFileIO.read(testFile);
 
252
        assertEquals(FrameBodyTPE1Test.TPE1_TEST_STRING, af.getTag().getFirst(FieldKey.ARTIST));
 
253
        assertEquals(FrameBodyTPE1Test.TPE1_TEST_STRING, af.getTag().getFirst(FieldKey.ARTIST));
 
254
        assertEquals(FrameBodyTPE1Test.TPE1_TEST_STRING, ((ID3v24Tag) af.getTag()).getFirst(ID3v24FieldKey.ARTIST));
 
255
        assertEquals(FrameBodyTPE1Test.TPE1_TEST_STRING,((TagTextField)af.getTag().getFirstField(FieldKey.ARTIST)).getContent());
 
256
        //.... but v1 value is still there
 
257
        assertEquals(V1_ARTIST, ((MP3File) af).getID3v1Tag().getFirst(FieldKey.ARTIST));
 
258
        //Write album ( new method)
 
259
        af.getTag().setField(FieldKey.ALBUM,ALBUM_TEST_STRING);
 
260
        af.commit();
 
261
 
 
262
        //Read back album (new method)
 
263
        af = AudioFileIO.read(testFile);
 
264
        assertEquals(ALBUM_TEST_STRING, af.getTag().getFirst(FieldKey.ALBUM));
 
265
        assertEquals(ALBUM_TEST_STRING, af.getTag().getFirst(FieldKey.ALBUM));
 
266
        assertEquals(ALBUM_TEST_STRING, ((ID3v24Tag) af.getTag()).getFirst(ID3v24FieldKey.ALBUM));
 
267
        assertEquals(ALBUM_TEST_STRING,((TagTextField)af.getTag().getFirstField(FieldKey.ALBUM)).getContent());
 
268
        assertEquals(1, af.getTag().getFields(FieldKey.ALBUM).size());
 
269
 
 
270
        //Read back album (old method)
 
271
        AbstractID3v2Frame checkframe = (AbstractID3v2Frame) ((MP3File) af).getID3v2Tag().getFrame(ID3v24Frames.FRAME_ID_ALBUM);
 
272
        assertEquals(ALBUM_TEST_STRING, ((FrameBodyTALB) checkframe.getBody()).getText());
 
273
 
 
274
        //If addField again, the value gets appended using the null char sperator system
 
275
        af.getTag().addField(FieldKey.ALBUM,ALBUM_TEST_STRING2);
 
276
        af.commit();
 
277
        af = AudioFileIO.read(testFile);
 
278
        assertEquals(ALBUM_TEST_STRING + "\u0000" + ALBUM_TEST_STRING2, af.getTag().getFirst(FieldKey.ALBUM));
 
279
        assertEquals(ALBUM_TEST_STRING + "\u0000" + ALBUM_TEST_STRING2, af.getTag().getValue(FieldKey.ALBUM,0));
 
280
        assertEquals(ALBUM_TEST_STRING, af.getTag().getSubValue(FieldKey.ALBUM,0,0));
 
281
        assertEquals(ALBUM_TEST_STRING2, af.getTag().getSubValue(FieldKey.ALBUM,0,1));
 
282
        assertEquals(ALBUM_TEST_STRING + "\u0000" + ALBUM_TEST_STRING2, ((ID3v24Tag) af.getTag()).getFirst(ID3v24FieldKey.ALBUM));
 
283
        assertEquals(ALBUM_TEST_STRING + "\u0000" + ALBUM_TEST_STRING2,((TagTextField)af.getTag().getFirstField(FieldKey.ALBUM)).getContent());
 
284
        assertEquals(1, af.getTag().getFields(FieldKey.ALBUM).size());
 
285
 
 
286
        //And can replace existing value
 
287
        af.getTag().setField(FieldKey.ALBUM,ALBUM_TEST_STRING2);
 
288
        af.commit();
 
289
        af = AudioFileIO.read(testFile);
 
290
        assertEquals(ALBUM_TEST_STRING2, af.getTag().getFirst(FieldKey.ALBUM));
 
291
        assertEquals(ALBUM_TEST_STRING2, af.getTag().getFirst(FieldKey.ALBUM));
 
292
        assertEquals(ALBUM_TEST_STRING2, ((ID3v24Tag) af.getTag()).getFirst(ID3v24FieldKey.ALBUM));
 
293
        assertEquals(1, af.getTag().getFields(FieldKey.ALBUM).size());
 
294
 
 
295
        //and deleteField it
 
296
        af.getTag().deleteField(FieldKey.ALBUM);
 
297
        af.commit();
 
298
        af = AudioFileIO.read(testFile);
 
299
        assertEquals("", af.getTag().getFirst(FieldKey.ALBUM));
 
300
        assertEquals("", af.getTag().getFirst(FieldKey.ALBUM));
 
301
        assertEquals("", ((ID3v24Tag) af.getTag()).getFirst(ID3v24FieldKey.ALBUM));
 
302
        assertEquals(0, af.getTag().getFields(FieldKey.ALBUM).size());
 
303
 
 
304
        //Test out the other basic fields
 
305
        //Year
 
306
        af.getTag().setField(FieldKey.YEAR,"1991");
 
307
        af.commit();
 
308
        af = AudioFileIO.read(testFile);
 
309
        assertEquals("1991", af.getTag().getFirst(FieldKey.YEAR));
 
310
        assertEquals("1991", af.getTag().getFirst(FieldKey.YEAR));
 
311
        assertEquals("1991", ((ID3v24Tag) af.getTag()).getFirst(ID3v24FieldKey.YEAR));
 
312
        assertEquals("1991",((TagTextField)af.getTag().getFirstField(FieldKey.YEAR)).getContent());
 
313
        assertEquals(1, af.getTag().getFields(FieldKey.YEAR).size());
 
314
        assertEquals(2, af.getTag().getFieldCount());
 
315
 
 
316
        //Title
 
317
        af.getTag().setField(FieldKey.TITLE,"Title");
 
318
        af.commit();
 
319
        af = AudioFileIO.read(testFile);
 
320
        assertEquals("Title", af.getTag().getFirst(FieldKey.TITLE));
 
321
        assertEquals("Title", af.getTag().getFirst(FieldKey.TITLE));
 
322
        assertEquals("Title", ((ID3v24Tag) af.getTag()).getFirst(ID3v24FieldKey.TITLE));
 
323
        assertEquals("Title",((TagTextField)af.getTag().getFirstField(FieldKey.TITLE)).getContent());
 
324
        assertEquals(1, af.getTag().getFields(FieldKey.TITLE).size());
 
325
        assertEquals(3, af.getTag().getFieldCount());
 
326
 
 
327
        //Comment, trickier because uses different framebody subclass to the ones above
 
328
        af.getTag().setField(FieldKey.COMMENT,"Comment");
 
329
        af.commit();
 
330
        af = AudioFileIO.read(testFile);
 
331
        assertEquals("Comment", af.getTag().getFirst(FieldKey.COMMENT));
 
332
        assertEquals("Comment", ((ID3v24Tag) af.getTag()).getFirst(ID3v24FieldKey.COMMENT));
 
333
 
 
334
        //By default comments are created with empty description because this is what expected
 
335
        //by plyers such as iTunes.
 
336
        ID3v24Frame commentFrame = (ID3v24Frame) ((ID3v24Tag) af.getTag()).getFrame("COMM");
 
337
        FrameBodyCOMM fb = (FrameBodyCOMM) commentFrame.getBody();
 
338
        assertEquals("", fb.getDescription());
 
339
        assertEquals("Comment", fb.getText());
 
340
        //Change description, cant do this with common interface
 
341
        fb.setDescription("test");
 
342
        //Because has different description the following setField will addField another comment rather than overwriting the first one
 
343
        af.getTag().setField(FieldKey.COMMENT,"Comment2");
 
344
        assertEquals(2, af.getTag().getFields(FieldKey.COMMENT).size());
 
345
        //Add third Comment
 
346
        List<TagField> comments = af.getTag().getFields(FieldKey.COMMENT);
 
347
        ((FrameBodyCOMM) ((ID3v24Frame) comments.get(1)).getBody()).setDescription("test2");
 
348
        af.getTag().setField(FieldKey.COMMENT,"Comment3");
 
349
        af.commit();
 
350
        af = AudioFileIO.read(testFile);
 
351
        assertEquals(3, af.getTag().getFields(FieldKey.COMMENT).size());
 
352
 
 
353
        //Add fourth Comment (but duplicate key - so overwrites 3rd comment)
 
354
        af.getTag().setField(FieldKey.COMMENT,"Comment4");
 
355
        af.commit();
 
356
        af = AudioFileIO.read(testFile);
 
357
        assertEquals(3, af.getTag().getFields(FieldKey.COMMENT).size());
 
358
 
 
359
        //Remove all Comment tags
 
360
        af.getTag().deleteField(FieldKey.COMMENT);
 
361
        assertEquals(0, af.getTag().getFields(FieldKey.COMMENT).size());
 
362
 
 
363
        //Add first one back in
 
364
        af.getTag().setField(FieldKey.COMMENT,"Comment");
 
365
        af.commit();
 
366
        af = AudioFileIO.read(testFile);
 
367
        assertEquals(1, af.getTag().getFields(FieldKey.COMMENT).size());
 
368
        assertEquals(4, af.getTag().getFieldCount());
 
369
 
 
370
        //Genre
 
371
        //TODO only one genre frame allowed, but that can contain multiple GENRE values, currently
 
372
        //must parse as one genre e.g 34 67
 
373
        af.getTag().setField(FieldKey.GENRE,"CustomGenre");
 
374
        af.commit();
 
375
        af = AudioFileIO.read(testFile);
 
376
        assertEquals("CustomGenre", af.getTag().getFirst(FieldKey.GENRE));
 
377
        assertEquals("CustomGenre", af.getTag().getFirst(FieldKey.GENRE));
 
378
        assertEquals("CustomGenre", ((ID3v24Tag) af.getTag()).getFirst(ID3v24FieldKey.GENRE));
 
379
        assertEquals(1, af.getTag().getFields(FieldKey.GENRE).size());
 
380
        assertEquals(5, af.getTag().getFieldCount());
 
381
 
 
382
        //Track
 
383
        af.getTag().setField(FieldKey.TRACK,"7");
 
384
        af.getTag().setField(af.getTag().createField(FieldKey.TRACK_TOTAL, "11"));
 
385
        assertEquals("7",af.getTag().getFirst(FieldKey.TRACK));
 
386
        assertEquals("11",af.getTag().getFirst(FieldKey.TRACK_TOTAL));
 
387
        af.commit();
 
388
        af = AudioFileIO.read(testFile);
 
389
        assertEquals("7", af.getTag().getFirst(FieldKey.TRACK));
 
390
        assertEquals("7", af.getTag().getFirst(FieldKey.TRACK));
 
391
        assertEquals("7", ((ID3v24Tag) af.getTag()).getFirst(ID3v24FieldKey.TRACK));
 
392
        assertEquals("11",af.getTag().getFirst(FieldKey.TRACK_TOTAL));
 
393
        assertEquals(1, af.getTag().getFields(FieldKey.TRACK).size());
 
394
        assertEquals(6, af.getTag().getFieldCount());
 
395
 
 
396
        //AmazonId
 
397
        //This is one of many fields that uses the TXXX frame, the logic is more complicated
 
398
        af.getTag().setField(af.getTag().createField(FieldKey.AMAZON_ID, "asin123456" + "\u01ff"));
 
399
        af.commit();
 
400
        af = AudioFileIO.read(testFile);
 
401
 
 
402
         //Mood
 
403
        af.getTag().setField(af.getTag().createField(FieldKey.MOOD, "mood"));
 
404
        af.commit();
 
405
        af = AudioFileIO.read(testFile);
 
406
 
 
407
        assertEquals("asin123456" + "\u01ff", af.getTag().getFirst(FieldKey.AMAZON_ID));
 
408
        assertEquals("asin123456" + "\u01ff", ((ID3v24Tag) af.getTag()).getFirst(ID3v24FieldKey.AMAZON_ID));
 
409
        assertEquals(1, af.getTag().getFields(FieldKey.AMAZON_ID).size());
 
410
        assertEquals(8, af.getTag().getFieldCount());
 
411
 
 
412
        //Now addField another different field that also uses a TXXX frame
 
413
        af.getTag().setField(af.getTag().createField(FieldKey.MUSICIP_ID, "musicip_id"));
 
414
        af.commit();
 
415
        af = AudioFileIO.read(testFile);
 
416
        assertEquals(2, ((List) ((ID3v24Tag) af.getTag()).getFrame("TXXX")).size());
 
417
        assertEquals("musicip_id", af.getTag().getFirst(FieldKey.MUSICIP_ID));
 
418
        assertEquals("musicip_id", ((ID3v24Tag) af.getTag()).getFirst(ID3v24FieldKey.MUSICIP_ID));
 
419
        assertEquals(1, af.getTag().getFields(FieldKey.MUSICIP_ID).size());
 
420
        assertEquals("asin123456" + "\u01ff", af.getTag().getFirst(FieldKey.AMAZON_ID));
 
421
        assertEquals(9, af.getTag().getFieldCount());
 
422
 
 
423
        //Now addField yet another different field that also uses a TXXX frame
 
424
        af.getTag().setField(af.getTag().createField(FieldKey.MUSICBRAINZ_RELEASEID, "releaseid"));
 
425
        af.commit();
 
426
        af = AudioFileIO.read(testFile);
 
427
        assertEquals(3, ((List) ((ID3v24Tag) af.getTag()).getFrame("TXXX")).size());
 
428
        assertEquals("musicip_id", af.getTag().getFirst(FieldKey.MUSICIP_ID));
 
429
        assertEquals("releaseid", af.getTag().getFirst(FieldKey.MUSICBRAINZ_RELEASEID));
 
430
        assertEquals("releaseid",((TagTextField)af.getTag().getFirstField(FieldKey.MUSICBRAINZ_RELEASEID)).getContent());
 
431
        assertEquals("asin123456" + "\u01ff", af.getTag().getFirst(FieldKey.AMAZON_ID));
 
432
        assertEquals(1, af.getTag().getFields(FieldKey.MUSICIP_ID).size());
 
433
        assertEquals(1, af.getTag().getFields(FieldKey.AMAZON_ID).size());
 
434
        assertEquals(1, af.getTag().getFields(FieldKey.MUSICBRAINZ_RELEASEID).size());
 
435
        assertEquals(10, af.getTag().getFieldCount());
 
436
 
 
437
        //Now deleteField field
 
438
        af.getTag().deleteField(FieldKey.MUSICBRAINZ_RELEASEID);
 
439
        af.commit();
 
440
        af = AudioFileIO.read(testFile);
 
441
        assertEquals(2, ((List) ((ID3v24Tag) af.getTag()).getFrame("TXXX")).size());
 
442
        assertEquals(1, af.getTag().getFields(FieldKey.MUSICIP_ID).size());
 
443
        assertEquals(1, af.getTag().getFields(FieldKey.AMAZON_ID).size());
 
444
        assertEquals(9, af.getTag().getFieldCount());
 
445
 
 
446
        //Cover Art:invalid way to do it
 
447
        try
 
448
        {
 
449
            af.getTag().setField(af.getTag().createField(FieldKey.COVER_ART, "coverart"));
 
450
        }
 
451
        catch (java.lang.UnsupportedOperationException uoe)
 
452
        {
 
453
            e = uoe;
 
454
        }
 
455
        assertTrue(e instanceof UnsupportedOperationException);
 
456
 
 
457
        //Add new image correctly
 
458
        RandomAccessFile imageFile = new RandomAccessFile(new File("testdata", "coverart.png"), "r");
 
459
        byte[] imagedata = new byte[(int) imageFile.length()];
 
460
        imageFile.read(imagedata);
 
461
        af.getTag().addField(tag.createArtworkField(imagedata, "image/png"));
 
462
        af.commit();
 
463
        af = AudioFileIO.read(testFile);
 
464
        assertEquals(1, ((ID3v24Tag) af.getTag()).getFields(FieldKey.COVER_ART).size());
 
465
        assertEquals(1, ((ID3v24Tag) af.getTag()).getFields(ID3v24FieldKey.COVER_ART.getFieldName()).size());
 
466
        //TODO This isnt very user friendly
 
467
        TagField tagField = af.getTag().getFirstField(ID3v24FieldKey.COVER_ART.getFieldName());
 
468
        assertEquals("image/png::18545",((TagTextField)af.getTag().getFirstField(FieldKey.COVER_ART)).getContent());
 
469
 
 
470
        assertTrue(tagField instanceof ID3v24Frame);
 
471
        ID3v24Frame apicFrame = (ID3v24Frame) tagField;
 
472
        assertTrue(apicFrame.getBody() instanceof FrameBodyAPIC);
 
473
        FrameBodyAPIC apicframebody = (FrameBodyAPIC) apicFrame.getBody();
 
474
        assertFalse(apicframebody.isImageUrl());
 
475
        assertEquals(10, af.getTag().getFieldCount());
 
476
 
 
477
        //Add another image correctly
 
478
        imageFile = new RandomAccessFile(new File("testdata", "coverart_small.png"), "r");
 
479
        imagedata = new byte[(int) imageFile.length()];
 
480
        imageFile.read(imagedata);
 
481
        af.getTag().addField(tag.createArtworkField(imagedata, "image/png"));
 
482
        af.commit();
 
483
        af = AudioFileIO.read(testFile);
 
484
        assertEquals(2, af.getTag().getFields(FieldKey.COVER_ART).size());
 
485
        assertEquals(11, af.getTag().getFieldCount());
 
486
 
 
487
        //Actually createField the image from the read data
 
488
        BufferedImage bi = null;
 
489
        TagField imageField = af.getTag().getFields(FieldKey.COVER_ART).get(0);
 
490
        if (imageField instanceof AbstractID3v2Frame)
 
491
        {
 
492
            FrameBodyAPIC imageFrameBody = (FrameBodyAPIC) ((AbstractID3v2Frame) imageField).getBody();
 
493
            if (!imageFrameBody.isImageUrl())
 
494
            {
 
495
                byte[] imageRawData = (byte[]) imageFrameBody.getObjectValue(DataTypes.OBJ_PICTURE_DATA);
 
496
                bi = ImageIO.read(new ByteArrayInputStream(imageRawData));
 
497
            }
 
498
        }
 
499
        assertNotNull(bi);
 
500
 
 
501
        //Add a linked Image
 
502
        af.getTag().addField(tag.createLinkedArtworkField("../testdata/coverart.jpg"));
 
503
        af.commit();
 
504
 
 
505
        af = AudioFileIO.read(testFile);
 
506
        assertEquals(3, af.getTag().getFields(FieldKey.COVER_ART).size());
 
507
        assertEquals(12, af.getTag().getFieldCount());
 
508
        List<TagField> imageFields = af.getTag().getFields(FieldKey.COVER_ART);
 
509
        tagField = imageFields.get(2);
 
510
        apicFrame = (ID3v24Frame) tagField;
 
511
        assertTrue(apicFrame.getBody() instanceof FrameBodyAPIC);
 
512
        apicframebody = (FrameBodyAPIC) apicFrame.getBody();
 
513
        assertTrue(apicframebody.isImageUrl());
 
514
        assertEquals("../testdata/coverart.jpg", apicframebody.getImageUrl());
 
515
 
 
516
 
 
517
    }
 
518
 
 
519
    /*  public void testReadUrlImage() throws Exception
 
520
       {
 
521
           Exception ex = null;
 
522
           try
 
523
           {
 
524
               File testFile = AbstractTestCase.copyAudioToTmp("testV1withurlimage.mp3");
 
525
               org.jaudiotagger.audio.AudioFile audioFile = org.jaudiotagger.audio.AudioFileIO.read(testFile);
 
526
               ID3v23Tag newTag = (ID3v23Tag)audioFile.getTag();
 
527
               assertEquals(1, newTag.getFields(FieldKey.COVER_ART).size());
 
528
               TagField tagField = newTag.getFirstField(ID3v23FieldKey.COVER_ART.getFieldName());
 
529
               assertTrue(tagField instanceof ID3v23Frame);
 
530
               ID3v23Frame apicFrame = (ID3v23Frame)tagField;
 
531
               assertTrue(apicFrame.getBody() instanceof FrameBodyAPIC);
 
532
               FrameBodyAPIC apicframebody = (FrameBodyAPIC)apicFrame.getBody();
 
533
               assertFalse(apicframebody.isImageUrl());
 
534
           }
 
535
           catch(Exception e)
 
536
           {
 
537
               ex=e;
 
538
               ex.printStackTrace();
 
539
           }
 
540
           assertNull(ex);
 
541
       }
 
542
    */
 
543
    public void testNewInterfaceBasicReadandWriteID3v23() throws Exception
 
544
    {
 
545
        Exception e = null;
 
546
        File testFile = AbstractTestCase.copyAudioToTmp("testV1.mp3", new File("testnewIntId3v23.mp3"));
 
547
        MP3File mp3File = new MP3File(testFile);
 
548
 
 
549
        //Has no tag at this point
 
550
        assertFalse(mp3File.hasID3v1Tag());
 
551
        assertFalse(mp3File.hasID3v2Tag());
 
552
 
 
553
        //Create v1 tag (old method)
 
554
        ID3v11Tag v1tag = new ID3v11Tag();
 
555
        v1tag.setField(FieldKey.ARTIST,V1_ARTIST);
 
556
        v1tag.setField(FieldKey.ALBUM,"V1ALBUM");
 
557
        mp3File.setID3v1Tag(v1tag);
 
558
        mp3File.save();
 
559
 
 
560
        //Has only v1 tag at this point
 
561
        assertTrue(mp3File.hasID3v1Tag());
 
562
        assertFalse(mp3File.hasID3v2Tag());
 
563
 
 
564
        //Read back artist (new method ,v1)
 
565
        AudioFile af = AudioFileIO.read(testFile);
 
566
        assertEquals(V1_ARTIST, af.getTag().getFirst(FieldKey.ARTIST));
 
567
        assertEquals(V1_ARTIST, af.getTag().getFirst(FieldKey.ARTIST));
 
568
        assertEquals(V1_ARTIST, af.getTag().getFirst(FieldKey.ARTIST));
 
569
 
 
570
        //Add artist frame (old method)
 
571
        ID3v23Tag tag = new ID3v23Tag();
 
572
        ID3v23Frame frame = new ID3v23Frame(ID3v23Frames.FRAME_ID_V3_ARTIST);
 
573
        ((FrameBodyTPE1) frame.getBody()).setText(FrameBodyTPE1Test.TPE1_TEST_STRING);
 
574
        tag.setFrame(frame);
 
575
        mp3File.setID3v2TagOnly(tag);
 
576
        mp3File.save();
 
577
 
 
578
        //Has v1 and v2 tag at this point
 
579
        assertTrue(mp3File.hasID3v1Tag());
 
580
        assertTrue(mp3File.hasID3v2Tag());
 
581
 
 
582
        //Read back artist (new method ,v1 value overrriden by v2 method)
 
583
        af = AudioFileIO.read(testFile);
 
584
        assertEquals(FrameBodyTPE1Test.TPE1_TEST_STRING, af.getTag().getFirst(FieldKey.ARTIST));
 
585
        assertEquals(FrameBodyTPE1Test.TPE1_TEST_STRING, af.getTag().getFirst(FieldKey.ARTIST));
 
586
        assertEquals(FrameBodyTPE1Test.TPE1_TEST_STRING, ((ID3v23Tag) af.getTag()).getFirst(ID3v23FieldKey.ARTIST));
 
587
        //.... but v1 value is still there
 
588
        assertEquals(V1_ARTIST, ((MP3File) af).getID3v1Tag().getFirst(FieldKey.ARTIST));
 
589
        //Write album ( new method)
 
590
        af.getTag().setField(FieldKey.ALBUM,ALBUM_TEST_STRING);
 
591
        af.commit();
 
592
 
 
593
        //Read back album (new method)
 
594
        af = AudioFileIO.read(testFile);
 
595
        assertEquals(ALBUM_TEST_STRING, af.getTag().getFirst(FieldKey.ALBUM));
 
596
        assertEquals(ALBUM_TEST_STRING, af.getTag().getFirst(FieldKey.ALBUM));
 
597
        assertEquals(ALBUM_TEST_STRING, ((ID3v23Tag) af.getTag()).getFirst(ID3v23FieldKey.ALBUM));
 
598
        assertEquals(1, af.getTag().getFields(FieldKey.ALBUM).size());
 
599
 
 
600
        //Read back album (old method)
 
601
        AbstractID3v2Frame checkframe = (AbstractID3v2Frame) ((MP3File) af).getID3v2Tag().getFrame(ID3v23Frames.FRAME_ID_V3_ALBUM);
 
602
        assertEquals(ALBUM_TEST_STRING, ((FrameBodyTALB) checkframe.getBody()).getText());
 
603
 
 
604
        //If add smae field again appended to existiong frame
 
605
        af.getTag().addField(FieldKey.ALBUM,ALBUM_TEST_STRING2);
 
606
        af.commit();
 
607
        af = AudioFileIO.read(testFile);
 
608
        assertEquals(ALBUM_TEST_STRING + "\u0000" + ALBUM_TEST_STRING2, af.getTag().getFirst(FieldKey.ALBUM));
 
609
        assertEquals(ALBUM_TEST_STRING + "\u0000" + ALBUM_TEST_STRING2, af.getTag().getFirst(FieldKey.ALBUM));
 
610
        assertEquals(ALBUM_TEST_STRING, af.getTag().getSubValue(FieldKey.ALBUM,0,0));
 
611
        assertEquals(ALBUM_TEST_STRING2, af.getTag().getSubValue(FieldKey.ALBUM,0,1));
 
612
        assertEquals(ALBUM_TEST_STRING + "\u0000" + ALBUM_TEST_STRING2, ((ID3v23Tag) af.getTag()).getFirst(ID3v23FieldKey.ALBUM));
 
613
        assertEquals(1, af.getTag().getFields(FieldKey.ALBUM).size());
 
614
 
 
615
        //But can replace existing value
 
616
        af.getTag().setField(FieldKey.ALBUM,ALBUM_TEST_STRING2);
 
617
        af.commit();
 
618
        af = AudioFileIO.read(testFile);
 
619
        assertEquals(ALBUM_TEST_STRING2, af.getTag().getFirst(FieldKey.ALBUM));
 
620
        assertEquals(ALBUM_TEST_STRING2, af.getTag().getFirst(FieldKey.ALBUM));
 
621
        assertEquals(ALBUM_TEST_STRING2, ((ID3v23Tag) af.getTag()).getFirst(ID3v23FieldKey.ALBUM));
 
622
        assertEquals(1, af.getTag().getFields(FieldKey.ALBUM).size());
 
623
 
 
624
        //and deleteField it
 
625
        af.getTag().deleteField(FieldKey.ALBUM);
 
626
        af.commit();
 
627
        af = AudioFileIO.read(testFile);
 
628
        assertEquals("", af.getTag().getFirst(FieldKey.ALBUM));
 
629
        assertEquals("", af.getTag().getFirst(FieldKey.ALBUM));
 
630
        assertEquals("", ((ID3v23Tag) af.getTag()).getFirst(ID3v23FieldKey.ALBUM));
 
631
        assertEquals(0, af.getTag().getFields(FieldKey.ALBUM).size());
 
632
 
 
633
        //Test out the other basic fields
 
634
        //Year
 
635
        af.getTag().setField(FieldKey.YEAR,"1991");
 
636
        af.commit();
 
637
        af = AudioFileIO.read(testFile);
 
638
        assertEquals("1991", af.getTag().getFirst(FieldKey.YEAR));
 
639
        assertEquals("1991", af.getTag().getFirst(FieldKey.YEAR));
 
640
        assertEquals("1991", ((ID3v23Tag) af.getTag()).getFirst(ID3v23FieldKey.YEAR));
 
641
        assertEquals(1, af.getTag().getFields(FieldKey.YEAR).size());
 
642
        assertEquals(2, af.getTag().getFieldCount());
 
643
 
 
644
        //Title
 
645
        af.getTag().setField(FieldKey.TITLE,"Title");
 
646
        af.commit();
 
647
        af = AudioFileIO.read(testFile);
 
648
        assertEquals("Title", af.getTag().getFirst(FieldKey.TITLE));
 
649
        assertEquals("Title", af.getTag().getFirst(FieldKey.TITLE));
 
650
        assertEquals("Title", ((ID3v23Tag) af.getTag()).getFirst(ID3v23FieldKey.TITLE));
 
651
        assertEquals(1, af.getTag().getFields(FieldKey.TITLE).size());
 
652
        assertEquals(3, af.getTag().getFieldCount());
 
653
 
 
654
        //Comment, trickier because uses different framebody subclass to the ones above
 
655
        af.getTag().setField(FieldKey.COMMENT,"Comment");
 
656
        af.commit();
 
657
        af = AudioFileIO.read(testFile);
 
658
        assertEquals("Comment", af.getTag().getFirst(FieldKey.COMMENT));
 
659
        assertEquals("Comment", ((ID3v23Tag) af.getTag()).getFirst(ID3v23FieldKey.COMMENT));
 
660
        assertEquals(1, af.getTag().getFields(FieldKey.COMMENT).size());
 
661
        assertEquals(4, af.getTag().getFieldCount());
 
662
 
 
663
        //Genre
 
664
        //TODO only one genre frame allowed, but that can contain multiple GENRE values, currently
 
665
        //must parse as one genre e.g 34 67
 
666
        af.getTag().setField(FieldKey.GENRE,"CustomGenre");
 
667
        af.commit();
 
668
        af = AudioFileIO.read(testFile);
 
669
        assertEquals("CustomGenre", af.getTag().getFirst(FieldKey.GENRE));
 
670
        assertEquals("CustomGenre", ((ID3v23Tag) af.getTag()).getFirst(ID3v23FieldKey.GENRE));
 
671
        assertEquals(1, af.getTag().getFields(FieldKey.GENRE).size());
 
672
        assertEquals(5, af.getTag().getFieldCount());
 
673
 
 
674
 
 
675
        //Track
 
676
        af.getTag().setField(FieldKey.TRACK,"7");
 
677
        af.getTag().setField(af.getTag().createField(FieldKey.TRACK_TOTAL, "11"));
 
678
        assertEquals("7",af.getTag().getFirst(FieldKey.TRACK));
 
679
        assertEquals("11",af.getTag().getFirst(FieldKey.TRACK_TOTAL));
 
680
 
 
681
        af.commit();
 
682
        af = AudioFileIO.read(testFile);
 
683
        assertEquals("7", af.getTag().getFirst(FieldKey.TRACK));
 
684
        assertEquals("7", af.getTag().getFirst(FieldKey.TRACK));
 
685
        assertEquals("7", ((ID3v23Tag) af.getTag()).getFirst(ID3v23FieldKey.TRACK));
 
686
        assertEquals(1, af.getTag().getFields(FieldKey.TRACK).size());
 
687
        assertEquals(6, af.getTag().getFieldCount());
 
688
 
 
689
        assertEquals("7",af.getTag().getFirst(FieldKey.TRACK));
 
690
        
 
691
        //AmazonId also testing utf encoding here
 
692
        //This is one of many fields that uses the TXXX frame, the logic is more complicated
 
693
        af.getTag().setField(af.getTag().createField(FieldKey.AMAZON_ID, "asin123456" + "\u01ff"));
 
694
        af.commit();
 
695
        af = AudioFileIO.read(testFile);
 
696
        assertEquals("asin123456" + "\u01ff", af.getTag().getFirst(FieldKey.AMAZON_ID));
 
697
        assertEquals("asin123456" + "\u01ff", ((ID3v23Tag) af.getTag()).getFirst(ID3v23FieldKey.AMAZON_ID));
 
698
        assertEquals(1, af.getTag().getFields(FieldKey.AMAZON_ID).size());
 
699
        assertEquals(7, af.getTag().getFieldCount());
 
700
 
 
701
         //Mood
 
702
        af.getTag().setField(af.getTag().createField(FieldKey.MOOD, "mood"));
 
703
        af.commit();
 
704
        af = AudioFileIO.read(testFile);
 
705
        assertEquals("mood", af.getTag().getFirst(FieldKey.MOOD));
 
706
        //Now deleteField field
 
707
        af.getTag().deleteField(FieldKey.MOOD);
 
708
        af.commit();
 
709
        af = AudioFileIO.read(testFile);
 
710
 
 
711
        assertEquals("7",af.getTag().getFirst(FieldKey.TRACK));
 
712
 
 
713
        //Track Total
 
714
        af.getTag().setField(af.getTag().createField(FieldKey.TRACK_TOTAL, "11"));
 
715
        assertEquals("11",af.getTag().getFirst(FieldKey.TRACK_TOTAL));
 
716
        
 
717
        //Now addField another different field that also uses a TXXX frame
 
718
        af.getTag().setField(af.getTag().createField(FieldKey.MUSICIP_ID, "musicip_id"));
 
719
        af.commit();
 
720
        af = AudioFileIO.read(testFile);
 
721
        assertEquals(2, ((List) ((ID3v23Tag) af.getTag()).getFrame("TXXX")).size());
 
722
        assertEquals("musicip_id", af.getTag().getFirst(FieldKey.MUSICIP_ID));
 
723
        assertEquals("musicip_id", ((ID3v23Tag) af.getTag()).getFirst(ID3v23FieldKey.MUSICIP_ID));
 
724
        assertEquals(1, af.getTag().getFields(FieldKey.MUSICIP_ID).size());
 
725
        assertEquals("asin123456" + "\u01ff", af.getTag().getFirst(FieldKey.AMAZON_ID));
 
726
        assertEquals("7",af.getTag().getFirst(FieldKey.TRACK));
 
727
        assertEquals(8, af.getTag().getFieldCount());
 
728
        assertEquals("11",af.getTag().getFirst(FieldKey.TRACK_TOTAL));
 
729
        assertEquals("7",((ID3v23Tag)af.getTag()).getFirst(ID3v23FieldKey.TRACK));
 
730
        assertEquals("11",((ID3v23Tag)af.getTag()).getFirst(ID3v23FieldKey.TRACK_TOTAL));
 
731
        
 
732
        //Now addField yet another different field that also uses a TXXX frame
 
733
        af.getTag().setField(af.getTag().createField(FieldKey.MUSICBRAINZ_RELEASEID, "releaseid"));
 
734
        af.commit();
 
735
        af = AudioFileIO.read(testFile);
 
736
        assertEquals(3, ((List) ((ID3v23Tag) af.getTag()).getFrame("TXXX")).size());
 
737
        assertEquals("musicip_id", af.getTag().getFirst(FieldKey.MUSICIP_ID));
 
738
        assertEquals("releaseid", af.getTag().getFirst(FieldKey.MUSICBRAINZ_RELEASEID));
 
739
        assertEquals("asin123456" + "\u01ff", af.getTag().getFirst(FieldKey.AMAZON_ID));
 
740
        assertEquals(1, af.getTag().getFields(FieldKey.MUSICIP_ID).size());
 
741
        assertEquals(1, af.getTag().getFields(FieldKey.AMAZON_ID).size());
 
742
        assertEquals(1, af.getTag().getFields(FieldKey.MUSICBRAINZ_RELEASEID).size());
 
743
        assertEquals(9, af.getTag().getFieldCount());
 
744
 
 
745
        //Now deleteField field
 
746
        af.getTag().deleteField(FieldKey.MUSICBRAINZ_RELEASEID);
 
747
        af.commit();
 
748
        af = AudioFileIO.read(testFile);
 
749
        assertEquals(2, ((List) ((ID3v23Tag) af.getTag()).getFrame("TXXX")).size());
 
750
        assertEquals(1, af.getTag().getFields(FieldKey.MUSICIP_ID).size());
 
751
        assertEquals(1, af.getTag().getFields(FieldKey.AMAZON_ID).size());
 
752
        assertEquals(8, af.getTag().getFieldCount());
 
753
 
 
754
        //Cover Art:invalid way to do it
 
755
        try
 
756
        {
 
757
            af.getTag().setField(af.getTag().createField(FieldKey.COVER_ART, "coverart"));
 
758
        }
 
759
        catch (java.lang.UnsupportedOperationException uoe)
 
760
        {
 
761
            e = uoe;
 
762
        }
 
763
        assertTrue(e instanceof UnsupportedOperationException);
 
764
 
 
765
        //Add new image correctly
 
766
        RandomAccessFile imageFile = new RandomAccessFile(new File("testdata", "coverart.png"), "r");
 
767
        byte[] imagedata = new byte[(int) imageFile.length()];
 
768
        imageFile.read(imagedata);
 
769
        af.getTag().addField(tag.createArtworkField(imagedata, "image/png"));
 
770
        af.commit();
 
771
        af = AudioFileIO.read(testFile);
 
772
        assertEquals(1, af.getTag().getFields(FieldKey.COVER_ART).size());
 
773
        assertEquals(9, af.getTag().getFieldCount());
 
774
 
 
775
        //Add another image correctly
 
776
        imageFile = new RandomAccessFile(new File("testdata", "coverart_small.png"), "r");
 
777
        imagedata = new byte[(int) imageFile.length()];
 
778
        imageFile.read(imagedata);
 
779
        af.getTag().addField(tag.createArtworkField(imagedata, "image/png"));
 
780
        af.commit();
 
781
        af = AudioFileIO.read(testFile);
 
782
        assertEquals(2, af.getTag().getFields(FieldKey.COVER_ART).size());
 
783
        assertEquals(10, af.getTag().getFieldCount());
 
784
 
 
785
 
 
786
    }
 
787
 
 
788
    public void testNewInterfaceBasicReadandWriteID3v22() throws Exception
 
789
    {
 
790
        Exception e = null;
 
791
        File testFile = AbstractTestCase.copyAudioToTmp("testV1.mp3", new File("testnewIntId3v22.mp3"));
 
792
        MP3File mp3File = new MP3File(testFile);
 
793
 
 
794
        //Has no tag at this point
 
795
        assertFalse(mp3File.hasID3v1Tag());
 
796
        assertFalse(mp3File.hasID3v2Tag());
 
797
 
 
798
        //Create v1 tag (old method)
 
799
        ID3v11Tag v1tag = new ID3v11Tag();
 
800
        v1tag.setField(FieldKey.ARTIST,V1_ARTIST);
 
801
        v1tag.setField(FieldKey.ALBUM,"V1ALBUM");
 
802
        mp3File.setID3v1Tag(v1tag);
 
803
        mp3File.save();
 
804
 
 
805
        //Has only v1 tag at this point
 
806
        assertTrue(mp3File.hasID3v1Tag());
 
807
        assertFalse(mp3File.hasID3v2Tag());
 
808
 
 
809
        //Read back artist (new method ,v1)
 
810
        AudioFile af = AudioFileIO.read(testFile);
 
811
        assertEquals(V1_ARTIST, af.getTag().getFirst(FieldKey.ARTIST));
 
812
        assertEquals(V1_ARTIST, af.getTag().getFirst(FieldKey.ARTIST));
 
813
        assertEquals(V1_ARTIST, af.getTag().getFirst(FieldKey.ARTIST));
 
814
 
 
815
        //Add artist frame (old method)
 
816
        ID3v22Tag tag = new ID3v22Tag();
 
817
        ID3v22Frame frame = new ID3v22Frame(ID3v22Frames.FRAME_ID_V2_ARTIST);
 
818
        ((FrameBodyTPE1) frame.getBody()).setText(FrameBodyTPE1Test.TPE1_TEST_STRING);
 
819
        tag.setFrame(frame);
 
820
        mp3File.setID3v2TagOnly(tag);
 
821
        mp3File.save();
 
822
 
 
823
        //Has v1 and v2 tag at this point
 
824
        assertTrue(mp3File.hasID3v1Tag());
 
825
        assertTrue(mp3File.hasID3v2Tag());
 
826
 
 
827
        //Read back artist (new method ,v1 value overrriden by v2 method)
 
828
        af = AudioFileIO.read(testFile);
 
829
        assertEquals(FrameBodyTPE1Test.TPE1_TEST_STRING, af.getTag().getFirst(FieldKey.ARTIST));
 
830
        assertEquals(FrameBodyTPE1Test.TPE1_TEST_STRING, af.getTag().getFirst(FieldKey.ARTIST));
 
831
 
 
832
        assertEquals(FrameBodyTPE1Test.TPE1_TEST_STRING, ((ID3v22Tag) af.getTag()).getFirst(ID3v22FieldKey.ARTIST));
 
833
        //.... but v1 value is still there
 
834
        assertEquals(V1_ARTIST, ((MP3File) af).getID3v1Tag().getFirst(FieldKey.ARTIST));
 
835
        //Write album ( new method)
 
836
        af.getTag().setField(FieldKey.ALBUM,ALBUM_TEST_STRING);
 
837
        assertEquals(ALBUM_TEST_STRING, af.getTag().getFirst(FieldKey.ALBUM));
 
838
        assertEquals(1, af.getTag().getFields(FieldKey.ALBUM).size());
 
839
 
 
840
        af.commit();
 
841
 
 
842
        //Read back album (new method)
 
843
        af = AudioFileIO.read(testFile);
 
844
        assertEquals(ALBUM_TEST_STRING, af.getTag().getFirst(FieldKey.ALBUM));
 
845
        assertEquals(ALBUM_TEST_STRING, af.getTag().getFirst(FieldKey.ALBUM));
 
846
        assertEquals(ALBUM_TEST_STRING, ((ID3v22Tag) af.getTag()).getFirst(ID3v22FieldKey.ALBUM));
 
847
        assertEquals(1, af.getTag().getFields(FieldKey.ALBUM).size());
 
848
 
 
849
        //Read back album (old method)
 
850
        AbstractID3v2Frame checkframe = (AbstractID3v2Frame) ((MP3File) af).getID3v2Tag().getFrame(ID3v22Frames.FRAME_ID_V2_ALBUM);
 
851
        assertEquals(ALBUM_TEST_STRING, ((FrameBodyTALB) checkframe.getBody()).getText());
 
852
 
 
853
        //If add extra text field its appended to existing frame
 
854
        af.getTag().addField(FieldKey.ALBUM,ALBUM_TEST_STRING2);
 
855
        af.commit();
 
856
        af = AudioFileIO.read(testFile);
 
857
        assertEquals(ALBUM_TEST_STRING + "\u0000" + ALBUM_TEST_STRING2, af.getTag().getFirst(FieldKey.ALBUM));
 
858
        assertEquals(ALBUM_TEST_STRING + "\u0000" + ALBUM_TEST_STRING2, af.getTag().getFirst(FieldKey.ALBUM));
 
859
        assertEquals(ALBUM_TEST_STRING, af.getTag().getSubValue(FieldKey.ALBUM,0,0));
 
860
        assertEquals(ALBUM_TEST_STRING2, af.getTag().getSubValue(FieldKey.ALBUM,0,1));
 
861
        assertEquals(ALBUM_TEST_STRING + "\u0000" + ALBUM_TEST_STRING2, ((ID3v22Tag) af.getTag()).getFirst(ID3v22FieldKey.ALBUM));
 
862
        assertEquals(1, af.getTag().getFields(FieldKey.ALBUM).size());
 
863
 
 
864
        //But can replace existing value
 
865
        af.getTag().setField(FieldKey.ALBUM,ALBUM_TEST_STRING2);
 
866
        af.commit();
 
867
        af = AudioFileIO.read(testFile);
 
868
        assertEquals(ALBUM_TEST_STRING2, af.getTag().getFirst(FieldKey.ALBUM));
 
869
        assertEquals(ALBUM_TEST_STRING2, af.getTag().getFirst(FieldKey.ALBUM));
 
870
        assertEquals(ALBUM_TEST_STRING2, ((ID3v22Tag) af.getTag()).getFirst(ID3v22FieldKey.ALBUM));
 
871
        assertEquals(1,af.getTag().getFields(FieldKey.ALBUM).size());
 
872
 
 
873
        //and deleteField it
 
874
        af.getTag().deleteField(FieldKey.ALBUM);
 
875
        af.commit();
 
876
        af = AudioFileIO.read(testFile);
 
877
        assertEquals("", af.getTag().getFirst(FieldKey.ALBUM));
 
878
        assertEquals("", af.getTag().getFirst(FieldKey.ALBUM));
 
879
        assertEquals("", ((ID3v22Tag) af.getTag()).getFirst(ID3v22FieldKey.ALBUM));
 
880
        assertEquals(0, af.getTag().getFields(FieldKey.ALBUM).size());
 
881
 
 
882
        //Test out the other basic fields
 
883
        //Year
 
884
        af.getTag().setField(FieldKey.YEAR,"1991");
 
885
        af.commit();
 
886
        af = AudioFileIO.read(testFile);
 
887
        assertEquals("1991", af.getTag().getFirst(FieldKey.YEAR));
 
888
        assertEquals("1991", af.getTag().getFirst(FieldKey.YEAR));
 
889
        assertEquals("1991", ((ID3v22Tag) af.getTag()).getFirst(ID3v22FieldKey.YEAR));
 
890
        assertEquals(1, af.getTag().getFields(FieldKey.YEAR).size());
 
891
        assertEquals(2, af.getTag().getFieldCount());
 
892
 
 
893
        //Title
 
894
        af.getTag().setField(FieldKey.TITLE,"Title");
 
895
        af.commit();
 
896
        af = AudioFileIO.read(testFile);
 
897
        assertEquals("Title", af.getTag().getFirst(FieldKey.TITLE));
 
898
        assertEquals("Title", af.getTag().getFirst(FieldKey.TITLE));
 
899
        assertEquals("Title", ((ID3v22Tag) af.getTag()).getFirst(ID3v22FieldKey.TITLE));
 
900
        assertEquals(1, af.getTag().getFields(FieldKey.TITLE).size());
 
901
        assertEquals(3, af.getTag().getFieldCount());
 
902
 
 
903
        //Comment, trickier because uses different framebody subclass to the ones above
 
904
        af.getTag().setField(FieldKey.COMMENT,"Comment");
 
905
        af.commit();
 
906
        af = AudioFileIO.read(testFile);
 
907
        assertEquals("Comment", af.getTag().getFirst(FieldKey.COMMENT));
 
908
        assertEquals("Comment", af.getTag().getFirst(FieldKey.COMMENT));
 
909
        assertEquals("Comment", ((ID3v22Tag) af.getTag()).getFirst(ID3v22FieldKey.COMMENT));
 
910
        assertEquals(1, af.getTag().getFields(FieldKey.COMMENT).size());
 
911
        assertEquals(4, af.getTag().getFieldCount());
 
912
 
 
913
        //Genre
 
914
        //TODO only one genre frame allowed, but that can contain multiple GENRE values, currently
 
915
        //must parse as one genre e.g 34 67
 
916
        af.getTag().setField(FieldKey.GENRE,"CustomGenre");
 
917
        af.commit();
 
918
        af = AudioFileIO.read(testFile);
 
919
        assertEquals("CustomGenre", af.getTag().getFirst(FieldKey.GENRE));
 
920
        assertEquals("CustomGenre", af.getTag().getFirst(FieldKey.GENRE));
 
921
        assertEquals("CustomGenre", ((ID3v22Tag) af.getTag()).getFirst(ID3v22FieldKey.GENRE));
 
922
        assertEquals(1, af.getTag().getFields(FieldKey.GENRE).size());
 
923
        assertEquals(5, af.getTag().getFieldCount());
 
924
 
 
925
        //Track
 
926
        af.getTag().setField(FieldKey.TRACK,"7");
 
927
        af.getTag().setField(af.getTag().createField(FieldKey.TRACK_TOTAL, "11"));
 
928
        assertEquals("7",af.getTag().getFirst(FieldKey.TRACK));
 
929
        assertEquals("11",af.getTag().getFirst(FieldKey.TRACK_TOTAL));
 
930
        af.commit();
 
931
        af = AudioFileIO.read(testFile);
 
932
        assertEquals("7", af.getTag().getFirst(FieldKey.TRACK));
 
933
        assertEquals("7", af.getTag().getFirst(FieldKey.TRACK));
 
934
        assertEquals("7", ((ID3v22Tag) af.getTag()).getFirst(ID3v22FieldKey.TRACK));
 
935
        assertEquals("11",af.getTag().getFirst(FieldKey.TRACK_TOTAL));
 
936
        assertEquals(1, af.getTag().getFields(FieldKey.TRACK).size());
 
937
        assertEquals(1, af.getTag().getFields(FieldKey.TRACK).size());
 
938
        assertEquals(6, af.getTag().getFieldCount());
 
939
 
 
940
        //AmazonId
 
941
        //This is one of many fields that uses the TXXX frame, the logic is more complicated
 
942
        af.getTag().setField(af.getTag().createField(FieldKey.AMAZON_ID, "asin123456" + "\u01ff"));
 
943
        af.commit();
 
944
        af = AudioFileIO.read(testFile);
 
945
 
 
946
        //Mood
 
947
        af.getTag().setField(af.getTag().createField(FieldKey.MOOD, "mood"));
 
948
        af.commit();
 
949
        af = AudioFileIO.read(testFile);
 
950
         assertEquals("mood", af.getTag().getFirst(FieldKey.MOOD));
 
951
        //Now deleteField field
 
952
        af.getTag().deleteField(FieldKey.MOOD);
 
953
        af.commit();
 
954
        af = AudioFileIO.read(testFile);
 
955
 
 
956
        assertEquals("asin123456" + "\u01ff", af.getTag().getFirst(FieldKey.AMAZON_ID));
 
957
        assertEquals("asin123456" + "\u01ff", ((ID3v22Tag) af.getTag()).getFirst(ID3v22FieldKey.AMAZON_ID));
 
958
        assertEquals(1, af.getTag().getFields(FieldKey.AMAZON_ID).size());
 
959
        assertEquals(7, af.getTag().getFieldCount());
 
960
 
 
961
        //Now addField another different field that also uses a TXX frame
 
962
        af.getTag().setField(af.getTag().createField(FieldKey.MUSICIP_ID, "musicip_id"));
 
963
        af.commit();
 
964
        af = AudioFileIO.read(testFile);
 
965
        assertEquals(2, ((List) ((ID3v22Tag) af.getTag()).getFrame("TXX")).size());
 
966
        assertEquals("musicip_id", af.getTag().getFirst(FieldKey.MUSICIP_ID));
 
967
        assertEquals("musicip_id", ((ID3v22Tag) af.getTag()).getFirst(ID3v22FieldKey.MUSICIP_ID));
 
968
        assertEquals(1, af.getTag().getFields(FieldKey.MUSICIP_ID).size());
 
969
        assertEquals("asin123456" + "\u01ff", af.getTag().getFirst(FieldKey.AMAZON_ID));
 
970
        assertEquals(8, af.getTag().getFieldCount());
 
971
 
 
972
        //Now addField yet another different field that also uses a TXX frame
 
973
        af.getTag().setField(af.getTag().createField(FieldKey.MUSICBRAINZ_RELEASEID, "releaseid"));
 
974
        af.commit();
 
975
        af = AudioFileIO.read(testFile);
 
976
        assertEquals(3, ((List) ((ID3v22Tag) af.getTag()).getFrame("TXX")).size());
 
977
        assertEquals("musicip_id", af.getTag().getFirst(FieldKey.MUSICIP_ID));
 
978
        assertEquals("releaseid", af.getTag().getFirst(FieldKey.MUSICBRAINZ_RELEASEID));
 
979
        assertEquals("asin123456" + "\u01ff", af.getTag().getFirst(FieldKey.AMAZON_ID));
 
980
        assertEquals(1, af.getTag().getFields(FieldKey.MUSICIP_ID).size());
 
981
        assertEquals(1, af.getTag().getFields(FieldKey.AMAZON_ID).size());
 
982
        assertEquals(1, af.getTag().getFields(FieldKey.MUSICBRAINZ_RELEASEID).size());
 
983
        assertEquals(9, af.getTag().getFieldCount());
 
984
 
 
985
        //Now deleteField field
 
986
        af.getTag().deleteField(FieldKey.MUSICBRAINZ_RELEASEID);
 
987
        af.commit();
 
988
        af = AudioFileIO.read(testFile);
 
989
        assertEquals(2, ((List) ((ID3v22Tag) af.getTag()).getFrame("TXX")).size());
 
990
        assertEquals(1, af.getTag().getFields(FieldKey.MUSICIP_ID).size());
 
991
        assertEquals(1, af.getTag().getFields(FieldKey.AMAZON_ID).size());
 
992
        assertEquals(8, af.getTag().getFieldCount());
 
993
 
 
994
        //Cover Art:invalid way to do it
 
995
        try
 
996
        {
 
997
            af.getTag().setField(af.getTag().createField(FieldKey.COVER_ART, "coverart"));
 
998
        }
 
999
        catch (java.lang.UnsupportedOperationException uoe)
 
1000
        {
 
1001
            e = uoe;
 
1002
        }
 
1003
        assertTrue(e instanceof UnsupportedOperationException);
 
1004
 
 
1005
        //Add new image correctly
 
1006
        RandomAccessFile imageFile = new RandomAccessFile(new File("testdata", "coverart.png"), "r");
 
1007
        byte[] imagedata = new byte[(int) imageFile.length()];
 
1008
        imageFile.read(imagedata);
 
1009
        af.getTag().addField(tag.createArtworkField(imagedata, "image/png"));
 
1010
        af.commit();
 
1011
        af = AudioFileIO.read(testFile);
 
1012
        assertEquals(1, af.getTag().getFields(FieldKey.COVER_ART).size());
 
1013
        assertEquals(9, af.getTag().getFieldCount());
 
1014
 
 
1015
        //Add another image correctly
 
1016
        imageFile = new RandomAccessFile(new File("testdata", "coverart_small.png"), "r");
 
1017
        imagedata = new byte[(int) imageFile.length()];
 
1018
        imageFile.read(imagedata);
 
1019
        af.getTag().addField(tag.createArtworkField(imagedata, "image/png"));
 
1020
        af.commit();
 
1021
        af = AudioFileIO.read(testFile);
 
1022
        assertEquals(2, af.getTag().getFields(FieldKey.COVER_ART).size());
 
1023
        assertEquals(10, af.getTag().getFieldCount());
 
1024
    }
 
1025
 
 
1026
    /**
 
1027
     * Test how adding multiple frameswith new interface  of same type is is handled
 
1028
     *
 
1029
     * @throws Exception
 
1030
     */
 
1031
    public void testSettingMultipleFramesofSameType() throws Exception
 
1032
    {
 
1033
        Exception e = null;
 
1034
        File testFile = AbstractTestCase.copyAudioToTmp("testV1.mp3", new File("testSetMultiple.mp3"));
 
1035
        AudioFile af = AudioFileIO.read(testFile);
 
1036
        MP3File mp3File = (MP3File) af;
 
1037
        ID3v24Tag tag = new ID3v24Tag();
 
1038
        ID3v24Frame frame = new ID3v24Frame(ID3v24Frames.FRAME_ID_COMMENT);
 
1039
        ((FrameBodyCOMM) frame.getBody()).setText("Comment");
 
1040
        tag.setFrame(frame);
 
1041
        mp3File.setID3v2TagOnly(tag);
 
1042
        mp3File.save();
 
1043
        af = AudioFileIO.read(testFile);
 
1044
        mp3File = (MP3File) af;
 
1045
 
 
1046
        //COMM
 
1047
        {
 
1048
            ID3v24Frame commentFrame = (ID3v24Frame) ((ID3v24Tag) af.getTag()).getFrame("COMM");
 
1049
            FrameBodyCOMM fb = (FrameBodyCOMM) commentFrame.getBody();
 
1050
            assertEquals("", fb.getDescription());
 
1051
            assertEquals("Comment", fb.getText());
 
1052
            //Change description, cant do this with common interface
 
1053
            fb.setDescription("test");
 
1054
            //Because has different description the following setField will addField another comment rather than overwriting the first one
 
1055
            af.getTag().setField(FieldKey.COMMENT,"Comment2");
 
1056
            assertEquals(2, af.getTag().getFields(FieldKey.COMMENT).size());
 
1057
            //Add third Comment
 
1058
            List<TagField> comments = af.getTag().getFields(FieldKey.COMMENT);
 
1059
            ((FrameBodyCOMM) ((ID3v24Frame) comments.get(1)).getBody()).setDescription("test2");
 
1060
            af.getTag().setField(FieldKey.COMMENT,"Comment3");
 
1061
            af.commit();
 
1062
            af = AudioFileIO.read(testFile);
 
1063
            assertEquals(3, af.getTag().getFields(FieldKey.COMMENT).size());
 
1064
 
 
1065
            //Add fourth Comment (but duplicate key - so overwrites 3rd comment)
 
1066
            af.getTag().setField(FieldKey.COMMENT,"Comment4");
 
1067
            af.commit();
 
1068
            af = AudioFileIO.read(testFile);
 
1069
            assertEquals(3, af.getTag().getFields(FieldKey.COMMENT).size());
 
1070
 
 
1071
            //Add comment using generic call
 
1072
            af.getTag().setField(af.getTag().createField(FieldKey.COMMENT, "abcdef-ghijklmn"));
 
1073
 
 
1074
            //Remove all Comment tags
 
1075
            af.getTag().deleteField(FieldKey.COMMENT);
 
1076
            assertEquals(0, af.getTag().getFields(FieldKey.COMMENT).size());
 
1077
 
 
1078
            //Add first one back in
 
1079
            af.getTag().setField(FieldKey.COMMENT,"Comment");
 
1080
            af.commit();
 
1081
            af = AudioFileIO.read(testFile);
 
1082
            assertEquals(1, af.getTag().getFields(FieldKey.COMMENT).size());
 
1083
            assertEquals(1, af.getTag().getFieldCount());
 
1084
        }
 
1085
 
 
1086
        //TXXX
 
1087
        {
 
1088
            tag = (ID3v24Tag) af.getTag();
 
1089
            frame = new ID3v24Frame(ID3v24Frames.FRAME_ID_USER_DEFINED_INFO);
 
1090
            ((FrameBodyTXXX) frame.getBody()).setText("UserDefined");
 
1091
            tag.setFrame(frame);
 
1092
            ID3v24Frame txxxFrame = (ID3v24Frame) tag.getFrame("TXXX");
 
1093
            FrameBodyTXXX fb = (FrameBodyTXXX) txxxFrame.getBody();
 
1094
            assertEquals("", fb.getDescription());
 
1095
            assertEquals("UserDefined", fb.getText());
 
1096
            //Change description, cant do this with common interface
 
1097
            fb.setDescription("test");
 
1098
            //Because has different description the following setField will addField another txxx rather than overwriting the first one
 
1099
            af.getTag().setField(af.getTag().createField(FieldKey.MUSICBRAINZ_ARTISTID, "abcdef-ghijklmn"));
 
1100
            assertEquals(2, ((List) tag.getFrame("TXXX")).size());
 
1101
            //Now adding TXXX with same id so gets overwritten
 
1102
            af.getTag().setField(af.getTag().createField(FieldKey.MUSICBRAINZ_ARTISTID, "abcfffff"));
 
1103
            assertEquals(2, ((List) tag.getFrame("TXXX")).size());
 
1104
 
 
1105
            //Try deleting some of these
 
1106
            tag.removeFrameOfType("TXXX");
 
1107
            assertNull(tag.getFrame("TXXX"));
 
1108
 
 
1109
            af.getTag().setField(af.getTag().createField(FieldKey.MUSICBRAINZ_ARTISTID, "abcdef-ghijklmn"));
 
1110
            ((ID3v24Tag) af.getTag()).deleteField(FieldKey.MUSICBRAINZ_ARTISTID);
 
1111
            assertNull(tag.getFrame("TXXX"));
 
1112
 
 
1113
        }
 
1114
 
 
1115
        //UFID
 
1116
        {
 
1117
            tag = (ID3v24Tag) af.getTag();
 
1118
            frame = new ID3v24Frame(ID3v24Frames.FRAME_ID_UNIQUE_FILE_ID);
 
1119
            ((FrameBodyUFID) frame.getBody()).setOwner("owner");
 
1120
            tag.setFrame(frame);
 
1121
            ID3v24Frame ufidFrame = (ID3v24Frame) tag.getFrame("UFID");
 
1122
            FrameBodyUFID fb = (FrameBodyUFID) ufidFrame.getBody();
 
1123
            assertEquals("owner", fb.getOwner());
 
1124
 
 
1125
            //Because has different owner the following setField will addField another ufid rather than overwriting the first one
 
1126
            af.getTag().setField(af.getTag().createField(FieldKey.MUSICBRAINZ_TRACK_ID, "abcdef-ghijklmn"));
 
1127
            assertEquals(2, ((List) tag.getFrame("UFID")).size());
 
1128
            //Now adding UFID with same owner so gets overwritten
 
1129
            af.getTag().setField(af.getTag().createField(FieldKey.MUSICBRAINZ_TRACK_ID, "abcfffff"));
 
1130
            assertEquals(2, ((List) tag.getFrame("UFID")).size());
 
1131
 
 
1132
            //Try deleting some of these
 
1133
            tag.removeFrame("UFID");
 
1134
            assertNull(tag.getFrame("UFID"));
 
1135
        }
 
1136
 
 
1137
        //ULST
 
1138
        {
 
1139
            tag = (ID3v24Tag) af.getTag();
 
1140
            frame = new ID3v24Frame(ID3v24Frames.FRAME_ID_UNSYNC_LYRICS);
 
1141
            ((FrameBodyUSLT) frame.getBody()).setDescription("lyrics1");
 
1142
            tag.setFrame(frame);
 
1143
            ID3v24Frame usltFrame = (ID3v24Frame) tag.getFrame("USLT");
 
1144
            FrameBodyUSLT fb = (FrameBodyUSLT) usltFrame.getBody();
 
1145
            assertEquals("lyrics1", fb.getDescription());
 
1146
 
 
1147
            //Because has different desc the following setField will addField another uslt rather than overwriting the first one
 
1148
            af.getTag().setField(af.getTag().createField(FieldKey.LYRICS, "abcdef-ghijklmn"));
 
1149
            assertEquals(2, ((List) tag.getFrame("USLT")).size());
 
1150
            assertEquals(2, af.getTag().getFields(FieldKey.LYRICS).size());
 
1151
            frame = (ID3v24Frame) ((List) tag.getFrame("USLT")).get(1);
 
1152
            assertEquals("", ((FrameBodyUSLT) frame.getBody()).getDescription());
 
1153
            //Now adding USLT with same description so gets overwritten
 
1154
            af.getTag().setField(af.getTag().createField(FieldKey.LYRICS, "abcfffff"));
 
1155
            assertEquals(2, ((List) tag.getFrame("USLT")).size());
 
1156
            assertEquals(2, af.getTag().getFields(FieldKey.LYRICS).size());
 
1157
 
 
1158
        }
 
1159
 
 
1160
        //POPM TODO not a supported FieldKey yet
 
1161
        {
 
1162
            tag = (ID3v24Tag) af.getTag();
 
1163
            frame = new ID3v24Frame(ID3v24Frames.FRAME_ID_POPULARIMETER);
 
1164
            ((FrameBodyPOPM) frame.getBody()).setEmailToUser("paultaylor@jthink.net");
 
1165
            tag.setFrame(frame);
 
1166
            ID3v24Frame popmFrame = (ID3v24Frame) tag.getFrame("POPM");
 
1167
            FrameBodyPOPM fb = (FrameBodyPOPM) popmFrame.getBody();
 
1168
            assertEquals("paultaylor@jthink.net", fb.getEmailToUser());
 
1169
        }
 
1170
 
 
1171
    }
 
1172
 
 
1173
   
 
1174
    public void testIterator() throws Exception
 
1175
    {
 
1176
        File orig = new File("testdata", "test26.mp3");
 
1177
        if (!orig.isFile())
 
1178
        {
 
1179
            return;
 
1180
        }
 
1181
 
 
1182
        Exception e = null;
 
1183
        File testFile = AbstractTestCase.copyAudioToTmp("test26.mp3");
 
1184
        MP3File mp3File = new MP3File(testFile);
 
1185
 
 
1186
 
 
1187
        assertEquals(0, mp3File.getID3v2Tag().getFieldCount());
 
1188
        Iterator<TagField> i = mp3File.getID3v2Tag().getFields();
 
1189
        assertFalse(i.hasNext());
 
1190
        try
 
1191
        {
 
1192
            i.next();
 
1193
        }
 
1194
        catch(Exception ex)
 
1195
        {
 
1196
            e=ex;
 
1197
        }
 
1198
        assertTrue(e instanceof NoSuchElementException);
 
1199
 
 
1200
        mp3File.getID3v2Tag().addField(FieldKey.ALBUM,"album");
 
1201
        assertEquals(1, mp3File.getID3v2Tag().getFieldCount());
 
1202
        i = mp3File.getID3v2Tag().getFields();
 
1203
 
 
1204
        //Should be able to iterate without actually having to call isNext() first
 
1205
        i.next();
 
1206
 
 
1207
        //Should be able to call hasNext() without it having any effect
 
1208
        i = mp3File.getID3v2Tag().getFields();
 
1209
        assertTrue(i.hasNext());
 
1210
        Object o = i.next();
 
1211
        assertTrue( o instanceof ID3v23Frame);
 
1212
        assertEquals("album",((AbstractFrameBodyTextInfo)(((ID3v23Frame)o).getBody())).getFirstTextValue());
 
1213
 
 
1214
        try
 
1215
        {
 
1216
            i.next();
 
1217
        }
 
1218
        catch(Exception ex)
 
1219
        {
 
1220
            e=ex;
 
1221
        }
 
1222
        assertTrue(e instanceof NoSuchElementException);
 
1223
        assertFalse(i.hasNext());
 
1224
 
 
1225
        //Empty frame map and force adding of empty list
 
1226
        mp3File.getID3v2Tag().frameMap.clear();
 
1227
        mp3File.getID3v2Tag().frameMap.put("TXXX",new ArrayList());
 
1228
        assertEquals(0,mp3File.getID3v2Tag().getFieldCount());
 
1229
 
 
1230
        //Issue #236
 
1231
        //i = mp3File.getID3v2Tag().getFields();
 
1232
        //assertFalse(i.hasNext());
 
1233
    }
 
1234
 
 
1235
    /**
 
1236
     * Currently genres are written to and from v2 tag as is, the decoding from genre number to string has to be done manually
 
1237
     */
 
1238
    public void testGenres()
 
1239
    {
 
1240
        Exception ex = null;
 
1241
        try
 
1242
        {
 
1243
            File testFile = AbstractTestCase.copyAudioToTmp("testV1.mp3", new File("testBasicWrite.mp3"));
 
1244
            org.jaudiotagger.audio.AudioFile audioFile = org.jaudiotagger.audio.AudioFileIO.read(testFile);
 
1245
            org.jaudiotagger.tag.Tag newTag = audioFile.getTag();
 
1246
            assertTrue(newTag == null);
 
1247
            if (audioFile.getTag() == null)
 
1248
            {
 
1249
                audioFile.setTag(new ID3v23Tag());
 
1250
                newTag = audioFile.getTag();
 
1251
            }
 
1252
 
 
1253
            //Write literal String
 
1254
            newTag.setField(FieldKey.GENRE,"Rock");
 
1255
            audioFile.commit();
 
1256
            audioFile = org.jaudiotagger.audio.AudioFileIO.read(testFile);
 
1257
            newTag = audioFile.getTag();
 
1258
            //..and read back
 
1259
            assertEquals("Rock", newTag.getFirst(FieldKey.GENRE));
 
1260
 
 
1261
            //Write Code
 
1262
            newTag.setField(FieldKey.GENRE,"(17)");
 
1263
            audioFile.commit();
 
1264
            audioFile = org.jaudiotagger.audio.AudioFileIO.read(testFile);
 
1265
            newTag = audioFile.getTag();
 
1266
            //..and read back
 
1267
            assertEquals("(17)", newTag.getFirst(FieldKey.GENRE));
 
1268
 
 
1269
        }
 
1270
        catch (Exception e)
 
1271
        {
 
1272
            ex = e;
 
1273
            ex.printStackTrace();
 
1274
        }
 
1275
        assertNull(ex);
 
1276
    }
 
1277
 
 
1278
    public void testRemoveFrameOfType()
 
1279
    {
 
1280
        File orig = new File("testdata", "test30.mp3");
 
1281
        if (!orig.isFile())
 
1282
        {
 
1283
            return;
 
1284
        }
 
1285
 
 
1286
        Exception exceptionCaught = null;
 
1287
        File testFile = AbstractTestCase.copyAudioToTmp("test30.mp3");
 
1288
        MP3File mp3file = null;
 
1289
        try
 
1290
        {
 
1291
            mp3file = new MP3File(testFile);
 
1292
            //deleteField multiple frames starting make change to file
 
1293
            ((ID3v24Tag) mp3file.getID3v2Tag()).removeFrameOfType("PRIV");
 
1294
 
 
1295
        }
 
1296
        catch (Exception e)
 
1297
        {
 
1298
            e.printStackTrace();
 
1299
            exceptionCaught = e;
 
1300
        }
 
1301
        assertNull(exceptionCaught);
 
1302
 
 
1303
 
 
1304
    }
 
1305
}