Free cookie consent management tool by TermsFeed Policy Generator

source: branches/2895_PushGP_GenealogyAnalysis/HeuristicLab.Tests/Interpreter/Expressions/VectorExpressionTests.cs @ 15903

Last change on this file since 15903 was 15771, checked in by bburlacu, 7 years ago

#2895: Add solution skeleton for PushGP with genealogy analysis.
File size: 15.1 KB
Line 
1namespace HeuristicLab.Tests.Interpreter.Expressions {
2  using System.Collections.Generic;
3  using System.Linq;
4  using HeuristicLab.Problems.ProgramSynthesis;
5  using Microsoft.VisualStudio.TestTools.UnitTesting;
6
7  public abstract class VectorExpressionTests<T> : CommonTests<IReadOnlyList<T>> {
8
9    protected abstract IPushStack<T> LiteralStack { get; }
10    protected abstract IReadOnlyList<T> GetLiterals(int count);
11
12    [TestMethod]
13    [TestProperty("Time", "Short")]
14    [TestCategory("ExpressionTest")]
15    [TestCategory("VectorExpressionTest")]
16    public void TestVectorButLast() {
17      var vector = GetValues(1)[0];
18      Stack.Push(vector);
19
20      var result = vector.Take(vector.Count - 1);
21      var expression = ExpressionTable.GetStatelessExpression(TypeName + ".BUTLAST");
22      interpreter.Run(expression);
23
24      Assert.IsTrue(result.SequenceEqual(Stack.Top));
25    }
26
27    [TestMethod]
28    [TestProperty("Time", "Short")]
29    [TestCategory("ExpressionTest")]
30    [TestCategory("VectorExpressionTest")]
31    public void TestVectorConcat() {
32      var vectors = GetValues(2);
33      Stack.Push(vectors);
34
35      var result = vectors.SelectMany(x => x);
36      var expression = ExpressionTable.GetStatelessExpression(TypeName + ".CONCAT");
37      interpreter.Run(expression);
38
39      Assert.IsTrue(result.SequenceEqual(Stack.Top));
40    }
41
42    [TestMethod]
43    [TestProperty("Time", "Short")]
44    [TestCategory("ExpressionTest")]
45    [TestCategory("VectorExpressionTest")]
46    public void TestVectorConj() {
47      var vectors = GetValues(1);
48      var literals = GetLiterals(1);
49
50      Stack.Push(vectors);
51      LiteralStack.Push(literals);
52
53      var result = new List<T>(vectors[0]);
54      result.AddRange(literals);
55
56      var expression = ExpressionTable.GetStatelessExpression(TypeName + ".CONJ");
57      interpreter.Run(expression);
58
59      Assert.IsTrue(result.SequenceEqual(Stack.Top));
60    }
61
62    [TestMethod]
63    [TestProperty("Time", "Short")]
64    [TestCategory("ExpressionTest")]
65    [TestCategory("VectorExpressionTest")]
66    public void TestVectorContains() {
67      var vectors = Get2Different();
68      var literalContained = vectors[0].Last();
69      var literalNotContained = vectors[1].FirstOrDefault(x => !vectors[0].Contains(x));
70      var expression = ExpressionTable.GetStatelessExpression(TypeName + ".CONTAINS");
71
72      Stack.Push(vectors[0], vectors[0]);
73      LiteralStack.Push(literalContained, literalNotContained);
74
75      interpreter.Run(expression);
76      interpreter.Run(expression);
77
78      Assert.IsTrue(interpreter.BooleanStack[0]);
79      Assert.IsFalse(interpreter.BooleanStack[1]);
80    }
81
82    [TestMethod]
83    [TestProperty("Time", "Short")]
84    [TestCategory("ExpressionTest")]
85    [TestCategory("VectorExpressionTest")]
86    public void TestVectorEmpty() {
87      var emptyVector = new List<T>();
88      var noneEmptyVector = GetValues(1)[0];
89      var expression = ExpressionTable.GetStatelessExpression(TypeName + ".EMPTYVECTOR");
90
91      Stack.Push(emptyVector, noneEmptyVector);
92      interpreter.Run(expression);
93      interpreter.Run(expression);
94
95      Assert.IsTrue(interpreter.BooleanStack[0]);
96      Assert.IsFalse(interpreter.BooleanStack[1]);
97    }
98
99    [TestMethod]
100    [TestProperty("Time", "Short")]
101    [TestCategory("ExpressionTest")]
102    [TestCategory("VectorExpressionTest")]
103    public void TestVectorFirst() {
104      var vector = GetValues(1)[0];
105      var emptyVector = new List<T>();
106      var expression = ExpressionTable.GetStatelessExpression(TypeName + ".FIRST");
107
108      Stack.Push(emptyVector);
109      interpreter.Run(expression);
110      Assert.IsTrue(LiteralStack.IsEmpty);
111
112      Stack.Push(vector);
113      interpreter.Run(expression);
114      Assert.AreEqual(vector.First(), LiteralStack.Top);
115    }
116
117    [TestMethod]
118    [TestProperty("Time", "Short")]
119    [TestCategory("ExpressionTest")]
120    [TestCategory("VectorExpressionTest")]
121    public void TestVectorIndexOf() {
122      var vector = GetValues(1)[0].Distinct().ToList();
123      var emptyVector = new List<T>();
124      var literal = vector.Last();
125      var expression = ExpressionTable.GetStatelessExpression(TypeName + ".INDEXOF");
126
127      Stack.Push(emptyVector);
128      LiteralStack.Push(literal);
129      interpreter.Run(expression);
130      Assert.IsTrue(LiteralStack == interpreter.IntegerStack ? LiteralStack.Count == 1 : LiteralStack.IsEmpty);
131
132      Stack.Push(vector);
133      LiteralStack.Push(literal);
134      interpreter.Run(expression);
135      Assert.AreEqual(vector.Count - 1, interpreter.IntegerStack.Top);
136    }
137
138    [TestMethod]
139    [TestProperty("Time", "Short")]
140    [TestCategory("ExpressionTest")]
141    [TestCategory("VectorExpressionTest")]
142    public void TestVectorIterate() {
143      var vector = GetValues(1)[0];
144      var emptyVector = new List<T>();
145      var expression = ExpressionTable.GetStatelessExpression(TypeName + ".ITERATE");
146      var bodyExpression = new ExecNoopExpression();
147
148      Stack.Push(emptyVector);
149      interpreter.Run(new PushProgram(new[] { expression, bodyExpression }));
150      Assert.IsTrue(LiteralStack.IsEmpty);
151      Assert.AreEqual(0, Stack.Top.Count);
152
153      Stack.Push(vector);
154      interpreter.Run(new PushProgram(new[] { bodyExpression, expression }));
155      Assert.AreEqual(vector.Count, LiteralStack.Count);
156      Assert.IsTrue(LiteralStack.Reverse().SequenceEqual(vector));
157    }
158
159
160    [TestMethod]
161    [TestProperty("Time", "Short")]
162    [TestCategory("ExpressionTest")]
163    [TestCategory("VectorExpressionTest")]
164    public void TestVectorLast() {
165      var vector = GetValues(1)[0];
166      var emptyVector = new List<T>();
167      var expression = ExpressionTable.GetStatelessExpression(TypeName + ".LAST");
168
169      Stack.Push(emptyVector);
170      interpreter.Run(expression);
171      Assert.IsTrue(LiteralStack.IsEmpty);
172
173      Stack.Push(vector);
174      interpreter.Run(expression);
175      Assert.AreEqual(vector.Last(), LiteralStack.Top);
176    }
177
178    [TestMethod]
179    [TestProperty("Time", "Short")]
180    [TestCategory("ExpressionTest")]
181    [TestCategory("VectorExpressionTest")]
182    public void TestVectorLength() {
183      var vector = GetValues(1)[0];
184      var emptyVector = new List<T>();
185      var expression = ExpressionTable.GetStatelessExpression(TypeName + ".LENGTH");
186
187      Stack.Push(emptyVector);
188      interpreter.Run(expression);
189      Assert.AreEqual(0, interpreter.IntegerStack.Top);
190
191      Stack.Push(vector);
192      interpreter.Run(expression);
193      Assert.AreEqual(vector.Count, interpreter.IntegerStack.Top);
194    }
195
196    [TestMethod]
197    [TestProperty("Time", "Short")]
198    [TestCategory("ExpressionTest")]
199    [TestCategory("VectorExpressionTest")]
200    public void TestVectorNth() {
201      var vector = GetValues(1)[0];
202      var emptyVector = new List<T>();
203      var index = vector.Count / 2;
204      var expression = ExpressionTable.GetStatelessExpression(TypeName + ".NTH");
205
206      Stack.Push(emptyVector);
207      interpreter.IntegerStack.Push(index);
208      interpreter.Run(expression);
209      Assert.IsTrue(LiteralStack == interpreter.IntegerStack ? LiteralStack.Count == 1 : LiteralStack.IsEmpty);
210
211      Stack.Push(vector);
212      interpreter.IntegerStack.Push(index);
213      interpreter.Run(expression);
214      Assert.AreEqual(vector[index], LiteralStack.Top);
215    }
216
217    [TestMethod]
218    [TestProperty("Time", "Short")]
219    [TestCategory("ExpressionTest")]
220    [TestCategory("VectorExpressionTest")]
221    public void TestVectorOccurrenceOf() {
222      var vector = GetValues(1)[0];
223      var literal = vector.Last();
224      var result = vector.Count(x => x.Equals(literal));
225      var emptyVector = new List<T>();
226      var expression = ExpressionTable.GetStatelessExpression(TypeName + ".OCCURRENCEOF");
227
228      Stack.Push(emptyVector);
229      LiteralStack.Push(literal);
230      interpreter.Run(expression);
231      Assert.AreEqual(0, interpreter.IntegerStack.Top);
232
233      Stack.Push(vector);
234      LiteralStack.Push(literal);
235      interpreter.Run(expression);
236      Assert.AreEqual(result, interpreter.IntegerStack.Top);
237    }
238
239    [TestMethod]
240    [TestProperty("Time", "Short")]
241    [TestCategory("ExpressionTest")]
242    [TestCategory("VectorExpressionTest")]
243    public void TestVectorPushAll() {
244      var vector = GetValues(1)[0];
245      var emptyVector = new List<T>();
246      var expression = ExpressionTable.GetStatelessExpression(TypeName + ".PUSHALL");
247
248      Stack.Push(emptyVector);
249      interpreter.Run(expression);
250      Assert.IsTrue(LiteralStack.IsEmpty);
251
252      Stack.Push(vector);
253      interpreter.Run(expression);
254      Assert.IsTrue(LiteralStack.Reverse().SequenceEqual(vector));
255    }
256
257    [TestMethod]
258    [TestProperty("Time", "Short")]
259    [TestCategory("ExpressionTest")]
260    [TestCategory("VectorExpressionTest")]
261    public void TestVectorRemove() {
262      var vector = GetValues(1)[0];
263      var emptyVector = new List<T>();
264      var literal = vector.Last();
265      var result = vector.Where(x => !x.Equals(literal));
266      var expression = ExpressionTable.GetStatelessExpression(TypeName + ".REMOVE");
267
268      Stack.Push(emptyVector);
269      LiteralStack.Push(literal);
270      interpreter.Run(expression);
271      Assert.AreEqual(0, Stack.Top.Count);
272
273      Stack.Push(vector);
274      LiteralStack.Push(literal);
275      interpreter.Run(expression);
276      Assert.IsTrue(Stack.Top.SequenceEqual(result));
277    }
278
279    [TestMethod]
280    [TestProperty("Time", "Short")]
281    [TestCategory("ExpressionTest")]
282    [TestCategory("VectorExpressionTest")]
283    public void TestVectorReplace() {
284      var vector = GetValues(1)[0];
285      var emptyVector = new List<T>();
286      var literal = vector.Last();
287      var literalTarget = vector.First();
288      var result = vector.Select(x => x.Equals(literal) ? literalTarget : x);
289      var expression = ExpressionTable.GetStatelessExpression(TypeName + ".REPLACE");
290
291      Stack.Push(emptyVector);
292      LiteralStack.Push(literal, literalTarget);
293      interpreter.Run(expression);
294      Assert.AreEqual(0, Stack.Top.Count);
295
296      Stack.Push(vector);
297      LiteralStack.Push(literal, literalTarget);
298      interpreter.Run(expression);
299      Assert.IsTrue(Stack.Top.SequenceEqual(result));
300    }
301
302    [TestMethod]
303    [TestProperty("Time", "Short")]
304    [TestCategory("ExpressionTest")]
305    [TestCategory("VectorExpressionTest")]
306    public void TestVectorReplaceFirst() {
307      var vector = GetValues(1)[0];
308      var emptyVector = new List<T>();
309      var literal = vector.Last();
310      var literalTarget = vector.First(x => !x.Equals(literal));
311      var firstReplaced = false;
312      var result = vector.Select(x => {
313        if (!x.Equals(literal) || firstReplaced) return x;
314        firstReplaced = true;
315        return literalTarget;
316      }).ToArray();
317
318      var expression = ExpressionTable.GetStatelessExpression(TypeName + ".REPLACEFIRST");
319
320      Stack.Push(emptyVector);
321      LiteralStack.Push(literal, literalTarget);
322      interpreter.Run(expression);
323      Assert.AreEqual(0, Stack.Top.Count);
324
325      Stack.Push(vector);
326      LiteralStack.Push(literal, literalTarget);
327      interpreter.Run(expression);
328      Assert.IsTrue(Stack.Top.SequenceEqual(result));
329    }
330
331    [TestMethod]
332    [TestProperty("Time", "Short")]
333    [TestCategory("ExpressionTest")]
334    [TestCategory("VectorExpressionTest")]
335    public void TestVectorRest() {
336      var vector = GetValues(1)[0];
337      var emptyVector = new List<T>();
338      var result = vector.Skip(1);
339      var expression = ExpressionTable.GetStatelessExpression(TypeName + ".REST");
340
341      Stack.Push(emptyVector);
342      interpreter.Run(expression);
343      Assert.AreEqual(0, Stack.Top.Count);
344
345      Stack.Push(vector);
346      interpreter.Run(expression);
347      Assert.IsTrue(Stack.Top.SequenceEqual(result));
348    }
349
350    [TestMethod]
351    [TestProperty("Time", "Short")]
352    [TestCategory("ExpressionTest")]
353    [TestCategory("VectorExpressionTest")]
354    public void TestVectorReverse() {
355      var vector = GetValues(1)[0];
356      var emptyVector = new List<T>();
357      var result = new List<T>(vector);
358      result.Reverse();
359      var expression = ExpressionTable.GetStatelessExpression(TypeName + ".REVERSE");
360
361      Stack.Push(emptyVector);
362      interpreter.Run(expression);
363      Assert.AreEqual(emptyVector, Stack.Top);
364
365      Stack.Push(vector);
366      interpreter.Run(expression);
367      Assert.IsTrue(Stack.Top.SequenceEqual(result));
368    }
369
370    [TestMethod]
371    [TestProperty("Time", "Short")]
372    [TestCategory("ExpressionTest")]
373    [TestCategory("VectorExpressionTest")]
374    public void TestVectorSet() {
375      var vector = GetValues(1)[0];
376      var emptyVector = new List<T>();
377      var index = vector.Count / 2;
378      var literal = vector.Last();
379      var result = vector.ToArray();
380      result[index] = literal;
381      var expression = ExpressionTable.GetStatelessExpression(TypeName + ".SET");
382
383      Stack.Push(emptyVector);
384      LiteralStack.Push(literal);
385      interpreter.IntegerStack.Push(index);
386      interpreter.Run(expression);
387      Assert.AreEqual(emptyVector, Stack.Top);
388
389      Stack.Push(vector);
390      interpreter.IntegerStack.Push(index);
391      LiteralStack.Push(literal);
392      interpreter.Run(expression);
393      Assert.IsTrue(Stack.Top.SequenceEqual(result));
394    }
395
396    [TestMethod]
397    [TestProperty("Time", "Short")]
398    [TestCategory("ExpressionTest")]
399    [TestCategory("VectorExpressionTest")]
400    public void TestVectorSub() {
401      var vector = GetValues(1)[0];
402      var emptyVector = new List<T>();
403      var start = 0;
404      var end = vector.Count / 2;
405      var result = vector.Skip(start).Take(end).ToArray();
406      var expression = ExpressionTable.GetStatelessExpression(TypeName + ".SUB");
407
408      Stack.Push(emptyVector);
409      interpreter.IntegerStack.Push(start, end);
410      interpreter.Run(expression);
411      Assert.AreEqual(emptyVector, Stack.Top);
412
413      Stack.Push(vector);
414      interpreter.IntegerStack.Push(start, end);
415      interpreter.Run(expression);
416      Assert.IsTrue(Stack.Top.SequenceEqual(result));
417    }
418
419    [TestMethod]
420    [TestProperty("Time", "Short")]
421    [TestCategory("ExpressionTest")]
422    [TestCategory("VectorExpressionTest")]
423    public void TestVectorTake() {
424      var vector = GetValues(1)[0];
425      var emptyVector = new List<T>();
426      var count = vector.Count / 2;
427      var result = vector.Take(count).ToArray();
428      var expression = ExpressionTable.GetStatelessExpression(TypeName + ".TAKE");
429
430      Stack.Push(emptyVector);
431      interpreter.IntegerStack.Push(count);
432      interpreter.Run(expression);
433      Assert.AreEqual(emptyVector, Stack.Top);
434
435      Stack.Push(vector);
436      interpreter.IntegerStack.Push(count);
437      interpreter.Run(expression);
438      Assert.IsTrue(Stack.Top.SequenceEqual(result));
439
440      Stack.Push(vector);
441      interpreter.IntegerStack.Push(count * -1);
442      interpreter.Run(expression);
443      Assert.IsTrue(Stack.Top.SequenceEqual(result));
444
445      Stack.Push(vector);
446      interpreter.IntegerStack.Push(count + vector.Count);
447      interpreter.Run(expression);
448      Assert.IsTrue(Stack.Top.SequenceEqual(result));
449    }
450  }
451}
Note: See TracBrowser for help on using the repository browser.