diff --git a/LibreMetaverse.Tests/BinaryLLSDTests.cs b/LibreMetaverse.Tests/BinaryLLSDTests.cs index b3247d28..e6f2a3db 100644 --- a/LibreMetaverse.Tests/BinaryLLSDTests.cs +++ b/LibreMetaverse.Tests/BinaryLLSDTests.cs @@ -1,6 +1,6 @@ /* * Copyright (c) 2006-2016, openmetaverse.co - * Copyright (c) 2021-2022, Sjofn LLC. + * Copyright (c) 2021-2024, Sjofn LLC. * All rights reserved. * * - Redistribution and use in source and binary forms, with or without @@ -42,6 +42,7 @@ using System.IO; using System.Text; using System.Xml; using NUnit.Framework; +using NUnit.Framework.Legacy; using OpenMetaverse; using OpenMetaverse.StructuredData; @@ -62,39 +63,39 @@ namespace LibreMetaverse.Tests stream.Position = 0L; bool result = OSDParser.FindString(stream, "this"); - Assert.AreEqual(true, result); - Assert.AreEqual(4L, stream.Position); + ClassicAssert.AreEqual(true, result); + ClassicAssert.AreEqual(4L, stream.Position); stream.Position = 10L; result = OSDParser.FindString(stream, "teststring"); - Assert.AreEqual(true, result); - Assert.AreEqual(20L, stream.Position); + ClassicAssert.AreEqual(true, result); + ClassicAssert.AreEqual(20L, stream.Position); stream.Position = 25L; result = OSDParser.FindString(stream, "notfound"); - Assert.AreEqual(false, result); - Assert.AreEqual(25L, stream.Position); + ClassicAssert.AreEqual(false, result); + ClassicAssert.AreEqual(25L, stream.Position); stream.Position = 60L; result = OSDParser.FindString(stream, "beginningAndMore"); - Assert.AreEqual(false, result); - Assert.AreEqual(60L, stream.Position); + ClassicAssert.AreEqual(false, result); + ClassicAssert.AreEqual(60L, stream.Position); byte[] sFrontWhiteSpace = Encoding.ASCII.GetBytes(" \t\t\n\rtest"); MemoryStream streamTwo = new MemoryStream(sFrontWhiteSpace); OSDParser.SkipWhiteSpace(streamTwo); - Assert.AreEqual(7L, streamTwo.Position); + ClassicAssert.AreEqual(7L, streamTwo.Position); byte[] sMiddleWhiteSpace = Encoding.ASCII.GetBytes("test \t\t\n\rtest"); MemoryStream streamThree = new MemoryStream(sMiddleWhiteSpace); streamThree.Position = 4L; OSDParser.SkipWhiteSpace(streamThree); - Assert.AreEqual(9L, streamThree.Position); + ClassicAssert.AreEqual(9L, streamThree.Position); byte[] sNoWhiteSpace = Encoding.ASCII.GetBytes("testtesttest"); MemoryStream streamFour = new MemoryStream(sNoWhiteSpace); OSDParser.SkipWhiteSpace(streamFour); - Assert.AreEqual(0L, streamFour.Position); + ClassicAssert.AreEqual(0L, streamFour.Position); } @@ -106,7 +107,7 @@ namespace LibreMetaverse.Tests public void DeserializeUndef() { OSD llsdUndef = OSDParser.DeserializeLLSDBinary(binaryUndef); - Assert.AreEqual(OSDType.Unknown, llsdUndef.Type); + ClassicAssert.AreEqual(OSDType.Unknown, llsdUndef.Type); } [Test()] @@ -114,7 +115,7 @@ namespace LibreMetaverse.Tests { OSD llsdUndef = new OSD(); byte[] binaryUndefSerialized = OSDParser.SerializeLLSDBinary(llsdUndef); - Assert.AreEqual(binaryUndef, binaryUndefSerialized); + ClassicAssert.AreEqual(binaryUndef, binaryUndefSerialized); } private static byte[] binaryTrueValue = { 0x31 }; @@ -128,12 +129,12 @@ namespace LibreMetaverse.Tests public void DeserializeBool() { OSD llsdTrue = OSDParser.DeserializeLLSDBinary(binaryTrue); - Assert.AreEqual(OSDType.Boolean, llsdTrue.Type); - Assert.AreEqual(true, llsdTrue.AsBoolean()); + ClassicAssert.AreEqual(OSDType.Boolean, llsdTrue.Type); + ClassicAssert.AreEqual(true, llsdTrue.AsBoolean()); OSD llsdFalse = OSDParser.DeserializeLLSDBinary(binaryFalse); - Assert.AreEqual(OSDType.Boolean, llsdFalse.Type); - Assert.AreEqual(false, llsdFalse.AsBoolean()); + ClassicAssert.AreEqual(OSDType.Boolean, llsdFalse.Type); + ClassicAssert.AreEqual(false, llsdFalse.AsBoolean()); } [Test()] @@ -141,11 +142,11 @@ namespace LibreMetaverse.Tests { OSD llsdTrue = OSD.FromBoolean(true); byte[] binaryTrueSerialized = OSDParser.SerializeLLSDBinary(llsdTrue); - Assert.AreEqual(binaryTrue, binaryTrueSerialized); + ClassicAssert.AreEqual(binaryTrue, binaryTrueSerialized); OSD llsdFalse = OSD.FromBoolean(false); byte[] binaryFalseSerialized = OSDParser.SerializeLLSDBinary(llsdFalse); - Assert.AreEqual(binaryFalse, binaryFalseSerialized); + ClassicAssert.AreEqual(binaryFalse, binaryFalseSerialized); } private static byte[] binaryZeroIntValue = { 0x69, 0x0, 0x0, 0x0, 0x0 }; @@ -158,13 +159,13 @@ namespace LibreMetaverse.Tests public void DeserializeInteger() { OSD llsdZeroInteger = OSDParser.DeserializeLLSDBinary(binaryZeroInt); - Assert.AreEqual(OSDType.Integer, llsdZeroInteger.Type); - Assert.AreEqual(0, llsdZeroInteger.AsInteger()); + ClassicAssert.AreEqual(OSDType.Integer, llsdZeroInteger.Type); + ClassicAssert.AreEqual(0, llsdZeroInteger.AsInteger()); OSD llsdAnInteger = OSDParser.DeserializeLLSDBinary(binaryAnInt); - Assert.AreEqual(OSDType.Integer, llsdAnInteger.Type); - Assert.AreEqual(1234843, llsdAnInteger.AsInteger()); + ClassicAssert.AreEqual(OSDType.Integer, llsdAnInteger.Type); + ClassicAssert.AreEqual(1234843, llsdAnInteger.AsInteger()); } [Test()] @@ -172,17 +173,17 @@ namespace LibreMetaverse.Tests { OSD llsdZeroInt = OSD.FromInteger(0); byte[] binaryZeroIntSerialized = OSDParser.SerializeLLSDBinary(llsdZeroInt); - Assert.AreEqual(binaryZeroInt, binaryZeroIntSerialized); + ClassicAssert.AreEqual(binaryZeroInt, binaryZeroIntSerialized); binaryZeroIntSerialized = OSDParser.SerializeLLSDBinary(llsdZeroInt, false); - Assert.AreEqual(binaryZeroIntValue, binaryZeroIntSerialized); + ClassicAssert.AreEqual(binaryZeroIntValue, binaryZeroIntSerialized); OSD llsdAnInt = OSD.FromInteger(1234843); byte[] binaryAnIntSerialized = OSDParser.SerializeLLSDBinary(llsdAnInt); - Assert.AreEqual(binaryAnInt, binaryAnIntSerialized); + ClassicAssert.AreEqual(binaryAnInt, binaryAnIntSerialized); binaryAnIntSerialized = OSDParser.SerializeLLSDBinary(llsdAnInt, false); - Assert.AreEqual(binaryAnIntValue, binaryAnIntSerialized); + ClassicAssert.AreEqual(binaryAnIntValue, binaryAnIntSerialized); } private static byte[] binaryRealValue = { 0x72, 0x41, 0x2c, 0xec, 0xf6, 0x77, 0xce, 0xd9, 0x17 }; @@ -192,8 +193,8 @@ namespace LibreMetaverse.Tests public void DeserializeReal() { OSD llsdReal = OSDParser.DeserializeLLSDBinary(binaryReal); - Assert.AreEqual(OSDType.Real, llsdReal.Type); - Assert.AreEqual(947835.234d, llsdReal.AsReal()); + ClassicAssert.AreEqual(OSDType.Real, llsdReal.Type); + ClassicAssert.AreEqual(947835.234d, llsdReal.AsReal()); } [Test()] @@ -201,10 +202,10 @@ namespace LibreMetaverse.Tests { OSD llsdReal = OSD.FromReal(947835.234d); byte[] binaryRealSerialized = OSDParser.SerializeLLSDBinary(llsdReal); - Assert.AreEqual(binaryReal, binaryRealSerialized); + ClassicAssert.AreEqual(binaryReal, binaryRealSerialized); binaryRealSerialized = OSDParser.SerializeLLSDBinary(llsdReal); - Assert.AreEqual(binaryReal, binaryRealSerialized); + ClassicAssert.AreEqual(binaryReal, binaryRealSerialized); } private static byte[] binaryAUUIDValue = { 0x75, 0x97, 0xf4, 0xae, 0xca, 0x88, 0xa1, 0x42, 0xa1, @@ -219,12 +220,12 @@ namespace LibreMetaverse.Tests public void DeserializeUUID() { OSD llsdAUUID = OSDParser.DeserializeLLSDBinary(binaryAUUID); - Assert.AreEqual(OSDType.UUID, llsdAUUID.Type); - Assert.AreEqual("97f4aeca-88a1-42a1-b385-b97b18abb255", llsdAUUID.AsString()); + ClassicAssert.AreEqual(OSDType.UUID, llsdAUUID.Type); + ClassicAssert.AreEqual("97f4aeca-88a1-42a1-b385-b97b18abb255", llsdAUUID.AsString()); OSD llsdZeroUUID = OSDParser.DeserializeLLSDBinary(binaryZeroUUID); - Assert.AreEqual(OSDType.UUID, llsdZeroUUID.Type); - Assert.AreEqual("00000000-0000-0000-0000-000000000000", llsdZeroUUID.AsString()); + ClassicAssert.AreEqual(OSDType.UUID, llsdZeroUUID.Type); + ClassicAssert.AreEqual("00000000-0000-0000-0000-000000000000", llsdZeroUUID.AsString()); } @@ -233,17 +234,17 @@ namespace LibreMetaverse.Tests { OSD llsdAUUID = OSD.FromUUID(new UUID("97f4aeca-88a1-42a1-b385-b97b18abb255")); byte[] binaryAUUIDSerialized = OSDParser.SerializeLLSDBinary(llsdAUUID); - Assert.AreEqual(binaryAUUID, binaryAUUIDSerialized); + ClassicAssert.AreEqual(binaryAUUID, binaryAUUIDSerialized); binaryAUUIDSerialized = OSDParser.SerializeLLSDBinary(llsdAUUID); - Assert.AreEqual(binaryAUUID, binaryAUUIDSerialized); + ClassicAssert.AreEqual(binaryAUUID, binaryAUUIDSerialized); OSD llsdZeroUUID = OSD.FromUUID(new UUID("00000000-0000-0000-0000-000000000000")); byte[] binaryZeroUUIDSerialized = OSDParser.SerializeLLSDBinary(llsdZeroUUID); - Assert.AreEqual(binaryZeroUUID, binaryZeroUUIDSerialized); + ClassicAssert.AreEqual(binaryZeroUUID, binaryZeroUUIDSerialized); binaryZeroUUIDSerialized = OSDParser.SerializeLLSDBinary(llsdZeroUUID); - Assert.AreEqual(binaryZeroUUID, binaryZeroUUIDSerialized); + ClassicAssert.AreEqual(binaryZeroUUID, binaryZeroUUIDSerialized); } private static byte[] binaryBinStringValue = { 0x62, 0x0, 0x0, 0x0, 0x34, // this line is the encoding header @@ -257,12 +258,12 @@ namespace LibreMetaverse.Tests public void DeserializeLLSDBinary() { OSD llsdBytes = OSDParser.DeserializeLLSDBinary(binaryBinString); - Assert.AreEqual(OSDType.Binary, llsdBytes.Type); + ClassicAssert.AreEqual(OSDType.Binary, llsdBytes.Type); byte[] contentBinString = { 0x74, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x20, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0xa, 0xd }; - Assert.AreEqual(contentBinString, llsdBytes.AsBinary()); + ClassicAssert.AreEqual(contentBinString, llsdBytes.AsBinary()); } [Test()] @@ -274,7 +275,7 @@ namespace LibreMetaverse.Tests 0x69, 0x73, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0xa, 0xd }; OSD llsdBinary = OSD.FromBinary(contentBinString); byte[] binaryBinarySerialized = OSDParser.SerializeLLSDBinary(llsdBinary); - Assert.AreEqual(binaryBinString, binaryBinarySerialized); + ClassicAssert.AreEqual(binaryBinString, binaryBinarySerialized); } private static byte[] binaryEmptyStringValue = { 0x73, 0x0, 0x0, 0x0, 0x0 }; @@ -292,14 +293,14 @@ namespace LibreMetaverse.Tests public void DeserializeString() { OSD llsdEmptyString = OSDParser.DeserializeLLSDBinary(binaryEmptyString); - Assert.AreEqual(OSDType.String, llsdEmptyString.Type); + ClassicAssert.AreEqual(OSDType.String, llsdEmptyString.Type); string contentEmptyString = ""; - Assert.AreEqual(contentEmptyString, llsdEmptyString.AsString()); + ClassicAssert.AreEqual(contentEmptyString, llsdEmptyString.AsString()); OSD llsdLongString = OSDParser.DeserializeLLSDBinary(binaryLongString); - Assert.AreEqual(OSDType.String, llsdLongString.Type); + ClassicAssert.AreEqual(OSDType.String, llsdLongString.Type); string contentLongString = "abcdefghijklmnopqrstuvwxyz01234567890"; - Assert.AreEqual(contentLongString, llsdLongString.AsString()); + ClassicAssert.AreEqual(contentLongString, llsdLongString.AsString()); } [Test()] @@ -307,7 +308,7 @@ namespace LibreMetaverse.Tests { OSD llsdString = OSD.FromString("abcdefghijklmnopqrstuvwxyz01234567890"); byte[] binaryLongStringSerialized = OSDParser.SerializeLLSDBinary(llsdString); - Assert.AreEqual(binaryLongString, binaryLongStringSerialized); + ClassicAssert.AreEqual(binaryLongString, binaryLongStringSerialized); // A test with some utf8 characters string contentAStringXML = "ƖȔȠȨɆɒ"; @@ -320,8 +321,8 @@ namespace LibreMetaverse.Tests OSD llsdAString = OSD.FromString(contentAString); byte[] binaryAString = OSDParser.SerializeLLSDBinary(llsdAString); OSD llsdAStringDS = OSDParser.DeserializeLLSDBinary(binaryAString); - Assert.AreEqual(OSDType.String, llsdAStringDS.Type); - Assert.AreEqual(contentAString, llsdAStringDS.AsString()); + ClassicAssert.AreEqual(OSDType.String, llsdAStringDS.Type); + ClassicAssert.AreEqual(contentAString, llsdAStringDS.AsString()); // we also test for a 4byte character. string xml = "𐄷"; @@ -334,8 +335,8 @@ namespace LibreMetaverse.Tests OSD llsdStringOne = OSD.FromString(content); byte[] binaryAStringOneSerialized = OSDParser.SerializeLLSDBinary(llsdStringOne); OSD llsdStringOneDS = OSDParser.DeserializeLLSDBinary(binaryAStringOneSerialized); - Assert.AreEqual(OSDType.String, llsdStringOneDS.Type); - Assert.AreEqual(content, llsdStringOneDS.AsString()); + ClassicAssert.AreEqual(OSDType.String, llsdStringOneDS.Type); + ClassicAssert.AreEqual(content, llsdStringOneDS.AsString()); } @@ -351,9 +352,9 @@ namespace LibreMetaverse.Tests public void DeserializeURI() { OSD llsdURI = OSDParser.DeserializeLLSDBinary(binaryURI); - Assert.AreEqual(OSDType.URI, llsdURI.Type); + ClassicAssert.AreEqual(OSDType.URI, llsdURI.Type); Uri uri = new Uri("http://www.testurl.test/"); - Assert.AreEqual(uri, llsdURI.AsUri()); + ClassicAssert.AreEqual(uri, llsdURI.AsUri()); } @@ -362,7 +363,7 @@ namespace LibreMetaverse.Tests { OSD llsdUri = OSD.FromUri(new Uri("http://www.testurl.test/")); byte[] binaryURISerialized = OSDParser.SerializeLLSDBinary(llsdUri); - Assert.AreEqual(binaryURI, binaryURISerialized); + ClassicAssert.AreEqual(binaryURI, binaryURISerialized); } // Here is a problem. @@ -377,10 +378,10 @@ namespace LibreMetaverse.Tests public void DeserializeDateTime() { OSD llsdDateTime = OSDParser.DeserializeLLSDBinary(binaryDateTime); - Assert.AreEqual(OSDType.Date, llsdDateTime.Type); + ClassicAssert.AreEqual(OSDType.Date, llsdDateTime.Type); DateTime dt = new DateTime(2008, 1, 1, 20, 10, 31, 0, DateTimeKind.Utc); DateTime dateLocal = llsdDateTime.AsDate(); - Assert.AreEqual(dt, dateLocal.ToUniversalTime()); + ClassicAssert.AreEqual(dt, dateLocal.ToUniversalTime()); } [Test()] @@ -389,22 +390,22 @@ namespace LibreMetaverse.Tests DateTime dt = new DateTime(2008, 1, 1, 20, 10, 31, 0, DateTimeKind.Utc); OSD llsdDate = OSD.FromDate(dt); byte[] binaryDateSerialized = OSDParser.SerializeLLSDBinary(llsdDate); - Assert.AreEqual(binaryDateTime, binaryDateSerialized); + ClassicAssert.AreEqual(binaryDateTime, binaryDateSerialized); // check if a *local* time can be serialized and deserialized DateTime dtOne = new DateTime(2009, 12, 30, 8, 25, 10, DateTimeKind.Local); OSD llsdDateOne = OSD.FromDate(dtOne); byte[] binaryDateOneSerialized = OSDParser.SerializeLLSDBinary(llsdDateOne); OSD llsdDateOneDS = OSDParser.DeserializeLLSDBinary(binaryDateOneSerialized); - Assert.AreEqual(OSDType.Date, llsdDateOneDS.Type); - Assert.AreEqual(dtOne, llsdDateOneDS.AsDate()); + ClassicAssert.AreEqual(OSDType.Date, llsdDateOneDS.Type); + ClassicAssert.AreEqual(dtOne, llsdDateOneDS.AsDate()); DateTime dtTwo = new DateTime(2010, 11, 11, 10, 8, 20, DateTimeKind.Utc); OSD llsdDateTwo = OSD.FromDate(dtTwo); byte[] binaryDateTwoSerialized = OSDParser.SerializeLLSDBinary(llsdDateTwo); OSD llsdDateTwoDS = OSDParser.DeserializeLLSDBinary(binaryDateTwoSerialized); - Assert.AreEqual(OSDType.Date, llsdDateOneDS.Type); - Assert.AreEqual(dtTwo.ToLocalTime(), llsdDateTwoDS.AsDate()); + ClassicAssert.AreEqual(OSDType.Date, llsdDateOneDS.Type); + ClassicAssert.AreEqual(dtTwo.ToLocalTime(), llsdDateTwoDS.AsDate()); } // Data for empty array { } @@ -426,27 +427,27 @@ namespace LibreMetaverse.Tests public void DeserializeArray() { OSD llsdEmptyArray = OSDParser.DeserializeLLSDBinary(binaryEmptyArray); - Assert.AreEqual(OSDType.Array, llsdEmptyArray.Type); + ClassicAssert.AreEqual(OSDType.Array, llsdEmptyArray.Type); OSDArray llsdEmptyArrayArray = (OSDArray)llsdEmptyArray; - Assert.AreEqual(0, llsdEmptyArrayArray.Count); + ClassicAssert.AreEqual(0, llsdEmptyArrayArray.Count); OSD llsdSimpleArray = OSDParser.DeserializeLLSDBinary(binarySimpleArray); - Assert.AreEqual(OSDType.Array, llsdSimpleArray.Type); + ClassicAssert.AreEqual(OSDType.Array, llsdSimpleArray.Type); OSDArray llsdArray = (OSDArray)llsdSimpleArray; - Assert.AreEqual(OSDType.Integer, llsdArray[0].Type); - Assert.AreEqual(0, llsdArray[0].AsInteger()); + ClassicAssert.AreEqual(OSDType.Integer, llsdArray[0].Type); + ClassicAssert.AreEqual(0, llsdArray[0].AsInteger()); OSD llsdSimpleArrayTwo = OSDParser.DeserializeLLSDBinary(binarySimpleArrayTwo); - Assert.AreEqual(OSDType.Array, llsdSimpleArrayTwo.Type); + ClassicAssert.AreEqual(OSDType.Array, llsdSimpleArrayTwo.Type); OSDArray llsdArrayTwo = (OSDArray)llsdSimpleArrayTwo; - Assert.AreEqual(2, llsdArrayTwo.Count); + ClassicAssert.AreEqual(2, llsdArrayTwo.Count); - Assert.AreEqual(OSDType.Integer, llsdArrayTwo[0].Type); - Assert.AreEqual(0, llsdArrayTwo[0].AsInteger()); - Assert.AreEqual(OSDType.Integer, llsdArrayTwo[1].Type); - Assert.AreEqual(0, llsdArrayTwo[1].AsInteger()); + ClassicAssert.AreEqual(OSDType.Integer, llsdArrayTwo[0].Type); + ClassicAssert.AreEqual(0, llsdArrayTwo[0].AsInteger()); + ClassicAssert.AreEqual(OSDType.Integer, llsdArrayTwo[1].Type); + ClassicAssert.AreEqual(0, llsdArrayTwo[1].AsInteger()); } [Test()] @@ -454,27 +455,27 @@ namespace LibreMetaverse.Tests { OSDArray llsdEmptyArray = new OSDArray(); byte[] binaryEmptyArraySerialized = OSDParser.SerializeLLSDBinary(llsdEmptyArray); - Assert.AreEqual(binaryEmptyArray, binaryEmptyArraySerialized); + ClassicAssert.AreEqual(binaryEmptyArray, binaryEmptyArraySerialized); binaryEmptyArraySerialized = OSDParser.SerializeLLSDBinary(llsdEmptyArray, false); - Assert.AreEqual(binaryEmptyArrayValue, binaryEmptyArraySerialized); + ClassicAssert.AreEqual(binaryEmptyArrayValue, binaryEmptyArraySerialized); OSDArray llsdSimpleArray = new OSDArray(); llsdSimpleArray.Add(OSD.FromInteger(0)); byte[] binarySimpleArraySerialized = OSDParser.SerializeLLSDBinary(llsdSimpleArray); - Assert.AreEqual(binarySimpleArray, binarySimpleArraySerialized); + ClassicAssert.AreEqual(binarySimpleArray, binarySimpleArraySerialized); binarySimpleArraySerialized = OSDParser.SerializeLLSDBinary(llsdSimpleArray, false); - Assert.AreEqual(binarySimpleArrayValue, binarySimpleArraySerialized); + ClassicAssert.AreEqual(binarySimpleArrayValue, binarySimpleArraySerialized); OSDArray llsdSimpleArrayTwo = new OSDArray(); llsdSimpleArrayTwo.Add(OSD.FromInteger(0)); llsdSimpleArrayTwo.Add(OSD.FromInteger(0)); byte[] binarySimpleArrayTwoSerialized = OSDParser.SerializeLLSDBinary(llsdSimpleArrayTwo); - Assert.AreEqual(binarySimpleArrayTwo, binarySimpleArrayTwoSerialized); + ClassicAssert.AreEqual(binarySimpleArrayTwo, binarySimpleArrayTwoSerialized); binarySimpleArrayTwoSerialized = OSDParser.SerializeLLSDBinary(llsdSimpleArrayTwo, false); - Assert.AreEqual(binarySimpleArrayTwoValue, binarySimpleArrayTwoSerialized); + ClassicAssert.AreEqual(binarySimpleArrayTwoValue, binarySimpleArrayTwoSerialized); } // Data for empty dictionary { } @@ -508,23 +509,23 @@ namespace LibreMetaverse.Tests public void DeserializeDictionary() { OSDMap llsdEmptyMap = (OSDMap)OSDParser.DeserializeLLSDBinary(binaryEmptyMap); - Assert.AreEqual(OSDType.Map, llsdEmptyMap.Type); - Assert.AreEqual(0, llsdEmptyMap.Count); + ClassicAssert.AreEqual(OSDType.Map, llsdEmptyMap.Type); + ClassicAssert.AreEqual(0, llsdEmptyMap.Count); OSDMap llsdSimpleMap = (OSDMap)OSDParser.DeserializeLLSDBinary(binarySimpleMap); - Assert.AreEqual(OSDType.Map, llsdSimpleMap.Type); - Assert.AreEqual(1, llsdSimpleMap.Count); - Assert.AreEqual(OSDType.Integer, llsdSimpleMap["test"].Type); - Assert.AreEqual(0, llsdSimpleMap["test"].AsInteger()); + ClassicAssert.AreEqual(OSDType.Map, llsdSimpleMap.Type); + ClassicAssert.AreEqual(1, llsdSimpleMap.Count); + ClassicAssert.AreEqual(OSDType.Integer, llsdSimpleMap["test"].Type); + ClassicAssert.AreEqual(0, llsdSimpleMap["test"].AsInteger()); OSDMap llsdSimpleMapTwo = (OSDMap)OSDParser.DeserializeLLSDBinary(binarySimpleMapTwo); - Assert.AreEqual(OSDType.Map, llsdSimpleMapTwo.Type); - Assert.AreEqual(3, llsdSimpleMapTwo.Count); - Assert.AreEqual(OSDType.Unknown, llsdSimpleMapTwo["test"].Type); - Assert.AreEqual(OSDType.String, llsdSimpleMapTwo["tes1"].Type); - Assert.AreEqual("aha", llsdSimpleMapTwo["tes1"].AsString()); - Assert.AreEqual(OSDType.Integer, llsdSimpleMapTwo["t0st"].Type); - Assert.AreEqual(241, llsdSimpleMapTwo["t0st"].AsInteger()); + ClassicAssert.AreEqual(OSDType.Map, llsdSimpleMapTwo.Type); + ClassicAssert.AreEqual(3, llsdSimpleMapTwo.Count); + ClassicAssert.AreEqual(OSDType.Unknown, llsdSimpleMapTwo["test"].Type); + ClassicAssert.AreEqual(OSDType.String, llsdSimpleMapTwo["tes1"].Type); + ClassicAssert.AreEqual("aha", llsdSimpleMapTwo["tes1"].AsString()); + ClassicAssert.AreEqual(OSDType.Integer, llsdSimpleMapTwo["t0st"].Type); + ClassicAssert.AreEqual(241, llsdSimpleMapTwo["t0st"].AsInteger()); } @@ -534,12 +535,12 @@ namespace LibreMetaverse.Tests { OSDMap llsdEmptyMap = new OSDMap(); byte[] binaryEmptyMapSerialized = OSDParser.SerializeLLSDBinary(llsdEmptyMap); - Assert.AreEqual(binaryEmptyMap, binaryEmptyMapSerialized); + ClassicAssert.AreEqual(binaryEmptyMap, binaryEmptyMapSerialized); OSDMap llsdSimpleMap = new OSDMap(); llsdSimpleMap["test"] = OSD.FromInteger(0); byte[] binarySimpleMapSerialized = OSDParser.SerializeLLSDBinary(llsdSimpleMap); - Assert.AreEqual(binarySimpleMap, binarySimpleMapSerialized); + ClassicAssert.AreEqual(binarySimpleMap, binarySimpleMapSerialized); OSDMap llsdSimpleMapTwo = new OSDMap(); llsdSimpleMapTwo["t0st"] = OSD.FromInteger(241); @@ -551,13 +552,13 @@ namespace LibreMetaverse.Tests // the original serialized value is not *exactly* the same. Instead we compare to a deserialized // version created by this deserializer. OSDMap llsdSimpleMapDeserialized = (OSDMap)OSDParser.DeserializeLLSDBinary(binarySimpleMapTwoSerialized); - Assert.AreEqual(OSDType.Map, llsdSimpleMapDeserialized.Type); - Assert.AreEqual(3, llsdSimpleMapDeserialized.Count); - Assert.AreEqual(OSDType.Integer, llsdSimpleMapDeserialized["t0st"].Type); - Assert.AreEqual(241, llsdSimpleMapDeserialized["t0st"].AsInteger()); - Assert.AreEqual(OSDType.String, llsdSimpleMapDeserialized["tes1"].Type); - Assert.AreEqual("aha", llsdSimpleMapDeserialized["tes1"].AsString()); - Assert.AreEqual(OSDType.Unknown, llsdSimpleMapDeserialized["test"].Type); + ClassicAssert.AreEqual(OSDType.Map, llsdSimpleMapDeserialized.Type); + ClassicAssert.AreEqual(3, llsdSimpleMapDeserialized.Count); + ClassicAssert.AreEqual(OSDType.Integer, llsdSimpleMapDeserialized["t0st"].Type); + ClassicAssert.AreEqual(241, llsdSimpleMapDeserialized["t0st"].AsInteger()); + ClassicAssert.AreEqual(OSDType.String, llsdSimpleMapDeserialized["tes1"].Type); + ClassicAssert.AreEqual("aha", llsdSimpleMapDeserialized["tes1"].AsString()); + ClassicAssert.AreEqual(OSDType.Unknown, llsdSimpleMapDeserialized["test"].Type); // we also test for a 4byte key character. string xml = "𐄷"; @@ -570,13 +571,13 @@ namespace LibreMetaverse.Tests OSDMap llsdSimpleMapThree = new OSDMap(); OSD llsdSimpleValue = OSD.FromString(content); llsdSimpleMapThree[content] = llsdSimpleValue; - Assert.AreEqual(content, llsdSimpleMapThree[content].AsString()); + ClassicAssert.AreEqual(content, llsdSimpleMapThree[content].AsString()); byte[] binarySimpleMapThree = OSDParser.SerializeLLSDBinary(llsdSimpleMapThree); OSDMap llsdSimpleMapThreeDS = (OSDMap)OSDParser.DeserializeLLSDBinary(binarySimpleMapThree); - Assert.AreEqual(OSDType.Map, llsdSimpleMapThreeDS.Type); - Assert.AreEqual(1, llsdSimpleMapThreeDS.Count); - Assert.AreEqual(content, llsdSimpleMapThreeDS[content].AsString()); + ClassicAssert.AreEqual(OSDType.Map, llsdSimpleMapThreeDS.Type); + ClassicAssert.AreEqual(1, llsdSimpleMapThreeDS.Count); + ClassicAssert.AreEqual(content, llsdSimpleMapThreeDS[content].AsString()); } @@ -600,33 +601,33 @@ namespace LibreMetaverse.Tests public void DeserializeNestedComposite() { OSD llsdNested = OSDParser.DeserializeLLSDBinary(binaryNested); - Assert.AreEqual(OSDType.Array, llsdNested.Type); + ClassicAssert.AreEqual(OSDType.Array, llsdNested.Type); OSDArray llsdArray = (OSDArray)llsdNested; - Assert.AreEqual(3, llsdArray.Count); + ClassicAssert.AreEqual(3, llsdArray.Count); OSDMap llsdMap = (OSDMap)llsdArray[0]; - Assert.AreEqual(OSDType.Map, llsdMap.Type); - Assert.AreEqual(2, llsdMap.Count); + ClassicAssert.AreEqual(OSDType.Map, llsdMap.Type); + ClassicAssert.AreEqual(2, llsdMap.Count); OSDArray llsdNestedArray = (OSDArray)llsdMap["t0st"]; - Assert.AreEqual(OSDType.Array, llsdNestedArray.Type); + ClassicAssert.AreEqual(OSDType.Array, llsdNestedArray.Type); OSDInteger llsdNestedIntOne = (OSDInteger)llsdNestedArray[0]; - Assert.AreEqual(OSDType.Integer, llsdNestedIntOne.Type); - Assert.AreEqual(1, llsdNestedIntOne.AsInteger()); + ClassicAssert.AreEqual(OSDType.Integer, llsdNestedIntOne.Type); + ClassicAssert.AreEqual(1, llsdNestedIntOne.AsInteger()); OSDInteger llsdNestedIntTwo = (OSDInteger)llsdNestedArray[1]; - Assert.AreEqual(OSDType.Integer, llsdNestedIntTwo.Type); - Assert.AreEqual(2, llsdNestedIntTwo.AsInteger()); + ClassicAssert.AreEqual(OSDType.Integer, llsdNestedIntTwo.Type); + ClassicAssert.AreEqual(2, llsdNestedIntTwo.AsInteger()); OSDString llsdString = (OSDString)llsdMap["test"]; - Assert.AreEqual(OSDType.String, llsdString.Type); - Assert.AreEqual("what", llsdString.AsString()); + ClassicAssert.AreEqual(OSDType.String, llsdString.Type); + ClassicAssert.AreEqual("what", llsdString.AsString()); OSDInteger llsdIntOne = (OSDInteger)llsdArray[1]; - Assert.AreEqual(OSDType.Integer, llsdIntOne.Type); - Assert.AreEqual(124, llsdIntOne.AsInteger()); + ClassicAssert.AreEqual(OSDType.Integer, llsdIntOne.Type); + ClassicAssert.AreEqual(124, llsdIntOne.AsInteger()); OSDInteger llsdIntTwo = (OSDInteger)llsdArray[2]; - Assert.AreEqual(OSDType.Integer, llsdIntTwo.Type); - Assert.AreEqual(987, llsdIntTwo.AsInteger()); + ClassicAssert.AreEqual(OSDType.Integer, llsdIntTwo.Type); + ClassicAssert.AreEqual(987, llsdIntTwo.AsInteger()); } @@ -647,30 +648,30 @@ namespace LibreMetaverse.Tests byte[] binaryNestedSerialized = OSDParser.SerializeLLSDBinary(llsdNested); // Because maps don't preserve order, we compare here to a deserialized value. OSDArray llsdNestedDeserialized = (OSDArray)OSDParser.DeserializeLLSDBinary(binaryNestedSerialized); - Assert.AreEqual(OSDType.Array, llsdNestedDeserialized.Type); - Assert.AreEqual(3, llsdNestedDeserialized.Count); + ClassicAssert.AreEqual(OSDType.Array, llsdNestedDeserialized.Type); + ClassicAssert.AreEqual(3, llsdNestedDeserialized.Count); OSDMap llsdMapDeserialized = (OSDMap)llsdNestedDeserialized[0]; - Assert.AreEqual(OSDType.Map, llsdMapDeserialized.Type); - Assert.AreEqual(2, llsdMapDeserialized.Count); - Assert.AreEqual(OSDType.Array, llsdMapDeserialized["t0st"].Type); + ClassicAssert.AreEqual(OSDType.Map, llsdMapDeserialized.Type); + ClassicAssert.AreEqual(2, llsdMapDeserialized.Count); + ClassicAssert.AreEqual(OSDType.Array, llsdMapDeserialized["t0st"].Type); OSDArray llsdNestedArray = (OSDArray)llsdMapDeserialized["t0st"]; - Assert.AreEqual(OSDType.Array, llsdNestedArray.Type); - Assert.AreEqual(2, llsdNestedArray.Count); - Assert.AreEqual(OSDType.Integer, llsdNestedArray[0].Type); - Assert.AreEqual(1, llsdNestedArray[0].AsInteger()); - Assert.AreEqual(OSDType.Integer, llsdNestedArray[1].Type); - Assert.AreEqual(2, llsdNestedArray[1].AsInteger()); + ClassicAssert.AreEqual(OSDType.Array, llsdNestedArray.Type); + ClassicAssert.AreEqual(2, llsdNestedArray.Count); + ClassicAssert.AreEqual(OSDType.Integer, llsdNestedArray[0].Type); + ClassicAssert.AreEqual(1, llsdNestedArray[0].AsInteger()); + ClassicAssert.AreEqual(OSDType.Integer, llsdNestedArray[1].Type); + ClassicAssert.AreEqual(2, llsdNestedArray[1].AsInteger()); - Assert.AreEqual(OSDType.String, llsdMapDeserialized["test"].Type); - Assert.AreEqual("what", llsdMapDeserialized["test"].AsString()); + ClassicAssert.AreEqual(OSDType.String, llsdMapDeserialized["test"].Type); + ClassicAssert.AreEqual("what", llsdMapDeserialized["test"].AsString()); - Assert.AreEqual(OSDType.Integer, llsdNestedDeserialized[1].Type); - Assert.AreEqual(124, llsdNestedDeserialized[1].AsInteger()); + ClassicAssert.AreEqual(OSDType.Integer, llsdNestedDeserialized[1].Type); + ClassicAssert.AreEqual(124, llsdNestedDeserialized[1].AsInteger()); - Assert.AreEqual(OSDType.Integer, llsdNestedDeserialized[2].Type); - Assert.AreEqual(987, llsdNestedDeserialized[2].AsInteger()); + ClassicAssert.AreEqual(OSDType.Integer, llsdNestedDeserialized[2].Type); + ClassicAssert.AreEqual(987, llsdNestedDeserialized[2].AsInteger()); } @@ -700,18 +701,18 @@ namespace LibreMetaverse.Tests byte[] binaryData = OSDParser.SerializeLLSDBinary( llsdMap ); OSDMap llsdMapDS = (OSDMap)OSDParser.DeserializeLLSDBinary( binaryData ); - Assert.AreEqual( OSDType.Map, llsdMapDS.Type ); - Assert.AreEqual( 10, llsdMapDS.Count ); - Assert.AreEqual( sOne, llsdMapDS["testOne"].AsString()); - Assert.AreEqual( sTwo, llsdMapDS["testTwo"].AsString()); - Assert.AreEqual( sOne, llsdMapDS["testThree"].AsString()); - Assert.AreEqual( sTwo, llsdMapDS["testFour"].AsString()); - Assert.AreEqual( sOne, llsdMapDS["testFive"].AsString()); - Assert.AreEqual( sTwo, llsdMapDS["testSix"].AsString()); - Assert.AreEqual( sOne, llsdMapDS["testSeven"].AsString()); - Assert.AreEqual( sTwo, llsdMapDS["testEight"].AsString()); - Assert.AreEqual( sOne, llsdMapDS["testNine"].AsString()); - Assert.AreEqual( sTwo, llsdMapDS["testTen"].AsString()); + ClassicAssert.AreEqual( OSDType.Map, llsdMapDS.Type ); + ClassicAssert.AreEqual( 10, llsdMapDS.Count ); + ClassicAssert.AreEqual( sOne, llsdMapDS["testOne"].AsString()); + ClassicAssert.AreEqual( sTwo, llsdMapDS["testTwo"].AsString()); + ClassicAssert.AreEqual( sOne, llsdMapDS["testThree"].AsString()); + ClassicAssert.AreEqual( sTwo, llsdMapDS["testFour"].AsString()); + ClassicAssert.AreEqual( sOne, llsdMapDS["testFive"].AsString()); + ClassicAssert.AreEqual( sTwo, llsdMapDS["testSix"].AsString()); + ClassicAssert.AreEqual( sOne, llsdMapDS["testSeven"].AsString()); + ClassicAssert.AreEqual( sTwo, llsdMapDS["testEight"].AsString()); + ClassicAssert.AreEqual( sOne, llsdMapDS["testNine"].AsString()); + ClassicAssert.AreEqual( sTwo, llsdMapDS["testTen"].AsString()); } diff --git a/LibreMetaverse.Tests/GridClientTests.cs b/LibreMetaverse.Tests/GridClientTests.cs index 8e30bf9f..aa9d7ec2 100644 --- a/LibreMetaverse.Tests/GridClientTests.cs +++ b/LibreMetaverse.Tests/GridClientTests.cs @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021-2022, Sjofn LLC + * Copyright (c) 2021-2024, Sjofn LLC * All rights reserved. * * - Redistribution and use in source and binary forms, with or without @@ -57,15 +57,15 @@ namespace LibreMetaverse.Tests Console.Write($"Logging in {fullusername}..."); // Connect to the grid string startLoc = NetworkManager.StartLocation("Hooper", 179, 18, 32); - Assert.IsTrue(Client.Network.Login(username[0], username[1], password, "Unit Test Framework", startLoc, - "contact@radegast.life"), "Client failed to login, reason: " + Client.Network.LoginMessage); + Assert.That(Client.Network.Login(username[0], username[1], password, "Unit Test Framework", startLoc, + "contact@radegast.life"), Is.True, "Client failed to login, reason: " + Client.Network.LoginMessage); Console.WriteLine("Done"); - Assert.IsTrue(Client.Network.Connected, "Client is not connected to the grid"); + Assert.That(Client.Network.Connected, Is.True, "Client is not connected to the grid"); //int start = Environment.TickCount; - Assert.AreEqual("hooper", Client.Network.CurrentSim.Name.ToLower(), + Assert.That(Client.Network.CurrentSim.Name, Is.EqualTo("hooper").IgnoreCase, $"Logged in to region {Client.Network.CurrentSim.Name} instead of Hooper"); } @@ -81,8 +81,8 @@ namespace LibreMetaverse.Tests public void GetGridRegion() { GridRegion region; - Assert.IsTrue(Client.Grid.GetGridRegion("Hippo Hollow", GridLayerType.Terrain, out region)); - Assert.AreEqual("hippo hollow", region.Name.ToLower()); + Assert.That(Client.Grid.GetGridRegion("Hippo Hollow", GridLayerType.Terrain, out region), Is.True); + Assert.That(region.Name, Is.EqualTo("hippo hollow").IgnoreCase); } } } diff --git a/LibreMetaverse.Tests/LibreMetaverse.Tests.csproj b/LibreMetaverse.Tests/LibreMetaverse.Tests.csproj index b9849bcd..68444c2b 100644 --- a/LibreMetaverse.Tests/LibreMetaverse.Tests.csproj +++ b/LibreMetaverse.Tests/LibreMetaverse.Tests.csproj @@ -37,9 +37,9 @@ - - - + + + all runtime; build; native; contentfiles; analyzers; buildtransitive diff --git a/LibreMetaverse.Tests/MessageTests.cs b/LibreMetaverse.Tests/MessageTests.cs index a2783b27..683f3a9e 100644 --- a/LibreMetaverse.Tests/MessageTests.cs +++ b/LibreMetaverse.Tests/MessageTests.cs @@ -1,6 +1,6 @@ /* * Copyright (c) 2006-2016, openmetaverse.co - * Copyright (c) 2021-2022, Sjofn LLC + * Copyright (c) 2021-2024, Sjofn LLC * All rights reserved. * * - Redistribution and use in source and binary forms, with or without @@ -35,6 +35,7 @@ using OpenMetaverse; using OpenMetaverse.StructuredData; using OpenMetaverse.Messages.Linden; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace LibreMetaverse.Tests { @@ -97,21 +98,21 @@ namespace LibreMetaverse.Tests AgentGroupDataUpdateMessage t = new AgentGroupDataUpdateMessage(); t.Deserialize(map); - Assert.AreEqual(s.AgentID, t.AgentID); + ClassicAssert.AreEqual(s.AgentID, t.AgentID); for (int i = 0; i < t.GroupDataBlock.Length; i++) { - Assert.AreEqual(s.GroupDataBlock[i].AcceptNotices, t.GroupDataBlock[i].AcceptNotices); - Assert.AreEqual(s.GroupDataBlock[i].Contribution, t.GroupDataBlock[i].Contribution); - Assert.AreEqual(s.GroupDataBlock[i].GroupID, t.GroupDataBlock[i].GroupID); - Assert.AreEqual(s.GroupDataBlock[i].GroupInsigniaID, t.GroupDataBlock[i].GroupInsigniaID); - Assert.AreEqual(s.GroupDataBlock[i].GroupName, t.GroupDataBlock[i].GroupName); - Assert.AreEqual(s.GroupDataBlock[i].GroupPowers, t.GroupDataBlock[i].GroupPowers); + ClassicAssert.AreEqual(s.GroupDataBlock[i].AcceptNotices, t.GroupDataBlock[i].AcceptNotices); + ClassicAssert.AreEqual(s.GroupDataBlock[i].Contribution, t.GroupDataBlock[i].Contribution); + ClassicAssert.AreEqual(s.GroupDataBlock[i].GroupID, t.GroupDataBlock[i].GroupID); + ClassicAssert.AreEqual(s.GroupDataBlock[i].GroupInsigniaID, t.GroupDataBlock[i].GroupInsigniaID); + ClassicAssert.AreEqual(s.GroupDataBlock[i].GroupName, t.GroupDataBlock[i].GroupName); + ClassicAssert.AreEqual(s.GroupDataBlock[i].GroupPowers, t.GroupDataBlock[i].GroupPowers); } for (int i = 0; i < t.NewGroupDataBlock.Length; i++) { - Assert.AreEqual(s.NewGroupDataBlock[i].ListInProfile, t.NewGroupDataBlock[i].ListInProfile); + ClassicAssert.AreEqual(s.NewGroupDataBlock[i].ListInProfile, t.NewGroupDataBlock[i].ListInProfile); } } @@ -133,14 +134,14 @@ namespace LibreMetaverse.Tests TeleportFinishMessage t = new TeleportFinishMessage(); t.Deserialize(map); - Assert.AreEqual(s.AgentID, t.AgentID); - Assert.AreEqual(s.Flags, t.Flags); - Assert.AreEqual(s.IP, t.IP); - Assert.AreEqual(s.LocationID, t.LocationID); - Assert.AreEqual(s.Port, t.Port); - Assert.AreEqual(s.RegionHandle, t.RegionHandle); - Assert.AreEqual(s.SeedCapability, t.SeedCapability); - Assert.AreEqual(s.SimAccess, t.SimAccess); + ClassicAssert.AreEqual(s.AgentID, t.AgentID); + ClassicAssert.AreEqual(s.Flags, t.Flags); + ClassicAssert.AreEqual(s.IP, t.IP); + ClassicAssert.AreEqual(s.LocationID, t.LocationID); + ClassicAssert.AreEqual(s.Port, t.Port); + ClassicAssert.AreEqual(s.RegionHandle, t.RegionHandle); + ClassicAssert.AreEqual(s.SeedCapability, t.SeedCapability); + ClassicAssert.AreEqual(s.SimAccess, t.SimAccess); } [Test] @@ -157,10 +158,10 @@ namespace LibreMetaverse.Tests EstablishAgentCommunicationMessage t = new EstablishAgentCommunicationMessage(); t.Deserialize(map); - Assert.AreEqual(s.Address, t.Address); - Assert.AreEqual(s.AgentID, t.AgentID); - Assert.AreEqual(s.Port, t.Port); - Assert.AreEqual(s.SeedCapability, t.SeedCapability); + ClassicAssert.AreEqual(s.Address, t.Address); + ClassicAssert.AreEqual(s.AgentID, t.AgentID); + ClassicAssert.AreEqual(s.Port, t.Port); + ClassicAssert.AreEqual(s.SeedCapability, t.SeedCapability); } [Test] @@ -192,11 +193,11 @@ namespace LibreMetaverse.Tests for (int i = 0; i < t.PrimOwnersBlock.Length; i++) { - Assert.AreEqual(s.PrimOwnersBlock[i].Count, t.PrimOwnersBlock[i].Count); - Assert.AreEqual(s.PrimOwnersBlock[i].IsGroupOwned, t.PrimOwnersBlock[i].IsGroupOwned); - Assert.AreEqual(s.PrimOwnersBlock[i].OnlineStatus, t.PrimOwnersBlock[i].OnlineStatus); - Assert.AreEqual(s.PrimOwnersBlock[i].OwnerID, t.PrimOwnersBlock[i].OwnerID); - Assert.AreEqual(s.PrimOwnersBlock[i].TimeStamp, t.PrimOwnersBlock[i].TimeStamp); + ClassicAssert.AreEqual(s.PrimOwnersBlock[i].Count, t.PrimOwnersBlock[i].Count); + ClassicAssert.AreEqual(s.PrimOwnersBlock[i].IsGroupOwned, t.PrimOwnersBlock[i].IsGroupOwned); + ClassicAssert.AreEqual(s.PrimOwnersBlock[i].OnlineStatus, t.PrimOwnersBlock[i].OnlineStatus); + ClassicAssert.AreEqual(s.PrimOwnersBlock[i].OwnerID, t.PrimOwnersBlock[i].OwnerID); + ClassicAssert.AreEqual(s.PrimOwnersBlock[i].TimeStamp, t.PrimOwnersBlock[i].TimeStamp); } } @@ -223,19 +224,19 @@ namespace LibreMetaverse.Tests ChatterBoxInvitationMessage t = new ChatterBoxInvitationMessage(); t.Deserialize(map); - Assert.AreEqual(s.BinaryBucket, t.BinaryBucket); - Assert.AreEqual(s.Dialog, t.Dialog); - Assert.AreEqual(s.FromAgentID, t.FromAgentID); - Assert.AreEqual(s.FromAgentName, t.FromAgentName); - Assert.AreEqual(s.GroupIM, t.GroupIM); - Assert.AreEqual(s.IMSessionID, t.IMSessionID); - Assert.AreEqual(s.Message, t.Message); - Assert.AreEqual(s.Offline, t.Offline); - Assert.AreEqual(s.ParentEstateID, t.ParentEstateID); - Assert.AreEqual(s.Position, t.Position); - Assert.AreEqual(s.RegionID, t.RegionID); - Assert.AreEqual(s.Timestamp, t.Timestamp); - Assert.AreEqual(s.ToAgentID, t.ToAgentID); + ClassicAssert.AreEqual(s.BinaryBucket, t.BinaryBucket); + ClassicAssert.AreEqual(s.Dialog, t.Dialog); + ClassicAssert.AreEqual(s.FromAgentID, t.FromAgentID); + ClassicAssert.AreEqual(s.FromAgentName, t.FromAgentName); + ClassicAssert.AreEqual(s.GroupIM, t.GroupIM); + ClassicAssert.AreEqual(s.IMSessionID, t.IMSessionID); + ClassicAssert.AreEqual(s.Message, t.Message); + ClassicAssert.AreEqual(s.Offline, t.Offline); + ClassicAssert.AreEqual(s.ParentEstateID, t.ParentEstateID); + ClassicAssert.AreEqual(s.Position, t.Position); + ClassicAssert.AreEqual(s.RegionID, t.RegionID); + ClassicAssert.AreEqual(s.Timestamp, t.Timestamp); + ClassicAssert.AreEqual(s.ToAgentID, t.ToAgentID); } [Test] @@ -250,8 +251,8 @@ namespace LibreMetaverse.Tests ChatterboxSessionEventReplyMessage t = new ChatterboxSessionEventReplyMessage(); t.Deserialize(map); - Assert.AreEqual(s.SessionID, t.SessionID); - Assert.AreEqual(s.Success, t.Success); + ClassicAssert.AreEqual(s.SessionID, t.SessionID); + ClassicAssert.AreEqual(s.Success, t.Success); } [Test] @@ -271,13 +272,13 @@ namespace LibreMetaverse.Tests ChatterBoxSessionStartReplyMessage t = new ChatterBoxSessionStartReplyMessage(); t.Deserialize(map); - Assert.AreEqual(s.ModeratedVoice, t.ModeratedVoice); - Assert.AreEqual(s.SessionID, t.SessionID); - Assert.AreEqual(s.SessionName, t.SessionName); - Assert.AreEqual(s.Success, t.Success); - Assert.AreEqual(s.TempSessionID, t.TempSessionID); - Assert.AreEqual(s.Type, t.Type); - Assert.AreEqual(s.VoiceEnabled, t.VoiceEnabled); + ClassicAssert.AreEqual(s.ModeratedVoice, t.ModeratedVoice); + ClassicAssert.AreEqual(s.SessionID, t.SessionID); + ClassicAssert.AreEqual(s.SessionName, t.SessionName); + ClassicAssert.AreEqual(s.Success, t.Success); + ClassicAssert.AreEqual(s.TempSessionID, t.TempSessionID); + ClassicAssert.AreEqual(s.Type, t.Type); + ClassicAssert.AreEqual(s.VoiceEnabled, t.VoiceEnabled); } [Test] @@ -311,15 +312,15 @@ namespace LibreMetaverse.Tests ChatterBoxSessionAgentListUpdatesMessage t = new ChatterBoxSessionAgentListUpdatesMessage(); t.Deserialize(map); - Assert.AreEqual(s.SessionID, t.SessionID); + ClassicAssert.AreEqual(s.SessionID, t.SessionID); for (int i = 0; i < t.Updates.Length; i++) { - Assert.AreEqual(s.Updates[i].AgentID, t.Updates[i].AgentID); - Assert.AreEqual(s.Updates[i].CanVoiceChat, t.Updates[i].CanVoiceChat); - Assert.AreEqual(s.Updates[i].IsModerator, t.Updates[i].IsModerator); - Assert.AreEqual(s.Updates[i].MuteText, t.Updates[i].MuteText); - Assert.AreEqual(s.Updates[i].MuteVoice, t.Updates[i].MuteVoice); - Assert.AreEqual(s.Updates[i].Transition, t.Updates[i].Transition); + ClassicAssert.AreEqual(s.Updates[i].AgentID, t.Updates[i].AgentID); + ClassicAssert.AreEqual(s.Updates[i].CanVoiceChat, t.Updates[i].CanVoiceChat); + ClassicAssert.AreEqual(s.Updates[i].IsModerator, t.Updates[i].IsModerator); + ClassicAssert.AreEqual(s.Updates[i].MuteText, t.Updates[i].MuteText); + ClassicAssert.AreEqual(s.Updates[i].MuteVoice, t.Updates[i].MuteVoice); + ClassicAssert.AreEqual(s.Updates[i].Transition, t.Updates[i].Transition); } } @@ -374,47 +375,47 @@ namespace LibreMetaverse.Tests ViewerStatsMessage t = new ViewerStatsMessage(); t.Deserialize(map); - Assert.AreEqual(s.AgentFPS, t.AgentFPS); - Assert.AreEqual(s.AgentsInView, t.AgentsInView); - Assert.AreEqual(s.SystemCPU, t.SystemCPU); - Assert.AreEqual(s.StatsDropped, t.StatsDropped); - Assert.AreEqual(s.StatsFailedResends, t.StatsFailedResends); - Assert.AreEqual(s.SystemGPU, t.SystemGPU); - Assert.AreEqual(s.SystemGPUClass, t.SystemGPUClass); - Assert.AreEqual(s.SystemGPUVendor, t.SystemGPUVendor); - Assert.AreEqual(s.SystemGPUVersion, t.SystemGPUVersion); - Assert.AreEqual(s.InCompressedPackets, t.InCompressedPackets); - Assert.AreEqual(s.InKbytes, t.InKbytes); - Assert.AreEqual(s.InPackets, t.InPackets); - Assert.AreEqual(s.InSavings, t.InSavings); - Assert.AreEqual(s.MiscInt1, t.MiscInt1); - Assert.AreEqual(s.MiscInt2, t.MiscInt2); - Assert.AreEqual(s.FailuresInvalid, t.FailuresInvalid); - Assert.AreEqual(s.AgentLanguage, t.AgentLanguage); - Assert.AreEqual(s.AgentMemoryUsed, t.AgentMemoryUsed); - Assert.AreEqual(s.MetersTraveled, t.MetersTraveled); - Assert.AreEqual(s.object_kbytes, t.object_kbytes); - Assert.AreEqual(s.FailuresOffCircuit, t.FailuresOffCircuit); - Assert.AreEqual(s.SystemOS, t.SystemOS); - Assert.AreEqual(s.OutCompressedPackets, t.OutCompressedPackets); - Assert.AreEqual(s.OutKbytes, t.OutKbytes); - Assert.AreEqual(s.OutPackets, t.OutPackets); - Assert.AreEqual(s.OutSavings, t.OutSavings); - Assert.AreEqual(s.AgentPing, t.AgentPing); - Assert.AreEqual(s.SystemInstalledRam, t.SystemInstalledRam); - Assert.AreEqual(s.RegionsVisited, t.RegionsVisited); - Assert.AreEqual(s.FailuresResent, t.FailuresResent); - Assert.AreEqual(s.AgentRuntime, t.AgentRuntime); - Assert.AreEqual(s.FailuresSendPacket, t.FailuresSendPacket); - Assert.AreEqual(s.SessionID, t.SessionID); - Assert.AreEqual(s.SimulatorFPS, t.SimulatorFPS); - Assert.AreEqual(s.AgentStartTime, t.AgentStartTime); - Assert.AreEqual(s.MiscString1, t.MiscString1); - Assert.AreEqual(s.texture_kbytes, t.texture_kbytes); - Assert.AreEqual(s.AgentVersion, t.AgentVersion); - Assert.AreEqual(s.MiscVersion, t.MiscVersion); - Assert.AreEqual(s.VertexBuffersEnabled, t.VertexBuffersEnabled); - Assert.AreEqual(s.world_kbytes, t.world_kbytes); + ClassicAssert.AreEqual(s.AgentFPS, t.AgentFPS); + ClassicAssert.AreEqual(s.AgentsInView, t.AgentsInView); + ClassicAssert.AreEqual(s.SystemCPU, t.SystemCPU); + ClassicAssert.AreEqual(s.StatsDropped, t.StatsDropped); + ClassicAssert.AreEqual(s.StatsFailedResends, t.StatsFailedResends); + ClassicAssert.AreEqual(s.SystemGPU, t.SystemGPU); + ClassicAssert.AreEqual(s.SystemGPUClass, t.SystemGPUClass); + ClassicAssert.AreEqual(s.SystemGPUVendor, t.SystemGPUVendor); + ClassicAssert.AreEqual(s.SystemGPUVersion, t.SystemGPUVersion); + ClassicAssert.AreEqual(s.InCompressedPackets, t.InCompressedPackets); + ClassicAssert.AreEqual(s.InKbytes, t.InKbytes); + ClassicAssert.AreEqual(s.InPackets, t.InPackets); + ClassicAssert.AreEqual(s.InSavings, t.InSavings); + ClassicAssert.AreEqual(s.MiscInt1, t.MiscInt1); + ClassicAssert.AreEqual(s.MiscInt2, t.MiscInt2); + ClassicAssert.AreEqual(s.FailuresInvalid, t.FailuresInvalid); + ClassicAssert.AreEqual(s.AgentLanguage, t.AgentLanguage); + ClassicAssert.AreEqual(s.AgentMemoryUsed, t.AgentMemoryUsed); + ClassicAssert.AreEqual(s.MetersTraveled, t.MetersTraveled); + ClassicAssert.AreEqual(s.object_kbytes, t.object_kbytes); + ClassicAssert.AreEqual(s.FailuresOffCircuit, t.FailuresOffCircuit); + ClassicAssert.AreEqual(s.SystemOS, t.SystemOS); + ClassicAssert.AreEqual(s.OutCompressedPackets, t.OutCompressedPackets); + ClassicAssert.AreEqual(s.OutKbytes, t.OutKbytes); + ClassicAssert.AreEqual(s.OutPackets, t.OutPackets); + ClassicAssert.AreEqual(s.OutSavings, t.OutSavings); + ClassicAssert.AreEqual(s.AgentPing, t.AgentPing); + ClassicAssert.AreEqual(s.SystemInstalledRam, t.SystemInstalledRam); + ClassicAssert.AreEqual(s.RegionsVisited, t.RegionsVisited); + ClassicAssert.AreEqual(s.FailuresResent, t.FailuresResent); + ClassicAssert.AreEqual(s.AgentRuntime, t.AgentRuntime); + ClassicAssert.AreEqual(s.FailuresSendPacket, t.FailuresSendPacket); + ClassicAssert.AreEqual(s.SessionID, t.SessionID); + ClassicAssert.AreEqual(s.SimulatorFPS, t.SimulatorFPS); + ClassicAssert.AreEqual(s.AgentStartTime, t.AgentStartTime); + ClassicAssert.AreEqual(s.MiscString1, t.MiscString1); + ClassicAssert.AreEqual(s.texture_kbytes, t.texture_kbytes); + ClassicAssert.AreEqual(s.AgentVersion, t.AgentVersion); + ClassicAssert.AreEqual(s.MiscVersion, t.MiscVersion); + ClassicAssert.AreEqual(s.VertexBuffersEnabled, t.VertexBuffersEnabled); + ClassicAssert.AreEqual(s.world_kbytes, t.world_kbytes); } @@ -432,9 +433,9 @@ namespace LibreMetaverse.Tests ParcelVoiceInfoRequestMessage t = new ParcelVoiceInfoRequestMessage(); t.Deserialize(map); - Assert.AreEqual(s.SipChannelUri, t.SipChannelUri); - Assert.AreEqual(s.ParcelID, t.ParcelID); - Assert.AreEqual(s.RegionName, t.RegionName); + ClassicAssert.AreEqual(s.SipChannelUri, t.SipChannelUri); + ClassicAssert.AreEqual(s.ParcelID, t.ParcelID); + ClassicAssert.AreEqual(s.RegionName, t.RegionName); } [Test] @@ -451,10 +452,10 @@ namespace LibreMetaverse.Tests ScriptRunningReplyMessage t = new ScriptRunningReplyMessage(); t.Deserialize(map); - Assert.AreEqual(s.ItemID, t.ItemID); - Assert.AreEqual(s.Mono, t.Mono); - Assert.AreEqual(s.ObjectID, t.ObjectID); - Assert.AreEqual(s.Running, t.Running); + ClassicAssert.AreEqual(s.ItemID, t.ItemID); + ClassicAssert.AreEqual(s.Mono, t.Mono); + ClassicAssert.AreEqual(s.ObjectID, t.ObjectID); + ClassicAssert.AreEqual(s.Running, t.Running); } @@ -494,16 +495,16 @@ namespace LibreMetaverse.Tests t.Deserialize(map); - Assert.AreEqual(s.Flags, t.Flags); + ClassicAssert.AreEqual(s.Flags, t.Flags); for (int i = 0; i < s.LayerDataBlocks.Length; i++) { - Assert.AreEqual(s.LayerDataBlocks[i].ImageID, t.LayerDataBlocks[i].ImageID); - Assert.AreEqual(s.LayerDataBlocks[i].Top, t.LayerDataBlocks[i].Top); - Assert.AreEqual(s.LayerDataBlocks[i].Left, t.LayerDataBlocks[i].Left); - Assert.AreEqual(s.LayerDataBlocks[i].Right, t.LayerDataBlocks[i].Right); - Assert.AreEqual(s.LayerDataBlocks[i].Bottom, t.LayerDataBlocks[i].Bottom); + ClassicAssert.AreEqual(s.LayerDataBlocks[i].ImageID, t.LayerDataBlocks[i].ImageID); + ClassicAssert.AreEqual(s.LayerDataBlocks[i].Top, t.LayerDataBlocks[i].Top); + ClassicAssert.AreEqual(s.LayerDataBlocks[i].Left, t.LayerDataBlocks[i].Left); + ClassicAssert.AreEqual(s.LayerDataBlocks[i].Right, t.LayerDataBlocks[i].Right); + ClassicAssert.AreEqual(s.LayerDataBlocks[i].Bottom, t.LayerDataBlocks[i].Bottom); } } @@ -521,11 +522,11 @@ namespace LibreMetaverse.Tests ChatSessionRequestStartConference t = new ChatSessionRequestStartConference(); t.Deserialize(map); - Assert.AreEqual(s.SessionID, t.SessionID); - Assert.AreEqual(s.Method, t.Method); + ClassicAssert.AreEqual(s.SessionID, t.SessionID); + ClassicAssert.AreEqual(s.Method, t.Method); for (int i = 0; i < t.AgentsBlock.Length; i++) { - Assert.AreEqual(s.AgentsBlock[i], t.AgentsBlock[i]); + ClassicAssert.AreEqual(s.AgentsBlock[i], t.AgentsBlock[i]); } } @@ -543,11 +544,11 @@ namespace LibreMetaverse.Tests ChatSessionRequestMuteUpdate t = new ChatSessionRequestMuteUpdate(); t.Deserialize(map); - Assert.AreEqual(s.AgentID, t.AgentID); - Assert.AreEqual(s.Method, t.Method); - Assert.AreEqual(s.RequestKey, t.RequestKey); - Assert.AreEqual(s.RequestValue, t.RequestValue); - Assert.AreEqual(s.SessionID, t.SessionID); + ClassicAssert.AreEqual(s.AgentID, t.AgentID); + ClassicAssert.AreEqual(s.Method, t.Method); + ClassicAssert.AreEqual(s.RequestKey, t.RequestKey); + ClassicAssert.AreEqual(s.RequestValue, t.RequestValue); + ClassicAssert.AreEqual(s.SessionID, t.SessionID); } [Test] @@ -561,8 +562,8 @@ namespace LibreMetaverse.Tests ChatSessionAcceptInvitation t = new ChatSessionAcceptInvitation(); t.Deserialize(map); - Assert.AreEqual(s.Method, t.Method); - Assert.AreEqual(s.SessionID, t.SessionID); + ClassicAssert.AreEqual(s.Method, t.Method); + ClassicAssert.AreEqual(s.SessionID, t.SessionID); } [Test] @@ -578,9 +579,9 @@ namespace LibreMetaverse.Tests RequiredVoiceVersionMessage t = new RequiredVoiceVersionMessage(); t.Deserialize(map); - Assert.AreEqual(s.MajorVersion, t.MajorVersion); - Assert.AreEqual(s.MinorVersion, t.MinorVersion); - Assert.AreEqual(s.RegionName, t.RegionName); + ClassicAssert.AreEqual(s.MajorVersion, t.MajorVersion); + ClassicAssert.AreEqual(s.MinorVersion, t.MinorVersion); + ClassicAssert.AreEqual(s.RegionName, t.RegionName); } [Test] @@ -598,11 +599,11 @@ namespace LibreMetaverse.Tests CopyInventoryFromNotecardMessage t = new CopyInventoryFromNotecardMessage(); t.Deserialize(map); - Assert.AreEqual(s.CallbackID, t.CallbackID); - Assert.AreEqual(s.FolderID, t.FolderID); - Assert.AreEqual(s.ItemID, t.ItemID); - Assert.AreEqual(s.NotecardID, t.NotecardID); - Assert.AreEqual(s.ObjectID, t.ObjectID); + ClassicAssert.AreEqual(s.CallbackID, t.CallbackID); + ClassicAssert.AreEqual(s.FolderID, t.FolderID); + ClassicAssert.AreEqual(s.ItemID, t.ItemID); + ClassicAssert.AreEqual(s.NotecardID, t.NotecardID); + ClassicAssert.AreEqual(s.ObjectID, t.ObjectID); } [Test] @@ -617,8 +618,8 @@ namespace LibreMetaverse.Tests ProvisionVoiceAccountRequestMessage t = new ProvisionVoiceAccountRequestMessage(); t.Deserialize(map); - Assert.AreEqual(s.Password, t.Password); - Assert.AreEqual(s.Username, t.Username); + ClassicAssert.AreEqual(s.Password, t.Password); + ClassicAssert.AreEqual(s.Username, t.Username); } [Test] @@ -633,8 +634,8 @@ namespace LibreMetaverse.Tests UpdateAgentLanguageMessage t = new UpdateAgentLanguageMessage(); t.Deserialize(map); - Assert.AreEqual(s.Language, t.Language); - Assert.AreEqual(s.LanguagePublic, t.LanguagePublic); + ClassicAssert.AreEqual(s.Language, t.Language); + ClassicAssert.AreEqual(s.LanguagePublic, t.LanguagePublic); } @@ -706,64 +707,64 @@ namespace LibreMetaverse.Tests t.Deserialize(map); - Assert.AreEqual(s.AABBMax, t.AABBMax); - Assert.AreEqual(s.AABBMin, t.AABBMin); - Assert.AreEqual(s.AnyAVSounds, t.AnyAVSounds); - Assert.AreEqual(s.Area, t.Area); - Assert.AreEqual(s.AuctionID, t.AuctionID); - Assert.AreEqual(s.AuthBuyerID, t.AuthBuyerID); - Assert.AreEqual(s.Bitmap, t.Bitmap); - Assert.AreEqual(s.Category, t.Category); - Assert.AreEqual(s.ClaimDate, t.ClaimDate); - Assert.AreEqual(s.ClaimPrice, t.ClaimPrice); - Assert.AreEqual(s.Desc, t.Desc); - Assert.AreEqual(s.GroupAVSounds, t.GroupAVSounds); - Assert.AreEqual(s.GroupID, t.GroupID); - Assert.AreEqual(s.GroupPrims, t.GroupPrims); - Assert.AreEqual(s.IsGroupOwned, t.IsGroupOwned); - Assert.AreEqual(s.LandingType, t.LandingType); - Assert.AreEqual(s.LocalID, t.LocalID); - Assert.AreEqual(s.MaxPrims, t.MaxPrims); - Assert.AreEqual(s.MediaAutoScale, t.MediaAutoScale); - Assert.AreEqual(s.MediaDesc, t.MediaDesc); - Assert.AreEqual(s.MediaHeight, t.MediaHeight); - Assert.AreEqual(s.MediaID, t.MediaID); - Assert.AreEqual(s.MediaLoop, t.MediaLoop); - Assert.AreEqual(s.MediaType, t.MediaType); - Assert.AreEqual(s.MediaURL, t.MediaURL); - Assert.AreEqual(s.MediaWidth, t.MediaWidth); - Assert.AreEqual(s.MusicURL, t.MusicURL); - Assert.AreEqual(s.Name, t.Name); - Assert.AreEqual(s.ObscureMedia, t.ObscureMedia); - Assert.AreEqual(s.ObscureMusic, t.ObscureMusic); - Assert.AreEqual(s.OtherCleanTime, t.OtherCleanTime); - Assert.AreEqual(s.OtherCount, t.OtherCount); - Assert.AreEqual(s.OtherPrims, t.OtherPrims); - Assert.AreEqual(s.OwnerID, t.OwnerID); - Assert.AreEqual(s.OwnerPrims, t.OwnerPrims); - Assert.AreEqual(s.ParcelFlags, t.ParcelFlags); - Assert.AreEqual(s.ParcelPrimBonus, t.ParcelPrimBonus); - Assert.AreEqual(s.PassHours, t.PassHours); - Assert.AreEqual(s.PassPrice, t.PassPrice); - Assert.AreEqual(s.PublicCount, t.PublicCount); - Assert.AreEqual(s.RegionDenyAgeUnverified, t.RegionDenyAgeUnverified); - Assert.AreEqual(s.RegionDenyAnonymous, t.RegionDenyAnonymous); - Assert.AreEqual(s.RegionPushOverride, t.RegionPushOverride); - Assert.AreEqual(s.RentPrice, t.RentPrice); - Assert.AreEqual(s.RequestResult, t.RequestResult); - Assert.AreEqual(s.SalePrice, t.SalePrice); - Assert.AreEqual(s.SeeAVs, t.SeeAVs); - Assert.AreEqual(s.SelectedPrims, t.SelectedPrims); - Assert.AreEqual(s.SelfCount, t.SelfCount); - Assert.AreEqual(s.SequenceID, t.SequenceID); - Assert.AreEqual(s.SimWideMaxPrims, t.SimWideMaxPrims); - Assert.AreEqual(s.SimWideTotalPrims, t.SimWideTotalPrims); - Assert.AreEqual(s.SnapSelection, t.SnapSelection); - Assert.AreEqual(s.SnapshotID, t.SnapshotID); - Assert.AreEqual(s.Status, t.Status); - Assert.AreEqual(s.TotalPrims, t.TotalPrims); - Assert.AreEqual(s.UserLocation, t.UserLocation); - Assert.AreEqual(s.UserLookAt, t.UserLookAt); + ClassicAssert.AreEqual(s.AABBMax, t.AABBMax); + ClassicAssert.AreEqual(s.AABBMin, t.AABBMin); + ClassicAssert.AreEqual(s.AnyAVSounds, t.AnyAVSounds); + ClassicAssert.AreEqual(s.Area, t.Area); + ClassicAssert.AreEqual(s.AuctionID, t.AuctionID); + ClassicAssert.AreEqual(s.AuthBuyerID, t.AuthBuyerID); + ClassicAssert.AreEqual(s.Bitmap, t.Bitmap); + ClassicAssert.AreEqual(s.Category, t.Category); + ClassicAssert.AreEqual(s.ClaimDate, t.ClaimDate); + ClassicAssert.AreEqual(s.ClaimPrice, t.ClaimPrice); + ClassicAssert.AreEqual(s.Desc, t.Desc); + ClassicAssert.AreEqual(s.GroupAVSounds, t.GroupAVSounds); + ClassicAssert.AreEqual(s.GroupID, t.GroupID); + ClassicAssert.AreEqual(s.GroupPrims, t.GroupPrims); + ClassicAssert.AreEqual(s.IsGroupOwned, t.IsGroupOwned); + ClassicAssert.AreEqual(s.LandingType, t.LandingType); + ClassicAssert.AreEqual(s.LocalID, t.LocalID); + ClassicAssert.AreEqual(s.MaxPrims, t.MaxPrims); + ClassicAssert.AreEqual(s.MediaAutoScale, t.MediaAutoScale); + ClassicAssert.AreEqual(s.MediaDesc, t.MediaDesc); + ClassicAssert.AreEqual(s.MediaHeight, t.MediaHeight); + ClassicAssert.AreEqual(s.MediaID, t.MediaID); + ClassicAssert.AreEqual(s.MediaLoop, t.MediaLoop); + ClassicAssert.AreEqual(s.MediaType, t.MediaType); + ClassicAssert.AreEqual(s.MediaURL, t.MediaURL); + ClassicAssert.AreEqual(s.MediaWidth, t.MediaWidth); + ClassicAssert.AreEqual(s.MusicURL, t.MusicURL); + ClassicAssert.AreEqual(s.Name, t.Name); + ClassicAssert.AreEqual(s.ObscureMedia, t.ObscureMedia); + ClassicAssert.AreEqual(s.ObscureMusic, t.ObscureMusic); + ClassicAssert.AreEqual(s.OtherCleanTime, t.OtherCleanTime); + ClassicAssert.AreEqual(s.OtherCount, t.OtherCount); + ClassicAssert.AreEqual(s.OtherPrims, t.OtherPrims); + ClassicAssert.AreEqual(s.OwnerID, t.OwnerID); + ClassicAssert.AreEqual(s.OwnerPrims, t.OwnerPrims); + ClassicAssert.AreEqual(s.ParcelFlags, t.ParcelFlags); + ClassicAssert.AreEqual(s.ParcelPrimBonus, t.ParcelPrimBonus); + ClassicAssert.AreEqual(s.PassHours, t.PassHours); + ClassicAssert.AreEqual(s.PassPrice, t.PassPrice); + ClassicAssert.AreEqual(s.PublicCount, t.PublicCount); + ClassicAssert.AreEqual(s.RegionDenyAgeUnverified, t.RegionDenyAgeUnverified); + ClassicAssert.AreEqual(s.RegionDenyAnonymous, t.RegionDenyAnonymous); + ClassicAssert.AreEqual(s.RegionPushOverride, t.RegionPushOverride); + ClassicAssert.AreEqual(s.RentPrice, t.RentPrice); + ClassicAssert.AreEqual(s.RequestResult, t.RequestResult); + ClassicAssert.AreEqual(s.SalePrice, t.SalePrice); + ClassicAssert.AreEqual(s.SeeAVs, t.SeeAVs); + ClassicAssert.AreEqual(s.SelectedPrims, t.SelectedPrims); + ClassicAssert.AreEqual(s.SelfCount, t.SelfCount); + ClassicAssert.AreEqual(s.SequenceID, t.SequenceID); + ClassicAssert.AreEqual(s.SimWideMaxPrims, t.SimWideMaxPrims); + ClassicAssert.AreEqual(s.SimWideTotalPrims, t.SimWideTotalPrims); + ClassicAssert.AreEqual(s.SnapSelection, t.SnapSelection); + ClassicAssert.AreEqual(s.SnapshotID, t.SnapshotID); + ClassicAssert.AreEqual(s.Status, t.Status); + ClassicAssert.AreEqual(s.TotalPrims, t.TotalPrims); + ClassicAssert.AreEqual(s.UserLocation, t.UserLocation); + ClassicAssert.AreEqual(s.UserLookAt, t.UserLookAt); } [Test] @@ -805,34 +806,34 @@ namespace LibreMetaverse.Tests t.Deserialize(map); - Assert.AreEqual(s.AnyAVSounds, t.AnyAVSounds); - Assert.AreEqual(s.AuthBuyerID, t.AuthBuyerID); - Assert.AreEqual(s.Category, t.Category); - Assert.AreEqual(s.Desc, t.Desc); - Assert.AreEqual(s.GroupAVSounds, t.GroupAVSounds); - Assert.AreEqual(s.GroupID, t.GroupID); - Assert.AreEqual(s.Landing, t.Landing); - Assert.AreEqual(s.LocalID, t.LocalID); - Assert.AreEqual(s.MediaAutoScale, t.MediaAutoScale); - Assert.AreEqual(s.MediaDesc, t.MediaDesc); - Assert.AreEqual(s.MediaHeight, t.MediaHeight); - Assert.AreEqual(s.MediaID, t.MediaID); - Assert.AreEqual(s.MediaLoop, t.MediaLoop); - Assert.AreEqual(s.MediaType, t.MediaType); - Assert.AreEqual(s.MediaURL, t.MediaURL); - Assert.AreEqual(s.MediaWidth, t.MediaWidth); - Assert.AreEqual(s.MusicURL, t.MusicURL); - Assert.AreEqual(s.Name, t.Name); - Assert.AreEqual(s.ObscureMedia, t.ObscureMedia); - Assert.AreEqual(s.ObscureMusic, t.ObscureMusic); - Assert.AreEqual(s.ParcelFlags, t.ParcelFlags); - Assert.AreEqual(s.PassHours, t.PassHours); - Assert.AreEqual(s.PassPrice, t.PassPrice); - Assert.AreEqual(s.SalePrice, t.SalePrice); - Assert.AreEqual(s.SeeAVs, t.SeeAVs); - Assert.AreEqual(s.SnapshotID, t.SnapshotID); - Assert.AreEqual(s.UserLocation, t.UserLocation); - Assert.AreEqual(s.UserLookAt, t.UserLookAt); + ClassicAssert.AreEqual(s.AnyAVSounds, t.AnyAVSounds); + ClassicAssert.AreEqual(s.AuthBuyerID, t.AuthBuyerID); + ClassicAssert.AreEqual(s.Category, t.Category); + ClassicAssert.AreEqual(s.Desc, t.Desc); + ClassicAssert.AreEqual(s.GroupAVSounds, t.GroupAVSounds); + ClassicAssert.AreEqual(s.GroupID, t.GroupID); + ClassicAssert.AreEqual(s.Landing, t.Landing); + ClassicAssert.AreEqual(s.LocalID, t.LocalID); + ClassicAssert.AreEqual(s.MediaAutoScale, t.MediaAutoScale); + ClassicAssert.AreEqual(s.MediaDesc, t.MediaDesc); + ClassicAssert.AreEqual(s.MediaHeight, t.MediaHeight); + ClassicAssert.AreEqual(s.MediaID, t.MediaID); + ClassicAssert.AreEqual(s.MediaLoop, t.MediaLoop); + ClassicAssert.AreEqual(s.MediaType, t.MediaType); + ClassicAssert.AreEqual(s.MediaURL, t.MediaURL); + ClassicAssert.AreEqual(s.MediaWidth, t.MediaWidth); + ClassicAssert.AreEqual(s.MusicURL, t.MusicURL); + ClassicAssert.AreEqual(s.Name, t.Name); + ClassicAssert.AreEqual(s.ObscureMedia, t.ObscureMedia); + ClassicAssert.AreEqual(s.ObscureMusic, t.ObscureMusic); + ClassicAssert.AreEqual(s.ParcelFlags, t.ParcelFlags); + ClassicAssert.AreEqual(s.PassHours, t.PassHours); + ClassicAssert.AreEqual(s.PassPrice, t.PassPrice); + ClassicAssert.AreEqual(s.SalePrice, t.SalePrice); + ClassicAssert.AreEqual(s.SeeAVs, t.SeeAVs); + ClassicAssert.AreEqual(s.SnapshotID, t.SnapshotID); + ClassicAssert.AreEqual(s.UserLocation, t.UserLocation); + ClassicAssert.AreEqual(s.UserLookAt, t.UserLookAt); } [Test] public void EnableSimulatorMessage() @@ -859,9 +860,9 @@ namespace LibreMetaverse.Tests for (int i = 0; i < t.Simulators.Length; i++) { - Assert.AreEqual(s.Simulators[i].IP, t.Simulators[i].IP); - Assert.AreEqual(s.Simulators[i].Port, t.Simulators[i].Port); - Assert.AreEqual(s.Simulators[i].RegionHandle, t.Simulators[i].RegionHandle); + ClassicAssert.AreEqual(s.Simulators[i].IP, t.Simulators[i].IP); + ClassicAssert.AreEqual(s.Simulators[i].Port, t.Simulators[i].Port); + ClassicAssert.AreEqual(s.Simulators[i].RegionHandle, t.Simulators[i].RegionHandle); } } @@ -875,7 +876,7 @@ namespace LibreMetaverse.Tests RemoteParcelRequestReply t = new RemoteParcelRequestReply(); t.Deserialize(map); - Assert.AreEqual(s.ParcelID, t.ParcelID); + ClassicAssert.AreEqual(s.ParcelID, t.ParcelID); } [Test] @@ -891,10 +892,10 @@ namespace LibreMetaverse.Tests UpdateScriptTaskUpdateMessage t = new UpdateScriptTaskUpdateMessage(); t.Deserialize(map); - Assert.AreEqual(s.ItemID, t.ItemID); - Assert.AreEqual(s.ScriptRunning, t.ScriptRunning); - Assert.AreEqual(s.Target, t.Target); - Assert.AreEqual(s.TaskID, t.TaskID); + ClassicAssert.AreEqual(s.ItemID, t.ItemID); + ClassicAssert.AreEqual(s.ScriptRunning, t.ScriptRunning); + ClassicAssert.AreEqual(s.Target, t.Target); + ClassicAssert.AreEqual(s.TaskID, t.TaskID); } [Test] @@ -909,8 +910,8 @@ namespace LibreMetaverse.Tests UpdateScriptAgentRequestMessage t = new UpdateScriptAgentRequestMessage(); t.Deserialize(map); - Assert.AreEqual(s.ItemID, t.ItemID); - Assert.AreEqual(s.Target, t.Target); + ClassicAssert.AreEqual(s.ItemID, t.ItemID); + ClassicAssert.AreEqual(s.Target, t.Target); } [Test] @@ -929,12 +930,12 @@ namespace LibreMetaverse.Tests SendPostcardMessage t = new SendPostcardMessage(); t.Deserialize(map); - Assert.AreEqual(s.FromEmail, t.FromEmail); - Assert.AreEqual(s.FromName, t.FromName); - Assert.AreEqual(s.GlobalPosition, t.GlobalPosition); - Assert.AreEqual(s.Message, t.Message); - Assert.AreEqual(s.Subject, t.Subject); - Assert.AreEqual(s.ToEmail, t.ToEmail); + ClassicAssert.AreEqual(s.FromEmail, t.FromEmail); + ClassicAssert.AreEqual(s.FromName, t.FromName); + ClassicAssert.AreEqual(s.GlobalPosition, t.GlobalPosition); + ClassicAssert.AreEqual(s.Message, t.Message); + ClassicAssert.AreEqual(s.Subject, t.Subject); + ClassicAssert.AreEqual(s.ToEmail, t.ToEmail); } [Test] @@ -948,7 +949,7 @@ namespace LibreMetaverse.Tests UpdateAgentInventoryRequestMessage t = new UpdateAgentInventoryRequestMessage(); t.Deserialize(map); - Assert.AreEqual(s.ItemID, t.ItemID); + ClassicAssert.AreEqual(s.ItemID, t.ItemID); } [Test] @@ -987,20 +988,20 @@ namespace LibreMetaverse.Tests LandStatReplyMessage t = new LandStatReplyMessage(); t.Deserialize(map); - Assert.AreEqual(s.ReportType, t.ReportType); - Assert.AreEqual(s.RequestFlags, t.RequestFlags); - Assert.AreEqual(s.TotalObjectCount, t.TotalObjectCount); + ClassicAssert.AreEqual(s.ReportType, t.ReportType); + ClassicAssert.AreEqual(s.RequestFlags, t.RequestFlags); + ClassicAssert.AreEqual(s.TotalObjectCount, t.TotalObjectCount); for (int i = 0; i < t.ReportDataBlocks.Length; i++) { - Assert.AreEqual(s.ReportDataBlocks[i].Location, t.ReportDataBlocks[i].Location); - Assert.AreEqual(s.ReportDataBlocks[i].MonoScore, t.ReportDataBlocks[i].MonoScore); - Assert.AreEqual(s.ReportDataBlocks[i].OwnerName, t.ReportDataBlocks[i].OwnerName); - Assert.AreEqual(s.ReportDataBlocks[i].Score, t.ReportDataBlocks[i].Score); - Assert.AreEqual(s.ReportDataBlocks[i].TaskID, t.ReportDataBlocks[i].TaskID); - Assert.AreEqual(s.ReportDataBlocks[i].TaskLocalID, t.ReportDataBlocks[i].TaskLocalID); - Assert.AreEqual(s.ReportDataBlocks[i].TaskName, t.ReportDataBlocks[i].TaskName); - Assert.AreEqual(s.ReportDataBlocks[i].TimeStamp, t.ReportDataBlocks[i].TimeStamp); + ClassicAssert.AreEqual(s.ReportDataBlocks[i].Location, t.ReportDataBlocks[i].Location); + ClassicAssert.AreEqual(s.ReportDataBlocks[i].MonoScore, t.ReportDataBlocks[i].MonoScore); + ClassicAssert.AreEqual(s.ReportDataBlocks[i].OwnerName, t.ReportDataBlocks[i].OwnerName); + ClassicAssert.AreEqual(s.ReportDataBlocks[i].Score, t.ReportDataBlocks[i].Score); + ClassicAssert.AreEqual(s.ReportDataBlocks[i].TaskID, t.ReportDataBlocks[i].TaskID); + ClassicAssert.AreEqual(s.ReportDataBlocks[i].TaskLocalID, t.ReportDataBlocks[i].TaskLocalID); + ClassicAssert.AreEqual(s.ReportDataBlocks[i].TaskName, t.ReportDataBlocks[i].TaskName); + ClassicAssert.AreEqual(s.ReportDataBlocks[i].TimeStamp, t.ReportDataBlocks[i].TimeStamp); } } @@ -1018,10 +1019,10 @@ namespace LibreMetaverse.Tests TeleportFailedMessage t = new TeleportFailedMessage(); t.Deserialize(map); - Assert.AreEqual(s.AgentID, t.AgentID); - Assert.AreEqual(s.ExtraParams, t.ExtraParams); - Assert.AreEqual(s.MessageKey, t.MessageKey); - Assert.AreEqual(s.Reason, t.Reason); + ClassicAssert.AreEqual(s.AgentID, t.AgentID); + ClassicAssert.AreEqual(s.ExtraParams, t.ExtraParams); + ClassicAssert.AreEqual(s.MessageKey, t.MessageKey); + ClassicAssert.AreEqual(s.Reason, t.Reason); } @@ -1035,7 +1036,7 @@ namespace LibreMetaverse.Tests UpdateAgentInformationMessage t = new UpdateAgentInformationMessage(); t.Deserialize(map); - Assert.AreEqual(s.MaxAccess, t.MaxAccess); + ClassicAssert.AreEqual(s.MaxAccess, t.MaxAccess); } [Test] @@ -1088,26 +1089,26 @@ namespace LibreMetaverse.Tests PlacesReplyMessage t = new PlacesReplyMessage(); t.Deserialize(map); - Assert.AreEqual(s.AgentID, t.AgentID); - Assert.AreEqual(s.TransactionID, t.TransactionID); - Assert.AreEqual(s.QueryID, t.QueryID); + ClassicAssert.AreEqual(s.AgentID, t.AgentID); + ClassicAssert.AreEqual(s.TransactionID, t.TransactionID); + ClassicAssert.AreEqual(s.QueryID, t.QueryID); for (int i = 0; i < s.QueryDataBlocks.Length; i++) { - Assert.AreEqual(s.QueryDataBlocks[i].ActualArea, t.QueryDataBlocks[i].ActualArea); - Assert.AreEqual(s.QueryDataBlocks[i].BillableArea, t.QueryDataBlocks[i].BillableArea); - Assert.AreEqual(s.QueryDataBlocks[i].Description, t.QueryDataBlocks[i].Description); - Assert.AreEqual(s.QueryDataBlocks[i].Dwell, t.QueryDataBlocks[i].Dwell); - Assert.AreEqual(s.QueryDataBlocks[i].Flags, t.QueryDataBlocks[i].Flags); - Assert.AreEqual(s.QueryDataBlocks[i].GlobalX, t.QueryDataBlocks[i].GlobalX); - Assert.AreEqual(s.QueryDataBlocks[i].GlobalY, t.QueryDataBlocks[i].GlobalY); - Assert.AreEqual(s.QueryDataBlocks[i].GlobalZ, t.QueryDataBlocks[i].GlobalZ); - Assert.AreEqual(s.QueryDataBlocks[i].Name, t.QueryDataBlocks[i].Name); - Assert.AreEqual(s.QueryDataBlocks[i].OwnerID, t.QueryDataBlocks[i].OwnerID); - Assert.AreEqual(s.QueryDataBlocks[i].Price, t.QueryDataBlocks[i].Price); - Assert.AreEqual(s.QueryDataBlocks[i].ProductSku, t.QueryDataBlocks[i].ProductSku); - Assert.AreEqual(s.QueryDataBlocks[i].SimName, t.QueryDataBlocks[i].SimName); - Assert.AreEqual(s.QueryDataBlocks[i].SnapShotID, t.QueryDataBlocks[i].SnapShotID); + ClassicAssert.AreEqual(s.QueryDataBlocks[i].ActualArea, t.QueryDataBlocks[i].ActualArea); + ClassicAssert.AreEqual(s.QueryDataBlocks[i].BillableArea, t.QueryDataBlocks[i].BillableArea); + ClassicAssert.AreEqual(s.QueryDataBlocks[i].Description, t.QueryDataBlocks[i].Description); + ClassicAssert.AreEqual(s.QueryDataBlocks[i].Dwell, t.QueryDataBlocks[i].Dwell); + ClassicAssert.AreEqual(s.QueryDataBlocks[i].Flags, t.QueryDataBlocks[i].Flags); + ClassicAssert.AreEqual(s.QueryDataBlocks[i].GlobalX, t.QueryDataBlocks[i].GlobalX); + ClassicAssert.AreEqual(s.QueryDataBlocks[i].GlobalY, t.QueryDataBlocks[i].GlobalY); + ClassicAssert.AreEqual(s.QueryDataBlocks[i].GlobalZ, t.QueryDataBlocks[i].GlobalZ); + ClassicAssert.AreEqual(s.QueryDataBlocks[i].Name, t.QueryDataBlocks[i].Name); + ClassicAssert.AreEqual(s.QueryDataBlocks[i].OwnerID, t.QueryDataBlocks[i].OwnerID); + ClassicAssert.AreEqual(s.QueryDataBlocks[i].Price, t.QueryDataBlocks[i].Price); + ClassicAssert.AreEqual(s.QueryDataBlocks[i].ProductSku, t.QueryDataBlocks[i].ProductSku); + ClassicAssert.AreEqual(s.QueryDataBlocks[i].SimName, t.QueryDataBlocks[i].SimName); + ClassicAssert.AreEqual(s.QueryDataBlocks[i].SnapShotID, t.QueryDataBlocks[i].SnapShotID); } } @@ -1146,18 +1147,18 @@ namespace LibreMetaverse.Tests DirLandReplyMessage t = new DirLandReplyMessage(); t.Deserialize(map); - Assert.AreEqual(s.AgentID, t.AgentID); - Assert.AreEqual(s.QueryID, t.QueryID); + ClassicAssert.AreEqual(s.AgentID, t.AgentID); + ClassicAssert.AreEqual(s.QueryID, t.QueryID); for (int i = 0; i < s.QueryReplies.Length; i++) { - Assert.AreEqual(s.QueryReplies[i].ActualArea, t.QueryReplies[i].ActualArea); - Assert.AreEqual(s.QueryReplies[i].Auction, t.QueryReplies[i].Auction); - Assert.AreEqual(s.QueryReplies[i].ForSale, t.QueryReplies[i].ForSale); - Assert.AreEqual(s.QueryReplies[i].Name, t.QueryReplies[i].Name); - Assert.AreEqual(s.QueryReplies[i].ProductSku, t.QueryReplies[i].ProductSku); - Assert.AreEqual(s.QueryReplies[i].ParcelID, t.QueryReplies[i].ParcelID); - Assert.AreEqual(s.QueryReplies[i].SalePrice, t.QueryReplies[i].SalePrice); + ClassicAssert.AreEqual(s.QueryReplies[i].ActualArea, t.QueryReplies[i].ActualArea); + ClassicAssert.AreEqual(s.QueryReplies[i].Auction, t.QueryReplies[i].Auction); + ClassicAssert.AreEqual(s.QueryReplies[i].ForSale, t.QueryReplies[i].ForSale); + ClassicAssert.AreEqual(s.QueryReplies[i].Name, t.QueryReplies[i].Name); + ClassicAssert.AreEqual(s.QueryReplies[i].ProductSku, t.QueryReplies[i].ProductSku); + ClassicAssert.AreEqual(s.QueryReplies[i].ParcelID, t.QueryReplies[i].ParcelID); + ClassicAssert.AreEqual(s.QueryReplies[i].SalePrice, t.QueryReplies[i].SalePrice); } } #region Performance Testing @@ -1178,7 +1179,7 @@ namespace LibreMetaverse.Tests RemoteParcelRequestReply t = new RemoteParcelRequestReply(); t.Deserialize(map); - Assert.AreEqual(s.ParcelID, t.ParcelID); + ClassicAssert.AreEqual(s.ParcelID, t.ParcelID); } TimeSpan duration = DateTime.UtcNow - messageTestTime; Console.WriteLine("RemoteParcelRequestReply: OMV Message System Serialization/Deserialization Passes: {0} Total time: {1}", TEST_ITER, duration); @@ -1197,7 +1198,7 @@ namespace LibreMetaverse.Tests stream.Seek(0, SeekOrigin.Begin); RemoteParcelRequestReply t = (RemoteParcelRequestReply)formatter.Deserialize(stream); - Assert.AreEqual(s.ParcelID, t.ParcelID); + ClassicAssert.AreEqual(s.ParcelID, t.ParcelID); } TimeSpan durationxml = DateTime.UtcNow - xmlTestTime; Console.WriteLine("RemoteParcelRequestReply: .NET BinarySerialization/Deserialization Passes: {0} Total time: {1}", TEST_ITER, durationxml); @@ -1243,18 +1244,18 @@ namespace LibreMetaverse.Tests DirLandReplyMessage t = new DirLandReplyMessage(); t.Deserialize(map); - Assert.AreEqual(s.AgentID, t.AgentID); - Assert.AreEqual(s.QueryID, t.QueryID); + ClassicAssert.AreEqual(s.AgentID, t.AgentID); + ClassicAssert.AreEqual(s.QueryID, t.QueryID); for (int i = 0; i < s.QueryReplies.Length; i++) { - Assert.AreEqual(s.QueryReplies[i].ActualArea, t.QueryReplies[i].ActualArea); - Assert.AreEqual(s.QueryReplies[i].Auction, t.QueryReplies[i].Auction); - Assert.AreEqual(s.QueryReplies[i].ForSale, t.QueryReplies[i].ForSale); - Assert.AreEqual(s.QueryReplies[i].Name, t.QueryReplies[i].Name); - Assert.AreEqual(s.QueryReplies[i].ProductSku, t.QueryReplies[i].ProductSku); - Assert.AreEqual(s.QueryReplies[i].ParcelID, t.QueryReplies[i].ParcelID); - Assert.AreEqual(s.QueryReplies[i].SalePrice, t.QueryReplies[i].SalePrice); + ClassicAssert.AreEqual(s.QueryReplies[i].ActualArea, t.QueryReplies[i].ActualArea); + ClassicAssert.AreEqual(s.QueryReplies[i].Auction, t.QueryReplies[i].Auction); + ClassicAssert.AreEqual(s.QueryReplies[i].ForSale, t.QueryReplies[i].ForSale); + ClassicAssert.AreEqual(s.QueryReplies[i].Name, t.QueryReplies[i].Name); + ClassicAssert.AreEqual(s.QueryReplies[i].ProductSku, t.QueryReplies[i].ProductSku); + ClassicAssert.AreEqual(s.QueryReplies[i].ParcelID, t.QueryReplies[i].ParcelID); + ClassicAssert.AreEqual(s.QueryReplies[i].SalePrice, t.QueryReplies[i].SalePrice); } } TimeSpan duration = DateTime.UtcNow - messageTestTime; @@ -1298,18 +1299,18 @@ namespace LibreMetaverse.Tests stream.Seek(0, SeekOrigin.Begin); DirLandReplyMessage t = (DirLandReplyMessage)formatter.Deserialize(stream); - Assert.AreEqual(s.AgentID, t.AgentID); - Assert.AreEqual(s.QueryID, t.QueryID); + ClassicAssert.AreEqual(s.AgentID, t.AgentID); + ClassicAssert.AreEqual(s.QueryID, t.QueryID); for (int i = 0; i < s.QueryReplies.Length; i++) { - Assert.AreEqual(s.QueryReplies[i].ActualArea, t.QueryReplies[i].ActualArea); - Assert.AreEqual(s.QueryReplies[i].Auction, t.QueryReplies[i].Auction); - Assert.AreEqual(s.QueryReplies[i].ForSale, t.QueryReplies[i].ForSale); - Assert.AreEqual(s.QueryReplies[i].Name, t.QueryReplies[i].Name); - Assert.AreEqual(s.QueryReplies[i].ProductSku, t.QueryReplies[i].ProductSku); - Assert.AreEqual(s.QueryReplies[i].ParcelID, t.QueryReplies[i].ParcelID); - Assert.AreEqual(s.QueryReplies[i].SalePrice, t.QueryReplies[i].SalePrice); + ClassicAssert.AreEqual(s.QueryReplies[i].ActualArea, t.QueryReplies[i].ActualArea); + ClassicAssert.AreEqual(s.QueryReplies[i].Auction, t.QueryReplies[i].Auction); + ClassicAssert.AreEqual(s.QueryReplies[i].ForSale, t.QueryReplies[i].ForSale); + ClassicAssert.AreEqual(s.QueryReplies[i].Name, t.QueryReplies[i].Name); + ClassicAssert.AreEqual(s.QueryReplies[i].ProductSku, t.QueryReplies[i].ProductSku); + ClassicAssert.AreEqual(s.QueryReplies[i].ParcelID, t.QueryReplies[i].ParcelID); + ClassicAssert.AreEqual(s.QueryReplies[i].SalePrice, t.QueryReplies[i].SalePrice); } } TimeSpan durationxml = DateTime.UtcNow - xmlTestTime; @@ -1445,61 +1446,61 @@ namespace LibreMetaverse.Tests t.Deserialize(map); - Assert.AreEqual(s.AABBMax, t.AABBMax); - Assert.AreEqual(s.AABBMin, t.AABBMin); - Assert.AreEqual(s.Area, t.Area); - Assert.AreEqual(s.AuctionID, t.AuctionID); - Assert.AreEqual(s.AuthBuyerID, t.AuthBuyerID); - Assert.AreEqual(s.Bitmap, t.Bitmap); - Assert.AreEqual(s.Category, t.Category); - Assert.AreEqual(s.ClaimDate, t.ClaimDate); - Assert.AreEqual(s.ClaimPrice, t.ClaimPrice); - Assert.AreEqual(s.Desc, t.Desc); - Assert.AreEqual(s.GroupID, t.GroupID); - Assert.AreEqual(s.GroupPrims, t.GroupPrims); - Assert.AreEqual(s.IsGroupOwned, t.IsGroupOwned); - Assert.AreEqual(s.LandingType, t.LandingType); - Assert.AreEqual(s.LocalID, t.LocalID); - Assert.AreEqual(s.MaxPrims, t.MaxPrims); - Assert.AreEqual(s.MediaAutoScale, t.MediaAutoScale); - Assert.AreEqual(s.MediaDesc, t.MediaDesc); - Assert.AreEqual(s.MediaHeight, t.MediaHeight); - Assert.AreEqual(s.MediaID, t.MediaID); - Assert.AreEqual(s.MediaLoop, t.MediaLoop); - Assert.AreEqual(s.MediaType, t.MediaType); - Assert.AreEqual(s.MediaURL, t.MediaURL); - Assert.AreEqual(s.MediaWidth, t.MediaWidth); - Assert.AreEqual(s.MusicURL, t.MusicURL); - Assert.AreEqual(s.Name, t.Name); - Assert.AreEqual(s.ObscureMedia, t.ObscureMedia); - Assert.AreEqual(s.ObscureMusic, t.ObscureMusic); - Assert.AreEqual(s.OtherCleanTime, t.OtherCleanTime); - Assert.AreEqual(s.OtherCount, t.OtherCount); - Assert.AreEqual(s.OtherPrims, t.OtherPrims); - Assert.AreEqual(s.OwnerID, t.OwnerID); - Assert.AreEqual(s.OwnerPrims, t.OwnerPrims); - Assert.AreEqual(s.ParcelFlags, t.ParcelFlags); - Assert.AreEqual(s.ParcelPrimBonus, t.ParcelPrimBonus); - Assert.AreEqual(s.PassHours, t.PassHours); - Assert.AreEqual(s.PassPrice, t.PassPrice); - Assert.AreEqual(s.PublicCount, t.PublicCount); - Assert.AreEqual(s.RegionDenyAgeUnverified, t.RegionDenyAgeUnverified); - Assert.AreEqual(s.RegionDenyAnonymous, t.RegionDenyAnonymous); - Assert.AreEqual(s.RegionPushOverride, t.RegionPushOverride); - Assert.AreEqual(s.RentPrice, t.RentPrice); - Assert.AreEqual(s.RequestResult, t.RequestResult); - Assert.AreEqual(s.SalePrice, t.SalePrice); - Assert.AreEqual(s.SelectedPrims, t.SelectedPrims); - Assert.AreEqual(s.SelfCount, t.SelfCount); - Assert.AreEqual(s.SequenceID, t.SequenceID); - Assert.AreEqual(s.SimWideMaxPrims, t.SimWideMaxPrims); - Assert.AreEqual(s.SimWideTotalPrims, t.SimWideTotalPrims); - Assert.AreEqual(s.SnapSelection, t.SnapSelection); - Assert.AreEqual(s.SnapshotID, t.SnapshotID); - Assert.AreEqual(s.Status, t.Status); - Assert.AreEqual(s.TotalPrims, t.TotalPrims); - Assert.AreEqual(s.UserLocation, t.UserLocation); - Assert.AreEqual(s.UserLookAt, t.UserLookAt); + ClassicAssert.AreEqual(s.AABBMax, t.AABBMax); + ClassicAssert.AreEqual(s.AABBMin, t.AABBMin); + ClassicAssert.AreEqual(s.Area, t.Area); + ClassicAssert.AreEqual(s.AuctionID, t.AuctionID); + ClassicAssert.AreEqual(s.AuthBuyerID, t.AuthBuyerID); + ClassicAssert.AreEqual(s.Bitmap, t.Bitmap); + ClassicAssert.AreEqual(s.Category, t.Category); + ClassicAssert.AreEqual(s.ClaimDate, t.ClaimDate); + ClassicAssert.AreEqual(s.ClaimPrice, t.ClaimPrice); + ClassicAssert.AreEqual(s.Desc, t.Desc); + ClassicAssert.AreEqual(s.GroupID, t.GroupID); + ClassicAssert.AreEqual(s.GroupPrims, t.GroupPrims); + ClassicAssert.AreEqual(s.IsGroupOwned, t.IsGroupOwned); + ClassicAssert.AreEqual(s.LandingType, t.LandingType); + ClassicAssert.AreEqual(s.LocalID, t.LocalID); + ClassicAssert.AreEqual(s.MaxPrims, t.MaxPrims); + ClassicAssert.AreEqual(s.MediaAutoScale, t.MediaAutoScale); + ClassicAssert.AreEqual(s.MediaDesc, t.MediaDesc); + ClassicAssert.AreEqual(s.MediaHeight, t.MediaHeight); + ClassicAssert.AreEqual(s.MediaID, t.MediaID); + ClassicAssert.AreEqual(s.MediaLoop, t.MediaLoop); + ClassicAssert.AreEqual(s.MediaType, t.MediaType); + ClassicAssert.AreEqual(s.MediaURL, t.MediaURL); + ClassicAssert.AreEqual(s.MediaWidth, t.MediaWidth); + ClassicAssert.AreEqual(s.MusicURL, t.MusicURL); + ClassicAssert.AreEqual(s.Name, t.Name); + ClassicAssert.AreEqual(s.ObscureMedia, t.ObscureMedia); + ClassicAssert.AreEqual(s.ObscureMusic, t.ObscureMusic); + ClassicAssert.AreEqual(s.OtherCleanTime, t.OtherCleanTime); + ClassicAssert.AreEqual(s.OtherCount, t.OtherCount); + ClassicAssert.AreEqual(s.OtherPrims, t.OtherPrims); + ClassicAssert.AreEqual(s.OwnerID, t.OwnerID); + ClassicAssert.AreEqual(s.OwnerPrims, t.OwnerPrims); + ClassicAssert.AreEqual(s.ParcelFlags, t.ParcelFlags); + ClassicAssert.AreEqual(s.ParcelPrimBonus, t.ParcelPrimBonus); + ClassicAssert.AreEqual(s.PassHours, t.PassHours); + ClassicAssert.AreEqual(s.PassPrice, t.PassPrice); + ClassicAssert.AreEqual(s.PublicCount, t.PublicCount); + ClassicAssert.AreEqual(s.RegionDenyAgeUnverified, t.RegionDenyAgeUnverified); + ClassicAssert.AreEqual(s.RegionDenyAnonymous, t.RegionDenyAnonymous); + ClassicAssert.AreEqual(s.RegionPushOverride, t.RegionPushOverride); + ClassicAssert.AreEqual(s.RentPrice, t.RentPrice); + ClassicAssert.AreEqual(s.RequestResult, t.RequestResult); + ClassicAssert.AreEqual(s.SalePrice, t.SalePrice); + ClassicAssert.AreEqual(s.SelectedPrims, t.SelectedPrims); + ClassicAssert.AreEqual(s.SelfCount, t.SelfCount); + ClassicAssert.AreEqual(s.SequenceID, t.SequenceID); + ClassicAssert.AreEqual(s.SimWideMaxPrims, t.SimWideMaxPrims); + ClassicAssert.AreEqual(s.SimWideTotalPrims, t.SimWideTotalPrims); + ClassicAssert.AreEqual(s.SnapSelection, t.SnapSelection); + ClassicAssert.AreEqual(s.SnapshotID, t.SnapshotID); + ClassicAssert.AreEqual(s.Status, t.Status); + ClassicAssert.AreEqual(s.TotalPrims, t.TotalPrims); + ClassicAssert.AreEqual(s.UserLocation, t.UserLocation); + ClassicAssert.AreEqual(s.UserLookAt, t.UserLookAt); } TimeSpan duration = DateTime.UtcNow - messageTestTime; Console.WriteLine("ParcelPropertiesMessage: OMV Message System Serialization/Deserialization Passes: {0} Total time: {1}", TEST_ITER, duration); @@ -1575,61 +1576,61 @@ namespace LibreMetaverse.Tests ParcelPropertiesMessage t = (ParcelPropertiesMessage)formatter.Deserialize(stream); - Assert.AreEqual(s.AABBMax, t.AABBMax); - Assert.AreEqual(s.AABBMin, t.AABBMin); - Assert.AreEqual(s.Area, t.Area); - Assert.AreEqual(s.AuctionID, t.AuctionID); - Assert.AreEqual(s.AuthBuyerID, t.AuthBuyerID); - Assert.AreEqual(s.Bitmap, t.Bitmap); - Assert.AreEqual(s.Category, t.Category); - Assert.AreEqual(s.ClaimDate, t.ClaimDate); - Assert.AreEqual(s.ClaimPrice, t.ClaimPrice); - Assert.AreEqual(s.Desc, t.Desc); - Assert.AreEqual(s.GroupID, t.GroupID); - Assert.AreEqual(s.GroupPrims, t.GroupPrims); - Assert.AreEqual(s.IsGroupOwned, t.IsGroupOwned); - Assert.AreEqual(s.LandingType, t.LandingType); - Assert.AreEqual(s.LocalID, t.LocalID); - Assert.AreEqual(s.MaxPrims, t.MaxPrims); - Assert.AreEqual(s.MediaAutoScale, t.MediaAutoScale); - Assert.AreEqual(s.MediaDesc, t.MediaDesc); - Assert.AreEqual(s.MediaHeight, t.MediaHeight); - Assert.AreEqual(s.MediaID, t.MediaID); - Assert.AreEqual(s.MediaLoop, t.MediaLoop); - Assert.AreEqual(s.MediaType, t.MediaType); - Assert.AreEqual(s.MediaURL, t.MediaURL); - Assert.AreEqual(s.MediaWidth, t.MediaWidth); - Assert.AreEqual(s.MusicURL, t.MusicURL); - Assert.AreEqual(s.Name, t.Name); - Assert.AreEqual(s.ObscureMedia, t.ObscureMedia); - Assert.AreEqual(s.ObscureMusic, t.ObscureMusic); - Assert.AreEqual(s.OtherCleanTime, t.OtherCleanTime); - Assert.AreEqual(s.OtherCount, t.OtherCount); - Assert.AreEqual(s.OtherPrims, t.OtherPrims); - Assert.AreEqual(s.OwnerID, t.OwnerID); - Assert.AreEqual(s.OwnerPrims, t.OwnerPrims); - Assert.AreEqual(s.ParcelFlags, t.ParcelFlags); - Assert.AreEqual(s.ParcelPrimBonus, t.ParcelPrimBonus); - Assert.AreEqual(s.PassHours, t.PassHours); - Assert.AreEqual(s.PassPrice, t.PassPrice); - Assert.AreEqual(s.PublicCount, t.PublicCount); - Assert.AreEqual(s.RegionDenyAgeUnverified, t.RegionDenyAgeUnverified); - Assert.AreEqual(s.RegionDenyAnonymous, t.RegionDenyAnonymous); - Assert.AreEqual(s.RegionPushOverride, t.RegionPushOverride); - Assert.AreEqual(s.RentPrice, t.RentPrice); - Assert.AreEqual(s.RequestResult, t.RequestResult); - Assert.AreEqual(s.SalePrice, t.SalePrice); - Assert.AreEqual(s.SelectedPrims, t.SelectedPrims); - Assert.AreEqual(s.SelfCount, t.SelfCount); - Assert.AreEqual(s.SequenceID, t.SequenceID); - Assert.AreEqual(s.SimWideMaxPrims, t.SimWideMaxPrims); - Assert.AreEqual(s.SimWideTotalPrims, t.SimWideTotalPrims); - Assert.AreEqual(s.SnapSelection, t.SnapSelection); - Assert.AreEqual(s.SnapshotID, t.SnapshotID); - Assert.AreEqual(s.Status, t.Status); - Assert.AreEqual(s.TotalPrims, t.TotalPrims); - Assert.AreEqual(s.UserLocation, t.UserLocation); - Assert.AreEqual(s.UserLookAt, t.UserLookAt); + ClassicAssert.AreEqual(s.AABBMax, t.AABBMax); + ClassicAssert.AreEqual(s.AABBMin, t.AABBMin); + ClassicAssert.AreEqual(s.Area, t.Area); + ClassicAssert.AreEqual(s.AuctionID, t.AuctionID); + ClassicAssert.AreEqual(s.AuthBuyerID, t.AuthBuyerID); + ClassicAssert.AreEqual(s.Bitmap, t.Bitmap); + ClassicAssert.AreEqual(s.Category, t.Category); + ClassicAssert.AreEqual(s.ClaimDate, t.ClaimDate); + ClassicAssert.AreEqual(s.ClaimPrice, t.ClaimPrice); + ClassicAssert.AreEqual(s.Desc, t.Desc); + ClassicAssert.AreEqual(s.GroupID, t.GroupID); + ClassicAssert.AreEqual(s.GroupPrims, t.GroupPrims); + ClassicAssert.AreEqual(s.IsGroupOwned, t.IsGroupOwned); + ClassicAssert.AreEqual(s.LandingType, t.LandingType); + ClassicAssert.AreEqual(s.LocalID, t.LocalID); + ClassicAssert.AreEqual(s.MaxPrims, t.MaxPrims); + ClassicAssert.AreEqual(s.MediaAutoScale, t.MediaAutoScale); + ClassicAssert.AreEqual(s.MediaDesc, t.MediaDesc); + ClassicAssert.AreEqual(s.MediaHeight, t.MediaHeight); + ClassicAssert.AreEqual(s.MediaID, t.MediaID); + ClassicAssert.AreEqual(s.MediaLoop, t.MediaLoop); + ClassicAssert.AreEqual(s.MediaType, t.MediaType); + ClassicAssert.AreEqual(s.MediaURL, t.MediaURL); + ClassicAssert.AreEqual(s.MediaWidth, t.MediaWidth); + ClassicAssert.AreEqual(s.MusicURL, t.MusicURL); + ClassicAssert.AreEqual(s.Name, t.Name); + ClassicAssert.AreEqual(s.ObscureMedia, t.ObscureMedia); + ClassicAssert.AreEqual(s.ObscureMusic, t.ObscureMusic); + ClassicAssert.AreEqual(s.OtherCleanTime, t.OtherCleanTime); + ClassicAssert.AreEqual(s.OtherCount, t.OtherCount); + ClassicAssert.AreEqual(s.OtherPrims, t.OtherPrims); + ClassicAssert.AreEqual(s.OwnerID, t.OwnerID); + ClassicAssert.AreEqual(s.OwnerPrims, t.OwnerPrims); + ClassicAssert.AreEqual(s.ParcelFlags, t.ParcelFlags); + ClassicAssert.AreEqual(s.ParcelPrimBonus, t.ParcelPrimBonus); + ClassicAssert.AreEqual(s.PassHours, t.PassHours); + ClassicAssert.AreEqual(s.PassPrice, t.PassPrice); + ClassicAssert.AreEqual(s.PublicCount, t.PublicCount); + ClassicAssert.AreEqual(s.RegionDenyAgeUnverified, t.RegionDenyAgeUnverified); + ClassicAssert.AreEqual(s.RegionDenyAnonymous, t.RegionDenyAnonymous); + ClassicAssert.AreEqual(s.RegionPushOverride, t.RegionPushOverride); + ClassicAssert.AreEqual(s.RentPrice, t.RentPrice); + ClassicAssert.AreEqual(s.RequestResult, t.RequestResult); + ClassicAssert.AreEqual(s.SalePrice, t.SalePrice); + ClassicAssert.AreEqual(s.SelectedPrims, t.SelectedPrims); + ClassicAssert.AreEqual(s.SelfCount, t.SelfCount); + ClassicAssert.AreEqual(s.SequenceID, t.SequenceID); + ClassicAssert.AreEqual(s.SimWideMaxPrims, t.SimWideMaxPrims); + ClassicAssert.AreEqual(s.SimWideTotalPrims, t.SimWideTotalPrims); + ClassicAssert.AreEqual(s.SnapSelection, t.SnapSelection); + ClassicAssert.AreEqual(s.SnapshotID, t.SnapshotID); + ClassicAssert.AreEqual(s.Status, t.Status); + ClassicAssert.AreEqual(s.TotalPrims, t.TotalPrims); + ClassicAssert.AreEqual(s.UserLocation, t.UserLocation); + ClassicAssert.AreEqual(s.UserLookAt, t.UserLookAt); } TimeSpan durationxml = DateTime.UtcNow - xmlTestTime; Console.WriteLine("ParcelPropertiesMessage: .NET BinarySerialization/Deserialization Passes: {0} Total time: {1}", TEST_ITER, durationxml); diff --git a/LibreMetaverse.Tests/NetworkTests.cs b/LibreMetaverse.Tests/NetworkTests.cs index f57b2aae..60a6289d 100644 --- a/LibreMetaverse.Tests/NetworkTests.cs +++ b/LibreMetaverse.Tests/NetworkTests.cs @@ -66,15 +66,16 @@ namespace LibreMetaverse.Tests Console.Write($"Logging in {fullusername}..."); // Connect to the grid string startLoc = NetworkManager.StartLocation("Hooper", 179, 18, 32); - Assert.IsTrue(Client.Network.Login(username[0], username[1], password, "Unit Test Framework", startLoc, - "contact@radegast.life"), "Client failed to login, reason: " + Client.Network.LoginMessage); + Assert.That(Client.Network.Login(username[0], username[1], password, "Unit Test Framework", + startLoc, "contact@radegast.life"), Is.True, + "Client failed to login, reason: " + Client.Network.LoginMessage); Console.WriteLine("Done"); - Assert.IsTrue(Client.Network.Connected, "Client is not connected to the grid"); + Assert.That(Client.Network.Connected, Is.True, "Client is not connected to the grid"); //int start = Environment.TickCount; - Assert.AreEqual("hooper", Client.Network.CurrentSim.Name.ToLower(), + Assert.That(Client.Network.CurrentSim.Name, Is.EqualTo("hooper").IgnoreCase, $"Logged in to region {Client.Network.CurrentSim.Name} instead of Hooper"); } @@ -144,7 +145,8 @@ namespace LibreMetaverse.Tests [Test] public void CapsQueue() { - Assert.IsTrue(CapsQueueRunning(), "CAPS Event Queue is not running and failed to start"); + Assert.That(CapsQueueRunning(), Is.True, + "CAPS Event Queue is not running and failed to start"); } public bool CapsQueueRunning() diff --git a/LibreMetaverse.Tests/NotationLLSDTests.cs b/LibreMetaverse.Tests/NotationLLSDTests.cs index 25bedb85..3764415e 100644 --- a/LibreMetaverse.Tests/NotationLLSDTests.cs +++ b/LibreMetaverse.Tests/NotationLLSDTests.cs @@ -1,6 +1,6 @@ /* * Copyright (c) 2006-2016, openmetaverse.co - * Copyright (c) 2021-2022, Sjofn LLC. + * Copyright (c) 2021-2024, Sjofn LLC. * All rights reserved. * * - Redistribution and use in source and binary forms, with or without @@ -42,6 +42,7 @@ using System.IO; using System.Text; using System.Xml; using NUnit.Framework; +using NUnit.Framework.Legacy; using OpenMetaverse; using OpenMetaverse.StructuredData; @@ -58,22 +59,22 @@ namespace LibreMetaverse.Tests char[] charsOne = { 't', 'e', 's', 't' }; int resultOne = OSDParser.BufferCharactersEqual(reader, charsOne, 0); - Assert.AreEqual(charsOne.Length, resultOne); + ClassicAssert.AreEqual(charsOne.Length, resultOne); char[] charsTwo = { '1', 't', 'e' }; int resultTwo = OSDParser.BufferCharactersEqual(reader, charsTwo, 0); - Assert.AreEqual(2, resultTwo); + ClassicAssert.AreEqual(2, resultTwo); char[] charsThree = { 'a', 's', 't', '2', 't', 'e', 's' }; int resultThree = OSDParser.BufferCharactersEqual(reader, charsThree, 1); - Assert.AreEqual(1, resultThree); + ClassicAssert.AreEqual(1, resultThree); int resultFour = OSDParser.BufferCharactersEqual(reader, charsThree, 0); - Assert.AreEqual(charsThree.Length, resultFour); + ClassicAssert.AreEqual(charsThree.Length, resultFour); char[] charsFive = { 't', '3', 'a', 'a' }; int resultFive = OSDParser.BufferCharactersEqual(reader, charsFive, 0); - Assert.AreEqual(2, resultFive); + ClassicAssert.AreEqual(2, resultFive); } @@ -83,7 +84,7 @@ namespace LibreMetaverse.Tests { string s = "!"; OSD llsd = OSDParser.DeserializeLLSDNotation(s); - Assert.AreEqual(OSDType.Unknown, llsd.Type); + ClassicAssert.AreEqual(OSDType.Unknown, llsd.Type); } [Test()] @@ -93,7 +94,7 @@ namespace LibreMetaverse.Tests string s = OSDParser.SerializeLLSDNotation(llsd); OSD llsdDS = OSDParser.DeserializeLLSDNotation(s); - Assert.AreEqual(OSDType.Unknown, llsdDS.Type); + ClassicAssert.AreEqual(OSDType.Unknown, llsdDS.Type); } [Test()] @@ -101,53 +102,53 @@ namespace LibreMetaverse.Tests { string t = "true"; OSD llsdT = OSDParser.DeserializeLLSDNotation(t); - Assert.AreEqual(OSDType.Boolean, llsdT.Type); - Assert.AreEqual(true, llsdT.AsBoolean()); + ClassicAssert.AreEqual(OSDType.Boolean, llsdT.Type); + ClassicAssert.AreEqual(true, llsdT.AsBoolean()); string tTwo = "t"; OSD llsdTTwo = OSDParser.DeserializeLLSDNotation(tTwo); - Assert.AreEqual(OSDType.Boolean, llsdTTwo.Type); - Assert.AreEqual(true, llsdTTwo.AsBoolean()); + ClassicAssert.AreEqual(OSDType.Boolean, llsdTTwo.Type); + ClassicAssert.AreEqual(true, llsdTTwo.AsBoolean()); string tThree = "TRUE"; OSD llsdTThree = OSDParser.DeserializeLLSDNotation(tThree); - Assert.AreEqual(OSDType.Boolean, llsdTThree.Type); - Assert.AreEqual(true, llsdTThree.AsBoolean()); + ClassicAssert.AreEqual(OSDType.Boolean, llsdTThree.Type); + ClassicAssert.AreEqual(true, llsdTThree.AsBoolean()); string tFour = "T"; OSD llsdTFour = OSDParser.DeserializeLLSDNotation(tFour); - Assert.AreEqual(OSDType.Boolean, llsdTFour.Type); - Assert.AreEqual(true, llsdTFour.AsBoolean()); + ClassicAssert.AreEqual(OSDType.Boolean, llsdTFour.Type); + ClassicAssert.AreEqual(true, llsdTFour.AsBoolean()); string tFive = "1"; OSD llsdTFive = OSDParser.DeserializeLLSDNotation(tFive); - Assert.AreEqual(OSDType.Boolean, llsdTFive.Type); - Assert.AreEqual(true, llsdTFive.AsBoolean()); + ClassicAssert.AreEqual(OSDType.Boolean, llsdTFive.Type); + ClassicAssert.AreEqual(true, llsdTFive.AsBoolean()); string f = "false"; OSD llsdF = OSDParser.DeserializeLLSDNotation(f); - Assert.AreEqual(OSDType.Boolean, llsdF.Type); - Assert.AreEqual(false, llsdF.AsBoolean()); + ClassicAssert.AreEqual(OSDType.Boolean, llsdF.Type); + ClassicAssert.AreEqual(false, llsdF.AsBoolean()); string fTwo = "f"; OSD llsdFTwo = OSDParser.DeserializeLLSDNotation(fTwo); - Assert.AreEqual(OSDType.Boolean, llsdFTwo.Type); - Assert.AreEqual(false, llsdFTwo.AsBoolean()); + ClassicAssert.AreEqual(OSDType.Boolean, llsdFTwo.Type); + ClassicAssert.AreEqual(false, llsdFTwo.AsBoolean()); string fThree = "FALSE"; OSD llsdFThree = OSDParser.DeserializeLLSDNotation(fThree); - Assert.AreEqual(OSDType.Boolean, llsdFThree.Type); - Assert.AreEqual(false, llsdFThree.AsBoolean()); + ClassicAssert.AreEqual(OSDType.Boolean, llsdFThree.Type); + ClassicAssert.AreEqual(false, llsdFThree.AsBoolean()); string fFour = "F"; OSD llsdFFour = OSDParser.DeserializeLLSDNotation(fFour); - Assert.AreEqual(OSDType.Boolean, llsdFFour.Type); - Assert.AreEqual(false, llsdFFour.AsBoolean()); + ClassicAssert.AreEqual(OSDType.Boolean, llsdFFour.Type); + ClassicAssert.AreEqual(false, llsdFFour.AsBoolean()); string fFive = "0"; OSD llsdFFive = OSDParser.DeserializeLLSDNotation(fFive); - Assert.AreEqual(OSDType.Boolean, llsdFFive.Type); - Assert.AreEqual(false, llsdFFive.AsBoolean()); + ClassicAssert.AreEqual(OSDType.Boolean, llsdFFive.Type); + ClassicAssert.AreEqual(false, llsdFFive.AsBoolean()); } [Test()] @@ -156,14 +157,14 @@ namespace LibreMetaverse.Tests OSD llsdTrue = OSD.FromBoolean(true); string sTrue = OSDParser.SerializeLLSDNotation(llsdTrue); OSD llsdTrueDS = OSDParser.DeserializeLLSDNotation(sTrue); - Assert.AreEqual(OSDType.Boolean, llsdTrueDS.Type); - Assert.AreEqual(true, llsdTrueDS.AsBoolean()); + ClassicAssert.AreEqual(OSDType.Boolean, llsdTrueDS.Type); + ClassicAssert.AreEqual(true, llsdTrueDS.AsBoolean()); OSD llsdFalse = OSD.FromBoolean(false); string sFalse = OSDParser.SerializeLLSDNotation(llsdFalse); OSD llsdFalseDS = OSDParser.DeserializeLLSDNotation(sFalse); - Assert.AreEqual(OSDType.Boolean, llsdFalseDS.Type); - Assert.AreEqual(false, llsdFalseDS.AsBoolean()); + ClassicAssert.AreEqual(OSDType.Boolean, llsdFalseDS.Type); + ClassicAssert.AreEqual(false, llsdFalseDS.AsBoolean()); } [Test()] @@ -171,13 +172,13 @@ namespace LibreMetaverse.Tests { string integerOne = "i12319423"; OSD llsdOne = OSDParser.DeserializeLLSDNotation(integerOne); - Assert.AreEqual(OSDType.Integer, llsdOne.Type); - Assert.AreEqual(12319423, llsdOne.AsInteger()); + ClassicAssert.AreEqual(OSDType.Integer, llsdOne.Type); + ClassicAssert.AreEqual(12319423, llsdOne.AsInteger()); string integerTwo = "i-489234"; OSD llsdTwo = OSDParser.DeserializeLLSDNotation(integerTwo); - Assert.AreEqual(OSDType.Integer, llsdTwo.Type); - Assert.AreEqual(-489234, llsdTwo.AsInteger()); + ClassicAssert.AreEqual(OSDType.Integer, llsdTwo.Type); + ClassicAssert.AreEqual(-489234, llsdTwo.AsInteger()); } [Test()] @@ -186,14 +187,14 @@ namespace LibreMetaverse.Tests OSD llsdOne = OSD.FromInteger(12319423); string sOne = OSDParser.SerializeLLSDNotation(llsdOne); OSD llsdOneDS = OSDParser.DeserializeLLSDNotation(sOne); - Assert.AreEqual(OSDType.Integer, llsdOneDS.Type); - Assert.AreEqual(12319423, llsdOne.AsInteger()); + ClassicAssert.AreEqual(OSDType.Integer, llsdOneDS.Type); + ClassicAssert.AreEqual(12319423, llsdOne.AsInteger()); OSD llsdTwo = OSD.FromInteger(-71892034); string sTwo = OSDParser.SerializeLLSDNotation(llsdTwo); OSD llsdTwoDS = OSDParser.DeserializeLLSDNotation(sTwo); - Assert.AreEqual(OSDType.Integer, llsdTwoDS.Type); - Assert.AreEqual(-71892034, llsdTwoDS.AsInteger()); + ClassicAssert.AreEqual(OSDType.Integer, llsdTwoDS.Type); + ClassicAssert.AreEqual(-71892034, llsdTwoDS.AsInteger()); } [Test()] @@ -201,28 +202,28 @@ namespace LibreMetaverse.Tests { string realOne = "r1123412345.465711"; OSD llsdOne = OSDParser.DeserializeLLSDNotation(realOne); - Assert.AreEqual(OSDType.Real, llsdOne.Type); - Assert.AreEqual(1123412345.465711d, llsdOne.AsReal()); + ClassicAssert.AreEqual(OSDType.Real, llsdOne.Type); + ClassicAssert.AreEqual(1123412345.465711d, llsdOne.AsReal()); string realTwo = "r-11234684.923411"; OSD llsdTwo = OSDParser.DeserializeLLSDNotation(realTwo); - Assert.AreEqual(OSDType.Real, llsdTwo.Type); - Assert.AreEqual(-11234684.923411d, llsdTwo.AsReal()); + ClassicAssert.AreEqual(OSDType.Real, llsdTwo.Type); + ClassicAssert.AreEqual(-11234684.923411d, llsdTwo.AsReal()); string realThree = "r1"; OSD llsdThree = OSDParser.DeserializeLLSDNotation(realThree); - Assert.AreEqual(OSDType.Real, llsdThree.Type); - Assert.AreEqual(1d, llsdThree.AsReal()); + ClassicAssert.AreEqual(OSDType.Real, llsdThree.Type); + ClassicAssert.AreEqual(1d, llsdThree.AsReal()); string realFour = "r2.0193899999999998204e-06"; OSD llsdFour = OSDParser.DeserializeLLSDNotation(realFour); - Assert.AreEqual(OSDType.Real, llsdFour.Type); - Assert.AreEqual(2.0193899999999998204e-06d, llsdFour.AsReal()); + ClassicAssert.AreEqual(OSDType.Real, llsdFour.Type); + ClassicAssert.AreEqual(2.0193899999999998204e-06d, llsdFour.AsReal()); string realFive = "r0"; OSD llsdFive = OSDParser.DeserializeLLSDNotation(realFive); - Assert.AreEqual(OSDType.Real, llsdFive.Type); - Assert.AreEqual(0d, llsdFive.AsReal()); + ClassicAssert.AreEqual(OSDType.Real, llsdFive.Type); + ClassicAssert.AreEqual(0d, llsdFive.AsReal()); } [Test()] @@ -231,38 +232,38 @@ namespace LibreMetaverse.Tests OSD llsdOne = OSD.FromReal(12987234.723847d); string sOne = OSDParser.SerializeLLSDNotation(llsdOne); OSD llsdOneDS = OSDParser.DeserializeLLSDNotation(sOne); - Assert.AreEqual(OSDType.Real, llsdOneDS.Type); - Assert.AreEqual(12987234.723847d, llsdOneDS.AsReal()); + ClassicAssert.AreEqual(OSDType.Real, llsdOneDS.Type); + ClassicAssert.AreEqual(12987234.723847d, llsdOneDS.AsReal()); OSD llsdTwo = OSD.FromReal(-32347892.234234d); string sTwo = OSDParser.SerializeLLSDNotation(llsdTwo); OSD llsdTwoDS = OSDParser.DeserializeLLSDNotation(sTwo); - Assert.AreEqual(OSDType.Real, llsdTwoDS.Type); - Assert.AreEqual(-32347892.234234d, llsdTwoDS.AsReal()); + ClassicAssert.AreEqual(OSDType.Real, llsdTwoDS.Type); + ClassicAssert.AreEqual(-32347892.234234d, llsdTwoDS.AsReal()); OSD llsdThree = OSD.FromReal( double.MaxValue ); string sThree = OSDParser.SerializeLLSDNotation( llsdThree ); OSD llsdThreeDS = OSDParser.DeserializeLLSDNotation( sThree ); - Assert.AreEqual( OSDType.Real, llsdThreeDS.Type ); - Assert.AreEqual( double.MaxValue, llsdThreeDS.AsReal()); + ClassicAssert.AreEqual( OSDType.Real, llsdThreeDS.Type ); + ClassicAssert.AreEqual( double.MaxValue, llsdThreeDS.AsReal()); OSD llsdFour = OSD.FromReal(double.MinValue); string sFour = OSDParser.SerializeLLSDNotation(llsdFour); OSD llsdFourDS = OSDParser.DeserializeLLSDNotation(sFour); - Assert.AreEqual(OSDType.Real, llsdFourDS.Type); - Assert.AreEqual(double.MinValue, llsdFourDS.AsReal()); + ClassicAssert.AreEqual(OSDType.Real, llsdFourDS.Type); + ClassicAssert.AreEqual(double.MinValue, llsdFourDS.AsReal()); OSD llsdFive = OSD.FromReal(-1.1123123E+50d); string sFive = OSDParser.SerializeLLSDNotation(llsdFive); OSD llsdFiveDS = OSDParser.DeserializeLLSDNotation(sFive); - Assert.AreEqual(OSDType.Real, llsdFiveDS.Type); - Assert.AreEqual(-1.1123123E+50d, llsdFiveDS.AsReal()); + ClassicAssert.AreEqual(OSDType.Real, llsdFiveDS.Type); + ClassicAssert.AreEqual(-1.1123123E+50d, llsdFiveDS.AsReal()); OSD llsdSix = OSD.FromReal(2.0193899999999998204e-06); string sSix = OSDParser.SerializeLLSDNotation(llsdSix); OSD llsdSixDS = OSDParser.DeserializeLLSDNotation(sSix); - Assert.AreEqual(OSDType.Real, llsdSixDS.Type); - Assert.AreEqual(2.0193899999999998204e-06, llsdSixDS.AsReal()); + ClassicAssert.AreEqual(OSDType.Real, llsdSixDS.Type); + ClassicAssert.AreEqual(2.0193899999999998204e-06, llsdSixDS.AsReal()); } [Test()] @@ -270,13 +271,13 @@ namespace LibreMetaverse.Tests { string uuidOne = "u97f4aeca-88a1-42a1-b385-b97b18abb255"; OSD llsdOne = OSDParser.DeserializeLLSDNotation(uuidOne); - Assert.AreEqual(OSDType.UUID, llsdOne.Type); - Assert.AreEqual("97f4aeca-88a1-42a1-b385-b97b18abb255", llsdOne.AsString()); + ClassicAssert.AreEqual(OSDType.UUID, llsdOne.Type); + ClassicAssert.AreEqual("97f4aeca-88a1-42a1-b385-b97b18abb255", llsdOne.AsString()); string uuidTwo = "u00000000-0000-0000-0000-000000000000"; OSD llsdTwo = OSDParser.DeserializeLLSDNotation(uuidTwo); - Assert.AreEqual(OSDType.UUID, llsdTwo.Type); - Assert.AreEqual("00000000-0000-0000-0000-000000000000", llsdTwo.AsString()); + ClassicAssert.AreEqual(OSDType.UUID, llsdTwo.Type); + ClassicAssert.AreEqual("00000000-0000-0000-0000-000000000000", llsdTwo.AsString()); } [Test()] @@ -285,28 +286,28 @@ namespace LibreMetaverse.Tests OSD llsdOne = OSD.FromUUID(new UUID("97f4aeca-88a1-42a1-b385-b97b18abb255")); string sOne = OSDParser.SerializeLLSDNotation(llsdOne); OSD llsdOneDS = OSDParser.DeserializeLLSDNotation(sOne); - Assert.AreEqual(OSDType.UUID, llsdOneDS.Type); - Assert.AreEqual("97f4aeca-88a1-42a1-b385-b97b18abb255", llsdOneDS.AsString()); + ClassicAssert.AreEqual(OSDType.UUID, llsdOneDS.Type); + ClassicAssert.AreEqual("97f4aeca-88a1-42a1-b385-b97b18abb255", llsdOneDS.AsString()); OSD llsdTwo = OSD.FromUUID(new UUID("00000000-0000-0000-0000-000000000000")); string sTwo = OSDParser.SerializeLLSDNotation(llsdTwo); OSD llsdTwoDS = OSDParser.DeserializeLLSDNotation(sTwo); - Assert.AreEqual(OSDType.UUID, llsdTwoDS.Type); - Assert.AreEqual("00000000-0000-0000-0000-000000000000", llsdTwoDS.AsString()); + ClassicAssert.AreEqual(OSDType.UUID, llsdTwoDS.Type); + ClassicAssert.AreEqual("00000000-0000-0000-0000-000000000000", llsdTwoDS.AsString()); } public void DeserializeString() { string sOne = "''"; OSD llsdOne = OSDParser.DeserializeLLSDNotation(sOne); - Assert.AreEqual(OSDType.String, llsdOne.Type); - Assert.AreEqual("", llsdOne.AsString()); + ClassicAssert.AreEqual(OSDType.String, llsdOne.Type); + ClassicAssert.AreEqual("", llsdOne.AsString()); // This is double escaping. Once for the encoding, and once for csharp. string sTwo = "'test\\'\"test'"; OSD llsdTwo = OSDParser.DeserializeLLSDNotation(sTwo); - Assert.AreEqual(OSDType.String, llsdTwo.Type); - Assert.AreEqual("test'\"test", llsdTwo.AsString()); + ClassicAssert.AreEqual(OSDType.String, llsdTwo.Type); + ClassicAssert.AreEqual("test'\"test", llsdTwo.AsString()); // "test \\lest" char[] cThree = { (char)0x27, (char)0x74, (char)0x65, (char)0x73, (char)0x74, (char)0x20, (char)0x5c, @@ -314,35 +315,35 @@ namespace LibreMetaverse.Tests string sThree = new string(cThree); OSD llsdThree = OSDParser.DeserializeLLSDNotation(sThree); - Assert.AreEqual(OSDType.String, llsdThree.Type); - Assert.AreEqual("test \\lest", llsdThree.AsString()); + ClassicAssert.AreEqual(OSDType.String, llsdThree.Type); + ClassicAssert.AreEqual("test \\lest", llsdThree.AsString()); string sFour = "'aa\t la'"; OSD llsdFour = OSDParser.DeserializeLLSDNotation(sFour); - Assert.AreEqual(OSDType.String, llsdFour.Type); - Assert.AreEqual("aa\t la", llsdFour.AsString()); + ClassicAssert.AreEqual(OSDType.String, llsdFour.Type); + ClassicAssert.AreEqual("aa\t la", llsdFour.AsString()); char[] cFive = { (char)0x27, (char)0x5c, (char)0x5c, (char)0x27 }; string sFive = new string(cFive); OSD llsdFive = OSDParser.DeserializeLLSDNotation(sFive); - Assert.AreEqual(OSDType.String, llsdFive.Type); - Assert.AreEqual("\\", llsdFive.AsString()); + ClassicAssert.AreEqual(OSDType.String, llsdFive.Type); + ClassicAssert.AreEqual("\\", llsdFive.AsString()); string sSix = "s(10)\"1234567890\""; OSD llsdSix = OSDParser.DeserializeLLSDNotation(sSix); - Assert.AreEqual(OSDType.String, llsdSix.Type); - Assert.AreEqual("1234567890", llsdSix.AsString()); + ClassicAssert.AreEqual(OSDType.String, llsdSix.Type); + ClassicAssert.AreEqual("1234567890", llsdSix.AsString()); string sSeven = "s(5)\"\\\\\\\\\\\""; OSD llsdSeven = OSDParser.DeserializeLLSDNotation(sSeven); - Assert.AreEqual(OSDType.String, llsdSeven.Type); - Assert.AreEqual(@"\\\\\", llsdSeven.AsString()); + ClassicAssert.AreEqual(OSDType.String, llsdSeven.Type); + ClassicAssert.AreEqual(@"\\\\\", llsdSeven.AsString()); string sEight = "\"aouAOUhsdjklfghskldjfghqeiurtzwieortzaslxfjkgh\""; OSD llsdEight = OSDParser.DeserializeLLSDNotation(sEight); - Assert.AreEqual(OSDType.String, llsdEight.Type); - Assert.AreEqual("aouAOUhsdjklfghskldjfghqeiurtzwieortzaslxfjkgh", llsdEight.AsString()); + ClassicAssert.AreEqual(OSDType.String, llsdEight.Type); + ClassicAssert.AreEqual("aouAOUhsdjklfghskldjfghqeiurtzwieortzaslxfjkgh", llsdEight.AsString()); @@ -353,8 +354,8 @@ namespace LibreMetaverse.Tests OSD llsdOne = OSD.FromString(s); string sOne = OSDParser.SerializeLLSDNotation(llsdOne); OSD llsdOneDS = OSDParser.DeserializeLLSDNotation(sOne); - Assert.AreEqual(OSDType.String, llsdOne.Type); - Assert.AreEqual(s, llsdOneDS.AsString()); + ClassicAssert.AreEqual(OSDType.String, llsdOne.Type); + ClassicAssert.AreEqual(s, llsdOneDS.AsString()); } @@ -397,13 +398,13 @@ namespace LibreMetaverse.Tests { string sUriOne = "l\"http://test.com/test test>\\\"/&yes\""; OSD llsdOne = OSDParser.DeserializeLLSDNotation(sUriOne); - Assert.AreEqual(OSDType.URI, llsdOne.Type); - Assert.AreEqual("http://test.com/test%20test%3E%22/&yes", llsdOne.AsString()); + ClassicAssert.AreEqual(OSDType.URI, llsdOne.Type); + ClassicAssert.AreEqual("http://test.com/test%20test%3E%22/&yes", llsdOne.AsString()); string sUriTwo = "l\"test/test/test?test=1&toast=2\""; OSD llsdTwo = OSDParser.DeserializeLLSDNotation(sUriTwo); - Assert.AreEqual(OSDType.URI, llsdTwo.Type); - Assert.AreEqual("test/test/test?test=1&toast=2", llsdTwo.AsString()); + ClassicAssert.AreEqual(OSDType.URI, llsdTwo.Type); + ClassicAssert.AreEqual("test/test/test?test=1&toast=2", llsdTwo.AsString()); } [Test()] @@ -413,15 +414,15 @@ namespace LibreMetaverse.Tests OSD llsdOne = OSD.FromUri(uriOne); string sUriOne = OSDParser.SerializeLLSDNotation(llsdOne); OSD llsdOneDS = OSDParser.DeserializeLLSDNotation(sUriOne); - Assert.AreEqual(OSDType.URI, llsdOneDS.Type); - Assert.AreEqual(uriOne, llsdOneDS.AsUri()); + ClassicAssert.AreEqual(OSDType.URI, llsdOneDS.Type); + ClassicAssert.AreEqual(uriOne, llsdOneDS.AsUri()); Uri uriTwo = new Uri("test/test/near/the/end?test=1", UriKind.RelativeOrAbsolute); OSD llsdTwo = OSD.FromUri(uriTwo); string sUriTwo = OSDParser.SerializeLLSDNotation(llsdTwo); OSD llsdTwoDS = OSDParser.DeserializeLLSDNotation(sUriTwo); - Assert.AreEqual(OSDType.URI, llsdTwoDS.Type); - Assert.AreEqual(uriTwo, llsdTwoDS.AsUri()); + ClassicAssert.AreEqual(OSDType.URI, llsdTwoDS.Type); + ClassicAssert.AreEqual(uriTwo, llsdTwoDS.AsUri()); } [Test()] @@ -429,10 +430,10 @@ namespace LibreMetaverse.Tests { string sDateOne = "d\"2007-12-31T20:49:10Z\""; OSD llsdOne = OSDParser.DeserializeLLSDNotation(sDateOne); - Assert.AreEqual(OSDType.Date, llsdOne.Type); + ClassicAssert.AreEqual(OSDType.Date, llsdOne.Type); DateTime dt = new DateTime(2007, 12, 31, 20, 49, 10, 0, DateTimeKind.Utc); DateTime dtDS = llsdOne.AsDate(); - Assert.AreEqual(dt, dtDS.ToUniversalTime()); + ClassicAssert.AreEqual(dt, dtDS.ToUniversalTime()); } [Test()] @@ -442,25 +443,25 @@ namespace LibreMetaverse.Tests OSD llsdOne = OSD.FromDate(dtOne); string sDtOne = OSDParser.SerializeLLSDNotation(llsdOne); OSD llsdOneDS = OSDParser.DeserializeLLSDNotation(sDtOne); - Assert.AreEqual(OSDType.Date, llsdOneDS.Type); + ClassicAssert.AreEqual(OSDType.Date, llsdOneDS.Type); DateTime dtOneDS = llsdOneDS.AsDate(); - Assert.AreEqual(dtOne, dtOneDS.ToUniversalTime()); + ClassicAssert.AreEqual(dtOne, dtOneDS.ToUniversalTime()); DateTime dtTwo = new DateTime(2010, 10, 11, 23, 00, 10, 100, DateTimeKind.Utc); OSD llsdTwo = OSD.FromDate(dtTwo); string sDtTwo = OSDParser.SerializeLLSDNotation(llsdTwo); OSD llsdTwoDS = OSDParser.DeserializeLLSDNotation(sDtTwo); - Assert.AreEqual(OSDType.Date, llsdTwoDS.Type); + ClassicAssert.AreEqual(OSDType.Date, llsdTwoDS.Type); DateTime dtTwoDS = llsdTwoDS.AsDate(); - Assert.AreEqual(dtTwo, dtTwoDS.ToUniversalTime()); + ClassicAssert.AreEqual(dtTwo, dtTwoDS.ToUniversalTime()); // check if a *local* time can be serialized and deserialized DateTime dtThree = new DateTime(2009, 12, 30, 8, 25, 10, DateTimeKind.Local); OSD llsdDateThree = OSD.FromDate(dtThree); string sDateThreeSerialized = OSDParser.SerializeLLSDNotation(llsdDateThree); OSD llsdDateThreeDS = OSDParser.DeserializeLLSDNotation(sDateThreeSerialized); - Assert.AreEqual(OSDType.Date, llsdDateThreeDS.Type); - Assert.AreEqual(dtThree, llsdDateThreeDS.AsDate()); + ClassicAssert.AreEqual(OSDType.Date, llsdDateThreeDS.Type); + ClassicAssert.AreEqual(dtThree, llsdDateThreeDS.AsDate()); } [Test()] @@ -472,8 +473,8 @@ namespace LibreMetaverse.Tests OSD llsdBinary = OSD.FromBinary(binary); string sBinarySerialized = OSDParser.SerializeLLSDNotation(llsdBinary); OSD llsdBinaryDS = OSDParser.DeserializeLLSDNotation(sBinarySerialized); - Assert.AreEqual(OSDType.Binary, llsdBinaryDS.Type); - Assert.AreEqual(binary, llsdBinaryDS.AsBinary()); + ClassicAssert.AreEqual(OSDType.Binary, llsdBinaryDS.Type); + ClassicAssert.AreEqual(binary, llsdBinaryDS.AsBinary()); } [Test()] @@ -481,41 +482,41 @@ namespace LibreMetaverse.Tests { string sArrayOne = "[]"; OSDArray llsdArrayOne = (OSDArray)OSDParser.DeserializeLLSDNotation(sArrayOne); - Assert.AreEqual(OSDType.Array, llsdArrayOne.Type); - Assert.AreEqual(0, llsdArrayOne.Count); + ClassicAssert.AreEqual(OSDType.Array, llsdArrayOne.Type); + ClassicAssert.AreEqual(0, llsdArrayOne.Count); string sArrayTwo = "[ i0 ]"; OSDArray llsdArrayTwo = (OSDArray)OSDParser.DeserializeLLSDNotation(sArrayTwo); - Assert.AreEqual(OSDType.Array, llsdArrayTwo.Type); - Assert.AreEqual(1, llsdArrayTwo.Count); + ClassicAssert.AreEqual(OSDType.Array, llsdArrayTwo.Type); + ClassicAssert.AreEqual(1, llsdArrayTwo.Count); OSDInteger llsdIntOne = (OSDInteger)llsdArrayTwo[0]; - Assert.AreEqual(OSDType.Integer, llsdIntOne.Type); - Assert.AreEqual(0, llsdIntOne.AsInteger()); + ClassicAssert.AreEqual(OSDType.Integer, llsdIntOne.Type); + ClassicAssert.AreEqual(0, llsdIntOne.AsInteger()); string sArrayThree = "[ i0, i1 ]"; OSDArray llsdArrayThree = (OSDArray)OSDParser.DeserializeLLSDNotation(sArrayThree); - Assert.AreEqual(OSDType.Array, llsdArrayThree.Type); - Assert.AreEqual(2, llsdArrayThree.Count); + ClassicAssert.AreEqual(OSDType.Array, llsdArrayThree.Type); + ClassicAssert.AreEqual(2, llsdArrayThree.Count); OSDInteger llsdIntTwo = (OSDInteger)llsdArrayThree[0]; - Assert.AreEqual(OSDType.Integer, llsdIntTwo.Type); - Assert.AreEqual(0, llsdIntTwo.AsInteger()); + ClassicAssert.AreEqual(OSDType.Integer, llsdIntTwo.Type); + ClassicAssert.AreEqual(0, llsdIntTwo.AsInteger()); OSDInteger llsdIntThree = (OSDInteger)llsdArrayThree[1]; - Assert.AreEqual(OSDType.Integer, llsdIntThree.Type); - Assert.AreEqual(1, llsdIntThree.AsInteger()); + ClassicAssert.AreEqual(OSDType.Integer, llsdIntThree.Type); + ClassicAssert.AreEqual(1, llsdIntThree.AsInteger()); string sArrayFour = " [ \"testtest\", \"aha\",t,f,i1, r1.2, [ i1] ] "; OSDArray llsdArrayFour = (OSDArray)OSDParser.DeserializeLLSDNotation(sArrayFour); - Assert.AreEqual(OSDType.Array, llsdArrayFour.Type); - Assert.AreEqual(7, llsdArrayFour.Count); - Assert.AreEqual("testtest", llsdArrayFour[0].AsString()); - Assert.AreEqual("aha", llsdArrayFour[1].AsString()); - Assert.AreEqual(true, llsdArrayFour[2].AsBoolean()); - Assert.AreEqual(false, llsdArrayFour[3].AsBoolean()); - Assert.AreEqual(1, llsdArrayFour[4].AsInteger()); - Assert.AreEqual(1.2d, llsdArrayFour[5].AsReal()); - Assert.AreEqual(OSDType.Array, llsdArrayFour[6].Type); + ClassicAssert.AreEqual(OSDType.Array, llsdArrayFour.Type); + ClassicAssert.AreEqual(7, llsdArrayFour.Count); + ClassicAssert.AreEqual("testtest", llsdArrayFour[0].AsString()); + ClassicAssert.AreEqual("aha", llsdArrayFour[1].AsString()); + ClassicAssert.AreEqual(true, llsdArrayFour[2].AsBoolean()); + ClassicAssert.AreEqual(false, llsdArrayFour[3].AsBoolean()); + ClassicAssert.AreEqual(1, llsdArrayFour[4].AsInteger()); + ClassicAssert.AreEqual(1.2d, llsdArrayFour[5].AsReal()); + ClassicAssert.AreEqual(OSDType.Array, llsdArrayFour[6].Type); OSDArray llsdArrayFive = (OSDArray)llsdArrayFour[6]; - Assert.AreEqual(1, llsdArrayFive[0].AsInteger()); + ClassicAssert.AreEqual(1, llsdArrayFive[0].AsInteger()); } @@ -525,8 +526,8 @@ namespace LibreMetaverse.Tests OSDArray llsdOne = new OSDArray(); string sOne = OSDParser.SerializeLLSDNotation(llsdOne); OSDArray llsdOneDS = (OSDArray)OSDParser.DeserializeLLSDNotation(sOne); - Assert.AreEqual(OSDType.Array, llsdOneDS.Type); - Assert.AreEqual(0, llsdOneDS.Count); + ClassicAssert.AreEqual(OSDType.Array, llsdOneDS.Type); + ClassicAssert.AreEqual(0, llsdOneDS.Count); OSD llsdTwo = OSD.FromInteger(123234); OSD llsdThree = OSD.FromString("asedkfjhaqweiurohzasdf"); @@ -540,20 +541,20 @@ namespace LibreMetaverse.Tests string sFive = OSDParser.SerializeLLSDNotation(llsdOne); OSDArray llsdFive = (OSDArray)OSDParser.DeserializeLLSDNotation(sFive); - Assert.AreEqual(OSDType.Array, llsdFive.Type); - Assert.AreEqual(3, llsdFive.Count); - Assert.AreEqual(OSDType.Integer, llsdFive[0].Type); - Assert.AreEqual(123234, llsdFive[0].AsInteger()); - Assert.AreEqual(OSDType.String, llsdFive[1].Type); - Assert.AreEqual("asedkfjhaqweiurohzasdf", llsdFive[1].AsString()); + ClassicAssert.AreEqual(OSDType.Array, llsdFive.Type); + ClassicAssert.AreEqual(3, llsdFive.Count); + ClassicAssert.AreEqual(OSDType.Integer, llsdFive[0].Type); + ClassicAssert.AreEqual(123234, llsdFive[0].AsInteger()); + ClassicAssert.AreEqual(OSDType.String, llsdFive[1].Type); + ClassicAssert.AreEqual("asedkfjhaqweiurohzasdf", llsdFive[1].AsString()); OSDArray llsdSix = (OSDArray)llsdFive[2]; - Assert.AreEqual(OSDType.Array, llsdSix.Type); - Assert.AreEqual(2, llsdSix.Count); - Assert.AreEqual(OSDType.Integer, llsdSix[0].Type); - Assert.AreEqual(123234, llsdSix[0].AsInteger()); - Assert.AreEqual(OSDType.String, llsdSix[1].Type); - Assert.AreEqual("asedkfjhaqweiurohzasdf", llsdSix[1].AsString()); + ClassicAssert.AreEqual(OSDType.Array, llsdSix.Type); + ClassicAssert.AreEqual(2, llsdSix.Count); + ClassicAssert.AreEqual(OSDType.Integer, llsdSix[0].Type); + ClassicAssert.AreEqual(123234, llsdSix[0].AsInteger()); + ClassicAssert.AreEqual(OSDType.String, llsdSix[1].Type); + ClassicAssert.AreEqual("asedkfjhaqweiurohzasdf", llsdSix[1].AsString()); } [Test()] @@ -561,39 +562,39 @@ namespace LibreMetaverse.Tests { string sMapOne = " { } "; OSDMap llsdMapOne = (OSDMap)OSDParser.DeserializeLLSDNotation(sMapOne); - Assert.AreEqual(OSDType.Map, llsdMapOne.Type); - Assert.AreEqual(0, llsdMapOne.Count); + ClassicAssert.AreEqual(OSDType.Map, llsdMapOne.Type); + ClassicAssert.AreEqual(0, llsdMapOne.Count); string sMapTwo = " { \"test\":i2 } "; OSDMap llsdMapTwo = (OSDMap)OSDParser.DeserializeLLSDNotation(sMapTwo); - Assert.AreEqual(OSDType.Map, llsdMapTwo.Type); - Assert.AreEqual(1, llsdMapTwo.Count); - Assert.AreEqual(OSDType.Integer, llsdMapTwo["test"].Type); - Assert.AreEqual(2, llsdMapTwo["test"].AsInteger()); + ClassicAssert.AreEqual(OSDType.Map, llsdMapTwo.Type); + ClassicAssert.AreEqual(1, llsdMapTwo.Count); + ClassicAssert.AreEqual(OSDType.Integer, llsdMapTwo["test"].Type); + ClassicAssert.AreEqual(2, llsdMapTwo["test"].AsInteger()); string sMapThree = " { 'test':\"testtesttest\", 'aha':\"muahahaha\" , \"anywhere\":! } "; OSDMap llsdMapThree = (OSDMap)OSDParser.DeserializeLLSDNotation(sMapThree); - Assert.AreEqual(OSDType.Map, llsdMapThree.Type); - Assert.AreEqual(3, llsdMapThree.Count); - Assert.AreEqual(OSDType.String, llsdMapThree["test"].Type); - Assert.AreEqual("testtesttest", llsdMapThree["test"].AsString()); - Assert.AreEqual(OSDType.String, llsdMapThree["test"].Type); - Assert.AreEqual("muahahaha", llsdMapThree["aha"].AsString()); - Assert.AreEqual(OSDType.Unknown, llsdMapThree["self"].Type); + ClassicAssert.AreEqual(OSDType.Map, llsdMapThree.Type); + ClassicAssert.AreEqual(3, llsdMapThree.Count); + ClassicAssert.AreEqual(OSDType.String, llsdMapThree["test"].Type); + ClassicAssert.AreEqual("testtesttest", llsdMapThree["test"].AsString()); + ClassicAssert.AreEqual(OSDType.String, llsdMapThree["test"].Type); + ClassicAssert.AreEqual("muahahaha", llsdMapThree["aha"].AsString()); + ClassicAssert.AreEqual(OSDType.Unknown, llsdMapThree["self"].Type); string sMapFour = " { 'test' : { 'test' : i1, 't0st' : r2.5 }, 'tist' : \"hello world!\", 'tast' : \"last\" } "; OSDMap llsdMapFour = (OSDMap)OSDParser.DeserializeLLSDNotation(sMapFour); - Assert.AreEqual(OSDType.Map, llsdMapFour.Type); - Assert.AreEqual(3, llsdMapFour.Count); - Assert.AreEqual("hello world!", llsdMapFour["tist"].AsString()); - Assert.AreEqual("last", llsdMapFour["tast"].AsString()); + ClassicAssert.AreEqual(OSDType.Map, llsdMapFour.Type); + ClassicAssert.AreEqual(3, llsdMapFour.Count); + ClassicAssert.AreEqual("hello world!", llsdMapFour["tist"].AsString()); + ClassicAssert.AreEqual("last", llsdMapFour["tast"].AsString()); OSDMap llsdMapFive = (OSDMap)llsdMapFour["test"]; - Assert.AreEqual(OSDType.Map, llsdMapFive.Type); - Assert.AreEqual(2, llsdMapFive.Count); - Assert.AreEqual(OSDType.Integer, llsdMapFive["test"].Type); - Assert.AreEqual(1, llsdMapFive["test"].AsInteger()); - Assert.AreEqual(OSDType.Real, llsdMapFive["t0st"].Type); - Assert.AreEqual(2.5d, llsdMapFive["t0st"].AsReal()); + ClassicAssert.AreEqual(OSDType.Map, llsdMapFive.Type); + ClassicAssert.AreEqual(2, llsdMapFive.Count); + ClassicAssert.AreEqual(OSDType.Integer, llsdMapFive["test"].Type); + ClassicAssert.AreEqual(1, llsdMapFive["test"].AsInteger()); + ClassicAssert.AreEqual(OSDType.Real, llsdMapFive["t0st"].Type); + ClassicAssert.AreEqual(2.5d, llsdMapFive["t0st"].AsReal()); } @@ -603,8 +604,8 @@ namespace LibreMetaverse.Tests OSDMap llsdOne = new OSDMap(); string sOne = OSDParser.SerializeLLSDNotation(llsdOne); OSDMap llsdOneDS = (OSDMap)OSDParser.DeserializeLLSDNotation(sOne); - Assert.AreEqual(OSDType.Map, llsdOneDS.Type); - Assert.AreEqual(0, llsdOneDS.Count); + ClassicAssert.AreEqual(OSDType.Map, llsdOneDS.Type); + ClassicAssert.AreEqual(0, llsdOneDS.Count); OSD llsdTwo = OSD.FromInteger(123234); OSD llsdThree = OSD.FromString("asedkfjhaqweiurohzasdf"); @@ -618,20 +619,20 @@ namespace LibreMetaverse.Tests string sFive = OSDParser.SerializeLLSDNotation(llsdOne); OSDMap llsdFive = (OSDMap)OSDParser.DeserializeLLSDNotation(sFive); - Assert.AreEqual(OSDType.Map, llsdFive.Type); - Assert.AreEqual(3, llsdFive.Count); - Assert.AreEqual(OSDType.Integer, llsdFive["test0"].Type); - Assert.AreEqual(123234, llsdFive["test0"].AsInteger()); - Assert.AreEqual(OSDType.String, llsdFive["test1"].Type); - Assert.AreEqual("asedkfjhaqweiurohzasdf", llsdFive["test1"].AsString()); + ClassicAssert.AreEqual(OSDType.Map, llsdFive.Type); + ClassicAssert.AreEqual(3, llsdFive.Count); + ClassicAssert.AreEqual(OSDType.Integer, llsdFive["test0"].Type); + ClassicAssert.AreEqual(123234, llsdFive["test0"].AsInteger()); + ClassicAssert.AreEqual(OSDType.String, llsdFive["test1"].Type); + ClassicAssert.AreEqual("asedkfjhaqweiurohzasdf", llsdFive["test1"].AsString()); OSDMap llsdSix = (OSDMap)llsdFive["test2"]; - Assert.AreEqual(OSDType.Map, llsdSix.Type); - Assert.AreEqual(2, llsdSix.Count); - Assert.AreEqual(OSDType.Integer, llsdSix["test0"].Type); - Assert.AreEqual(123234, llsdSix["test0"].AsInteger()); - Assert.AreEqual(OSDType.String, llsdSix["test1"].Type); - Assert.AreEqual("asedkfjhaqweiurohzasdf", llsdSix["test1"].AsString()); + ClassicAssert.AreEqual(OSDType.Map, llsdSix.Type); + ClassicAssert.AreEqual(2, llsdSix.Count); + ClassicAssert.AreEqual(OSDType.Integer, llsdSix["test0"].Type); + ClassicAssert.AreEqual(123234, llsdSix["test0"].AsInteger()); + ClassicAssert.AreEqual(OSDType.String, llsdSix["test1"].Type); + ClassicAssert.AreEqual("asedkfjhaqweiurohzasdf", llsdSix["test1"].AsString()); // We test here also for 4byte characters as map keys string xml = "𐄷"; @@ -645,9 +646,9 @@ namespace LibreMetaverse.Tests llsdSeven[content] = OSD.FromString(content); string sSeven = OSDParser.SerializeLLSDNotation(llsdSeven); OSDMap llsdSevenDS = (OSDMap)OSDParser.DeserializeLLSDNotation(sSeven); - Assert.AreEqual(OSDType.Map, llsdSevenDS.Type); - Assert.AreEqual(1, llsdSevenDS.Count); - Assert.AreEqual(content, llsdSevenDS[content].AsString()); + ClassicAssert.AreEqual(OSDType.Map, llsdSevenDS.Type); + ClassicAssert.AreEqual(1, llsdSevenDS.Count); + ClassicAssert.AreEqual(content, llsdSevenDS[content].AsString()); } [Test()] @@ -684,23 +685,23 @@ namespace LibreMetaverse.Tests // We dont do full testing here. We are fine if a few values are right // and the parser doesnt throw an exception OSDArray llsdArray = (OSDArray)OSDParser.DeserializeLLSDNotation(realWorldExample); - Assert.AreEqual(OSDType.Array, llsdArray.Type); - Assert.AreEqual(3, llsdArray.Count); + ClassicAssert.AreEqual(OSDType.Array, llsdArray.Type); + ClassicAssert.AreEqual(3, llsdArray.Count); OSDMap llsdMapOne = (OSDMap)llsdArray[0]; - Assert.AreEqual(OSDType.Map, llsdMapOne.Type); - Assert.AreEqual("http://secondlife.com", llsdMapOne["destination"].AsString()); + ClassicAssert.AreEqual(OSDType.Map, llsdMapOne.Type); + ClassicAssert.AreEqual("http://secondlife.com", llsdMapOne["destination"].AsString()); OSDMap llsdMapTwo = (OSDMap)llsdArray[1]; - Assert.AreEqual(OSDType.Map, llsdMapTwo.Type); - Assert.AreEqual(OSDType.Integer, llsdMapTwo["version"].Type); - Assert.AreEqual(1, llsdMapTwo["version"].AsInteger()); + ClassicAssert.AreEqual(OSDType.Map, llsdMapTwo.Type); + ClassicAssert.AreEqual(OSDType.Integer, llsdMapTwo["version"].Type); + ClassicAssert.AreEqual(1, llsdMapTwo["version"].AsInteger()); OSDMap llsdMapThree = (OSDMap)llsdArray[2]; - Assert.AreEqual(OSDType.UUID, llsdMapThree["session_id"].Type); - Assert.AreEqual("2c585cec-038c-40b0-b42e-a25ebab4d132", llsdMapThree["session_id"].AsString()); - Assert.AreEqual(OSDType.UUID, llsdMapThree["agent_id"].Type); - Assert.AreEqual("3c115e51-04f4-523c-9fa6-98aff1034730", llsdMapThree["agent_id"].AsString()); + ClassicAssert.AreEqual(OSDType.UUID, llsdMapThree["session_id"].Type); + ClassicAssert.AreEqual("2c585cec-038c-40b0-b42e-a25ebab4d132", llsdMapThree["session_id"].AsString()); + ClassicAssert.AreEqual(OSDType.UUID, llsdMapThree["agent_id"].Type); + ClassicAssert.AreEqual("3c115e51-04f4-523c-9fa6-98aff1034730", llsdMapThree["agent_id"].AsString()); } @@ -734,14 +735,14 @@ namespace LibreMetaverse.Tests // we also try to parse this... and look a little at the results OSDArray llsdSeven = (OSDArray)OSDParser.DeserializeLLSDNotation(sThree); - Assert.AreEqual(OSDType.Array, llsdSeven.Type); - Assert.AreEqual(3, llsdSeven.Count); - Assert.AreEqual(OSDType.Integer, llsdSeven[0].Type); - Assert.AreEqual(1, llsdSeven[0].AsInteger()); - Assert.AreEqual(OSDType.Integer, llsdSeven[1].Type); - Assert.AreEqual(1, llsdSeven[1].AsInteger()); + ClassicAssert.AreEqual(OSDType.Array, llsdSeven.Type); + ClassicAssert.AreEqual(3, llsdSeven.Count); + ClassicAssert.AreEqual(OSDType.Integer, llsdSeven[0].Type); + ClassicAssert.AreEqual(1, llsdSeven[0].AsInteger()); + ClassicAssert.AreEqual(OSDType.Integer, llsdSeven[1].Type); + ClassicAssert.AreEqual(1, llsdSeven[1].AsInteger()); - Assert.AreEqual(OSDType.Map, llsdSeven[2].Type); + ClassicAssert.AreEqual(OSDType.Map, llsdSeven[2].Type); // thats enough for now. } } diff --git a/LibreMetaverse.Tests/PacketTests.cs b/LibreMetaverse.Tests/PacketTests.cs index 5ad42aff..f64b2524 100644 --- a/LibreMetaverse.Tests/PacketTests.cs +++ b/LibreMetaverse.Tests/PacketTests.cs @@ -1,6 +1,6 @@ /* * Copyright (c) 2006-2016, openmetaverse.co - * Copyright (c) 2021-2022, Sjofn LLC. + * Copyright (c) 2021-2024, Sjofn LLC. * All rights reserved. * * - Redistribution and use in source and binary forms, with or without @@ -45,50 +45,50 @@ namespace LibreMetaverse.Tests packet.Header.Resent = false; packet.Header.Zerocoded = false; - Assert.IsFalse(packet.Header.AppendedAcks, "AppendedAcks: Failed to initially set the flag to false"); - Assert.IsFalse(packet.Header.Reliable, "Reliable: Failed to initially set the flag to false"); - Assert.IsFalse(packet.Header.Resent, "Resent: Failed to initially set the flag to false"); - Assert.IsFalse(packet.Header.Zerocoded, "Zerocoded: Failed to initially set the flag to false"); + Assert.That(packet.Header.AppendedAcks, Is.False, "AppendedAcks: Failed to initially set the flag to false"); + Assert.That(packet.Header.Reliable, Is.False, "Reliable: Failed to initially set the flag to false"); + Assert.That(packet.Header.Resent, Is.False, "Resent: Failed to initially set the flag to false"); + Assert.That(packet.Header.Zerocoded, Is.False, "Zerocoded: Failed to initially set the flag to false"); packet.Header.AppendedAcks = false; packet.Header.Reliable = false; packet.Header.Resent = false; packet.Header.Zerocoded = false; - Assert.IsFalse(packet.Header.AppendedAcks, "AppendedAcks: Failed to set the flag to false a second time"); - Assert.IsFalse(packet.Header.Reliable, "Reliable: Failed to set the flag to false a second time"); - Assert.IsFalse(packet.Header.Resent, "Resent: Failed to set the flag to false a second time"); - Assert.IsFalse(packet.Header.Zerocoded, "Zerocoded: Failed to set the flag to false a second time"); + Assert.That(packet.Header.AppendedAcks, Is.False, "AppendedAcks: Failed to set the flag to false a second time"); + Assert.That(packet.Header.Reliable, Is.False, "Reliable: Failed to set the flag to false a second time"); + Assert.That(packet.Header.Resent, Is.False, "Resent: Failed to set the flag to false a second time"); + Assert.That(packet.Header.Zerocoded, Is.False, "Zerocoded: Failed to set the flag to false a second time"); packet.Header.AppendedAcks = true; packet.Header.Reliable = true; packet.Header.Resent = true; packet.Header.Zerocoded = true; - Assert.IsTrue(packet.Header.AppendedAcks, "AppendedAcks: Failed to set the flag to true"); - Assert.IsTrue(packet.Header.Reliable, "Reliable: Failed to set the flag to true"); - Assert.IsTrue(packet.Header.Resent, "Resent: Failed to set the flag to true"); - Assert.IsTrue(packet.Header.Zerocoded, "Zerocoded: Failed to set the flag to true"); + Assert.That(packet.Header.AppendedAcks, Is.True, "AppendedAcks: Failed to set the flag to true"); + Assert.That(packet.Header.Reliable, Is.True, "Reliable: Failed to set the flag to true"); + Assert.That(packet.Header.Resent, Is.True, "Resent: Failed to set the flag to true"); + Assert.That(packet.Header.Zerocoded, Is.True, "Zerocoded: Failed to set the flag to true"); packet.Header.AppendedAcks = true; packet.Header.Reliable = true; packet.Header.Resent = true; packet.Header.Zerocoded = true; - Assert.IsTrue(packet.Header.AppendedAcks, "AppendedAcks: Failed to set the flag to true a second time"); - Assert.IsTrue(packet.Header.Reliable, "Reliable: Failed to set the flag to true a second time"); - Assert.IsTrue(packet.Header.Resent, "Resent: Failed to set the flag to true a second time"); - Assert.IsTrue(packet.Header.Zerocoded, "Zerocoded: Failed to set the flag to true a second time"); + Assert.That(packet.Header.AppendedAcks, Is.True, "AppendedAcks: Failed to set the flag to true a second time"); + Assert.That(packet.Header.Reliable, Is.True, "Reliable: Failed to set the flag to true a second time"); + Assert.That(packet.Header.Resent, Is.True, "Resent: Failed to set the flag to true a second time"); + Assert.That(packet.Header.Zerocoded, Is.True, "Zerocoded: Failed to set the flag to true a second time"); packet.Header.AppendedAcks = false; packet.Header.Reliable = false; packet.Header.Resent = false; packet.Header.Zerocoded = false; - Assert.IsFalse(packet.Header.AppendedAcks, "AppendedAcks: Failed to set the flag back to false"); - Assert.IsFalse(packet.Header.Reliable, "Reliable: Failed to set the flag back to false"); - Assert.IsFalse(packet.Header.Resent, "Resent: Failed to set the flag back to false"); - Assert.IsFalse(packet.Header.Zerocoded, "Zerocoded: Failed to set the flag back to false"); + Assert.That(packet.Header.AppendedAcks, Is.False, "AppendedAcks: Failed to set the flag back to false"); + Assert.That(packet.Header.Reliable, Is.False, "Reliable: Failed to set the flag back to false"); + Assert.That(packet.Header.Resent, Is.False, "Resent: Failed to set the flag back to false"); + Assert.That(packet.Header.Zerocoded, Is.False, "Zerocoded: Failed to set the flag back to false"); } [Test] @@ -136,13 +136,13 @@ namespace LibreMetaverse.Tests int len = packetData.Length - 1; DirPlacesReplyPacket packet = (DirPlacesReplyPacket)Packet.BuildPacket(packetData, ref len, packetData); - Assert.IsTrue(packet.AgentData.AgentID == bigPacket.AgentData.AgentID); + Assert.That(packet.AgentData.AgentID, Is.EqualTo(bigPacket.AgentData.AgentID)); for (int j = 0; j < packet.QueryReplies.Length; j++) { - Assert.IsTrue(packet.QueryReplies[j].Dwell == (float)(queryRepliesCount + j), + Assert.That(packet.QueryReplies[j].Dwell, Is.EqualTo(queryRepliesCount + j).Within(0.1f), "Expected Dwell of " + (float)(queryRepliesCount + j) + " but got " + packet.QueryReplies[j].Dwell); - Assert.IsTrue(packet.QueryReplies[j].ParcelID == testID); + Assert.That(packet.QueryReplies[j].ParcelID, Is.EqualTo(testID)); } queryDataCount += packet.QueryData.Length; @@ -150,9 +150,9 @@ namespace LibreMetaverse.Tests statusDataCount += packet.StatusData.Length; } - Assert.IsTrue(queryDataCount == bigPacket.QueryData.Length); - Assert.IsTrue(queryRepliesCount == bigPacket.QueryData.Length); - Assert.IsTrue(statusDataCount == bigPacket.StatusData.Length); + Assert.That(queryDataCount, Is.EqualTo(bigPacket.QueryData.Length)); + Assert.That(queryRepliesCount, Is.EqualTo(bigPacket.QueryData.Length)); + Assert.That(statusDataCount, Is.EqualTo(bigPacket.StatusData.Length)); ScriptDialogPacket scriptDialogPacket = new ScriptDialogPacket(); scriptDialogPacket.Data.ChatChannel = 0; @@ -169,8 +169,9 @@ namespace LibreMetaverse.Tests byte[][] splitPacket = scriptDialogPacket.ToBytesMultiple(); - Assert.IsNotNull(splitPacket); - Assert.IsTrue(splitPacket.Length == 1, "Expected ScriptDialog packet to split into 1 packet but got " + splitPacket.Length); + Assert.That(splitPacket, Is.Not.Null); + Assert.That(splitPacket.Length, Is.EqualTo(1), + "Expected ScriptDialog packet to split into 1 packet but got " + splitPacket.Length); ParcelReturnObjectsPacket proPacket = new ParcelReturnObjectsPacket(); proPacket.AgentData.AgentID = UUID.Zero; @@ -184,8 +185,9 @@ namespace LibreMetaverse.Tests splitPacket = proPacket.ToBytesMultiple(); - Assert.IsNotNull(splitPacket); - Assert.IsTrue(splitPacket.Length == 1, "Expected ParcelReturnObjectsPacket packet to split into 1 packet but got " + splitPacket.Length); + Assert.That(splitPacket, Is.Not.Null); + Assert.That(splitPacket.Length, Is.EqualTo(1), + "Expected ParcelReturnObjectsPacket packet to split into 1 packet but got " + splitPacket.Length); InventoryDescendentsPacket invPacket = new InventoryDescendentsPacket(); invPacket.FolderData = new InventoryDescendentsPacket.FolderDataBlock[1]; @@ -201,15 +203,18 @@ namespace LibreMetaverse.Tests splitPacket = invPacket.ToBytesMultiple(); - Assert.IsNotNull(splitPacket); - Assert.IsTrue(splitPacket.Length == 1, "Split InventoryDescendents packet into " + splitPacket.Length + " instead of 1 packet"); + Assert.That(splitPacket, Is.Not.Null); + Assert.That(splitPacket.Length, Is.EqualTo(1), + "Split InventoryDescendents packet into " + splitPacket.Length + " instead of 1 packet"); int x = 0; int y = splitPacket[0].Length - 1; invPacket.FromBytes(splitPacket[0], ref x, ref y, null); - Assert.IsTrue(invPacket.FolderData.Length == 1, "InventoryDescendents packet came back with " + invPacket.FolderData.Length + " FolderData blocks"); - Assert.IsTrue(invPacket.ItemData.Length == 5, "InventoryDescendents packet came back with " + invPacket.ItemData.Length + " ItemData blocks"); + Assert.That(invPacket.FolderData.Length, Is.EqualTo(1), + "InventoryDescendents packet came back with " + invPacket.FolderData.Length + " FolderData blocks"); + Assert.That(invPacket.ItemData.Length, Is.EqualTo(5), + "InventoryDescendents packet came back with " + invPacket.ItemData.Length + " ItemData blocks"); } } } diff --git a/LibreMetaverse.Tests/PrimObjectTests.cs b/LibreMetaverse.Tests/PrimObjectTests.cs index d7955705..61348448 100644 --- a/LibreMetaverse.Tests/PrimObjectTests.cs +++ b/LibreMetaverse.Tests/PrimObjectTests.cs @@ -42,8 +42,8 @@ namespace LibreMetaverse.Tests float floatValue = Primitive.UnpackBeginCut(i); ushort result = Primitive.PackBeginCut(floatValue); - Assert.IsTrue(result == i, "Started with " + i + ", float value was " + floatValue + - ", and ended up with " + result); + Assert.That(result == i, Is.True, + "Started with " + i + ", float value was " + floatValue + ", and ended up with " + result); } } @@ -55,8 +55,8 @@ namespace LibreMetaverse.Tests float floatValue = Primitive.UnpackEndCut(i); ushort result = Primitive.PackEndCut(floatValue); - Assert.IsTrue(result == i, "Started with " + i + ", float value was " + floatValue + - ", and ended up with " + result); + Assert.That(result == i, Is.True, + "Started with " + i + ", float value was " + floatValue + ", and ended up with " + result); } } @@ -68,8 +68,8 @@ namespace LibreMetaverse.Tests float floatValue = Primitive.UnpackPathRevolutions(i); byte result = Primitive.PackPathRevolutions(floatValue); - Assert.IsTrue(result == i, "Started with " + i + ", float value was " + floatValue + - ", and ended up with " + result); + Assert.That(result == i, Is.True, + "Started with " + i + ", float value was " + floatValue + ", and ended up with " + result); } } @@ -81,8 +81,8 @@ namespace LibreMetaverse.Tests float floatValue = Primitive.UnpackPathScale(i); byte result = Primitive.PackPathScale(floatValue); - Assert.IsTrue(result == i, "Started with " + i + ", float value was " + floatValue + - ", and ended up with " + result); + Assert.That(result == i, Is.True, + "Started with " + i + ", float value was " + floatValue + ", and ended up with " + result); } } @@ -107,8 +107,8 @@ namespace LibreMetaverse.Tests float floatValue = Primitive.UnpackPathTaper(i); sbyte result = Primitive.PackPathTaper(floatValue); - Assert.IsTrue(result == i, "Started with " + i + ", float value was " + floatValue + - ", and ended up with " + result); + Assert.That(result == i, Is.True, + "Started with " + i + ", float value was " + floatValue + ", and ended up with " + result); } } @@ -123,7 +123,8 @@ namespace LibreMetaverse.Tests float foffset = Helpers.TEOffsetFloat(BitConverter.GetBytes(offset), 0); foffset = (float)Math.Round(foffset, 3); - Assert.IsTrue(foffset - i < float.Epsilon, foffset + " is not equal to " + i); + Assert.That(foffset - i < float.Epsilon, Is.True, + foffset + " is not equal to " + i); } } @@ -151,11 +152,11 @@ namespace LibreMetaverse.Tests byte[] teBytes2 = te2.GetBytes(); - Assert.IsTrue(teBytes.Length == teBytes2.Length); + Assert.That(teBytes.Length, Is.EqualTo(teBytes2.Length)); for (int i = 0; i < teBytes.Length; i++) { - Assert.IsTrue(teBytes[i] == teBytes2[i], "Byte " + i + " is not equal"); + Assert.That(teBytes[i], Is.EqualTo(teBytes2[i]), "Byte " + i + " is not equal"); } } } diff --git a/LibreMetaverse.Tests/TypeTests.cs b/LibreMetaverse.Tests/TypeTests.cs index 4a327b16..942b8e92 100644 --- a/LibreMetaverse.Tests/TypeTests.cs +++ b/LibreMetaverse.Tests/TypeTests.cs @@ -1,6 +1,6 @@ /* * Copyright (c) 2006-2016, openmetaverse.co - * Copyright (c) 2021-2022, Sjofn LLC. + * Copyright (c) 2021-2024, Sjofn LLC. * All rights reserved. * * - Redistribution and use in source and binary forms, with or without @@ -43,7 +43,7 @@ namespace LibreMetaverse.Tests UUID a = new UUID(); byte[] bytes = a.GetBytes(); for (int i = 0; i < 16; i++) - Assert.IsTrue(bytes[i] == 0x00); + Assert.That(bytes[i], Is.EqualTo(0x00)); // Comparison a = new UUID(new byte[] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, @@ -51,8 +51,8 @@ namespace LibreMetaverse.Tests UUID b = new UUID(new byte[] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }, 0); - Assert.IsTrue(a == b, "UUID comparison operator failed, " + a + " should equal " + - b); + Assert.That(a, Is.EqualTo(b), + "UUID comparison operator failed, " + a + " should equal " + b); // From string a = new UUID(new byte[] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, @@ -60,12 +60,12 @@ namespace LibreMetaverse.Tests string zeroonetwo = "00010203-0405-0607-0809-0a0b0c0d0e0f"; b = new UUID(zeroonetwo); - Assert.IsTrue(a == b, "UUID hyphenated string constructor failed, should have " + a + - " but we got " + b); + Assert.That(a, Is.EqualTo(b), + "UUID hyphenated string constructor failed, should have " + a + " but we got " + b); // ToString() - Assert.IsTrue(a == b); - Assert.IsTrue(a == (UUID)zeroonetwo); + Assert.That(a, Is.EqualTo(b)); + Assert.That(a, Is.EqualTo((UUID)zeroonetwo)); // TODO: CRC test } @@ -76,46 +76,50 @@ namespace LibreMetaverse.Tests Vector3 a = new Vector3(1f, 0f, 0f); Vector3 b = new Vector3(0f, 0f, 0f); - Assert.IsFalse(a.ApproxEquals(b, 0.9f), "ApproxEquals failed (1)"); - Assert.IsTrue(a.ApproxEquals(b, 1.0f), "ApproxEquals failed (2)"); + Assert.That(a.ApproxEquals(b, 0.9f), Is.False, "ApproxEquals failed (1)"); + Assert.That(a.ApproxEquals(b, 1.0f), Is.True, "ApproxEquals failed (2)"); a = new Vector3(-1f, 0f, 0f); b = new Vector3(1f, 0f, 0f); - Assert.IsFalse(a.ApproxEquals(b, 1.9f), "ApproxEquals failed (3)"); - Assert.IsTrue(a.ApproxEquals(b, 2.0f), "ApproxEquals failed (4)"); + Assert.That(a.ApproxEquals(b, 1.9f), Is.False, "ApproxEquals failed (3)"); + Assert.That(a.ApproxEquals(b, 2.0f), Is.True, "ApproxEquals failed (4)"); a = new Vector3(0f, -1f, 0f); b = new Vector3(0f, -1.1f, 0f); - Assert.IsFalse(a.ApproxEquals(b, 0.09f), "ApproxEquals failed (5)"); - Assert.IsTrue(a.ApproxEquals(b, 0.11f), "ApproxEquals failed (6)"); + Assert.That(a.ApproxEquals(b, 0.09f), Is.False, "ApproxEquals failed (5)"); + Assert.That(a.ApproxEquals(b, 0.11f), Is.True, "ApproxEquals failed (6)"); a = new Vector3(0f, 0f, 0.00001f); b = new Vector3(0f, 0f, 0f); - Assert.IsFalse(b.ApproxEquals(a, float.Epsilon), "ApproxEquals failed (6)"); - Assert.IsTrue(b.ApproxEquals(a, 0.0001f), "ApproxEquals failed (7)"); + Assert.That(b.ApproxEquals(a, float.Epsilon), Is.False, "ApproxEquals failed (6)"); + Assert.That(b.ApproxEquals(a, 0.0001f), Is.True, "ApproxEquals failed (7)"); } [Test] public void VectorCasting() { - var testNumbers = new Dictionary(); - testNumbers["1.0"] = 1.0; - testNumbers["1.1"] = 1.1; - testNumbers["1.01"] = 1.01; - testNumbers["1.001"] = 1.001; - testNumbers["1.0001"] = 1.0001; - testNumbers["1.00001"] = 1.00001; - testNumbers["1.000001"] = 1.000001; - testNumbers["1.0000001"] = 1.0000001; - testNumbers["1.00000001"] = 1.00000001; + var testNumbers = new Dictionary + { + ["1.0"] = 1.0, + ["1.1"] = 1.1, + ["1.01"] = 1.01, + ["1.001"] = 1.001, + ["1.0001"] = 1.0001, + ["1.00001"] = 1.00001, + ["1.000001"] = 1.000001, + ["1.0000001"] = 1.0000001, + ["1.00000001"] = 1.00000001 + }; - foreach (KeyValuePair kvp in testNumbers) + foreach (var kvp in testNumbers) { double testNumber = kvp.Value; - double testNumber2 = (double)((float)testNumber); + // ReSharper disable once RedundantCast + double testNumber2 = (double)(float)testNumber; + // ReSharper disable once CompareOfFloatsByEqualityOperator bool noPrecisionLoss = testNumber == testNumber2; Vector3 a = new Vector3( @@ -134,18 +138,18 @@ namespace LibreMetaverse.Tests } else { - Assert.IsFalse(a == b, + Assert.That(a, Is.Not.EqualTo(b), "Vector casting failed, precision loss should" + " have occurred. " + $"{kvp.Key}: {a.X}, {b.X}"); - Assert.IsFalse(b == d, + Assert.That(b, Is.Not.EqualTo(d), "Vector casting failed, explicit cast of double" + " to float should result in precision loss" + - " whichwas should not magically disappear when" + " Vector3 is implicitly cast to Vector3d." + + " which should not magically disappear when" + " Vector3 is implicitly cast to Vector3d." + $" {kvp.Key}: {b.X}, {d.X}"); } - Assert.IsTrue(a == c, + Assert.That(a, Is.EqualTo(c), "Vector casting failed, Vector3 compared to" + " explicit cast of Vector3d to Vector3 should" + " result in identical precision loss." + $" {kvp.Key}: {a.X}, {c.X}"); - Assert.IsTrue(a == d, + Assert.That(a == d, Is.True, "Vector casting failed, implicit cast of Vector3" + " to Vector3d should not result in precision loss." + $" {kvp.Key}: {a.X}, {d.X}"); } @@ -157,33 +161,33 @@ namespace LibreMetaverse.Tests Quaternion a = new Quaternion(1, 0, 0, 0); Quaternion b = new Quaternion(1, 0, 0, 0); - Assert.IsTrue(a == b, "Quaternion comparison operator failed"); + Assert.That(a, Is.EqualTo(b), "Quaternion comparison operator failed"); Quaternion expected = new Quaternion(0, 0, 0, -1); Quaternion result = a * b; - Assert.IsTrue(result == expected, a + " * " + b + " produced " + result + - " instead of " + expected); + Assert.That(result, Is.EqualTo(expected), + a + " * " + b + " produced " + result + " instead of " + expected); a = new Quaternion(1, 0, 0, 0); b = new Quaternion(0, 1, 0, 0); expected = new Quaternion(0, 0, 1, 0); result = a * b; - Assert.IsTrue(result == expected, a + " * " + b + " produced " + result + - " instead of " + expected); + Assert.That(result, Is.EqualTo(expected), + a + " * " + b + " produced " + result + " instead of " + expected); a = new Quaternion(0, 0, 1, 0); b = new Quaternion(0, 1, 0, 0); expected = new Quaternion(-1, 0, 0, 0); result = a * b; - Assert.IsTrue(result == expected, a + " * " + b + " produced " + result + - " instead of " + expected); + Assert.That(result, Is.EqualTo(expected), + a + " * " + b + " produced " + result + " instead of " + expected); } [Test] - public void testMatrix() + public void TestMatrix() { Matrix4 matrix = new Matrix4(0, 0, 74, 1, 0, 435, 0, 1, @@ -191,10 +195,10 @@ namespace LibreMetaverse.Tests 0, 0, 0, 0); /* determinant of singular matrix returns zero */ - Assert.AreEqual(0d, (double)matrix.Determinant(), 0.001d); + Assert.That(0d, Is.EqualTo((double)matrix.Determinant()).Within(0.001d)); /* inverse of identity matrix is the identity matrix */ - Assert.IsTrue(Matrix4.Identity == Matrix4.Inverse(Matrix4.Identity)); + Assert.That(Matrix4.Identity, Is.EqualTo(Matrix4.Inverse(Matrix4.Identity))); /* inverse of non-singular matrix returns True And InverseMatrix */ matrix = new Matrix4(1, 1, 0, 0, @@ -205,7 +209,7 @@ namespace LibreMetaverse.Tests 1,-1, 1, 0, -1, 1, 0, 0, 0, 0, 0, 1); - Assert.AreEqual(expectedInverse, Matrix4.Inverse(matrix)); + Assert.That(Matrix4.Inverse(matrix), Is.EqualTo(expectedInverse)); } //[Test] @@ -224,29 +228,29 @@ namespace LibreMetaverse.Tests public void FloatsToTerseStrings() { float f = 1.20f; - string a = string.Empty; - string b = "1.2"; + string fstr = "1.2"; + string str; - a = Helpers.FloatToTerseString(f); - Assert.IsTrue(a == b, f + " converted to " + a + ", expecting " + b); + str = Helpers.FloatToTerseString(f); + Assert.That(str, Is.EqualTo(fstr), f + " converted to " + str + ", expecting " + fstr); f = 24.00f; - b = "24"; + fstr = "24"; - a = Helpers.FloatToTerseString(f); - Assert.IsTrue(a == b, f + " converted to " + a + ", expecting " + b); + str = Helpers.FloatToTerseString(f); + Assert.That(str, Is.EqualTo(fstr), f + " converted to " + str + ", expecting " + fstr); f = -0.59f; - b = "-.59"; + fstr = "-.59"; - a = Helpers.FloatToTerseString(f); - Assert.IsTrue(a == b, f + " converted to " + a + ", expecting " + b); + str = Helpers.FloatToTerseString(f); + Assert.That(str, Is.EqualTo(fstr), f + " converted to " + str + ", expecting " + fstr); f = 0.59f; - b = ".59"; + fstr = ".59"; - a = Helpers.FloatToTerseString(f); - Assert.IsTrue(a == b, f + " converted to " + a + ", expecting " + b); + str = Helpers.FloatToTerseString(f); + Assert.That(str, Is.EqualTo(fstr), f + " converted to " + str + ", expecting " + fstr); } [Test] @@ -256,24 +260,24 @@ namespace LibreMetaverse.Tests BitPack bitpacker = new BitPack(data, 0); int b = bitpacker.UnpackBits(1); - Assert.IsTrue(b == 1, "Unpacked " + b + " instead of 1"); + Assert.That(b, Is.EqualTo(1), "Unpacked " + b + " instead of 1"); b = bitpacker.UnpackBits(1); - Assert.IsTrue(b == 0, "Unpacked " + b + " instead of 0"); + Assert.That(b, Is.Zero, "Unpacked " + b + " instead of 0"); bitpacker = new BitPack(data, 2); b = bitpacker.UnpackBits(4); - Assert.IsTrue(b == 0, "Unpacked " + b + " instead of 0"); + Assert.That(b, Is.Zero, "Unpacked " + b + " instead of 0"); b = bitpacker.UnpackBits(8); - Assert.IsTrue(b == 0xF5, "Unpacked " + b + " instead of 0xF5"); + Assert.That(b, Is.EqualTo(0xF5), "Unpacked " + b + " instead of 0xF5"); b = bitpacker.UnpackBits(4); - Assert.IsTrue(b == 0, "Unpacked " + b + " instead of 0"); + Assert.That(b, Is.Zero, "Unpacked " + b + " instead of 0"); b = bitpacker.UnpackBits(10); - Assert.IsTrue(b == 0x0183, "Unpacked " + b + " instead of 0x0183"); + Assert.That(b, Is.EqualTo(0x0183), "Unpacked " + b + " instead of 0x0183"); } [Test] @@ -290,16 +294,16 @@ namespace LibreMetaverse.Tests bitpacker = new BitPack(packedBytes, 0); int b = bitpacker.UnpackBits(32); - Assert.IsTrue(b == 0x0ABBCCDD, "Unpacked " + b + " instead of 2864434397"); + Assert.That(b, Is.EqualTo(0x0ABBCCDD), "Unpacked " + b + " instead of 2864434397"); b = bitpacker.UnpackBits(5); - Assert.IsTrue(b == 25, "Unpacked " + b + " instead of 25"); + Assert.That(b, Is.EqualTo(25), "Unpacked " + b + " instead of 25"); float f = bitpacker.UnpackFloat(); - Assert.IsTrue(f == 123.321f, "Unpacked " + f + " instead of 123.321"); + Assert.That(f, Is.EqualTo(123.321f), "Unpacked " + f + " instead of 123.321"); b = bitpacker.UnpackBits(16); - Assert.IsTrue(b == 1000, "Unpacked " + b + " instead of 1000"); + Assert.That(b, Is.EqualTo(1000), "Unpacked " + b + " instead of 1000"); packedBytes = new byte[1]; bitpacker = new BitPack(packedBytes, 0); @@ -307,15 +311,16 @@ namespace LibreMetaverse.Tests bitpacker = new BitPack(packedBytes, 0); b = bitpacker.UnpackBits(1); - Assert.IsTrue(b == 1, "Unpacked " + b + " instead of 1"); + Assert.That(b, Is.EqualTo(1), "Unpacked " + b + " instead of 1"); + // ReSharper disable once RedundantExplicitArraySize packedBytes = new byte[1] { byte.MaxValue }; bitpacker = new BitPack(packedBytes, 0); bitpacker.PackBit(false); bitpacker = new BitPack(packedBytes, 0); b = bitpacker.UnpackBits(1); - Assert.IsTrue(b == 0, "Unpacked " + b + " instead of 0"); + Assert.That(b, Is.Zero, "Unpacked " + b + " instead of 0"); } [Test] @@ -326,35 +331,37 @@ namespace LibreMetaverse.Tests string testThree = "{'region_handle':[r255232, r256512], 'position':[r33.6, r33.71, r43.13], 'look_at':[r34.6, r33.71, r43.13]}"; OSD obj = OSDParser.DeserializeLLSDNotation(testOne); - Assert.IsInstanceOf(obj, "Expected SDArray, got " + obj.GetType()); + Assert.That(obj, Is.InstanceOf(typeof(OSDArray)), "Expected SDArray, got " + obj.GetType()); OSDArray array = (OSDArray)obj; - Assert.IsTrue(array.Count == 3, "Expected three contained objects, got " + array.Count); - Assert.IsTrue(array[0].AsReal() > 0.9d && array[0].AsReal() < 1.0d, "Unexpected value for first real " + array[0].AsReal()); - Assert.IsTrue(array[1].AsReal() < 0.0d && array[1].AsReal() > -0.03d, "Unexpected value for second real " + array[1].AsReal()); - Assert.IsTrue(array[2].AsReal() == 0.0d, "Unexpected value for third real " + array[2].AsReal()); + Assert.That(array, Has.Exactly(3).Items, "Expected three contained objects, got " + array.Count); + Assert.That(array[0].AsReal(), Is.EqualTo(0.999d).Within(0.1d), + "Unexpected value for first real " + array[0].AsReal()); + Assert.That(array[1].AsReal(), Is.EqualTo(-0.02d).Within(0.1d), + "Unexpected value for second real " + array[1].AsReal()); + Assert.That(array[2].AsReal(), Is.Zero, "Unexpected value for third real " + array[2].AsReal()); obj = OSDParser.DeserializeLLSDNotation(testTwo); - Assert.IsInstanceOf(obj, "Expected SDArray, got " + obj.GetType()); + Assert.That(obj, Is.InstanceOf(typeof(OSDArray)), "Expected SDArray, got " + obj.GetType()); array = (OSDArray)obj; - Assert.IsTrue(array.Count == 2, "Expected two contained objects, got " + array.Count); - Assert.IsTrue(array[1].AsReal() == 0.0d, "Unexpected value for real " + array[1].AsReal()); + Assert.That(array, Has.Exactly(2).Items, "Expected two contained objects, got " + array.Count); + Assert.That(array[1].AsReal(), Is.Zero, "Unexpected value for real " + array[1].AsReal()); obj = array[0]; - Assert.IsInstanceOf(obj, "Expected ArrayList, got " + obj.GetType()); + Assert.That(obj, Is.InstanceOf(typeof(OSDArray)), "Expected ArrayList, got " + obj.GetType()); array = (OSDArray)obj; - Assert.IsTrue(array[0].AsReal() == 1.0d && array[1].AsReal() == 1.0d && array[2].AsReal() == 1.0d, - "Unexpected value(s) for nested array: " + array[0].AsReal() + ", " + array[1].AsReal() + ", " + - array[2].AsReal()); + Assert.That(array[0].AsReal(), Is.EqualTo(1.0d), "Unexpected value(s) for nested array: "+array[0].AsReal()); + Assert.That(array[1].AsReal(), Is.EqualTo(1.0d), "Unexpected value(s) for nested array: "+array[1].AsReal()); + Assert.That(array[2].AsReal(), Is.EqualTo(1.0d), "Unexpected value(s) for nested array: "+array[2].AsReal()); obj = OSDParser.DeserializeLLSDNotation(testThree); - Assert.IsInstanceOf(obj, "Expected LLSDMap, got " + obj.GetType()); + Assert.That(obj, Is.InstanceOf(typeof(OSDMap)), "Expected LLSDMap, got " + obj.GetType()); OSDMap hashtable = (OSDMap)obj; - Assert.IsTrue(hashtable.Count == 3, "Expected three contained objects, got " + hashtable.Count); - Assert.IsInstanceOf(hashtable["region_handle"]); - Assert.IsTrue(((OSDArray)hashtable["region_handle"]).Count == 2); - Assert.IsInstanceOf(hashtable["position"]); - Assert.IsTrue(((OSDArray)hashtable["position"]).Count == 3); - Assert.IsInstanceOf(hashtable["look_at"]); - Assert.IsTrue(((OSDArray)hashtable["look_at"]).Count == 3); + Assert.That(hashtable, Has.Exactly(3).Items, "Expected three contained objects, got " + hashtable.Count); + Assert.That(hashtable["region_handle"], Is.InstanceOf(typeof(OSDArray))); + Assert.That(hashtable["region_handle"], Has.Exactly(2).Items); + Assert.That(hashtable["position"], Is.InstanceOf(typeof(OSDArray))); + Assert.That(hashtable["position"], Has.Exactly(3).Items); + Assert.That(hashtable["look_at"], Is.InstanceOf(typeof(OSDArray))); + Assert.That(hashtable["look_at"], Has.Exactly(3).Items); } } } diff --git a/LibreMetaverse.Tests/UtilsConversionsTests.cs b/LibreMetaverse.Tests/UtilsConversionsTests.cs index 83b05e26..389e5cd2 100644 --- a/LibreMetaverse.Tests/UtilsConversionsTests.cs +++ b/LibreMetaverse.Tests/UtilsConversionsTests.cs @@ -42,7 +42,7 @@ namespace LibreMetaverse.Tests string test = "Your squirrel, your imagination"; byte[] bytes = Utils.StringToBytes(test); string decoded = Utils.BytesToString(bytes); - Assert.AreEqual(test, decoded); + Assert.That(decoded, Is.EqualTo(test)); } } } diff --git a/LibreMetaverse.Tests/XmlLLSDTests.cs b/LibreMetaverse.Tests/XmlLLSDTests.cs index e379a366..6a46ac57 100644 --- a/LibreMetaverse.Tests/XmlLLSDTests.cs +++ b/LibreMetaverse.Tests/XmlLLSDTests.cs @@ -1,6 +1,6 @@ /* * Copyright (c) 2006-2016, openmetaverse.co - * Copyright (c) 2021-2022, Sjofn LLC. + * Copyright (c) 2021-2024, Sjofn LLC. * All rights reserved. * * - Redistribution and use in source and binary forms, with or without @@ -28,14 +28,14 @@ using System; using System.Text; using NUnit.Framework; +using NUnit.Framework.Legacy; using OpenMetaverse; using OpenMetaverse.StructuredData; namespace LibreMetaverse.Tests { /// - /// XmlSDTests is a suite of tests for libsl implementation of the SD XML format. - /// + /// XmlSDTests is a suite of tests for libsl implementation of the SD XML for /// [TestFixture] public class XmlSDTests @@ -85,73 +85,73 @@ namespace LibreMetaverse.Tests theSD = OSDParser.DeserializeLLSDXml(bytes); //Confirm the contents - Assert.IsNotNull(theSD); - Assert.IsTrue(theSD is OSDMap); - Assert.IsTrue(theSD.Type == OSDType.Map); + ClassicAssert.IsNotNull(theSD); + ClassicAssert.IsTrue(theSD is OSDMap); + ClassicAssert.IsTrue(theSD.Type == OSDType.Map); map = (OSDMap)theSD; tempSD = map["region_id"]; - Assert.IsNotNull(tempSD); - Assert.IsTrue(tempSD is OSDUUID); - Assert.IsTrue(tempSD.Type == OSDType.UUID); + ClassicAssert.IsNotNull(tempSD); + ClassicAssert.IsTrue(tempSD is OSDUUID); + ClassicAssert.IsTrue(tempSD.Type == OSDType.UUID); tempUUID = (OSDUUID)tempSD; - Assert.AreEqual(new UUID("67153d5b-3659-afb4-8510-adda2c034649"), tempUUID.AsUUID()); + ClassicAssert.AreEqual(new UUID("67153d5b-3659-afb4-8510-adda2c034649"), tempUUID.AsUUID()); tempSD = map["scale"]; - Assert.IsNotNull(tempSD); - Assert.IsTrue(tempSD is OSDString); - Assert.IsTrue(tempSD.Type == OSDType.String); + ClassicAssert.IsNotNull(tempSD); + ClassicAssert.IsTrue(tempSD is OSDString); + ClassicAssert.IsTrue(tempSD.Type == OSDType.String); tempStr = (OSDString)tempSD; - Assert.AreEqual("one minute", tempStr.AsString()); + ClassicAssert.AreEqual("one minute", tempStr.AsString()); tempSD = map["simulator statistics"]; - Assert.IsNotNull(tempSD); - Assert.IsTrue(tempSD is OSDMap); - Assert.IsTrue(tempSD.Type == OSDType.Map); + ClassicAssert.IsNotNull(tempSD); + ClassicAssert.IsTrue(tempSD is OSDMap); + ClassicAssert.IsTrue(tempSD.Type == OSDType.Map); map = (OSDMap)tempSD; tempSD = map["time dilation"]; - Assert.IsNotNull(tempSD); - Assert.IsTrue(tempSD is OSDReal); - Assert.IsTrue(tempSD.Type == OSDType.Real); + ClassicAssert.IsNotNull(tempSD); + ClassicAssert.IsTrue(tempSD is OSDReal); + ClassicAssert.IsTrue(tempSD.Type == OSDType.Real); tempReal = (OSDReal)tempSD; - Assert.AreEqual(0.9878624d, tempReal.AsReal()); + ClassicAssert.AreEqual(0.9878624d, tempReal.AsReal()); //TODO - figure out any relevant rounding variability for 64 bit reals tempSD = map["sim fps"]; - Assert.IsNotNull(tempSD); - Assert.IsTrue(tempSD is OSDReal); - Assert.IsTrue(tempSD.Type == OSDType.Real); + ClassicAssert.IsNotNull(tempSD); + ClassicAssert.IsTrue(tempSD is OSDReal); + ClassicAssert.IsTrue(tempSD.Type == OSDType.Real); tempReal = (OSDReal)tempSD; - Assert.AreEqual(44.38898d, tempReal.AsReal()); + ClassicAssert.AreEqual(44.38898d, tempReal.AsReal()); tempSD = map["agent updates per second"]; - Assert.IsNotNull(tempSD); - Assert.IsTrue(tempSD is OSDReal); - Assert.IsTrue(tempSD.Type == OSDType.Real); + ClassicAssert.IsNotNull(tempSD); + ClassicAssert.IsTrue(tempSD is OSDReal); + ClassicAssert.IsTrue(tempSD.Type == OSDType.Real); tempReal = (OSDReal)tempSD; - Assert.AreEqual(double.NaN, tempSD.AsReal()); + ClassicAssert.AreEqual(double.NaN, tempSD.AsReal()); tempSD = map["total task count"]; - Assert.IsNotNull(tempSD); - Assert.IsTrue(tempSD is OSDReal); - Assert.IsTrue(tempSD.Type == OSDType.Real); + ClassicAssert.IsNotNull(tempSD); + ClassicAssert.IsTrue(tempSD is OSDReal); + ClassicAssert.IsTrue(tempSD.Type == OSDType.Real); tempReal = (OSDReal)tempSD; - Assert.AreEqual(4.0d, tempReal.AsReal()); + ClassicAssert.AreEqual(4.0d, tempReal.AsReal()); tempSD = map["active task count"]; - Assert.IsNotNull(tempSD); - Assert.IsTrue(tempSD is OSDReal); - Assert.IsTrue(tempSD.Type == OSDType.Real); + ClassicAssert.IsNotNull(tempSD); + ClassicAssert.IsTrue(tempSD is OSDReal); + ClassicAssert.IsTrue(tempSD.Type == OSDType.Real); tempReal = (OSDReal)tempSD; - Assert.AreEqual(0.0d, tempReal.AsReal()); + ClassicAssert.AreEqual(0.0d, tempReal.AsReal()); tempSD = map["pending uploads"]; - Assert.IsNotNull(tempSD); - Assert.IsTrue(tempSD is OSDReal); - Assert.IsTrue(tempSD.Type == OSDType.Real); + ClassicAssert.IsNotNull(tempSD); + ClassicAssert.IsTrue(tempSD is OSDReal); + ClassicAssert.IsTrue(tempSD.Type == OSDType.Real); tempReal = (OSDReal)tempSD; - Assert.AreEqual(0.0001096525d, tempReal.AsReal()); + ClassicAssert.AreEqual(0.0001096525d, tempReal.AsReal()); } @@ -173,11 +173,11 @@ namespace LibreMetaverse.Tests byte[] bytes = Encoding.UTF8.GetBytes(testSD); OSD theSD = OSDParser.DeserializeLLSDXml(bytes); - Assert.IsTrue(theSD is OSDMap); + ClassicAssert.IsTrue(theSD is OSDMap); OSDMap map = (OSDMap)theSD; - Assert.AreEqual(map["MINUTES"].AsInteger(), 5); - Assert.AreEqual(map["NAME"].AsString(), "Hippotropolis"); + ClassicAssert.AreEqual(map["MINUTES"].AsInteger(), 5); + ClassicAssert.AreEqual(map["NAME"].AsString(), "Hippotropolis"); } /// @@ -199,11 +199,11 @@ namespace LibreMetaverse.Tests byte[] bytes = Encoding.UTF8.GetBytes(testSD); OSD theSD = OSDParser.DeserializeLLSDXml(bytes); - Assert.IsTrue(theSD is OSDMap); + ClassicAssert.IsTrue(theSD is OSDMap); OSDMap map = (OSDMap)theSD; - Assert.AreEqual(map["MINUTES"].AsInteger(), 5); - Assert.AreEqual(map["NAME"].AsString(), "Hippotropolis"); + ClassicAssert.AreEqual(map["MINUTES"].AsInteger(), 5); + ClassicAssert.AreEqual(map["NAME"].AsString(), "Hippotropolis"); } /// @@ -230,28 +230,28 @@ namespace LibreMetaverse.Tests byte[] bytes = Encoding.UTF8.GetBytes(testSD); theSD = OSDParser.DeserializeLLSDXml(bytes); - Assert.IsTrue(theSD is OSDArray); + ClassicAssert.IsTrue(theSD is OSDArray); array = (OSDArray)theSD; - Assert.AreEqual(OSDType.Real, array[0].Type); + ClassicAssert.AreEqual(OSDType.Real, array[0].Type); tempReal = (OSDReal)array[0]; - Assert.AreEqual(44.38898d, tempReal.AsReal()); + ClassicAssert.AreEqual(44.38898d, tempReal.AsReal()); - Assert.AreEqual(OSDType.Real, array[1].Type); + ClassicAssert.AreEqual(OSDType.Real, array[1].Type); tempReal = (OSDReal)array[1]; - Assert.AreEqual(double.NaN, tempReal.AsReal()); + ClassicAssert.AreEqual(double.NaN, tempReal.AsReal()); - Assert.AreEqual(OSDType.Real, array[2].Type); + ClassicAssert.AreEqual(OSDType.Real, array[2].Type); tempReal = (OSDReal)array[2]; - Assert.AreEqual(4.0d, tempReal.AsReal()); + ClassicAssert.AreEqual(4.0d, tempReal.AsReal()); - Assert.AreEqual(OSDType.Real, array[3].Type); + ClassicAssert.AreEqual(OSDType.Real, array[3].Type); tempReal = (OSDReal)array[3]; - Assert.AreEqual(-13.333d, tempReal.AsReal()); + ClassicAssert.AreEqual(-13.333d, tempReal.AsReal()); - Assert.AreEqual(OSDType.Real, array[4].Type); + ClassicAssert.AreEqual(OSDType.Real, array[4].Type); tempReal = (OSDReal)array[4]; - Assert.AreEqual(0d, tempReal.AsReal()); + ClassicAssert.AreEqual(0d, tempReal.AsReal()); } /// @@ -277,24 +277,24 @@ namespace LibreMetaverse.Tests byte[] bytes = Encoding.UTF8.GetBytes(testSD); theSD = OSDParser.DeserializeLLSDXml(bytes); - Assert.IsTrue(theSD is OSDArray); + ClassicAssert.IsTrue(theSD is OSDArray); array = (OSDArray)theSD; - Assert.AreEqual(OSDType.String, array[0].Type); + ClassicAssert.AreEqual(OSDType.String, array[0].Type); tempStr = (OSDString)array[0]; - Assert.AreEqual("Kissling", tempStr.AsString()); + ClassicAssert.AreEqual("Kissling", tempStr.AsString()); - Assert.AreEqual(OSDType.String, array[1].Type); + ClassicAssert.AreEqual(OSDType.String, array[1].Type); tempStr = (OSDString)array[1]; - Assert.AreEqual("Attack ships on fire off the shoulder of Orion", tempStr.AsString()); + ClassicAssert.AreEqual("Attack ships on fire off the shoulder of Orion", tempStr.AsString()); - Assert.AreEqual(OSDType.String, array[2].Type); + ClassicAssert.AreEqual(OSDType.String, array[2].Type); tempStr = (OSDString)array[2]; - Assert.AreEqual("< > & \' \"", tempStr.AsString()); + ClassicAssert.AreEqual("< > & \' \"", tempStr.AsString()); - Assert.AreEqual(OSDType.String, array[3].Type); + ClassicAssert.AreEqual(OSDType.String, array[3].Type); tempStr = (OSDString)array[3]; - Assert.AreEqual("", tempStr.AsString()); + ClassicAssert.AreEqual("", tempStr.AsString()); } @@ -327,28 +327,28 @@ namespace LibreMetaverse.Tests byte[] bytes = Encoding.UTF8.GetBytes(testSD); theSD = OSDParser.DeserializeLLSDXml(bytes); - Assert.IsTrue(theSD is OSDArray); + ClassicAssert.IsTrue(theSD is OSDArray); array = (OSDArray)theSD; - Assert.AreEqual(OSDType.Integer, array[0].Type); + ClassicAssert.AreEqual(OSDType.Integer, array[0].Type); tempInt = (OSDInteger)array[0]; - Assert.AreEqual(2147483647, tempInt.AsInteger()); + ClassicAssert.AreEqual(2147483647, tempInt.AsInteger()); - Assert.AreEqual(OSDType.Integer, array[1].Type); + ClassicAssert.AreEqual(OSDType.Integer, array[1].Type); tempInt = (OSDInteger)array[1]; - Assert.AreEqual(-2147483648, tempInt.AsInteger()); + ClassicAssert.AreEqual(-2147483648, tempInt.AsInteger()); - Assert.AreEqual(OSDType.Integer, array[2].Type); + ClassicAssert.AreEqual(OSDType.Integer, array[2].Type); tempInt = (OSDInteger)array[2]; - Assert.AreEqual(0, tempInt.AsInteger()); + ClassicAssert.AreEqual(0, tempInt.AsInteger()); - Assert.AreEqual(OSDType.Integer, array[3].Type); + ClassicAssert.AreEqual(OSDType.Integer, array[3].Type); tempInt = (OSDInteger)array[3]; - Assert.AreEqual(13, tempInt.AsInteger()); + ClassicAssert.AreEqual(13, tempInt.AsInteger()); - Assert.AreEqual(OSDType.Integer, array[4].Type); + ClassicAssert.AreEqual(OSDType.Integer, array[4].Type); tempInt = (OSDInteger)array[4]; - Assert.AreEqual(0, tempInt.AsInteger()); + ClassicAssert.AreEqual(0, tempInt.AsInteger()); } /// @@ -372,16 +372,16 @@ namespace LibreMetaverse.Tests byte[] bytes = Encoding.UTF8.GetBytes(testSD); theSD = OSDParser.DeserializeLLSDXml(bytes); - Assert.IsTrue(theSD is OSDArray); + ClassicAssert.IsTrue(theSD is OSDArray); array = (OSDArray)theSD; - Assert.AreEqual(OSDType.UUID, array[0].Type); + ClassicAssert.AreEqual(OSDType.UUID, array[0].Type); tempUUID = (OSDUUID)array[0]; - Assert.AreEqual(new UUID("d7f4aeca-88f1-42a1-b385-b9db18abb255"), tempUUID.AsUUID()); + ClassicAssert.AreEqual(new UUID("d7f4aeca-88f1-42a1-b385-b9db18abb255"), tempUUID.AsUUID()); - Assert.AreEqual(OSDType.UUID, array[1].Type); + ClassicAssert.AreEqual(OSDType.UUID, array[1].Type); tempUUID = (OSDUUID)array[1]; - Assert.AreEqual(UUID.Zero, tempUUID.AsUUID()); + ClassicAssert.AreEqual(UUID.Zero, tempUUID.AsUUID()); } /// @@ -407,22 +407,22 @@ namespace LibreMetaverse.Tests byte[] bytes = Encoding.UTF8.GetBytes(testSD); theSD = OSDParser.DeserializeLLSDXml(bytes); - Assert.IsTrue(theSD is OSDArray); + ClassicAssert.IsTrue(theSD is OSDArray); array = (OSDArray)theSD; - Assert.AreEqual(OSDType.Date, array[0].Type); + ClassicAssert.AreEqual(OSDType.Date, array[0].Type); tempDate = (OSDDate)array[0]; DateTime.TryParse("2006-02-01T14:29:53Z", out testDate); - Assert.AreEqual(testDate, tempDate.AsDate()); + ClassicAssert.AreEqual(testDate, tempDate.AsDate()); - Assert.AreEqual(OSDType.Date, array[1].Type); + ClassicAssert.AreEqual(OSDType.Date, array[1].Type); tempDate = (OSDDate)array[1]; DateTime.TryParse("1999-01-01T00:00:00Z", out testDate); - Assert.AreEqual(testDate, tempDate.AsDate()); + ClassicAssert.AreEqual(testDate, tempDate.AsDate()); - Assert.AreEqual(OSDType.Date, array[2].Type); + ClassicAssert.AreEqual(OSDType.Date, array[2].Type); tempDate = (OSDDate)array[2]; - Assert.AreEqual(Utils.Epoch, tempDate.AsDate()); + ClassicAssert.AreEqual(Utils.Epoch, tempDate.AsDate()); } /// @@ -449,28 +449,28 @@ namespace LibreMetaverse.Tests byte[] bytes = Encoding.UTF8.GetBytes(testSD); theSD = OSDParser.DeserializeLLSDXml(bytes); - Assert.IsTrue(theSD is OSDArray); + ClassicAssert.IsTrue(theSD is OSDArray); array = (OSDArray)theSD; - Assert.AreEqual(OSDType.Boolean, array[0].Type); + ClassicAssert.AreEqual(OSDType.Boolean, array[0].Type); tempBool = (OSDBoolean)array[0]; - Assert.AreEqual(true, tempBool.AsBoolean()); + ClassicAssert.AreEqual(true, tempBool.AsBoolean()); - Assert.AreEqual(OSDType.Boolean, array[1].Type); + ClassicAssert.AreEqual(OSDType.Boolean, array[1].Type); tempBool = (OSDBoolean)array[1]; - Assert.AreEqual(true, tempBool.AsBoolean()); + ClassicAssert.AreEqual(true, tempBool.AsBoolean()); - Assert.AreEqual(OSDType.Boolean, array[2].Type); + ClassicAssert.AreEqual(OSDType.Boolean, array[2].Type); tempBool = (OSDBoolean)array[2]; - Assert.AreEqual(false, tempBool.AsBoolean()); + ClassicAssert.AreEqual(false, tempBool.AsBoolean()); - Assert.AreEqual(OSDType.Boolean, array[3].Type); + ClassicAssert.AreEqual(OSDType.Boolean, array[3].Type); tempBool = (OSDBoolean)array[3]; - Assert.AreEqual(false, tempBool.AsBoolean()); + ClassicAssert.AreEqual(false, tempBool.AsBoolean()); - Assert.AreEqual(OSDType.Boolean, array[4].Type); + ClassicAssert.AreEqual(OSDType.Boolean, array[4].Type); tempBool = (OSDBoolean)array[4]; - Assert.AreEqual(false, tempBool.AsBoolean()); + ClassicAssert.AreEqual(false, tempBool.AsBoolean()); } /// @@ -496,23 +496,23 @@ namespace LibreMetaverse.Tests byte[] bytes = Encoding.UTF8.GetBytes(testSD); theSD = OSDParser.DeserializeLLSDXml(bytes); - Assert.IsTrue(theSD is OSDArray); + ClassicAssert.IsTrue(theSD is OSDArray); array = (OSDArray)theSD; - Assert.AreEqual(OSDType.Binary, array[0].Type); + ClassicAssert.AreEqual(OSDType.Binary, array[0].Type); tempBinary = (OSDBinary)array[0]; byte[] testData1 = {114, 97, 110, 100, 111, 109}; TestHelper.TestBinary(tempBinary, testData1); - Assert.AreEqual(OSDType.Binary, array[1].Type); + ClassicAssert.AreEqual(OSDType.Binary, array[1].Type); tempBinary = (OSDBinary)array[1]; byte[] testData2 = {116, 104, 101, 32, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120}; TestHelper.TestBinary(tempBinary, testData2); - Assert.AreEqual(OSDType.Binary, array[1].Type); + ClassicAssert.AreEqual(OSDType.Binary, array[1].Type); tempBinary = (OSDBinary)array[2]; - Assert.AreEqual(0, tempBinary.AsBinary().Length); + ClassicAssert.AreEqual(0, tempBinary.AsBinary().Length); } /// @@ -534,7 +534,7 @@ namespace LibreMetaverse.Tests byte[] bytes = Encoding.UTF8.GetBytes(testSD); theSD = OSDParser.DeserializeLLSDXml(bytes); - Assert.IsTrue(theSD != null); + ClassicAssert.IsTrue(theSD != null); } /// @@ -558,17 +558,17 @@ namespace LibreMetaverse.Tests byte[] bytes = Encoding.UTF8.GetBytes(testSD); theSD = OSDParser.DeserializeLLSDXml(bytes); - Assert.IsTrue(theSD is OSDArray); + ClassicAssert.IsTrue(theSD is OSDArray); array = (OSDArray)theSD; - Assert.AreEqual(OSDType.URI, array[0].Type); + ClassicAssert.AreEqual(OSDType.URI, array[0].Type); tempURI = (OSDUri)array[0]; Uri testURI = new Uri("http://sim956.agni.lindenlab.com:12035/runtime/agents"); - Assert.AreEqual(testURI, tempURI.AsUri()); + ClassicAssert.AreEqual(testURI, tempURI.AsUri()); - Assert.AreEqual(OSDType.URI, array[1].Type); + ClassicAssert.AreEqual(OSDType.URI, array[1].Type); tempURI = (OSDUri)array[1]; - Assert.AreEqual("", tempURI.AsUri().ToString()); + ClassicAssert.AreEqual("", tempURI.AsUri().ToString()); } /// @@ -611,36 +611,36 @@ namespace LibreMetaverse.Tests byte[] bytes = Encoding.UTF8.GetBytes(testSD); theSD = OSDParser.DeserializeLLSDXml(bytes); - Assert.IsTrue(theSD is OSDArray); + ClassicAssert.IsTrue(theSD is OSDArray); array = (OSDArray)theSD; - Assert.AreEqual(2, array.Count); + ClassicAssert.AreEqual(2, array.Count); //The first element of top level array, a map - Assert.AreEqual(OSDType.Map, array[0].Type); + ClassicAssert.AreEqual(OSDType.Map, array[0].Type); map = (OSDMap)array[0]; //First nested map tempSD = map["Map One"]; - Assert.IsNotNull(tempSD); - Assert.AreEqual(OSDType.Map, tempSD.Type); + ClassicAssert.IsNotNull(tempSD); + ClassicAssert.AreEqual(OSDType.Map, tempSD.Type); map = (OSDMap)tempSD; //First nested array tempSD = map["Array One"]; - Assert.IsNotNull(tempSD); - Assert.AreEqual(OSDType.Array, tempSD.Type); + ClassicAssert.IsNotNull(tempSD); + ClassicAssert.AreEqual(OSDType.Array, tempSD.Type); array = (OSDArray)tempSD; - Assert.AreEqual(2, array.Count); + ClassicAssert.AreEqual(2, array.Count); array = (OSDArray)theSD; //Second element of top level array, an array tempSD = array[1]; - Assert.AreEqual(OSDType.Array, tempSD.Type); + ClassicAssert.AreEqual(OSDType.Array, tempSD.Type); array = (OSDArray)tempSD; - Assert.AreEqual(3, array.Count); + ClassicAssert.AreEqual(3, array.Count); //Nested array tempSD = array[2]; - Assert.AreEqual(OSDType.Array, tempSD.Type); + ClassicAssert.AreEqual(OSDType.Array, tempSD.Type); array = (OSDArray)tempSD; - Assert.AreEqual(3, array.Count); + ClassicAssert.AreEqual(3, array.Count); } } @@ -655,12 +655,12 @@ namespace LibreMetaverse.Tests internal static void TestBinary(OSDBinary inBinary, byte[] inExpected) { byte[] binary = inBinary.AsBinary(); - Assert.AreEqual(inExpected.Length, binary.Length); + ClassicAssert.AreEqual(inExpected.Length, binary.Length); for (int i = 0; i < inExpected.Length; i++) { if (inExpected[i] != binary[i]) { - Assert.Fail("Expected " + inExpected[i] + " at position " + i + + ClassicAssert.Fail("Expected " + inExpected[i] + " at position " + i + " but saw " + binary[i]); } }