public void Boolean__(string input, string expected)
{
object result;
bool parsed = Parser.TryParse(input, typeof(bool), out result);
Assert.True(parsed); // boolean always parses
string back = Parser.ToRawString(result);
Assert.Equal(expected, back);
}
public void ToRawString_WhenInputIsValid_ReturnValidString(string rawValue)
{
object outValObj;
if (rawValue != null)
{
Assert.True(TypeParser.TryParse(rawValue, typeof(string[]), out outValObj));
}
else
{
Assert.False(TypeParser.TryParse(null, typeof(string[]), out outValObj));
}
Assert.Equal(rawValue, TypeParser.ToRawString(outValObj as string[]));
}
public void ToRawString_WhenInputIsValid_ReturnValidString(string rawValue)
{
object outValObj;
long outVal;
Assert.True(TypeParser.TryParse(rawValue, typeof(long), out outValObj));
outVal = (long)outValObj;
Assert.Equal(rawValue, TypeParser.ToRawString(outVal));
}
public void ToNetworkCredential_WhenInputIsValid_ReturnValidStringCredentials(string rawValue)
{
object creds = null;
Assert.True(TypeParser.TryParse(rawValue, typeof(NetworkCredential), out creds));
var networkCredentials = (NetworkCredential)creds;
Assert.Equal("user", networkCredentials.UserName);
Assert.Equal("pass", networkCredentials.Password);
Assert.Equal("domain", networkCredentials.Domain);
}
public void ToRawString_WhenInputIsValid_ReturnValidString(string rawValue)
{
object outValObj;
double outVal;
Assert.True(TypeParser.TryParse(rawValue, typeof(double), out outValObj));
outVal = (double)outValObj;
string actual = TypeParser.ToRawString(outVal);
Assert.True(rawValue == actual, $"{rawValue} != {actual}");
}
public void ToRawString_WhenInputIsValid_ReturnValidString(string rawValue)
{
object outValObj;
byte outVal;
Assert.True(TypeParser.TryParse(rawValue, typeof(byte), out outValObj));
outVal = (byte)outValObj;
if (rawValue.StartsWith("0x"))
{
Assert.Equal(rawValue, "0x" + outVal.ToString("X2"));
}
else
{
Assert.Equal(rawValue, TypeParser.ToRawString(outVal));
}
}
public void ParseTwoWays_Variable_Variable()
{
var date = DateTime.UtcNow;
string s = TypeParser.ToRawString(date);
object date1Obj;
DateTime date1;
bool parsed = TypeParser.TryParse(s, typeof(DateTime), out date1Obj);
Assert.True(parsed);
Assert.NotNull(date1Obj);
date1 = (DateTime)date1Obj;
Assert.True(parsed);
Assert.Equal(date.RoundToDay(), date1.RoundToDay());
}
/// <summary>
/// Reads the option value
/// </summary>
/// <typeparam name="T">Option type</typeparam>
/// <param name="option">Option reference</param>
/// <returns>Option value</returns>
public T Read <T>(Option <T> option)
{
CheckConfigured();
CheckCanParse(option.NonNullableType);
OptionValue optionValue;
_nameToOptionValue.TryGetValue(option.Name, out optionValue);
if (!optionValue.IsExpired(_config.CacheTimeout))
{
return((T)optionValue.RawValue);
}
string value = ReadFirstValue(option.Name);
if (value == null)
{
optionValue.RawValue = option.DefaultValue;
}
else if (DefaultParser.IsSupported(option.NonNullableType))
{
object resultObject;
if (DefaultParser.TryParse(value, option.NonNullableType, out resultObject))
{
optionValue.Update <T>((T)resultObject);
}
else
{
optionValue.Update(option.DefaultValue);
}
}
else
{
ITypeParser typeParser = _config.GetParser(option.NonNullableType);
object result;
typeParser.TryParse(value, option.NonNullableType, out result);
optionValue.Update <T>((T)result);
}
OnReadOption(option, optionValue.RawValue);
return((T)optionValue.RawValue);
}
public bool TryParse(Type propertyType, string rawValue, out object result)
{
if (_defaultParser.IsSupported(propertyType)) //type here must be a non-nullable one
{
if (!_defaultParser.TryParse(rawValue, propertyType, out result))
{
return(false);
}
}
else
{
ITypeParser typeParser = GetParser(propertyType);
if (!typeParser.TryParse(rawValue, propertyType, out result))
{
return(false);
}
}
return(true);
}
public void ToRawString_WhenInputIsValid_ReturnValidString(string rawValue, string expected = null)
{
if (expected == null)
{
expected = rawValue;
}
bool parsed = TypeParser.TryParse(rawValue, typeof(string[]), out object outValObj);
if (rawValue != null)
{
Assert.True(parsed);
}
else
{
Assert.False(parsed);
}
Assert.Equal(expected, TypeParser.ToRawString(outValObj as string[]));
}