ANTLR API: /Users/parrt/antlr/code/antlr/main/runtime/CSharp/Sources/Antlr3.Runtime.Tests/ITreeNodeStreamFixture.cs Source File

00001 /*
00002 [The "BSD licence"]
00003 Copyright (c) 2005-2007 Kunle Odutola
00004 All rights reserved.
00005 
00006 Redistribution and use in source and binary forms, with or without
00007 modification, are permitted provided that the following conditions
00008 are met:
00009 1. Redistributions of source code MUST RETAIN the above copyright
00010    notice, this list of conditions and the following disclaimer.
00011 2. Redistributions in binary form MUST REPRODUCE the above copyright
00012    notice, this list of conditions and the following disclaimer in 
00013    the documentation and/or other materials provided with the 
00014    distribution.
00015 3. The name of the author may not be used to endorse or promote products
00016    derived from this software without specific prior WRITTEN permission.
00017 4. Unless explicitly state otherwise, any contribution intentionally 
00018    submitted for inclusion in this work to the copyright owner or licensor
00019    shall be under the terms and conditions of this license, without any 
00020    additional terms or conditions.
00021 
00022 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
00023 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
00024 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
00025 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
00026 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
00027 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
00028 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
00029 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
00030 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
00031 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00032 */
00033 
00034 
00035 namespace Antlr.Runtime.Tests
00036 {
00037         using System;
00038         using StringBuilder = System.Text.StringBuilder;
00039 
00040         using IToken = Antlr.Runtime.IToken;
00041         using Token = Antlr.Runtime.Token;
00042         using CommonToken = Antlr.Runtime.CommonToken;
00043         using ITree = Antlr.Runtime.Tree.ITree;
00044         using ITreeNodeStream = Antlr.Runtime.Tree.ITreeNodeStream;
00045         using CommonTree = Antlr.Runtime.Tree.CommonTree;
00046         using CommonTreeNodeStream = Antlr.Runtime.Tree.CommonTreeNodeStream;
00047         using UnBufferedTreeNodeStream = Antlr.Runtime.Tree.UnBufferedTreeNodeStream;
00048 
00049         using MbUnit.Framework;
00050 
00051         [TestFixture]
00052         public class ITreeNodeStreamFixture : TestFixtureBase
00053         {
00054                 #region CommonTreeNodeStream Tests
00055 
00056                 [Test]
00057                 public void testSingleNode()
00058                 {
00059                         ITree t = new CommonTree(new CommonToken(101));
00060 
00061                         ITreeNodeStream stream = CreateCommonTreeNodeStream(t);
00062                         string expected = " 101";
00063                         string actual = GetStringOfEntireStreamContentsWithNodeTypesOnly(stream);
00064                         Assert.AreEqual(expected, actual);
00065 
00066                         expected = " 101";
00067                         actual = stream.ToString();
00068                         Assert.AreEqual(expected, actual);
00069                 }
00070 
00071                 [Test]
00075                 public void test4Nodes()
00076                 {
00077                         ITree t = new CommonTree(new CommonToken(101));
00078                         t.AddChild(new CommonTree(new CommonToken(102)));
00079                         t.GetChild(0).AddChild(new CommonTree(new CommonToken(103)));
00080                         t.AddChild(new CommonTree(new CommonToken(104)));
00081 
00082                         ITreeNodeStream stream = CreateCommonTreeNodeStream(t);
00083                         string expected = " 101 102 103 104";
00084                         string actual = GetStringOfEntireStreamContentsWithNodeTypesOnly(stream);
00085                         Assert.AreEqual(expected, actual);
00086 
00087                         expected = " 101 2 102 2 103 3 104 3";
00088                         actual = stream.ToString();
00089                         Assert.AreEqual(expected, actual);
00090                 }
00091 
00092                 [Test]
00093                 public void testList()
00094                 {
00095                         ITree root = new CommonTree((IToken)null);
00096 
00097                         ITree t = new CommonTree(new CommonToken(101));
00098                         t.AddChild(new CommonTree(new CommonToken(102)));
00099                         t.GetChild(0).AddChild(new CommonTree(new CommonToken(103)));
00100                         t.AddChild(new CommonTree(new CommonToken(104)));
00101 
00102                         ITree u = new CommonTree(new CommonToken(105));
00103 
00104                         root.AddChild(t);
00105                         root.AddChild(u);
00106 
00107                         CommonTreeNodeStream stream = new CommonTreeNodeStream(root);
00108                         string expected = " 101 102 103 104 105";
00109                         string actual = GetStringOfEntireStreamContentsWithNodeTypesOnly(stream);
00110                         Assert.AreEqual(expected, actual);
00111 
00112                         expected = " 101 2 102 2 103 3 104 3 105";
00113                         actual = stream.ToString();
00114                         Assert.AreEqual(expected, actual);
00115                 }
00116 
00117                 [Test]
00118                 public void testFlatList()
00119                 {
00120                         ITree root = new CommonTree((IToken)null);
00121 
00122                         root.AddChild(new CommonTree(new CommonToken(101)));
00123                         root.AddChild(new CommonTree(new CommonToken(102)));
00124                         root.AddChild(new CommonTree(new CommonToken(103)));
00125 
00126                         CommonTreeNodeStream stream = new CommonTreeNodeStream(root);
00127                         string expected = " 101 102 103";
00128                         string actual = GetStringOfEntireStreamContentsWithNodeTypesOnly(stream);
00129                         Assert.AreEqual(expected, actual);
00130 
00131                         expected = " 101 102 103";
00132                         actual = stream.ToString();
00133                         Assert.AreEqual(expected, actual);
00134                 }
00135 
00136                 [Test]
00137                 public void testListWithOneNode()
00138                 {
00139                         ITree root = new CommonTree((IToken)null);
00140 
00141                         root.AddChild(new CommonTree(new CommonToken(101)));
00142 
00143                         CommonTreeNodeStream stream = new CommonTreeNodeStream(root);
00144                         string expected = " 101";
00145                         string actual = GetStringOfEntireStreamContentsWithNodeTypesOnly(stream);
00146                         Assert.AreEqual(expected, actual);
00147 
00148                         expected = " 101";
00149                         actual = stream.ToString();
00150                         Assert.AreEqual(expected, actual);
00151                 }
00152 
00153                 [Test]
00154                 public void testAoverB()
00155                 {
00156                         ITree t = new CommonTree(new CommonToken(101));
00157                         t.AddChild(new CommonTree(new CommonToken(102)));
00158 
00159                         ITreeNodeStream stream = CreateCommonTreeNodeStream(t);
00160                         string expected = " 101 102";
00161                         string actual = GetStringOfEntireStreamContentsWithNodeTypesOnly(stream);
00162                         Assert.AreEqual(expected, actual);
00163 
00164                         expected = " 101 2 102 3";
00165                         actual = stream.ToString();
00166                         Assert.AreEqual(expected, actual);
00167                 }
00168 
00169                 [Test]
00170                 public void testLT()
00171                 {
00172                         // ^(101 ^(102 103) 104)
00173                         ITree t = new CommonTree(new CommonToken(101));
00174                         t.AddChild(new CommonTree(new CommonToken(102)));
00175                         t.GetChild(0).AddChild(new CommonTree(new CommonToken(103)));
00176                         t.AddChild(new CommonTree(new CommonToken(104)));
00177 
00178                         ITreeNodeStream stream = CreateCommonTreeNodeStream(t);
00179                         Assert.AreEqual(101, ((ITree)stream.LT(1)).Type);
00180                         Assert.AreEqual(Token.DOWN, ((ITree)stream.LT(2)).Type);
00181                         Assert.AreEqual(102, ((ITree)stream.LT(3)).Type);
00182                         Assert.AreEqual(Token.DOWN, ((ITree)stream.LT(4)).Type);
00183                         Assert.AreEqual(103, ((ITree)stream.LT(5)).Type);
00184                         Assert.AreEqual(Token.UP, ((ITree)stream.LT(6)).Type);
00185                         Assert.AreEqual(104, ((ITree)stream.LT(7)).Type);
00186                         Assert.AreEqual(Token.UP, ((ITree)stream.LT(8)).Type);
00187                         Assert.AreEqual(Token.EOF, ((ITree)stream.LT(9)).Type);
00188                         // check way ahead
00189                         Assert.AreEqual(Token.EOF, ((ITree)stream.LT(100)).Type);
00190                 }
00191 
00192                 [Test]
00193                 public void testMarkRewindEntire()
00194                 {
00195                         // ^(101 ^(102 103 ^(106 107) ) 104 105)
00196                         // stream has 7 real + 6 nav nodes
00197                         // Sequence of types: 101 DN 102 DN 103 106 DN 107 UP UP 104 105 UP EOF
00198                         ITree r0 = new CommonTree(new CommonToken(101));
00199                         ITree r1 = new CommonTree(new CommonToken(102));
00200                         r0.AddChild(r1);
00201                         r1.AddChild(new CommonTree(new CommonToken(103)));
00202                         ITree r2 = new CommonTree(new CommonToken(106));
00203                         r2.AddChild(new CommonTree(new CommonToken(107)));
00204                         r1.AddChild(r2);
00205                         r0.AddChild(new CommonTree(new CommonToken(104)));
00206                         r0.AddChild(new CommonTree(new CommonToken(105)));
00207 
00208                         CommonTreeNodeStream stream = new CommonTreeNodeStream(r0);
00209                         int m = stream.Mark(); // MARK
00210                         for (int k = 1; k <= 13; k++)
00211                         { // consume til end
00212                                 stream.LT(1);
00213                                 stream.Consume();
00214                         }
00215                         Assert.AreEqual(Token.EOF, ((ITree)stream.LT(1)).Type);
00216                         Assert.AreEqual(Token.UP, ((ITree)stream.LT(-1)).Type);
00217                         stream.Rewind(m);      // REWIND
00218 
00219                         // consume til end again :)
00220                         for (int k = 1; k <= 13; k++)
00221                         { // consume til end
00222                                 stream.LT(1);
00223                                 stream.Consume();
00224                         }
00225                         Assert.AreEqual(Token.EOF, ((ITree)stream.LT(1)).Type);
00226                         Assert.AreEqual(Token.UP, ((ITree)stream.LT(-1)).Type);
00227                 }
00228 
00229                 [Test]
00230                 public void testMarkRewindInMiddle()
00231                 {
00232                         // ^(101 ^(102 103 ^(106 107) ) 104 105)
00233                         // stream has 7 real + 6 nav nodes
00234                         // Sequence of types: 101 DN 102 DN 103 106 DN 107 UP UP 104 105 UP EOF
00235                         ITree r0 = new CommonTree(new CommonToken(101));
00236                         ITree r1 = new CommonTree(new CommonToken(102));
00237                         r0.AddChild(r1);
00238                         r1.AddChild(new CommonTree(new CommonToken(103)));
00239                         ITree r2 = new CommonTree(new CommonToken(106));
00240                         r2.AddChild(new CommonTree(new CommonToken(107)));
00241                         r1.AddChild(r2);
00242                         r0.AddChild(new CommonTree(new CommonToken(104)));
00243                         r0.AddChild(new CommonTree(new CommonToken(105)));
00244 
00245                         CommonTreeNodeStream stream = new CommonTreeNodeStream(r0);
00246                         for (int k = 1; k <= 7; k++)
00247                         { // consume til middle
00248                                 //System.out.println(((ITree)stream.LT(1)).Type);
00249                                 stream.Consume();
00250                         }
00251                         Assert.AreEqual(107, ((ITree)stream.LT(1)).Type);
00252                         int m = stream.Mark(); // MARK
00253                         stream.Consume(); // consume 107
00254                         stream.Consume(); // consume UP
00255                         stream.Consume(); // consume UP
00256                         stream.Consume(); // consume 104
00257                         stream.Rewind(m);      // REWIND
00258 
00259                         Assert.AreEqual(107, ((ITree)stream.LT(1)).Type);
00260                         stream.Consume();
00261                         Assert.AreEqual(Token.UP, ((ITree)stream.LT(1)).Type);
00262                         stream.Consume();
00263                         Assert.AreEqual(Token.UP, ((ITree)stream.LT(1)).Type);
00264                         stream.Consume();
00265                         Assert.AreEqual(104, ((ITree)stream.LT(1)).Type);
00266                         stream.Consume();
00267                         // now we're past rewind position
00268                         Assert.AreEqual(105, ((ITree)stream.LT(1)).Type);
00269                         stream.Consume();
00270                         Assert.AreEqual(Token.UP, ((ITree)stream.LT(1)).Type);
00271                         stream.Consume();
00272                         Assert.AreEqual(Token.EOF, ((ITree)stream.LT(1)).Type);
00273                         Assert.AreEqual(Token.UP, ((ITree)stream.LT(-1)).Type);
00274                 }
00275 
00276                 [Test]
00277                 public void testMarkRewindNested()
00278                 {
00279                         // ^(101 ^(102 103 ^(106 107) ) 104 105)
00280                         // stream has 7 real + 6 nav nodes
00281                         // Sequence of types: 101 DN 102 DN 103 106 DN 107 UP UP 104 105 UP EOF
00282                         ITree r0 = new CommonTree(new CommonToken(101));
00283                         ITree r1 = new CommonTree(new CommonToken(102));
00284                         r0.AddChild(r1);
00285                         r1.AddChild(new CommonTree(new CommonToken(103)));
00286                         ITree r2 = new CommonTree(new CommonToken(106));
00287                         r2.AddChild(new CommonTree(new CommonToken(107)));
00288                         r1.AddChild(r2);
00289                         r0.AddChild(new CommonTree(new CommonToken(104)));
00290                         r0.AddChild(new CommonTree(new CommonToken(105)));
00291 
00292                         CommonTreeNodeStream stream = new CommonTreeNodeStream(r0);
00293                         int m = stream.Mark(); // MARK at start
00294                         stream.Consume(); // consume 101
00295                         stream.Consume(); // consume DN
00296                         int m2 = stream.Mark(); // MARK on 102
00297                         stream.Consume(); // consume 102
00298                         stream.Consume(); // consume DN
00299                         stream.Consume(); // consume 103
00300                         stream.Consume(); // consume 106
00301                         stream.Rewind(m2);      // REWIND to 102
00302                         Assert.AreEqual(102, ((ITree)stream.LT(1)).Type);
00303                         stream.Consume();
00304                         Assert.AreEqual(Token.DOWN, ((ITree)stream.LT(1)).Type);
00305                         stream.Consume();
00306                         // stop at 103 and rewind to start
00307                         stream.Rewind(m); // REWIND to 101
00308                         Assert.AreEqual(101, ((ITree)stream.LT(1)).Type);
00309                         stream.Consume();
00310                         Assert.AreEqual(Token.DOWN, ((ITree)stream.LT(1)).Type);
00311                         stream.Consume();
00312                         Assert.AreEqual(102, ((ITree)stream.LT(1)).Type);
00313                         stream.Consume();
00314                         Assert.AreEqual(Token.DOWN, ((ITree)stream.LT(1)).Type);
00315                 }
00316 
00317                 [Test]
00318                 public void testSeek()
00319                 {
00320                         // ^(101 ^(102 103 ^(106 107) ) 104 105)
00321                         // stream has 7 real + 6 nav nodes
00322                         // Sequence of types: 101 DN 102 DN 103 106 DN 107 UP UP 104 105 UP EOF
00323                         ITree r0 = new CommonTree(new CommonToken(101));
00324                         ITree r1 = new CommonTree(new CommonToken(102));
00325                         r0.AddChild(r1);
00326                         r1.AddChild(new CommonTree(new CommonToken(103)));
00327                         ITree r2 = new CommonTree(new CommonToken(106));
00328                         r2.AddChild(new CommonTree(new CommonToken(107)));
00329                         r1.AddChild(r2);
00330                         r0.AddChild(new CommonTree(new CommonToken(104)));
00331                         r0.AddChild(new CommonTree(new CommonToken(105)));
00332 
00333                         CommonTreeNodeStream stream = new CommonTreeNodeStream(r0);
00334                         stream.Consume(); // consume 101
00335                         stream.Consume(); // consume DN
00336                         stream.Consume(); // consume 102
00337                         stream.Seek(7);   // seek to 107
00338                         Assert.AreEqual(107, ((ITree)stream.LT(1)).Type);
00339                         stream.Consume(); // consume 107
00340                         stream.Consume(); // consume UP
00341                         stream.Consume(); // consume UP
00342                         Assert.AreEqual(104, ((ITree)stream.LT(1)).Type);
00343                 }
00344 
00345                 [Test]
00346                 public void testSeekFromStart()
00347                 {
00348                         // ^(101 ^(102 103 ^(106 107) ) 104 105)
00349                         // stream has 7 real + 6 nav nodes
00350                         // Sequence of types: 101 DN 102 DN 103 106 DN 107 UP UP 104 105 UP EOF
00351                         ITree r0 = new CommonTree(new CommonToken(101));
00352                         ITree r1 = new CommonTree(new CommonToken(102));
00353                         r0.AddChild(r1);
00354                         r1.AddChild(new CommonTree(new CommonToken(103)));
00355                         ITree r2 = new CommonTree(new CommonToken(106));
00356                         r2.AddChild(new CommonTree(new CommonToken(107)));
00357                         r1.AddChild(r2);
00358                         r0.AddChild(new CommonTree(new CommonToken(104)));
00359                         r0.AddChild(new CommonTree(new CommonToken(105)));
00360 
00361                         CommonTreeNodeStream stream = new CommonTreeNodeStream(r0);
00362                         stream.Seek(7);   // seek to 107
00363                         Assert.AreEqual(107, ((ITree)stream.LT(1)).Type);
00364                         stream.Consume(); // consume 107
00365                         stream.Consume(); // consume UP
00366                         stream.Consume(); // consume UP
00367                         Assert.AreEqual(104, ((ITree)stream.LT(1)).Type);
00368                 }
00369 
00370                 [Test]
00371                 public void testPushPop()
00372                 {
00373                         // ^(101 ^(102 103) ^(104 105) ^(106 107) 108 109)
00374                         // stream has 9 real + 8 nav nodes
00375                         // Sequence of types: 101 DN 102 DN 103 UP 104 DN 105 UP 106 DN 107 UP 108 109 UP
00376                         ITree r0 = new CommonTree(new CommonToken(101));
00377                         ITree r1 = new CommonTree(new CommonToken(102));
00378                         r1.AddChild(new CommonTree(new CommonToken(103)));
00379                         r0.AddChild(r1);
00380                         ITree r2 = new CommonTree(new CommonToken(104));
00381                         r2.AddChild(new CommonTree(new CommonToken(105)));
00382                         r0.AddChild(r2);
00383                         ITree r3 = new CommonTree(new CommonToken(106));
00384                         r3.AddChild(new CommonTree(new CommonToken(107)));
00385                         r0.AddChild(r3);
00386                         r0.AddChild(new CommonTree(new CommonToken(108)));
00387                         r0.AddChild(new CommonTree(new CommonToken(109)));
00388 
00389                         CommonTreeNodeStream stream = new CommonTreeNodeStream(r0);
00390                         String expecting = " 101 2 102 2 103 3 104 2 105 3 106 2 107 3 108 109 3";
00391                         String found = stream.ToString();
00392                         Assert.AreEqual(expecting, found);
00393 
00394                         // Assume we want to hit node 107 and then "call 102" then return
00395 
00396                         int indexOf102 = 2;
00397                         int indexOf107 = 12;
00398                         for (int k = 1; k <= indexOf107; k++)
00399                         { // consume til 107 node
00400                                 stream.Consume();
00401                         }
00402                         // CALL 102
00403                         Assert.AreEqual(107, ((ITree)stream.LT(1)).Type);
00404                         stream.Push(indexOf102);
00405                         Assert.AreEqual(102, ((ITree)stream.LT(1)).Type);
00406                         stream.Consume(); // consume 102
00407                         Assert.AreEqual(Token.DOWN, ((ITree)stream.LT(1)).Type);
00408                         stream.Consume(); // consume DN
00409                         Assert.AreEqual(103, ((ITree)stream.LT(1)).Type);
00410                         stream.Consume(); // consume 103
00411                         Assert.AreEqual(Token.UP, ((ITree)stream.LT(1)).Type);
00412                         // RETURN
00413                         stream.Pop();
00414                         Assert.AreEqual(107, ((ITree)stream.LT(1)).Type);
00415                 }
00416 
00417                 [Test]
00418                 public void testNestedPushPop()
00419                 {
00420                         // ^(101 ^(102 103) ^(104 105) ^(106 107) 108 109)
00421                         // stream has 9 real + 8 nav nodes
00422                         // Sequence of types: 101 DN 102 DN 103 UP 104 DN 105 UP 106 DN 107 UP 108 109 UP
00423                         ITree r0 = new CommonTree(new CommonToken(101));
00424                         ITree r1 = new CommonTree(new CommonToken(102));
00425                         r1.AddChild(new CommonTree(new CommonToken(103)));
00426                         r0.AddChild(r1);
00427                         ITree r2 = new CommonTree(new CommonToken(104));
00428                         r2.AddChild(new CommonTree(new CommonToken(105)));
00429                         r0.AddChild(r2);
00430                         ITree r3 = new CommonTree(new CommonToken(106));
00431                         r3.AddChild(new CommonTree(new CommonToken(107)));
00432                         r0.AddChild(r3);
00433                         r0.AddChild(new CommonTree(new CommonToken(108)));
00434                         r0.AddChild(new CommonTree(new CommonToken(109)));
00435 
00436                         CommonTreeNodeStream stream = new CommonTreeNodeStream(r0);
00437 
00438                         // Assume we want to hit node 107 and then "call 102", which
00439                         // calls 104, then return
00440 
00441                         int indexOf102 = 2;
00442                         int indexOf107 = 12;
00443                         for (int k = 1; k <= indexOf107; k++)
00444                         { // consume til 107 node
00445                                 stream.Consume();
00446                         }
00447                         Assert.AreEqual(107, ((ITree)stream.LT(1)).Type);
00448                         // CALL 102
00449                         stream.Push(indexOf102);
00450                         Assert.AreEqual(102, ((ITree)stream.LT(1)).Type);
00451                         stream.Consume(); // consume 102
00452                         Assert.AreEqual(Token.DOWN, ((ITree)stream.LT(1)).Type);
00453                         stream.Consume(); // consume DN
00454                         Assert.AreEqual(103, ((ITree)stream.LT(1)).Type);
00455                         stream.Consume(); // consume 103
00456 
00457                         // CALL 104
00458                         int indexOf104 = 6;
00459                         stream.Push(indexOf104);
00460                         Assert.AreEqual(104, ((ITree)stream.LT(1)).Type);
00461                         stream.Consume(); // consume 102
00462                         Assert.AreEqual(Token.DOWN, ((ITree)stream.LT(1)).Type);
00463                         stream.Consume(); // consume DN
00464                         Assert.AreEqual(105, ((ITree)stream.LT(1)).Type);
00465                         stream.Consume(); // consume 103
00466                         Assert.AreEqual(Token.UP, ((ITree)stream.LT(1)).Type);
00467                         // RETURN (to UP node in 102 subtree)
00468                         stream.Pop();
00469 
00470                         Assert.AreEqual(Token.UP, ((ITree)stream.LT(1)).Type);
00471                         // RETURN (to empty stack)
00472                         stream.Pop();
00473                         Assert.AreEqual(107, ((ITree)stream.LT(1)).Type);
00474                 }
00475 
00476                 [Test]
00477                 public void testPushPopFromEOF()
00478                 {
00479                         // ^(101 ^(102 103) ^(104 105) ^(106 107) 108 109)
00480                         // stream has 9 real + 8 nav nodes
00481                         // Sequence of types: 101 DN 102 DN 103 UP 104 DN 105 UP 106 DN 107 UP 108 109 UP
00482                         ITree r0 = new CommonTree(new CommonToken(101));
00483                         ITree r1 = new CommonTree(new CommonToken(102));
00484                         r1.AddChild(new CommonTree(new CommonToken(103)));
00485                         r0.AddChild(r1);
00486                         ITree r2 = new CommonTree(new CommonToken(104));
00487                         r2.AddChild(new CommonTree(new CommonToken(105)));
00488                         r0.AddChild(r2);
00489                         ITree r3 = new CommonTree(new CommonToken(106));
00490                         r3.AddChild(new CommonTree(new CommonToken(107)));
00491                         r0.AddChild(r3);
00492                         r0.AddChild(new CommonTree(new CommonToken(108)));
00493                         r0.AddChild(new CommonTree(new CommonToken(109)));
00494 
00495                         CommonTreeNodeStream stream = new CommonTreeNodeStream(r0);
00496 
00497                         while (stream.LA(1) != Token.EOF)
00498                         {
00499