blob: 7c2357e4a6304a765831f695f832ed5d2c53ca2e [file] [log] [blame]
/*******************************************************************************
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
******************************************************************************/
package org.apache.olingo.odata2.core.uri.expression;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.util.Locale;
import org.apache.olingo.odata2.api.edm.EdmEntityType;
import org.apache.olingo.odata2.api.edm.EdmProperty;
import org.apache.olingo.odata2.api.edm.EdmType;
import org.apache.olingo.odata2.api.exception.MessageReference;
import org.apache.olingo.odata2.api.exception.ODataApplicationException;
import org.apache.olingo.odata2.api.exception.ODataMessageException;
import org.apache.olingo.odata2.api.uri.expression.CommonExpression;
import org.apache.olingo.odata2.api.uri.expression.ExceptionVisitExpression;
import org.apache.olingo.odata2.api.uri.expression.ExpressionKind;
import org.apache.olingo.odata2.api.uri.expression.ExpressionParserException;
import org.apache.olingo.odata2.api.uri.expression.ExpressionVisitor;
import org.apache.olingo.odata2.api.uri.expression.SortOrder;
import org.apache.olingo.odata2.core.exception.MessageService;
import org.apache.olingo.odata2.core.exception.MessageService.Message;
import org.junit.Test;
/**
* Helper for testing the expression parser.
*/
public class ParserTool {
private String expression;
private CommonExpression tree;
private CommonExpression curNode;
private Exception curException;
private static final Locale DEFAULT_LANGUAGE = new Locale("test", "FOO");
public ParserTool(final String expression, final boolean isOrder, final boolean addTestfunctions,
final boolean allowOnlyBinary, final EdmEntityType resourceEntityType) {
this.expression = expression;
try {
if (isOrder) {
tree = new OrderByParserImpl(resourceEntityType).parseOrderByString(expression);
} else {
FilterParserImplTool parser = new FilterParserImplTool(resourceEntityType);
if (addTestfunctions) {
parser.addTestfunctions();
}
tree = parser.parseFilterString(expression, allowOnlyBinary).getExpression();
}
} catch (ExpressionParserException e) {
curException = e;
} catch (ExpressionParserInternalError e) {
curException = e;
}
curNode = tree;
}
ParserTool aKind(final ExpressionKind kind) {
String info = "GetInfoKind(" + expression + ")-->";
assertEquals(info, kind, curNode.getKind());
return this;
}
public ParserTool aUriLiteral(final String uriLiteral) {
String info = "GetUriLiteral(" + expression + ")-->";
assertEquals(info, uriLiteral, curNode.getUriLiteral());
return this;
}
/**
* Verifies that the thrown exception is of {@paramref expected}
*
* @param expected
* Expected Exception class
* @return ParserTool
*/
public ParserTool aExType(final Class<? extends Exception> expected) {
String info = "GetExceptionType(" + expression + ")-->";
assertNotNull(info, curException);
assertTrue(info, expected.isAssignableFrom(curException.getClass()));
return this;
}
/**
* Verifies that the message text of the thrown exception serialized is {@paramref messageText}
*
* @param messageText
* Expected message text
* @return this
*/
public ParserTool aExMsgText(final String messageText) {
String info = "aExMessageText(" + expression + ")-->";
aExType(ODataMessageException.class);
info = " " + info + "Expected: '" + messageText + "' Actual: '" + getExceptionText() + "'";
assertEquals(info, messageText, getExceptionText());
return this;
}
/**
* Verifies that all place holders in the message text definition of the
* thrown exception are provided with content
*
* @return ParserTool
*/
public ParserTool aExMsgContentAllSet() {
String info = "aExMessageTextNoEmptyTag(" + expression + ")-->";
aExType(ODataMessageException.class);
info = " " + info + "Messagetext: '" + getExceptionText() + "contains [%";
assertFalse(info, getExceptionText().contains("[%"));
return this;
}
/**
* Verifies that the message text of the thrown exception is not empty
*
* @return ParserTool
*/
public ParserTool aExMsgNotEmpty() {
String info = "aExMsgNotEmpty(" + expression + ")-->";
aExType(ODataMessageException.class);
info = " " + info + "check if Messagetext is empty";
assertFalse(info, getExceptionText().isEmpty());
return this;
}
public ParserTool aExKey(final MessageReference expressionExpectedAtPos) {
String info = "GetExceptionType(" + expression + ")-->";
aExType(ODataMessageException.class);
assertEquals(info, expressionExpectedAtPos.getKey(),
((ODataMessageException) curException).getMessageReference().getKey());
return this;
}
public String getExceptionText() {
ODataMessageException messageException = (ODataMessageException) curException;
Message ms = MessageService.getMessage(DEFAULT_LANGUAGE, messageException.getMessageReference());
return ms.getText();
}
public ParserTool aEdmType(final EdmType type) {
assertNull("aEdmType", curException);
String info = "GetEdmType(" + expression + ")-->";
assertNotNull(curNode.getEdmType());
assertEquals(info, type, curNode.getEdmType());
return this;
}
public ParserTool aSortOrder(final SortOrder orderType) {
String info = "GetSortOrder(" + expression + ")-->";
aKind(ExpressionKind.ORDER);
assertEquals(info, orderType, ((OrderExpressionImpl) curNode).getSortOrder());
return this;
}
public ParserTool aExpr() {
String info = "GetExpr(" + expression + ")-->";
aKind(ExpressionKind.ORDER);
curNode = ((OrderExpressionImpl) curNode).getExpression();
assertNotNull(info, curNode);
return this;
}
public ParserTool aEdmProperty(final EdmProperty property) {
String info = "GetEdmProperty(" + expression + ")-->";
aKind(ExpressionKind.PROPERTY);
assertEquals(info, property, ((PropertyExpressionImpl) curNode).getEdmProperty());
return this;
}
public ParserTool aSerializedCompr(final String expected) {
aSerialized(compress(expected));
return this;
}
public ParserTool aSerialized(final String expected) {
assertNull("aSerialized", curException);
String actual = null;
ExpressionVisitor visitor = new VisitorTool();
try {
actual = tree.accept(visitor).toString();
} catch (ExceptionVisitExpression e) {
fail("Error in visitor:" + e.getLocalizedMessage());
} catch (ODataApplicationException e) {
fail("Error in visitor:" + e.getLocalizedMessage());
}
String info = "GetSerialized(" + expression + ")-->";
assertEquals(info, expected, actual);
return this;
}
public ParserTool left() {
String info = "param(" + expression + ")-->";
assertTrue(info, curNode.getKind() == ExpressionKind.BINARY
|| curNode.getKind() == ExpressionKind.UNARY
|| curNode.getKind() == ExpressionKind.MEMBER);
if (curNode.getKind() == ExpressionKind.BINARY) {
curNode = ((BinaryExpressionImpl) curNode).getLeftOperand();
} else if (curNode.getKind() == ExpressionKind.UNARY) {
curNode = ((UnaryExpressionImpl) curNode).getOperand();
} else if (curNode.getKind() == ExpressionKind.MEMBER) {
curNode = ((MemberExpressionImpl) curNode).getPath();
}
return this;
}
public ParserTool right() {
String info = "param(" + expression + ")-->";
assertTrue(info, curNode.getKind() == ExpressionKind.BINARY
|| curNode.getKind() == ExpressionKind.UNARY
|| curNode.getKind() == ExpressionKind.MEMBER);
if (curNode.getKind() == ExpressionKind.BINARY) {
curNode = ((BinaryExpressionImpl) curNode).getRightOperand();
} else if (curNode.getKind() == ExpressionKind.UNARY) {
curNode = ((UnaryExpressionImpl) curNode).getOperand();
} else if (curNode.getKind() == ExpressionKind.MEMBER) {
curNode = ((MemberExpressionImpl) curNode).getProperty();
}
return this;
}
public ParserTool order(final int i) {
String info = "param(" + expression + ")-->";
aKind(ExpressionKind.ORDERBY);
OrderByExpressionImpl orderByExpressionImpl = (OrderByExpressionImpl) curNode;
assertTrue(info, i < orderByExpressionImpl.getOrdersCount());
curNode = orderByExpressionImpl.getOrders().get(i);
return this;
}
public ParserTool param(final int i) {
String info = "param(" + expression + ")-->";
aKind(ExpressionKind.METHOD);
MethodExpressionImpl methodExpressionImpl = (MethodExpressionImpl) curNode;
assertTrue(info, i < methodExpressionImpl.getParameterCount());
curNode = methodExpressionImpl.getParameters().get(i);
return this;
}
public ParserTool root() {
curNode = tree;
return this;
}
static public String compress(final String expression) {
String ret = "";
char[] charArray = expression.trim().toCharArray();
Character oldChar = null;
for (char x : charArray) {
if ((x != ' ') || (oldChar == null) || (oldChar != ' ')) {
ret += x;
}
oldChar = x;
}
ret = ret.replace("{ ", "{");
ret = ret.replace(" }", "}");
return ret;
}
public static class testParserTool {
@Test
public void testCompr() {
// leading and trailing spaces
assertEquals("Error in parsertool", compress(" a"), "a");
assertEquals("Error in parsertool", compress("a "), "a");
assertEquals("Error in parsertool", compress(" a "), "a");
assertEquals("Error in parsertool", compress("{ a}"), "{a}");
assertEquals("Error in parsertool", compress("{ a}"), "{a}");
assertEquals("Error in parsertool", compress("{a }"), "{a}");
assertEquals("Error in parsertool", compress("{ a }"), "{a}");
assertEquals("Error in parsertool", compress("{ a }"), "{a}");
assertEquals("Error in parsertool", compress("{ a a }"), "{a a}");
assertEquals("Error in parsertool", compress("{ a a }"), "{a a}");
assertEquals("Error in parsertool", compress(" { a a } "), "{a a}");
assertEquals("Error in parsertool", compress(" { a { } a } "), "{a {} a}");
}
}
}