public void PackTest5()
{
object data = (object)new object[] { 1.4, 1.4f, 1.4d, -1.4, -1.4f, -1.4d };
IPM pm = new PM(string.Format("left({0})", Value.Pack(data)));
RArgs args = (RArgs)pm.Levels[0].Args[0].data;
Assert.Equal(6, args.Length);
Assert.Equal(ArgumentType.Double, args[0].type);
Assert.Equal(1.4d, args[0].data);
Assert.Equal(ArgumentType.Float, args[1].type);
Assert.Equal(1.4f, args[1].data);
Assert.Equal(ArgumentType.Double, args[2].type);
Assert.Equal(1.4d, args[2].data);
Assert.Equal(ArgumentType.Double, args[3].type);
Assert.Equal(-1.4d, args[3].data);
Assert.Equal(ArgumentType.Float, args[4].type);
Assert.Equal(-1.4f, args[4].data);
Assert.Equal(ArgumentType.Double, args[5].type);
Assert.Equal(-1.4d, args[5].data);
}
public void DetectArgumentTest3()
{
IPM pm = new PM(" m77(\"guid\", 12, {\"p1\", {4, \"test\", 8, 'y'}, true}, {false, 'p2'}) ");
Assert.True(pm.Is(LevelType.Method, "m77"));
var args = pm.Levels[0].Args;
Assert.Equal(4, args.Length);
Assert.Equal(ArgumentType.StringDouble, args[0].type);
Assert.Equal("guid", args[0].data);
Assert.Equal(ArgumentType.Integer, args[1].type);
Assert.Equal(12, args[1].data);
Assert.Equal(ArgumentType.Object, args[2].type);
{
RArgs args2 = (RArgs)args[2].data;
Assert.Equal(3, args2.Length);
Assert.Equal(ArgumentType.StringDouble, args2[0].type);
Assert.Equal("p1", args2[0].data);
Assert.Equal(ArgumentType.Object, args2[1].type);
{
RArgs args21 = (RArgs)args2[1].data;
Assert.Equal(4, args21.Length);
Assert.Equal(ArgumentType.Integer, args21[0].type);
Assert.Equal(4, args21[0].data);
Assert.Equal(ArgumentType.StringDouble, args21[1].type);
Assert.Equal("test", args21[1].data);
Assert.Equal(ArgumentType.Integer, args21[2].type);
Assert.Equal(8, args21[2].data);
Assert.Equal(ArgumentType.Char, args21[3].type);
Assert.Equal('y', args21[3].data);
}
Assert.Equal(ArgumentType.Boolean, args2[2].type);
Assert.Equal(true, args2[2].data);
}
Assert.Equal(ArgumentType.Object, args[3].type);
{
RArgs args3 = (RArgs)args[3].data;
Assert.Equal(2, args3.Length);
Assert.Equal(ArgumentType.Boolean, args3[0].type);
Assert.Equal(false, args3[0].data);
Assert.Equal(ArgumentType.StringSingle, args3[1].type);
Assert.Equal("p2", args3[1].data);
}
}
public void PackTest4()
{
object data = new object[] { "str", 123, -1.4, true, 'n', new object[] { 1.2f, "str2", 'y', false }, -24.574 };
IPM pm = new PM(string.Format("left({0})", Value.Pack(data)));
var raw = pm.Levels[0].Args;
Assert.Single(raw);
Assert.Equal(ArgumentType.Object, raw[0].type);
{
RArgs args = (RArgs)raw[0].data;
Assert.Equal(7, args.Length);
Assert.Equal(ArgumentType.StringDouble, args[0].type);
Assert.Equal("str", args[0].data);
Assert.Equal(ArgumentType.Integer, args[1].type);
Assert.Equal(123, args[1].data);
Assert.Equal(ArgumentType.Double, args[2].type);
Assert.Equal(-1.4, args[2].data);
Assert.Equal(ArgumentType.Boolean, args[3].type);
Assert.Equal(true, args[3].data);
Assert.Equal(ArgumentType.Char, args[4].type);
Assert.Equal('n', args[4].data);
Assert.Equal(ArgumentType.Object, args[5].type);
{
RArgs args5 = (RArgs)args[5].data;
Assert.Equal(4, args5.Length);
Assert.Equal(ArgumentType.Float, args5[0].type);
Assert.Equal(1.2f, args5[0].data);
Assert.Equal(ArgumentType.StringDouble, args5[1].type);
Assert.Equal("str2", args5[1].data);
Assert.Equal(ArgumentType.Char, args5[2].type);
Assert.Equal('y', args5[2].data);
Assert.Equal(ArgumentType.Boolean, args5[3].type);
Assert.Equal(false, args5[3].data);
}
Assert.Equal(ArgumentType.Double, args[6].type);
Assert.Equal(-24.574, args[6].data);
}
}
protected string CopyFile(IPM pm, RArgs files, string dest, bool overwrite, RArgs except = null)
{
dest = dest.DirectoryPathFormat();
foreach (Argument src in files)
{
if (src.type != ArgumentType.StringDouble)
{
throw new PMArgException(src, "Input files. Define as {\"f1\", \"f2\", ...}");
}
CopyFile(pm, src.data.ToString(), dest, overwrite, except);
}
return(Value.Empty);
}
protected string DeleteFiles(IPM pm, RArgs files, RArgs except = null)
{
if (files.Any(p => p.type != ArgumentType.StringDouble))
{
throw new PMArgException(files, "Input files. Define as {\"f1\", \"f2\", ...}");
}
if (except != null && except.Any(p => p.type != ArgumentType.StringDouble))
{
throw new PMArgException(except, "'except' argument. Define as {\"f1\", \"f2\", ...}");
}
string exs(string file, int idx)
{
if (!string.IsNullOrWhiteSpace(file))
{
return(GetLocation(file));
}
throw new ArgumentException($"File name is empty. Fail in '{idx}' position.");
}
string[] input = files.Select((f, i) => exs((string)f.data, i)).ToArray().ExtractFiles(Exer.BasePath);
#if DEBUG
LSender.Send(this, $"DeleteFiles: Found files `{string.Join(", ", input)}`", MsgLevel.Trace);
#endif
if (except != null)
{
input = input.Except
(
except
.Where(f => !string.IsNullOrWhiteSpace((string)f.data))
.Select(f => GetLocation((string)f.data))
.ToArray()
.ExtractFiles(Exer.BasePath)
)
.ToArray();
}
if (input.Length < 1)
{
throw new PMArgException(files, "Input files was not found. Check your mask and the exception list if used.");
}
DeleteFiles(input);
return(Value.Empty);
}
protected static string GetMessage(RArgs args, string expected)
{
string pNull, pSize;
if (args == null)
{
pNull = "null";
pSize = "";
}
else
{
pNull = "not null";
pSize = " with size " + args.Count;
}
return($"Incorrect arguments: {pNull} value{pSize}. Expected `{expected}`");
}
/// <summary>
/// Extract SNode.RArguments into system object[] data.
/// </summary>
/// <param name="args">SNode arguments.</param>
/// <returns></returns>
public static object[] Extract(RArgs args)
{
object[] ret = new object[args.Length];
for (int i = 0; i < args.Length; ++i)
{
if (args[i].data is RArgs)
{
ret[i] = Extract((RArgs)args[i].data);
continue;
}
ret[i] = args[i].data;
#if DEBUG
LSender.Send(typeof(Value), $"Value.extract: SNode.Argument - '{ret[i]}'", MsgLevel.Trace);
#endif
}
return(ret);
}
protected string DoCatch(string cmd, Exception ex, RArgs args)
{
LSender.Send(this, $"Catched error `{ex.Message}`", MsgLevel.Info);
if (args == null)
{
return(Evaluate(cmd));
}
if (args.Count == 2 &&
args[0].type == ArgumentType.EnumOrConst &&
args[1].type == ArgumentType.EnumOrConst)
{
// try{ }catch(err, msg){ }
return(DoCatch(cmd, ex, args[0].data.ToString(), args[1].data.ToString()));
}
throw new NotSupportedOperationException("the format of the catch block is incorrect or not supported yet.");
}
protected string CopyFile(IPM pm, string src, string dest, bool overwrite, RArgs except = null)
{
if (string.IsNullOrWhiteSpace(src) || string.IsNullOrWhiteSpace(dest))
{
throw new ArgumentException("The source file or the destination path argument is empty.");
}
if (except != null && except.Any(p => p.type != ArgumentType.StringDouble))
{
throw new PMArgException(except, "'except' argument. Define as {\"f1\", \"f2\", ...}");
}
dest = GetLocation(dest.TrimEnd());
string destDir = Path.GetDirectoryName(dest);
string destFile = Path.GetFileName(dest);
src = GetLocation(src);
string[] input = new[] { src }.ExtractFiles(Exer.BasePath);
#if DEBUG
LSender.Send(this, $"Found files to copy `{string.Join(", ", input)}`", MsgLevel.Trace);
#endif
if (except != null)
{
string path = Path.GetDirectoryName(src);
input = input.Except
(
except
.Where(f => !string.IsNullOrWhiteSpace((string)f.data))
.Select(f => GetLocation((string)f.data, path))
.ToArray()
.ExtractFiles(Exer.BasePath)
)
.ToArray();
}
if (input.Length < 1)
{
throw new ArgumentException("The input files was not found. Check your mask and the exception list if used.");
}
CopyFile(destDir, destFile, overwrite, input);
return(Value.Empty);
}
public PMArgException(RArgs args, string expected)
: base(GetMessage(args, expected), args)
{
}
