source: proto/pabloj/trunk/src/test/pabloS/PabloSTestHarness.java @ 2947

Last change on this file since 2947 was 2947, checked in by ksherdy, 6 years ago

Code clean up and comments.

File size: 9.4 KB
Line 
1
2package  test.pabloS;
3
4import java.io.File;
5import java.io.FileNotFoundException;
6import java.util.*;
7
8import pabloS.lexicalAnalyzer.LexicalController;
9import pabloS.parser.Parser;
10
11import  pabloS.tokens.Tokens;
12import  pabloS.ast.ASTNode;
13import  pabloS.logging.ScatterLogger;
14
15import compiler.test.*;
16import compiler.lang.carry.CarryBuiltins2CPP;
17import compiler.lang.carry.CarryBuiltins2Lang;
18import compiler.lang.pabloS.PabloSBuiltins2CPP;
19import compiler.lang.pabloS.Builtins2Lang;
20import compiler.lang.pabloS.Builtins;
21
22import compiler.transformers.pabloS.AdvanceCombinerXFormer;
23import compiler.transformers.pabloS.AugAssignXFormer;
24import compiler.transformers.pabloS.Bitwise2IDISAXFormer;
25import compiler.transformers.pabloS.CarryIntroXFormer;
26import compiler.transformers.pabloS.StreamFuncVisitor;
27import compiler.transformers.pabloS.helpers.AssertCompare;
28
29@SuppressWarnings("unused")
30public class PabloSTestHarness {
31
32        private static final String PABLOSEXT = ".pablos";
33        protected static final int EXIT_CODE_FOR_ERROR = 1;
34        protected static String outputDirectory = "output/";
35        protected static String testDirectoryName = null;
36       
37        public enum Visitor {
38            ADVANCECOMBINER("AdvanceCombinerXFormer", true),
39            ADVANCENCOUNTER("AdvanceNCounterVisitor", true),
40            AUGASSIGN("AugAssignXFormer", true),
41            BITWISE2IDISA("Bitwise2IDISAXFormer", true),
42            CARRYCOUNTER("CarryCounterVisitor", true),
43            //PABLO2CARRYQNOTFINALBLOCK("Pablo2CarryQXFormer/NotFinalBlock", true),
44            //PABLO2CARRYQFINALBLOCK("Pablo2CarryQXFormer/FinalBlock", true),
45            CARRYINITTOONELIST("CarryInitToOneListVisitor", true),
46            STREAMFUNCVISITOR("StreamFuncVisitor", true),
47            CARRYINTROXFORMERNOTFINALBLOCK("CarryIntroXFormer/NotFinalBlock", true),
48            CARRYINTROXFORMERFINALBLOCK("CarryIntroXFormer/FinalBlock", true);
49            //ASSERTZERO("",true); // TODO
50           
51            private final String directoryName;
52            private boolean addTest = false;
53           
54            Visitor(String directoryName, boolean addTest) {
55                this.directoryName = directoryName;
56                this.addTest = addTest;
57            }
58           
59            public String directory() { return directoryName; }
60            public boolean addTest() { return addTest; }
61        }
62       
63        /** Compiles a Pablo file.
64         * @param args
65         * @throws FileNotFoundException
66         */     
67       
68        public static void main(String[] args) throws FileNotFoundException {
69                               
70                checkArgs(args, "PabloCompilerTestHarness");
71                Tokens.setPrintLevel(Tokens.Level.FULL);       
72                File testBase = new File(testDirectoryName);
73                boolean isFinalBlock;
74               
75                for(Visitor test: Visitor.values()) {
76                       
77                        if (test.addTest()) {
78                       
79                                String dir = new String();
80                                ArrayList<File> files = new ArrayList<File>();
81                                dir = testBase.getAbsolutePath() + File.separator + test.directory();
82                                files = matchFiles(new File (dir), PABLOSEXT);
83                               
84                                for(File file: files) {
85                                       
86                                        String fileAbsolutePath = file.getAbsolutePath();
87                                        System.out.println("Running: " + fileAbsolutePath);
88                                       
89                                       
90                                        switch(test) {
91                                                case ADVANCECOMBINER:
92                                                        advanceCombinerTest(fileAbsolutePath);
93                                                        break;
94                                                case ADVANCENCOUNTER:
95                                                        // TODO
96                                                        break;
97                                                case AUGASSIGN:                                 
98                                                        AugAssignTest(fileAbsolutePath);
99                                                        break;
100                                                case BITWISE2IDISA:
101                                                        bitwise2IDISATest(fileAbsolutePath);
102                                                        break;                                 
103                                                case CARRYCOUNTER:
104                                                        // TODO
105                                                        break;
106                                                case CARRYINTROXFORMERFINALBLOCK:
107                                                        isFinalBlock = true;
108                                                        carryIntroXFormerTest(fileAbsolutePath, isFinalBlock);
109                                                        break; 
110                                                case CARRYINTROXFORMERNOTFINALBLOCK:
111                                                        isFinalBlock = false;
112                                                        carryIntroXFormerTest(fileAbsolutePath, isFinalBlock);
113                                                        break;                 
114                                                case CARRYINITTOONELIST:
115                                                        // TODO
116                                                        break;                                 
117                                                case STREAMFUNCVISITOR:
118                                                        // TODO
119                                                        break;
120                                                default:
121                                                        System.err.println("Undefined test case.");
122                                                        break;
123                                        }
124                                }
125                        }
126                }
127               
128                System.out.print("Tests complete.");
129        }
130       
131        /**
132         * @param fileAbsolutePath
133         * @throws FileNotFoundException
134         */
135        public static void advanceCombinerTest(String fileAbsolutePath) throws FileNotFoundException {
136                               
137                LexicalController lexController = LexicalController.make(fileAbsolutePath);
138                ASTNode syntaxTree = Parser.parse(lexController);
139               
140                StreamFuncVisitor streamFuncVisitor = new StreamFuncVisitor(syntaxTree);
141                Map<String, ASTNode> streamFuncMap = streamFuncVisitor.makeStreamFuncMap();
142               
143                for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {                                             
144                    AdvanceCombinerXFormer advanceCombiner = new AdvanceCombinerXFormer(entry.getValue());
145                    advanceCombiner.XForm();                       
146                }   
147               
148                AssertCompare astTest = new AssertCompare(syntaxTree);
149                astTest.compareAssignNodes();
150        }
151
152        /**
153         * @param fileAbsolutePath
154         * @throws FileNotFoundException
155         */
156        public static void bitwise2IDISATest(String fileAbsolutePath) throws FileNotFoundException {
157                               
158                LexicalController lexController = LexicalController.make(fileAbsolutePath);
159                ASTNode syntaxTree = Parser.parse(lexController);
160               
161                StreamFuncVisitor streamFuncVisitor = new StreamFuncVisitor(syntaxTree);
162                Map<String, ASTNode> streamFuncMap = streamFuncVisitor.makeStreamFuncMap();
163               
164                for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {                                             
165                        Bitwise2IDISAXFormer bitwiseToIDISA = new Bitwise2IDISAXFormer(entry.getValue());
166                        bitwiseToIDISA.XForm();                     
167                }
168               
169                AssertCompare astTest = new AssertCompare(syntaxTree);
170                astTest.compareAssignNodes();
171               
172        }
173
174        /**
175         * @param fileAbsolutePath
176         * @throws FileNotFoundException
177         */
178        public static void AugAssignTest(String fileAbsolutePath) throws FileNotFoundException {
179                               
180                LexicalController lexController = LexicalController.make(fileAbsolutePath);
181                ASTNode syntaxTree = Parser.parse(lexController);
182               
183                StreamFuncVisitor streamFuncVisitor = new StreamFuncVisitor(syntaxTree);
184                Map<String, ASTNode> streamFuncMap = streamFuncVisitor.makeStreamFuncMap();
185               
186                for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {                                                                     
187                        AugAssignXFormer AugAssign = new AugAssignXFormer(entry.getValue());   
188                        AugAssign.XForm();
189                }   
190               
191                AssertCompare astTest = new AssertCompare(syntaxTree);
192                astTest.compareAssignNodes();
193        }
194       
195        /**
196         * @param fileAbsolutePath
197         * @throws FileNotFoundException - Final Block
198         */
199       
200        /*
201         * Deprecated.
202         */
203        public static void carryIntroXFormerTest(String fileAbsolutePath, boolean isFinalBlock) throws FileNotFoundException {
204                LexicalController lexController = LexicalController.make(fileAbsolutePath);
205                ASTNode syntaxTree = Parser.parse(lexController);
206               
207                StreamFuncVisitor streamFuncVisitor = new StreamFuncVisitor(syntaxTree);
208                Map<String, ASTNode> streamFuncMap = streamFuncVisitor.makeStreamFuncMap();
209               
210                Builtins2Lang builtins2CPP = new PabloSBuiltins2CPP();
211               
212                for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {     
213                        ASTNode value = entry.getValue();                               
214                        CarryBuiltins2Lang carrySet2CPP = new CarryBuiltins2CPP();
215                        CarryIntroXFormer pablo2CarryQ = new CarryIntroXFormer(value, builtins2CPP, carrySet2CPP);
216                        pablo2CarryQ.XForm(isFinalBlock);
217                }   
218               
219                AssertCompare astTest = new AssertCompare(syntaxTree);
220                astTest.compareAssignNodes();
221               
222        }       
223       
224       
225//  CarryCounter carryCounter = new CarryCounter(node);
226//  AdvanceNCounter advNCounter = new AdvanceNCounter(node);                       
227//      System.out.println(entry.getKey());
228//      System.out.println("Carry Count = " + carryCounter.count());
229//      System.out.println("Adv n Count = " + advNCounter.count());
230//      System.out.println();
231
232        private static void generateCodeIfNoErrors(String filename, ASTNode decoratedTree)
233                        throws FileNotFoundException {
234                if(thereAreErrors()) {
235                        stopProcessing();
236                } 
237                else {
238                        generateAndPrintCode(decoratedTree);
239                }
240        }
241
242        // stopProcessing -- inform user and clean up.
243        private static void stopProcessing() {
244                informUserNoCodeGenerated();
245        }
246        private static void informUserNoCodeGenerated() {
247                System.err.println("program has errors.  no parser produced.");
248        }
249       
250        // normal code generation.
251        private static void generateAndPrintCode(ASTNode decoratedTree) 
252                        throws FileNotFoundException {
253                //      CodeGenerator generator = new CodeGenerator(outputDirectory, decoratedTree);
254                //      generator.generate();
255        }
256
257        private static boolean thereAreErrors() {
258                return ScatterLogger.hasErrors();
259        }
260
261        protected static void checkArgs(String[] args, String applicationName) {
262                int length = args.length;
263                boolean inputDirectoryFound = false;
264               
265                for(int i=0; i<length; i++) {
266
267                        String arg = args[i];
268                       
269                        if(arg.equals("-o")) {
270                                if(i==length-1) {
271                                        exitWithUsageMessage(applicationName);
272                                }
273                                arg = args[++i];
274                                outputDirectory = arg + "/";
275                        }
276                        else if(!inputDirectoryFound) {
277                                testDirectoryName = arg;
278                       
279                                if (! new File(testDirectoryName).isDirectory()) {
280                                        System.err.println("Input directory does not exist.");
281                                        exitWithUsageMessage(applicationName);
282                                }
283                       
284                                inputDirectoryFound = true;
285                        }
286                        else {
287                                exitWithUsageMessage(applicationName);
288                        }                       
289                }
290        }
291       
292        private static void exitWithUsageMessage(String applicationName) {
293                System.err.println("usage: " + applicationName + " inputDirectory [-o outputDirectory]");
294                System.exit(EXIT_CODE_FOR_ERROR);
295        }       
296
297        public static ArrayList<File> matchFiles(File file, String suffix) {
298               
299                ArrayList<File> list = new ArrayList<File>();
300               
301                if(file.isFile() &&  file.getName().endsWith(suffix)) {
302                        list.add(file);
303                        return list;
304                }
305               
306                if(file.isDirectory()) {
307                        File [] files = file.listFiles();
308                        for(File f : file.listFiles()) {
309                                list.addAll(matchFiles(f, suffix));
310                        }
311                }
312                       
313                return list;
314        }       
315       
316}
317
Note: See TracBrowser for help on using the repository browser.