static Converter()
{
BoolConverter.Initialize();
CharConverter.Initialize();
ByteConverter.Initialize();
SByteConverter.Initialize();
Int16Converter.Initialize();
UInt16Converter.Initialize();
Int32Converter.Initialize();
UInt32Converter.Initialize();
Int64Converter.Initialize();
UInt64Converter.Initialize();
SingleConverter.Initialize();
DoubleConverter.Initialize();
DecimalConverter.Initialize();
BigIntegerConverter.Initialize();
BytesConverter.Initialize();
CharsConverter.Initialize();
StringConverter.Initialize();
StringBuilderConverter.Initialize();
DateTimeConverter.Initialize();
TimeSpanConverter.Initialize();
GuidConverter.Initialize();
MemoryStreamConverter.Initialize();
StreamConverter.Initialize();
}
public void PropertiesTest()
{
var converter = new Int64Converter();
Assert.AreEqual(true, converter.AcceptsNativeType);
Assert.AreEqual(typeof(long), converter.ConvertedType);
}
public override void Encode(ulong obj, PacketData data)
{
Int64Converter conv = obj;
var pos = data.Position;
var bytes = data.Data;
if (BitConverter.IsLittleEndian)
{
bytes[pos] = conv.Byte0;
bytes[pos + 1] = conv.Byte1;
bytes[pos + 2] = conv.Byte2;
bytes[pos + 3] = conv.Byte3;
bytes[pos + 4] = conv.Byte4;
bytes[pos + 5] = conv.Byte5;
bytes[pos + 6] = conv.Byte6;
bytes[pos + 7] = conv.Byte7;
}
else
{
bytes[pos + 7] = conv.Byte0;
bytes[pos + 6] = conv.Byte1;
bytes[pos + 5] = conv.Byte2;
bytes[pos + 4] = conv.Byte3;
bytes[pos + 3] = conv.Byte4;
bytes[pos + 2] = conv.Byte5;
bytes[pos + 1] = conv.Byte6;
bytes[pos] = conv.Byte7;
}
data.ShiftPosition(ByteSize);
}
/// <summary>
/// Extends ConvertTo so that methods that return a specific type object given a Type parameter can be
/// used as generic method and casting is not required.
/// <example>
/// typeconverter.ConvertTo<int>(value);
/// </example>
/// </summary>
public static T ConvertTo <T>(this Int64Converter typeconverter, Object value)
{
if (typeconverter == null)
{
throw new ArgumentNullException("typeconverter");
}
return((T)typeconverter.ConvertTo(value, typeof(T)));
}
/// <summary>
/// Extends ConvertTo so that methods that return a specific type object given a Type parameter can be
/// used as generic method and casting is not required.
/// <example>
/// basenumberconverter.ConvertTo<int>(context, culture, value);
/// </example>
/// </summary>
public static T ConvertTo <T>(this Int64Converter basenumberconverter, ITypeDescriptorContext context, System.Globalization.CultureInfo culture, Object value)
{
if (basenumberconverter == null)
{
throw new ArgumentNullException("basenumberconverter");
}
return((T)basenumberconverter.ConvertTo(context, culture, value, typeof(T)));
}
public void TargetType()
{
// Arrange
IConverter converter = new Int64Converter();
var expectedType = typeof(Int64);
// Act
var actualType = converter.TargetType;
// Assert
Assert.Equal(expectedType, actualType);
}
private JsonFxAOT()
{
TypeConverter c;
c = new ArrayConverter();
m_fakeFlag = c.Equals(c);
//c = new BaseNumberConverter();
//m_fakeFlag = c.Equals(c);
c = new BooleanConverter();
m_fakeFlag = c.Equals(c);
c = new ByteConverter();
m_fakeFlag = c.Equals(c);
c = new CollectionConverter();
m_fakeFlag = c.Equals(c);
c = new ComponentConverter(typeof(int));
m_fakeFlag = c.Equals(c);
c = new CultureInfoConverter();
m_fakeFlag = c.Equals(c);
c = new DateTimeConverter();
m_fakeFlag = c.Equals(c);
c = new DecimalConverter();
m_fakeFlag = c.Equals(c);
c = new DoubleConverter();
m_fakeFlag = c.Equals(c);
c = new EnumConverter(typeof(int));
m_fakeFlag = c.Equals(c);
c = new ExpandableObjectConverter();
m_fakeFlag = c.Equals(c);
c = new Int16Converter();
m_fakeFlag = c.Equals(c);
c = new Int32Converter();
m_fakeFlag = c.Equals(c);
c = new Int64Converter();
m_fakeFlag = c.Equals(c);
c = new NullableConverter(typeof(object));
m_fakeFlag = c.Equals(c);
c = new SByteConverter();
m_fakeFlag = c.Equals(c);
c = new SingleConverter();
m_fakeFlag = c.Equals(c);
c = new StringConverter();
m_fakeFlag = c.Equals(c);
c = new TimeSpanConverter();
m_fakeFlag = c.Equals(c);
c = new UInt16Converter();
m_fakeFlag = c.Equals(c);
c = new UInt32Converter();
m_fakeFlag = c.Equals(c);
c = new UInt64Converter();
m_fakeFlag = c.Equals(c);
}
public void Conversion()
{
// Arrange
IConverter converter = new Int64Converter();
var value = "42";
Int64 expectedValue = 42;
// Act
var actualValue = converter.Convert(value, converter.TargetType);
// Assert
Assert.NotNull(actualValue);
Assert.IsType <Int64>(actualValue);
Assert.Equal(expectedValue, (Int64)actualValue);
}
public void t()
{
DateTime dt = DateTime.Now;
long ticks = dt.Ticks;
Int64Converter c = new Int64Converter();
byte[] bs = c.ConvertToBytes(ticks);
long t2 = (long)c.ConvertToObject(bs);
Assert.AreEqual(ticks, t2);
DateTime dt2 = new DateTime(t2);
Assert.AreEqual(dt, dt2);
}
public void t()
{
DateTime dt = DateTime.Now;
long ticks = dt.Ticks;
Int64Converter c = new Int64Converter();
byte[] bs = c.ConvertToBytes(ticks);
long t2 = (long)c.ConvertToObject(bs);
Assert.AreEqual(ticks, t2);
DateTime dt2 = new DateTime(t2);
Assert.AreEqual(dt, dt2);
}
/// <summary>
/// Tries to parse a 64-bit integer from a string. This method should handle hexadecimal values
/// as well as normal values.
/// </summary>
/// <param name="value">The string value to parse.</param>
/// <param name="result">The parsed integer, if the string was valid. If invalid, this
/// will be the default integer value.</param>
/// <returns>True if the conversion was successful; otherwise returns false.</returns>
public static bool TryParseEx(string value, out long result)
{
bool canConvert = true;
try
{
var converter = new Int64Converter();
result = (long)converter.ConvertFromString(value);
}
catch (Exception)
{
result = default(long);
canConvert = false;
}
return(canConvert);
}
public int GetIntFromSecret(string secret)
{
Int64 num1;
string num = "";
int numSpaces = 0;
for (int j = 0; j < secret.Length; j++)
{
if (secret[j] == ' ')
numSpaces++;
if (secret[j] >= '0' && secret[j] <= '9')
{
num += secret[j];
}
}
Int64Converter t = new Int64Converter();
num1 = Int64.Parse(num) / numSpaces;
return (int)num1;
}
public void BadValueConversion()
{
// Arrange
IConverter converter = new Int64Converter();
var value = "Hello";
var expectedExceptionMessage = Constants.ExceptionMessages.FormatConverterUnableConvert(value, typeof(long));
var expectedInnerExceptionMessage = "Input string was not in a correct format.";
// Act
using (new LangageSwitcher("en-us"))
{
var actualException =
Assert.Throws <CommandLineParserException>(() => converter.Convert(value, converter.TargetType));
// Assert
Assert.Equal(expectedExceptionMessage, actualException.Message);
Assert.NotNull(actualException.InnerException);
var actualInnerExecption = Assert.IsAssignableFrom <FormatException>(actualException.InnerException);
Assert.Equal(expectedInnerExceptionMessage, actualInnerExecption.Message);
}
}
public void ConvertFromExcelTest()
{
var converter = new Int64Converter();
var typeConverterOptions = new TypeConverterOptions {
CultureInfo = CultureInfo.CurrentCulture
};
Assert.AreEqual((long)123, converter.ConvertFromExcel(typeConverterOptions, (double)123));
Assert.AreEqual((long)123, converter.ConvertFromExcel(typeConverterOptions, "123"));
Assert.AreEqual((long)123, converter.ConvertFromExcel(typeConverterOptions, " 123 "));
Assert.AreEqual((long)0, converter.ConvertFromExcel(typeConverterOptions, null));
typeConverterOptions.NumberStyle = NumberStyles.HexNumber;
Assert.AreEqual((long)0x123, converter.ConvertFromExcel(typeConverterOptions, "123"));
try {
converter.ConvertFromExcel(typeConverterOptions, "");
Assert.Fail();
} catch (ExcelTypeConverterException) {
}
}
internal object ConvertToType(Type type, object obj)
{
if (obj == null)
{
return(null);
}
if (obj is IDictionary <string, object> )
{
if (type == null)
{
obj = EvaluateDictionary((IDictionary <string, object>)obj);
}
else
{
JavaScriptConverter converter = GetConverter(type);
if (converter != null)
{
return(converter.Deserialize(
EvaluateDictionary((IDictionary <string, object>)obj),
type, this));
}
}
return(ConvertToObject((IDictionary <string, object>)obj, type));
}
if (obj is IEnumerable <object> )
{
return(ConvertToList((IEnumerable <object>)obj, type));
}
if (type == null)
{
return(obj);
}
Type sourceType = obj.GetType();
if (type.IsAssignableFrom(sourceType))
{
return(obj);
}
if (type.IsEnum)
{
return(Enum.ToObject(type, obj));
}
TypeConverter c = null;
try {
c = TypeDescriptor.GetConverter(type);
} catch (Exception) {
if (type.FullName == "System.Int32")
{
c = new Int32Converter();
// int
}
else if (type.FullName == "System.Int64")
{
c = new Int64Converter();
// long
}
else if (type.FullName == "System.Single")
{
c = new SingleConverter();
// float
}
else if (type.FullName == "System.Double")
{
c = new DoubleConverter();
// float
}
else if (type.FullName == "System.Boolean")
{
c = new BooleanConverter();
// bool
}
else if (type.FullName == "System.Byte")
{
c = new ByteConverter();
}
}
if (c.CanConvertFrom(sourceType))
{
if (obj is string)
{
return(c.ConvertFromInvariantString((string)obj));
}
return(c.ConvertFrom(obj));
}
/*
* Take care of the special case whereas in JSON an empty string ("") really means
* an empty value
* (see: https://bugzilla.novell.com/show_bug.cgi?id=328836)
*/
if ((type.IsGenericType) && (type.GetGenericTypeDefinition() == typeof(Nullable <>)))
{
string s = obj as String;
if (String.IsNullOrEmpty(s))
{
return(null);
}
}
return(Convert.ChangeType(obj, type));
}
public void SetUp()
{
converter = new Int64Converter();
}
internal static TypeConverter GetCoreConverterFromCustomType(Type type)
{
TypeConverter result = null;
if (type.IsEnum)
{
result = new EnumConverter(type);
}
else if (typeof(int).IsAssignableFrom(type))
{
result = new Int32Converter();
}
else if (typeof(short).IsAssignableFrom(type))
{
result = new Int16Converter();
}
else if (typeof(long).IsAssignableFrom(type))
{
result = new Int64Converter();
}
else if (typeof(uint).IsAssignableFrom(type))
{
result = new UInt32Converter();
}
else if (typeof(ushort).IsAssignableFrom(type))
{
result = new UInt16Converter();
}
else if (typeof(ulong).IsAssignableFrom(type))
{
result = new UInt64Converter();
}
else if (typeof(bool).IsAssignableFrom(type))
{
result = new BooleanConverter();
}
else if (typeof(double).IsAssignableFrom(type))
{
result = new DoubleConverter();
}
else if (typeof(float).IsAssignableFrom(type))
{
result = new SingleConverter();
}
else if (typeof(byte).IsAssignableFrom(type))
{
result = new ByteConverter();
}
else if (typeof(sbyte).IsAssignableFrom(type))
{
result = new SByteConverter();
}
else if (typeof(char).IsAssignableFrom(type))
{
result = new CharConverter();
}
else if (typeof(decimal).IsAssignableFrom(type))
{
result = new DecimalConverter();
}
else if (typeof(TimeSpan).IsAssignableFrom(type))
{
result = new TimeSpanConverter();
}
else if (typeof(Guid).IsAssignableFrom(type))
{
result = new GuidConverter();
}
else if (typeof(string).IsAssignableFrom(type))
{
result = new StringConverter();
}
else if (typeof(CultureInfo).IsAssignableFrom(type))
{
result = new CultureInfoConverter();
}
else if (typeof(Type).IsAssignableFrom(type))
{
result = new TypeTypeConverter();
}
else if (typeof(DateTime).IsAssignableFrom(type))
{
result = new DateTimeConverter2();
}
return(result);
}
private static TypeConverter GetCoreConverterFromCoreType(Type type)
{
TypeConverter result = null;
if (type == typeof(int))
{
result = new Int32Converter();
}
else if (type == typeof(short))
{
result = new Int16Converter();
}
else if (type == typeof(long))
{
result = new Int64Converter();
}
else if (type == typeof(uint))
{
result = new UInt32Converter();
}
else if (type == typeof(ushort))
{
result = new UInt16Converter();
}
else if (type == typeof(ulong))
{
result = new UInt64Converter();
}
else if (type == typeof(bool))
{
result = new BooleanConverter();
}
else if (type == typeof(double))
{
result = new DoubleConverter();
}
else if (type == typeof(float))
{
result = new SingleConverter();
}
else if (type == typeof(byte))
{
result = new ByteConverter();
}
else if (type == typeof(sbyte))
{
result = new SByteConverter();
}
else if (type == typeof(char))
{
result = new CharConverter();
}
else if (type == typeof(decimal))
{
result = new DecimalConverter();
}
else if (type == typeof(TimeSpan))
{
result = new TimeSpanConverter();
}
else if (type == typeof(Guid))
{
result = new GuidConverter();
}
else if (type == typeof(string))
{
result = new StringConverter();
}
else if (type == typeof(CultureInfo))
{
result = new CultureInfoConverter();
}
else if (type == typeof(Type))
{
result = new TypeTypeConverter();
}
else if (type == typeof(DateTime))
{
result = new DateTimeConverter2();
}
else if (ReflectionHelper.IsNullableType(type))
{
result = new NullableConverter(type);
}
return(result);
}
public ValueName(UdsReader udsReader, string[] lineArray)
{
LineArray = lineArray;
if (lineArray.Length >= 5)
{
try
{
string textMin = lineArray[1];
if (textMin.Length >= 2 && textMin.Length % 2 == 0 && !textMin.StartsWith("0x") && textMin.StartsWith("0"))
{
if (Int64.TryParse(textMin, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out Int64 minValue))
{
MinValue = minValue;
}
}
else
{
if (textMin.Length < 34)
{
object valueObjMin = new Int64Converter().ConvertFromInvariantString(textMin);
if (valueObjMin != null)
{
MinValue = (Int64)valueObjMin;
}
}
}
}
catch (Exception)
{
// ignored
}
try
{
string textMax = lineArray[2];
if (textMax.Length >= 2 && textMax.Length % 2 == 0 && !textMax.StartsWith("0x") && textMax.StartsWith("0"))
{
if (Int64.TryParse(textMax, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out Int64 maxValue))
{
MaxValue = maxValue;
}
}
else
{
if (textMax.Length < 34)
{
object valueObjMax = new Int64Converter().ConvertFromInvariantString(textMax);
if (valueObjMax != null)
{
MaxValue = (Int64)valueObjMax;
}
}
}
}
catch (Exception)
{
// ignored
}
if (UInt32.TryParse(lineArray[3], NumberStyles.Integer, CultureInfo.InvariantCulture, out UInt32 valueNameKey))
{
if (udsReader._textMap.TryGetValue(valueNameKey, out string[] nameValueArray))