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)); } }