public void GetNotExistPropWillReturnNull()
{
var val = new { A = 3 };
var prop = DynamicRuntimeMacros.GetProp(val, "A.A");
Assert.Null(prop);
}
public void CanGetNextedObjectValue()
{
var val = new { A = new { B = 4 } };
var getted = DynamicRuntimeMacros.GetPropValue(val, "A.B");
Assert.Equal(4, getted);
}
public void GetSimplePropOk()
{
var val = new { A = 3 };
var prop = DynamicRuntimeMacros.GetProp(val, "A");
Assert.NotNull(prop);
}
public void GetNestedPropOk()
{
var val = new { A = new { A = 3 } };
var prop = DynamicRuntimeMacros.GetProp(val, "A.A");
Assert.NotNull(prop);
}
public void HelloWorld()
{
var val = "Hello World";
var actual = DynamicRuntimeMacros.Val(OneCallContext.CreateEmpty(), "", val, null);
Assert.True(actual.IsSuccess);
Assert.Equal(val, actual.Value);
}
public void InputNullWillBeEmpty()
{
string val = null;
var actual = DynamicRuntimeMacros.Val(OneCallContext.CreateEmpty(), "", val, null);
Assert.True(actual.IsSuccess);
Assert.Equal(string.Empty, actual.Value);
}
public void NotExistPropShouldFail()
{
var val = DynamicRuntimeMacros.Iif(OneCallContext.CreateEmpty(),
"",
new { A = new bool?() },
new object[] { "B", "true", "false" });
Assert.False(val.IsSuccess);
}
private Result <string> CallIsNotEqual(object self, string prop, object val, string result)
{
if (val is int)
{
val = Convert.ToDouble(val);
}
return(DynamicRuntimeMacros.IsNotEqual(OneCallContext.CreateEmpty(),
"", self, new object[] { prop, val, result }));
}
public void WillEmitPropNameWhenFail()
{
var val = DynamicRuntimeMacros.IsNotEmpty(OneCallContext.CreateEmpty(),
"",
new { A = DateTime.Now },
new object[] { "ThePropertyName", "Ok" });
Assert.True(val.IsFailure);
Assert.Contains("ThePropertyName", val.Error);
}
public void ValueIsNotEmpty()
{
var val = DynamicRuntimeMacros.IsNotEmpty(OneCallContext.CreateEmpty(),
"",
new { A = DateTime.Now },
new object[] { "A", "Ok" });
Assert.True(val.IsSuccess);
Assert.Equal("Ok", val.Value);
}
public void Smoke()
{
var val = DynamicRuntimeMacros.Iif(OneCallContext.CreateEmpty(),
"",
new { A = true },
new object[] { "A", "true", "false" });
Assert.True(val.IsSuccess);
Assert.Equal("true", val.Value);
}
public void EmptyNullShouldTreatFalsy()
{
var val = DynamicRuntimeMacros.Iif(OneCallContext.CreateEmpty(),
"",
new { A = new bool?() },
new object[] { "A", "true", "false" });
Assert.True(val.IsSuccess);
Assert.Equal("false", val.Value);
}
public static bool PropertyExistsAndEvalToTrue(object obj, string propName)
{
var val = DynamicRuntimeMacros.GetPropValue(obj, propName);
if (val is bool)
{
return((bool)val);
}
if (val is bool?)
{
return(((bool?)val).GetValueOrDefault());
}
return(false);
}
private Result <string> CallCompare(object self, string op, string prop, int val, string result)
{
switch (op)
{
case ">":
return(DynamicRuntimeMacros.IsGreaterThan(OneCallContext.CreateEmpty(),
"", self, new object[] { prop, val, result }));
case "<":
return(DynamicRuntimeMacros.IsLessThan(OneCallContext.CreateEmpty(),
"", self, new object[] { prop, val, result }));
case ">=":
return(DynamicRuntimeMacros.IsGreaterEqual(OneCallContext.CreateEmpty(),
"", self, new object[] { prop, val, result }));
case "<=":
return(DynamicRuntimeMacros.IsLessEqual(OneCallContext.CreateEmpty(),
"", self, new object[] { prop, val, result }));
default:
throw new ArgumentOutOfRangeException(nameof(op));
}
}
public void CanImplementDepInMacro()
{
var code = "sql v1{#def<B, 'Nice'>#isNotEmptyWithDeps<A, sql {ABCDEFG}, B>}";
var rt = new SdmapCompiler();
rt.AddSourceCode(code);
string id = "isNotEmptyWithDeps";
rt.AddMacro(id, (context, ns, self, arguments) =>
{
if (self == null)
{
return(Result.Fail <string>($"Query requires not null in macro '{id}'."));
}
;
var prop = self.GetType().GetProperty((string)arguments[0]);
if (prop == null)
{
return(Result.Fail <string>($"Query requires property '{prop}' in macro '{id}'."));
}
if (!DynamicRuntimeMacros.IsEmpty(DynamicRuntimeMacros.GetPropValue(self, (string)arguments[0])))
{
foreach (var dep in arguments.Skip(2).OfType <string>())
{
context.Deps.Add(dep);
}
return(((EmitFunction)arguments[1])(context.DupNewFragments()));
}
return(Result.Ok(string.Empty));
});
var result = rt.Emit("v1", new { A = new[] { 1, 2, 3 } });
Assert.Equal("NiceABCDEFG", result);
}
private Result <string> CallIsNotNull(object self, string prop, string result)
{
return(DynamicRuntimeMacros.IsNotNull(OneCallContext.CreateEmpty(), "", self, new[] { prop, result }));
}
public void BoolEqualBool()
{
Assert.True(DynamicRuntimeMacros.IsEqual(true, true));
}
public void DecimalEqualToDecimal()
{
Assert.True(DynamicRuntimeMacros.IsEqual(3.14m, 3.14m));
}
private Result <string> CallEach(object self,
string prop, string joiner, EmitFunction ef)
{
return(DynamicRuntimeMacros.Each(OneCallContext.CreateEmpty(),
"", self, new object[] { prop, joiner, ef }));
}
public void GetNotExistPropWillNotThrow()
{
var val = new { A = 3 };
var prop = DynamicRuntimeMacros.GetProp(val, "B.C.D");
}
public static object LoadProp(object obj, string propName) => DynamicRuntimeMacros.GetPropValue(obj, propName);
public void CanDetectNotEmptyArray()
{
var arr = Enumerable.Range(1, 10);
Assert.False(DynamicRuntimeMacros.ArrayEmpty(arr));
}
private Result<string> CallIterate(object self, string joiner, string text)
{
return DynamicRuntimeMacros.Iterate(OneCallContext.CreateByObj(self),
"", self, new object[] { joiner, text });
}
public void NumberEqualsNumber()
{
Assert.True(DynamicRuntimeMacros.IsEqual(3.11m, 3.11));
}
private Result<string> CallEach(object self,
string prop, string joiner, string text)
{
return DynamicRuntimeMacros.Each(OneCallContext.CreateEmpty(),
"", self, new object[] { prop, joiner, text });
}
public void DateEqualsDate()
{
var date = new DateTime(2016, 1, 1);
Assert.True(DynamicRuntimeMacros.IsEqual(date, DateUtil.Parse("2016/1/1").Value));
}
private Result <string> CallIterate(object self, string joiner, EmitFunction ef)
{
return(DynamicRuntimeMacros.Iterate(OneCallContext.CreateByObj(self),
"", self, new object[] { joiner, ef }));
}