本文整理汇总了C#中Loader.LoadFromString方法的典型用法代码示例。如果您正苦于以下问题:C# Loader.LoadFromString方法的具体用法?C# Loader.LoadFromString怎么用?C# Loader.LoadFromString使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类Loader
的用法示例。
在下文中一共展示了Loader.LoadFromString方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: TestMeta
public void TestMeta()
{
const string input1 =
@"
Name fixture\storage\meta;
Description ""Contains dummy meta information for a unit test"";
Author SealedSun;
Import
{
System,
System::Text
};
Is AsFastAsPossible;
Add System::Xml To Imports;
";
var ldr = new Loader(engine, target);
ldr.LoadFromString(input1);
Assert.AreEqual(0, ldr.ErrorCount);
var stored = ldr.Options.TargetApplication.StoreInString();
Console.WriteLine(stored);
var reldr = new Loader(engine, new Application());
reldr.LoadFromString(stored);
var restored = reldr.Options.TargetApplication.StoreInString();
Assert.That(stored,
Is.EqualTo(stored).Using((IEqualityComparer<string>)Engine.DefaultStringComparer),
_storedShouldBeEqual);
}
示例2: GetInstructions
protected List<Instruction> GetInstructions(string assemblerCode)
{
var app = new Application("getInstructions");
var opt = new LoaderOptions(engine, app);
opt.UseIndicesLocally = false;
var ldr = new Loader(opt);
ldr.LoadFromString("function MyAssemblerFunction does asm {" + assemblerCode + "\n}");
if (ldr.ErrorCount != 0)
{
Console.WriteLine("--------------- Assembler Code --------------------");
Console.WriteLine(assemblerCode);
Console.WriteLine("---------------- End Asm Code ---------------------");
foreach (var error in ldr.Errors)
Assert.Fail(string.Format("Error in the expected assembler code: {0}", error));
}
return app.Functions["MyAssemblerFunction"].Code;
}
示例3: TestEmpty
public void TestEmpty()
{
const string input1 = "";
var ldr = new Loader(engine, target);
Console.WriteLine("-- Compiling fixture");
ldr.LoadFromString(input1);
Assert.AreEqual(0, ldr.ErrorCount);
var stored = ldr.Options.TargetApplication.StoreInString();
Console.WriteLine(stored);
Console.WriteLine("-- Compiling stored result");
var reldr = new Loader(engine, new Application());
reldr.LoadFromString(stored);
var restored = reldr.Options.TargetApplication.StoreInString();
Assert.That(stored,
Is.EqualTo(stored).Using((IEqualityComparer<string>) Engine.DefaultStringComparer),
_storedShouldBeEqual);
}
示例4: AsmIdArgInstructions
public void AsmIdArgInstructions()
{
const string input1 =
@"
function func1 does asm
{
newobj.1 ""Object(\""System.Text.StringBuilder\"")""
newtype.1 ""Object""
get.3 ToString
set.2 __\defaultIndex
new.1 ""Object(\""System.DateTime\"")""
sget.10 ""Object(\""System.Console\"")::WriteLine""
sset.1 ""Object(\""System.Console\"")::ForegroundColor""
indloc.2 aFunction
indglob.3 anotherFunction
}
";
var opt = new LoaderOptions(engine, target);
opt.UseIndicesLocally = false;
var ldr = new Loader(opt);
ldr.LoadFromString(input1);
Assert.AreEqual(0, ldr.ErrorCount, "There were errors during compilation.");
var code = target.Functions["func1"].Code;
var i = 0;
Assert.AreEqual(OpCode.newobj, code[i].OpCode);
Assert.AreEqual("Object(\"System.Text.StringBuilder\")", code[i].Id);
Assert.AreEqual(1, code[i++].Arguments);
Assert.AreEqual(OpCode.newtype, code[i].OpCode);
Assert.AreEqual("Object", code[i].Id);
Assert.AreEqual(1, code[i++].Arguments);
Assert.AreEqual(OpCode.get, code[i].OpCode);
Assert.AreEqual("ToString", code[i].Id);
Assert.AreEqual(3, code[i++].Arguments);
Assert.AreEqual(OpCode.set, code[i].OpCode);
Assert.AreEqual("__\\defaultIndex", code[i].Id);
Assert.AreEqual(2, code[i++].Arguments);
Assert.AreEqual(OpCode.newobj, code[i].OpCode);
Assert.AreEqual("Object(\"System.DateTime\")", code[i].Id);
Assert.AreEqual(1, code[i++].Arguments);
Assert.AreEqual(OpCode.sget, code[i].OpCode);
Assert.AreEqual("Object(\"System.Console\")::WriteLine", code[i].Id);
Assert.AreEqual(10, code[i++].Arguments);
Assert.AreEqual(OpCode.sset, code[i].OpCode);
Assert.AreEqual("Object(\"System.Console\")::ForegroundColor", code[i].Id);
Assert.AreEqual(1, code[i++].Arguments);
Assert.AreEqual(OpCode.indloc, code[i].OpCode);
Assert.AreEqual("aFunction", code[i].Id);
Assert.AreEqual(2, code[i++].Arguments);
Assert.AreEqual(OpCode.indglob, code[i].OpCode);
Assert.AreEqual("anotherFunction", code[i].Id);
Assert.AreEqual(3, code[i++].Arguments);
}
示例5: AsmSpecialInstructions
public void AsmSpecialInstructions()
{
const string input1 =
@"
function func1(param1) [ key value; ] does asm
{
rot.2,3
swap
ldc.real -2.53e-3
ldc.real 2.5
ldc.bool false
ldc.bool TrUe
indarg.3
inda.0
}
";
var opt = new LoaderOptions(engine, target);
opt.UseIndicesLocally = false;
var ldr = new Loader(opt);
ldr.LoadFromString(input1);
Assert.AreEqual(0, ldr.ErrorCount, "There were errors during compilation.");
var code = target.Functions["func1"].Code;
var i = 0;
Assert.AreEqual(OpCode.rot, code[i].OpCode);
Assert.AreEqual(2, code[i].Arguments);
Assert.AreEqual(3, (int) code[i++].GenericArgument);
Assert.AreEqual(OpCode.rot, code[i].OpCode);
Assert.AreEqual(1, code[i].Arguments);
Assert.AreEqual(2, (int) code[i++].GenericArgument);
Assert.AreEqual(OpCode.ldc_real, code[i].OpCode);
Assert.AreEqual(-2.53e-3, (double) code[i++].GenericArgument);
Assert.AreEqual(OpCode.ldc_real, code[i].OpCode);
Assert.AreEqual(2.5, (double) code[i++].GenericArgument);
Assert.AreEqual(OpCode.ldc_bool, code[i].OpCode);
Assert.AreEqual(0, code[i++].Arguments);
Assert.AreEqual(OpCode.ldc_bool, code[i].OpCode);
Assert.AreEqual(1, code[i++].Arguments);
Assert.AreEqual(OpCode.indarg, code[i].OpCode);
Assert.AreEqual(3, code[i++].Arguments);
Assert.AreEqual(OpCode.indarg, code[i].OpCode);
Assert.AreEqual(0, code[i++].Arguments);
}
示例6: AsmIdInstructions
public void AsmIdInstructions()
{
const string input1 =
@"
var glob1;
function func1 does asm
{
var loc1
ldc.string ""Hello World""
ldr.func func1
ldr.glob glob1
ldr.loc loc1
ldr.type Int
ldloc loc1
stloc loc1
ldglob glob1
stglob glob1
check.const Int
cast.const Int
}
";
var opt = new LoaderOptions(engine, target);
opt.UseIndicesLocally = false;
var ldr = new Loader(opt);
ldr.LoadFromString(input1);
Assert.AreEqual(0, ldr.ErrorCount, "There were errors during compilation.");
var code = target.Functions["func1"].Code;
var i = 0;
Assert.AreEqual(OpCode.ldc_string, code[i].OpCode);
Assert.AreEqual("Hello World", code[i++].Id);
Assert.AreEqual(OpCode.ldr_func, code[i].OpCode);
Assert.AreEqual("func1", code[i++].Id);
Assert.AreEqual(OpCode.ldr_glob, code[i].OpCode);
Assert.AreEqual("glob1", code[i++].Id);
Assert.AreEqual(OpCode.ldr_loc, code[i].OpCode);
Assert.AreEqual("loc1", code[i++].Id);
Assert.AreEqual(OpCode.ldr_type, code[i].OpCode);
Assert.AreEqual("Int", code[i++].Id);
Assert.AreEqual(OpCode.ldloc, code[i].OpCode);
Assert.AreEqual("loc1", code[i++].Id);
Assert.AreEqual(OpCode.stloc, code[i].OpCode);
Assert.AreEqual("loc1", code[i++].Id);
Assert.AreEqual(OpCode.ldglob, code[i].OpCode);
Assert.AreEqual("glob1", code[i++].Id);
Assert.AreEqual(OpCode.stglob, code[i].OpCode);
Assert.AreEqual("glob1", code[i++].Id);
Assert.AreEqual(OpCode.check_const, code[i].OpCode);
Assert.AreEqual("Int", code[i++].Id);
Assert.AreEqual(OpCode.cast_const, code[i].OpCode);
Assert.AreEqual("Int", code[i++].Id);
}
示例7: AsmNullInstructions
public void AsmNullInstructions()
{
const string input1 =
@"
function func1() does asm
{
//Instructions in the null group
nop //0
ldc.null //1
nop //2
nop //3
neg //4
not //5
add //6
sub //7
mul //8
div //9
mod //10
pow //11
ceq //12
cne //13
cgt //14
cge //15
clt //16
cle //17
or //18
and //19
xor //20
check.arg //21
cast . arg //22
ldr.eng //23
ldr. app //24
ret.exit //25
ret.break //26
ret.continue //27
ret.set //28
ret.value //29
//Aliases
continue //30
break //31
ret //32
exit //33
}
";
var opt = new LoaderOptions(engine, target);
opt.UseIndicesLocally = false;
var ldr = new Loader(opt);
ldr.LoadFromString(input1);
Assert.AreEqual(0, ldr.ErrorCount);
var code = target.Functions["func1"].Code;
var i = 0;
Assert.AreEqual(OpCode.nop, code[i++].OpCode);
Assert.AreEqual(OpCode.ldc_null, code[i++].OpCode);
Assert.AreEqual(OpCode.nop, code[i++].OpCode);
Assert.AreEqual(OpCode.nop, code[i++].OpCode);
//operator aliases
Assert.AreEqual(OpCode.cmd, code[i].OpCode);
Assert.AreEqual(1, code[i].Arguments);
Assert.AreEqual(UnaryNegation.DefaultAlias, code[i++].Id);
Assert.AreEqual(1, code[i].Arguments);
Assert.AreEqual(OpCode.cmd, code[i].OpCode);
Assert.AreEqual(LogicalNot.DefaultAlias, code[i++].Id);
Assert.AreEqual(2, code[i].Arguments);
Assert.AreEqual(OpCode.cmd, code[i].OpCode);
Assert.AreEqual(Addition.DefaultAlias, code[i++].Id);
Assert.AreEqual(OpCode.cmd, code[i].OpCode);
Assert.AreEqual(2, code[i].Arguments);
Assert.AreEqual(Subtraction.DefaultAlias, code[i++].Id);
Assert.AreEqual(OpCode.cmd, code[i].OpCode);
Assert.AreEqual(2, code[i].Arguments);
Assert.AreEqual(Multiplication.DefaultAlias, code[i++].Id);
Assert.AreEqual(OpCode.cmd, code[i].OpCode);
Assert.AreEqual(2, code[i].Arguments);
Assert.AreEqual(Division.DefaultAlias, code[i++].Id);
Assert.AreEqual(OpCode.cmd, code[i].OpCode);
Assert.AreEqual(2, code[i].Arguments);
Assert.AreEqual(Modulus.DefaultAlias, code[i++].Id);
Assert.AreEqual(OpCode.cmd, code[i].OpCode);
Assert.AreEqual(2, code[i].Arguments);
Assert.AreEqual(Power.DefaultAlias, code[i++].Id);
Assert.AreEqual(OpCode.cmd, code[i].OpCode);
Assert.AreEqual(2, code[i].Arguments);
Assert.AreEqual(Equality.DefaultAlias, code[i++].Id);
Assert.AreEqual(OpCode.cmd, code[i].OpCode);
Assert.AreEqual(2, code[i].Arguments);
Assert.AreEqual(Inequality.DefaultAlias, code[i++].Id);
Assert.AreEqual(OpCode.cmd, code[i].OpCode);
Assert.AreEqual(2, code[i].Arguments);
Assert.AreEqual(GreaterThan.DefaultAlias, code[i++].Id);
Assert.AreEqual(OpCode.cmd, code[i].OpCode);
Assert.AreEqual(2, code[i].Arguments);
Assert.AreEqual(GreaterThanOrEqual.DefaultAlias, code[i++].Id);
Assert.AreEqual(OpCode.cmd, code[i].OpCode);
Assert.AreEqual(2, code[i].Arguments);
Assert.AreEqual(LessThan.DefaultAlias, code[i++].Id);
Assert.AreEqual(OpCode.cmd, code[i].OpCode);
Assert.AreEqual(2, code[i].Arguments);
//.........这里部分代码省略.........
示例8: VariableDeclarations
public void VariableDeclarations()
{
const string input1 =
@"
function func0
{
var obj0;
var obj1;
var obj2;
ref func1;
ref ifunc0;
ref cor0;
declare var gobj0;
declare var gobj1;
static sobj0;
static sobj1;
}
";
var opt = new LoaderOptions(engine, target) {UseIndicesLocally = false};
var ldr = new Loader(opt);
ldr.LoadFromString(input1);
foreach (var message in ldr.Errors)
{
Console.WriteLine(message);
}
Assert.AreEqual(0, ldr.ErrorCount, "Errors during compilation.");
// We allow up to two instructions (`return sobj1`) to accomodate the
// relaxed treatment of variable declarations in Prexonite 2
Assert.That(ldr.FunctionTargets["func0"].Code.Count, Is.LessThanOrEqualTo(2));
CompilerTarget tar = ldr.FunctionTargets["func0"];
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.LocalObjectVariable, "obj0", null),
LookupSymbolEntry(tar.Symbols, "obj0"));
Assert.IsTrue(tar.Function.Variables.Contains("obj0"));
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.LocalObjectVariable, "obj1", null),
LookupSymbolEntry(tar.Symbols, "obj1"));
Assert.IsTrue(tar.Function.Variables.Contains("obj1"));
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.LocalObjectVariable, "obj2", null),
LookupSymbolEntry(tar.Symbols, "obj2"));
Assert.IsTrue(tar.Function.Variables.Contains("obj2"));
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.LocalReferenceVariable, "func1", null),
LookupSymbolEntry(tar.Symbols, "func1"));
Assert.IsTrue(tar.Function.Variables.Contains("func1"));
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.LocalReferenceVariable, "ifunc0", null),
LookupSymbolEntry(tar.Symbols, "ifunc0"));
Assert.IsTrue(tar.Function.Variables.Contains("ifunc0"));
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.LocalReferenceVariable, "cor0", null),
LookupSymbolEntry(tar.Symbols, "cor0"));
Assert.IsTrue(tar.Function.Variables.Contains("cor0"));
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.GlobalObjectVariable, "gobj0", target.Module.Name),
LookupSymbolEntry(tar.Symbols, "gobj0"));
Assert.IsFalse(
tar.Function.Variables.Contains("gobj0"),
"\"declare var <id>;\" only declares a global variable.");
Assert.IsFalse(
ldr.Options.TargetApplication.Variables.ContainsKey("gobj0"),
"\"global <id>;\" only declares a global variable.");
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.GlobalObjectVariable, "gobj1", target.Module.Name),
LookupSymbolEntry(tar.Symbols, "gobj1"));
Assert.IsFalse(
tar.Function.Variables.Contains("gobj1"),
"\"declare var <id>;\" only declares a global variable.");
Assert.IsFalse(
ldr.Options.TargetApplication.Variables.ContainsKey("gobj1"),
"\"declare var <id>;\" only declares a global variable.");
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.GlobalObjectVariable, "func0\\static\\sobj0", target.Module.Name),
LookupSymbolEntry(tar.Symbols, "sobj0"));
Assert.IsTrue(
ldr.Options.TargetApplication.Variables.ContainsKey("func0\\static\\sobj0"));
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.GlobalObjectVariable, "func0\\static\\sobj1", target.Module.Name),
LookupSymbolEntry(tar.Symbols, "sobj1"));
Assert.IsTrue(
ldr.Options.TargetApplication.Variables.ContainsKey("func0\\static\\sobj1"));
}
示例9: TestDeclarations
public void TestDeclarations()
{
const string input1 =
@"
var obj0;
var obj1;
ref func0
[
Description ""Contains a constant value"";
is constant;
UsedBy func1;
];
ref func2;
function func1 does asm {}
ref func0 [ Add func2 to UsedBy; ];
function func2(arg0, arg1, arg2)
[
Uses { func0, func1 };
]
{//line# 20
goto L1;
L0:;
func0();
goto LE;
L1:;
func1();
goto L0;
LE:;
}
";
var ldr = new Loader(engine, target);
ldr.LoadFromString(input1);
Assert.AreEqual(0, ldr.ErrorCount);
var stored = ldr.Options.TargetApplication.StoreInString();
Console.WriteLine("//== 1st Store");
Console.WriteLine(stored);
var reldr = new Loader(engine, new Application());
reldr.LoadFromString(stored);
var restored = reldr.Options.TargetApplication.StoreInString();
Console.WriteLine("//== 2nd Store");
Console.WriteLine(restored);
//The two of them are not supposed to be equal because of a debug feature
/*Assert.IsTrue(Engine.StringsAreEqual(stored, restored),
storedShouldBeEqual); //*/
}
示例10: DefineGlobal
public void DefineGlobal()
{
//First declare the variables
const string input1 =
"declare var name1; " +
"declare ref name2; " +
"declare var value;";
var opt = new LoaderOptions(engine, target);
opt.UseIndicesLocally = false;
var ldr = new Loader(opt);
ldr.LoadFromString(input1);
Assert.AreEqual(
0, ldr.ErrorCount, "The compiler reported errors in the first chunk of code.");
var symbols = ldr.TopLevelSymbols;
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.GlobalObjectVariable, "name1", target.Module.Name),
LookupSymbolEntry(symbols, "name1"));
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.GlobalReferenceVariable, "name2", target.Module.Name),
LookupSymbolEntry(symbols, "name2"));
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.GlobalObjectVariable, "value", target.Module.Name),
LookupSymbolEntry(symbols, "value"));
//Then define them
const string input2 =
"var name1; " +
"ref name2 [ Description NotUseful; ]; " +
"var name3;";
ldr.LoadFromString(input2);
Assert.AreEqual(
0, ldr.ErrorCount, "The compiler reported errors in the second chunk of code.");
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.GlobalObjectVariable, "name1", target.Module.Name),
LookupSymbolEntry(symbols, "name1"));
Assert.IsNotNull(target.Variables["name1"]);
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.GlobalReferenceVariable, "name2", target.Module.Name),
LookupSymbolEntry(symbols, "name2"));
Assert.IsNotNull(target.Variables["name2"]);
Assert.AreEqual("NotUseful", target.Variables["name2"].Meta["description"].Text);
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.GlobalObjectVariable, "name3", target.Module.Name),
LookupSymbolEntry(symbols, "name3"));
Assert.IsNotNull(target.Variables["name3"]);
}
示例11: Redeclare
public void Redeclare()
{
const string input =
"declare function name1; " +
"declare var name2; " +
"declare ref name1, name2; " +
"declare function name1;";
var opt = new LoaderOptions(engine, target);
opt.UseIndicesLocally = false;
var ldr = new Loader(opt);
ldr.LoadFromString(input);
Assert.AreEqual(0, ldr.ErrorCount);
var symbols = ldr.TopLevelSymbols;
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.Function, "name1", target.Module.Name), LookupSymbolEntry(symbols, "name1"));
Assert.AreNotEqual(
new SymbolEntry(SymbolInterpretations.GlobalObjectVariable, "name2", target.Module.Name),
LookupSymbolEntry(symbols, "name2"));
Assert.AreNotEqual(
new SymbolEntry(SymbolInterpretations.GlobalReferenceVariable, "name1", target.Module.Name),
LookupSymbolEntry(symbols, "name1"));
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.GlobalReferenceVariable, "name2", target.Module.Name),
LookupSymbolEntry(symbols, "name2"));
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.Function, "name1", target.Module.Name), LookupSymbolEntry(symbols, "name1"));
const string input2 =
"declare function name1; " +
"declare function name2; ";
ldr.LoadFromString(input2);
Assert.AreEqual(0, ldr.ErrorCount);
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.Function, "name1", target.Module.Name), LookupSymbolEntry(symbols, "name1"));
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.Function, "name2", target.Module.Name), LookupSymbolEntry(symbols, "name2"));
}
示例12: Declare
public void Declare()
{
const string input =
"declare function f\\1; " +
"declare var go\\1; " +
"declare ref gf\\1, gf\\2; " +
"declare function if\\1;";
var opt = new LoaderOptions(engine, target) {UseIndicesLocally = false};
var ldr = new Loader(opt);
ldr.LoadFromString(input);
Assert.AreEqual(0, ldr.ErrorCount);
var symbols = ldr.TopLevelSymbols;
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.Function, "f\\1", target.Module.Name), LookupSymbolEntry(symbols, @"f\1"));
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.GlobalObjectVariable, "go\\1", target.Module.Name),
LookupSymbolEntry(symbols, @"go\1"));
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.GlobalReferenceVariable, "gf\\1", target.Module.Name),
LookupSymbolEntry(symbols, @"gf\1"));
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.GlobalReferenceVariable, "gf\\2", target.Module.Name),
LookupSymbolEntry(symbols, @"gf\2"));
Assert.AreEqual(
new SymbolEntry(SymbolInterpretations.Function, "if\\1", target.Module.Name), LookupSymbolEntry(symbols, @"if\1"));
}
示例13: AddingMetadata
public void AddingMetadata()
{
const string input1 =
"MyList { elem1, elem2, elem3 };";
var opt = new LoaderOptions(engine, target);
opt.UseIndicesLocally = false;
var ldr = new Loader(opt);
ldr.LoadFromString(input1);
Assert.AreEqual(0, ldr.ErrorCount);
Assert.IsTrue(target.Meta.ContainsKey("MyList"), "MyList missing");
Assert.IsTrue(target.Meta["MyList"].IsList, "MyList should be a list");
Assert.AreEqual(3, target.Meta["MyList"].List.Length);
Assert.AreEqual("elem2", target.Meta["MyList"].List[1].Text);
const string input2 =
"Add elem4 to MyList;";
ldr.LoadFromString(input2);
Assert.AreEqual(0, ldr.ErrorCount);
Assert.IsTrue(target.Meta.ContainsKey("MyList"), "MyList missing after modification");
Assert.IsTrue(
target.Meta["MyList"].IsList, "MyList should be a list, even after modification");
Assert.AreEqual(4, target.Meta["MyList"].List.Length);
Assert.AreEqual("elem4", target.Meta["MyList"].List[3].Text);
const string input3 =
"Add { elem5, elem6 } to MyList;";
ldr.LoadFromString(input3);
Assert.AreEqual(0, ldr.ErrorCount);
Assert.IsTrue(
target.Meta.ContainsKey("MyList"), "MyList missing after 2nd modification");
Assert.IsTrue(
target.Meta["MyList"].IsList, "MyList should be a list, even after 2nd modification");
Assert.AreEqual(6, target.Meta["MyList"].List.Length);
Assert.AreEqual("elem6", target.Meta["MyList"].List[5].Text);
const string input4 =
@"Import
{
System,
System::Text
};
Add System::Xml to Imports;
";
ldr.LoadFromString(input4);
Assert.AreEqual(0, ldr.ErrorCount, "There were errors during compilator of input4");
Assert.IsTrue(target.Meta.ContainsKey("Import"), "Import missing");
Assert.IsTrue(
target.Meta["Import"].IsList, "Import should be a list after 2nd modification");
Assert.AreEqual(3, target.Meta["Import"].List.Length);
Assert.AreEqual("System", target.Meta["Import"].List[0].Text);
Assert.AreEqual("System.Text", target.Meta["Import"].List[1].Text);
Assert.AreEqual("System.Xml", target.Meta["Import"].List[2].Text);
}
示例14: NestedMetadata
public void NestedMetadata()
{
const string input1 =
"FirstList { \"first String\", firstId, true, 55 } ;" +
"SecondList { \"second String\", { \"first }}Nested{ string\", secondNestedId }, thirdId }; ";
var opt = new LoaderOptions(engine, target);
opt.UseIndicesLocally = false;
var ldr = new Loader(opt);
ldr.LoadFromString(input1);
Assert.AreEqual(0, ldr.ErrorCount);
//First list
Assert.IsTrue(target.Meta.ContainsKey("firstList"), "firstList missing");
Assert.IsTrue(target.Meta["firstList"].IsList, "firstList should be a list");
Assert.AreEqual("first String", target.Meta["firstList"].List[0].Text);
Assert.AreEqual("firstId", target.Meta["firstList"].List[1].Text);
Assert.AreEqual(true, target.Meta["firstList"].List[2].Switch);
Assert.AreEqual("55", target.Meta["firstList"].List[3].Text);
//Second list
Assert.IsTrue(target.Meta.ContainsKey("secondList"), "secondList missing");
Assert.IsTrue(target.Meta["secondList"].IsList, "secondList should be a list");
Assert.AreEqual("second String", target.Meta["secondList"].List[0].Text);
Assert.IsTrue(
target.Meta["secondList"].List[1].IsList, "second element should be a list");
Assert.AreEqual(
"first }}Nested{ string", target.Meta["secondList"].List[1].List[0].Text);
Assert.AreEqual("secondNestedId", target.Meta["secondList"].List[1].List[1].Text);
Assert.AreEqual("thirdId", target.Meta["secondList"].List[2].Text);
}
示例15: _justCompile
private Loader _justCompile(string input)
{
var opt = new LoaderOptions(engine, target) {UseIndicesLocally = false};
var ldr = new Loader(opt);
ldr.LoadFromString(input);
return ldr;
}