Skip to content

Commit b1bad76

Browse files
RoogRoog
committed
Testing framework adjusted .net 6
1 parent f718489 commit b1bad76

19 files changed

+376
-919
lines changed

‎src/EmberLibConsumer.net/Lawo.EmberPlusSharpTest/Ember/CompatibilityTest.cs

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,7 @@ public class CompatibilityTest : TestBase
2424
[TestMethod]
2525
public void BooleanTest()
2626
{
27-
var value = this.Random.Next(0, 2) == 1;
27+
var value = Random.Shared.Next(0, 2) == 1;
2828
this.AssertEqual((w, i, v) => w.WriteValue(i, v), r => r.GetBoolean(), value);
2929
this.AssertEqual((w, t, v) => w.Write(t, v), r => r.ReadContentsAsBoolean(), value);
3030
}
@@ -34,7 +34,7 @@ public void BooleanTest()
3434
public void IntegerTest()
3535
{
3636
var longBytes = new byte[Marshal.SizeOf(typeof(long))];
37-
this.Random.NextBytes(longBytes);
37+
Random.Shared.NextBytes(longBytes);
3838
var value = BitConverter.ToInt64(longBytes, 0);
3939

4040
this.AssertEqual((w, i, v) => w.WriteValue(i, v), r => r.GetLong(), value);
@@ -46,7 +46,7 @@ public void IntegerTest()
4646
public void OctetstringTest()
4747
{
4848
var value = new byte[1024];
49-
this.Random.NextBytes(value);
49+
Random.Shared.NextBytes(value);
5050
this.CollectionAssertEqual((w, i, v) => w.WriteValue(i, v), r => r.GetOctetString(), value);
5151
this.CollectionAssertEqual((w, t, v) => w.Write(t, v), r => r.ReadContentsAsByteArray(), value);
5252
}
@@ -55,7 +55,7 @@ public void OctetstringTest()
5555
[TestMethod]
5656
public void RealTest()
5757
{
58-
var value = (this.Random.NextDouble() - 0.5) * this.Random.Next(int.MaxValue);
58+
var value = (Random.Shared.NextDouble() - 0.5) * Random.Shared.Next(int.MaxValue);
5959
this.AssertEqual((w, i, v) => w.WriteValue(i, v), r => r.GetReal(), value);
6060
this.AssertEqual((w, t, v) => w.Write(t, v), r => r.ReadContentsAsDouble(), value);
6161
}
@@ -82,11 +82,11 @@ public void Utf8StringTest()
8282
[TestMethod]
8383
public void RelativeObjectIdentifierTest()
8484
{
85-
var value = new int[this.Random.Next(0, 16)];
85+
var value = new int[Random.Shared.Next(0, 16)];
8686

8787
for (int index = 0; index < value.Length; ++index)
8888
{
89-
value[index] = this.Random.Next();
89+
value[index] = Random.Shared.Next();
9090
}
9191

9292
this.CollectionAssertEqual((w, i, v) => w.WriteValue(i, v), r => r.GetRelativeOid(), value);
@@ -138,7 +138,7 @@ private void CollectionAssertEqual<T>(
138138
private void AssertEqual<T>(
139139
Action<EmberWriter, EmberId, T> write, Func<EmberLib.EmberReader, T> read, T value, Action<T, T> assertEqual)
140140
{
141-
var number = this.Random.Next();
141+
var number = Random.Shared.Next();
142142
var outer = EmberId.CreateApplication(number);
143143
var tag = new BerTag(BerClass.Application, (uint)number);
144144

@@ -160,7 +160,7 @@ private void AssertEqual<T>(
160160
private void AssertEqual<T>(
161161
Action<EmberLib.EmberWriter, BerTag, T> write, Func<EmberReader, T> read, T value, Action<T, T> assertEqual)
162162
{
163-
var number = this.Random.Next();
163+
var number = Random.Shared.Next();
164164
var outerId = EmberId.CreateApplication(number);
165165
var tag = new BerTag(BerClass.Application, (uint)number);
166166

‎src/EmberLibConsumer.net/Lawo.EmberPlusSharpTest/Ember/EmberConverterTest.cs

Lines changed: 11 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -28,23 +28,21 @@ public class EmberConverterTest : TestBase
2828
[TestMethod]
2929
public void ExceptionTest()
3030
{
31-
AssertThrow<ArgumentNullException>(
32-
() => new EmberType(null).Ignore(),
33-
() => new EmberTypeBag(null).Ignore(),
34-
() => new EmberConverter(null).Ignore());
31+
Assert.ThrowsException<ArgumentNullException>(() => new EmberType(null).Ignore());
32+
Assert.ThrowsException<ArgumentNullException>(() => new EmberTypeBag(null).Ignore());
33+
Assert.ThrowsException<ArgumentNullException>(() => new EmberConverter(null).Ignore());
3534

36-
AssertThrow<ArgumentException>(() => new EmberType().Ignore());
35+
Assert.ThrowsException<ArgumentException>(() => new EmberType().Ignore());
3736

3837
using (var stream = new MemoryStream())
3938
using (var reader = new EmberReader(stream))
4039
using (var writer = XmlWriter.Create(new StringBuilder()))
4140
{
4241
var converter = new EmberConverter();
43-
AssertThrow<ArgumentNullException>(
44-
() => converter.ToXml((byte[])null, writer),
45-
() => converter.ToXml(new byte[0], null),
46-
() => converter.ToXml((EmberReader)null, writer),
47-
() => converter.ToXml(reader, null));
42+
Assert.ThrowsException<ArgumentNullException>(() => converter.ToXml((byte[]) null, writer));
43+
Assert.ThrowsException<ArgumentNullException>(() => converter.ToXml(new byte[0], null));
44+
Assert.ThrowsException<ArgumentNullException>(() => converter.ToXml((EmberReader) null, writer));
45+
Assert.ThrowsException<ArgumentNullException>(() => converter.ToXml(reader, null));
4846
}
4947

5048
using (var stringReader = new StringReader(string.Empty))
@@ -53,10 +51,9 @@ public void ExceptionTest()
5351
using (var writer = new EmberWriter(stream))
5452
{
5553
var converter = new EmberConverter();
56-
AssertThrow<ArgumentNullException>(
57-
() => converter.FromXml(null),
58-
() => converter.FromXml(null, writer),
59-
() => converter.FromXml(reader, null));
54+
Assert.ThrowsException<ArgumentNullException>(() => converter.FromXml(null));
55+
Assert.ThrowsException<ArgumentNullException>(() => converter.FromXml(null, writer));
56+
Assert.ThrowsException<ArgumentNullException>(() => converter.FromXml(reader, null));
6057
}
6158

6259
AssertXmlException("<whatever type=\"A-11\"></whatever>", "Unknown field path: whatever.");

‎src/EmberLibConsumer.net/Lawo.EmberPlusSharpTest/Ember/EmberReaderTest.cs

Lines changed: 23 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -23,6 +23,7 @@ namespace Lawo.EmberPlusSharp.Ember
2323
/// <summary>Tests <see cref="EmberReader"/>.</summary>
2424
[TestClass]
2525
public class EmberReaderTest : TestBase
26+
public class EmberReaderTest
2627
{
2728
/// <summary>Tests with an empty stream.</summary>
2829
[TestMethod]
@@ -48,7 +49,7 @@ public void SkipContentsTest()
4849
}
4950

5051
var original = new byte[64];
51-
this.Random.NextBytes(original);
52+
Random.Shared.NextBytes(original);
5253
byte[] encoded;
5354

5455
using (var stream = new MemoryStream())
@@ -109,14 +110,14 @@ public void ShortOctetstringTest()
109110
{
110111
AssertDecode(new byte[0]);
111112
AssertDecode(this.Randomize(new byte[1]));
112-
AssertDecode(this.Randomize(new byte[this.Random.Next(126)]));
113+
AssertDecode(this.Randomize(new byte[Random.Shared.Next(126)]));
113114
}
114115

115116
/// <summary>Tests Octetstring contents with lengths &gt;= 128.</summary>
116117
[TestMethod]
117118
public void LongOctetstringTest()
118119
{
119-
var contents = new byte[this.Random.Next(128, 253)];
120+
var contents = new byte[Random.Shared.Next(128, 253)];
120121
this.Randomize(contents);
121122

122123
var header =
@@ -167,11 +168,11 @@ public void RelativeObjectIdentifierTest()
167168
{
168169
AssertDecode(new int[] { });
169170

170-
var relativeObjectIdentifier = new int[this.Random.Next(32)];
171+
var relativeObjectIdentifier = new int[Random.Shared.Next(32)];
171172

172173
for (int index = 0; index < relativeObjectIdentifier.Length; ++index)
173174
{
174-
relativeObjectIdentifier[index] = this.Random.Next(128);
175+
relativeObjectIdentifier[index] = Random.Shared.Next(128);
175176
}
176177

177178
AssertDecode(relativeObjectIdentifier);
@@ -185,10 +186,10 @@ public void ContainerTest()
185186
reader =>
186187
{
187188
Assert.IsFalse(reader.CanReadContents);
188-
AssertThrow<InvalidOperationException>(() => reader.ReadContentsAsObject());
189+
Assert.ThrowsException<InvalidOperationException>(() => reader.ReadContentsAsObject());
189190
Assert.IsTrue(reader.Read());
190191
Assert.AreEqual(InnerNumber.EndContainer, reader.InnerNumber);
191-
AssertThrow<InvalidOperationException>(() => reader.OuterId.Ignore());
192+
Assert.ThrowsException<InvalidOperationException>(() => reader.OuterId.Ignore());
192193
};
193194

194195
AssertDecode(InnerNumber.Sequence, assertEqual, 0x60, 0x80, 0x30, 0x80, 0x00, 0x00, 0x00, 0x00);
@@ -203,16 +204,16 @@ public void ContainerTest()
203204
[TestMethod]
204205
public void ExceptionTest()
205206
{
206-
TestStandardExceptionConstructors<EmberException>();
207+
//TestStandardExceptionConstructors<EmberException>();
207208

208-
AssertThrow<ArgumentNullException>(() => new EmberReader(null, 1).Dispose());
209+
Assert.ThrowsException<ArgumentNullException>(() => new EmberReader(null, 1).Dispose());
209210
AssertEmberException("Incorrect length at position 3.", 0x60, 0x03, 0x0D, 0x01, 0xFF, 0x00);
210211

211212
using (var stream = new MemoryStream(new byte[] { 0x60, 0x03, 0x01, 0x01, 0xFF }))
212213
using (var reader = new EmberReader(stream, 1))
213214
{
214215
reader.Read();
215-
AssertThrow<InvalidOperationException>(() => reader.ReadContentsAsString());
216+
Assert.ThrowsException<InvalidOperationException>(() => reader.ReadContentsAsString());
216217
reader.ReadContentsAsBoolean();
217218
}
218219

@@ -411,22 +412,22 @@ private static void AssertDecode(int expectedInnerNumber, Action<EmberReader> as
411412
using (var stream = new MemoryStream(input))
412413
using (var reader = new EmberReader(stream, 1))
413414
{
414-
AssertThrow<InvalidOperationException>(() => reader.InnerNumber.GetHashCode().Ignore());
415-
AssertThrow<InvalidOperationException>(() => reader.OuterId.Ignore());
416-
AssertThrow<InvalidOperationException>(() => reader.ReadContentsAsObject());
415+
Assert.ThrowsException<InvalidOperationException>(() => reader.InnerNumber.GetHashCode().Ignore());
416+
Assert.ThrowsException<InvalidOperationException>(() => reader.OuterId.Ignore());
417+
Assert.ThrowsException<InvalidOperationException>(() => reader.ReadContentsAsObject());
417418
Assert.IsFalse(reader.CanReadContents);
418419
Assert.IsTrue(reader.Read());
419420
Assert.AreEqual(EmberId.CreateApplication(0), reader.OuterId);
420421
Assert.AreEqual(expectedInnerNumber, reader.InnerNumber);
421422
assertEqual(reader);
422-
AssertThrow<InvalidOperationException>(() => reader.ReadContentsAsObject());
423+
Assert.ThrowsException<InvalidOperationException>(() => reader.ReadContentsAsObject());
423424
Assert.IsFalse(reader.Read());
424425

425426
reader.Dispose();
426427
Assert.IsFalse(reader.CanReadContents);
427-
AssertThrow<ObjectDisposedException>(() => reader.InnerNumber.Ignore());
428-
AssertThrow<ObjectDisposedException>(() => reader.OuterId.Ignore());
429-
AssertThrow<ObjectDisposedException>(() => reader.ReadContentsAsObject());
428+
Assert.ThrowsException<ObjectDisposedException>(() => reader.InnerNumber.Ignore());
429+
Assert.ThrowsException<ObjectDisposedException>(() => reader.OuterId.Ignore());
430+
Assert.ThrowsException<ObjectDisposedException>(() => reader.ReadContentsAsObject());
430431
}
431432

432433
using (var writer = XmlWriter.Create(Console.Out, new XmlWriterSettings() { Indent = true }))
@@ -460,15 +461,15 @@ private static void ReadAll(params byte[] input)
460461
switch (reader.InnerNumber)
461462
{
462463
case InnerNumber.EndContainer:
463-
AssertThrow<InvalidOperationException>(() => reader.OuterId.Ignore());
464+
Assert.ThrowsException<InvalidOperationException>(() => reader.OuterId.Ignore());
464465
Assert.IsFalse(reader.CanReadContents);
465-
AssertThrow<InvalidOperationException>(() => reader.ReadContentsAsObject());
466+
Assert.ThrowsException<InvalidOperationException>(() => reader.ReadContentsAsObject());
466467
break;
467468
case InnerNumber.Sequence:
468469
case InnerNumber.Set:
469470
reader.OuterId.Ignore();
470471
Assert.IsFalse(reader.CanReadContents);
471-
AssertThrow<InvalidOperationException>(() => reader.ReadContentsAsObject());
472+
Assert.ThrowsException<InvalidOperationException>(() => reader.ReadContentsAsObject());
472473
break;
473474
case InnerNumber.Boolean:
474475
case InnerNumber.Integer:
@@ -484,7 +485,7 @@ private static void ReadAll(params byte[] input)
484485
Assert.IsTrue(reader.InnerNumber >= InnerNumber.FirstApplication);
485486
reader.OuterId.Ignore();
486487
Assert.IsFalse(reader.CanReadContents);
487-
AssertThrow<InvalidOperationException>(() => reader.ReadContentsAsObject());
488+
Assert.ThrowsException<InvalidOperationException>(() => reader.ReadContentsAsObject());
488489
break;
489490
}
490491
}
@@ -493,7 +494,7 @@ private static void ReadAll(params byte[] input)
493494

494495
private byte[] Randomize(byte[] bytes)
495496
{
496-
this.Random.NextBytes(bytes);
497+
Random.Shared.NextBytes(bytes);
497498
return bytes;
498499
}
499500
}

‎src/EmberLibConsumer.net/Lawo.EmberPlusSharpTest/Ember/EmberWriterTest.cs

Lines changed: 16 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -74,33 +74,31 @@ public void MainTest()
7474
[TestMethod]
7575
public void ExceptionTest()
7676
{
77-
AssertThrow<ArgumentNullException>(() => new EmberWriter(null, 1).Dispose());
78-
AssertThrow<ArgumentException>(() => new EmberWriter(new MemoryStream(), 0).Dispose());
77+
Assert.ThrowsException<ArgumentNullException>(() => new EmberWriter(null, 1).Dispose());
78+
Assert.ThrowsException<ArgumentException>(() => new EmberWriter(new MemoryStream(), 0).Dispose());
7979

8080
using (var writer = new EmberWriter(new MemoryStream(), 1))
8181
{
8282
var outer = EmberId.CreateApplication(0);
8383

84-
AssertThrow<ArgumentNullException>(
85-
() => writer.WriteValue(outer, (byte[])null),
86-
() => writer.WriteValue(outer, (int[])null),
87-
() => writer.WriteValue(outer, (string)null));
84+
Assert.ThrowsException<ArgumentNullException>(() => writer.WriteValue(outer, (byte[]) null));
85+
Assert.ThrowsException<ArgumentNullException>(() => writer.WriteValue(outer, (int[]) null));
86+
Assert.ThrowsException<ArgumentNullException>(() => writer.WriteValue(outer, (string)null));
8887

89-
AssertThrow<ArgumentOutOfRangeException>(
88+
Assert.ThrowsException<ArgumentOutOfRangeException>(
9089
() => writer.WriteStartApplicationDefinedType(outer, InnerNumber.FirstApplication - 1));
9190

9291
writer.Dispose();
93-
AssertThrow<ObjectDisposedException>(
94-
() => writer.WriteValue(outer, true),
95-
() => writer.WriteValue(outer, 0),
96-
() => writer.WriteValue(outer, new byte[] { }),
97-
() => writer.WriteValue(outer, 0.0),
98-
() => writer.WriteValue(outer, string.Empty),
99-
() => writer.WriteValue(outer, new int[] { }),
100-
() => writer.WriteStartSequence(outer),
101-
() => writer.WriteStartSet(outer),
102-
() => writer.WriteStartApplicationDefinedType(outer, InnerNumber.FirstApplication),
103-
() => writer.WriteEndContainer());
92+
Assert.ThrowsException<ObjectDisposedException>(() => writer.WriteValue(outer, true));
93+
Assert.ThrowsException<ObjectDisposedException>(() => writer.WriteValue(outer, 0));
94+
Assert.ThrowsException<ObjectDisposedException>(() => writer.WriteValue(outer, new byte[] { }));
95+
Assert.ThrowsException<ObjectDisposedException>(() => writer.WriteValue(outer, 0.0));
96+
Assert.ThrowsException<ObjectDisposedException>(() => writer.WriteValue(outer, string.Empty));
97+
Assert.ThrowsException<ObjectDisposedException>(() => writer.WriteValue(outer, new int[] { }));
98+
Assert.ThrowsException<ObjectDisposedException>(() => writer.WriteStartSequence(outer));
99+
Assert.ThrowsException<ObjectDisposedException>(() => writer.WriteStartSet(outer));
100+
Assert.ThrowsException<ObjectDisposedException>(() => writer.WriteStartApplicationDefinedType(outer, InnerNumber.FirstApplication));
101+
Assert.ThrowsException<ObjectDisposedException>(() => writer.WriteEndContainer());
104102
}
105103
}
106104

‎src/EmberLibConsumer.net/Lawo.EmberPlusSharpTest/Glow/GlowLogConverterTest.cs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -31,10 +31,10 @@ public void MainTest()
3131

3232
/// <summary>Tests <see cref="GlowLogConverter"/> exceptions.</summary>
3333
[TestMethod]
34-
public void ExceptionTest() =>
35-
AssertThrow<ArgumentNullException>(
36-
() => GlowLogConverter.Convert(null, XmlWriter.Create(Stream.Null)),
37-
() => GlowLogConverter.Convert(XmlReader.Create(Stream.Null), null));
34+
public void ExceptionTest() {
35+
Assert.ThrowsException<ArgumentNullException>(() => GlowLogConverter.Convert(null, XmlWriter.Create(Stream.Null)));
36+
Assert.ThrowsException<ArgumentNullException>(() => GlowLogConverter.Convert(XmlReader.Create(Stream.Null), null));
37+
}
3838

3939
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
4040

0 commit comments

Comments
 (0)