public void Test_ConstructorLjava_lang_String() { NumberFormatException e = new NumberFormatException("fixture"); Junit.Framework.Assert.AssertEquals("fixture", e.Message); Junit.Framework.Assert.AssertNull(e.InnerException); }
/// <summary> /// Parses the string argument as if it was an <see cref="int"/> value and returns the /// result. Throws <see cref="FormatException"/> if the string does not represent an /// <see cref="int"/> quantity. The second argument specifies the radix to use when parsing /// the value. /// <para/> /// NOTE: This was parseInt() in Lucene /// </summary> /// <param name="chars"> A string representation of an int quantity. </param> /// <param name="radix"> The base to use for conversion. </param> /// <returns> The value represented by the argument </returns> /// <exception cref="FormatException"> If the argument could not be parsed as an int quantity. </exception> public static int ParseInt32(char[] chars, int offset, int len, int radix) { int minRadix = 2, maxRadix = 36; if (chars is null || radix < minRadix || radix > maxRadix) { throw NumberFormatException.Create(); } int i = 0; if (len == 0) { throw NumberFormatException.Create("chars length is 0"); } bool negative = chars[offset + i] == '-'; if (negative && ++i == len) { throw NumberFormatException.Create("can't convert to an int"); } if (negative == true) { offset++; len--; } return(Parse(chars, offset, len, radix, negative)); }
public void Test_Constructor() { NumberFormatException e = new NumberFormatException(); Junit.Framework.Assert.AssertNull(e.Message); Junit.Framework.Assert.AssertNull(e.Message); Junit.Framework.Assert.AssertNull(e.InnerException); }
/// <summary> /// Converts a hex string at the specified index and length of <paramref name="hex"/> /// into an <see cref="int"/>. /// <para/> /// NOTE: This was hexToInt() in Lucene /// </summary> /// <param name="hex"> /// A string in capital or lower case hex, of no more then 16 /// characters. /// </param> /// <param name="startIndex">The index of the first character to begin parsing.</param> /// <param name="length">The number of characters to parse.</param> /// <exception cref="FormatException">if the string is more than 16 characters long, or if any /// character is not in the set [0-9a-fA-f]</exception> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="startIndex"/> or <paramref name="length"/> is less than zero. /// <para/> /// -or- /// <para/> /// <paramref name="startIndex"/> and <paramref name="length"/> refer to a location outside of <paramref name="hex"/>. /// </exception> // LUCENENET specific overload public static int HexToInt32(string hex, int startIndex, int length) { if ((length > 16) || !Integer.TryParse(hex, startIndex, length, radix: 16, out int result)) { throw NumberFormatException.Create(); } return(result); }
public static int GetPrefixCodedInt32Shift(BytesRef val) { int shift = val.Bytes[val.Offset] - SHIFT_START_INT32; if (shift > 31 || shift < 0) { throw NumberFormatException.Create("Invalid shift value in prefixCoded bytes (is encoded value really an INT?)"); } return(shift); }
/// <summary> /// Returns an <see cref="int"/> from prefixCoded bytes. /// Rightmost bits will be zero for lower precision codes. /// This method can be used to decode a term's value. /// <para/> /// NOTE: This was prefixCodedToInt() in Lucene /// </summary> /// <exception cref="FormatException"> if the supplied <see cref="BytesRef"/> is /// not correctly prefix encoded. </exception> /// <seealso cref="Int32ToPrefixCodedBytes(int, int, BytesRef)"/> public static int PrefixCodedToInt32(BytesRef val) { long sortableBits = 0; for (int i = val.Offset, limit = val.Offset + val.Length; i < limit; i++) { sortableBits <<= 7; var b = val.Bytes[i]; if (b < 0) { throw NumberFormatException.Create("Invalid prefixCoded numerical value representation (byte " + (b & 0xff).ToString("x") + " at position " + (i - val.Offset) + " is invalid)"); } sortableBits |= b; } return((int)((sortableBits << GetPrefixCodedInt32Shift(val)) ^ 0x80000000)); }
/// <summary> /// Returns a <see cref="long"/> from prefixCoded bytes. /// Rightmost bits will be zero for lower precision codes. /// This method can be used to decode a term's value. /// <para/> /// NOTE: This was prefixCodedToLong() in Lucene /// </summary> /// <exception cref="FormatException"> if the supplied <see cref="BytesRef"/> is /// not correctly prefix encoded. </exception> /// <seealso cref="Int64ToPrefixCodedBytes(long, int, BytesRef)"/> public static long PrefixCodedToInt64(BytesRef val) { long sortableBits = 0L; for (int i = val.Offset + 1, limit = val.Offset + val.Length; i < limit; i++) { sortableBits <<= 7; var b = val.Bytes[i]; if (b < 0) { throw NumberFormatException.Create("Invalid prefixCoded numerical value representation (byte " + (b & 0xff).ToString("x") + " at position " + (i - val.Offset) + " is invalid)"); } sortableBits |= (byte)b; } return((long)((ulong)(sortableBits << GetPrefixCodedInt64Shift(val)) ^ 0x8000000000000000L)); // LUCENENET TODO: Is the casting here necessary? }
/// <summary> /// Converts a hex string into an <see cref="int"/>. /// <para/> /// NOTE: This was hexToInt() in Lucene /// </summary> /// <param name="hex"> /// A string in capital or lower case hex, of no more then 16 /// characters. /// </param> /// <exception cref="FormatException">if the string is more than 16 characters long, or if any /// character is not in the set [0-9a-fA-f]</exception> public static int HexToInt32(string hex) { int len = hex.Length; if (len > 16) { throw NumberFormatException.Create(); } try { // LUCENENET NOTE: Convert.ToInt32(string, int) throws a // FormatException if the character does not fall in // the correct range, which is the behavior we are expecting. // But throws an ArgumentException if passed a negative number. // So we need to convert to FormatException to provide the correct behavior. return(Convert.ToInt32(hex, 16)); } catch (ArgumentException e) { throw NumberFormatException.Create(e); } }
private static int Parse(char[] chars, int offset, int len, int radix, bool negative) { int max = int.MinValue / radix; int result = 0; for (int i = 0; i < len; i++) { int digit = (int)char.GetNumericValue(chars[i + offset]); if (digit == -1) { throw NumberFormatException.Create("Unable to parse"); } if (max > result) { throw NumberFormatException.Create("Unable to parse"); } int next = result * radix - digit; if (next > result) { throw NumberFormatException.Create("Unable to parse"); } result = next; } /*while (offset < len) { * }*/ if (!negative) { result = -result; if (result < 0) { throw NumberFormatException.Create("Unable to parse"); } } return(result); }