You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@openaz.apache.org by pd...@apache.org on 2015/04/13 17:38:26 UTC
[26/51] [partial] incubator-openaz git commit: Initial seed of merged
of AT&T and JP Morgan code
http://git-wip-us.apache.org/repos/asf/incubator-openaz/blob/94fcdd90/openaz-xacml-test/src/test/java/com/att/research/xacmlatt/pdp/std/functions/FunctionDefinitionBagTest.java
----------------------------------------------------------------------
diff --git a/openaz-xacml-test/src/test/java/com/att/research/xacmlatt/pdp/std/functions/FunctionDefinitionBagTest.java b/openaz-xacml-test/src/test/java/com/att/research/xacmlatt/pdp/std/functions/FunctionDefinitionBagTest.java
new file mode 100755
index 0000000..4901916
--- /dev/null
+++ b/openaz-xacml-test/src/test/java/com/att/research/xacmlatt/pdp/std/functions/FunctionDefinitionBagTest.java
@@ -0,0 +1,527 @@
+package com.att.research.xacmlatt.pdp.std.functions;
+
+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 java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.junit.Test;
+
+import com.att.research.xacml.api.AttributeValue;
+import com.att.research.xacml.api.XACML3;
+import com.att.research.xacml.std.datatypes.DataTypes;
+import com.att.research.xacmlatt.pdp.policy.Bag;
+import com.att.research.xacmlatt.pdp.policy.ExpressionResult;
+import com.att.research.xacmlatt.pdp.policy.FunctionArgument;
+import com.att.research.xacmlatt.pdp.policy.FunctionArgumentAttributeValue;
+import com.att.research.xacmlatt.pdp.std.StdFunctions;
+
+/**
+ * Test of PDP Functions (See XACML core spec section A.3)
+ *
+ * TO RUN - use jUnit
+ * In Eclipse select this file or the enclosing directory, right-click and select Run As/JUnit Test
+ *
+ * @author glenngriffin
+ *
+ */
+public class FunctionDefinitionBagTest {
+
+
+ /*
+ * variables useful in the following tests
+ */
+ List<FunctionArgument> arguments = new ArrayList<FunctionArgument>();
+
+
+ FunctionArgumentAttributeValue attrInteger = null;
+ FunctionArgumentAttributeValue attrString = null;
+
+ public FunctionDefinitionBagTest() {
+ try {
+ attrInteger = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(1111111111));
+ attrString = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("a string value"));
+ } catch (Exception e) {
+ fail("creating attributes e="+e);
+ }
+ }
+
+ @Test
+ public void testString() {
+
+ String s1 = "abc";
+ String s2 = "def";
+ FunctionArgumentAttributeValue attr1 = null;
+ FunctionArgumentAttributeValue attr2 = null;
+ try {
+ attr1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(s1));
+ attr2 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(s2));
+ } catch (Exception e) {
+ fail("creating attributes e="+e);
+ }
+
+ FunctionDefinitionBag<?> fd = (FunctionDefinitionBag<?>) StdFunctions.FD_STRING_BAG;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_STRING_BAG, fd.getId());
+ assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertTrue(fd.returnsBag());
+
+ // bag with only one
+ arguments.clear();
+ arguments.add(attr1);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Bag bag = res.getBag();
+ assertNotNull(bag);
+ Iterator<AttributeValue<?>> it = bag.getAttributeValues();
+ assertEquals(1, bag.size());
+ AttributeValue<?> attrValueObject = it.next();
+ assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
+ assertEquals(s1, attrValueObject.getValue());
+
+ // zero args => empty bag
+ arguments.clear();
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ assertEquals(0, bag.size());
+
+
+ // null argument
+ arguments.clear();
+ arguments.add(null);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-bag Got null argument", res.getStatus().getStatusMessage());
+ assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // argument of other type
+ arguments.clear();
+ arguments.add(attrInteger);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-bag Expected data type 'string' saw 'integer'", res.getStatus().getStatusMessage());
+ assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // 2 args (check response is correct)
+ arguments.clear();
+ arguments.add(attr1);
+ arguments.add(attr2);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(2, bag.size());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
+ assertEquals(s1, attrValueObject.getValue());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
+ assertEquals(s2, attrValueObject.getValue());
+
+ // duplicate args (verify return)
+ arguments.clear();
+ arguments.add(attr1);
+ arguments.add(attr2);
+ arguments.add(attr1);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(3, bag.size());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
+ assertEquals(s1, attrValueObject.getValue());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
+ assertEquals(s2, attrValueObject.getValue());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
+ assertEquals(s1, attrValueObject.getValue());
+
+ // lots of args
+ arguments.clear();
+ for (int i = 0; i < 1000; i++) {
+ arguments.add(attr1);
+ }
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(1000, bag.size());
+
+ }
+
+
+ @Test
+ public void testBoolean() {
+
+ Boolean s1 = true;
+ Boolean s2 = false;
+ FunctionArgumentAttributeValue attr1 = null;
+ FunctionArgumentAttributeValue attr2 = null;
+ try {
+ attr1 = new FunctionArgumentAttributeValue(DataTypes.DT_BOOLEAN.createAttributeValue(s1));
+ attr2 = new FunctionArgumentAttributeValue(DataTypes.DT_BOOLEAN.createAttributeValue(s2));
+ } catch (Exception e) {
+ fail("creating attributes e="+e);
+ }
+
+ FunctionDefinitionBag<?> fd = (FunctionDefinitionBag<?>) StdFunctions.FD_BOOLEAN_BAG;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_BOOLEAN_BAG, fd.getId());
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertTrue(fd.returnsBag());
+
+ // bag with only one
+ arguments.clear();
+ arguments.add(attr1);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Bag bag = res.getBag();
+ assertNotNull(bag);
+ Iterator<AttributeValue<?>> it = bag.getAttributeValues();
+ assertEquals(1, bag.size());
+ AttributeValue<?> attrValueObject = it.next();
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), attrValueObject.getDataTypeId());
+ assertEquals(s1, attrValueObject.getValue());
+
+ // zero args => empty bag
+ arguments.clear();
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ assertEquals(0, bag.size());
+
+
+ // null argument
+ arguments.clear();
+ arguments.add(null);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:boolean-bag Got null argument", res.getStatus().getStatusMessage());
+ assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // argument of other type
+ arguments.clear();
+ arguments.add(attrInteger);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:boolean-bag Expected data type 'boolean' saw 'integer'", res.getStatus().getStatusMessage());
+ assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // 2 args (check response is correct)
+ arguments.clear();
+ arguments.add(attr1);
+ arguments.add(attr2);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(2, bag.size());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), attrValueObject.getDataTypeId());
+ assertEquals(s1, attrValueObject.getValue());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), attrValueObject.getDataTypeId());
+ assertEquals(s2, attrValueObject.getValue());
+
+ // duplicate args (verify return)
+ arguments.clear();
+ arguments.add(attr1);
+ arguments.add(attr2);
+ arguments.add(attr1);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(3, bag.size());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), attrValueObject.getDataTypeId());
+ assertEquals(s1, attrValueObject.getValue());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), attrValueObject.getDataTypeId());
+ assertEquals(s2, attrValueObject.getValue());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), attrValueObject.getDataTypeId());
+ assertEquals(s1, attrValueObject.getValue());
+
+ // lots of args
+ arguments.clear();
+ for (int i = 0; i < 1000; i++) {
+ arguments.add(attr1);
+ }
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(1000, bag.size());
+
+ }
+
+
+
+ @Test
+ public void testInteger() {
+
+ BigInteger s1 = new BigInteger("123");
+ BigInteger s2 = new BigInteger("456");
+ FunctionArgumentAttributeValue attr1 = null;
+ FunctionArgumentAttributeValue attr2 = null;
+ try {
+ attr1 = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(s1));
+ attr2 = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(s2));
+ } catch (Exception e) {
+ fail("creating attributes e="+e);
+ }
+
+ FunctionDefinitionBag<?> fd = (FunctionDefinitionBag<?>) StdFunctions.FD_INTEGER_BAG;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_INTEGER_BAG, fd.getId());
+ assertEquals(DataTypes.DT_INTEGER.getId(), fd.getDataTypeId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertTrue(fd.returnsBag());
+
+ // bag with only one
+ arguments.clear();
+ arguments.add(attr1);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Bag bag = res.getBag();
+ assertNotNull(bag);
+ Iterator<AttributeValue<?>> it = bag.getAttributeValues();
+ assertEquals(1, bag.size());
+ AttributeValue<?> attrValueObject = it.next();
+ assertEquals(DataTypes.DT_INTEGER.getId(), attrValueObject.getDataTypeId());
+ assertEquals(s1, attrValueObject.getValue());
+
+ // zero args => empty bag
+ arguments.clear();
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ assertEquals(0, bag.size());
+
+
+ // null argument
+ arguments.clear();
+ arguments.add(null);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:integer-bag Got null argument", res.getStatus().getStatusMessage());
+ assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // argument of other type
+ arguments.clear();
+ arguments.add(attrString);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:integer-bag Expected data type 'integer' saw 'string'", res.getStatus().getStatusMessage());
+ assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // 2 args (check response is correct)
+ arguments.clear();
+ arguments.add(attr1);
+ arguments.add(attr2);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(2, bag.size());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_INTEGER.getId(), attrValueObject.getDataTypeId());
+ assertEquals(s1, attrValueObject.getValue());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_INTEGER.getId(), attrValueObject.getDataTypeId());
+ assertEquals(s2, attrValueObject.getValue());
+
+ // duplicate args (verify return)
+ arguments.clear();
+ arguments.add(attr1);
+ arguments.add(attr2);
+ arguments.add(attr1);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(3, bag.size());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_INTEGER.getId(), attrValueObject.getDataTypeId());
+ assertEquals(s1, attrValueObject.getValue());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_INTEGER.getId(), attrValueObject.getDataTypeId());
+ assertEquals(s2, attrValueObject.getValue());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_INTEGER.getId(), attrValueObject.getDataTypeId());
+ assertEquals(s1, attrValueObject.getValue());
+
+ // lots of args
+ arguments.clear();
+ for (int i = 0; i < 1000; i++) {
+ arguments.add(attr1);
+ }
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(1000, bag.size());
+
+ }
+
+
+
+
+ @Test
+ public void testDouble() {
+
+ Double s1 = 123.45;
+ Double s2 = 678.901;
+ FunctionArgumentAttributeValue attr1 = null;
+ FunctionArgumentAttributeValue attr2 = null;
+ try {
+ attr1 = new FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(s1));
+ attr2 = new FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(s2));
+ } catch (Exception e) {
+ fail("creating attributes e="+e);
+ }
+
+ FunctionDefinitionBag<?> fd = (FunctionDefinitionBag<?>) StdFunctions.FD_DOUBLE_BAG;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_DOUBLE_BAG, fd.getId());
+ assertEquals(DataTypes.DT_DOUBLE.getId(), fd.getDataTypeId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertTrue(fd.returnsBag());
+
+ // bag with only one
+ arguments.clear();
+ arguments.add(attr1);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Bag bag = res.getBag();
+ assertNotNull(bag);
+ Iterator<AttributeValue<?>> it = bag.getAttributeValues();
+ assertEquals(1, bag.size());
+ AttributeValue<?> attrValueObject = it.next();
+ assertEquals(DataTypes.DT_DOUBLE.getId(), attrValueObject.getDataTypeId());
+ assertEquals(s1, attrValueObject.getValue());
+
+ // zero args => empty bag
+ arguments.clear();
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ assertEquals(0, bag.size());
+
+
+ // null argument
+ arguments.clear();
+ arguments.add(null);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:double-bag Got null argument", res.getStatus().getStatusMessage());
+ assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // argument of other type
+ arguments.clear();
+ arguments.add(attrInteger);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:double-bag Expected data type 'double' saw 'integer'", res.getStatus().getStatusMessage());
+ assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // 2 args (check response is correct)
+ arguments.clear();
+ arguments.add(attr1);
+ arguments.add(attr2);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(2, bag.size());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_DOUBLE.getId(), attrValueObject.getDataTypeId());
+ assertEquals(s1, attrValueObject.getValue());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_DOUBLE.getId(), attrValueObject.getDataTypeId());
+ assertEquals(s2, attrValueObject.getValue());
+
+ // duplicate args (verify return)
+ arguments.clear();
+ arguments.add(attr1);
+ arguments.add(attr2);
+ arguments.add(attr1);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(3, bag.size());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_DOUBLE.getId(), attrValueObject.getDataTypeId());
+ assertEquals(s1, attrValueObject.getValue());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_DOUBLE.getId(), attrValueObject.getDataTypeId());
+ assertEquals(s2, attrValueObject.getValue());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_DOUBLE.getId(), attrValueObject.getDataTypeId());
+ assertEquals(s1, attrValueObject.getValue());
+
+ // lots of args
+ arguments.clear();
+ for (int i = 0; i < 1000; i++) {
+ arguments.add(attr1);
+ }
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(1000, bag.size());
+
+ }
+
+
+
+
+
+ //
+ //
+ // REST OF DATA TYPES OMITTED
+ // because they "should" all work the same
+ //
+ //
+
+
+
+
+}
http://git-wip-us.apache.org/repos/asf/incubator-openaz/blob/94fcdd90/openaz-xacml-test/src/test/java/com/att/research/xacmlatt/pdp/std/functions/FunctionDefinitionBaseTest.java
----------------------------------------------------------------------
diff --git a/openaz-xacml-test/src/test/java/com/att/research/xacmlatt/pdp/std/functions/FunctionDefinitionBaseTest.java b/openaz-xacml-test/src/test/java/com/att/research/xacmlatt/pdp/std/functions/FunctionDefinitionBaseTest.java
new file mode 100755
index 0000000..0a967f5
--- /dev/null
+++ b/openaz-xacml-test/src/test/java/com/att/research/xacmlatt/pdp/std/functions/FunctionDefinitionBaseTest.java
@@ -0,0 +1,121 @@
+/*
+ * AT&T - PROPRIETARY
+ * THIS FILE CONTAINS PROPRIETARY INFORMATION OF
+ * AT&T AND IS NOT TO BE DISCLOSED OR USED EXCEPT IN
+ * ACCORDANCE WITH APPLICABLE AGREEMENTS.
+ *
+ * Copyright (c) 2013 AT&T Knowledge Ventures
+ * Unpublished and Not for Publication
+ * All Rights Reserved
+ */
+package com.att.research.xacmlatt.pdp.std.functions;
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+import com.att.research.xacml.api.Identifier;
+import com.att.research.xacml.api.XACML3;
+import com.att.research.xacmlatt.pdp.policy.FunctionDefinition;
+import com.att.research.xacmlatt.pdp.std.StdFunctions;
+
+/**
+ * Test functions in the abstract FunctionDefinitionSimpleTest class.
+ * Functions are tested by creating instances of other classes that should have appropriate properties to verify all variations of the responses expected.
+ *
+ * Note: we do not test getDataTypeId() because all it does is get the String out of the Identity object and we assume that the Data Type Identity objects
+ * are tested enough in everything else that any errors in them will be found and fixed quickly.
+ *
+ * TO RUN - use jUnit
+ * In Eclipse select this file or the enclosing directory, right-click and select Run As/JUnit Test
+ *
+ * @author glenngriffin
+ *
+ */
+public class FunctionDefinitionBaseTest {
+ /**
+ * getId() is pretty trivial, so verifying one should be enough to check that the mechanism is working ok
+ */
+ @Test
+ public void testGetId() {
+ FunctionDefinition fd = StdFunctions.FD_STRING_EQUAL;
+ Identifier id = fd.getId();
+ assertTrue(XACML3.ID_FUNCTION_STRING_EQUAL.stringValue().equals(id.stringValue()) );
+ }
+
+ /**
+ * check an instance of every result type that we can deal with
+ */
+ @Test
+ public void testGetDataType() {
+
+//?? Need functions that return each of these data types except for Boolean which is returned by any of the EQUAL functions
+ FunctionDefinition fdstring = StdFunctions.FD_STRING_NORMALIZE_SPACE;
+ assertEquals(XACML3.ID_DATATYPE_STRING, fdstring.getDataTypeId());
+
+ FunctionDefinition fdboolean = StdFunctions.FD_STRING_EQUAL;
+ assertEquals(XACML3.ID_DATATYPE_BOOLEAN, fdboolean.getDataTypeId());
+
+ FunctionDefinition fdinteger = StdFunctions.FD_INTEGER_ADD;
+ assertEquals(XACML3.ID_DATATYPE_INTEGER, fdinteger.getDataTypeId());
+
+ FunctionDefinition fddouble = StdFunctions.FD_DOUBLE_ADD;
+ assertEquals(XACML3.ID_DATATYPE_DOUBLE, fddouble.getDataTypeId());
+
+ FunctionDefinition fddate = StdFunctions.FD_DATE_BAG;
+ assertEquals(XACML3.ID_DATATYPE_DATE, fddate.getDataTypeId());
+
+ FunctionDefinition fdtime = StdFunctions.FD_TIME_BAG;
+ assertEquals(XACML3.ID_DATATYPE_TIME, fdtime.getDataTypeId());
+
+ FunctionDefinition fddateTime = StdFunctions.FD_DATETIME_BAG;
+ assertEquals(XACML3.ID_DATATYPE_DATETIME, fddateTime.getDataTypeId());
+
+ FunctionDefinition fddayTimeDuration = StdFunctions.FD_DAYTIMEDURATION_FROM_STRING;
+ assertEquals(XACML3.ID_DATATYPE_DAYTIMEDURATION, fddayTimeDuration.getDataTypeId());
+
+ FunctionDefinition fdyearMonthDuration = StdFunctions.FD_YEARMONTHDURATION_FROM_STRING;
+ assertEquals(XACML3.ID_DATATYPE_YEARMONTHDURATION, fdyearMonthDuration.getDataTypeId());
+
+ FunctionDefinition fdanyURI = StdFunctions.FD_ANYURI_FROM_STRING;
+ assertEquals(XACML3.ID_DATATYPE_ANYURI, fdanyURI.getDataTypeId());
+
+ FunctionDefinition fdhexBinary = StdFunctions.FD_HEXBINARY_UNION;
+ assertEquals(XACML3.ID_DATATYPE_HEXBINARY, fdhexBinary.getDataTypeId());
+
+ FunctionDefinition fdbase64Binary = StdFunctions.FD_BASE64BINARY_UNION;
+ assertEquals(XACML3.ID_DATATYPE_BASE64BINARY, fdbase64Binary.getDataTypeId());
+
+ FunctionDefinition fdrfc822Name = StdFunctions.FD_RFC822NAME_FROM_STRING;
+ assertEquals(XACML3.ID_DATATYPE_RFC822NAME, fdrfc822Name.getDataTypeId());
+
+ FunctionDefinition fdx500Name = StdFunctions.FD_X500NAME_FROM_STRING;
+ assertEquals(XACML3.ID_DATATYPE_X500NAME, fdx500Name.getDataTypeId());
+
+//TODO - There are currently no functions that return XPathExpression objects
+// FunctionDefinition fdxpathExpression = StdFunctions.FD_XPATHEXPRESSION_FROM_STRING;
+// assertEquals(XACML3.ID_DATATYPE_XPATHEXPRESSION, fdxpathExpression.getDataTypeId());
+
+ FunctionDefinition fdipAddress = StdFunctions.FD_IPADDRESS_FROM_STRING;
+ assertEquals(XACML3.ID_DATATYPE_IPADDRESS, fdipAddress.getDataTypeId());
+
+ FunctionDefinition fddnsName = StdFunctions.FD_DNSNAME_FROM_STRING;
+ assertEquals(XACML3.ID_DATATYPE_DNSNAME, fddnsName.getDataTypeId());
+ }
+
+ /**
+ * check the type of return, single vs multiple values
+ */
+ @Test
+ public void testReturnsBag() {
+ FunctionDefinition fdNotBag = StdFunctions.FD_BOOLEAN_EQUAL;
+ assertFalse(fdNotBag.returnsBag());
+
+ FunctionDefinitionBag<?> fdBag = (FunctionDefinitionBag<?>) StdFunctions.FD_STRING_BAG;
+ assertTrue(fdBag.returnsBag());
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/incubator-openaz/blob/94fcdd90/openaz-xacml-test/src/test/java/com/att/research/xacmlatt/pdp/std/functions/FunctionDefinitionComparisonTest.java
----------------------------------------------------------------------
diff --git a/openaz-xacml-test/src/test/java/com/att/research/xacmlatt/pdp/std/functions/FunctionDefinitionComparisonTest.java b/openaz-xacml-test/src/test/java/com/att/research/xacmlatt/pdp/std/functions/FunctionDefinitionComparisonTest.java
new file mode 100755
index 0000000..a93bf14
--- /dev/null
+++ b/openaz-xacml-test/src/test/java/com/att/research/xacmlatt/pdp/std/functions/FunctionDefinitionComparisonTest.java
@@ -0,0 +1,1356 @@
+/*
+ * AT&T - PROPRIETARY
+ * THIS FILE CONTAINS PROPRIETARY INFORMATION OF
+ * AT&T AND IS NOT TO BE DISCLOSED OR USED EXCEPT IN
+ * ACCORDANCE WITH APPLICABLE AGREEMENTS.
+ *
+ * Copyright (c) 2013 AT&T Knowledge Ventures
+ * Unpublished and Not for Publication
+ * All Rights Reserved
+ */
+package com.att.research.xacmlatt.pdp.std.functions;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.List;
+
+import org.junit.Test;
+
+import com.att.research.xacml.api.XACML3;
+import com.att.research.xacml.std.datatypes.DataTypes;
+import com.att.research.xacml.std.datatypes.ISO8601Date;
+import com.att.research.xacml.std.datatypes.ISO8601DateTime;
+import com.att.research.xacml.std.datatypes.ISO8601Time;
+import com.att.research.xacmlatt.pdp.policy.ExpressionResult;
+import com.att.research.xacmlatt.pdp.policy.FunctionArgument;
+import com.att.research.xacmlatt.pdp.policy.FunctionArgumentAttributeValue;
+import com.att.research.xacmlatt.pdp.std.StdFunctions;
+
+/**
+ * Test FunctionDefinitionComparison
+ *
+ * TO RUN - use jUnit
+ * In Eclipse select this file or the enclosing directory, right-click and select Run As/JUnit Test
+ *
+ * @author glenngriffin
+ *
+ */
+public class FunctionDefinitionComparisonTest {
+
+ /*
+ * variables useful in the following tests
+ */
+ List<FunctionArgument> arguments = new ArrayList<FunctionArgument>();
+
+ FunctionArgumentAttributeValue stringAttr1 = null;
+ FunctionArgumentAttributeValue stringAttr1a = null;
+ FunctionArgumentAttributeValue stringAttr2 = null;
+ FunctionArgumentAttributeValue stringAttrNeg1 = null;
+
+
+ FunctionArgumentAttributeValue intAttr1 = null;
+ FunctionArgumentAttributeValue intAttr1a = null;
+ FunctionArgumentAttributeValue intAttr2 = null;
+ FunctionArgumentAttributeValue intAttr0 = null;
+ FunctionArgumentAttributeValue intAttrNeg1 = null;
+
+ FunctionArgumentAttributeValue attr1 = null;
+ FunctionArgumentAttributeValue attr1a = null;
+ FunctionArgumentAttributeValue attr2 = null;
+ FunctionArgumentAttributeValue attrNeg1 = null;
+
+ FunctionArgumentAttributeValue attrDateToday = null;
+ FunctionArgumentAttributeValue attrDateSameDay = null;
+ FunctionArgumentAttributeValue attrDateTommorrow = null;
+ FunctionArgumentAttributeValue attrDateYesterday = null;
+ FunctionArgumentAttributeValue attrDateWithTimeZone = null;
+ FunctionArgumentAttributeValue attrDateNoTimeZone = null;
+
+
+ FunctionArgumentAttributeValue attrTimeToday = null;
+ FunctionArgumentAttributeValue attrTimeSameDay = null;
+ FunctionArgumentAttributeValue attrTimeTommorrow = null;
+ FunctionArgumentAttributeValue attrTimeYesterday = null;
+ FunctionArgumentAttributeValue attrTimeWithTimeZone = null;
+ FunctionArgumentAttributeValue attrTimeNoTimeZone = null;
+
+ FunctionArgumentAttributeValue attrDateTimeToday = null;
+ FunctionArgumentAttributeValue attrDateTimeSameDay = null;
+ FunctionArgumentAttributeValue attrDateTimeTommorrow = null;
+ FunctionArgumentAttributeValue attrDateTimeYesterday = null;
+ FunctionArgumentAttributeValue attrDateTimeWithTimeZone = null;
+ FunctionArgumentAttributeValue attrDateTimeNoTimeZone = null;
+
+ /**
+ * Set up some common variables on startup
+ */
+ public FunctionDefinitionComparisonTest() {
+ try {
+ stringAttr1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("abc"));
+ stringAttr1a = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("abc"));
+ stringAttr2 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("def"));
+ stringAttrNeg1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("AAA"));
+
+
+ intAttr1 = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(1));
+ intAttr1a = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(1));
+ intAttr2 = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(2));
+ intAttr0 = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(0));
+ intAttrNeg1 = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(-1));
+
+ attr1 = new FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(1.0));
+ attr1a = new FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(1.0));
+ attr2 = new FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(2.4));
+ attrNeg1 = new FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(-1.0));
+
+ // create dates
+ Calendar calendar = Calendar.getInstance();
+ Date today = calendar.getTime();
+ Date longAgo = new Date(1234);
+ // create a date that is different than "today" but within the same day (i.e. has a different hour)
+ if (calendar.get(Calendar.HOUR_OF_DAY) > 3) {
+ calendar.set(Calendar.HOUR_OF_DAY, 3);
+ } else {
+ calendar.set(Calendar.HOUR_OF_DAY, 5);
+ }
+ Date todayPlus = calendar.getTime();
+ calendar.add(Calendar.DATE, 1);
+ Date tommorrow = calendar.getTime();
+ attrDateToday = new FunctionArgumentAttributeValue(DataTypes.DT_DATE.createAttributeValue(today));
+ attrDateSameDay = new FunctionArgumentAttributeValue(DataTypes.DT_DATE.createAttributeValue(todayPlus));
+ attrDateTommorrow = new FunctionArgumentAttributeValue(DataTypes.DT_DATE.createAttributeValue(tommorrow));
+ attrDateYesterday = new FunctionArgumentAttributeValue(DataTypes.DT_DATE.createAttributeValue(longAgo));
+ ISO8601Date isoDate = new ISO8601Date(1920, 5, 8);
+ attrDateNoTimeZone = new FunctionArgumentAttributeValue(DataTypes.DT_DATE.createAttributeValue(isoDate));
+ isoDate = new ISO8601Date("GMT+00:02", 1920, 5, 8);
+ attrDateWithTimeZone = new FunctionArgumentAttributeValue(DataTypes.DT_DATE.createAttributeValue(isoDate));
+
+ // create Times
+ ISO8601Time isoTime = new ISO8601Time(14, 43, 12, 145);
+ attrTimeToday = new FunctionArgumentAttributeValue(DataTypes.DT_TIME.createAttributeValue(isoTime));
+ attrTimeSameDay = new FunctionArgumentAttributeValue(DataTypes.DT_TIME.createAttributeValue(isoTime));
+ isoTime = new ISO8601Time(18, 53, 34, 423);
+ attrTimeTommorrow = new FunctionArgumentAttributeValue(DataTypes.DT_TIME.createAttributeValue(isoTime));
+ isoTime = new ISO8601Time(7, 34, 6,543);
+ attrTimeYesterday = new FunctionArgumentAttributeValue(DataTypes.DT_TIME.createAttributeValue(isoTime));
+ isoTime = new ISO8601Time(12, 12, 12, 12);
+ attrTimeNoTimeZone = new FunctionArgumentAttributeValue(DataTypes.DT_TIME.createAttributeValue(isoTime));
+ isoTime = new ISO8601Time("GMT:+00:03", 12, 12, 12, 12);
+ attrTimeWithTimeZone = new FunctionArgumentAttributeValue(DataTypes.DT_TIME.createAttributeValue(isoTime));
+
+ // create DateTimes
+ isoDate = new ISO8601Date(1920, 5, 8);
+ isoTime = new ISO8601Time( 18, 53, 34, 423);
+ ISO8601DateTime isoDateTime = new ISO8601DateTime((String)null, 1920, 5, 8, 18, 53, 34, 423);
+ attrDateTimeToday = new FunctionArgumentAttributeValue(DataTypes.DT_DATETIME.createAttributeValue(isoDateTime));
+ attrDateTimeSameDay = new FunctionArgumentAttributeValue(DataTypes.DT_DATETIME.createAttributeValue(isoDateTime));
+ isoTime = new ISO8601Time(20, 53, 34, 423);
+ isoDateTime = new ISO8601DateTime((String)null, 1920, 5, 8, 20, 53, 34, 423);
+ attrDateTimeTommorrow = new FunctionArgumentAttributeValue(DataTypes.DT_DATETIME.createAttributeValue(isoDateTime));
+ isoTime = new ISO8601Time(7, 34, 6,543);
+ isoDateTime = new ISO8601DateTime((String)null, 1920, 5, 8, 7, 34, 6, 543);
+ attrDateTimeYesterday = new FunctionArgumentAttributeValue(DataTypes.DT_DATETIME.createAttributeValue(isoDateTime));
+ isoTime = new ISO8601Time(12, 12, 12, 12);
+ isoDateTime = new ISO8601DateTime((String)null, 1920, 5, 8, 12, 12, 12, 12);
+ attrDateTimeNoTimeZone = new FunctionArgumentAttributeValue(DataTypes.DT_DATETIME.createAttributeValue(isoDateTime));
+ isoTime = new ISO8601Time("GMT:+00:03", 12, 12, 12, 12);
+ isoDate = new ISO8601Date("GMT:+00:03", 1920, 5, 8);
+ isoDateTime = new ISO8601DateTime("GMT:+00:03", 1920, 5, 8, 12, 12, 12, 12);
+ attrDateTimeWithTimeZone = new FunctionArgumentAttributeValue(DataTypes.DT_DATETIME.createAttributeValue(isoDateTime));
+
+
+
+
+ } catch (Exception e) {
+ fail("Error creating values e="+ e);
+ }
+ }
+
+ /**
+ * String
+ */
+ @Test
+ public void testString_GT() {
+
+ FunctionDefinitionComparison<?> fd = (FunctionDefinitionComparison<?>) StdFunctions.FD_STRING_GREATER_THAN;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_STRING_GREATER_THAN, fd.getId());
+ assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(2), fd.getNumArgs());
+
+ // first == second
+ arguments.add(stringAttr1);
+ arguments.add(stringAttr1a);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // check first < second
+ arguments.clear();
+ arguments.add(stringAttr1);
+ arguments.add(stringAttr2);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first > second
+ arguments.clear();
+ arguments.add(stringAttr1);
+ arguments.add(stringAttrNeg1);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // test bad args data types? Not needed?
+ arguments.clear();
+ arguments.add(intAttr1);
+ arguments.add(stringAttr1);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ }
+
+ @Test
+ public void testString_GTE() {
+
+ FunctionDefinitionComparison<?> fd = (FunctionDefinitionComparison<?>) StdFunctions.FD_STRING_GREATER_THAN_OR_EQUAL;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_STRING_GREATER_THAN_OR_EQUAL, fd.getId());
+ assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(2), fd.getNumArgs());
+
+ // first == second
+ arguments.add(stringAttr1);
+ arguments.add(stringAttr1a);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // check first < second
+ arguments.clear();
+ arguments.add(stringAttr1);
+ arguments.add(stringAttr2);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first > second
+ arguments.clear();
+ arguments.add(stringAttr1);
+ arguments.add(stringAttrNeg1);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+ }
+
+ @Test
+ public void testString_LT() {
+
+ FunctionDefinitionComparison<?> fd = (FunctionDefinitionComparison<?>) StdFunctions.FD_STRING_LESS_THAN;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_STRING_LESS_THAN, fd.getId());
+ assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(2), fd.getNumArgs());
+
+ // first == second
+ arguments.add(stringAttr1);
+ arguments.add(stringAttr1a);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // check first < second
+ arguments.clear();
+ arguments.add(stringAttr1);
+ arguments.add(stringAttr2);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // first > second
+ arguments.clear();
+ arguments.add(stringAttr1);
+ arguments.add(stringAttrNeg1);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+ }
+
+ @Test
+ public void testString_LTE() {
+
+ FunctionDefinitionComparison<?> fd = (FunctionDefinitionComparison<?>) StdFunctions.FD_STRING_LESS_THAN_OR_EQUAL;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_STRING_LESS_THAN_OR_EQUAL, fd.getId());
+ assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(2), fd.getNumArgs());
+
+ // first == second
+ arguments.add(stringAttr1);
+ arguments.add(stringAttr1a);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // check first < second
+ arguments.clear();
+ arguments.add(stringAttr1);
+ arguments.add(stringAttr2);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // first > second
+ arguments.clear();
+ arguments.add(stringAttr1);
+ arguments.add(stringAttrNeg1);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+ }
+
+
+
+ /**
+ * Integer
+ */
+ @Test
+ public void testInteger_GT() {
+
+ FunctionDefinitionComparison<?> fd = (FunctionDefinitionComparison<?>) StdFunctions.FD_INTEGER_GREATER_THAN;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_INTEGER_GREATER_THAN, fd.getId());
+ assertEquals(DataTypes.DT_INTEGER.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(2), fd.getNumArgs());
+
+ // first == second
+ arguments.add(intAttr1);
+ arguments.add(intAttr1a);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // check first < second
+ arguments.clear();
+ arguments.add(intAttr1);
+ arguments.add(intAttr2);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first > second
+ arguments.clear();
+ arguments.add(intAttr1);
+ arguments.add(intAttrNeg1);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // test bad args data types? Not needed?
+ arguments.clear();
+ arguments.add(stringAttr1);
+ arguments.add(intAttr1);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ }
+
+ @Test
+ public void testInteger_GTE() {
+
+ FunctionDefinitionComparison<?> fd = (FunctionDefinitionComparison<?>) StdFunctions.FD_INTEGER_GREATER_THAN_OR_EQUAL;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_INTEGER_GREATER_THAN_OR_EQUAL, fd.getId());
+ assertEquals(DataTypes.DT_INTEGER.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(2), fd.getNumArgs());
+
+ // first == second
+ arguments.add(intAttr1);
+ arguments.add(intAttr1a);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // check first < second
+ arguments.clear();
+ arguments.add(intAttr1);
+ arguments.add(intAttr2);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first > second
+ arguments.clear();
+ arguments.add(intAttr1);
+ arguments.add(intAttrNeg1);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+ }
+
+ @Test
+ public void testInteger_LT() {
+
+ FunctionDefinitionComparison<?> fd = (FunctionDefinitionComparison<?>) StdFunctions.FD_INTEGER_LESS_THAN;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_INTEGER_LESS_THAN, fd.getId());
+ assertEquals(DataTypes.DT_INTEGER.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(2), fd.getNumArgs());
+
+ // first == second
+ arguments.add(intAttr1);
+ arguments.add(intAttr1a);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // check first < second
+ arguments.clear();
+ arguments.add(intAttr1);
+ arguments.add(intAttr2);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // first > second
+ arguments.clear();
+ arguments.add(intAttr1);
+ arguments.add(intAttrNeg1);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+ }
+
+ @Test
+ public void testInteger_LTE() {
+
+ FunctionDefinitionComparison<?> fd = (FunctionDefinitionComparison<?>) StdFunctions.FD_INTEGER_LESS_THAN_OR_EQUAL;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_INTEGER_LESS_THAN_OR_EQUAL, fd.getId());
+ assertEquals(DataTypes.DT_INTEGER.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(2), fd.getNumArgs());
+
+ // first == second
+ arguments.add(intAttr1);
+ arguments.add(intAttr1a);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // check first < second
+ arguments.clear();
+ arguments.add(intAttr1);
+ arguments.add(intAttr2);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // first > second
+ arguments.clear();
+ arguments.add(intAttr1);
+ arguments.add(intAttrNeg1);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+ }
+
+
+
+
+ /**
+ * Double
+ */
+ @Test
+ public void testDouble_GT() {
+
+ FunctionDefinitionComparison<?> fd = (FunctionDefinitionComparison<?>) StdFunctions.FD_DOUBLE_GREATER_THAN;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_DOUBLE_GREATER_THAN, fd.getId());
+ assertEquals(DataTypes.DT_DOUBLE.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(2), fd.getNumArgs());
+
+ // first == second
+ arguments.add(attr1);
+ arguments.add(attr1a);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first < second
+ arguments.clear();
+ arguments.add(attr1);
+ arguments.add(attr2);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first > second
+ arguments.clear();
+ arguments.add(attr1);
+ arguments.add(attrNeg1);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // test bad args data types? Not needed?
+ arguments.clear();
+ arguments.add(stringAttr1);
+ arguments.add(intAttr1);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+
+ }
+
+ @Test
+ public void testDouble_GTE() {
+
+ FunctionDefinitionComparison<?> fd = (FunctionDefinitionComparison<?>) StdFunctions.FD_DOUBLE_GREATER_THAN_OR_EQUAL;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_DOUBLE_GREATER_THAN_OR_EQUAL, fd.getId());
+ assertEquals(DataTypes.DT_DOUBLE.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(2), fd.getNumArgs());
+
+ // first == second
+ arguments.add(attr1);
+ arguments.add(attr1a);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // first < second
+ arguments.clear();
+ arguments.add(attr1);
+ arguments.add(attr2);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first > second
+ arguments.clear();
+ arguments.add(attr1);
+ arguments.add(attrNeg1);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+ }
+
+ @Test
+ public void testDouble_LT() {
+
+ FunctionDefinitionComparison<?> fd = (FunctionDefinitionComparison<?>) StdFunctions.FD_DOUBLE_LESS_THAN;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_DOUBLE_LESS_THAN, fd.getId());
+ assertEquals(DataTypes.DT_DOUBLE.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(2), fd.getNumArgs());
+
+ // first == second
+ arguments.add(attr1);
+ arguments.add(attr1a);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first < second
+ arguments.clear();
+ arguments.add(attr1);
+ arguments.add(attr2);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // first > second
+ arguments.clear();
+ arguments.add(attr1);
+ arguments.add(attrNeg1);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+ }
+
+ @Test
+ public void testDouble_LTE() {
+
+ FunctionDefinitionComparison<?> fd = (FunctionDefinitionComparison<?>) StdFunctions.FD_DOUBLE_LESS_THAN_OR_EQUAL;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_DOUBLE_LESS_THAN_OR_EQUAL, fd.getId());
+ assertEquals(DataTypes.DT_DOUBLE.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(2), fd.getNumArgs());
+
+ // first == second
+ arguments.add(attr1);
+ arguments.add(attr1a);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // first < second
+ arguments.clear();
+ arguments.add(attr1);
+ arguments.add(attr2);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // first > second
+ arguments.clear();
+ arguments.add(attr1);
+ arguments.add(attrNeg1);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+ }
+
+
+
+ /**
+ * Date
+ */
+
+ @Test
+ public void testDate_GT() {
+
+ FunctionDefinitionComparison<?> fd = (FunctionDefinitionComparison<?>) StdFunctions.FD_DATE_GREATER_THAN;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_DATE_GREATER_THAN, fd.getId());
+ assertEquals(DataTypes.DT_DATE.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(2), fd.getNumArgs());
+
+ // first == second
+ arguments.add(attrDateToday);
+ arguments.add(attrDateSameDay);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first < second
+ arguments.clear();
+ arguments.add(attrDateToday);
+ arguments.add(attrDateTommorrow);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first > second
+ arguments.clear();
+ arguments.add(attrDateToday);
+ arguments.add(attrDateYesterday);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // test bad args data types? One with TimeZone and one without
+ arguments.clear();
+ arguments.add(stringAttr1);
+ arguments.add(intAttr1);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+
+ // test with TimeZone vs without
+ arguments.clear();
+ arguments.add(attrDateWithTimeZone);
+ arguments.add(attrDateNoTimeZone);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:date-greater-than Cannot compare this ISO8601DateTime with non-time-zoned ISO8601DateTime", res.getStatus().getStatusMessage());
+ assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+
+ }
+
+ @Test
+ public void testDate_GTE() {
+
+ FunctionDefinitionComparison<?> fd = (FunctionDefinitionComparison<?>) StdFunctions.FD_DATE_GREATER_THAN_OR_EQUAL;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_DATE_GREATER_THAN_OR_EQUAL, fd.getId());
+ assertEquals(DataTypes.DT_DATE.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(2), fd.getNumArgs());
+
+ // first == second
+ arguments.add(attrDateToday);
+ arguments.add(attrDateSameDay);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // first < second
+ arguments.clear();
+ arguments.add(attrDateToday);
+ arguments.add(attrDateTommorrow);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first > second
+ arguments.clear();
+ arguments.add(attrDateToday);
+ arguments.add(attrDateYesterday);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+ }
+
+ @Test
+ public void testDate_LT() {
+
+ FunctionDefinitionComparison<?> fd = (FunctionDefinitionComparison<?>) StdFunctions.FD_DATE_LESS_THAN;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_DATE_LESS_THAN, fd.getId());
+ assertEquals(DataTypes.DT_DATE.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(2), fd.getNumArgs());
+
+ // first == second
+ arguments.add(attrDateToday);
+ arguments.add(attrDateSameDay);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first < second
+ arguments.clear();
+ arguments.add(attrDateToday);
+ arguments.add(attrDateTommorrow);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // first > second
+ arguments.clear();
+ arguments.add(attrDateToday);
+ arguments.add(attrDateYesterday);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+ }
+
+ @Test
+ public void testDate_LTE() {
+
+ FunctionDefinitionComparison<?> fd = (FunctionDefinitionComparison<?>) StdFunctions.FD_DATE_LESS_THAN_OR_EQUAL;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_DATE_LESS_THAN_OR_EQUAL, fd.getId());
+ assertEquals(DataTypes.DT_DATE.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(2), fd.getNumArgs());
+
+ // first == second
+ arguments.add(attrDateToday);
+ arguments.add(attrDateSameDay);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // first < second
+ arguments.clear();
+ arguments.add(attrDateToday);
+ arguments.add(attrDateTommorrow);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // first > second
+ arguments.clear();
+ arguments.add(attrDateToday);
+ arguments.add(attrDateYesterday);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+ }
+
+
+
+
+
+
+
+ /**
+ * Time
+ */
+
+ @Test
+ public void testTime_GT() {
+
+ FunctionDefinitionComparison<?> fd = (FunctionDefinitionComparison<?>) StdFunctions.FD_TIME_GREATER_THAN;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_TIME_GREATER_THAN, fd.getId());
+ assertEquals(DataTypes.DT_TIME.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(2), fd.getNumArgs());
+
+ // first == second
+ arguments.add(attrTimeToday);
+ arguments.add(attrTimeSameDay);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first < second
+ arguments.clear();
+ arguments.add(attrTimeToday);
+ arguments.add(attrTimeTommorrow);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first > second
+ arguments.clear();
+ arguments.add(attrTimeToday);
+ arguments.add(attrTimeYesterday);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // test bad args data types? One with TimeZone and one without
+ arguments.clear();
+ arguments.add(stringAttr1);
+ arguments.add(intAttr1);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+
+ // test with TimeZone vs without
+ arguments.clear();
+ arguments.add(attrTimeWithTimeZone);
+ arguments.add(attrTimeNoTimeZone);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:time-greater-than Cannot compare this ISO8601DateTime with non-time-zoned ISO8601DateTime", res.getStatus().getStatusMessage());
+ assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+
+ }
+
+ @Test
+ public void testTime_GTE() {
+
+ FunctionDefinitionComparison<?> fd = (FunctionDefinitionComparison<?>) StdFunctions.FD_TIME_GREATER_THAN_OR_EQUAL;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_TIME_GREATER_THAN_OR_EQUAL, fd.getId());
+ assertEquals(DataTypes.DT_TIME.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(2), fd.getNumArgs());
+
+ // first == second
+ arguments.add(attrTimeToday);
+ arguments.add(attrTimeSameDay);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // first < second
+ arguments.clear();
+ arguments.add(attrTimeToday);
+ arguments.add(attrTimeTommorrow);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first > second
+ arguments.clear();
+ arguments.add(attrTimeToday);
+ arguments.add(attrTimeYesterday);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+ }
+
+ @Test
+ public void testTime_LT() {
+
+ FunctionDefinitionComparison<?> fd = (FunctionDefinitionComparison<?>) StdFunctions.FD_TIME_LESS_THAN;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_TIME_LESS_THAN, fd.getId());
+ assertEquals(DataTypes.DT_TIME.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(2), fd.getNumArgs());
+
+ // first == second
+ arguments.add(attrTimeToday);
+ arguments.add(attrTimeSameDay);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first < second
+ arguments.clear();
+ arguments.add(attrTimeToday);
+ arguments.add(attrTimeTommorrow);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // first > second
+ arguments.clear();
+ arguments.add(attrTimeToday);
+ arguments.add(attrTimeYesterday);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+ }
+
+ @Test
+ public void testTime_LTE() {
+
+ FunctionDefinitionComparison<?> fd = (FunctionDefinitionComparison<?>) StdFunctions.FD_TIME_LESS_THAN_OR_EQUAL;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_TIME_LESS_THAN_OR_EQUAL, fd.getId());
+ assertEquals(DataTypes.DT_TIME.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(2), fd.getNumArgs());
+
+ // first == second
+ arguments.add(attrTimeToday);
+ arguments.add(attrTimeSameDay);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // first < second
+ arguments.clear();
+ arguments.add(attrTimeToday);
+ arguments.add(attrTimeTommorrow);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // first > second
+ arguments.clear();
+ arguments.add(attrTimeToday);
+ arguments.add(attrTimeYesterday);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+ }
+
+
+
+
+
+ /**
+ * Time-in-range
+ */
+ @Test
+ public void testTime_in_range() {
+
+ FunctionDefinitionTimeInRange<?> fd = (FunctionDefinitionTimeInRange<?>) StdFunctions.FD_TIME_IN_RANGE;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_TIME_IN_RANGE, fd.getId());
+ assertEquals(DataTypes.DT_TIME.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(3), fd.getNumArgs());
+
+ // arg 0 in range of others
+ arguments.add(attrTimeToday);
+ arguments.add(attrTimeYesterday);
+ arguments.add(attrTimeTommorrow);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // below range
+ arguments.clear();
+ arguments.add(attrTimeYesterday);
+ arguments.add(attrTimeToday);
+ arguments.add(attrTimeTommorrow);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // above range
+ arguments.clear();
+ arguments.add(attrTimeTommorrow);
+ arguments.add(attrTimeYesterday);
+ arguments.add(attrTimeToday);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // range bad
+ arguments.clear();
+ arguments.add(attrTimeToday);
+ arguments.add(attrTimeTommorrow);
+ arguments.add(attrTimeYesterday);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // bad types
+ arguments.clear();
+ arguments.add(attrDateTimeWithTimeZone);
+ arguments.add(attrDateTimeNoTimeZone);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:time-in-range Expected 3 arguments, got 2", res.getStatus().getStatusMessage());
+ assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ arguments.clear();
+ arguments.add(attrDateTimeWithTimeZone);
+ arguments.add(attrDateTimeNoTimeZone);
+ arguments.add(intAttr1);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:time-in-range Expected data type 'time' saw 'dateTime' at arg index 0", res.getStatus().getStatusMessage());
+ assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ }
+
+
+
+
+
+
+ /**
+ * DateTime
+ */
+
+ @Test
+ public void testDateTime_GT() {
+
+ FunctionDefinitionComparison<?> fd = (FunctionDefinitionComparison<?>) StdFunctions.FD_DATETIME_GREATER_THAN;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_DATETIME_GREATER_THAN, fd.getId());
+ assertEquals(DataTypes.DT_DATETIME.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(2), fd.getNumArgs());
+
+ // first == second
+ arguments.add(attrDateTimeToday);
+ arguments.add(attrDateTimeSameDay);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first < second
+ arguments.clear();
+ arguments.add(attrDateTimeToday);
+ arguments.add(attrDateTimeTommorrow);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first > second
+ arguments.clear();
+ arguments.add(attrDateTimeToday);
+ arguments.add(attrDateTimeYesterday);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // test bad args data types? One with TimeZone and one without
+ arguments.clear();
+ arguments.add(stringAttr1);
+ arguments.add(intAttr1);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+
+ // test with TimeZone vs without
+ arguments.clear();
+ arguments.add(attrDateTimeWithTimeZone);
+ arguments.add(attrDateTimeNoTimeZone);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:dateTime-greater-than Cannot compare this ISO8601DateTime with non-time-zoned ISO8601DateTime", res.getStatus().getStatusMessage());
+ assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+
+ }
+
+ @Test
+ public void testDateTime_GTE() {
+
+ FunctionDefinitionComparison<?> fd = (FunctionDefinitionComparison<?>) StdFunctions.FD_DATETIME_GREATER_THAN_OR_EQUAL;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_DATETIME_GREATER_THAN_OR_EQUAL, fd.getId());
+ assertEquals(DataTypes.DT_DATETIME.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(2), fd.getNumArgs());
+
+ // first == second
+ arguments.add(attrDateTimeToday);
+ arguments.add(attrDateTimeSameDay);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // first < second
+ arguments.clear();
+ arguments.add(attrDateTimeToday);
+ arguments.add(attrDateTimeTommorrow);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first > second
+ arguments.clear();
+ arguments.add(attrDateTimeToday);
+ arguments.add(attrDateTimeYesterday);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+ }
+
+ @Test
+ public void testDateTime_LT() {
+
+ FunctionDefinitionComparison<?> fd = (FunctionDefinitionComparison<?>) StdFunctions.FD_DATETIME_LESS_THAN;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_DATETIME_LESS_THAN, fd.getId());
+ assertEquals(DataTypes.DT_DATETIME.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(2), fd.getNumArgs());
+
+ // first == second
+ arguments.add(attrDateTimeToday);
+ arguments.add(attrDateTimeSameDay);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first < second
+ arguments.clear();
+ arguments.add(attrDateTimeToday);
+ arguments.add(attrDateTimeTommorrow);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // first > second
+ arguments.clear();
+ arguments.add(attrDateTimeToday);
+ arguments.add(attrDateTimeYesterday);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+ }
+
+ @Test
+ public void testDateTime_LTE() {
+
+ FunctionDefinitionComparison<?> fd = (FunctionDefinitionComparison<?>) StdFunctions.FD_DATETIME_LESS_THAN_OR_EQUAL;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_DATETIME_LESS_THAN_OR_EQUAL, fd.getId());
+ assertEquals(DataTypes.DT_DATETIME.getId(), fd.getDataTypeArgs().getId());
+
+ // just to be safe... If tests take too long these can probably be eliminated
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+ assertFalse(fd.returnsBag());
+ assertEquals(new Integer(2), fd.getNumArgs());
+
+ // first == second
+ arguments.add(attrDateTimeToday);
+ arguments.add(attrDateTimeSameDay);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // first < second
+ arguments.clear();
+ arguments.add(attrDateTimeToday);
+ arguments.add(attrDateTimeTommorrow);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // first > second
+ arguments.clear();
+ arguments.add(attrDateTimeToday);
+ arguments.add(attrDateTimeYesterday);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+ }
+
+
+
+}
\ No newline at end of file