public void LoadFromStream()
{
TestFiles.RelocateTestFiles();
LoadFromStreamInternal(TestFiles.Big, NbtCompression.None);
LoadFromStreamInternal(TestFiles.BigGZip, NbtCompression.GZip);
LoadFromStreamInternal(TestFiles.BigZLib, NbtCompression.ZLib);
}
public void SkippingTagsOnFileLoad()
{
TestFiles.RelocateTestFiles();
var loadedFile = new NbtFile();
loadedFile.LoadFromFile("TestFiles/bigtest.nbt",
NbtCompression.None,
tag => tag.Name != "nested compound test");
Assert.IsFalse(loadedFile.RootTag.Contains("nested compound test"));
Assert.IsTrue(loadedFile.RootTag.Contains("listTest (long)"));
loadedFile.LoadFromFile("TestFiles/bigtest.nbt",
NbtCompression.None,
tag => tag.TagType != NbtTagType.Float || tag.Parent.Name != "Level");
Assert.IsFalse(loadedFile.RootTag.Contains("floatTest"));
Assert.AreEqual(0.75f, loadedFile.RootTag["nested compound test"]["ham"]["value"].FloatValue);
loadedFile.LoadFromFile("TestFiles/bigtest.nbt",
NbtCompression.None,
tag => tag.Name != "listTest (long)");
Assert.IsFalse(loadedFile.RootTag.Contains("listTest (long)"));
Assert.IsTrue(loadedFile.RootTag.Contains("byteTest"));
loadedFile.LoadFromFile("TestFiles/bigtest.nbt",
NbtCompression.None,
tag => false);
Assert.AreEqual(0, loadedFile.RootTag.Count);
}
public void PartialReadTest()
{
TestFiles.RelocateTestFiles();
// read the whole thing as one tag, one byte at a time
TestFiles.AssertValueTest(PartialReadTestInternal(new NbtFile(TestFiles.MakeValueTest())));
TestFiles.AssertNbtSmallFile(PartialReadTestInternal(TestFiles.MakeSmallFile()));
TestFiles.AssertNbtBigFile(PartialReadTestInternal(new NbtFile(TestFiles.Big)));
}
public void PartialBatchReadTest()
{
TestFiles.RelocateTestFiles();
// read the whole thing as one tag, in batches of 4 bytes
// Verifies fix for https://github.com/fragmer/fNbt/issues/26
TestFiles.AssertValueTest(PartialReadTestInternal(new NbtFile(TestFiles.MakeValueTest()), 4));
TestFiles.AssertNbtSmallFile(PartialReadTestInternal(TestFiles.MakeSmallFile(), 4));
TestFiles.AssertNbtBigFile(PartialReadTestInternal(new NbtFile(TestFiles.Big), 4));
}
public void TestNbtSmallFileSavingUncompressed()
{
TestFiles.RelocateTestFiles();
NbtFile file = TestFiles.MakeSmallFile();
string testFileName = Path.Combine(TestDirName, "test.nbt");
file.SaveToFile(testFileName, NbtCompression.None);
FileAssert.AreEqual(TestFiles.Small, testFileName);
}
public void TestNbtSmallFileLoadingUncompressed()
{
TestFiles.RelocateTestFiles();
var file = new NbtFile(TestFiles.Small);
Assert.AreEqual(TestFiles.Small, file.FileName);
Assert.AreEqual(NbtCompression.None, file.FileCompression);
TestFiles.AssertNbtSmallFile(file);
}
public void LoadingSmallFileZLib()
{
TestFiles.RelocateTestFiles();
var file = new NbtFile(TestFiles.SmallZLib);
Assert.AreEqual(TestFiles.SmallZLib, file.FileName);
Assert.AreEqual(NbtCompression.ZLib, file.FileCompression);
TestFiles.AssertNbtSmallFile(file);
}
public void LoadingBigFileZLib()
{
TestFiles.RelocateTestFiles();
var file = new NbtFile();
long length = file.LoadFromFile(TestFiles.BigZLib);
TestFiles.AssertNbtBigFile(file);
Assert.AreEqual(length, new FileInfo(TestFiles.BigZLib).Length);
}
public void ReadRootTag()
{
TestFiles.RelocateTestFiles();
Assert.Throws <FileNotFoundException>(() => NbtFile.ReadRootTagName("NonExistentFile"));
ReadRootTagInternal(TestFiles.Big, NbtCompression.None);
ReadRootTagInternal(TestFiles.BigGZip, NbtCompression.GZip);
ReadRootTagInternal(TestFiles.BigZLib, NbtCompression.ZLib);
}
public void PrettyPrint()
{
TestFiles.RelocateTestFiles();
var loadedFile = new NbtFile(TestFiles.Big);
Assert.AreEqual(loadedFile.RootTag.ToString(), loadedFile.ToString());
Assert.AreEqual(loadedFile.RootTag.ToString(" "), loadedFile.ToString(" "));
Assert.Throws <ArgumentNullException>(() => loadedFile.ToString(null));
Assert.Throws <ArgumentNullException>(() => NbtTag.DefaultIndentString = null);
}
public void ReloadFileUnbuffered()
{
TestFiles.RelocateTestFiles();
ReloadFileInternal("bigtest.nbt", NbtCompression.None, true, false);
ReloadFileInternal("bigtest.nbt.gz", NbtCompression.GZip, true, false);
ReloadFileInternal("bigtest.nbt.z", NbtCompression.ZLib, true, false);
ReloadFileInternal("bigtest.nbt", NbtCompression.None, false, false);
ReloadFileInternal("bigtest.nbt.gz", NbtCompression.GZip, false, false);
ReloadFileInternal("bigtest.nbt.z", NbtCompression.ZLib, false, false);
}
public void NonSeekableStreamSkip1()
{
TestFiles.RelocateTestFiles();
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 LoadingBigFileStream()
{
TestFiles.RelocateTestFiles();
byte[] fileBytes = File.ReadAllBytes(TestFiles.Big);
using (var ms = new MemoryStream(fileBytes)) {
using (var nss = new NonSeekableStream(ms)) {
var file = new NbtFile();
long length = file.LoadFromStream(nss, NbtCompression.None, null);
TestFiles.AssertNbtBigFile(file);
Assert.AreEqual(length, new FileInfo(TestFiles.Big).Length);
}
}
}
public void LoadingBigFileBuffer()
{
TestFiles.RelocateTestFiles();
byte[] fileBytes = File.ReadAllBytes(TestFiles.Big);
var file = new NbtFile();
Assert.Throws <ArgumentNullException>(
() => file.LoadFromBuffer(null, 0, fileBytes.Length, NbtCompression.AutoDetect, null));
long length = file.LoadFromBuffer(fileBytes, 0, fileBytes.Length, NbtCompression.AutoDetect, null);
TestFiles.AssertNbtBigFile(file);
Assert.AreEqual(length, new FileInfo(TestFiles.Big).Length);
}
public void TestNbtSmallFileSavingUncompressedStream()
{
TestFiles.RelocateTestFiles();
NbtFile file = TestFiles.MakeSmallFile();
var nbtStream = new MemoryStream();
Assert.Throws <ArgumentNullException>(() => file.SaveToStream(null, NbtCompression.None));
Assert.Throws <ArgumentException>(() => file.SaveToStream(nbtStream, NbtCompression.AutoDetect));
Assert.Throws <ArgumentOutOfRangeException>(() => file.SaveToStream(nbtStream, (NbtCompression)255));
file.SaveToStream(nbtStream, NbtCompression.None);
FileStream testFileStream = File.OpenRead(TestFiles.Small);
FileAssert.AreEqual(testFileStream, nbtStream);
}
public void PrintBigFileUncompressed()
{
TestFiles.RelocateTestFiles();
using (FileStream fs = File.OpenRead("TestFiles/bigtest.nbt")) {
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 ReloadNonSeekableStream()
{
TestFiles.RelocateTestFiles();
var loadedFile = new NbtFile(TestFiles.Big);
using (var ms = new MemoryStream()) {
using (var nss = new NonSeekableStream(ms)) {
long bytesWritten = loadedFile.SaveToStream(nss, NbtCompression.None);
ms.Position = 0;
Assert.Throws <NotSupportedException>(() => loadedFile.LoadFromStream(nss, NbtCompression.AutoDetect));
ms.Position = 0;
Assert.Throws <InvalidDataException>(() => loadedFile.LoadFromStream(nss, NbtCompression.ZLib));
ms.Position = 0;
long bytesRead = loadedFile.LoadFromStream(nss, NbtCompression.None);
Assert.AreEqual(bytesWritten, bytesRead);
TestFiles.AssertNbtBigFile(loadedFile);
}
}
}
