ECOMP-PDP/src/test/java/org/openecomp/policy/pdp/test/FunctionDefinitionHigherOrderBagTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ECOMP-PDP
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.policy.pdp.test;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertFalse;
  25 import static org.junit.Assert.assertNull;
  26 import static org.junit.Assert.assertTrue;
  27 import static org.junit.Assert.fail;
  28
  29 import java.util.ArrayList;
  30 import java.util.List;
  31
  32 import org.junit.Test;
  33
  34 import com.att.research.xacml.api.AttributeValue;
  35 import com.att.research.xacml.api.XACML3;
  36 import com.att.research.xacml.std.datatypes.DataTypes;
  37 import com.att.research.xacmlatt.pdp.policy.Bag;
  38 import com.att.research.xacmlatt.pdp.policy.ExpressionResult;
  39 import com.att.research.xacmlatt.pdp.policy.FunctionArgument;
  40 import com.att.research.xacmlatt.pdp.policy.FunctionArgumentAttributeValue;
  41 import com.att.research.xacmlatt.pdp.policy.FunctionArgumentBag;
  42 import com.att.research.xacmlatt.pdp.std.StdFunctions;
  43 import com.att.research.xacmlatt.pdp.std.functions.*;
  44
  45 /**
  46  * Test of PDP Functions (See XACML core spec section A.3)
  47  *
  48  * TO RUN - use jUnit
  49  * In Eclipse select this file or the enclosing directory, right-click and select Run As/JUnit Test
  50  *
  51  *
  52  */
  53 public class FunctionDefinitionHigherOrderBagTest {
  54
  55
  56         /*
  57          * variables useful in the following tests
  58          */
  59         List<FunctionArgument> arguments = new ArrayList<>();
  60
  61
  62
  63         //
  64         // ANY-OF tests
  65         //
  66
  67
  68         @Test
  69         public void testAny_of() {
  70                 String a = "a";
  71                 String b = "b";
  72                 String c = "c";
  73                 String d = "d";
  74                 String e = "e";
  75                 String f = "f";
  76                 String g = "g";
  77                 String h = "h";
  78                 String j = "j";
  79
  80
  81                 Bag bagabcdefg = null;
  82                 Bag bagbdfhj = null;
  83                 Bag bagace = null;
  84                 Bag bagb = null;
  85                 Bag bagaaacccef = null;
  86                 Bag bagInt = null;
  87                 Bag bagStringInt = null;
  88                 Bag bagEmpty = null;
  89                 Bag bagStringBooleansTrue = null;
  90                 Bag bagStringBooleansFalse = null;
  91
  92
  93                 // primitive attrs
  94                 FunctionArgumentAttributeValue attra = null;
  95                 FunctionArgumentAttributeValue attrb = null;
  96                 FunctionArgumentAttributeValue attrh = null;
  97
  98
  99                 // predicates passed as arguments
 100                 FunctionArgumentAttributeValue attrPredicateStringEqual = null;
 101                 FunctionArgumentAttributeValue attrPredicateStringIntersection = null;
 102                 FunctionArgumentAttributeValue attrPredicateBooleanFromString = null;
 103
 104                 try {
 105
 106                         // Create Bag contents
 107                         bagabcdefg = new Bag();
 108                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(a));
 109                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(b));
 110                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(c));
 111                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(d));
 112                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(e));
 113                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(f));
 114                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(g));
 115                         bagbdfhj = new Bag();
 116                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(b));
 117                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(d));
 118                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(f));
 119                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(h));
 120                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(j));
 121                         bagace = new Bag();
 122                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(a));
 123                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(c));
 124                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(e));
 125                         bagb = new Bag();
 126                                 bagb.add(DataTypes.DT_STRING.createAttributeValue(b));
 127                         bagaaacccef = new Bag();
 128                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
 129                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
 130                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
 131                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
 132                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
 133                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
 134                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(e));
 135                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(f));
 136                         bagInt = new Bag();
 137                                 bagInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
 138                         bagStringInt = new Bag();
 139                                 bagStringInt.add(DataTypes.DT_STRING.createAttributeValue(a));
 140                                 bagStringInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
 141                         bagEmpty = new Bag();
 142                         bagStringBooleansTrue = new Bag();
 143                                 bagStringBooleansTrue.add(DataTypes.DT_STRING.createAttributeValue("false"));
 144                                 bagStringBooleansTrue.add(DataTypes.DT_STRING.createAttributeValue("false"));
 145                                 bagStringBooleansTrue.add(DataTypes.DT_STRING.createAttributeValue("true"));
 146                         bagStringBooleansFalse = new Bag();
 147                                 bagStringBooleansFalse.add(DataTypes.DT_STRING.createAttributeValue("false"));
 148                                 bagStringBooleansFalse.add(DataTypes.DT_STRING.createAttributeValue("false"));
 149
 150
 151                         // create primitive attrs
 152                         attra = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(a));
 153                         attrb = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(b));
 154                         attrh = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(h));
 155
 156
 157                         // predicates passed as function arguments
 158                         attrPredicateStringEqual = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_STRING_EQUAL));
 159                         attrPredicateStringIntersection = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_STRING_INTERSECTION));
 160                         attrPredicateBooleanFromString = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_BOOLEAN_FROM_STRING));
 161
 162                 } catch (Exception ex) {
 163                         fail("creating attribute e="+ ex);
 164                 }
 165
 166                 // make into attributes
 167                 FunctionArgumentBag attrBagabcdefg = new FunctionArgumentBag(bagabcdefg);
 168                 FunctionArgumentBag attrBagbdfhj = new FunctionArgumentBag(bagbdfhj);
 169                 FunctionArgumentBag attrBagace = new FunctionArgumentBag(bagace);
 170                 FunctionArgumentBag attrBagStringInt = new FunctionArgumentBag(bagStringInt);
 171                 FunctionArgumentBag attrBagEmpty = new FunctionArgumentBag(bagEmpty);
 172                 FunctionArgumentBag attrBagStringBooleansTrue = new FunctionArgumentBag(bagStringBooleansTrue);
 173                 FunctionArgumentBag attrBagStringBooleansFalse = new FunctionArgumentBag(bagStringBooleansFalse);
 174
 175                 FunctionDefinitionHigherOrderBag<?,?> fd = (FunctionDefinitionHigherOrderBag<?,?>) StdFunctions.FD_ANY_OF;
 176
 177                 // check identity and type of the thing created
 178                 assertEquals(XACML3.ID_FUNCTION_ANY_OF, fd.getId());
 179                 assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
 180
 181                 // just to be safe...  If tests take too long these can probably be eliminated
 182                 assertFalse(fd.returnsBag());
 183
 184                 // normal match
 185                 arguments.clear();
 186                 arguments.add(attrPredicateStringEqual);
 187                 arguments.add(attra);
 188                 arguments.add(attrBagabcdefg);
 189                 ExpressionResult res = fd.evaluate(null, arguments);
 190                 assertTrue(res.isOk());
 191                 Boolean resValue = (Boolean)res.getValue().getValue();
 192                 assertTrue(resValue);
 193
 194                 // bag in first position - match
 195                 arguments.clear();
 196                 arguments.add(attrPredicateStringEqual);
 197                 arguments.add(attrBagabcdefg);
 198                 arguments.add(attra);
 199                 res = fd.evaluate(null, arguments);
 200                 assertTrue(res.isOk());
 201                 resValue = (Boolean)res.getValue().getValue();
 202                 assertTrue(resValue);
 203
 204                 // normal no-match
 205                 arguments.clear();
 206                 arguments.add(attrPredicateStringEqual);
 207                 arguments.add(attra);
 208                 arguments.add(attrBagbdfhj);
 209                 res = fd.evaluate(null, arguments);
 210                 assertTrue(res.isOk());
 211                 resValue = (Boolean)res.getValue().getValue();
 212                 assertFalse(resValue);
 213
 214                 // multiple primitives
 215                 arguments.clear();
 216                 arguments.add(attrPredicateStringEqual);
 217                 arguments.add(attrh);
 218                 arguments.add(attrb);
 219                 arguments.add(attrBagace);
 220                 arguments.add(attra);
 221                 res = fd.evaluate(null, arguments);
 222                 assertFalse(res.isOk());
 223                 assertEquals("function:any-of Predicate error: function:string-equal Expected 2 arguments, got 4", res.getStatus().getStatusMessage());
 224                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 225
 226
 227                 // no primitives - predicate function expects 2
 228                 arguments.clear();
 229                 arguments.add(attrPredicateStringEqual);
 230                 arguments.add(attrBagace);
 231                 res = fd.evaluate(null, arguments);
 232                 assertFalse(res.isOk());
 233                 assertEquals("function:any-of Predicate error: function:string-equal Expected 2 arguments, got 1", res.getStatus().getStatusMessage());
 234                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 235
 236                 // no primitives - predicate expects only 1 arg
 237                 arguments.clear();
 238                 arguments.add(attrPredicateBooleanFromString);
 239                 arguments.add(attrBagStringBooleansTrue);
 240                 res = fd.evaluate(null, arguments);
 241                 assertTrue(res.isOk());
 242                 resValue = (Boolean)res.getValue().getValue();
 243                 assertTrue(resValue);
 244
 245                 arguments.clear();
 246                 arguments.add(attrPredicateBooleanFromString);
 247                 arguments.add(attrBagStringBooleansFalse);
 248                 res = fd.evaluate(null, arguments);
 249                 assertTrue(res.isOk());
 250                 resValue = (Boolean)res.getValue().getValue();
 251                 assertFalse(resValue);
 252
 253                 // bag is empty
 254                 arguments.clear();
 255                 arguments.add(attrPredicateStringEqual);
 256                 arguments.add(attrh);
 257                 arguments.add(attrBagEmpty);
 258                 res = fd.evaluate(null, arguments);
 259                 assertTrue(res.isOk());
 260                 resValue = (Boolean)res.getValue().getValue();
 261                 assertFalse(resValue);
 262
 263                 // no bag
 264                 arguments.clear();
 265                 arguments.add(attrPredicateStringEqual);
 266                 arguments.add(attrh);
 267                 res = fd.evaluate(null, arguments);
 268                 assertFalse(res.isOk());
 269                 assertEquals("function:any-of Did not get any Bag argument; must have at least 1", res.getStatus().getStatusMessage());
 270                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 271
 272                 // extra bag
 273                 arguments.clear();
 274                 arguments.add(attrPredicateStringEqual);
 275                 arguments.add(attrh);
 276                 arguments.add(attrBagStringBooleansTrue);
 277                 arguments.add(attrh);
 278                 arguments.add(attrBagStringBooleansTrue);
 279                 res = fd.evaluate(null, arguments);
 280                 assertFalse(res.isOk());
 281                 assertEquals("function:any-of must have only 1 bag; found one at index 2 and another at 4", res.getStatus().getStatusMessage());
 282                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 283
 284
 285                 // bad predicate
 286                 arguments.clear();
 287                 arguments.add(attrh);
 288                 arguments.add(attrBagStringInt);
 289                 res = fd.evaluate(null, arguments);
 290                 assertFalse(res.isOk());
 291                 assertEquals("function:any-of First argument expected URI, got http://www.w3.org/2001/XMLSchema#string", res.getStatus().getStatusMessage());
 292                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 293
 294                 // non-boolean predicate
 295                 arguments.clear();
 296                 arguments.add(attrPredicateStringIntersection);
 297                 arguments.add(attrh);
 298                 arguments.add(attrBagStringInt);
 299                 res = fd.evaluate(null, arguments);
 300                 assertFalse(res.isOk());
 301                 assertEquals("function:any-of Predicate Function must return boolean, but 'urn:oasis:names:tc:xacml:1.0:function:string-intersection' returns 'string", res.getStatus().getStatusMessage());
 302                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 303
 304                 // predicate after first arg
 305                 arguments.clear();
 306                 arguments.add(attrPredicateStringEqual);
 307                 arguments.add(attrPredicateStringIntersection);
 308                 arguments.add(attrBagStringInt);
 309                 res = fd.evaluate(null, arguments);
 310                 assertFalse(res.isOk());
 311                 assertEquals("function:any-of Predicate error: function:string-equal Expected data type 'string' saw 'anyURI' at arg index 0", res.getStatus().getStatusMessage());
 312                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 313
 314                 // bags of different types
 315                 arguments.clear();
 316                 arguments.add(attrPredicateStringEqual);
 317                 arguments.add(attrh);
 318                 arguments.add(attrBagStringInt);
 319                 res = fd.evaluate(null, arguments);
 320                 assertFalse(res.isOk());
 321
 322                 // first null
 323                 arguments.clear();
 324                 arguments.add(null);
 325                 arguments.add(attrBagabcdefg);
 326                 res = fd.evaluate(null, arguments);
 327                 assertFalse(res.isOk());
 328                 assertEquals("function:any-of Predicate Function (first argument) was null", res.getStatus().getStatusMessage());
 329                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 330
 331                 // second null
 332                 arguments.clear();
 333                 arguments.add(attrPredicateStringEqual);
 334                 arguments.add(attrBagabcdefg);
 335                 arguments.add(null);
 336                 res = fd.evaluate(null, arguments);
 337                 assertFalse(res.isOk());
 338                 assertEquals("function:any-of Got null argument at index 2", res.getStatus().getStatusMessage());
 339                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 340
 341         }
 342
 343
 344
 345
 346
 347         @Test
 348         public void testAll_of() {
 349                 String a = "a";
 350                 String b = "b";
 351                 String c = "c";
 352                 String d = "d";
 353                 String e = "e";
 354                 String f = "f";
 355                 String g = "g";
 356                 String h = "h";
 357                 String j = "j";
 358
 359                 String w = "w";
 360
 361
 362                 Bag bagabcdefg = null;
 363                 Bag bagbdfhj = null;
 364                 Bag bagace = null;
 365                 Bag bagb = null;
 366                 Bag bagaaacccef = null;
 367                 Bag bagInt = null;
 368                 Bag bagStringInt = null;
 369                 Bag bagEmpty = null;
 370                 Bag bagStringBooleansFalse = null;
 371                 Bag bagStringBooleansTrue = null;
 372
 373
 374                 // primitive attrs
 375                 FunctionArgumentAttributeValue attra = null;
 376                 FunctionArgumentAttributeValue attrh = null;
 377                 FunctionArgumentAttributeValue attrw = null;
 378
 379
 380
 381                 // predicates passed as arguments
 382                 FunctionArgumentAttributeValue attrPredicateStringEqual = null;
 383                 FunctionArgumentAttributeValue attrPredicateStringIntersection = null;
 384                 FunctionArgumentAttributeValue attrPredicateStringGreaterThan = null;
 385                 FunctionArgumentAttributeValue attrPredicateBooleanFromString = null;
 386
 387                 try {
 388
 389                         // Create Bag contents
 390                         bagabcdefg = new Bag();
 391                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(a));
 392                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(b));
 393                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(c));
 394                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(d));
 395                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(e));
 396                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(f));
 397                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(g));
 398                         bagbdfhj = new Bag();
 399                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(b));
 400                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(d));
 401                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(f));
 402                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(h));
 403                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(j));
 404                         bagace = new Bag();
 405                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(a));
 406                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(c));
 407                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(e));
 408                         bagb = new Bag();
 409                                 bagb.add(DataTypes.DT_STRING.createAttributeValue(b));
 410                         bagaaacccef = new Bag();
 411                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
 412                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
 413                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
 414                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
 415                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
 416                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
 417                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(e));
 418                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(f));
 419                         bagInt = new Bag();
 420                                 bagInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
 421                         bagStringInt = new Bag();
 422                                 bagStringInt.add(DataTypes.DT_STRING.createAttributeValue(a));
 423                                 bagStringInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
 424                         bagEmpty = new Bag();
 425                         bagStringBooleansTrue = new Bag();
 426                                 bagStringBooleansTrue.add(DataTypes.DT_STRING.createAttributeValue("true"));
 427                                 bagStringBooleansTrue.add(DataTypes.DT_STRING.createAttributeValue("true"));
 428                                 bagStringBooleansTrue.add(DataTypes.DT_STRING.createAttributeValue("true"));
 429                         bagStringBooleansFalse = new Bag();
 430                                 bagStringBooleansFalse.add(DataTypes.DT_STRING.createAttributeValue("false"));
 431                                 bagStringBooleansFalse.add(DataTypes.DT_STRING.createAttributeValue("false"));
 432
 433
 434
 435                         // create primitive attrs
 436                         attra = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(a));
 437                         attrh = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(h));
 438                         attrw = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(w));
 439
 440
 441                         // predicates passed as function arguments
 442                         attrPredicateStringEqual = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_STRING_EQUAL));
 443                         attrPredicateStringIntersection = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_STRING_INTERSECTION));
 444                         attrPredicateStringGreaterThan = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_STRING_GREATER_THAN));
 445                         attrPredicateBooleanFromString = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_BOOLEAN_FROM_STRING));
 446
 447                 } catch (Exception ex) {
 448                         fail("creating attribute e="+ ex);
 449                 }
 450
 451                 // make into attributes
 452                 FunctionArgumentBag attrBagabcdefg = new FunctionArgumentBag(bagabcdefg);
 453                 FunctionArgumentBag attrBagbdfhj = new FunctionArgumentBag(bagbdfhj);
 454                 FunctionArgumentBag attrBagace = new FunctionArgumentBag(bagace);
 455                 FunctionArgumentBag attrBagStringInt = new FunctionArgumentBag(bagStringInt);
 456                 FunctionArgumentBag attrBagEmpty = new FunctionArgumentBag(bagEmpty);
 457                 FunctionArgumentBag attrBagStringBooleansTrue = new FunctionArgumentBag(bagStringBooleansTrue);
 458                 FunctionArgumentBag attrBagStringBooleansFalse = new FunctionArgumentBag(bagStringBooleansFalse);
 459
 460                 FunctionDefinitionHigherOrderBag<?,?> fd = (FunctionDefinitionHigherOrderBag<?,?>) StdFunctions.FD_ALL_OF;
 461
 462                 // check identity and type of the thing created
 463                 assertEquals(XACML3.ID_FUNCTION_ALL_OF, fd.getId());
 464                 assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
 465
 466                 // just to be safe...  If tests take too long these can probably be eliminated
 467                 assertFalse(fd.returnsBag());
 468
 469                 // normal match
 470                 arguments.clear();
 471                 arguments.add(attrPredicateStringGreaterThan);
 472                 arguments.add(attrw);
 473                 arguments.add(attrBagace);
 474                 ExpressionResult res = fd.evaluate(null, arguments);
 475                 assertTrue(res.isOk());
 476                 Boolean resValue = (Boolean)res.getValue().getValue();
 477                 assertTrue(resValue);
 478
 479                 // normal no-match
 480                 arguments.clear();
 481                 arguments.add(attrPredicateStringGreaterThan);
 482                 arguments.add(attra);
 483                 arguments.add(attrBagbdfhj);
 484                 res = fd.evaluate(null, arguments);
 485                 assertTrue(res.isOk());
 486                 resValue = (Boolean)res.getValue().getValue();
 487                 assertFalse(resValue);
 488
 489                 // no primitives - predicate function expects 2
 490                 arguments.clear();
 491                 arguments.add(attrPredicateStringEqual);
 492                 arguments.add(attrBagace);
 493                 res = fd.evaluate(null, arguments);
 494                 assertFalse(res.isOk());
 495                 assertEquals("function:all-of Predicate error: function:string-equal Expected 2 arguments, got 1", res.getStatus().getStatusMessage());
 496                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 497
 498                 // no primitives - predicate expects only 1 arg
 499                 arguments.clear();
 500                 arguments.add(attrPredicateBooleanFromString);
 501                 arguments.add(attrBagStringBooleansTrue);
 502                 res = fd.evaluate(null, arguments);
 503                 assertTrue(res.isOk());
 504                 resValue = (Boolean)res.getValue().getValue();
 505                 assertTrue(resValue);
 506
 507                 arguments.clear();
 508                 arguments.add(attrPredicateBooleanFromString);
 509                 arguments.add(attrBagStringBooleansFalse);
 510                 res = fd.evaluate(null, arguments);
 511                 assertTrue(res.isOk());
 512                 resValue = (Boolean)res.getValue().getValue();
 513                 assertFalse(resValue);
 514
 515                 // bag is empty
 516                 arguments.clear();
 517                 arguments.add(attrPredicateStringGreaterThan);
 518                 arguments.add(attrh);
 519                 arguments.add(attrBagEmpty);
 520                 res = fd.evaluate(null, arguments);
 521                 assertTrue(res.isOk());
 522                 resValue = (Boolean)res.getValue().getValue();
 523                 assertTrue(resValue);
 524
 525                 // no bag
 526                 arguments.clear();
 527                 arguments.add(attrPredicateStringGreaterThan);
 528                 arguments.add(attrh);
 529                 res = fd.evaluate(null, arguments);
 530                 assertFalse(res.isOk());
 531                 assertEquals("function:all-of Did not get any Bag argument; must have at least 1", res.getStatus().getStatusMessage());
 532                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 533
 534                 // extra bag
 535                 arguments.clear();
 536                 arguments.add(attrPredicateStringEqual);
 537                 arguments.add(attrh);
 538                 arguments.add(attrBagStringBooleansTrue);
 539                 arguments.add(attrh);
 540                 arguments.add(attrBagStringBooleansTrue);
 541                 res = fd.evaluate(null, arguments);
 542                 assertFalse(res.isOk());
 543                 assertEquals("function:all-of must have only 1 bag; found one at index 2 and another at 4", res.getStatus().getStatusMessage());
 544                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 545
 546
 547                 // bad predicate
 548                 arguments.clear();
 549                 arguments.add(attrh);
 550                 arguments.add(attrBagStringInt);
 551                 res = fd.evaluate(null, arguments);
 552                 assertFalse(res.isOk());
 553                 assertEquals("function:all-of First argument expected URI, got http://www.w3.org/2001/XMLSchema#string", res.getStatus().getStatusMessage());
 554                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 555
 556                 // non-boolean predicate
 557                 arguments.clear();
 558                 arguments.add(attrPredicateStringIntersection);
 559                 arguments.add(attrh);
 560                 arguments.add(attrBagStringInt);
 561                 res = fd.evaluate(null, arguments);
 562                 assertFalse(res.isOk());
 563                 assertEquals("function:all-of Predicate Function must return boolean, but 'urn:oasis:names:tc:xacml:1.0:function:string-intersection' returns 'string", res.getStatus().getStatusMessage());
 564                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 565
 566                 // predicate after first arg
 567                 arguments.clear();
 568                 arguments.add(attrPredicateStringGreaterThan);
 569                 arguments.add(attrPredicateStringIntersection);
 570                 arguments.add(attrBagStringInt);
 571                 res = fd.evaluate(null, arguments);
 572                 assertFalse(res.isOk());
 573                 assertEquals("function:all-of Predicate error: function:string-greater-than Expected data type 'string' saw 'anyURI' at arg index 0", res.getStatus().getStatusMessage());
 574                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 575
 576                 // bags of different types
 577                 arguments.clear();
 578                 arguments.add(attrPredicateStringGreaterThan);
 579                 arguments.add(attrh);
 580                 arguments.add(attrBagStringInt);
 581                 res = fd.evaluate(null, arguments);
 582                 assertFalse(res.isOk());
 583
 584                 // first null
 585                 arguments.clear();
 586                 arguments.add(null);
 587                 arguments.add(attrBagabcdefg);
 588                 res = fd.evaluate(null, arguments);
 589                 assertFalse(res.isOk());
 590                 assertEquals("function:all-of Predicate Function (first argument) was null", res.getStatus().getStatusMessage());
 591                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 592
 593                 // second null
 594                 arguments.clear();
 595                 arguments.add(attrPredicateStringGreaterThan);
 596                 arguments.add(attrBagabcdefg);
 597                 arguments.add(null);
 598                 res = fd.evaluate(null, arguments);
 599                 assertFalse(res.isOk());
 600                 assertEquals("function:all-of Got null argument at index 2", res.getStatus().getStatusMessage());
 601                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 602
 603         }
 604
 605
 606
 607
 608
 609
 610
 611
 612
 613
 614
 615
 616
 617         @Test
 618         public void testAny_of_any() {
 619                 String a = "a";
 620                 String b = "b";
 621                 String c = "c";
 622                 String d = "d";
 623                 String e = "e";
 624                 String f = "f";
 625                 String g = "g";
 626                 String h = "h";
 627                 String j = "j";
 628
 629                 String w = "w";
 630
 631
 632                 Bag bagabcdefg = null;
 633                 Bag bagbdfhj = null;
 634                 Bag bagace = null;
 635                 Bag bagb = null;
 636                 Bag bagaaacccef = null;
 637                 Bag bagInt = null;
 638                 Bag bagStringInt = null;
 639                 Bag bagEmpty = null;
 640                 Bag bagStringBooleansFalse = null;
 641                 Bag bagStringBooleansTrue = null;
 642                 Bag bagBooleansFalse = null;
 643                 Bag bagBooleansTrue = null;
 644
 645
 646                 // primitive attrs
 647                 FunctionArgumentAttributeValue attra = null;
 648                 FunctionArgumentAttributeValue attrh = null;
 649                 FunctionArgumentAttributeValue attrw = null;
 650
 651
 652                 FunctionArgumentAttributeValue attrInt4 = null;
 653
 654
 655                 // predicates passed as arguments
 656                 FunctionArgumentAttributeValue attrPredicateStringEqual = null;
 657                 FunctionArgumentAttributeValue attrPredicateStringIntersection = null;
 658                 FunctionArgumentAttributeValue attrPredicateStringGreaterThan = null;
 659                 FunctionArgumentAttributeValue attrPredicateBooleanFromString = null;
 660                 FunctionArgumentAttributeValue attrPredicateNof = null;
 661
 662                 try {
 663
 664                         // Create Bag contents
 665                         bagabcdefg = new Bag();
 666                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(a));
 667                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(b));
 668                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(c));
 669                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(d));
 670                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(e));
 671                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(f));
 672                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(g));
 673                         bagbdfhj = new Bag();
 674                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(b));
 675                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(d));
 676                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(f));
 677                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(h));
 678                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(j));
 679                         bagace = new Bag();
 680                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(a));
 681                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(c));
 682                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(e));
 683                         bagb = new Bag();
 684                                 bagb.add(DataTypes.DT_STRING.createAttributeValue(b));
 685                         bagaaacccef = new Bag();
 686                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
 687                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
 688                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
 689                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
 690                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
 691                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
 692                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(e));
 693                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(f));
 694                         bagInt = new Bag();
 695                                 bagInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
 696                         bagStringInt = new Bag();
 697                                 bagStringInt.add(DataTypes.DT_STRING.createAttributeValue(a));
 698                                 bagStringInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
 699                         bagEmpty = new Bag();
 700                         bagStringBooleansTrue = new Bag();
 701                                 bagStringBooleansTrue.add(DataTypes.DT_STRING.createAttributeValue("true"));
 702                                 bagStringBooleansTrue.add(DataTypes.DT_STRING.createAttributeValue("false"));
 703                                 bagStringBooleansTrue.add(DataTypes.DT_STRING.createAttributeValue("true"));
 704                         bagStringBooleansFalse = new Bag();
 705                                 bagStringBooleansFalse.add(DataTypes.DT_STRING.createAttributeValue("false"));
 706                                 bagStringBooleansFalse.add(DataTypes.DT_STRING.createAttributeValue("false"));
 707                         bagBooleansTrue = new Bag();
 708                                 bagBooleansTrue.add(DataTypes.DT_BOOLEAN.createAttributeValue(false));
 709                                 bagBooleansTrue.add(DataTypes.DT_BOOLEAN.createAttributeValue(false));
 710                                 bagBooleansTrue.add(DataTypes.DT_BOOLEAN.createAttributeValue(true));
 711                         bagBooleansFalse = new Bag();
 712                                 bagBooleansFalse.add(DataTypes.DT_BOOLEAN.createAttributeValue(false));
 713                                 bagBooleansFalse.add(DataTypes.DT_BOOLEAN.createAttributeValue(false));
 714
 715
 716                         // create primitive attrs
 717                         attra = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(a));
 718                         attrh = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(h));
 719                         attrw = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(w));
 720
 721                         attrInt4 = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(4));
 722
 723
 724                         // predicates passed as function arguments
 725                         attrPredicateStringEqual = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_STRING_EQUAL));
 726                         attrPredicateStringIntersection = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_STRING_INTERSECTION));
 727                         attrPredicateStringGreaterThan = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_STRING_GREATER_THAN));
 728                         attrPredicateBooleanFromString = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_BOOLEAN_FROM_STRING));
 729                         attrPredicateNof = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_N_OF));
 730
 731                 } catch (Exception ex) {
 732                         fail("creating attribute e="+ ex);
 733                 }
 734
 735                 // make into attributes
 736                 FunctionArgumentBag attrBagabcdefg = new FunctionArgumentBag(bagabcdefg);
 737                 FunctionArgumentBag attrBagbdfhj = new FunctionArgumentBag(bagbdfhj);
 738                 FunctionArgumentBag attrBagace = new FunctionArgumentBag(bagace);
 739                 FunctionArgumentBag attrBagStringInt = new FunctionArgumentBag(bagStringInt);
 740                 FunctionArgumentBag attrBagEmpty = new FunctionArgumentBag(bagEmpty);
 741                 FunctionArgumentBag attrBagStringBooleansTrue = new FunctionArgumentBag(bagStringBooleansTrue);
 742                 FunctionArgumentBag attrBagStringBooleansFalse = new FunctionArgumentBag(bagStringBooleansFalse);
 743                 FunctionArgumentBag attrBagBooleansTrue = new FunctionArgumentBag(bagBooleansTrue);
 744                 FunctionArgumentBag attrBagBooleansFalse = new FunctionArgumentBag(bagBooleansFalse);
 745
 746                 FunctionDefinitionHigherOrderBag<?,?> fd = (FunctionDefinitionHigherOrderBag<?,?>) StdFunctions.FD_ANY_OF_ANY;
 747
 748                 // check identity and type of the thing created
 749                 assertEquals(XACML3.ID_FUNCTION_ANY_OF_ANY, fd.getId());
 750                 assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
 751
 752                 // just to be safe...  If tests take too long these can probably be eliminated
 753                 assertFalse(fd.returnsBag());
 754
 755                 // normal match
 756                 arguments.clear();
 757                 arguments.add(attrPredicateStringGreaterThan);
 758                 arguments.add(attrw);
 759                 arguments.add(attrBagace);
 760                 ExpressionResult res = fd.evaluate(null, arguments);
 761                 assertTrue(res.isOk());
 762                 Boolean resValue = (Boolean)res.getValue().getValue();
 763                 assertTrue(resValue);
 764
 765                 // normal no-match
 766                 arguments.clear();
 767                 arguments.add(attrPredicateStringGreaterThan);
 768                 arguments.add(attra);
 769                 arguments.add(attrBagbdfhj);
 770                 res = fd.evaluate(null, arguments);
 771                 assertTrue(res.isOk());
 772                 resValue = (Boolean)res.getValue().getValue();
 773                 assertFalse(resValue);
 774
 775                 // no primitives - predicate function expects 2
 776                 arguments.clear();
 777                 arguments.add(attrPredicateStringEqual);
 778                 arguments.add(attrBagace);
 779                 res = fd.evaluate(null, arguments);
 780                 assertFalse(res.isOk());
 781                 assertEquals("function:any-of-any Predicate error: function:string-equal Expected 2 arguments, got 1", res.getStatus().getStatusMessage());
 782                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 783
 784                 arguments.clear();
 785                 arguments.add(attrPredicateStringEqual);
 786                 arguments.add(attrBagace);
 787                 arguments.add(attrBagace);
 788                 res = fd.evaluate(null, arguments);
 789                 assertTrue(res.isOk());
 790                 resValue = (Boolean)res.getValue().getValue();
 791                 assertTrue(resValue);
 792
 793                 // no primitives - predicate expects only 1 arg
 794                 arguments.clear();
 795                 arguments.add(attrPredicateBooleanFromString);
 796                 arguments.add(attrBagStringBooleansTrue);
 797                 res = fd.evaluate(null, arguments);
 798                 assertTrue(res.isOk());
 799                 resValue = (Boolean)res.getValue().getValue();
 800                 assertTrue(resValue);
 801
 802                 arguments.clear();
 803                 arguments.add(attrPredicateBooleanFromString);
 804                 arguments.add(attrBagStringBooleansFalse);
 805                 res = fd.evaluate(null, arguments);
 806                 assertTrue(res.isOk());
 807                 resValue = (Boolean)res.getValue().getValue();
 808                 assertFalse(resValue);
 809
 810                 // n-of with lots of bags - success
 811                 arguments.clear();
 812                 arguments.add(attrPredicateNof);
 813                 arguments.add(attrInt4);
 814                 arguments.add(attrBagBooleansTrue);
 815                 arguments.add(attrBagBooleansTrue);
 816                 arguments.add(attrBagBooleansTrue);
 817                 arguments.add(attrBagBooleansTrue);
 818                 arguments.add(attrBagBooleansTrue);
 819                 arguments.add(attrBagBooleansTrue);
 820                 arguments.add(attrBagBooleansTrue);
 821                 res = fd.evaluate(null, arguments);
 822                 assertTrue(res.isOk());
 823                 resValue = (Boolean)res.getValue().getValue();
 824                 assertTrue(resValue);
 825
 826                 // n-of with lots of bags - fail
 827                 arguments.clear();
 828                 arguments.add(attrPredicateNof);
 829                 arguments.add(attrInt4);
 830                 arguments.add(attrBagBooleansFalse);
 831                 arguments.add(attrBagBooleansFalse);
 832                 arguments.add(attrBagBooleansTrue);
 833                 arguments.add(attrBagBooleansTrue);
 834                 arguments.add(attrBagBooleansFalse);
 835                 arguments.add(attrBagBooleansFalse);
 836                 arguments.add(attrBagBooleansFalse);
 837                 arguments.add(attrBagBooleansFalse);
 838                 arguments.add(attrBagBooleansFalse);
 839                 arguments.add(attrBagBooleansFalse);
 840                 arguments.add(attrBagBooleansFalse);
 841                 arguments.add(attrBagBooleansFalse);
 842                 arguments.add(attrBagBooleansFalse);
 843                 res = fd.evaluate(null, arguments);
 844                 assertTrue(res.isOk());
 845                 resValue = (Boolean)res.getValue().getValue();
 846                 assertFalse(resValue);
 847
 848
 849                 // bag is empty
 850                 arguments.clear();
 851                 arguments.add(attrPredicateStringGreaterThan);
 852                 arguments.add(attrh);
 853                 arguments.add(attrBagEmpty);
 854                 res = fd.evaluate(null, arguments);
 855                 assertFalse(res.isOk());
 856                 assertEquals("function:any-of-any Bag is empty at index 2", res.getStatus().getStatusMessage());
 857                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 858
 859
 860                 // no bag
 861                 arguments.clear();
 862                 arguments.add(attrPredicateStringGreaterThan);
 863                 arguments.add(attrh);
 864                 res = fd.evaluate(null, arguments);
 865                 assertFalse(res.isOk());
 866                 assertEquals("function:any-of-any Predicate error: function:string-greater-than Expected 2 arguments, got 1", res.getStatus().getStatusMessage());
 867                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 868
 869                 arguments.clear();
 870                 arguments.add(attrPredicateStringGreaterThan);
 871                 arguments.add(attrh);
 872                 arguments.add(attrh);
 873                 res = fd.evaluate(null, arguments);
 874                 assertTrue(res.isOk());
 875                 resValue = (Boolean)res.getValue().getValue();
 876                 assertFalse(resValue);
 877
 878                 // bad predicate
 879                 arguments.clear();
 880                 arguments.add(attrh);
 881                 arguments.add(attrBagStringInt);
 882                 res = fd.evaluate(null, arguments);
 883                 assertFalse(res.isOk());
 884                 assertEquals("function:any-of-any First argument expected URI, got http://www.w3.org/2001/XMLSchema#string", res.getStatus().getStatusMessage());
 885                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 886
 887                 // non-boolean predicate
 888                 arguments.clear();
 889                 arguments.add(attrPredicateStringIntersection);
 890                 arguments.add(attrh);
 891                 arguments.add(attrBagStringInt);
 892                 res = fd.evaluate(null, arguments);
 893                 assertFalse(res.isOk());
 894                 assertEquals("function:any-of-any Predicate Function must return boolean, but 'urn:oasis:names:tc:xacml:1.0:function:string-intersection' returns 'string", res.getStatus().getStatusMessage());
 895                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 896
 897                 // predicate after first arg
 898                 arguments.clear();
 899                 arguments.add(attrPredicateStringGreaterThan);
 900                 arguments.add(attrPredicateStringIntersection);
 901                 arguments.add(attrBagStringInt);
 902                 res = fd.evaluate(null, arguments);
 903                 assertFalse(res.isOk());
 904                 assertEquals("function:any-of-any Predicate error: function:string-greater-than Expected data type 'string' saw 'anyURI' at arg index 0", res.getStatus().getStatusMessage());
 905                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 906
 907                 // bags of different types
 908                 arguments.clear();
 909                 arguments.add(attrPredicateStringGreaterThan);
 910                 arguments.add(attrh);
 911                 arguments.add(attrBagStringInt);
 912                 res = fd.evaluate(null, arguments);
 913                 assertTrue(res.isOk());
 914                 resValue = (Boolean)res.getValue().getValue();
 915                 assertTrue(resValue);
 916
 917                 // first null
 918                 arguments.clear();
 919                 arguments.add(null);
 920                 arguments.add(attrBagabcdefg);
 921                 res = fd.evaluate(null, arguments);
 922                 assertFalse(res.isOk());
 923                 assertEquals("function:any-of-any Predicate Function (first argument) was null", res.getStatus().getStatusMessage());
 924                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 925
 926                 // second null
 927                 arguments.clear();
 928                 arguments.add(attrPredicateStringGreaterThan);
 929                 arguments.add(attrBagabcdefg);
 930                 arguments.add(null);
 931                 res = fd.evaluate(null, arguments);
 932                 assertFalse(res.isOk());
 933                 assertEquals("function:any-of-any Got null argument at index 2", res.getStatus().getStatusMessage());
 934                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 935
 936         }
 937
 938
 939
 940
 941
 942
 943
 944
 945
 946
 947
 948
 949
 950
 951
 952         @Test
 953         public void testAll_of_any() {
 954                 String a = "a";
 955                 String b = "b";
 956                 String c = "c";
 957                 String d = "d";
 958                 String e = "e";
 959                 String f = "f";
 960                 String g = "g";
 961                 String h = "h";
 962                 String j = "j";
 963
 964                 String w = "w";
 965                 String x = "x";
 966
 967
 968                 Bag bagabcdefg = null;
 969                 Bag bagbdfhj = null;
 970                 Bag bagace = null;
 971                 Bag bagb = null;
 972                 Bag bagaaacccef = null;
 973                 Bag bagawx = null;
 974                 Bag bagInt = null;
 975                 Bag bagStringInt = null;
 976                 Bag bagEmpty = null;
 977                 Bag bagStringBooleansFalse = null;
 978                 Bag bagStringBooleansTrue = null;
 979                 Bag bagBooleansFalse = null;
 980                 Bag bagBooleansTrue = null;
 981
 982
 983                 // primitive attrs
 984                 FunctionArgumentAttributeValue attra = null;
 985                 FunctionArgumentAttributeValue attrh = null;
 986
 987
 988
 989
 990                 // predicates passed as arguments
 991                 FunctionArgumentAttributeValue attrPredicateStringEqual = null;
 992                 FunctionArgumentAttributeValue attrPredicateStringIntersection = null;
 993                 FunctionArgumentAttributeValue attrPredicateStringLessThan = null;
 994                 FunctionArgumentAttributeValue attrPredicateStringGreaterThan = null;
 995                 FunctionArgumentAttributeValue attrPredicateBooleanFromString = null;
 996
 997                 try {
 998
 999                         // Create Bag contents
1000                         bagabcdefg = new Bag();
1001                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(a));
1002                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(b));
1003                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(c));
1004                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(d));
1005                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(e));
1006                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(f));
1007                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(g));
1008                         bagbdfhj = new Bag();
1009                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(b));
1010                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(d));
1011                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(f));
1012                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(h));
1013                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(j));
1014                         bagace = new Bag();
1015                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(a));
1016                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(c));
1017                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(e));
1018                         bagb = new Bag();
1019                                 bagb.add(DataTypes.DT_STRING.createAttributeValue(b));
1020                         bagaaacccef = new Bag();
1021                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
1022                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
1023                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
1024                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
1025                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
1026                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
1027                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(e));
1028                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(f));
1029                         bagawx = new Bag();
1030                                 bagawx.add(DataTypes.DT_STRING.createAttributeValue(a));
1031                                 bagawx.add(DataTypes.DT_STRING.createAttributeValue(w));
1032                                 bagawx.add(DataTypes.DT_STRING.createAttributeValue(x));
1033                         bagInt = new Bag();
1034                                 bagInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
1035                         bagStringInt = new Bag();
1036                                 bagStringInt.add(DataTypes.DT_STRING.createAttributeValue(a));
1037                                 bagStringInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
1038                         bagEmpty = new Bag();
1039                         bagStringBooleansTrue = new Bag();
1040                                 bagStringBooleansTrue.add(DataTypes.DT_STRING.createAttributeValue("true"));
1041                                 bagStringBooleansTrue.add(DataTypes.DT_STRING.createAttributeValue("false"));
1042                                 bagStringBooleansTrue.add(DataTypes.DT_STRING.createAttributeValue("true"));
1043                         bagStringBooleansFalse = new Bag();
1044                                 bagStringBooleansFalse.add(DataTypes.DT_STRING.createAttributeValue("false"));
1045                                 bagStringBooleansFalse.add(DataTypes.DT_STRING.createAttributeValue("false"));
1046                         bagBooleansTrue = new Bag();
1047                                 bagBooleansTrue.add(DataTypes.DT_BOOLEAN.createAttributeValue(false));
1048                                 bagBooleansTrue.add(DataTypes.DT_BOOLEAN.createAttributeValue(false));
1049                                 bagBooleansTrue.add(DataTypes.DT_BOOLEAN.createAttributeValue(true));
1050                         bagBooleansFalse = new Bag();
1051                                 bagBooleansFalse.add(DataTypes.DT_BOOLEAN.createAttributeValue(false));
1052                                 bagBooleansFalse.add(DataTypes.DT_BOOLEAN.createAttributeValue(false));
1053
1054
1055                         // create primitive attrs
1056                         attra = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(a));
1057                         attrh = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(h));
1058
1059
1060
1061                         // predicates passed as function arguments
1062                         attrPredicateStringEqual = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_STRING_EQUAL));
1063                         attrPredicateStringIntersection = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_STRING_INTERSECTION));
1064                         attrPredicateStringLessThan = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_STRING_LESS_THAN));
1065                         attrPredicateStringGreaterThan = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_STRING_GREATER_THAN));
1066                         attrPredicateBooleanFromString = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_BOOLEAN_FROM_STRING));
1067
1068                 } catch (Exception ex) {
1069                         fail("creating attribute e="+ ex);
1070                 }
1071
1072                 // make into attributes
1073                 FunctionArgumentBag attrBagabcdefg = new FunctionArgumentBag(bagabcdefg);
1074                 FunctionArgumentBag attrBagace = new FunctionArgumentBag(bagace);
1075                 FunctionArgumentBag attrBagawx = new FunctionArgumentBag(bagawx);
1076                 FunctionArgumentBag attrBagStringInt = new FunctionArgumentBag(bagStringInt);
1077                 FunctionArgumentBag attrBagEmpty = new FunctionArgumentBag(bagEmpty);
1078                 FunctionArgumentBag attrBagStringBooleansTrue = new FunctionArgumentBag(bagStringBooleansTrue);
1079
1080                 FunctionDefinitionHigherOrderBag<?,?> fd = (FunctionDefinitionHigherOrderBag<?,?>) StdFunctions.FD_ALL_OF_ANY;
1081
1082                 // check identity and type of the thing created
1083                 assertEquals(XACML3.ID_FUNCTION_ALL_OF_ANY, fd.getId());
1084                 assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
1085
1086                 // just to be safe...  If tests take too long these can probably be eliminated
1087                 assertFalse(fd.returnsBag());
1088
1089                 // normal match
1090                 arguments.clear();
1091                 arguments.add(attrPredicateStringLessThan);
1092                 arguments.add(attrBagabcdefg);
1093                 arguments.add(attrBagawx);
1094                 ExpressionResult res = fd.evaluate(null, arguments);
1095                 assertTrue(res.isOk());
1096                 Boolean resValue = (Boolean)res.getValue().getValue();
1097                 assertTrue(resValue);
1098
1099                 // normal no-match
1100                 arguments.clear();
1101                 arguments.add(attrPredicateStringGreaterThan);
1102                 arguments.add(attrBagace);
1103                 arguments.add(attrBagawx);
1104                 res = fd.evaluate(null, arguments);
1105                 assertTrue(res.isOk());
1106                 resValue = (Boolean)res.getValue().getValue();
1107                 assertFalse(resValue);
1108
1109                 // primitive instead of bag
1110                 arguments.clear();
1111                 arguments.add(attrPredicateStringEqual);
1112                 arguments.add(attra);
1113                 arguments.add(attrBagace);
1114                 res = fd.evaluate(null, arguments);
1115                 assertFalse(res.isOk());
1116                 assertEquals("function:all-of-any 2nd argument must be bag, got 'string'", res.getStatus().getStatusMessage());
1117                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1118
1119                 arguments.clear();
1120                 arguments.add(attrPredicateStringEqual);
1121                 arguments.add(attrBagace);
1122                 arguments.add(attra);
1123                 res = fd.evaluate(null, arguments);
1124                 assertFalse(res.isOk());
1125                 assertEquals("function:all-of-any 3rd argument must be bag, got 'string'", res.getStatus().getStatusMessage());
1126                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1127
1128                 // no primitives - predicate expects only 1 arg
1129                 arguments.clear();
1130                 arguments.add(attrPredicateBooleanFromString);
1131                 arguments.add(attrBagStringBooleansTrue);
1132                 arguments.add(attrBagStringBooleansTrue);
1133                 res = fd.evaluate(null, arguments);
1134                 assertFalse(res.isOk());
1135                 assertEquals("function:all-of-any Predicate error: function:boolean-from-string Expected 1 arguments, got 2", res.getStatus().getStatusMessage());
1136                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1137
1138
1139
1140                 // bag is empty
1141                 arguments.clear();
1142                 arguments.add(attrPredicateStringGreaterThan);
1143                 arguments.add(attrBagace);
1144                 arguments.add(attrBagEmpty);
1145                 res = fd.evaluate(null, arguments);
1146                 assertTrue(res.isOk());
1147                 resValue = (Boolean)res.getValue().getValue();
1148                 assertFalse(resValue);
1149
1150                 arguments.clear();
1151                 arguments.add(attrPredicateStringGreaterThan);
1152                 arguments.add(attrBagEmpty);
1153                 arguments.add(attrBagace);
1154                 res = fd.evaluate(null, arguments);
1155                 assertTrue(res.isOk());
1156                 resValue = (Boolean)res.getValue().getValue();
1157                 assertTrue(resValue);
1158
1159                 // no bag
1160                 arguments.clear();
1161                 arguments.add(attrPredicateStringGreaterThan);
1162                 arguments.add(attrh);
1163                 res = fd.evaluate(null, arguments);
1164                 assertFalse(res.isOk());
1165                 assertEquals("function:all-of-any Expected 3 arguments, got 2", res.getStatus().getStatusMessage());
1166                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1167
1168
1169                 // bad predicate
1170                 arguments.clear();
1171                 arguments.add(attrh);
1172                 arguments.add(attrBagStringInt);
1173                 arguments.add(attrBagStringInt);
1174                 res = fd.evaluate(null, arguments);
1175                 assertFalse(res.isOk());
1176                 assertEquals("function:all-of-any First argument expected URI, got http://www.w3.org/2001/XMLSchema#string", res.getStatus().getStatusMessage());
1177                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1178
1179                 // non-boolean predicate
1180                 arguments.clear();
1181                 arguments.add(attrPredicateStringIntersection);
1182                 arguments.add(attrBagStringInt);
1183                 arguments.add(attrBagStringInt);
1184                 res = fd.evaluate(null, arguments);
1185                 assertFalse(res.isOk());
1186                 assertEquals("function:all-of-any Predicate Function must return boolean, but 'urn:oasis:names:tc:xacml:1.0:function:string-intersection' returns 'string", res.getStatus().getStatusMessage());
1187                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1188
1189                 // predicate after first arg
1190                 arguments.clear();
1191                 arguments.add(attrPredicateStringGreaterThan);
1192                 arguments.add(attrPredicateStringIntersection);
1193                 arguments.add(attrBagStringInt);
1194                 res = fd.evaluate(null, arguments);
1195                 assertFalse(res.isOk());
1196                 assertEquals("function:all-of-any 2nd argument must be bag, got 'anyURI'", res.getStatus().getStatusMessage());
1197                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1198
1199                 // bags of different types
1200                 arguments.clear();
1201                 arguments.add(attrPredicateStringGreaterThan);
1202                 arguments.add(attrBagace);
1203                 arguments.add(attrBagStringInt);
1204                 res = fd.evaluate(null, arguments);
1205                 assertFalse(res.isOk());
1206                 assertEquals("function:all-of-any Predicate error: function:string-greater-than Expected data type 'string' saw 'integer' at arg index 1", res.getStatus().getStatusMessage());
1207                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1208
1209                 // no args
1210                 arguments.clear();
1211                 res = fd.evaluate(null, arguments);
1212                 assertFalse(res.isOk());
1213                 assertEquals("function:all-of-any Expected at least 2 arguments, got 0", res.getStatus().getStatusMessage());
1214                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1215
1216                 // one arg
1217                 arguments.clear();
1218                 arguments.add(attrBagabcdefg);
1219                 res = fd.evaluate(null, arguments);
1220                 assertFalse(res.isOk());
1221                 assertEquals("function:all-of-any Expected at least 2 arguments, got 1", res.getStatus().getStatusMessage());
1222                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1223
1224                 // too many args
1225                 arguments.clear();
1226                 arguments.add(attrBagabcdefg);
1227                 arguments.add(attrBagabcdefg);
1228                 arguments.add(attrBagabcdefg);
1229                 arguments.add(attrBagabcdefg);
1230                 res = fd.evaluate(null, arguments);
1231                 assertFalse(res.isOk());
1232                 assertEquals("function:all-of-any Expected 3 arguments, got 4", res.getStatus().getStatusMessage());
1233                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1234
1235
1236                 // first null
1237                 arguments.clear();
1238                 arguments.add(null);
1239                 arguments.add(attrBagabcdefg);
1240                 res = fd.evaluate(null, arguments);
1241                 assertFalse(res.isOk());
1242                 assertEquals("function:all-of-any Expected 3 arguments, got 2", res.getStatus().getStatusMessage());
1243                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1244
1245                 // second null
1246                 arguments.clear();
1247                 arguments.add(attrPredicateStringGreaterThan);
1248                 arguments.add(attrBagabcdefg);
1249                 arguments.add(null);
1250                 res = fd.evaluate(null, arguments);
1251                 assertFalse(res.isOk());
1252                 assertEquals("function:all-of-any 3rd argument must be bag, got 'null'", res.getStatus().getStatusMessage());
1253                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1254
1255         }
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268         @Test
1269         public void testAny_of_all() {
1270                 String a = "a";
1271                 String b = "b";
1272                 String c = "c";
1273                 String d = "d";
1274                 String e = "e";
1275                 String f = "f";
1276                 String g = "g";
1277                 String h = "h";
1278                 String j = "j";
1279
1280                 String w = "w";
1281                 String x = "x";
1282
1283
1284                 Bag bagabcdefg = null;
1285                 Bag bagbdfhj = null;
1286                 Bag bagace = null;
1287                 Bag bagb = null;
1288                 Bag bagaaacccef = null;
1289                 Bag bagewx = null;
1290                 Bag bagInt = null;
1291                 Bag bagStringInt = null;
1292                 Bag bagEmpty = null;
1293                 Bag bagStringBooleansFalse = null;
1294                 Bag bagStringBooleansTrue = null;
1295                 Bag bagBooleansFalse = null;
1296                 Bag bagBooleansTrue = null;
1297
1298
1299                 // primitive attrs
1300                 FunctionArgumentAttributeValue attra = null;
1301                 FunctionArgumentAttributeValue attrh = null;
1302
1303
1304
1305
1306                 // predicates passed as arguments
1307                 FunctionArgumentAttributeValue attrPredicateStringEqual = null;
1308                 FunctionArgumentAttributeValue attrPredicateStringIntersection = null;
1309                 FunctionArgumentAttributeValue attrPredicateStringGreaterThanOrEqual = null;
1310                 FunctionArgumentAttributeValue attrPredicateStringGreaterThan = null;
1311                 FunctionArgumentAttributeValue attrPredicateBooleanFromString = null;
1312
1313                 try {
1314
1315                         // Create Bag contents
1316                         bagabcdefg = new Bag();
1317                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(a));
1318                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(b));
1319                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(c));
1320                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(d));
1321                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(e));
1322                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(f));
1323                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(g));
1324                         bagbdfhj = new Bag();
1325                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(b));
1326                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(d));
1327                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(f));
1328                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(h));
1329                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(j));
1330                         bagace = new Bag();
1331                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(a));
1332                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(c));
1333                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(e));
1334                         bagb = new Bag();
1335                                 bagb.add(DataTypes.DT_STRING.createAttributeValue(b));
1336                         bagaaacccef = new Bag();
1337                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
1338                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
1339                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
1340                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
1341                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
1342                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
1343                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(e));
1344                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(f));
1345                         bagewx = new Bag();
1346                                 bagewx.add(DataTypes.DT_STRING.createAttributeValue(e));
1347                                 bagewx.add(DataTypes.DT_STRING.createAttributeValue(w));
1348                                 bagewx.add(DataTypes.DT_STRING.createAttributeValue(x));
1349                         bagInt = new Bag();
1350                                 bagInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
1351                         bagStringInt = new Bag();
1352                                 bagStringInt.add(DataTypes.DT_STRING.createAttributeValue(a));
1353                                 bagStringInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
1354                         bagEmpty = new Bag();
1355                         bagStringBooleansTrue = new Bag();
1356                                 bagStringBooleansTrue.add(DataTypes.DT_STRING.createAttributeValue("true"));
1357                                 bagStringBooleansTrue.add(DataTypes.DT_STRING.createAttributeValue("false"));
1358                                 bagStringBooleansTrue.add(DataTypes.DT_STRING.createAttributeValue("true"));
1359                         bagStringBooleansFalse = new Bag();
1360                                 bagStringBooleansFalse.add(DataTypes.DT_STRING.createAttributeValue("false"));
1361                                 bagStringBooleansFalse.add(DataTypes.DT_STRING.createAttributeValue("false"));
1362                         bagBooleansTrue = new Bag();
1363                                 bagBooleansTrue.add(DataTypes.DT_BOOLEAN.createAttributeValue(false));
1364                                 bagBooleansTrue.add(DataTypes.DT_BOOLEAN.createAttributeValue(false));
1365                                 bagBooleansTrue.add(DataTypes.DT_BOOLEAN.createAttributeValue(true));
1366                         bagBooleansFalse = new Bag();
1367                                 bagBooleansFalse.add(DataTypes.DT_BOOLEAN.createAttributeValue(false));
1368                                 bagBooleansFalse.add(DataTypes.DT_BOOLEAN.createAttributeValue(false));
1369
1370
1371                         // create primitive attrs
1372                         attra = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(a));
1373                         attrh = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(h));
1374
1375
1376
1377                         // predicates passed as function arguments
1378                         attrPredicateStringEqual = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_STRING_EQUAL));
1379                         attrPredicateStringIntersection = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_STRING_INTERSECTION));
1380                         attrPredicateStringGreaterThanOrEqual = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_STRING_GREATER_THAN_OR_EQUAL));
1381                         attrPredicateStringGreaterThan = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_STRING_GREATER_THAN));
1382                         attrPredicateBooleanFromString = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_BOOLEAN_FROM_STRING));
1383
1384                 } catch (Exception ex) {
1385                         fail("creating attribute e="+ ex);
1386                 }
1387
1388                 // make into attributes
1389                 FunctionArgumentBag attrBagabcdefg = new FunctionArgumentBag(bagabcdefg);
1390                 FunctionArgumentBag attrBagace = new FunctionArgumentBag(bagace);
1391                 FunctionArgumentBag attrBagewx = new FunctionArgumentBag(bagewx);
1392                 FunctionArgumentBag attrBagStringInt = new FunctionArgumentBag(bagStringInt);
1393                 FunctionArgumentBag attrBagEmpty = new FunctionArgumentBag(bagEmpty);
1394                 FunctionArgumentBag attrBagStringBooleansTrue = new FunctionArgumentBag(bagStringBooleansTrue);
1395
1396                 FunctionDefinitionHigherOrderBag<?,?> fd = (FunctionDefinitionHigherOrderBag<?,?>) StdFunctions.FD_ANY_OF_ALL;
1397
1398                 // check identity and type of the thing created
1399                 assertEquals(XACML3.ID_FUNCTION_ANY_OF_ALL, fd.getId());
1400                 assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
1401
1402                 // just to be safe...  If tests take too long these can probably be eliminated
1403                 assertFalse(fd.returnsBag());
1404
1405                 // normal match
1406                 arguments.clear();
1407                 arguments.add(attrPredicateStringGreaterThanOrEqual);
1408                 arguments.add(attrBagewx);
1409                 arguments.add(attrBagace);
1410                 ExpressionResult res = fd.evaluate(null, arguments);
1411                 assertTrue(res.isOk());
1412                 Boolean resValue = (Boolean)res.getValue().getValue();
1413                 assertTrue(resValue);
1414
1415                 // normal no-match
1416                 arguments.clear();
1417                 arguments.add(attrPredicateStringGreaterThan);
1418                 arguments.add(attrBagace);
1419                 arguments.add(attrBagewx);
1420                 res = fd.evaluate(null, arguments);
1421                 assertTrue(res.isOk());
1422                 resValue = (Boolean)res.getValue().getValue();
1423                 assertFalse(resValue);
1424
1425                 // primitive instead of bag
1426                 arguments.clear();
1427                 arguments.add(attrPredicateStringEqual);
1428                 arguments.add(attra);
1429                 arguments.add(attrBagace);
1430                 res = fd.evaluate(null, arguments);
1431                 assertFalse(res.isOk());
1432                 assertEquals("function:any-of-all 2nd argument must be bag, got 'string'", res.getStatus().getStatusMessage());
1433                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1434
1435                 arguments.clear();
1436                 arguments.add(attrPredicateStringEqual);
1437                 arguments.add(attrBagace);
1438                 arguments.add(attra);
1439                 res = fd.evaluate(null, arguments);
1440                 assertFalse(res.isOk());
1441                 assertEquals("function:any-of-all 3rd argument must be bag, got 'string'", res.getStatus().getStatusMessage());
1442                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1443
1444                 // no primitives - predicate expects only 1 arg
1445                 arguments.clear();
1446                 arguments.add(attrPredicateBooleanFromString);
1447                 arguments.add(attrBagStringBooleansTrue);
1448                 arguments.add(attrBagStringBooleansTrue);
1449                 res = fd.evaluate(null, arguments);
1450                 assertFalse(res.isOk());
1451                 assertEquals("function:any-of-all Predicate error: function:boolean-from-string Expected 1 arguments, got 2", res.getStatus().getStatusMessage());
1452                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1453
1454                 // bag is empty
1455                 arguments.clear();
1456                 arguments.add(attrPredicateStringGreaterThan);
1457                 arguments.add(attrBagace);
1458                 arguments.add(attrBagEmpty);
1459                 res = fd.evaluate(null, arguments);
1460                 assertTrue(res.isOk());
1461                 resValue = (Boolean)res.getValue().getValue();
1462                 assertTrue(resValue);
1463
1464                 arguments.clear();
1465                 arguments.add(attrPredicateStringGreaterThan);
1466                 arguments.add(attrBagEmpty);
1467                 arguments.add(attrBagace);
1468                 res = fd.evaluate(null, arguments);
1469                 assertTrue(res.isOk());
1470                 resValue = (Boolean)res.getValue().getValue();
1471                 assertFalse(resValue);
1472
1473                 // no bag
1474                 arguments.clear();
1475                 arguments.add(attrPredicateStringGreaterThan);
1476                 arguments.add(attrh);
1477                 res = fd.evaluate(null, arguments);
1478                 assertFalse(res.isOk());
1479                 assertEquals("function:any-of-all Expected 3 arguments, got 2", res.getStatus().getStatusMessage());
1480                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1481
1482
1483                 // bad predicate
1484                 arguments.clear();
1485                 arguments.add(attrh);
1486                 arguments.add(attrBagStringInt);
1487                 arguments.add(attrBagStringInt);
1488                 res = fd.evaluate(null, arguments);
1489                 assertFalse(res.isOk());
1490                 assertEquals("function:any-of-all First argument expected URI, got http://www.w3.org/2001/XMLSchema#string", res.getStatus().getStatusMessage());
1491                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1492
1493                 // non-boolean predicate
1494                 arguments.clear();
1495                 arguments.add(attrPredicateStringIntersection);
1496                 arguments.add(attrBagStringInt);
1497                 arguments.add(attrBagStringInt);
1498                 res = fd.evaluate(null, arguments);
1499                 assertFalse(res.isOk());
1500                 assertEquals("function:any-of-all Predicate Function must return boolean, but 'urn:oasis:names:tc:xacml:1.0:function:string-intersection' returns 'string", res.getStatus().getStatusMessage());
1501                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1502
1503                 // predicate after first arg
1504                 arguments.clear();
1505                 arguments.add(attrPredicateStringGreaterThan);
1506                 arguments.add(attrPredicateStringIntersection);
1507                 arguments.add(attrBagStringInt);
1508                 res = fd.evaluate(null, arguments);
1509                 assertFalse(res.isOk());
1510                 assertEquals("function:any-of-all 2nd argument must be bag, got 'anyURI'", res.getStatus().getStatusMessage());
1511                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1512
1513                 // bags of different types
1514                 arguments.clear();
1515                 arguments.add(attrPredicateStringGreaterThan);
1516                 arguments.add(attrBagace);
1517                 arguments.add(attrBagStringInt);
1518                 res = fd.evaluate(null, arguments);
1519                 assertFalse(res.isOk());
1520                 assertEquals("function:any-of-all Predicate error: function:string-greater-than Expected data type 'string' saw 'integer' at arg index 1", res.getStatus().getStatusMessage());
1521                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1522
1523                 // no args
1524                 arguments.clear();
1525                 res = fd.evaluate(null, arguments);
1526                 assertFalse(res.isOk());
1527                 assertEquals("function:any-of-all Expected at least 2 arguments, got 0", res.getStatus().getStatusMessage());
1528                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1529
1530                 // one arg
1531                 arguments.clear();
1532                 arguments.add(attrBagabcdefg);
1533                 res = fd.evaluate(null, arguments);
1534                 assertFalse(res.isOk());
1535                 assertEquals("function:any-of-all Expected at least 2 arguments, got 1", res.getStatus().getStatusMessage());
1536                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1537
1538                 // too many args
1539                 arguments.clear();
1540                 arguments.add(attrBagabcdefg);
1541                 arguments.add(attrBagabcdefg);
1542                 arguments.add(attrBagabcdefg);
1543                 arguments.add(attrBagabcdefg);
1544                 res = fd.evaluate(null, arguments);
1545                 assertFalse(res.isOk());
1546                 assertEquals("function:any-of-all Expected 3 arguments, got 4", res.getStatus().getStatusMessage());
1547                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1548
1549
1550                 // first null
1551                 arguments.clear();
1552                 arguments.add(null);
1553                 arguments.add(attrBagabcdefg);
1554                 res = fd.evaluate(null, arguments);
1555                 assertFalse(res.isOk());
1556                 assertEquals("function:any-of-all Expected 3 arguments, got 2", res.getStatus().getStatusMessage());
1557                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1558
1559                 // second null
1560                 arguments.clear();
1561                 arguments.add(attrPredicateStringGreaterThan);
1562                 arguments.add(attrBagabcdefg);
1563                 arguments.add(null);
1564                 res = fd.evaluate(null, arguments);
1565                 assertFalse(res.isOk());
1566                 assertEquals("function:any-of-all 3rd argument must be bag, got 'null'", res.getStatus().getStatusMessage());
1567                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1568
1569         }
1570
1571
1572
1573
1574
1575
1576         @Test
1577         public void testAll_of_all() {
1578                 String a = "a";
1579                 String b = "b";
1580                 String c = "c";
1581                 String d = "d";
1582                 String e = "e";
1583                 String f = "f";
1584                 String g = "g";
1585                 String h = "h";
1586                 String j = "j";
1587
1588                 String w = "w";
1589                 String x = "x";
1590
1591
1592                 Bag bagabcdefg = null;
1593                 Bag bagbdfhj = null;
1594                 Bag bagace = null;
1595                 Bag bagb = null;
1596                 Bag bagaaacccef = null;
1597                 Bag bagawx = null;
1598                 Bag bagwx = null;
1599                 Bag bagInt = null;
1600                 Bag bagStringInt = null;
1601                 Bag bagEmpty = null;
1602                 Bag bagStringBooleansFalse = null;
1603                 Bag bagStringBooleansTrue = null;
1604                 Bag bagBooleansFalse = null;
1605                 Bag bagBooleansTrue = null;
1606
1607
1608                 // primitive attrs
1609                 FunctionArgumentAttributeValue attra = null;
1610                 FunctionArgumentAttributeValue attrh = null;
1611
1612
1613
1614
1615                 // predicates passed as arguments
1616                 FunctionArgumentAttributeValue attrPredicateStringEqual = null;
1617                 FunctionArgumentAttributeValue attrPredicateStringIntersection = null;
1618                 FunctionArgumentAttributeValue attrPredicateStringGreaterThan = null;
1619                 FunctionArgumentAttributeValue attrPredicateBooleanFromString = null;
1620
1621                 try {
1622
1623                         // Create Bag contents
1624                         bagabcdefg = new Bag();
1625                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(a));
1626                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(b));
1627                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(c));
1628                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(d));
1629                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(e));
1630                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(f));
1631                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(g));
1632                         bagbdfhj = new Bag();
1633                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(b));
1634                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(d));
1635                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(f));
1636                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(h));
1637                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(j));
1638                         bagace = new Bag();
1639                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(a));
1640                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(c));
1641                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(e));
1642                         bagb = new Bag();
1643                                 bagb.add(DataTypes.DT_STRING.createAttributeValue(b));
1644                         bagaaacccef = new Bag();
1645                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
1646                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
1647                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
1648                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
1649                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
1650                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
1651                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(e));
1652                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(f));
1653                         bagawx = new Bag();
1654                                 bagawx.add(DataTypes.DT_STRING.createAttributeValue(a));
1655                                 bagawx.add(DataTypes.DT_STRING.createAttributeValue(w));
1656                                 bagawx.add(DataTypes.DT_STRING.createAttributeValue(x));
1657                         bagwx = new Bag();
1658                                 bagwx.add(DataTypes.DT_STRING.createAttributeValue(w));
1659                                 bagwx.add(DataTypes.DT_STRING.createAttributeValue(x));
1660                         bagInt = new Bag();
1661                                 bagInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
1662                         bagStringInt = new Bag();
1663                                 bagStringInt.add(DataTypes.DT_STRING.createAttributeValue(a));
1664                                 bagStringInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
1665                         bagEmpty = new Bag();
1666                         bagStringBooleansTrue = new Bag();
1667                                 bagStringBooleansTrue.add(DataTypes.DT_STRING.createAttributeValue("true"));
1668                                 bagStringBooleansTrue.add(DataTypes.DT_STRING.createAttributeValue("false"));
1669                                 bagStringBooleansTrue.add(DataTypes.DT_STRING.createAttributeValue("true"));
1670                         bagStringBooleansFalse = new Bag();
1671                                 bagStringBooleansFalse.add(DataTypes.DT_STRING.createAttributeValue("false"));
1672                                 bagStringBooleansFalse.add(DataTypes.DT_STRING.createAttributeValue("false"));
1673                         bagBooleansTrue = new Bag();
1674                                 bagBooleansTrue.add(DataTypes.DT_BOOLEAN.createAttributeValue(false));
1675                                 bagBooleansTrue.add(DataTypes.DT_BOOLEAN.createAttributeValue(false));
1676                                 bagBooleansTrue.add(DataTypes.DT_BOOLEAN.createAttributeValue(true));
1677                         bagBooleansFalse = new Bag();
1678                                 bagBooleansFalse.add(DataTypes.DT_BOOLEAN.createAttributeValue(false));
1679                                 bagBooleansFalse.add(DataTypes.DT_BOOLEAN.createAttributeValue(false));
1680
1681
1682                         // create primitive attrs
1683                         attra = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(a));
1684                         attrh = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(h));
1685
1686
1687
1688                         // predicates passed as function arguments
1689                         attrPredicateStringEqual = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_STRING_EQUAL));
1690                         attrPredicateStringIntersection = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_STRING_INTERSECTION));
1691                         attrPredicateStringGreaterThan = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_STRING_GREATER_THAN));
1692                         attrPredicateBooleanFromString = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_BOOLEAN_FROM_STRING));
1693
1694                 } catch (Exception ex) {
1695                         fail("creating attribute e="+ ex);
1696                 }
1697
1698                 // make into attributes
1699                 FunctionArgumentBag attrBagabcdefg = new FunctionArgumentBag(bagabcdefg);
1700                 FunctionArgumentBag attrBagace = new FunctionArgumentBag(bagace);
1701                 FunctionArgumentBag attrBagawx = new FunctionArgumentBag(bagawx);
1702                 FunctionArgumentBag attrBagwx = new FunctionArgumentBag(bagwx);
1703                 FunctionArgumentBag attrBagStringInt = new FunctionArgumentBag(bagStringInt);
1704                 FunctionArgumentBag attrBagEmpty = new FunctionArgumentBag(bagEmpty);
1705                 FunctionArgumentBag attrBagStringBooleansTrue = new FunctionArgumentBag(bagStringBooleansTrue);
1706
1707                 FunctionDefinitionHigherOrderBag<?,?> fd = (FunctionDefinitionHigherOrderBag<?,?>) StdFunctions.FD_ALL_OF_ALL;
1708
1709                 // check identity and type of the thing created
1710                 assertEquals(XACML3.ID_FUNCTION_ALL_OF_ALL, fd.getId());
1711                 assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
1712
1713                 // just to be safe...  If tests take too long these can probably be eliminated
1714                 assertFalse(fd.returnsBag());
1715
1716                 // normal match
1717                 arguments.clear();
1718                 arguments.add(attrPredicateStringGreaterThan);
1719                 arguments.add(attrBagwx);
1720                 arguments.add(attrBagace);
1721                 ExpressionResult res = fd.evaluate(null, arguments);
1722                 assertTrue(res.isOk());
1723                 Boolean resValue = (Boolean)res.getValue().getValue();
1724                 assertTrue(resValue);
1725
1726                 // normal no-match
1727                 arguments.clear();
1728                 arguments.add(attrPredicateStringGreaterThan);
1729                 arguments.add(attrBagawx);
1730                 arguments.add(attrBagace);
1731                 res = fd.evaluate(null, arguments);
1732                 assertTrue(res.isOk());
1733                 resValue = (Boolean)res.getValue().getValue();
1734                 assertFalse(resValue);
1735
1736                 arguments.clear();
1737                 arguments.add(attrPredicateStringGreaterThan);
1738                 arguments.add(attrBagace);
1739                 arguments.add(attrBagwx);
1740                 res = fd.evaluate(null, arguments);
1741                 assertTrue(res.isOk());
1742                 resValue = (Boolean)res.getValue().getValue();
1743                 assertFalse(resValue);
1744
1745                 // primitive instead of bag
1746                 arguments.clear();
1747                 arguments.add(attrPredicateStringEqual);
1748                 arguments.add(attra);
1749                 arguments.add(attrBagace);
1750                 res = fd.evaluate(null, arguments);
1751                 assertFalse(res.isOk());
1752                 assertEquals("function:all-of-all 2nd argument must be bag, got 'string'", res.getStatus().getStatusMessage());
1753                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1754
1755                 arguments.clear();
1756                 arguments.add(attrPredicateStringEqual);
1757                 arguments.add(attrBagace);
1758                 arguments.add(attra);
1759                 res = fd.evaluate(null, arguments);
1760                 assertFalse(res.isOk());
1761                 assertEquals("function:all-of-all 3rd argument must be bag, got 'string'", res.getStatus().getStatusMessage());
1762                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1763
1764                 // no primitives - predicate expects only 1 arg
1765                 arguments.clear();
1766                 arguments.add(attrPredicateBooleanFromString);
1767                 arguments.add(attrBagStringBooleansTrue);
1768                 arguments.add(attrBagStringBooleansTrue);
1769                 res = fd.evaluate(null, arguments);
1770                 assertFalse(res.isOk());
1771                 assertEquals("function:all-of-all Predicate error: function:boolean-from-string Expected 1 arguments, got 2", res.getStatus().getStatusMessage());
1772                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1773
1774                 // bag is empty
1775                 arguments.clear();
1776                 arguments.add(attrPredicateStringGreaterThan);
1777                 arguments.add(attrBagace);
1778                 arguments.add(attrBagEmpty);
1779                 res = fd.evaluate(null, arguments);
1780                 assertTrue(res.isOk());
1781                 resValue = (Boolean)res.getValue().getValue();
1782                 assertTrue(resValue);
1783
1784                 arguments.clear();
1785                 arguments.add(attrPredicateStringGreaterThan);
1786                 arguments.add(attrBagEmpty);
1787                 arguments.add(attrBagace);
1788                 res = fd.evaluate(null, arguments);
1789                 assertTrue(res.isOk());
1790                 resValue = (Boolean)res.getValue().getValue();
1791                 assertTrue(resValue);
1792
1793                 // no bag
1794                 arguments.clear();
1795                 arguments.add(attrPredicateStringGreaterThan);
1796                 arguments.add(attrh);
1797                 res = fd.evaluate(null, arguments);
1798                 assertFalse(res.isOk());
1799                 assertEquals("function:all-of-all Expected 3 arguments, got 2", res.getStatus().getStatusMessage());
1800                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1801
1802
1803                 // bad predicate
1804                 arguments.clear();
1805                 arguments.add(attrh);
1806                 arguments.add(attrBagStringInt);
1807                 arguments.add(attrBagStringInt);
1808                 res = fd.evaluate(null, arguments);
1809                 assertFalse(res.isOk());
1810                 assertEquals("function:all-of-all First argument expected URI, got http://www.w3.org/2001/XMLSchema#string", res.getStatus().getStatusMessage());
1811                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1812
1813                 // non-boolean predicate
1814                 arguments.clear();
1815                 arguments.add(attrPredicateStringIntersection);
1816                 arguments.add(attrBagStringInt);
1817                 arguments.add(attrBagStringInt);
1818                 res = fd.evaluate(null, arguments);
1819                 assertFalse(res.isOk());
1820                 assertEquals("function:all-of-all Predicate Function must return boolean, but 'urn:oasis:names:tc:xacml:1.0:function:string-intersection' returns 'string", res.getStatus().getStatusMessage());
1821                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1822
1823                 // predicate after first arg
1824                 arguments.clear();
1825                 arguments.add(attrPredicateStringGreaterThan);
1826                 arguments.add(attrPredicateStringIntersection);
1827                 arguments.add(attrBagStringInt);
1828                 res = fd.evaluate(null, arguments);
1829                 assertFalse(res.isOk());
1830                 assertEquals("function:all-of-all 2nd argument must be bag, got 'anyURI'", res.getStatus().getStatusMessage());
1831                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1832
1833                 // bags of different types
1834                 arguments.clear();
1835                 arguments.add(attrPredicateStringGreaterThan);
1836                 arguments.add(attrBagwx);
1837                 arguments.add(attrBagStringInt);
1838                 res = fd.evaluate(null, arguments);
1839                 assertFalse(res.isOk());
1840                 assertEquals("function:all-of-all Predicate error: function:string-greater-than Expected data type 'string' saw 'integer' at arg index 1", res.getStatus().getStatusMessage());
1841                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1842
1843                 // no args
1844                 arguments.clear();
1845                 res = fd.evaluate(null, arguments);
1846                 assertFalse(res.isOk());
1847                 assertEquals("function:all-of-all Expected at least 2 arguments, got 0", res.getStatus().getStatusMessage());
1848                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1849
1850                 // one arg
1851                 arguments.clear();
1852                 arguments.add(attrBagabcdefg);
1853                 res = fd.evaluate(null, arguments);
1854                 assertFalse(res.isOk());
1855                 assertEquals("function:all-of-all Expected at least 2 arguments, got 1", res.getStatus().getStatusMessage());
1856                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1857
1858                 // too many args
1859                 arguments.clear();
1860                 arguments.add(attrBagabcdefg);
1861                 arguments.add(attrBagabcdefg);
1862                 arguments.add(attrBagabcdefg);
1863                 arguments.add(attrBagabcdefg);
1864                 res = fd.evaluate(null, arguments);
1865                 assertFalse(res.isOk());
1866                 assertEquals("function:all-of-all Expected 3 arguments, got 4", res.getStatus().getStatusMessage());
1867                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1868
1869
1870                 // first null
1871                 arguments.clear();
1872                 arguments.add(null);
1873                 arguments.add(attrBagabcdefg);
1874                 res = fd.evaluate(null, arguments);
1875                 assertFalse(res.isOk());
1876                 assertEquals("function:all-of-all Expected 3 arguments, got 2", res.getStatus().getStatusMessage());
1877                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1878
1879                 // second null
1880                 arguments.clear();
1881                 arguments.add(attrPredicateStringGreaterThan);
1882                 arguments.add(attrBagabcdefg);
1883                 arguments.add(null);
1884                 res = fd.evaluate(null, arguments);
1885                 assertFalse(res.isOk());
1886                 assertEquals("function:all-of-all 3rd argument must be bag, got 'null'", res.getStatus().getStatusMessage());
1887                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1888
1889         }
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900         @Test
1901         public void testMap() {
1902                 String a = "a";
1903                 String b = "b";
1904                 String c = "c";
1905                 String d = "d";
1906                 String e = "e";
1907                 String f = "f";
1908                 String g = "g";
1909                 String h = "h";
1910                 String j = "j";
1911
1912
1913                 Bag bagabcdefg = null;
1914                 Bag bagbdfhj = null;
1915                 Bag bagace = null;
1916                 Bag bagb = null;
1917                 Bag bagaaacccef = null;
1918                 Bag bagInt = null;
1919                 Bag bagStringInt = null;
1920                 Bag bagEmpty = null;
1921                 Bag bagStringBooleansFalse = null;
1922                 Bag bagStringBooleansTrue = null;
1923                 Bag bagInt123 = null;
1924                 Bag bagInt789 = null;
1925
1926
1927                 // primitive attrs
1928                 FunctionArgumentAttributeValue attrh = null;
1929                 FunctionArgumentAttributeValue attrInt7 = null;
1930
1931
1932
1933                 // predicates passed as arguments
1934                 FunctionArgumentAttributeValue attrPredicateStringNormalizeToLowerCase = null;
1935                 FunctionArgumentAttributeValue attrPredicateIntegerEqual = null;
1936                 FunctionArgumentAttributeValue attrPredicateIntegerAdd = null;
1937
1938                 try {
1939
1940                         // Create Bag contents
1941                         bagabcdefg = new Bag();
1942                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(a));
1943                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(b));
1944                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(c));
1945                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(d));
1946                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(e));
1947                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(f));
1948                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(g));
1949                         bagbdfhj = new Bag();
1950                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(b));
1951                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(d));
1952                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(f));
1953                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(h));
1954                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(j));
1955                         bagace = new Bag();
1956                                 bagace.add(DataTypes.DT_STRING.createAttributeValue("A"));
1957                                 bagace.add(DataTypes.DT_STRING.createAttributeValue("C"));
1958                                 bagace.add(DataTypes.DT_STRING.createAttributeValue("E"));
1959                         bagb = new Bag();
1960                                 bagb.add(DataTypes.DT_STRING.createAttributeValue(b));
1961                         bagaaacccef = new Bag();
1962                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
1963                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
1964                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
1965                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
1966                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
1967                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
1968                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(e));
1969                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(f));
1970                         bagInt = new Bag();
1971                                 bagInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
1972                         bagStringInt = new Bag();
1973                                 bagStringInt.add(DataTypes.DT_STRING.createAttributeValue(a));
1974
1975                                 bagStringInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
1976                         bagEmpty = new Bag();
1977                         bagStringBooleansTrue = new Bag();
1978                                 bagStringBooleansTrue.add(DataTypes.DT_STRING.createAttributeValue("true"));
1979                                 bagStringBooleansTrue.add(DataTypes.DT_STRING.createAttributeValue("true"));
1980                                 bagStringBooleansTrue.add(DataTypes.DT_STRING.createAttributeValue("true"));
1981                         bagStringBooleansFalse = new Bag();
1982                                 bagStringBooleansFalse.add(DataTypes.DT_STRING.createAttributeValue("false"));
1983                                 bagStringBooleansFalse.add(DataTypes.DT_STRING.createAttributeValue("false"));
1984                         bagInt123 = new Bag();
1985                                 bagInt123.add(DataTypes.DT_INTEGER.createAttributeValue(1));
1986                                 bagInt123.add(DataTypes.DT_INTEGER.createAttributeValue(2));
1987                                 bagInt123.add(DataTypes.DT_INTEGER.createAttributeValue(3));
1988                         bagInt789 = new Bag();
1989                                 bagInt789.add(DataTypes.DT_INTEGER.createAttributeValue(7));
1990                                 bagInt789.add(DataTypes.DT_INTEGER.createAttributeValue(8));
1991                                 bagInt789.add(DataTypes.DT_INTEGER.createAttributeValue(9));
1992
1993
1994
1995                         // create primitive attrs
1996                         attrh = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(h));
1997                         attrInt7 = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(7));
1998
1999
2000                         // predicates passed as function arguments
2001                         attrPredicateStringNormalizeToLowerCase = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_STRING_NORMALIZE_TO_LOWER_CASE));
2002                         attrPredicateIntegerEqual = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_INTEGER_EQUAL));
2003                         attrPredicateIntegerAdd = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(XACML3.ID_FUNCTION_INTEGER_ADD));
2004
2005                 } catch (Exception ex) {
2006                         fail("creating attribute e="+ ex);
2007                 }
2008
2009                 // make into attributes
2010                 FunctionArgumentBag attrBagabcdefg = new FunctionArgumentBag(bagabcdefg);
2011                 FunctionArgumentBag attrBagace = new FunctionArgumentBag(bagace);
2012                 FunctionArgumentBag attrBagStringInt = new FunctionArgumentBag(bagStringInt);
2013                 FunctionArgumentBag attrBagEmpty = new FunctionArgumentBag(bagEmpty);
2014                 FunctionArgumentBag attrBagStringBooleansTrue = new FunctionArgumentBag(bagStringBooleansTrue);
2015                 FunctionArgumentBag attrBagInt789 = new FunctionArgumentBag(bagInt789);
2016
2017                 FunctionDefinitionHigherOrderBag<?,?> fd = (FunctionDefinitionHigherOrderBag<?,?>) StdFunctions.FD_MAP;
2018
2019                 // check identity and type of the thing created
2020                 assertEquals(XACML3.ID_FUNCTION_MAP, fd.getId());
2021                 assertNull( fd.getDataTypeId());
2022
2023                 // just to be safe...  If tests take too long these can probably be eliminated
2024                 assertTrue(fd.returnsBag());
2025
2026                 // normal match
2027                 arguments.clear();
2028                 arguments.add(attrPredicateStringNormalizeToLowerCase);
2029                 arguments.add(attrBagace);
2030                 ExpressionResult res = fd.evaluate(null, arguments);
2031                 assertTrue(res.isOk());
2032                 assertTrue(res.isBag());
2033                 Bag bag = res.getBag();
2034                 assertEquals(3, bag.size());
2035                 List<AttributeValue<?>> bagAttributes = bag.getAttributeValueList();
2036                 try {
2037                         assertTrue(bagAttributes.contains(DataTypes.DT_STRING.createAttributeValue("a")));
2038                         assertFalse(bagAttributes.contains(DataTypes.DT_STRING.createAttributeValue("A")));
2039                         assertTrue(bagAttributes.contains(DataTypes.DT_STRING.createAttributeValue("c")));
2040                         assertFalse(bagAttributes.contains(DataTypes.DT_STRING.createAttributeValue("C")));
2041                         assertTrue(bagAttributes.contains(DataTypes.DT_STRING.createAttributeValue("e")));
2042                         assertFalse(bagAttributes.contains(DataTypes.DT_STRING.createAttributeValue("E")));
2043                 } catch (Exception ex) {
2044                         fail("checking result e="+ex);
2045                 }
2046
2047                 // 2-input predicate
2048                 arguments.clear();
2049                 arguments.add(attrPredicateIntegerAdd);
2050                 arguments.add(attrInt7);
2051                 arguments.add(attrBagInt789);
2052                 res = fd.evaluate(null, arguments);
2053                 assertTrue(res.isOk());
2054                 assertTrue(res.isBag());
2055                 bag = res.getBag();
2056                 assertEquals(3, bag.size());
2057                 bagAttributes = bag.getAttributeValueList();
2058                 try {
2059                         assertTrue(bagAttributes.contains(DataTypes.DT_INTEGER.createAttributeValue("14")));
2060                         assertTrue(bagAttributes.contains(DataTypes.DT_INTEGER.createAttributeValue("15")));
2061                         assertTrue(bagAttributes.contains(DataTypes.DT_INTEGER.createAttributeValue("16")));
2062                 } catch (Exception ex) {
2063                         fail("checking result e="+ex);
2064                 }
2065
2066
2067                 // predicate returns booleans
2068                 arguments.clear();
2069                 arguments.add(attrPredicateIntegerEqual);
2070                 arguments.add(attrInt7);
2071                 arguments.add(attrBagInt789);
2072                 res = fd.evaluate(null, arguments);
2073                 assertTrue(res.isOk());
2074                 assertTrue(res.isBag());
2075                 bag = res.getBag();
2076                 assertEquals(3, bag.size());
2077                 bagAttributes = bag.getAttributeValueList();
2078                 try {
2079                         assertEquals(bagAttributes.get(0), (DataTypes.DT_BOOLEAN.createAttributeValue(true)));
2080                         assertEquals(bagAttributes.get(1), (DataTypes.DT_BOOLEAN.createAttributeValue(false)));
2081                         assertEquals(bagAttributes.get(2), (DataTypes.DT_BOOLEAN.createAttributeValue(false)));
2082                 } catch (Exception ex) {
2083                         fail("checking result e="+ex);
2084                 }
2085
2086                 // predicate returns bag
2087
2088
2089
2090                 // no primitives - predicate function expects 2
2091                 arguments.clear();
2092                 arguments.add(attrPredicateIntegerAdd);
2093                 arguments.add(attrBagace);
2094                 res = fd.evaluate(null, arguments);
2095                 assertFalse(res.isOk());
2096                 assertEquals("function:map Predicate error: function:integer-add Expected 2 arguments, got 1", res.getStatus().getStatusMessage());
2097                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2098
2099                 // bag is empty
2100                 arguments.clear();
2101                 arguments.add(attrPredicateStringNormalizeToLowerCase);
2102                 arguments.add(attrh);
2103                 arguments.add(attrBagEmpty);
2104                 res = fd.evaluate(null, arguments);
2105                 assertTrue(res.isOk());
2106                 assertTrue(res.isBag());
2107                 bag = res.getBag();
2108                 assertEquals(0, bag.size());;
2109
2110                 // no bag
2111                 arguments.clear();
2112                 arguments.add(attrPredicateStringNormalizeToLowerCase);
2113                 arguments.add(attrh);
2114                 res = fd.evaluate(null, arguments);
2115                 assertFalse(res.isOk());
2116                 assertEquals("function:map Did not get any Bag argument; must have at least 1", res.getStatus().getStatusMessage());
2117                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2118
2119                 // extra bag
2120                 arguments.clear();
2121                 arguments.add(attrPredicateStringNormalizeToLowerCase);
2122                 arguments.add(attrh);
2123                 arguments.add(attrBagStringBooleansTrue);
2124                 arguments.add(attrh);
2125                 arguments.add(attrBagStringBooleansTrue);
2126                 res = fd.evaluate(null, arguments);
2127                 assertFalse(res.isOk());
2128                 assertEquals("function:map must have only 1 bag; found one at index 2 and another at 4", res.getStatus().getStatusMessage());
2129                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2130
2131
2132                 // bad predicate
2133                 arguments.clear();
2134                 arguments.add(attrh);
2135                 arguments.add(attrBagStringInt);
2136                 res = fd.evaluate(null, arguments);
2137                 assertFalse(res.isOk());
2138                 assertEquals("function:map First argument expected URI, got http://www.w3.org/2001/XMLSchema#string", res.getStatus().getStatusMessage());
2139                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2140
2141                 // predicate gets unexpected number of args
2142                 arguments.clear();
2143                 arguments.add(attrPredicateStringNormalizeToLowerCase);
2144                 arguments.add(attrh);
2145                 arguments.add(attrBagStringInt);
2146                 res = fd.evaluate(null, arguments);
2147                 assertFalse(res.isOk());
2148                 assertEquals("function:map Predicate error: function:string-normalize-to-lower-case Expected 1 arguments, got 2", res.getStatus().getStatusMessage());
2149                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2150
2151                 // predicate gets bad primitive type
2152                 arguments.clear();
2153                 arguments.add(attrPredicateStringNormalizeToLowerCase);
2154                 arguments.add(attrPredicateStringNormalizeToLowerCase);
2155                 arguments.add(attrBagStringInt);
2156                 res = fd.evaluate(null, arguments);
2157                 assertFalse(res.isOk());
2158                 assertEquals("function:map Predicate error: function:string-normalize-to-lower-case Expected 1 arguments, got 2", res.getStatus().getStatusMessage());
2159                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2160
2161                 // bags of different types
2162                 arguments.clear();
2163                 arguments.add(attrPredicateStringNormalizeToLowerCase);
2164                 arguments.add(attrh);
2165                 arguments.add(attrBagStringInt);
2166                 res = fd.evaluate(null, arguments);
2167                 assertFalse(res.isOk());
2168
2169                 // first null
2170                 arguments.clear();
2171                 arguments.add(null);
2172                 arguments.add(attrBagabcdefg);
2173                 res = fd.evaluate(null, arguments);
2174                 assertFalse(res.isOk());
2175                 assertEquals("function:map Predicate Function (first argument) was null", res.getStatus().getStatusMessage());
2176                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2177
2178                 // second null
2179                 arguments.clear();
2180                 arguments.add(attrPredicateStringNormalizeToLowerCase);
2181                 arguments.add(attrBagabcdefg);
2182                 arguments.add(null);
2183                 res = fd.evaluate(null, arguments);
2184                 assertFalse(res.isOk());
2185                 assertEquals("function:map Got null argument at index 2", res.getStatus().getStatusMessage());
2186                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2187
2188         }
2189
2190
2191
2192
2193 }