nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/languagestyle/NEMOParse/NEMOparserTokenManagerTest.java

   1 /*\r
   2  * Copyright (c) 2015 Huawei, Inc. and others. All rights reserved.\r
   3  *\r
   4  * This program and the accompanying materials are made available under the\r
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html\r
   7  */\r
   8 /* Generated By:JavaCC: Do not edit this line. NEMOparserTokenManager.java */\r
   9 package org.opendaylight.nemo.user.vnspacemanager.languagestyle.NEMOParse;\r
  10 import junit.framework.TestCase;\r
  11 import org.junit.Assert;\r
  12 import org.junit.Before;\r
  13 import org.junit.BeforeClass;\r
  14 import org.junit.Test;\r
  15 import org.junit.runner.RunWith;\r
  16 import org.opendaylight.nemo.user.vnspacemanager.languagestyle.NEMOParse.NEMOparser;\r
  17 import org.opendaylight.nemo.user.vnspacemanager.languagestyle.NEMOParse.NEMOparserTokenManager;\r
  18 import org.opendaylight.nemo.user.vnspacemanager.languagestyle.NEMOParse.SimpleCharStream;\r
  19 import org.opendaylight.nemo.user.vnspacemanager.languagestyle.NEMOParse.Token;\r
  20 \r
  21 import java.io.IOException;\r
  22 import java.io.PrintStream;\r
  23 import java.io.Reader;\r
  24 import java.lang.reflect.Field;\r
  25 import java.lang.reflect.Member;\r
  26 import java.lang.reflect.Method;\r
  27 \r
  28 import static org.junit.Assert.*;\r
  29 import static org.mockito.Mockito.*;\r
  30 import org.powermock.api.mockito.PowerMockito;\r
  31 import org.powermock.api.support.membermodification.MemberMatcher;\r
  32 import org.powermock.api.support.membermodification.MemberModifier;\r
  33 import org.powermock.core.classloader.annotations.PrepareForTest;\r
  34 import org.powermock.modules.junit4.PowerMockRunner;\r
  35 /**\r
  36  * Created by zhangmeng on 2015/12/17.\r
  37  */\r
  38 @RunWith(PowerMockRunner.class)\r
  39 @PrepareForTest({NEMOparserTokenManager.class,SimpleCharStream.class})\r
  40 public class NEMOparserTokenManagerTest extends TestCase {\r
  41     private SimpleCharStream simpleCharStream;\r
  42     private int lexState;\r
  43     private NEMOparserTokenManager nemOparserTokenManager;\r
  44     private Class<NEMOparserTokenManager> class1;\r
  45     private Field field;\r
  46     @Before\r
  47     public void setUp() throws Exception {\r
  48         class1 = NEMOparserTokenManager.class;\r
  49         field = class1.getDeclaredField("input_stream");\r
  50         field.setAccessible(true);\r
  51         field.set(class1,null);\r
  52 \r
  53         simpleCharStream = mock(SimpleCharStream.class);\r
  54         lexState = 0;\r
  55     }\r
  56 \r
  57     @Test\r
  58     public void Init_ReInit() throws Exception{\r
  59         nemOparserTokenManager = new NEMOparserTokenManager(simpleCharStream);\r
  60         NEMOparserTokenManager.ReInit(null);\r
  61         nemOparserTokenManager = new NEMOparserTokenManager(simpleCharStream,lexState);//curLexstate = 0\r
  62         NEMOparserTokenManager.ReInit(null, lexState);\r
  63 \r
  64         Assert.assertTrue(field.get(class1) == null);\r
  65     }\r
  66 \r
  67     @Test\r
  68     public void testSetDebugStream() throws Exception {\r
  69         NEMOparserTokenManager.setDebugStream(null);\r
  70         Field field1 = class1.getField("debugStream");\r
  71         field1.setAccessible(true);\r
  72         Assert.assertTrue(field1.get(class1) == null);\r
  73     }\r
  74 \r
  75 \r
  76     @Test\r
  77     public void testJjFillToken() throws Exception {\r
  78         nemOparserTokenManager = new NEMOparserTokenManager(simpleCharStream);\r
  79         PowerMockito.mockStatic(SimpleCharStream.class);\r
  80         PowerMockito.when(SimpleCharStream.GetImage()).thenReturn("test");\r
  81         Assert.assertTrue(NEMOparserTokenManager.jjFillToken() != null);\r
  82     }\r
  83 \r
  84     @Test\r
  85     public void testGetNextToken() throws Exception {\r
  86         char curChar = 40;\r
  87         nemOparserTokenManager = new NEMOparserTokenManager(simpleCharStream);\r
  88         Assert.assertTrue(field.get(nemOparserTokenManager) == simpleCharStream);\r
  89         PowerMockito.mockStatic(SimpleCharStream.class);\r
  90         PowerMockito.when(SimpleCharStream.BeginToken()).thenReturn(curChar);\r
  91 //        System.out.println("out :" + NEMOparserTokenManager.getNextToken());\r
  92         Assert.assertTrue(NEMOparserTokenManager.getNextToken() != null);\r
  93     }\r
  94 \r
  95     @Test\r
  96     public void testjjStartNfa_0() throws Exception{\r
  97         Method method = class1.getDeclaredMethod("jjStartNfa_0",new Class[]{int.class,long.class});\r
  98         method.setAccessible(true);\r
  99         int pos = 1;\r
 100         long active0 = 1L;\r
 101 \r
 102         Assert.assertTrue((Integer) method.invoke(class1, pos, active0) == 3);\r
 103 //        System.out.println("method.invoke(class1,pos,active0):" + method.invoke(class1,pos,active0));\r
 104     }\r
 105 \r
 106     @Test\r
 107     public void testjjStopStringLiteralDfa_0() throws Exception{\r
 108         Method method = class1.getDeclaredMethod("jjStopStringLiteralDfa_0",new Class[]{\r
 109                 int.class,\r
 110                 long.class\r
 111         });\r
 112         method.setAccessible(true);\r
 113 //        System.out.println("testjjStopStringLiteralDfa_0" + method.invoke(class1, 0, 0));\r
 114         Assert.assertTrue((Integer) method.invoke(class1, 0, 0) == -1);\r
 115 //        System.out.println("testjjStopStringLiteralDfa_0" + method.invoke(class1, 0, 0x74800000000000L));\r
 116         Assert.assertTrue((Integer) method.invoke(class1, 0, 0x74800000000000L) == 205);\r
 117 //        System.out.println("testjjStopStringLiteralDfa_0" + method.invoke(class1, 0, 0x3000000000000L));\r
 118         Assert.assertTrue((Integer) method.invoke(class1, 0, 0x3000000000000L) == 81);\r
 119         //case1\r
 120         Assert.assertTrue((Integer) method.invoke(class1, 1, 0x77800000000000L) == 205);\r
 121         Assert.assertTrue((Integer) method.invoke(class1, 1, 0) == -1);\r
 122         //case2\r
 123         Assert.assertTrue((Integer) method.invoke(class1, 2, 0x77800000000000L) == 205);\r
 124         Assert.assertTrue((Integer) method.invoke(class1, 2, 0) == -1);\r
 125         //case3\r
 126         Assert.assertTrue((Integer) method.invoke(class1, 3, 0x77800000000000L) == 205);\r
 127         Assert.assertTrue((Integer) method.invoke(class1, 3, 0) == -1);\r
 128         //case4\r
 129         Assert.assertTrue((Integer) method.invoke(class1, 4, 0x35000000000000L) == 205);\r
 130         Assert.assertTrue((Integer) method.invoke(class1, 4, 0x42800000000000L) == 205);\r
 131         Assert.assertTrue((Integer) method.invoke(class1, 4, 0) == -1);\r
 132         //case5\r
 133         Assert.assertTrue((Integer) method.invoke(class1, 5, 0x25000000000000L) == 205);\r
 134         Assert.assertTrue((Integer) method.invoke(class1, 5, 0x10000000000000L) == 205);\r
 135         Assert.assertTrue((Integer) method.invoke(class1, 5, 0) == -1);\r
 136         //case6\r
 137         Assert.assertTrue((Integer) method.invoke(class1, 6, 0x5000000000000L) == 205);\r
 138         Assert.assertTrue((Integer) method.invoke(class1, 6, 0x20000000000000L) == 205);\r
 139         Assert.assertTrue((Integer) method.invoke(class1, 6, 0) == -1);\r
 140         //case7\r
 141         Assert.assertTrue((Integer) method.invoke(class1, 7, 0x5000000000000L) == 205);\r
 142         Assert.assertTrue((Integer) method.invoke(class1, 7, 0) == -1);\r
 143         //case8\r
 144         Assert.assertTrue((Integer) method.invoke(class1, 8, 0x5000000000000L) == 205);\r
 145         Assert.assertTrue((Integer) method.invoke(class1, 8, 0) == -1);\r
 146         //case9\r
 147         Assert.assertTrue((Integer) method.invoke(class1, 9, 0x4000000000000L) == 205);\r
 148         Assert.assertTrue((Integer) method.invoke(class1, 9, 0x1000000000000L) == 205);\r
 149         Assert.assertTrue((Integer) method.invoke(class1, 9, 0) == -1);\r
 150         //case default\r
 151         Assert.assertTrue((Integer) method.invoke(class1, 10, 0) == -1);\r
 152 \r
 153     }\r
 154 \r
 155     @Test\r
 156     public void testjjStopAtPos() throws Exception{\r
 157         Method method = class1.getDeclaredMethod("jjStopAtPos",new Class[]{\r
 158                 int.class,\r
 159                 int.class\r
 160         });\r
 161         method.setAccessible(true);\r
 162 \r
 163         Assert.assertTrue((Integer) method.invoke(class1,1,1) == 2);\r
 164     }\r
 165 \r
 166     @Test\r
 167     public void testjjMoveStringLiteralDfa0_0() throws Exception{\r
 168         Method method = class1.getDeclaredMethod("jjMoveStringLiteralDfa0_0");\r
 169         method.setAccessible(true);\r
 170         Field field = class1.getDeclaredField("curChar");\r
 171         field.setAccessible(true);\r
 172 \r
 173         PowerMockito.mockStatic(SimpleCharStream.class);\r
 174         PowerMockito.when(SimpleCharStream.readChar()).thenReturn((char) 0);\r
 175 \r
 176         NEMOparserTokenManager.curChar = 33;\r
 177 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 178         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 179         NEMOparserTokenManager.curChar = 38;\r
 180 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 181         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 182         NEMOparserTokenManager.curChar = 40;\r
 183 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 184         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 185         NEMOparserTokenManager.curChar = 41;\r
 186 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 187         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 188         NEMOparserTokenManager.curChar = 42;\r
 189 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 190         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 191         NEMOparserTokenManager.curChar = 43;\r
 192 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 193         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 194         NEMOparserTokenManager.curChar = 44;\r
 195 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 196         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 197         NEMOparserTokenManager.curChar = 58;\r
 198 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 199         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 200         NEMOparserTokenManager.curChar = 59;\r
 201 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 202         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 203         NEMOparserTokenManager.curChar = 60;\r
 204 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 205         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 206         NEMOparserTokenManager.curChar = 61;\r
 207 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 208         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 209         NEMOparserTokenManager.curChar = 65;\r
 210 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 211         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 212         NEMOparserTokenManager.curChar = 66;\r
 213 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 214         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 215         NEMOparserTokenManager.curChar = 67;\r
 216 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 217         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 218         NEMOparserTokenManager.curChar = 68;\r
 219 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 220         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 221         NEMOparserTokenManager.curChar = 69;\r
 222 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 223         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 224         NEMOparserTokenManager.curChar = 70;\r
 225 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 226         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 227         NEMOparserTokenManager.curChar = 73;\r
 228 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 229         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 230         NEMOparserTokenManager.curChar = 77;\r
 231 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 232         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 233         NEMOparserTokenManager.curChar = 78;\r
 234 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 235         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 236         NEMOparserTokenManager.curChar = 79;\r
 237 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 238         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 239         NEMOparserTokenManager.curChar = 80;\r
 240 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 241         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 242         NEMOparserTokenManager.curChar = 81;\r
 243 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 244         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 245         NEMOparserTokenManager.curChar = 84;\r
 246 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 247         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 248         NEMOparserTokenManager.curChar = 85;\r
 249 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 250         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 251         NEMOparserTokenManager.curChar = 91;\r
 252 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 253         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 254         NEMOparserTokenManager.curChar = 93;\r
 255 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 256         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 257         NEMOparserTokenManager.curChar = 99;\r
 258 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 259         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 260         NEMOparserTokenManager.curChar = 102;\r
 261 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 262         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 263         NEMOparserTokenManager.curChar = 105;\r
 264 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 265         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 266         NEMOparserTokenManager.curChar = 110;\r
 267 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 268         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 269         NEMOparserTokenManager.curChar = 111;\r
 270 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 271         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 272         NEMOparserTokenManager.curChar = 114;\r
 273 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 274         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 275         NEMOparserTokenManager.curChar = 115;\r
 276 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 277         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 278         NEMOparserTokenManager.curChar = 124;\r
 279 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 280         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 281         NEMOparserTokenManager.curChar = 1;\r
 282 //        System.out.println("jjMoveStringLiteralDfa0_0" + method.invoke(class1));\r
 283         Assert.assertTrue((Integer) method.invoke(class1) != 0);\r
 284     }\r
 285 \r
 286     @Test\r
 287     public void testjjMoveStringLiteralDfa1_0() throws Exception{\r
 288         Method method = class1.getDeclaredMethod("jjMoveStringLiteralDfa1_0",new Class[]{long.class});\r
 289         method.setAccessible(true);\r
 290 \r
 291         PowerMockito.mockStatic(SimpleCharStream.class);\r
 292         PowerMockito.when(SimpleCharStream.readChar())\r
 293                 .thenReturn((char) 0)\r
 294                 .thenReturn((char) 38)\r
 295                 .thenReturn((char) 61)\r
 296                 .thenReturn((char) 61)\r
 297                 .thenReturn((char) 61)\r
 298                 .thenReturn((char) 69)\r
 299                 .thenReturn((char) 77)\r
 300                 .thenReturn((char) 80)\r
 301                 .thenReturn((char) 82)\r
 302                 .thenReturn((char) 97)\r
 303                 .thenReturn((char) 99)\r
 304                 .thenReturn((char) 101)\r
 305                 .thenReturn((char) 108)\r
 306                 .thenReturn((char) 110)\r
 307                 .thenReturn((char) 111)\r
 308                 .thenReturn((char) 112)\r
 309                 .thenReturn((char) 114)\r
 310                 .thenReturn((char) 116)\r
 311                 .thenReturn((char) 117)\r
 312                 .thenReturn((char) 121)\r
 313                 .thenReturn((char) 124);\r
 314 \r
 315         //case default\r
 316         Assert.assertTrue((Integer) method.invoke(class1, 1L) == 2);\r
 317         Assert.assertTrue(NEMOparserTokenManager.curChar == 0);\r
 318         //case 38 and so on\r
 319 //        System.out.println("0x8000L" + method.invoke(class1, 0x1000L));\r
 320         Assert.assertTrue((Integer) method.invoke(class1, 0x1000L) == 2);\r
 321         Assert.assertTrue(NEMOparserTokenManager.curChar == 38);\r
 322 //        System.out.println("0x8000L" + method.invoke(class1, 0x8000L));\r
 323         Assert.assertTrue((Integer) method.invoke(class1, 0x8000L) == 2);\r
 324         Assert.assertTrue(NEMOparserTokenManager.curChar == 61);\r
 325 //        System.out.println("0x8000L" + method.invoke(class1,0x40000L));\r
 326         Assert.assertTrue((Integer) method.invoke(class1, 0x40000L) == 2);\r
 327         Assert.assertTrue(NEMOparserTokenManager.curChar == 61);\r
 328 //        System.out.println("0x8000L" + method.invoke(class1,0x80000L));\r
 329         Assert.assertTrue((Integer) method.invoke(class1, 0x80000L) == 2);\r
 330         Assert.assertTrue(NEMOparserTokenManager.curChar == 61);\r
 331 //        System.out.println("0x8000L" + method.invoke(class1,0L));\r
 332         Assert.assertTrue((Integer) method.invoke(class1, 0L) == 2);\r
 333         Assert.assertTrue(NEMOparserTokenManager.curChar == 69);\r
 334         Assert.assertTrue((Integer) method.invoke(class1, 0L) == 2);\r
 335         Assert.assertTrue(NEMOparserTokenManager.curChar == 77);\r
 336         Assert.assertTrue((Integer) method.invoke(class1, 0L) == 2);\r
 337         Assert.assertTrue(NEMOparserTokenManager.curChar == 80);\r
 338         Assert.assertTrue((Integer) method.invoke(class1, 0L) == 2);\r
 339         Assert.assertTrue(NEMOparserTokenManager.curChar == 82);\r
 340         Assert.assertTrue((Integer) method.invoke(class1, 0L) == 2);\r
 341         Assert.assertTrue(NEMOparserTokenManager.curChar == 97);\r
 342         Assert.assertTrue((Integer) method.invoke(class1, 0L) == 2);\r
 343         Assert.assertTrue(NEMOparserTokenManager.curChar == 99);\r
 344         Assert.assertTrue((Integer) method.invoke(class1, 0L) == 2);\r
 345         Assert.assertTrue(NEMOparserTokenManager.curChar == 101);\r
 346         Assert.assertTrue((Integer) method.invoke(class1, 0L) == 2);\r
 347         Assert.assertTrue(NEMOparserTokenManager.curChar == 108);\r
 348         Assert.assertTrue((Integer) method.invoke(class1, 0L) == 2);\r
 349         Assert.assertTrue(NEMOparserTokenManager.curChar == 110);\r
 350         Assert.assertTrue((Integer) method.invoke(class1, 0L) == 2);\r
 351         Assert.assertTrue(NEMOparserTokenManager.curChar == 111);\r
 352         Assert.assertTrue((Integer) method.invoke(class1, 0L) == 2);\r
 353         Assert.assertTrue(NEMOparserTokenManager.curChar == 112);\r
 354         Assert.assertTrue((Integer) method.invoke(class1, 0L) == 2);\r
 355         Assert.assertTrue(NEMOparserTokenManager.curChar == 114);\r
 356         Assert.assertTrue((Integer) method.invoke(class1, 0L) == 2);\r
 357         Assert.assertTrue(NEMOparserTokenManager.curChar == 116);\r
 358         Assert.assertTrue((Integer) method.invoke(class1, 0L) == 2);\r
 359         Assert.assertTrue(NEMOparserTokenManager.curChar == 117);\r
 360         Assert.assertTrue((Integer) method.invoke(class1, 0L) == 2);\r
 361         Assert.assertTrue(NEMOparserTokenManager.curChar == 121);\r
 362         Assert.assertTrue((Integer) method.invoke(class1, 0L) == 2);\r
 363         Assert.assertTrue(NEMOparserTokenManager.curChar == 124);\r
 364     }\r
 365 \r
 366     @Test\r
 367     public void testjjMoveStringLiteralDfa2_0() throws Exception{\r
 368         Method method = class1.getDeclaredMethod("jjMoveStringLiteralDfa2_0",new Class[]{\r
 369                 long.class,\r
 370                 long.class\r
 371         });\r
 372         method.setAccessible(true);\r
 373 \r
 374         PowerMockito.mockStatic(SimpleCharStream.class);\r
 375         PowerMockito.when(SimpleCharStream.readChar())\r
 376                 .thenReturn((char) 0)\r
 377                 .thenReturn((char) 68)\r
 378                 .thenReturn((char) 69)\r
 379                 .thenReturn((char) 76)\r
 380                 .thenReturn((char) 80)\r
 381                 .thenReturn((char) 97)\r
 382                 .thenReturn((char) 100)\r
 383                 .thenReturn((char) 101)\r
 384                 .thenReturn((char) 103)\r
 385                 .thenReturn((char) 105)\r
 386                 .thenReturn((char) 110)\r
 387                 .thenReturn((char) 111)\r
 388                 .thenReturn((char) 112)\r
 389                 .thenReturn((char) 114)\r
 390                 .thenReturn((char) 116);\r
 391 \r
 392         //case default\r
 393 //        System.out.println("0x8000L" + method.invoke(class1, 1L, 1L));\r
 394         Assert.assertTrue((Integer)method.invoke(class1,1L,1L) == 3);\r
 395         Assert.assertTrue(NEMOparserTokenManager.curChar == 0);\r
 396         //case others\r
 397         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 3);\r
 398         Assert.assertTrue(NEMOparserTokenManager.curChar == 68);\r
 399         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 3);\r
 400         Assert.assertTrue(NEMOparserTokenManager.curChar == 69);\r
 401         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 3);\r
 402         Assert.assertTrue(NEMOparserTokenManager.curChar == 76);\r
 403         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 3);\r
 404         Assert.assertTrue(NEMOparserTokenManager.curChar == 80);\r
 405         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 3);\r
 406         Assert.assertTrue(NEMOparserTokenManager.curChar == 97);\r
 407         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 3);\r
 408         Assert.assertTrue(NEMOparserTokenManager.curChar == 100);\r
 409         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 3);\r
 410         Assert.assertTrue(NEMOparserTokenManager.curChar == 101);\r
 411         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 3);\r
 412         Assert.assertTrue(NEMOparserTokenManager.curChar == 103);\r
 413         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 3);\r
 414         Assert.assertTrue(NEMOparserTokenManager.curChar == 105);\r
 415         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 3);\r
 416         Assert.assertTrue(NEMOparserTokenManager.curChar == 110);\r
 417         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 3);\r
 418         Assert.assertTrue(NEMOparserTokenManager.curChar == 111);\r
 419         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 3);\r
 420         Assert.assertTrue(NEMOparserTokenManager.curChar == 112);\r
 421         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 3);\r
 422         Assert.assertTrue(NEMOparserTokenManager.curChar == 114);\r
 423         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 3);\r
 424         Assert.assertTrue(NEMOparserTokenManager.curChar == 116);\r
 425 \r
 426     }\r
 427 \r
 428     @Test\r
 429     public void testjjMoveStringLiteralDfa3_0() throws Exception{\r
 430         Method method = class1.getDeclaredMethod("jjMoveStringLiteralDfa3_0",new Class[]{\r
 431                 long.class,\r
 432                 long.class\r
 433         });\r
 434         method.setAccessible(true);\r
 435 \r
 436         PowerMockito.mockStatic(SimpleCharStream.class);\r
 437         PowerMockito.when(SimpleCharStream.readChar())\r
 438                 .thenReturn((char) 0)\r
 439                 .thenReturn((char) 65)\r
 440                 .thenReturn((char) 69)\r
 441                 .thenReturn((char) 79)\r
 442                 .thenReturn((char) 99)\r
 443                 .thenReturn((char) 100)\r
 444                 .thenReturn((char) 101)\r
 445                 .thenReturn((char) 103)\r
 446                 .thenReturn((char) 105)\r
 447                 .thenReturn((char) 109)\r
 448                 .thenReturn((char) 110)\r
 449                 .thenReturn((char) 111)\r
 450                 .thenReturn((char) 112)\r
 451                 .thenReturn((char) 114)\r
 452                 .thenReturn((char) 116)\r
 453                 .thenReturn((char) 119);\r
 454 \r
 455         //case default\r
 456         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 4);\r
 457         Assert.assertTrue(NEMOparserTokenManager.curChar == 0);\r
 458         //case others\r
 459         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 4);\r
 460         Assert.assertTrue(NEMOparserTokenManager.curChar == 65);\r
 461         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 4);\r
 462         Assert.assertTrue(NEMOparserTokenManager.curChar == 69);\r
 463         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 4);\r
 464         Assert.assertTrue(NEMOparserTokenManager.curChar == 79);\r
 465         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 4);\r
 466         Assert.assertTrue(NEMOparserTokenManager.curChar == 99);\r
 467         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 4);\r
 468         Assert.assertTrue(NEMOparserTokenManager.curChar == 100);\r
 469         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 4);\r
 470         Assert.assertTrue(NEMOparserTokenManager.curChar == 101);\r
 471         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 4);\r
 472         Assert.assertTrue(NEMOparserTokenManager.curChar == 103);\r
 473         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 4);\r
 474         Assert.assertTrue(NEMOparserTokenManager.curChar == 105);\r
 475         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 4);\r
 476         Assert.assertTrue(NEMOparserTokenManager.curChar == 109);\r
 477         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 4);\r
 478         Assert.assertTrue(NEMOparserTokenManager.curChar == 110);\r
 479         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 4);\r
 480         Assert.assertTrue(NEMOparserTokenManager.curChar == 111);\r
 481         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 4);\r
 482         Assert.assertTrue(NEMOparserTokenManager.curChar == 112);\r
 483         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 4);\r
 484         Assert.assertTrue(NEMOparserTokenManager.curChar == 114);\r
 485         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 4);\r
 486         Assert.assertTrue(NEMOparserTokenManager.curChar == 116);\r
 487         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 4);\r
 488         Assert.assertTrue(NEMOparserTokenManager.curChar == 119);\r
 489 \r
 490     }\r
 491 \r
 492     @Test\r
 493     public void testjjMoveStringLiteralDfa4_0() throws Exception{\r
 494         Method method = class1.getDeclaredMethod("jjMoveStringLiteralDfa4_0",new Class[]{\r
 495                 long.class,\r
 496                 long.class\r
 497         });\r
 498         method.setAccessible(true);\r
 499 \r
 500         PowerMockito.mockStatic(SimpleCharStream.class);\r
 501         PowerMockito.when(SimpleCharStream.readChar())\r
 502                 .thenReturn((char) 0)\r
 503                 .thenReturn((char) 77)\r
 504                 .thenReturn((char) 82)\r
 505                 .thenReturn((char) 84)\r
 506                 .thenReturn((char) 97)\r
 507                 .thenReturn((char) 101)\r
 508 //                .thenReturn((char) 101)\r
 509                 .thenReturn((char) 103)\r
 510                 .thenReturn((char) 104)\r
 511 //                .thenReturn((char) 104)\r
 512                 .thenReturn((char) 105)\r
 513 //                .thenReturn((char) 110)\r
 514                 .thenReturn((char) 110)\r
 515                 .thenReturn((char) 111)\r
 516                 .thenReturn((char) 114)\r
 517 //                .thenReturn((char) 115)\r
 518 //                .thenReturn((char) 115)\r
 519                 .thenReturn((char) 115)\r
 520                 .thenReturn((char) 121);\r
 521 \r
 522         //case default:\r
 523         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 5);\r
 524         Assert.assertTrue(NEMOparserTokenManager.curChar == 0);\r
 525         //case others\r
 526         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 5);\r
 527         Assert.assertTrue(NEMOparserTokenManager.curChar == 77);\r
 528         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 5);\r
 529         Assert.assertTrue(NEMOparserTokenManager.curChar == 82);\r
 530         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 5);\r
 531         Assert.assertTrue(NEMOparserTokenManager.curChar == 84);\r
 532         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 5);\r
 533         Assert.assertTrue(NEMOparserTokenManager.curChar == 97);\r
 534 //        Assert.assertTrue((Integer) method.invoke(class1, 0x40000000000000L, 0x40000000000000L) == 5);\r
 535 //        System.out.println("0x40000000000000L" + method.invoke(class1, 0x40000000000000L, 0x40000000000000L));\r
 536 //        Assert.assertTrue(NEMOparserTokenManager.curChar == 101);\r
 537         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 5);\r
 538         Assert.assertTrue(NEMOparserTokenManager.curChar == 101);\r
 539         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 5);\r
 540         Assert.assertTrue(NEMOparserTokenManager.curChar == 103);\r
 541 //        System.out.println("0x40000000000000L" + method.invoke(class1, 0x1000000000L, 0x1000000000L));\r
 542 //        Assert.assertTrue(NEMOparserTokenManager.curChar == 104);\r
 543         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 5);\r
 544         Assert.assertTrue(NEMOparserTokenManager.curChar == 104);\r
 545         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 5);\r
 546         Assert.assertTrue(NEMOparserTokenManager.curChar == 105);\r
 547 //        System.out.println("0x40000000000000L" + method.invoke(class1, 0x200000000000L, 0x200000000000L));\r
 548 //        Assert.assertTrue(NEMOparserTokenManager.curChar == 110);\r
 549         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 5);\r
 550         Assert.assertTrue(NEMOparserTokenManager.curChar == 110);\r
 551         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 5);\r
 552         Assert.assertTrue(NEMOparserTokenManager.curChar == 111);\r
 553         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 5);\r
 554         Assert.assertTrue(NEMOparserTokenManager.curChar == 114);\r
 555         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 5);\r
 556         Assert.assertTrue(NEMOparserTokenManager.curChar == 115);\r
 557         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 5);\r
 558         Assert.assertTrue(NEMOparserTokenManager.curChar == 121);\r
 559     }\r
 560 \r
 561     @Test\r
 562     public void testjjMoveStringLiteralDfa5_0() throws Exception{\r
 563         Method method = class1.getDeclaredMethod("jjMoveStringLiteralDfa5_0",new Class[]{\r
 564                 long.class,\r
 565                 long.class\r
 566         });\r
 567         method.setAccessible(true);\r
 568 \r
 569         PowerMockito.mockStatic(SimpleCharStream.class);\r
 570         PowerMockito.when(SimpleCharStream.readChar())\r
 571                 .thenReturn((char) 0)\r
 572                 .thenReturn((char) 69)\r
 573                 .thenReturn((char) 69)\r
 574                 .thenReturn((char) 69)\r
 575                 .thenReturn((char) 84)\r
 576                 .thenReturn((char) 97)\r
 577                 .thenReturn((char) 99)\r
 578                 .thenReturn((char) 100)\r
 579                 .thenReturn((char) 101)\r
 580                 .thenReturn((char) 103)\r
 581                 .thenReturn((char) 105)\r
 582                 .thenReturn((char) 110)\r
 583                 .thenReturn((char) 111)\r
 584                 .thenReturn((char) 114)\r
 585                 .thenReturn((char) 116)\r
 586                 .thenReturn((char) 116);\r
 587 \r
 588 \r
 589         //case default:\r
 590         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 6);\r
 591         Assert.assertTrue(NEMOparserTokenManager.curChar == 0);\r
 592         //case others\r
 593         Assert.assertTrue((Integer) method.invoke(class1, 0x2000000L, 0x2000000L) == 6);\r
 594         Assert.assertTrue(NEMOparserTokenManager.curChar == 69);\r
 595         Assert.assertTrue((Integer) method.invoke(class1, 0x10000000L, 0x10000000L) == 6);\r
 596         Assert.assertTrue(NEMOparserTokenManager.curChar == 69);\r
 597         Assert.assertTrue((Integer) method.invoke(class1, 0x8000000L, 0x8000000L) == 6);\r
 598         Assert.assertTrue(NEMOparserTokenManager.curChar == 69);\r
 599         Assert.assertTrue((Integer) method.invoke(class1, 0x4000000L, 0x4000000L) == 6);\r
 600         Assert.assertTrue(NEMOparserTokenManager.curChar == 84);\r
 601         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 6);\r
 602         Assert.assertTrue(NEMOparserTokenManager.curChar == 97);\r
 603         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 6);\r
 604         Assert.assertTrue(NEMOparserTokenManager.curChar == 99);\r
 605         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 6);\r
 606         Assert.assertTrue(NEMOparserTokenManager.curChar == 100);\r
 607         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 6);\r
 608         Assert.assertTrue(NEMOparserTokenManager.curChar == 101);\r
 609         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 6);\r
 610         Assert.assertTrue(NEMOparserTokenManager.curChar == 103);\r
 611         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 6);\r
 612         Assert.assertTrue(NEMOparserTokenManager.curChar == 105);\r
 613         Assert.assertTrue((Integer) method.invoke(class1, 0x10000000000L, 0x10000000000L) == 6);\r
 614         Assert.assertTrue(NEMOparserTokenManager.curChar == 110);\r
 615         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 6);\r
 616         Assert.assertTrue(NEMOparserTokenManager.curChar == 111);\r
 617         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 6);\r
 618         Assert.assertTrue(NEMOparserTokenManager.curChar == 114);\r
 619         Assert.assertTrue((Integer) method.invoke(class1, 0x4000000000L, 0x4000000000L) == 6);\r
 620         Assert.assertTrue(NEMOparserTokenManager.curChar == 116);\r
 621         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 6);\r
 622         Assert.assertTrue(NEMOparserTokenManager.curChar == 116);\r
 623     }\r
 624 \r
 625     @Test\r
 626     public void testjjMoveStringLiteralDfa6_0() throws Exception{\r
 627         Method method = class1.getDeclaredMethod("jjMoveStringLiteralDfa6_0",new Class[]{\r
 628                 long.class,\r
 629                 long.class\r
 630         });\r
 631         method.setAccessible(true);\r
 632 \r
 633         PowerMockito.mockStatic(SimpleCharStream.class);\r
 634         PowerMockito.when(SimpleCharStream.readChar())\r
 635                 .thenReturn((char) 0)\r
 636                 .thenReturn((char) 99)\r
 637                 .thenReturn((char) 100)\r
 638                 .thenReturn((char) 101)\r
 639                 .thenReturn((char) 105)\r
 640                 .thenReturn((char) 110)\r
 641                 .thenReturn((char) 114)\r
 642                 .thenReturn((char) 116);\r
 643 \r
 644         //case default\r
 645         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 7);\r
 646         Assert.assertTrue(NEMOparserTokenManager.curChar == 0);\r
 647         //case others\r
 648         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 7);\r
 649         Assert.assertTrue(NEMOparserTokenManager.curChar == 99);\r
 650         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 7);\r
 651         Assert.assertTrue(NEMOparserTokenManager.curChar == 100);\r
 652         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 7);\r
 653         Assert.assertTrue(NEMOparserTokenManager.curChar == 101);\r
 654         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 7);\r
 655         Assert.assertTrue(NEMOparserTokenManager.curChar == 105);\r
 656         Assert.assertTrue((Integer) method.invoke(class1, 0x80000000L, 0x80000000L) == 7);\r
 657         Assert.assertTrue(NEMOparserTokenManager.curChar == 110);\r
 658         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 7);\r
 659         Assert.assertTrue(NEMOparserTokenManager.curChar == 114);\r
 660         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 7);\r
 661         Assert.assertTrue(NEMOparserTokenManager.curChar == 116);\r
 662 \r
 663     }\r
 664 \r
 665     @Test\r
 666     public void testjjMoveStringLiteralDfa7_0() throws Exception{\r
 667         Method method = class1.getDeclaredMethod("jjMoveStringLiteralDfa7_0",new Class[]{\r
 668                 long.class,\r
 669                 long.class\r
 670         });\r
 671         method.setAccessible(true);\r
 672 \r
 673         PowerMockito.mockStatic(SimpleCharStream.class);\r
 674         PowerMockito.when(SimpleCharStream.readChar())\r
 675                 .thenReturn((char) 0)\r
 676                 .thenReturn((char) 101)\r
 677                 .thenReturn((char) 105)\r
 678                 .thenReturn((char) 111)\r
 679                 .thenReturn((char) 115)\r
 680                 .thenReturn((char) 116)\r
 681                 .thenReturn((char) 121)\r
 682                 .thenReturn((char) 121);\r
 683 \r
 684         //case default:\r
 685         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 8);\r
 686         Assert.assertTrue(NEMOparserTokenManager.curChar == 0);\r
 687 \r
 688         //case others:\r
 689         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 8);\r
 690         Assert.assertTrue(NEMOparserTokenManager.curChar == 101);\r
 691         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 8);\r
 692         Assert.assertTrue(NEMOparserTokenManager.curChar == 105);\r
 693         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 8);\r
 694         Assert.assertTrue(NEMOparserTokenManager.curChar == 111);\r
 695         Assert.assertTrue((Integer) method.invoke(class1, 0x400000000L, 0x400000000L) == 8);\r
 696         Assert.assertTrue(NEMOparserTokenManager.curChar == 115);\r
 697         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 8);\r
 698         Assert.assertTrue(NEMOparserTokenManager.curChar == 116);\r
 699         Assert.assertTrue((Integer) method.invoke(class1, 0x100000000L, 0x100000000L) == 8);\r
 700         Assert.assertTrue(NEMOparserTokenManager.curChar == 121);\r
 701         Assert.assertTrue((Integer) method.invoke(class1, 0x80000000000L, 0x80000000000L) == 8);\r
 702         Assert.assertTrue(NEMOparserTokenManager.curChar == 121);\r
 703     }\r
 704 \r
 705     @Test\r
 706     public void testjjMoveStringLiteralDfa8_0() throws Exception{\r
 707         Method method = class1.getDeclaredMethod("jjMoveStringLiteralDfa8_0",new Class[]{\r
 708                 long.class,\r
 709                 long.class\r
 710         });\r
 711         method.setAccessible(true);\r
 712 \r
 713         PowerMockito.mockStatic(SimpleCharStream.class);\r
 714         PowerMockito.when(SimpleCharStream.readChar())\r
 715                 .thenReturn((char) 0)\r
 716                 .thenReturn((char) 105)\r
 717                 .thenReturn((char) 108)\r
 718                 .thenReturn((char) 110)\r
 719                 .thenReturn((char) 110)\r
 720                 .thenReturn((char) 110)\r
 721                 .thenReturn((char) 111);\r
 722 \r
 723         //case default:\r
 724         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 9);\r
 725         Assert.assertTrue(NEMOparserTokenManager.curChar == 0);\r
 726 \r
 727         //case others\r
 728         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 9);\r
 729         Assert.assertTrue(NEMOparserTokenManager.curChar == 105);\r
 730         Assert.assertTrue((Integer) method.invoke(class1, 0x8000000000000L, 0x8000000000000L) == 9);\r
 731         Assert.assertTrue(NEMOparserTokenManager.curChar == 108);\r
 732         Assert.assertTrue((Integer) method.invoke(class1, 0x2000000000L, 0x2000000000L) == 9);\r
 733         Assert.assertTrue(NEMOparserTokenManager.curChar == 110);\r
 734         Assert.assertTrue((Integer) method.invoke(class1, 0x8000000000L, 0x8000000000L) == 9);\r
 735         Assert.assertTrue(NEMOparserTokenManager.curChar == 110);\r
 736         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 9);\r
 737         Assert.assertTrue(NEMOparserTokenManager.curChar == 110);\r
 738         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 9);\r
 739         Assert.assertTrue(NEMOparserTokenManager.curChar == 111);\r
 740     }\r
 741 \r
 742     @Test\r
 743     public void testjjMoveStringLiteralDfa9_0() throws Exception{\r
 744         Method method = class1.getDeclaredMethod("jjMoveStringLiteralDfa9_0",new Class[]{\r
 745                 long.class,\r
 746                 long.class\r
 747         });\r
 748         method.setAccessible(true);\r
 749 \r
 750         PowerMockito.mockStatic(SimpleCharStream.class);\r
 751         PowerMockito.when(SimpleCharStream.readChar())\r
 752                 .thenReturn((char) 0)\r
 753                 .thenReturn((char) 110)\r
 754                 .thenReturn((char) 110)\r
 755                 .thenReturn((char) 111)\r
 756                 .thenReturn((char) 115);\r
 757 \r
 758         //case default:\r
 759         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 10);\r
 760         Assert.assertTrue(NEMOparserTokenManager.curChar == 0);\r
 761 \r
 762         //case others\r
 763         Assert.assertTrue((Integer) method.invoke(class1, 0x200000000L, 0x200000000L) == 10);\r
 764         Assert.assertTrue(NEMOparserTokenManager.curChar == 110);\r
 765         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 10);\r
 766         Assert.assertTrue(NEMOparserTokenManager.curChar == 110);\r
 767         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 10);\r
 768         Assert.assertTrue(NEMOparserTokenManager.curChar == 111);\r
 769         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 10);\r
 770         Assert.assertTrue(NEMOparserTokenManager.curChar == 115);\r
 771     }\r
 772 \r
 773     @Test\r
 774     public void testjjMoveStringLiteralDfa10_0() throws Exception {\r
 775         Method method = class1.getDeclaredMethod("jjMoveStringLiteralDfa10_0", new Class[]{\r
 776                 long.class,\r
 777                 long.class\r
 778         });\r
 779         method.setAccessible(true);\r
 780 \r
 781         PowerMockito.mockStatic(SimpleCharStream.class);\r
 782         PowerMockito.when(SimpleCharStream.readChar())\r
 783                 .thenReturn((char) 0)\r
 784                 .thenReturn((char) 110)\r
 785                 .thenReturn((char) 115);\r
 786 \r
 787         //case default:\r
 788         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 11);\r
 789         Assert.assertTrue(NEMOparserTokenManager.curChar == 0);\r
 790 \r
 791         //case others\r
 792         Assert.assertTrue((Integer) method.invoke(class1, 0x100000000000L, 0x100000000000L) == 11);\r
 793         Assert.assertTrue(NEMOparserTokenManager.curChar == 110);\r
 794         Assert.assertTrue((Integer) method.invoke(class1, 1L, 1L) == 11);\r
 795         Assert.assertTrue(NEMOparserTokenManager.curChar == 115);\r
 796     }\r
 797 \r
 798     @Test\r
 799     public void testjjStartNfaWithStates_0() throws Exception {\r
 800     }\r
 801 \r
 802     @Test\r
 803     public void testjjMoveNfa_0() throws Exception {\r
 804     }\r
 805 \r
 806     @Test\r
 807     public void testjjCheckNAdd() throws Exception {\r
 808         Field field = class1.getDeclaredField("jjrounds");\r
 809         field.setAccessible(true);\r
 810         Field field1 = class1.getDeclaredField("jjround");\r
 811         field1.setAccessible(true);\r
 812 \r
 813         int state  = 1;\r
 814         int jjrounds[] = new int[205];\r
 815         jjrounds[0] = 1;\r
 816         int jjround = 1;\r
 817 \r
 818     }\r
 819 }