Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
11/16/16 23:14:01 (8 years ago)
Author:
pkimmesw
Message:

#2665 Expressions are splitted into StatefullExpressions and StatelessExpressions, Added traits for tests

Location:
branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Benchmark/ExampleConverter.cs

    r14392 r14398  
    1 using System;
    2 using System.Linq;
     1using System.Linq;
    32
    43namespace HeuristicLab.Tests.Benchmark
    … …  
    109        private static readonly char[] arraySymbolTrim = new[] { '[', ']' };
    1110
    12         public static Converter<string, long> Integer = new Converter<string, long>(GetInteger);
    13         public static Converter<string, long[]> Integers = new Converter<string, long[]>(GetIntegers);
    1411
    15         public static long GetInteger(string str)
     12        public static long Integer(string str)
    1613        {
    1714            return long.Parse(str);
    1815        }
    1916
    20         public static long[] GetIntegers(string str)
     17        public static long[] Integers(string str)
    2118        {
    2219            var values = str
    … …  
    3027            for (var i = 0; i < result.Length; i++)
    3128            {
    32                 result[i] = GetInteger(values[i]);
     29                result[i] = Integer(values[i]);
    3330            }
    3431

  • branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Benchmark/Problem/CountOdds.cs

    r14397 r14398  
    1717        public CountOdds()
    1818        {
    19             this.Examples = this.GetExamples(ProblemFileName, ExampleConverter.Integers, ExampleConverter.Integer);
     19            Examples = GetExamples(ProblemFileName, ExampleConverter.Integers, ExampleConverter.Integer);
    2020        }
    2121
    2222        [TestMethod]
     23        [TestProperty("Time", "Medium")]
     24        [TestCategory("ProblemTest")]
    2325        public void RandomWalk()
    2426        {
    25             var limit = 1000;
     27            var maxProgramSizeLimit = 1000;
    2628            var iterations = 20000;
    2729            var best = double.MaxValue;
    … …  
    3941
    4042                var execCounter = 0;
    41                 var program = interpreter.CodeGenerator.RandomProgram(limit);
     43                var program = interpreter.CodeGenerator.RandomProgram(maxProgramSizeLimit);
    4244                var results = new List<long>();
    4345
    44                 foreach (var example in this.Examples)
     46                foreach (var example in Examples)
    4547                {
    4648                    if (example.Input.Length > 0)

  • branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/BooleanExpressionTests.cs

    r14392 r14398  
    1212
    1313        [TestMethod]
     14        [TestProperty("Time", "Short")]
     15        [TestCategory("ExpressionTest")]
     16        [TestCategory("BooleanExpressionTest")]
    1417        public void TestAnd()
    1518        {
    … …  
    1922            Assert.AreEqual(false, interpreter.BooleanStack.Top);
    2023
    21             this.TestStackCounts(booleanStack: 1);
     24            TestStackCounts(booleanStack: 1);
    2225        }
    2326
    2427        [TestMethod]
     28        [TestProperty("Time", "Short")]
     29        [TestCategory("ExpressionTest")]
     30        [TestCategory("BooleanExpressionTest")]
    2531        public void TestAndWithInsufficientArguments()
    2632        {
    27             this.TestWithInsufficientArguments("AND", 1);
     33            TestWithInsufficientArguments("AND", 1);
    2834        }
    2935
    3036        [TestMethod]
     37        [TestProperty("Time", "Short")]
     38        [TestCategory("ExpressionTest")]
     39        [TestCategory("BooleanExpressionTest")]
    3140        public void TestOr()
    3241        {
    … …  
    3645            Assert.AreEqual(true, interpreter.BooleanStack.Top);
    3746
    38             this.TestStackCounts(booleanStack: 1);
     47            TestStackCounts(booleanStack: 1);
    3948        }
    4049
    4150        [TestMethod]
     51        [TestProperty("Time", "Short")]
     52        [TestCategory("ExpressionTest")]
     53        [TestCategory("BooleanExpressionTest")]
    4254        public void TestOrWithInsufficientArguments()
    4355        {
    44             this.TestWithInsufficientArguments("OR", 1);
     56            TestWithInsufficientArguments("OR", 1);
    4557        }
    4658
    4759        [TestMethod]
     60        [TestProperty("Time", "Short")]
     61        [TestCategory("ExpressionTest")]
     62        [TestCategory("BooleanExpressionTest")]
    4863        public void TestNot()
    4964        {
    … …  
    5368            Assert.AreEqual(false, interpreter.BooleanStack.Top);
    5469
    55             this.TestStackCounts(booleanStack: 1);
     70            TestStackCounts(booleanStack: 1);
    5671        }
    5772
    5873        [TestMethod]
     74        [TestProperty("Time", "Short")]
     75        [TestCategory("ExpressionTest")]
     76        [TestCategory("BooleanExpressionTest")]
    5977        public void TestNotWithInsufficientArguments()
    6078        {
    61             this.TestWithInsufficientArguments("NOT");
     79            TestWithInsufficientArguments("NOT");
    6280        }
    6381
    6482        [TestMethod]
     83        [TestProperty("Time", "Short")]
     84        [TestCategory("ExpressionTest")]
     85        [TestCategory("BooleanExpressionTest")]
    6586        public void TestFromFloat()
    6687        {
    … …  
    7091            Assert.AreEqual(true, interpreter.BooleanStack.Top);
    7192
    72             this.TestStackCounts(booleanStack: 1);
     93            TestStackCounts(booleanStack: 1);
    7394        }
    7495
    7596        [TestMethod]
     97        [TestProperty("Time", "Short")]
     98        [TestCategory("ExpressionTest")]
     99        [TestCategory("BooleanExpressionTest")]
    76100        public void TestFromFloatWithInsufficientArguments()
    77101        {
    78             this.TestWithInsufficientArguments("FROMFLOAT");
     102            TestWithInsufficientArguments("FROMFLOAT");
    79103        }
    80104
    81105        [TestMethod]
     106        [TestProperty("Time", "Short")]
     107        [TestCategory("ExpressionTest")]
     108        [TestCategory("BooleanExpressionTest")]
    82109        public void TestFromInteger()
    83110        {
    … …  
    87114            Assert.AreEqual(true, interpreter.BooleanStack.Top);
    88115
    89             this.TestStackCounts(booleanStack: 1);
     116            TestStackCounts(booleanStack: 1);
    90117        }
    91118
    92119        [TestMethod]
     120        [TestProperty("Time", "Short")]
     121        [TestCategory("ExpressionTest")]
     122        [TestCategory("BooleanExpressionTest")]
    93123        public void TestFromIntegerWithInsufficientArguments()
    94124        {
    95             this.TestWithInsufficientArguments("FROMINTEGER");
     125            TestWithInsufficientArguments("FROMINTEGER");
    96126        }
    97127
    … …  
    110140        protected override void CheckOtherStacksAreEmpty()
    111141        {
    112             this.TestStackCounts(booleanStack: null);
     142            TestStackCounts(booleanStack: null);
    113143        }
    114144    }

  • branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/CodeExpressionTests.cs

    r14392 r14398  
    1616        public CodeExpressionTests()
    1717        {
    18             this.cg = new CodeGenerator(interpreter);
    19         }
    20 
    21         [TestMethod]
     18            cg = new CodeGenerator(interpreter);
     19        }
     20
     21        [TestMethod]
     22        [TestProperty("Time", "Short")]
     23        [TestCategory("ExpressionTest")]
     24        [TestCategory("CodeExpressionTest")]
    2225        public void TestAppendLists()
    2326        {
    … …  
    3033
    3134            Assert.AreEqual(result, interpreter.CodeStack.Top);
    32             this.CheckOtherStacksAreEmpty();
    33         }
    34 
    35         [TestMethod]
     35            CheckOtherStacksAreEmpty();
     36        }
     37
     38        [TestMethod]
     39        [TestProperty("Time", "Short")]
     40        [TestCategory("ExpressionTest")]
     41        [TestCategory("CodeExpressionTest")]
    3642        public void TestAppendListAndLiteral()
    3743        {
    … …  
    4450
    4551            Assert.AreEqual(result, interpreter.CodeStack.Top);
    46             this.CheckOtherStacksAreEmpty();
    47         }
    48 
    49         [TestMethod]
     52            CheckOtherStacksAreEmpty();
     53        }
     54
     55        [TestMethod]
     56        [TestProperty("Time", "Short")]
     57        [TestCategory("ExpressionTest")]
     58        [TestCategory("CodeExpressionTest")]
    5059        public void TestAppendLiterals()
    5160        {
    … …  
    5867
    5968            Assert.AreEqual(result, interpreter.CodeStack.Top);
    60             this.CheckOtherStacksAreEmpty();
    61         }
    62 
    63         [TestMethod]
     69            CheckOtherStacksAreEmpty();
     70        }
     71
     72        [TestMethod]
     73        [TestProperty("Time", "Short")]
     74        [TestCategory("ExpressionTest")]
     75        [TestCategory("CodeExpressionTest")]
    6476        public void TestAtomList()
    6577        {
    … …  
    7082
    7183            Assert.AreEqual(false, interpreter.BooleanStack.Top);
    72             this.TestStackCounts(booleanStack: 1);
    73         }
    74 
    75         [TestMethod]
     84            TestStackCounts(booleanStack: 1);
     85        }
     86
     87        [TestMethod]
     88        [TestProperty("Time", "Short")]
     89        [TestCategory("ExpressionTest")]
     90        [TestCategory("CodeExpressionTest")]
    7691        public void TestAtomLiteral()
    7792        {
    … …  
    8297
    8398            Assert.AreEqual(true, interpreter.BooleanStack.Top);
    84             this.TestStackCounts(booleanStack: 1);
    85         }
    86 
    87         [TestMethod]
     99            TestStackCounts(booleanStack: 1);
     100        }
     101
     102        [TestMethod]
     103        [TestProperty("Time", "Short")]
     104        [TestCategory("ExpressionTest")]
     105        [TestCategory("CodeExpressionTest")]
    88106        public void TestAtomSingleInstruction()
    89107        {
    … …  
    94112
    95113            Assert.AreEqual(true, interpreter.BooleanStack.Top);
    96             this.TestStackCounts(booleanStack: 1);
    97         }
    98 
    99         [TestMethod]
     114            TestStackCounts(booleanStack: 1);
     115        }
     116
     117        [TestMethod]
     118        [TestProperty("Time", "Short")]
     119        [TestCategory("ExpressionTest")]
     120        [TestCategory("CodeExpressionTest")]
    100121        public void TestCarList()
    101122        {
    … …  
    107128
    108129            Assert.AreEqual(result, interpreter.CodeStack.Top);
    109             this.CheckOtherStacksAreEmpty();
    110         }
    111 
    112         [TestMethod]
     130            CheckOtherStacksAreEmpty();
     131        }
     132
     133        [TestMethod]
     134        [TestProperty("Time", "Short")]
     135        [TestCategory("ExpressionTest")]
     136        [TestCategory("CodeExpressionTest")]
    113137        public void TestCarNoList()
    114138        {
    … …  
    120144
    121145            Assert.AreEqual(result, interpreter.CodeStack.Top);
    122             this.CheckOtherStacksAreEmpty();
    123         }
    124 
    125         [TestMethod]
     146            CheckOtherStacksAreEmpty();
     147        }
     148
     149        [TestMethod]
     150        [TestProperty("Time", "Short")]
     151        [TestCategory("ExpressionTest")]
     152        [TestCategory("CodeExpressionTest")]
    126153        public void TestCdrList()
    127154        {
    … …  
    133160
    134161            Assert.AreEqual(result, interpreter.CodeStack.Top);
    135             this.CheckOtherStacksAreEmpty();
    136         }
    137 
    138         [TestMethod]
     162            CheckOtherStacksAreEmpty();
     163        }
     164
     165        [TestMethod]
     166        [TestProperty("Time", "Short")]
     167        [TestCategory("ExpressionTest")]
     168        [TestCategory("CodeExpressionTest")]
    139169        public void TestCdrNoList()
    140170        {
    … …  
    146176
    147177            Assert.AreEqual(result, interpreter.CodeStack.Top);
    148             this.CheckOtherStacksAreEmpty();
    149         }
    150 
    151         [TestMethod]
     178            CheckOtherStacksAreEmpty();
     179        }
     180
     181        [TestMethod]
     182        [TestProperty("Time", "Short")]
     183        [TestCategory("ExpressionTest")]
     184        [TestCategory("CodeExpressionTest")]
    152185        public void TestCons()
    153186        {
    … …  
    160193
    161194            Assert.AreEqual(result, interpreter.CodeStack.Top);
    162             this.CheckOtherStacksAreEmpty();
    163         }
    164 
    165         [TestMethod]
     195            CheckOtherStacksAreEmpty();
     196        }
     197
     198        [TestMethod]
     199        [TestProperty("Time", "Short")]
     200        [TestCategory("ExpressionTest")]
     201        [TestCategory("CodeExpressionTest")]
    166202        public void TestContainsTrue()
    167203        {
    … …  
    173209
    174210            Assert.AreEqual(true, interpreter.BooleanStack.Top);
    175             this.TestStackCounts(booleanStack: 1);
    176         }
    177 
    178         [TestMethod]
     211            TestStackCounts(booleanStack: 1);
     212        }
     213
     214        [TestMethod]
     215        [TestProperty("Time", "Short")]
     216        [TestCategory("ExpressionTest")]
     217        [TestCategory("CodeExpressionTest")]
    179218        public void TestContainsFalse()
    180219        {
    … …  
    186225
    187226            Assert.AreEqual(false, interpreter.BooleanStack.Top);
    188             this.TestStackCounts(booleanStack: 1);
    189         }
    190 
    191         [TestMethod]
     227            TestStackCounts(booleanStack: 1);
     228        }
     229
     230        [TestMethod]
     231        [TestProperty("Time", "Short")]
     232        [TestCategory("ExpressionTest")]
     233        [TestCategory("CodeExpressionTest")]
    192234        public void TestContainer()
    193235        {
    … …  
    200242
    201243            Assert.AreEqual(result, interpreter.CodeStack.Top);
    202             this.CheckOtherStacksAreEmpty();
    203         }
    204 
    205         [TestMethod]
     244            CheckOtherStacksAreEmpty();
     245        }
     246
     247        [TestMethod]
     248        [TestProperty("Time", "Short")]
     249        [TestCategory("ExpressionTest")]
     250        [TestCategory("CodeExpressionTest")]
    206251        public void TestDefinition()
    207252        {
    … …  
    214259
    215260            Assert.AreEqual(code, interpreter.CodeStack.Top);
    216             this.CheckOtherStacksAreEmpty();
    217         }
    218 
    219         [TestMethod]
     261            CheckOtherStacksAreEmpty();
     262        }
     263
     264        [TestMethod]
     265        [TestProperty("Time", "Short")]
     266        [TestCategory("ExpressionTest")]
     267        [TestCategory("CodeExpressionTest")]
    220268        public void TestDefinitionWithoutMatchingName()
    221269        {
    … …  
    227275            interpreter.Interpret(program);
    228276
    229             this.TestStackCounts(nameStack: 1);
    230         }
    231 
    232         [TestMethod]
     277            TestStackCounts(nameStack: 1);
     278        }
     279
     280        [TestMethod]
     281        [TestProperty("Time", "Short")]
     282        [TestCategory("ExpressionTest")]
     283        [TestCategory("CodeExpressionTest")]
    233284        public void TestDiscrepancy()
    234285        {
    … …  
    240291
    241292            Assert.AreEqual(2, interpreter.IntegerStack.Top);
    242             this.TestStackCounts(integerStack: 1);
    243         }
    244 
    245         [TestMethod]
     293            TestStackCounts(integerStack: 1);
     294        }
     295
     296        [TestMethod]
     297        [TestProperty("Time", "Short")]
     298        [TestCategory("ExpressionTest")]
     299        [TestCategory("CodeExpressionTest")]
    246300        public void TestDiscrepancyAllEqual()
    247301        {
    … …  
    253307
    254308            Assert.AreEqual(0, interpreter.IntegerStack.Top);
    255             this.TestStackCounts(integerStack: 1);
    256         }
    257 
    258         [TestMethod]
     309            TestStackCounts(integerStack: 1);
     310        }
     311
     312        [TestMethod]
     313        [TestProperty("Time", "Short")]
     314        [TestCategory("ExpressionTest")]
     315        [TestCategory("CodeExpressionTest")]
    259316        public void TestDiscrepancyComplex()
    260317        {
    … …  
    266323
    267324            Assert.AreEqual(3, interpreter.IntegerStack.Top);
    268             this.TestStackCounts(integerStack: 1);
    269         }
    270 
    271         [TestMethod]
     325            TestStackCounts(integerStack: 1);
     326        }
     327
     328        [TestMethod]
     329        [TestProperty("Time", "Short")]
     330        [TestCategory("ExpressionTest")]
     331        [TestCategory("CodeExpressionTest")]
    272332        public void TestDiscrepancWithLists()
    273333        {
    … …  
    279339
    280340            Assert.AreEqual(5, interpreter.IntegerStack.Top);
    281             this.TestStackCounts(integerStack: 1);
    282         }
    283 
    284         [TestMethod]
     341            TestStackCounts(integerStack: 1);
     342        }
     343
     344        [TestMethod]
     345        [TestProperty("Time", "Short")]
     346        [TestCategory("ExpressionTest")]
     347        [TestCategory("CodeExpressionTest")]
    285348        public void TestDo()
    286349        {
    … …  
    291354
    292355            Assert.AreEqual(10, interpreter.IntegerStack.Top);
    293             this.TestStackCounts(integerStack: 1);
    294         }
    295 
    296         [TestMethod]
     356            TestStackCounts(integerStack: 1);
     357        }
     358
     359        [TestMethod]
     360        [TestProperty("Time", "Short")]
     361        [TestCategory("ExpressionTest")]
     362        [TestCategory("CodeExpressionTest")]
    297363        public void TestDoX()
    298364        {
    … …  
    303369
    304370            Assert.AreEqual(10, interpreter.IntegerStack.Top);
    305             this.TestStackCounts(integerStack: 1);
    306         }
    307 
    308         [TestMethod]
     371            TestStackCounts(integerStack: 1);
     372        }
     373
     374        [TestMethod]
     375        [TestProperty("Time", "Short")]
     376        [TestCategory("ExpressionTest")]
     377        [TestCategory("CodeExpressionTest")]
    309378        public void TestDoCount()
    310379        {
    … …  
    316385
    317386            Assert.AreEqual(6, interpreter.IntegerStack.Top);
    318             this.TestStackCounts(integerStack: 1);
    319         }
    320 
    321         [TestMethod]
     387            TestStackCounts(integerStack: 1);
     388        }
     389
     390        [TestMethod]
     391        [TestProperty("Time", "Short")]
     392        [TestCategory("ExpressionTest")]
     393        [TestCategory("CodeExpressionTest")]
    322394        public void TestDoCountWithNegativeCounter()
    323395        {
    … …  
    329401
    330402            Assert.AreEqual(-1, interpreter.IntegerStack.Top);
    331             this.TestStackCounts(codeStack: 1, integerStack: 1);
    332         }
    333 
    334         [TestMethod]
     403            TestStackCounts(codeStack: 1, integerStack: 1);
     404        }
     405
     406        [TestMethod]
     407        [TestProperty("Time", "Short")]
     408        [TestCategory("ExpressionTest")]
     409        [TestCategory("CodeExpressionTest")]
    335410        public void TestDoRange()
    336411        {
    … …  
    342417
    343418            Assert.AreEqual(12, interpreter.IntegerStack.Top);
    344             this.TestStackCounts(integerStack: 1);
    345         }
    346 
    347         [TestMethod]
     419            TestStackCounts(integerStack: 1);
     420        }
     421
     422        [TestMethod]
     423        [TestProperty("Time", "Short")]
     424        [TestCategory("ExpressionTest")]
     425        [TestCategory("CodeExpressionTest")]
    348426        public void TestDoRangeWithEqualIndecators()
    349427        {
    … …  
    355433
    356434            Assert.AreEqual(3, interpreter.IntegerStack.Top);
    357             this.TestStackCounts(codeStack: 1, integerStack: 2);
    358         }
    359 
    360         [TestMethod]
     435            TestStackCounts(codeStack: 1, integerStack: 2);
     436        }
     437
     438        [TestMethod]
     439        [TestProperty("Time", "Short")]
     440        [TestCategory("ExpressionTest")]
     441        [TestCategory("CodeExpressionTest")]
    361442        public void TestDoRangeWithNegativeIndecators()
    362443        {
    … …  
    368449
    369450            Assert.AreEqual(-12, interpreter.IntegerStack.Top);
    370             this.TestStackCounts(integerStack: 1);
    371         }
    372 
    373         [TestMethod]
     451            TestStackCounts(integerStack: 1);
     452        }
     453
     454        [TestMethod]
     455        [TestProperty("Time", "Short")]
     456        [TestCategory("ExpressionTest")]
     457        [TestCategory("CodeExpressionTest")]
    374458        public void TestDoTimes()
    375459        {
    … …  
    381465
    382466            Assert.AreEqual(32, interpreter.IntegerStack.Top);
    383             this.TestStackCounts(integerStack: 1);
    384         }
    385 
    386         [TestMethod]
     467            TestStackCounts(integerStack: 1);
     468        }
     469
     470        [TestMethod]
     471        [TestProperty("Time", "Short")]
     472        [TestCategory("ExpressionTest")]
     473        [TestCategory("CodeExpressionTest")]
    387474        public void TestDoTimesWithNegativeCounter()
    388475        {
    … …  
    394481
    395482            Assert.AreEqual(-3, interpreter.IntegerStack.Top);
    396             this.TestStackCounts(codeStack: 1, integerStack: 2);
    397         }
    398 
    399         [TestMethod]
     483            TestStackCounts(codeStack: 1, integerStack: 2);
     484        }
     485
     486        [TestMethod]
     487        [TestProperty("Time", "Short")]
     488        [TestCategory("ExpressionTest")]
     489        [TestCategory("CodeExpressionTest")]
    400490        public void TestNestedDoRange()
    401491        {
    … …  
    403493
    404494            Assert.AreEqual(144, interpreter.IntegerStack.Top);
    405             this.TestStackCounts(integerStack: 1);
    406         }
    407 
    408         [TestMethod]
     495            TestStackCounts(integerStack: 1);
     496        }
     497
     498        [TestMethod]
     499        [TestProperty("Time", "Short")]
     500        [TestCategory("ExpressionTest")]
     501        [TestCategory("CodeExpressionTest")]
    409502        public void TestNestedDoCount()
    410503        {
    … …  
    412505
    413506            Assert.AreEqual(144, interpreter.IntegerStack.Top);
    414             this.TestStackCounts(integerStack: 1);
    415         }
    416 
    417         [TestMethod]
     507            TestStackCounts(integerStack: 1);
     508        }
     509
     510        [TestMethod]
     511        [TestProperty("Time", "Short")]
     512        [TestCategory("ExpressionTest")]
     513        [TestCategory("CodeExpressionTest")]
    418514        public void TestNestedDoTimes()
    419515        {
    … …  
    421517
    422518            Assert.AreEqual(128, interpreter.IntegerStack.Top);
    423             this.TestStackCounts(integerStack: 1);
    424         }
    425 
    426         [TestMethod]
     519            TestStackCounts(integerStack: 1);
     520        }
     521
     522        [TestMethod]
     523        [TestProperty("Time", "Short")]
     524        [TestCategory("ExpressionTest")]
     525        [TestCategory("CodeExpressionTest")]
    427526        public void TestExtract()
    428527        {
    … …  
    435534
    436535            Assert.AreEqual(result, interpreter.CodeStack.Top);
    437             this.CheckOtherStacksAreEmpty();
    438         }
    439 
    440         [TestMethod]
     536            CheckOtherStacksAreEmpty();
     537        }
     538
     539        [TestMethod]
     540        [TestProperty("Time", "Short")]
     541        [TestCategory("ExpressionTest")]
     542        [TestCategory("CodeExpressionTest")]
    441543        public void TestExtractInteger()
    442544        {
    … …  
    449551
    450552            Assert.AreEqual(result, interpreter.CodeStack.Top);
    451             this.CheckOtherStacksAreEmpty();
    452         }
    453 
    454         [TestMethod]
     553            CheckOtherStacksAreEmpty();
     554        }
     555
     556        [TestMethod]
     557        [TestProperty("Time", "Short")]
     558        [TestCategory("ExpressionTest")]
     559        [TestCategory("CodeExpressionTest")]
    455560        public void TestExtractFloat()
    456561        {
    … …  
    463568
    464569            Assert.AreEqual(result, interpreter.CodeStack.Top);
    465             this.CheckOtherStacksAreEmpty();
    466         }
    467 
    468         [TestMethod]
     570            CheckOtherStacksAreEmpty();
     571        }
     572
     573        [TestMethod]
     574        [TestProperty("Time", "Short")]
     575        [TestCategory("ExpressionTest")]
     576        [TestCategory("CodeExpressionTest")]
    469577        public void TestExtractBoolean()
    470578        {
    … …  
    477585
    478586            Assert.AreEqual(result, interpreter.CodeStack.Top);
    479             this.CheckOtherStacksAreEmpty();
    480         }
    481 
    482         [TestMethod]
     587            CheckOtherStacksAreEmpty();
     588        }
     589
     590        [TestMethod]
     591        [TestProperty("Time", "Short")]
     592        [TestCategory("ExpressionTest")]
     593        [TestCategory("CodeExpressionTest")]
    483594        public void TestExtractInstruction()
    484595        {
    … …  
    491602
    492603            Assert.AreEqual(result, interpreter.CodeStack.Top);
    493             this.CheckOtherStacksAreEmpty();
    494         }
    495 
    496         [TestMethod]
     604            CheckOtherStacksAreEmpty();
     605        }
     606
     607        [TestMethod]
     608        [TestProperty("Time", "Short")]
     609        [TestCategory("ExpressionTest")]
     610        [TestCategory("CodeExpressionTest")]
    497611        public void TestFromBoolean()
    498612        {
    … …  
    502616
    503617            Assert.AreEqual(result, interpreter.CodeStack.Top);
    504             this.CheckOtherStacksAreEmpty();
    505         }
    506 
    507         [TestMethod]
     618            CheckOtherStacksAreEmpty();
     619        }
     620
     621        [TestMethod]
     622        [TestProperty("Time", "Short")]
     623        [TestCategory("ExpressionTest")]
     624        [TestCategory("CodeExpressionTest")]
    508625        public void TestFromFloat()
    509626        {
    … …  
    513630
    514631            Assert.AreEqual(result, interpreter.CodeStack.Top);
    515             this.CheckOtherStacksAreEmpty();
    516         }
    517 
    518         [TestMethod]
     632            CheckOtherStacksAreEmpty();
     633        }
     634
     635        [TestMethod]
     636        [TestProperty("Time", "Short")]
     637        [TestCategory("ExpressionTest")]
     638        [TestCategory("CodeExpressionTest")]
    519639        public void TestFromInteger()
    520640        {
    … …  
    524644
    525645            Assert.AreEqual(result, interpreter.CodeStack.Top);
    526             this.CheckOtherStacksAreEmpty();
    527         }
    528 
    529         [TestMethod]
     646            CheckOtherStacksAreEmpty();
     647        }
     648
     649        [TestMethod]
     650        [TestProperty("Time", "Short")]
     651        [TestCategory("ExpressionTest")]
     652        [TestCategory("CodeExpressionTest")]
    530653        public void TestFromName()
    531654        {
    … …  
    535658
    536659            Assert.AreEqual(result, interpreter.CodeStack.Top);
    537             this.CheckOtherStacksAreEmpty();
    538         }
    539 
    540         [TestMethod]
     660            CheckOtherStacksAreEmpty();
     661        }
     662
     663        [TestMethod]
     664        [TestProperty("Time", "Short")]
     665        [TestCategory("ExpressionTest")]
     666        [TestCategory("CodeExpressionTest")]
    541667        public void TestIfTrue()
    542668        {
    … …  
    549675
    550676            Assert.AreEqual("WAHR", interpreter.NameStack.Top);
    551             this.TestStackCounts(nameStack: 1);
    552         }
    553 
    554         [TestMethod]
     677            TestStackCounts(nameStack: 1);
     678        }
     679
     680        [TestMethod]
     681        [TestProperty("Time", "Short")]
     682        [TestCategory("ExpressionTest")]
     683        [TestCategory("CodeExpressionTest")]
    555684        public void TestIfFalse()
    556685        {
    … …  
    563692
    564693            Assert.AreEqual("FALSCH", interpreter.NameStack.Top);
    565             this.TestStackCounts(nameStack: 1);
    566         }
    567 
    568         [TestMethod]
     694            TestStackCounts(nameStack: 1);
     695        }
     696
     697        [TestMethod]
     698        [TestProperty("Time", "Short")]
     699        [TestCategory("ExpressionTest")]
     700        [TestCategory("CodeExpressionTest")]
    569701        public void TestInsert()
    570702        {
    … …  
    578710
    579711            Assert.AreEqual(result, interpreter.CodeStack.Top);
    580             this.CheckOtherStacksAreEmpty();
    581         }
    582 
    583         [TestMethod]
     712            CheckOtherStacksAreEmpty();
     713        }
     714
     715        [TestMethod]
     716        [TestProperty("Time", "Short")]
     717        [TestCategory("ExpressionTest")]
     718        [TestCategory("CodeExpressionTest")]
    584719        public void TestInsertWithNegativeN()
    585720        {
    … …  
    593728
    594729            Assert.AreEqual(result, interpreter.CodeStack.Top);
    595             this.CheckOtherStacksAreEmpty();
    596         }
    597 
    598         [TestMethod]
     730            CheckOtherStacksAreEmpty();
     731        }
     732
     733        [TestMethod]
     734        [TestProperty("Time", "Short")]
     735        [TestCategory("ExpressionTest")]
     736        [TestCategory("CodeExpressionTest")]
    599737        public void TestInsertWithTooBigN()
    600738        {
    … …  
    608746
    609747            Assert.AreEqual(result, interpreter.CodeStack.Top);
    610             this.CheckOtherStacksAreEmpty();
    611         }
    612 
    613         [TestMethod]
     748            CheckOtherStacksAreEmpty();
     749        }
     750
     751        [TestMethod]
     752        [TestProperty("Time", "Short")]
     753        [TestCategory("ExpressionTest")]
     754        [TestCategory("CodeExpressionTest")]
    614755        public void TestList()
    615756        {
    … …  
    622763
    623764            Assert.AreEqual(result, interpreter.CodeStack.Top);
    624             this.CheckOtherStacksAreEmpty();
    625         }
    626 
    627         [TestMethod]
     765            CheckOtherStacksAreEmpty();
     766        }
     767
     768        [TestMethod]
     769        [TestProperty("Time", "Short")]
     770        [TestCategory("ExpressionTest")]
     771        [TestCategory("CodeExpressionTest")]
    628772        public void TestMemberTrue()
    629773        {
    … …  
    635779
    636780            Assert.AreEqual(true, interpreter.BooleanStack.Top);
    637             this.TestStackCounts(booleanStack: 1);
    638         }
    639 
    640         [TestMethod]
     781            TestStackCounts(booleanStack: 1);
     782        }
     783
     784        [TestMethod]
     785        [TestProperty("Time", "Short")]
     786        [TestCategory("ExpressionTest")]
     787        [TestCategory("CodeExpressionTest")]
    641788        public void TestMemberFalse()
    642789        {
    … …  
    648795
    649796            Assert.AreEqual(false, interpreter.BooleanStack.Top);
    650             this.TestStackCounts(booleanStack: 1);
    651         }
    652 
    653         [TestMethod]
     797            TestStackCounts(booleanStack: 1);
     798        }
     799
     800        [TestMethod]
     801        [TestProperty("Time", "Short")]
     802        [TestCategory("ExpressionTest")]
     803        [TestCategory("CodeExpressionTest")]
    654804        public void TestMemberIfNoList()
    655805        {
    … …  
    661811
    662812            Assert.AreEqual(true, interpreter.BooleanStack.Top);
    663             this.TestStackCounts(booleanStack: 1);
    664         }
    665 
    666         [TestMethod]
     813            TestStackCounts(booleanStack: 1);
     814        }
     815
     816        [TestMethod]
     817        [TestProperty("Time", "Short")]
     818        [TestCategory("ExpressionTest")]
     819        [TestCategory("CodeExpressionTest")]
    667820        public void TestNoop()
    668821        {
    669822            interpreter.Interpret(new CodeNoopExpression());
    670823
    671             this.CheckOtherStacksAreEmpty();
    672         }
    673 
    674         [TestMethod]
     824            CheckOtherStacksAreEmpty();
     825        }
     826
     827        [TestMethod]
     828        [TestProperty("Time", "Short")]
     829        [TestCategory("ExpressionTest")]
     830        [TestCategory("CodeExpressionTest")]
    675831        public void TestNthIfNoList()
    676832        {
    … …  
    683839
    684840            Assert.AreEqual(result, interpreter.CodeStack.Top);
    685             this.CheckOtherStacksAreEmpty();
    686         }
    687 
    688         [TestMethod]
     841            CheckOtherStacksAreEmpty();
     842        }
     843
     844        [TestMethod]
     845        [TestProperty("Time", "Short")]
     846        [TestCategory("ExpressionTest")]
     847        [TestCategory("CodeExpressionTest")]
    689848        public void TestNthIfEmpty()
    690849        {
    … …  
    697856
    698857            Assert.AreEqual(result, interpreter.CodeStack.Top);
    699             this.CheckOtherStacksAreEmpty();
    700         }
    701 
    702         [TestMethod]
     858            CheckOtherStacksAreEmpty();
     859        }
     860
     861        [TestMethod]
     862        [TestProperty("Time", "Short")]
     863        [TestCategory("ExpressionTest")]
     864        [TestCategory("CodeExpressionTest")]
    703865        public void TestNth()
    704866        {
    … …  
    711873
    712874            Assert.AreEqual(result, interpreter.CodeStack.Top);
    713             this.CheckOtherStacksAreEmpty();
    714         }
    715 
    716         [TestMethod]
     875            CheckOtherStacksAreEmpty();
     876        }
     877
     878        [TestMethod]
     879        [TestProperty("Time", "Short")]
     880        [TestCategory("ExpressionTest")]
     881        [TestCategory("CodeExpressionTest")]
    717882        public void TestNthWithTooBigN()
    718883        {
    … …  
    725890
    726891            Assert.AreEqual(result, interpreter.CodeStack.Top);
    727             this.CheckOtherStacksAreEmpty();
    728         }
    729 
    730         [TestMethod]
     892            CheckOtherStacksAreEmpty();
     893        }
     894
     895        [TestMethod]
     896        [TestProperty("Time", "Short")]
     897        [TestCategory("ExpressionTest")]
     898        [TestCategory("CodeExpressionTest")]
    731899        public void TestNthWithNegativeN()
    732900        {
    … …  
    739907
    740908            Assert.AreEqual(result, interpreter.CodeStack.Top);
    741             this.CheckOtherStacksAreEmpty();
    742         }
    743 
    744         [TestMethod]
     909            CheckOtherStacksAreEmpty();
     910        }
     911
     912        [TestMethod]
     913        [TestProperty("Time", "Short")]
     914        [TestCategory("ExpressionTest")]
     915        [TestCategory("CodeExpressionTest")]
    745916        public void TestNthCdr()
    746917        {
    … …  
    753924
    754925            Assert.AreEqual(result, interpreter.CodeStack.Top);
    755             this.CheckOtherStacksAreEmpty();
    756         }
    757 
    758         [TestMethod]
     926            CheckOtherStacksAreEmpty();
     927        }
     928
     929        [TestMethod]
     930        [TestProperty("Time", "Short")]
     931        [TestCategory("ExpressionTest")]
     932        [TestCategory("CodeExpressionTest")]
    759933        public void TestNthCdrWithTooBigN()
    760934        {
    … …  
    767941
    768942            Assert.AreEqual(result, interpreter.CodeStack.Top);
    769             this.CheckOtherStacksAreEmpty();
    770         }
    771 
    772         [TestMethod]
     943            CheckOtherStacksAreEmpty();
     944        }
     945
     946        [TestMethod]
     947        [TestProperty("Time", "Short")]
     948        [TestCategory("ExpressionTest")]
     949        [TestCategory("CodeExpressionTest")]
    773950        public void TestNthCdrWithNegativeN()
    774951        {
    … …  
    781958
    782959            Assert.AreEqual(result, interpreter.CodeStack.Top);
    783             this.CheckOtherStacksAreEmpty();
    784         }
    785 
    786         [TestMethod]
     960            CheckOtherStacksAreEmpty();
     961        }
     962
     963        [TestMethod]
     964        [TestProperty("Time", "Short")]
     965        [TestCategory("ExpressionTest")]
     966        [TestCategory("CodeExpressionTest")]
    787967        public void TestNthCdrIfEmpty()
    788968        {
    … …  
    795975
    796976            Assert.AreEqual(result, interpreter.CodeStack.Top);
    797             this.CheckOtherStacksAreEmpty();
    798         }
    799 
    800         [TestMethod]
     977            CheckOtherStacksAreEmpty();
     978        }
     979
     980        [TestMethod]
     981        [TestProperty("Time", "Short")]
     982        [TestCategory("ExpressionTest")]
     983        [TestCategory("CodeExpressionTest")]
    801984        public void TestNthCdrIfNoList()
    802985        {
    … …  
    809992
    810993            Assert.AreEqual(result, interpreter.CodeStack.Top);
    811             this.CheckOtherStacksAreEmpty();
    812         }
    813 
    814         [TestMethod]
     994            CheckOtherStacksAreEmpty();
     995        }
     996
     997        [TestMethod]
     998        [TestProperty("Time", "Short")]
     999        [TestCategory("ExpressionTest")]
     1000        [TestCategory("CodeExpressionTest")]
    8151001        public void TestNullTrue()
    8161002        {
    … …  
    8211007
    8221008            Assert.AreEqual(true, interpreter.BooleanStack.Top);
    823             this.TestStackCounts(booleanStack: 1);
    824         }
    825 
    826         [TestMethod]
     1009            TestStackCounts(booleanStack: 1);
     1010        }
     1011
     1012        [TestMethod]
     1013        [TestProperty("Time", "Short")]
     1014        [TestCategory("ExpressionTest")]
     1015        [TestCategory("CodeExpressionTest")]
    8271016        public void TestNullFalse()
    8281017        {
    … …  
    8331022
    8341023            Assert.AreEqual(false, interpreter.BooleanStack.Top);
    835             this.TestStackCounts(booleanStack: 1);
    836         }
    837 
    838         [TestMethod]
     1024            TestStackCounts(booleanStack: 1);
     1025        }
     1026
     1027        [TestMethod]
     1028        [TestProperty("Time", "Short")]
     1029        [TestCategory("ExpressionTest")]
     1030        [TestCategory("CodeExpressionTest")]
    8391031        public void TestPosition()
    8401032        {
    … …  
    8461038
    8471039            Assert.AreEqual(2, interpreter.IntegerStack.Top);
    848             this.TestStackCounts(integerStack: 1);
    849         }
    850 
    851         [TestMethod]
     1040            TestStackCounts(integerStack: 1);
     1041        }
     1042
     1043        [TestMethod]
     1044        [TestProperty("Time", "Short")]
     1045        [TestCategory("ExpressionTest")]
     1046        [TestCategory("CodeExpressionTest")]
    8521047        public void TestQuote()
    8531048        {
    … …  
    8571052
    8581053            Assert.AreEqual(result, interpreter.CodeStack.Top);
    859             this.CheckOtherStacksAreEmpty();
    860         }
    861 
    862         [TestMethod]
     1054            CheckOtherStacksAreEmpty();
     1055        }
     1056
     1057        [TestMethod]
     1058        [TestProperty("Time", "Short")]
     1059        [TestCategory("ExpressionTest")]
     1060        [TestCategory("CodeExpressionTest")]
    8631061        public void TestSize()
    8641062        {
    … …  
    8691067
    8701068            Assert.AreEqual(4, interpreter.IntegerStack.Top);
    871             this.TestStackCounts(integerStack: 1);
    872         }
    873 
    874         [TestMethod]
     1069            TestStackCounts(integerStack: 1);
     1070        }
     1071
     1072        [TestMethod]
     1073        [TestProperty("Time", "Short")]
     1074        [TestCategory("ExpressionTest")]
     1075        [TestCategory("CodeExpressionTest")]
    8751076        public void TestSubstitude()
    8761077        {
    … …  
    8841085
    8851086            Assert.AreEqual(result, interpreter.CodeStack.Top);
    886             this.CheckOtherStacksAreEmpty();
     1087            CheckOtherStacksAreEmpty();
    8871088        }
    8881089
    … …  
    9101111        protected override void CheckOtherStacksAreEmpty()
    9111112        {
    912             this.TestStackCounts(codeStack: null);
     1113            TestStackCounts(codeStack: null);
    9131114        }
    9141115    }

  • branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/CommonTests.cs

    r14392 r14398  
    77{
    88
    9     public abstract class CommonTests<T> : InterpreterTest
     9    public abstract class CommonTests<T> : ExpressionTest
    1010    {
    1111        protected const string FullInstructionNameFormat = "{0}.{1}";
    … …  
    1717        protected virtual T[] Get2Different()
    1818        {
    19             return this.GetValues(2);
     19            return GetValues(2);
    2020        }
    2121
    2222        protected virtual void Test(Expression expression)
    2323        {
    24             this.interpreter.Interpret(expression);
     24            interpreter.Interpret(expression);
    2525        }
    2626
    … …  
    2828
    2929        [TestMethod]
     30        [TestProperty("Time", "Short")]
     31        [TestCategory("ExpressionTest")]
     32        [TestCategory("CommonExpressionTest")]
    3033        public virtual void TestEqualsTrue()
    3134        {
    32             var values = this.GetValues(1);
     35            var values = GetValues(1);
    3336            var merged = new[] { values[0], values[0] };
    3437
    35             this.Stack.Push(merged);
     38            Stack.Push(merged);
    3639
    3740            var isBooleanStack = interpreter.BooleanStack.Count == 2;
    3841
    39             this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".="));
     42            Test(ExpressionTable.GetStatelessExpression(TypeName + ".="));
    4043
    4144            if (isBooleanStack)
    4245            {
    43                 Assert.AreEqual(1, this.Stack.Count);
     46                Assert.AreEqual(1, Stack.Count);
    4447            }
    4548            else
    4649            {
    47                 Assert.AreEqual(0, this.Stack.Count);
     50                Assert.AreEqual(0, Stack.Count);
    4851            }
    4952
    … …  
    5255
    5356        [TestMethod]
     57        [TestProperty("Time", "Short")]
     58        [TestCategory("ExpressionTest")]
     59        [TestCategory("CommonExpressionTest")]
    5460        public virtual void TestEqualsFalse()
    5561        {
    56             var values = this.Get2Different();
    57             this.Stack.Push(values);
     62            var values = Get2Different();
     63            Stack.Push(values);
    5864            var isBooleanStack = interpreter.BooleanStack.Count == 2;
    5965
    60             this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".="));
     66            Test(ExpressionTable.GetStatelessExpression(TypeName + ".="));
    6167
    6268            if (isBooleanStack)
    6369            {
    64                 Assert.AreEqual(1, this.Stack.Count);
     70                Assert.AreEqual(1, Stack.Count);
    6571            }
    6672            else
    6773            {
    68                 Assert.AreEqual(0, this.Stack.Count);
     74                Assert.AreEqual(0, Stack.Count);
    6975            }
    7076
    … …  
    7379
    7480        [TestMethod]
     81        [TestProperty("Time", "Short")]
     82        [TestCategory("ExpressionTest")]
     83        [TestCategory("CommonExpressionTest")]
    7584        public virtual void TestEqualsWithInsufficientArguments()
    7685        {
    77             this.TestWithInsufficientArguments("=", 1);
    78         }
    79 
    80         [TestMethod]
     86            TestWithInsufficientArguments("=", 1);
     87        }
     88
     89        [TestMethod]
     90        [TestProperty("Time", "Short")]
     91        [TestCategory("ExpressionTest")]
     92        [TestCategory("CommonExpressionTest")]
    8193        public virtual void TestPop()
    8294        {
    83             var values = this.GetValues(2);
    84             this.Stack.Push(values);
    85 
    86             this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".POP"));
    87 
    88             this.CheckOtherStacksAreEmpty();
    89         }
    90 
    91         [TestMethod]
     95            var values = GetValues(2);
     96            Stack.Push(values);
     97
     98            Test(ExpressionTable.GetStatelessExpression(TypeName + ".POP"));
     99
     100            CheckOtherStacksAreEmpty();
     101        }
     102
     103        [TestMethod]
     104        [TestProperty("Time", "Short")]
     105        [TestCategory("ExpressionTest")]
     106        [TestCategory("CommonExpressionTest")]
    92107        public virtual void TestSwap()
    93108        {
    94             var values = this.GetValues(3);
    95             this.Stack.Push(values);
    96 
    97             this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".SWAP"));
    98 
    99             Assert.AreEqual(values[0], this.Stack[0]);
    100             Assert.AreEqual(values[2], this.Stack[1]);
    101             Assert.AreEqual(values[1], this.Stack[2]);
    102 
    103             this.CheckOtherStacksAreEmpty();
    104         }
    105 
    106         [TestMethod]
     109            var values = GetValues(3);
     110            Stack.Push(values);
     111
     112            Test(ExpressionTable.GetStatelessExpression(TypeName + ".SWAP"));
     113
     114            Assert.AreEqual(values[0], Stack[0]);
     115            Assert.AreEqual(values[2], Stack[1]);
     116            Assert.AreEqual(values[1], Stack[2]);
     117
     118            CheckOtherStacksAreEmpty();
     119        }
     120
     121        [TestMethod]
     122        [TestProperty("Time", "Short")]
     123        [TestCategory("ExpressionTest")]
     124        [TestCategory("CommonExpressionTest")]
    107125        public virtual void TestSwapWithInsufficientArguments()
    108126        {
    109             this.TestWithInsufficientArguments("SWAP", 1);
    110         }
    111 
    112 
    113         [TestMethod]
     127            TestWithInsufficientArguments("SWAP", 1);
     128        }
     129
     130
     131        [TestMethod]
     132        [TestProperty("Time", "Short")]
     133        [TestCategory("ExpressionTest")]
     134        [TestCategory("CommonExpressionTest")]
    114135        public virtual void TestRotate()
    115136        {
    116             var values = this.GetValues(4);
    117             this.Stack.Push(values);
    118 
    119             this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".ROT"));
    120 
    121             Assert.AreEqual(values[0], this.Stack[0]);
    122             Assert.AreEqual(values[3], this.Stack[1]);
    123             Assert.AreEqual(values[1], this.Stack[2]);
    124             Assert.AreEqual(values[2], this.Stack[3]);
    125 
    126             this.CheckOtherStacksAreEmpty();
    127         }
    128 
    129         [TestMethod]
     137            var values = GetValues(4);
     138            Stack.Push(values);
     139
     140            Test(ExpressionTable.GetStatelessExpression(TypeName + ".ROT"));
     141
     142            Assert.AreEqual(values[0], Stack[0]);
     143            Assert.AreEqual(values[3], Stack[1]);
     144            Assert.AreEqual(values[1], Stack[2]);
     145            Assert.AreEqual(values[2], Stack[3]);
     146
     147            CheckOtherStacksAreEmpty();
     148        }
     149
     150        [TestMethod]
     151        [TestProperty("Time", "Short")]
     152        [TestCategory("ExpressionTest")]
     153        [TestCategory("CommonExpressionTest")]
    130154        public virtual void TestRotateWithInsufficientArguments()
    131155        {
    132             this.TestWithInsufficientArguments("ROT", 2);
    133         }
    134 
    135         [TestMethod]
     156            TestWithInsufficientArguments("ROT", 2);
     157        }
     158
     159        [TestMethod]
     160        [TestProperty("Time", "Short")]
     161        [TestCategory("ExpressionTest")]
     162        [TestCategory("CommonExpressionTest")]
    136163        public virtual void TestShove()
    137164        {
    138             var values = this.GetValues(3);
    139             this.Stack.Push(values);
     165            var values = GetValues(3);
     166            Stack.Push(values);
    140167
    141168            interpreter.IntegerStack.Push(1);
    142             this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".SHOVE"));
    143 
    144             Assert.AreEqual(values[0], this.Stack[0]);
    145             Assert.AreEqual(values[2], this.Stack[1]);
    146             Assert.AreEqual(values[1], this.Stack[2]);
    147 
    148             this.CheckOtherStacksAreEmpty();
    149         }
    150 
    151         [TestMethod]
     169            Test(ExpressionTable.GetStatelessExpression(TypeName + ".SHOVE"));
     170
     171            Assert.AreEqual(values[0], Stack[0]);
     172            Assert.AreEqual(values[2], Stack[1]);
     173            Assert.AreEqual(values[1], Stack[2]);
     174
     175            CheckOtherStacksAreEmpty();
     176        }
     177
     178        [TestMethod]
     179        [TestProperty("Time", "Short")]
     180        [TestCategory("ExpressionTest")]
     181        [TestCategory("CommonExpressionTest")]
    152182        public virtual void TestShoveWithInsufficientArguments()
    153183        {
    154             this.TestWithInsufficientArguments("SHOVE", 1);
    155         }
    156 
    157         [TestMethod]
     184            TestWithInsufficientArguments("SHOVE", 1);
     185        }
     186
     187        [TestMethod]
     188        [TestProperty("Time", "Short")]
     189        [TestCategory("ExpressionTest")]
     190        [TestCategory("CommonExpressionTest")]
    158191        public virtual void TestShoveWithNegativeIndex()
    159192        {
    160             this.TestWithNegativeIndex("SHOVE");
    161         }
    162 
    163         [TestMethod]
     193            TestWithNegativeIndex("SHOVE");
     194        }
     195
     196        [TestMethod]
     197        [TestProperty("Time", "Short")]
     198        [TestCategory("ExpressionTest")]
     199        [TestCategory("CommonExpressionTest")]
    164200        public virtual void TestYank()
    165201        {
    166             var values = this.GetValues(3);
    167             this.Stack.Push(values);
     202            var values = GetValues(3);
     203            Stack.Push(values);
    168204
    169205            interpreter.IntegerStack.Push(1);
    170             this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".YANK"));
    171 
    172             Assert.AreEqual(values[0], this.Stack[0]);
    173             Assert.AreEqual(values[2], this.Stack[1]);
    174             Assert.AreEqual(values[1], this.Stack[2]);
    175 
    176             this.CheckOtherStacksAreEmpty();
    177         }
    178 
    179         [TestMethod]
     206            Test(ExpressionTable.GetStatelessExpression(TypeName + ".YANK"));
     207
     208            Assert.AreEqual(values[0], Stack[0]);
     209            Assert.AreEqual(values[2], Stack[1]);
     210            Assert.AreEqual(values[1], Stack[2]);
     211
     212            CheckOtherStacksAreEmpty();
     213        }
     214
     215        [TestMethod]
     216        [TestProperty("Time", "Short")]
     217        [TestCategory("ExpressionTest")]
     218        [TestCategory("CommonExpressionTest")]
    180219        public virtual void TestYankWithInsufficientArguments()
    181220        {
    182             this.TestWithInsufficientArguments("YANK", 1);
    183         }
    184 
    185         [TestMethod]
     221            TestWithInsufficientArguments("YANK", 1);
     222        }
     223
     224        [TestMethod]
     225        [TestProperty("Time", "Short")]
     226        [TestCategory("ExpressionTest")]
     227        [TestCategory("CommonExpressionTest")]
    186228        public virtual void TestYankWithNegativeIndex()
    187229        {
    188             this.TestWithNegativeIndex("YANK");
    189         }
    190 
    191         [TestMethod]
     230            TestWithNegativeIndex("YANK");
     231        }
     232
     233        [TestMethod]
     234        [TestProperty("Time", "Short")]
     235        [TestCategory("ExpressionTest")]
     236        [TestCategory("CommonExpressionTest")]
    192237        public virtual void TestYankDuplicate()
    193238        {
    194             var values = this.GetValues(3);
    195             this.Stack.Push(values);
     239            var values = GetValues(3);
     240            Stack.Push(values);
    196241
    197242            interpreter.IntegerStack.Push(1);
    198             this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".YANKDUP"));
    199 
    200             Assert.AreEqual(values[0], this.Stack[0]);
    201             Assert.AreEqual(values[1], this.Stack[1]);
    202             Assert.AreEqual(values[2], this.Stack[2]);
    203             Assert.AreEqual(values[1], this.Stack[3]);
    204 
    205             this.CheckOtherStacksAreEmpty();
    206         }
    207 
    208         [TestMethod]
     243            Test(ExpressionTable.GetStatelessExpression(TypeName + ".YANKDUP"));
     244
     245            Assert.AreEqual(values[0], Stack[0]);
     246            Assert.AreEqual(values[1], Stack[1]);
     247            Assert.AreEqual(values[2], Stack[2]);
     248            Assert.AreEqual(values[1], Stack[3]);
     249
     250            CheckOtherStacksAreEmpty();
     251        }
     252
     253        [TestMethod]
     254        [TestProperty("Time", "Short")]
     255        [TestCategory("ExpressionTest")]
     256        [TestCategory("CommonExpressionTest")]
    209257        public virtual void TestYankDuplicateWithInsufficientArguments()
    210258        {
    211             this.TestWithInsufficientArguments("YANKDUP", 1);
    212         }
    213 
    214         [TestMethod]
     259            TestWithInsufficientArguments("YANKDUP", 1);
     260        }
     261
     262        [TestMethod]
     263        [TestProperty("Time", "Short")]
     264        [TestCategory("ExpressionTest")]
     265        [TestCategory("CommonExpressionTest")]
    215266        public virtual void TestYankDuplicateWithNegativeIndex()
    216267        {
    217             this.TestWithNegativeIndex("YANKDUP");
    218         }
    219 
    220         [TestMethod]
     268            TestWithNegativeIndex("YANKDUP");
     269        }
     270
     271        [TestMethod]
     272        [TestProperty("Time", "Short")]
     273        [TestCategory("ExpressionTest")]
     274        [TestCategory("CommonExpressionTest")]
    221275        public virtual void TestStackdpeth()
    222276        {
    223             var values = this.GetValues(3);
    224             this.Stack.Push(values);
    225 
    226             this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".STACKDEPTH"));
     277            var values = GetValues(3);
     278            Stack.Push(values);
     279
     280            Test(ExpressionTable.GetStatelessExpression(TypeName + ".STACKDEPTH"));
    227281
    228282            // if stack is integer stack
    229             if (this.Stack.Count != values.Length)
    230             {
    231                 Assert.AreEqual(4, this.Stack.Count);
    232                 this.CheckOtherStacksAreEmpty();
     283            if (Stack.Count != values.Length)
     284            {
     285                Assert.AreEqual(4, Stack.Count);
     286                CheckOtherStacksAreEmpty();
    233287            }
    234288            else
    235289            {
    236                 Assert.AreEqual(3, this.Stack.Count);
     290                Assert.AreEqual(3, Stack.Count);
    237291                Assert.AreEqual(values.Length, interpreter.IntegerStack.Top);
    238292            }
    … …  
    243297            for (var i = 0; i < argCount + 1; i++)
    244298            {
    245                 var values = this.GetValues(i);
    246                 this.Stack.Push(values);
    247 
    248                 var fullInstructionname = string.Format(FullInstructionNameFormat, this.TypeName, instructionName);
    249                 this.Test(ExpressionTable.GetStatelessExpression(fullInstructionname));
     299                var values = GetValues(i);
     300                Stack.Push(values);
     301
     302                var fullInstructionname = string.Format(FullInstructionNameFormat, TypeName, instructionName);
     303                Test(ExpressionTable.GetStatelessExpression(fullInstructionname));
    250304
    251305                for (var j = 0; j < i; j++)
    252306                {
    253                     Assert.AreEqual(values[j], this.Stack[j]);
     307                    Assert.AreEqual(values[j], Stack[j]);
    254308                }
    255309
    256                 this.CheckOtherStacksAreEmpty();
     310                CheckOtherStacksAreEmpty();
    257311                interpreter.Clear();
    258312            }
    … …  
    261315        protected void TestWithNegativeIndex(string instructionName)
    262316        {
    263             var values = this.GetValues(1);
    264             this.Stack.Push(values);
     317            var values = GetValues(1);
     318            Stack.Push(values);
    265319
    266320            interpreter.IntegerStack.Push(-1);
    267321
    268             var fullInstructionname = string.Format(FullInstructionNameFormat, this.TypeName, instructionName);
    269             this.Test(ExpressionTable.GetStatelessExpression(fullInstructionname));
    270 
    271             Assert.AreEqual(values[0], this.Stack[0]);
     322            var fullInstructionname = string.Format(FullInstructionNameFormat, TypeName, instructionName);
     323            Test(ExpressionTable.GetStatelessExpression(fullInstructionname));
     324
     325            Assert.AreEqual(values[0], Stack[0]);
    272326        }
    273327    }

  • branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/ExampleTests.cs

    r14392 r14398  
    55{
    66    [TestClass]
    7     public class MixedExpressionTests : InterpreterTest
     7    public class MixedExpressionTests : ExpressionTest
    88    {
    99        const double Delta = 0.00000001;
    1010
    1111        [TestMethod]
     12        [TestProperty("Time", "Short")]
     13        [TestCategory("ExampleTest")]
    1214        public void Example1()
    1315        {
    14             this.interpreter.Interpret("( 2 3 INTEGER.* 4.1 5.2 FLOAT.+ TRUE FALSE BOOLEAN.OR )");
     16            interpreter.Interpret("( 2 3 INTEGER.* 4.1 5.2 FLOAT.+ TRUE FALSE BOOLEAN.OR )");
    1517
    1618            Assert.AreEqual(6, interpreter.IntegerStack.Top);
    … …  
    2325
    2426        [TestMethod]
     27        [TestProperty("Time", "Short")]
     28        [TestCategory("ExampleTest")]
    2529        public void Example2()
    2630        {
    27             this.interpreter.Interpret("( 5 1.23 INTEGER.+ ( 4 ) INTEGER.- 5.67 FLOAT.* )");
     31            interpreter.Interpret("( 5 1.23 INTEGER.+ ( 4 ) INTEGER.- 5.67 FLOAT.* )");
    2832
    2933            Assert.AreEqual(1, interpreter.IntegerStack.Top);
    … …  
    3640
    3741        [TestMethod]
     42        [TestProperty("Time", "Short")]
     43        [TestCategory("ExampleTest")]
    3844        public void Example3()
    3945        {
    40             this.interpreter.Interpret("( 5 INTEGER.DUP INTEGER.+ )");
    41 
    42             Assert.AreEqual(10, interpreter.IntegerStack.Top);
    43             Assert.IsTrue(interpreter.CodeStack.IsEmpty);
    44             Assert.IsTrue(interpreter.ExecStack.IsEmpty);
    45             Assert.IsTrue(interpreter.NameStack.IsEmpty);
    46             Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
    47             Assert.IsTrue(interpreter.FloatStack.IsEmpty);
    48         }
    49 
    50         [TestMethod]
     46            interpreter.Interpret("( 5 INTEGER.DUP INTEGER.+ )");
     47
     48            Assert.AreEqual(10, interpreter.IntegerStack.Top);
     49            Assert.IsTrue(interpreter.CodeStack.IsEmpty);
     50            Assert.IsTrue(interpreter.ExecStack.IsEmpty);
     51            Assert.IsTrue(interpreter.NameStack.IsEmpty);
     52            Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
     53            Assert.IsTrue(interpreter.FloatStack.IsEmpty);
     54        }
     55
     56        [TestMethod]
     57        [TestProperty("Time", "Short")]
     58        [TestCategory("ExampleTest")]
    5159        public void Example4()
    5260        {
    53             this.interpreter.Interpret("( 5 CODE.QUOTE ( INTEGER.DUP INTEGER.+ ) CODE.DO )");
    54 
    55             Assert.AreEqual(10, interpreter.IntegerStack.Top);
    56             Assert.IsTrue(interpreter.CodeStack.IsEmpty);
    57             Assert.IsTrue(interpreter.ExecStack.IsEmpty);
    58             Assert.IsTrue(interpreter.NameStack.IsEmpty);
    59             Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
    60             Assert.IsTrue(interpreter.FloatStack.IsEmpty);
    61         }
    62 
    63         [TestMethod]
     61            interpreter.Interpret("( 5 CODE.QUOTE ( INTEGER.DUP INTEGER.+ ) CODE.DO )");
     62
     63            Assert.AreEqual(10, interpreter.IntegerStack.Top);
     64            Assert.IsTrue(interpreter.CodeStack.IsEmpty);
     65            Assert.IsTrue(interpreter.ExecStack.IsEmpty);
     66            Assert.IsTrue(interpreter.NameStack.IsEmpty);
     67            Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
     68            Assert.IsTrue(interpreter.FloatStack.IsEmpty);
     69        }
     70
     71        [TestMethod]
     72        [TestProperty("Time", "Short")]
     73        [TestCategory("ExampleTest")]
    6474        public void Example5()
    6575        {
    66             this.interpreter.Interpret("( DOUBLE CODE.QUOTE ( INTEGER.DUP INTEGER.+ ) CODE.DEFINE 5 DOUBLE )");
    67 
    68             Assert.AreEqual(10, interpreter.IntegerStack.Top);
    69             Assert.IsTrue(interpreter.CodeStack.IsEmpty);
    70             Assert.IsTrue(interpreter.ExecStack.IsEmpty);
    71             Assert.IsTrue(interpreter.NameStack.IsEmpty);
    72             Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
    73             Assert.IsTrue(interpreter.FloatStack.IsEmpty);
    74         }
    75 
    76         [TestMethod]
     76            interpreter.Interpret("( DOUBLE CODE.QUOTE ( INTEGER.DUP INTEGER.+ ) CODE.DEFINE 5 DOUBLE )");
     77
     78            Assert.AreEqual(10, interpreter.IntegerStack.Top);
     79            Assert.IsTrue(interpreter.CodeStack.IsEmpty);
     80            Assert.IsTrue(interpreter.ExecStack.IsEmpty);
     81            Assert.IsTrue(interpreter.NameStack.IsEmpty);
     82            Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
     83            Assert.IsTrue(interpreter.FloatStack.IsEmpty);
     84        }
     85
     86        [TestMethod]
     87        [TestProperty("Time", "Short")]
     88        [TestCategory("ExampleTest")]
    7789        public void Example6()
    7890        {
    79             this.interpreter.Interpret("( CODE.QUOTE ( INTEGER.DUP INTEGER.+ ) DOUBLE CODE.DEFINE 5 DOUBLE )");
    80 
    81             Assert.AreEqual(10, interpreter.IntegerStack.Top);
    82             Assert.IsTrue(interpreter.CodeStack.IsEmpty);
    83             Assert.IsTrue(interpreter.ExecStack.IsEmpty);
    84             Assert.IsTrue(interpreter.NameStack.IsEmpty);
    85             Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
    86             Assert.IsTrue(interpreter.FloatStack.IsEmpty);
    87         }
    88 
    89         [TestMethod]
     91            interpreter.Interpret("( CODE.QUOTE ( INTEGER.DUP INTEGER.+ ) DOUBLE CODE.DEFINE 5 DOUBLE )");
     92
     93            Assert.AreEqual(10, interpreter.IntegerStack.Top);
     94            Assert.IsTrue(interpreter.CodeStack.IsEmpty);
     95            Assert.IsTrue(interpreter.ExecStack.IsEmpty);
     96            Assert.IsTrue(interpreter.NameStack.IsEmpty);
     97            Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
     98            Assert.IsTrue(interpreter.FloatStack.IsEmpty);
     99        }
     100
     101        [TestMethod]
     102        [TestProperty("Time", "Short")]
     103        [TestCategory("ExampleTest")]
    90104        public void Example7()
    91105        {
    92             this.interpreter.Interpret("( DOUBLE EXEC.DEFINE ( INTEGER.DUP INTEGER.+ ) 5 DOUBLE )");
    93 
    94             Assert.AreEqual(10, interpreter.IntegerStack.Top);
    95             Assert.IsTrue(interpreter.CodeStack.IsEmpty);
    96             Assert.IsTrue(interpreter.ExecStack.IsEmpty);
    97             Assert.IsTrue(interpreter.NameStack.IsEmpty);
    98             Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
    99             Assert.IsTrue(interpreter.FloatStack.IsEmpty);
    100         }
    101 
    102         [TestMethod]
     106            interpreter.Interpret("( DOUBLE EXEC.DEFINE ( INTEGER.DUP INTEGER.+ ) 5 DOUBLE )");
     107
     108            Assert.AreEqual(10, interpreter.IntegerStack.Top);
     109            Assert.IsTrue(interpreter.CodeStack.IsEmpty);
     110            Assert.IsTrue(interpreter.ExecStack.IsEmpty);
     111            Assert.IsTrue(interpreter.NameStack.IsEmpty);
     112            Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
     113            Assert.IsTrue(interpreter.FloatStack.IsEmpty);
     114        }
     115
     116        [TestMethod]
     117        [TestProperty("Time", "Short")]
     118        [TestCategory("ExampleTest")]
    103119        public void Example8()
    104120        {
    105             this.interpreter.Configuration.TopLevelPushCode = true;
    106 
    107             this.interpreter.IntegerStack.Push(5);
    108             this.interpreter.Interpret(@"( CODE.QUOTE ( INTEGER.POP 1 )
     121            interpreter.Configuration.TopLevelPushCode = true;
     122
     123            interpreter.IntegerStack.Push(5);
     124            interpreter.Interpret(@"( CODE.QUOTE ( INTEGER.POP 1 )
    109125                                           CODE.QUOTE ( CODE.DUP INTEGER.DUP 1 INTEGER.- CODE.DO INTEGER.* )
    110126                                           INTEGER.DUP 2 INTEGER.< CODE.IF )");
    … …  
    119135
    120136        [TestMethod]
     137        [TestProperty("Time", "Short")]
     138        [TestCategory("ExampleTest")]
    121139        public void Example9()
    122140        {
    123             this.interpreter.IntegerStack.Push(5);
    124             this.interpreter.Interpret("( 1 INTEGER.MAX 1 EXEC.DO*RANGE INTEGER.* )");
     141            interpreter.IntegerStack.Push(5);
     142            interpreter.Interpret("( 1 INTEGER.MAX 1 EXEC.DO*RANGE INTEGER.* )");
    125143
    126144            Assert.AreEqual(120, interpreter.IntegerStack.Top);
    … …  
    133151
    134152        [TestMethod]
     153        [TestProperty("Time", "Short")]
     154        [TestCategory("ExampleTest")]
    135155        public void Example10()
    136156        {
    137             this.interpreter.IntegerStack.Push(5);
    138             this.interpreter.Interpret("( 1 INTEGER.MAX 1 EXEC.DO*RANGE ( 2 INTEGER.* ) )");
     157            interpreter.IntegerStack.Push(5);
     158            interpreter.Interpret("( 1 INTEGER.MAX 1 EXEC.DO*RANGE ( 2 INTEGER.* ) )");
    139159
    140160            Assert.AreEqual(2, interpreter.IntegerStack.Top);
    … …  
    147167
    148168        [TestMethod]
     169        [TestProperty("Time", "Short")]
     170        [TestCategory("ExampleTest")]
    149171        public void Example11()
    150172        {
    151173            var program = PushGPInterpreter.Encode("( INTEGER.= CODE.QUOTE FLOAT.* CODE.QUOTE FLOAT./ CODE.IF )");
    152174
    153             this.interpreter.IntegerStack.Push(1, 1);
    154             this.interpreter.FloatStack.Push(2.1, 0.7);
    155 
    156             this.interpreter.Interpret(program);
     175            interpreter.IntegerStack.Push(1, 1);
     176            interpreter.FloatStack.Push(2.1, 0.7);
     177
     178            interpreter.Interpret(program);
    157179
    158180            Assert.IsTrue(interpreter.IntegerStack.IsEmpty);
    … …  
    163185            Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
    164186
    165             this.interpreter.Clear();
    166             this.interpreter.IntegerStack.Push(1, 2);
    167             this.interpreter.FloatStack.Push(2.1, 0.7);
    168             this.interpreter.Interpret(program);
     187            interpreter.Clear();
     188            interpreter.IntegerStack.Push(1, 2);
     189            interpreter.FloatStack.Push(2.1, 0.7);
     190            interpreter.Interpret(program);
    169191
    170192            Assert.IsTrue(interpreter.IntegerStack.IsEmpty);
    … …  
    177199
    178200        [TestMethod]
     201        [TestProperty("Time", "Short")]
     202        [TestCategory("ExampleTest")]
    179203        public void Example12()
    180204        {
    181205            var program = PushGPInterpreter.Encode("( INTEGER.= EXEC.IF FLOAT.* FLOAT./ )");
    182206
    183             this.interpreter.IntegerStack.Push(1, 1);
    184             this.interpreter.FloatStack.Push(2.1, 0.7);
    185 
    186             this.interpreter.Interpret(program);
     207            interpreter.IntegerStack.Push(1, 1);
     208            interpreter.FloatStack.Push(2.1, 0.7);
     209
     210            interpreter.Interpret(program);
    187211
    188212            Assert.IsTrue(interpreter.IntegerStack.IsEmpty);
    … …  
    193217            Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
    194218
    195             this.interpreter.Clear();
    196             this.interpreter.IntegerStack.Push(1, 2);
    197             this.interpreter.FloatStack.Push(2.1, 0.7);
    198             this.interpreter.Interpret(program);
     219            interpreter.Clear();
     220            interpreter.IntegerStack.Push(1, 2);
     221            interpreter.FloatStack.Push(2.1, 0.7);
     222            interpreter.Interpret(program);
    199223
    200224            Assert.IsTrue(interpreter.IntegerStack.IsEmpty);
    … …  
    207231
    208232        [TestMethod]
     233        [TestProperty("Time", "Short")]
     234        [TestCategory("ExampleTest")]
    209235        public void Example13()
    210236        {
    211             this.interpreter.IntegerStack.Push(5);
    212             this.interpreter.Interpret("( EXEC.Y ( ( FALSE 2 INTEGER.* ) EXEC.IF ( ) EXEC.POP ) )");
    213 
    214             Assert.AreEqual(10, interpreter.IntegerStack.Top);
    215             Assert.IsTrue(interpreter.CodeStack.IsEmpty);
    216             Assert.IsTrue(interpreter.ExecStack.IsEmpty);
    217             Assert.IsTrue(interpreter.NameStack.IsEmpty);
    218             Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
    219             Assert.IsTrue(interpreter.FloatStack.IsEmpty);
    220         }
    221 
    222         [TestMethod]
     237            interpreter.IntegerStack.Push(5);
     238            interpreter.Interpret("( EXEC.Y ( ( FALSE 2 INTEGER.* ) EXEC.IF ( ) EXEC.POP ) )");
     239
     240            Assert.AreEqual(10, interpreter.IntegerStack.Top);
     241            Assert.IsTrue(interpreter.CodeStack.IsEmpty);
     242            Assert.IsTrue(interpreter.ExecStack.IsEmpty);
     243            Assert.IsTrue(interpreter.NameStack.IsEmpty);
     244            Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
     245            Assert.IsTrue(interpreter.FloatStack.IsEmpty);
     246        }
     247
     248        [TestMethod]
     249        [TestProperty("Time", "Short")]
     250        [TestCategory("ExampleTest")]
    223251        public void Example14()
    224252        {
    225             this.interpreter.IntegerStack.Push(5);
    226             this.interpreter.Interpret("( EXEC.Y ( ( 2 INTEGER.* INTEGER.DUP 1000 INTEGER.< ) EXEC.IF ( ) EXEC.POP ) )");
     253            interpreter.IntegerStack.Push(5);
     254            interpreter.Interpret("( EXEC.Y ( ( 2 INTEGER.* INTEGER.DUP 1000 INTEGER.< ) EXEC.IF ( ) EXEC.POP ) )");
    227255
    228256            Assert.AreEqual(1280, interpreter.IntegerStack.Top);
    … …  
    235263
    236264        [TestMethod]
     265        [TestProperty("Time", "Short")]
     266        [TestCategory("ExampleTest")]
    237267        public void Example15()
    238268        {
    239             this.interpreter.IntegerStack.Push(10);
    240             this.interpreter.FloatStack.Push(2);
    241             this.interpreter.Interpret(@"( ARG FLOAT.DEFINE
     269            interpreter.IntegerStack.Push(10);
     270            interpreter.FloatStack.Push(2);
     271            interpreter.Interpret(@"( ARG FLOAT.DEFINE
    242272                                           EXEC.Y (
    243273                                           ARG FLOAT.*

  • branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/ExecExpressionTests.cs

    r14392 r14398  
    1515        protected override void Test(Expression expression)
    1616        {
    17             this.interpreter.InterpretAsync(expression, true).Wait();
     17            interpreter.InterpretAsync(expression, true).Wait();
    1818        }
    1919
    2020        [TestMethod]
     21        [TestProperty("Time", "Short")]
     22        [TestCategory("ExpressionTest")]
     23        [TestCategory("ExecExpressionTest")]
    2124        public void TestIfTrue()
    2225        {
    … …  
    2528
    2629            Assert.AreEqual("WAHR", interpreter.NameStack.Top);
    27             this.TestStackCounts(nameStack: 1);
     30            TestStackCounts(nameStack: 1);
    2831        }
    2932
    3033        [TestMethod]
     34        [TestProperty("Time", "Short")]
     35        [TestCategory("ExpressionTest")]
     36        [TestCategory("ExecExpressionTest")]
    3137        public void TestIfFalse()
    3238        {
    … …  
    3541
    3642            Assert.AreEqual("FALSCH", interpreter.NameStack.Top);
    37             this.TestStackCounts(nameStack: 1);
     43            TestStackCounts(nameStack: 1);
    3844        }
    3945
    4046        [TestMethod]
     47        [TestProperty("Time", "Short")]
     48        [TestCategory("ExpressionTest")]
     49        [TestCategory("ExecExpressionTest")]
    4150        public void TestK()
    4251        {
    … …  
    4655
    4756            interpreter.ExecStack.Push(third, second, first);
    48             this.Test(new ExecKExpression());
     57            Test(new ExecKExpression());
    4958
    5059            Assert.AreEqual(first, interpreter.ExecStack.Top);
    5160            Assert.AreEqual(third, interpreter.ExecStack.Bottom);
    52             this.TestStackCounts(execStack: 2);
     61            TestStackCounts(execStack: 2);
    5362        }
    5463
    5564        [TestMethod]
     65        [TestProperty("Time", "Short")]
     66        [TestCategory("ExpressionTest")]
     67        [TestCategory("ExecExpressionTest")]
    5668        public void TestS()
    5769        {
    … …  
    6274
    6375            interpreter.ExecStack.Push(third, second, first);
    64             this.Test(new ExecSExpression());
     76            Test(new ExecSExpression());
    6577
    6678            Assert.AreEqual(result, interpreter.ExecStack.ReverseElementAt(2));
    6779            Assert.AreEqual(third, interpreter.ExecStack.ReverseElementAt(1));
    6880            Assert.AreEqual(first, interpreter.ExecStack.Top);
    69             this.TestStackCounts(execStack: 3);
     81            TestStackCounts(execStack: 3);
    7082        }
    7183
    7284        [TestMethod]
     85        [TestProperty("Time", "Short")]
     86        [TestCategory("ExpressionTest")]
     87        [TestCategory("ExecExpressionTest")]
    7388        public void TestY()
    7489        {
    … …  
    7792
    7893            interpreter.ExecStack.Push(first);
    79             this.Test(new ExecYExpression());
     94            Test(new ExecYExpression());
    8095
    8196            Assert.AreEqual(first, interpreter.ExecStack.Top);
    8297            Assert.AreEqual(result, interpreter.ExecStack.ReverseElementAt(1));
    83             this.TestStackCounts(execStack: 2);
     98            TestStackCounts(execStack: 2);
    8499        }
    85100
    86101        [TestMethod]
     102        [TestProperty("Time", "Short")]
     103        [TestCategory("ExpressionTest")]
     104        [TestCategory("ExecExpressionTest")]
    87105        public void TestNestedDoRange()
    88106        {
    … …  
    90108
    91109            Assert.AreEqual(144, interpreter.IntegerStack.Top);
    92             this.TestStackCounts(integerStack: 1);
     110            TestStackCounts(integerStack: 1);
    93111        }
    94112
    95113        [TestMethod]
     114        [TestProperty("Time", "Short")]
     115        [TestCategory("ExpressionTest")]
     116        [TestCategory("ExecExpressionTest")]
    96117        public void TestNestedDoCount()
    97118        {
    … …  
    99120
    100121            Assert.AreEqual(144, interpreter.IntegerStack.Top);
    101             this.TestStackCounts(integerStack: 1);
     122            TestStackCounts(integerStack: 1);
    102123        }
    103124
    104125        [TestMethod]
     126        [TestProperty("Time", "Short")]
     127        [TestCategory("ExpressionTest")]
     128        [TestCategory("ExecExpressionTest")]
    105129        public void TestNestedDoTimes()
    106130        {
    … …  
    108132
    109133            Assert.AreEqual(128, interpreter.IntegerStack.Top);
    110             this.TestStackCounts(integerStack: 1);
     134            TestStackCounts(integerStack: 1);
    111135        }
    112136
    … …  
    134158        protected override void CheckOtherStacksAreEmpty()
    135159        {
    136             this.TestStackCounts(execStack: null);
     160            TestStackCounts(execStack: null);
    137161        }
    138162    }

  • branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/FloatExpressionTests.cs

    r14392 r14398  
    1414
    1515        [TestMethod]
     16        [TestProperty("Time", "Short")]
     17        [TestCategory("ExpressionTest")]
     18        [TestCategory("FloatExpressionTest")]
    1619        public void TestAdd()
    1720        {
    … …  
    2124            Assert.AreEqual(10.6, interpreter.FloatStack.Top, delta);
    2225
    23             this.TestStackCounts(floatStack: 1);
    24         }
    25 
    26         [TestMethod]
     26            TestStackCounts(floatStack: 1);
     27        }
     28
     29        [TestMethod]
     30        [TestProperty("Time", "Short")]
     31        [TestCategory("ExpressionTest")]
     32        [TestCategory("FloatExpressionTest")]
    2733        public void TestAddWithInsufficientArguments()
    2834        {
    29             this.TestWithInsufficientArguments("+", 1);
    30         }
    31 
    32         [TestMethod]
     35            TestWithInsufficientArguments("+", 1);
     36        }
     37
     38        [TestMethod]
     39        [TestProperty("Time", "Short")]
     40        [TestCategory("ExpressionTest")]
     41        [TestCategory("FloatExpressionTest")]
    3342        public void TestSubtract()
    3443        {
    … …  
    3847            Assert.AreEqual(4.9, interpreter.FloatStack.Top, delta);
    3948
    40             this.TestStackCounts(floatStack: 1);
    41         }
    42 
    43         [TestMethod]
     49            TestStackCounts(floatStack: 1);
     50        }
     51
     52        [TestMethod]
     53        [TestProperty("Time", "Short")]
     54        [TestCategory("ExpressionTest")]
     55        [TestCategory("FloatExpressionTest")]
    4456        public void TestSubractWithInsufficientArguments()
    4557        {
    46             this.TestWithInsufficientArguments("-", 1);
    47         }
    48 
    49         [TestMethod]
     58            TestWithInsufficientArguments("-", 1);
     59        }
     60
     61        [TestMethod]
     62        [TestProperty("Time", "Short")]
     63        [TestCategory("ExpressionTest")]
     64        [TestCategory("FloatExpressionTest")]
    5065        public void TestMultiply()
    5166        {
    … …  
    5570            Assert.AreEqual(32.67, interpreter.FloatStack.Top, delta);
    5671
    57             this.TestStackCounts(floatStack: 1);
    58         }
    59 
    60         [TestMethod]
     72            TestStackCounts(floatStack: 1);
     73        }
     74
     75        [TestMethod]
     76        [TestProperty("Time", "Short")]
     77        [TestCategory("ExpressionTest")]
     78        [TestCategory("FloatExpressionTest")]
    6179        public void TestMultiplyWithInsufficientArguments()
    6280        {
    63             this.TestWithInsufficientArguments("*", 1);
    64         }
    65 
    66         [TestMethod]
     81            TestWithInsufficientArguments("*", 1);
     82        }
     83
     84        [TestMethod]
     85        [TestProperty("Time", "Short")]
     86        [TestCategory("ExpressionTest")]
     87        [TestCategory("FloatExpressionTest")]
    6788        public void TestDivide()
    6889        {
    … …  
    7293            Assert.AreEqual(3.0, interpreter.FloatStack.Top, delta);
    7394
    74             this.TestStackCounts(floatStack: 1);
    75         }
    76 
    77         [TestMethod]
     95            TestStackCounts(floatStack: 1);
     96        }
     97
     98        [TestMethod]
     99        [TestProperty("Time", "Short")]
     100        [TestCategory("ExpressionTest")]
     101        [TestCategory("FloatExpressionTest")]
    78102        public void TestDivideWithInsufficientArguments()
    79103        {
    80             this.TestWithInsufficientArguments("/", 1);
    81         }
    82 
    83         [TestMethod]
     104            TestWithInsufficientArguments("/", 1);
     105        }
     106
     107        [TestMethod]
     108        [TestProperty("Time", "Short")]
     109        [TestCategory("ExpressionTest")]
     110        [TestCategory("FloatExpressionTest")]
    84111        public void TestModulo()
    85112        {
    … …  
    89116            Assert.AreEqual(1, interpreter.FloatStack.Top, delta);
    90117
    91             this.TestStackCounts(floatStack: 1);
    92         }
    93 
    94         [TestMethod]
     118            TestStackCounts(floatStack: 1);
     119        }
     120
     121        [TestMethod]
     122        [TestProperty("Time", "Short")]
     123        [TestCategory("ExpressionTest")]
     124        [TestCategory("FloatExpressionTest")]
    95125        public void TestModuloWithInsufficientArguments()
    96126        {
    97             this.TestWithInsufficientArguments("%", 1);
    98         }
    99 
    100         [TestMethod]
     127            TestWithInsufficientArguments("%", 1);
     128        }
     129
     130        [TestMethod]
     131        [TestProperty("Time", "Short")]
     132        [TestCategory("ExpressionTest")]
     133        [TestCategory("FloatExpressionTest")]
    101134        public void TestMin()
    102135        {
    … …  
    106139            Assert.AreEqual(5.3, interpreter.FloatStack.Top, delta);
    107140
    108             this.TestStackCounts(floatStack: 1);
    109         }
    110 
    111         [TestMethod]
     141            TestStackCounts(floatStack: 1);
     142        }
     143
     144        [TestMethod]
     145        [TestProperty("Time", "Short")]
     146        [TestCategory("ExpressionTest")]
     147        [TestCategory("FloatExpressionTest")]
    112148        public void TestMinWithInsufficientArguments()
    113149        {
    114             this.TestWithInsufficientArguments("MIN", 1);
    115         }
    116 
    117         [TestMethod]
     150            TestWithInsufficientArguments("MIN", 1);
     151        }
     152
     153        [TestMethod]
     154        [TestProperty("Time", "Short")]
     155        [TestCategory("ExpressionTest")]
     156        [TestCategory("FloatExpressionTest")]
    118157        public void TestMax()
    119158        {
    … …  
    123162            Assert.AreEqual(10.3, interpreter.FloatStack.Top, delta);
    124163
    125             this.TestStackCounts(floatStack: 1);
    126         }
    127 
    128         [TestMethod]
     164            TestStackCounts(floatStack: 1);
     165        }
     166
     167        [TestMethod]
     168        [TestProperty("Time", "Short")]
     169        [TestCategory("ExpressionTest")]
     170        [TestCategory("FloatExpressionTest")]
    129171        public void TestMaxWithInsufficientArguments()
    130172        {
    131             this.TestWithInsufficientArguments("MAX", 1);
    132         }
    133 
    134         [TestMethod]
     173            TestWithInsufficientArguments("MAX", 1);
     174        }
     175
     176        [TestMethod]
     177        [TestProperty("Time", "Short")]
     178        [TestCategory("ExpressionTest")]
     179        [TestCategory("FloatExpressionTest")]
    135180        public void TestSmallerThan()
    136181        {
    … …  
    140185            Assert.AreEqual(false, interpreter.BooleanStack.Top);
    141186
    142             this.TestStackCounts(booleanStack: 1);
    143         }
    144 
    145         [TestMethod]
     187            TestStackCounts(booleanStack: 1);
     188        }
     189
     190        [TestMethod]
     191        [TestProperty("Time", "Short")]
     192        [TestCategory("ExpressionTest")]
     193        [TestCategory("FloatExpressionTest")]
    146194        public void TestSmallerThanWithInsufficientArguments()
    147195        {
    148             this.TestWithInsufficientArguments("<", 1);
    149         }
    150 
    151         [TestMethod]
     196            TestWithInsufficientArguments("<", 1);
     197        }
     198
     199        [TestMethod]
     200        [TestProperty("Time", "Short")]
     201        [TestCategory("ExpressionTest")]
     202        [TestCategory("FloatExpressionTest")]
    152203        public void TestGreaterThan()
    153204        {
    … …  
    157208            Assert.AreEqual(true, interpreter.BooleanStack.Top);
    158209
    159             this.TestStackCounts(booleanStack: 1);
    160         }
    161 
    162         [TestMethod]
     210            TestStackCounts(booleanStack: 1);
     211        }
     212
     213        [TestMethod]
     214        [TestProperty("Time", "Short")]
     215        [TestCategory("ExpressionTest")]
     216        [TestCategory("FloatExpressionTest")]
    163217        public void TestGreaterThanWithInsufficientArguments()
    164218        {
    165             this.TestWithInsufficientArguments(">", 1);
    166         }
    167 
    168         [TestMethod]
     219            TestWithInsufficientArguments(">", 1);
     220        }
     221
     222        [TestMethod]
     223        [TestProperty("Time", "Short")]
     224        [TestCategory("ExpressionTest")]
     225        [TestCategory("FloatExpressionTest")]
    169226        public void TestFromBooleanTrue()
    170227        {
    … …  
    174231            Assert.AreEqual(1d, interpreter.FloatStack.Top, delta);
    175232
    176             this.TestStackCounts(floatStack: 1);
    177         }
    178 
    179         [TestMethod]
     233            TestStackCounts(floatStack: 1);
     234        }
     235
     236        [TestMethod]
     237        [TestProperty("Time", "Short")]
     238        [TestCategory("ExpressionTest")]
     239        [TestCategory("FloatExpressionTest")]
    180240        public void TestFromBooleanFalse()
    181241        {
    … …  
    185245            Assert.AreEqual(0d, interpreter.FloatStack.Top, delta);
    186246
    187             this.TestStackCounts(floatStack: 1);
    188         }
    189 
    190         [TestMethod]
     247            TestStackCounts(floatStack: 1);
     248        }
     249
     250        [TestMethod]
     251        [TestProperty("Time", "Short")]
     252        [TestCategory("ExpressionTest")]
     253        [TestCategory("FloatExpressionTest")]
    191254        public void TestFromBooleanWithInsufficientArguments()
    192255        {
    193             this.TestWithInsufficientArguments("FROMBOOLEAN");
    194         }
    195 
    196         [TestMethod]
     256            TestWithInsufficientArguments("FROMBOOLEAN");
     257        }
     258
     259        [TestMethod]
     260        [TestProperty("Time", "Short")]
     261        [TestCategory("ExpressionTest")]
     262        [TestCategory("FloatExpressionTest")]
    197263        public void TestFromInteger()
    198264        {
    … …  
    202268            Assert.AreEqual(5d, interpreter.FloatStack.Top, delta);
    203269
    204             this.TestStackCounts(floatStack: 1);
    205         }
    206 
    207         [TestMethod]
     270            TestStackCounts(floatStack: 1);
     271        }
     272
     273        [TestMethod]
     274        [TestProperty("Time", "Short")]
     275        [TestCategory("ExpressionTest")]
     276        [TestCategory("FloatExpressionTest")]
    208277        public void TestFromIntegerWithInsufficientArguments()
    209278        {
    210             this.TestWithInsufficientArguments("FROMINTEGER");
    211         }
    212 
    213         [TestMethod]
     279            TestWithInsufficientArguments("FROMINTEGER");
     280        }
     281
     282        [TestMethod]
     283        [TestProperty("Time", "Short")]
     284        [TestCategory("ExpressionTest")]
     285        [TestCategory("FloatExpressionTest")]
    214286        public void TestSine()
    215287        {
    … …  
    219291            Assert.AreEqual(1, interpreter.FloatStack.Top, delta);
    220292
    221             this.TestStackCounts(floatStack: 1);
    222         }
    223 
    224         [TestMethod]
     293            TestStackCounts(floatStack: 1);
     294        }
     295
     296        [TestMethod]
     297        [TestProperty("Time", "Short")]
     298        [TestCategory("ExpressionTest")]
     299        [TestCategory("FloatExpressionTest")]
    225300        public void TestSineWithInsufficientArguments()
    226301        {
    227             this.TestWithInsufficientArguments("SIN");
    228         }
    229 
    230         [TestMethod]
     302            TestWithInsufficientArguments("SIN");
     303        }
     304
     305        [TestMethod]
     306        [TestProperty("Time", "Short")]
     307        [TestCategory("ExpressionTest")]
     308        [TestCategory("FloatExpressionTest")]
    231309        public void TestCosine()
    232310        {
    … …  
    236314            Assert.AreEqual(-1, interpreter.FloatStack.Top, delta);
    237315
    238             this.TestStackCounts(floatStack: 1);
    239         }
    240 
    241         [TestMethod]
     316            TestStackCounts(floatStack: 1);
     317        }
     318
     319        [TestMethod]
     320        [TestProperty("Time", "Short")]
     321        [TestCategory("ExpressionTest")]
     322        [TestCategory("FloatExpressionTest")]
    242323        public void TestCosineWithInsufficientArguments()
    243324        {
    244             this.TestWithInsufficientArguments("COS");
     325            TestWithInsufficientArguments("COS");
    245326        }
    246327
    … …  
    259340        protected override void CheckOtherStacksAreEmpty()
    260341        {
    261             this.TestStackCounts(floatStack: null);
     342            TestStackCounts(floatStack: null);
    262343        }
    263344    }

  • branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/IntegerExpressionTests.cs

    r14392 r14398  
    1212
    1313        [TestMethod]
     14        [TestProperty("Time", "Short")]
     15        [TestCategory("ExpressionTest")]
     16        [TestCategory("IntegerExpressionTest")]
    1417        public void TestAdd()
    1518        {
    … …  
    1922            Assert.AreEqual(10, interpreter.IntegerStack.Top);
    2023
    21             this.TestStackCounts(integerStack: 1);
    22         }
    23 
    24         [TestMethod]
     24            TestStackCounts(integerStack: 1);
     25        }
     26
     27        [TestMethod]
     28        [TestProperty("Time", "Short")]
     29        [TestCategory("ExpressionTest")]
     30        [TestCategory("IntegerExpressionTest")]
    2531        public void TestAddWithInsufficientArguments()
    2632        {
    27             this.TestWithInsufficientArguments("+", 1);
    28         }
    29 
    30         [TestMethod]
     33            TestWithInsufficientArguments("+", 1);
     34        }
     35
     36        [TestMethod]
     37        [TestProperty("Time", "Short")]
     38        [TestCategory("ExpressionTest")]
     39        [TestCategory("IntegerExpressionTest")]
    3140        public void TestSubtract()
    3241        {
    … …  
    3645            Assert.AreEqual(5, interpreter.IntegerStack.Top);
    3746
    38             this.TestStackCounts(integerStack: 1);
    39         }
    40 
    41         [TestMethod]
     47            TestStackCounts(integerStack: 1);
     48        }
     49
     50        [TestMethod]
     51        [TestProperty("Time", "Short")]
     52        [TestCategory("ExpressionTest")]
     53        [TestCategory("IntegerExpressionTest")]
    4254        public void TestSubtractWithInsufficientArguments()
    4355        {
    44             this.TestWithInsufficientArguments("-", 1);
    45         }
    46 
    47         [TestMethod]
     56            TestWithInsufficientArguments("-", 1);
     57        }
     58
     59        [TestMethod]
     60        [TestProperty("Time", "Short")]
     61        [TestCategory("ExpressionTest")]
     62        [TestCategory("IntegerExpressionTest")]
    4863        public void TestMultiply()
    4964        {
    … …  
    5368            Assert.AreEqual(50, interpreter.IntegerStack.Top);
    5469
    55             this.TestStackCounts(integerStack: 1);
    56         }
    57 
    58         [TestMethod]
     70            TestStackCounts(integerStack: 1);
     71        }
     72
     73        [TestMethod]
     74        [TestProperty("Time", "Short")]
     75        [TestCategory("ExpressionTest")]
     76        [TestCategory("IntegerExpressionTest")]
    5977        public void TestMultiplyWithInsufficientArguments()
    6078        {
    61             this.TestWithInsufficientArguments("*", 1);
    62         }
    63 
    64         [TestMethod]
     79            TestWithInsufficientArguments("*", 1);
     80        }
     81
     82        [TestMethod]
     83        [TestProperty("Time", "Short")]
     84        [TestCategory("ExpressionTest")]
     85        [TestCategory("IntegerExpressionTest")]
    6586        public void TestDivide()
    6687        {
    … …  
    7091            Assert.AreEqual(2, interpreter.IntegerStack.Top);
    7192
    72             this.TestStackCounts(integerStack: 1);
    73         }
    74 
    75         [TestMethod]
     93            TestStackCounts(integerStack: 1);
     94        }
     95
     96        [TestMethod]
     97        [TestProperty("Time", "Short")]
     98        [TestCategory("ExpressionTest")]
     99        [TestCategory("IntegerExpressionTest")]
    76100        public void TestDivideWithInsufficientArguments()
    77101        {
    78             this.TestWithInsufficientArguments("/", 1);
    79         }
    80 
    81         [TestMethod]
     102            TestWithInsufficientArguments("/", 1);
     103        }
     104
     105        [TestMethod]
     106        [TestProperty("Time", "Short")]
     107        [TestCategory("ExpressionTest")]
     108        [TestCategory("IntegerExpressionTest")]
    82109        public void TestModulo()
    83110        {
    … …  
    87114            Assert.AreEqual(0, interpreter.IntegerStack.Top);
    88115
    89             this.TestStackCounts(integerStack: 1);
    90         }
    91 
    92         [TestMethod]
     116            TestStackCounts(integerStack: 1);
     117        }
     118
     119        [TestMethod]
     120        [TestProperty("Time", "Short")]
     121        [TestCategory("ExpressionTest")]
     122        [TestCategory("IntegerExpressionTest")]
    93123        public void TestModuloWithInsufficientArguments()
    94124        {
    95             this.TestWithInsufficientArguments("%", 1);
    96         }
    97 
    98         [TestMethod]
     125            TestWithInsufficientArguments("%", 1);
     126        }
     127
     128        [TestMethod]
     129        [TestProperty("Time", "Short")]
     130        [TestCategory("ExpressionTest")]
     131        [TestCategory("IntegerExpressionTest")]
    99132        public void TestMin()
    100133        {
    … …  
    104137            Assert.AreEqual(5, interpreter.IntegerStack.Top);
    105138
    106             this.TestStackCounts(integerStack: 1);
    107         }
    108 
    109         [TestMethod]
     139            TestStackCounts(integerStack: 1);
     140        }
     141
     142        [TestMethod]
     143        [TestProperty("Time", "Short")]
     144        [TestCategory("ExpressionTest")]
     145        [TestCategory("IntegerExpressionTest")]
    110146        public void TestMinWithInsufficientArguments()
    111147        {
    112             this.TestWithInsufficientArguments("MIN", 1);
    113         }
    114 
    115         [TestMethod]
     148            TestWithInsufficientArguments("MIN", 1);
     149        }
     150
     151        [TestMethod]
     152        [TestProperty("Time", "Short")]
     153        [TestCategory("ExpressionTest")]
     154        [TestCategory("IntegerExpressionTest")]
    116155        public void TestMax()
    117156        {
    … …  
    121160            Assert.AreEqual(10, interpreter.IntegerStack.Top);
    122161
    123             this.TestStackCounts(integerStack: 1);
    124         }
    125 
    126         [TestMethod]
     162            TestStackCounts(integerStack: 1);
     163        }
     164
     165        [TestMethod]
     166        [TestProperty("Time", "Short")]
     167        [TestCategory("ExpressionTest")]
     168        [TestCategory("IntegerExpressionTest")]
    127169        public void TestMaxWithInsufficientArguments()
    128170        {
    129             this.TestWithInsufficientArguments("MAX", 1);
    130         }
    131 
    132         [TestMethod]
     171            TestWithInsufficientArguments("MAX", 1);
     172        }
     173
     174        [TestMethod]
     175        [TestProperty("Time", "Short")]
     176        [TestCategory("ExpressionTest")]
     177        [TestCategory("IntegerExpressionTest")]
    133178        public void TestSmallerThan()
    134179        {
    … …  
    138183            Assert.AreEqual(false, interpreter.BooleanStack.Top);
    139184
    140             this.TestStackCounts(booleanStack: 1);
    141         }
    142 
    143         [TestMethod]
     185            TestStackCounts(booleanStack: 1);
     186        }
     187
     188        [TestMethod]
     189        [TestProperty("Time", "Short")]
     190        [TestCategory("ExpressionTest")]
     191        [TestCategory("IntegerExpressionTest")]
    144192        public void TestSmallerThanWithInsufficientArguments()
    145193        {
    146             this.TestWithInsufficientArguments("<", 1);
    147         }
    148 
    149         [TestMethod]
     194            TestWithInsufficientArguments("<", 1);
     195        }
     196
     197        [TestMethod]
     198        [TestProperty("Time", "Short")]
     199        [TestCategory("ExpressionTest")]
     200        [TestCategory("IntegerExpressionTest")]
    150201        public void TestGreaterThan()
    151202        {
    … …  
    155206            Assert.AreEqual(true, interpreter.BooleanStack.Top);
    156207
    157             this.TestStackCounts(booleanStack: 1);
    158         }
    159 
    160         [TestMethod]
     208            TestStackCounts(booleanStack: 1);
     209        }
     210
     211        [TestMethod]
     212        [TestProperty("Time", "Short")]
     213        [TestCategory("ExpressionTest")]
     214        [TestCategory("IntegerExpressionTest")]
    161215        public void TestGreaterThanWithInsufficientArguments()
    162216        {
    163             this.TestWithInsufficientArguments(">", 1);
    164         }
    165 
    166         [TestMethod]
     217            TestWithInsufficientArguments(">", 1);
     218        }
     219
     220        [TestMethod]
     221        [TestProperty("Time", "Short")]
     222        [TestCategory("ExpressionTest")]
     223        [TestCategory("IntegerExpressionTest")]
    167224        public void TestFromBooleanTrue()
    168225        {
    … …  
    172229            Assert.AreEqual(1, interpreter.IntegerStack.Top);
    173230
    174             this.TestStackCounts(integerStack: 1);
    175         }
    176 
    177         [TestMethod]
     231            TestStackCounts(integerStack: 1);
     232        }
     233
     234        [TestMethod]
     235        [TestProperty("Time", "Short")]
     236        [TestCategory("ExpressionTest")]
     237        [TestCategory("IntegerExpressionTest")]
    178238        public void TestFromBooleanWithInsufficientArguments()
    179239        {
    180             this.TestWithInsufficientArguments("FROMBOOLEAN");
    181         }
    182 
    183         [TestMethod]
     240            TestWithInsufficientArguments("FROMBOOLEAN");
     241        }
     242
     243        [TestMethod]
     244        [TestProperty("Time", "Short")]
     245        [TestCategory("ExpressionTest")]
     246        [TestCategory("IntegerExpressionTest")]
    184247        public void TestFromBooleanFalse()
    185248        {
    … …  
    189252            Assert.AreEqual(0, interpreter.IntegerStack.Top);
    190253
    191             this.TestStackCounts(integerStack: 1);
    192         }
    193 
    194         [TestMethod]
     254            TestStackCounts(integerStack: 1);
     255        }
     256
     257        [TestMethod]
     258        [TestProperty("Time", "Short")]
     259        [TestCategory("ExpressionTest")]
     260        [TestCategory("IntegerExpressionTest")]
    195261        public void TestFromFloat()
    196262        {
    … …  
    200266            Assert.AreEqual(1, interpreter.IntegerStack.Top);
    201267
    202             this.TestStackCounts(integerStack: 1);
    203         }
    204 
    205         [TestMethod]
     268            TestStackCounts(integerStack: 1);
     269        }
     270
     271        [TestMethod]
     272        [TestProperty("Time", "Short")]
     273        [TestCategory("ExpressionTest")]
     274        [TestCategory("IntegerExpressionTest")]
    206275        public void TestFromFloatWithInsufficientArguments()
    207276        {
    208             this.TestWithInsufficientArguments("FROMFLOAT");
     277            TestWithInsufficientArguments("FROMFLOAT");
    209278        }
    210279
    … …  
    223292        protected override void CheckOtherStacksAreEmpty()
    224293        {
    225             this.TestStackCounts(integerStack: null);
     294            TestStackCounts(integerStack: null);
    226295        }
    227296    }

  • branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/NameExpressionTests.cs

    r14392 r14398  
    1414
    1515        [TestMethod]
     16        [TestProperty("Time", "Short")]
     17        [TestCategory("ExpressionTest")]
     18        [TestCategory("NameExpressionTest")]
    1619        public void TestRand()
    1720        {
    … …  
    2023            Assert.IsTrue(interpreter.NameStack.Count == 1);
    2124
    22             this.CheckOtherStacksAreEmpty();
     25            CheckOtherStacksAreEmpty();
    2326        }
    2427
    2528        [TestMethod]
     29        [TestProperty("Time", "Short")]
     30        [TestCategory("ExpressionTest")]
     31        [TestCategory("NameExpressionTest")]
    2632        public void TestRandomBound()
    2733        {
    … …  
    3440            Assert.IsTrue(interpreter.CustomExpressions.Keys.Contains(interpreter.NameStack.Top));
    3541
    36             this.CheckOtherStacksAreEmpty();
     42            CheckOtherStacksAreEmpty();
    3743        }
    3844
    3945        [TestMethod]
     46        [TestProperty("Time", "Short")]
     47        [TestCategory("ExpressionTest")]
     48        [TestCategory("NameExpressionTest")]
    4049        public void TestRandomBoundWithInsufficientArguments()
    4150        {
    42             this.TestWithInsufficientArguments("RANDBOUNDNAME");
     51            TestWithInsufficientArguments("RANDBOUNDNAME");
    4352        }
    4453
    4554        [TestMethod]
     55        [TestProperty("Time", "Short")]
     56        [TestCategory("ExpressionTest")]
     57        [TestCategory("NameExpressionTest")]
    4658        public void TestQuote()
    4759        {
    … …  
    5062            Assert.IsTrue(interpreter.IsNameQuoteFlagSet);
    5163
    52             this.TestStackCounts();
     64            TestStackCounts();
    5365        }
    5466
    … …  
    6880        protected override void CheckOtherStacksAreEmpty()
    6981        {
    70             this.TestStackCounts(nameStack: null);
     82            TestStackCounts(nameStack: null);
    7183        }
    7284    }

  • branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/InterpreterTest.cs

    r14392 r14398  
    44namespace HeuristicLab.Tests.Interpreter
    55{
    6     public class InterpreterTest
     6    public class ExpressionTest
    77    {
    88        protected PushGPInterpreter interpreter;
Note: See TracChangeset for help on using the changeset viewer.