Context Navigation

source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/CodeExpressionTests.cs @ 14875

Visit:

Last change on this file since 14875 was 14834, checked in by pkimmesw, 8 years ago
#2665 LexicaseSelector, Performance improvements, UI Fixes, Debugger only shows used stacks, fixed Debugger stepping, Added vector expressions, ERCOptions,
File size: 34.7 KB

Rev	Line
[14727]	1	namespace HeuristicLab.Tests.Interpreter.Expressions {
	2	using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
	3	using HeuristicLab.Problems.ProgramSynthesis.Push.Parser;
	4	using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;
	5	using Microsoft.VisualStudio.TestTools.UnitTesting;
	6
	7
	8	[TestClass]
	9	public class CodeExpressionTests : CommonTests<Expression> {
	10	protected override string TypeName
	11	{
	12	get
	13	{
	14	return "CODE";
	15	}
	16	}
	17
[14834]	18	protected override IPushStack<Expression> Stack
[14727]	19	{
	20	get
	21	{
	22	return this.interpreter.CodeStack;
	23	}
	24	}
	25
	26	[TestMethod]
	27	[TestProperty("Time", "Short")]
	28	[TestCategory("ExpressionTest")]
	29	[TestCategory("CodeExpressionTest")]
	30	public void TestAppendLists() {
[14733]	31	var first = PushParser.Parse("( A )");
	32	var second = PushParser.Parse("( B )");
	33	var result = PushParser.Parse("( A B )");
[14727]	34
	35	this.interpreter.CodeStack.Push(second, first);
	36	this.interpreter.Run(new CodeAppendExpression());
	37
	38	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	39	this.CheckOtherStacksAreEmpty();
	40	}
	41
	42	[TestMethod]
	43	[TestProperty("Time", "Short")]
	44	[TestCategory("ExpressionTest")]
	45	[TestCategory("CodeExpressionTest")]
	46	public void TestAppendListAndLiteral() {
[14733]	47	var first = PushParser.Parse("( A )");
	48	var second = PushParser.Parse("5");
	49	var result = PushParser.Parse("( A 5 )");
[14727]	50
	51	this.interpreter.CodeStack.Push(second, first);
	52	this.interpreter.Run(new CodeAppendExpression());
	53
	54	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	55	this.CheckOtherStacksAreEmpty();
	56	}
	57
	58	[TestMethod]
	59	[TestProperty("Time", "Short")]
	60	[TestCategory("ExpressionTest")]
	61	[TestCategory("CodeExpressionTest")]
	62	public void TestAppendLiterals() {
[14733]	63	var first = PushParser.Parse("4");
	64	var second = PushParser.Parse("5");
	65	var result = PushParser.Parse("( 4 5 )");
[14727]	66
	67	this.interpreter.CodeStack.Push(second, first);
	68	this.interpreter.Run(new CodeAppendExpression());
	69
	70	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	71	this.CheckOtherStacksAreEmpty();
	72	}
	73
	74	[TestMethod]
	75	[TestProperty("Time", "Short")]
	76	[TestCategory("ExpressionTest")]
	77	[TestCategory("CodeExpressionTest")]
	78	public void TestDuplicateList() {
[14733]	79	var list = PushParser.Parse("( A B C )");
	80	var result = PushParser.Parse("( A B C )");
[14727]	81
	82	this.interpreter.CodeStack.Push(list);
	83	this.interpreter.Run(new CodeDuplicateExpression());
	84
	85	Assert.AreEqual(this.Stack.Count, 2);
	86	Assert.AreEqual(this.Stack[0], list);
	87	Assert.AreEqual(this.Stack[1], result);
	88
	89	this.CheckOtherStacksAreEmpty();
	90	}
	91
	92	[TestMethod]
	93	[TestProperty("Time", "Short")]
	94	[TestCategory("ExpressionTest")]
	95	[TestCategory("CodeExpressionTest")]
	96	public void TestAtomList() {
[14733]	97	var first = PushParser.Parse("( A )");
[14727]	98
	99	this.interpreter.CodeStack.Push(first);
	100	this.interpreter.Run(new CodeAtomExpression());
	101
	102	Assert.AreEqual(false, this.interpreter.BooleanStack.Top);
	103	this.TestStackCounts(booleanStack: 1);
	104	}
	105
	106	[TestMethod]
	107	[TestProperty("Time", "Short")]
	108	[TestCategory("ExpressionTest")]
	109	[TestCategory("CodeExpressionTest")]
	110	public void TestAtomLiteral() {
[14733]	111	var first = PushParser.Parse("5");
[14727]	112
	113	this.interpreter.CodeStack.Push(first);
	114	this.interpreter.Run(new CodeAtomExpression());
	115
	116	Assert.AreEqual(true, this.interpreter.BooleanStack.Top);
	117	this.TestStackCounts(booleanStack: 1);
	118	}
	119
	120	[TestMethod]
	121	[TestProperty("Time", "Short")]
	122	[TestCategory("ExpressionTest")]
	123	[TestCategory("CodeExpressionTest")]
	124	public void TestAtomSingleInstruction() {
[14733]	125	var first = PushParser.Parse("INTEGER.+");
[14727]	126
	127	this.interpreter.CodeStack.Push(first);
	128	this.interpreter.Run(new CodeAtomExpression());
	129
	130	Assert.AreEqual(true, this.interpreter.BooleanStack.Top);
	131	this.TestStackCounts(booleanStack: 1);
	132	}
	133
	134	[TestMethod]
	135	[TestProperty("Time", "Short")]
	136	[TestCategory("ExpressionTest")]
	137	[TestCategory("CodeExpressionTest")]
	138	public void TestCarList() {
[14733]	139	var first = PushParser.Parse("( A B C )");
	140	var result = PushParser.Parse("A");
[14727]	141
	142	this.interpreter.CodeStack.Push(first);
	143	this.interpreter.Run(new CodeCarExpression());
	144
	145	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	146	this.CheckOtherStacksAreEmpty();
	147	}
	148
	149	[TestMethod]
	150	[TestProperty("Time", "Short")]
	151	[TestCategory("ExpressionTest")]
	152	[TestCategory("CodeExpressionTest")]
	153	public void TestCarNoList() {
[14733]	154	var first = PushParser.Parse("5");
	155	var result = PushParser.Parse("5");
[14727]	156
	157	this.interpreter.CodeStack.Push(first);
	158	this.interpreter.Run(new CodeCarExpression());
	159
	160	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	161	this.CheckOtherStacksAreEmpty();
	162	}
	163
	164	[TestMethod]
	165	[TestProperty("Time", "Short")]
	166	[TestCategory("ExpressionTest")]
	167	[TestCategory("CodeExpressionTest")]
	168	public void TestCdrList() {
[14733]	169	var first = PushParser.Parse("( A B C )");
	170	var result = PushParser.Parse("( B C )");
[14727]	171
	172	this.interpreter.CodeStack.Push(first);
	173	this.interpreter.Run(new CodeCdrExpression());
	174
	175	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	176	this.CheckOtherStacksAreEmpty();
	177	}
	178
	179	[TestMethod]
	180	[TestProperty("Time", "Short")]
	181	[TestCategory("ExpressionTest")]
	182	[TestCategory("CodeExpressionTest")]
	183	public void TestCdrNoList() {
[14733]	184	var first = PushParser.Parse("5");
	185	var result = PushParser.Parse("( )");
[14727]	186
	187	this.interpreter.CodeStack.Push(first);
	188	this.interpreter.Run(new CodeCdrExpression());
	189
	190	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	191	this.CheckOtherStacksAreEmpty();
	192	}
	193
	194	[TestMethod]
	195	[TestProperty("Time", "Short")]
	196	[TestCategory("ExpressionTest")]
	197	[TestCategory("CodeExpressionTest")]
	198	public void TestCons() {
[14733]	199	var first = PushParser.Parse("( B C )");
	200	var second = PushParser.Parse("A");
	201	var result = PushParser.Parse("( A B C )");
[14727]	202
	203	this.interpreter.CodeStack.Push(second, first);
	204	this.interpreter.Run(new CodeConsExpression());
	205
	206	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	207	this.CheckOtherStacksAreEmpty();
	208	}
	209
	210	[TestMethod]
	211	[TestProperty("Time", "Short")]
	212	[TestCategory("ExpressionTest")]
	213	[TestCategory("CodeExpressionTest")]
	214	public void TestContainsTrue() {
[14733]	215	var first = PushParser.Parse("A");
	216	var second = PushParser.Parse("( A B C )");
[14727]	217
	218	this.interpreter.CodeStack.Push(second, first);
	219	this.interpreter.Run(new CodeContainsExpression());
	220
	221	Assert.AreEqual(true, this.interpreter.BooleanStack.Top);
	222	this.TestStackCounts(booleanStack: 1);
	223	}
	224
	225	[TestMethod]
	226	[TestProperty("Time", "Short")]
	227	[TestCategory("ExpressionTest")]
	228	[TestCategory("CodeExpressionTest")]
	229	public void TestContainsFalse() {
[14733]	230	var first = PushParser.Parse("D");
	231	var second = PushParser.Parse("( A B C )");
[14727]	232
	233	this.interpreter.CodeStack.Push(second, first);
	234	this.interpreter.Run(new CodeContainsExpression());
	235
	236	Assert.AreEqual(false, this.interpreter.BooleanStack.Top);
	237	this.TestStackCounts(booleanStack: 1);
	238	}
	239
	240	[TestMethod]
	241	[TestProperty("Time", "Short")]
	242	[TestCategory("ExpressionTest")]
	243	[TestCategory("CodeExpressionTest")]
	244	public void TestContainer() {
[14733]	245	var first = PushParser.Parse("( A )");
	246	var second = PushParser.Parse("( B ( C ( A ) ) ( D ( A ) ) )");
	247	var result = PushParser.Parse("( C ( A ) )");
[14727]	248
	249	this.interpreter.CodeStack.Push(second, first);
	250	this.interpreter.Run(new CodeContainerExpression());
	251
	252	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	253	this.CheckOtherStacksAreEmpty();
	254	}
	255
	256	[TestMethod]
	257	[TestProperty("Time", "Short")]
	258	[TestCategory("ExpressionTest")]
	259	[TestCategory("CodeExpressionTest")]
	260	public void TestDefinition() {
[14733]	261	var code = PushParser.Parse("( A )");
[14727]	262
	263	this.interpreter.CustomExpressions.Add("Test", code);
	264	this.interpreter.NameStack.Push("Test");
	265
	266	this.interpreter.Run(new CodeDefinitionExpression());
	267
	268	Assert.AreEqual(code, this.interpreter.CodeStack.Top);
	269	this.CheckOtherStacksAreEmpty();
	270	}
	271
	272	[TestMethod]
	273	[TestProperty("Time", "Short")]
	274	[TestCategory("ExpressionTest")]
	275	[TestCategory("CodeExpressionTest")]
	276	public void TestDefinitionWithoutMatchingName() {
[14733]	277	var code = PushParser.Parse("( A )");
[14727]	278	var program = new CodeDefinitionExpression();
	279
	280	this.interpreter.CustomExpressions.Add("Test1", code);
	281	this.interpreter.NameStack.Push("Test2");
	282	this.interpreter.Run(program);
	283
	284	this.TestStackCounts(nameStack: 1);
	285	}
	286
	287	[TestMethod]
	288	[TestProperty("Time", "Short")]
	289	[TestCategory("ExpressionTest")]
	290	[TestCategory("CodeExpressionTest")]
	291	public void TestDiscrepancy() {
[14733]	292	var first = PushParser.Parse("( A B )");
	293	var second = PushParser.Parse("( B C )");
[14727]	294
	295	this.interpreter.CodeStack.Push(second, first);
	296	this.interpreter.Run(new CodeDiscrepancyExpression());
	297
	298	Assert.AreEqual(2, this.interpreter.IntegerStack.Top);
	299	this.TestStackCounts(integerStack: 1);
	300	}
	301
	302	[TestMethod]
	303	[TestProperty("Time", "Short")]
	304	[TestCategory("ExpressionTest")]
	305	[TestCategory("CodeExpressionTest")]
	306	public void TestDiscrepancyAllEqual() {
[14733]	307	var first = PushParser.Parse("( A B )");
	308	var second = PushParser.Parse("( B A )");
[14727]	309
	310	this.interpreter.CodeStack.Push(second, first);
	311	this.interpreter.Run(new CodeDiscrepancyExpression());
	312
	313	Assert.AreEqual(0, this.interpreter.IntegerStack.Top);
	314	this.TestStackCounts(integerStack: 1);
	315	}
	316
	317	[TestMethod]
	318	[TestProperty("Time", "Short")]
	319	[TestCategory("ExpressionTest")]
	320	[TestCategory("CodeExpressionTest")]
	321	public void TestDiscrepancyComplex() {
[14733]	322	var first = PushParser.Parse("( A A B C D A )");
	323	var second = PushParser.Parse("( A A B D E )");
[14727]	324
	325	this.interpreter.CodeStack.Push(second, first);
	326	this.interpreter.Run(new CodeDiscrepancyExpression());
	327
	328	Assert.AreEqual(3, this.interpreter.IntegerStack.Top);
	329	this.TestStackCounts(integerStack: 1);
	330	}
	331
	332	[TestMethod]
	333	[TestProperty("Time", "Short")]
	334	[TestCategory("ExpressionTest")]
	335	[TestCategory("CodeExpressionTest")]
	336	public void TestDiscrepancWithLists() {
[14733]	337	var first = PushParser.Parse("( ( A ) A ( B ) C D A )");
	338	var second = PushParser.Parse("( A ( A ) B D E )");
[14727]	339
	340	this.interpreter.CodeStack.Push(second, first);
	341	this.interpreter.Run(new CodeDiscrepancyExpression());
	342
	343	Assert.AreEqual(5, this.interpreter.IntegerStack.Top);
	344	this.TestStackCounts(integerStack: 1);
	345	}
	346
	347	[TestMethod]
	348	[TestProperty("Time", "Short")]
	349	[TestCategory("ExpressionTest")]
	350	[TestCategory("CodeExpressionTest")]
	351	public void TestDo() {
[14733]	352	var prog = PushParser.Parse("( 10 )");
[14727]	353
	354	this.interpreter.CodeStack.Push(prog);
	355	this.interpreter.Run(new CodeDoExpression());
	356
	357	Assert.AreEqual(10, this.interpreter.IntegerStack.Top);
	358	this.TestStackCounts(integerStack: 1);
	359	}
	360
	361	[TestMethod]
	362	[TestProperty("Time", "Short")]
	363	[TestCategory("ExpressionTest")]
	364	[TestCategory("CodeExpressionTest")]
	365	public void TestDoX() {
[14733]	366	var prog = PushParser.Parse("( 10 )");
[14727]	367
	368	this.interpreter.CodeStack.Push(prog);
	369	this.interpreter.Run(new CodeDoXExpression());
	370
	371	Assert.AreEqual(10, this.interpreter.IntegerStack.Top);
	372	this.TestStackCounts(integerStack: 1);
	373	}
	374
	375	[TestMethod]
	376	[TestProperty("Time", "Short")]
	377	[TestCategory("ExpressionTest")]
	378	[TestCategory("CodeExpressionTest")]
	379	public void TestDoCount() {
[14733]	380	var prog = PushParser.Parse("INTEGER.+");
[14727]	381
	382	this.interpreter.IntegerStack.Push(3);
	383	this.interpreter.CodeStack.Push(prog);
	384	this.interpreter.Run(new CodeDoCountExpression());
	385
	386	Assert.AreEqual(6, this.interpreter.IntegerStack.Top);
	387	this.TestStackCounts(integerStack: 1);
	388	}
	389
	390	[TestMethod]
	391	[TestProperty("Time", "Short")]
	392	[TestCategory("ExpressionTest")]
	393	[TestCategory("CodeExpressionTest")]
	394	public void TestDoCountWithNegativeCounter() {
[14733]	395	var prog = PushParser.Parse("INTEGER.+");
[14727]	396
	397	this.interpreter.IntegerStack.Push(-1);
	398	this.interpreter.CodeStack.Push(prog);
	399	this.interpreter.Run(new CodeDoCountExpression());
	400
	401	Assert.AreEqual(-1, this.interpreter.IntegerStack.Top);
	402	this.TestStackCounts(codeStack: 1, integerStack: 1);
	403	}
	404
	405	[TestMethod]
	406	[TestProperty("Time", "Short")]
	407	[TestCategory("ExpressionTest")]
	408	[TestCategory("CodeExpressionTest")]
	409	public void TestDoRange() {
[14733]	410	var prog = PushParser.Parse("INTEGER.+");
[14727]	411
	412	this.interpreter.IntegerStack.Push(3, 5);
	413	this.interpreter.CodeStack.Push(prog);
	414	this.interpreter.Run(new CodeDoRangeExpression());
	415
	416	Assert.AreEqual(12, this.interpreter.IntegerStack.Top);
	417	this.TestStackCounts(integerStack: 1);
	418	}
	419
	420	[TestMethod]
	421	[TestProperty("Time", "Short")]
	422	[TestCategory("ExpressionTest")]
	423	[TestCategory("CodeExpressionTest")]
	424	public void TestDoRangeWithEqualIndecators() {
[14733]	425	var prog = PushParser.Parse("INTEGER.+");
[14727]	426
	427	this.interpreter.IntegerStack.Push(3, 3);
	428	this.interpreter.CodeStack.Push(prog);
	429	this.interpreter.Run(new CodeDoRangeExpression());
	430
	431	Assert.AreEqual(3, this.interpreter.IntegerStack.Top);
	432	this.TestStackCounts(codeStack: 1, integerStack: 2);
	433	}
	434
	435	[TestMethod]
	436	[TestProperty("Time", "Short")]
	437	[TestCategory("ExpressionTest")]
	438	[TestCategory("CodeExpressionTest")]
	439	public void TestDoRangeWithNegativeIndecators() {
[14733]	440	var prog = PushParser.Parse("INTEGER.+");
[14727]	441
	442	this.interpreter.IntegerStack.Push(-3, -5);
	443	this.interpreter.CodeStack.Push(prog);
	444	this.interpreter.Run(new CodeDoRangeExpression());
	445
	446	Assert.AreEqual(-12, this.interpreter.IntegerStack.Top);
	447	this.TestStackCounts(integerStack: 1);
	448	}
	449
	450	[TestMethod]
	451	[TestProperty("Time", "Short")]
	452	[TestCategory("ExpressionTest")]
	453	[TestCategory("CodeExpressionTest")]
	454	public void TestDoTimes() {
[14733]	455	var prog = PushParser.Parse("( INTEGER.DUP INTEGER.+ )");
[14727]	456
	457	this.interpreter.IntegerStack.Push(2, 3);
	458	this.interpreter.CodeStack.Push(prog);
	459	this.interpreter.Run(new CodeDoTimesExpression());
	460
	461	Assert.AreEqual(32, this.interpreter.IntegerStack.Top);
	462	this.TestStackCounts(integerStack: 1);
	463	}
	464
	465	[TestMethod]
	466	[TestProperty("Time", "Short")]
	467	[TestCategory("ExpressionTest")]
	468	[TestCategory("CodeExpressionTest")]
	469	public void TestDoTimesWithNegativeCounter() {
[14733]	470	var prog = PushParser.Parse("( INTEGER.DUP INTEGER.+ )");
[14727]	471
	472	this.interpreter.IntegerStack.Push(2, -3);
	473	this.interpreter.CodeStack.Push(prog);
	474	this.interpreter.Run(new CodeDoTimesExpression());
	475
	476	Assert.AreEqual(-3, this.interpreter.IntegerStack.Top);
	477	this.TestStackCounts(codeStack: 1, integerStack: 2);
	478	}
	479
	480	[TestMethod]
	481	[TestProperty("Time", "Short")]
	482	[TestCategory("ExpressionTest")]
	483	[TestCategory("CodeExpressionTest")]
	484	public void TestNestedDoRange() {
	485	this.interpreter.Run(
	486	"( 0 2 CODE.QUOTE ( 1 INTEGER.+ 0 3 CODE.QUOTE ( 1 INTEGER.+ INTEGER.* ) CODE.DORANGE INTEGER.+ ) CODE.DORANGE )");
	487
	488	Assert.AreEqual(144, this.interpreter.IntegerStack.Top);
	489	this.TestStackCounts(integerStack: 1);
	490	}
	491
	492	[TestMethod]
	493	[TestProperty("Time", "Short")]
	494	[TestCategory("ExpressionTest")]
	495	[TestCategory("CodeExpressionTest")]
	496	public void TestNestedDoCount() {
	497	this.interpreter.Run(
	498	"( 2 CODE.QUOTE ( 1 INTEGER.+ 3 CODE.QUOTE ( 1 INTEGER.+ INTEGER.* ) CODE.DOCOUNT INTEGER.+ ) CODE.DOCOUNT )");
	499
	500	Assert.AreEqual(144, this.interpreter.IntegerStack.Top);
	501	this.TestStackCounts(integerStack: 1);
	502	}
	503
	504	[TestMethod]
	505	[TestProperty("Time", "Short")]
	506	[TestCategory("ExpressionTest")]
	507	[TestCategory("CodeExpressionTest")]
	508	public void TestNestedDoTimes() {
	509	this.interpreter.Run(
	510	"( 3 CODE.QUOTE ( 2 3 CODE.QUOTE ( 2 INTEGER.* ) CODE.DOTIMES INTEGER.+ ) CODE.DOTIMES )");
	511
	512	Assert.AreEqual(128, this.interpreter.IntegerStack.Top);
	513	this.TestStackCounts(integerStack: 1);
	514	}
	515
	516	[TestMethod]
	517	[TestProperty("Time", "Short")]
	518	[TestCategory("ExpressionTest")]
	519	[TestCategory("CodeExpressionTest")]
	520	public void TestExtract() {
[14733]	521	var prog = PushParser.Parse("( A ( B C ( D ) E ) F G H I J ( K ) L )");
	522	var result = PushParser.Parse("( D )");
[14727]	523
	524	this.interpreter.IntegerStack.Push(5);
	525	this.interpreter.CodeStack.Push(prog);
	526	this.interpreter.Run(new CodeExtractExpression());
	527
	528	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	529	this.CheckOtherStacksAreEmpty();
	530	}
	531
	532	[TestMethod]
	533	[TestProperty("Time", "Short")]
	534	[TestCategory("ExpressionTest")]
	535	[TestCategory("CodeExpressionTest")]
	536	public void TestExtractInteger() {
[14733]	537	var prog = PushParser.Parse("( A ( 5 C ( 4.2 ) INTEGER.+ ) FALSE )");
	538	var result = PushParser.Parse("5");
[14727]	539
	540	this.interpreter.IntegerStack.Push(3);
	541	this.interpreter.CodeStack.Push(prog);
	542	this.interpreter.Run(new CodeExtractExpression());
	543
	544	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	545	this.CheckOtherStacksAreEmpty();
	546	}
	547
	548	[TestMethod]
	549	[TestProperty("Time", "Short")]
	550	[TestCategory("ExpressionTest")]
	551	[TestCategory("CodeExpressionTest")]
	552	public void TestExtractFloat() {
[14733]	553	var prog = PushParser.Parse("( A ( 5 C ( 4.2 ) INTEGER.+ ) FALSE )");
	554	var result = PushParser.Parse("4.2");
[14727]	555
	556	this.interpreter.IntegerStack.Push(6);
	557	this.interpreter.CodeStack.Push(prog);
	558	this.interpreter.Run(new CodeExtractExpression());
	559
	560	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	561	this.CheckOtherStacksAreEmpty();
	562	}
	563
	564	[TestMethod]
	565	[TestProperty("Time", "Short")]
	566	[TestCategory("ExpressionTest")]
	567	[TestCategory("CodeExpressionTest")]
	568	public void TestExtractBoolean() {
[14733]	569	var prog = PushParser.Parse("( A ( 5 C ( 4.2 ) INTEGER.+ ) FALSE )");
	570	var result = PushParser.Parse("FALSE");
[14727]	571
	572	this.interpreter.IntegerStack.Push(8);
	573	this.interpreter.CodeStack.Push(prog);
	574	this.interpreter.Run(new CodeExtractExpression());
	575
	576	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	577	this.CheckOtherStacksAreEmpty();
	578	}
	579
	580	[TestMethod]
	581	[TestProperty("Time", "Short")]
	582	[TestCategory("ExpressionTest")]
	583	[TestCategory("CodeExpressionTest")]
	584	public void TestExtractInstruction() {
[14733]	585	var prog = PushParser.Parse("( A ( 5 C ( 4.2 ) INTEGER.+ ) FALSE )");
	586	var result = PushParser.Parse("INTEGER.+");
[14727]	587
	588	this.interpreter.IntegerStack.Push(7);
	589	this.interpreter.CodeStack.Push(prog);
	590	this.interpreter.Run(new CodeExtractExpression());
	591
	592	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	593	this.CheckOtherStacksAreEmpty();
	594	}
	595
	596	[TestMethod]
	597	[TestProperty("Time", "Short")]
	598	[TestCategory("ExpressionTest")]
	599	[TestCategory("CodeExpressionTest")]
	600	public void TestFromBoolean() {
[14733]	601	var result = PushParser.Parse("FALSE");
[14727]	602	this.interpreter.BooleanStack.Push(false);
	603	this.interpreter.Run(new CodeFromBooleanExpression());
	604
	605	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	606	this.CheckOtherStacksAreEmpty();
	607	}
	608
	609	[TestMethod]
	610	[TestProperty("Time", "Short")]
	611	[TestCategory("ExpressionTest")]
	612	[TestCategory("CodeExpressionTest")]
	613	public void TestFromFloat() {
[14733]	614	var result = PushParser.Parse("4.1");
[14727]	615	this.interpreter.FloatStack.Push(4.1);
	616	this.interpreter.Run(new CodeFromFloatExpression());
	617
	618	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	619	this.CheckOtherStacksAreEmpty();
	620	}
	621
	622	[TestMethod]
	623	[TestProperty("Time", "Short")]
	624	[TestCategory("ExpressionTest")]
	625	[TestCategory("CodeExpressionTest")]
	626	public void TestFromInteger() {
[14733]	627	var result = PushParser.Parse("4");
[14727]	628	this.interpreter.IntegerStack.Push(4);
	629	this.interpreter.Run(new CodeFromIntegerExpression());
	630
	631	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	632	this.CheckOtherStacksAreEmpty();
	633	}
	634
	635	[TestMethod]
	636	[TestProperty("Time", "Short")]
	637	[TestCategory("ExpressionTest")]
	638	[TestCategory("CodeExpressionTest")]
	639	public void TestFromName() {
[14733]	640	var result = PushParser.Parse("A");
[14727]	641	this.interpreter.NameStack.Push("A");
	642	this.interpreter.Run(new CodeFromNameExpression());
	643
	644	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	645	this.CheckOtherStacksAreEmpty();
	646	}
	647
	648	[TestMethod]
	649	[TestProperty("Time", "Short")]
	650	[TestCategory("ExpressionTest")]
	651	[TestCategory("CodeExpressionTest")]
	652	public void TestIfTrue() {
[14733]	653	var first = PushParser.Parse("FALSCH");
	654	var second = PushParser.Parse("WAHR");
[14727]	655
	656	this.interpreter.BooleanStack.Push(true);
	657	this.interpreter.CodeStack.Push(second, first);
	658	this.interpreter.Run(new CodeIfExpression());
	659
	660	Assert.AreEqual("WAHR", this.interpreter.NameStack.Top);
	661	this.TestStackCounts(nameStack: 1);
	662	}
	663
	664	[TestMethod]
	665	[TestProperty("Time", "Short")]
	666	[TestCategory("ExpressionTest")]
	667	[TestCategory("CodeExpressionTest")]
	668	public void TestIfFalse() {
[14733]	669	var first = PushParser.Parse("FALSCH");
	670	var second = PushParser.Parse("WAHR");
[14727]	671
	672	this.interpreter.BooleanStack.Push(false);
	673	this.interpreter.CodeStack.Push(second, first);
	674	this.interpreter.Run(new CodeIfExpression());
	675
	676	Assert.AreEqual("FALSCH", this.interpreter.NameStack.Top);
	677	this.TestStackCounts(nameStack: 1);
	678	}
	679
	680	[TestMethod]
	681	[TestProperty("Time", "Short")]
	682	[TestCategory("ExpressionTest")]
	683	[TestCategory("CodeExpressionTest")]
	684	public void TestInsert() {
[14733]	685	var first = PushParser.Parse("( A ( B ) C D )");
	686	var second = PushParser.Parse("( E )");
	687	var result = PushParser.Parse("( A ( B ) ( E ) D )");
[14727]	688
	689	this.interpreter.IntegerStack.Push(2);
	690	this.interpreter.CodeStack.Push(second, first);
	691	this.interpreter.Run(new CodeInsertExpression());
	692
	693	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	694	this.CheckOtherStacksAreEmpty();
	695	}
	696
	697	[TestMethod]
	698	[TestProperty("Time", "Short")]
	699	[TestCategory("ExpressionTest")]
	700	[TestCategory("CodeExpressionTest")]
	701	public void TestInsertWithNegativeN() {
[14733]	702	var first = PushParser.Parse("( A ( B ) C D )");
	703	var second = PushParser.Parse("( E )");
	704	var result = PushParser.Parse("( A ( B ) ( E ) D )");
[14727]	705
	706	this.interpreter.IntegerStack.Push(-2);
	707	this.interpreter.CodeStack.Push(second, first);
	708	this.interpreter.Run(new CodeInsertExpression());
	709
	710	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	711	this.CheckOtherStacksAreEmpty();
	712	}
	713
	714	[TestMethod]
	715	[TestProperty("Time", "Short")]
	716	[TestCategory("ExpressionTest")]
	717	[TestCategory("CodeExpressionTest")]
	718	public void TestInsertWithTooBigN() {
[14733]	719	var first = PushParser.Parse("( A ( B ) C D )");
	720	var second = PushParser.Parse("( E )");
	721	var result = PushParser.Parse("( A ( B ) ( E ) D )");
[14727]	722
	723	this.interpreter.IntegerStack.Push(10);
	724	this.interpreter.CodeStack.Push(second, first);
	725	this.interpreter.Run(new CodeInsertExpression());
	726
	727	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	728	this.CheckOtherStacksAreEmpty();
	729	}
	730
	731	[TestMethod]
	732	[TestProperty("Time", "Short")]
	733	[TestCategory("ExpressionTest")]
	734	[TestCategory("CodeExpressionTest")]
	735	public void TestList() {
[14733]	736	var first = PushParser.Parse("A");
	737	var second = PushParser.Parse("( B )");
	738	var result = PushParser.Parse("( A ( B ) )");
[14727]	739
	740	this.interpreter.CodeStack.Push(second, first);
	741	this.interpreter.Run(new CodeListExpression());
	742
	743	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	744	this.CheckOtherStacksAreEmpty();
	745	}
	746
	747	[TestMethod]
	748	[TestProperty("Time", "Short")]
	749	[TestCategory("ExpressionTest")]
	750	[TestCategory("CodeExpressionTest")]
	751	public void TestMemberTrue() {
[14733]	752	var first = PushParser.Parse("( A B ( B ) C ");
	753	var second = PushParser.Parse("( B )");
[14727]	754
	755	this.interpreter.CodeStack.Push(second, first);
	756	this.interpreter.Run(new CodeMemberExpression());
	757
	758	Assert.AreEqual(true, this.interpreter.BooleanStack.Top);
	759	this.TestStackCounts(booleanStack: 1);
	760	}
	761
	762	[TestMethod]
	763	[TestProperty("Time", "Short")]
	764	[TestCategory("ExpressionTest")]
	765	[TestCategory("CodeExpressionTest")]
	766	public void TestMemberFalse() {
[14733]	767	var first = PushParser.Parse("( A B C ");
	768	var second = PushParser.Parse("( B )");
[14727]	769
	770	this.interpreter.CodeStack.Push(second, first);
	771	this.interpreter.Run(new CodeMemberExpression());
	772
	773	Assert.AreEqual(false, this.interpreter.BooleanStack.Top);
	774	this.TestStackCounts(booleanStack: 1);
	775	}
	776
	777	[TestMethod]
	778	[TestProperty("Time", "Short")]
	779	[TestCategory("ExpressionTest")]
	780	[TestCategory("CodeExpressionTest")]
	781	public void TestMemberIfNoList() {
[14733]	782	var first = PushParser.Parse("B");
	783	var second = PushParser.Parse("B");
[14727]	784
	785	this.interpreter.CodeStack.Push(second, first);
	786	this.interpreter.Run(new CodeMemberExpression());
	787
	788	Assert.AreEqual(true, this.interpreter.BooleanStack.Top);
	789	this.TestStackCounts(booleanStack: 1);
	790	}
	791
	792	[TestMethod]
	793	[TestProperty("Time", "Short")]
	794	[TestCategory("ExpressionTest")]
	795	[TestCategory("CodeExpressionTest")]
	796	public void TestNoop() {
	797	this.interpreter.Run(new CodeNoopExpression());
	798
	799	this.CheckOtherStacksAreEmpty();
	800	}
	801
	802	[TestMethod]
	803	[TestProperty("Time", "Short")]
	804	[TestCategory("ExpressionTest")]
	805	[TestCategory("CodeExpressionTest")]
	806	public void TestNthIfNoList() {
[14733]	807	var prog = PushParser.Parse("A");
	808	var result = PushParser.Parse("A");
[14727]	809
	810	this.interpreter.IntegerStack.Push(3);
	811	this.interpreter.CodeStack.Push(prog);
	812	this.interpreter.Run(new CodeNthExpression());
	813
	814	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	815	this.CheckOtherStacksAreEmpty();
	816	}
	817
	818	[TestMethod]
	819	[TestProperty("Time", "Short")]
	820	[TestCategory("ExpressionTest")]
	821	[TestCategory("CodeExpressionTest")]
	822	public void TestNthIfEmpty() {
[14733]	823	var prog = PushParser.Parse("( )");
	824	var result = PushParser.Parse("( )");
[14727]	825
	826	this.interpreter.IntegerStack.Push(3);
	827	this.interpreter.CodeStack.Push(prog);
	828	this.interpreter.Run(new CodeNthExpression());
	829
	830	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	831	this.CheckOtherStacksAreEmpty();
	832	}
	833
	834	[TestMethod]
	835	[TestProperty("Time", "Short")]
	836	[TestCategory("ExpressionTest")]
	837	[TestCategory("CodeExpressionTest")]
	838	public void TestNth() {
[14733]	839	var prog = PushParser.Parse("( A B C D E )");
	840	var result = PushParser.Parse("D");
[14727]	841
	842	this.interpreter.IntegerStack.Push(3);
	843	this.interpreter.CodeStack.Push(prog);
	844	this.interpreter.Run(new CodeNthExpression());
	845
	846	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	847	this.CheckOtherStacksAreEmpty();
	848	}
	849
	850	[TestMethod]
	851	[TestProperty("Time", "Short")]
	852	[TestCategory("ExpressionTest")]
	853	[TestCategory("CodeExpressionTest")]
	854	public void TestNthWithTooBigN() {
[14733]	855	var prog = PushParser.Parse("( A B C D E )");
	856	var result = PushParser.Parse("D");
[14727]	857
	858	this.interpreter.IntegerStack.Push(13);
	859	this.interpreter.CodeStack.Push(prog);
	860	this.interpreter.Run(new CodeNthExpression());
	861
	862	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	863	this.CheckOtherStacksAreEmpty();
	864	}
	865
	866	[TestMethod]
	867	[TestProperty("Time", "Short")]
	868	[TestCategory("ExpressionTest")]
	869	[TestCategory("CodeExpressionTest")]
	870	public void TestNthWithNegativeN() {
[14733]	871	var prog = PushParser.Parse("( A B C D E )");
	872	var result = PushParser.Parse("D");
[14727]	873
	874	this.interpreter.IntegerStack.Push(-3);
	875	this.interpreter.CodeStack.Push(prog);
	876	this.interpreter.Run(new CodeNthExpression());
	877
	878	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	879	this.CheckOtherStacksAreEmpty();
	880	}
	881
	882	[TestMethod]
	883	[TestProperty("Time", "Short")]
	884	[TestCategory("ExpressionTest")]
	885	[TestCategory("CodeExpressionTest")]
	886	public void TestNthCdr() {
[14733]	887	var prog = PushParser.Parse("( A B C D E )");
	888	var result = PushParser.Parse("D");
[14727]	889
	890	this.interpreter.IntegerStack.Push(2);
	891	this.interpreter.CodeStack.Push(prog);
	892	this.interpreter.Run(new CodeNthCdrExpression());
	893
	894	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	895	this.CheckOtherStacksAreEmpty();
	896	}
	897
	898	[TestMethod]
	899	[TestProperty("Time", "Short")]
	900	[TestCategory("ExpressionTest")]
	901	[TestCategory("CodeExpressionTest")]
	902	public void TestNthCdrWithTooBigN() {
[14733]	903	var prog = PushParser.Parse("( A B C D E )");
	904	var result = PushParser.Parse("D");
[14727]	905
	906	this.interpreter.IntegerStack.Push(10);
	907	this.interpreter.CodeStack.Push(prog);
	908	this.interpreter.Run(new CodeNthCdrExpression());
	909
	910	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	911	this.CheckOtherStacksAreEmpty();
	912	}
	913
	914	[TestMethod]
	915	[TestProperty("Time", "Short")]
	916	[TestCategory("ExpressionTest")]
	917	[TestCategory("CodeExpressionTest")]
	918	public void TestNthCdrWithNegativeN() {
[14733]	919	var prog = PushParser.Parse("( A B C D E )");
	920	var result = PushParser.Parse("D");
[14727]	921
	922	this.interpreter.IntegerStack.Push(-2);
	923	this.interpreter.CodeStack.Push(prog);
	924	this.interpreter.Run(new CodeNthCdrExpression());
	925
	926	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	927	this.CheckOtherStacksAreEmpty();
	928	}
	929
	930	[TestMethod]
	931	[TestProperty("Time", "Short")]
	932	[TestCategory("ExpressionTest")]
	933	[TestCategory("CodeExpressionTest")]
	934	public void TestNthCdrIfEmpty() {
[14733]	935	var prog = PushParser.Parse("( )");
	936	var result = PushParser.Parse("( )");
[14727]	937
	938	this.interpreter.IntegerStack.Push(3);
	939	this.interpreter.CodeStack.Push(prog);
	940	this.interpreter.Run(new CodeNthCdrExpression());
	941
	942	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	943	this.CheckOtherStacksAreEmpty();
	944	}
	945
	946	[TestMethod]
	947	[TestProperty("Time", "Short")]
	948	[TestCategory("ExpressionTest")]
	949	[TestCategory("CodeExpressionTest")]
	950	public void TestNthCdrIfNoList() {
[14733]	951	var prog = PushParser.Parse("A");
	952	var result = PushParser.Parse("A");
[14727]	953
	954	this.interpreter.IntegerStack.Push(3);
	955	this.interpreter.CodeStack.Push(prog);
	956	this.interpreter.Run(new CodeNthCdrExpression());
	957
	958	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	959	this.CheckOtherStacksAreEmpty();
	960	}
	961
	962	[TestMethod]
	963	[TestProperty("Time", "Short")]
	964	[TestCategory("ExpressionTest")]
	965	[TestCategory("CodeExpressionTest")]
	966	public void TestNullTrue() {
[14733]	967	var prog = PushParser.Parse("( )");
[14727]	968
	969	this.interpreter.CodeStack.Push(prog);
	970	this.interpreter.Run(new CodeNullExpression());
	971
	972	Assert.AreEqual(true, this.interpreter.BooleanStack.Top);
	973	this.TestStackCounts(booleanStack: 1);
	974	}
	975
	976	[TestMethod]
	977	[TestProperty("Time", "Short")]
	978	[TestCategory("ExpressionTest")]
	979	[TestCategory("CodeExpressionTest")]
	980	public void TestNullFalse() {
[14733]	981	var prog = PushParser.Parse("A");
[14727]	982
	983	this.interpreter.CodeStack.Push(prog);
	984	this.interpreter.Run(new CodeNullExpression());
	985
	986	Assert.AreEqual(false, this.interpreter.BooleanStack.Top);
	987	this.TestStackCounts(booleanStack: 1);
	988	}
	989
	990	[TestMethod]
	991	[TestProperty("Time", "Short")]
	992	[TestCategory("ExpressionTest")]
	993	[TestCategory("CodeExpressionTest")]
	994	public void TestPosition() {
[14733]	995	var first = PushParser.Parse("( A B C D )");
	996	var second = PushParser.Parse("C");
[14727]	997
	998	this.interpreter.CodeStack.Push(second, first);
	999	this.interpreter.Run(new CodePositionExpression());
	1000
	1001	Assert.AreEqual(2, this.interpreter.IntegerStack.Top);
	1002	this.TestStackCounts(integerStack: 1);
	1003	}
	1004
	1005	[TestMethod]
	1006	[TestProperty("Time", "Short")]
	1007	[TestCategory("ExpressionTest")]
	1008	[TestCategory("CodeExpressionTest")]
	1009	public void TestQuote() {
[14733]	1010	var result = PushParser.Parse("A");
[14727]	1011
	1012	this.interpreter.Run("( CODE.QUOTE A )");
	1013
	1014	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	1015	this.CheckOtherStacksAreEmpty();
	1016	}
	1017
	1018	[TestMethod]
	1019	[TestProperty("Time", "Short")]
	1020	[TestCategory("ExpressionTest")]
	1021	[TestCategory("CodeExpressionTest")]
	1022	public void TestSize() {
[14733]	1023	var prog = PushParser.Parse("( A ( B ( C ) ) ( D ) INTEGER.+ )");
[14727]	1024
	1025	this.interpreter.CodeStack.Push(prog);
	1026	this.interpreter.Run(new CodeSizeExpression());
	1027
	1028	Assert.AreEqual(4, this.interpreter.IntegerStack.Top);
	1029	this.TestStackCounts(integerStack: 1);
	1030	}
	1031
	1032	[TestMethod]
	1033	[TestProperty("Time", "Short")]
	1034	[TestCategory("ExpressionTest")]
	1035	[TestCategory("CodeExpressionTest")]
	1036	public void TestSubstitude() {
[14733]	1037	var first = PushParser.Parse("( A B C D A B C D )");
	1038	var second = PushParser.Parse("E");
	1039	var third = PushParser.Parse("A");
	1040	var result = PushParser.Parse("( E B C D E B C D )");
[14727]	1041
	1042	this.interpreter.CodeStack.Push(third, second, first);
	1043	this.interpreter.Run(new CodeSubstitutionExpression());
	1044
	1045	Assert.AreEqual(result, this.interpreter.CodeStack.Top);
	1046	this.CheckOtherStacksAreEmpty();
	1047	}
	1048
	1049	protected override Expression[] GetValues(int count) {
	1050	var values = new Expression[count];
	1051
	1052	for (var i = 0; i < count; i++) values[i] = new CodeNoopExpression();
	1053
	1054	return values;
	1055	}
	1056
	1057	protected override Expression[] Get2Different() {
	1058	return new Expression[] { new CodeNoopExpression(), new CodeNullExpression() };
	1059	}
	1060
	1061	protected override void CheckOtherStacksAreEmpty() {
	1062	this.TestStackCounts(codeStack: null);
	1063	}
	1064	}
	1065	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Update cookies preferences