Changeset 2576


Ignore:
Timestamp:
Oct 28, 2012, 1:55:04 PM (6 years ago)
Author:
ksherdy
Message:

Updated test harness code.

Location:
proto/pablo/src/compiler/test
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • proto/pablo/src/compiler/test/ASTComparator.java

    r2459 r2576  
    4141        static public void compare(ASTNode ASTTree1, ASTNode ASTTree2) {
    4242                ASTComparator comparator = new ASTComparator();
    43                 comparator.compareSubtree(ASTTree1, ASTTree2);
     43                boolean result = comparator.compareSubtree(ASTTree1, ASTTree2);
     44               
     45                if (!result) {
     46                        printFailure(ASTTree1, ASTTree2);
     47                }
    4448        }
     49
     50        static private void printFailure(ASTNode node1, ASTNode node2) {
     51               
     52                System.err.println("AST Expected: ");
     53                if (node1 != null) {
     54                        System.err.println(node1.toString());
     55                } else {
     56                        System.err.println("null");
     57                }
     58               
     59               
     60                System.err.println("AST Actual: ");
     61                if (node2 != null) {
     62                        System.err.println(node2.toString());
     63                } else {
     64                        System.err.println("null");
     65                }
     66        }       
    4567       
    46         private void compareSubtree(ASTNode node1, ASTNode node2) { // DFS compare
    47                 compareNodes(node1, node2);
     68        private boolean compareSubtree(ASTNode node1, ASTNode node2) { // DFS compare
     69               
     70                boolean result = true;
     71               
     72                result &= compareNodes(node1, node2);
    4873               
    4974                List<ASTNode> children1 = node1.getChildren();
     
    5681                        ASTNode child1 = children1.get(i);
    5782                        ASTNode child2 = children2.get(i);
    58                         compareSubtree(child1, child2);
     83                        result &= compareSubtree(child1, child2);
    5984                }
    6085               
    6186                if(children1.size() > children2.size() ) {
    62                         compareNodes(children1.get(i), null);
     87                        result &= compareNodes(children1.get(i), null);
    6388                }
    6489               
    6590                if(children1.size() < children2.size() ){
    66                         compareNodes(null, children2.get(i));
     91                        result &= compareNodes(null, children2.get(i));
    6792                }
     93                               
     94                return result;
    6895        }
    6996       
    70         private void compareNodes(ASTNode node1, ASTNode node2) {
    71                 compareNodeClass(node1, node2);
    72                 compareToken(node1, node2);
    73                 compareAttributes(node1, node2);
     97        private boolean compareNodes(ASTNode node1, ASTNode node2) {
     98                boolean result = true;
     99               
     100                result &= compareNodeClass(node1, node2);
     101                result &= compareToken(node1, node2);
     102                result &= compareAttributes(node1, node2);
     103               
     104                return result;
    74105        }
    75106       
    76         private void compareNodeClass(ASTNode node1, ASTNode node2) {
    77                 if(comparisonLevel.compareNodeClass()) {
    78                         String nodeClassSimpleName1 = null;
    79                         String nodeClassSimpleName2 = null;
    80                        
    81                         if(node1 != null) {
    82                                 nodeClassSimpleName1 = node1.getClass().getSimpleName();
     107        private boolean compareNodeClass(ASTNode node1, ASTNode node2) {
     108                if(comparisonLevel.compareNodeClass()) {                       
     109                        if ((node1 != null) && (node2 != null)) {
     110                                String nodeClassSimpleName1 = node1.getClass().getSimpleName();
     111                                String nodeClassSimpleName2 = node2.getClass().getSimpleName();
     112                                if (!nodeClassSimpleName1.equals(nodeClassSimpleName2)) {
     113                                        System.err.println("Node class mismatch at: " + getFailureLocation(node1, node2));
     114                                        System.err.println("");
     115                                        System.err.println("Expected: " + nodeClassSimpleName1);
     116                                        System.err.println("Actual: " + nodeClassSimpleName2);
     117                                        System.err.println("");
     118                                        return false;   
     119                                }
    83120                        }
    84                        
    85                         if(node2 != null) {
    86                                 nodeClassSimpleName2 = node2.getClass().getSimpleName();
     121                }
     122                return true;
     123        }
     124       
     125        private boolean compareToken(ASTNode node1, ASTNode node2) {
     126                if(comparisonLevel.compareToken()) {                   
     127                        if ((node1 != null) && (node2 != null)) {
     128                                String tokenSimpleName1 = node1.getToken().toString();
     129                                String tokenSimpleName2 = node2.getToken().toString();
     130                               
     131                                if(!tokenSimpleName1.equals(tokenSimpleName2)) {
     132                                        System.err.println("Token mismatch at: " + getFailureLocation(node1, node2));
     133                                        System.err.println("");
     134                                        System.err.println("Expected: " + tokenSimpleName1);
     135                                        System.err.println("Actual: " + tokenSimpleName2);
     136                                        System.err.println("");
     137                                        return false;   
     138                                }
     139                               
     140                                return tokenSimpleName1.equals(tokenSimpleName2);
     141                               
     142                        } else {       
     143                                return false;
     144                        }                       
     145                }
     146                return true;
     147        }
     148       
     149        private boolean compareAttributes(ASTNode node1, ASTNode node2) {
     150                if(comparisonLevel.compareFull()) {
     151                        if ((node1 != null) && (node2 != null)) {
     152                                String attributeString1 = node1.attributeString();
     153                                String attributeString2 = node2.attributeString();
     154                               
     155                                if(!attributeString1.equals(attributeString2)) {
     156                                        System.err.println("Attribute mismatch at: " + getFailureLocation(node1, node2));
     157                                        System.err.println("");
     158                                        System.err.println("Expected: " + attributeString1);
     159                                        System.err.println("Actual: " + attributeString2);
     160                                        System.err.println("");
     161                                        return false;
     162                                }
    87163                        }
    88                        
    89                         assert nodeClassSimpleName1.equals(nodeClassSimpleName2)
    90                         : "\nExpected node class name: " + nodeClassSimpleName1
    91                         + "\nActual node class name: " + nodeClassSimpleName2
    92                         + "\nLocation: " + getLocation(node1, node2) + ".";
    93164                }
    94         }
    95         private void compareToken(ASTNode node1, ASTNode node2) {
    96                 if(comparisonLevel.compareToken()) {
    97                         String tokenSimpleName1 = null;
    98                         String tokenSimpleName2 = null;
    99                        
    100                         if(node1 != null) {
    101                                 tokenSimpleName1 = node1.getToken().toString();
    102                         }
    103                        
    104                         if(node2 != null) {
    105                                 tokenSimpleName2 = node2.getToken().toString();
    106                         }
    107                        
    108                         assert tokenSimpleName1.equals(tokenSimpleName2)
    109                         : "\nExpected token simple name: " + tokenSimpleName1
    110                         + "\nActual token simple name: " + tokenSimpleName2
    111                         + "\nLocation: " + getLocation(node1, node2) + ".";
    112                                                
    113                 }
    114         }
    115         private void compareAttributes(ASTNode node1, ASTNode node2) {
    116                 if(comparisonLevel.compareFull()) {
    117                        
    118                         String attributeString1 = null;
    119                         String attributeString2 = null;
    120                        
    121                         if(node1 != null) {
    122                                 attributeString1 = node1.attributeString();
    123                         }
    124                        
    125                         if(node2 != null) {
    126                                 attributeString2 = node2.attributeString();
    127                         }
    128                        
    129                         assert attributeString1.equals(attributeString2)
    130                         : "\nExpected attribute string: " + attributeString1 
    131                         + "\nActual attribute string: " + attributeString2
    132                         + "\nLocation: " + getLocation(node1, node2) + ".";
    133                 }
     165                return true;
    134166        }
    135167
    136         private String getLocation(ASTNode node1, ASTNode node2) {
    137                 String location = null;
     168        private String getFailureLocation(ASTNode node1, ASTNode node2) {
     169       
     170                String location= null;
    138171               
    139                 if (node1 != null) {
     172                if (node2 != null) {
     173                        location = node2.getToken().getLocation().toString();
     174                } else if (node1 != null) {
    140175                        location = node1.getToken().getLocation().toString();
    141                 } else if (node2 != null) {
    142                         location = node2.getToken().getLocation().toString();
    143176                }
    144177               
  • proto/pablo/src/compiler/test/ASTTest.java

    r2459 r2576  
    3939                public void assertComplete() {
    4040                                               
    41                         assert (this.ASTTree1 == null) :
    42                                                                 "Missing actual result AST subtree."
    43                                                                 + "\nExpected node class name: " + this.ASTTree1.getClass().getSimpleName()
    44                                                                 + "\nActual node class name: " + null
    45                                                                 + "\nLocation: " + this.ASTTree1.getToken().getLocation() + ".";
     41                        if (this.ASTTree1 != null) {
     42                                System.err.println("Missing comparison node."
     43                                                                + "\nExpected: " + this.ASTTree1.toString()
     44                                                                + "\nActual: " + null);
     45                                System.err.println("Location: " + this.ASTTree1.getToken().getLocation() + ".");
     46                                System.exit(9);
     47                        }
    4648                }
    4749               
Note: See TracChangeset for help on using the changeset viewer.