View Javadoc

1   /**
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *     http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing, software
13   * distributed under the License is distributed on an "AS IS" BASIS,
14   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15   * See the License for the specific language governing permissions and
16   * limitations under the License.
17   */
18  package org.apache.hadoop.hbase.security.visibility;
19  
20  import static org.junit.Assert.assertEquals;
21  import static org.junit.Assert.assertTrue;
22  import static org.junit.Assert.fail;
23  
24  import org.apache.hadoop.hbase.testclassification.SmallTests;
25  import org.apache.hadoop.hbase.security.visibility.expression.ExpressionNode;
26  import org.apache.hadoop.hbase.security.visibility.expression.LeafExpressionNode;
27  import org.apache.hadoop.hbase.security.visibility.expression.NonLeafExpressionNode;
28  import org.apache.hadoop.hbase.security.visibility.expression.Operator;
29  import org.junit.Test;
30  import org.junit.experimental.categories.Category;
31  
32  @Category(SmallTests.class)
33  public class TestExpressionParser {
34  
35    private ExpressionParser parser = new ExpressionParser();
36  
37    @Test
38    public void testPositiveCases() throws Exception {
39      // abc -> (abc)
40      ExpressionNode node = parser.parse("abc");
41      assertTrue(node instanceof LeafExpressionNode);
42      assertEquals("abc", ((LeafExpressionNode) node).getIdentifier());
43  
44      // a&b|c&d -> (((a & b) | c) & )
45      node = parser.parse("a&b|c&d");
46      assertTrue(node instanceof NonLeafExpressionNode);
47      NonLeafExpressionNode nlNode = (NonLeafExpressionNode) node;
48      assertEquals(Operator.AND, nlNode.getOperator());
49      assertEquals(2, nlNode.getChildExps().size());
50      assertEquals("d", ((LeafExpressionNode) nlNode.getChildExps().get(1)).getIdentifier());
51      assertTrue(nlNode.getChildExps().get(0) instanceof NonLeafExpressionNode);
52      nlNode = (NonLeafExpressionNode) nlNode.getChildExps().get(0);
53      assertEquals(Operator.OR, nlNode.getOperator());
54      assertEquals(2, nlNode.getChildExps().size());
55      assertEquals("c", ((LeafExpressionNode) nlNode.getChildExps().get(1)).getIdentifier());
56      assertTrue(nlNode.getChildExps().get(0) instanceof NonLeafExpressionNode);
57      nlNode = (NonLeafExpressionNode) nlNode.getChildExps().get(0);
58      assertEquals(Operator.AND, nlNode.getOperator());
59      assertEquals(2, nlNode.getChildExps().size());
60      assertEquals("b", ((LeafExpressionNode) nlNode.getChildExps().get(1)).getIdentifier());
61      assertEquals("a", ((LeafExpressionNode) nlNode.getChildExps().get(0)).getIdentifier());
62  
63      // (a) -> (a)
64      node = parser.parse("(a)");
65      assertTrue(node instanceof LeafExpressionNode);
66      assertEquals("a", ((LeafExpressionNode) node).getIdentifier());
67  
68      // (a&b) -> (a & b)
69      node = parser.parse(" ( a & b )");
70      assertTrue(node instanceof NonLeafExpressionNode);
71      nlNode = (NonLeafExpressionNode) node;
72      assertEquals(Operator.AND, nlNode.getOperator());
73      assertEquals(2, nlNode.getChildExps().size());
74      assertEquals("a", ((LeafExpressionNode) nlNode.getChildExps().get(0)).getIdentifier());
75      assertEquals("b", ((LeafExpressionNode) nlNode.getChildExps().get(1)).getIdentifier());
76  
77      // ((((a&b)))) -> (a & b)
78      node = parser.parse("((((a&b))))");
79      assertTrue(node instanceof NonLeafExpressionNode);
80      nlNode = (NonLeafExpressionNode) node;
81      assertEquals(Operator.AND, nlNode.getOperator());
82      assertEquals(2, nlNode.getChildExps().size());
83      assertEquals("a", ((LeafExpressionNode) nlNode.getChildExps().get(0)).getIdentifier());
84      assertEquals("b", ((LeafExpressionNode) nlNode.getChildExps().get(1)).getIdentifier());
85  
86      // (a|b)&(cc|def) -> ((a | b) & (cc | def))
87      node = parser.parse("( a | b ) & (cc|def)");
88      assertTrue(node instanceof NonLeafExpressionNode);
89      nlNode = (NonLeafExpressionNode) node;
90      assertEquals(Operator.AND, nlNode.getOperator());
91      assertEquals(2, nlNode.getChildExps().size());
92      assertTrue(nlNode.getChildExps().get(0) instanceof NonLeafExpressionNode);
93      assertTrue(nlNode.getChildExps().get(1) instanceof NonLeafExpressionNode);
94      NonLeafExpressionNode nlNodeLeft = (NonLeafExpressionNode) nlNode.getChildExps().get(0);
95      NonLeafExpressionNode nlNodeRight = (NonLeafExpressionNode) nlNode.getChildExps().get(1);
96      assertEquals(Operator.OR, nlNodeLeft.getOperator());
97      assertEquals(2, nlNodeLeft.getChildExps().size());
98      assertEquals("a", ((LeafExpressionNode) nlNodeLeft.getChildExps().get(0)).getIdentifier());
99      assertEquals("b", ((LeafExpressionNode) nlNodeLeft.getChildExps().get(1)).getIdentifier());
100     assertEquals(Operator.OR, nlNodeRight.getOperator());
101     assertEquals(2, nlNodeRight.getChildExps().size());
102     assertEquals("cc", ((LeafExpressionNode) nlNodeRight.getChildExps().get(0)).getIdentifier());
103     assertEquals("def", ((LeafExpressionNode) nlNodeRight.getChildExps().get(1)).getIdentifier());
104 
105     // a&(cc|de) -> (a & (cc | de))
106     node = parser.parse("a&(cc|de)");
107     assertTrue(node instanceof NonLeafExpressionNode);
108     nlNode = (NonLeafExpressionNode) node;
109     assertEquals(Operator.AND, nlNode.getOperator());
110     assertEquals(2, nlNode.getChildExps().size());
111     assertEquals("a", ((LeafExpressionNode) nlNode.getChildExps().get(0)).getIdentifier());
112     assertTrue(nlNode.getChildExps().get(1) instanceof NonLeafExpressionNode);
113     nlNode = (NonLeafExpressionNode) nlNode.getChildExps().get(1);
114     assertEquals(Operator.OR, nlNode.getOperator());
115     assertEquals(2, nlNode.getChildExps().size());
116     assertEquals("cc", ((LeafExpressionNode) nlNode.getChildExps().get(0)).getIdentifier());
117     assertEquals("de", ((LeafExpressionNode) nlNode.getChildExps().get(1)).getIdentifier());
118 
119     // (a&b)|c -> ((a & b) | c)
120     node = parser.parse("(a&b)|c");
121     assertTrue(node instanceof NonLeafExpressionNode);
122     nlNode = (NonLeafExpressionNode) node;
123     assertEquals(Operator.OR, nlNode.getOperator());
124     assertEquals(2, nlNode.getChildExps().size());
125     assertEquals("c", ((LeafExpressionNode) nlNode.getChildExps().get(1)).getIdentifier());
126     assertTrue(nlNode.getChildExps().get(0) instanceof NonLeafExpressionNode);
127     nlNode = (NonLeafExpressionNode) nlNode.getChildExps().get(0);
128     assertEquals(Operator.AND, nlNode.getOperator());
129     assertEquals(2, nlNode.getChildExps().size());
130     assertEquals("a", ((LeafExpressionNode) nlNode.getChildExps().get(0)).getIdentifier());
131     assertEquals("b", ((LeafExpressionNode) nlNode.getChildExps().get(1)).getIdentifier());
132 
133     // (a&b&c)|d -> (((a & b) & c) | d)
134     node = parser.parse("(a&b&c)|d");
135     assertTrue(node instanceof NonLeafExpressionNode);
136     nlNode = (NonLeafExpressionNode) node;
137     assertEquals(Operator.OR, nlNode.getOperator());
138     assertEquals(2, nlNode.getChildExps().size());
139     assertEquals("d", ((LeafExpressionNode) nlNode.getChildExps().get(1)).getIdentifier());
140     assertTrue(nlNode.getChildExps().get(0) instanceof NonLeafExpressionNode);
141     nlNode = (NonLeafExpressionNode) nlNode.getChildExps().get(0);
142     assertEquals(Operator.AND, nlNode.getOperator());
143     assertEquals(2, nlNode.getChildExps().size());
144     assertEquals("c", ((LeafExpressionNode) nlNode.getChildExps().get(1)).getIdentifier());
145     assertTrue(nlNode.getChildExps().get(0) instanceof NonLeafExpressionNode);
146     nlNode = (NonLeafExpressionNode) nlNode.getChildExps().get(0);
147     assertEquals(Operator.AND, nlNode.getOperator());
148     assertEquals(2, nlNode.getChildExps().size());
149     assertEquals("b", ((LeafExpressionNode) nlNode.getChildExps().get(1)).getIdentifier());
150     assertEquals("a", ((LeafExpressionNode) nlNode.getChildExps().get(0)).getIdentifier());
151 
152     // a&(b|(c|d)) -> (a & (b | (c | d)))
153     node = parser.parse("a&(b|(c|d))");
154     assertTrue(node instanceof NonLeafExpressionNode);
155     nlNode = (NonLeafExpressionNode) node;
156     assertEquals(Operator.AND, nlNode.getOperator());
157     assertEquals(2, nlNode.getChildExps().size());
158     assertEquals("a", ((LeafExpressionNode) nlNode.getChildExps().get(0)).getIdentifier());
159     assertTrue(nlNode.getChildExps().get(1) instanceof NonLeafExpressionNode);
160     nlNode = (NonLeafExpressionNode) nlNode.getChildExps().get(1);
161     assertEquals(Operator.OR, nlNode.getOperator());
162     assertEquals(2, nlNode.getChildExps().size());
163     assertEquals("b", ((LeafExpressionNode) nlNode.getChildExps().get(0)).getIdentifier());
164     assertTrue(nlNode.getChildExps().get(1) instanceof NonLeafExpressionNode);
165     nlNode = (NonLeafExpressionNode) nlNode.getChildExps().get(1);
166     assertEquals(Operator.OR, nlNode.getOperator());
167     assertEquals(2, nlNode.getChildExps().size());
168     assertEquals("c", ((LeafExpressionNode) nlNode.getChildExps().get(0)).getIdentifier());
169     assertEquals("d", ((LeafExpressionNode) nlNode.getChildExps().get(1)).getIdentifier());
170 
171     // (!a) -> (!a)
172     node = parser.parse("(!a)");
173     assertTrue(node instanceof NonLeafExpressionNode);
174     nlNode = (NonLeafExpressionNode) node;
175     assertEquals(Operator.NOT, nlNode.getOperator());
176     assertEquals("a", ((LeafExpressionNode) nlNode.getChildExps().get(0)).getIdentifier());
177 
178     // a&(!b) -> (a & (!b))
179     node = parser.parse("a&(!b)");
180     assertTrue(node instanceof NonLeafExpressionNode);
181     nlNode = (NonLeafExpressionNode) node;
182     assertEquals(Operator.AND, nlNode.getOperator());
183     assertEquals(2, nlNode.getChildExps().size());
184     assertEquals("a", ((LeafExpressionNode) nlNode.getChildExps().get(0)).getIdentifier());
185     assertTrue(nlNode.getChildExps().get(1) instanceof NonLeafExpressionNode);
186     nlNode = (NonLeafExpressionNode) nlNode.getChildExps().get(1);
187     assertEquals(Operator.NOT, nlNode.getOperator());
188     assertEquals(1, nlNode.getChildExps().size());
189     assertEquals("b", ((LeafExpressionNode) nlNode.getChildExps().get(0)).getIdentifier());
190 
191     // !a&b -> ((!a) & b)
192     node = parser.parse("!a&b");
193     assertTrue(node instanceof NonLeafExpressionNode);
194     nlNode = (NonLeafExpressionNode) node;
195     assertEquals(Operator.AND, nlNode.getOperator());
196     assertEquals(2, nlNode.getChildExps().size());
197     assertEquals("b", ((LeafExpressionNode) nlNode.getChildExps().get(1)).getIdentifier());
198     assertTrue(nlNode.getChildExps().get(0) instanceof NonLeafExpressionNode);
199     nlNode = (NonLeafExpressionNode) nlNode.getChildExps().get(0);
200     assertEquals(Operator.NOT, nlNode.getOperator());
201     assertEquals(1, nlNode.getChildExps().size());
202     assertEquals("a", ((LeafExpressionNode) nlNode.getChildExps().get(0)).getIdentifier());
203 
204     // !a&(!b) -> ((!a) & (!b))
205     node = parser.parse("!a&(!b)");
206     assertTrue(node instanceof NonLeafExpressionNode);
207     nlNode = (NonLeafExpressionNode) node;
208     assertEquals(Operator.AND, nlNode.getOperator());
209     assertEquals(2, nlNode.getChildExps().size());
210     assertTrue(nlNode.getChildExps().get(0) instanceof NonLeafExpressionNode);
211     assertTrue(nlNode.getChildExps().get(1) instanceof NonLeafExpressionNode);
212     nlNodeLeft = (NonLeafExpressionNode) nlNode.getChildExps().get(0);
213     nlNodeRight = (NonLeafExpressionNode) nlNode.getChildExps().get(1);
214     assertEquals(Operator.NOT, nlNodeLeft.getOperator());
215     assertEquals(1, nlNodeLeft.getChildExps().size());
216     assertEquals("a", ((LeafExpressionNode) nlNodeLeft.getChildExps().get(0)).getIdentifier());
217     assertEquals(Operator.NOT, nlNodeRight.getOperator());
218     assertEquals(1, nlNodeRight.getChildExps().size());
219     assertEquals("b", ((LeafExpressionNode) nlNodeRight.getChildExps().get(0)).getIdentifier());
220 
221     // !a&!b -> ((!a) & (!b))
222     node = parser.parse("!a&!b");
223     assertTrue(node instanceof NonLeafExpressionNode);
224     nlNode = (NonLeafExpressionNode) node;
225     assertEquals(Operator.AND, nlNode.getOperator());
226     assertEquals(2, nlNode.getChildExps().size());
227     assertTrue(nlNode.getChildExps().get(0) instanceof NonLeafExpressionNode);
228     assertTrue(nlNode.getChildExps().get(1) instanceof NonLeafExpressionNode);
229     nlNodeLeft = (NonLeafExpressionNode) nlNode.getChildExps().get(0);
230     nlNodeRight = (NonLeafExpressionNode) nlNode.getChildExps().get(1);
231     assertEquals(Operator.NOT, nlNodeLeft.getOperator());
232     assertEquals(1, nlNodeLeft.getChildExps().size());
233     assertEquals("a", ((LeafExpressionNode) nlNodeLeft.getChildExps().get(0)).getIdentifier());
234     assertEquals(Operator.NOT, nlNodeRight.getOperator());
235     assertEquals(1, nlNodeRight.getChildExps().size());
236     assertEquals("b", ((LeafExpressionNode) nlNodeRight.getChildExps().get(0)).getIdentifier());
237 
238     // !(a&b) -> (!(a & b))
239     node = parser.parse("!(a&b)");
240     assertTrue(node instanceof NonLeafExpressionNode);
241     nlNode = (NonLeafExpressionNode) node;
242     assertEquals(Operator.NOT, nlNode.getOperator());
243     assertEquals(1, nlNode.getChildExps().size());
244     nlNode = (NonLeafExpressionNode) nlNode.getChildExps().get(0);
245     assertEquals(Operator.AND, nlNode.getOperator());
246     assertEquals(2, nlNode.getChildExps().size());
247     assertEquals("a", ((LeafExpressionNode) nlNode.getChildExps().get(0)).getIdentifier());
248     assertEquals("b", ((LeafExpressionNode) nlNode.getChildExps().get(1)).getIdentifier());
249 
250     // a&!b -> (a & (!b))
251     node = parser.parse("a&!b");
252     assertTrue(node instanceof NonLeafExpressionNode);
253     nlNode = (NonLeafExpressionNode) node;
254     assertEquals(Operator.AND, nlNode.getOperator());
255     assertEquals(2, nlNode.getChildExps().size());
256     assertEquals("a", ((LeafExpressionNode) nlNode.getChildExps().get(0)).getIdentifier());
257     assertTrue(nlNode.getChildExps().get(1) instanceof NonLeafExpressionNode);
258     nlNode = (NonLeafExpressionNode) nlNode.getChildExps().get(1);
259     assertEquals(Operator.NOT, nlNode.getOperator());
260     assertEquals(1, nlNode.getChildExps().size());
261     assertEquals("b", ((LeafExpressionNode) nlNode.getChildExps().get(0)).getIdentifier());
262 
263     // !((a|b)&!(c&!b)) -> (!((a | b) & (!(c & (!b)))))
264     node = parser.parse("!((a | b) & !(c & !b))");
265     assertTrue(node instanceof NonLeafExpressionNode);
266     nlNode = (NonLeafExpressionNode) node;
267     assertEquals(Operator.NOT, nlNode.getOperator());
268     assertEquals(1, nlNode.getChildExps().size());
269     nlNode = (NonLeafExpressionNode) nlNode.getChildExps().get(0);
270     assertEquals(Operator.AND, nlNode.getOperator());
271     assertEquals(2, nlNode.getChildExps().size());
272     assertTrue(nlNode.getChildExps().get(0) instanceof NonLeafExpressionNode);
273     assertTrue(nlNode.getChildExps().get(1) instanceof NonLeafExpressionNode);
274     nlNodeLeft = (NonLeafExpressionNode) nlNode.getChildExps().get(0);
275     nlNodeRight = (NonLeafExpressionNode) nlNode.getChildExps().get(1);
276     assertEquals(Operator.OR, nlNodeLeft.getOperator());
277     assertEquals("a", ((LeafExpressionNode) nlNodeLeft.getChildExps().get(0)).getIdentifier());
278     assertEquals("b", ((LeafExpressionNode) nlNodeLeft.getChildExps().get(1)).getIdentifier());
279     assertEquals(Operator.NOT, nlNodeRight.getOperator());
280     assertEquals(1, nlNodeRight.getChildExps().size());
281     nlNodeRight = (NonLeafExpressionNode) nlNodeRight.getChildExps().get(0);
282     assertEquals(Operator.AND, nlNodeRight.getOperator());
283     assertEquals(2, nlNodeRight.getChildExps().size());
284     assertEquals("c", ((LeafExpressionNode) nlNodeRight.getChildExps().get(0)).getIdentifier());
285     assertTrue(nlNodeRight.getChildExps().get(1) instanceof NonLeafExpressionNode);
286     nlNodeRight = (NonLeafExpressionNode) nlNodeRight.getChildExps().get(1);
287     assertEquals(Operator.NOT, nlNodeRight.getOperator());
288     assertEquals(1, nlNodeRight.getChildExps().size());
289     assertEquals("b", ((LeafExpressionNode) nlNodeRight.getChildExps().get(0)).getIdentifier());
290   }
291 
292   @Test
293   public void testNegativeCases() throws Exception {
294     executeNegativeCase("(");
295     executeNegativeCase(")");
296     executeNegativeCase("()");
297     executeNegativeCase("(a");
298     executeNegativeCase("a&");
299     executeNegativeCase("a&|b");
300     executeNegativeCase("!");
301     executeNegativeCase("a!");
302     executeNegativeCase("a!&");
303     executeNegativeCase("&");
304     executeNegativeCase("|");
305     executeNegativeCase("!(a|(b&c)&!b");
306     executeNegativeCase("!!a");
307     executeNegativeCase("( a & b ) | ( c & d e)");
308     executeNegativeCase("! a");
309   }
310 
311   @Test
312   public void testNonAsciiCases() throws Exception {
313     ExpressionNode node = parser.parse(CellVisibility.quote("\u0027") + "&"
314         + CellVisibility.quote("\u002b") + "|" + CellVisibility.quote("\u002d") + "&"
315         + CellVisibility.quote("\u003f"));
316     assertTrue(node instanceof NonLeafExpressionNode);
317     NonLeafExpressionNode nlNode = (NonLeafExpressionNode) node;
318     assertEquals(Operator.AND, nlNode.getOperator());
319     assertEquals(2, nlNode.getChildExps().size());
320     assertEquals("\u003f", ((LeafExpressionNode) nlNode.getChildExps().get(1)).getIdentifier());
321     assertTrue(nlNode.getChildExps().get(0) instanceof NonLeafExpressionNode);
322     nlNode = (NonLeafExpressionNode) nlNode.getChildExps().get(0);
323     assertEquals(Operator.OR, nlNode.getOperator());
324     assertEquals(2, nlNode.getChildExps().size());
325     assertEquals("\u002d", ((LeafExpressionNode) nlNode.getChildExps().get(1)).getIdentifier());
326     assertTrue(nlNode.getChildExps().get(0) instanceof NonLeafExpressionNode);
327     nlNode = (NonLeafExpressionNode) nlNode.getChildExps().get(0);
328     assertEquals(Operator.AND, nlNode.getOperator());
329     assertEquals(2, nlNode.getChildExps().size());
330     assertEquals("\u002b", ((LeafExpressionNode) nlNode.getChildExps().get(1)).getIdentifier());
331     assertEquals("\u0027", ((LeafExpressionNode) nlNode.getChildExps().get(0)).getIdentifier());
332 
333     node = parser.parse(CellVisibility.quote("\u0027") + "&" + CellVisibility.quote("\u002b") + "|"
334         + CellVisibility.quote("\u002d") + "&" + CellVisibility.quote("\u003f"));
335     assertTrue(node instanceof NonLeafExpressionNode);
336     nlNode = (NonLeafExpressionNode) node;
337     assertEquals(Operator.AND, nlNode.getOperator());
338     assertEquals(2, nlNode.getChildExps().size());
339     assertEquals("\u003f", ((LeafExpressionNode) nlNode.getChildExps().get(1)).getIdentifier());
340     assertTrue(nlNode.getChildExps().get(0) instanceof NonLeafExpressionNode);
341     nlNode = (NonLeafExpressionNode) nlNode.getChildExps().get(0);
342     assertEquals(Operator.OR, nlNode.getOperator());
343     assertEquals(2, nlNode.getChildExps().size());
344     assertEquals("\u002d", ((LeafExpressionNode) nlNode.getChildExps().get(1)).getIdentifier());
345     assertTrue(nlNode.getChildExps().get(0) instanceof NonLeafExpressionNode);
346     nlNode = (NonLeafExpressionNode) nlNode.getChildExps().get(0);
347     assertEquals(Operator.AND, nlNode.getOperator());
348     assertEquals(2, nlNode.getChildExps().size());
349     assertEquals("\u002b", ((LeafExpressionNode) nlNode.getChildExps().get(1)).getIdentifier());
350     assertEquals("\u0027", ((LeafExpressionNode) nlNode.getChildExps().get(0)).getIdentifier());
351   }
352 
353   @Test
354   public void testCasesSeperatedByDoubleQuotes() throws Exception {
355     ExpressionNode node = null;
356     try {
357       node = parser.parse("\u0027&\"|\u002b&\u003f");
358       fail("Excpetion must be thrown as there are special characters without quotes");
359     } catch (ParseException e) {
360     }
361     node = parser.parse(CellVisibility.quote("\u0027") + "&" + CellVisibility.quote("\"") + "|"
362         + CellVisibility.quote("\u002b" + "&" + "\u003f"));
363     assertTrue(node instanceof NonLeafExpressionNode);
364     NonLeafExpressionNode nlNode = (NonLeafExpressionNode) node;
365     assertEquals(Operator.OR, nlNode.getOperator());
366     assertEquals(2, nlNode.getChildExps().size());
367     assertEquals("\u002b" + "&" + "\u003f",
368         ((LeafExpressionNode) nlNode.getChildExps().get(1)).getIdentifier());
369     assertTrue(nlNode.getChildExps().get(0) instanceof NonLeafExpressionNode);
370     nlNode = (NonLeafExpressionNode) nlNode.getChildExps().get(0);
371     assertEquals(Operator.AND, nlNode.getOperator());
372     assertEquals(2, nlNode.getChildExps().size());
373     assertEquals("\"", ((LeafExpressionNode) nlNode.getChildExps().get(1)).getIdentifier());
374     assertEquals("\u0027", ((LeafExpressionNode) nlNode.getChildExps().get(0)).getIdentifier());
375     try {
376       node = parser.parse(CellVisibility.quote("\u0027&\\") + "|"
377           + CellVisibility.quote("\u002b" + "&" + "\\") + CellVisibility.quote("$$\""));
378       fail("Excpetion must be thrown as there is not operator");
379     } catch (ParseException e) {
380     }
381     node = parser.parse(CellVisibility.quote("\u0027" + "&" + "\\") + "|"
382         + CellVisibility.quote("\u003f" + "&" + "\\") + "&" + CellVisibility.quote("$$\""));
383     assertTrue(node instanceof NonLeafExpressionNode);
384     nlNode = (NonLeafExpressionNode) node;
385     assertEquals(Operator.AND, nlNode.getOperator());
386     assertEquals(2, nlNode.getChildExps().size());
387     assertEquals("$$\"", ((LeafExpressionNode) nlNode.getChildExps().get(1)).getIdentifier());
388     assertTrue(nlNode.getChildExps().get(0) instanceof NonLeafExpressionNode);
389     nlNode = (NonLeafExpressionNode) nlNode.getChildExps().get(0);
390     assertEquals(Operator.OR, nlNode.getOperator());
391     assertEquals(2, nlNode.getChildExps().size());
392     assertEquals("\u0027" + "&" + "\\",
393         ((LeafExpressionNode) nlNode.getChildExps().get(0)).getIdentifier());
394     assertEquals("\u003f" + "&" + "\\",
395         ((LeafExpressionNode) nlNode.getChildExps().get(1)).getIdentifier());
396     try {
397       node = parser.parse(CellVisibility.quote("\u002b&\\") + "|" + CellVisibility.quote("\u0027&\\") + "&"
398           + "\"$$");
399       fail("Excpetion must be thrown as there is no end quote");
400     } catch (ParseException e) {
401     }
402   }
403 
404   private void executeNegativeCase(String exp) {
405     try {
406       parser.parse(exp);
407       fail("Expected ParseException for expression " + exp);
408     } catch (ParseException e) {
409     }
410   }
411 }