BinaryOperatorEntryTest


1   package org.hanseltest.stack;
2   
3   
4   import junit.framework.Test;
5   import junit.framework.TestCase;
6   
7   import org.hansel.CoverageDecorator;
8   import org.hansel.stack.BinaryOperatorEntry;
9   import org.hansel.stack.HanselValue;
10  import org.hansel.stack.OperatorEntry;
11  
12  /**
13   * Test the BinaryOperatorEntry and class.
14   * @author Niklas Mehner
15   */
16  public class BinaryOperatorEntryTest extends TestCase {
17  
18      /**
19       * Create a new Test.
20       * @param name Name of the test.
21       */
22      public BinaryOperatorEntryTest(String   name) {
23          super(name);
24      }
25      
26      /**
27       * Returns a new BinaryOperatorEntry.
28       * @param operator String representing the operator.
29       * @param precedence Precedence of the operator.
30       * @param type Type of the result.
31       * @param arg1 Name of the first argument.
32       * @param arg2 Name of the second argument.
33       * @return new BinaryOperatorEntry.
34       */
35      private HanselValue getOperatorEntry(String   operator,
36                                           int precedence,
37                                           String   arg1,
38                                           String   arg2) {
39          HanselValue se1 = new HanselValue(arg1, false, 1);
40          HanselValue se2 = new HanselValue(arg2, false, 1);
41  
42          return new BinaryOperatorEntry(operator, precedence, se1, se2);
43      }
44  
45      /**
46       * Test simple addition.
47       */
48      public void testSimple() {
49          assertEquals("arg1 + arg2", 
50                       getOperatorEntry("+", 3,
51                                        "arg1", "arg2").toString());
52      }
53  
54      /** Test the getOperator*() methods. */
55      public void testGetOperator() {
56          HanselValue se1 = new HanselValue("arg1", false, 1);
57          HanselValue se2 = new HanselValue("arg2", false, 1);
58          BinaryOperatorEntry boe = new BinaryOperatorEntry("+", 3, se1, se2);
59  
60          assertSame(se1, boe.getOperator1());
61          assertSame(se2, boe.getOperator2());
62      }
63  
64      /** Test compress. */
65      public void testCompress() {
66          HanselValue se1 = new HanselValue("arg1", false, 1);
67          HanselValue se2 = new HanselValue("arg2", false, 1);
68          BinaryOperatorEntry boe = new BinaryOperatorEntry("+", 3, se1, se2);
69          
70          assertSame(boe, boe.compress());
71      }
72  
73      /**
74       * Test precedence.
75       */
76      public void testPrecedence1() {
77          HanselValue entry1 = new HanselValue("arg1", false, 1);
78          HanselValue entry2 = getOperatorEntry("*", 2,
79                                               "arg2", "arg3");
80          assertEquals("arg1 + arg2 * arg3", 
81                       new BinaryOperatorEntry("+", 3, 
82                                               entry1, entry2).toString());
83      }
84  
85      /**
86       * Test precedence.
87       */
88      public void testPrecedence2() {
89          HanselValue entry1 = new HanselValue("arg1", false, 1);
90          HanselValue entry2 = getOperatorEntry("+", 3, 
91                                               "arg2", "arg3");
92          assertEquals("arg1 * (arg2 + arg3)", 
93                       new BinaryOperatorEntry("*", 2, 
94                                               entry1, entry2).toString());
95      }
96  
97      /**
98       * Test precedence.
99       */
100     public void testPrecedence3() {
101         HanselValue entry1 = new HanselValue("arg1", false, 1);
102         HanselValue entry2 = getOperatorEntry("+", 3, 
103         "arg2", "arg3");
104         assertEquals("arg1 + arg2 + arg3", 
105                      new BinaryOperatorEntry("+", 3, 
106                                              entry1, entry2).toString());
107     }
108 
109     /**
110      * Test precedence.
111      */
112     public void testPrecedence4() {
113         HanselValue entry1 = getOperatorEntry("+", 3, 
114                                              "arg1", "arg2");
115         HanselValue entry2 = getOperatorEntry("+", 3, 
116                                              "arg3", "arg4");
117         assertEquals("(arg1 + arg2) * (arg3 + arg4)", 
118                      new BinaryOperatorEntry("*", 2, 
119                                              entry1, entry2).toString());
120     }
121 
122     /**
123      * Returns a coverage decorator for this test.
124      * @return CoverageTest.
125      */
126     public static Test suite() {
127         return new CoverageDecorator(BinaryOperatorEntryTest.class,
128                                      new Class  [] {OperatorEntry.class,
129                                                   BinaryOperatorEntry.class});
130     }
131 }
132
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags