/// <summary>
/// Makes an expression slim representing a ConstantExpression.
/// </summary>
/// <param name="node">Original expression.</param>
/// <returns>Slim representation of the original expression.</returns>
protected override ExpressionSlim MakeConstant(ConstantExpression node)
{
var type = MakeType(node.Type);
var obj = ObjectSlim.Create(node.Value, type, node.Type);
return(_factory.Constant(obj, type));
}
public void ObjectSlim_NullArguments()
{
AssertEx.ThrowsException <ArgumentNullException>(() => ObjectSlim.Create(value: null, typeSlim: null, type: null), ex => Assert.AreEqual(ex.ParamName, "typeSlim"));
AssertEx.ThrowsException <ArgumentNullException>(() => ObjectSlim.Create(value: null, SlimType, type: null), ex => Assert.AreEqual(ex.ParamName, "type"));
AssertEx.ThrowsException <ArgumentNullException>(() => ObjectSlim.Create(liftedValue: null, typeSlim: null, reduceFactory: (Func <Type, Func <object, object> >)null), ex => Assert.AreEqual(ex.ParamName, "typeSlim"));
AssertEx.ThrowsException <ArgumentNullException>(() => ObjectSlim.Create(liftedValue: null, SlimType, reduceFactory: (Func <Type, Func <object, object> >)null), ex => Assert.AreEqual(ex.ParamName, "reduceFactory"));
}
public void ObjectSlim_Reduce_Exceptions()
{
var os1 = ObjectSlim.Create(1, SlimType, typeof(int));
var os2 = ObjectSlim.Create("1", SlimType, t => o => o);
AssertEx.ThrowsException <ArgumentNullException>(() => os2.Reduce(type: null), ex => Assert.AreEqual(ex.ParamName, "type"));
}
public void ObjectSlim_Lift_Exceptions()
{
var os1 = ObjectSlim.Create(1, SlimType, typeof(int));
var os2 = ObjectSlim.Create <string>("1", SlimType, t => o => o);
AssertEx.ThrowsException <ArgumentNullException>(() => os1.Lift <string>(liftFactory: null), ex => Assert.AreEqual(ex.ParamName, "liftFactory"));
Assert.ThrowsException <InvalidOperationException>(() => { var ot = os2.OriginalType; });
Assert.ThrowsException <InvalidOperationException>(() => os2.Lift <string>(t => o => o.ToString()));
}
protected override Json.Expression VisitConstantValue(ObjectSlim value)
{
if (!value.CanLift)
{
return((Json.Expression)value.Value);
}
return(value.Lift(_liftFactory));
}
public void ObjectSlim_CanLift()
{
var os1 = ObjectSlim.Create(1, SlimType, typeof(int));
var os2 = ObjectSlim.Create("1", SlimType, _ => x => int.Parse(x));
Assert.IsTrue(os1.CanLift);
Assert.IsFalse(os2.CanLift);
Assert.AreSame(typeof(int), os1.OriginalType);
Assert.AreEqual(os1.Lift <string>(t => o => o.ToString()), "1");
}
internal static ConstantExpressionSlim Make(ObjectSlim value, TypeSlim type)
{
// NB: The overloaded operator == on TypeSlim can be expensive, so we'll just
// look for reference equality.
if (ReferenceEquals(value.TypeSlim, type))
{
return(new ConstantExpressionSlim(value));
}
return(new TypedConstantExpressionSlim(value, type));
}
public void ConstantExpressionSlim_ArgumentChecks()
{
var t = typeof(string).ToTypeSlim();
var v = ObjectSlim.Create(value: null, t, typeof(string));
AssertEx.ThrowsException <ArgumentNullException>(() => ExpressionSlim.Constant(value: null, t), ex => Assert.AreEqual("value", ex.ParamName));
AssertEx.ThrowsException <ArgumentNullException>(() => ExpressionSlim.Constant(v, type: null), ex => Assert.AreEqual("type", ex.ParamName));
AssertEx.ThrowsException <ArgumentNullException>(() => new ConstantExpressionSlim(value: null), ex => Assert.AreEqual("value", ex.ParamName));
AssertEx.ThrowsException <ArgumentNullException>(() => new TypedConstantExpressionSlim(value: null, t), ex => Assert.AreEqual("value", ex.ParamName));
AssertEx.ThrowsException <ArgumentNullException>(() => new TypedConstantExpressionSlim(v, type: null), ex => Assert.AreEqual("type", ex.ParamName));
}
public void ExpressionSlimToExpressionConverter_Constant_Null()
{
var objNull = ObjectSlim.Create(value: null, typeof(object).ToTypeSlim(), typeof(object));
var strNull = ObjectSlim.Create(value: null, typeof(string).ToTypeSlim(), typeof(string));
var n1 = ExpressionSlim.Constant(objNull);
var n2 = ExpressionSlim.Constant(strNull, typeof(string).ToTypeSlim());
var c1 = (ConstantExpression)n1.ToExpression();
var c2 = (ConstantExpression)n2.ToExpression();
Assert.IsNull(c1.Value);
Assert.AreEqual(typeof(object), c1.Type);
Assert.IsNull(c2.Value);
Assert.AreEqual(typeof(string), c2.Type);
}
/// <summary> /// Gets the hash code for the specified object <paramref name="value"/>. /// </summary> /// <param name="value">The object value to get the hash code for.</param> /// <returns>A hash code for the specified object <paramref name="value"/>.</returns> protected virtual int GetHashCode(ObjectSlim value) => value?.Value?.GetHashCode() ?? 0;
protected override ObjectSlim VisitConstantValue(Json.Expression value, TypeSlim type) => ObjectSlim.Create(value, type, _reduceFactory);
protected override Json.Expression VisitConstantValue(ObjectSlim value)
{
return(Json.Expression.String("0"));
}
public void ExpressionSlim_ToString_Constant()
{
AssertToString(ExpressionSlim.Constant(ObjectSlim.Create(value: null, typeof(string).ToTypeSlim(), typeof(string)), typeof(string).ToTypeSlim()), "Constant(null, System.String)");
AssertToString(Expression.Constant(value: null, typeof(string)).ToExpressionSlim(), "Constant(null, System.String)");
AssertToString(Expression.Constant("bar", typeof(string)).ToExpressionSlim(), "Constant(bar, System.String)");
}
protected override ObjectSlim VisitConstantValue(Json.Expression value, TypeSlim type)
{
return(ObjectSlim.Create(value ?? Json.Expression.Null(), type, ReduceJsonFactory));
}
protected override Json.Expression VisitConstantValue(ObjectSlim value)
{
var liftedValue = value.CanLift ? value.Lift(LiftAndStringify) : value.Value.ToString();
return(Json.Expression.Parse(liftedValue, ensureTopLevelObjectOrArray: false));
}
internal TypedConstantExpressionSlim(ObjectSlim value, TypeSlim type)
: base(value)
{
Type = type ?? throw new ArgumentNullException(nameof(type));
}
private void Append(ObjectSlim value) => _sb.Append(value?.ToString());
internal ConstantExpressionSlim(ObjectSlim value)
{
Value = value ?? throw new ArgumentNullException(nameof(value));
}
