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

   1 /*
   2  * Copyright (c) 2015 Huawei, Inc. and others. All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 /* Generated By:JavaCC: Do not edit this line. NEMOparser.java */
   9 package org.opendaylight.nemo.user.vnspacemanager.languagestyle.NEMOParse;
  10
  11 import junit.framework.TestCase;
  12 import org.junit.*;
  13 import org.junit.runner.RunWith;
  14 import org.opendaylight.nemo.user.vnspacemanager.languagestyle.NEMOParse.NEMOparser;
  15
  16 import static org.junit.Assert.*;
  17 import org.opendaylight.nemo.user.vnspacemanager.languagestyle.updateintentlang.UpdateNodeLang;
  18 import org.opendaylight.nemo.user.vnspacemanager.languagestyle.updateintentlang.UpdateConnectionLang;
  19 import org.opendaylight.nemo.user.vnspacemanager.languagestyle.updateintentlang.UpdateFlowLang;
  20 import org.opendaylight.nemo.user.vnspacemanager.languagestyle.updateintentlang.UpdateOperationLang;
  21 import org.opendaylight.nemo.user.vnspacemanager.languagestyle.deleteintentlang.DeleteNodeLang;
  22 import org.opendaylight.nemo.user.vnspacemanager.languagestyle.deleteintentlang.DeleteConnectionLang;
  23 import org.opendaylight.nemo.user.vnspacemanager.languagestyle.deleteintentlang.DeleteFlowLang;
  24 import org.opendaylight.nemo.user.vnspacemanager.languagestyle.deleteintentlang.DeleteOperationLang;
  25 import org.opendaylight.nemo.user.vnspacemanager.languagestyle.Query;
  26 import org.opendaylight.nemo.user.vnspacemanager.languagestyle.NEMOConstants;
  27 import org.opendaylight.nemo.user.vnspacemanager.languagestyle.updateintentlang.UpdateTemplateDefinitionLang;
  28
  29 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  30 import org.opendaylight.nemo.user.tenantmanager.TenantManage;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.UserId;
  32
  33 import java.io.InputStream;
  34 import java.io.Reader;
  35 import java.lang.reflect.Field;
  36 import java.util.LinkedHashMap;
  37 import java.util.List;
  38 import java.util.ArrayList;
  39 import java.io.StringReader;
  40 import java.util.Map;
  41
  42 import static org.mockito.Mockito.*;
  43 import org.powermock.api.mockito.PowerMockito;
  44 import org.powermock.api.support.membermodification.MemberMatcher;
  45 import org.powermock.api.support.membermodification.MemberModifier;
  46 import org.powermock.core.classloader.annotations.PrepareForTest;
  47 import org.powermock.modules.junit4.PowerMockRunner;
  48 /**
  49  * Created by zhangmeng on 2016/1/5.
  50  */
  51 @RunWith(PowerMockRunner.class)
  52 @PrepareForTest({NEMOparser.class,SimpleCharStream.class,NEMOparserTokenManager.class})
  53 public class NEMOparserTest extends TestCase {
  54     private Class<NEMOparser> class1;
  55     private Class<SimpleCharStream> class2;
  56     private Class<NEMOparserTokenManager> class3;
  57     private java.io.InputStream inputStream;
  58     private java.io.Reader reader;
  59     private NEMOparser nemOparser;
  60     private NEMOparserTokenManager nemOparserTokenManager;
  61     private SimpleCharStream simpleCharStream;
  62     private Field field_NemoParser_jj_initialized_once; //bool
  63     private Field field_NemoParser_jj_input_stream; //SimpleCharStream
  64     private Field field_NemoParser_token_source;//NEMOparserTokenManager
  65     private Field field_SimpleCharStream_inputStream;  //reader
  66     private Field field_NEMOparserTokenManager_input_stream; //SimpleCharStream
  67
  68     @Before
  69     public void setUp() throws Exception {
  70         inputStream = mock(InputStream.class);
  71         reader = mock(Reader.class);
  72         nemOparserTokenManager = mock(NEMOparserTokenManager.class);
  73         simpleCharStream = mock(SimpleCharStream.class);
  74
  75         class1 = NEMOparser.class;
  76         class2 = SimpleCharStream.class;
  77         class3 = NEMOparserTokenManager.class;
  78
  79         field_NemoParser_jj_initialized_once = class1.getDeclaredField("jj_initialized_once");//bool
  80         field_NemoParser_jj_input_stream = class1.getDeclaredField("jj_input_stream"); //SimpleCharStream
  81         field_NemoParser_token_source = class1.getDeclaredField("token_source"); //NEMOparserTokenManager
  82         field_SimpleCharStream_inputStream = class2.getDeclaredField("inputStream"); // reader
  83         field_NEMOparserTokenManager_input_stream = class3.getDeclaredField("input_stream"); //SimpleCharStream
  84
  85         field_NemoParser_jj_input_stream.setAccessible(true);
  86         field_SimpleCharStream_inputStream.setAccessible(true);
  87         field_NEMOparserTokenManager_input_stream.setAccessible(true);
  88         field_NemoParser_jj_initialized_once.setAccessible(true);
  89         field_NemoParser_token_source.setAccessible(true);
  90
  91         field_NemoParser_jj_initialized_once.set(class1, false);
  92         field_NEMOparserTokenManager_input_stream.set(class3, null);
  93         field_SimpleCharStream_inputStream.set(class2, null);
  94     }
  95     @After
  96     public void teardown() throws Exception{
  97         field_NemoParser_jj_initialized_once.set(class1,false);
  98         field_NEMOparserTokenManager_input_stream.set(class3,null);
  99         field_SimpleCharStream_inputStream.set(class2,null);
 100     }
 101
 102     @Test
 103     public void testInit_ReInit() throws Exception{
 104
 105         nemOparser = new NEMOparser(inputStream);
 106         field_NemoParser_jj_input_stream.set(nemOparser, simpleCharStream);
 107         field_NemoParser_token_source.set(nemOparser, nemOparserTokenManager);
 108         doNothing().when(simpleCharStream).ReInit(any(InputStream.class), any(String.class), any(int.class), any(int.class));
 109         //doNothing().when(nemOparserTokenManager).ReInit(any(SimpleCharStream.class));
 110         nemOparser.ReInit(inputStream);
 111         verify(simpleCharStream).ReInit(inputStream, null, 1, 1);
 112
 113         field_NemoParser_jj_initialized_once.set(class1, false);
 114         field_NEMOparserTokenManager_input_stream.set(class3, null);
 115         field_SimpleCharStream_inputStream.set(class2,null);
 116         nemOparser = new NEMOparser(reader);
 117         field_NemoParser_jj_input_stream.set(nemOparser, simpleCharStream);
 118         doNothing().when(simpleCharStream).ReInit(any(Reader.class), any(int.class), any(int.class));
 119         nemOparser.ReInit(reader);
 120         verify(simpleCharStream).ReInit(any(Reader.class), any(int.class), any(int.class));
 121     }
 122
 123     @Test
 124     public void testParseNEMO() throws Exception {
 125
 126     }
 127
 128     @Test
 129     public void testNEMO() throws Exception {
 130
 131     }
 132
 133     @Test
 134     public void testUpdateIntent() throws Exception {
 135
 136     }
 137
 138     @Test
 139     public void testDeleteIntent() throws Exception {
 140
 141     }
 142
 143     @Test
 144     public void testUpdateNode() throws Exception {
 145
 146     }
 147
 148     @Test
 149     public void testUpdateConnection() throws Exception {
 150
 151     }
 152
 153     @Test
 154     public void testUpdateFlow() throws Exception {
 155
 156     }
 157
 158     @Test
 159     public void testUpdateOperation() throws Exception {
 160
 161     }
 162
 163     @Test
 164     public void testNodeModel() throws Exception {
 165         UserId userId = mock(UserId.class);
 166         DataBroker dataBroker = mock(DataBroker.class);
 167         TenantManage tenantManage = mock(TenantManage.class);
 168
 169         Field field_jj_ntk = class1.getDeclaredField("jj_ntk");
 170         field_jj_ntk.setAccessible(true);
 171         Field field_token = class1.getDeclaredField("token");
 172         field_token.setAccessible(true);
 173
 174         Token token = new Token();
 175         Token token_ID = new Token();
 176         token_ID.kind = NEMOparserConstants.ID;
 177         token_ID.image = "test";
 178         Token token_PROPERTY = new Token();
 179         token_PROPERTY.kind = NEMOparserConstants.PROPERTY;
 180         Token token_STRING = new Token();
 181         token_STRING.kind = NEMOparserConstants.STRING;
 182         token_STRING.image = "test_string";
 183         Token token_COLON = new Token();
 184         token_COLON.kind = NEMOparserConstants.COLON;
 185         Token token_ID1 = new Token();
 186         token_ID1.kind = NEMOparserConstants.ID;
 187         token_ID1.image = "test1";
 188         Token token_SEMICOLON = new Token();
 189         token_SEMICOLON.kind = NEMOparserConstants.SEMICOLON;
 190         Token token_NODE = new Token();
 191         token_NODE.kind = NEMOparserConstants.NODE;
 192
 193
 194         //connect
 195         token.next = token_ID;
 196         token_ID.next = token_PROPERTY;
 197         token_PROPERTY.next = token_STRING;
 198         token_STRING.next = token_COLON;
 199         token_COLON.next = token_ID1;
 200         token_ID1.next = token_SEMICOLON;
 201         token_SEMICOLON.next = token_NODE;
 202
 203         field_jj_ntk.set(class1, NEMOparserConstants.STRING);
 204         field_token.set(class1, token);
 205         PowerMockito.spy(NEMOparser.class);
 206         PowerMockito.when(NEMOparser.class,"jj_ntk")
 207                 .thenReturn(NEMOparserConstants.NODE)
 208                 .thenReturn(NEMOparserConstants.NODE)
 209                 .thenReturn(NEMOparserConstants.SEMICOLON);
 210         PowerMockito.mockStatic(NEMOparser.class);
 211         PowerMockito.when(NEMOparser.abstractNode(any(UpdateTemplateDefinitionLang.class))).thenReturn("zhangmeng");
 212         Assert.assertTrue(NEMOparser.NodeModel(userId, dataBroker, tenantManage) == null);
 213     }
 214
 215     @Test
 216     public void testAbstractNode() throws Exception {
 217         UpdateTemplateDefinitionLang definition = mock(UpdateTemplateDefinitionLang.class);
 218
 219         Field field_jj_ntk = class1.getDeclaredField("jj_ntk");
 220         field_jj_ntk.setAccessible(true);
 221         Field field_token = class1.getDeclaredField("token");
 222         field_token.setAccessible(true);
 223
 224         Token token = new Token();
 225         Token token_ID = new Token();
 226         token_ID.kind = NEMOparserConstants.ID;
 227         token_ID.image = "test";
 228         Token token_TYPE = new Token();
 229         token_TYPE.kind = NEMOparserConstants.TYPE;
 230         Token token_ID1 = new Token();
 231         token_ID1.kind = NEMOparserConstants.ID;
 232         token_ID1.image = "test1";
 233         Token token_CONTAIN = new Token();
 234         token_CONTAIN.kind = NEMOparserConstants.CONTAIN;
 235         Token token_ID2 = new Token();
 236         token_ID2.kind = NEMOparserConstants.ID;
 237         token_ID2.image = "test2";
 238         Token token_SEMICOLON = new Token();
 239         token_SEMICOLON.kind = NEMOparserConstants.SEMICOLON;
 240
 241         //connect
 242         token.next = token_ID;
 243         token_ID.next = token_TYPE;
 244         token_TYPE.next = token_ID1;
 245         token_ID1.next = token_CONTAIN;
 246         token_CONTAIN.next = token_ID2;
 247         token_ID2.next = token_SEMICOLON;
 248
 249         field_jj_ntk.set(class1, NEMOparserConstants.CONTAIN);
 250         field_token.set(class1, token);
 251         Assert.assertTrue(NEMOparser.abstractNode(definition) == null);
 252
 253         //branch PROPERTY
 254         //connect aggin
 255         Token token_PROPERTY = new Token();
 256         token_PROPERTY.kind = NEMOparserConstants.PROPERTY;
 257         Token token_COLON = new Token();
 258         token_COLON.kind = NEMOparserConstants.COLON;
 259         PowerMockito.mockStatic(NEMOparser.class);
 260         PowerMockito.when(NEMOparser.property()).thenReturn(new LinkedHashMap<String, String>());
 261         token.next = token_ID;
 262         token_ID.next = token_TYPE;
 263         token_TYPE.next = token_ID1;
 264         token_ID1.next = token_PROPERTY;
 265         token_PROPERTY.next = token_ID2;
 266         token_ID2.next = token_COLON;
 267         token_COLON.next = token_SEMICOLON;
 268
 269         field_jj_ntk.set(class1, NEMOparserConstants.PROPERTY);
 270         field_token.set(class1, token);
 271         Assert.assertTrue(NEMOparser.abstractNode(definition) == null);
 272
 273     }
 274
 275     @Test
 276     public void testAbstractConnection() throws Exception {
 277         UpdateTemplateDefinitionLang definition = mock(UpdateTemplateDefinitionLang.class);
 278
 279         Field field_jj_ntk = class1.getDeclaredField("jj_ntk");
 280         field_jj_ntk.setAccessible(true);
 281         Field field_token = class1.getDeclaredField("token");
 282         field_token.setAccessible(true);
 283
 284         Token token = new Token();
 285         Token token_ID = new Token();
 286         token_ID.kind = NEMOparserConstants.ID;
 287         token_ID.image = "test";
 288         Token token_TYPE = new Token();
 289         token_TYPE.kind = NEMOparserConstants.TYPE;
 290         Token token_ID1 = new Token();
 291         token_ID1.kind = NEMOparserConstants.ID;
 292         token_ID1.image = "test1";
 293         Token token_ENDNODES = new Token()  ;
 294         token_ENDNODES.kind = NEMOparserConstants.ENDNODES;
 295         Token token_ID2 = new Token();
 296         token_ID2.kind = NEMOparserConstants.ID;
 297         token_ID2.image = "test2";
 298         Token token_SEMICOLON = new Token();
 299         token_SEMICOLON.kind = NEMOparserConstants.SEMICOLON;
 300         //connect
 301         token.next = token_ID;
 302         token_ID.next = token_TYPE;
 303         token_TYPE.next = token_ID1;
 304         token_ID1.next = token_ENDNODES;
 305         token_ENDNODES.next = token_ID2;
 306         token_ID2.next = token_SEMICOLON;
 307
 308         field_jj_ntk.set(class1, NEMOparserConstants.ENDNODES);
 309         field_token.set(class1, token);
 310
 311         Assert.assertTrue(NEMOparser.abstractConnection(definition) == null);
 312
 313         //branch PROPERTY
 314         //connect aggin
 315         Token token_PROPERTY = new Token();
 316         token_PROPERTY.kind = NEMOparserConstants.PROPERTY;
 317         Token token_COLON = new Token();
 318         token_COLON.kind = NEMOparserConstants.COLON;
 319         PowerMockito.mockStatic(NEMOparser.class);
 320         PowerMockito.when(NEMOparser.property()).thenReturn(new LinkedHashMap<String, String>());
 321         token.next = token_ID;
 322         token_ID.next = token_TYPE;
 323         token_TYPE.next = token_ID1;
 324         token_ID1.next = token_PROPERTY;
 325         token_PROPERTY.next = token_ID2;
 326         token_ID2.next = token_COLON;
 327         token_COLON.next = token_SEMICOLON;
 328
 329         field_jj_ntk.set(class1, NEMOparserConstants.PROPERTY);
 330         field_token.set(class1, token);
 331         Assert.assertTrue(NEMOparser.abstractConnection(definition) == null);
 332     }
 333
 334     @Test
 335     public void testAbstractFlow() throws Exception {
 336         UpdateTemplateDefinitionLang definition = mock(UpdateTemplateDefinitionLang.class);
 337
 338         Field field_jj_ntk = class1.getDeclaredField("jj_ntk");
 339         field_jj_ntk.setAccessible(true);
 340         Field field_token = class1.getDeclaredField("token");
 341         field_token.setAccessible(true);
 342
 343         Token token = new Token();
 344         Token token_ID = new Token();
 345         token_ID.kind = NEMOparserConstants.ID;
 346         token_ID.image = "test";
 347         Token token_MATCH = new Token();
 348         token_MATCH.kind = NEMOparserConstants.MATCH;
 349         Token token_ID1 = new Token();
 350         token_ID1.kind = NEMOparserConstants.ID;
 351         Token token_COLON = new Token();
 352         token_COLON.kind = NEMOparserConstants.COLON;
 353         Token token_PROPERTY = new Token();
 354         token_PROPERTY.kind = NEMOparserConstants.PROPERTY;
 355         Token token_ID2 = new Token();
 356         token_ID2.kind = NEMOparserConstants.ID;
 357         Token token_COLON1 = new Token();
 358         token_COLON1.kind = NEMOparserConstants.COLON;
 359         Token token_SEMICOLON = new Token();
 360         token_SEMICOLON.kind = NEMOparserConstants.SEMICOLON;
 361         //connect
 362         token.next = token_ID;
 363         token_ID.next = token_MATCH;
 364         token_MATCH.next = token_ID1;
 365         token_ID1.next = token_COLON;
 366         token_COLON.next = token_PROPERTY;
 367         token_PROPERTY.next = token_ID2;
 368         token_ID2.next = token_COLON1;
 369         token_COLON1.next = token_SEMICOLON;
 370
 371         field_jj_ntk.set(class1, NEMOparserConstants.PROPERTY);
 372         field_token.set(class1, token);
 373
 374         PowerMockito.mockStatic(NEMOparser.class);
 375         PowerMockito.when(NEMOparser.property()).thenReturn(new LinkedHashMap<String, String>());
 376         when(definition.createAbstractFlow(any(String.class), any(LinkedHashMap.class), any(LinkedHashMap.class))).thenReturn("test");
 377         Assert.assertTrue(NEMOparser.abstractFlow(definition) == null);
 378
 379     }
 380
 381     @Test
 382     public void testAbstractOperation() throws Exception {
 383 //        NEMOparser.abstractConnection();
 384     }
 385
 386     @Test
 387     public void testDeleteNode() throws Exception {
 388         UserId userId = mock(UserId.class);
 389         DataBroker dataBroker = mock(DataBroker.class);
 390         TenantManage tenantManage = mock(TenantManage.class);
 391
 392         Field field_token = class1.getDeclaredField("token");
 393         field_token.setAccessible(true);
 394
 395         Token token1 = new Token();
 396         Token token2 = new Token();
 397         Token token3 = new Token();
 398         token1.next = token2;
 399         token1.kind = token2.kind = 56;
 400         token1.image = token2.image = token3.image = "test";
 401         token3.kind = 7;
 402
 403         field_token.set(class1, token1);
 404
 405         //get into method "jj_consume_token" arg(56)
 406         //returned token2
 407         //get into method "jj_consume_token" arg(7) token = token2
 408         PowerMockito.mockStatic(NEMOparserTokenManager.class);
 409         PowerMockito.when(NEMOparserTokenManager.getNextToken()).thenReturn(token3);
 410         //returned token3  token = token3
 411         //get into method "DeleteOperationHandling" args(userid,0)
 412         when(tenantManage.getObjectId(userId,"test")).thenReturn(null);
 413         Assert.assertTrue(NEMOparser.DeleteNode(userId, dataBroker, tenantManage).equals("The node " + "test" + " is not exist."));
 414     }
 415
 416     @Test
 417     public void testDeleteConnection() throws Exception {
 418         UserId userId = mock(UserId.class);
 419         DataBroker dataBroker = mock(DataBroker.class);
 420         TenantManage tenantManage = mock(TenantManage.class);
 421
 422         Field field_token = class1.getDeclaredField("token");
 423         field_token.setAccessible(true);
 424
 425         Token token1 = new Token();
 426         Token token2 = new Token();
 427         Token token3 = new Token();
 428         token1.next = token2;
 429         token1.kind = token2.kind = 56;
 430         token1.image = token2.image = token3.image = "test";
 431         token3.kind = 7;
 432
 433         field_token.set(class1, token1);
 434
 435         //get into method "jj_consume_token" arg(56)
 436         //returned token2
 437         //get into method "jj_consume_token" arg(7) token = token2
 438         PowerMockito.mockStatic(NEMOparserTokenManager.class);
 439         PowerMockito.when(NEMOparserTokenManager.getNextToken()).thenReturn(token3);
 440         //returned token3  token = token3
 441         //get into method "DeleteOperationHandling" args(userid,0)
 442         when(tenantManage.getObjectId(userId,"test")).thenReturn(null);
 443         Assert.assertTrue(NEMOparser.DeleteConnection(userId, dataBroker, tenantManage).equals("The connection " + "test" + " is not exist."));
 444     }
 445
 446     @Test
 447     public void testDeleteFlow() throws Exception {
 448         UserId userId = mock(UserId.class);
 449         DataBroker dataBroker = mock(DataBroker.class);
 450         TenantManage tenantManage = mock(TenantManage.class);
 451
 452         Field field_token = class1.getDeclaredField("token");
 453         field_token.setAccessible(true);
 454
 455         Token token1 = new Token();
 456         Token token2 = new Token();
 457         Token token3 = new Token();
 458         token1.next = token2;
 459         token1.kind = token2.kind = 56;
 460         token1.image = token2.image = token3.image = "test";
 461         token3.kind = 7;
 462
 463         field_token.set(class1, token1);
 464
 465         //get into method "jj_consume_token" arg(56)
 466         //returned token2
 467         //get into method "jj_consume_token" arg(7) token = token2
 468         PowerMockito.mockStatic(NEMOparserTokenManager.class);
 469         PowerMockito.when(NEMOparserTokenManager.getNextToken()).thenReturn(token3);
 470         //returned token3  token = token3
 471         //get into method "DeleteOperationHandling" args(userid,0)
 472         when(tenantManage.getObjectId(userId,"test")).thenReturn(null);
 473         Assert.assertTrue(NEMOparser.DeleteFlow(userId, dataBroker, tenantManage).equals("The flow " + "test" + " is not exist."));
 474     }
 475
 476     @Test
 477     public void testDeleteOperation() throws Exception {
 478         UserId userId = mock(UserId.class);
 479         DataBroker dataBroker = mock(DataBroker.class);
 480         TenantManage tenantManage = mock(TenantManage.class);
 481
 482         Field field_token = class1.getDeclaredField("token");
 483         field_token.setAccessible(true);
 484
 485         Token token1 = new Token();
 486         Token token2 = new Token();
 487         Token token3 = new Token();
 488         token1.next = token2;
 489         token1.kind = token2.kind = 56;
 490         token1.image = token2.image = token3.image = "test";
 491         token3.kind = 7;
 492
 493         field_token.set(class1, token1);
 494
 495         //get into method "jj_consume_token" arg(56)
 496         //returned token2
 497         //get into method "jj_consume_token" arg(7) token = token2
 498         PowerMockito.mockStatic(NEMOparserTokenManager.class);
 499         PowerMockito.when(NEMOparserTokenManager.getNextToken()).thenReturn(token3);
 500         //returned token3  token = token3
 501         //get into method "DeleteOperationHandling" args(userid,0)
 502         when(tenantManage.getObjectId(userId,"test")).thenReturn(null);
 503         Assert.assertTrue(NEMOparser.DeleteOperation(userId, dataBroker, tenantManage).equals("The operation " + "test" + " is not exist."));
 504     }
 505
 506     @Test
 507     public void testQuery() throws Exception {
 508         UserId userId = mock(UserId.class);
 509         DataBroker dataBroker = mock(DataBroker.class);
 510         TenantManage tenantManage = mock(TenantManage.class);
 511
 512         Field field_jj_ntk = class1.getDeclaredField("jj_ntk");
 513         field_jj_ntk.setAccessible(true);
 514         Field field_token = class1.getDeclaredField("token");
 515         field_token.setAccessible(true);
 516
 517         Token token1 = new Token();
 518         Token token2 = new Token();
 519         Token token3 = new Token();
 520         token1.next = token2;
 521         token2.next = token3;
 522         token3.kind = NEMOparserConstants.SEMICOLON;
 523
 524         token2.kind = NEMOparserConstants.TYPE;
 525         token2.image = "1";
 526         field_token.set(class1,token1);
 527         field_jj_ntk.set(class1, NEMOparserConstants.TYPE);
 528         Assert.assertTrue(NEMOparser.Query(userId,dataBroker,tenantManage).equals("The item is not supported."));
 529
 530         token2.kind = NEMOparserConstants.CONTAIN;
 531         token2.image = "2";
 532         field_token.set(class1,token1);
 533         field_jj_ntk.set(class1, NEMOparserConstants.CONTAIN);
 534         Assert.assertTrue(NEMOparser.Query(userId,dataBroker,tenantManage).equals("The item is not supported."));
 535
 536         token2.kind = NEMOparserConstants.PROPERTY;
 537         token2.image = "2";
 538         field_token.set(class1,token1);
 539         field_jj_ntk.set(class1, NEMOparserConstants.PROPERTY);
 540         Assert.assertTrue(NEMOparser.Query(userId,dataBroker,tenantManage).equals("The item is not supported."));
 541
 542         token2.kind = NEMOparserConstants.ENDNODES;
 543         token2.image = "2";
 544         field_token.set(class1,token1);
 545         field_jj_ntk.set(class1, NEMOparserConstants.ENDNODES);
 546         Assert.assertTrue(NEMOparser.Query(userId,dataBroker,tenantManage).equals("The item is not supported."));
 547
 548         token2.kind = NEMOparserConstants.MATCH;
 549         token2.image = "2";
 550         field_token.set(class1,token1);
 551         field_jj_ntk.set(class1, NEMOparserConstants.MATCH);
 552         Assert.assertTrue(NEMOparser.Query(userId,dataBroker,tenantManage).equals("The item is not supported."));
 553
 554         token2.kind = NEMOparserConstants.PRIORITY;
 555         token2.image = "2";
 556         field_token.set(class1,token1);
 557         field_jj_ntk.set(class1, NEMOparserConstants.PRIORITY);
 558         Assert.assertTrue(NEMOparser.Query(userId,dataBroker,tenantManage).equals("The item is not supported."));
 559
 560         token2.kind = NEMOparserConstants.TARGET;
 561         token2.image = "2";
 562         field_token.set(class1,token1);
 563         field_jj_ntk.set(class1, NEMOparserConstants.TARGET);
 564         Assert.assertTrue(NEMOparser.Query(userId,dataBroker,tenantManage).equals("The item is not supported."));
 565
 566         token2.kind = NEMOparserConstants.CONDITION;
 567         token2.image = "2";
 568         field_token.set(class1,token1);
 569         field_jj_ntk.set(class1, NEMOparserConstants.CONDITION);
 570         Assert.assertTrue(NEMOparser.Query(userId,dataBroker,tenantManage).equals("The item is not supported."));
 571
 572         token2.kind = NEMOparserConstants.ACTION;
 573         token2.image = "2";
 574         field_token.set(class1,token1);
 575         field_jj_ntk.set(class1, NEMOparserConstants.ACTION);
 576         Assert.assertTrue(NEMOparser.Query(userId,dataBroker,tenantManage).equals("The item is not supported."));
 577
 578         token2.kind = NEMOparserConstants.ID;
 579         token2.image = "2";
 580         field_token.set(class1,token1);
 581         field_jj_ntk.set(class1, NEMOparserConstants.ID);
 582         Assert.assertTrue(NEMOparser.Query(userId,dataBroker,tenantManage).equals("The item is not supported."));
 583
 584         token2.kind = NEMOparserConstants.NODES;
 585         token2.image = "2";
 586         field_token.set(class1,token1);
 587         field_jj_ntk.set(class1, NEMOparserConstants.NODES);
 588         Assert.assertTrue(NEMOparser.Query(userId,dataBroker,tenantManage).equals("The item is not supported."));
 589
 590         token2.kind = NEMOparserConstants.CONNECTIONS;
 591         token2.image = "2";
 592         field_token.set(class1,token1);
 593         field_jj_ntk.set(class1, NEMOparserConstants.CONNECTIONS);
 594         Assert.assertTrue(NEMOparser.Query(userId,dataBroker,tenantManage).equals("The item is not supported."));
 595
 596         token2.kind = NEMOparserConstants.FLOWS;
 597         token2.image = "2";
 598         field_token.set(class1,token1);
 599         field_jj_ntk.set(class1, NEMOparserConstants.FLOWS);
 600         Assert.assertTrue(NEMOparser.Query(userId,dataBroker,tenantManage).equals("The item is not supported."));
 601
 602         token2.kind = NEMOparserConstants.OPERATIONS;
 603         token2.image = "2";
 604         field_token.set(class1,token1);
 605         field_jj_ntk.set(class1, NEMOparserConstants.OPERATIONS);
 606         Assert.assertTrue(NEMOparser.Query(userId,dataBroker,tenantManage).equals("The item is not supported."));
 607     }
 608
 609     @Test
 610     public void testConditionTarget() throws Exception {
 611         Field field_jj_ntk = class1.getDeclaredField("jj_ntk");
 612         field_jj_ntk.setAccessible(true);
 613         Field field_token = class1.getDeclaredField("token");
 614         field_token.setAccessible(true);
 615
 616         Token token1 = new Token();
 617         Token token2 = new Token();
 618         token1.next = token2;
 619
 620         token2.kind = NEMOparserConstants.ID;
 621         token2.image = "1";
 622         field_token.set(class1,token1);
 623         field_jj_ntk.set(class1, NEMOparserConstants.ID);
 624         Assert.assertTrue(NEMOparser.conditionTarget().containsKey("1"));
 625
 626         token2.kind = NEMOparserConstants.TIMEVAL;
 627         token2.image = "2";
 628         field_token.set(class1,token1);
 629         field_jj_ntk.set(class1, NEMOparserConstants.TIMEVAL);
 630         Assert.assertTrue(NEMOparser.conditionTarget().containsKey("2"));
 631
 632         token2.kind = NEMOparserConstants.FULLTIME;
 633         token2.image = "3";
 634         field_token.set(class1,token1);
 635         field_jj_ntk.set(class1, NEMOparserConstants.FULLTIME);
 636         Assert.assertTrue(NEMOparser.conditionTarget().containsKey("3"));
 637
 638         token2.kind = NEMOparserConstants.UNUMBER;
 639         token2.image = "4";
 640         field_token.set(class1,token1);
 641         field_jj_ntk.set(class1, NEMOparserConstants.UNUMBER);
 642         Assert.assertTrue(NEMOparser.conditionTarget().containsKey("4"));
 643
 644         //test case LPAREN
 645         Token token = new Token();
 646         Token token_LPAREN = new Token();
 647         Token token_UNUMBER = new Token();
 648         Token token_COMMA = new Token();
 649         Token token_UNUMBER1 = new Token();
 650         Token token_RPAREN = new Token();
 651         //connect tokens
 652         token.next = token_LPAREN;
 653         token_LPAREN.next = token_UNUMBER;
 654         token_UNUMBER.next = token_COMMA;
 655         token_COMMA.next = token_UNUMBER1;
 656         token_UNUMBER1.next = token_RPAREN;
 657         token_RPAREN.next = null;
 658         //attribute values
 659         token_LPAREN.kind = NEMOparserConstants.LPAREN;
 660         token_UNUMBER.kind = token_UNUMBER1.kind = NEMOparserConstants.UNUMBER;
 661         token_COMMA.kind = NEMOparserConstants.COMMA;
 662         token_RPAREN.kind = NEMOparserConstants.RPAREN;
 663         token_UNUMBER.image = "zhangmeng";
 664         token_UNUMBER.image = "zhangyuanyuan";
 665
 666
 667         field_token.set(class1,token);
 668         field_jj_ntk.set(class1, NEMOparserConstants.LPAREN);
 669         Assert.assertTrue(NEMOparser.conditionTarget().containsValue("range"));
 670
 671 //        PowerMockito.mockStatic(NEMOparserTokenManager.class);
 672 //        PowerMockito.when(NEMOparserTokenManager.getNextToken())
 673 //                .thenReturn()
 674 //                .thenReturn();
 675
 676     }
 677
 678     @Test
 679     public void testProperty() throws Exception {
 680         Field field_jj_ntk = class1.getDeclaredField("jj_ntk");
 681         field_jj_ntk.setAccessible(true);
 682         Field field_token = class1.getDeclaredField("token");
 683         field_token.setAccessible(true);
 684
 685         Token token1 = new Token();
 686         Token token2 = new Token();
 687         token1.next = token2;
 688
 689         token2.kind = NEMOparserConstants.ID;
 690         token2.image = "1";
 691         field_token.set(class1,token1);
 692         field_jj_ntk.set(class1, NEMOparserConstants.ID);
 693         Assert.assertTrue(NEMOparser.property().containsKey("1"));
 694
 695         token2.kind = NEMOparserConstants.ETHADDR;
 696         token2.image = "2";
 697         field_token.set(class1,token1);
 698         field_jj_ntk.set(class1, NEMOparserConstants.ETHADDR);
 699         Assert.assertTrue(NEMOparser.property().containsKey("2"));
 700
 701         token2.kind = NEMOparserConstants.IPV4PREF;
 702         token2.image = "3";
 703         field_token.set(class1,token1);
 704         field_jj_ntk.set(class1, NEMOparserConstants.IPV4PREF);
 705         Assert.assertTrue(NEMOparser.property().containsKey("3"));
 706
 707         token2.kind = NEMOparserConstants.IPV4ADDR;
 708         token2.image = "4";
 709         field_token.set(class1,token1);
 710         field_jj_ntk.set(class1, NEMOparserConstants.IPV4ADDR);
 711         Assert.assertTrue(NEMOparser.property().containsKey("4"));
 712
 713         token2.kind = NEMOparserConstants.TIMEVAL;
 714         token2.image = "5";
 715         field_token.set(class1,token1);
 716         field_jj_ntk.set(class1, NEMOparserConstants.TIMEVAL);
 717         Assert.assertTrue(NEMOparser.property().containsKey("5"));
 718
 719         token2.kind = NEMOparserConstants.FULLTIME;
 720         token2.image = "6";
 721         field_token.set(class1,token1);
 722         field_jj_ntk.set(class1, NEMOparserConstants.FULLTIME);
 723         Assert.assertTrue(NEMOparser.property().containsKey("6"));
 724
 725         token2.kind = NEMOparserConstants.TEMPID;
 726         token2.image = "7";
 727         field_token.set(class1,token1);
 728         field_jj_ntk.set(class1, NEMOparserConstants.TEMPID);
 729         Assert.assertTrue(NEMOparser.property().containsKey("7"));
 730
 731         token2.kind = NEMOparserConstants.UNUMBER;
 732         token2.image = "8";
 733         field_token.set(class1,token1);
 734         field_jj_ntk.set(class1, NEMOparserConstants.UNUMBER);
 735         Assert.assertTrue(NEMOparser.property().containsKey("8"));
 736
 737     }
 738
 739     @Test
 740     public void testNodeMultiProperty() throws Exception {
 741
 742     }
 743
 744     @Test
 745     public void testReInit() throws Exception {
 746         nemOparser = new NEMOparser(nemOparserTokenManager);
 747         nemOparser.ReInit(nemOparserTokenManager);
 748     }
 749
 750
 751     @Test
 752     public void testGetToken_GetNextToken() throws Exception {
 753         Field field_token = class1.getDeclaredField("token");
 754         field_token.setAccessible(true);
 755
 756         Token token1 = new Token();
 757         Token token2 = new Token();
 758         token1.next = token2;
 759
 760         field_token.set(class1, token1);
 761
 762         PowerMockito.mockStatic(NEMOparserTokenManager.class);
 763         PowerMockito.when(NEMOparserTokenManager.getNextToken()).thenReturn(token1);
 764
 765         Assert.assertTrue(NEMOparser.getToken(2) == token1);
 766         Assert.assertTrue(NEMOparser.getNextToken() == token2);
 767         field_token.set(class1, token2);
 768         Assert.assertTrue(NEMOparser.getNextToken() == token1);
 769     }
 770
 771     @Test
 772     public void testGenerateParseException() throws Exception {
 773         Field field_jj_kind = class1.getDeclaredField("jj_kind");
 774         field_jj_kind.setAccessible(true);
 775         Field field_jj_la1 = class1.getDeclaredField("jj_la1");
 776         field_jj_la1.setAccessible(true);
 777         Field field_jj_gen = class1.getDeclaredField("jj_gen");
 778         field_jj_gen.setAccessible(true);
 779         Field field_jj_la1_0 = class1.getDeclaredField("jj_la1_0");
 780         field_jj_la1_0.setAccessible(true);
 781         Field field_jj_la1_1 = class1.getDeclaredField("jj_la1_1");
 782         field_jj_la1_1.setAccessible(true);
 783         Field field_jj_la1_2 = class1.getDeclaredField("jj_la1_2");
 784         field_jj_la1_2.setAccessible(true);
 785         Field field_token = class1.getDeclaredField("token");
 786         field_token.setAccessible(true);
 787
 788         Token token1 = new Token();
 789         Token token2 = new Token();
 790         int jj_la1[] = new int[68];
 791         int jj_la1_0[] = new int[100];
 792         int jj_la1_1[] = new int[100];
 793         int jj_la1_2[] = new int[100];
 794         Assert.assertTrue(jj_la1_0[1] == 0);
 795         for (int i = 0;i < 68;i++)
 796             jj_la1[i] = 0;
 797         jj_la1[0] = 1;
 798         jj_la1_0[0] = 1;
 799         jj_la1_1[0] = 1;
 800         jj_la1_2[0] = 1;
 801         token1.next = token2;
 802
 803         field_jj_kind.set(class1,0);
 804         field_jj_gen.set(class1,1);
 805         field_jj_la1.set(class1,jj_la1);
 806         field_jj_la1_0.set(class1,jj_la1_0);
 807         field_jj_la1_1.set(class1,jj_la1_1);
 808         field_jj_la1_2.set(class1,jj_la1_2);
 809         field_token.set(class1,token1);
 810
 811         Assert.assertTrue(NEMOparser.generateParseException() != null);
 812     }
 813
 814     @Test
 815     public void testEnable_tracing() throws Exception {
 816         NEMOparser.enable_tracing();
 817     }
 818
 819     @Test
 820     public void testDisable_tracing() throws Exception {
 821         NEMOparser.disable_tracing();
 822     }
 823 }