← Back to branch summary

~ubuntu-branches/ubuntu/utopic/libjaudiotagger-java/utopic

« back to all changes in this revision

Viewing changes to srctest/org/jaudiotagger/tag/id3/ID3v11TagTest.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/ID3v11TagTest.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.tag.FieldKey;
7
 
import org.jaudiotagger.tag.TagOptionSingleton;
8
 
import org.jaudiotagger.tag.TagTextField;
9
 
 
10
 
/**
11
 
 *
12
 
 */
13
 
public class ID3v11TagTest extends TestCase
14
 
{
15
 
    public static final String ARTIST = "artist";
16
 
    public static final String ALBUM = "album";
17
 
    public static final String COMMENT = "comment";
18
 
    public static final String TITLE = "title";
19
 
    public static final String TRACK_VALUE = "10";
20
 
    public static final String GENRE_VAL = "Country";
21
 
    public static final String YEAR = "1971";
22
 
 
23
 
    /**
24
 
     * Provides an initilised object to be used in other tests
25
 
     * to prevent code duplication
26
 
     *
27
 
     * @return ID3v11Tag
28
 
     */
29
 
    public static ID3v11Tag getInitialisedTag()
30
 
    {
31
 
        ID3v11Tag v11Tag = new ID3v11Tag();
32
 
        v11Tag.setArtist(ARTIST);
33
 
        v11Tag.setAlbum(ALBUM);
34
 
        v11Tag.setComment(COMMENT);
35
 
        v11Tag.setTitle(TITLE);
36
 
        v11Tag.setTrack(TRACK_VALUE);
37
 
        v11Tag.setGenre(GENRE_VAL);
38
 
        v11Tag.setYear(YEAR);
39
 
        return v11Tag;
40
 
    }
41
 
 
42
 
    /**
43
 
     * Constructor
44
 
     *
45
 
     * @param arg0
46
 
     */
47
 
    public ID3v11TagTest(String arg0)
48
 
    {
49
 
        super(arg0);
50
 
    }
51
 
 
52
 
    /**
53
 
     * Command line entrance.
54
 
     *
55
 
     * @param args
56
 
     */
57
 
    public static void main(String[] args)
58
 
    {
59
 
        junit.textui.TestRunner.run(ID3v11TagTest.suite());
60
 
    }
61
 
 
62
 
    /////////////////////////////////////////////////////////////////////////
63
 
    // TestCase classes to override
64
 
    /////////////////////////////////////////////////////////////////////////
65
 
 
66
 
    /**
67
 
      *
68
 
      */
69
 
     protected void setUp()
70
 
     {
71
 
         TagOptionSingleton.getInstance().setToDefault();
72
 
     }
73
 
 
74
 
     /**
75
 
      *
76
 
      */
77
 
     protected void tearDown()
78
 
     {
79
 
     }
80
 
 
81
 
    /**
82
 
     *
83
 
     */
84
 
//    protected void runTest()
85
 
//    {
86
 
//    }
87
 
 
88
 
    /**
89
 
     * Builds the Test Suite.
90
 
     *
91
 
     * @return the Test Suite.
92
 
     */
93
 
    public static Test suite()
94
 
    {
95
 
        return new TestSuite(ID3v11TagTest.class);
96
 
    }
97
 
 
98
 
    /////////////////////////////////////////////////////////////////////////
99
 
    // Tests
100
 
    /////////////////////////////////////////////////////////////////////////
101
 
 
102
 
    public void testCreateID3v11Tag()
103
 
    {
104
 
        ID3v11Tag v11Tag = new ID3v11Tag();
105
 
        v11Tag.setArtist(ARTIST);
106
 
        v11Tag.setAlbum(ALBUM);
107
 
        v11Tag.setComment(COMMENT);
108
 
        v11Tag.setTitle(TITLE);
109
 
        v11Tag.setTrack(TRACK_VALUE);
110
 
        v11Tag.setGenre(GENRE_VAL);
111
 
        v11Tag.setYear(YEAR);
112
 
 
113
 
        assertEquals((byte) 1, v11Tag.getRelease());
114
 
        assertEquals((byte) 1, v11Tag.getMajorVersion());
115
 
        assertEquals((byte) 0, v11Tag.getRevision());
116
 
 
117
 
        assertEquals(ARTIST, v11Tag.getFirst(FieldKey.ARTIST));
118
 
        assertEquals(ALBUM, v11Tag.getFirst(FieldKey.ALBUM));
119
 
        assertEquals(COMMENT, v11Tag.getFirstComment());
120
 
        assertEquals(TITLE, v11Tag.getFirst(FieldKey.TITLE));
121
 
        assertEquals(TRACK_VALUE, v11Tag.getFirst(FieldKey.TRACK));
122
 
        assertEquals(GENRE_VAL, v11Tag.getFirst(FieldKey.GENRE));
123
 
        assertEquals(YEAR, v11Tag.getFirst(FieldKey.YEAR));
124
 
 
125
 
        //Check with entagged interface
126
 
        assertEquals(ID3v1TagTest.ARTIST, ((TagTextField) v11Tag.getArtist().get(0)).getContent());
127
 
        assertEquals(ID3v1TagTest.ALBUM, ((TagTextField) v11Tag.getAlbum().get(0)).getContent());
128
 
        assertEquals(ID3v1TagTest.COMMENT, ((TagTextField) v11Tag.getComment().get(0)).getContent());
129
 
        assertEquals(ID3v1TagTest.TITLE, ((TagTextField) v11Tag.getTitle().get(0)).getContent());
130
 
        assertEquals(ID3v1TagTest.GENRE_VAL, ((TagTextField) v11Tag.getGenre().get(0)).getContent());
131
 
        assertEquals(ID3v1TagTest.TRACK_VALUE, ((TagTextField) v11Tag.getTrack().get(0)).getContent());
132
 
        assertEquals(ID3v1TagTest.YEAR, ((TagTextField) v11Tag.getYear().get(0)).getContent());
133
 
 
134
 
 
135
 
    }
136
 
 
137
 
    public void testCreateID3v11FromID3v24()
138
 
    {
139
 
        ID3v24Tag v2Tag = new ID3v24Tag();
140
 
        ID3v11Tag v1Tag = new ID3v11Tag(v2Tag);
141
 
        assertNotNull(v1Tag);
142
 
        assertEquals((byte) 1, v1Tag.getRelease());
143
 
        assertEquals((byte) 1, v1Tag.getMajorVersion());
144
 
        assertEquals((byte) 0, v1Tag.getRevision());
145
 
 
146
 
 
147
 
    }
148
 
 
149
 
    public void testCreateID3v11FromID3v23()
150
 
    {
151
 
        ID3v23Tag v2Tag = new ID3v23Tag();
152
 
        ID3v11Tag v1Tag = new ID3v11Tag(v2Tag);
153
 
        assertNotNull(v1Tag);
154
 
        assertEquals((byte) 1, v1Tag.getRelease());
155
 
        assertEquals((byte) 1, v1Tag.getMajorVersion());
156
 
        assertEquals((byte) 0, v1Tag.getRevision());
157
 
 
158
 
    }
159
 
 
160
 
    public void testCreateID3v11FromID3v22()
161
 
    {
162
 
        ID3v22Tag v2Tag = new ID3v22Tag();
163
 
        ID3v11Tag v1Tag = new ID3v11Tag(v2Tag);
164
 
        assertNotNull(v1Tag);
165
 
        assertEquals((byte) 1, v1Tag.getRelease());
166
 
        assertEquals((byte) 1, v1Tag.getMajorVersion());
167
 
        assertEquals((byte) 0, v1Tag.getRevision());
168
 
    }
169
 
 
170
 
    public void testNewInterface()
171
 
    {
172
 
        Exception exceptionCaught = null;
173
 
        ID3v1Tag v1Tag = new ID3v11Tag();
174
 
        assertTrue(v1Tag.isEmpty());
175
 
 
176
 
        v1Tag.setField(new ID3v1TagField(FieldKey.ARTIST.name(), "artist"));
177
 
        assertEquals("artist", ((TagTextField) v1Tag.getFields(FieldKey.ARTIST).get(0)).getContent());
178
 
        assertEquals("artist", v1Tag.getFirst(FieldKey.ARTIST));
179
 
        assertEquals("artist", ((TagTextField) (v1Tag.getArtist().get(0))).getContent());
180
 
        assertEquals("artist", ((TagTextField) v1Tag.getFirstField(FieldKey.ARTIST.name())).getContent());
181
 
        assertEquals("artist", ((TagTextField) (v1Tag.get(FieldKey.ARTIST.name()).get(0))).getContent());
182
 
 
183
 
        v1Tag.setField(new ID3v1TagField(FieldKey.ALBUM.name(), "album"));
184
 
        assertEquals("album", ((TagTextField) v1Tag.getFields(FieldKey.ALBUM).get(0)).getContent());
185
 
        assertEquals("album", v1Tag.getFirst(FieldKey.ALBUM));
186
 
        assertEquals("album", ((TagTextField) (v1Tag.getAlbum().get(0))).getContent());
187
 
        assertEquals("album", ((TagTextField) v1Tag.getFirstField(FieldKey.ALBUM.name())).getContent());
188
 
 
189
 
        v1Tag.setField(new ID3v1TagField(FieldKey.TITLE.name(), "title"));
190
 
        assertEquals("title", ((TagTextField) v1Tag.getFields(FieldKey.TITLE).get(0)).getContent());
191
 
        assertEquals("title", v1Tag.getFirst(FieldKey.TITLE));
192
 
        assertEquals("title", ((TagTextField) (v1Tag.getTitle().get(0))).getContent());
193
 
        assertEquals("title", ((TagTextField) v1Tag.getFirstField(FieldKey.TITLE.name())).getContent());
194
 
 
195
 
        v1Tag.setField(new ID3v1TagField(FieldKey.YEAR.name(), "year"));
196
 
        assertEquals("year", ((TagTextField) v1Tag.getFields(FieldKey.YEAR).get(0)).getContent());
197
 
        assertEquals("year", v1Tag.getFirst(FieldKey.YEAR));
198
 
        assertEquals("year", ((TagTextField) (v1Tag.getYear().get(0))).getContent());
199
 
        assertEquals("year", ((TagTextField) v1Tag.getFirstField(FieldKey.YEAR.name())).getContent());
200
 
 
201
 
        v1Tag.setField(new ID3v1TagField(FieldKey.GENRE.name(), "Country"));
202
 
        assertEquals("Country", ((TagTextField) v1Tag.getFields(FieldKey.GENRE).get(0)).getContent());
203
 
        assertEquals("Country", v1Tag.getFirst(FieldKey.GENRE));
204
 
        assertEquals("Country", ((TagTextField) (v1Tag.getGenre().get(0))).getContent());
205
 
        assertEquals("Country", ((TagTextField) v1Tag.getFirstField(FieldKey.GENRE.name())).getContent());
206
 
 
207
 
        v1Tag.setField(new ID3v1TagField(FieldKey.COMMENT.name(), "comment"));
208
 
        assertEquals("comment", ((TagTextField) v1Tag.getFields(FieldKey.COMMENT).get(0)).getContent());
209
 
        assertEquals("comment", v1Tag.getFirstComment());
210
 
        assertEquals("comment", ((TagTextField) (v1Tag.getFields(FieldKey.COMMENT).get(0))).getContent());
211
 
        assertEquals("comment", ((TagTextField) v1Tag.getFirstField(FieldKey.COMMENT.name())).getContent());
212
 
 
213
 
        v1Tag.setField(new ID3v1TagField(FieldKey.TRACK.name(), "5"));
214
 
        assertEquals("5", ((TagTextField) v1Tag.getFields(FieldKey.TRACK).get(0)).getContent());
215
 
        assertEquals("5", v1Tag.getFirst(FieldKey.TRACK));
216
 
        assertEquals("5", ((TagTextField) (v1Tag.getTrack().get(0))).getContent());
217
 
        assertEquals("5", ((TagTextField) v1Tag.getFirstField(FieldKey.TRACK.name())).getContent());
218
 
 
219
 
        //Check nothing been overwritten
220
 
        assertEquals("year", v1Tag.getFirst(FieldKey.YEAR));
221
 
        assertEquals("Country", v1Tag.getFirst(FieldKey.GENRE));
222
 
        assertEquals("title", v1Tag.getFirst(FieldKey.TITLE));
223
 
        assertEquals("album", v1Tag.getFirst(FieldKey.ALBUM));
224
 
        assertEquals("artist", v1Tag.getFirst(FieldKey.ARTIST));
225
 
 
226
 
        //Delete artist field
227
 
        v1Tag.deleteField(FieldKey.ARTIST);
228
 
        assertEquals("", v1Tag.getFirst(FieldKey.ARTIST));
229
 
        assertEquals("year", v1Tag.getFirst(FieldKey.YEAR));
230
 
        assertEquals("Country", v1Tag.getFirst(FieldKey.GENRE));
231
 
        assertEquals("title", v1Tag.getFirst(FieldKey.TITLE));
232
 
        assertEquals("album", v1Tag.getFirst(FieldKey.ALBUM));
233
 
 
234
 
        //Not Empty
235
 
        assertFalse(v1Tag.isEmpty());
236
 
 
237
 
        v1Tag.deleteField(FieldKey.ALBUM);
238
 
        v1Tag.deleteField(FieldKey.YEAR);
239
 
        v1Tag.deleteField(FieldKey.GENRE);
240
 
        v1Tag.deleteField(FieldKey.TITLE);
241
 
        v1Tag.deleteField(FieldKey.COMMENT);
242
 
        v1Tag.setField(new ID3v1TagField(FieldKey.COMMENT.name(), ""));
243
 
        v1Tag.deleteField(FieldKey.TRACK);
244
 
        //Empty
245
 
        assertTrue(v1Tag.isEmpty());
246
 
 
247
 
        //Null Handling
248
 
        try
249
 
        {
250
 
            v1Tag.setField(new ID3v1TagField(FieldKey.COMMENT.name(), null));
251
 
        }
252
 
        catch (Exception e)
253
 
        {
254
 
            exceptionCaught = e;
255
 
        }
256
 
        assertTrue(exceptionCaught instanceof IllegalArgumentException);
257
 
    }
258
 
}
 
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.mp3.MP3File;
 
8
import org.jaudiotagger.tag.FieldKey;
 
9
import org.jaudiotagger.tag.TagOptionSingleton;
 
10
import org.jaudiotagger.tag.TagTextField;
 
11
 
 
12
import java.io.File;
 
13
 
 
14
/**
 
15
 *
 
16
 */
 
17
public class ID3v11TagTest extends TestCase
 
18
{
 
19
    public static final String ARTIST = "artist";
 
20
    public static final String ALBUM = "album";
 
21
    public static final String COMMENT = "comment";
 
22
    public static final String TITLE = "title";
 
23
    public static final String TRACK_VALUE = "10";
 
24
    public static final String GENRE_VAL = "Country";
 
25
    public static final String YEAR = "1971";
 
26
 
 
27
    /**
 
28
     * Provides an initilised object to be used in other tests
 
29
     * to prevent code duplication
 
30
     *
 
31
     * @return ID3v11Tag
 
32
     */
 
33
    public static ID3v11Tag getInitialisedTag()
 
34
    {
 
35
        ID3v11Tag v11Tag = new ID3v11Tag();
 
36
        v11Tag.setArtist(ARTIST);
 
37
        v11Tag.setAlbum(ALBUM);
 
38
        v11Tag.setComment(COMMENT);
 
39
        v11Tag.setTitle(TITLE);
 
40
        v11Tag.setTrack(TRACK_VALUE);
 
41
        v11Tag.setGenre(GENRE_VAL);
 
42
        v11Tag.setYear(YEAR);
 
43
        return v11Tag;
 
44
    }
 
45
 
 
46
    /**
 
47
     * Constructor
 
48
     *
 
49
     * @param arg0
 
50
     */
 
51
    public ID3v11TagTest(String arg0)
 
52
    {
 
53
        super(arg0);
 
54
    }
 
55
 
 
56
    /**
 
57
     * Command line entrance.
 
58
     *
 
59
     * @param args
 
60
     */
 
61
    public static void main(String[] args)
 
62
    {
 
63
        junit.textui.TestRunner.run(ID3v11TagTest.suite());
 
64
    }
 
65
 
 
66
    /////////////////////////////////////////////////////////////////////////
 
67
    // TestCase classes to override
 
68
    /////////////////////////////////////////////////////////////////////////
 
69
 
 
70
    /**
 
71
      *
 
72
      */
 
73
     protected void setUp()
 
74
     {
 
75
         TagOptionSingleton.getInstance().setToDefault();
 
76
     }
 
77
 
 
78
     /**
 
79
      *
 
80
      */
 
81
     protected void tearDown()
 
82
     {
 
83
     }
 
84
 
 
85
    /**
 
86
     *
 
87
     */
 
88
//    protected void runTest()
 
89
//    {
 
90
//    }
 
91
 
 
92
    /**
 
93
     * Builds the Test Suite.
 
94
     *
 
95
     * @return the Test Suite.
 
96
     */
 
97
    public static Test suite()
 
98
    {
 
99
        return new TestSuite(ID3v11TagTest.class);
 
100
    }
 
101
 
 
102
    /////////////////////////////////////////////////////////////////////////
 
103
    // Tests
 
104
    /////////////////////////////////////////////////////////////////////////
 
105
 
 
106
    public void testCreateID3v11Tag()     throws Exception
 
107
    {
 
108
        ID3v11Tag v11Tag = new ID3v11Tag();
 
109
        v11Tag.setArtist(ARTIST);
 
110
        v11Tag.setAlbum(ALBUM);
 
111
        v11Tag.setComment(COMMENT);
 
112
        v11Tag.setTitle(TITLE);
 
113
        v11Tag.setTrack(TRACK_VALUE);
 
114
        v11Tag.setGenre(GENRE_VAL);
 
115
        v11Tag.setYear(YEAR);
 
116
 
 
117
        assertEquals((byte) 1, v11Tag.getRelease());
 
118
        assertEquals((byte) 1, v11Tag.getMajorVersion());
 
119
        assertEquals((byte) 0, v11Tag.getRevision());
 
120
 
 
121
        assertEquals(ARTIST, v11Tag.getFirst(FieldKey.ARTIST));
 
122
        assertEquals(ALBUM, v11Tag.getFirst(FieldKey.ALBUM));
 
123
        assertEquals(COMMENT, v11Tag.getFirstComment());
 
124
        assertEquals(TITLE, v11Tag.getFirst(FieldKey.TITLE));
 
125
        assertEquals(TRACK_VALUE, v11Tag.getFirst(FieldKey.TRACK));
 
126
        assertEquals(GENRE_VAL, v11Tag.getFirst(FieldKey.GENRE));
 
127
        assertEquals(YEAR, v11Tag.getFirst(FieldKey.YEAR));
 
128
 
 
129
        //Check with entagged interface
 
130
        assertEquals(ID3v1TagTest.ARTIST, ((TagTextField) v11Tag.getArtist().get(0)).getContent());
 
131
        assertEquals(ID3v1TagTest.ALBUM, ((TagTextField) v11Tag.getAlbum().get(0)).getContent());
 
132
        assertEquals(ID3v1TagTest.COMMENT, ((TagTextField) v11Tag.getComment().get(0)).getContent());
 
133
        assertEquals(ID3v1TagTest.TITLE, ((TagTextField) v11Tag.getTitle().get(0)).getContent());
 
134
        assertEquals(ID3v1TagTest.GENRE_VAL, ((TagTextField) v11Tag.getGenre().get(0)).getContent());
 
135
        assertEquals(ID3v1TagTest.TRACK_VALUE, ((TagTextField) v11Tag.getTrack().get(0)).getContent());
 
136
        assertEquals(ID3v1TagTest.YEAR, ((TagTextField) v11Tag.getYear().get(0)).getContent());
 
137
 
 
138
        v11Tag.setField(FieldKey.TRACK,"3");
 
139
        assertEquals("3",v11Tag.getFirst(FieldKey.TRACK));
 
140
 
 
141
 
 
142
    }
 
143
 
 
144
    public void testCreateID3v11FromID3v24()
 
145
    {
 
146
        ID3v24Tag v2Tag = new ID3v24Tag();
 
147
        ID3v11Tag v1Tag = new ID3v11Tag(v2Tag);
 
148
        assertNotNull(v1Tag);
 
149
        assertEquals((byte) 1, v1Tag.getRelease());
 
150
        assertEquals((byte) 1, v1Tag.getMajorVersion());
 
151
        assertEquals((byte) 0, v1Tag.getRevision());
 
152
 
 
153
 
 
154
    }
 
155
 
 
156
    public void testCreateID3v11FromID3v23()
 
157
    {
 
158
        ID3v23Tag v2Tag = new ID3v23Tag();
 
159
        ID3v11Tag v1Tag = new ID3v11Tag(v2Tag);
 
160
        assertNotNull(v1Tag);
 
161
        assertEquals((byte) 1, v1Tag.getRelease());
 
162
        assertEquals((byte) 1, v1Tag.getMajorVersion());
 
163
        assertEquals((byte) 0, v1Tag.getRevision());
 
164
 
 
165
    }
 
166
 
 
167
    public void testCreateID3v11FromID3v22()
 
168
    {
 
169
        ID3v22Tag v2Tag = new ID3v22Tag();
 
170
        ID3v11Tag v1Tag = new ID3v11Tag(v2Tag);
 
171
        assertNotNull(v1Tag);
 
172
        assertEquals((byte) 1, v1Tag.getRelease());
 
173
        assertEquals((byte) 1, v1Tag.getMajorVersion());
 
174
        assertEquals((byte) 0, v1Tag.getRevision());
 
175
    }
 
176
 
 
177
    public void testNewInterface()
 
178
    {
 
179
        Exception exceptionCaught = null;
 
180
        ID3v1Tag v1Tag = new ID3v11Tag();
 
181
        assertTrue(v1Tag.isEmpty());
 
182
 
 
183
        v1Tag.setField(new ID3v1TagField(FieldKey.ARTIST.name(), "artist"));
 
184
        assertEquals("artist", ((TagTextField) v1Tag.getFields(FieldKey.ARTIST).get(0)).getContent());
 
185
        assertEquals("artist", v1Tag.getFirst(FieldKey.ARTIST));
 
186
        assertEquals("artist", ((TagTextField) (v1Tag.getArtist().get(0))).getContent());
 
187
        assertEquals("artist", ((TagTextField) v1Tag.getFirstField(FieldKey.ARTIST.name())).getContent());
 
188
        assertEquals("artist", ((TagTextField) (v1Tag.getFields(FieldKey.ARTIST.name()).get(0))).getContent());
 
189
 
 
190
        v1Tag.setField(new ID3v1TagField(FieldKey.ALBUM.name(), "album"));
 
191
        assertEquals("album", ((TagTextField) v1Tag.getFields(FieldKey.ALBUM).get(0)).getContent());
 
192
        assertEquals("album", v1Tag.getFirst(FieldKey.ALBUM));
 
193
        assertEquals("album", ((TagTextField) (v1Tag.getAlbum().get(0))).getContent());
 
194
        assertEquals("album", ((TagTextField) v1Tag.getFirstField(FieldKey.ALBUM.name())).getContent());
 
195
 
 
196
        v1Tag.setField(new ID3v1TagField(FieldKey.TITLE.name(), "title"));
 
197
        assertEquals("title", ((TagTextField) v1Tag.getFields(FieldKey.TITLE).get(0)).getContent());
 
198
        assertEquals("title", v1Tag.getFirst(FieldKey.TITLE));
 
199
        assertEquals("title", ((TagTextField) (v1Tag.getTitle().get(0))).getContent());
 
200
        assertEquals("title", ((TagTextField) v1Tag.getFirstField(FieldKey.TITLE.name())).getContent());
 
201
 
 
202
        v1Tag.setField(new ID3v1TagField(FieldKey.YEAR.name(), "year"));
 
203
        assertEquals("year", ((TagTextField) v1Tag.getFields(FieldKey.YEAR).get(0)).getContent());
 
204
        assertEquals("year", v1Tag.getFirst(FieldKey.YEAR));
 
205
        assertEquals("year", ((TagTextField) (v1Tag.getYear().get(0))).getContent());
 
206
        assertEquals("year", ((TagTextField) v1Tag.getFirstField(FieldKey.YEAR.name())).getContent());
 
207
 
 
208
        v1Tag.setField(new ID3v1TagField(FieldKey.GENRE.name(), "Country"));
 
209
        assertEquals("Country", ((TagTextField) v1Tag.getFields(FieldKey.GENRE).get(0)).getContent());
 
210
        assertEquals("Country", v1Tag.getFirst(FieldKey.GENRE));
 
211
        assertEquals("Country", ((TagTextField) (v1Tag.getGenre().get(0))).getContent());
 
212
        assertEquals("Country", ((TagTextField) v1Tag.getFirstField(FieldKey.GENRE.name())).getContent());
 
213
 
 
214
        v1Tag.setField(new ID3v1TagField(FieldKey.COMMENT.name(), "comment"));
 
215
        assertEquals("comment", ((TagTextField) v1Tag.getFields(FieldKey.COMMENT).get(0)).getContent());
 
216
        assertEquals("comment", v1Tag.getFirstComment());
 
217
        assertEquals("comment", ((TagTextField) (v1Tag.getFields(FieldKey.COMMENT).get(0))).getContent());
 
218
        assertEquals("comment", ((TagTextField) v1Tag.getFirstField(FieldKey.COMMENT.name())).getContent());
 
219
 
 
220
        v1Tag.setField(new ID3v1TagField(FieldKey.TRACK.name(), "5"));
 
221
        assertEquals("5", ((TagTextField) v1Tag.getFields(FieldKey.TRACK).get(0)).getContent());
 
222
        assertEquals("5", v1Tag.getFirst(FieldKey.TRACK));
 
223
        assertEquals("5", ((TagTextField) (v1Tag.getTrack().get(0))).getContent());
 
224
        assertEquals("5", ((TagTextField) v1Tag.getFirstField(FieldKey.TRACK.name())).getContent());
 
225
 
 
226
        //Check nothing been overwritten
 
227
        assertEquals("year", v1Tag.getFirst(FieldKey.YEAR));
 
228
        assertEquals("Country", v1Tag.getFirst(FieldKey.GENRE));
 
229
        assertEquals("title", v1Tag.getFirst(FieldKey.TITLE));
 
230
        assertEquals("album", v1Tag.getFirst(FieldKey.ALBUM));
 
231
        assertEquals("artist", v1Tag.getFirst(FieldKey.ARTIST));
 
232
 
 
233
        //Delete artist field
 
234
        v1Tag.deleteField(FieldKey.ARTIST);
 
235
        assertEquals("", v1Tag.getFirst(FieldKey.ARTIST));
 
236
        assertEquals("year", v1Tag.getFirst(FieldKey.YEAR));
 
237
        assertEquals("Country", v1Tag.getFirst(FieldKey.GENRE));
 
238
        assertEquals("title", v1Tag.getFirst(FieldKey.TITLE));
 
239
        assertEquals("album", v1Tag.getFirst(FieldKey.ALBUM));
 
240
 
 
241
        //Not Empty
 
242
        assertFalse(v1Tag.isEmpty());
 
243
 
 
244
        v1Tag.deleteField(FieldKey.ALBUM);
 
245
        v1Tag.deleteField(FieldKey.YEAR);
 
246
        v1Tag.deleteField(FieldKey.GENRE);
 
247
        v1Tag.deleteField(FieldKey.TITLE);
 
248
        v1Tag.deleteField(FieldKey.COMMENT);
 
249
        v1Tag.setField(new ID3v1TagField(FieldKey.COMMENT.name(), ""));
 
250
        v1Tag.deleteField(FieldKey.TRACK);
 
251
        //Empty
 
252
        assertTrue(v1Tag.isEmpty());
 
253
 
 
254
        //Null Handling
 
255
        try
 
256
        {
 
257
            v1Tag.setField(new ID3v1TagField(FieldKey.COMMENT.name(), null));
 
258
        }
 
259
        catch (Exception e)
 
260
        {
 
261
            exceptionCaught = e;
 
262
        }
 
263
        assertTrue(exceptionCaught instanceof IllegalArgumentException);
 
264
    }
 
265
 
 
266
    public void testSaveID3v11TagToFile() throws Exception
 
267
    {
 
268
        File testFile = AbstractTestCase.copyAudioToTmp("testV1.mp3");
 
269
        MP3File mp3File = new MP3File(testFile);
 
270
 
 
271
        //Create v11 Tag
 
272
        ID3v11Tag tag = new ID3v11Tag();
 
273
        tag.setArtist(ID3v11TagTest.ARTIST);
 
274
        tag.setAlbum(ID3v11TagTest.ALBUM);
 
275
        tag.setComment(ID3v11TagTest.COMMENT);
 
276
        tag.setTitle(ID3v11TagTest.TITLE);
 
277
        tag.setGenre(ID3v11TagTest.GENRE_VAL);
 
278
        tag.setYear(ID3v11TagTest.YEAR);
 
279
        tag.setTrack(ID3v11TagTest.TRACK_VALUE);
 
280
        //Save tag to file
 
281
        mp3File.setID3v1Tag(tag);
 
282
        mp3File.save();
 
283
 
 
284
        //Reload
 
285
        mp3File = new MP3File(testFile);
 
286
        tag = (ID3v11Tag)mp3File.getID3v1Tag();
 
287
        assertEquals(ID3v11TagTest.ARTIST, tag.getFirst(FieldKey.ARTIST));
 
288
        assertEquals(ID3v11TagTest.ALBUM, tag.getFirst(FieldKey.ALBUM));
 
289
        assertEquals(ID3v11TagTest.COMMENT, tag.getFirstComment());
 
290
        assertEquals(ID3v11TagTest.TITLE, tag.getFirst(FieldKey.TITLE));
 
291
        assertEquals(ID3v11TagTest.GENRE_VAL, tag.getFirst(FieldKey.GENRE));
 
292
        assertEquals(ID3v11TagTest.YEAR, tag.getFirst(FieldKey.YEAR));
 
293
        assertEquals(ID3v11TagTest.YEAR, tag.getFirst(FieldKey.YEAR));
 
294
        assertEquals(ID3v11TagTest.TRACK_VALUE, tag.getFirst(FieldKey.TRACK));
 
295
 
 
296
        tag.setField(FieldKey.TRACK,"3");
 
297
        mp3File.save();
 
298
        mp3File = new MP3File(testFile);
 
299
        tag = (ID3v11Tag)mp3File.getID3v1Tag();
 
300
        assertEquals("3", tag.getFirst(FieldKey.TRACK ));
 
301
    }
 
302
}