| /******************************************************************************* |
| * 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.edm; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertTrue; |
| import static org.junit.Assert.fail; |
| |
| import org.apache.olingo.odata2.api.edm.EdmException; |
| import org.apache.olingo.odata2.api.edm.EdmLiteral; |
| import org.apache.olingo.odata2.api.edm.EdmLiteralException; |
| import org.apache.olingo.odata2.api.edm.EdmSimpleType; |
| import org.apache.olingo.odata2.api.edm.EdmSimpleTypeKind; |
| import org.apache.olingo.odata2.api.exception.MessageReference; |
| import org.apache.olingo.odata2.api.uri.UriSyntaxException; |
| import org.apache.olingo.odata2.testutil.fit.BaseTest; |
| import org.junit.Test; |
| |
| /** |
| * Tests for the parsing of URI literals |
| * |
| */ |
| public class EdmSimpleTypeFacadeTest extends BaseTest { |
| |
| public static void parse(final String literal, final EdmSimpleType expectedType) throws EdmLiteralException { |
| final EdmLiteral uriLiteral = EdmSimpleTypeKind.parseUriLiteral(literal); |
| assertNotNull(uriLiteral); |
| if (!expectedType.equals(EdmNull.getInstance())) { |
| assertNotNull(uriLiteral.getLiteral()); |
| assertTrue(uriLiteral.getLiteral().length() > 0); |
| } |
| assertNotNull(uriLiteral.getType()); |
| assertEquals(expectedType, uriLiteral.getType()); |
| } |
| |
| public static void compare(final EdmSimpleTypeKind simpleType) { |
| final EdmSimpleType bin1 = simpleType.getEdmSimpleTypeInstance(); |
| assertNotNull(bin1); |
| |
| final EdmSimpleType bin2 = simpleType.getEdmSimpleTypeInstance(); |
| assertNotNull(bin2); |
| |
| assertEquals(bin1, bin2); |
| } |
| |
| @Test |
| public void parseUriLiteralBinary() throws EdmLiteralException { |
| parse("X'Fa12aAA1'", EdmBinary.getInstance()); |
| parse("binary'FA12AAA1'", EdmBinary.getInstance()); |
| } |
| |
| @Test |
| public void parseUriLiteralBoolean() throws EdmLiteralException { |
| parse("true", EdmBoolean.getInstance()); |
| parse("false", EdmBoolean.getInstance()); |
| } |
| |
| @Test |
| public void parseUriLiteralBit() throws EdmLiteralException { |
| parse("1", Bit.getInstance()); |
| parse("0", Bit.getInstance()); |
| } |
| |
| @Test |
| public void parseUriLiteralByte() throws EdmLiteralException { |
| parse("255", EdmByte.getInstance()); |
| } |
| |
| @Test |
| public void parseUriLiteralUint7() throws EdmLiteralException { |
| parse("123", Uint7.getInstance()); |
| parse("111", Uint7.getInstance()); |
| parse("42", Uint7.getInstance()); |
| } |
| |
| @Test |
| public void parseUriLiteralDateTime() throws EdmLiteralException { |
| parse("datetime'2009-12-26T21:23:38'", EdmDateTime.getInstance()); |
| } |
| |
| @Test |
| public void parseUriLiteralDateTimeOffset() throws EdmLiteralException { |
| parse("datetimeoffset'2009-12-26T21:23:38Z'", EdmDateTimeOffset.getInstance()); |
| parse("datetimeoffset'2002-10-10T12:00:00-05:00'", EdmDateTimeOffset.getInstance()); |
| parse("datetimeoffset'2009-12-26T21:23:38'", EdmDateTimeOffset.getInstance()); |
| } |
| |
| @Test |
| public void parseUriLiteralDecimal() throws EdmLiteralException { |
| parse("4.5m", EdmDecimal.getInstance()); |
| parse("4.5M", EdmDecimal.getInstance()); |
| } |
| |
| @Test |
| public void parseUriLiteralDouble() throws EdmLiteralException { |
| parse("4.5d", EdmDouble.getInstance()); |
| parse("4.5D", EdmDouble.getInstance()); |
| } |
| |
| @Test |
| public void parseUriLiteralGuid() throws EdmLiteralException { |
| parse("guid'1225c695-cfb8-4ebb-aaaa-80da344efa6a'", EdmGuid.getInstance()); |
| } |
| |
| @Test |
| public void parseUriLiteralInt16() throws EdmLiteralException { |
| parse("-32768", EdmInt16.getInstance()); |
| parse("3276", EdmInt16.getInstance()); |
| } |
| |
| @Test |
| public void parseUriLiteralInt32() throws EdmLiteralException { |
| parse("-327687", EdmInt32.getInstance()); |
| parse("32768", EdmInt32.getInstance()); |
| } |
| |
| @Test |
| public void parseUriLiteralInt64() throws EdmLiteralException { |
| parse("64l", EdmInt64.getInstance()); |
| parse("64L", EdmInt64.getInstance()); |
| } |
| |
| @Test |
| public void parseUriLiteralNull() throws EdmLiteralException { |
| parse(null, EdmNull.getInstance()); |
| parse("null", EdmNull.getInstance()); |
| } |
| |
| @Test |
| public void parseUriLiteralSByte() throws EdmLiteralException { |
| parse("-123", EdmSByte.getInstance()); |
| } |
| |
| @Test |
| public void parseUriLiteralSingle() throws EdmLiteralException { |
| parse("4.5f", EdmSingle.getInstance()); |
| parse("4.5F", EdmSingle.getInstance()); |
| parse("-INF", EdmSingle.getInstance()); |
| parse("INF", EdmSingle.getInstance()); |
| parse("NaN", EdmSingle.getInstance()); |
| } |
| |
| @Test |
| public void parseUriLiteralString() throws EdmLiteralException { |
| parse("'abc'", EdmString.getInstance()); |
| } |
| |
| @Test |
| public void parseUriLiteralTime() throws EdmLiteralException { |
| parse("time'PT120S'", EdmTime.getInstance()); |
| } |
| |
| @Test |
| public void compareTypes() { |
| compare(EdmSimpleTypeKind.Binary); |
| compare(EdmSimpleTypeKind.Boolean); |
| compare(EdmSimpleTypeKind.Byte); |
| compare(EdmSimpleTypeKind.SByte); |
| compare(EdmSimpleTypeKind.DateTime); |
| compare(EdmSimpleTypeKind.DateTimeOffset); |
| compare(EdmSimpleTypeKind.Decimal); |
| compare(EdmSimpleTypeKind.Double); |
| compare(EdmSimpleTypeKind.Guid); |
| compare(EdmSimpleTypeKind.Int16); |
| compare(EdmSimpleTypeKind.Int32); |
| compare(EdmSimpleTypeKind.Int64); |
| compare(EdmSimpleTypeKind.Single); |
| compare(EdmSimpleTypeKind.Time); |
| } |
| |
| /** |
| * Parse a URI literal value string and assert that it is compatible |
| * to the given EDM simple type and has the correct parsed value. |
| * |
| * @param literal |
| * the URI literal value to be parsed as string |
| * @param typeKind |
| * the {@link EdmSimpleTypeKind} the URI literal should be compatible to |
| * @param expectedLiteral |
| * the expected literal value |
| * @throws UriSyntaxException |
| * @throws EdmException |
| */ |
| private void parseLiteral(final String literal, final EdmSimpleTypeKind typeKind, final String expectedLiteral) |
| throws UriSyntaxException, EdmException { |
| final EdmLiteral uriLiteral = EdmSimpleTypeKind.parseUriLiteral(literal); |
| |
| assertTrue(typeKind.getEdmSimpleTypeInstance().isCompatible(uriLiteral.getType())); |
| assertEquals(expectedLiteral, uriLiteral.getLiteral()); |
| } |
| |
| @Test |
| public void parseDecimal() throws Exception { |
| parseLiteral("4.5m", EdmSimpleTypeKind.Decimal, "4.5"); |
| parseLiteral("4.5M", EdmSimpleTypeKind.Decimal, "4.5"); |
| parseLiteral("1", EdmSimpleTypeKind.Decimal, "1"); |
| parseLiteral("255", EdmSimpleTypeKind.Decimal, "255"); |
| parseLiteral("-32768", EdmSimpleTypeKind.Decimal, "-32768"); |
| parseLiteral("32768", EdmSimpleTypeKind.Decimal, "32768"); |
| parseLiteral("3000000", EdmSimpleTypeKind.Decimal, "3000000"); |
| parseLiteral("4.5d", EdmSimpleTypeKind.Decimal, "4.5"); |
| parseLiteral("4.2E9F", EdmSimpleTypeKind.Decimal, "4.2E9"); |
| parseLiteral("1234567890", EdmSimpleTypeKind.Decimal, "1234567890"); |
| } |
| |
| @Test |
| public void parseInt16() throws Exception { |
| parseLiteral("16", EdmSimpleTypeKind.Int16, "16"); |
| parseLiteral("-16", EdmSimpleTypeKind.Int16, "-16"); |
| parseLiteral("255", EdmSimpleTypeKind.Int16, "255"); |
| parseLiteral("-32768", EdmSimpleTypeKind.Int16, "-32768"); |
| |
| } |
| |
| @Test |
| public void parseInt32() throws Exception { |
| parseLiteral("32", EdmSimpleTypeKind.Int32, "32"); |
| parseLiteral("-127", EdmSimpleTypeKind.Int32, "-127"); |
| parseLiteral("255", EdmSimpleTypeKind.Int32, "255"); |
| parseLiteral("32767", EdmSimpleTypeKind.Int32, "32767"); |
| parseLiteral("-32769", EdmSimpleTypeKind.Int32, "-32769"); |
| } |
| |
| @Test |
| public void parseInt64() throws Exception { |
| parseLiteral("64", EdmSimpleTypeKind.Int64, "64"); |
| parseLiteral("255", EdmSimpleTypeKind.Int64, "255"); |
| parseLiteral("1000", EdmSimpleTypeKind.Int64, "1000"); |
| parseLiteral("100000", EdmSimpleTypeKind.Int64, "100000"); |
| parseLiteral("-64L", EdmSimpleTypeKind.Int64, "-64"); |
| parseLiteral("" + Long.MAX_VALUE + "L", EdmSimpleTypeKind.Int64, "" + Long.MAX_VALUE); |
| parseLiteral("" + Long.MIN_VALUE + "l", EdmSimpleTypeKind.Int64, "" + Long.MIN_VALUE); |
| } |
| |
| @Test |
| public void parseString() throws Exception { |
| parseLiteral("'abc'", EdmSimpleTypeKind.String, "abc"); |
| parseLiteral("'true'", EdmSimpleTypeKind.String, "true"); |
| parseLiteral("''", EdmSimpleTypeKind.String, ""); |
| } |
| |
| @Test |
| public void parseSingle() throws Exception { |
| parseLiteral("45", EdmSimpleTypeKind.Single, "45"); |
| parseLiteral("255", EdmSimpleTypeKind.Single, "255"); |
| parseLiteral("-32768", EdmSimpleTypeKind.Single, "-32768"); |
| parseLiteral("32768", EdmSimpleTypeKind.Single, "32768"); |
| parseLiteral("1L", EdmSimpleTypeKind.Single, "1"); |
| parseLiteral("4.5f", EdmSimpleTypeKind.Single, "4.5"); |
| parseLiteral("4.5F", EdmSimpleTypeKind.Single, "4.5"); |
| parseLiteral("4.5e9f", EdmSimpleTypeKind.Single, "4.5e9"); |
| parseLiteral("-INF", EdmSimpleTypeKind.Single, "-INF"); |
| parseLiteral("INF", EdmSimpleTypeKind.Single, "INF"); |
| parseLiteral("NaN", EdmSimpleTypeKind.Single, "NaN"); |
| } |
| |
| @Test |
| public void parseDouble() throws Exception { |
| parseLiteral("45", EdmSimpleTypeKind.Double, "45"); |
| parseLiteral("255", EdmSimpleTypeKind.Double, "255"); |
| parseLiteral("-32768", EdmSimpleTypeKind.Double, "-32768"); |
| parseLiteral("32768", EdmSimpleTypeKind.Double, "32768"); |
| parseLiteral("1l", EdmSimpleTypeKind.Double, "1"); |
| parseLiteral("4.5d", EdmSimpleTypeKind.Double, "4.5"); |
| parseLiteral("4.5D", EdmSimpleTypeKind.Double, "4.5"); |
| parseLiteral("4.5e21f", EdmSimpleTypeKind.Double, "4.5e21"); |
| } |
| |
| @Test |
| public void parseByte() throws Exception { |
| parseLiteral("255", EdmSimpleTypeKind.Byte, "255"); |
| parseLiteral("123", EdmSimpleTypeKind.Byte, "123"); |
| } |
| |
| @Test |
| public void parseGuid() throws Exception { |
| parseLiteral("guid'1225c695-cfb8-4ebb-aaaa-80da344efa6a'", EdmSimpleTypeKind.Guid, |
| "1225c695-cfb8-4ebb-aaaa-80da344efa6a"); |
| } |
| |
| @Test |
| public void parseTime() throws Exception { |
| parseLiteral("time'PT120S'", EdmSimpleTypeKind.Time, "PT120S"); |
| } |
| |
| @Test |
| public void parseDatetime() throws Exception { |
| parseLiteral("datetime'2009-12-26T21:23:38'", EdmSimpleTypeKind.DateTime, "2009-12-26T21:23:38"); |
| } |
| |
| @Test |
| public void parseDatetimeOffset() throws Exception { |
| parseLiteral("datetimeoffset'2009-12-26T21:23:38Z'", EdmSimpleTypeKind.DateTimeOffset, "2009-12-26T21:23:38Z"); |
| parseLiteral("datetimeoffset'2002-10-10T12:00:00-05:00'", EdmSimpleTypeKind.DateTimeOffset, |
| "2002-10-10T12:00:00-05:00"); |
| parseLiteral("datetimeoffset'2009-12-26T21:23:38'", EdmSimpleTypeKind.DateTimeOffset, "2009-12-26T21:23:38"); |
| } |
| |
| @Test |
| public void parseBoolean() throws Exception { |
| parseLiteral("true", EdmSimpleTypeKind.Boolean, "true"); |
| parseLiteral("false", EdmSimpleTypeKind.Boolean, "false"); |
| parseLiteral("1", EdmSimpleTypeKind.Boolean, "1"); |
| parseLiteral("0", EdmSimpleTypeKind.Boolean, "0"); |
| } |
| |
| @Test |
| public void parseSByte() throws Exception { |
| parseLiteral("-123", EdmSimpleTypeKind.SByte, "-123"); |
| parseLiteral("12", EdmSimpleTypeKind.SByte, "12"); |
| } |
| |
| @Test |
| public void parseBinary() throws Exception { |
| parseLiteral("X'Fa12aAA1'", EdmSimpleTypeKind.Binary, "+hKqoQ=="); |
| parseLiteral("binary'FA12AAA1'", EdmSimpleTypeKind.Binary, "+hKqoQ=="); |
| } |
| |
| private void parseWrongLiteralContent(final String literal, final MessageReference messageReference) { |
| try { |
| EdmSimpleTypeKind.parseUriLiteral(literal); |
| fail("Expected EdmLiteralException not thrown"); |
| } catch (EdmLiteralException e) { |
| assertNotNull(e); |
| assertEquals(messageReference.getKey(), e.getMessageReference().getKey()); |
| } |
| } |
| |
| @Test |
| public void parseLiteralWithWrongContent() throws Exception { |
| parseWrongLiteralContent("binary'abcde'", EdmLiteralException.LITERALFORMAT); |
| parseWrongLiteralContent("'", EdmLiteralException.UNKNOWNLITERAL); |
| parseWrongLiteralContent("'a", EdmLiteralException.UNKNOWNLITERAL); |
| parseWrongLiteralContent("wrongprefix'PT1H2M3S'", EdmLiteralException.UNKNOWNLITERAL); |
| parseWrongLiteralContent("32i", EdmLiteralException.UNKNOWNLITERAL); |
| parseWrongLiteralContent("9876543210", EdmLiteralException.LITERALFORMAT); |
| parseWrongLiteralContent("-9876543210", EdmLiteralException.LITERALFORMAT); |
| parseWrongLiteralContent("12345678901234567890L", EdmLiteralException.LITERALFORMAT); |
| parseWrongLiteralContent("guid'a'", EdmLiteralException.LITERALFORMAT); |
| parseWrongLiteralContent("datetime'1'", EdmLiteralException.LITERALFORMAT); |
| parseWrongLiteralContent("datetimeoffset'2'", EdmLiteralException.LITERALFORMAT); |
| parseWrongLiteralContent("time'3'", EdmLiteralException.LITERALFORMAT); |
| } |
| |
| private void parseIncompatibleLiteralContent(final String literal, final EdmSimpleTypeKind typeKind) |
| throws EdmLiteralException { |
| final EdmLiteral uriLiteral = EdmSimpleTypeKind.parseUriLiteral(literal); |
| assertFalse(typeKind.getEdmSimpleTypeInstance().isCompatible(uriLiteral.getType())); |
| } |
| |
| @Test |
| public void parseIncompatibleLiteral() throws Exception { |
| parseIncompatibleLiteralContent("1D", EdmSimpleTypeKind.Binary); |
| parseIncompatibleLiteralContent("'0'", EdmSimpleTypeKind.Boolean); |
| parseIncompatibleLiteralContent("'1'", EdmSimpleTypeKind.Boolean); |
| parseIncompatibleLiteralContent("2", EdmSimpleTypeKind.Boolean); |
| parseIncompatibleLiteralContent("-1", EdmSimpleTypeKind.Byte); |
| parseIncompatibleLiteralContent("-129", EdmSimpleTypeKind.Byte); |
| parseIncompatibleLiteralContent("time'PT11H12M13S'", EdmSimpleTypeKind.DateTime); |
| parseIncompatibleLiteralContent("time'PT11H12M13S'", EdmSimpleTypeKind.DateTimeOffset); |
| parseIncompatibleLiteralContent("'1'", EdmSimpleTypeKind.Decimal); |
| parseIncompatibleLiteralContent("1M", EdmSimpleTypeKind.Double); |
| parseIncompatibleLiteralContent("1", EdmSimpleTypeKind.Guid); |
| parseIncompatibleLiteralContent("32768", EdmSimpleTypeKind.Int16); |
| parseIncompatibleLiteralContent("1L", EdmSimpleTypeKind.Int32); |
| parseIncompatibleLiteralContent("1M", EdmSimpleTypeKind.Int64); |
| parseIncompatibleLiteralContent("128", EdmSimpleTypeKind.SByte); |
| parseIncompatibleLiteralContent("1D", EdmSimpleTypeKind.Single); |
| parseIncompatibleLiteralContent("1", EdmSimpleTypeKind.String); |
| parseIncompatibleLiteralContent("datetime'2012-10-10T11:12:13'", EdmSimpleTypeKind.Time); |
| } |
| } |