TokenStreamRewriterTest source code

1 module TokenStreamRewriterTest;
2 
3 version(unittest) {
4 
5     import RuleTranslatorLexer;
6     import RuleTranslatorParser: RuleTranslatorParser;
7     import RuleTranslatorBaseListener;
8     import antlr.v4.runtime.ANTLRInputStream;
9     import antlr.v4.runtime.CommonToken;
10     import antlr.v4.runtime.CommonTokenStream;
11     import antlr.v4.runtime.TokenStream;
12     import antlr.v4.runtime.DiagnosticErrorListener;
13     import antlr.v4.runtime.LexerNoViableAltException;
14     import antlr.v4.runtime.Token;
15     import antlr.v4.runtime.TokenStreamRewriter : TokenStreamRewriter;
16     import antlr.v4.runtime.atn.ParserATNSimulator;
17     import antlr.v4.runtime.tree.ParseTreeWalker;
18     import dshould : be, equal, not, should;
19     import dshould.thrown;
20     import std.conv : to;
21     import std.stdio : File, writefln;
22     import std.file;
23     import unit_threaded;
24 
25     public class InsertTestListenerReplace : RuleTranslatorBaseListener {
26 			
27         TokenStreamRewriter rewriter;
28 			
29         this(TokenStream tokens)
30         {
31             rewriter = new TokenStreamRewriter(tokens);
32         }
33         /**
34          * <p>The default implementation does nothing.</p>
35          */
36         override public void enterFile_input(RuleTranslatorParser.File_inputContext ctx) {
37             writefln("enterFile");
38         }
39         /**
40 	 * {@inheritDoc}
41 	 *
42 	 * <p>The default implementation does nothing.</p>
43 	 */
44 	override public void exitStmt(RuleTranslatorParser.StmtContext ctx) {
45             debug(TokenStreamRewriter) {
46                 import std.stdio : writefln;
47                 writefln("exitStmt ctx.start = %s", ctx.start);
48             }
49             rewriter.replace(ctx.start, ctx.stop, "gamma");
50         }
51     }
52     
53     public class InsertTestListenerDelete : RuleTranslatorBaseListener {
54 			
55         TokenStreamRewriter rewriter;
56 			
57         this(TokenStream tokens)
58         {
59             rewriter = new TokenStreamRewriter(tokens);
60         }
61         /**
62          * <p>The default implementation does nothing.</p>
63          */
64         override public void enterFile_input(RuleTranslatorParser.File_inputContext ctx) {
65             writefln("enterFile");
66         }
67         /**
68 	 * {@inheritDoc}
69 	 *
70 	 * <p>The default implementation does nothing.</p>
71 	 */
72 	override public void exitStmt(RuleTranslatorParser.StmtContext ctx) {
73             debug(TokenStreamRewriter) {
74                 import std.stdio : writefln;
75                 writefln("exitStmt ctx.start = %s", ctx.start);
76             }
77             rewriter.deleteT(ctx.start, ctx.stop);
78         }
79     }
80     
81     public class InsertTestListener : RuleTranslatorBaseListener {
82 			
83         TokenStreamRewriter rewriter;
84 			
85         this(TokenStream tokens)
86         {
87             rewriter = new TokenStreamRewriter(tokens);
88         }
89         /**
90          * <p>The default implementation does nothing.</p>
91          */
92         override public void enterFile_input(RuleTranslatorParser.File_inputContext ctx) {
93             writefln("enterFile");
94         }
95         /**
96 	 * {@inheritDoc}
97 	 *
98 	 * <p>The default implementation does nothing.</p>
99 	 */
100 	override public void exitStmt(RuleTranslatorParser.StmtContext ctx) {
101             auto str = "alpha";
102             rewriter.insertAfter(ctx.start, "beta");
103             rewriter.insertBefore(ctx.start, str);
104         }
105     }
106         
107     class Test {
108         @Tags("TokenStreamRewriter")
109         @("replace")
110         unittest {
111             auto input =
112                 `# Text definition DEFAS
113 # for automatic announcements
114 # Version 2018-02-21
115 
116 rule Delay as DELAY de
117 base de.Phrases
118 
119 "Information zu"
120 `
121                 ;
122 
123             auto expected =
124                 `
125 ruleDelayasDELAYde
126 basede.Phrases
127 gamma`;
128 
129             auto antlrInput = new ANTLRInputStream(input);
130             auto lexer = new RuleTranslatorLexer(antlrInput);
131             auto cts = new CommonTokenStream(lexer);
132             cts.fill;
133             auto tokens = cts.getTokens;
134             foreach (i, t; tokens) {
135                 writefln("token %s: %s", i, t);
136             }
137             cts.getNumberOfOnChannelTokens.should.equal(15);
138             auto parser = new RuleTranslatorParser(cts);
139             // Specify entry point
140             auto rootContext = parser.file_input;
141             parser.numberOfSyntaxErrors.should.equal(0);
142             auto extractor = new InsertTestListenerReplace(cts);
143             auto walker = new ParseTreeWalker;
144             walker.walk(extractor, rootContext);
145             auto str = extractor.rewriter.getText;        
146             str.should.equal(expected);
147         }
148 
149         @Tags("TokenStreamRewriter")
150         @("insert after and before")
151         unittest {
152             auto input =
153                 `# Text definition DEFAS
154 # for automatic announcements
155 # Version 2018-02-21
156 
157 rule Delay as DELAY de
158 base de.Phrases
159 
160 "Information zu"
161 `
162                 ;
163 
164             auto expected =
165                 `
166 ruleDelayasDELAYde
167 basede.Phrases
168 alpha"Information zu"beta
169 `;
170 
171             auto antlrInput = new ANTLRInputStream(input);
172             auto lexer = new RuleTranslatorLexer(antlrInput);
173             auto cts = new CommonTokenStream(lexer);
174             cts.fill;
175             auto tokens = cts.getTokens;
176             foreach (i, t; tokens) {
177                 writefln("token %s: %s", i, t);
178             }
179             cts.getNumberOfOnChannelTokens.should.equal(15);
180             auto parser = new RuleTranslatorParser(cts);
181             // Specify entry point
182             auto rootContext = parser.file_input;
183             parser.numberOfSyntaxErrors.should.equal(0);
184             auto extractor = new InsertTestListener(cts);
185             auto walker = new ParseTreeWalker;
186             walker.walk(extractor, rootContext);
187             auto str = extractor.rewriter.getText;        
188             str.should.equal(expected);
189         }
190     }
191     @Tags("TokenStreamRewriter")
192         @("deleteT")
193         unittest {
194             auto input =
195                 `# Text definition DEFAS
196 # for automatic announcements
197 # Version 2018-02-21
198 
199 rule Delay as DELAY de
200 base de.Phrases
201 
202 "Information zu"
203 `
204                 ;
205 
206             auto expected =
207                 `
208 ruleDelayasDELAYde
209 basede.Phrases
210 `;
211 
212             auto antlrInput = new ANTLRInputStream(input);
213             auto lexer = new RuleTranslatorLexer(antlrInput);
214             auto cts = new CommonTokenStream(lexer);
215             cts.fill;
216             auto tokens = cts.getTokens;
217             foreach (i, t; tokens) {
218                 writefln("token %s: %s", i, t);
219             }
220             cts.getNumberOfOnChannelTokens.should.equal(15);
221             auto parser = new RuleTranslatorParser(cts);
222             // Specify entry point
223             auto rootContext = parser.file_input;
224             parser.numberOfSyntaxErrors.should.equal(0);
225             auto extractor = new InsertTestListenerDelete(cts);
226             auto walker = new ParseTreeWalker;
227             walker.walk(extractor, rootContext);
228             auto str = extractor.rewriter.getText;        
229             str.should.equal(expected);
230         }
231 }