Skip to content

Commit 80c2804

Browse files
decriptordecriptor
committed
Fix TaglibSharp.Tests build
1 parent 8e07683 commit 80c2804

File tree

115 files changed

+16005
-15956
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

115 files changed

+16005
-15956
lines changed

‎tests/TaglibSharp.Tests/Collections/ByteVectorCollectionTest.cs

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -19,32 +19,32 @@ static ByteVectorCollection BuildList ()
1919
[Test]
2020
public void Add ()
2121
{
22-
Assert.AreEqual ("ABC:DEF:GHI", BuildList ().ToByteVector (":").ToString ());
22+
ClassicAssert.AreEqual ("ABC:DEF:GHI", BuildList ().ToByteVector (":").ToString ());
2323
}
2424

2525
[Test]
2626
public void Remove ()
2727
{
2828
var list = BuildList ();
2929
list.Remove ("DEF");
30-
Assert.AreEqual ("ABCGHI", list.ToByteVector ("").ToString ());
30+
ClassicAssert.AreEqual ("ABCGHI", list.ToByteVector ("").ToString ());
3131
}
3232

3333
[Test]
3434
public void Insert ()
3535
{
3636
var list = BuildList ();
3737
list.Insert (1, "QUACK");
38-
Assert.AreEqual ("ABC,QUACK,DEF,GHI", list.ToByteVector (",").ToString ());
38+
ClassicAssert.AreEqual ("ABC,QUACK,DEF,GHI", list.ToByteVector (",").ToString ());
3939
}
4040

4141
[Test]
4242
public void Contains ()
4343
{
4444
var list = BuildList ();
45-
Assert.IsTrue (list.Contains ("DEF"));
46-
Assert.IsFalse (list.Contains ("CDEFG"));
47-
Assert.AreEqual (2, list.ToByteVector ("").Find ("CDEFG"));
45+
ClassicAssert.IsTrue (list.Contains ("DEF"));
46+
ClassicAssert.IsFalse (list.Contains ("CDEFG"));
47+
ClassicAssert.AreEqual (2, list.ToByteVector ("").Find ("CDEFG"));
4848
}
4949

5050
/*[Test]

‎tests/TaglibSharp.Tests/Collections/ByteVectorTest.cs

Lines changed: 37 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -14,49 +14,49 @@ public class ByteVectorTest
1414
[Test]
1515
public void Length ()
1616
{
17-
Assert.AreEqual (TestInput.Length, TestVector.Count);
17+
ClassicAssert.AreEqual (TestInput.Length, TestVector.Count);
1818
}
1919

2020
[Test]
2121
public void StartsWith ()
2222
{
23-
Assert.IsTrue (TestVector.StartsWith ("ABCDE"));
24-
Assert.IsFalse (TestVector.StartsWith ("NOOP"));
23+
ClassicAssert.IsTrue (TestVector.StartsWith ("ABCDE"));
24+
ClassicAssert.IsFalse (TestVector.StartsWith ("NOOP"));
2525
}
2626

2727
[Test]
2828
public void EndsWith ()
2929
{
30-
Assert.IsTrue (TestVector.EndsWith ("UVWXYZ"));
31-
Assert.IsFalse (TestVector.EndsWith ("NOOP"));
30+
ClassicAssert.IsTrue (TestVector.EndsWith ("UVWXYZ"));
31+
ClassicAssert.IsFalse (TestVector.EndsWith ("NOOP"));
3232
}
3333

3434
[Test]
3535
public void ContainsAt ()
3636
{
37-
Assert.IsTrue (TestVector.ContainsAt ("JKLMNO", 9));
38-
Assert.IsFalse (TestVector.ContainsAt ("NOOP", 30));
37+
ClassicAssert.IsTrue (TestVector.ContainsAt ("JKLMNO", 9));
38+
ClassicAssert.IsFalse (TestVector.ContainsAt ("NOOP", 30));
3939
}
4040

4141
[Test]
4242
public void Find ()
4343
{
44-
Assert.AreEqual (17, TestVector.Find ("RSTUV"));
45-
Assert.AreEqual (-1, TestVector.Find ("NOOP"));
44+
ClassicAssert.AreEqual (17, TestVector.Find ("RSTUV"));
45+
ClassicAssert.AreEqual (-1, TestVector.Find ("NOOP"));
4646
}
4747

4848
[Test]
4949
public void RFind ()
5050
{
51-
Assert.AreEqual (6, TestVector.RFind ("GHIJ"));
52-
Assert.AreEqual (-1, TestVector.RFind ("NOOP"));
51+
ClassicAssert.AreEqual (6, TestVector.RFind ("GHIJ"));
52+
ClassicAssert.AreEqual (-1, TestVector.RFind ("NOOP"));
5353
}
5454

5555
[Test]
5656
public void Mid ()
5757
{
58-
Assert.AreEqual (ByteVector.FromString ("KLMNOPQRSTUVWXYZ", StringType.UTF8), TestVector.Mid (10));
59-
Assert.AreEqual (ByteVector.FromString ("PQRSTU", StringType.UTF8), TestVector.Mid (15, 6));
58+
ClassicAssert.AreEqual (ByteVector.FromString ("KLMNOPQRSTUVWXYZ", StringType.UTF8), TestVector.Mid (10));
59+
ClassicAssert.AreEqual (ByteVector.FromString ("PQRSTU", StringType.UTF8), TestVector.Mid (15, 6));
6060
}
6161

6262
[Test]
@@ -66,55 +66,55 @@ public void CopyResize ()
6666
var b = ByteVector.FromString ("ABCDEFGHIJKL", StringType.UTF8);
6767
a.Resize (12);
6868

69-
Assert.AreEqual (b, a);
70-
Assert.AreEqual (b.ToString (), a.ToString ());
71-
Assert.IsFalse (a.Count == TestVector.Count);
69+
ClassicAssert.AreEqual (b, a);
70+
ClassicAssert.AreEqual (b.ToString (), a.ToString ());
71+
ClassicAssert.IsFalse (a.Count == TestVector.Count);
7272
}
7373

7474
[Test]
7575
public void Int ()
7676
{
77-
Assert.AreEqual (int.MaxValue, ByteVector.FromInt (int.MaxValue).ToInt ());
78-
Assert.AreEqual (int.MinValue, ByteVector.FromInt (int.MinValue).ToInt ());
79-
Assert.AreEqual (0, ByteVector.FromInt (0).ToInt ());
80-
Assert.AreEqual (30292, ByteVector.FromInt (30292).ToInt ());
81-
Assert.AreEqual (-30292, ByteVector.FromInt (-30292).ToInt ());
82-
Assert.AreEqual (-1, ByteVector.FromInt (-1).ToInt ());
77+
ClassicAssert.AreEqual (int.MaxValue, ByteVector.FromInt (int.MaxValue).ToInt ());
78+
ClassicAssert.AreEqual (int.MinValue, ByteVector.FromInt (int.MinValue).ToInt ());
79+
ClassicAssert.AreEqual (0, ByteVector.FromInt (0).ToInt ());
80+
ClassicAssert.AreEqual (30292, ByteVector.FromInt (30292).ToInt ());
81+
ClassicAssert.AreEqual (-30292, ByteVector.FromInt (-30292).ToInt ());
82+
ClassicAssert.AreEqual (-1, ByteVector.FromInt (-1).ToInt ());
8383
}
8484

8585
[Test]
8686
public void UInt ()
8787
{
88-
Assert.AreEqual (uint.MaxValue, ByteVector.FromUInt (uint.MaxValue).ToUInt ());
89-
Assert.AreEqual (uint.MinValue, ByteVector.FromUInt (uint.MinValue).ToUInt ());
90-
Assert.AreEqual (0, ByteVector.FromUInt (0).ToUInt ());
91-
Assert.AreEqual (30292, ByteVector.FromUInt (30292).ToUInt ());
88+
ClassicAssert.AreEqual (uint.MaxValue, ByteVector.FromUInt (uint.MaxValue).ToUInt ());
89+
ClassicAssert.AreEqual (uint.MinValue, ByteVector.FromUInt (uint.MinValue).ToUInt ());
90+
ClassicAssert.AreEqual (0, ByteVector.FromUInt (0).ToUInt ());
91+
ClassicAssert.AreEqual (30292, ByteVector.FromUInt (30292).ToUInt ());
9292
}
9393

9494
[Test]
9595
public void Long ()
9696
{
97-
Assert.AreEqual (ulong.MaxValue, ByteVector.FromULong (ulong.MaxValue).ToULong ());
98-
Assert.AreEqual (ulong.MinValue, ByteVector.FromULong (ulong.MinValue).ToULong ());
99-
Assert.AreEqual (0, ByteVector.FromULong (0).ToULong ());
100-
Assert.AreEqual (30292, ByteVector.FromULong (30292).ToULong ());
97+
ClassicAssert.AreEqual (ulong.MaxValue, ByteVector.FromULong (ulong.MaxValue).ToULong ());
98+
ClassicAssert.AreEqual (ulong.MinValue, ByteVector.FromULong (ulong.MinValue).ToULong ());
99+
ClassicAssert.AreEqual (0, ByteVector.FromULong (0).ToULong ());
100+
ClassicAssert.AreEqual (30292, ByteVector.FromULong (30292).ToULong ());
101101
}
102102

103103
[Test]
104104
public void Short ()
105105
{
106-
Assert.AreEqual (ushort.MaxValue, ByteVector.FromUShort (ushort.MaxValue).ToUShort ());
107-
Assert.AreEqual (ushort.MinValue, ByteVector.FromUShort (ushort.MinValue).ToUShort ());
108-
Assert.AreEqual (0, ByteVector.FromUShort (0).ToUShort ());
109-
Assert.AreEqual (8009, ByteVector.FromUShort (8009).ToUShort ());
106+
ClassicAssert.AreEqual (ushort.MaxValue, ByteVector.FromUShort (ushort.MaxValue).ToUShort ());
107+
ClassicAssert.AreEqual (ushort.MinValue, ByteVector.FromUShort (ushort.MinValue).ToUShort ());
108+
ClassicAssert.AreEqual (0, ByteVector.FromUShort (0).ToUShort ());
109+
ClassicAssert.AreEqual (8009, ByteVector.FromUShort (8009).ToUShort ());
110110
}
111111

112112
[Test]
113113
public void FromUri ()
114114
{
115115
var vector = ByteVector.FromPath (TestPath.Samples + "vector.bin");
116-
Assert.AreEqual (3282169185, vector.Checksum);
117-
Assert.AreEqual ("1aaa46c484d70c7c80510a5f99e7805d", MD5Hash (vector.Data));
116+
ClassicAssert.AreEqual (3282169185, vector.Checksum);
117+
ClassicAssert.AreEqual ("1aaa46c484d70c7c80510a5f99e7805d", MD5Hash (vector.Data));
118118
}
119119

120120
[Test]
@@ -147,7 +147,7 @@ public void CommentsFrameError ()
147147
var encoding = (StringType)vector[0];
148148
//var language = vector.ToString (StringType.Latin1, 1, 3);
149149
var split = vector.ToStrings (encoding, 4, 3);
150-
Assert.AreEqual (2, split.Length);
150+
ClassicAssert.AreEqual (2, split.Length);
151151
}
152152

153153
static string MD5Hash (byte[] bytes)

‎tests/TaglibSharp.Tests/Collections/FileTest.cs

Lines changed: 44 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,8 @@
11
using NUnit.Framework;
22
using TagLib;
33

4+
using File = TagLib.File;
5+
46
namespace TaglibSharp.Tests.Collections
57
{
68
[TestFixture]
@@ -33,127 +35,127 @@ public void RFind ()
3335
{
3436
// file1
3537
var file1 = CreateFile (length1);
36-
Assert.AreEqual (-1, file1.RFind (Pattern1));
37-
Assert.AreEqual (-1, file1.RFind (Pattern1, 5));
38+
ClassicAssert.AreEqual (-1, file1.RFind (Pattern1));
39+
ClassicAssert.AreEqual (-1, file1.RFind (Pattern1, 5));
3840

3941
file1.Insert (Pattern1, 30, 2);
40-
Assert.AreEqual (30, file1.RFind (Pattern1));
42+
ClassicAssert.AreEqual (30, file1.RFind (Pattern1));
4143

4244
file1.Insert (Pattern1, length1 / 2, 2);
43-
Assert.AreEqual (length1 / 2, file1.RFind (Pattern1));
45+
ClassicAssert.AreEqual (length1 / 2, file1.RFind (Pattern1));
4446

4547
file1.Insert (Pattern1, length1 - 30, 2);
46-
Assert.AreEqual (length1 - 30, file1.RFind (Pattern1));
48+
ClassicAssert.AreEqual (length1 - 30, file1.RFind (Pattern1));
4749

48-
Assert.AreEqual (30, file1.RFind (Pattern1, length1 - length1 / 2 + 1));
49-
Assert.AreEqual (length1 / 2, file1.RFind (Pattern1, 30 + 1));
50-
Assert.AreEqual (length1 - 30, file1.RFind (Pattern1, 2 + 1));
50+
ClassicAssert.AreEqual (30, file1.RFind (Pattern1, length1 - length1 / 2 + 1));
51+
ClassicAssert.AreEqual (length1 / 2, file1.RFind (Pattern1, 30 + 1));
52+
ClassicAssert.AreEqual (length1 - 30, file1.RFind (Pattern1, 2 + 1));
5153

5254

5355
// file2
5456
var file2 = CreateFile (length2);
55-
Assert.AreEqual (-1, file2.RFind (Pattern1));
56-
Assert.AreEqual (-1, file2.RFind (Pattern1, 8));
57+
ClassicAssert.AreEqual (-1, file2.RFind (Pattern1));
58+
ClassicAssert.AreEqual (-1, file2.RFind (Pattern1, 8));
5759

5860
file2.Insert (Pattern1, 30, Pattern1.Length);
59-
Assert.AreEqual (30, file2.RFind (Pattern1));
61+
ClassicAssert.AreEqual (30, file2.RFind (Pattern1));
6062

6163
file2.Insert (Pattern1, length2 / 2, Pattern1.Length);
62-
Assert.AreEqual (length2 / 2, file2.RFind (Pattern1));
64+
ClassicAssert.AreEqual (length2 / 2, file2.RFind (Pattern1));
6365

6466
file2.Insert (Pattern1, length2 - 30, Pattern1.Length);
65-
Assert.AreEqual (length2 - 30, file2.RFind (Pattern1));
67+
ClassicAssert.AreEqual (length2 - 30, file2.RFind (Pattern1));
6668

67-
Assert.AreEqual (30, file2.RFind (Pattern1, length2 - length2 / 2));
68-
Assert.AreEqual (length2 / 2, file2.RFind (Pattern1, 30));
69-
Assert.AreEqual (length2 - 30, file2.RFind (Pattern1, 2));
69+
ClassicAssert.AreEqual (30, file2.RFind (Pattern1, length2 - length2 / 2));
70+
ClassicAssert.AreEqual (length2 / 2, file2.RFind (Pattern1, 30));
71+
ClassicAssert.AreEqual (length2 - 30, file2.RFind (Pattern1, 2));
7072

7173

7274
// file3
7375
// especially used to test searching if the search pattern is splattened to
7476
// different buffer reads
7577
// this test is specialized to the used algorithm
7678
var file3 = CreateFile (length3);
77-
Assert.AreEqual (-1, file3.RFind (Pattern1));
78-
Assert.AreEqual (-1, file3.RFind (Pattern1, 13));
79+
ClassicAssert.AreEqual (-1, file3.RFind (Pattern1));
80+
ClassicAssert.AreEqual (-1, file3.RFind (Pattern1, 13));
7981

8082
long buffer_cross2 = file3.Length - 2 * File.BufferSize - (Pattern1.Length / 2);
8183
file3.Insert (Pattern1, buffer_cross2, Pattern1.Length);
82-
Assert.AreEqual (buffer_cross2, file3.RFind (Pattern1));
84+
ClassicAssert.AreEqual (buffer_cross2, file3.RFind (Pattern1));
8385

8486
long buffer_cross1 = file3.Length - File.BufferSize - (Pattern1.Length / 2);
8587
file3.Insert (Pattern1, buffer_cross1, Pattern1.Length);
86-
Assert.AreEqual (buffer_cross1, file3.RFind (Pattern1));
88+
ClassicAssert.AreEqual (buffer_cross1, file3.RFind (Pattern1));
8789

8890
// see Find()
8991
long buffer_cross3 = file3.Length - File.BufferSize - Pattern3.Length + 1;
9092
file3.Insert (Pattern3, buffer_cross3 + 1, Pattern3.Length);
9193
file3.Insert (Pattern3, buffer_cross3, Pattern3.Length);
92-
Assert.AreEqual (buffer_cross3, file3.RFind (Pattern3));
94+
ClassicAssert.AreEqual (buffer_cross3, file3.RFind (Pattern3));
9395
}
9496

9597
[Test]
9698
public void Find ()
9799
{
98100
// file1
99101
var file1 = CreateFile (length1);
100-
Assert.AreEqual (Chars.IndexOf ('U'), file1.Find ((byte)'U'));
102+
ClassicAssert.AreEqual (Chars.IndexOf ('U'), file1.Find ((byte)'U'));
101103

102-
Assert.AreEqual (-1, file1.Find (Pattern1));
103-
Assert.AreEqual (-1, file1.Find (Pattern1, 9));
104+
ClassicAssert.AreEqual (-1, file1.Find (Pattern1));
105+
ClassicAssert.AreEqual (-1, file1.Find (Pattern1, 9));
104106

105107
file1.Insert (Pattern1, length1 - 30, Pattern1.Length);
106-
Assert.AreEqual (length1 - 30, file1.Find (Pattern1));
108+
ClassicAssert.AreEqual (length1 - 30, file1.Find (Pattern1));
107109

108110
file1.Insert (Pattern1, length1 / 2, Pattern1.Length);
109-
Assert.AreEqual (length1 / 2, file1.Find (Pattern1));
111+
ClassicAssert.AreEqual (length1 / 2, file1.Find (Pattern1));
110112

111113
file1.Insert (Pattern1, 30, Pattern1.Length);
112-
Assert.AreEqual (30, file1.Find (Pattern1));
114+
ClassicAssert.AreEqual (30, file1.Find (Pattern1));
113115

114116

115117
// file2
116118
var file2 = CreateFile (length2);
117-
Assert.AreEqual (Chars.IndexOf ('M'), file2.Find ((byte)'M'));
119+
ClassicAssert.AreEqual (Chars.IndexOf ('M'), file2.Find ((byte)'M'));
118120

119-
Assert.AreEqual (-1, file2.Find (Pattern1));
120-
Assert.AreEqual (-1, file2.Find (Pattern1, 3));
121+
ClassicAssert.AreEqual (-1, file2.Find (Pattern1));
122+
ClassicAssert.AreEqual (-1, file2.Find (Pattern1, 3));
121123

122124
file2.Insert (Pattern1, length2 - 30, Pattern1.Length);
123-
Assert.AreEqual (length2 - 30, file2.Find (Pattern1));
125+
ClassicAssert.AreEqual (length2 - 30, file2.Find (Pattern1));
124126

125127
file2.Insert (Pattern1, length2 / 2, Pattern1.Length);
126-
Assert.AreEqual (length2 / 2, file2.Find (Pattern1));
128+
ClassicAssert.AreEqual (length2 / 2, file2.Find (Pattern1));
127129

128130
file2.Insert (Pattern1, 30, Pattern1.Length);
129-
Assert.AreEqual (30, file2.Find (Pattern1));
131+
ClassicAssert.AreEqual (30, file2.Find (Pattern1));
130132

131-
Assert.AreEqual (30, file2.Find (Pattern1, 2));
132-
Assert.AreEqual (length2 / 2, file2.Find (Pattern1, 31));
133-
Assert.AreEqual (length2 - 30, file2.Find (Pattern1, length2 / 2 + 3));
133+
ClassicAssert.AreEqual (30, file2.Find (Pattern1, 2));
134+
ClassicAssert.AreEqual (length2 / 2, file2.Find (Pattern1, 31));
135+
ClassicAssert.AreEqual (length2 - 30, file2.Find (Pattern1, length2 / 2 + 3));
134136

135137
// file3
136138
// especially used to test searching if the search pattern is splattened to
137139
// different buffer reads.
138140
// this test is specialized to the used algorithm
139141
var file3 = CreateFile (length3);
140-
Assert.AreEqual (-1, file3.Find (Pattern1));
141-
Assert.AreEqual (-1, file3.Find (Pattern1, 13));
142+
ClassicAssert.AreEqual (-1, file3.Find (Pattern1));
143+
ClassicAssert.AreEqual (-1, file3.Find (Pattern1, 13));
142144

143145
long buffer_cross2 = 2 * File.BufferSize - (Pattern1.Length / 2);
144146
file3.Insert (Pattern1, buffer_cross2, Pattern1.Length);
145-
Assert.AreEqual (buffer_cross2, file3.Find (Pattern1));
147+
ClassicAssert.AreEqual (buffer_cross2, file3.Find (Pattern1));
146148

147149
long buffer_cross1 = File.BufferSize - (Pattern1.Length / 2);
148150
file3.Insert (Pattern1, buffer_cross1, Pattern1.Length);
149-
Assert.AreEqual (buffer_cross1, file3.Find (Pattern1));
151+
ClassicAssert.AreEqual (buffer_cross1, file3.Find (Pattern1));
150152

151-
Assert.AreEqual (buffer_cross2, file3.Find (Pattern1, buffer_cross1 + 1));
153+
ClassicAssert.AreEqual (buffer_cross2, file3.Find (Pattern1, buffer_cross1 + 1));
152154

153155
long buffer_cross3 = File.BufferSize - 1;
154156
file3.Insert (Pattern3, buffer_cross3 - 1, Pattern3.Length);
155157
file3.Insert (Pattern3, buffer_cross3, Pattern3.Length);
156-
Assert.AreEqual (buffer_cross3, file3.Find (Pattern3));
158+
ClassicAssert.AreEqual (buffer_cross3, file3.Find (Pattern3));
157159
}
158160
}
159161

0 commit comments

Comments
 (0)