← Back to branch summary

~dobey/ubuntu/natty/banshee/fix-and-amz

« back to all changes in this revision

Viewing changes to src/Core/Banshee.Services/Banshee.Metadata/Tests/TaglibReadWriteTests.cs

  • Committer: Bazaar Package Importer
  • Author(s): Chow Loong Jin
  • Date: 2010-01-28 23:52:53 UTC
  • mto: (6.4.6 sid) (1.14.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 88.
  • Revision ID: james.westby@ubuntu.com-20100128235253-qyw3pkf2vw7ld3kg
Import upstream version 1.5.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/Core/Banshee.Services/Banshee.Metadata/Tests/TaglibReadWriteTests.cs
 
1
//
 
2
// TaglibReadWriteTests.cs
 
3
//
 
4
// Author:
 
5
//   Gabriel Burt <gburt@novell.com>
 
6
//
 
7
// Copyright (C) 2008 Novell, Inc.
 
8
//
 
9
// Permission is hereby granted, free of charge, to any person obtaining
 
10
// a copy of this software and associated documentation files (the
 
11
// "Software"), to deal in the Software without restriction, including
 
12
// without limitation the rights to use, copy, modify, merge, publish,
 
13
// distribute, sublicense, and/or sell copies of the Software, and to
 
14
// permit persons to whom the Software is furnished to do so, subject to
 
15
// the following conditions:
 
16
//
 
17
// The above copyright notice and this permission notice shall be
 
18
// included in all copies or substantial portions of the Software.
 
19
//
 
20
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 
21
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 
22
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 
23
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 
24
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 
25
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 
26
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
27
//
 
28
 
 
29
#if ENABLE_TESTS
 
30
 
 
31
using System;
 
32
using System.IO;
 
33
using System.Reflection;
 
34
using NUnit.Framework;
 
35
 
 
36
using Banshee.Base;
 
37
using Banshee.Collection;
 
38
using Banshee.Streaming;
 
39
using Banshee.Configuration.Schema;
 
40
 
 
41
using Hyena.Tests;
 
42
 
 
43
namespace Banshee.Metadata
 
44
{
 
45
    // FIXME: These tests don't really belong here
 
46
 
 
47
    [TestFixture]
 
48
    public class TaglibReadWriteTests : TestBase
 
49
    {
 
50
        private string [] files;
 
51
 
 
52
        [TestFixtureSetUp]
 
53
        public void Setup ()
 
54
        {
 
55
            Mono.Addins.AddinManager.Initialize (BinDir);
 
56
 
 
57
            files = new string [] {
 
58
                Path.Combine (TestsDir, "data/test.mp3")
 
59
            };
 
60
        }
 
61
 
 
62
        [Test]
 
63
        public void TestSystemIO ()
 
64
        {
 
65
            Banshee.IO.Provider.SetProvider (new Banshee.IO.SystemIO.Provider ());
 
66
            WriteMetadata (files, ChangeTrack, VerifyTrack);
 
67
        }
 
68
 
 
69
        [Test]
 
70
        public void TestUnixIO ()
 
71
        {
 
72
            Banshee.IO.Provider.SetProvider (CreateUnixIOProvider ());
 
73
            WriteMetadata (files, ChangeTrack, VerifyTrack);
 
74
        }
 
75
 
 
76
        [Test]
 
77
        public void TestGenre ()
 
78
        {
 
79
            Banshee.IO.Provider.SetProvider (CreateUnixIOProvider ());
 
80
            WriteMetadata (files, delegate (TrackInfo track) {
 
81
                ChangeTrack (track);
 
82
                track.Genre = "My Genre";
 
83
            }, delegate (TrackInfo track) {
 
84
                VerifyTrack (track);
 
85
                Assert.AreEqual ("My Genre", track.Genre);
 
86
            });
 
87
        }
 
88
 
 
89
        [Test]
 
90
        public void TestNullGenreBug ()
 
91
        {
 
92
            // Bug in taglib-sharp-2.0.3.0: Crash if you send it a genre of "{ null }" on
 
93
            // a song with both ID3v1 and ID3v2 metadata. It's happy with "{}", though.
 
94
            // (see http://forum.taglib-sharp.com/viewtopic.php?f=5&t=239 )
 
95
            // This tests our workaround.
 
96
            Banshee.IO.Provider.SetProvider (CreateUnixIOProvider ());
 
97
            WriteMetadata (files, delegate (TrackInfo track) {
 
98
                ChangeTrack (track);
 
99
                track.Genre = null;
 
100
            }, delegate (TrackInfo track) {
 
101
                VerifyTrack (track);
 
102
                Assert.IsNull (track.Genre);
 
103
            });
 
104
        }
 
105
 
 
106
        [Test]
 
107
        public void TestIsCompilation ()
 
108
        {
 
109
            Banshee.IO.Provider.SetProvider (CreateUnixIOProvider ());
 
110
            WriteMetadata (files, delegate (TrackInfo track) {
 
111
                ChangeTrack (track);
 
112
                // bgo#563283: IsCompilation was reset if AlbumArtist == Artist
 
113
                track.AlbumArtist = track.ArtistName;
 
114
                track.IsCompilation = true;
 
115
            }, delegate (TrackInfo track) {
 
116
                VerifyTrack (track);
 
117
                Assert.AreEqual (track.ArtistName, track.AlbumArtist);
 
118
                Assert.IsTrue (track.IsCompilation);
 
119
            });
 
120
        }
 
121
 
 
122
        [Test]
 
123
        public void TestIsNotCompilation ()
 
124
        {
 
125
            Banshee.IO.Provider.SetProvider (CreateUnixIOProvider ());
 
126
            WriteMetadata (files, delegate (TrackInfo track) {
 
127
                ChangeTrack (track);
 
128
                track.AlbumArtist = track.ArtistName;
 
129
                track.IsCompilation = false;
 
130
            }, delegate (TrackInfo track) {
 
131
                VerifyTrack (track);
 
132
                Assert.AreEqual (track.ArtistName, track.AlbumArtist);
 
133
                Assert.IsFalse (track.IsCompilation);
 
134
            });
 
135
        }
 
136
 
 
137
        [Test]
 
138
        public void TestIsCompilationAndAlbumArtist ()
 
139
        {
 
140
            Banshee.IO.Provider.SetProvider (CreateUnixIOProvider ());
 
141
            WriteMetadata (files, delegate (TrackInfo track) {
 
142
                ChangeTrack (track);
 
143
                track.AlbumArtist = "My Album Artist";
 
144
                track.IsCompilation = true;
 
145
            }, delegate (TrackInfo track) {
 
146
                VerifyTrack (track);
 
147
                Assert.AreEqual ("My Album Artist", track.AlbumArtist);
 
148
                Assert.IsTrue (track.IsCompilation);
 
149
            });
 
150
        }
 
151
 
 
152
        private void WriteMetadata (string [] files, Action<TrackInfo> change, Action<TrackInfo> verify)
 
153
        {
 
154
            SafeUri newuri = null;
 
155
            bool write_metadata = LibrarySchema.WriteMetadata.Get();
 
156
            LibrarySchema.WriteMetadata.Set (true);
 
157
            try {
 
158
                AssertForEach<string> (files, delegate (string uri) {
 
159
                    string extension = System.IO.Path.GetExtension (uri);
 
160
                    newuri = new SafeUri (Path.Combine (TestsDir, "data/test_write." + extension));
 
161
 
 
162
                    Banshee.IO.File.Copy (new SafeUri (uri), newuri, true);
 
163
 
 
164
                    ChangeAndVerify (newuri, change, verify);
 
165
                });
 
166
            } finally {
 
167
                LibrarySchema.WriteMetadata.Set (write_metadata);
 
168
                if (newuri != null)
 
169
                    Banshee.IO.File.Delete (newuri);
 
170
            }
 
171
        }
 
172
 
 
173
        private void ChangeAndVerify (SafeUri uri, Action<TrackInfo> change, Action<TrackInfo> verify)
 
174
        {
 
175
            TagLib.File file = StreamTagger.ProcessUri (uri);
 
176
            TrackInfo track = new TrackInfo ();
 
177
            StreamTagger.TrackInfoMerge (track, file);
 
178
 
 
179
            // Make changes
 
180
            change (track);
 
181
 
 
182
            // Save changes
 
183
            bool saved = StreamTagger.SaveToFile (track, true, true);
 
184
            Assert.IsTrue (saved);
 
185
 
 
186
            // Read changes
 
187
            file = StreamTagger.ProcessUri (uri);
 
188
            track = new TrackInfo ();
 
189
            StreamTagger.TrackInfoMerge (track, file, false, true);
 
190
 
 
191
            // Verify changes
 
192
            verify (track);
 
193
        }
 
194
 
 
195
        private void ChangeTrack (TrackInfo track)
 
196
        {
 
197
            track.TrackTitle = "My Title";
 
198
            track.ArtistName = "My Artist";
 
199
            track.AlbumTitle = "My Album";
 
200
            track.TrackNumber = 4;
 
201
            track.DiscNumber = 4;
 
202
            track.Year = 1999;
 
203
            track.Rating = 2;
 
204
            track.PlayCount = 3;
 
205
        }
 
206
 
 
207
        private void VerifyTrack (TrackInfo track)
 
208
        {
 
209
            Assert.AreEqual ("My Title", track.TrackTitle);
 
210
            Assert.AreEqual ("My Artist", track.ArtistName);
 
211
            Assert.AreEqual ("My Album", track.AlbumTitle);
 
212
            Assert.AreEqual (4, track.TrackNumber);
 
213
            Assert.AreEqual (4, track.DiscNumber);
 
214
            Assert.AreEqual (1999, track.Year);
 
215
            Assert.AreEqual (2, track.Rating);
 
216
            Assert.AreEqual (3, track.PlayCount);
 
217
        }
 
218
 
 
219
        private Type unix_io_type;
 
220
 
 
221
        private Banshee.IO.IProvider CreateUnixIOProvider ()
 
222
        {
 
223
            if (unix_io_type == null) {
 
224
                Assembly asm = Assembly.LoadFrom (BinDir + "/Banshee.Unix.dll");
 
225
                unix_io_type = asm.GetType ("Banshee.IO.Unix.Provider");
 
226
            }
 
227
 
 
228
            return (Banshee.IO.IProvider)Activator.CreateInstance (unix_io_type);
 
229
        }
 
230
    }
 
231
}
 
232
 
 
233
#endif