Changeset 3171


Ignore:
Timestamp:
May 22, 2013, 2:29:27 AM (6 years ago)
Author:
ksherdy
Message:

Refactored visitor test harness. Additional work needed to test carryIntroXFormer transformations.

Location:
proto/pabloj/branches/refactor-experimental/src/test
Files:
3 edited
1 moved

Legend:

Unmodified
Added
Removed
  • proto/pabloj/branches/refactor-experimental/src/test/helpers/FileUtil.java

    r3169 r3171  
    88import java.util.List;
    99
    10 public class TestUtil {
     10public class FileUtil {
    1111
    12         public static List<File> listFilesInDirectory(File dir, String pattern) {
    13                 List<File> file = new ArrayList<File>();
    14                 File [] files = dir.listFiles();
    15                 if (files != null) {
    16                         for (File f : files) {
    17                                 if (f.isDirectory()) {
    18                                         file.addAll(listFilesInDirectory(f, pattern));
    19                                 }
    20                                 else {
    21                                         if (f.getName().endsWith(pattern)) {
    22                                                 file.add(f);
    23                                         }
    24                                 }
     12        /*
     13         * Recursively searches and returns all files with the given file extension.
     14         */
     15        public static ArrayList<File> listFilesWithExtension(File file, String fileExtension) {
     16               
     17                ArrayList<File> list = new ArrayList<File>();
     18               
     19                if(file.isFile() &&  file.getName().endsWith(fileExtension)) {
     20                        list.add(file);
     21                        return list;
     22                }
     23               
     24                if(file.isDirectory()) {
     25                        for(File f : file.listFiles()) {
     26                                list.addAll(listFilesWithExtension(f, fileExtension));
    2527                        }
    2628                }
    27                 return file;
    28         }
    29                
     29                       
     30                return list;
     31        }       
     32                       
     33       
    3034    public static String file2String(File f) throws IOException {
    3135        BufferedReader reader = new BufferedReader(new FileReader(f));
  • proto/pabloj/branches/refactor-experimental/src/test/pabloB/PabloBAST.java

    r3165 r3171  
    11/*
    2  * Quick and dirty.
     2 * Simple parse test.
    33 *
    4  * Recursively traverses and parses PabloB files (.pabloB). 
    5  * If no errors PabloS AST prints AST otherwise prints error message.
    6  *
     4 * Parses a .pabloB file. If no errors PabloS AST prints AST otherwise prints error message.
     5
    76 * @author Ken Herdy <ksherdy at sfu dot ca>
    87 * @date December 17 2012
  • proto/pabloj/branches/refactor-experimental/src/test/pabloS/PabloSAST.java

    r3165 r3171  
    11/*
    2  * Quick and dirty.
     2 * Simple parse test.
    33 *
    4  * Recursively traverses and parses PabloS files (.pabloS). 
    5  * If no errors PabloS AST prints AST otherwise prints error message.
     4 * Parses a .pabloS file. If no errors PabloS AST prints AST otherwise prints error message.
    65 *
    76 * @author Ken Herdy <ksherdy at sfu dot ca>
  • proto/pabloj/branches/refactor-experimental/src/test/pabloS/PabloSTestHarness.java

    r3168 r3171  
     1/*
     2 * Basic test harness to test PabloS transformations.
     3 *
     4 *
     5 *
     6 * Useful for regression testing.
     7 *
     8 */
    19
    210package  test.pabloS;
     
    412import java.io.File;
    513import java.io.FileNotFoundException;
     14import java.lang.reflect.InvocationTargetException;
     15import java.lang.reflect.Method;
    616import java.util.*;
    717
     
    1222import pabloS.tokens.Tokens;
    1323
    14 import toolchain.pabloS.semanticAnalyzer.helpers.AssertCompare;
     24import test.helpers.FileUtil;
     25import toolchain.pabloS.semanticAnalyzer.helpers.NodePairComparator;
    1526import toolchain.pabloS.semanticAnalyzer.visitors.CombineAdvances;
    1627import toolchain.pabloS.semanticAnalyzer.visitors.ExpandAugmentedAssignments;
    1728import toolchain.pabloS.semanticAnalyzer.visitors.ConvertBitwiseBooleanToIDISACalls;
    1829import toolchain.pabloS.semanticAnalyzer.visitors.InitializeStreamDefaults;
    19 import toolchain.pabloS.semanticAnalyzer.visitors.StreamFuncVisitor;
     30import toolchain.pabloS.semanticAnalyzer.visitors.StreamFunctionMapGenerator;
     31import toolchain.pabloS.semanticAnalyzer.visitors.carry.Carry1Count;
    2032import toolchain.pabloS.semanticAnalyzer.visitors.carry.CarryIntroXFormer;
     33import toolchain.pabloS.semanticAnalyzer.visitors.carry.CarryNCount;
    2134import toolchain.test.*;
    2235
     
    2639public class PabloSTestHarness {
    2740
    28         private static final String PABLOSEXT = ".pablos";
    29         protected static final String TEST_DIR_BASE = "test/";
     41        private static final String PABLOS_EXT = ".pablos";
     42        private static final String VISITORS_TEST_DIRECTORY = "input/test/visitors/";
    3043       
    31         public enum VisitorUnderTest {
    32             COMBINE_ADVANCES("CombineAdvances");
     44        public enum VisitorsUnderTest {
     45            COMBINE_ADVANCES(CombineAdvances.class, "apply", "CombineAdvances"),
     46            CONVERT_BITWISE_BOOLEAN_TO_IDISA_CALLS(ConvertBitwiseBooleanToIDISACalls.class, "apply", "ConvertBitwiseBooleanToIDISACalls"),
     47            EXPAND_AUGMENTED_ASSIGNMENTS(ExpandAugmentedAssignments.class, "apply", "ExpandAugmentedAssignments");
    3348           
    34             /*
    35             ADVANCENCOUNTER("AdvanceNCounterVisitor"),
    36             AUGASSIGN("AugAssignXFormer"),
    37             BITWISE2IDISA("Bitwise2IDISAXFormer"),
    38             CARRYCOUNTER("CarryCounterVisitor"),
    39             //PABLO2CARRYQNOTFINALBLOCK("Pablo2CarryQXFormer/NotFinalBlock"),
    40             //PABLO2CARRYQFINALBLOCK("Pablo2CarryQXFormer/FinalBlock"),
    41             CARRYINITTOONELIST("CarryInitToOneListVisitor"),
    42             STREAMFUNCVISITOR("StreamFuncVisitor"),
     49            /*// TODO
    4350            CARRYINTROXFORMERNOTFINALBLOCK("CarryIntroXFormer/NotFinalBlock"),
    4451            CARRYINTROXFORMERFINALBLOCK("CarryIntroXFormer/FinalBlock");
    45             //ASSERTZERO("",true); // TODO
    4652            */
    4753           
    48             private String testDir;
    49             private boolean isExcludeTest = false;
     54            private Class<?> clazz;
     55            private String method;
     56            private String testDirectory;
     57            private boolean isExcluded = false;
    5058           
    51             VisitorUnderTest(String testDirName) {
    52                 this.testDir = TEST_DIR_BASE + File.separator + testDirName;
     59            VisitorsUnderTest(Class<?> clazz, String method, String testDirName) {
     60                this.clazz = clazz;
     61                this.method = method;
     62                this.testDirectory = VISITORS_TEST_DIRECTORY + testDirName;
    5363            }
    5464           
    55             VisitorUnderTest(String testDirName, boolean isExcludedTest) {
    56                 this.testDir = TEST_DIR_BASE + File.separator + testDirName;
    57                 this.isExcludeTest = isExcludedTest;
     65            VisitorsUnderTest(Class<?> clazz, String method, String testDirName, boolean isExcludedTest) {
     66                this.clazz = clazz;
     67                this.method = method;
     68                this.testDirectory = VISITORS_TEST_DIRECTORY + testDirName;
     69                this.isExcluded = isExcludedTest;
    5870            }
    5971           
    6072            public boolean isExcludedTest() {
    61                 return isExcludeTest;
     73                return isExcluded;
    6274            }
    6375           
    64             public void doTest() {
     76            public void test() {
    6577               
     78                ArrayList<File> files = this.getTestFiles();
     79       
     80                        for(File file: files) {
     81                       
     82                                String absolutePath = file.getAbsolutePath();
     83                               
     84                                System.out.println(this.toString() + ": " + absolutePath);
     85                       
     86                                LexicalController lexicalController = LexicalController.make(absolutePath);
     87                                ASTNode syntaxTree = Parser.parse(lexicalController);
     88                                                                       
     89                                try {
     90                                        Method m;
     91                                        m = clazz.getDeclaredMethod(method, ASTNode.class);
     92                                        m.invoke(null, syntaxTree);
     93                                } catch (SecurityException e) {
     94                                        e.printStackTrace();
     95                                } catch (NoSuchMethodException e) {
     96                                        e.printStackTrace();
     97                                } catch (IllegalArgumentException e) {
     98                                        e.printStackTrace();
     99                                } catch (IllegalAccessException e) {
     100                                        e.printStackTrace();
     101                                } catch (InvocationTargetException e) {
     102                                        e.printStackTrace();
     103                                }
     104                               
     105                                NodePairComparator comparator = new NodePairComparator(syntaxTree);
     106                                comparator.compareAssignNodePairs();
     107                        }
    66108            }
    67109
    68                 private static ArrayList<File> getTestFiles(File testBase, VisitorUnderTest test) {
    69                         String dir = new String();
     110                private ArrayList<File> getTestFiles() {
    70111                        ArrayList<File> files = new ArrayList<File>();
    71                         files = listFilesWithExtension(new File (test.testDir), PABLOSEXT);
     112                        files = FileUtil.listFilesWithExtension(new File (this.testDirectory), ".pablos");
    72113                        return files;
    73114                }       
    74                
    75                 private static ArrayList<File> listFilesWithExtension(File file, String fileExtension) {
    76                        
    77                         ArrayList<File> list = new ArrayList<File>();
    78                        
    79                         if(file.isFile() &&  file.getName().endsWith(fileExtension)) {
    80                                 list.add(file);
    81                                 return list;
    82                         }
    83                        
    84                         if(file.isDirectory()) {
    85                                 File [] files = file.listFiles();
    86                                 for(File f : file.listFiles()) {
    87                                         list.addAll(listFilesWithExtension(f, fileExtension));
    88                                 }
    89                         }
    90                                
    91                         return list;
    92                 }       
    93115                           
    94            
    95116        }
    96117       
    97         /** Compiles a Pablo file.
    98          * @param args
    99          * @throws FileNotFoundException
    100          */     
    101        
    102118        public static void main(String[] args) throws FileNotFoundException {
     119               
     120                for(VisitorsUnderTest vut: VisitorsUnderTest.values()) {
     121                        vut.test();
     122                }
    103123
    104                 Tokens.setPrintLevel(Tokens.Level.FULL);       
     124/*              boolean isFinalBlock;   
     125                case CARRYINTROXFORMERFINALBLOCK:
     126                        isFinalBlock = true;
     127                        carryIntroXFormerTest(fileAbsolutePath, isFinalBlock);
     128                        break; 
     129                case CARRYINTROXFORMERNOTFINALBLOCK:
     130                        isFinalBlock = false;
     131                        carryIntroXFormerTest(fileAbsolutePath, isFinalBlock);
     132                        break;                 
     133*/
    105134               
    106 //              File testBase = new File(testDirBase);
    107                
    108                 //boolean isFinalBlock;
    109                
    110                 for(VisitorUnderTest test: VisitorUnderTest.values()) {
    111                        
    112 //                      if (!test.isExcludeTest()) {
    113                        
    114 //                              ArrayList<File> files = getTestFiles(testBase, test);
    115                                
    116 //                              for(File file: files) {
    117 //                                     
    118 //                                      String fileAbsolutePath = file.getAbsolutePath();
    119 //                                      System.out.println("Running: " + fileAbsolutePath);
    120 //                                     
    121 //                                     
    122 //                                      switch(test) {
    123 //                                              case COMBINE_ADVANCES:
    124 //                                                      COMBINEADVANCESTest(fileAbsolutePath);
    125 //                                                      break;
    126                                                
    127                                                         /*
    128                                                        
    129                                                 case ADVANCENCOUNTER:
    130                                                         // TODO
    131                                                         break;
    132                                                 case AUGASSIGN:                                 
    133                                                         AugAssignTest(fileAbsolutePath);
    134                                                         break;
    135                                                 case BITWISE2IDISA:
    136                                                         bitwise2IDISATest(fileAbsolutePath);
    137                                                         break;                                 
    138                                                 case CARRYCOUNTER:
    139                                                         // TODO
    140                                                         break;
    141                                                 case CARRYINTROXFORMERFINALBLOCK:
    142                                                         isFinalBlock = true;
    143                                                         carryIntroXFormerTest(fileAbsolutePath, isFinalBlock);
    144                                                         break; 
    145                                                 case CARRYINTROXFORMERNOTFINALBLOCK:
    146                                                         isFinalBlock = false;
    147                                                         carryIntroXFormerTest(fileAbsolutePath, isFinalBlock);
    148                                                         break;                 
    149                                                 case CARRYINITTOONELIST:
    150                                                         // TODO
    151                                                         break;                                 
    152                                                 case STREAMFUNCVISITOR:
    153                                                         // TODO
    154                                                         break;
    155                                                        
    156                                                         */
    157 //                                                     
    158 //                                              default:
    159 //                                                      System.err.println("Undefined test case.");
    160 //                                                      break;
    161 //                                      }
    162 //                              }
    163 //                      }
    164 //              }
    165                
    166                 System.out.print("Tests complete.");
    167                 }
    168         }
    169 
    170 
    171        
    172         /**
    173          * @param fileAbsolutePath
    174          * @throws FileNotFoundException
    175          */
    176         public static void COMBINEADVANCESTest(String fileAbsolutePath) throws FileNotFoundException {
    177                                
    178                 LexicalController lexController = LexicalController.make(fileAbsolutePath);
    179                 ASTNode syntaxTree = Parser.parse(lexController);
    180                
    181                 StreamFuncVisitor streamFuncVisitor = new StreamFuncVisitor(syntaxTree);
    182                 Map<String, ASTNode> streamFuncMap = streamFuncVisitor.makeStreamFuncMap();
    183                
    184                 for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {                                             
    185                     CombineAdvances.apply(entry.getValue());   
    186                 }   
    187                
    188                 AssertCompare astTest = new AssertCompare(syntaxTree);
    189                 astTest.compareAssignNodes();
    190         }
    191 
    192         /*
    193        
    194         /**
    195          * @param fileAbsolutePath
    196          * @throws FileNotFoundException
    197          */
    198         public static void bitwise2IDISATest(String fileAbsolutePath) throws FileNotFoundException {
    199                                
    200                 LexicalController lexController = LexicalController.make(fileAbsolutePath);
    201                 ASTNode syntaxTree = Parser.parse(lexController);
    202                
    203                 StreamFuncVisitor streamFuncVisitor = new StreamFuncVisitor(syntaxTree);
    204                 Map<String, ASTNode> streamFuncMap = streamFuncVisitor.makeStreamFuncMap();
    205                
    206                 for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {                                             
    207                         ASTNode bitwise2IDISA = ConvertBitwiseBooleanToIDISACalls.apply(entry.getValue());
    208                 }
    209                
    210                 AssertCompare astTest = new AssertCompare(syntaxTree);
    211                 astTest.compareAssignNodes();
     135                System.out.print("All tests complete.");
    212136               
    213137        }
    214 
    215         /**
    216          * @param fileAbsolutePath
    217          * @throws FileNotFoundException
    218          */
    219         public static void AugAssignTest(String fileAbsolutePath) throws FileNotFoundException {
    220                                
    221                 LexicalController lexController = LexicalController.make(fileAbsolutePath);
    222                 ASTNode syntaxTree = Parser.parse(lexController);
    223                
    224                 StreamFuncVisitor streamFuncVisitor = new StreamFuncVisitor(syntaxTree);
    225                 Map<String, ASTNode> streamFuncMap = streamFuncVisitor.makeStreamFuncMap();
    226                
    227                 for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {                                                                     
    228                         ExpandAugmentedAssignments.apply(entry.getValue());     
    229                 }   
    230                
    231                 AssertCompare astTest = new AssertCompare(syntaxTree);
    232                 astTest.compareAssignNodes();
    233         }
    234138       
    235         /**
    236          * @param fileAbsolutePath
    237          * @throws FileNotFoundException - Final Block
    238          */
    239        
    240         /*
    241          * Deprecated.
    242          */
    243 //      public static void carryIntroXFormerTest(String fileAbsolutePath, boolean isFinalBlock) throws FileNotFoundException {
    244 //              LexicalController lexController = LexicalController.make(fileAbsolutePath);
    245 //              ASTNode syntaxTree = Parser.parse(lexController);
    246 //             
    247 //              StreamFuncVisitor streamFuncVisitor = new StreamFuncVisitor(syntaxTree);
    248 //              Map<String, ASTNode> streamFuncMap = streamFuncVisitor.makeStreamFuncMap();
    249 //             
    250 //              BuiltinEncoder builtins2CPP = new PabloSBuiltins2CPP();
    251 //             
    252 //              for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {     
    253 //                      ASTNode value = entry.getValue();                               
    254 //                      CarrySetEncoder carrySet2CPP = new CarrySetBuiltins2CPP();
    255 //                      ASTNode pablo2CarryQ = CarryIntroXFormer.apply(value, builtins2CPP, carrySet2CPP, isFinalBlock);
    256 //              }   
    257 //             
    258 //              AssertCompare astTest = new AssertCompare(syntaxTree);
    259 //              astTest.compareAssignNodes();
    260 //             
    261 //      }       
    262 
    263        
    264        
    265        
    266 //  CarryCounter carryCounter = new CarryCounter(node);
    267 //  AdvanceNCounter advNCounter = new AdvanceNCounter(node);                       
    268 //      System.out.println(entry.getKey());
    269 //      System.out.println("Carry Count = " + carryCounter.count());
    270 //      System.out.println("Adv n Count = " + advNCounter.count());
    271 //      System.out.println();
    272 
    273         public static final int EXIT_CODE_FOR_ERROR = 1;
     139        private static final int EXIT_CODE_FOR_ERROR = 1;
    274140       
    275141        private static void generateCodeIfNoErrors(String filename, ASTNode decoratedTree) throws FileNotFoundException {
     
    293159        }       
    294160
    295 
    296161}
    297162
Note: See TracChangeset for help on using the changeset viewer.