Changeset 3168


Ignore:
Timestamp:
May 21, 2013, 6:36:37 PM (6 years ago)
Author:
ksherdy
Message:

Initial refactoring for visitor tests.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/branches/refactor-experimental/src/test/pabloS/PabloSTestHarness.java

    r3133 r3168  
    66import java.util.*;
    77
     8import pabloS.ast.ASTNode;
     9import pabloS.logging.ScatterLogger;
    810import pabloS.lexicalAnalyzer.LexicalController;
    911import pabloS.parser.Parser;
    10 
    11 import  pabloS.tokens.Tokens;
    12 import  pabloS.ast.ASTNode;
    13 import  pabloS.logging.ScatterLogger;
    14 import toolchain.pabloB.lang.carrySet.CarrySetEncoder;
    15 import toolchain.pabloB.lang.carrySet.CarrySetBuiltins2CPP;
    16 import toolchain.pabloS.lang.BuiltinEncoder;
    17 import toolchain.pabloS.lang.PabloSBuiltins;
    18 import toolchain.pabloS.lang.PabloSBuiltins2CPP;
     12import pabloS.tokens.Tokens;
     13
    1914import toolchain.pabloS.semanticAnalyzer.helpers.AssertCompare;
    2015import toolchain.pabloS.semanticAnalyzer.visitors.CombineAdvances;
     
    3227
    3328        private static final String PABLOSEXT = ".pablos";
    34         protected static final int EXIT_CODE_FOR_ERROR = 1;
    35         protected static String outputDirectory = "output/";
    36         protected static String testDirectoryName = null;
    37        
    38         public enum Visitor {
    39             ADVANCECOMBINER("AdvanceCombinerXFormer", true),
    40             ADVANCENCOUNTER("AdvanceNCounterVisitor", true),
    41             AUGASSIGN("AugAssignXFormer", true),
    42             BITWISE2IDISA("Bitwise2IDISAXFormer", true),
    43             CARRYCOUNTER("CarryCounterVisitor", true),
    44             //PABLO2CARRYQNOTFINALBLOCK("Pablo2CarryQXFormer/NotFinalBlock", true),
    45             //PABLO2CARRYQFINALBLOCK("Pablo2CarryQXFormer/FinalBlock", true),
    46             CARRYINITTOONELIST("CarryInitToOneListVisitor", true),
    47             STREAMFUNCVISITOR("StreamFuncVisitor", true),
    48             CARRYINTROXFORMERNOTFINALBLOCK("CarryIntroXFormer/NotFinalBlock", true),
    49             CARRYINTROXFORMERFINALBLOCK("CarryIntroXFormer/FinalBlock", true);
    50            
     29        protected static final String TEST_DIR_BASE = "test/";
     30       
     31        public enum VisitorUnderTest {
     32            COMBINE_ADVANCES("CombineAdvances");
     33           
     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"),
     43            CARRYINTROXFORMERNOTFINALBLOCK("CarryIntroXFormer/NotFinalBlock"),
     44            CARRYINTROXFORMERFINALBLOCK("CarryIntroXFormer/FinalBlock");
    5145            //ASSERTZERO("",true); // TODO
    52            
    53             private final String directoryName;
    54             private boolean addTest = false;
    55            
    56             Visitor(String directoryName, boolean addTest) {
    57                 this.directoryName = directoryName;
    58                 this.addTest = addTest;
    59             }
    60            
    61             public String directory() { return directoryName; }
    62             public boolean addTest() { return addTest; }
     46            */
     47           
     48            private String testDir;
     49            private boolean isExcludeTest = false;
     50           
     51            VisitorUnderTest(String testDirName) {
     52                this.testDir = TEST_DIR_BASE + File.separator + testDirName;
     53            }
     54           
     55            VisitorUnderTest(String testDirName, boolean isExcludedTest) {
     56                this.testDir = TEST_DIR_BASE + File.separator + testDirName;
     57                this.isExcludeTest = isExcludedTest;
     58            }
     59           
     60            public boolean isExcludedTest() {
     61                return isExcludeTest;
     62            }
     63           
     64            public void doTest() {
     65               
     66            }
     67
     68                private static ArrayList<File> getTestFiles(File testBase, VisitorUnderTest test) {
     69                        String dir = new String();
     70                        ArrayList<File> files = new ArrayList<File>();
     71                        files = listFilesWithExtension(new File (test.testDir), PABLOSEXT);
     72                        return files;
     73                }       
     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                }       
     93                           
     94           
    6395        }
    6496       
     
    69101       
    70102        public static void main(String[] args) throws FileNotFoundException {
    71                                
    72                 checkArgs(args, "PabloCompilerTestHarness");
     103
    73104                Tokens.setPrintLevel(Tokens.Level.FULL);       
    74                 File testBase = new File(testDirectoryName);
    75                 boolean isFinalBlock;
    76                
    77                 for(Visitor test: Visitor.values()) {
    78                        
    79                         if (test.addTest()) {
    80                        
    81                                 String dir = new String();
    82                                 ArrayList<File> files = new ArrayList<File>();
    83                                 dir = testBase.getAbsolutePath() + File.separator + test.directory();
    84                                 files = matchFiles(new File (dir), PABLOSEXT);
    85                                
    86                                 for(File file: files) {
    87                                        
    88                                         String fileAbsolutePath = file.getAbsolutePath();
    89                                         System.out.println("Running: " + fileAbsolutePath);
    90                                        
    91                                        
    92                                         switch(test) {
    93                                                 case ADVANCECOMBINER:
    94                                                         advanceCombinerTest(fileAbsolutePath);
    95                                                         break;
     105               
     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                                                       
    96129                                                case ADVANCENCOUNTER:
    97130                                                        // TODO
     
    120153                                                        // TODO
    121154                                                        break;
    122                                                 default:
    123                                                         System.err.println("Undefined test case.");
    124                                                         break;
    125                                         }
    126                                 }
    127                         }
     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.");
    128167                }
    129                
    130                 System.out.print("Tests complete.");
    131         }
    132        
    133         /**
    134          * @param fileAbsolutePath
    135          * @throws FileNotFoundException
    136          */
    137         public static void advanceCombinerTest(String fileAbsolutePath) throws FileNotFoundException {
     168        }
     169
     170
     171       
     172        /**
     173         * @param fileAbsolutePath
     174         * @throws FileNotFoundException
     175         */
     176        public static void COMBINEADVANCESTest(String fileAbsolutePath) throws FileNotFoundException {
    138177                               
    139178                LexicalController lexController = LexicalController.make(fileAbsolutePath);
     
    151190        }
    152191
     192        /*
     193       
    153194        /**
    154195         * @param fileAbsolutePath
     
    200241         * Deprecated.
    201242         */
    202         public static void carryIntroXFormerTest(String fileAbsolutePath, boolean isFinalBlock) throws FileNotFoundException {
    203                 LexicalController lexController = LexicalController.make(fileAbsolutePath);
    204                 ASTNode syntaxTree = Parser.parse(lexController);
    205                
    206                 StreamFuncVisitor streamFuncVisitor = new StreamFuncVisitor(syntaxTree);
    207                 Map<String, ASTNode> streamFuncMap = streamFuncVisitor.makeStreamFuncMap();
    208                
    209                 BuiltinEncoder builtins2CPP = new PabloSBuiltins2CPP();
    210                
    211                 for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {     
    212                         ASTNode value = entry.getValue();                               
    213                         CarrySetEncoder carrySet2CPP = new CarrySetBuiltins2CPP();
    214                         ASTNode pablo2CarryQ = CarryIntroXFormer.apply(value, builtins2CPP, carrySet2CPP, isFinalBlock);
    215                 }   
    216                
    217                 AssertCompare astTest = new AssertCompare(syntaxTree);
    218                 astTest.compareAssignNodes();
    219                
    220         }       
     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       
    221264       
    222265       
     
    228271//      System.out.println();
    229272
    230         private static void generateCodeIfNoErrors(String filename, ASTNode decoratedTree)
    231                         throws FileNotFoundException {
     273        public static final int EXIT_CODE_FOR_ERROR = 1;
     274       
     275        private static void generateCodeIfNoErrors(String filename, ASTNode decoratedTree) throws FileNotFoundException {
    232276                if(thereAreErrors()) {
    233277                        stopProcessing();
     278                        exitWithMessage();
    234279                }
    235                 else {
    236                         generateAndPrintCode(decoratedTree);
    237                 }
    238         }
    239 
    240         // stopProcessing -- inform user and clean up.
     280        }
     281
    241282        private static void stopProcessing() {
    242                 informUserNoCodeGenerated();
    243         }
    244         private static void informUserNoCodeGenerated() {
    245                 System.err.println("program has errors.  no parser produced.");
    246         }
    247        
    248         // normal code generation.
    249         private static void generateAndPrintCode(ASTNode decoratedTree)
    250                         throws FileNotFoundException {
    251                 //      CodeGenerator generator = new CodeGenerator(outputDirectory, decoratedTree);
    252                 //      generator.generate();
     283                exitWithMessage();
    253284        }
    254285
     
    256287                return ScatterLogger.hasErrors();
    257288        }
    258 
    259         protected static void checkArgs(String[] args, String applicationName) {
    260                 int length = args.length;
    261                 boolean inputDirectoryFound = false;
    262                
    263                 for(int i=0; i<length; i++) {
    264 
    265                         String arg = args[i];
    266                        
    267                         if(arg.equals("-o")) {
    268                                 if(i==length-1) {
    269                                         exitWithUsageMessage(applicationName);
    270                                 }
    271                                 arg = args[++i];
    272                                 outputDirectory = arg + "/";
    273                         }
    274                         else if(!inputDirectoryFound) {
    275                                 testDirectoryName = arg;
    276                        
    277                                 if (! new File(testDirectoryName).isDirectory()) {
    278                                         System.err.println("Input directory does not exist.");
    279                                         exitWithUsageMessage(applicationName);
    280                                 }
    281                        
    282                                 inputDirectoryFound = true;
    283                         }
    284                         else {
    285                                 exitWithUsageMessage(applicationName);
    286                         }                       
    287                 }
    288         }
    289        
    290         private static void exitWithUsageMessage(String applicationName) {
    291                 System.err.println("usage: " + applicationName + " inputDirectory [-o outputDirectory]");
     289       
     290        private static void exitWithMessage() {
     291                System.err.println("Test file has syntax errors. Aborting.");
    292292                System.exit(EXIT_CODE_FOR_ERROR);
    293293        }       
    294294
    295         public static ArrayList<File> matchFiles(File file, String suffix) {
    296                
    297                 ArrayList<File> list = new ArrayList<File>();
    298                
    299                 if(file.isFile() &&  file.getName().endsWith(suffix)) {
    300                         list.add(file);
    301                         return list;
    302                 }
    303                
    304                 if(file.isDirectory()) {
    305                         File [] files = file.listFiles();
    306                         for(File f : file.listFiles()) {
    307                                 list.addAll(matchFiles(f, suffix));
    308                         }
    309                 }
    310                        
    311                 return list;
    312         }       
    313        
     295
    314296}
    315297
Note: See TracChangeset for help on using the changeset viewer.