private void Read(StreamFile streamFile)
{
streamFile.Stream.Position = streamFile.Position;
using (BinaryReader reader = new BinaryReader(streamFile.Stream, Encoding.ASCII, true))
{
if (reader.ReadInt32() != MagicNumber)
{
throw new Exception("SPD: wrong Magic Number");
}
if (reader.ReadInt32() != 0x2)
{
}
if (reader.ReadInt32() != streamFile.Size)
{
}
if (reader.ReadInt32() != 0)
{
}
if (reader.ReadInt32() != 0x20)
{
}
ushort TextureCount = reader.ReadUInt16();
ushort KeyCount = reader.ReadUInt16();
int TextureKeyPosition = reader.ReadInt32();
int KeyPosition = reader.ReadInt32();
ReadTexture(streamFile, TextureKeyPosition, TextureCount);
ReadKey(streamFile, KeyPosition, KeyCount);
}
}
public StreamResult GetVideo()
{
try
{
StreamFile sf = new StreamFile();
bool containHeaderInfo = HttpContext.Request.Headers.ContainsKey("Accept");
if (containHeaderInfo)
{
Microsoft.Extensions.Primitives.StringValues headers;
if (HttpContext.Request.Headers.TryGetValue("Accept", out headers))
{
// Check for vide and wild card. Only firefox had the actual video type
if (headers.ToString().Contains("video") || headers.ToString().Contains("*/*"))
{
StreamResult sr = sf.GetVideoStream();
return((sr == null) ? sf.GetEmptyStream() : sr);
}
}
}
return(sf.GetEmptyStream());
}
catch (Exception ex)
{
throw ex;
}
}
public override void DoEncoded(IStreamEncoder encoder, Action action)
{
// Encode the data into a stream
Stream encoded = null;
using (MemoryStream memStream = new MemoryStream()) {
// Stream key
string key = CurrentPointer.ToString() + "_decoded";
// Add the stream
StreamFile sf = new StreamFile(key, memStream, Context)
{
Endianness = currentFile.Endianness
};
Context.AddFile(sf);
DoAt(sf.StartPointer, () => {
action();
memStream.Position = 0;
encoded = encoder.EncodeStream(memStream);
});
Context.RemoveFile(sf);
}
// Turn stream into array & write bytes
if (encoded != null)
{
using (MemoryStream ms = new MemoryStream()) {
encoded.CopyTo(ms);
writer.Write(ms.ToArray());
}
encoded.Close();
}
}
/// <summary>
/// Creates a <see cref="MemoryFileSystem"/> based on the given <see cref="Stream"/>.
/// </summary>
/// <param name="streamFile">The in-memory file to add to the file system.</param>
/// <param name="streamManager">The stream manager for this file system.</param>
/// <returns>The created <see cref="IFileSystem"/> for this stream.</returns>
public static IFileSystem CreateMemoryFileSystem(StreamFile streamFile, IStreamManager streamManager)
{
var stream = streamFile.Stream;
var directory = streamFile.Path.GetDirectory();
// 1. Create file system
var fileSystem = new MemoryFileSystem(streamManager);
if (!directory.IsEmpty && !fileSystem.DirectoryExists(directory))
{
fileSystem.CreateDirectory(directory);
}
var createdStream = fileSystem.OpenFile(streamFile.Path.ToAbsolute(), FileMode.CreateNew, FileAccess.Write, FileShare.Write);
// 2. Copy data
var bkPos = stream.Position;
stream.Position = 0;
stream.CopyTo(createdStream);
stream.Position = bkPos;
createdStream.Position = 0;
createdStream.Close();
return(fileSystem);
}
private void Read(StreamFile streamFile, string name)
{
GetType(streamFile);
int index = 0;
streamFile.Stream.Position = streamFile.Position;
using (BinaryReader reader = Utilities.IO.OpenReadFile(streamFile.Stream, IsLittleEndian))
do
{
int Size = reader.ReadInt32();
if (streamFile.Position + streamFile.Size < Size + streamFile.Stream.Position)
{
throw new Exception("TBL error");
}
byte[] tempdata = reader.ReadBytes(Size);
FileType fileType = Utilities.PersonaFile.GetFileType(tempdata);
string ext = Path.GetExtension(name);
string tempName = name.Substring(0, name.Length - ext.Length) + "(" + index++.ToString().PadLeft(2, '0') + ")";
if (fileType == FileType.Unknown)
{
tempName += ".DAT";
}
else
{
tempName += "." + fileType.ToString();
}
SubFiles.Add(Utilities.PersonaFile.OpenFile(tempName, tempdata, fileType == FileType.Unknown ? FileType.DAT : fileType));
reader.BaseStream.Position += Utilities.Utilities.Alignment(reader.BaseStream.Position - streamFile.Position, 16);
} while (streamFile.Stream.Position < streamFile.Position + streamFile.Size);
}
public void Length_GivenAFileStream_ReturnsLength()
{
using var fs = File.Open(@"./Binaries/pidgin.exe", FileMode.Open);
var file = new StreamFile(fs);
Assert.Equal(60176, file.Length);
}
public void AsSpan_GivenAStream_ReturnsSpan()
{
var file = new StreamFile(_ms);
var s = file.AsSpan(2, 2);
Assert.Equal(0x22, s[0]);
Assert.Equal(0x33, s[1]);
}
private void ReadKey(StreamFile streamFile, int pos, int count)
{
streamFile.Stream.Position = streamFile.Position + pos;
using (BinaryReader reader = new BinaryReader(streamFile.Stream, Encoding.ASCII, true))
for (int i = 0; i < count; i++)
{
KeyList.Add(new SPDKey(reader));
}
}
private void Read(StreamFile streamFile)
{
GetEndian(streamFile);
streamFile.Stream.Position = streamFile.Position;
using (BinaryReader reader = Utilities.IO.OpenReadFile(streamFile.Stream, IsLittleEndian))
{
if (reader.ReadInt32() != HeaderNumber)
{
throw new Exception("FTD: header read error");
}
if (reader.ReadUInt32() != MagicNumber)
{
throw new Exception("FTD: wrong magic number");
}
if (reader.ReadInt32() > streamFile.Size)
{
throw new Exception("FTD: wrong file size");
}
int entryCount = reader.ReadInt32();
List <int> Entry = new List <int>();
for (int i = 0; i < entryCount; i++)
{
Entry.Add(reader.ReadInt32());
}
foreach (var a in Entry)
{
streamFile.Stream.Position = a + 4;
int size = reader.ReadInt32();
int count = reader.ReadInt32();
streamFile.Stream.Position += 4;
if (size % count != 0)
{
throw new Exception("FTD: Hm...");
}
byte[] data = reader.ReadBytes(size);
int subEntry_Size = size / count;
byte[][] entries = new byte[count][];
for (int i = 0; i < count; i++)
{
entries[i] = data.SubArray(i * subEntry_Size, subEntry_Size);
}
Entries.Add(entries);
}
}
}
public static StreamFile AddStreamFile(this Context context, string name, Stream stream, BinaryFile.Endian endianness = BinaryFile.Endian.Little, bool recreateOnWrite = true)
{
var file = new StreamFile(name, stream, context)
{
Endianness = endianness,
RecreateOnWrite = recreateOnWrite
};
context.AddFile(file);
return(file);
}
private void Read(StreamFile streamFile)
{
streamFile.Stream.Position = streamFile.Position;
using (BinaryReader reader = new BinaryReader(streamFile.Stream, Encoding.ASCII, true))
{
uint ty = reader.ReadUInt32();
if (ty != MagicNumber)
{
throw new Exception("DDS: wrong Magic Number");
}
else
{
ReadT1(reader);
}
}
}
public static T ReadStreamData <T>(this Context context, Stream stream, string name = "Stream", Endian?endian = null, bool leaveOpen = false, Action <T>?onPreSerialize = null)
where T : BinarySerializable, new()
{
BinaryFile file = new StreamFile(context, name, stream, endian, leaveOpen: leaveOpen);
context.AddFile(file);
try
{
return(FileFactory.Read <T>(context, name, (_, o) => onPreSerialize?.Invoke(o)));
}
finally
{
context.RemoveFile(file);
}
}
public static void WriteStreamData <T>(this Context context, Stream stream, T obj, string name = "Stream", Endian?endian = null, bool leaveOpen = false)
where T : BinarySerializable, new()
{
BinaryFile file = new StreamFile(context, name, stream, endian, leaveOpen: leaveOpen);
context.AddFile(file);
try
{
FileFactory.Write(context, name, obj);
}
finally
{
context.RemoveFile(file);
}
}
public void WriteByte_GivenAStreamAndOffset_WritesByteAtOffset()
{
var buff = new byte[]
{
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
};
using var ms = new MemoryStream(buff);
var sf = new StreamFile(ms);
sf.WriteByte(2, 0xff);
Assert.Equal(0xff, buff[2]);
}
/// <inheritdoc />
public async Task <LoadResult> LoadFile(StreamFile streamFile, LoadFileContext loadFileContext)
{
ContractAssertions.IsNotNull(_fileState, "fileState");
// 1. Load file
var loadResult = await _parentFileManager.LoadFile(streamFile, loadFileContext);
if (!loadResult.IsSuccessful)
{
return(loadResult);
}
// 2. Add file to loaded files
_loadedFiles.Add(loadResult.LoadedFileState);
return(loadResult);
}
private void GetType(StreamFile streamFile)
{
try
{
streamFile.Stream.Position = streamFile.Position;
using (BinaryReader reader = Utilities.IO.OpenReadFile(streamFile.Stream, true))
do
{
int Size = reader.ReadInt32();
if (streamFile.Position + streamFile.Size < Size + streamFile.Stream.Position)
{
throw new Exception("TBL error");
}
reader.BaseStream.Position += Size;
reader.BaseStream.Position += Utilities.Utilities.Alignment(reader.BaseStream.Position - streamFile.Position, 16);
} while (streamFile.Stream.Position < streamFile.Position + streamFile.Size);
IsLittleEndian = true;
}
catch
{
try
{
streamFile.Stream.Position = streamFile.Position;
using (BinaryReader reader = Utilities.IO.OpenReadFile(streamFile.Stream, false))
do
{
int Size = reader.ReadInt32();
if (streamFile.Position + streamFile.Size < Size + streamFile.Stream.Position)
{
throw new Exception("TBL error");
}
reader.BaseStream.Position += Size;
reader.BaseStream.Position += Utilities.Utilities.Alignment(reader.BaseStream.Position - streamFile.Position, 16);
} while (streamFile.Stream.Position < streamFile.Position + streamFile.Size);
IsLittleEndian = false;
}
catch
{
throw new Exception("TBL error");
}
}
}
public void ReadUnicodeString_GivenAStream_ReturnsAString()
{
var buff = new byte[] {
0x00, 0x00, // garbage
0x68, 0x00, // h
0x65, 0x00, // e
0x6c, 0x00, // l
0x6c, 0x00, // l
0x6f, 0x00, // o
0x00, 0x00, // string termination
0x11, 0x22 // garbage
};
using var ms = new MemoryStream(buff);
var file = new StreamFile(ms);
Assert.Equal("hello", file.ReadUnicodeString(2));
}
public void WriteUShort_GivenAStreamAndOffset_WritesUShortAtOffset()
{
var buff = new byte[]
{
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
};
using var ms = new MemoryStream(buff);
var sf = new StreamFile(ms);
sf.WriteUShort(2, 0x1122);
Assert.Equal(0x22, buff[2]);
Assert.Equal(0x11, buff[3]);
}
private void ReadTexture(StreamFile streamFile, int pos, int count)
{
streamFile.Stream.Position = streamFile.Position + pos;
using (BinaryReader reader = new BinaryReader(streamFile.Stream, Encoding.ASCII, true))
for (int i = 0; i < count; i++)
{
streamFile.Stream.Position += 8;
long texPos = reader.ReadUInt32();
int texSize = reader.ReadInt32();
streamFile.Stream.Position += 16;
string name = Encoding.ASCII.GetString(reader.ReadBytes(16)).TrimEnd('\0');
long tempPos = streamFile.Stream.Position;
streamFile.Stream.Position = texPos;
SubFiles.Add(Utilities.PersonaFile.OpenFile(name + ".dds", reader.ReadBytes(texSize), Interfaces.FileType.DDS));
streamFile.Stream.Position = tempPos;
}
}
private MediaTrack[] MapTextTracks(string textTracks)
{
List <MediaTrack> tracks = new List <MediaTrack>();
if (!string.IsNullOrEmpty(textTracks))
{
string[] tracksInfo = textTracks.Split(Constants.MultiItemsSeparator);
foreach (string trackInfo in tracksInfo)
{
MediaTrack track = new MediaTrack();
string[] textTrack = trackInfo.Split(Constants.MultiItemSeparator);
track.Type = textTrack[0];
track.Source = textTrack[1];
track.Language = StreamFile.GetLanguageCode(track.Source);
tracks.Add(track);
}
}
return(tracks.ToArray());
}
private void GetEndian(StreamFile streamFile)
{
streamFile.Stream.Position = streamFile.Position + 4;
byte[] magicnum = new byte[4];
streamFile.Stream.Read(magicnum, 0, 4);
if (BitConverter.ToUInt32(magicnum, 0) == MagicNumber)
{
IsLittleEndian = true;
}
else if (BitConverter.ToUInt32(magicnum.Reverse().ToArray(), 0) == MagicNumber)
{
IsLittleEndian = false;
}
else
{
throw new Exception("FTD: wrong magic number");
}
}
public Mp3Tagger()
{
Receive <dynamic>(message =>
{
// NOTE: gettting stack overflow here!
var streamFile = new StreamFile(message.Resource, message.Path);
var f = File.Create(streamFile);
f.Tag.Album = message.Album;
// f.Tag.AlbumArtists = new[] {message.Artist};
f.Tag.Title = message.Track;
//f.Tag.Pictures = new IPicture[new Picture()];
f.Save();
var buffer = new byte[streamFile.ReadStream.Length];
streamFile.ReadStream.Read(buffer, 0, Convert.ToInt32(streamFile.ReadStream.Length));
});
}
/// <summary>
/// Get <see cref="StreamFile"/> object from EPGStation's recorded file <see cref="Program"/>.
/// </summary>
/// <param name="body"></param>
/// <param name="mEPG">A working access to EPGStation.</param>
/// <returns></returns>
public static StreamFile GetStreamFileObj(this Program body, EPGAccess mEPG)
{
if (body == null)
{
return(null);
}
StreamFile mFile = new StreamFile();
mFile.ChannelName = mEPG.GetChannelNameByID(body.channelId);
mFile.Content = body.description;
mFile.Infomation = body.extended;
mFile.Title = body.name;
mFile.recTitle = body.name;
mFile.recKeyWord = "EPGStation " + body.id.ToString();
mFile.recSubTitle = body.videoResolution + body.videoResolution + body.videoType;
mFile.recKeywordInfo = string.Format("Error:E({0})D({1})S({2})", body.errorCnt, body.dropCnt, body.scramblingCnt);
mFile.Genre = body.Genre;
mFile.StartTime = GetTimeFromUNIXTime(body.startAt);
mFile.EndTime = GetTimeFromUNIXTime(body.endAt);
mFile.FilePath = System.IO.Path.Combine(mEPG.BaseFolder, System.Web.HttpUtility.UrlDecode(body.filename));
mFile.EPGStation = new EPGMetaFile(mEPG, body);
return(mFile);
}
static void Main(string[] args)
{
// Altseed を初期化します。
if (!Engine.Initialize("StaticFile", 640, 480, new Configuration()))
{
return;
}
// ファイルを読み込みます。
var streamFile = StreamFile.Create(@"TestData\IO\test.txt");
// メインループ。
// Altseed のウインドウが閉じられると終了します。
while (Engine.DoEvents())
{
// Altseedを更新します。
Engine.Update();
// 1バイト読み込む
var size = streamFile.Read(1);
// バイト配列をUTF8として、string型に変換します。
var text = Encoding.UTF8.GetString(streamFile.TempBuffer);
// コンソールに出力します。
Console.WriteLine(text);
// 新たに読み込んだデータが0なら終了させます。
if (size == 0)
{
break;
}
}
// Altseed の終了処理をします。
Engine.Terminate();
}
public void WriteULong_GivenAStreamAndOffset_WritesULongAtOffset()
{
var buff = new byte[]
{
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
};
using var ms = new MemoryStream(buff);
var sf = new StreamFile(ms);
sf.WriteULong(2, 0x1122334455667788);
Assert.Equal(0x88, buff[2]);
Assert.Equal(0x77, buff[3]);
Assert.Equal(0x66, buff[4]);
Assert.Equal(0x55, buff[5]);
Assert.Equal(0x44, buff[6]);
Assert.Equal(0x33, buff[7]);
Assert.Equal(0x22, buff[8]);
Assert.Equal(0x11, buff[9]);
}
/// <inheritdoc />
public Task <LoadResult> LoadFile(StreamFile streamFile)
{
return(LoadFile(streamFile, new LoadFileContext()));
}
/// <summary>
/// Writes the files to the archive
/// </summary>
/// <param name="generator">The generator</param>
/// <param name="archive">The loaded archive data</param>
/// <param name="outputFileStream">The file output stream for the archive</param>
/// <param name="files">The files to include</param>
public void WriteArchive(IDisposable?generator, object archive, ArchiveFileStream outputFileStream, IList <ArchiveFileItem> files)
{
Logger.Info("A CNT archive is being repacked...");
// Get the archive data
var data = (CNT)archive;
// Create the file generator
using ArchiveFileGenerator <CNT_File> fileGenerator = new();
// Get files and entries
var archiveFiles = files.Select(x => new
{
Entry = (CNT_File)x.ArchiveEntry,
FileItem = x
}).ToArray();
// Set files and directories
data.Directories = files.Select(x => x.Directory).Distinct().Where(x => !x.IsNullOrWhiteSpace()).ToArray();
data.Files = archiveFiles.Select(x => x.Entry).ToArray();
// Set the directory indexes
foreach (var file in archiveFiles)
{
// Set the directory index
file.Entry.DirectoryIndex = file.FileItem.Directory == String.Empty ? -1 : data.Directories.FindItemIndex(x => x == file.FileItem.Directory);
}
BinaryFile binaryFile = new StreamFile(Context, outputFileStream.Name, outputFileStream.Stream, leaveOpen: true);
try
{
Context.AddFile(binaryFile);
// Initialize the data
data.Init(binaryFile.StartPointer);
// Set the current pointer position to the header size
data.RecalculateSize();
uint pointer = (uint)data.Size;
// Disable checksum
data.IsChecksumUsed = false;
// NOTE: We can't disable the XOR key entirely as that would disable it for the file bytes too, which would require them all to be decrypted
// Reset XOR keys
data.StringsXORKey = 0;
// Load each file
foreach (var file in archiveFiles)
{
// Get the file entry
CNT_File entry = file.Entry;
// Reset checksum and XOR key
entry.FileChecksum = 0;
entry.Pre_FileNameXORKey = 0;
// Add to the generator
fileGenerator.Add(entry, () =>
{
// Get the file stream to write to the archive
Stream fileStream = file.FileItem.GetFileData(generator).Stream;
// Set the pointer
entry.FileOffset = pointer;
// Update the pointer by the file size
pointer += entry.FileSize;
// Invoke event
OnWritingFileToArchive?.Invoke(this, new ValueEventArgs <ArchiveFileItem>(file.FileItem));
return(fileStream);
});
}
// Make sure we have a generator for each file
if (fileGenerator.Count != data.Files.Length)
{
throw new Exception("The .cnt file can't be serialized without a file generator for each file");
}
// Write the file contents
foreach (CNT_File file in data.Files)
{
// Get the file stream
using Stream fileStream = fileGenerator.GetFileStream(file);
// Set the position to the pointer
outputFileStream.Stream.Position = file.FileOffset;
// Write the contents from the generator
fileStream.CopyTo(outputFileStream.Stream);
}
outputFileStream.Stream.Position = 0;
// Serialize the data
FileFactory.Write(Context, binaryFile.FilePath, data);
Logger.Info("The CNT archive has been repacked");
}
finally
{
Context.RemoveFile(binaryFile);
}
}
/// <inheritdoc />
public Task <LoadResult> LoadFile(StreamFile streamFile, Guid pluginId)
{
return(LoadFile(streamFile, new LoadFileContext {
PluginId = pluginId
}));
}
/// <summary>
/// Writes the files to the archive
/// </summary>
/// <param name="generator">The generator</param>
/// <param name="archive">The loaded archive data</param>
/// <param name="outputFileStream">The file output stream for the archive</param>
/// <param name="files">The files to include</param>
public void WriteArchive(IDisposable?generator, object archive, ArchiveFileStream outputFileStream, IList <ArchiveFileItem> files)
{
Logger.Info("An R1 PC archive is being repacked...");
// Get the archive data
var data = (PC_FileArchive)archive;
// Create the file generator
using ArchiveFileGenerator <PC_FileArchiveEntry> fileGenerator = new();
// Get files and entries
var archiveFiles = files.Select(x => new
{
Entry = (PC_FileArchiveEntry)x.ArchiveEntry,
FileItem = x
}).ToArray();
// Set files and directories
data.Entries = archiveFiles.Select(x => x.Entry).ToArray();
BinaryFile binaryFile = new StreamFile(Context, outputFileStream.Name, outputFileStream.Stream, leaveOpen: true);
try
{
Context.AddFile(binaryFile);
// Initialize the data
data.Init(binaryFile.StartPointer);
// Set the current pointer position to the header size
data.RecalculateSize();
uint pointer = (uint)data.Size;
// Load each file
foreach (var file in archiveFiles)
{
// Process the file name
file.Entry.FileName = ProcessFileName(file.Entry.FileName);
// Get the file entry
PC_FileArchiveEntry entry = file.Entry;
// Add to the generator
fileGenerator.Add(entry, () =>
{
// Get the file stream to write to the archive
Stream fileStream = file.FileItem.GetFileData(generator).Stream;
// Set the pointer
entry.FileOffset = pointer;
// Update the pointer by the file size
pointer += entry.FileSize;
// Invoke event
OnWritingFileToArchive?.Invoke(this, new ValueEventArgs <ArchiveFileItem>(file.FileItem));
return(fileStream);
});
}
// Make sure we have a generator for each file
if (fileGenerator.Count != data.Entries.Length)
{
throw new Exception("The .dat file can't be serialized without a file generator for each file");
}
// Write the file contents
foreach (PC_FileArchiveEntry file in data.Entries)
{
// Get the file stream
using Stream fileStream = fileGenerator.GetFileStream(file);
// Set the position to the pointer
outputFileStream.Stream.Position = file.FileOffset;
// Write the contents from the generator
fileStream.CopyTo(outputFileStream.Stream);
}
outputFileStream.Stream.Position = 0;
// Serialize the data
FileFactory.Write(Context, binaryFile.FilePath, data);
Logger.Info("The R1 PC archive has been repacked");
}
finally
{
Context.RemoveFile(binaryFile);
}
}
public void StreamFileBase()
{
Assert.True(Engine.Initialize("Altseed2 C# Engine", 800, 600, new Configuration()));
// pack files
Assert.True(Engine.File.Pack("../../Core/TestData/IO/", "pack.pack"));
Assert.True(Engine.File.PackWithPassword("../../Core/TestData/IO/pack/", "password.pack", "altseed"));
// add package
Assert.True(Engine.File.AddRootPackage("pack.pack"));
// create static file, and compare no-package and package without password
StreamFile test = null;
Assert.AreNotEqual(test = StreamFile.Create("../../Core/TestData/IO/test.txt"), null);
Assert.False(test.IsInPackage);
StreamFile testPack = null;
Assert.AreNotEqual(testPack = StreamFile.Create("test.txt"), null);
Assert.True(testPack.IsInPackage);
Assert.AreEqual(test.Size, testPack.Size);
Assert.AreEqual(test.TempBufferSize, 0);
Assert.AreEqual(testPack.TempBufferSize, 0);
for (int i = 0; i < test.Size; i++)
{
Assert.AreEqual(test.Read(1), 1);
Assert.AreEqual(testPack.Read(1), 1);
Assert.AreEqual(test.TempBufferSize, i + 1);
Assert.AreEqual(testPack.TempBufferSize, i + 1);
Assert.AreEqual(test.TempBuffer, test.TempBuffer);
}
// add package
Assert.True(Engine.File.AddRootPackageWithPassword("password.pack", "altseed"));
// clear cache
Engine.Resources.Clear();
StreamFile testPack2 = null;
Assert.AreNotEqual(testPack2 = StreamFile.Create("test.txt"), null);
Assert.True(testPack2.IsInPackage);
Assert.AreNotEqual(testPack, testPack2);
Assert.AreNotEqual(testPack.Size, testPack2.Size);
// create static file, and compare no-package and package with password
StreamFile test3 = null;
Assert.AreNotEqual(test3 = StreamFile.Create("../../Core/TestData/IO/pack/test.txt"), null);
Assert.AreEqual(test3.Size, testPack2.Size);
Assert.AreEqual(test3.Size, testPack2.Size);
Assert.AreEqual(test3.TempBufferSize, 0);
Assert.AreEqual(testPack2.TempBufferSize, 0);
for (int i = 0; i < test3.Size; i++)
{
Assert.AreEqual(test3.Read(1), 1);
Assert.AreEqual(testPack2.Read(1), 1);
Assert.AreEqual(test3.TempBufferSize, i + 1);
Assert.AreEqual(testPack2.TempBufferSize, i + 1);
}
Engine.Terminate();
}
