Skip to content

A Swiss Army knife for developers.

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.csproj
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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&apos;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.resx
new file mode 100644
index 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 file
diff --git a/src/app/dev/DevToys.Tools/Tools/Converters/NumberBase/NumberBaseConverterCommandLineTool.cs b/src/app/dev/DevToys.Tools/Tools/Converters/NumberBase/NumberBaseConverterCommandLineTool.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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);
+ }
+}