public void ValueTest()
{
// write one named tag for every value type, and read it back
using (var ms = new MemoryStream()) {
var writer = new NbtWriter(ms, "root");
Assert.AreEqual(ms, writer.BaseStream);
{
writer.WriteByte("byte", 1);
writer.WriteShort("short", 2);
writer.WriteInt("int", 3);
writer.WriteLong("long", 4L);
writer.WriteFloat("float", 5f);
writer.WriteDouble("double", 6d);
writer.WriteByteArray("byteArray", new byte[] { 10, 11, 12 });
writer.WriteIntArray("intArray", new[] { 20, 21, 22 });
writer.WriteString("string", "123");
}
Assert.IsFalse(writer.IsDone);
writer.EndCompound();
Assert.IsTrue(writer.IsDone);
writer.Finish();
ms.Position = 0;
var file = new NbtFile();
file.LoadFromStream(ms, NbtCompression.None);
TestFiles.AssertValueTest(file);
}
}
public async Task WriteSlotAsync(ItemStack slot)
{
await this.WriteBooleanAsync(slot.Present);
if (slot.Present)
{
await this.WriteVarIntAsync(slot.Id);
await this.WriteByteAsync((sbyte)slot.Count);
var writer = new NbtWriter(this, "");
if (slot.Nbt == null)
{
writer.EndCompound();
writer.Finish();
return;
}
//TODO write enchants
writer.WriteShort("id", (short)slot.Id);
writer.WriteInt("Damage", slot.Nbt.Damage);
writer.WriteByte("Count", (byte)slot.Count);
writer.EndCompound();
writer.Finish();
}
}
static void WriteHeader([NotNull] Map mapToSave, [NotNull] string path, [NotNull] NbtWriter writer)
{
writer.WriteByte("FormatVersion", 1);
// write name and UUID
World mapWorld = mapToSave.World;
string mapName;
if (mapWorld != null)
{
mapName = mapWorld.Name;
}
else
{
mapName = Path.GetFileNameWithoutExtension(path);
}
writer.WriteString("Name", mapName);
writer.WriteByteArray("UUID", mapToSave.Guid.ToByteArray());
// write map dimensions
writer.WriteShort("X", (short)mapToSave.Width);
writer.WriteShort("Y", (short)mapToSave.Height);
writer.WriteShort("Z", (short)mapToSave.Length);
// write spawn
writer.BeginCompound("Spawn");
{
Position spawn = mapToSave.Spawn;
writer.WriteShort("X", spawn.X);
writer.WriteShort("Y", spawn.Z);
writer.WriteShort("Z", spawn.Y);
writer.WriteByte("H", spawn.R);
writer.WriteByte("P", spawn.L);
}
writer.EndCompound();
// write timestamps
writer.WriteLong("TimeCreated", mapToSave.DateCreated.ToUnixTime());
writer.WriteLong("LastModified", mapToSave.DateCreated.ToUnixTime());
// TODO: TimeAccessed
// TODO: write CreatedBy
// Write map origin information
writer.BeginCompound("MapGenerator");
{
writer.WriteString("Software", "fCraft " + Updater.CurrentRelease.VersionString);
string genName;
if (!mapToSave.Metadata.TryGetValue(MapGenUtil.ParamsMetaGroup,
MapGenUtil.GenNameMetaKey,
out genName))
{
genName = "Unknown";
}
writer.WriteString("MapGeneratorName", genName);
}
writer.EndCompound();
}
public void ValueTest()
{
// write one named tag for every value type, and read it back
using (var ms = new MemoryStream()) {
var writer = new NbtWriter(ms, "root");
{
writer.WriteByte("byte", 1);
writer.WriteShort("short", 2);
writer.WriteInt("int", 3);
writer.WriteLong("long", 4L);
writer.WriteFloat("float", 5f);
writer.WriteDouble("double", 6d);
writer.WriteByteArray("byteArray", new byte[] { 10, 11, 12 });
writer.WriteIntArray("intArray", new[] { 20, 21, 22 });
writer.WriteString("string", "123");
}
writer.EndCompound();
writer.Finish();
ms.Position = 0;
var file = new NbtFile();
file.LoadFromStream(ms, NbtCompression.None);
TestFiles.AssertValueTest(file);
}
}
public void ListTest()
{
// write short (1-element) lists of every possible kind
using (var ms = new MemoryStream()) {
var writer = new NbtWriter(ms, "Test");
writer.BeginList("LotsOfLists", NbtTagType.List, 11);
{
writer.BeginList(NbtTagType.Byte, 1);
writer.WriteByte(1);
writer.EndList();
writer.BeginList(NbtTagType.ByteArray, 1);
writer.WriteByteArray(new byte[] {
1
});
writer.EndList();
writer.BeginList(NbtTagType.Compound, 1);
writer.BeginCompound();
writer.EndCompound();
writer.EndList();
writer.BeginList(NbtTagType.Double, 1);
writer.WriteDouble(1);
writer.EndList();
writer.BeginList(NbtTagType.Float, 1);
writer.WriteFloat(1);
writer.EndList();
writer.BeginList(NbtTagType.Int, 1);
writer.WriteInt(1);
writer.EndList();
writer.BeginList(NbtTagType.IntArray, 1);
writer.WriteIntArray(new[] {
1
});
writer.EndList();
writer.BeginList(NbtTagType.List, 1);
writer.BeginList(NbtTagType.List, 0);
writer.EndList();
writer.EndList();
writer.BeginList(NbtTagType.Long, 1);
writer.WriteLong(1);
writer.EndList();
writer.BeginList(NbtTagType.Short, 1);
writer.WriteShort(1);
writer.EndList();
writer.BeginList(NbtTagType.String, 1);
writer.WriteString("ponies");
writer.EndList();
}
writer.EndList();
writer.EndCompound();
writer.Finish();
ms.Position = 0;
var reader = new NbtReader(ms);
Assert.DoesNotThrow(() => reader.ReadAsTag());
}
}
public void ErrorTest()
{
using (var ms = new MemoryStream()) {
// null constructor parameters, or a non-writable stream
Assert.Throws<ArgumentNullException>(() => new NbtWriter(null, "root"));
Assert.Throws<ArgumentNullException>(() => new NbtWriter(ms, null));
Assert.Throws<ArgumentException>(() => new NbtWriter(new NonWritableStream(), "root"));
var writer = new NbtWriter(ms, "root");
{
// use negative list size
Assert.Throws<ArgumentOutOfRangeException>(() => writer.BeginList("list", NbtTagType.Int, -1));
writer.BeginList("listOfLists", NbtTagType.List, 1);
Assert.Throws<ArgumentOutOfRangeException>(() => writer.BeginList(NbtTagType.Int, -1));
writer.BeginList(NbtTagType.Int, 0);
writer.EndList();
writer.EndList();
writer.BeginList("list", NbtTagType.Int, 1);
// invalid list type
Assert.Throws<ArgumentOutOfRangeException>(() => writer.BeginList(NbtTagType.End, 0));
// call EndCompound when not in a compound
Assert.Throws<NbtFormatException>(writer.EndCompound);
// end list before all elements have been written
Assert.Throws<NbtFormatException>(writer.EndList);
// write the wrong kind of tag inside a list
Assert.Throws<NbtFormatException>(() => writer.WriteShort(0));
// write a named tag where an unnamed tag is expected
Assert.Throws<NbtFormatException>(() => writer.WriteInt("NamedInt", 0));
// write too many list elements
writer.WriteTag(new NbtInt());
Assert.Throws<NbtFormatException>(() => writer.WriteInt(0));
writer.EndList();
// write a null tag
Assert.Throws<ArgumentNullException>(() => writer.WriteTag(null));
// write an unnamed tag where a named tag is expected
Assert.Throws<NbtFormatException>(() => writer.WriteTag(new NbtInt()));
Assert.Throws<NbtFormatException>(() => writer.WriteInt(0));
// end a list when not in a list
Assert.Throws<NbtFormatException>(writer.EndList);
// write null values where unacceptable
Assert.Throws<ArgumentNullException>(() => writer.WriteString("NullString", null));
Assert.Throws<ArgumentNullException>(() => writer.WriteByteArray("NullByteArray", null));
Assert.Throws<ArgumentNullException>(() => writer.WriteIntArray("NullIntArray", null));
Assert.Throws<ArgumentNullException>(() => writer.WriteString(null));
Assert.Throws<ArgumentNullException>(() => writer.WriteByteArray(null));
Assert.Throws<ArgumentNullException>(() => writer.WriteIntArray(null));
// trying to read from non-readable stream
Assert.Throws<ArgumentException>(
() => writer.WriteByteArray("ByteStream", new NonReadableStream(), 0));
// finish too early
Assert.Throws<NbtFormatException>(writer.Finish);
writer.EndCompound();
writer.Finish();
// write tag after finishing
Assert.Throws<NbtFormatException>(() => writer.WriteTag(new NbtInt()));
}
}
}
public void ErrorTest()
{
byte[] dummyByteArray = { 1, 2, 3, 4, 5 };
int[] dummyIntArray = { 1, 2, 3, 4, 5 };
byte[] dummyBuffer = new byte[1024];
MemoryStream dummyStream = new MemoryStream(dummyByteArray);
using (var ms = new MemoryStream()) {
// null constructor parameters, or a non-writable stream
Assert.Throws <ArgumentNullException>(() => new NbtWriter(null, "root"));
Assert.Throws <ArgumentNullException>(() => new NbtWriter(ms, null));
Assert.Throws <ArgumentException>(() => new NbtWriter(new NonWritableStream(), "root"));
var writer = new NbtWriter(ms, "root");
{
// use negative list size
Assert.Throws <ArgumentOutOfRangeException>(() => writer.BeginList("list", NbtTagType.Int, -1));
writer.BeginList("listOfLists", NbtTagType.List, 1);
Assert.Throws <ArgumentOutOfRangeException>(() => writer.BeginList(NbtTagType.Int, -1));
writer.BeginList(NbtTagType.Int, 0);
writer.EndList();
writer.EndList();
writer.BeginList("list", NbtTagType.Int, 1);
// invalid list type
Assert.Throws <ArgumentOutOfRangeException>(() => writer.BeginList(NbtTagType.End, 0));
Assert.Throws <ArgumentOutOfRangeException>(() => writer.BeginList("list", NbtTagType.End, 0));
// call EndCompound when not in a compound
Assert.Throws <NbtFormatException>(writer.EndCompound);
// end list before all elements have been written
Assert.Throws <NbtFormatException>(writer.EndList);
// write the wrong kind of tag inside a list
Assert.Throws <NbtFormatException>(() => writer.WriteShort(0));
// write a named tag where an unnamed tag is expected
Assert.Throws <NbtFormatException>(() => writer.WriteInt("NamedInt", 0));
// write too many list elements
writer.WriteTag(new NbtInt());
Assert.Throws <NbtFormatException>(() => writer.WriteInt(0));
writer.EndList();
// write a null tag
Assert.Throws <ArgumentNullException>(() => writer.WriteTag(null));
// write an unnamed tag where a named tag is expected
Assert.Throws <NbtFormatException>(() => writer.WriteTag(new NbtInt()));
Assert.Throws <NbtFormatException>(() => writer.WriteInt(0));
// end a list when not in a list
Assert.Throws <NbtFormatException>(writer.EndList);
// unacceptable nulls: WriteString
Assert.Throws <ArgumentNullException>(() => writer.WriteString(null));
Assert.Throws <ArgumentNullException>(() => writer.WriteString("NullString", null));
// unacceptable nulls: WriteByteArray from array
Assert.Throws <ArgumentNullException>(() => writer.WriteByteArray(null));
Assert.Throws <ArgumentNullException>(() => writer.WriteByteArray(null, 0, 5));
Assert.Throws <ArgumentNullException>(() => writer.WriteByteArray("NullByteArray", null));
Assert.Throws <ArgumentNullException>(() => writer.WriteByteArray("NullByteArray", null, 0, 5));
// unacceptable nulls: WriteByteArray from stream
Assert.Throws <ArgumentNullException>(() => writer.WriteByteArray(null, 5));
Assert.Throws <ArgumentNullException>(() => writer.WriteByteArray(null, 5, null));
Assert.Throws <ArgumentNullException>(() => writer.WriteByteArray(dummyStream, 5, null));
Assert.Throws <ArgumentNullException>(() => writer.WriteByteArray("NullBuffer", dummyStream, 5, null));
Assert.Throws <ArgumentNullException>(() => writer.WriteByteArray("NullStream", null, 5));
Assert.Throws <ArgumentNullException>(
() => writer.WriteByteArray("NullStream", null, 5, dummyByteArray));
// unacceptable nulls: WriteIntArray
Assert.Throws <ArgumentNullException>(() => writer.WriteIntArray(null));
Assert.Throws <ArgumentNullException>(() => writer.WriteIntArray(null, 0, 5));
Assert.Throws <ArgumentNullException>(() => writer.WriteIntArray("NullIntArray", null));
Assert.Throws <ArgumentNullException>(() => writer.WriteIntArray("NullIntArray", null, 0, 5));
// non-readable streams are unacceptable
Assert.Throws <ArgumentException>(() => writer.WriteByteArray(new NonReadableStream(), 0));
Assert.Throws <ArgumentException>(
() => writer.WriteByteArray(new NonReadableStream(), 0, new byte[10]));
Assert.Throws <ArgumentException>(
() => writer.WriteByteArray("NonReadableStream", new NonReadableStream(), 0));
// trying to write array with out-of-range offset/count
Assert.Throws <ArgumentOutOfRangeException>(() => writer.WriteByteArray(dummyByteArray, -1, 5));
Assert.Throws <ArgumentOutOfRangeException>(() => writer.WriteByteArray(dummyByteArray, 0, -1));
Assert.Throws <ArgumentException>(() => writer.WriteByteArray(dummyByteArray, 0, 6));
Assert.Throws <ArgumentException>(() => writer.WriteByteArray(dummyByteArray, 1, 5));
Assert.Throws <ArgumentOutOfRangeException>(
() => writer.WriteByteArray("OutOfRangeByteArray", dummyByteArray, -1, 5));
Assert.Throws <ArgumentOutOfRangeException>(
() => writer.WriteByteArray("OutOfRangeByteArray", dummyByteArray, 0, -1));
Assert.Throws <ArgumentException>(
() => writer.WriteByteArray("OutOfRangeByteArray", dummyByteArray, 0, 6));
Assert.Throws <ArgumentException>(
() => writer.WriteByteArray("OutOfRangeByteArray", dummyByteArray, 1, 5));
Assert.Throws <ArgumentOutOfRangeException>(() => writer.WriteIntArray(dummyIntArray, -1, 5));
Assert.Throws <ArgumentOutOfRangeException>(() => writer.WriteIntArray(dummyIntArray, 0, -1));
Assert.Throws <ArgumentException>(() => writer.WriteIntArray(dummyIntArray, 0, 6));
Assert.Throws <ArgumentException>(() => writer.WriteIntArray(dummyIntArray, 1, 5));
Assert.Throws <ArgumentOutOfRangeException>(
() => writer.WriteIntArray("OutOfRangeIntArray", dummyIntArray, -1, 5));
Assert.Throws <ArgumentOutOfRangeException>(
() => writer.WriteIntArray("OutOfRangeIntArray", dummyIntArray, 0, -1));
Assert.Throws <ArgumentException>(
() => writer.WriteIntArray("OutOfRangeIntArray", dummyIntArray, 0, 6));
Assert.Throws <ArgumentException>(
() => writer.WriteIntArray("OutOfRangeIntArray", dummyIntArray, 1, 5));
// out-of-range values for stream-reading overloads of WriteByteArray
Assert.Throws <ArgumentOutOfRangeException>(() => writer.WriteByteArray(dummyStream, -1));
Assert.Throws <ArgumentOutOfRangeException>(() => writer.WriteByteArray("BadLength", dummyStream, -1));
Assert.Throws <ArgumentOutOfRangeException>(
() => writer.WriteByteArray(dummyStream, -1, dummyByteArray));
Assert.Throws <ArgumentOutOfRangeException>(
() => writer.WriteByteArray("BadLength", dummyStream, -1, dummyByteArray));
Assert.Throws <ArgumentException>(() => writer.WriteByteArray(dummyStream, 5, new byte[0]));
Assert.Throws <ArgumentException>(
() => writer.WriteByteArray("BadLength", dummyStream, 5, new byte[0]));
// trying to read from non-readable stream
Assert.Throws <ArgumentException>(
() => writer.WriteByteArray("ByteStream", new NonReadableStream(), 0));
// finish too early
Assert.Throws <NbtFormatException>(writer.Finish);
writer.EndCompound();
writer.Finish();
// write tag after finishing
Assert.Throws <NbtFormatException>(() => writer.WriteTag(new NbtInt()));
}
}
}
public void ListTest()
{
// write short (1-element) lists of every possible kind
using (var ms = new MemoryStream()) {
var writer = new NbtWriter(ms, "Test");
writer.BeginList("LotsOfLists", NbtTagType.List, 11);
{
writer.BeginList(NbtTagType.Byte, 1);
writer.WriteByte(1);
writer.EndList();
writer.BeginList(NbtTagType.ByteArray, 1);
writer.WriteByteArray(new byte[] {
1
});
writer.EndList();
writer.BeginList(NbtTagType.Compound, 1);
writer.BeginCompound();
writer.EndCompound();
writer.EndList();
writer.BeginList(NbtTagType.Double, 1);
writer.WriteDouble(1);
writer.EndList();
writer.BeginList(NbtTagType.Float, 1);
writer.WriteFloat(1);
writer.EndList();
writer.BeginList(NbtTagType.Int, 1);
writer.WriteInt(1);
writer.EndList();
writer.BeginList(NbtTagType.IntArray, 1);
writer.WriteIntArray(new[] {
1
});
writer.EndList();
writer.BeginList(NbtTagType.List, 1);
writer.BeginList(NbtTagType.List, 0);
writer.EndList();
writer.EndList();
writer.BeginList(NbtTagType.Long, 1);
writer.WriteLong(1);
writer.EndList();
writer.BeginList(NbtTagType.Short, 1);
writer.WriteShort(1);
writer.EndList();
writer.BeginList(NbtTagType.String, 1);
writer.WriteString("ponies");
writer.EndList();
}
writer.EndList();
Assert.IsFalse(writer.IsDone);
writer.EndCompound();
Assert.IsTrue(writer.IsDone);
writer.Finish();
ms.Position = 0;
var reader = new NbtReader(ms);
Assert.DoesNotThrow(() => reader.ReadAsTag());
}
}
public void ErrorTest()
{
byte[] dummyByteArray = { 1, 2, 3, 4, 5 };
int[] dummyIntArray = { 1, 2, 3, 4, 5 };
byte[] dummyBuffer = new byte[1024];
MemoryStream dummyStream = new MemoryStream(dummyByteArray);
using (var ms = new MemoryStream()) {
// null constructor parameters, or a non-writable stream
Assert.Throws<ArgumentNullException>(() => new NbtWriter(null, "root"));
Assert.Throws<ArgumentNullException>(() => new NbtWriter(ms, null));
Assert.Throws<ArgumentException>(() => new NbtWriter(new NonWritableStream(), "root"));
var writer = new NbtWriter(ms, "root");
{
// use negative list size
Assert.Throws<ArgumentOutOfRangeException>(() => writer.BeginList("list", NbtTagType.Int, -1));
writer.BeginList("listOfLists", NbtTagType.List, 1);
Assert.Throws<ArgumentOutOfRangeException>(() => writer.BeginList(NbtTagType.Int, -1));
writer.BeginList(NbtTagType.Int, 0);
writer.EndList();
writer.EndList();
writer.BeginList("list", NbtTagType.Int, 1);
// invalid list type
Assert.Throws<ArgumentOutOfRangeException>(() => writer.BeginList(NbtTagType.End, 0));
Assert.Throws<ArgumentOutOfRangeException>(() => writer.BeginList("list", NbtTagType.End, 0));
// call EndCompound when not in a compound
Assert.Throws<NbtFormatException>(writer.EndCompound);
// end list before all elements have been written
Assert.Throws<NbtFormatException>(writer.EndList);
// write the wrong kind of tag inside a list
Assert.Throws<NbtFormatException>(() => writer.WriteShort(0));
// write a named tag where an unnamed tag is expected
Assert.Throws<NbtFormatException>(() => writer.WriteInt("NamedInt", 0));
// write too many list elements
writer.WriteTag(new NbtInt());
Assert.Throws<NbtFormatException>(() => writer.WriteInt(0));
writer.EndList();
// write a null tag
Assert.Throws<ArgumentNullException>(() => writer.WriteTag(null));
// write an unnamed tag where a named tag is expected
Assert.Throws<NbtFormatException>(() => writer.WriteTag(new NbtInt()));
Assert.Throws<NbtFormatException>(() => writer.WriteInt(0));
// end a list when not in a list
Assert.Throws<NbtFormatException>(writer.EndList);
// unacceptable nulls: WriteString
Assert.Throws<ArgumentNullException>(() => writer.WriteString(null));
Assert.Throws<ArgumentNullException>(() => writer.WriteString("NullString", null));
// unacceptable nulls: WriteByteArray from array
Assert.Throws<ArgumentNullException>(() => writer.WriteByteArray(null));
Assert.Throws<ArgumentNullException>(() => writer.WriteByteArray(null, 0, 5));
Assert.Throws<ArgumentNullException>(() => writer.WriteByteArray("NullByteArray", null));
Assert.Throws<ArgumentNullException>(() => writer.WriteByteArray("NullByteArray", null, 0, 5));
// unacceptable nulls: WriteByteArray from stream
Assert.Throws<ArgumentNullException>(() => writer.WriteByteArray(null, 5));
Assert.Throws<ArgumentNullException>(() => writer.WriteByteArray(null, 5, null));
Assert.Throws<ArgumentNullException>(() => writer.WriteByteArray(dummyStream, 5, null));
Assert.Throws<ArgumentNullException>(() => writer.WriteByteArray("NullBuffer", dummyStream, 5, null));
Assert.Throws<ArgumentNullException>(() => writer.WriteByteArray("NullStream", null, 5));
Assert.Throws<ArgumentNullException>(
() => writer.WriteByteArray("NullStream", null, 5, dummyByteArray));
// unacceptable nulls: WriteIntArray
Assert.Throws<ArgumentNullException>(() => writer.WriteIntArray(null));
Assert.Throws<ArgumentNullException>(() => writer.WriteIntArray(null, 0, 5));
Assert.Throws<ArgumentNullException>(() => writer.WriteIntArray("NullIntArray", null));
Assert.Throws<ArgumentNullException>(() => writer.WriteIntArray("NullIntArray", null, 0, 5));
// non-readable streams are unacceptable
Assert.Throws<ArgumentException>(() => writer.WriteByteArray(new NonReadableStream(), 0));
Assert.Throws<ArgumentException>(
() => writer.WriteByteArray(new NonReadableStream(), 0, new byte[10]));
Assert.Throws<ArgumentException>(
() => writer.WriteByteArray("NonReadableStream", new NonReadableStream(), 0));
// trying to write array with out-of-range offset/count
Assert.Throws<ArgumentOutOfRangeException>(() => writer.WriteByteArray(dummyByteArray, -1, 5));
Assert.Throws<ArgumentOutOfRangeException>(() => writer.WriteByteArray(dummyByteArray, 0, -1));
Assert.Throws<ArgumentException>(() => writer.WriteByteArray(dummyByteArray, 0, 6));
Assert.Throws<ArgumentException>(() => writer.WriteByteArray(dummyByteArray, 1, 5));
Assert.Throws<ArgumentOutOfRangeException>(
() => writer.WriteByteArray("OutOfRangeByteArray", dummyByteArray, -1, 5));
Assert.Throws<ArgumentOutOfRangeException>(
() => writer.WriteByteArray("OutOfRangeByteArray", dummyByteArray, 0, -1));
Assert.Throws<ArgumentException>(
() => writer.WriteByteArray("OutOfRangeByteArray", dummyByteArray, 0, 6));
Assert.Throws<ArgumentException>(
() => writer.WriteByteArray("OutOfRangeByteArray", dummyByteArray, 1, 5));
Assert.Throws<ArgumentOutOfRangeException>(() => writer.WriteIntArray(dummyIntArray, -1, 5));
Assert.Throws<ArgumentOutOfRangeException>(() => writer.WriteIntArray(dummyIntArray, 0, -1));
Assert.Throws<ArgumentException>(() => writer.WriteIntArray(dummyIntArray, 0, 6));
Assert.Throws<ArgumentException>(() => writer.WriteIntArray(dummyIntArray, 1, 5));
Assert.Throws<ArgumentOutOfRangeException>(
() => writer.WriteIntArray("OutOfRangeIntArray", dummyIntArray, -1, 5));
Assert.Throws<ArgumentOutOfRangeException>(
() => writer.WriteIntArray("OutOfRangeIntArray", dummyIntArray, 0, -1));
Assert.Throws<ArgumentException>(
() => writer.WriteIntArray("OutOfRangeIntArray", dummyIntArray, 0, 6));
Assert.Throws<ArgumentException>(
() => writer.WriteIntArray("OutOfRangeIntArray", dummyIntArray, 1, 5));
// out-of-range values for stream-reading overloads of WriteByteArray
Assert.Throws<ArgumentOutOfRangeException>(() => writer.WriteByteArray(dummyStream, -1));
Assert.Throws<ArgumentOutOfRangeException>(() => writer.WriteByteArray("BadLength", dummyStream, -1));
Assert.Throws<ArgumentOutOfRangeException>(
() => writer.WriteByteArray(dummyStream, -1, dummyByteArray));
Assert.Throws<ArgumentOutOfRangeException>(
() => writer.WriteByteArray("BadLength", dummyStream, -1, dummyByteArray));
Assert.Throws<ArgumentException>(() => writer.WriteByteArray(dummyStream, 5, new byte[0]));
Assert.Throws<ArgumentException>(
() => writer.WriteByteArray("BadLength", dummyStream, 5, new byte[0]));
// trying to read from non-readable stream
Assert.Throws<ArgumentException>(
() => writer.WriteByteArray("ByteStream", new NonReadableStream(), 0));
// finish too early
Assert.Throws<NbtFormatException>(writer.Finish);
writer.EndCompound();
writer.Finish();
// write tag after finishing
Assert.Throws<NbtFormatException>(() => writer.WriteTag(new NbtInt()));
}
}
}
