public void WritesInChunks()
{
int bufferSize = 500;
int size = 3000;
var buffers = new List <ArraySegment <byte> >();
var writer = new BinaryTextWriter((buffer, state) =>
{
buffers.Add(buffer);
},
null, reuseBuffers: true, bufferSize: bufferSize);
writer.Write(new string('C', size));
writer.Flush();
var expected = GetChunks(size, bufferSize).ToArray();
Assert.NotEmpty(buffers);
Assert.Equal(expected.Length, buffers.Count);
for (int i = 0; i < buffers.Count; i++)
{
Assert.Equal(expected[i], buffers[i].Count);
}
}
public void CanInterleaveStringsAndRawBinary()
{
var buffers = new List <ArraySegment <byte> >();
var writer = new BinaryTextWriter((buffer, state) =>
{
buffers.Add(buffer);
},
null, reuseBuffers: true, bufferSize: 128);
var encoding = new UTF8Encoding();
writer.Write('H');
writer.Write('e');
writer.Write("llo ");
writer.Write(new ArraySegment <byte>(encoding.GetBytes("World")));
writer.Flush();
Assert.Equal(2, buffers.Count);
var s = "";
foreach (var buffer in buffers)
{
s += encoding.GetString(buffer.Array, buffer.Offset, buffer.Count);
}
Assert.Equal("Hello World", s);
}
public void WriteDefault()
{ //****************************************
byte[] MyResult;
byte[] TempOutput;
//****************************************
using (var RawStream = new MemoryStream())
{
using (var Writer = new StreamWriter(RawStream))
{
Writer.Write(_TestInput);
}
TempOutput = RawStream.ToArray();
}
//****************************************
using (var Buffer = new BufferWriter <byte>())
using (var Writer = new BinaryTextWriter(Buffer))
{
Writer.Write(_TestInput);
Writer.Flush();
MyResult = Buffer.ToSequence().ToArray();
}
//****************************************
CollectionAssert.AreEqual(TempOutput, MyResult);
}
public void WriteUnicode([Values(false, true)] bool bigEndian)
{ //****************************************
byte[] MyResult;
byte[] TempOutput;
var MyEncoding = new UnicodeEncoding(bigEndian, true);
//****************************************
using (var RawStream = new MemoryStream())
{
using (var Writer = new StreamWriter(RawStream, MyEncoding))
{
Writer.Write(_TestInput);
}
TempOutput = RawStream.ToArray();
}
//****************************************
using (var Buffer = new BufferWriter <byte>())
using (var Writer = new BinaryTextWriter(Buffer, MyEncoding))
{
Writer.Write(_TestInput);
Writer.Flush();
MyResult = Buffer.ToSequence().ToArray();
}
//****************************************
CollectionAssert.AreEqual(TempOutput, MyResult);
}
public void StringTest()
{
var btw = new BinaryTextWriter();
btw.AddString("TEST");
btw.AddString("1.2.3");
var btr = new BinaryTextReader(btw.GetOutputString());
Assert.AreEqual("TEST", btr.ReadString(4));
Assert.AreEqual("1.2.3", btr.ReadString(5));
}
public void NumberTest()
{
var btw = new BinaryTextWriter();
btw.AddNumber(7, 4);
btw.AddNumber(1, 10);
var btr = new BinaryTextReader(btw.GetOutputString());
Assert.AreEqual(7, btr.ReadNumber(4));
Assert.AreEqual(1, btr.ReadNumber(10));
}
public void BoolTest()
{
var btw = new BinaryTextWriter();
btw.AddBool(true);
btw.AddBool(false);
var btr = new BinaryTextReader(btw.GetOutputString());
Assert.IsTrue(btr.ReadBool());
Assert.IsFalse(btr.ReadBool());
}
public byte[] ConvertToStringBytes()
{
BinaryTextWriter btw = new BinaryTextWriter();
// version
btw.AddNumber(version, 10);
// items
btw.AddBool(randomAbilities);
btw.AddBool(randomTanks);
// excluded items
for (int i = 0; i < 100; i++)
{
bool excluded = excludedItems.Contains(i);
btw.AddBool(excluded);
}
btw.AddNumber((int)gameCompletion, 2);
btw.AddBool(iceNotRequired);
btw.AddBool(plasmaNotRequired);
btw.AddBool(noPBsBeforeChozodia);
btw.AddBool(chozoStatueHints);
btw.AddBool(infiniteBombJump);
btw.AddBool(wallJumping);
// palettes
btw.AddBool(tilesetPalettes);
btw.AddBool(enemyPalettes);
btw.AddBool(beamPalettes);
btw.AddNumber(hueMinimum, 8);
btw.AddNumber(hueMaximum, 8);
// misc
btw.AddBool(enableItemToggle);
btw.AddBool(obtainUnkItems);
btw.AddBool(hardModeAvailable);
btw.AddBool(pauseScreenInfo);
btw.AddBool(removeCutscenes);
btw.AddBool(removeNorfairVine);
btw.AddBool(removeVariaAnimation);
btw.AddBool(skipSuitless);
return(btw.GetOutputString());
}
public void CanEncodingSurrogatePairsCorrectly()
{
var bytes = new List <byte>();
var writer = new BinaryTextWriter((buffer, state) =>
{
for (int i = buffer.Offset; i < buffer.Count; i++)
{
bytes.Add(buffer.Array[i]);
}
}, null, reuseBuffers: true, bufferSize: 128);
writer.Write("\U00024B62"[0]);
writer.Write("\U00024B62"[1]);
writer.Flush();
var expected = new byte[] { 0xF0, 0xA4, 0xAD, 0xA2 };
Assert.Equal(expected, bytes);
}
public void Write([Values(8, 16, 32, 64, 128)] int capacity)
{ //****************************************
byte[] MyResult;
//****************************************
using (var Buffer = new BufferWriter <byte>())
using (var Writer = new BinaryTextWriter(Buffer, Encoding.UTF8, capacity))
{
Writer.Write(_TestInput);
Writer.Flush();
MyResult = Buffer.ToSequence().ToArray();
}
//****************************************
CollectionAssert.AreEqual(_TestOutput, MyResult);
}
public void WriteUTF8()
{ //****************************************
byte[] MyResult;
//****************************************
using (var Buffer = new BufferWriter <byte>())
using (var Writer = new BinaryTextWriter(Buffer, Encoding.UTF8))
{
Writer.Write(_TestInput);
Writer.Flush();
MyResult = Buffer.ToSequence().ToArray();
}
//****************************************
CollectionAssert.AreEqual(_TestOutput, MyResult);
}
public void WriteSameBufferIsUsedForWritingChunksIfReuseBuffersTrue()
{
var buffers = new List <ArraySegment <byte> >();
var writer = new BinaryTextWriter((buffer, state) =>
{
buffers.Add(buffer);
},
null, reuseBuffers: true, bufferSize: 128);
writer.Write(new string('C', 10000));
writer.Flush();
Assert.True(buffers.Count > 1);
var underlyingBuffer = buffers[0].Array;
for (int i = 1; i < buffers.Count; i++)
{
Assert.Same(underlyingBuffer, buffers[i].Array);
}
}
public string GetString()
{
BinaryTextWriter btw = new BinaryTextWriter();
// version
string[] nums = Program.Version.Split('.');
btw.AddNumber(int.Parse(nums[0]), 4);
btw.AddNumber(int.Parse(nums[1]), 4);
btw.AddNumber(int.Parse(nums[2]), 4);
// items
btw.AddNumber((int)AbilitySwap, 2);
btw.AddNumber((int)TankSwap, 2);
if (NumItemsRemoved == 0)
{
btw.AddBool(false);
}
else
{
btw.AddBool(true);
btw.AddNumber(NumItemsRemoved, 7);
if (RemoveSpecificItems)
{
btw.AddBool(true);
btw.AddNumber(NumAbilitiesRemoved.Value, 4);
}
}
if (SwapOrRemoveItems)
{
btw.AddNumber((int)Completion, 2);
btw.AddBool(IceNotRequired);
btw.AddBool(PlasmaNotRequired);
btw.AddBool(NoPBsBeforeChozodia);
btw.AddBool(ChozoStatueHints);
btw.AddBool(InfiniteBombJump);
btw.AddBool(WallJumping);
}
// locations
if (CustomAssignments.Count == 0)
{
btw.AddBool(false);
}
else
{
btw.AddBool(true);
btw.AddNumber(CustomAssignments.Count, 7);
for (int i = 0; i < 100; i++)
{
if (CustomAssignments.TryGetValue(i, out ItemType item))
{
btw.AddNumber(i, 7);
btw.AddNumber((int)item, 5);
}
}
}
// enemies
btw.AddBool(RandoEnemies);
// palettes
btw.AddBool(TilesetPalettes);
btw.AddBool(EnemyPalettes);
btw.AddBool(SamusPalettes);
btw.AddBool(BeamPalettes);
if (RandomPalettes)
{
if (HueMinimum == 0)
{
btw.AddBool(false);
}
else
{
btw.AddBool(true);
btw.AddNumber(HueMinimum, 8);
}
if (HueMaximum == 180)
{
btw.AddBool(false);
}
else
{
btw.AddBool(true);
btw.AddNumber(HueMaximum, 8);
}
}
// misc
btw.AddBool(EnableItemToggle);
btw.AddBool(ObtainUnkItems);
btw.AddBool(HardModeAvailable);
btw.AddBool(PauseScreenInfo);
btw.AddBool(RemoveCutscenes);
btw.AddBool(SkipSuitless);
btw.AddBool(SkipDoorTransitions);
return(btw.GetOutputString());
}
