< Summary

Information
Class: ValidateLib.TabularData.Datatypes.HexBinaryDT
Assembly: validatelib.dll
File(s): C:\skola_karlovka\RP\code\csv-validator\CSV_Validator\ValidateLib\TabularData\Datatypes\HexBinaryDT.cs
Line coverage
55%
Covered lines: 20
Uncovered lines: 16
Coverable lines: 36
Total lines: 83
Line coverage: 55.5%
Branch coverage
N/A
Covered branches: 0
Total branches: 0
Branch coverage: N/A
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

File(s)

C:\skola_karlovka\RP\code\csv-validator\CSV_Validator\ValidateLib\TabularData\Datatypes\HexBinaryDT.cs

#LineLine coverage
 1using System.Text.RegularExpressions;
 2using ValidateLib.ErrorsAndWarnings.Errors;
 3using ValidateLib.Metadata.Descriptors;
 4
 5namespace ValidateLib.TabularData.Datatypes
 6{
 7    public class HexBinaryDT : BaseDT, ILength
 8    {
 19        public byte[]? Value { get; set; }
 110        public HexBinaryDT() { }
 111        public HexBinaryDT(string stringValue) : base(stringValue)
 12        {
 113            CheckLexicalSpace(stringValue);
 14            try
 15            {
 116                Value = getValueFromString(stringValue);
 117            }
 118            catch (Exception)
 19            {
 120                ErrorFactory.ThrowDatatypeValidationError(stringValue);
 021            }
 122        }
 23
 024        public HexBinaryDT(string stringValue, FormatDescriptor format) : base(stringValue, format)
 25        {
 026            CheckLexicalSpace(stringValue);
 027            MatchRegex(format.pattern!, stringValue);
 28            try
 29            {
 030                Value = getValueFromString(stringValue);
 031            }
 032            catch (Exception)
 33            {
 034                ErrorFactory.ThrowDatatypeValidationError(stringValue);
 035            }
 36
 037        }
 38
 39        void CheckLexicalSpace(string stringValue)
 40        {
 141            string pattern = @"([0-9a-fA-F]{2})*";
 142            if (!Regex.IsMatch(stringValue, pattern))
 043                ErrorFactory.ThrowDatatypeValidationError(stringValue);
 44
 145        }
 46
 47        byte[] getValueFromString(string stringValue)
 48        {
 149            if (stringValue.Length % 2 != 0)
 50            {
 151                throw new ArgumentException("Hex string must have an even number of characters.");
 52            }
 53
 154            byte[] byteArray = new byte[stringValue.Length / 2];
 55
 156            for (int i = 0; i < byteArray.Length; i++)
 57            {
 158                byteArray[i] = Convert.ToByte(stringValue.Substring(i * 2, 2), 16);
 59            }
 60
 161            return byteArray;
 62        }
 63
 64        public int Length()
 65        {
 166            if (Value == null) return 0;
 167            return Value!.Count();
 68        }
 69
 70        public override bool IsPatternValid(FormatDescriptor format)
 71        {
 72            try
 73            {
 074                Regex regex = new Regex(format.pattern!);
 075                return true;
 76            }
 077            catch (Exception)
 78            {
 079                return false;
 80            }
 081        }
 82    }
 83}