public void ReadAsTagTest4()
{
// read a bunch of lists as tags
byte[] testData = new NbtFile(TestFiles.MakeListTest()).SaveToBuffer(NbtCompression.None);
// first, read everything all-at-once
{
var reader = new NbtReader(new MemoryStream(testData));
while (!reader.IsAtStreamEnd)
{
Console.WriteLine(reader.ReadAsTag());
}
}
// next, read each list individually
{
var reader = new NbtReader(new MemoryStream(testData));
reader.ReadToFollowing(); // read to root
reader.ReadToFollowing(); // read to first list tag
while (!reader.IsAtStreamEnd)
{
Console.WriteLine(reader.ReadAsTag());
}
}
}
public Map LoadHeader(string path)
{
using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read)) {
using (GZipStream gs = new GZipStream(fs, CompressionMode.Decompress)) {
NbtReader reader = new NbtReader(gs);
reader.ReadToFollowing(); // skip root tag
reader.ReadToFollowing(); // skip to first inner tag
int width = 0,
length = 0,
height = 0;
do
{
switch (reader.TagName)
{
case "X":
width = reader.ReadValueAs <short>();
break;
case "Y":
height = reader.ReadValueAs <short>();
break;
case "Z":
length = reader.ReadValueAs <short>();
break;
}
if (width > 0 && length > 0 && height > 0)
{
return(new Map(null, width, length, height, false));
}
} while (reader.ReadToNextSibling());
}
}
throw new MapFormatException("Could not locate map dimensions.");
}
public void ReadToDescendantTest()
{
var reader = new NbtReader(TestFiles.MakeReaderTest());
Assert.IsTrue(reader.ReadToDescendant("third-comp"));
Assert.AreEqual("third-comp", reader.TagName);
Assert.IsTrue(reader.ReadToDescendant("inComp2"));
Assert.AreEqual("inComp2", reader.TagName);
Assert.IsFalse(reader.ReadToDescendant("derp"));
Assert.AreEqual("inComp3", reader.TagName);
reader.ReadToFollowing(); // at fourth-list
Assert.IsTrue(reader.ReadToDescendant("inList2"));
Assert.AreEqual("inList2", reader.TagName);
// Read through the rest of the file until we run out of tags in a compound
Assert.IsFalse(reader.ReadToDescendant("*"));
// Ensure ReadToDescendant returns false when at end-of-stream
while (reader.ReadToFollowing())
{
}
Assert.IsFalse(reader.ReadToDescendant("*"));
// Ensure that this works even on the root
Assert.IsFalse(new NbtReader(TestFiles.MakeReaderTest()).ReadToDescendant("*"));
}
public void ReadValueAsTest()
{
byte[] testData = new NbtFile(TestFiles.MakeValueTest()).SaveToBuffer(NbtCompression.None);
var reader = new NbtReader(new MemoryStream(testData));
Assert.IsTrue(reader.ReadToFollowing()); // root
Assert.IsTrue(reader.ReadToFollowing()); // byte
Assert.AreEqual(1, reader.ReadValueAs <byte>());
Assert.IsTrue(reader.ReadToFollowing()); // short
Assert.AreEqual(2, reader.ReadValueAs <short>());
Assert.IsTrue(reader.ReadToFollowing()); // int
Assert.AreEqual(3, reader.ReadValueAs <int>());
Assert.IsTrue(reader.ReadToFollowing()); // long
Assert.AreEqual(4L, reader.ReadValueAs <long>());
Assert.IsTrue(reader.ReadToFollowing()); // float
Assert.AreEqual(5f, reader.ReadValueAs <float>());
Assert.IsTrue(reader.ReadToFollowing()); // double
Assert.AreEqual(6d, reader.ReadValueAs <double>());
Assert.IsTrue(reader.ReadToFollowing()); // byteArray
CollectionAssert.AreEqual(new byte[] { 10, 11, 12 }, reader.ReadValueAs <byte[]>());
Assert.IsTrue(reader.ReadToFollowing()); // intArray
CollectionAssert.AreEqual(new[] { 20, 21, 22 }, reader.ReadValueAs <int[]>());
Assert.IsTrue(reader.ReadToFollowing()); // string
Assert.AreEqual("123", reader.ReadValueAs <string>());
}
public void ErrorTest()
{
var root = new NbtCompound("root");
byte[] testData = new NbtFile(root).SaveToBuffer(NbtCompression.None);
// creating NbtReader without a stream, or with a non-readable stream
Assert.Throws <ArgumentNullException>(() => new NbtReader(null));
Assert.Throws <ArgumentException>(() => new NbtReader(new NonReadableStream()));
// corrupt the data
testData[0] = 123;
var reader = new NbtReader(new MemoryStream(testData));
// attempt to use ReadValue when not at value
Assert.Throws <InvalidOperationException>(() => reader.ReadValue());
reader.CacheTagValues = true;
Assert.Throws <InvalidOperationException>(() => reader.ReadValue());
// attempt to read a corrupt stream
Assert.Throws <NbtFormatException>(() => reader.ReadToFollowing());
// make sure we've properly entered the error state
Assert.IsTrue(reader.IsInErrorState);
Assert.IsFalse(reader.HasName);
Assert.Throws <InvalidReaderStateException>(() => reader.ReadToFollowing());
Assert.Throws <InvalidReaderStateException>(() => reader.ReadListAsArray <int>());
Assert.Throws <InvalidReaderStateException>(() => reader.ReadToNextSibling());
Assert.Throws <InvalidReaderStateException>(() => reader.ReadToDescendant("derp"));
Assert.Throws <InvalidReaderStateException>(() => reader.ReadAsTag());
Assert.Throws <InvalidReaderStateException>(() => reader.Skip());
}
private static (string, Dictionary <string, Object>) GetNbtVal(MemoryStream ms)
{
string name = "";
var nbt = new NbtReader(ms, false);
var dictParams = new Dictionary <string, Object>();
nbt.ReadToFollowing();
if (!nbt.IsCompound)
{
throw new Exception("Could not read nbt");
}
if (nbt.ReadToDescendant("name"))
{
name = nbt.ReadValueAs <string>();
nbt.ReadToNextSibling();
while (nbt.TagType != NbtTagType.End)
{
fNbt.Tags.NbtTag tag = nbt.ReadAsTag();
switch (tag.Name)
{
case "version":
continue;
case "states":
IEnumerable <fNbt.Tags.NbtTag> enumTag = (IEnumerable <fNbt.Tags.NbtTag>)tag;
foreach (var subtag in enumTag)
{
if ((subtag.Name == "direction") || (subtag.Name == "facing_direction") || (subtag.Name == "open_bit"))
{
int subtagvalue = GetTagValue(subtag);
dictParams.Add(subtag.Name, subtagvalue);
}
if ((subtag.Name == "color") || (subtag.Name == "lever_direction"))
{
if (subtag.TagType == NbtTagType.String)
{
dictParams.Add(subtag.Name, subtag.StringValue);
}
}
}
break;
case "val":
int value = GetTagValue(tag);
dictParams.Add(tag.Name, value);
break;
}
}
}
while (!nbt.IsAtStreamEnd)
{
nbt.ReadToFollowing();
}
return(name, dictParams);
}
public void ReadToFollowingNotFound()
{
var reader = new NbtReader(TestFiles.MakeReaderTest());
Assert.IsTrue(reader.ReadToFollowing()); // at "root"
Assert.IsFalse(reader.ReadToFollowing("no such tag"));
Assert.IsFalse(reader.ReadToFollowing("not this one either"));
Assert.IsTrue(reader.IsAtStreamEnd);
}
private static (string, Dictionary <string, Object>) GetNbtVal(MemoryStream ms)
{
string name = "";
var nbt = new NbtReader(ms, false);
var dictParams = new Dictionary <string, Object>();
nbt.ReadToFollowing();
if (!nbt.IsCompound)
{
throw new Exception("Could not read nbt");
}
if (nbt.ReadToDescendant("name"))
{
name = nbt.ReadValueAs <string>();
nbt.ReadToNextSibling();
while (nbt.TagType != NbtTagType.End)
{
fNbt.Tags.NbtTag tag = nbt.ReadAsTag();
switch (tag.Name)
{
case "version":
continue;
case "states":
IEnumerable <fNbt.Tags.NbtTag> enumTag = (IEnumerable <fNbt.Tags.NbtTag>)tag;
foreach (var subtag in enumTag)
{
if ((subtag.Name == "direction") || (subtag.Name == "facing_direction") || (subtag.Name == "open_bit") || (subtag.Name == "multi_face_direction_bits") || (subtag.Name == "stripped_bit") || (subtag.Name == "wall_post_bit") || (subtag.Name == "button_pressed_bit") || (subtag.Name == "rail_direction") || (subtag.Name == "rail_data_bit") || (subtag.Name == "bite_counter") || (subtag.Name == "respawn_anchor_charge") || (subtag.Name == "growth") || (subtag.Name == "powered_bit") || (subtag.Name == "upper_block_bit") || (subtag.Name == "hanging") || (subtag.Name == "coral_direction") || (subtag.Name == "coral_hang_type_bit") || (subtag.Name == "dead_bit") || (subtag.Name == "end_portal_eye_bit") || (subtag.Name == "head_piece_bit") || (subtag.Name == "age"))
{
int subtagvalue = GetTagValue(subtag);
dictParams.Add(subtag.Name, subtagvalue);
}
if ((subtag.Name == "color") || (subtag.Name == "lever_direction") || (subtag.Name == "wall_block_type") || (subtag.Name == "pillar_axis") || (subtag.Name == "wood_type") || (subtag.Name == "old_log_type") || (subtag.Name == "new_log_type") || (subtag.Name == "old_leaf_type") || (subtag.Name == "new_leaf_type") || (subtag.Name == "sapling_type") || subtag.Name.StartsWith("wall_connection_type_") || (subtag.Name == "chisel_type") || subtag.Name.StartsWith("stone_slab_type") || (subtag.Name == "sponge_type") || (subtag.Name == "double_plant_type") || (subtag.Name == "flower_type") || (subtag.Name == "sand_type") || (subtag.Name == "stone_type") || (subtag.Name == "damage") || (subtag.Name == "dripstone_thickness") || (subtag.Name == "coral_color") || (subtag.Name == "monster_egg_stone_type") || (subtag.Name == "stone_brick_type"))
{
dictParams.Add(subtag.Name, subtag.StringValue);
}
}
break;
case "val":
int value = GetTagValue(tag);
dictParams.Add(tag.Name, value);
break;
}
}
}
while (!nbt.IsAtStreamEnd)
{
nbt.ReadToFollowing();
}
return(name, dictParams);
}
public void ReadListAsArray()
{
NbtCompound intList = TestFiles.MakeListTest();
var ms = new MemoryStream();
new NbtFile(intList).SaveToStream(ms, NbtCompression.None);
ms.Seek(0, SeekOrigin.Begin);
var reader = new NbtReader(ms);
// attempt to read value before we're in a list
Assert.Throws <InvalidOperationException>(() => reader.ReadListAsArray <int>());
// test byte values
reader.ReadToFollowing("ByteList");
byte[] bytes = reader.ReadListAsArray <byte>();
CollectionAssert.AreEqual(new byte[] { 100, 20, 3 }, bytes);
// test double values
reader.ReadToFollowing("DoubleList");
double[] doubles = reader.ReadListAsArray <double>();
CollectionAssert.AreEqual(new[] { 1d, 2000d, -3000000d }, doubles);
// test float values
reader.ReadToFollowing("FloatList");
float[] floats = reader.ReadListAsArray <float>();
CollectionAssert.AreEqual(new[] { 1f, 2000f, -3000000f }, floats);
// test int values
reader.ReadToFollowing("IntList");
int[] ints = reader.ReadListAsArray <int>();
CollectionAssert.AreEqual(new[] { 1, 2000, -3000000 }, ints);
// test long values
reader.ReadToFollowing("LongList");
long[] longs = reader.ReadListAsArray <long>();
CollectionAssert.AreEqual(new[] { 1L, 2000L, -3000000L }, longs);
// test short values
reader.ReadToFollowing("ShortList");
short[] shorts = reader.ReadListAsArray <short>();
CollectionAssert.AreEqual(new short[] { 1, 200, -30000 }, shorts);
// test short values
reader.ReadToFollowing("StringList");
string[] strings = reader.ReadListAsArray <string>();
CollectionAssert.AreEqual(new[] { "one", "two thousand", "negative three million" }, strings);
// try reading list of compounds (should fail)
reader.ReadToFollowing("CompoundList");
Assert.Throws <InvalidOperationException>(() => reader.ReadListAsArray <NbtCompound>());
// skip to the end of the stream
while (reader.ReadToFollowing())
{
}
Assert.Throws <EndOfStreamException>(() => reader.ReadListAsArray <int>());
}
public void CacheTagValuesTest()
{
byte[] testData = new NbtFile(TestFiles.MakeValueTest()).SaveToBuffer(NbtCompression.None);
var reader = new NbtReader(new MemoryStream(testData));
Assert.IsFalse(reader.CacheTagValues);
reader.CacheTagValues = true;
Assert.IsTrue(reader.ReadToFollowing()); // root
Assert.IsTrue(reader.ReadToFollowing()); // byte
Assert.AreEqual(reader.ReadValue(), 1);
Assert.AreEqual(reader.ReadValue(), 1);
Assert.IsTrue(reader.ReadToFollowing()); // short
Assert.AreEqual(reader.ReadValue(), 2);
Assert.AreEqual(reader.ReadValue(), 2);
Assert.IsTrue(reader.ReadToFollowing()); // int
Assert.AreEqual(reader.ReadValue(), 3);
Assert.AreEqual(reader.ReadValue(), 3);
Assert.IsTrue(reader.ReadToFollowing()); // long
Assert.AreEqual(reader.ReadValue(), 4L);
Assert.AreEqual(reader.ReadValue(), 4L);
Assert.IsTrue(reader.ReadToFollowing()); // float
Assert.AreEqual(reader.ReadValue(), 5f);
Assert.AreEqual(reader.ReadValue(), 5f);
Assert.IsTrue(reader.ReadToFollowing()); // double
Assert.AreEqual(reader.ReadValue(), 6d);
Assert.AreEqual(reader.ReadValue(), 6d);
Assert.IsTrue(reader.ReadToFollowing()); // byteArray
CollectionAssert.AreEqual((byte[])reader.ReadValue(),
new byte[] {
10, 11, 12
});
CollectionAssert.AreEqual((byte[])reader.ReadValue(),
new byte[] {
10, 11, 12
});
Assert.IsTrue(reader.ReadToFollowing()); // intArray
CollectionAssert.AreEqual((int[])reader.ReadValue(),
new[] {
20, 21, 22
});
CollectionAssert.AreEqual((int[])reader.ReadValue(),
new[] {
20, 21, 22
});
Assert.IsTrue(reader.ReadToFollowing()); // string
Assert.AreEqual(reader.ReadValue(), "123");
Assert.AreEqual(reader.ReadValue(), "123");
}
public void ReadToSiblingTest()
{
NbtReader reader = new NbtReader(MakeTest());
Assert.IsTrue(reader.ReadToFollowing());
Assert.AreEqual(reader.TagName, "root");
Assert.IsTrue(reader.ReadToFollowing());
Assert.AreEqual(reader.TagName, "first");
Assert.IsTrue(reader.ReadToNextSibling("third-comp"));
Assert.AreEqual(reader.TagName, "third-comp");
Assert.IsTrue(reader.ReadToNextSibling());
Assert.AreEqual(reader.TagName, "fourth-list");
Assert.IsTrue(reader.ReadToNextSibling());
Assert.AreEqual(reader.TagName, "fifth");
Assert.IsFalse(reader.ReadToNextSibling());
}
public void EndTagTest()
{
using (MemoryStream ms = new MemoryStream()) {
var root = new NbtCompound("root")
{
new NbtInt("test", 0)
};
new NbtFile(root).SaveToStream(ms, NbtCompression.None);
ms.Position = 0;
NbtReader reader = new NbtReader(ms)
{
SkipEndTags = false
};
reader.ReadToDescendant("test");
Assert.AreEqual(NbtTagType.Int, reader.TagType);
Assert.IsTrue(reader.ReadToNextSibling());
// should be at root's End tag now
Assert.AreEqual(NbtTagType.End, reader.TagType);
Assert.IsFalse(reader.IsInErrorState);
Assert.IsFalse(reader.IsAtStreamEnd);
Assert.IsFalse(reader.IsCompound);
Assert.IsFalse(reader.IsList);
Assert.IsFalse(reader.IsListElement);
Assert.IsFalse(reader.HasValue);
Assert.IsFalse(reader.HasName);
Assert.IsFalse(reader.HasLength);
Assert.Throws <InvalidOperationException>(() => reader.ReadAsTag()); // Cannot create NbtTag from TAG_END
// We done now
Assert.IsFalse(reader.ReadToFollowing());
Assert.IsTrue(reader.IsAtStreamEnd);
}
}
public void ErrorTest()
{
var root = new NbtCompound("root");
byte[] testData = new NbtFile(root).SaveToBuffer(NbtCompression.None);
// creating NbtReader without a stream, or with a non-readable stream
Assert.Throws<ArgumentNullException>(() => new NbtReader(null));
Assert.Throws<ArgumentException>(() => new NbtReader(new NonReadableStream()));
// corrupt the data
testData[0] = 123;
var reader = new NbtReader(new MemoryStream(testData));
// attempt to use ReadValue when not at value
Assert.Throws<InvalidOperationException>(() => reader.ReadValue());
reader.CacheTagValues = true;
Assert.Throws<InvalidOperationException>(() => reader.ReadValue());
// attempt to read a corrupt stream
Assert.Throws<NbtFormatException>(() => reader.ReadToFollowing());
// make sure we've properly entered the error state
Assert.IsTrue(reader.IsInErrorState);
Assert.IsFalse(reader.HasName);
Assert.Throws<InvalidReaderStateException>(() => reader.ReadToFollowing());
Assert.Throws<InvalidReaderStateException>(() => reader.ReadListAsArray<int>());
Assert.Throws<InvalidReaderStateException>(() => reader.ReadToNextSibling());
Assert.Throws<InvalidReaderStateException>(() => reader.ReadToDescendant("derp"));
Assert.Throws<InvalidReaderStateException>(() => reader.ReadAsTag());
Assert.Throws<InvalidReaderStateException>(() => reader.Skip());
}
public void NestedListTest()
{
var root = new NbtCompound("root")
{
new NbtList("OuterList")
{
new NbtList {
new NbtByte()
},
new NbtList {
new NbtShort()
},
new NbtList {
new NbtInt()
}
}
};
byte[] testData = new NbtFile(root).SaveToBuffer(NbtCompression.None);
using (var ms = new MemoryStream(testData)) {
var reader = new NbtReader(ms);
while (reader.ReadToFollowing())
{
Console.WriteLine(reader.ToString(true));
}
}
}
private static (string, int) GetNbtVal(MemoryStream ms)
{
int value = 0;
string name = "";
var nbt = new NbtReader(ms, false);
nbt.ReadToFollowing();
if (!nbt.IsCompound)
{
throw new Exception("Could not read nbt");
}
if (nbt.ReadToDescendant("name"))
{
name = nbt.ReadValueAs <string>();
}
if (nbt.ReadToNextSibling("val"))
{
switch (nbt.TagType)
{
case NbtTagType.Int:
value = nbt.ReadValueAs <int>();
break;
case NbtTagType.Short:
value = nbt.ReadValueAs <short>();
break;
case NbtTagType.Long:
value = (int)nbt.ReadValueAs <long>();
break;
default:
Console.WriteLine("could not comprehend val");
break;
}
}
while (!nbt.IsAtStreamEnd)
{
nbt.ReadToFollowing();
}
return(name, value);
}
public void ReadAsTagTest3()
{
// read values as tags
byte[] testData = new NbtFile(TestFiles.MakeValueTest()).SaveToBuffer(NbtCompression.None);
var reader = new NbtReader(new MemoryStream(testData));
var root = new NbtCompound("root");
// skip root
reader.ReadToFollowing();
reader.ReadToFollowing();
while (!reader.IsAtStreamEnd)
{
root.Add(reader.ReadAsTag());
}
TestFiles.AssertValueTest(new NbtFile(root));
}
public void ReadToSiblingTest2()
{
var reader = new NbtReader(TestFiles.MakeReaderTest());
Assert.IsTrue(reader.ReadToFollowing("inComp1"));
// Expect all siblings to be read while we search for a non-existent one
Assert.IsFalse(reader.ReadToNextSibling("no such tag"));
// Expect to pop out of "third-comp" by now
Assert.AreEqual("fourth-list", reader.TagName);
}
public void NonSeekableStreamSkip2()
{
using (var ms = TestFiles.MakeReaderTest()) {
using (var nss = new NonSeekableStream(ms)) {
var reader = new NbtReader(nss);
reader.ReadToFollowing();
reader.Skip();
}
}
}
public void NonSeekableStreamSkip1()
{
byte[] fileBytes = File.ReadAllBytes("TestFiles/bigtest.nbt");
using (var ms = new MemoryStream(fileBytes)) {
using (var nss = new NonSeekableStream(ms)) {
var reader = new NbtReader(nss);
reader.ReadToFollowing();
reader.Skip();
}
}
}
public void ReadToDescendantTest()
{
var reader = new NbtReader(TestFiles.MakeReaderTest());
Assert.IsTrue(reader.ReadToDescendant("third-comp"));
Assert.AreEqual("third-comp", reader.TagName);
Assert.IsTrue(reader.ReadToDescendant("inComp2"));
Assert.AreEqual("inComp2", reader.TagName);
Assert.IsFalse(reader.ReadToDescendant("derp"));
Assert.AreEqual("inComp3", reader.TagName);
reader.ReadToFollowing(); // at fourth-list
Assert.IsTrue(reader.ReadToDescendant("inList2"));
Assert.AreEqual("inList2", reader.TagName);
// Ensure ReadToDescendant returns false when at end-of-stream
while (reader.ReadToFollowing())
{
}
Assert.IsFalse(reader.ReadToDescendant("*"));
}
public void PrintBigFileUncompressed()
{
using( FileStream fs = File.OpenRead( "TestFiles/bigtest.nbt" ) ) {
NbtReader reader = new NbtReader( fs );
while( reader.ReadToFollowing() ) {
Console.Write( "@" + reader.TagStartOffset + " " );
Console.WriteLine( reader.ToString( true ) );
}
Assert.AreEqual( reader.RootName, "Level" );
}
}
public void ReadToSiblingTest()
{
var reader = new NbtReader(TestFiles.MakeReaderTest());
Assert.IsTrue(reader.ReadToFollowing());
Assert.AreEqual("root", reader.TagName);
Assert.IsTrue(reader.ReadToFollowing());
Assert.AreEqual("first", reader.TagName);
Assert.IsTrue(reader.ReadToNextSibling("third-comp"));
Assert.AreEqual("third-comp", reader.TagName);
Assert.IsTrue(reader.ReadToNextSibling());
Assert.AreEqual("fourth-list", reader.TagName);
Assert.IsTrue(reader.ReadToNextSibling());
Assert.AreEqual("fifth", reader.TagName);
Assert.IsTrue(reader.ReadToNextSibling());
Assert.AreEqual("hugeArray", reader.TagName);
Assert.IsFalse(reader.ReadToNextSibling());
// Test twice, since we hit different paths through the code
Assert.IsFalse(reader.ReadToNextSibling());
}
public void ReadAsTagTest1()
{
// read various lists/compounds as tags
var reader = new NbtReader(TestFiles.MakeReaderTest());
reader.ReadToFollowing(); // skip root
while (!reader.IsAtStreamEnd)
{
reader.ReadAsTag();
}
Assert.Throws <EndOfStreamException>(() => reader.ReadAsTag());
}
public void PrintBigFileUncompressed()
{
using (FileStream fs = File.OpenRead("TestFiles/bigtest.nbt")) {
NbtReader reader = new NbtReader(fs);
while (reader.ReadToFollowing())
{
Console.Write("@" + reader.TagStartOffset + " ");
Console.WriteLine(reader.ToString(true));
}
Assert.AreEqual(reader.RootName, "Level");
}
}
public void PrintBigFileUncompressed()
{
using (FileStream fs = File.OpenRead(TestFiles.Big)) {
var reader = new NbtReader(fs);
Assert.AreEqual(fs, reader.BaseStream);
while (reader.ReadToFollowing())
{
Console.Write("@" + reader.TagStartOffset + " ");
Console.WriteLine(reader.ToString());
}
Assert.AreEqual("Level", reader.RootName);
}
}
public void ReadValueTest()
{
NbtCompound root = new NbtCompound("root")
{
new NbtByte("byte", 1),
new NbtShort("short", 2),
new NbtInt("int", 3),
new NbtLong("long", 4),
new NbtFloat("float", 5),
new NbtDouble("double", 6),
new NbtByteArray("byteArray", new byte[] { 10, 11, 12 }),
new NbtIntArray("intArray", new[] { 20, 21, 22 }),
new NbtString("string", "23")
};
byte[] testData = new NbtFile(root).SaveToBuffer(NbtCompression.None);
NbtReader reader = new NbtReader(new MemoryStream(testData));
Assert.IsTrue(reader.ReadToFollowing()); // root
Assert.IsTrue(reader.ReadToFollowing()); // byte
Assert.AreEqual(reader.ReadValue(), 1);
Assert.IsTrue(reader.ReadToFollowing()); // short
Assert.AreEqual(reader.ReadValue(), 2);
Assert.IsTrue(reader.ReadToFollowing()); // int
Assert.AreEqual(reader.ReadValue(), 3);
Assert.IsTrue(reader.ReadToFollowing()); // long
Assert.AreEqual(reader.ReadValue(), 4);
Assert.IsTrue(reader.ReadToFollowing()); // float
Assert.AreEqual(reader.ReadValue(), 5f);
Assert.IsTrue(reader.ReadToFollowing()); // double
Assert.AreEqual(reader.ReadValue(), 6d);
Assert.IsTrue(reader.ReadToFollowing()); // byteArray
CollectionAssert.AreEqual((byte[])reader.ReadValue(), new byte[] { 10, 11, 12 });
Assert.IsTrue(reader.ReadToFollowing()); // intArray
CollectionAssert.AreEqual((int[])reader.ReadValue(), new[] { 20, 21, 22 });
Assert.IsTrue(reader.ReadToFollowing()); // string
Assert.AreEqual(reader.ReadValue(), "23");
}
public void ReadToDescendantTest()
{
NbtReader reader = new NbtReader(MakeTest());
Assert.IsTrue(reader.ReadToDescendant("third-comp"));
Assert.AreEqual(reader.TagName, "third-comp");
Assert.IsTrue(reader.ReadToDescendant("inComp2"));
Assert.AreEqual(reader.TagName, "inComp2");
Assert.IsFalse(reader.ReadToDescendant("derp"));
Assert.AreEqual(reader.TagName, "inComp3");
reader.ReadToFollowing(); // at fourth-list
Assert.IsTrue(reader.ReadToDescendant("inList2"));
Assert.AreEqual(reader.TagName, "inList2");
}
void TryReadBadFile(byte[] data)
{
using (MemoryStream ms = new MemoryStream(data)) {
NbtReader reader = new NbtReader(ms);
try {
while (reader.ReadToFollowing())
{
}
} catch (Exception) {
Assert.IsTrue(reader.IsInErrorState);
throw;
}
}
}
public void CacheTagValuesTest()
{
byte[] testData = new NbtFile(TestFiles.MakeValueTest()).SaveToBuffer(NbtCompression.None);
var reader = new NbtReader(new MemoryStream(testData));
Assert.IsFalse(reader.CacheTagValues);
reader.CacheTagValues = true;
Assert.IsTrue(reader.ReadToFollowing()); // root
Assert.IsTrue(reader.ReadToFollowing()); // byte
Assert.AreEqual(1, reader.ReadValue());
Assert.AreEqual(1, reader.ReadValue());
Assert.IsTrue(reader.ReadToFollowing()); // short
Assert.AreEqual(2, reader.ReadValue());
Assert.AreEqual(2, reader.ReadValue());
Assert.IsTrue(reader.ReadToFollowing()); // int
Assert.AreEqual(3, reader.ReadValue());
Assert.AreEqual(3, reader.ReadValue());
Assert.IsTrue(reader.ReadToFollowing()); // long
Assert.AreEqual(4L, reader.ReadValue());
Assert.AreEqual(4L, reader.ReadValue());
Assert.IsTrue(reader.ReadToFollowing()); // float
Assert.AreEqual(5f, reader.ReadValue());
Assert.AreEqual(5f, reader.ReadValue());
Assert.IsTrue(reader.ReadToFollowing()); // double
Assert.AreEqual(6d, reader.ReadValue());
Assert.AreEqual(6d, reader.ReadValue());
Assert.IsTrue(reader.ReadToFollowing()); // byteArray
CollectionAssert.AreEqual(new byte[] { 10, 11, 12 }, (byte[])reader.ReadValue());
CollectionAssert.AreEqual(new byte[] { 10, 11, 12 }, (byte[])reader.ReadValue());
Assert.IsTrue(reader.ReadToFollowing()); // intArray
CollectionAssert.AreEqual(new[] { 20, 21, 22 }, (int[])reader.ReadValue());
CollectionAssert.AreEqual(new[] { 20, 21, 22 }, (int[])reader.ReadValue());
Assert.IsTrue(reader.ReadToFollowing()); // string
Assert.AreEqual("123", reader.ReadValue());
Assert.AreEqual("123", reader.ReadValue());
}
public void PrintBigFileUncompressedNoSkip()
{
using (FileStream fs = File.OpenRead("TestFiles/bigtest.nbt")) {
var reader = new NbtReader(fs)
{
SkipEndTags = false
};
Assert.AreEqual(fs, reader.BaseStream);
while (reader.ReadToFollowing())
{
Console.Write("@" + reader.TagStartOffset + " ");
Console.WriteLine(reader.ToString());
}
Assert.AreEqual("Level", reader.RootName);
}
}
public void PrintBigFileUncompressedNoSkip()
{
using (FileStream fs = File.OpenRead("TestFiles/bigtest.nbt"))
{
var reader = new NbtReader(fs)
{
SkipEndTags = false
};
Assert.Equal(fs, reader.BaseStream);
while (reader.ReadToFollowing())
{
Console.Write("@" + reader.TagStartOffset + " ");
Console.WriteLine(reader.ToString());
}
Assert.Equal("Level", reader.RootName);
}
}
public void ReadListAsArrayRecast()
{
NbtCompound intList = TestFiles.MakeListTest();
var ms = new MemoryStream();
new NbtFile(intList).SaveToStream(ms, NbtCompression.None);
ms.Seek(0, SeekOrigin.Begin);
var reader = new NbtReader(ms);
// test bytes as shorts
reader.ReadToFollowing("ByteList");
short[] bytes = reader.ReadListAsArray <short>();
CollectionAssert.AreEqual(bytes,
new short[] {
100, 20, 3
});
}
public void SkipTest()
{
NbtReader reader = new NbtReader(MakeTest());
reader.ReadToFollowing(); // at root
reader.ReadToFollowing(); // at first
reader.ReadToFollowing(); // at second
reader.ReadToFollowing(); // at third-comp
reader.ReadToFollowing(); // at inComp1
Assert.AreEqual(reader.TagName, "inComp1");
Assert.AreEqual(reader.Skip(), 2);
Assert.AreEqual(reader.TagName, "fourth-list");
Assert.AreEqual(reader.Skip(), 10);
Assert.IsFalse(reader.ReadToFollowing());
}
public void SkipTest()
{
var reader = new NbtReader(TestFiles.MakeReaderTest());
reader.ReadToFollowing(); // at root
reader.ReadToFollowing(); // at first
reader.ReadToFollowing(); // at second
reader.ReadToFollowing(); // at third-comp
reader.ReadToFollowing(); // at inComp1
Assert.AreEqual("inComp1", reader.TagName);
Assert.AreEqual(2, reader.Skip());
Assert.AreEqual("fourth-list", reader.TagName);
Assert.AreEqual(11, reader.Skip());
Assert.IsFalse(reader.ReadToFollowing());
Assert.AreEqual(0, reader.Skip());
}
public void CacheTagValuesTest()
{
byte[] testData = new NbtFile(TestFiles.MakeValueTest()).SaveToBuffer(NbtCompression.None);
var reader = new NbtReader(new MemoryStream(testData));
Assert.False(reader.CacheTagValues);
reader.CacheTagValues = true;
Assert.True(reader.ReadToFollowing()); // root
Assert.True(reader.ReadToFollowing()); // byte
Assert.Equal((byte) 1, reader.ReadValue());
Assert.Equal((byte) 1, reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // short
Assert.Equal((Int16) 2, reader.ReadValue());
Assert.Equal((Int16) 2, reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // int
Assert.Equal(3, reader.ReadValue());
Assert.Equal(3, reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // long
Assert.Equal(4L, reader.ReadValue());
Assert.Equal(4L, reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // float
Assert.Equal(5f, reader.ReadValue());
Assert.Equal(5f, reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // double
Assert.Equal(6d, reader.ReadValue());
Assert.Equal(6d, reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // byteArray
Assert.Equal(new byte[] {10, 11, 12}, (byte[]) reader.ReadValue());
Assert.Equal(new byte[] {10, 11, 12}, (byte[]) reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // intArray
Assert.Equal(new[] {20, 21, 22}, (int[]) reader.ReadValue());
Assert.Equal(new[] {20, 21, 22}, (int[]) reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // string
Assert.Equal("123", reader.ReadValue());
Assert.Equal("123", reader.ReadValue());
}
public void NestedListTest()
{
NbtCompound root = new NbtCompound( "root" ) {
new NbtList( "OuterList" ) {
new NbtList {
new NbtByte()
},
new NbtList {
new NbtShort()
},
new NbtList {
new NbtInt()
}
}
};
byte[] testData = new NbtFile( root ).SaveToBuffer( NbtCompression.None );
using( MemoryStream ms = new MemoryStream( testData ) ) {
NbtReader reader = new NbtReader( ms );
while( reader.ReadToFollowing() ) {
Console.WriteLine( reader.ToString( true ) );
}
}
}
public void ReadValueAsTest()
{
byte[] testData = new NbtFile(TestFiles.MakeValueTest()).SaveToBuffer(NbtCompression.None);
var reader = new NbtReader(new MemoryStream(testData));
Assert.True(reader.ReadToFollowing()); // root
Assert.True(reader.ReadToFollowing()); // byte
Assert.Equal(1, reader.ReadValueAs<byte>());
Assert.True(reader.ReadToFollowing()); // short
Assert.Equal(2, reader.ReadValueAs<short>());
Assert.True(reader.ReadToFollowing()); // int
Assert.Equal(3, reader.ReadValueAs<int>());
Assert.True(reader.ReadToFollowing()); // long
Assert.Equal(4L, reader.ReadValueAs<long>());
Assert.True(reader.ReadToFollowing()); // float
Assert.Equal(5f, reader.ReadValueAs<float>());
Assert.True(reader.ReadToFollowing()); // double
Assert.Equal(6d, reader.ReadValueAs<double>());
Assert.True(reader.ReadToFollowing()); // byteArray
Assert.Equal(new byte[] {10, 11, 12}, reader.ReadValueAs<byte[]>());
Assert.True(reader.ReadToFollowing()); // intArray
Assert.Equal(new[] {20, 21, 22}, reader.ReadValueAs<int[]>());
Assert.True(reader.ReadToFollowing()); // string
Assert.Equal("123", reader.ReadValueAs<string>());
}
public void ReadListAsArrayRecast()
{
NbtCompound intList = TestFiles.MakeListTest();
var ms = new MemoryStream();
new NbtFile(intList).SaveToStream(ms, NbtCompression.None);
ms.Seek(0, SeekOrigin.Begin);
var reader = new NbtReader(ms);
// test bytes as shorts
reader.ReadToFollowing("ByteList");
short[] bytes = reader.ReadListAsArray<short>();
Assert.Equal(bytes,
new short[]
{
100, 20, 3
});
}
public void ReadValueTest()
{
byte[] testData = new NbtFile(TestFiles.MakeValueTest()).SaveToBuffer(NbtCompression.None);
var reader = new NbtReader(new MemoryStream(testData));
Assert.True(reader.ReadToFollowing()); // root
Assert.True(reader.ReadToFollowing()); // byte
Assert.Equal((byte) 1, reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // short
Assert.Equal((Int16) 2, reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // int
Assert.Equal(3, reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // long
Assert.Equal(4L, reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // float
Assert.Equal(5f, reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // double
Assert.Equal(6d, reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // byteArray
Assert.Equal(new byte[] {10, 11, 12}, (byte[]) reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // intArray
Assert.Equal(new[] {20, 21, 22}, (int[]) reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // string
Assert.Equal("123", reader.ReadValue());
// Skip to the very end and make sure that we can't read any more values
reader.ReadToFollowing();
Assert.Throws<EndOfStreamException>(() => reader.ReadValue());
}
public void ReadAsTagTest4()
{
// read a bunch of lists as tags
byte[] testData = new NbtFile(TestFiles.MakeListTest()).SaveToBuffer(NbtCompression.None);
// first, read everything all-at-once
{
var reader = new NbtReader(new MemoryStream(testData));
while (!reader.IsAtStreamEnd)
{
Console.WriteLine(reader.ReadAsTag());
}
}
// next, read each list individually
{
var reader = new NbtReader(new MemoryStream(testData));
reader.ReadToFollowing(); // read to root
reader.ReadToFollowing(); // read to first list tag
while (!reader.IsAtStreamEnd)
{
Console.WriteLine(reader.ReadAsTag());
}
}
}
public void ReadListAsArray()
{
NbtCompound intList = TestFiles.MakeListTest();
var ms = new MemoryStream();
new NbtFile(intList).SaveToStream(ms, NbtCompression.None);
ms.Seek(0, SeekOrigin.Begin);
var reader = new NbtReader(ms);
// attempt to read value before we're in a list
Assert.Throws<InvalidOperationException>(() => reader.ReadListAsArray<int>());
// test byte values
reader.ReadToFollowing("ByteList");
byte[] bytes = reader.ReadListAsArray<byte>();
Assert.Equal(new byte[] {100, 20, 3}, bytes);
// test double values
reader.ReadToFollowing("DoubleList");
double[] doubles = reader.ReadListAsArray<double>();
Assert.Equal(doubles, new[] {1d, 2000d, -3000000d});
// test float values
reader.ReadToFollowing("FloatList");
float[] floats = reader.ReadListAsArray<float>();
Assert.Equal(new[] {1f, 2000f, -3000000f}, floats);
// test int values
reader.ReadToFollowing("IntList");
int[] ints = reader.ReadListAsArray<int>();
Assert.Equal(new[] {1, 2000, -3000000}, ints);
// test long values
reader.ReadToFollowing("LongList");
long[] longs = reader.ReadListAsArray<long>();
Assert.Equal(new[] {1L, 2000L, -3000000L}, longs);
// test short values
reader.ReadToFollowing("ShortList");
short[] shorts = reader.ReadListAsArray<short>();
Assert.Equal(new short[] {1, 200, -30000}, shorts);
// test short values
reader.ReadToFollowing("StringList");
string[] strings = reader.ReadListAsArray<string>();
Assert.Equal(new[] {"one", "two thousand", "negative three million"}, strings);
// try reading list of compounds (should fail)
reader.ReadToFollowing("CompoundList");
Assert.Throws<InvalidOperationException>(() => reader.ReadListAsArray<NbtCompound>());
// skip to the end of the stream
while (reader.ReadToFollowing())
{
}
Assert.Throws<EndOfStreamException>(() => reader.ReadListAsArray<int>());
}
public void SkipTest()
{
var reader = new NbtReader(TestFiles.MakeReaderTest());
reader.ReadToFollowing(); // at root
reader.ReadToFollowing(); // at first
reader.ReadToFollowing(); // at second
reader.ReadToFollowing(); // at third-comp
reader.ReadToFollowing(); // at inComp1
Assert.AreEqual(reader.TagName, "inComp1");
Assert.AreEqual(reader.Skip(), 2);
Assert.AreEqual(reader.TagName, "fourth-list");
Assert.AreEqual(reader.Skip(), 10);
Assert.IsFalse(reader.ReadToFollowing());
}
public void ReadToDescendantTest()
{
var reader = new NbtReader(TestFiles.MakeReaderTest());
Assert.IsTrue(reader.ReadToDescendant("third-comp"));
Assert.AreEqual(reader.TagName, "third-comp");
Assert.IsTrue(reader.ReadToDescendant("inComp2"));
Assert.AreEqual(reader.TagName, "inComp2");
Assert.IsFalse(reader.ReadToDescendant("derp"));
Assert.AreEqual(reader.TagName, "inComp3");
reader.ReadToFollowing(); // at fourth-list
Assert.IsTrue(reader.ReadToDescendant("inList2"));
Assert.AreEqual(reader.TagName, "inList2");
}
public void SkipTest()
{
var reader = new NbtReader(TestFiles.MakeReaderTest());
reader.ReadToFollowing(); // at root
reader.ReadToFollowing(); // at first
reader.ReadToFollowing(); // at second
reader.ReadToFollowing(); // at third-comp
reader.ReadToFollowing(); // at inComp1
Assert.Equal("inComp1", reader.TagName);
Assert.Equal(2, reader.Skip());
Assert.Equal("fourth-list", reader.TagName);
Assert.Equal(11, reader.Skip());
Assert.False(reader.ReadToFollowing());
Assert.Equal(0, reader.Skip());
}
public void ReadAsTagTest1()
{
// read various lists/compounds as tags
var reader = new NbtReader(TestFiles.MakeReaderTest());
reader.ReadToFollowing(); // skip root
while (!reader.IsAtStreamEnd)
{
reader.ReadAsTag();
}
Assert.Throws<EndOfStreamException>(() => reader.ReadAsTag());
}
public void ReadToSiblingTest()
{
var reader = new NbtReader(TestFiles.MakeReaderTest());
Assert.True(reader.ReadToFollowing());
Assert.Equal("root", reader.TagName);
Assert.True(reader.ReadToFollowing());
Assert.Equal("first", reader.TagName);
Assert.True(reader.ReadToNextSibling("third-comp"));
Assert.Equal("third-comp", reader.TagName);
Assert.True(reader.ReadToNextSibling());
Assert.Equal("fourth-list", reader.TagName);
Assert.True(reader.ReadToNextSibling());
Assert.Equal("fifth", reader.TagName);
Assert.True(reader.ReadToNextSibling());
Assert.Equal("hugeArray", reader.TagName);
Assert.False(reader.ReadToNextSibling());
// Test twice, since we hit different paths through the code
Assert.False(reader.ReadToNextSibling());
}
public void ReadToDescendantTest()
{
var reader = new NbtReader(TestFiles.MakeReaderTest());
Assert.True(reader.ReadToDescendant("third-comp"));
Assert.Equal("third-comp", reader.TagName);
Assert.True(reader.ReadToDescendant("inComp2"));
Assert.Equal("inComp2", reader.TagName);
Assert.False(reader.ReadToDescendant("derp"));
Assert.Equal("inComp3", reader.TagName);
reader.ReadToFollowing(); // at fourth-list
Assert.True(reader.ReadToDescendant("inList2"));
Assert.Equal("inList2", reader.TagName);
// Ensure ReadToDescendant returns false when at end-of-stream
while (reader.ReadToFollowing())
{
}
Assert.False(reader.ReadToDescendant("*"));
}
public void PropertiesTest()
{
var reader = new NbtReader(TestFiles.MakeReaderTest());
Assert.Equal(0, reader.Depth);
Assert.Equal(0, reader.TagsRead);
Assert.True(reader.ReadToFollowing());
Assert.Equal("root", reader.TagName);
Assert.Equal(NbtTagType.Compound, reader.TagType);
Assert.Equal(NbtTagType.Unknown, reader.ListType);
Assert.False(reader.HasValue);
Assert.True(reader.IsCompound);
Assert.False(reader.IsList);
Assert.False(reader.IsListElement);
Assert.False(reader.HasLength);
Assert.Equal(0, reader.ListIndex);
Assert.Equal(1, reader.Depth);
Assert.Equal(null, reader.ParentName);
Assert.Equal(NbtTagType.Unknown, reader.ParentTagType);
Assert.Equal(0, reader.ParentTagLength);
Assert.Equal(0, reader.TagLength);
Assert.Equal(1, reader.TagsRead);
Assert.True(reader.ReadToFollowing());
Assert.Equal("first", reader.TagName);
Assert.Equal(NbtTagType.Int, reader.TagType);
Assert.Equal(NbtTagType.Unknown, reader.ListType);
Assert.True(reader.HasValue);
Assert.False(reader.IsCompound);
Assert.False(reader.IsList);
Assert.False(reader.IsListElement);
Assert.False(reader.HasLength);
Assert.Equal(0, reader.ListIndex);
Assert.Equal(2, reader.Depth);
Assert.Equal("root", reader.ParentName);
Assert.Equal(NbtTagType.Compound, reader.ParentTagType);
Assert.Equal(0, reader.ParentTagLength);
Assert.Equal(0, reader.TagLength);
Assert.Equal(2, reader.TagsRead);
Assert.True(reader.ReadToFollowing("fourth-list"));
Assert.Equal("fourth-list", reader.TagName);
Assert.Equal(NbtTagType.List, reader.TagType);
Assert.Equal(NbtTagType.List, reader.ListType);
Assert.False(reader.HasValue);
Assert.False(reader.IsCompound);
Assert.True(reader.IsList);
Assert.False(reader.IsListElement);
Assert.True(reader.HasLength);
Assert.Equal(0, reader.ListIndex);
Assert.Equal(2, reader.Depth);
Assert.Equal("root", reader.ParentName);
Assert.Equal(NbtTagType.Compound, reader.ParentTagType);
Assert.Equal(0, reader.ParentTagLength);
Assert.Equal(3, reader.TagLength);
Assert.Equal(8, reader.TagsRead);
Assert.True(reader.ReadToFollowing()); // first list element, itself a list
Assert.Equal(null, reader.TagName);
Assert.Equal(NbtTagType.List, reader.TagType);
Assert.Equal(NbtTagType.Compound, reader.ListType);
Assert.False(reader.HasValue);
Assert.False(reader.IsCompound);
Assert.True(reader.IsList);
Assert.True(reader.IsListElement);
Assert.True(reader.HasLength);
Assert.Equal(0, reader.ListIndex);
Assert.Equal(3, reader.Depth);
Assert.Equal("fourth-list", reader.ParentName);
Assert.Equal(NbtTagType.List, reader.ParentTagType);
Assert.Equal(3, reader.ParentTagLength);
Assert.Equal(1, reader.TagLength);
Assert.Equal(9, reader.TagsRead);
Assert.True(reader.ReadToFollowing()); // first nested list element, compound
Assert.Equal(null, reader.TagName);
Assert.Equal(NbtTagType.Compound, reader.TagType);
Assert.Equal(NbtTagType.Unknown, reader.ListType);
Assert.False(reader.HasValue);
Assert.True(reader.IsCompound);
Assert.False(reader.IsList);
Assert.True(reader.IsListElement);
Assert.False(reader.HasLength);
Assert.Equal(0, reader.ListIndex);
Assert.Equal(4, reader.Depth);
Assert.Equal(null, reader.ParentName);
Assert.Equal(NbtTagType.List, reader.ParentTagType);
Assert.Equal(1, reader.ParentTagLength);
Assert.Equal(0, reader.TagLength);
Assert.Equal(10, reader.TagsRead);
Assert.True(reader.ReadToFollowing("fifth"));
Assert.Equal("fifth", reader.TagName);
Assert.Equal(NbtTagType.Int, reader.TagType);
Assert.Equal(NbtTagType.Unknown, reader.ListType);
Assert.True(reader.HasValue);
Assert.False(reader.IsCompound);
Assert.False(reader.IsList);
Assert.False(reader.IsListElement);
Assert.False(reader.HasLength);
Assert.Equal(0, reader.ListIndex);
Assert.Equal(2, reader.Depth);
Assert.Equal("root", reader.ParentName);
Assert.Equal(NbtTagType.Compound, reader.ParentTagType);
Assert.Equal(0, reader.ParentTagLength);
Assert.Equal(0, reader.TagLength);
Assert.Equal(18, reader.TagsRead);
Assert.True(reader.ReadToFollowing());
Assert.Equal("hugeArray", reader.TagName);
Assert.Equal(NbtTagType.ByteArray, reader.TagType);
Assert.Equal(NbtTagType.Unknown, reader.ListType);
Assert.True(reader.HasValue);
Assert.False(reader.IsCompound);
Assert.False(reader.IsList);
Assert.False(reader.IsListElement);
Assert.True(reader.HasLength);
Assert.Equal(0, reader.ListIndex);
Assert.Equal(2, reader.Depth);
Assert.Equal("root", reader.ParentName);
Assert.Equal(NbtTagType.Compound, reader.ParentTagType);
Assert.Equal(0, reader.ParentTagLength);
Assert.Equal(1024*1024, reader.TagLength);
Assert.Equal(19, reader.TagsRead);
}
public Map LoadHeader(string path) {
using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read)) {
using (GZipStream gs = new GZipStream(fs, CompressionMode.Decompress)) {
NbtReader reader = new NbtReader(gs);
reader.ReadToFollowing(); // skip root tag
reader.ReadToFollowing(); // skip to first inner tag
int width = 0,
length = 0,
height = 0;
do {
switch (reader.TagName) {
case "X":
width = reader.ReadValueAs<short>();
break;
case "Y":
height = reader.ReadValueAs<short>();
break;
case "Z":
length = reader.ReadValueAs<short>();
break;
}
if (width > 0 && length > 0 && height > 0) {
return new Map(null, width, length, height, false);
}
} while (reader.ReadToNextSibling());
}
}
throw new MapFormatException("Could not locate map dimensions.");
}
public void ReadToSiblingTest()
{
var reader = new NbtReader(TestFiles.MakeReaderTest());
Assert.IsTrue(reader.ReadToFollowing());
Assert.AreEqual(reader.TagName, "root");
Assert.IsTrue(reader.ReadToFollowing());
Assert.AreEqual(reader.TagName, "first");
Assert.IsTrue(reader.ReadToNextSibling("third-comp"));
Assert.AreEqual(reader.TagName, "third-comp");
Assert.IsTrue(reader.ReadToNextSibling());
Assert.AreEqual(reader.TagName, "fourth-list");
Assert.IsTrue(reader.ReadToNextSibling());
Assert.AreEqual(reader.TagName, "fifth");
Assert.IsFalse(reader.ReadToNextSibling());
}
public void PropertiesTest()
{
var reader = new NbtReader(TestFiles.MakeReaderTest());
Assert.AreEqual(reader.Depth, 0);
Assert.AreEqual(reader.TagsRead, 0);
Assert.IsTrue(reader.ReadToFollowing());
Assert.AreEqual(reader.TagName, "root");
Assert.AreEqual(reader.TagType, NbtTagType.Compound);
Assert.AreEqual(reader.ListType, NbtTagType.Unknown);
Assert.IsFalse(reader.HasValue);
Assert.IsTrue(reader.IsCompound);
Assert.IsFalse(reader.IsList);
Assert.IsFalse(reader.IsListElement);
Assert.IsFalse(reader.HasLength);
Assert.AreEqual(reader.ListIndex, 0);
Assert.AreEqual(reader.Depth, 1);
Assert.AreEqual(reader.ParentName, null);
Assert.AreEqual(reader.ParentTagType, NbtTagType.Unknown);
Assert.AreEqual(reader.ParentTagLength, 0);
Assert.AreEqual(reader.TagLength, 0);
Assert.AreEqual(reader.TagsRead, 1);
Assert.IsTrue(reader.ReadToFollowing());
Assert.AreEqual(reader.TagName, "first");
Assert.AreEqual(reader.TagType, NbtTagType.Int);
Assert.AreEqual(reader.ListType, NbtTagType.Unknown);
Assert.IsTrue(reader.HasValue);
Assert.IsFalse(reader.IsCompound);
Assert.IsFalse(reader.IsList);
Assert.IsFalse(reader.IsListElement);
Assert.IsFalse(reader.HasLength);
Assert.AreEqual(reader.ListIndex, 0);
Assert.AreEqual(reader.Depth, 2);
Assert.AreEqual(reader.ParentName, "root");
Assert.AreEqual(reader.ParentTagType, NbtTagType.Compound);
Assert.AreEqual(reader.ParentTagLength, 0);
Assert.AreEqual(reader.TagLength, 0);
Assert.AreEqual(reader.TagsRead, 2);
Assert.IsTrue(reader.ReadToFollowing("fourth-list"));
Assert.AreEqual(reader.TagName, "fourth-list");
Assert.AreEqual(reader.TagType, NbtTagType.List);
Assert.AreEqual(reader.ListType, NbtTagType.List);
Assert.IsFalse(reader.HasValue);
Assert.IsFalse(reader.IsCompound);
Assert.IsTrue(reader.IsList);
Assert.IsFalse(reader.IsListElement);
Assert.IsTrue(reader.HasLength);
Assert.AreEqual(reader.ListIndex, 0);
Assert.AreEqual(reader.Depth, 2);
Assert.AreEqual(reader.ParentName, "root");
Assert.AreEqual(reader.ParentTagType, NbtTagType.Compound);
Assert.AreEqual(reader.ParentTagLength, 0);
Assert.AreEqual(reader.TagLength, 3);
Assert.AreEqual(reader.TagsRead, 8);
Assert.IsTrue(reader.ReadToFollowing()); // first list element, itself a list
Assert.AreEqual(reader.TagName, null);
Assert.AreEqual(reader.TagType, NbtTagType.List);
Assert.AreEqual(reader.ListType, NbtTagType.Compound);
Assert.IsFalse(reader.HasValue);
Assert.IsFalse(reader.IsCompound);
Assert.IsTrue(reader.IsList);
Assert.IsTrue(reader.IsListElement);
Assert.IsTrue(reader.HasLength);
Assert.AreEqual(reader.ListIndex, 0);
Assert.AreEqual(reader.Depth, 3);
Assert.AreEqual(reader.ParentName, "fourth-list");
Assert.AreEqual(reader.ParentTagType, NbtTagType.List);
Assert.AreEqual(reader.ParentTagLength, 3);
Assert.AreEqual(reader.TagLength, 1);
Assert.AreEqual(reader.TagsRead, 9);
Assert.IsTrue(reader.ReadToFollowing()); // first nested list element, compound
Assert.AreEqual(reader.TagName, null);
Assert.AreEqual(reader.TagType, NbtTagType.Compound);
Assert.AreEqual(reader.ListType, NbtTagType.Unknown);
Assert.IsFalse(reader.HasValue);
Assert.IsTrue(reader.IsCompound);
Assert.IsFalse(reader.IsList);
Assert.IsTrue(reader.IsListElement);
Assert.IsFalse(reader.HasLength);
Assert.AreEqual(reader.ListIndex, 0);
Assert.AreEqual(reader.Depth, 4);
Assert.AreEqual(reader.ParentName, null);
Assert.AreEqual(reader.ParentTagType, NbtTagType.List);
Assert.AreEqual(reader.ParentTagLength, 1);
Assert.AreEqual(reader.TagLength, 0);
Assert.AreEqual(reader.TagsRead, 10);
}
public void ReadAsTagTest3()
{
// read values as tags
byte[] testData = new NbtFile(TestFiles.MakeValueTest()).SaveToBuffer(NbtCompression.None);
var reader = new NbtReader(new MemoryStream(testData));
var root = new NbtCompound("root");
// skip root
reader.ReadToFollowing();
reader.ReadToFollowing();
while (!reader.IsAtStreamEnd)
{
root.Add(reader.ReadAsTag());
}
TestFiles.AssertValueTest(new NbtFile(root));
}
public void NonSeekableStreamSkip1()
{
byte[] fileBytes = File.ReadAllBytes("TestFiles/bigtest.nbt");
using (var ms = new MemoryStream(fileBytes))
{
using (var nss = new NonSeekableStream(ms))
{
var reader = new NbtReader(nss);
reader.ReadToFollowing();
reader.Skip();
}
}
}
public void NonSeekableStreamSkip2()
{
using (var ms = TestFiles.MakeReaderTest())
{
using (var nss = new NonSeekableStream(ms))
{
var reader = new NbtReader(nss);
reader.ReadToFollowing();
reader.Skip();
}
}
}
void TryReadBadFile(byte[] data)
{
using (MemoryStream ms = new MemoryStream(data))
{
NbtReader reader = new NbtReader(ms);
try
{
while (reader.ReadToFollowing())
{
}
}
catch (Exception)
{
Assert.True(reader.IsInErrorState);
throw;
}
}
}
public void ReadValueTest()
{
NbtCompound root = new NbtCompound( "root" ) {
new NbtByte( "byte", 1 ),
new NbtShort( "short", 2 ),
new NbtInt( "int", 3 ),
new NbtLong( "long", 4 ),
new NbtFloat( "float", 5 ),
new NbtDouble( "double", 6 ),
new NbtByteArray( "byteArray", new byte[] { 10, 11, 12 } ),
new NbtIntArray( "intArray", new[] { 20, 21, 22 } ),
new NbtString( "string", "23" )
};
byte[] testData = new NbtFile( root ).SaveToBuffer( NbtCompression.None );
NbtReader reader = new NbtReader( new MemoryStream( testData ) );
Assert.IsTrue( reader.ReadToFollowing() ); // root
Assert.IsTrue( reader.ReadToFollowing() ); // byte
Assert.AreEqual( reader.ReadValue(), 1 );
Assert.IsTrue( reader.ReadToFollowing() ); // short
Assert.AreEqual( reader.ReadValue(), 2 );
Assert.IsTrue( reader.ReadToFollowing() ); // int
Assert.AreEqual( reader.ReadValue(), 3 );
Assert.IsTrue( reader.ReadToFollowing() ); // long
Assert.AreEqual( reader.ReadValue(), 4 );
Assert.IsTrue( reader.ReadToFollowing() ); // float
Assert.AreEqual( reader.ReadValue(), 5f );
Assert.IsTrue( reader.ReadToFollowing() ); // double
Assert.AreEqual( reader.ReadValue(), 6d );
Assert.IsTrue( reader.ReadToFollowing() ); // byteArray
CollectionAssert.AreEqual( (byte[])reader.ReadValue(), new byte[] { 10, 11, 12 } );
Assert.IsTrue( reader.ReadToFollowing() ); // intArray
CollectionAssert.AreEqual( (int[])reader.ReadValue(), new[] { 20, 21, 22 } );
Assert.IsTrue( reader.ReadToFollowing() ); // string
Assert.AreEqual( reader.ReadValue(), "23" );
}
