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.file;
22     import std.variant;
23     import unit_threaded;
24 
25     public class InsertAt0TestListenerReplace : RuleTranslatorBaseListener {
26 
27         TokenStreamRewriter rewriter;
28         Token currentToken;
29 
30         this(TokenStream tokens)
31         {
32             rewriter = new TokenStreamRewriter(tokens);
33         }
34 
35         override public void enterFile_input(RuleTranslatorParser.File_inputContext ctx) {
36             currentToken = ctx.start;
37         }
38 
39         override public void exitStmt(RuleTranslatorParser.StmtContext ctx) {
40             debug(TokenStreamRewriter) {
41                 import std.stdio : writefln;
42                 writefln("exitStmt ctx.start = %s", ctx.start);
43             }
44             Variant parameter = "alpha";
45             rewriter.replace(currentToken, ctx.stop, parameter);
46         }
47     }
48 
49         public class InsertTestListenerReplace : RuleTranslatorBaseListener {
50 
51         TokenStreamRewriter rewriter;
52         Token currentToken;
53 
54         this(TokenStream tokens)
55         {
56             rewriter = new TokenStreamRewriter(tokens);
57         }
58 
59         override public void enterFile_input(RuleTranslatorParser.File_inputContext ctx) {
60             currentToken = ctx.start;
61         }
62 
63         override public void exitStmt(RuleTranslatorParser.StmtContext ctx) {
64             debug(TokenStreamRewriter) {
65                 import std.stdio : writefln;
66                 writefln("exitStmt ctx.start = %s", ctx.start);
67             }
68             Variant parameter = "gamma";
69             rewriter.replace(ctx.start, ctx.stop, parameter);
70         }
71     }
72 
73     public class InsertTestListenerDelete : RuleTranslatorBaseListener {
74 
75         TokenStreamRewriter rewriter;
76 
77         this(TokenStream tokens)
78         {
79             rewriter = new TokenStreamRewriter(tokens);
80         }
81 
82         /**
83          * {@inheritDoc}
84          *
85          * <p>The default implementation does nothing.</p>
86          */
87         override public void exitStmt(RuleTranslatorParser.StmtContext ctx) {
88             debug(TokenStreamRewriter) {
89                 import std.stdio : writefln;
90                 writefln("exitStmt ctx.start = %s", ctx.start);
91             }
92             rewriter.deleteT(ctx.start, ctx.stop);
93         }
94     }
95 
96     public class InsertTestListener : RuleTranslatorBaseListener {
97 
98         TokenStreamRewriter rewriter;
99 
100         this(TokenStream tokens)
101         {
102             rewriter = new TokenStreamRewriter(tokens);
103         }
104 
105         /**
106          * {@inheritDoc}struct Result { ushort indent; string text;}
107          *
108          * <p>The default implementation does nothing.</p>
109          */
110         override public void exitStmt(RuleTranslatorParser.StmtContext ctx) {
111             Variant str_a = "alpha";
112             Variant str_b = "beta";
113             rewriter.insertBefore(ctx.start, str_a);
114             rewriter.insertAfter(ctx.start, str_b);
115         }
116     }
117 
118     class Test {
119         @Tags("TokenStreamRewriter")
120         @("replace_and_delete")
121         unittest {
122             auto input =
123                 `# Text definition DEFAS
124 # for automatic announcements
125 # Version 2018-02-21
126 
127 rule Delay as DELAY de
128 base de.Phrases
129 
130 "Information zu"
131 `
132                 ;
133 
134             auto expected =
135                 `
136 ruleDelayasDELAYde
137 basede.Phrases
138 gamma`;
139 
140             auto antlrInput = new ANTLRInputStream(input);
141             auto lexer = new RuleTranslatorLexer(antlrInput);
142             auto cts = new CommonTokenStream(lexer);
143             cts.fill;
144             auto tokens = cts.getTokens;
145             cts.getNumberOfOnChannelTokens.should.equal(15);
146             auto parser = new RuleTranslatorParser(cts);
147             // Specify entry point
148             auto rootContext = parser.file_input;
149             parser.numberOfSyntaxErrors.should.equal(0);
150             auto extractor = new InsertTestListenerReplace(cts);
151             auto walker = new ParseTreeWalker;
152             walker.walk(extractor, rootContext);
153             auto str = extractor.rewriter.getText.get!(string);
154             str.should.equal(expected);
155             extractor.rewriter.deleteProgram;
156             str = extractor.rewriter.getText.get!(string);
157             expected =
158                 `
159 ruleDelayasDELAYde
160 basede.Phrases
161 "Information zu"
162 `;
163             str.should.equal(expected);
164         }
165 
166         @Tags("TokenStreamRewriter")
167         @("insert after and before")
168         unittest {
169             auto input =
170                 `# Text definition DEFAS
171 # for automatic announcements
172 # Version 2018-02-21
173 
174 rule Delay as DELAY de
175 base de.Phrases
176 
177 "Information zu"
178 `
179                 ;
180 
181             auto expected =
182                 `
183 ruleDelayasDELAYde
184 basede.Phrases
185 alpha"Information zu"beta
186 `;
187 
188             auto antlrInput = new ANTLRInputStream(input);
189             auto lexer = new RuleTranslatorLexer(antlrInput);
190             auto cts = new CommonTokenStream(lexer);
191             cts.fill;
192             auto tokens = cts.getTokens;
193             cts.getNumberOfOnChannelTokens.should.equal(15);
194             auto parser = new RuleTranslatorParser(cts);
195             // Specify entry point
196             auto rootContext = parser.file_input;
197             parser.numberOfSyntaxErrors.should.equal(0);
198             auto extractor = new InsertTestListener(cts);
199             auto walker = new ParseTreeWalker;
200             walker.walk(extractor, rootContext);
201             auto str = extractor.rewriter.getText.get!(string);
202             str.should.equal(expected);
203         }
204     }
205 
206     @Tags("TokenStreamRewriter")
207         @("deleteT")
208         unittest {
209             auto input =
210                 `# Text definition DEFAS
211 # for automatic announcements
212 # Version 2018-02-21
213 
214 rule Delay as DELAY de
215 base de.Phrases
216 
217 "Information zu"
218 `
219                 ;
220 
221             auto expected =
222                 `
223 ruleDelayasDELAYde
224 basede.Phrases
225 `;
226 
227             auto antlrInput = new ANTLRInputStream(input);
228             auto lexer = new RuleTranslatorLexer(antlrInput);
229             auto cts = new CommonTokenStream(lexer);
230             cts.fill;
231             auto tokens = cts.getTokens;
232             cts.getNumberOfOnChannelTokens.should.equal(15);
233             auto parser = new RuleTranslatorParser(cts);
234             // Specify entry point
235             auto rootContext = parser.file_input;
236             parser.numberOfSyntaxErrors.should.equal(0);
237             auto extractor = new InsertTestListenerDelete(cts);
238             auto walker = new ParseTreeWalker;
239             walker.walk(extractor, rootContext);
240             auto str = extractor.rewriter.getText.get!(string);
241             str.should.equal(expected);
242         }
243 
244         @Tags("TokenStreamRewriter")
245         @("replaceAt0")
246         unittest {
247             auto input =
248                 `# Text definition DEFAS
249 # for automatic announcements
250 # Version 2018-02-21
251 
252 rule Delay as DELAY de
253 base de.Phrases
254 
255 "Information zu"
256 `
257                 ;
258 
259             auto expected = "alpha";
260 
261             auto antlrInput = new ANTLRInputStream(input);
262             auto lexer = new RuleTranslatorLexer(antlrInput);
263             auto cts = new CommonTokenStream(lexer);
264             cts.fill;
265             auto tokens = cts.getTokens;
266             cts.getNumberOfOnChannelTokens.should.equal(15);
267             auto parser = new RuleTranslatorParser(cts);
268             // Specify entry point
269             auto rootContext = parser.file_input;
270             parser.numberOfSyntaxErrors.should.equal(0);
271             auto extractor = new InsertAt0TestListenerReplace(cts);
272             auto walker = new ParseTreeWalker;
273             walker.walk(extractor, rootContext);
274             auto str = extractor.rewriter.getText.get!(string);
275             str.should.equal(expected);
276         }
277 
278 }