示例#1
0
        public RUSEMCModuleDevice(WordSerializator serializator) : base(serializator)
        {
            _serial   = 100;
            _status16 = 0;

            _calibrationFile      = deserialize(Properties.Resources.V01_RUS40_Cal, FileType.CALIBRATION);
            _factorySettingsFile  = deserialize(Properties.Resources.V01_RUS40_FSet, FileType.FACTORY_SETTINGS);
            _dataPacketFormatFile = generateDataPacketFormatFile();

            byte[] generateDataPacketFormatFile()
            {
                var body = new Enumerable <byte>()
                {
                    "EMC_Mdl_0101DDMMYYF_".GetASCIIBytes(),
                    serializator.Serialize(_serial),
                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Reserved
                };
                var i = new SmartInt().Add(1);

                addEntity("STAT", i, i.Add(2).DValue, 0);
                addEntity("STAT", i, i.Add(2).DValue, 0);
                addEntity("TST1", i, i.Add(2).DValue, 0);
                addEntity("TST2", i, i.Add(2).DValue, 0);

                return(body.ToArray());

                void addEntity(string mnemonicName, int position, int length, byte numOfBits)
                {
                    body.Add(mnemonicName.GetASCIIBytes());
                    body.Add(_serializator.Serialize((ushort)position));
                    body.Add((byte)length);
                    body.Add(numOfBits);
                }
            }
        }
示例#2
0
 public void Parse_SmartDouble()
 {
     for (int i = 0; i < N; i++)
     {
         sd_doubles[i] = SmartInt.Parse(s_doubles[i]);
     }
 }
示例#3
0
        /// <summary>
        /// Implicit conversion between SmartInt and System.Decimal.
        /// </summary>
        public static void AssignmentDecimal()
        {
            try
            {
                SmartInt       v1 = 7;
                System.Decimal v2 = 5;

                Console.Write(v1.ToString());  // Use v1.ToString() instead of single v1 to avoid implicit conversion to int
                Console.Write(", ");
                Console.WriteLine(v2);

                v2 = v1;                      // Implicit conversion

                Console.Write(v1.ToString()); // Use v1.ToString() instead of single v1 to avoid implicit conversion to int
                Console.Write(", ");
                Console.WriteLine(v2);

                v2 = 4;
                v1 = (SmartInt)v2;            // Only explicit conversion allowed

                Console.Write(v1.ToString()); // Use v1.ToString() instead of single v1 to avoid implicit conversion to int
                Console.Write(", ");
                Console.WriteLine(v2);
            }
            catch (Exception ex)
            {
                Console.Write("Exception:");
                Console.Write(ex.Message);
                Console.WriteLine();
            }
        }
示例#4
0
        /// <summary>
        /// Use SmartInt in for cycle and as indexer in place where System.Int32 is used.
        /// </summary>
        public static void IteratorIndexer()
        {
            try
            {
                String shello = "Hello !";
                Char[] chello = { 'H', 'e', 'l', 'l', 'o', ' ', '!' };

                for (SmartInt i = 0; i < shello.Length; i++)
                {
                    Console.Write(shello[i]);
                }

                Console.WriteLine();

                for (SmartInt i = 0; i < chello.Length; i++)
                {
                    Console.Write(chello[i]);
                }

                Console.WriteLine();
            }
            catch (Exception ex)
            {
                Console.Write("Exception:");
                Console.Write(ex.Message);
                Console.WriteLine();
            }
        }
示例#5
0
        /// <summary>
        /// Implicit conversion between SmartInt and System.Int16.
        /// </summary>
        public static void AssignmentSingle()
        {
            try
            {
                SmartInt     v1 = 7;
                System.Int16 v2 = 5;

                Console.Write(v1.ToString());  // Use v1.ToString() instead of single v1 to avoid implicit conversion to int
                Console.Write(", ");
                Console.WriteLine(v2);

                v2 = (System.Int16)v1;        // Explicit conversion

                Console.Write(v1.ToString()); // Use v1.ToString() instead of single v1 to avoid implicit conversion to int
                Console.Write(", ");
                Console.WriteLine(v2);

                v2 = 4;
                v1 = v2;                      // Implicit conversion

                Console.Write(v1.ToString()); // Use v1.ToString() instead of single v1 to avoid implicit conversion to int
                Console.Write(", ");
                Console.WriteLine(v2);
            }
            catch (Exception ex)
            {
                Console.Write("Exception:");
                Console.Write(ex.Message);
                Console.WriteLine();
            }
        }
示例#6
0
 public void ToString_SmartDouble()
 {
     for (int i = 0; i < N; i++)
     {
         d_strings[i] = SmartInt.ToStringValue(ints[i]);
     }
 }
示例#7
0
 public override bool Equals(object obj)
 {
     if (obj is SmartInt)
     {
         SmartInt other = (SmartInt)obj;
         return((int)this == (int)other);
     }
     return(base.Equals(obj));
 }
示例#8
0
    static void ParsePropertyValue <T>(T obj, FieldInfo fieldInfo, string valueStr)
    {
        System.Object value = valueStr;
        if (fieldInfo.FieldType.IsEnum)
        {
            value = Enum.Parse(fieldInfo.FieldType, valueStr);
        }
        else
        {
            if (fieldInfo.FieldType == typeof(int))
            {
                value = int.Parse(valueStr);
            }
            else if (fieldInfo.FieldType == typeof(byte))
            {
                value = byte.Parse(valueStr);
            }
            else if (fieldInfo.FieldType == typeof(SmartInt))
            {
                value = new SmartInt(int.Parse(valueStr));
            }
            else if (fieldInfo.FieldType == typeof(float))
            {
                value = float.Parse(valueStr);
            }
            else if (fieldInfo.FieldType == typeof(double))
            {
                value = double.Parse(valueStr);
            }
            else
            {
                if (valueStr.Contains("\"\""))
                {
                    valueStr = valueStr.Replace("\"\"", "\"");
                }

                // process the excel string.
                if (valueStr.Length > 2 && valueStr[0] == '\"' && valueStr[valueStr.Length - 1] == '\"')
                {
                    valueStr = valueStr.Substring(1, valueStr.Length - 2);
                }

                value = valueStr;
            }
        }

        if (value == null)
        {
            return;
        }

        fieldInfo.SetValue(obj, value);
    }
示例#9
0
        public InclinometrVirtualDevice(WordSerializator serializator) : base(serializator)
        {
            _serial = 999;

            _calibrationFile            = deserialize(Properties.Resources.V01_RUS03_Cal, FileType.CALIBRATION);
            _factorySettingsFile        = deserialize(Properties.Resources.V01_RUS03_FSet, FileType.FACTORY_SETTINGS);
            _dataPacketFormatFile       = generateDataPacketFormatFile();
            _flashDataPacketFormatFile  = _dataPacketFormatFile;
            _temperatureCalibrationFile = deserialize(Properties.Resources.V01_RUS03_TCal, FileType.TEMPERATURE_CALIBRATION);

            byte[] generateDataPacketFormatFile()
            {
                var body = new Enumerable <byte>()
                {
                    "INCL____0101DDMMYYF_".GetASCIIBytes(),
                    serializator.Serialize(_serial),
                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Reserve
                };
                var i = new SmartInt().Add(1);

                addEntity("STAT", (ushort)i, (byte)i.Add(2).DValue, 0, false);
                addEntity("INC_", (ushort)i, (byte)i.Add(2).DValue, 0, false);
                addEntity("AZI_", (ushort)i, (byte)i.Add(2).DValue, 0, false);
                addEntity("GTF_", (ushort)i, (byte)i.Add(2).DValue, 0, false);
                addEntity("XGpr", (ushort)i, (byte)i.Add(2).DValue, 0, false);
                addEntity("YGpr", (ushort)i, (byte)i.Add(2).DValue, 0, false);
                addEntity("ZGpr", (ushort)i, (byte)i.Add(2).DValue, 0, false);
                addEntity("XMpr", (ushort)i, (byte)i.Add(2).DValue, 0, false);
                addEntity("YMpr", (ushort)i, (byte)i.Add(2).DValue, 0, false);
                addEntity("ZMpr", (ushort)i, (byte)i.Add(2).DValue, 0, false);
                addEntity("TGad", (ushort)i, (byte)i.Add(2).DValue, 0, true);
                addEntity("TMad", (ushort)i, (byte)i.Add(2).DValue, 0, true);

                return(body.ToArray());

                void addEntity(string mnemonicName, ushort position, byte length, byte numOfBits, bool isSigned)
                {
                    body.Add(mnemonicName.GetASCIIBytes());
                    body.Add(_serializator.Serialize(position));
                    body.Add(length);
                    body.Add((isSigned ? (1 << 7) : 0).ToByte().BitOR(numOfBits));
                }
            }
        }
示例#10
0
        public RotationSensorVirtualDevice(WordSerializator serializator) : base(serializator)
        {
            _calibrationFile            = deserialize(Properties.Resources.V01_RUS07_Cal, FileType.CALIBRATION);
            _factorySettingsFile        = deserialize(Properties.Resources.V01_RUS07_FSet, FileType.FACTORY_SETTINGS);
            _dataPacketFormatFile       = generateDataPacketFormatFile();
            _flashDataPacketFormatFile  = generateDataPacketFormatFile();
            _temperatureCalibrationFile = deserialize(Properties.Resources.V01_RUS07_TCal, FileType.TEMPERATURE_CALIBRATION);

            byte[] generateDataPacketFormatFile()
            {
                var body = new Enumerable <byte>()
                {
                    "Bl_Gyro_0101DDMMYYF_".GetASCIIBytes(),
                    serializator.Serialize(_serial),
                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Reserve
                };
                var i = new SmartInt().Add(1);

                addEntity("STAT", (ushort)i, (byte)i.Add(2).DValue, 0, false);
                addEntity("SGY1", (ushort)i, (byte)i.Add(2).DValue, 0, true);
                addEntity("SRO1", (ushort)i, (byte)i.Add(2).DValue, 0, true);
                addEntity("ANG1", (ushort)i, (byte)i.Add(2).DValue, 0, false);
                addEntity("TEM1", (ushort)i, (byte)i.Add(2).DValue, 0, true);
                addEntity("SGY2", (ushort)i, (byte)i.Add(2).DValue, 0, true);
                addEntity("SRO2", (ushort)i, (byte)i.Add(2).DValue, 0, true);
                addEntity("ANG2", (ushort)i, (byte)i.Add(2).DValue, 0, false);
                addEntity("TEM2", (ushort)i, (byte)i.Add(2).DValue, 0, true);
                addEntity("ADSG", (ushort)i, (byte)i.Add(2).DValue, 0, false);
                addEntity("ADH1", (ushort)i, (byte)i.Add(2).DValue, 0, false);
                addEntity("ADH2", (ushort)i, (byte)i.Add(2).DValue, 0, false);
                addEntity("ADTM", (ushort)i, (byte)i.Add(2).DValue, 0, true);

                return(body.ToArray());

                void addEntity(string mnemonicName, ushort position, byte length, byte numOfBits, bool isSigned)
                {
                    body.Add(mnemonicName.GetASCIIBytes());
                    body.Add(_serializator.Serialize(position));
                    body.Add(length);
                    body.Add((isSigned ? 1 : 0).ToByte().BitLShift(7).BitOR(numOfBits));
                }
            }
        }
示例#11
0
        public void SmartInt_Parse_BruteForce_Test()
        {
            int    test_count = 10000000;
            Random rnd        = new Random();

            for (int i = 0; i < test_count; i++)
            {
                int v = rnd.Next();

                string s  = v.ToString();
                string sp = "+" + s;
                string sn = "-" + s;

                SmartInt siv  = SmartInt.Parse(s);
                SmartInt sipv = SmartInt.Parse(sp);
                SmartInt sinv = SmartInt.Parse(sn);

                Assert.IsTrue((siv == v) && (sipv == v) && (sinv == -v), "Parsing " + v.ToString());
            }
        }
示例#12
0
        /// <summary>
        /// Parse and error control of SmartInt and System.Int32.
        /// SmartInt takes SmartInt.BadValue value.
        /// System.Int32.Parse throws exception.
        /// </summary>
        public static void Parse1Error()
        {
            try
            {
                SmartInt i = SmartInt.Parse("abc");
                Console.Write("SmartInt:");
                Console.Write(i.ToString());  // Use i.ToString() instead of single i to avoid implicit conversion to int
                Console.Write("  IsBad:");
                Console.WriteLine(i.isBad());

                System.Int32 i2 = System.Int32.Parse("abc");
                Console.Write("System.Int32:");
                Console.WriteLine(i2);
            }
            catch (Exception ex)
            {
                Console.Write("Exception:");
                Console.Write(ex.Message);
                Console.WriteLine();
            }
        }
示例#13
0
        /// <summary>
        /// Compare sizes of arrays of int, int?s and SmartInt
        /// </summary>
        public static void ArraySize()
        {
            int objects_count = 1000;

            long memory1 = GC.GetTotalMemory(true);

            int[] ai      = new int[objects_count];
            long  memory2 = GC.GetTotalMemory(true);

            int?[] ani     = new int?[objects_count];
            long   memory3 = GC.GetTotalMemory(true);

            SmartInt[] asi     = new SmartInt[objects_count];
            long       memory4 = GC.GetTotalMemory(true);

            // Compiler can optimize and do not allocate arrays if they are not used
            // So we write their lengths
            Console.WriteLine("Array sizes {0}, {1}, {2}", ai.Length, ani.Length, asi.Length);
            Console.WriteLine("Memory for int \t {0}", memory2 - memory1);
            Console.WriteLine("Memory for int? \t {0}", memory3 - memory2);
            Console.WriteLine("Memory for SmartInt \t {0}", memory4 - memory3);
        }
示例#14
0
        public void SmartInt_ToString_BruteForce_Test()
        {
            int    test_count = 10000000;
            Random rnd        = new Random();

            for (int i = 0; i < test_count; i++)
            {
                int v  = rnd.Next();
                int vn = -v;

                string s  = v.ToString();
                string sn = vn.ToString();

                SmartInt siv  = v;
                SmartInt sivn = vn;

                string sis  = siv.ToString();
                string sisn = sivn.ToString();

                Assert.IsTrue((sis == s) && (sisn == sn), "ToString " + v.ToString());
            }
        }
示例#15
0
        public static RequestInfo GetRequestDescription(RUSDeviceId deviceId, Command request)
        {
            var info = (deviceId, request);

            if (info.request.IsOneOf(Command.KEEP_MTF, Command.ROTATE_WITH_CONSTANT_SPEED, Command.DRILL_DIRECTLY, Command.TURN_ON_AZIMUTH))
            {
                var i = new SmartInt();
                return(new RequestInfo(deviceId, request, new EntityDescriptor[]
                {
                    new EntityDescriptor("Inc", i, i.Add(2).DValue, DataEntityFormat.INT16),
                    new EntityDescriptor("Azi", i, i.Add(2).DValue, DataEntityFormat.INT16),
                    new EntityDescriptor("MTF", i, i.Add(2).DValue, DataEntityFormat.INT16),
                }));
            }
            else if (info == (RUSDeviceId.LWD_LINK, Command.PBP_SETTINGS))
            {
                return(new RequestInfo(deviceId, request, new EntityDescriptor[]
                {
                    new EntityDescriptor("Количество секторов", 0, 1, DataEntityFormat.UINT8),
                    new EntityDescriptor("Время молчания", 1, 1, DataEntityFormat.UINT8)
                }));
            }
示例#16
0
        public RUSTechnologicalModuleDevice(WordSerializator serializator) : base(serializator)
        {
            _serial   = 100;
            _status32 = Global.Random.NextUInt();

            _calibrationFile            = deserialize(Properties.Resources.V01_RUS24_Cal, FileType.CALIBRATION);
            _factorySettingsFile        = deserialize(Properties.Resources.V01_RUS24_FSet, FileType.FACTORY_SETTINGS);
            _dataPacketFormatFile       = generateDataPacketFormatFile();
            _flashDataPacketFormatFile  = generateDataPacketFormatFile();
            _temperatureCalibrationFile = deserialize(Properties.Resources.V01_RUS24_TCal, FileType.TEMPERATURE_CALIBRATION);
            _workModeFile = deserialize(Properties.Resources.V01_RUS24_WMode, FileType.WORK_MODE);

            byte[] generateDataPacketFormatFile()
            {
                var body = new Enumerable <byte>()
                {
                    "TEXMODUL0101DDMMYYF_".GetASCIIBytes(),
                    serializator.Serialize(_serial),
                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Reserved
                };
                var i = new SmartInt().Add(1);

                addEntity("STAT", i, i.Add(2).DValue, 0);
                addEntity("STAT", i, i.Add(2).DValue, 0);
                addEntity("TST1", i, i.Add(2).DValue, 0);
                addEntity("TST2", i, i.Add(2).DValue, 0);

                return(body.ToArray());

                void addEntity(string mnemonicName, int position, int length, byte numOfBits)
                {
                    body.Add(mnemonicName.GetASCIIBytes());
                    body.Add(_serializator.Serialize((ushort)position));
                    body.Add((byte)length);
                    body.Add(numOfBits);
                }
            }
        }
示例#17
0
        static Files()
        {
            var         pos     = new SmartInt();
            var         dpedPos = new SmartInt();
            RUSDeviceId id      = 0;
            string      name    = null;

            var descriptors = new Dictionary <FileDescriptorsTarget, FileStructure>();

            BaseFileTemplate = new FBED[]
            {
                new FBED("Краткое название прибора", pos, pos.Add(8).DValue, DataEntityFormat.ASCII_STRING, FileEntityType.ANOTHER),
                new FBED("Модификация", pos, pos.Add(2), DataEntityFormat.ASCII_STRING, FileEntityType.MODIFICATION),
                new FBED("Версия ПО или пакета данных", pos, pos.Add(2).DValue, DataEntityFormat.ASCII_STRING, FileEntityType.FORMAT_VERSION),
                new FBED("Дата составления файла", pos, pos.Add(2).DValue, DataEntityFormat.ASCII_STRING, FileEntityType.BURN_DAY),
                new FBED("Месяц составления файла", pos, pos.Add(2).DValue, DataEntityFormat.ASCII_STRING, FileEntityType.BURN_MONTH),
                new FBED("Год составления файла", pos, pos.Add(2).DValue, DataEntityFormat.ASCII_STRING, FileEntityType.BURN_YEAR),
                new FBED("Указатель типа файла", pos, pos.Add(2).DValue, DataEntityFormat.ASCII_STRING, FileEntityType.FILE_TYPE_POINTER),
                new FBED("Серийный номер прибора", pos, pos.Add(2).DValue, DataEntityFormat.UINT16, FileEntityType.SERIAL_NUMBER),
            };

            #region Telemetry 0b00000001

            name      = "________";
            id        = RUSDeviceId.TELEMETRY;
            pos.Value = 0;

            registerStandard(FileType.FACTORY_SETTINGS);
            registerStandard(FileType.CALIBRATION);
            registerStandard(FileType.DATA_PACKET_CONFIGURATION);
            registerStandard(FileType.FLASH_DATA_PACKET_CONFIGURATION);

            #endregion

            #region RUSModule 0b00000010

            name      = "________";
            id        = RUSDeviceId.RUS_MODULE;
            pos.Value = 0;

            registerStandard(FileType.FACTORY_SETTINGS);
            registerStandard(FileType.CALIBRATION);
            registerStandard(FileType.DATA_PACKET_CONFIGURATION);
            registerStandard(FileType.FLASH_DATA_PACKET_CONFIGURATION);

            #endregion

            #region DriveControll 0b00000110

            name      = "________";
            id        = RUSDeviceId.DRIVE_CONTROL;
            pos.Value = 0;

            registerStandard(FileType.FACTORY_SETTINGS);
            registerStandard(FileType.CALIBRATION);
            registerStandard(FileType.DATA_PACKET_CONFIGURATION);
            registerStandard(FileType.FLASH_DATA_PACKET_CONFIGURATION);

            #endregion

            #region Telesystem 0b00001000

            name      = "________";
            id        = RUSDeviceId.TELESYSTEM;
            pos.Value = 0;

            registerStandard(FileType.FACTORY_SETTINGS);
            registerStandard(FileType.CALIBRATION);
            registerStandard(FileType.DATA_PACKET_CONFIGURATION);
            registerStandard(FileType.FLASH_DATA_PACKET_CONFIGURATION);

            #endregion

            #region RUSEMCModule 0b01010000

            name      = "EMC_Mdl_";
            id        = RUSDeviceId.EMC_MODULE;
            pos.Value = 0;

            registerStandard(FileType.FACTORY_SETTINGS);
            registerStandard(FileType.CALIBRATION);
            registerStandard(FileType.DATA_PACKET_CONFIGURATION);
            registerStandard(FileType.FLASH_DATA_PACKET_CONFIGURATION);

            #endregion

            #region TechnologicalModule 0b00001000

            name      = "TexModul";
            id        = RUSDeviceId.RUS_TECHNOLOGICAL_MODULE;
            pos.Value = 0;

            {
                pos.Value = 0;
                var v01Target = new FileDescriptorsTarget(FileType.FACTORY_SETTINGS, "01", id);
                var v01       = new Enumerable <FED>
                {
                    createHeader(name, FileType.FACTORY_SETTINGS.GetInfo().FileTypePointerName),
                    new FED("Резерв", pos, pos.Add(14).DValue, DataEntityFormat.BYTE_ARRAY, new byte[pos.DValue]),
                    new FED("Массив UInt8[36]", pos, pos.Add(36).DValue, DataEntityFormat.BYTE_ARRAY, new byte[pos.DValue]),
                }.ToArray();

                descriptors.Add(v01Target, new FileStructure(v01));
            }
            registerStandard(FileType.DATA_PACKET_CONFIGURATION);
            registerStandard(FileType.FLASH_DATA_PACKET_CONFIGURATION);

            {
                pos.Value = 0;
                var v01CalibrationTarget
                    = new FileDescriptorsTarget(FileType.CALIBRATION, "01", id);
                var v01Calibration = new Enumerable <FED>
                {
                    createHeader(name, FileType.CALIBRATION.GetInfo().FileTypePointerName),
                    new FED("Резерв", pos, pos.Add(14).DValue, DataEntityFormat.BYTE_ARRAY, new byte[pos.DValue]),
                    new FED("Калибровки", pos, pos.Add(36).DValue, DataEntityFormat.BYTE_ARRAY, new byte[pos.DValue]),
                }.ToArray();

                descriptors.Add(v01CalibrationTarget, new FileStructure(v01Calibration));
            }

            {
                pos.Value = 0;
                var v01TemperatureCalibrationTarget
                    = new FileDescriptorsTarget(FileType.TEMPERATURE_CALIBRATION, "01", id);
                var v01TemperatureCalibration = new Enumerable <FED>
                {
                    createHeader(name, FileType.TEMPERATURE_CALIBRATION.GetInfo().FileTypePointerName),
                    new FED("Резерв", pos, pos.Add(14).DValue, DataEntityFormat.BYTE_ARRAY, new byte[pos.DValue]),
                    new FED("Калибровки", pos, pos.Add(36).DValue, DataEntityFormat.BYTE_ARRAY, new byte[pos.DValue]),
                }.ToArray();

                descriptors.Add(v01TemperatureCalibrationTarget, new FileStructure(v01TemperatureCalibration));
            }

            pos.Value = 0;
            var v01CalibrationFileForTechnologicalModuleTarget
                = new FileDescriptorsTarget(FileType.WORK_MODE, "01", id);
            var v01CalibrationFileForTechnologicalModule = new Enumerable <FED>
            {
                createHeader(name, FileType.WORK_MODE.GetInfo().FileTypePointerName),
                new FED("Резерв", pos, pos.Add(14).DValue, DataEntityFormat.BYTE_ARRAY, new byte[14]),
                new FED("Режим работы", pos, pos.Add(36).DValue, DataEntityFormat.BYTE_ARRAY, new byte[pos.DValue])
            }.ToArray();

            descriptors.Add(v01CalibrationFileForTechnologicalModuleTarget, new FileStructure(v01CalibrationFileForTechnologicalModule));

            #endregion

            #region RUSLWDLink 0b00001001

            name      = "SNAPUNIT";
            id        = RUSDeviceId.LWD_LINK;
            pos.Value = 0;

            registerStandard(FileType.FACTORY_SETTINGS);
            registerStandard(FileType.CALIBRATION);
            registerStandard(FileType.DATA_PACKET_CONFIGURATION);
            registerStandard(FileType.FLASH_DATA_PACKET_CONFIGURATION);

            #endregion

            #region ShockSensor 0b00000101

            name = "SHOCK___";
            id   = RUSDeviceId.SHOCK_SENSOR;

            registerStandard(FileType.FACTORY_SETTINGS);

            pos.Value = 0;
            var v01DataPacketConfigurationFileForShockSensorTarget
                = new FileDescriptorsTarget(FileType.DATA_PACKET_CONFIGURATION, "01", id);
            var v01DataPacketConfigurationFileForShockSensor = new Enumerable <FED>
            {
                createHeader(name, "F_"),
                new FED("Резерв", pos, pos.Add(14).DValue, DataEntityFormat.BYTE_ARRAY, new byte[14]),
                new FED("Массив описаний пакета данных", pos, EntityLength.TILL_THE_END_OF_A_PACKET, DataEntityFormat.DATA_PACKET_ENTITIES_ARRAY,
                        new DataPacketEntityDescriptor[]
                {
                    new DataPacketEntityDescriptor("SH5O", 2, 1, false),
                    new DataPacketEntityDescriptor("SH1O", 2, 3, false),
                    new DataPacketEntityDescriptor("SH2O", 2, 5, false),
                    new DataPacketEntityDescriptor("SH3O", 2, 7, false),
                    new DataPacketEntityDescriptor("SH5R", 2, 9, false),
                    new DataPacketEntityDescriptor("SH1R", 2, 11, false),
                    new DataPacketEntityDescriptor("SH2R", 2, 13, false),
                    new DataPacketEntityDescriptor("SH3R", 2, 15, false),
                    new DataPacketEntityDescriptor("ARAD", 2, 17, false),
                    new DataPacketEntityDescriptor("AOSV", 2, 19, false),
                }),
            }.ToArray();
            registerStandard(FileType.FLASH_DATA_PACKET_CONFIGURATION);

            pos.Value = 0;
            var v01CalibrationFileForShockSensorTarget
                = new FileDescriptorsTarget(FileType.CALIBRATION, "01", id);
            var v01CalibrationFileForShockSensor = new Enumerable <FED>
            {
                createHeader(name, "K_"),
                new FED("Резерв", pos, pos.Add(14).DValue, DataEntityFormat.BYTE_ARRAY, new byte[14]),
                new FED("Калибровки", pos, EntityLength.TILL_THE_END_OF_A_PACKET, DataEntityFormat.CALIBRATION_PACKET_ENTITIES_ARRAY,
                        new CalibrationFileEntity[]
                {
                    CalibrationFileEntity.CreateConstantsTable("G0_", DataTypes.UINT16, new ushort[] { 517, 517, 517 }),
                    CalibrationFileEntity.CreateConstantsTable("POR_", DataTypes.UINT16, new ushort[] { 41, 82, 164, 246 }),
                    CalibrationFileEntity.CreateConstantsTable("TMR", DataTypes.UINT16, new ushort[] { 2 }),
                }),
            }.ToArray();


            descriptors.Add(v01CalibrationFileForShockSensorTarget, new FileStructure(v01CalibrationFileForShockSensor));
            descriptors.Add(v01DataPacketConfigurationFileForShockSensorTarget, new FileStructure(v01DataPacketConfigurationFileForShockSensor));

            #endregion

            #region RotationSensor 0b00000111

            name          = "Bl_Gyro_";
            id            = RUSDeviceId.ROTATIONS_SENSOR;
            pos.Value     = 0;
            dpedPos.Value = 1;

            registerStandard(FileType.FACTORY_SETTINGS);

            pos.Value = 0;
            var v01DataPacketConfigurationFileForRotationSensorTarget
                = new FileDescriptorsTarget(FileType.DATA_PACKET_CONFIGURATION, "01", id);
            var v01DataPacketConfigurationFileForRotationSensor = new Enumerable <FED>
            {
                createHeader(name, "F_"),
                new FED("Резерв", pos, pos.Add(14).DValue, DataEntityFormat.BYTE_ARRAY, new byte[14]),
                new FED("Массив описаний пакета данных", pos, EntityLength.TILL_THE_END_OF_A_PACKET, DataEntityFormat.DATA_PACKET_ENTITIES_ARRAY,
                        new DataPacketEntityDescriptor[]
                {
                    new DataPacketEntityDescriptor("STAT", dpedPos.Add(2).DValue, dpedPos.PreviousValue, false),
                    new DataPacketEntityDescriptor("SGY1", dpedPos.Add(2).DValue, dpedPos.PreviousValue, true),
                    new DataPacketEntityDescriptor("SRO1", dpedPos.Add(2).DValue, dpedPos.PreviousValue, true),
                    new DataPacketEntityDescriptor("ANG1", dpedPos.Add(2).DValue, dpedPos.PreviousValue, false),
                    new DataPacketEntityDescriptor("TEM1", dpedPos.Add(2).DValue, dpedPos.PreviousValue, true),
                    new DataPacketEntityDescriptor("SGY2", dpedPos.Add(2).DValue, dpedPos.PreviousValue, true),
                    new DataPacketEntityDescriptor("SRO2", dpedPos.Add(2).DValue, dpedPos.PreviousValue, true),
                    new DataPacketEntityDescriptor("ANG2", dpedPos.Add(2).DValue, dpedPos.PreviousValue, false),
                    new DataPacketEntityDescriptor("TEM2", dpedPos.Add(2).DValue, dpedPos.PreviousValue, true),
                    new DataPacketEntityDescriptor("ADSG", dpedPos.Add(2).DValue, dpedPos.PreviousValue, false),
                    new DataPacketEntityDescriptor("ADH1", dpedPos.Add(2).DValue, dpedPos.PreviousValue, false),
                    new DataPacketEntityDescriptor("ADH2", dpedPos.Add(2).DValue, dpedPos.PreviousValue, false),
                    new DataPacketEntityDescriptor("ADTM", dpedPos.Add(2).DValue, dpedPos.PreviousValue, true),
                }),
            }.ToArray();

            registerStandard(FileType.FLASH_DATA_PACKET_CONFIGURATION);

            registerStandardCalibrationFile(CalibrationFileEntity.CreateConstantsTable("dTe", DataTypes.INT16, new short[] { 0 }));

            pos.Value = 0;
            var v01TemperatureCalibrationFileForRotationSensorTarget
                = new FileDescriptorsTarget(FileType.TEMPERATURE_CALIBRATION, "01", id);
            var v01TemperatureCalibrationFileForRotationSensor = new Enumerable <FED>
            {
                createHeader(name, "T_"),
                new FED("Резерв", pos, pos.Add(14).DValue, DataEntityFormat.BYTE_ARRAY, new byte[14]),
                new FED("Калибровки", pos, EntityLength.TILL_THE_END_OF_A_PACKET, DataEntityFormat.CALIBRATION_PACKET_ENTITIES_ARRAY,
                        new CalibrationFileEntity[]
                {
                    CalibrationFileEntity.CreateArray("AH1", DataTypes.UINT16, Enumerable.Repeat((ushort)32498, 156).ToArray()),
                    CalibrationFileEntity.CreateArray("AH2", DataTypes.UINT16, Enumerable.Repeat((ushort)32715, 156).ToArray()),
                    CalibrationFileEntity.CreateArray("ASG", DataTypes.UINT16, Enumerable.Repeat((ushort)32809, 156).ToArray()),
                    CalibrationFileEntity.CreateArray("Kgy", DataTypes.FLOAT, Enumerable.Repeat((float)0.12947888, 156).ToArray())
                }),
            }.ToArray();

            descriptors.Add(v01DataPacketConfigurationFileForRotationSensorTarget, new FileStructure(v01DataPacketConfigurationFileForRotationSensor));
            descriptors.Add(v01TemperatureCalibrationFileForRotationSensorTarget, new FileStructure(v01TemperatureCalibrationFileForRotationSensor));

            #endregion

            #region Izmeritel 0b00000100

            name      = "Izmeritl";
            id        = RUSDeviceId.IZMERITEL;
            pos.Value = 0;

            registerStandard(FileType.FACTORY_SETTINGS);

            pos.Value = 0;
            var v01DataPacketConfigurationFileForIzmeritelTarget
                = new FileDescriptorsTarget(FileType.DATA_PACKET_CONFIGURATION, "01", id);
            var v01DataPacketConfigurationFileForIzmeritel = new Enumerable <FED>
            {
                createHeader(name, "F_"),
                new FED("Резерв", pos, pos.Add(14).DValue, DataEntityFormat.BYTE_ARRAY, new byte[14]),
                new FED("Массив описаний пакета данных", pos, EntityLength.TILL_THE_END_OF_A_PACKET, DataEntityFormat.DATA_PACKET_ENTITIES_ARRAY,
                        new DataPacketEntityDescriptor[]
                {
                    new DataPacketEntityDescriptor("TimP", 2, 0x07, false),
                    new DataPacketEntityDescriptor("DD1_", 2, 0x09, false),
                    new DataPacketEntityDescriptor("DD2_", 2, 0x0B, false),
                    new DataPacketEntityDescriptor("TDD1", 2, 0x0D, false),
                    new DataPacketEntityDescriptor("TDD2", 2, 0x0F, false),
                    new DataPacketEntityDescriptor("TACD", 2, 0x11, false),
                    new DataPacketEntityDescriptor("+INC", 2, 0x13, false),
                    new DataPacketEntityDescriptor("-INC", 2, 0x14, false),
                    new DataPacketEntityDescriptor("GK__", 2, 0x15, false),
                    new DataPacketEntityDescriptor("TIME", 2, 0x17, false),
                    new DataPacketEntityDescriptor("URTC", 2, 0x19, false),
                    new DataPacketEntityDescriptor("REZ_", 2, 0x1B, false),
                    new DataPacketEntityDescriptor("SerN", 2, 0x23, false),
                }),
            }.ToArray();

            registerStandard(FileType.FLASH_DATA_PACKET_CONFIGURATION);

            registerStandard(FileType.CALIBRATION);

            descriptors.Add(v01DataPacketConfigurationFileForIzmeritelTarget, new FileStructure(v01DataPacketConfigurationFileForIzmeritel));

            #endregion

            #region Inclinometr 0b00000011

            name          = "INCL____";
            id            = RUSDeviceId.INCLINOMETR;
            pos.Value     = 0;
            dpedPos.Value = 1;

            registerStandard(FileType.FACTORY_SETTINGS);

            pos.Value = 0;
            var v01DataPacketConfigurationFileForInclinometrTarget
                = new FileDescriptorsTarget(FileType.DATA_PACKET_CONFIGURATION, "01", id);
            var v01DataPacketConfigurationFileForInclinometr = new Enumerable <FED>
            {
                createHeader("INCL____", "F_"),
                new FED("Резерв", pos, pos.Add(14).DValue, DataEntityFormat.BYTE_ARRAY, new byte[14]),
                new FED("Массив описаний пакета данных", pos, EntityLength.TILL_THE_END_OF_A_PACKET, DataEntityFormat.DATA_PACKET_ENTITIES_ARRAY,
                        new DataPacketEntityDescriptor[]
                {
                    new DataPacketEntityDescriptor("STAT", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x10),
                    new DataPacketEntityDescriptor("INC_", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x10),
                    new DataPacketEntityDescriptor("GTF_", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x10),
                    new DataPacketEntityDescriptor("MTF_", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x10),
                    new DataPacketEntityDescriptor("AZI_", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x10),
                    new DataPacketEntityDescriptor("DIP_", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x8F),
                    new DataPacketEntityDescriptor("GTOT", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x10),
                    new DataPacketEntityDescriptor("BTOT", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x10),
                    new DataPacketEntityDescriptor("GCNT", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x10),
                    new DataPacketEntityDescriptor("Taks", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x10),
                    new DataPacketEntityDescriptor("Tmag", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x10),
                    new DataPacketEntityDescriptor("XGrp", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x8F),
                    new DataPacketEntityDescriptor("YGrp", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x8F),
                    new DataPacketEntityDescriptor("ZGrp", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x8F),
                    new DataPacketEntityDescriptor("XMrp", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x8F),
                    new DataPacketEntityDescriptor("YMrp", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x8F),
                    new DataPacketEntityDescriptor("ZMrp", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x8F),
                    new DataPacketEntityDescriptor("XGad", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x8F),
                    new DataPacketEntityDescriptor("YGad", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x8F),
                    new DataPacketEntityDescriptor("ZGad", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x8F),
                    new DataPacketEntityDescriptor("XMad", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x8F),
                    new DataPacketEntityDescriptor("YMad", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x8F),
                    new DataPacketEntityDescriptor("ZMad", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x8F),
                    new DataPacketEntityDescriptor("TGad", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x10),
                    new DataPacketEntityDescriptor("Tmad", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x10),
                    new DataPacketEntityDescriptor("UHV_", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x10),
                    new DataPacketEntityDescriptor("UHAL", dpedPos.Add(2).DValue, dpedPos.PreviousValue, 0x10),
                    new DataPacketEntityDescriptor("RSRV", dpedPos.Add(2).DValue, 59, 0x10),
                }),
            }.ToArray();

            registerStandard(FileType.FLASH_DATA_PACKET_CONFIGURATION);

            registerStandard(FileType.CALIBRATION);

            pos.Value = 0;
            var v01TemperatureCalibrationFileForInclinometrTarget
                = new FileDescriptorsTarget(FileType.TEMPERATURE_CALIBRATION, "01", id);
            var v01TemperatureCalibrationFileForInclinometr = new Enumerable <FED>
            {
                createHeader(name, "T_"),
                new FED("Резерв", pos, pos.Add(14).DValue, DataEntityFormat.BYTE_ARRAY, new byte[14]),
                new FED("Калибровки", pos, EntityLength.TILL_THE_END_OF_A_PACKET, DataEntityFormat.CALIBRATION_PACKET_ENTITIES_ARRAY, new CalibrationFileEntity[]
                {
                    CalibrationFileEntity.CreateLinearInterpolationTable("G1x", DataTypes.FLOAT, 140.Range().Select(_ => (0F, 1F)).ToArray()),
                    CalibrationFileEntity.CreateLinearInterpolationTable("G1y", DataTypes.FLOAT, 140.Range().Select(_ => (0F, 1F)).ToArray()),
                    CalibrationFileEntity.CreateLinearInterpolationTable("G1z", DataTypes.FLOAT, 140.Range().Select(_ => (0F, 1F)).ToArray()),
                    CalibrationFileEntity.CreateLinearInterpolationTable("M1x", DataTypes.FLOAT, 140.Range().Select(_ => (0F, 1F)).ToArray()),
                    CalibrationFileEntity.CreateLinearInterpolationTable("M1y", DataTypes.FLOAT, 140.Range().Select(_ => (0F, 1F)).ToArray()),
                    CalibrationFileEntity.CreateLinearInterpolationTable("M1z", DataTypes.FLOAT, 140.Range().Select(_ => (0F, 1F)).ToArray()),
                }),
示例#18
0
        public void SmartInt_Parse_String_Test()
        {
            #region General

            Assert.AreEqual(1, (int)SmartInt.Parse("1"), "Parsing \"1\"");
            Assert.AreEqual(73, (int)SmartInt.Parse("73"), "Parsing \"73\"");
            Assert.AreEqual(9462, (int)SmartInt.Parse("9462"), "Parsing \"9462\"");
            Assert.AreEqual(123456789, (int)SmartInt.Parse("123456789"), "Parsing \"123456789\"");

            Assert.AreEqual(-1, (int)SmartInt.Parse("-1"), "Parsing \"-1\"");
            Assert.AreEqual(-73, (int)SmartInt.Parse("-73"), "Parsing \"-73\"");
            Assert.AreEqual(-9462, (int)SmartInt.Parse("-9462"), "Parsing \"-9462\"");
            Assert.AreEqual(-123456789, (int)SmartInt.Parse("-123456789"), "Parsing \"-123456789\"");

            #endregion

            #region Leading zeros

            // Positive Sihned Leading zeros
            Assert.AreEqual(0, (int)SmartInt.Parse("0"), "Parsing \"0\"");
            Assert.AreEqual(1, (int)SmartInt.Parse("01"), "Parsing \"01\"");
            Assert.AreEqual(1, (int)SmartInt.Parse("001"), "Parsing \"001\"");
            Assert.AreEqual(1, (int)SmartInt.Parse("0001"), "Parsing \"0001\"");
            Assert.AreEqual(1, (int)SmartInt.Parse("00001"), "Parsing \"00001\"");
            Assert.AreEqual(1, (int)SmartInt.Parse("000001"), "Parsing \"000001\"");
            Assert.AreEqual(1, (int)SmartInt.Parse("0000001"), "Parsing \"0000001\"");

            Assert.AreEqual(123, (int)SmartInt.Parse("0123"), "Parsing \"0123\"");
            Assert.AreEqual(123, (int)SmartInt.Parse("00123"), "Parsing \"00123\"");
            Assert.AreEqual(123, (int)SmartInt.Parse("000123"), "Parsing \"000123\"");
            Assert.AreEqual(123, (int)SmartInt.Parse("0000123"), "Parsing \"0000123\"");
            Assert.AreEqual(123, (int)SmartInt.Parse("00000123"), "Parsing \"00000123\"");
            Assert.AreEqual(123, (int)SmartInt.Parse("000000123"), "Parsing \"000000123\"");

            // Negative Leading zeros
            Assert.AreEqual(0, (int)SmartInt.Parse("-0"), "Parsing \"-0\"");
            Assert.AreEqual(-1, (int)SmartInt.Parse("-01"), "Parsing \"-01\"");
            Assert.AreEqual(-1, (int)SmartInt.Parse("-001"), "Parsing \"-001\"");
            Assert.AreEqual(-1, (int)SmartInt.Parse("-0001"), "Parsing \"-0001\"");
            Assert.AreEqual(-1, (int)SmartInt.Parse("-00001"), "Parsing \"-00001\"");
            Assert.AreEqual(-1, (int)SmartInt.Parse("-000001"), "Parsing \"-000001\"");
            Assert.AreEqual(-1, (int)SmartInt.Parse("-0000001"), "Parsing \"-0000001\"");

            Assert.AreEqual(-123, (int)SmartInt.Parse("-0123"), "Parsing \"-0123\"");
            Assert.AreEqual(-123, (int)SmartInt.Parse("-00123"), "Parsing \"-00123\"");
            Assert.AreEqual(-123, (int)SmartInt.Parse("-000123"), "Parsing \"-000123\"");
            Assert.AreEqual(-123, (int)SmartInt.Parse("-0000123"), "Parsing \"-0000123\"");
            Assert.AreEqual(-123, (int)SmartInt.Parse("-00000123"), "Parsing \"-00000123\"");
            Assert.AreEqual(-123, (int)SmartInt.Parse("-000000123"), "Parsing \"-000000123\"");

            // Positively Sihned Leading zeros
            Assert.AreEqual(0, (int)SmartInt.Parse("+0"), "Parsing \"+0\"");
            Assert.AreEqual(1, (int)SmartInt.Parse("+01"), "Parsing \"+01\"");
            Assert.AreEqual(1, (int)SmartInt.Parse("+001"), "Parsing \"+001\"");
            Assert.AreEqual(1, (int)SmartInt.Parse("+0001"), "Parsing \"+0001\"");
            Assert.AreEqual(1, (int)SmartInt.Parse("+00001"), "Parsing \"+00001\"");
            Assert.AreEqual(1, (int)SmartInt.Parse("+000001"), "Parsing \"+000001\"");
            Assert.AreEqual(1, (int)SmartInt.Parse("+0000001"), "Parsing \"+0000001\"");

            Assert.AreEqual(123, (int)SmartInt.Parse("+0123"), "Parsing \"+0123\"");
            Assert.AreEqual(123, (int)SmartInt.Parse("+00123"), "Parsing \"+00123\"");
            Assert.AreEqual(123, (int)SmartInt.Parse("+000123"), "Parsing \"+000123\"");
            Assert.AreEqual(123, (int)SmartInt.Parse("+0000123"), "Parsing \"+0000123\"");
            Assert.AreEqual(123, (int)SmartInt.Parse("+00000123"), "Parsing \"+00000123\"");
            Assert.AreEqual(123, (int)SmartInt.Parse("+000000123"), "Parsing \"+000000123\"");

            #endregion

            #region With Spaces

            Assert.AreEqual(0, (int)SmartInt.Parse(" 0 "), "Parsing \" 0 \"");
            Assert.AreEqual(1, (int)SmartInt.Parse(" 01 "), "Parsing \" 01 \"");
            Assert.AreEqual(123, (int)SmartInt.Parse(" 0123 "), "Parsing \" 0123 \"");

            Assert.AreEqual(0, (int)SmartInt.Parse(" -0 "), "Parsing \" -0 \"");
            Assert.AreEqual(-1, (int)SmartInt.Parse(" -01 "), "Parsing \" -01 \"");
            Assert.AreEqual(-123, (int)SmartInt.Parse(" -0123 "), "Parsing \" -0123 \"");

            Assert.AreEqual(0, (int)SmartInt.Parse(" +0 "), "Parsing \" +0 \"");
            Assert.AreEqual(1, (int)SmartInt.Parse(" +01 "), "Parsing \" +01 \"");
            Assert.AreEqual(123, (int)SmartInt.Parse(" +0123 "), "Parsing \" +0123 \"");

            Assert.AreEqual(0, (int)SmartInt.Parse("   0     "), "Parsing \"   0     \"");
            Assert.AreEqual(1, (int)SmartInt.Parse("   01    "), "Parsing \"   01    \"");
            Assert.AreEqual(123, (int)SmartInt.Parse("   0123  "), "Parsing \"   0123  \"");

            Assert.AreEqual(0, (int)SmartInt.Parse("   -0     "), "Parsing \"   -0     \"");
            Assert.AreEqual(-1, (int)SmartInt.Parse("   -01    "), "Parsing \"   -01    \"");
            Assert.AreEqual(-123, (int)SmartInt.Parse("   -0123  "), "Parsing \"   -0123  \"");

            Assert.AreEqual(0, (int)SmartInt.Parse("   +0     "), "Parsing \"   +0     \"");
            Assert.AreEqual(1, (int)SmartInt.Parse("   +01    "), "Parsing \"   +01    \"");
            Assert.AreEqual(123, (int)SmartInt.Parse("   +0123  "), "Parsing \"   +0123  \"");

            // Leading Spaces
            Assert.AreEqual(0, (int)SmartInt.Parse(" 0"), "Parsing \" 0\"");
            Assert.AreEqual(1, (int)SmartInt.Parse(" 01"), "Parsing \" 01\"");
            Assert.AreEqual(123, (int)SmartInt.Parse(" 0123"), "Parsing \" 0123\"");

            Assert.AreEqual(0, (int)SmartInt.Parse(" -0"), "Parsing \" -0\"");
            Assert.AreEqual(-1, (int)SmartInt.Parse(" -01"), "Parsing \" -01\"");
            Assert.AreEqual(-123, (int)SmartInt.Parse(" -0123"), "Parsing \" -0123\"");

            Assert.AreEqual(0, (int)SmartInt.Parse(" +0"), "Parsing \" +0\"");
            Assert.AreEqual(1, (int)SmartInt.Parse(" +01"), "Parsing \" +01\"");
            Assert.AreEqual(123, (int)SmartInt.Parse(" +0123"), "Parsing \" +0123\"");

            Assert.AreEqual(0, (int)SmartInt.Parse("   0"), "Parsing \"   0\"");
            Assert.AreEqual(1, (int)SmartInt.Parse("   01"), "Parsing \"   01\"");
            Assert.AreEqual(123, (int)SmartInt.Parse("   0123"), "Parsing \"   0123\"");

            Assert.AreEqual(0, (int)SmartInt.Parse("   -0"), "Parsing \"   -0\"");
            Assert.AreEqual(-1, (int)SmartInt.Parse("   -01"), "Parsing \"   -01\"");
            Assert.AreEqual(-123, (int)SmartInt.Parse("   -0123"), "Parsing \"   -0123\"");

            Assert.AreEqual(0, (int)SmartInt.Parse("   +0"), "Parsing \"   +0\"");
            Assert.AreEqual(1, (int)SmartInt.Parse("   +01"), "Parsing \"   +01\"");
            Assert.AreEqual(123, (int)SmartInt.Parse("   +0123"), "Parsing \"   +0123\"");

            // Finaling Spaces
            Assert.AreEqual(0, (int)SmartInt.Parse("0 "), "Parsing \"0 \"");
            Assert.AreEqual(1, (int)SmartInt.Parse("01 "), "Parsing \"01 \"");
            Assert.AreEqual(123, (int)SmartInt.Parse("0123 "), "Parsing \"0123 \"");

            Assert.AreEqual(0, (int)SmartInt.Parse("-0 "), "Parsing \"-0 \"");
            Assert.AreEqual(-1, (int)SmartInt.Parse("-01 "), "Parsing \"-01 \"");
            Assert.AreEqual(-123, (int)SmartInt.Parse("-0123 "), "Parsing \"-0123 \"");

            Assert.AreEqual(0, (int)SmartInt.Parse("+0 "), "Parsing \"+0 \"");
            Assert.AreEqual(1, (int)SmartInt.Parse("+01 "), "Parsing \"+01 \"");
            Assert.AreEqual(123, (int)SmartInt.Parse("+0123 "), "Parsing \"+0123 \"");

            Assert.AreEqual(0, (int)SmartInt.Parse("0     "), "Parsing \"0     \"");
            Assert.AreEqual(1, (int)SmartInt.Parse("01    "), "Parsing \"01    \"");
            Assert.AreEqual(123, (int)SmartInt.Parse("0123  "), "Parsing \"0123  \"");

            Assert.AreEqual(0, (int)SmartInt.Parse("-0     "), "Parsing \"-0     \"");
            Assert.AreEqual(-1, (int)SmartInt.Parse("-01    "), "Parsing \"-01    \"");
            Assert.AreEqual(-123, (int)SmartInt.Parse("-0123  "), "Parsing \"-0123  \"");

            Assert.AreEqual(0, (int)SmartInt.Parse("+0     "), "Parsing \"+0     \"");
            Assert.AreEqual(1, (int)SmartInt.Parse("+01    "), "Parsing \"+01    \"");
            Assert.AreEqual(123, (int)SmartInt.Parse("+0123  "), "Parsing \"+0123  \"");

            #endregion

            #region Values that shall be parsed to SmartDouble.BadValue without throwing

            Assert.AreEqual(true, SmartInt.Parse("").isBad(), "Parsing \"\"");
            Assert.AreEqual(true, SmartInt.Parse(" ").isBad(), "Parsing \" \"");
            Assert.AreEqual(true, SmartInt.Parse("           ").isBad(), "Parsing \"           \"");
            Assert.AreEqual(true, SmartInt.Parse("           -").isBad(), "Parsing \"           -\"");
            Assert.AreEqual(true, SmartInt.Parse("           +").isBad(), "Parsing \"           +\"");
            Assert.AreEqual(true, SmartInt.Parse("-           ").isBad(), "Parsing \"-           \"");
            Assert.AreEqual(true, SmartInt.Parse("-           ").isBad(), "Parsing \"+           \"");
            Assert.AreEqual(true, SmartInt.Parse("      -     ").isBad(), "Parsing \"      -     \"");
            Assert.AreEqual(true, SmartInt.Parse("      +     ").isBad(), "Parsing \"      +     \"");
            Assert.AreEqual(true, SmartInt.Parse("-").isBad(), "Parsing \"-\"");
            Assert.AreEqual(true, SmartInt.Parse("+").isBad(), "Parsing \"+\"");

            string null_str = null;
            Assert.AreEqual(true, SmartInt.Parse(null_str).isBad(), "Parsing null");
            Assert.AreEqual(true, SmartInt.Parse("abrakadabra").isBad(), "Parsing \"abrakadabra\"");

            Assert.AreEqual(true, SmartInt.Parse("1.0").isBad(), "Parsing \"1.0\"");
            Assert.AreEqual(true, SmartInt.Parse("1 m.").isBad(), "Parsing \"1 m.\"");
            Assert.AreEqual(true, SmartInt.Parse("x1").isBad(), "Parsing \"x1\"");

            #endregion

            #region Extremal values that shall be parsed to SmartDouble.BadValue without throwing

            // 8 bills
            Assert.AreEqual(true, SmartInt.Parse("8123123123").isBad(), "Parsing \"8123123123\"");

            // Digits
            {
                int           strlen = 16 * 1024;
                StringBuilder sb     = new StringBuilder(strlen);

                for (int i = 0; i < strlen; i++)
                {
                    sb.Append((i % 10).ToString());
                }

                Assert.AreEqual(true, SmartInt.Parse(sb.ToString()).isBad(), "Parsing \"Extremal, Digits\"");
            }

            // Letters
            {
                int           strlen = 16 * 1024;
                StringBuilder sb     = new StringBuilder(strlen);

                for (int i = 0; i < strlen; i++)
                {
                    sb.Append("A" + (i % 10));
                }

                Assert.AreEqual(true, SmartInt.Parse(sb.ToString()).isBad(), "Parsing \"Extremal, Letters\"");
            }

            #endregion
        }