A Swiss Army knife for developers.
C# blazorcross-platformcsharpdesktopdesktop-appdesktop-applicationdeveloper-toolsextensiblefluentfluent-designlinuxmacosmicasyntax-highlightingtypescriptwindowswindows-10windows-11winui
Ported Number Base Converter to DevToys 2.0 (#1069)
Etienne Baudoux6e0a2924e3fa
diff --git a/src/app/dev/DevToys.Tools/DevToys.Tools.csproj b/src/app/dev/DevToys.Tools/DevToys.Tools.csprojindex 3cf85b308..ddd76bb3c 100644--- a/src/app/dev/DevToys.Tools/DevToys.Tools.csproj+++ b/src/app/dev/DevToys.Tools/DevToys.Tools.csproj@@ -43,6 +43,11 @@<AutoGen>True</AutoGen><DependentUpon>GlobalStrings.resx</DependentUpon></Compile>+ <Compile Update="Tools\Converters\NumberBase\NumberBaseConverter.Designer.cs">+ <DesignTime>True</DesignTime>+ <AutoGen>True</AutoGen>+ <DependentUpon>NumberBaseConverter.resx</DependentUpon>+ </Compile><Compile Update="Tools\Converters\Cron\CronParser.Designer.cs"><DesignTime>True</DesignTime><AutoGen>True</AutoGen>@@ -236,6 +241,10 @@<LastGenOutput>JsonTableConverter.Designer.cs</LastGenOutput><Generator>ResXFileCodeGenerator</Generator></EmbeddedResource>+ <EmbeddedResource Update="Tools\Converters\NumberBase\NumberBaseConverter.resx">+ <Generator>ResXFileCodeGenerator</Generator>+ <LastGenOutput>NumberBaseConverter.Designer.cs</LastGenOutput>+ </EmbeddedResource><EmbeddedResource Update="Tools\EncodersDecoders\Certificate\CertificateDecoder.resx"><Generator>ResXFileCodeGenerator</Generator><LastGenOutput>CertificateDecoder.Designer.cs</LastGenOutput>diff --git a/src/app/dev/DevToys.Tools/Helpers/NumberBaseHelper.cs b/src/app/dev/DevToys.Tools/Helpers/NumberBaseHelper.csnew file mode 100644index 000000000..dc8d4ebb1--- /dev/null+++ b/src/app/dev/DevToys.Tools/Helpers/NumberBaseHelper.cs@@ -0,0 +1,174 @@+using System.Globalization;+using System.Text;+using DevToys.Tools.Models.NumberBase;+using DevToys.Tools.Tools.Converters.NumberBase;+using Decimal = DevToys.Tools.Models.NumberBase.Decimal;++namespace DevToys.Tools.Helpers;++internal static class NumberBaseHelper+{+ internal static bool TryDetectNumberBase(string? potentialNumber, out INumberBaseDefinition<long>? numberBaseDefinition)+ {+ numberBaseDefinition = null;++ if (string.IsNullOrWhiteSpace(potentialNumber)+ || potentialNumber.Length > 100) // unlikely to be a number.+ {+ return false;+ }++ // Remove the potential formatting on the input number.+ string unformattedPotentialNumber = UnformatNumber(potentialNumber);++ // Try to detect the base of the input number.+ try+ {+ long parsedNumber = Decimal.Instance.Parse(unformattedPotentialNumber);+ numberBaseDefinition = Decimal.Instance;+ return true;+ }+ catch { }++ try+ {+ long parsedNumber = Binary.Instance.Parse(unformattedPotentialNumber);+ numberBaseDefinition = Binary.Instance;+ return true;+ }+ catch { }++ try+ {+ long parsedNumber = Hexadecimal.Instance.Parse(unformattedPotentialNumber);+ numberBaseDefinition = Hexadecimal.Instance;+ return true;+ }+ catch { }++ try+ {+ long parsedNumber = Octal.Instance.Parse(unformattedPotentialNumber);+ numberBaseDefinition = Octal.Instance;+ return true;+ }+ catch { }++ return false;+ }++ internal static bool TryConvertNumberBase(+ string? inputNumber,+ INumberBaseDefinition<long> numberBase,+ bool format,+ out string hexadecimal,+ out string @decimal,+ out string octal,+ out string binary,+ out string error)+ {+ Guard.IsNotNull(numberBase);++ hexadecimal = string.Empty;+ @decimal = string.Empty;+ octal = string.Empty;+ binary = string.Empty;+ error = string.Empty;++ if (string.IsNullOrWhiteSpace(inputNumber))+ {+ return true;+ }++ if (!TryParseNumber(inputNumber, numberBase, out long signedValue, out error))+ {+ return false;+ }++ // Convert the number to the other bases and format them if needed.+ hexadecimal = Hexadecimal.Instance.ToFormattedString(signedValue, format);+ @decimal = Decimal.Instance.ToFormattedString(signedValue, format);+ octal = Octal.Instance.ToFormattedString(signedValue, format);+ binary = Binary.Instance.ToFormattedString(signedValue, format);+ return true;+ }++ internal static bool TryConvertNumberBase<T>(+ string? inputNumber,+ INumberBaseDefinition<T> inputNumberBase,+ INumberBaseDefinition<T> outputNumberBase,+ bool format,+ out string result,+ out string error)+ where T : struct+ {+ Guard.IsNotNull(inputNumberBase);+ Guard.IsNotNull(outputNumberBase);++ result = string.Empty;+ error = string.Empty;++ if (string.IsNullOrWhiteSpace(inputNumber))+ {+ return true;+ }++ if (!TryParseNumber(inputNumber, inputNumberBase, out T unsignedValue, out error))+ {+ return false;+ }++ // Convert the number to the other bases and format them if needed.+ result = outputNumberBase.ToFormattedString(unsignedValue, format);+ return true;+ }++ private static bool TryParseNumber<T, U>(string? inputNumber, T numberBase, out U value, out string error)+ where T : INumberBaseDefinition<U>+ where U : struct+ {+ value = default;+ error = string.Empty;++ // Remove the potential formatting on the input number.+ string unformattedInputNumber = UnformatNumber(inputNumber);++ try+ {+ // Try to parse the number.+ value = numberBase.Parse(unformattedInputNumber);+ return true;+ }+ catch (OverflowException)+ {+ error = string.Format(NumberBaseConverter.ValueOverflow, numberBase.DisplayName, numberBase.MaxValue);+ return false;+ }+ catch (Exception)+ {+ error = string.Format(NumberBaseConverter.ValueInvalid, numberBase.DisplayName);+ return false;+ }+ }++ private static string UnformatNumber(string? formattedNumber)+ {+ if (string.IsNullOrWhiteSpace(formattedNumber!))+ {+ return string.Empty;+ }++ var unformattedNumber = new StringBuilder();++ string currentCulture = CultureInfo.CurrentCulture.NumberFormat.NumberGroupSeparator;+ for (int i = 0; i < formattedNumber.Length; i++)+ {+ if (!char.IsWhiteSpace(formattedNumber[i]) && formattedNumber[i] != Convert.ToChar(currentCulture))+ {+ unformattedNumber.Append(formattedNumber[i]);+ }+ }++ return unformattedNumber.ToString();+ }+}diff --git a/src/app/dev/DevToys.Tools/Models/NumberBase/Binary.cs b/src/app/dev/DevToys.Tools/Models/NumberBase/Binary.csnew file mode 100644index 000000000..a65d6f618--- /dev/null+++ b/src/app/dev/DevToys.Tools/Models/NumberBase/Binary.cs@@ -0,0 +1,54 @@+using System.Text;+using DevToys.Tools.Tools.Converters.NumberBase;++namespace DevToys.Tools.Models.NumberBase;++internal sealed class Binary : SignedLongNumberBaseDefinition+{+ internal static readonly Binary Instance = new();++ private Binary() : base(NumberBaseConverter.Binary, baseNumber: 2)+ {+ }++ protected override string Format(string number)+ {+ var formattedNumber = new StringBuilder();+ int count = 0;++ for (int i = number.Length - 1; i >= 0; i--)+ {+ if (count > 0 && count % 4 == 0)+ {+ formattedNumber.Insert(0, ' ');+ }++ formattedNumber.Insert(0, number[i]);+ count++;+ }++ // Ensure the first block is always 4 characters+ while (count % 4 != 0)+ {+ formattedNumber.Insert(0, '0');+ count++;+ }++ return formattedNumber.ToString();+ }++ protected override string AdjustNotFormatted(string number)+ {+ var formattedNumber = new StringBuilder(number);+ int count = formattedNumber.Length;++ // Ensure the first block is always 4 characters+ while (count % 4 != 0)+ {+ formattedNumber.Insert(0, '0');+ count++;+ }++ return formattedNumber.ToString();+ }+}diff --git a/src/app/dev/DevToys.Tools/Models/NumberBase/CustomUnsigned.cs b/src/app/dev/DevToys.Tools/Models/NumberBase/CustomUnsigned.csnew file mode 100644index 000000000..dcee0905e--- /dev/null+++ b/src/app/dev/DevToys.Tools/Models/NumberBase/CustomUnsigned.cs@@ -0,0 +1,14 @@+using DevToys.Tools.Tools.Converters.NumberBase;++namespace DevToys.Tools.Models.NumberBase;++internal sealed class CustomUnsigned : UnsignedLongNumberBaseDefinition+{+ internal CustomUnsigned(string dictionary)+ : base(+ NumberBaseConverter.CustomFormat,+ dictionary,+ isDictionaryCaseSensitive: true)+ {+ }+}diff --git a/src/app/dev/DevToys.Tools/Models/NumberBase/Decimal.cs b/src/app/dev/DevToys.Tools/Models/NumberBase/Decimal.csnew file mode 100644index 000000000..80a7f18e7--- /dev/null+++ b/src/app/dev/DevToys.Tools/Models/NumberBase/Decimal.cs@@ -0,0 +1,24 @@+using System.Globalization;+using DevToys.Tools.Tools.Converters.NumberBase;++namespace DevToys.Tools.Models.NumberBase;++internal sealed class Decimal : SignedLongNumberBaseDefinition+{+ internal static readonly Decimal Instance = new();++ private Decimal() : base(NumberBaseConverter.Decimal, baseNumber: 10)+ {+ }++ protected override string Format(string number)+ {+ if (decimal.TryParse(number, NumberStyles.Any, CultureInfo.InvariantCulture, out decimal parsedNumber))+ {+ // Convert to string using current culture.+ return parsedNumber.ToString("N0", CultureInfo.CurrentCulture);+ }++ return number;+ }+}diff --git a/src/app/dev/DevToys.Tools/Models/NumberBase/Hexadecimal.cs b/src/app/dev/DevToys.Tools/Models/NumberBase/Hexadecimal.csnew file mode 100644index 000000000..987de6d04--- /dev/null+++ b/src/app/dev/DevToys.Tools/Models/NumberBase/Hexadecimal.cs@@ -0,0 +1,37 @@+using System.Text;+using DevToys.Tools.Tools.Converters.NumberBase;++namespace DevToys.Tools.Models.NumberBase;++internal sealed class Hexadecimal : SignedLongNumberBaseDefinition+{+ internal static readonly Hexadecimal Instance = new();++ private Hexadecimal() : base(NumberBaseConverter.Hexadecimal, baseNumber: 16)+ {+ }++ protected override string Format(string number)+ {+ var formattedNumber = new StringBuilder();+ int count = 0;++ for (int i = number.Length - 1; i >= 0; i--)+ {+ if (count > 0 && count % 4 == 0)+ {+ formattedNumber.Insert(0, ' ');+ }++ formattedNumber.Insert(0, char.ToUpper(number[i]));+ count++;+ }++ return formattedNumber.ToString();+ }++ override protected string AdjustNotFormatted(string number)+ {+ return number.ToUpper();+ }+}diff --git a/src/app/dev/DevToys.Tools/Models/NumberBase/INumberBaseDefinition.cs b/src/app/dev/DevToys.Tools/Models/NumberBase/INumberBaseDefinition.csnew file mode 100644index 000000000..b02808f98--- /dev/null+++ b/src/app/dev/DevToys.Tools/Models/NumberBase/INumberBaseDefinition.cs@@ -0,0 +1,25 @@+namespace DevToys.Tools.Models.NumberBase;++internal interface INumberBaseDefinition<T> where T : struct+{+ /// <summary>+ /// Gets the display name of the number base.+ /// </summary>+ string DisplayName { get; }++ /// <summary>+ /// Gets the maximum value of the number base. This value ensure that the number doesn't overflow and+ /// is used to display to the user when the number is too large.+ /// </summary>+ T MaxValue { get; }++ /// <summary>+ /// Parses a string to a number. Raises an exception if the number is invalid or overflow.+ /// </summary>+ T Parse(string number);++ /// <summary>+ /// Converts a number to a string. If the format is true, the number is formatted.+ /// </summary>+ string ToFormattedString(T number, bool format);+}diff --git a/src/app/dev/DevToys.Tools/Models/NumberBase/Octal.cs b/src/app/dev/DevToys.Tools/Models/NumberBase/Octal.csnew file mode 100644index 000000000..588f8829b--- /dev/null+++ b/src/app/dev/DevToys.Tools/Models/NumberBase/Octal.cs@@ -0,0 +1,32 @@+using System.Text;+using DevToys.Tools.Tools.Converters.NumberBase;++namespace DevToys.Tools.Models.NumberBase;++internal sealed class Octal : SignedLongNumberBaseDefinition+{+ internal static readonly Octal Instance = new();++ private Octal() : base(NumberBaseConverter.Octal, baseNumber: 8)+ {+ }++ protected override string Format(string number)+ {+ var formattedNumber = new StringBuilder();+ int count = 0;++ for (int i = number.Length - 1; i >= 0; i--)+ {+ if (count > 0 && count % 3 == 0)+ {+ formattedNumber.Insert(0, ' ');+ }++ formattedNumber.Insert(0, number[i]);+ count++;+ }++ return formattedNumber.ToString();+ }+}diff --git a/src/app/dev/DevToys.Tools/Models/NumberBase/RFC4648Base16.cs b/src/app/dev/DevToys.Tools/Models/NumberBase/RFC4648Base16.csnew file mode 100644index 000000000..75e70151b--- /dev/null+++ b/src/app/dev/DevToys.Tools/Models/NumberBase/RFC4648Base16.cs@@ -0,0 +1,16 @@+using DevToys.Tools.Tools.Converters.NumberBase;++namespace DevToys.Tools.Models.NumberBase;++internal sealed class RFC4648Base16 : UnsignedLongNumberBaseDefinition+{+ internal static readonly RFC4648Base16 Instance = new();++ private RFC4648Base16()+ : base(+ displayName: NumberBaseConverter.RFC4648Base16,+ dictionary: "0123456789ABCDEF",+ isDictionaryCaseSensitive: false)+ {+ }+}diff --git a/src/app/dev/DevToys.Tools/Models/NumberBase/RFC4648Base32.cs b/src/app/dev/DevToys.Tools/Models/NumberBase/RFC4648Base32.csnew file mode 100644index 000000000..454ed4d48--- /dev/null+++ b/src/app/dev/DevToys.Tools/Models/NumberBase/RFC4648Base32.cs@@ -0,0 +1,16 @@+using DevToys.Tools.Tools.Converters.NumberBase;++namespace DevToys.Tools.Models.NumberBase;++internal sealed class RFC4648Base32 : UnsignedLongNumberBaseDefinition+{+ internal static readonly RFC4648Base32 Instance = new();++ private RFC4648Base32()+ : base(+ displayName: NumberBaseConverter.RFC4648Base32,+ dictionary: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",+ isDictionaryCaseSensitive: true)+ {+ }+}diff --git a/src/app/dev/DevToys.Tools/Models/NumberBase/RFC4648Base32ExtendedHex.cs b/src/app/dev/DevToys.Tools/Models/NumberBase/RFC4648Base32ExtendedHex.csnew file mode 100644index 000000000..a3da0bcfd--- /dev/null+++ b/src/app/dev/DevToys.Tools/Models/NumberBase/RFC4648Base32ExtendedHex.cs@@ -0,0 +1,16 @@+using DevToys.Tools.Tools.Converters.NumberBase;++namespace DevToys.Tools.Models.NumberBase;++internal sealed class RFC4648Base32ExtendedHex : UnsignedLongNumberBaseDefinition+{+ internal static readonly RFC4648Base32ExtendedHex Instance = new();++ private RFC4648Base32ExtendedHex()+ : base(+ displayName: NumberBaseConverter.RFC4648Base32ExtendedHex,+ dictionary: "0123456789ABCDEFGHIJKLMNOPQRSTUV",+ isDictionaryCaseSensitive: true)+ {+ }+}diff --git a/src/app/dev/DevToys.Tools/Models/NumberBase/RFC4648Base64.cs b/src/app/dev/DevToys.Tools/Models/NumberBase/RFC4648Base64.csnew file mode 100644index 000000000..d0a3d1a7a--- /dev/null+++ b/src/app/dev/DevToys.Tools/Models/NumberBase/RFC4648Base64.cs@@ -0,0 +1,16 @@+using DevToys.Tools.Tools.Converters.NumberBase;++namespace DevToys.Tools.Models.NumberBase;++internal sealed class RFC4648Base64 : UnsignedLongNumberBaseDefinition+{+ internal static readonly RFC4648Base64 Instance = new();++ private RFC4648Base64()+ : base(+ displayName: NumberBaseConverter.RFC4648Base64,+ dictionary: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",+ isDictionaryCaseSensitive: true)+ {+ }+}diff --git a/src/app/dev/DevToys.Tools/Models/NumberBase/RFC4648Base64UrlEncode.cs b/src/app/dev/DevToys.Tools/Models/NumberBase/RFC4648Base64UrlEncode.csnew file mode 100644index 000000000..ac872afab--- /dev/null+++ b/src/app/dev/DevToys.Tools/Models/NumberBase/RFC4648Base64UrlEncode.cs@@ -0,0 +1,16 @@+using DevToys.Tools.Tools.Converters.NumberBase;++namespace DevToys.Tools.Models.NumberBase;++internal sealed class RFC4648Base64UrlEncode : UnsignedLongNumberBaseDefinition+{+ internal static readonly RFC4648Base64UrlEncode Instance = new();++ private RFC4648Base64UrlEncode()+ : base(+ displayName: NumberBaseConverter.RFC4648Base64UrlEncode,+ dictionary: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_",+ isDictionaryCaseSensitive: true)+ {+ }+}diff --git a/src/app/dev/DevToys.Tools/Models/NumberBase/SignedLongNumberBaseDefinition.cs b/src/app/dev/DevToys.Tools/Models/NumberBase/SignedLongNumberBaseDefinition.csnew file mode 100644index 000000000..5b3770f37--- /dev/null+++ b/src/app/dev/DevToys.Tools/Models/NumberBase/SignedLongNumberBaseDefinition.cs@@ -0,0 +1,46 @@+namespace DevToys.Tools.Models.NumberBase;++internal abstract class SignedLongNumberBaseDefinition : INumberBaseDefinition<long>+{+ private readonly int _base;++ protected SignedLongNumberBaseDefinition(string displayName, int baseNumber)+ {+ Guard.IsNotNullOrWhiteSpace(displayName);+ Guard.IsGreaterThan(baseNumber, 0);+ DisplayName = displayName;+ _base = baseNumber;+ }++ public string DisplayName { get; }++ public long MaxValue => long.MaxValue / _base;++ public string ToFormattedString(long number, bool format)+ {+ string stringNumber = Convert.ToString(number, toBase: _base);++ if (format)+ {+ stringNumber = Format(stringNumber);+ }+ else+ {+ stringNumber = AdjustNotFormatted(stringNumber);+ }++ return stringNumber;+ }++ public long Parse(string number)+ {+ return Convert.ToInt64(number, fromBase: _base);+ }++ protected abstract string Format(string number);++ protected virtual string AdjustNotFormatted(string number)+ {+ return number;+ }+}diff --git a/src/app/dev/DevToys.Tools/Models/NumberBase/UnsignedLongNumberBaseDefinition.cs b/src/app/dev/DevToys.Tools/Models/NumberBase/UnsignedLongNumberBaseDefinition.csnew file mode 100644index 000000000..9122630e3--- /dev/null+++ b/src/app/dev/DevToys.Tools/Models/NumberBase/UnsignedLongNumberBaseDefinition.cs@@ -0,0 +1,138 @@+using System.Text;++namespace DevToys.Tools.Models.NumberBase;++internal abstract class UnsignedLongNumberBaseDefinition : INumberBaseDefinition<ulong>+{+ private readonly string _dictionary;+ private readonly ulong _base;+ private readonly bool _isDictionaryCaseSensitive;++ protected UnsignedLongNumberBaseDefinition(+ string displayName,+ string dictionary,+ bool isDictionaryCaseSensitive)+ {+ Guard.IsNotNullOrEmpty(dictionary);+ Guard.HasSizeGreaterThanOrEqualTo(dictionary, 2);+ Guard.IsNotNullOrWhiteSpace(displayName);+ _dictionary = dictionary!;+ _base = (ulong)dictionary.Length;+ _isDictionaryCaseSensitive = isDictionaryCaseSensitive;+ DisplayName = displayName;+ }++ public string DisplayName { get; }++ public ulong MaxValue => ulong.MaxValue / _base;++ public string ToFormattedString(ulong number, bool format)+ {+ // If the number is zero, return the first character of the dictionary as a string+ if (number == 0)+ {+ return _dictionary[0].ToString();+ }++ var result = new StringBuilder();++ // Convert the number to a string representation using the dictionary+ // by repeatedly dividing the number by the base and prepending the character+ // at the index of the remainder in the dictionary to the result+ while (number > 0)+ {+ ulong remainder = number % _base;+ result.Insert(0, _dictionary[(int)remainder]);+ number /= _base;+ }++ string numberString = result.ToString();++ // If no formatting is required, return the string representation+ if (!format)+ {+ return numberString;+ }++ // If formatting is required, insert a space every four characters+ // starting from the end of the string+ var formattedNumber = new StringBuilder();+ int count = 0;++ for (int i = numberString.Length - 1; i >= 0; i--)+ {+ if (count > 0 && count % 4 == 0)+ {+ formattedNumber.Insert(0, ' ');+ }++ formattedNumber.Insert(0, numberString[i]);+ count++;+ }++ // Return the formatted string+ return formattedNumber.ToString();+ }++ public ulong Parse(string number)+ {+ // Let's use a unsigned long to store the result. Unsigned numbers are always positive.+ ulong numericValue = 0;++ // Iterate over each character in the input string+ for (int i = 0; i < number.Length; i++)+ {+ // Check if the current character is valid+ char currentCharacter = number[i];+ if (!IsCharacterValid(currentCharacter, out int indexOfCurrentCharacterInDictionary))+ {+ throw new InvalidOperationException();+ }++ if (numericValue > MaxValue)+ {+ throw new OverflowException();+ }++ // Calculate the new result. This is done by multiplying the current result by the base and adding the value of the current character.+ // This is equivalent to shifting the current result left by the number of bits required to represent the base, and then adding the value of the current character.+ ulong newNumericValue = numericValue * _base + (ulong)indexOfCurrentCharacterInDictionary;++ // Check if the new result is less than the old result (which would indicate an overflow)+ if (newNumericValue < numericValue)+ {+ throw new OverflowException();+ }++ // Update the result+ numericValue = newNumericValue;+ }++ return numericValue;+ }++ private bool IsCharacterValid(char c, out int number)+ {+ if (!_isDictionaryCaseSensitive)+ {+ c = char.ToLowerInvariant(c);+ }++ for (number = 0; number < _dictionary.Length; number++)+ {+ char dictionaryChar = _dictionary[number];+ if (!_isDictionaryCaseSensitive)+ {+ dictionaryChar = char.ToLowerInvariant(dictionaryChar);+ }++ if (dictionaryChar == c)+ {+ return true;+ }+ }++ number = -1;+ return false;+ }+}diff --git a/src/app/dev/DevToys.Tools/SmartDetection/NumberBaseDataTypeDetector.cs b/src/app/dev/DevToys.Tools/SmartDetection/NumberBaseDataTypeDetector.csnew file mode 100644index 000000000..95bf1143d--- /dev/null+++ b/src/app/dev/DevToys.Tools/SmartDetection/NumberBaseDataTypeDetector.cs@@ -0,0 +1,23 @@+using DevToys.Tools.Helpers;+using DevToys.Tools.Models.NumberBase;++namespace DevToys.Tools.SmartDetection;++[Export(typeof(IDataTypeDetector))]+[DataTypeName("NumberBase", baseName: PredefinedCommonDataTypeNames.Text)]+internal sealed class NumberBaseDataTypeDetector : IDataTypeDetector+{+ public ValueTask<DataDetectionResult> TryDetectDataAsync(object rawData, DataDetectionResult? resultFromBaseDetector, CancellationToken cancellationToken)+ {+ if (resultFromBaseDetector is not null+ && resultFromBaseDetector.Data is string dataString)+ {+ if (NumberBaseHelper.TryDetectNumberBase(dataString, out INumberBaseDefinition<long>? numberBaseDefinition))+ {+ return ValueTask.FromResult(new DataDetectionResult(Success: true, Data: (dataString, numberBaseDefinition)));+ }+ }++ return ValueTask.FromResult(DataDetectionResult.Unsuccessful);+ }+}diff --git a/src/app/dev/DevToys.Tools/Tools/Converters/NumberBase/INumberBaseConverterGuiToolMode.cs b/src/app/dev/DevToys.Tools/Tools/Converters/NumberBase/INumberBaseConverterGuiToolMode.csnew file mode 100644index 000000000..7d4bed6bc--- /dev/null+++ b/src/app/dev/DevToys.Tools/Tools/Converters/NumberBase/INumberBaseConverterGuiToolMode.cs@@ -0,0 +1,12 @@+using DevToys.Tools.Models.NumberBase;++namespace DevToys.Tools.Tools.Converters.NumberBase;++internal interface INumberBaseConverterGuiToolMode+{+ IUIElement View { get; }++ void OnInputChanged();++ void OnDataReceived(object? parsedData);+}diff --git a/src/app/dev/DevToys.Tools/Tools/Converters/NumberBase/NumberBaseConverter.Designer.cs b/src/app/dev/DevToys.Tools/Tools/Converters/NumberBase/NumberBaseConverter.Designer.csnew file mode 100644index 000000000..4c38a42f3--- /dev/null+++ b/src/app/dev/DevToys.Tools/Tools/Converters/NumberBase/NumberBaseConverter.Designer.cs@@ -0,0 +1,306 @@+//------------------------------------------------------------------------------+// <auto-generated>+// This code was generated by a tool.+// Runtime Version:4.0.30319.42000+//+// Changes to this file may cause incorrect behavior and will be lost if+// the code is regenerated.+// </auto-generated>+//------------------------------------------------------------------------------++namespace DevToys.Tools.Tools.Converters.NumberBase {+ using System;+++ /// <summary>+ /// A strongly-typed resource class, for looking up localized strings, etc.+ /// </summary>+ // This class was auto-generated by the StronglyTypedResourceBuilder+ // class via a tool like ResGen or Visual Studio.+ // To add or remove a member, edit your .ResX file then rerun ResGen+ // with the /str option, or rebuild your VS project.+ [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]+ [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]+ internal class NumberBaseConverter {++ private static global::System.Resources.ResourceManager resourceMan;++ private static global::System.Globalization.CultureInfo resourceCulture;++ [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]+ internal NumberBaseConverter() {+ }++ /// <summary>+ /// Returns the cached ResourceManager instance used by this class.+ /// </summary>+ [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]+ internal static global::System.Resources.ResourceManager ResourceManager {+ get {+ if (object.ReferenceEquals(resourceMan, null)) {+ global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("DevToys.Tools.Tools.Converters.NumberBase.NumberBaseConverter", typeof(NumberBaseConverter).Assembly);+ resourceMan = temp;+ }+ return resourceMan;+ }+ }++ /// <summary>+ /// Overrides the current thread's CurrentUICulture property for all+ /// resource lookups using this strongly typed resource class.+ /// </summary>+ [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]+ internal static global::System.Globalization.CultureInfo Culture {+ get {+ return resourceCulture;+ }+ set {+ resourceCulture = value;+ }+ }++ /// <summary>+ /// Looks up a localized string similar to Number Base Converter tool.+ /// </summary>+ internal static string AccessibleName {+ get {+ return ResourceManager.GetString("AccessibleName", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to Advanced mode.+ /// </summary>+ internal static string AdvancedMode {+ get {+ return ResourceManager.GetString("AdvancedMode", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to Binary.+ /// </summary>+ internal static string Binary {+ get {+ return ResourceManager.GetString("Binary", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to Configuration.+ /// </summary>+ internal static string Configuration {+ get {+ return ResourceManager.GetString("Configuration", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to Please set at least two characters in the custom dictionary.+ /// </summary>+ internal static string CustomDictionaryTooSmall {+ get {+ return ResourceManager.GetString("CustomDictionaryTooSmall", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to Custom format.+ /// </summary>+ internal static string CustomFormat {+ get {+ return ResourceManager.GetString("CustomFormat", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to Decimal.+ /// </summary>+ internal static string Decimal {+ get {+ return ResourceManager.GetString("Decimal", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to Convert numbers from one base to another.+ /// </summary>+ internal static string Description {+ get {+ return ResourceManager.GetString("Description", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to Format number.+ /// </summary>+ internal static string Format {+ get {+ return ResourceManager.GetString("Format", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to Hexadecimal.+ /// </summary>+ internal static string Hexadecimal {+ get {+ return ResourceManager.GetString("Hexadecimal", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to Input.+ /// </summary>+ internal static string Input {+ get {+ return ResourceManager.GetString("Input", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to The base of the number to convert.+ /// </summary>+ internal static string InputBaseOptionDescription {+ get {+ return ResourceManager.GetString("InputBaseOptionDescription", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to Input dictionary.+ /// </summary>+ internal static string InputDictionary {+ get {+ return ResourceManager.GetString("InputDictionary", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to Number to convert.+ /// </summary>+ internal static string InputOptionDescription {+ get {+ return ResourceManager.GetString("InputOptionDescription", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to Number Base Converter.+ /// </summary>+ internal static string LongDisplayTitle {+ get {+ return ResourceManager.GetString("LongDisplayTitle", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to Octal.+ /// </summary>+ internal static string Octal {+ get {+ return ResourceManager.GetString("Octal", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to Output.+ /// </summary>+ internal static string Output {+ get {+ return ResourceManager.GetString("Output", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to The desired base to convert to..+ /// </summary>+ internal static string OutputBaseOptionDescription {+ get {+ return ResourceManager.GetString("OutputBaseOptionDescription", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to Output dictionary.+ /// </summary>+ internal static string OutputDictionary {+ get {+ return ResourceManager.GetString("OutputDictionary", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to RFC-4648 Base16.+ /// </summary>+ internal static string RFC4648Base16 {+ get {+ return ResourceManager.GetString("RFC4648Base16", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to RFC-4648 Base32.+ /// </summary>+ internal static string RFC4648Base32 {+ get {+ return ResourceManager.GetString("RFC4648Base32", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to RFC-4648 Base32 Extended Hex.+ /// </summary>+ internal static string RFC4648Base32ExtendedHex {+ get {+ return ResourceManager.GetString("RFC4648Base32ExtendedHex", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to RFC-4648 Base64.+ /// </summary>+ internal static string RFC4648Base64 {+ get {+ return ResourceManager.GetString("RFC4648Base64", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to RFC-4648 Base64 Url Encode.+ /// </summary>+ internal static string RFC4648Base64UrlEncode {+ get {+ return ResourceManager.GetString("RFC4648Base64UrlEncode", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to Number Base.+ /// </summary>+ internal static string ShortDisplayTitle {+ get {+ return ResourceManager.GetString("ShortDisplayTitle", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to The current {0} value isn't valid.+ /// </summary>+ internal static string ValueInvalid {+ get {+ return ResourceManager.GetString("ValueInvalid", resourceCulture);+ }+ }++ /// <summary>+ /// Looks up a localized string similar to The current {0} value cannot be converted as it exceeds the maximum value ({1}).+ /// </summary>+ internal static string ValueOverflow {+ get {+ return ResourceManager.GetString("ValueOverflow", resourceCulture);+ }+ }+ }+}diff --git a/src/app/dev/DevToys.Tools/Tools/Converters/NumberBase/NumberBaseConverter.resx b/src/app/dev/DevToys.Tools/Tools/Converters/NumberBase/NumberBaseConverter.resxnew file mode 100644index 000000000..229956c09--- /dev/null+++ b/src/app/dev/DevToys.Tools/Tools/Converters/NumberBase/NumberBaseConverter.resx@@ -0,0 +1,204 @@+<?xml version="1.0" encoding="utf-8"?>+<root>+ <!--+ Microsoft ResX Schema++ Version 2.0++ The primary goals of this format is to allow a simple XML format+ that is mostly human readable. The generation and parsing of the+ various data types are done through the TypeConverter classes+ associated with the data types.++ Example:++ ... ado.net/XML headers & schema ...+ <resheader name="resmimetype">text/microsoft-resx</resheader>+ <resheader name="version">2.0</resheader>+ <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>+ <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>+ <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>+ <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>+ <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">+ <value>[base64 mime encoded serialized .NET Framework object]</value>+ </data>+ <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">+ <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>+ <comment>This is a comment</comment>+ </data>++ There are any number of "resheader" rows that contain simple+ name/value pairs.++ Each data row contains a name, and value. The row also contains a+ type or mimetype. Type corresponds to a .NET class that support+ text/value conversion through the TypeConverter architecture.+ Classes that don't support this are serialized and stored with the+ mimetype set.++ The mimetype is used for serialized objects, and tells the+ ResXResourceReader how to depersist the object. This is currently not+ extensible. For a given mimetype the value must be set accordingly:++ Note - application/x-microsoft.net.object.binary.base64 is the format+ that the ResXResourceWriter will generate, however the reader can+ read any of the formats listed below.++ mimetype: application/x-microsoft.net.object.binary.base64+ value : The object must be serialized with+ : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter+ : and then encoded with base64 encoding.++ mimetype: application/x-microsoft.net.object.soap.base64+ value : The object must be serialized with+ : System.Runtime.Serialization.Formatters.Soap.SoapFormatter+ : and then encoded with base64 encoding.++ mimetype: application/x-microsoft.net.object.bytearray.base64+ value : The object must be serialized into a byte array+ : using a System.ComponentModel.TypeConverter+ : and then encoded with base64 encoding.+ -->+ <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">+ <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />+ <xsd:element name="root" msdata:IsDataSet="true">+ <xsd:complexType>+ <xsd:choice maxOccurs="unbounded">+ <xsd:element name="metadata">+ <xsd:complexType>+ <xsd:sequence>+ <xsd:element name="value" type="xsd:string" minOccurs="0" />+ </xsd:sequence>+ <xsd:attribute name="name" use="required" type="xsd:string" />+ <xsd:attribute name="type" type="xsd:string" />+ <xsd:attribute name="mimetype" type="xsd:string" />+ <xsd:attribute ref="xml:space" />+ </xsd:complexType>+ </xsd:element>+ <xsd:element name="assembly">+ <xsd:complexType>+ <xsd:attribute name="alias" type="xsd:string" />+ <xsd:attribute name="name" type="xsd:string" />+ </xsd:complexType>+ </xsd:element>+ <xsd:element name="data">+ <xsd:complexType>+ <xsd:sequence>+ <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />+ <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />+ </xsd:sequence>+ <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />+ <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />+ <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />+ <xsd:attribute ref="xml:space" />+ </xsd:complexType>+ </xsd:element>+ <xsd:element name="resheader">+ <xsd:complexType>+ <xsd:sequence>+ <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />+ </xsd:sequence>+ <xsd:attribute name="name" type="xsd:string" use="required" />+ </xsd:complexType>+ </xsd:element>+ </xsd:choice>+ </xsd:complexType>+ </xsd:element>+ </xsd:schema>+ <resheader name="resmimetype">+ <value>text/microsoft-resx</value>+ </resheader>+ <resheader name="version">+ <value>2.0</value>+ </resheader>+ <resheader name="reader">+ <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>+ </resheader>+ <resheader name="writer">+ <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>+ </resheader>+ <data name="AccessibleName" xml:space="preserve">+ <value>Number Base Converter tool</value>+ </data>+ <data name="AdvancedMode" xml:space="preserve">+ <value>Advanced mode</value>+ </data>+ <data name="Binary" xml:space="preserve">+ <value>Binary</value>+ </data>+ <data name="Configuration" xml:space="preserve">+ <value>Configuration</value>+ </data>+ <data name="CustomDictionaryTooSmall" xml:space="preserve">+ <value>Please set at least two characters in the custom dictionary</value>+ </data>+ <data name="CustomFormat" xml:space="preserve">+ <value>Custom format</value>+ </data>+ <data name="Decimal" xml:space="preserve">+ <value>Decimal</value>+ </data>+ <data name="Description" xml:space="preserve">+ <value>Convert numbers from one base to another</value>+ </data>+ <data name="Format" xml:space="preserve">+ <value>Format number</value>+ </data>+ <data name="Hexadecimal" xml:space="preserve">+ <value>Hexadecimal</value>+ </data>+ <data name="Input" xml:space="preserve">+ <value>Input</value>+ </data>+ <data name="InputBaseOptionDescription" xml:space="preserve">+ <value>The base of the number to convert</value>+ </data>+ <data name="InputDictionary" xml:space="preserve">+ <value>Input dictionary</value>+ </data>+ <data name="InputOptionDescription" xml:space="preserve">+ <value>Number to convert</value>+ <comment>CLI parameter description</comment>+ </data>+ <data name="LongDisplayTitle" xml:space="preserve">+ <value>Number Base Converter</value>+ </data>+ <data name="Octal" xml:space="preserve">+ <value>Octal</value>+ </data>+ <data name="Output" xml:space="preserve">+ <value>Output</value>+ </data>+ <data name="OutputBaseOptionDescription" xml:space="preserve">+ <value>The desired base to convert to.</value>+ </data>+ <data name="OutputDictionary" xml:space="preserve">+ <value>Output dictionary</value>+ </data>+ <data name="RFC4648Base16" xml:space="preserve">+ <value>RFC-4648 Base16</value>+ </data>+ <data name="RFC4648Base32" xml:space="preserve">+ <value>RFC-4648 Base32</value>+ </data>+ <data name="RFC4648Base32ExtendedHex" xml:space="preserve">+ <value>RFC-4648 Base32 Extended Hex</value>+ </data>+ <data name="RFC4648Base64" xml:space="preserve">+ <value>RFC-4648 Base64</value>+ </data>+ <data name="RFC4648Base64UrlEncode" xml:space="preserve">+ <value>RFC-4648 Base64 Url Encode</value>+ </data>+ <data name="ShortDisplayTitle" xml:space="preserve">+ <value>Number Base</value>+ </data>+ <data name="ValueInvalid" xml:space="preserve">+ <value>The current {0} value isn't valid</value>+ <comment>The parameter is the Base Number Type (Decimal, Octal, ...)</comment>+ </data>+ <data name="ValueOverflow" xml:space="preserve">+ <value>The current {0} value cannot be converted as it exceeds the maximum value ({1})</value>+ <comment>0 is the base number type (Decima, Octal...). 1 is the parameter is the Max value.</comment>+ </data>+</root>\ No newline at end of filediff --git a/src/app/dev/DevToys.Tools/Tools/Converters/NumberBase/NumberBaseConverterCommandLineTool.cs b/src/app/dev/DevToys.Tools/Tools/Converters/NumberBase/NumberBaseConverterCommandLineTool.csnew file mode 100644index 000000000..b35c6d73a--- /dev/null+++ b/src/app/dev/DevToys.Tools/Tools/Converters/NumberBase/NumberBaseConverterCommandLineTool.cs@@ -0,0 +1,88 @@+using DevToys.Tools.Helpers;+using DevToys.Tools.Models.NumberBase;+using Microsoft.Extensions.Logging;+using Decimal = DevToys.Tools.Models.NumberBase.Decimal;++namespace DevToys.Tools.Tools.Converters.NumberBase;++[Export(typeof(ICommandLineTool))]+[Name("NumberBaseConverter")]+[CommandName(+ Name = "numberbase",+ Alias = "nb",+ ResourceManagerBaseName = "DevToys.Tools.Tools.Converters.NumberBase.NumberBaseConverter",+ DescriptionResourceName = nameof(NumberBaseConverter.Description))]+internal sealed class NumberBaseConverterCommandLineTool : ICommandLineTool+{+ internal enum WellKnownNumberBases+ {+ Decimal,+ Octal,+ Hexadecimal,+ Binary+ }++ [CommandLineOption(+ Name = "input",+ Alias = "i",+ IsRequired = true,+ DescriptionResourceName = nameof(NumberBaseConverter.InputOptionDescription))]+ internal string? Input { get; set; }++ [CommandLineOption(+ Name = "base",+ Alias = "b",+ DescriptionResourceName = nameof(NumberBaseConverter.InputBaseOptionDescription))]+ internal WellKnownNumberBases InputBase { get; set; } = WellKnownNumberBases.Decimal;++ [CommandLineOption(+ Name = "outputBase",+ Alias = "o",+ DescriptionResourceName = nameof(NumberBaseConverter.OutputBaseOptionDescription))]+ internal WellKnownNumberBases OutputBase { get; set; } = WellKnownNumberBases.Hexadecimal;++ public ValueTask<int> InvokeAsync(ILogger logger, CancellationToken cancellationToken)+ {+ Guard.IsNotNullOrEmpty(Input);++ INumberBaseDefinition<long> inputBaseDefinition+ = InputBase switch+ {+ WellKnownNumberBases.Binary => Binary.Instance,+ WellKnownNumberBases.Octal => Octal.Instance,+ WellKnownNumberBases.Decimal => Decimal.Instance,+ WellKnownNumberBases.Hexadecimal => Hexadecimal.Instance,+ _ => throw new NotSupportedException()+ };++ INumberBaseDefinition<long> outputBaseDefinition+ = OutputBase switch+ {+ WellKnownNumberBases.Binary => Binary.Instance,+ WellKnownNumberBases.Octal => Octal.Instance,+ WellKnownNumberBases.Decimal => Decimal.Instance,+ WellKnownNumberBases.Hexadecimal => Hexadecimal.Instance,+ _ => throw new NotSupportedException()+ };++ bool succeeded+ = NumberBaseHelper.TryConvertNumberBase(+ Input,+ inputBaseDefinition,+ outputBaseDefinition,+ format: true,+ out string? result,+ out string? error);++ if (succeeded)+ {+ Console.WriteLine(result);+ return ValueTask.FromResult(0);+ }+ else+ {+ Console.Error.WriteLine(error);+ return ValueTask.FromResult(-1);+ }+ }+}diff --git a/src/app/dev/DevToys.Tools/Tools/Converters/NumberBase/NumberBaseConverterGuiTool.cs b/src/app/dev/DevToys.Tools/Tools/Converters/NumberBase/NumberBaseConverterGuiTool.csnew file mode 100644index 000000000..5ed7e9ad9--- /dev/null+++ b/src/app/dev/DevToys.Tools/Tools/Converters/NumberBase/NumberBaseConverterGuiTool.cs@@ -0,0 +1,140 @@+using DevToys.Tools.Models.NumberBase;+using Microsoft.Extensions.Logging;++namespace DevToys.Tools.Tools.Converters.NumberBase;++[Export(typeof(IGuiTool))]+[Name("NumberBaseConverter")]+[ToolDisplayInformation(+ IconFontName = "DevToys-Tools-Icons",+ IconGlyph = '\u0118',+ GroupName = PredefinedCommonToolGroupNames.Converters,+ ResourceManagerAssemblyIdentifier = nameof(DevToysToolsResourceManagerAssemblyIdentifier),+ ResourceManagerBaseName = "DevToys.Tools.Tools.Converters.NumberBase.NumberBaseConverter",+ ShortDisplayTitleResourceName = nameof(NumberBaseConverter.ShortDisplayTitle),+ LongDisplayTitleResourceName = nameof(NumberBaseConverter.LongDisplayTitle),+ DescriptionResourceName = nameof(NumberBaseConverter.Description),+ AccessibleNameResourceName = nameof(NumberBaseConverter.AccessibleName))]+[AcceptedDataTypeName("NumberBase")]+internal sealed class NumberBaseConverterGuiTool : IGuiTool+{+ /// <summary>+ /// Whether the value should be formatted or not.+ /// </summary>+ internal static readonly SettingDefinition<bool> formatted+ = new(+ name: $"{nameof(NumberBaseConverterGuiTool)}.{nameof(formatted)}",+ defaultValue: true);++ /// <summary>+ /// Whether the advanced mode should be used or not.+ /// </summary>+ private static readonly SettingDefinition<bool> advancedMode+ = new(+ name: $"{nameof(NumberBaseConverterGuiTool)}.{nameof(advancedMode)}",+ defaultValue: false);++ private readonly DisposableSemaphore _semaphore = new();+ private readonly ILogger _logger;+ private readonly ISettingsProvider _settingsProvider;+ private readonly IUIStack _modeContainer = Stack();+ private readonly IUIInfoBar _infoBar = InfoBar();+ private readonly Lazy<INumberBaseConverterGuiToolMode> _basicMode;+ private readonly Lazy<INumberBaseConverterGuiToolMode> _advancedMode;++ private INumberBaseConverterGuiToolMode _activeMode = null!;++ [ImportingConstructor]+ public NumberBaseConverterGuiTool(ISettingsProvider settingsProvider)+ {+ _logger = this.Log();+ _settingsProvider = settingsProvider;++ _basicMode = new(() => new NumberBaseConverterGuiToolBasicMode(_settingsProvider, OnError));+ _advancedMode = new(() => new NumberBaseConverterGuiToolAdvancedMode(_settingsProvider, OnError));++ ApplyMode();+ }++ public UIToolView View+ => new(+ isScrollable: true,+ Stack()+ .Vertical()+ .LargeSpacing()+ .WithChildren(++ // Configuration+ Stack()+ .Vertical()+ .WithChildren(++ Label().Text(NumberBaseConverter.Configuration),+ Setting()+ .Icon("FluentSystemIcons", '\uF7B2')+ .Title(NumberBaseConverter.Format)+ .Handle(+ _settingsProvider,+ formatted,+ OnFormatOptionChanged),+ Setting()+ .Icon("FluentSystemIcons", '\uF1EE')+ .Title(NumberBaseConverter.AdvancedMode)+ .Handle(+ _settingsProvider,+ advancedMode,+ (_) => ApplyMode())),++ _infoBar+ .Close()+ .NonClosable()+ .Warning(),++ // Content+ _modeContainer+ .Vertical()));++ public void OnDataReceived(string dataTypeName, object? parsedData)+ {+ if (dataTypeName == "NumberBase")+ {+ _settingsProvider.SetSetting(advancedMode, false);+ ApplyMode();++ _activeMode.OnDataReceived(parsedData);+ }+ }++ private void ApplyMode()+ {+ if (_settingsProvider.GetSetting(advancedMode))+ {+ _activeMode = _advancedMode.Value;+ }+ else+ {+ _activeMode = _basicMode.Value;+ }++ _modeContainer.WithChildren(_activeMode.View);+ }++ private void OnFormatOptionChanged(bool _)+ {+ Guard.IsNotNull(_activeMode);+ _activeMode.OnInputChanged();+ }++ private void OnError(string message)+ {+ if (string.IsNullOrEmpty(message))+ {+ _infoBar.Close();+ }+ else+ {+ _infoBar.Title(message);+ _infoBar.Open();+ }+ }+}diff --git a/src/app/dev/DevToys.Tools/Tools/Converters/NumberBase/NumberBaseConverterGuiToolAdvancedMode.cs b/src/app/dev/DevToys.Tools/Tools/Converters/NumberBase/NumberBaseConverterGuiToolAdvancedMode.csnew file mode 100644index 000000000..3aa3a5e0b--- /dev/null+++ b/src/app/dev/DevToys.Tools/Tools/Converters/NumberBase/NumberBaseConverterGuiToolAdvancedMode.cs@@ -0,0 +1,202 @@+using DevToys.Tools.Helpers;+using DevToys.Tools.Models.NumberBase;++namespace DevToys.Tools.Tools.Converters.NumberBase;++internal sealed class NumberBaseConverterGuiToolAdvancedMode : INumberBaseConverterGuiToolMode+{+ private readonly ISettingsProvider _settingsProvider;+ private readonly Action<string> _onErrorCallback;+ private readonly IUISelectDropDownList _inputDictionarySelectDropDownList = SelectDropDownList();+ private readonly IUISelectDropDownList _outputDictionarySelectDropDownList = SelectDropDownList();+ private readonly IUISingleLineTextInput _inputCustomFormat = SingleLineTextInput();+ private readonly IUISingleLineTextInput _outputCustomFormat = SingleLineTextInput();+ private readonly IUISingleLineTextInput _inputText = SingleLineTextInput();+ private readonly IUISingleLineTextInput _outputText = SingleLineTextInput();++ private bool _ignoreInputChanges;++ internal NumberBaseConverterGuiToolAdvancedMode(ISettingsProvider settingsProvider, Action<string> onErrorCallback)+ {+ Guard.IsNotNull(settingsProvider);+ Guard.IsNotNull(onErrorCallback);+ _settingsProvider = settingsProvider;+ _onErrorCallback = onErrorCallback;++ _ignoreInputChanges = true;+ InitializeInputAndOutputDictionarySelectDropDownList(_inputDictionarySelectDropDownList, OnSelectedInputDictionaryChanged);+ InitializeInputAndOutputDictionarySelectDropDownList(_outputDictionarySelectDropDownList, OnSelectedOutputDictionaryChanged);+ _ignoreInputChanges = false;+ }++ public IUIElement View+ => Stack()+ .Vertical()+ .LargeSpacing()+ .WithChildren(++ // Input+ Stack()+ .Vertical()+ .SmallSpacing()+ .WithChildren(++ SettingGroup()+ .Icon("FluentSystemIcons", '\uF2B0')+ .Title(NumberBaseConverter.InputDictionary)+ .InteractiveElement(_inputDictionarySelectDropDownList)+ .WithChildren(+ _inputCustomFormat+ .Title(NumberBaseConverter.CustomFormat)+ .HideCommandBar()+ .OnTextChanged(OnInputTextChanged)),++ _inputText+ .Title(NumberBaseConverter.Input)+ .OnTextChanged(OnInputTextChanged)),++ // Output+ Stack()+ .Vertical()+ .SmallSpacing()+ .WithChildren(++ SettingGroup()+ .Icon("FluentSystemIcons", '\uF2AA')+ .Title(NumberBaseConverter.OutputDictionary)+ .InteractiveElement(_outputDictionarySelectDropDownList)+ .WithChildren(+ _outputCustomFormat+ .Title(NumberBaseConverter.CustomFormat)+ .HideCommandBar()+ .OnTextChanged(OnInputTextChanged)),++ _outputText+ .Title(NumberBaseConverter.Output)+ .ReadOnly()));++ public void OnDataReceived(object? parsedData)+ {+ throw new NotImplementedException();+ }++ public void OnInputChanged()+ {+ if (_ignoreInputChanges)+ {+ return;+ }++ // Retrieve the input number base definition.+ INumberBaseDefinition<ulong> inputNumberBase;+ if (_inputDictionarySelectDropDownList.SelectedItem?.Text == NumberBaseConverter.CustomFormat)+ {+ if (_inputCustomFormat.Text.Length < 2)+ {+ _onErrorCallback.Invoke(NumberBaseConverter.CustomDictionaryTooSmall);+ _outputText.Text(string.Empty);+ return;+ }++ inputNumberBase = new CustomUnsigned(_inputCustomFormat.Text);+ }+ else+ {+ Guard.IsNotNull(_inputDictionarySelectDropDownList.SelectedItem);+ Guard.IsNotNull(_inputDictionarySelectDropDownList.SelectedItem.Value);+ Guard.IsAssignableToType(_inputDictionarySelectDropDownList.SelectedItem.Value, typeof(INumberBaseDefinition<ulong>));+ inputNumberBase = (INumberBaseDefinition<ulong>)_inputDictionarySelectDropDownList.SelectedItem.Value;+ }++ // Retrieve the output number base definition.+ INumberBaseDefinition<ulong> outputNumberBase;+ if (_outputDictionarySelectDropDownList.SelectedItem?.Text == NumberBaseConverter.CustomFormat)+ {+ if (_outputCustomFormat.Text.Length < 2)+ {+ _onErrorCallback.Invoke(NumberBaseConverter.CustomDictionaryTooSmall);+ _outputText.Text(string.Empty);+ return;+ }++ outputNumberBase = new CustomUnsigned(_outputCustomFormat.Text);+ }+ else+ {+ Guard.IsNotNull(_outputDictionarySelectDropDownList.SelectedItem);+ Guard.IsNotNull(_outputDictionarySelectDropDownList.SelectedItem.Value);+ Guard.IsAssignableToType(_outputDictionarySelectDropDownList.SelectedItem.Value, typeof(INumberBaseDefinition<ulong>));+ outputNumberBase = (INumberBaseDefinition<ulong>)_outputDictionarySelectDropDownList.SelectedItem.Value;+ }++ // Convert the number.+ bool format = _settingsProvider.GetSetting(NumberBaseConverterGuiTool.formatted);+ bool succeeded+ = NumberBaseHelper.TryConvertNumberBase(+ _inputText.Text,+ inputNumberBase,+ outputNumberBase,+ format,+ out string result,+ out string error);++ // Display result.+ _onErrorCallback.Invoke(error);++ if (succeeded)+ {+ _outputText.Text(result);+ }+ else+ {+ _outputText.Text(string.Empty);+ }+ }++ private void OnInputTextChanged(string _)+ {+ OnInputChanged();+ }++ private void OnSelectedInputDictionaryChanged()+ {+ if (_inputDictionarySelectDropDownList.SelectedItem?.Text == NumberBaseConverter.CustomFormat)+ {+ _inputCustomFormat.Enable();+ }+ else+ {+ _inputCustomFormat.Disable();+ }++ OnInputChanged();+ }++ private void OnSelectedOutputDictionaryChanged()+ {+ if (_outputDictionarySelectDropDownList.SelectedItem?.Text == NumberBaseConverter.CustomFormat)+ {+ _outputCustomFormat.Enable();+ }+ else+ {+ _outputCustomFormat.Disable();+ }++ OnInputChanged();+ }++ private static void InitializeInputAndOutputDictionarySelectDropDownList(IUISelectDropDownList selectDropDownList, Action onSelectedItemChanged)+ {+ selectDropDownList+ .WithItems(+ Item(RFC4648Base16.Instance.DisplayName, RFC4648Base16.Instance),+ Item(RFC4648Base32.Instance.DisplayName, RFC4648Base32.Instance),+ Item(RFC4648Base32ExtendedHex.Instance.DisplayName, RFC4648Base32ExtendedHex.Instance),+ Item(RFC4648Base64.Instance.DisplayName, RFC4648Base64.Instance),+ Item(RFC4648Base64UrlEncode.Instance.DisplayName, RFC4648Base64UrlEncode.Instance),+ Item(NumberBaseConverter.CustomFormat, null))+ .OnItemSelected((_) => onSelectedItemChanged())+ .Select(0);+ }+}diff --git a/src/app/dev/DevToys.Tools/Tools/Converters/NumberBase/NumberBaseConverterGuiToolBasicMode.cs b/src/app/dev/DevToys.Tools/Tools/Converters/NumberBase/NumberBaseConverterGuiToolBasicMode.csnew file mode 100644index 000000000..078455b9f--- /dev/null+++ b/src/app/dev/DevToys.Tools/Tools/Converters/NumberBase/NumberBaseConverterGuiToolBasicMode.cs@@ -0,0 +1,175 @@+using DevToys.Tools.Helpers;+using DevToys.Tools.Models.NumberBase;+using Decimal = DevToys.Tools.Models.NumberBase.Decimal;++namespace DevToys.Tools.Tools.Converters.NumberBase;++internal sealed class NumberBaseConverterGuiToolBasicMode : INumberBaseConverterGuiToolMode+{+ private readonly ISettingsProvider _settingsProvider;+ private readonly Action<string> _onErrorCallback;+ private readonly IUISingleLineTextInput _hexadecimalText = SingleLineTextInput();+ private readonly IUISingleLineTextInput _decimalText = SingleLineTextInput();+ private readonly IUISingleLineTextInput _octalText = SingleLineTextInput();+ private readonly IUISingleLineTextInput _binaryText = SingleLineTextInput();++ private bool _ignoreInputChanges;+ private (string number, INumberBaseDefinition<long> baseDefinition)? _inputValue;++ internal NumberBaseConverterGuiToolBasicMode(ISettingsProvider settingsProvider, Action<string> onErrorCallback)+ {+ Guard.IsNotNull(settingsProvider);+ Guard.IsNotNull(onErrorCallback);+ _settingsProvider = settingsProvider;+ _onErrorCallback = onErrorCallback;+ }++ public IUIElement View+ => Stack()+ .Vertical()+ .WithChildren(++ _hexadecimalText+ .Title(NumberBaseConverter.Hexadecimal)+ .OnTextChanged(OnHexadecimalChanged)+ .CanCopyWhenEditable(),++ _decimalText+ .Title(NumberBaseConverter.Decimal)+ .OnTextChanged(OnDecimalChanged)+ .CanCopyWhenEditable(),++ _octalText+ .Title(NumberBaseConverter.Octal)+ .OnTextChanged(OnOctalChanged)+ .CanCopyWhenEditable(),++ _binaryText+ .Title(NumberBaseConverter.Binary)+ .OnTextChanged(OnBinaryChanged)+ .CanCopyWhenEditable());++ public void OnDataReceived(object? parsedData)+ {+ if (parsedData is (string dataString, INumberBaseDefinition<long> numberBaseDefinition))+ {+ if (numberBaseDefinition == Hexadecimal.Instance)+ {+ _hexadecimalText.Text(dataString);+ }+ else if (numberBaseDefinition == Decimal.Instance)+ {+ _decimalText.Text(dataString);+ }+ else if (numberBaseDefinition == Octal.Instance)+ {+ _octalText.Text(dataString);+ }+ else if (numberBaseDefinition == Binary.Instance)+ {+ _binaryText.Text(dataString);+ }+ }+ }++ public void OnInputChanged()+ {+ if (_ignoreInputChanges)+ {+ return;+ }++ Guard.IsNotNull(_inputValue);++ bool format = _settingsProvider.GetSetting(NumberBaseConverterGuiTool.formatted);++ bool succeeded+ = NumberBaseHelper.TryConvertNumberBase(+ _inputValue.Value.number,+ _inputValue.Value.baseDefinition,+ format,+ out string hexadecimal,+ out string @decimal,+ out string octal,+ out string binary,+ out string error);++ UpdateUI(succeeded, hexadecimal, @decimal, octal, binary, error);+ }++ private void UpdateUI(+ bool succeeded,+ string hexadecimal,+ string @decimal,+ string octal,+ string binary,+ string error)+ {+ Guard.IsNotNull(_inputValue);++ _ignoreInputChanges = true;++ _onErrorCallback.Invoke(error);++ if (succeeded)+ {+ _hexadecimalText.Text(hexadecimal);+ _decimalText.Text(@decimal);+ _octalText.Text(octal);+ _binaryText.Text(binary);+ }+ else+ {+ if (_inputValue.Value.baseDefinition == Hexadecimal.Instance)+ {+ _decimalText.Text(string.Empty);+ _octalText.Text(string.Empty);+ _binaryText.Text(string.Empty);+ }+ else if (_inputValue.Value.baseDefinition == Decimal.Instance)+ {+ _hexadecimalText.Text(string.Empty);+ _octalText.Text(string.Empty);+ _binaryText.Text(string.Empty);+ }+ else if (_inputValue.Value.baseDefinition == Octal.Instance)+ {+ _hexadecimalText.Text(string.Empty);+ _decimalText.Text(string.Empty);+ _binaryText.Text(string.Empty);+ }+ else if (_inputValue.Value.baseDefinition == Binary.Instance)+ {+ _hexadecimalText.Text(string.Empty);+ _decimalText.Text(string.Empty);+ _octalText.Text(string.Empty);+ }+ }++ _ignoreInputChanges = false;+ }++ private void OnHexadecimalChanged(string number)+ {+ _inputValue = new(number, Hexadecimal.Instance);+ OnInputChanged();+ }++ private void OnDecimalChanged(string number)+ {+ _inputValue = new(number, Decimal.Instance);+ OnInputChanged();+ }++ private void OnOctalChanged(string number)+ {+ _inputValue = new(number, Octal.Instance);+ OnInputChanged();+ }++ private void OnBinaryChanged(string number)+ {+ _inputValue = new(number, Binary.Instance);+ OnInputChanged();+ }+}diff --git a/src/app/tests/DevToys.UnitTests/Tools/Helpers/NumberBaseHelperTests.cs b/src/app/tests/DevToys.UnitTests/Tools/Helpers/NumberBaseHelperTests.csnew file mode 100644index 000000000..e5bb93a2a--- /dev/null+++ b/src/app/tests/DevToys.UnitTests/Tools/Helpers/NumberBaseHelperTests.cs@@ -0,0 +1,471 @@+using DevToys.Tools.Helpers;+using DevToys.Tools.Models.NumberBase;+using Decimal = DevToys.Tools.Models.NumberBase.Decimal;++namespace DevToys.UnitTests.Tools.Helpers;++public class NumberBaseHelperTests+{+ [Theory]+ [InlineData(+ "123ABC",+ true,+ "12 3ABC",+ "1,194,684",+ "4 435 274",+ "0001 0010 0011 1010 1011 1100",+ true)]+ [InlineData(+ "123 ABC",+ true,+ "12 3ABC",+ "1,194,684",+ "4 435 274",+ "0001 0010 0011 1010 1011 1100",+ true)]+ [InlineData(+ "123abc",+ true,+ "12 3ABC",+ "1,194,684",+ "4 435 274",+ "0001 0010 0011 1010 1011 1100",+ true)]+ [InlineData(+ "123 abc",+ true,+ "12 3ABC",+ "1,194,684",+ "4 435 274",+ "0001 0010 0011 1010 1011 1100",+ true)]+ [InlineData(+ "C6AEA155",+ true,+ "C6AE A155",+ "3,333,333,333",+ "30 653 520 525",+ "1100 0110 1010 1110 1010 0001 0101 0101",+ true)]+ [InlineData(+ "C6AE A155",+ true,+ "C6AE A155",+ "3,333,333,333",+ "30 653 520 525",+ "1100 0110 1010 1110 1010 0001 0101 0101",+ true)]+ [InlineData(+ "C6AE A15 5",+ true,+ "C6AE A155",+ "3,333,333,333",+ "30 653 520 525",+ "1100 0110 1010 1110 1010 0001 0101 0101",+ true)]+ [InlineData(+ "FFFF FFFF FFFF FFF6",+ true,+ "FFFF FFFF FFFF FFF6",+ "-10",+ "1 777 777 777 777 777 777 766",+ "1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 0110",+ true)]+ [InlineData(+ "FFFFFFFFFFFFFFF6",+ true,+ "FFFF FFFF FFFF FFF6",+ "-10",+ "1 777 777 777 777 777 777 766",+ "1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 0110",+ true)]+ [InlineData(+ "123ABC",+ false,+ "123ABC",+ "1194684",+ "4435274",+ "000100100011101010111100",+ true)]+ [InlineData(+ "123abc",+ false,+ "123ABC",+ "1194684",+ "4435274",+ "000100100011101010111100",+ true)]+ [InlineData(+ "C6AEA155",+ false,+ "C6AEA155",+ "3333333333",+ "30653520525",+ "11000110101011101010000101010101",+ true)]+ [InlineData(+ "FFFFFFFFFFFFFFF6",+ false,+ "FFFFFFFFFFFFFFF6",+ "-10",+ "1777777777777777777766",+ "1111111111111111111111111111111111111111111111111111111111110110",+ true)]+ [InlineData(+ "123ZER",+ true,+ "",+ "",+ "",+ "",+ false)]+ [InlineData(+ "123&ER",+ true,+ "",+ "",+ "",+ "",+ false)]+ [InlineData(+ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",+ true,+ "",+ "",+ "",+ "",+ false)]+ public void ConvertFromHexadecimalWithFormatting(+ string input,+ bool format,+ string expectedHexadecimal,+ string expectedDecimal,+ string expectedOctal,+ string expectedBinary,+ bool expectedSuccess)+ {+ ConvertTest(+ Hexadecimal.Instance,+ format,+ input,+ expectedHexadecimal,+ expectedDecimal,+ expectedOctal,+ expectedBinary,+ expectedSuccess);+ }++ [Theory]+ [InlineData(+ "18006427676",+ true,+ "4 3144 481C",+ "18,006,427,676",+ "206 121 044 034",+ "0100 0011 0001 0100 0100 0100 1000 0001 1100",+ true)]+ [InlineData(+ "18,006,427,676",+ false,+ "43144481C",+ "18006427676",+ "206121044034",+ "010000110001010001000100100000011100",+ true)]+ [InlineData(+ "-18006427676",+ true,+ "FFFF FFFB CEBB B7E4",+ "-18,006,427,676",+ "1 777 777 777 571 656 733 744",+ "1111 1111 1111 1111 1111 1111 1111 1011 1100 1110 1011 1011 1011 0111 1110 0100",+ true)]+ [InlineData(+ "-18,006,427,676",+ false,+ "FFFFFFFBCEBBB7E4",+ "-18006427676",+ "1777777777571656733744",+ "1111111111111111111111111111101111001110101110111011011111100100",+ true)]+ [InlineData(+ "-18,006,427,676,999,999,999,999,999,999",+ false,+ "",+ "",+ "",+ "",+ false)]+ [InlineData(+ "abc",+ false,+ "",+ "",+ "",+ "",+ false)]+ public void ConvertFromDecimalWithFormatting(+ string input,+ bool format,+ string expectedHexadecimal,+ string expectedDecimal,+ string expectedOctal,+ string expectedBinary,+ bool expectedSuccess)+ {+ ConvertTest(+ Decimal.Instance,+ format,+ input,+ expectedHexadecimal,+ expectedDecimal,+ expectedOctal,+ expectedBinary,+ expectedSuccess);+ }++ [Theory]+ [InlineData(+ "30653520525",+ true,+ "C6AE A155",+ "3,333,333,333",+ "30 653 520 525",+ "1100 0110 1010 1110 1010 0001 0101 0101",+ true)]+ [InlineData(+ "30 653 520 525",+ false,+ "C6AEA155",+ "3333333333",+ "30653520525",+ "11000110101011101010000101010101",+ true)]+ [InlineData(+ "1777777777747124257253",+ true,+ "FFFF FFFF 3951 5EAB",+ "-3,333,333,333",+ "1 777 777 777 747 124 257 253",+ "1111 1111 1111 1111 1111 1111 1111 1111 0011 1001 0101 0001 0101 1110 1010 1011",+ true)]+ [InlineData(+ "1 777 777 777 747 124 257 253",+ false,+ "FFFFFFFF39515EAB",+ "-3333333333",+ "1777777777747124257253",+ "1111111111111111111111111111111100111001010100010101111010101011",+ true)]+ [InlineData(+ "30653520525&",+ false,+ "",+ "",+ "",+ "",+ false)]+ [InlineData(+ "30 653 520 525 &",+ false,+ "",+ "",+ "",+ "",+ false)]+ [InlineData(+ "306535205258",+ false,+ "",+ "",+ "",+ "",+ false)]+ [InlineData(+ "30 653 520 525 8",+ false,+ "",+ "",+ "",+ "",+ false)]+ [InlineData(+ "306535295256",+ false,+ "",+ "",+ "",+ "",+ false)]+ [InlineData(+ "30 653 529 525 6",+ false,+ "",+ "",+ "",+ "",+ false)]+ [InlineData(+ "3065352a5256",+ false,+ "",+ "",+ "",+ "",+ false)]+ [InlineData(+ "3065352A5256",+ false,+ "",+ "",+ "",+ "",+ false)]+ public void ConvertFromOctalWithFormatting(+ string input,+ bool format,+ string expectedHexadecimal,+ string expectedDecimal,+ string expectedOctal,+ string expectedBinary,+ bool expectedSuccess)+ {+ ConvertTest(+ Octal.Instance,+ format,+ input,+ expectedHexadecimal,+ expectedDecimal,+ expectedOctal,+ expectedBinary,+ expectedSuccess);+ }++ [Theory]+ [InlineData(+ "000101001101",+ false,+ "14D",+ "333",+ "515",+ "000101001101",+ true)]+ [InlineData(+ "11000110101011101010000101010101",+ false,+ "C6AEA155",+ "3333333333",+ "30653520525",+ "11000110101011101010000101010101",+ true)]+ [InlineData(+ "111111111 111111111111111111111 1100111001010100010 101111010101011",+ false,+ "FFFFFFFF39515EAB",+ "-3333333333",+ "1777777777747124257253",+ "1111111111111111111111111111111100111001010100010101111010101011",+ true)]+ [InlineData(+ "0001 0100 1101as",+ false,+ "",+ "",+ "",+ "",+ false)]+ [InlineData(+ "000101001101&",+ false,+ "",+ "",+ "",+ "",+ false)]+ public void ConvertFromBinaryWithFormatting(+ string input,+ bool format,+ string expectedHexadecimal,+ string expectedDecimal,+ string expectedOctal,+ string expectedBinary,+ bool expectedSuccess)+ {+ ConvertTest(+ Binary.Instance,+ format,+ input,+ expectedHexadecimal,+ expectedDecimal,+ expectedOctal,+ expectedBinary,+ expectedSuccess);+ }++ [Theory]+ [InlineData("0", ".", true)]+ [InlineData("FFFF FFFF FFFF FFFF", "?}: )>)) )')? ; _(", true)]+ public void ConvertFromRFC4648Base16ToCustomFormatWithFormatting(+ string rfc4648Base16Input,+ string expectedResult,+ bool expectedSuccess)+ {+ NumberBaseHelper.TryConvertNumberBase(+ rfc4648Base16Input,+ RFC4648Base16.Instance,+ new CustomUnsigned("./,<>?;':\"[]{ }()-_=+"),+ format: true,+ out string result,+ out string _)+ .Should().Be(expectedSuccess);++ result.Should().Be(expectedResult);+ }++ [Theory]+ [InlineData("0", ".", true)]+ [InlineData("FFFF FFFF FFFF FFFF", ",,/> ,,.< .<// >>.. >,>/ ,//, ,><.", true)]+ public void ConvertFromRFC4648Base16ToSmallCustomFormatWithFormatting(+ string rfc4648Base16Input,+ string expectedResult,+ bool expectedSuccess)+ {+ NumberBaseHelper.TryConvertNumberBase(+ rfc4648Base16Input,+ RFC4648Base16.Instance,+ new CustomUnsigned("./,<>"),+ format: true,+ out string result,+ out string _)+ .Should().Be(expectedSuccess);++ result.Should().Be(expectedResult);+ }++ private static void ConvertTest(+ SignedLongNumberBaseDefinition numberBaseDefinition,+ bool format,+ string input,+ string expectedHexadecimal,+ string expectedDecimal,+ string expectedOctal,+ string expectedBinary,+ bool expectedSuccess)+ {+ NumberBaseHelper.TryConvertNumberBase(+ input,+ numberBaseDefinition,+ format,+ out string hexadecimal,+ out string @decimal,+ out string octal,+ out string binary,+ out string _)+ .Should().Be(expectedSuccess);++ hexadecimal.Should().Be(expectedHexadecimal);+ @decimal.Should().Be(expectedDecimal);+ octal.Should().Be(expectedOctal);+ binary.Should().Be(expectedBinary);+ }+}diff --git a/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/BinaryTests.cs b/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/BinaryTests.csnew file mode 100644index 000000000..4477504b8--- /dev/null+++ b/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/BinaryTests.cs@@ -0,0 +1,26 @@+using DevToys.Tools.Models.NumberBase;++namespace DevToys.UnitTests.Tools.Models.NumberBase;++public class BinaryTests+{+ [Theory]+ [InlineData(333, "0001 0100 1101")]+ [InlineData(1869, "0111 0100 1101")]+ [InlineData(3917, "1111 0100 1101")]+ [InlineData(long.MinValue, "1000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000")]+ [InlineData(long.MaxValue, "0111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111")]+ public void FormatBinary(long input, string expectedResult)+ {+ Binary.Instance.ToFormattedString(input, true).Should().Be(expectedResult);+ }++ [Theory]+ [InlineData("1000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000", long.MinValue)]+ [InlineData("0111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111", long.MaxValue)]+ public void ParseBinary(string input, long expectedResult)+ {+ input = input.Replace(" ", string.Empty);+ Binary.Instance.Parse(input).Should().Be(expectedResult);+ }+}diff --git a/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/DecimalTests.cs b/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/DecimalTests.csnew file mode 100644index 000000000..74741b8e0--- /dev/null+++ b/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/DecimalTests.cs@@ -0,0 +1,27 @@+using Decimal = DevToys.Tools.Models.NumberBase.Decimal;++namespace DevToys.UnitTests.Tools.Models.NumberBase;++public class DecimalTests+{+ [Theory]+ [InlineData(123456, "123,456")]+ [InlineData(12345, "12,345")]+ [InlineData(-123456, "-123,456")]+ [InlineData(-12345, "-12,345")]+ [InlineData(long.MinValue, "-9,223,372,036,854,775,808")]+ [InlineData(long.MaxValue, "9,223,372,036,854,775,807")]+ public void FormatDecimal(long input, string expectedResult)+ {+ Decimal.Instance.ToFormattedString(input, true).Should().Be(expectedResult);+ }++ [Theory]+ [InlineData("-9,223,372,036,854,775,808", long.MinValue)]+ [InlineData("9,223,372,036,854,775,807", long.MaxValue)]+ public void ParseDecimal(string input, long expectedResult)+ {+ input = input.Replace(",", string.Empty);+ Decimal.Instance.Parse(input).Should().Be(expectedResult);+ }+}diff --git a/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/HexadecimalTests.cs b/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/HexadecimalTests.csnew file mode 100644index 000000000..bad884da4--- /dev/null+++ b/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/HexadecimalTests.cs@@ -0,0 +1,27 @@+using DevToys.Tools.Models.NumberBase;++namespace DevToys.UnitTests.Tools.Models.NumberBase;++public class HexadecimalTests+{+ [Theory]+ [InlineData(3333333333, "C6AE A155")]+ [InlineData(33333333, "1FC A055")]+ [InlineData(333333, "5 1615")]+ [InlineData(33333, "8235")]+ [InlineData(long.MinValue, "8000 0000 0000 0000")]+ [InlineData(long.MaxValue, "7FFF FFFF FFFF FFFF")]+ public void FormatHexadecimal(long input, string expectedResult)+ {+ Hexadecimal.Instance.ToFormattedString(input, true).Should().Be(expectedResult);+ }++ [Theory]+ [InlineData("8000 0000 0000 0000", long.MinValue)]+ [InlineData("7FFF FFFF FFFF FFFF", long.MaxValue)]+ public void ParseHexadecimal(string input, long expectedResult)+ {+ input = input.Replace(" ", string.Empty);+ Hexadecimal.Instance.Parse(input).Should().Be(expectedResult);+ }+}diff --git a/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/OctalTests.cs b/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/OctalTests.csnew file mode 100644index 000000000..c26007d2b--- /dev/null+++ b/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/OctalTests.cs@@ -0,0 +1,25 @@+using DevToys.Tools.Models.NumberBase;++namespace DevToys.UnitTests.Tools.Models.NumberBase;++public class OctalTests+{+ [Theory]+ [InlineData(206121044034, "2 777 561 304 102")]+ [InlineData(20612104403, "231 444 740 323")]+ [InlineData(long.MinValue, "1 000 000 000 000 000 000 000")]+ [InlineData(long.MaxValue, "777 777 777 777 777 777 777")]+ public void FormatDecimal(long input, string expectedResult)+ {+ Octal.Instance.ToFormattedString(input, true).Should().Be(expectedResult);+ }++ [Theory]+ [InlineData("1 000 000 000 000 000 000 000", long.MinValue)]+ [InlineData("777 777 777 777 777 777 777", long.MaxValue)]+ public void ParseHexadecimal(string input, long expectedResult)+ {+ input = input.Replace(" ", string.Empty);+ Octal.Instance.Parse(input).Should().Be(expectedResult);+ }+}diff --git a/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/RFC4648Base16Tests.cs b/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/RFC4648Base16Tests.csnew file mode 100644index 000000000..0cf58e1cb--- /dev/null+++ b/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/RFC4648Base16Tests.cs@@ -0,0 +1,23 @@+using DevToys.Tools.Models.NumberBase;++namespace DevToys.UnitTests.Tools.Models.NumberBase;++public class RFC4648Base16Tests+{+ [Theory]+ [InlineData(ulong.MinValue, "0")]+ [InlineData(ulong.MaxValue, "FFFF FFFF FFFF FFFF")]+ public void FormatRFC4648Base16(ulong input, string expectedResult)+ {+ RFC4648Base16.Instance.ToFormattedString(input, true).Should().Be(expectedResult);+ }++ [Theory]+ [InlineData("0", ulong.MinValue)]+ [InlineData("FFFF FFFF FFFF FFFF", ulong.MaxValue)]+ public void ParseRFC4648Base16(string input, ulong expectedResult)+ {+ input = input.Replace(" ", string.Empty);+ RFC4648Base16.Instance.Parse(input).Should().Be(expectedResult);+ }+}diff --git a/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/RFC4648Base32ExtendedHexTests.cs b/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/RFC4648Base32ExtendedHexTests.csnew file mode 100644index 000000000..e66c22a34--- /dev/null+++ b/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/RFC4648Base32ExtendedHexTests.cs@@ -0,0 +1,23 @@+using DevToys.Tools.Models.NumberBase;++namespace DevToys.UnitTests.Tools.Models.NumberBase;++public class RFC4648Base32ExtendedHexTests+{+ [Theory]+ [InlineData(ulong.MinValue, "0")]+ [InlineData(ulong.MaxValue, "F VVVV VVVV VVVV")]+ public void FormatRFC4648Base32ExtendedHex(ulong input, string expectedResult)+ {+ RFC4648Base32ExtendedHex.Instance.ToFormattedString(input, true).Should().Be(expectedResult);+ }++ [Theory]+ [InlineData("0", ulong.MinValue)]+ [InlineData("F VVVV VVVV VVVV", ulong.MaxValue)]+ public void ParseRFC4648Base32ExtendedHex(string input, ulong expectedResult)+ {+ input = input.Replace(" ", string.Empty);+ RFC4648Base32ExtendedHex.Instance.Parse(input).Should().Be(expectedResult);+ }+}diff --git a/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/RFC4648Base32Tests.cs b/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/RFC4648Base32Tests.csnew file mode 100644index 000000000..e04611910--- /dev/null+++ b/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/RFC4648Base32Tests.cs@@ -0,0 +1,23 @@+using DevToys.Tools.Models.NumberBase;++namespace DevToys.UnitTests.Tools.Models.NumberBase;++public class RFC4648Base32Tests+{+ [Theory]+ [InlineData(ulong.MinValue, "A")]+ [InlineData(ulong.MaxValue, "P 7777 7777 7777")]+ public void FormatRFC4648Base32(ulong input, string expectedResult)+ {+ RFC4648Base32.Instance.ToFormattedString(input, true).Should().Be(expectedResult);+ }++ [Theory]+ [InlineData("A", ulong.MinValue)]+ [InlineData("P 7777 7777 7777", ulong.MaxValue)]+ public void ParseRFC4648Base32(string input, ulong expectedResult)+ {+ input = input.Replace(" ", string.Empty);+ RFC4648Base32.Instance.Parse(input).Should().Be(expectedResult);+ }+}diff --git a/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/RFC4648Base64Tests.cs b/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/RFC4648Base64Tests.csnew file mode 100644index 000000000..1e87c4887--- /dev/null+++ b/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/RFC4648Base64Tests.cs@@ -0,0 +1,23 @@+using DevToys.Tools.Models.NumberBase;++namespace DevToys.UnitTests.Tools.Models.NumberBase;++public class RFC4648Base64Tests+{+ [Theory]+ [InlineData(ulong.MinValue, "A")]+ [InlineData(ulong.MaxValue, "P// //// ////")]+ public void FormatRFC4648Base64(ulong input, string expectedResult)+ {+ RFC4648Base64.Instance.ToFormattedString(input, true).Should().Be(expectedResult);+ }++ [Theory]+ [InlineData("A", ulong.MinValue)]+ [InlineData("P// //// ////", ulong.MaxValue)]+ public void ParseRFC4648Base64(string input, ulong expectedResult)+ {+ input = input.Replace(" ", string.Empty);+ RFC4648Base64.Instance.Parse(input).Should().Be(expectedResult);+ }+}diff --git a/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/RFC4648Base64UrlEncodeTests.cs b/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/RFC4648Base64UrlEncodeTests.csnew file mode 100644index 000000000..4136333b2--- /dev/null+++ b/src/app/tests/DevToys.UnitTests/Tools/Models/NumberBase/RFC4648Base64UrlEncodeTests.cs@@ -0,0 +1,23 @@+using DevToys.Tools.Models.NumberBase;++namespace DevToys.UnitTests.Tools.Models.NumberBase;++public class RFC4648Base64UrlEncodeTests+{+ [Theory]+ [InlineData(ulong.MinValue, "A")]+ [InlineData(ulong.MaxValue, "P__ ____ ____")]+ public void FormatRFC4648Base64UrlEncode(ulong input, string expectedResult)+ {+ RFC4648Base64UrlEncode.Instance.ToFormattedString(input, true).Should().Be(expectedResult);+ }++ [Theory]+ [InlineData("A", ulong.MinValue)]+ [InlineData("P__ ____ ____", ulong.MaxValue)]+ public void ParseRFC4648Base64UrlEncode(string input, ulong expectedResult)+ {+ input = input.Replace(" ", string.Empty);+ RFC4648Base64UrlEncode.Instance.Parse(input).Should().Be(expectedResult);+ }+}