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/FunctionDefinitionSetTest.java
----------------------------------------------------------------------
diff --git
a/openaz-xacml-test/src/test/java/com/att/research/xacmlatt/pdp/std/functions/FunctionDefinitionSetTest.java
b/openaz-xacml-test/src/test/java/com/att/research/xacmlatt/pdp/std/functions/FunctionDefinitionSetTest.java
new file mode 100755
index 0000000..0331386
--- /dev/null
+++
b/openaz-xacml-test/src/test/java/com/att/research/xacmlatt/pdp/std/functions/FunctionDefinitionSetTest.java
@@ -0,0 +1,1883 @@
+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.policy.FunctionArgumentBag;
+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 FunctionDefinitionSetTest {
+
+
+ /*
+ * variables useful in the following tests
+ */
+ List<FunctionArgument> arguments = new ArrayList<FunctionArgument>();
+
+
+
+ //
+ // INTERSECTION tests
+ //
+
+
+ @Test
+ public void testString_intersection() {
+ String a = "a";
+ String b = "b";
+ String c = "c";
+ String d = "d";
+ String e = "e";
+ String f = "f";
+ String g = "g";
+ String h = "h";
+ String j = "j";
+
+
+ Bag bagabcdefg = null;
+ Bag bagbdfhj = null;
+ Bag bagace = null;
+ Bag bagb = null;
+ Bag bagaaacccef = null;
+ Bag bagInt = null;
+ Bag bagStringInt = null;
+ Bag bagEmpty = null;
+
+ FunctionArgumentAttributeValue attrBadType = null;
+
+ try {
+ bagabcdefg = new Bag();
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(b));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(d));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(e));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(f));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(g));
+ bagbdfhj = new Bag();
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(b));
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(d));
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(f));
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(h));
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(j));
+ bagace = new Bag();
+
bagace.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagace.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagace.add(DataTypes.DT_STRING.createAttributeValue(e));
+ bagb = new Bag();
+
bagb.add(DataTypes.DT_STRING.createAttributeValue(b));
+ bagaaacccef = new Bag();
+
bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(e));
+
bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(f));
+ bagInt = new Bag();
+
bagInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
+ bagStringInt = new Bag();
+
bagStringInt.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagStringInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
+ bagEmpty = new Bag();
+
+ attrBadType = new
FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(1.1));
+ } catch (Exception ex) {
+ fail("creating attribute e="+ ex);
+ }
+
+ // make into attributes
+ FunctionArgumentBag attrBagabcdefg = new
FunctionArgumentBag(bagabcdefg);
+ FunctionArgumentBag attrBagbdfhj = new
FunctionArgumentBag(bagbdfhj);
+ FunctionArgumentBag attrBagace = new
FunctionArgumentBag(bagace);
+ FunctionArgumentBag attrBagb = new FunctionArgumentBag(bagb);
+ FunctionArgumentBag attrBagaaacccef = new
FunctionArgumentBag(bagaaacccef);
+ FunctionArgumentBag attrBagInt = new
FunctionArgumentBag(bagInt);
+ FunctionArgumentBag attrBagStringInt = new
FunctionArgumentBag(bagStringInt);
+ FunctionArgumentBag attrBagEmpty = new
FunctionArgumentBag(bagEmpty);
+
+ FunctionDefinitionSet<?,?> fd = (FunctionDefinitionSet<?,?>)
StdFunctions.FD_STRING_INTERSECTION;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_STRING_INTERSECTION,
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());
+
+ // normal intersection (everything in both bags, no duplicates)
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagabcdefg);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Bag bag = res.getBag();
+ assertNotNull(bag);
+ Iterator<AttributeValue<?>> it = bag.getAttributeValues();
+ assertEquals(7, bag.size());
+ AttributeValue<?> attrValueObject = it.next();
+ assertEquals(DataTypes.DT_STRING.getId(),
attrValueObject.getDataTypeId());
+ assertEquals(a, attrValueObject.getValue() );
+
+ // several but not all intersection
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagbdfhj);
+ 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(b, attrValueObject.getValue() );
+
+ // no intersection
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagbdfhj);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(0, bag.size());
+
+ // one intersection
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagb);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(1, bag.size());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_STRING.getId(),
attrValueObject.getDataTypeId());
+ assertEquals(b, attrValueObject.getValue() );
+
+ // bag one has duplicates that do not intersect
+ arguments.clear();
+ arguments.add(attrBagaaacccef);
+ arguments.add(attrBagbdfhj);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(1, bag.size());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_STRING.getId(),
attrValueObject.getDataTypeId());
+ assertEquals(f, attrValueObject.getValue() );
+
+ // bag one has duplicates that do intersect
+ arguments.clear();
+ arguments.add(attrBagaaacccef);
+ arguments.add(attrBagace);
+ 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(a, attrValueObject.getValue() );
+ attrValueObject = it.next();
+ assertEquals(c, attrValueObject.getValue() );
+ attrValueObject = it.next();
+ assertEquals(e, attrValueObject.getValue() );
+
+ // bag 2 has duplicates that do not intersect
+ arguments.clear();
+ arguments.add(attrBagbdfhj);
+ arguments.add(attrBagaaacccef);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(1, bag.size());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_STRING.getId(),
attrValueObject.getDataTypeId());
+ assertEquals(f, attrValueObject.getValue() );
+
+ // bag 2 has duplicates that intersect
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagaaacccef);
+ 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(a, attrValueObject.getValue() );
+ attrValueObject = it.next();
+ assertEquals(c, attrValueObject.getValue() );
+ attrValueObject = it.next();
+ assertEquals(e, attrValueObject.getValue() );
+
+ // first bag is empty
+ arguments.clear();
+ arguments.add(attrBagEmpty);
+ arguments.add(attrBagaaacccef);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(0, bag.size());
+
+ // second bag is empty
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagEmpty);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(0, bag.size());
+
+ // bags of different types
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagStringInt);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(1, bag.size());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_STRING.getId(),
attrValueObject.getDataTypeId());
+ assertEquals(a, attrValueObject.getValue() );
+
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagInt);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(0, bag.size());
+
+ // first not a bag
+ arguments.clear();
+ arguments.add(attrBadType);
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-intersection Expected a bag, saw
a simple value", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // second not a bag
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBadType);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-intersection Expected a bag, saw
a simple value", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+
+ // first null
+ arguments.clear();
+ arguments.add(null);
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-intersection Got null argument",
res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // second null
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(null);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-intersection Got null argument",
res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // too few args
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-intersection Expected 2
arguments, got 1", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ arguments.clear();
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-intersection Expected 2
arguments, got 0", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // too many args
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-intersection Expected 2
arguments, got 3", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ }
+
+
+
+ @Test
+ public void testInteger_intersection() {
+ BigInteger a = new BigInteger("1");
+ BigInteger b = new BigInteger("2");
+ BigInteger c = new BigInteger("3");
+ BigInteger d = new BigInteger("4");
+ BigInteger e = new BigInteger("5");
+ BigInteger f = new BigInteger("6");
+ BigInteger g = new BigInteger("7");
+ BigInteger h = new BigInteger("8");
+ BigInteger j = new BigInteger("9");
+
+
+ Bag bagabcdefg = null;
+ Bag bagbdfhj = null;
+ Bag bagace = null;
+ Bag bagb = null;
+ Bag bagaaacccef = null;
+ Bag bagInt = null;
+ Bag bagStringInt = null;
+ Bag bagEmpty = null;
+
+ FunctionArgumentAttributeValue attrBadType = null;
+
+ try {
+ bagabcdefg = new Bag();
+
bagabcdefg.add(DataTypes.DT_INTEGER.createAttributeValue(a));
+
bagabcdefg.add(DataTypes.DT_INTEGER.createAttributeValue(b));
+
bagabcdefg.add(DataTypes.DT_INTEGER.createAttributeValue(c));
+
bagabcdefg.add(DataTypes.DT_INTEGER.createAttributeValue(d));
+
bagabcdefg.add(DataTypes.DT_INTEGER.createAttributeValue(e));
+
bagabcdefg.add(DataTypes.DT_INTEGER.createAttributeValue(f));
+
bagabcdefg.add(DataTypes.DT_INTEGER.createAttributeValue(g));
+ bagbdfhj = new Bag();
+
bagbdfhj.add(DataTypes.DT_INTEGER.createAttributeValue(b));
+
bagbdfhj.add(DataTypes.DT_INTEGER.createAttributeValue(d));
+
bagbdfhj.add(DataTypes.DT_INTEGER.createAttributeValue(f));
+
bagbdfhj.add(DataTypes.DT_INTEGER.createAttributeValue(h));
+
bagbdfhj.add(DataTypes.DT_INTEGER.createAttributeValue(j));
+ bagace = new Bag();
+
bagace.add(DataTypes.DT_INTEGER.createAttributeValue(a));
+
bagace.add(DataTypes.DT_INTEGER.createAttributeValue(c));
+
bagace.add(DataTypes.DT_INTEGER.createAttributeValue(e));
+ bagb = new Bag();
+
bagb.add(DataTypes.DT_INTEGER.createAttributeValue(b));
+ bagaaacccef = new Bag();
+
bagaaacccef.add(DataTypes.DT_INTEGER.createAttributeValue(a));
+
bagaaacccef.add(DataTypes.DT_INTEGER.createAttributeValue(a));
+
bagaaacccef.add(DataTypes.DT_INTEGER.createAttributeValue(a));
+
bagaaacccef.add(DataTypes.DT_INTEGER.createAttributeValue(c));
+
bagaaacccef.add(DataTypes.DT_INTEGER.createAttributeValue(c));
+
bagaaacccef.add(DataTypes.DT_INTEGER.createAttributeValue(c));
+
bagaaacccef.add(DataTypes.DT_INTEGER.createAttributeValue(e));
+
bagaaacccef.add(DataTypes.DT_INTEGER.createAttributeValue(f));
+ bagInt = new Bag();
+
bagInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
+ bagStringInt = new Bag();
+
bagStringInt.add(DataTypes.DT_STRING.createAttributeValue("abc"));
+
bagStringInt.add(DataTypes.DT_INTEGER.createAttributeValue(1));
+ bagEmpty = new Bag();
+
+ attrBadType = new
FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(1.1));
+ } catch (Exception ex) {
+ fail("creating attribute e="+ ex);
+ }
+
+ // make into attributes
+ FunctionArgumentBag attrBagabcdefg = new
FunctionArgumentBag(bagabcdefg);
+ FunctionArgumentBag attrBagbdfhj = new
FunctionArgumentBag(bagbdfhj);
+ FunctionArgumentBag attrBagace = new
FunctionArgumentBag(bagace);
+ FunctionArgumentBag attrBagb = new FunctionArgumentBag(bagb);
+ FunctionArgumentBag attrBagaaacccef = new
FunctionArgumentBag(bagaaacccef);
+ FunctionArgumentBag attrBagInt = new
FunctionArgumentBag(bagInt);
+ FunctionArgumentBag attrBagStringInt = new
FunctionArgumentBag(bagStringInt);
+ FunctionArgumentBag attrBagEmpty = new
FunctionArgumentBag(bagEmpty);
+
+ FunctionDefinitionSet<?,?> fd = (FunctionDefinitionSet<?,?>)
StdFunctions.FD_INTEGER_INTERSECTION;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_INTEGER_INTERSECTION,
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());
+
+ // normal intersection (everything in both bags, no duplicates)
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagabcdefg);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Bag bag = res.getBag();
+ assertNotNull(bag);
+ Iterator<AttributeValue<?>> it = bag.getAttributeValues();
+ assertEquals(7, bag.size());
+ AttributeValue<?> attrValueObject = it.next();
+ assertEquals(DataTypes.DT_INTEGER.getId(),
attrValueObject.getDataTypeId());
+ assertEquals(a, attrValueObject.getValue() );
+
+ // several but not all intersection
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagbdfhj);
+ 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(b, attrValueObject.getValue() );
+
+ // no intersection
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagbdfhj);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(0, bag.size());
+
+ // one intersection
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagb);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(1, bag.size());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_INTEGER.getId(),
attrValueObject.getDataTypeId());
+ assertEquals(b, attrValueObject.getValue() );
+
+ // bag one has duplicates that do not intersect
+ arguments.clear();
+ arguments.add(attrBagaaacccef);
+ arguments.add(attrBagbdfhj);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(1, bag.size());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_INTEGER.getId(),
attrValueObject.getDataTypeId());
+ assertEquals(f, attrValueObject.getValue() );
+
+ // bag one has duplicates that do intersect
+ arguments.clear();
+ arguments.add(attrBagaaacccef);
+ arguments.add(attrBagace);
+ 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(a, attrValueObject.getValue() );
+ attrValueObject = it.next();
+ assertEquals(c, attrValueObject.getValue() );
+ attrValueObject = it.next();
+ assertEquals(e, attrValueObject.getValue() );
+
+ // bag 2 has duplicates that do not intersect
+ arguments.clear();
+ arguments.add(attrBagbdfhj);
+ arguments.add(attrBagaaacccef);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(1, bag.size());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_INTEGER.getId(),
attrValueObject.getDataTypeId());
+ assertEquals(f, attrValueObject.getValue() );
+
+ // bag 2 has duplicates that intersect
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagaaacccef);
+ 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(a, attrValueObject.getValue() );
+ attrValueObject = it.next();
+ assertEquals(c, attrValueObject.getValue() );
+ attrValueObject = it.next();
+ assertEquals(e, attrValueObject.getValue() );
+
+ // first bag is empty
+ arguments.clear();
+ arguments.add(attrBagEmpty);
+ arguments.add(attrBagaaacccef);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(0, bag.size());
+
+ // second bag is empty
+ arguments.clear();
+ arguments.add(attrBagbdfhj);
+ arguments.add(attrBagEmpty);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(0, bag.size());
+
+ // bags of different types
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagStringInt);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(1, bag.size());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_INTEGER.getId(),
attrValueObject.getDataTypeId());
+ assertEquals(a, attrValueObject.getValue() );
+
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagInt);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(1, bag.size());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_INTEGER.getId(),
attrValueObject.getDataTypeId());
+ assertEquals(a, attrValueObject.getValue() );
+
+
+ // first not a bag
+ arguments.clear();
+ arguments.add(attrBadType);
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:integer-intersection Expected a bag, saw
a simple value", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // second not a bag
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBadType);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:integer-intersection Expected a bag, saw
a simple value", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+
+ // first null
+ arguments.clear();
+ arguments.add(null);
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:integer-intersection Got null argument",
res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // second null
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(null);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:integer-intersection Got null argument",
res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // too few args
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:integer-intersection Expected 2
arguments, got 1", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ arguments.clear();
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:integer-intersection Expected 2
arguments, got 0", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // too many args
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:integer-intersection Expected 2
arguments, got 3", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+ //
+ // AT_LEAST_ONE_MEMBER_OF tests
+ //
+
+ @Test
+ public void testString_at_least_one_member_of() {
+ String a = "a";
+ String b = "b";
+ String c = "c";
+ String d = "d";
+ String e = "e";
+ String f = "f";
+ String g = "g";
+ String h = "h";
+ String j = "j";
+
+
+ Bag bagabcdefg = null;
+ Bag bagbdfhj = null;
+ Bag bagace = null;
+ Bag bagb = null;
+ Bag bagaaaccce = null;
+ Bag bagInt = null;
+ Bag bagStringInt = null;
+ Bag bagEmpty = null;
+
+ FunctionArgumentAttributeValue attrBadType = null;
+
+ try {
+ bagabcdefg = new Bag();
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(b));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(d));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(e));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(f));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(g));
+ bagbdfhj = new Bag();
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(b));
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(d));
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(f));
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(h));
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(j));
+ bagace = new Bag();
+
bagace.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagace.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagace.add(DataTypes.DT_STRING.createAttributeValue(e));
+ bagb = new Bag();
+
bagb.add(DataTypes.DT_STRING.createAttributeValue(b));
+ bagaaaccce = new Bag();
+
bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(e));
+ bagInt = new Bag();
+
bagInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
+ bagStringInt = new Bag();
+
bagStringInt.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagStringInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
+ bagEmpty = new Bag();
+
+ attrBadType = new
FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(1.1));
+ } catch (Exception ex) {
+ fail("creating attribute e="+ ex);
+ }
+
+ // make into attributes
+ FunctionArgumentBag attrBagabcdefg = new
FunctionArgumentBag(bagabcdefg);
+ FunctionArgumentBag attrBagbdfhj = new
FunctionArgumentBag(bagbdfhj);
+ FunctionArgumentBag attrBagace = new
FunctionArgumentBag(bagace);
+ FunctionArgumentBag attrBagb = new FunctionArgumentBag(bagb);
+ FunctionArgumentBag attrBagaaaccce = new
FunctionArgumentBag(bagaaaccce);
+ FunctionArgumentBag attrBagInt = new
FunctionArgumentBag(bagInt);
+ FunctionArgumentBag attrBagStringInt = new
FunctionArgumentBag(bagStringInt);
+ FunctionArgumentBag attrBagEmpty = new
FunctionArgumentBag(bagEmpty);
+
+ FunctionDefinitionSet<?,?> fd = (FunctionDefinitionSet<?,?>)
StdFunctions.FD_STRING_AT_LEAST_ONE_MEMBER_OF;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_STRING_AT_LEAST_ONE_MEMBER_OF,
fd.getId());
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+
+ // just to be safe... If tests take too long these can
probably be eliminated
+ assertFalse(fd.returnsBag());
+
+ // normal intersection (everything in both bags, no duplicates)
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagabcdefg);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+
+ // several but not all intersection
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagbdfhj);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // no intersection
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagbdfhj);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // one intersection
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagb);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // bag one has duplicates that do not intersect
+ arguments.clear();
+ arguments.add(attrBagaaaccce);
+ arguments.add(attrBagbdfhj);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // bag one has duplicates that do intersect
+ arguments.clear();
+ arguments.add(attrBagaaaccce);
+ arguments.add(attrBagace);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // bag 2 has duplicates that do not intersect
+ arguments.clear();
+ arguments.add(attrBagbdfhj);
+ arguments.add(attrBagaaaccce);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // bag 2 has duplicates that intersect
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagaaaccce);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // 2 empty bags
+ arguments.clear();
+ arguments.add(attrBagEmpty);
+ arguments.add(attrBagEmpty);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first non-empty, 2nd empty
+ arguments.clear();
+ arguments.add(attrBagaaaccce);
+ arguments.add(attrBagEmpty);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first empty, 2nd not empty
+ arguments.clear();
+ arguments.add(attrBagEmpty);
+ arguments.add(attrBagaaaccce);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // bags of different types
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagStringInt);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagInt);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagStringInt);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // first not a bag
+ arguments.clear();
+ arguments.add(attrBadType);
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-at-least-one-member-of Expected a
bag, saw a simple value", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // second not a bag
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBadType);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-at-least-one-member-of Expected a
bag, saw a simple value", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+
+ // first null
+ arguments.clear();
+ arguments.add(null);
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-at-least-one-member-of Got null
argument", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // second null
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(null);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-at-least-one-member-of Got null
argument", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // too few args
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-at-least-one-member-of Expected 2
arguments, got 1", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ arguments.clear();
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-at-least-one-member-of Expected 2
arguments, got 0", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // too many args
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-at-least-one-member-of Expected 2
arguments, got 3", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+ //
+ // UNION tests
+ //
+
+
+
+
+
+ @Test
+ public void testString_union() {
+ String a = "a";
+ String b = "b";
+ String c = "c";
+ String d = "d";
+ String e = "e";
+ String f = "f";
+ String g = "g";
+ String h = "h";
+ String j = "j";
+
+
+ Bag bagabcdefg = null;
+ Bag bagbdfhj = null;
+ Bag bagace = null;
+ Bag bagaaacccef = null;
+ Bag bagInt = null;
+ Bag bagStringInt = null;
+ Bag bagEmpty = null;
+
+ FunctionArgumentAttributeValue attrBadType = null;
+
+ try {
+ bagabcdefg = new Bag();
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(b));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(d));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(e));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(f));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(g));
+ bagbdfhj = new Bag();
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(b));
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(d));
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(f));
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(h));
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(j));
+ bagace = new Bag();
+
bagace.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagace.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagace.add(DataTypes.DT_STRING.createAttributeValue(e));
+ bagaaacccef = new Bag();
+
bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(e));
+
bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(f));
+ bagInt = new Bag();
+
bagInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
+ bagStringInt = new Bag();
+
bagStringInt.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagStringInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
+ bagEmpty = new Bag();
+
+ attrBadType = new
FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(1.1));
+ } catch (Exception ex) {
+ fail("creating attribute e="+ ex);
+ }
+
+ // make into attributes
+ FunctionArgumentBag attrBagabcdefg = new
FunctionArgumentBag(bagabcdefg);
+ FunctionArgumentBag attrBagbdfhj = new
FunctionArgumentBag(bagbdfhj);
+ FunctionArgumentBag attrBagace = new
FunctionArgumentBag(bagace);
+ FunctionArgumentBag attrBagaaacccef = new
FunctionArgumentBag(bagaaacccef);
+ FunctionArgumentBag attrBagInt = new
FunctionArgumentBag(bagInt);
+ FunctionArgumentBag attrBagStringInt = new
FunctionArgumentBag(bagStringInt);
+ FunctionArgumentBag attrBagEmpty = new
FunctionArgumentBag(bagEmpty);
+
+ FunctionDefinitionSet<?,?> fd = (FunctionDefinitionSet<?,?>)
StdFunctions.FD_STRING_UNION;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_STRING_UNION, 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());
+
+ // normal intersection (everything in both bags, no duplicates)
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagabcdefg);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Bag bag = res.getBag();
+ assertNotNull(bag);
+ Iterator<AttributeValue<?>> it = bag.getAttributeValues();
+ assertEquals(7, bag.size());
+ AttributeValue<?> attrValueObject = it.next();
+ assertEquals(DataTypes.DT_STRING.getId(),
attrValueObject.getDataTypeId());
+ assertEquals(a, attrValueObject.getValue() );
+
+ // several but not all union
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagbdfhj);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(8, bag.size());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_STRING.getId(),
attrValueObject.getDataTypeId());
+ assertEquals(a, attrValueObject.getValue() );
+
+ // bag one has duplicates that do not match first bag
+ arguments.clear();
+ arguments.add(attrBagaaacccef);
+ arguments.add(attrBagbdfhj);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(8, bag.size());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_STRING.getId(),
attrValueObject.getDataTypeId());
+ assertEquals(a, attrValueObject.getValue() );
+
+ // bag one has duplicates that do match first bag
+ arguments.clear();
+ arguments.add(attrBagaaacccef);
+ arguments.add(attrBagace);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(4, bag.size());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_STRING.getId(),
attrValueObject.getDataTypeId());
+ assertEquals(a, attrValueObject.getValue() );
+ attrValueObject = it.next();
+ assertEquals(c, attrValueObject.getValue() );
+ attrValueObject = it.next();
+ assertEquals(e, attrValueObject.getValue() );
+
+ // bag 2 has duplicates that do not match first bag
+ arguments.clear();
+ arguments.add(attrBagbdfhj);
+ arguments.add(attrBagaaacccef);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(8, bag.size());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_STRING.getId(),
attrValueObject.getDataTypeId());
+ assertEquals(b, attrValueObject.getValue() );
+
+ // bag 2 has duplicates that do match first bag
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagaaacccef);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(4, bag.size());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_STRING.getId(),
attrValueObject.getDataTypeId());
+ assertEquals(a, attrValueObject.getValue() );
+ attrValueObject = it.next();
+ assertEquals(c, attrValueObject.getValue() );
+ attrValueObject = it.next();
+ assertEquals(e, attrValueObject.getValue() );
+
+ // two empty bags
+ arguments.clear();
+ arguments.add(attrBagEmpty);
+ arguments.add(attrBagEmpty);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(0, bag.size());
+
+ // first bag empty, 2nd not empty
+ arguments.clear();
+ arguments.add(attrBagEmpty);
+ arguments.add(attrBagaaacccef);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(4, bag.size());
+
+ // first bag not empty, 2nd empty
+ arguments.clear();
+ arguments.add(attrBagaaacccef);
+ arguments.add(attrBagEmpty);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(4, bag.size());
+
+ // bags of different types
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagStringInt);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(4, bag.size());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_STRING.getId(),
attrValueObject.getDataTypeId());
+ assertEquals(a, attrValueObject.getValue() );
+
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagInt);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ bag = res.getBag();
+ assertNotNull(bag);
+ it = bag.getAttributeValues();
+ assertEquals(4, bag.size());
+ attrValueObject = it.next();
+ assertEquals(DataTypes.DT_STRING.getId(),
attrValueObject.getDataTypeId());
+ assertEquals(a, attrValueObject.getValue() );
+
+ // first not a bag
+ arguments.clear();
+ arguments.add(attrBadType);
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-union Expected a bag, saw a
simple value", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // second not a bag
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBadType);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-union Expected a bag, saw a
simple value", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+
+ // first null
+ arguments.clear();
+ arguments.add(null);
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-union Got null argument",
res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // second null
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(null);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-union Got null argument",
res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // too few args
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-union Expected 2 arguments, got
1", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ arguments.clear();
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-union Expected 2 arguments, got
0", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // too many args
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-union Expected 2 arguments, got
3", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ }
+
+
+
+
+
+
+
+
+
+
+ //
+ // SUBSET tests
+ //
+
+ @Test
+ public void testString_subset() {
+ String a = "a";
+ String b = "b";
+ String c = "c";
+ String d = "d";
+ String e = "e";
+ String f = "f";
+ String g = "g";
+ String h = "h";
+ String j = "j";
+
+
+ Bag bagabcdefg = null;
+ Bag bagbdfhj = null;
+ Bag bagace = null;
+ Bag bagb = null;
+ Bag bagaaaccce = null;
+ Bag bagInt = null;
+ Bag bagStringInt = null;
+ Bag bagEmpty = null;
+
+ FunctionArgumentAttributeValue attrBadType = null;
+
+ try {
+ bagabcdefg = new Bag();
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(b));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(d));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(e));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(f));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(g));
+ bagbdfhj = new Bag();
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(b));
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(d));
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(f));
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(h));
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(j));
+ bagace = new Bag();
+
bagace.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagace.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagace.add(DataTypes.DT_STRING.createAttributeValue(e));
+ bagb = new Bag();
+
bagb.add(DataTypes.DT_STRING.createAttributeValue(b));
+ bagaaaccce = new Bag();
+
bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(e));
+ bagInt = new Bag();
+
bagInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
+ bagStringInt = new Bag();
+
bagStringInt.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagStringInt.add(DataTypes.DT_STRING.createAttributeValue(b));
+
bagStringInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
+ bagEmpty = new Bag();
+
+ attrBadType = new
FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(1.1));
+ } catch (Exception ex) {
+ fail("creating attribute e="+ ex);
+ }
+
+ // make into attributes
+ FunctionArgumentBag attrBagabcdefg = new
FunctionArgumentBag(bagabcdefg);
+ FunctionArgumentBag attrBagbdfhj = new
FunctionArgumentBag(bagbdfhj);
+ FunctionArgumentBag attrBagace = new
FunctionArgumentBag(bagace);
+ FunctionArgumentBag attrBagb = new FunctionArgumentBag(bagb);
+ FunctionArgumentBag attrBagaaaccce = new
FunctionArgumentBag(bagaaaccce);
+ FunctionArgumentBag attrBagInt = new
FunctionArgumentBag(bagInt);
+ FunctionArgumentBag attrBagStringInt = new
FunctionArgumentBag(bagStringInt);
+ FunctionArgumentBag attrBagEmpty = new
FunctionArgumentBag(bagEmpty);
+
+ FunctionDefinitionSet<?,?> fd = (FunctionDefinitionSet<?,?>)
StdFunctions.FD_STRING_SUBSET;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_STRING_SUBSET, fd.getId());
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+
+ // just to be safe... If tests take too long these can
probably be eliminated
+ assertFalse(fd.returnsBag());
+
+ // normal intersection (everything in both bags, no duplicates)
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagabcdefg);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+
+ // not subset
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagbdfhj);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // subset
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+
+ // no intersection
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagbdfhj);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // Not
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagb);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // Subset
+ arguments.clear();
+ arguments.add(attrBagb);
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // bag one has duplicates that do not intersect
+ arguments.clear();
+ arguments.add(attrBagaaaccce);
+ arguments.add(attrBagbdfhj);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // bag one has duplicates that do intersect
+ arguments.clear();
+ arguments.add(attrBagaaaccce);
+ arguments.add(attrBagace);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // bag 2 has duplicates that do not intersect
+ arguments.clear();
+ arguments.add(attrBagbdfhj);
+ arguments.add(attrBagaaaccce);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // bag 2 has duplicates that intersect
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagaaaccce);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // 2 empty bags
+ arguments.clear();
+ arguments.add(attrBagEmpty);
+ arguments.add(attrBagEmpty);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // first non-empty, 2nd empty
+ arguments.clear();
+ arguments.add(attrBagaaaccce);
+ arguments.add(attrBagEmpty);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first empty, 2nd not empty
+ arguments.clear();
+ arguments.add(attrBagEmpty);
+ arguments.add(attrBagaaaccce);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // bags of different types
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagStringInt);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ arguments.clear();
+ arguments.add(attrBagb);
+ arguments.add(attrBagStringInt);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagInt);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first not a bag
+ arguments.clear();
+ arguments.add(attrBadType);
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-subset Expected a bag, saw a
simple value", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // second not a bag
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBadType);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-subset Expected a bag, saw a
simple value", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+
+ // first null
+ arguments.clear();
+ arguments.add(null);
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-subset Got null argument",
res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // second null
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(null);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-subset Got null argument",
res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // too few args
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-subset Expected 2 arguments, got
1", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ arguments.clear();
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-subset Expected 2 arguments, got
0", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // too many args
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-subset Expected 2 arguments, got
3", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ }
+
+
+
+
+
+
+
+
+
+
+
+ //
+ // SET_EQUALS tests
+ //
+
+ @Test
+ public void testString_set_equals() {
+ String a = "a";
+ String b = "b";
+ String c = "c";
+ String d = "d";
+ String e = "e";
+ String f = "f";
+ String g = "g";
+ String h = "h";
+ String j = "j";
+
+
+ Bag bagabcdefg = null;
+ Bag bagbdfhj = null;
+ Bag bagace = null;
+ Bag bagb = null;
+ Bag bagaaaccce = null;
+ Bag bagInt = null;
+ Bag bagStringInt = null;
+ Bag bagEmpty = null;
+
+ FunctionArgumentAttributeValue attrBadType = null;
+
+ try {
+ bagabcdefg = new Bag();
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(b));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(d));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(e));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(f));
+
bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(g));
+ bagbdfhj = new Bag();
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(b));
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(d));
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(f));
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(h));
+
bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(j));
+ bagace = new Bag();
+
bagace.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagace.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagace.add(DataTypes.DT_STRING.createAttributeValue(e));
+ bagb = new Bag();
+
bagb.add(DataTypes.DT_STRING.createAttributeValue(b));
+ bagaaaccce = new Bag();
+
bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(c));
+
bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(e));
+ bagInt = new Bag();
+
bagInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
+ bagStringInt = new Bag();
+
bagStringInt.add(DataTypes.DT_STRING.createAttributeValue(a));
+
bagStringInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
+ bagEmpty = new Bag();
+
+ attrBadType = new
FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(1.1));
+ } catch (Exception ex) {
+ fail("creating attribute e="+ ex);
+ }
+
+ // make into attributes
+ FunctionArgumentBag attrBagabcdefg = new
FunctionArgumentBag(bagabcdefg);
+ FunctionArgumentBag attrBagbdfhj = new
FunctionArgumentBag(bagbdfhj);
+ FunctionArgumentBag attrBagace = new
FunctionArgumentBag(bagace);
+ FunctionArgumentBag attrBagb = new FunctionArgumentBag(bagb);
+ FunctionArgumentBag attrBagaaaccce = new
FunctionArgumentBag(bagaaaccce);
+ FunctionArgumentBag attrBagInt = new
FunctionArgumentBag(bagInt);
+ FunctionArgumentBag attrBagStringInt = new
FunctionArgumentBag(bagStringInt);
+ FunctionArgumentBag attrBagEmpty = new
FunctionArgumentBag(bagEmpty);
+
+ FunctionDefinitionSet<?,?> fd = (FunctionDefinitionSet<?,?>)
StdFunctions.FD_STRING_SET_EQUALS;
+
+ // check identity and type of the thing created
+ assertEquals(XACML3.ID_FUNCTION_STRING_SET_EQUALS, fd.getId());
+ assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
+
+ // just to be safe... If tests take too long these can
probably be eliminated
+ assertFalse(fd.returnsBag());
+
+ // normal intersection (everything in both bags, no duplicates)
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagabcdefg);
+ ExpressionResult res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ Boolean resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+
+ // several but not all intersection
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagbdfhj);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // no intersection
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagbdfhj);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // one intersection
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagb);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // bag one has duplicates that do not intersect
+ arguments.clear();
+ arguments.add(attrBagaaaccce);
+ arguments.add(attrBagbdfhj);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // bag one has duplicates that do intersect
+ arguments.clear();
+ arguments.add(attrBagaaaccce);
+ arguments.add(attrBagace);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // bag 2 has duplicates that do not intersect
+ arguments.clear();
+ arguments.add(attrBagbdfhj);
+ arguments.add(attrBagaaaccce);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // bag 2 has duplicates that intersect
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagaaaccce);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // 2 empty bags
+ arguments.clear();
+ arguments.add(attrBagEmpty);
+ arguments.add(attrBagEmpty);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertTrue(resValue);
+
+ // first non-empty, 2nd empty
+ arguments.clear();
+ arguments.add(attrBagaaaccce);
+ arguments.add(attrBagEmpty);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first empty, 2nd not empty
+ arguments.clear();
+ arguments.add(attrBagEmpty);
+ arguments.add(attrBagaaaccce);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // bags of different types
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagStringInt);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ arguments.clear();
+ arguments.add(attrBagace);
+ arguments.add(attrBagInt);
+ res = fd.evaluate(null, arguments);
+ assertTrue(res.isOk());
+ resValue = (Boolean)res.getValue().getValue();
+ assertFalse(resValue);
+
+ // first not a bag
+ arguments.clear();
+ arguments.add(attrBadType);
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-set-equals Expected a bag, saw a
simple value", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // second not a bag
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBadType);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-set-equals Expected a bag, saw a
simple value", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+
+ // first null
+ arguments.clear();
+ arguments.add(null);
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-set-equals Got null argument",
res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // second null
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(null);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-set-equals Got null argument",
res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // too few args
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-set-equals Expected 2 arguments,
got 1", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ arguments.clear();
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-set-equals Expected 2 arguments,
got 0", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ // too many args
+ arguments.clear();
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagabcdefg);
+ arguments.add(attrBagabcdefg);
+ res = fd.evaluate(null, arguments);
+ assertFalse(res.isOk());
+ assertEquals("function:string-set-equals Expected 2 arguments,
got 3", res.getStatus().getStatusMessage());
+
assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error",
res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
+
+ }
+
+
+
+
+
+
+
+
+
+
+ //
+ //
+ // REST OF DATA TYPES OMITTED
+ // because they "should" all work the same
+ //
+ //
+
+
+
+
+}
