Miko/libremetaverse
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

NUnit4 Update redux. These OSD tests are AWFUl and should just be rewritten instead of updated.

Browse Source
This commit is contained in:
Cinder Roxley
2024-07-06 09:04:54 -05:00
parent 060ed00035
commit c8c0186c4e
11 changed files with 1052 additions and 1034 deletions
Download Patch File Download Diff File Expand all files Collapse all files

299
LibreMetaverse.Tests/BinaryLLSDTests.cs
View File

@@ -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 = "<x>&#x196;&#x214;&#x220;&#x228;&#x246;&#x252;</x>";
@@ -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 = "<x>&#x10137;</x>";
@@ -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 = "<x>&#x10137;</x>";
@@ -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());
}

14
LibreMetaverse.Tests/GridClientTests.cs
View File

@@ -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);
}
}
}

6
LibreMetaverse.Tests/LibreMetaverse.Tests.csproj
View File

@@ -37,9 +37,9 @@
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.1" />
<PackageReference Include="NUnit" Version="3.13.3" />
<PackageReference Include="NUnit.ConsoleRunner" Version="3.16.3" />
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0" />
<PackageReference Include="NUnit" Version="4.1.0" />
<PackageReference Include="NUnit.ConsoleRunner" Version="3.17.0" />
<PackageReference Include="NUnit3TestAdapter" Version="4.5.0">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

813
LibreMetaverse.Tests/MessageTests.cs
View File

File diff suppressed because it is too large Load Diff

12
LibreMetaverse.Tests/NetworkTests.cs
View File

@@ -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()

401
LibreMetaverse.Tests/NotationLLSDTests.cs
View File

@@ -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 = "<x>&#x10137;</x>";
@@ -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.
}
}

75
LibreMetaverse.Tests/PacketTests.cs
View File

@@ -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");
}
}
}

27
LibreMetaverse.Tests/PrimObjectTests.cs
View File

@@ -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");
}
}
}

185
LibreMetaverse.Tests/TypeTests.cs
View File

@@ -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<string, double>();
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<string, double>
{
["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<string, double> 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<OSDArray>(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<OSDArray>(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<OSDArray>(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<OSDMap>(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<OSDArray>(hashtable["region_handle"]);
Assert.IsTrue(((OSDArray)hashtable["region_handle"]).Count == 2);
Assert.IsInstanceOf<OSDArray>(hashtable["position"]);
Assert.IsTrue(((OSDArray)hashtable["position"]).Count == 3);
Assert.IsInstanceOf<OSDArray>(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);
}
}
}

2
LibreMetaverse.Tests/UtilsConversionsTests.cs
View File

@@ -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));
}
}
}

252
LibreMetaverse.Tests/XmlLLSDTests.cs
View File

@@ -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
{
/// <summary>
/// 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
/// </summary>
[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");
}
/// <summary>
@@ -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");
}
/// <summary>
@@ -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());
}
/// <summary>
@@ -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());
}
/// <summary>
@@ -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());
}
/// <summary>
@@ -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());
}
/// <summary>
@@ -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());
}
/// <summary>
@@ -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);
}
/// <summary>
@@ -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);
}
/// <summary>
@@ -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());
}
/// <summary>
@@ -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]);
}
}