private void CreateBitmaps()
{
CharBitmaps.Clear();
var bb = new SolidBrush(Color.Black);
var pr = new Pen(Color.DarkCyan);
for (int charIndex = 0; charIndex < CodePage.CharacterCount; charIndex++)
{
var charBitmap = new Bitmap(CharacterWidth, CharacterHeight);
var g = Graphics.FromImage(charBitmap);
var charData = _charData.Skip(charIndex * BytesPerChar).Take(BytesPerChar).ToArray();
var pixels = BinaryTools.BytesToBits(charData);
var pixel = 0;
for (int y = 0; y < CharacterHeight; y++)
{
for (int x = 0; x < CharacterWidth; x++)
{
if (pixels[pixel])
{
g.FillRectangle(bb, x, y, 1, 1);
}
pixel++;
}
}
CharBitmaps.Add(charBitmap);
}
}
/// <summary>
/// Returns 4-byte value
/// </summary>
/// <param name="paramInfo"></param>
/// <returns></returns>
private static string _Extract4Bytes(ParameterInfo paramInfo)
{
string returnedValue = "";
byte[] value = paramInfo.value;
if (value != null)
{
if (value.Length == 8)
{
// Resource case > Only last 4 bytes are kept
value = new[]
{
value[4], value[5], value[6], value[7]
};
}
using (BinaryReader reader = new BinaryReader(new MemoryStream(value)))
{
uint readValue = BinaryTools.ToBigEndian(reader.ReadUInt32());
returnedValue = readValue.ToString();
}
}
return(returnedValue);
}
private static Sections RunSection(string hex)
{
using (var reader = BinaryTools.HexToReader(hex))
{
return(ModuleParser.ToSections(reader));
}
}
public void ToExternalKind(string hex, ExternalKind expect)
{
using (var reader = BinaryTools.HexToReader(hex))
{
var kind = TypeParser.ToExternalKind(reader);
Assert.That(kind, Is.EqualTo(expect));
}
}
/// <summary>
/// Builds challenge mode value to be written
/// </summary>
/// <param name="challengeMode"></param>
/// <returns></returns>
private static byte[] _BuildChallengeMode(GameMode challengeMode)
{
byte[] returnedValue = new byte[4];
uint val = BinaryTools.ToBigEndian((uint)challengeMode);
Array2.Write4Bytes(returnedValue, 0, val);
return(returnedValue);
}
public void ToInstructionParseInvalid()
{
using (var reader = BinaryTools.HexToReader("FF"))
{
// ReSharper disable once AccessToDisposedClosure
Assert.That(() => CodeParser.ToInstruction(reader), Throws.InstanceOf <NotImplementedException>());
}
}
public void ToLocals()
{
using (var reader = BinaryTools.HexToReader(TestValues.LocalHex))
{
Assert.That(SegmentsParser.ToLocals(reader, out var length), Is.EqualTo(TestValues.Local).AsCollection);
Assert.That(length, Is.EqualTo(TestValues.LocalHex.Length / 2));
}
}
public void TestIntMaxValueCustom()
{
//just make sure there is no error
int i = int.MaxValue;
char[] encodingtable = new char[] { '0', '1' };
BinaryTools.DecimalToAnyBaseExpanded(i, encodingtable);
}
/// <summary>
/// Builds driving aids value to be written
/// </summary>
/// <param name="drivingAid"></param>
/// <returns></returns>
private static byte[] _BuildDrivingAid(DrivingAid drivingAid)
{
byte[] returnedValue = new byte[4];
uint val = BinaryTools.ToBigEndian((uint)drivingAid);
Array2.Write4Bytes(returnedValue, 0, val);
return(returnedValue);
}
public void ToInt()
{
const string hex = "9BF159";
using (var reader = BinaryTools.HexToReader(hex))
{
Assert.That(Values.ToInt(reader), Is.EqualTo(-624485));
}
}
public void DecimalToBinary_FasterTest()
{
int value = 23;
int expected = 10111;
int actual;
actual = BinaryTools.DecimalToBinaryCustom(value);
Assert.AreEqual(expected, actual);
}
public void ToSByte()
{
const string hex = "0A";
using (var reader = BinaryTools.HexToReader(hex))
{
Assert.That(Values.ToSByte(reader), Is.EqualTo(10));
}
}
/// <summary>
/// Builds 4-byte value to be written
/// </summary>
/// <param name="val"></param>
/// <returns></returns>
private static byte[] _Build4Bytes(uint val)
{
byte[] returnedValue = new byte[4];
val = BinaryTools.ToBigEndian(val);
Array2.Write4Bytes(returnedValue, 0, val);
return(returnedValue);
}
public void ToBool()
{
const string hex = "01";
using (var reader = BinaryTools.HexToReader(hex))
{
Assert.That(Values.ToBool(reader), Is.True);
}
}
public void ToInitExpr()
{
const string hex = "412A0B";
using (var reader = BinaryTools.HexToReader(hex))
{
var initExpr = CodeParser.ToInitExpr(reader);
Assert.That(initExpr.Length, Is.EqualTo(2));
}
}
public void ToImportGlobal()
{
const string hex = "0161016203" + TestValues.GlobalTypeHex;
using (var reader = BinaryTools.HexToReader(hex))
{
var import = SegmentsParser.ToImport(reader);
Assert.That(import.Global, Is.EqualTo(TestValues.GlobalType));
}
}
public void ToFunctionTypeError()
{
const string hex = "40047F7E7D7C70017F";
using (var reader = BinaryTools.HexToReader(hex))
{
// ReSharper disable once AccessToDisposedClosure
Assert.That(() => TypeParser.ToFunctionType(reader), Throws.TypeOf <NotImplementedException>());
}
}
public void VerifyAccuracyOfCustomExpanded()
{
foreach (KeyValuePair <int, Dictionary <BaseType, string> > test in _testmatrix)
{
foreach (KeyValuePair <BaseType, string> value in test.Value)
{
Assert.AreEqual(value.Value, BinaryTools.DecimalToAnyBaseExpanded(test.Key, GetEncodingTable(value.Key)));
}
}
}
public void ToMemoryType()
{
const string hex = "0001";
using (var reader = BinaryTools.HexToReader(hex))
{
var memoryType = TypeParser.ToMemoryType(reader);
Assert.That(memoryType.Limits, Is.EqualTo(new Limits(1)));
}
}
public void ToImportWrongKind()
{
const string hex = "0161016204";
using (var reader = BinaryTools.HexToReader(hex))
{
// ReSharper disable once AccessToDisposedClosure
Assert.That(() => SegmentsParser.ToImport(reader), Throws.TypeOf <NotImplementedException>());
}
}
public void ToElemType()
{
const string hex = "70";
using (var reader = BinaryTools.HexToReader(hex))
{
var elemType = TypeParser.ToElemType(reader);
Assert.That(elemType, Is.EqualTo(ElemType.AnyFunc));
}
}
public void ToGlobalType()
{
const string hex = "7F00";
using (var reader = BinaryTools.HexToReader(hex))
{
var globalType = TypeParser.ToGlobalType(reader);
Assert.That(globalType.ValueType, Is.EqualTo(ValueType.I32));
Assert.That(globalType.Mutable, Is.False);
}
}
public void Parse(byte opCode)
{
IInstruction inst;
using (var reader = BinaryTools.BytesToReader(opCode))
{
inst = CodeParser.ToInstruction(reader);
}
Assert.That(inst.OpCode, Is.EqualTo((OpCode)opCode));
Assert.That(inst.HaveImmediate, Is.False);
}
private byte[] CreateCharData(List <Bitmap> characters, bool invertColour = false)
{
var charData = new List <byte>();
foreach (var cb in characters)
{
charData.AddRange(BinaryTools.BitmapTo1BppData(cb, invertColour));
}
return(charData.ToArray());
}
public void Start()
{
const string hex = "2A";
var sections = new Sections();
using (var reader = BinaryTools.HexToReader(hex))
{
sections.ParseStart(reader);
}
Assert.That(sections.Start, Is.EqualTo(42));
}
public void ToLimits()
{
const string hex = "010102";
using (var reader = BinaryTools.HexToReader(hex))
{
var limits = TypeParser.ToLimits(reader);
Assert.That(limits.Min, Is.EqualTo(1));
Assert.That(limits.Max, Is.EqualTo(2));
}
}
public void DecimalToAnyBaseCustomTests()
{
//just make sure there are no exceptions
for (int i = 0; i < 20; i++)
{
char[] encodingtable = new char[] { '0', '1' };
BinaryTools.DecimalToAnyBaseCustom(int.MaxValue, i);
var t = int.MinValue;
BinaryTools.DecimalToAnyBaseCustom(int.MinValue, i);
}
}
public void ToTableType()
{
const string hex = "700001";
using (var reader = BinaryTools.HexToReader(hex))
{
var tableType = TypeParser.ToTableType(reader);
Assert.That(tableType.ElemType, Is.EqualTo(ElemType.AnyFunc));
Assert.That(tableType.Limits, Is.EqualTo(new Limits(1)));
}
}
public void ZeroUnsigned()
{
const string hex = "00";
using (var reader = BinaryTools.HexToReader(hex))
{
var number = Values.UnsignedVar(reader, out var count);
Assert.That(number, Is.EqualTo(0));
Assert.That(count, Is.EqualTo(1));
}
}
public void WikipediaUnsigned()
{
const string hex = "E58E26";
using (var reader = BinaryTools.HexToReader(hex))
{
var number = Values.UnsignedVar(reader, out var count);
Assert.That(number, Is.EqualTo(624485));
Assert.That(count, Is.EqualTo(3));
}
}
