public void SequenceValueStorage_Create_SupportsNullableDateTime()
{
DateTime?date = DateTime.Now;
var storage = ValueStorageExtensions.CreateFromObject(date);
Assert.True(storage.Type == ValueTypeEnum.DateTime);
Assert.Equal(date.Value, storage.AsDateTime);
}
/// <summary>
/// Ported from explicit value_t(const string& val, bool literal = false)
/// </summary>
public static Value Get(string value, bool literal = false)
{
if (literal)
{
return(new Value(ValueStorageExtensions.Create(value ?? String.Empty)));
}
else
{
return(Get(new Amount(value)));
}
}
public void ValueStorageExtensions_CreateFromObject_ClonesSequences()
{
IList <Value> sequence = new List <Value>();
var storage = ValueStorageExtensions.CreateFromObject(sequence);
IList <Value> newSequence = storage.AsSequence;
newSequence.Add(Value.One);
Assert.Single(newSequence);
Assert.Empty(sequence);
}
public void ValueStorageExtensions_CreateFromObject_ClonesBalances()
{
Balance balance = new Balance();
var storage = ValueStorageExtensions.CreateFromObject(balance);
Balance newBalance = storage.AsBalance;
newBalance.Add(new Amount(15));
Assert.Single(newBalance.Amounts);
Assert.Empty(balance.Amounts);
}
public void ValueStorageExtensions_CreateFromObject_ClonesAmounts()
{
Amount amount = new Amount(10);
var storage = ValueStorageExtensions.CreateFromObject(amount);
Amount newAmount = storage.AsAmount;
newAmount.Multiply(new Amount(15));
Assert.Equal(150, newAmount.Quantity.ToLong());
Assert.Equal(10, amount.Quantity.ToLong());
}
public void ValueStorageExtensions_CreateFromObject_ClonesSequences()
{
IList <Value> sequence = new List <Value>();
var storage = ValueStorageExtensions.CreateFromObject(sequence);
IList <Value> newSequence = storage.AsSequence;
newSequence.Add(Value.One);
Assert.AreEqual(1, newSequence.Count());
Assert.AreEqual(0, sequence.Count());
}
public void ValueStorageExtensions_CreateFromObject_ClonesBalances()
{
Balance balance = new Balance();
var storage = ValueStorageExtensions.CreateFromObject(balance);
Balance newBalance = storage.AsBalance;
newBalance.Add(new Amount(15));
Assert.AreEqual(1, newBalance.Amounts.Count());
Assert.AreEqual(0, balance.Amounts.Count());
}
public void PushFront(Value val)
{
if (Storage == null)
{
Storage = ValueStorageExtensions.Create(new List <Value>());
}
if (Storage.Type != ValueTypeEnum.Sequence)
{
Storage = ValueStorageExtensions.Create(Storage.AsSequence);
}
AsSequence.Insert(0, val);
}
public void PushBack(Value val)
{
if (Storage == null)
{
Storage = ValueStorageExtensions.Create(new List <Value>());
}
if (Storage.Type != ValueTypeEnum.Sequence)
{
Storage = ValueStorageExtensions.Create(Storage.AsSequence);
}
AsSequence.Add(val);
}
public void ValueStorageExtensions_Create_CreatesStorageInstancesByTypes()
{
IValueStorage value;
value = ValueStorageExtensions.Create(true);
Assert.True(value is BooleanValueStorage);
Assert.True(value.AsBoolean);
value = ValueStorageExtensions.Create(new DateTime(2010, 10, 10));
Assert.True(value is DateTimeValueStorage);
Assert.Equal(new DateTime(2010, 10, 10), value.AsDateTime);
value = ValueStorageExtensions.Create((int)100);
Assert.True(value is IntegerValueStorage);
Assert.Equal(100, value.AsLong);
value = ValueStorageExtensions.Create((long)100);
Assert.True(value is IntegerValueStorage);
Assert.Equal(100, value.AsLong);
Amount amount = new Amount(200);
value = ValueStorageExtensions.Create(amount);
Assert.True(value is AmountValueStorage);
Assert.Equal(amount, value.AsAmount);
Balance balance = new Balance(amount);
value = ValueStorageExtensions.Create(balance);
Assert.True(value is BalanceValueStorage);
Assert.Equal(balance, value.AsBalance);
string s = "test-string";
value = ValueStorageExtensions.Create(s);
Assert.True(value is StringValueStorage);
Assert.Equal(s, value.AsString);
Mask regex = new Mask(".");
value = ValueStorageExtensions.Create(regex);
Assert.True(value is MaskValueStorage);
Assert.Equal(regex, value.AsMask);
IList <Value> values = new List <Value>();
value = ValueStorageExtensions.Create(values);
Assert.True(value is SequenceValueStorage);
Assert.Equal(values.Count, value.AsSequence.Count);
}
public void SequenceValueStorage_Negate_CallsNegatedForChildren()
{
Amount amount = new Amount(100);
IList <Value> sequence = new List <Value>();
sequence.Add(Value.Get(amount));
var storage = ValueStorageExtensions.CreateFromObject(sequence);
storage.Negate();
Amount newAmount = storage.AsSequence.First().AsAmount;
Assert.Equal(-100, newAmount.Quantity.ToLong());
Assert.Equal(100, amount.Quantity.ToLong());
}
public static Value Get <T>(T value)
{
if (value == null)
{
return(new Value());
}
if (Object.Equals(value, default(T)) && !typeof(T).IsValueType)
{
return(new Value());
}
if (typeof(T) == typeof(String) && String.IsNullOrEmpty((string)(object)value))
{
return(new Value());
}
return(new Value(ValueStorageExtensions.Create(value)));
}
public Value InPlaceCast(ValueTypeEnum type)
{
if (Storage == null) // VOID
{
switch (type)
{
case ValueTypeEnum.Integer:
Storage = ValueStorageExtensions.Create(0);
return(this);
case ValueTypeEnum.Amount:
Storage = ValueStorageExtensions.Create(new Amount(0));
return(this);
case ValueTypeEnum.String:
Storage = ValueStorageExtensions.Create(String.Empty);
return(this);
default:
throw new InvalidOperationException(String.Format("Cannot cast VOID to {0}", type));
}
}
switch (type)
{
case ValueTypeEnum.Integer:
Storage = ValueStorageExtensions.Create(Storage.AsLong);
return(this);
case ValueTypeEnum.Boolean:
Storage = ValueStorageExtensions.Create(Storage.AsBoolean);
return(this);
case ValueTypeEnum.Date:
Storage = ValueStorageExtensions.Create(Storage.AsDate);
return(this);
case ValueTypeEnum.DateTime:
Storage = ValueStorageExtensions.Create(Storage.AsDateTime);
return(this);
case ValueTypeEnum.Amount:
Storage = ValueStorageExtensions.Create(Storage.AsAmount);
return(this);
case ValueTypeEnum.Balance:
Storage = ValueStorageExtensions.Create(Storage.AsBalance);
return(this);
case ValueTypeEnum.String:
Storage = ValueStorageExtensions.Create(Storage.AsString);
return(this);
case ValueTypeEnum.Mask:
Storage = ValueStorageExtensions.Create(Storage.AsMask);
return(this);
case ValueTypeEnum.Any:
Storage = ValueStorageExtensions.Create(Storage.StoredValue);
return(this);
case ValueTypeEnum.Scope:
Storage = ValueStorageExtensions.Create(Storage.AsScope);
return(this);
case ValueTypeEnum.Sequence:
Storage = ValueStorageExtensions.Create(Storage.AsSequence);
return(this);
default:
throw new InvalidOperationException();
}
}
public static Value Clone(Value value)
{
return(Value.IsNullOrEmpty(value) ? new Value() : new Value(ValueStorageExtensions.CreateFromObject(value.Storage.StoredValue)));
}
public static ValueTypeEnum GetValueType <T>()
{
return(ValueStorageExtensions.GetValueType <T>());
}
