Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
05/02/17 22:03:01 (7 years ago)
Author:
pkimmesw
Message:

#2665 Removed "this" qualifier

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r14875 r14908  
    1515
    1616    protected virtual T[] Get2Different() {
    17       return this.GetValues(2);
     17      return GetValues(2);
    1818    }
    1919
    2020    protected virtual void Test(Expression expression) {
    21       this.interpreter.Run(expression);
     21      interpreter.Run(expression);
    2222    }
    2323
    … …  
    2929    [TestCategory("CommonExpressionTest")]
    3030    public virtual void TestEqualsTrue() {
    31       var values = this.GetValues(1);
     31      var values = GetValues(1);
    3232      var merged = new[] { values[0], values[0] };
    3333
    34       this.Stack.Push(merged);
    35 
    36       var isBooleanStack = this.interpreter.BooleanStack.Count == 2;
    37 
    38       this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".="));
    39 
    40       if (isBooleanStack) Assert.AreEqual(1, this.Stack.Count);
    41       else Assert.AreEqual(0, this.Stack.Count);
    42 
    43       Assert.IsTrue(this.interpreter.BooleanStack.Top);
     34      Stack.Push(merged);
     35
     36      var isBooleanStack = interpreter.BooleanStack.Count == 2;
     37
     38      Test(ExpressionTable.GetStatelessExpression(TypeName + ".="));
     39
     40      if (isBooleanStack) Assert.AreEqual(1, Stack.Count);
     41      else Assert.AreEqual(0, Stack.Count);
     42
     43      Assert.IsTrue(interpreter.BooleanStack.Top);
    4444    }
    4545
    … …  
    4949    [TestCategory("CommonExpressionTest")]
    5050    public virtual void TestEqualsFalse() {
    51       var values = this.Get2Different();
    52       this.Stack.Push(values);
    53       var isBooleanStack = this.interpreter.BooleanStack.Count == 2;
    54 
    55       this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".="));
    56 
    57       if (isBooleanStack) Assert.AreEqual(1, this.Stack.Count);
    58       else Assert.AreEqual(0, this.Stack.Count);
    59 
    60       Assert.IsFalse(this.interpreter.BooleanStack.Top);
     51      var values = Get2Different();
     52      Stack.Push(values);
     53      var isBooleanStack = interpreter.BooleanStack.Count == 2;
     54
     55      Test(ExpressionTable.GetStatelessExpression(TypeName + ".="));
     56
     57      if (isBooleanStack) Assert.AreEqual(1, Stack.Count);
     58      else Assert.AreEqual(0, Stack.Count);
     59
     60      Assert.IsFalse(interpreter.BooleanStack.Top);
    6161    }
    6262
    … …  
    6666    [TestCategory("CommonExpressionTest")]
    6767    public virtual void TestEqualsWithInsufficientArguments() {
    68       this.TestWithInsufficientArguments("=", 1);
     68      TestWithInsufficientArguments("=", 1);
    6969    }
    7070
    … …  
    7474    [TestCategory("CommonExpressionTest")]
    7575    public virtual void TestDuplicate() {
    76       var values = this.GetValues(1);
    77       this.Stack.Push(values);
    78 
    79       this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".DUP"));
    80 
    81       Assert.AreEqual(this.Stack.Count, 2);
    82       Assert.AreEqual(this.Stack[0], values[0]);
    83       Assert.AreEqual(this.Stack[1], values[0]);
    84       this.CheckOtherStacksAreEmpty();
     76      var values = GetValues(1);
     77      Stack.Push(values);
     78
     79      Test(ExpressionTable.GetStatelessExpression(TypeName + ".DUP"));
     80
     81      Assert.AreEqual(Stack.Count, 2);
     82      Assert.AreEqual(Stack[0], values[0]);
     83      Assert.AreEqual(Stack[1], values[0]);
     84      CheckOtherStacksAreEmpty();
    8585    }
    8686
    … …  
    9090    [TestCategory("CommonExpressionTest")]
    9191    public virtual void TestPop() {
    92       var values = this.GetValues(2);
    93       this.Stack.Push(values);
    94 
    95       this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".POP"));
    96 
    97       this.CheckOtherStacksAreEmpty();
     92      var values = GetValues(2);
     93      Stack.Push(values);
     94
     95      Test(ExpressionTable.GetStatelessExpression(TypeName + ".POP"));
     96
     97      CheckOtherStacksAreEmpty();
    9898    }
    9999
    … …  
    103103    [TestCategory("CommonExpressionTest")]
    104104    public virtual void TestSwap() {
    105       var values = this.GetValues(3);
    106       this.Stack.Push(values);
    107 
    108       this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".SWAP"));
    109 
    110       Assert.AreEqual(values[0], this.Stack[2]);
    111       Assert.AreEqual(values[1], this.Stack[0]);
    112       Assert.AreEqual(values[2], this.Stack[1]);
    113 
    114       this.CheckOtherStacksAreEmpty();
     105      var values = GetValues(3);
     106      Stack.Push(values);
     107
     108      Test(ExpressionTable.GetStatelessExpression(TypeName + ".SWAP"));
     109
     110      Assert.AreEqual(values[0], Stack[2]);
     111      Assert.AreEqual(values[1], Stack[0]);
     112      Assert.AreEqual(values[2], Stack[1]);
     113
     114      CheckOtherStacksAreEmpty();
    115115    }
    116116
    … …  
    120120    [TestCategory("CommonExpressionTest")]
    121121    public virtual void TestSwapWithInsufficientArguments() {
    122       this.TestWithInsufficientArguments("SWAP", 1);
     122      TestWithInsufficientArguments("SWAP", 1);
    123123    }
    124124
    … …  
    138138      Assert.AreEqual(values[2], Stack[0]);
    139139
    140       this.CheckOtherStacksAreEmpty();
     140      CheckOtherStacksAreEmpty();
    141141    }
    142142
    … …  
    146146    [TestCategory("CommonExpressionTest")]
    147147    public virtual void TestRotateWithInsufficientArguments() {
    148       this.TestWithInsufficientArguments("ROT", 2);
     148      TestWithInsufficientArguments("ROT", 2);
    149149    }
    150150
    … …  
    154154    [TestCategory("CommonExpressionTest")]
    155155    public virtual void TestShove() {
    156       var values = this.GetValues(3);
    157       this.Stack.Push(values);
    158 
    159       this.interpreter.IntegerStack.Push(1);
    160       this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".SHOVE"));
    161 
    162       Assert.AreEqual(values[0], Stack[2]);
    163       Assert.AreEqual(values[1], Stack[0]);
    164       Assert.AreEqual(values[2], Stack[1]);
    165 
    166       this.CheckOtherStacksAreEmpty();
     156      var values = GetValues(3);
     157      Stack.Push(values);
     158
     159      interpreter.IntegerStack.Push(1);
     160      Test(ExpressionTable.GetStatelessExpression(TypeName + ".SHOVE"));
     161
     162      Assert.AreEqual(values[0], Stack[2]);
     163      Assert.AreEqual(values[1], Stack[0]);
     164      Assert.AreEqual(values[2], Stack[1]);
     165
     166      CheckOtherStacksAreEmpty();
    167167    }
    168168
    … …  
    172172    [TestCategory("CommonExpressionTest")]
    173173    public virtual void TestShoveWithInsufficientArguments() {
    174       this.TestWithInsufficientArguments("SHOVE", 1);
     174      TestWithInsufficientArguments("SHOVE", 1);
    175175    }
    176176
    … …  
    180180    [TestCategory("CommonExpressionTest")]
    181181    public virtual void TestShoveWithNegativeIndex() {
    182       var values = this.GetValues(3);
    183       this.Stack.Push(values);
    184 
    185       this.interpreter.IntegerStack.Push(-1);
    186       this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".SHOVE"));
    187 
    188       Assert.AreEqual(values[0], Stack[2]);
    189       Assert.AreEqual(values[1], Stack[0]);
    190       Assert.AreEqual(values[2], Stack[1]);
    191 
    192       this.CheckOtherStacksAreEmpty();
     182      var values = GetValues(3);
     183      Stack.Push(values);
     184
     185      interpreter.IntegerStack.Push(-1);
     186      Test(ExpressionTable.GetStatelessExpression(TypeName + ".SHOVE"));
     187
     188      Assert.AreEqual(values[0], Stack[2]);
     189      Assert.AreEqual(values[1], Stack[0]);
     190      Assert.AreEqual(values[2], Stack[1]);
     191
     192      CheckOtherStacksAreEmpty();
    193193    }
    194194
    … …  
    198198    [TestCategory("CommonExpressionTest")]
    199199    public virtual void TestYank() {
    200       var values = this.GetValues(3);
    201       this.Stack.Push(values);
    202 
    203       this.interpreter.IntegerStack.Push(1);
    204       this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".YANK"));
    205 
    206       Assert.AreEqual(values[0], Stack[2]);
    207       Assert.AreEqual(values[1], Stack[0]);
    208       Assert.AreEqual(values[2], Stack[1]);
    209 
    210       this.CheckOtherStacksAreEmpty();
     200      var values = GetValues(3);
     201      Stack.Push(values);
     202
     203      interpreter.IntegerStack.Push(1);
     204      Test(ExpressionTable.GetStatelessExpression(TypeName + ".YANK"));
     205
     206      Assert.AreEqual(values[0], Stack[2]);
     207      Assert.AreEqual(values[1], Stack[0]);
     208      Assert.AreEqual(values[2], Stack[1]);
     209
     210      CheckOtherStacksAreEmpty();
    211211    }
    212212
    … …  
    216216    [TestCategory("CommonExpressionTest")]
    217217    public virtual void TestYankWithInsufficientArguments() {
    218       this.TestWithInsufficientArguments("YANK", 1);
     218      TestWithInsufficientArguments("YANK", 1);
    219219    }
    220220
    … …  
    224224    [TestCategory("CommonExpressionTest")]
    225225    public virtual void TestYankWithNegativeIndex() {
    226       var values = this.GetValues(3);
    227       this.Stack.Push(values);
    228 
    229       this.interpreter.IntegerStack.Push(-1);
    230       this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".YANK"));
    231 
    232       Assert.AreEqual(values[0], Stack[2]);
    233       Assert.AreEqual(values[1], Stack[0]);
    234       Assert.AreEqual(values[2], Stack[1]);
    235 
    236       this.CheckOtherStacksAreEmpty();
     226      var values = GetValues(3);
     227      Stack.Push(values);
     228
     229      interpreter.IntegerStack.Push(-1);
     230      Test(ExpressionTable.GetStatelessExpression(TypeName + ".YANK"));
     231
     232      Assert.AreEqual(values[0], Stack[2]);
     233      Assert.AreEqual(values[1], Stack[0]);
     234      Assert.AreEqual(values[2], Stack[1]);
     235
     236      CheckOtherStacksAreEmpty();
    237237    }
    238238
    … …  
    242242    [TestCategory("CommonExpressionTest")]
    243243    public virtual void TestYankDuplicate() {
    244       var values = this.GetValues(3);
    245       this.Stack.Push(values);
    246 
    247       this.interpreter.IntegerStack.Push(1);
    248       this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".YANKDUP"));
    249 
    250       Assert.AreEqual(values[0], this.Stack[3]);
    251       Assert.AreEqual(values[1], this.Stack[2]);
    252       Assert.AreEqual(values[2], this.Stack[1]);
    253       Assert.AreEqual(values[1], this.Stack[0]);
    254 
    255       this.CheckOtherStacksAreEmpty();
     244      var values = GetValues(3);
     245      Stack.Push(values);
     246
     247      interpreter.IntegerStack.Push(1);
     248      Test(ExpressionTable.GetStatelessExpression(TypeName + ".YANKDUP"));
     249
     250      Assert.AreEqual(values[0], Stack[3]);
     251      Assert.AreEqual(values[1], Stack[2]);
     252      Assert.AreEqual(values[2], Stack[1]);
     253      Assert.AreEqual(values[1], Stack[0]);
     254
     255      CheckOtherStacksAreEmpty();
    256256    }
    257257
    … …  
    261261    [TestCategory("CommonExpressionTest")]
    262262    public virtual void TestYankDuplicateWithInsufficientArguments() {
    263       this.TestWithInsufficientArguments("YANKDUP", 1);
     263      TestWithInsufficientArguments("YANKDUP", 1);
    264264    }
    265265
    … …  
    269269    [TestCategory("CommonExpressionTest")]
    270270    public virtual void TestYankDuplicateWithNegativeIndex() {
    271       var values = this.GetValues(3);
    272       this.Stack.Push(values);
    273 
    274       this.interpreter.IntegerStack.Push(-1);
    275       this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".YANKDUP"));
    276 
    277       Assert.AreEqual(values[0], this.Stack[3]);
    278       Assert.AreEqual(values[1], this.Stack[2]);
    279       Assert.AreEqual(values[2], this.Stack[1]);
    280       Assert.AreEqual(values[1], this.Stack[0]);
    281 
    282       this.CheckOtherStacksAreEmpty();
     271      var values = GetValues(3);
     272      Stack.Push(values);
     273
     274      interpreter.IntegerStack.Push(-1);
     275      Test(ExpressionTable.GetStatelessExpression(TypeName + ".YANKDUP"));
     276
     277      Assert.AreEqual(values[0], Stack[3]);
     278      Assert.AreEqual(values[1], Stack[2]);
     279      Assert.AreEqual(values[2], Stack[1]);
     280      Assert.AreEqual(values[1], Stack[0]);
     281
     282      CheckOtherStacksAreEmpty();
    283283    }
    284284
    … …  
    288288    [TestCategory("CommonExpressionTest")]
    289289    public virtual void TestStackdpeth() {
    290       var values = this.GetValues(3);
    291       this.Stack.Push(values);
    292 
    293       this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".STACKDEPTH"));
     290      var values = GetValues(3);
     291      Stack.Push(values);
     292
     293      Test(ExpressionTable.GetStatelessExpression(TypeName + ".STACKDEPTH"));
    294294
    295295      // if stack is integer stack
    296       if (this.Stack.Count != values.Length) {
    297         Assert.AreEqual(4, this.Stack.Count);
    298         this.CheckOtherStacksAreEmpty();
     296      if (Stack.Count != values.Length) {
     297        Assert.AreEqual(4, Stack.Count);
     298        CheckOtherStacksAreEmpty();
    299299      } else {
    300         Assert.AreEqual(3, this.Stack.Count);
    301         Assert.AreEqual(values.Length, this.interpreter.IntegerStack.Top);
     300        Assert.AreEqual(3, Stack.Count);
     301        Assert.AreEqual(values.Length, interpreter.IntegerStack.Top);
    302302      }
    303303    }
    … …  
    305305    protected void TestWithInsufficientArguments(string instructionName, int argCount = 0) {
    306306      for (var i = 0; i < argCount + 1; i++) {
    307         var values = this.GetValues(i);
    308         this.Stack.Push(values);
    309 
    310         var fullInstructionName = string.Format(FullInstructionNameFormat, this.TypeName, instructionName);
    311         this.Test(ExpressionTable.GetStatelessExpression(fullInstructionName));
    312 
    313         for (var j = 0; j < i; j++) Assert.AreEqual(values[j], this.Stack.ReverseElementAt(j));
    314 
    315         this.CheckOtherStacksAreEmpty();
    316         this.interpreter.Clear();
     307        var values = GetValues(i);
     308        Stack.Push(values);
     309
     310        var fullInstructionName = string.Format(FullInstructionNameFormat, TypeName, instructionName);
     311        Test(ExpressionTable.GetStatelessExpression(fullInstructionName));
     312
     313        for (var j = 0; j < i; j++) Assert.AreEqual(values[j], Stack.ReverseElementAt(j));
     314
     315        CheckOtherStacksAreEmpty();
     316        interpreter.Clear();
    317317      }
    318318    }
    319319
    320320    protected void TestWithNegativeIndex(string instructionName) {
    321       var values = this.GetValues(3);
    322       this.Stack.Push(values);
    323 
    324       this.interpreter.IntegerStack.Push(-1);
    325 
    326       var fullInstructionname = string.Format(FullInstructionNameFormat, this.TypeName, instructionName);
    327       this.Test(ExpressionTable.GetStatelessExpression(fullInstructionname));
     321      var values = GetValues(3);
     322      Stack.Push(values);
     323
     324      interpreter.IntegerStack.Push(-1);
     325
     326      var fullInstructionname = string.Format(FullInstructionNameFormat, TypeName, instructionName);
     327      Test(ExpressionTable.GetStatelessExpression(fullInstructionname));
    328328
    329329      Assert.AreEqual(values[0], Stack[2]);
Note: See TracChangeset for help on using the changeset viewer.