Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
12/20/16 22:57:11 (7 years ago)
Author:
pkimmesw
Message:

#2665 Added Problem.ProgramSynthesis Project, Fixed Expression Issues, Fixed Code Generation

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r14398 r14513  
    1 using HeuristicLab.Algorithms.PushGP.Expressions;
    2 using HeuristicLab.Algorithms.PushGP.Stack;
    3 using Microsoft.VisualStudio.TestTools.UnitTesting;
    4 
    5 namespace HeuristicLab.Tests.Interpreter.Expressions
     1namespace HeuristicLab.Tests.Interpreter.Expressions
    62{
    7     [TestClass]
    8     public class IntegerExpressionTests : CommonTests<long>
    9     {
    10         protected override string TypeName { get { return "INTEGER"; } }
    11         protected override IStack<long> Stack { get { return interpreter.IntegerStack; } }
    12 
    13         [TestMethod]
    14         [TestProperty("Time", "Short")]
    15         [TestCategory("ExpressionTest")]
    16         [TestCategory("IntegerExpressionTest")]
    17         public void TestAdd()
    18         {
    19             interpreter.IntegerStack.Push(5, 5);
    20             interpreter.Interpret(new IntegerAddExpression());
    21 
    22             Assert.AreEqual(10, interpreter.IntegerStack.Top);
    23 
    24             TestStackCounts(integerStack: 1);
    25         }
    26 
    27         [TestMethod]
    28         [TestProperty("Time", "Short")]
    29         [TestCategory("ExpressionTest")]
    30         [TestCategory("IntegerExpressionTest")]
    31         public void TestAddWithInsufficientArguments()
    32         {
    33             TestWithInsufficientArguments("+", 1);
    34         }
    35 
    36         [TestMethod]
    37         [TestProperty("Time", "Short")]
    38         [TestCategory("ExpressionTest")]
    39         [TestCategory("IntegerExpressionTest")]
    40         public void TestSubtract()
    41         {
    42             interpreter.IntegerStack.Push(10, 5);
    43             interpreter.Interpret(new IntegerSubtractExpression());
    44 
    45             Assert.AreEqual(5, interpreter.IntegerStack.Top);
    46 
    47             TestStackCounts(integerStack: 1);
    48         }
    49 
    50         [TestMethod]
    51         [TestProperty("Time", "Short")]
    52         [TestCategory("ExpressionTest")]
    53         [TestCategory("IntegerExpressionTest")]
    54         public void TestSubtractWithInsufficientArguments()
    55         {
    56             TestWithInsufficientArguments("-", 1);
    57         }
    58 
    59         [TestMethod]
    60         [TestProperty("Time", "Short")]
    61         [TestCategory("ExpressionTest")]
    62         [TestCategory("IntegerExpressionTest")]
    63         public void TestMultiply()
    64         {
    65             interpreter.IntegerStack.Push(10, 5);
    66             interpreter.Interpret(new IntegerMultiplyExpression());
    67 
    68             Assert.AreEqual(50, interpreter.IntegerStack.Top);
    69 
    70             TestStackCounts(integerStack: 1);
    71         }
    72 
    73         [TestMethod]
    74         [TestProperty("Time", "Short")]
    75         [TestCategory("ExpressionTest")]
    76         [TestCategory("IntegerExpressionTest")]
    77         public void TestMultiplyWithInsufficientArguments()
    78         {
    79             TestWithInsufficientArguments("*", 1);
    80         }
    81 
    82         [TestMethod]
    83         [TestProperty("Time", "Short")]
    84         [TestCategory("ExpressionTest")]
    85         [TestCategory("IntegerExpressionTest")]
    86         public void TestDivide()
    87         {
    88             interpreter.IntegerStack.Push(10, 5);
    89             interpreter.Interpret(new IntegerDivideExpression());
    90 
    91             Assert.AreEqual(2, interpreter.IntegerStack.Top);
    92 
    93             TestStackCounts(integerStack: 1);
    94         }
    95 
    96         [TestMethod]
    97         [TestProperty("Time", "Short")]
    98         [TestCategory("ExpressionTest")]
    99         [TestCategory("IntegerExpressionTest")]
    100         public void TestDivideWithInsufficientArguments()
    101         {
    102             TestWithInsufficientArguments("/", 1);
    103         }
    104 
    105         [TestMethod]
    106         [TestProperty("Time", "Short")]
    107         [TestCategory("ExpressionTest")]
    108         [TestCategory("IntegerExpressionTest")]
    109         public void TestModulo()
    110         {
    111             interpreter.IntegerStack.Push(10, 5);
    112             interpreter.Interpret(new IntegerModuloExpression());
    113 
    114             Assert.AreEqual(0, interpreter.IntegerStack.Top);
    115 
    116             TestStackCounts(integerStack: 1);
    117         }
    118 
    119         [TestMethod]
    120         [TestProperty("Time", "Short")]
    121         [TestCategory("ExpressionTest")]
    122         [TestCategory("IntegerExpressionTest")]
    123         public void TestModuloWithInsufficientArguments()
    124         {
    125             TestWithInsufficientArguments("%", 1);
    126         }
    127 
    128         [TestMethod]
    129         [TestProperty("Time", "Short")]
    130         [TestCategory("ExpressionTest")]
    131         [TestCategory("IntegerExpressionTest")]
    132         public void TestMin()
    133         {
    134             interpreter.IntegerStack.Push(10, 5);
    135             interpreter.Interpret(new IntegerMinExpression());
    136 
    137             Assert.AreEqual(5, interpreter.IntegerStack.Top);
    138 
    139             TestStackCounts(integerStack: 1);
    140         }
    141 
    142         [TestMethod]
    143         [TestProperty("Time", "Short")]
    144         [TestCategory("ExpressionTest")]
    145         [TestCategory("IntegerExpressionTest")]
    146         public void TestMinWithInsufficientArguments()
    147         {
    148             TestWithInsufficientArguments("MIN", 1);
    149         }
    150 
    151         [TestMethod]
    152         [TestProperty("Time", "Short")]
    153         [TestCategory("ExpressionTest")]
    154         [TestCategory("IntegerExpressionTest")]
    155         public void TestMax()
    156         {
    157             interpreter.IntegerStack.Push(10, 5);
    158             interpreter.Interpret(new IntegerMaxExpression());
    159 
    160             Assert.AreEqual(10, interpreter.IntegerStack.Top);
    161 
    162             TestStackCounts(integerStack: 1);
    163         }
    164 
    165         [TestMethod]
    166         [TestProperty("Time", "Short")]
    167         [TestCategory("ExpressionTest")]
    168         [TestCategory("IntegerExpressionTest")]
    169         public void TestMaxWithInsufficientArguments()
    170         {
    171             TestWithInsufficientArguments("MAX", 1);
    172         }
    173 
    174         [TestMethod]
    175         [TestProperty("Time", "Short")]
    176         [TestCategory("ExpressionTest")]
    177         [TestCategory("IntegerExpressionTest")]
    178         public void TestSmallerThan()
    179         {
    180             interpreter.IntegerStack.Push(10, 5);
    181             interpreter.Interpret(new IntegerSmallerThanExpression());
    182 
    183             Assert.AreEqual(false, interpreter.BooleanStack.Top);
    184 
    185             TestStackCounts(booleanStack: 1);
    186         }
    187 
    188         [TestMethod]
    189         [TestProperty("Time", "Short")]
    190         [TestCategory("ExpressionTest")]
    191         [TestCategory("IntegerExpressionTest")]
    192         public void TestSmallerThanWithInsufficientArguments()
    193         {
    194             TestWithInsufficientArguments("<", 1);
    195         }
    196 
    197         [TestMethod]
    198         [TestProperty("Time", "Short")]
    199         [TestCategory("ExpressionTest")]
    200         [TestCategory("IntegerExpressionTest")]
    201         public void TestGreaterThan()
    202         {
    203             interpreter.IntegerStack.Push(10, 5);
    204             interpreter.Interpret(new IntegerGreaterThanExpression());
    205 
    206             Assert.AreEqual(true, interpreter.BooleanStack.Top);
    207 
    208             TestStackCounts(booleanStack: 1);
    209         }
    210 
    211         [TestMethod]
    212         [TestProperty("Time", "Short")]
    213         [TestCategory("ExpressionTest")]
    214         [TestCategory("IntegerExpressionTest")]
    215         public void TestGreaterThanWithInsufficientArguments()
    216         {
    217             TestWithInsufficientArguments(">", 1);
    218         }
    219 
    220         [TestMethod]
    221         [TestProperty("Time", "Short")]
    222         [TestCategory("ExpressionTest")]
    223         [TestCategory("IntegerExpressionTest")]
    224         public void TestFromBooleanTrue()
    225         {
    226             interpreter.BooleanStack.Push(true);
    227             interpreter.Interpret(new IntegerFromBooleanExpression());
    228 
    229             Assert.AreEqual(1, interpreter.IntegerStack.Top);
    230 
    231             TestStackCounts(integerStack: 1);
    232         }
    233 
    234         [TestMethod]
    235         [TestProperty("Time", "Short")]
    236         [TestCategory("ExpressionTest")]
    237         [TestCategory("IntegerExpressionTest")]
    238         public void TestFromBooleanWithInsufficientArguments()
    239         {
    240             TestWithInsufficientArguments("FROMBOOLEAN");
    241         }
    242 
    243         [TestMethod]
    244         [TestProperty("Time", "Short")]
    245         [TestCategory("ExpressionTest")]
    246         [TestCategory("IntegerExpressionTest")]
    247         public void TestFromBooleanFalse()
    248         {
    249             interpreter.BooleanStack.Push(false);
    250             interpreter.Interpret(new IntegerFromBooleanExpression());
    251 
    252             Assert.AreEqual(0, interpreter.IntegerStack.Top);
    253 
    254             TestStackCounts(integerStack: 1);
    255         }
    256 
    257         [TestMethod]
    258         [TestProperty("Time", "Short")]
    259         [TestCategory("ExpressionTest")]
    260         [TestCategory("IntegerExpressionTest")]
    261         public void TestFromFloat()
    262         {
    263             interpreter.FloatStack.Push(1.5);
    264             interpreter.Interpret(new IntegerFromFloatExpression());
    265 
    266             Assert.AreEqual(1, interpreter.IntegerStack.Top);
    267 
    268             TestStackCounts(integerStack: 1);
    269         }
    270 
    271         [TestMethod]
    272         [TestProperty("Time", "Short")]
    273         [TestCategory("ExpressionTest")]
    274         [TestCategory("IntegerExpressionTest")]
    275         public void TestFromFloatWithInsufficientArguments()
    276         {
    277             TestWithInsufficientArguments("FROMFLOAT");
    278         }
    279 
    280         protected override long[] GetValues(int count)
    281         {
    282             var values = new long[count];
    283 
    284             for (long i = 0; i < count; i++)
    285             {
    286                 values[i] = i;
    287             }
    288 
    289             return values;
    290         }
    291 
    292         protected override void CheckOtherStacksAreEmpty()
    293         {
    294             TestStackCounts(integerStack: null);
    295         }
    296     }
     3  using HeuristicLab.Algorithms.PushGP.Expressions;
     4  using HeuristicLab.Algorithms.PushGP.Stack;
     5
     6  using Microsoft.VisualStudio.TestTools.UnitTesting;
     7
     8  [TestClass]
     9  public class IntegerExpressionTests : CommonTests<long>
     10  {
     11    protected override string TypeName
     12    {
     13      get
     14      {
     15        return "INTEGER";
     16      }
     17    }
     18
     19    protected override IStack<long> Stack
     20    {
     21      get
     22      {
     23        return this.interpreter.IntegerStack;
     24      }
     25    }
     26
     27    [TestMethod]
     28    [TestProperty("Time", "Short")]
     29    [TestCategory("ExpressionTest")]
     30    [TestCategory("IntegerExpressionTest")]
     31    public void TestAdd()
     32    {
     33      this.interpreter.IntegerStack.Push(5, 5);
     34      this.interpreter.Interpret(new IntegerAddExpression());
     35
     36      Assert.AreEqual(10, this.interpreter.IntegerStack.Top);
     37
     38      this.TestStackCounts(integerStack: 1);
     39    }
     40
     41    [TestMethod]
     42    [TestProperty("Time", "Short")]
     43    [TestCategory("ExpressionTest")]
     44    [TestCategory("IntegerExpressionTest")]
     45    public void TestAddWithInsufficientArguments()
     46    {
     47      this.TestWithInsufficientArguments("+", 1);
     48    }
     49
     50    [TestMethod]
     51    [TestProperty("Time", "Short")]
     52    [TestCategory("ExpressionTest")]
     53    [TestCategory("IntegerExpressionTest")]
     54    public void TestSubtract()
     55    {
     56      this.interpreter.IntegerStack.Push(10, 5);
     57      this.interpreter.Interpret(new IntegerSubtractExpression());
     58
     59      Assert.AreEqual(5, this.interpreter.IntegerStack.Top);
     60
     61      this.TestStackCounts(integerStack: 1);
     62    }
     63
     64    [TestMethod]
     65    [TestProperty("Time", "Short")]
     66    [TestCategory("ExpressionTest")]
     67    [TestCategory("IntegerExpressionTest")]
     68    public void TestSubtractWithInsufficientArguments()
     69    {
     70      this.TestWithInsufficientArguments("-", 1);
     71    }
     72
     73    [TestMethod]
     74    [TestProperty("Time", "Short")]
     75    [TestCategory("ExpressionTest")]
     76    [TestCategory("IntegerExpressionTest")]
     77    public void TestMultiply()
     78    {
     79      this.interpreter.IntegerStack.Push(10, 5);
     80      this.interpreter.Interpret(new IntegerMultiplyExpression());
     81
     82      Assert.AreEqual(50, this.interpreter.IntegerStack.Top);
     83
     84      this.TestStackCounts(integerStack: 1);
     85    }
     86
     87    [TestMethod]
     88    [TestProperty("Time", "Short")]
     89    [TestCategory("ExpressionTest")]
     90    [TestCategory("IntegerExpressionTest")]
     91    public void TestMultiplyWithInsufficientArguments()
     92    {
     93      this.TestWithInsufficientArguments("*", 1);
     94    }
     95
     96    [TestMethod]
     97    [TestProperty("Time", "Short")]
     98    [TestCategory("ExpressionTest")]
     99    [TestCategory("IntegerExpressionTest")]
     100    public void TestDivide()
     101    {
     102      this.interpreter.IntegerStack.Push(10, 5);
     103      this.interpreter.Interpret(new IntegerDivideExpression());
     104
     105      Assert.AreEqual(2, this.interpreter.IntegerStack.Top);
     106
     107      this.TestStackCounts(integerStack: 1);
     108    }
     109
     110    [TestMethod]
     111    [TestProperty("Time", "Short")]
     112    [TestCategory("ExpressionTest")]
     113    [TestCategory("IntegerExpressionTest")]
     114    public void TestDivideWithInsufficientArguments()
     115    {
     116      this.TestWithInsufficientArguments("/", 1);
     117    }
     118
     119    [TestMethod]
     120    [TestProperty("Time", "Short")]
     121    [TestCategory("ExpressionTest")]
     122    [TestCategory("IntegerExpressionTest")]
     123    public void TestModulo()
     124    {
     125      this.interpreter.IntegerStack.Push(10, 5);
     126      this.interpreter.Interpret(new IntegerModuloExpression());
     127
     128      Assert.AreEqual(0, this.interpreter.IntegerStack.Top);
     129
     130      this.TestStackCounts(integerStack: 1);
     131    }
     132
     133    [TestMethod]
     134    [TestProperty("Time", "Short")]
     135    [TestCategory("ExpressionTest")]
     136    [TestCategory("IntegerExpressionTest")]
     137    public void TestModuloWithInsufficientArguments()
     138    {
     139      this.TestWithInsufficientArguments("%", 1);
     140    }
     141
     142    [TestMethod]
     143    [TestProperty("Time", "Short")]
     144    [TestCategory("ExpressionTest")]
     145    [TestCategory("IntegerExpressionTest")]
     146    public void TestMin()
     147    {
     148      this.interpreter.IntegerStack.Push(10, 5);
     149      this.interpreter.Interpret(new IntegerMinExpression());
     150
     151      Assert.AreEqual(5, this.interpreter.IntegerStack.Top);
     152
     153      this.TestStackCounts(integerStack: 1);
     154    }
     155
     156    [TestMethod]
     157    [TestProperty("Time", "Short")]
     158    [TestCategory("ExpressionTest")]
     159    [TestCategory("IntegerExpressionTest")]
     160    public void TestMinWithInsufficientArguments()
     161    {
     162      this.TestWithInsufficientArguments("MIN", 1);
     163    }
     164
     165    [TestMethod]
     166    [TestProperty("Time", "Short")]
     167    [TestCategory("ExpressionTest")]
     168    [TestCategory("IntegerExpressionTest")]
     169    public void TestMax()
     170    {
     171      this.interpreter.IntegerStack.Push(10, 5);
     172      this.interpreter.Interpret(new IntegerMaxExpression());
     173
     174      Assert.AreEqual(10, this.interpreter.IntegerStack.Top);
     175
     176      this.TestStackCounts(integerStack: 1);
     177    }
     178
     179    [TestMethod]
     180    [TestProperty("Time", "Short")]
     181    [TestCategory("ExpressionTest")]
     182    [TestCategory("IntegerExpressionTest")]
     183    public void TestMaxWithInsufficientArguments()
     184    {
     185      this.TestWithInsufficientArguments("MAX", 1);
     186    }
     187
     188    [TestMethod]
     189    [TestProperty("Time", "Short")]
     190    [TestCategory("ExpressionTest")]
     191    [TestCategory("IntegerExpressionTest")]
     192    public void TestSmallerThan()
     193    {
     194      this.interpreter.IntegerStack.Push(10, 5);
     195      this.interpreter.Interpret(new IntegerSmallerThanExpression());
     196
     197      Assert.AreEqual(false, this.interpreter.BooleanStack.Top);
     198
     199      this.TestStackCounts(booleanStack: 1);
     200    }
     201
     202    [TestMethod]
     203    [TestProperty("Time", "Short")]
     204    [TestCategory("ExpressionTest")]
     205    [TestCategory("IntegerExpressionTest")]
     206    public void TestSmallerThanWithInsufficientArguments()
     207    {
     208      this.TestWithInsufficientArguments("<", 1);
     209    }
     210
     211    [TestMethod]
     212    [TestProperty("Time", "Short")]
     213    [TestCategory("ExpressionTest")]
     214    [TestCategory("IntegerExpressionTest")]
     215    public void TestGreaterThan()
     216    {
     217      this.interpreter.IntegerStack.Push(10, 5);
     218      this.interpreter.Interpret(new IntegerGreaterThanExpression());
     219
     220      Assert.AreEqual(true, this.interpreter.BooleanStack.Top);
     221
     222      this.TestStackCounts(booleanStack: 1);
     223    }
     224
     225    [TestMethod]
     226    [TestProperty("Time", "Short")]
     227    [TestCategory("ExpressionTest")]
     228    [TestCategory("IntegerExpressionTest")]
     229    public void TestGreaterThanWithInsufficientArguments()
     230    {
     231      this.TestWithInsufficientArguments(">", 1);
     232    }
     233
     234    [TestMethod]
     235    [TestProperty("Time", "Short")]
     236    [TestCategory("ExpressionTest")]
     237    [TestCategory("IntegerExpressionTest")]
     238    public void TestFromBooleanTrue()
     239    {
     240      this.interpreter.BooleanStack.Push(true);
     241      this.interpreter.Interpret(new IntegerFromBooleanExpression());
     242
     243      Assert.AreEqual(1, this.interpreter.IntegerStack.Top);
     244
     245      this.TestStackCounts(integerStack: 1);
     246    }
     247
     248    [TestMethod]
     249    [TestProperty("Time", "Short")]
     250    [TestCategory("ExpressionTest")]
     251    [TestCategory("IntegerExpressionTest")]
     252    public void TestFromBooleanWithInsufficientArguments()
     253    {
     254      this.TestWithInsufficientArguments("FROMBOOLEAN");
     255    }
     256
     257    [TestMethod]
     258    [TestProperty("Time", "Short")]
     259    [TestCategory("ExpressionTest")]
     260    [TestCategory("IntegerExpressionTest")]
     261    public void TestFromBooleanFalse()
     262    {
     263      this.interpreter.BooleanStack.Push(false);
     264      this.interpreter.Interpret(new IntegerFromBooleanExpression());
     265
     266      Assert.AreEqual(0, this.interpreter.IntegerStack.Top);
     267
     268      this.TestStackCounts(integerStack: 1);
     269    }
     270
     271    [TestMethod]
     272    [TestProperty("Time", "Short")]
     273    [TestCategory("ExpressionTest")]
     274    [TestCategory("IntegerExpressionTest")]
     275    public void TestFromFloat()
     276    {
     277      this.interpreter.FloatStack.Push(1.5);
     278      this.interpreter.Interpret(new IntegerFromFloatExpression());
     279
     280      Assert.AreEqual(1, this.interpreter.IntegerStack.Top);
     281
     282      this.TestStackCounts(integerStack: 1);
     283    }
     284
     285    [TestMethod]
     286    [TestProperty("Time", "Short")]
     287    [TestCategory("ExpressionTest")]
     288    [TestCategory("IntegerExpressionTest")]
     289    public void TestFromFloatWithInsufficientArguments()
     290    {
     291      this.TestWithInsufficientArguments("FROMFLOAT");
     292    }
     293
     294    protected override long[] GetValues(int count)
     295    {
     296      var values = new long[count];
     297
     298      for (long i = 0; i < count; i++) values[i] = i;
     299
     300      return values;
     301    }
     302
     303    protected override void CheckOtherStacksAreEmpty()
     304    {
     305      this.TestStackCounts(integerStack: null);
     306    }
     307  }
    297308}
Note: See TracChangeset for help on using the changeset viewer.