public void TestInvalidConversionInvalidInt(string s)
{
Assert.Throws <FormatException>(() => SFDataConverter.ConvertToCSharpVal(s, SFDataType.FIXED, typeof(Int32)));
Assert.Throws <FormatException>(() => SFDataConverter.ConvertToCSharpVal(s, SFDataType.FIXED, typeof(Int64)));
Assert.Throws <FormatException>(() => SFDataConverter.ConvertToCSharpVal(s, SFDataType.FIXED, typeof(Int16)));
Assert.Throws <FormatException>(() => SFDataConverter.ConvertToCSharpVal(s, SFDataType.FIXED, typeof(byte)));
}
public void TestConvertToDecimal(string s)
{
decimal actual = (decimal)SFDataConverter.ConvertToCSharpVal(s, SFDataType.FIXED, typeof(decimal));
decimal expected = Convert.ToDecimal(s, CultureInfo.InvariantCulture);
Assert.AreEqual(expected, actual);
}
public void TestConvertToByte(string s)
{
byte actual = (byte)SFDataConverter.ConvertToCSharpVal(s, SFDataType.FIXED, typeof(byte));
byte expected = Convert.ToByte(s);
Assert.AreEqual(expected, actual);
}
public void TestConvertToInt16(string s)
{
Int16 actual = (Int16)SFDataConverter.ConvertToCSharpVal(s, SFDataType.FIXED, typeof(Int16));
Int16 expected = Convert.ToInt16(s);
Assert.AreEqual(expected, actual);
}
private void internalTestConvertDate(DateTime dtExpected, DateTime testValue)
{
var result = SFDataConverter.csharpTypeValToSfTypeVal(System.Data.DbType.Date, testValue);
// Convert result to DateTime for easier interpretation
var unixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
DateTime dtResult = unixEpoch.AddMilliseconds(Int64.Parse(result.Item2));
Assert.AreEqual(dtExpected, dtResult);
}
public void TestConvertToFloat(string s)
{
double actualDouble = (double)SFDataConverter.ConvertToCSharpVal(s, SFDataType.FIXED, typeof(double));
double expectedDoulbe = Convert.ToDouble(s, CultureInfo.InvariantCulture);
Assert.AreEqual(actualDouble, expectedDoulbe);
float actualFloat = (float)SFDataConverter.ConvertToCSharpVal(s, SFDataType.FIXED, typeof(float));
float expectedFloat = Convert.ToSingle(s, CultureInfo.InvariantCulture);
Assert.AreEqual(expectedFloat, actualFloat);
}
public void TestConvertBindToSFValFinlandLocale()
{
Thread testThread = new Thread(() =>
{
CultureInfo ci = new CultureInfo("en-FI");
Thread.CurrentThread.CurrentCulture = ci;
System.Tuple <string, string> t =
SFDataConverter.csharpTypeValToSfTypeVal(System.Data.DbType.Double, 1.2345);
Assert.AreEqual("REAL", t.Item1);
Assert.AreEqual("1.2345", t.Item2);
});
testThread.Start();
testThread.Join();
}
public void TestConvertDatetime(string inputTimeStr)
{
DateTime inputTime;
if (inputTimeStr == null)
{
inputTime = DateTime.Now;
}
else
{
inputTime = DateTime.ParseExact(inputTimeStr, "yyyy-MM-dd HH:mm:ss.fffffff", CultureInfo.InvariantCulture);
}
var unixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
var tickDiff = inputTime.Ticks - unixEpoch.Ticks;
var inputStringAsItWasFromDatabase = (tickDiff / 10000000.0m).ToString(CultureInfo.InvariantCulture);
var result = SFDataConverter.ConvertToCSharpVal(inputStringAsItWasFromDatabase, SFDataType.TIMESTAMP_NTZ, typeof(DateTime));
Assert.AreEqual(inputTime, result);
}
public void TestInvalidConversionInvalidDecimal(string s)
{
Assert.Throws <FormatException>(() => SFDataConverter.ConvertToCSharpVal(s, SFDataType.FIXED, typeof(decimal)));
}
public void TestInvalidConversionInvalidFloat(string s)
{
Assert.Throws <FormatException>(() => SFDataConverter.ConvertToCSharpVal(s, SFDataType.FIXED, typeof(float)));
Assert.Throws <FormatException>(() => SFDataConverter.ConvertToCSharpVal(s, SFDataType.FIXED, typeof(double)));
}
public void TestOverflowInt64(string s)
{
Assert.Throws <OverflowException>(() => SFDataConverter.ConvertToCSharpVal(s, SFDataType.FIXED, typeof(Int64)));
}
private Dictionary <string, BindingDTO> convertToBindList(List <SnowflakeDbParameter> parameters)
{
if (parameters == null || parameters.Count == 0)
{
return(null);
}
else
{
Dictionary <string, BindingDTO> binding = new Dictionary <string, BindingDTO>();
foreach (SnowflakeDbParameter parameter in parameters)
{
string bindingType = "";
object bindingVal;
if (parameter.Value.GetType().IsArray&&
// byte array and char array will not be treated as array binding
parameter.Value.GetType().GetElementType() != typeof(char) &&
parameter.Value.GetType().GetElementType() != typeof(byte))
{
List <object> vals = new List <object>();
foreach (object val in (Array)parameter.Value)
{
// if the user is using interface, SFDataType will be None and there will
// a conversion from DbType to SFDataType
// if the user is using concrete class, they should specify SFDataType.
if (parameter.SFDataType == SFDataType.None)
{
Tuple <string, string> typeAndVal = SFDataConverter
.csharpTypeValToSfTypeVal(parameter.DbType, val);
bindingType = typeAndVal.Item1;
vals.Add(typeAndVal.Item2);
}
else
{
bindingType = parameter.SFDataType.ToString();
vals.Add(SFDataConverter.csharpValToSfVal(parameter.SFDataType, val));
}
}
bindingVal = vals;
}
else
{
if (parameter.SFDataType == SFDataType.None)
{
Tuple <string, string> typeAndVal = SFDataConverter
.csharpTypeValToSfTypeVal(parameter.DbType, parameter.Value);
bindingType = typeAndVal.Item1;
bindingVal = typeAndVal.Item2;
}
else
{
bindingType = parameter.SFDataType.ToString();
bindingVal = SFDataConverter.csharpValToSfVal(parameter.SFDataType, parameter.Value);
}
}
binding[parameter.ParameterName] = new BindingDTO(bindingType, bindingVal);
}
return(binding);
}
}
public void TestConvertBoolean(string inputBooleanString, bool expected)
{
var actual = SFDataConverter.ConvertToCSharpVal(inputBooleanString, SFDataType.BOOLEAN, typeof(bool));
Assert.AreEqual(expected, actual);
}
