public void LengthTest()
{
var stream = new MemoryStream(new byte[1024]);
var target = new BufferedInMemoryStream(stream);
Assert.AreEqual(1024, target.Length, "Must exposed length of seekable base stream.");
}
public void CanWriteTest()
{
var stream = new MemoryStream(new byte[1024]);
var target = new BufferedInMemoryStream(stream);
Assert.AreEqual(true, target.CanWrite);
}
public static SimisStreamWriter ToStream(Stream output, bool isBinary, bool isCompressed)
{
var compressedLengthPosition = 0L;
var innerStream = output;
if (isBinary)
{
using (var writer = new BinaryWriter(new UnclosableStream(output), ByteEncoding.Encoding)) {
if (isCompressed)
{
writer.Write("SIMISA@F".ToCharArray());
compressedLengthPosition = output.Position;
writer.Write("\0\0\0\0@@@@\x78\x9C".ToCharArray());
innerStream = new BufferedInMemoryStream(new DeflateStream(output, CompressionMode.Compress));
}
else
{
writer.Write("SIMISA@@@@@@@@@@".ToCharArray());
}
}
}
else
{
Debug.Assert(!isCompressed, "SimisStreamWriter does not support compressed text.");
using (var writer = new BinaryWriter(new UnclosableStream(output), Encoding.Unicode)) {
writer.Write(Encoding.Unicode.GetPreamble());
writer.Write("SIMISA@@@@@@@@@@".ToCharArray());
}
}
return(new SimisStreamWriter(output, innerStream, isBinary, isCompressed, compressedLengthPosition));
}
public void ConstructorTest()
{
var stream = new MemoryStream(new byte[1024]);
var target = new BufferedInMemoryStream(stream);
Assert.AreEqual(0, stream.Position, "Must not read from base stream.");
Assert.AreEqual(0, target.Position, "Must start from the beginning.");
}
public void PositionTest()
{
var stream = new MemoryStream(new byte[1024]);
var target = new BufferedInMemoryStream(stream);
target.WriteByte(0);
Assert.AreEqual(1, target.Position, "Must advance stream for writes.");
}
public void FlushTest()
{
var stream = new MemoryStream(new byte[1024]);
var target = new BufferedInMemoryStream(stream);
target.WriteByte(0);
target.Flush();
Assert.AreEqual(0, stream.Position, "Must not advance base stream.");
}
public void RealFlushTest()
{
var stream = new MemoryStream(new byte[1024]);
var target = new BufferedInMemoryStream(stream);
target.WriteByte(1);
target.RealFlush();
Assert.AreNotEqual(0, stream.Position, "Must advanced base stream on ReadFlush() after Write().");
Assert.Inconclusive("Verify 'stream' has correct contents.");
}
public void WriteTest()
{
var stream = new MemoryStream(new byte[1024]);
var target = new BufferedInMemoryStream(stream); // TODO: Initialize to an appropriate value
var buffer = new byte[0]; // TODO: Initialize to an appropriate value
var offset = 0; // TODO: Initialize to an appropriate value
var count = 0; // TODO: Initialize to an appropriate value
target.Write(buffer, offset, count);
Assert.Inconclusive("A method that does not return a value cannot be verified.");
}
public void SetLengthTest()
{
var stream = new MemoryStream(new byte[1024]);
var target = new BufferedInMemoryStream(stream);
try {
target.SetLength(0);
Assert.Fail("Must throw NotImplementedException.");
} catch (NotImplementedException) {
}
}
public void CloseTest()
{
var stream = new MemoryStream(new byte[1024]);
var target = new BufferedInMemoryStream(stream);
var i = stream.Position;
target.Close();
try {
i = stream.Position;
Assert.Fail("Must close base stream.");
} catch (ObjectDisposedException) {
}
}
public void ReadTest()
{
var stream = new MemoryStream(new byte[1024]);
var target = new BufferedInMemoryStream(stream);
var buffer = new byte[10];
var offset = 0;
var count = 10;
var actual = target.Read(buffer, offset, count);
Assert.AreNotEqual(0, stream.Position, "Base stream must have advanced.");
Assert.AreEqual(count, actual, "Must read 'count' bytes.");
Assert.AreEqual(count, target.Position, "Must advanced 'count' bytes.");
Assert.Inconclusive("Verify 'buffer' has correct contents.");
}
/// <summary>
/// Creates a <see cref="SimisFile"/> from a file.
/// </summary>
/// <param name="fileName">The file to read from.</param>
/// <param name="simisProvider">A <see cref="SimisProvider"/> within which the appropriate <see cref="Bnf"/> for parsing can be found.</param>
public SimisFile(string fileName, SimisProvider simisProvider)
{
FileName = fileName;
SimisProvider = simisProvider;
try {
using (var fileStream = File.OpenRead(FileName)) {
using (var stream = new BufferedInMemoryStream(fileStream)) {
ReadStream(stream, out StreamIsBinary, out StreamIsCompressed, out JinxStreamIsBinary, out JinxStreamFormat, out Tree, out Ace);
}
}
} catch (ReaderException e) {
throw new FileException(FileName, e);
}
}
public void SeekTest()
{
var stream = new MemoryStream(new byte[1024]);
var target = new BufferedInMemoryStream(stream);
var offset = 10;
target.Seek(offset, SeekOrigin.Begin);
Assert.AreEqual(0, stream.Position, "Must not advanced base stream.");
target.ReadByte();
Assert.AreNotEqual(0, stream.Position, "Must advanced base stream.");
{
var actual = target.Seek(offset, SeekOrigin.Begin);
Assert.AreEqual(offset, actual, "Must seek stream.");
}
}
public void ReadFile()
{
MessageSend(LevelInformation, "Loading '" + FileName + "'...");
try {
using (var fileStream = File.OpenRead(FileName)) {
using (var stream = new BufferedInMemoryStream(fileStream)) {
using (var reader = new StreamReader(stream, true)) {
var parser = new BnfParser(this, reader);
while (true)
{
var rule = parser.NextRule();
if (rule == null)
{
break;
}
MessageSend(LevelDebug, rule.ToString());
var ruleD = rule as BnfDefinition;
if (ruleD != null)
{
if (rule.Symbol.Reference == "FILE")
{
Func <Operator, Func <Operator, IEnumerable <string> >, IEnumerable <string> > scan = null;
scan = (op, finder) => {
var uop = op as UnaryOperator;
if (uop != null)
{
return(scan(uop.Right, finder));
}
var lop = op as BinaryOperator;
if (lop != null)
{
return(scan(lop.Left, finder).Concat(scan(lop.Right, finder)));
}
return(finder(op));
};
BnfFileRoots = new List <string>(
scan(rule.Expression, op => {
var rop = op as ReferenceOperator;
if (rop != null)
{
return(new string[] { rop.Reference });
}
return(new string[] { });
})
);
}
else if ((rule.Symbol.Reference == "FILE_NAME") && (rule.Expression is StringOperator))
{
BnfFileName = ((StringOperator)rule.Expression).Value;
}
else if ((rule.Symbol.Reference == "FILE_EXT") && (rule.Expression is StringOperator))
{
BnfFileExtension = ((StringOperator)rule.Expression).Value;
}
else if ((rule.Symbol.Reference == "FILE_TYPE") && (rule.Expression is StringOperator))
{
BnfFileType = ((StringOperator)rule.Expression).Value;
}
else if ((rule.Symbol.Reference == "FILE_TYPE_VER") && (rule.Expression is StringOperator))
{
if (((StringOperator)rule.Expression).Value.Length > 0)
{
BnfFileTypeVersion = int.Parse(((StringOperator)rule.Expression).Value, CultureInfo.InvariantCulture);
}
}
if (Bnf.Definitions.ContainsKey(rule.Symbol.Reference))
{
throw new FileException(FileName, "BNF file contains multiple definitions for '" + rule.Symbol.Reference + "'.");
}
Bnf.Definitions.Add(rule.Symbol.Reference, ruleD);
}
var ruleP = rule as BnfProduction;
if (ruleP != null)
{
if (Bnf.Productions.ContainsKey(rule.Symbol.Reference))
{
throw new FileException(FileName, "BNF file contains multiple productions for '" + rule.Symbol.Reference + "'.");
}
Bnf.Productions.Add(rule.Symbol.Reference, ruleP);
}
}
Debug.Assert(reader.BaseStream.Position >= reader.BaseStream.Length, "Parser " + parser.ToString() + " failed to consume all input for <" + FileName + ">.");
}
}
}
} catch (InvalidBnfFormatException ex) {
throw new FileException(FileName, ex);
}
MessageSend(LevelInformation, "Done.");
try {
if (BnfFileName.Length == 0)
{
throw new InvalidDataException("BNF file does not specify a name.");
}
if (BnfFileExtension.Length == 0)
{
throw new InvalidDataException("BNF file does not specify a file extension.");
}
if (BnfFileType.Length == 0)
{
throw new InvalidDataException("BNF file does not specify a valid Simis Format.");
}
if (BnfFileTypeVersion == -1)
{
throw new InvalidDataException("BNF file does not specify a valid Simis Format Version.");
}
} catch (InvalidDataException ex) {
throw new FileException(FileName, ex);
}
}
