ECOMP-PDP/src/test/java/org/openecomp/policy/pdp/test/FunctionDefinitionSetTest.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.assertNotNull;
  26 import static org.junit.Assert.assertTrue;
  27 import static org.junit.Assert.fail;
  28
  29 import java.math.BigInteger;
  30 import java.util.ArrayList;
  31 import java.util.Iterator;
  32 import java.util.List;
  33
  34 import org.junit.Test;
  35
  36 import com.att.research.xacml.api.AttributeValue;
  37 import com.att.research.xacml.api.XACML3;
  38 import com.att.research.xacml.std.datatypes.DataTypes;
  39 import com.att.research.xacmlatt.pdp.policy.Bag;
  40 import com.att.research.xacmlatt.pdp.policy.ExpressionResult;
  41 import com.att.research.xacmlatt.pdp.policy.FunctionArgument;
  42 import com.att.research.xacmlatt.pdp.policy.FunctionArgumentAttributeValue;
  43 import com.att.research.xacmlatt.pdp.policy.FunctionArgumentBag;
  44 import com.att.research.xacmlatt.pdp.std.StdFunctions;
  45 import com.att.research.xacmlatt.pdp.std.functions.*;
  46
  47 /**
  48  * Test of PDP Functions (See XACML core spec section A.3)
  49  *
  50  * TO RUN - use jUnit
  51  * In Eclipse select this file or the enclosing directory, right-click and select Run As/JUnit Test
  52  *
  53  *
  54  */
  55 public class FunctionDefinitionSetTest {
  56
  57
  58         /*
  59          * variables useful in the following tests
  60          */
  61         List<FunctionArgument> arguments = new ArrayList<>();
  62
  63
  64
  65         //
  66         // INTERSECTION tests
  67         //
  68
  69
  70         @Test
  71         public void testString_intersection() {
  72                 String a = "a";
  73                 String b = "b";
  74                 String c = "c";
  75                 String d = "d";
  76                 String e = "e";
  77                 String f = "f";
  78                 String g = "g";
  79                 String h = "h";
  80                 String j = "j";
  81
  82
  83                 Bag bagabcdefg = null;
  84                 Bag bagbdfhj = null;
  85                 Bag bagace = null;
  86                 Bag bagb = null;
  87                 Bag bagaaacccef = null;
  88                 Bag bagInt = null;
  89                 Bag bagStringInt = null;
  90                 Bag bagEmpty = null;
  91
  92                 FunctionArgumentAttributeValue attrBadType = null;
  93
  94                 try {
  95                         bagabcdefg = new Bag();
  96                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(a));
  97                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(b));
  98                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(c));
  99                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(d));
 100                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(e));
 101                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(f));
 102                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(g));
 103                         bagbdfhj = new Bag();
 104                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(b));
 105                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(d));
 106                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(f));
 107                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(h));
 108                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(j));
 109                         bagace = new Bag();
 110                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(a));
 111                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(c));
 112                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(e));
 113                         bagb = new Bag();
 114                                 bagb.add(DataTypes.DT_STRING.createAttributeValue(b));
 115                         bagaaacccef = new Bag();
 116                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
 117                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
 118                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
 119                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
 120                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
 121                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
 122                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(e));
 123                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(f));
 124                         bagInt = new Bag();
 125                                 bagInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
 126                         bagStringInt = new Bag();
 127                                 bagStringInt.add(DataTypes.DT_STRING.createAttributeValue(a));
 128                                 bagStringInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
 129                         bagEmpty = new Bag();
 130
 131                         attrBadType = new FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(1.1));
 132                 } catch (Exception ex) {
 133                         fail("creating attribute e="+ ex);
 134                 }
 135
 136                 // make into attributes
 137                 FunctionArgumentBag attrBagabcdefg = new FunctionArgumentBag(bagabcdefg);
 138                 FunctionArgumentBag attrBagbdfhj = new FunctionArgumentBag(bagbdfhj);
 139                 FunctionArgumentBag attrBagace = new FunctionArgumentBag(bagace);
 140                 FunctionArgumentBag attrBagb = new FunctionArgumentBag(bagb);
 141                 FunctionArgumentBag attrBagaaacccef = new FunctionArgumentBag(bagaaacccef);
 142                 FunctionArgumentBag attrBagInt = new FunctionArgumentBag(bagInt);
 143                 FunctionArgumentBag attrBagStringInt = new FunctionArgumentBag(bagStringInt);
 144                 FunctionArgumentBag attrBagEmpty = new FunctionArgumentBag(bagEmpty);
 145
 146                 FunctionDefinitionSet<?,?> fd = (FunctionDefinitionSet<?,?>) StdFunctions.FD_STRING_INTERSECTION;
 147
 148                 // check identity and type of the thing created
 149                 assertEquals(XACML3.ID_FUNCTION_STRING_INTERSECTION, fd.getId());
 150                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeId());
 151
 152                 // just to be safe...  If tests take too long these can probably be eliminated
 153                 assertTrue(fd.returnsBag());
 154
 155                 // normal intersection (everything in both bags, no duplicates)
 156                 arguments.clear();
 157                 arguments.add(attrBagabcdefg);
 158                 arguments.add(attrBagabcdefg);
 159                 ExpressionResult res = fd.evaluate(null, arguments);
 160                 assertTrue(res.isOk());
 161                 Bag bag = res.getBag();
 162                 assertNotNull(bag);
 163                 Iterator<AttributeValue<?>> it = bag.getAttributeValues();
 164                 assertEquals(7, bag.size());
 165                 AttributeValue<?> attrValueObject = it.next();
 166                 assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
 167                 assertEquals(a, attrValueObject.getValue() );
 168
 169                 // several but not all intersection
 170                 arguments.clear();
 171                 arguments.add(attrBagabcdefg);
 172                 arguments.add(attrBagbdfhj);
 173                 res = fd.evaluate(null, arguments);
 174                 assertTrue(res.isOk());
 175                 bag = res.getBag();
 176                 assertNotNull(bag);
 177                 it = bag.getAttributeValues();
 178                 assertEquals(3, bag.size());
 179                 attrValueObject = it.next();
 180                 assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
 181                 assertEquals(b, attrValueObject.getValue() );
 182
 183                 // no intersection
 184                 arguments.clear();
 185                 arguments.add(attrBagace);
 186                 arguments.add(attrBagbdfhj);
 187                 res = fd.evaluate(null, arguments);
 188                 assertTrue(res.isOk());
 189                 bag = res.getBag();
 190                 assertNotNull(bag);
 191                 it = bag.getAttributeValues();
 192                 assertEquals(0, bag.size());
 193
 194                 // one intersection
 195                 arguments.clear();
 196                 arguments.add(attrBagabcdefg);
 197                 arguments.add(attrBagb);
 198                 res = fd.evaluate(null, arguments);
 199                 assertTrue(res.isOk());
 200                 bag = res.getBag();
 201                 assertNotNull(bag);
 202                 it = bag.getAttributeValues();
 203                 assertEquals(1, bag.size());
 204                 attrValueObject = it.next();
 205                 assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
 206                 assertEquals(b, attrValueObject.getValue() );
 207
 208                 // bag one has duplicates that do not intersect
 209                 arguments.clear();
 210                 arguments.add(attrBagaaacccef);
 211                 arguments.add(attrBagbdfhj);
 212                 res = fd.evaluate(null, arguments);
 213                 assertTrue(res.isOk());
 214                 bag = res.getBag();
 215                 assertNotNull(bag);
 216                 it = bag.getAttributeValues();
 217                 assertEquals(1, bag.size());
 218                 attrValueObject = it.next();
 219                 assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
 220                 assertEquals(f, attrValueObject.getValue() );
 221
 222                 // bag one has duplicates that do intersect
 223                 arguments.clear();
 224                 arguments.add(attrBagaaacccef);
 225                 arguments.add(attrBagace);
 226                 res = fd.evaluate(null, arguments);
 227                 assertTrue(res.isOk());
 228                 bag = res.getBag();
 229                 assertNotNull(bag);
 230                 it = bag.getAttributeValues();
 231                 assertEquals(3, bag.size());
 232                 attrValueObject = it.next();
 233                 assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
 234                 assertEquals(a, attrValueObject.getValue() );
 235                 attrValueObject = it.next();
 236                 assertEquals(c, attrValueObject.getValue() );
 237                 attrValueObject = it.next();
 238                 assertEquals(e, attrValueObject.getValue() );
 239
 240                 // bag 2 has duplicates that do not intersect
 241                 arguments.clear();
 242                 arguments.add(attrBagbdfhj);
 243                 arguments.add(attrBagaaacccef);
 244                 res = fd.evaluate(null, arguments);
 245                 assertTrue(res.isOk());
 246                 bag = res.getBag();
 247                 assertNotNull(bag);
 248                 it = bag.getAttributeValues();
 249                 assertEquals(1, bag.size());
 250                 attrValueObject = it.next();
 251                 assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
 252                 assertEquals(f, attrValueObject.getValue() );
 253
 254                 // bag 2 has duplicates that intersect
 255                 arguments.clear();
 256                 arguments.add(attrBagace);
 257                 arguments.add(attrBagaaacccef);
 258                 res = fd.evaluate(null, arguments);
 259                 assertTrue(res.isOk());
 260                 bag = res.getBag();
 261                 assertNotNull(bag);
 262                 it = bag.getAttributeValues();
 263                 assertEquals(3, bag.size());
 264                 attrValueObject = it.next();
 265                 assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
 266                 assertEquals(a, attrValueObject.getValue() );
 267                 attrValueObject = it.next();
 268                 assertEquals(c, attrValueObject.getValue() );
 269                 attrValueObject = it.next();
 270                 assertEquals(e, attrValueObject.getValue() );
 271
 272                 // first bag is empty
 273                 arguments.clear();
 274                 arguments.add(attrBagEmpty);
 275                 arguments.add(attrBagaaacccef);
 276                 res = fd.evaluate(null, arguments);
 277                 assertTrue(res.isOk());
 278                 bag = res.getBag();
 279                 assertNotNull(bag);
 280                 it = bag.getAttributeValues();
 281                 assertEquals(0, bag.size());
 282
 283                 // second bag is empty
 284                 arguments.clear();
 285                 arguments.add(attrBagace);
 286                 arguments.add(attrBagEmpty);
 287                 res = fd.evaluate(null, arguments);
 288                 assertTrue(res.isOk());
 289                 bag = res.getBag();
 290                 assertNotNull(bag);
 291                 it = bag.getAttributeValues();
 292                 assertEquals(0, bag.size());
 293
 294                 // bags of different types
 295                 arguments.clear();
 296                 arguments.add(attrBagace);
 297                 arguments.add(attrBagStringInt);
 298                 res = fd.evaluate(null, arguments);
 299                 assertTrue(res.isOk());
 300                 bag = res.getBag();
 301                 assertNotNull(bag);
 302                 it = bag.getAttributeValues();
 303                 assertEquals(1, bag.size());
 304                 attrValueObject = it.next();
 305                 assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
 306                 assertEquals(a, attrValueObject.getValue() );
 307
 308                 arguments.clear();
 309                 arguments.add(attrBagace);
 310                 arguments.add(attrBagInt);
 311                 res = fd.evaluate(null, arguments);
 312                 assertTrue(res.isOk());
 313                 bag = res.getBag();
 314                 assertNotNull(bag);
 315                 it = bag.getAttributeValues();
 316                 assertEquals(0, bag.size());
 317
 318                 // first not a bag
 319                 arguments.clear();
 320                 arguments.add(attrBadType);
 321                 arguments.add(attrBagabcdefg);
 322                 res = fd.evaluate(null, arguments);
 323                 assertFalse(res.isOk());
 324                 assertEquals("function:string-intersection Expected a bag, saw a simple value", res.getStatus().getStatusMessage());
 325                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 326
 327                 // second not a bag
 328                 arguments.clear();
 329                 arguments.add(attrBagabcdefg);
 330                 arguments.add(attrBadType);
 331                 res = fd.evaluate(null, arguments);
 332                 assertFalse(res.isOk());
 333                 assertEquals("function:string-intersection Expected a bag, saw a simple value", res.getStatus().getStatusMessage());
 334                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 335
 336
 337                 // first null
 338                 arguments.clear();
 339                 arguments.add(null);
 340                 arguments.add(attrBagabcdefg);
 341                 res = fd.evaluate(null, arguments);
 342                 assertFalse(res.isOk());
 343                 assertEquals("function:string-intersection Got null argument", res.getStatus().getStatusMessage());
 344                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 345
 346                 // second null
 347                 arguments.clear();
 348                 arguments.add(attrBagabcdefg);
 349                 arguments.add(null);
 350                 res = fd.evaluate(null, arguments);
 351                 assertFalse(res.isOk());
 352                 assertEquals("function:string-intersection Got null argument", res.getStatus().getStatusMessage());
 353                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 354
 355                 // too few args
 356                 arguments.clear();
 357                 arguments.add(attrBagabcdefg);
 358                 res = fd.evaluate(null, arguments);
 359                 assertFalse(res.isOk());
 360                 assertEquals("function:string-intersection Expected 2 arguments, got 1", res.getStatus().getStatusMessage());
 361                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 362
 363                 arguments.clear();
 364                 res = fd.evaluate(null, arguments);
 365                 assertFalse(res.isOk());
 366                 assertEquals("function:string-intersection Expected 2 arguments, got 0", res.getStatus().getStatusMessage());
 367                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 368
 369                 // too many args
 370                 arguments.clear();
 371                 arguments.add(attrBagabcdefg);
 372                 arguments.add(attrBagabcdefg);
 373                 arguments.add(attrBagabcdefg);
 374                 res = fd.evaluate(null, arguments);
 375                 assertFalse(res.isOk());
 376                 assertEquals("function:string-intersection Expected 2 arguments, got 3", res.getStatus().getStatusMessage());
 377                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 378
 379         }
 380
 381
 382
 383         @Test
 384         public void testInteger_intersection() {
 385                 BigInteger a = new BigInteger("1");
 386                 BigInteger b = new BigInteger("2");
 387                 BigInteger c = new BigInteger("3");
 388                 BigInteger d = new BigInteger("4");
 389                 BigInteger e = new BigInteger("5");
 390                 BigInteger f = new BigInteger("6");
 391                 BigInteger g = new BigInteger("7");
 392                 BigInteger h = new BigInteger("8");
 393                 BigInteger j = new BigInteger("9");
 394
 395
 396                 Bag bagabcdefg = null;
 397                 Bag bagbdfhj = null;
 398                 Bag bagace = null;
 399                 Bag bagb = null;
 400                 Bag bagaaacccef = null;
 401                 Bag bagInt = null;
 402                 Bag bagStringInt = null;
 403                 Bag bagEmpty = null;
 404
 405                 FunctionArgumentAttributeValue attrBadType = null;
 406
 407                 try {
 408                         bagabcdefg = new Bag();
 409                                 bagabcdefg.add(DataTypes.DT_INTEGER.createAttributeValue(a));
 410                                 bagabcdefg.add(DataTypes.DT_INTEGER.createAttributeValue(b));
 411                                 bagabcdefg.add(DataTypes.DT_INTEGER.createAttributeValue(c));
 412                                 bagabcdefg.add(DataTypes.DT_INTEGER.createAttributeValue(d));
 413                                 bagabcdefg.add(DataTypes.DT_INTEGER.createAttributeValue(e));
 414                                 bagabcdefg.add(DataTypes.DT_INTEGER.createAttributeValue(f));
 415                                 bagabcdefg.add(DataTypes.DT_INTEGER.createAttributeValue(g));
 416                         bagbdfhj = new Bag();
 417                                 bagbdfhj.add(DataTypes.DT_INTEGER.createAttributeValue(b));
 418                                 bagbdfhj.add(DataTypes.DT_INTEGER.createAttributeValue(d));
 419                                 bagbdfhj.add(DataTypes.DT_INTEGER.createAttributeValue(f));
 420                                 bagbdfhj.add(DataTypes.DT_INTEGER.createAttributeValue(h));
 421                                 bagbdfhj.add(DataTypes.DT_INTEGER.createAttributeValue(j));
 422                         bagace = new Bag();
 423                                 bagace.add(DataTypes.DT_INTEGER.createAttributeValue(a));
 424                                 bagace.add(DataTypes.DT_INTEGER.createAttributeValue(c));
 425                                 bagace.add(DataTypes.DT_INTEGER.createAttributeValue(e));
 426                         bagb = new Bag();
 427                                 bagb.add(DataTypes.DT_INTEGER.createAttributeValue(b));
 428                         bagaaacccef = new Bag();
 429                                 bagaaacccef.add(DataTypes.DT_INTEGER.createAttributeValue(a));
 430                                 bagaaacccef.add(DataTypes.DT_INTEGER.createAttributeValue(a));
 431                                 bagaaacccef.add(DataTypes.DT_INTEGER.createAttributeValue(a));
 432                                 bagaaacccef.add(DataTypes.DT_INTEGER.createAttributeValue(c));
 433                                 bagaaacccef.add(DataTypes.DT_INTEGER.createAttributeValue(c));
 434                                 bagaaacccef.add(DataTypes.DT_INTEGER.createAttributeValue(c));
 435                                 bagaaacccef.add(DataTypes.DT_INTEGER.createAttributeValue(e));
 436                                 bagaaacccef.add(DataTypes.DT_INTEGER.createAttributeValue(f));
 437                         bagInt = new Bag();
 438                                 bagInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
 439                         bagStringInt = new Bag();
 440                                 bagStringInt.add(DataTypes.DT_STRING.createAttributeValue("abc"));
 441                                 bagStringInt.add(DataTypes.DT_INTEGER.createAttributeValue(1));
 442                         bagEmpty = new Bag();
 443
 444                         attrBadType = new FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(1.1));
 445                 } catch (Exception ex) {
 446                         fail("creating attribute e="+ ex);
 447                 }
 448
 449                 // make into attributes
 450                 FunctionArgumentBag attrBagabcdefg = new FunctionArgumentBag(bagabcdefg);
 451                 FunctionArgumentBag attrBagbdfhj = new FunctionArgumentBag(bagbdfhj);
 452                 FunctionArgumentBag attrBagace = new FunctionArgumentBag(bagace);
 453                 FunctionArgumentBag attrBagb = new FunctionArgumentBag(bagb);
 454                 FunctionArgumentBag attrBagaaacccef = new FunctionArgumentBag(bagaaacccef);
 455                 FunctionArgumentBag attrBagInt = new FunctionArgumentBag(bagInt);
 456                 FunctionArgumentBag attrBagStringInt = new FunctionArgumentBag(bagStringInt);
 457                 FunctionArgumentBag attrBagEmpty = new FunctionArgumentBag(bagEmpty);
 458
 459                 FunctionDefinitionSet<?,?> fd = (FunctionDefinitionSet<?,?>) StdFunctions.FD_INTEGER_INTERSECTION;
 460
 461                 // check identity and type of the thing created
 462                 assertEquals(XACML3.ID_FUNCTION_INTEGER_INTERSECTION, fd.getId());
 463                 assertEquals(DataTypes.DT_INTEGER.getId(), fd.getDataTypeId());
 464
 465                 // just to be safe...  If tests take too long these can probably be eliminated
 466                 assertTrue(fd.returnsBag());
 467
 468                 // normal intersection (everything in both bags, no duplicates)
 469                 arguments.clear();
 470                 arguments.add(attrBagabcdefg);
 471                 arguments.add(attrBagabcdefg);
 472                 ExpressionResult res = fd.evaluate(null, arguments);
 473                 assertTrue(res.isOk());
 474                 Bag bag = res.getBag();
 475                 assertNotNull(bag);
 476                 Iterator<AttributeValue<?>> it = bag.getAttributeValues();
 477                 assertEquals(7, bag.size());
 478                 AttributeValue<?> attrValueObject = it.next();
 479                 assertEquals(DataTypes.DT_INTEGER.getId(), attrValueObject.getDataTypeId());
 480                 assertEquals(a, attrValueObject.getValue() );
 481
 482                 // several but not all intersection
 483                 arguments.clear();
 484                 arguments.add(attrBagabcdefg);
 485                 arguments.add(attrBagbdfhj);
 486                 res = fd.evaluate(null, arguments);
 487                 assertTrue(res.isOk());
 488                 bag = res.getBag();
 489                 assertNotNull(bag);
 490                 it = bag.getAttributeValues();
 491                 assertEquals(3, bag.size());
 492                 attrValueObject = it.next();
 493                 assertEquals(DataTypes.DT_INTEGER.getId(), attrValueObject.getDataTypeId());
 494                 assertEquals(b, attrValueObject.getValue() );
 495
 496                 // no intersection
 497                 arguments.clear();
 498                 arguments.add(attrBagace);
 499                 arguments.add(attrBagbdfhj);
 500                 res = fd.evaluate(null, arguments);
 501                 assertTrue(res.isOk());
 502                 bag = res.getBag();
 503                 assertNotNull(bag);
 504                 it = bag.getAttributeValues();
 505                 assertEquals(0, bag.size());
 506
 507                 // one intersection
 508                 arguments.clear();
 509                 arguments.add(attrBagabcdefg);
 510                 arguments.add(attrBagb);
 511                 res = fd.evaluate(null, arguments);
 512                 assertTrue(res.isOk());
 513                 bag = res.getBag();
 514                 assertNotNull(bag);
 515                 it = bag.getAttributeValues();
 516                 assertEquals(1, bag.size());
 517                 attrValueObject = it.next();
 518                 assertEquals(DataTypes.DT_INTEGER.getId(), attrValueObject.getDataTypeId());
 519                 assertEquals(b, attrValueObject.getValue() );
 520
 521                 // bag one has duplicates that do not intersect
 522                 arguments.clear();
 523                 arguments.add(attrBagaaacccef);
 524                 arguments.add(attrBagbdfhj);
 525                 res = fd.evaluate(null, arguments);
 526                 assertTrue(res.isOk());
 527                 bag = res.getBag();
 528                 assertNotNull(bag);
 529                 it = bag.getAttributeValues();
 530                 assertEquals(1, bag.size());
 531                 attrValueObject = it.next();
 532                 assertEquals(DataTypes.DT_INTEGER.getId(), attrValueObject.getDataTypeId());
 533                 assertEquals(f, attrValueObject.getValue() );
 534
 535                 // bag one has duplicates that do intersect
 536                 arguments.clear();
 537                 arguments.add(attrBagaaacccef);
 538                 arguments.add(attrBagace);
 539                 res = fd.evaluate(null, arguments);
 540                 assertTrue(res.isOk());
 541                 bag = res.getBag();
 542                 assertNotNull(bag);
 543                 it = bag.getAttributeValues();
 544                 assertEquals(3, bag.size());
 545                 attrValueObject = it.next();
 546                 assertEquals(DataTypes.DT_INTEGER.getId(), attrValueObject.getDataTypeId());
 547                 assertEquals(a, attrValueObject.getValue() );
 548                 attrValueObject = it.next();
 549                 assertEquals(c, attrValueObject.getValue() );
 550                 attrValueObject = it.next();
 551                 assertEquals(e, attrValueObject.getValue() );
 552
 553                 // bag 2 has duplicates that do not intersect
 554                 arguments.clear();
 555                 arguments.add(attrBagbdfhj);
 556                 arguments.add(attrBagaaacccef);
 557                 res = fd.evaluate(null, arguments);
 558                 assertTrue(res.isOk());
 559                 bag = res.getBag();
 560                 assertNotNull(bag);
 561                 it = bag.getAttributeValues();
 562                 assertEquals(1, bag.size());
 563                 attrValueObject = it.next();
 564                 assertEquals(DataTypes.DT_INTEGER.getId(), attrValueObject.getDataTypeId());
 565                 assertEquals(f, attrValueObject.getValue() );
 566
 567                 // bag 2 has duplicates that intersect
 568                 arguments.clear();
 569                 arguments.add(attrBagace);
 570                 arguments.add(attrBagaaacccef);
 571                 res = fd.evaluate(null, arguments);
 572                 assertTrue(res.isOk());
 573                 bag = res.getBag();
 574                 assertNotNull(bag);
 575                 it = bag.getAttributeValues();
 576                 assertEquals(3, bag.size());
 577                 attrValueObject = it.next();
 578                 assertEquals(DataTypes.DT_INTEGER.getId(), attrValueObject.getDataTypeId());
 579                 assertEquals(a, attrValueObject.getValue() );
 580                 attrValueObject = it.next();
 581                 assertEquals(c, attrValueObject.getValue() );
 582                 attrValueObject = it.next();
 583                 assertEquals(e, attrValueObject.getValue() );
 584
 585                 // first bag is empty
 586                 arguments.clear();
 587                 arguments.add(attrBagEmpty);
 588                 arguments.add(attrBagaaacccef);
 589                 res = fd.evaluate(null, arguments);
 590                 assertTrue(res.isOk());
 591                 bag = res.getBag();
 592                 assertNotNull(bag);
 593                 it = bag.getAttributeValues();
 594                 assertEquals(0, bag.size());
 595
 596                 // second bag is empty
 597                 arguments.clear();
 598                 arguments.add(attrBagbdfhj);
 599                 arguments.add(attrBagEmpty);
 600                 res = fd.evaluate(null, arguments);
 601                 assertTrue(res.isOk());
 602                 bag = res.getBag();
 603                 assertNotNull(bag);
 604                 it = bag.getAttributeValues();
 605                 assertEquals(0, bag.size());
 606
 607                 // bags of different types
 608                 arguments.clear();
 609                 arguments.add(attrBagace);
 610                 arguments.add(attrBagStringInt);
 611                 res = fd.evaluate(null, arguments);
 612                 assertTrue(res.isOk());
 613                 bag = res.getBag();
 614                 assertNotNull(bag);
 615                 it = bag.getAttributeValues();
 616                 assertEquals(1, bag.size());
 617                 attrValueObject = it.next();
 618                 assertEquals(DataTypes.DT_INTEGER.getId(), attrValueObject.getDataTypeId());
 619                 assertEquals(a, attrValueObject.getValue() );
 620
 621                 arguments.clear();
 622                 arguments.add(attrBagace);
 623                 arguments.add(attrBagInt);
 624                 assertTrue(res.isOk());
 625                 bag = res.getBag();
 626                 assertNotNull(bag);
 627                 it = bag.getAttributeValues();
 628                 assertEquals(1, bag.size());
 629                 attrValueObject = it.next();
 630                 assertEquals(DataTypes.DT_INTEGER.getId(), attrValueObject.getDataTypeId());
 631                 assertEquals(a, attrValueObject.getValue() );
 632
 633
 634                 // first not a bag
 635                 arguments.clear();
 636                 arguments.add(attrBadType);
 637                 arguments.add(attrBagabcdefg);
 638                 res = fd.evaluate(null, arguments);
 639                 assertFalse(res.isOk());
 640                 assertEquals("function:integer-intersection Expected a bag, saw a simple value", res.getStatus().getStatusMessage());
 641                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 642
 643                 // second not a bag
 644                 arguments.clear();
 645                 arguments.add(attrBagabcdefg);
 646                 arguments.add(attrBadType);
 647                 res = fd.evaluate(null, arguments);
 648                 assertFalse(res.isOk());
 649                 assertEquals("function:integer-intersection Expected a bag, saw a simple value", res.getStatus().getStatusMessage());
 650                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 651
 652
 653                 // first null
 654                 arguments.clear();
 655                 arguments.add(null);
 656                 arguments.add(attrBagabcdefg);
 657                 res = fd.evaluate(null, arguments);
 658                 assertFalse(res.isOk());
 659                 assertEquals("function:integer-intersection Got null argument", res.getStatus().getStatusMessage());
 660                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 661
 662                 // second null
 663                 arguments.clear();
 664                 arguments.add(attrBagabcdefg);
 665                 arguments.add(null);
 666                 res = fd.evaluate(null, arguments);
 667                 assertFalse(res.isOk());
 668                 assertEquals("function:integer-intersection Got null argument", res.getStatus().getStatusMessage());
 669                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 670
 671                 // too few args
 672                 arguments.clear();
 673                 arguments.add(attrBagabcdefg);
 674                 res = fd.evaluate(null, arguments);
 675                 assertFalse(res.isOk());
 676                 assertEquals("function:integer-intersection Expected 2 arguments, got 1", res.getStatus().getStatusMessage());
 677                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 678
 679                 arguments.clear();
 680                 res = fd.evaluate(null, arguments);
 681                 assertFalse(res.isOk());
 682                 assertEquals("function:integer-intersection Expected 2 arguments, got 0", res.getStatus().getStatusMessage());
 683                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 684
 685                 // too many args
 686                 arguments.clear();
 687                 arguments.add(attrBagabcdefg);
 688                 arguments.add(attrBagabcdefg);
 689                 arguments.add(attrBagabcdefg);
 690                 res = fd.evaluate(null, arguments);
 691                 assertFalse(res.isOk());
 692                 assertEquals("function:integer-intersection Expected 2 arguments, got 3", res.getStatus().getStatusMessage());
 693                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 694
 695         }
 696
 697
 698
 699
 700
 701
 702
 703
 704
 705
 706
 707
 708
 709         //
 710         // AT_LEAST_ONE_MEMBER_OF tests
 711         //
 712
 713         @Test
 714         public void testString_at_least_one_member_of() {
 715                 String a = "a";
 716                 String b = "b";
 717                 String c = "c";
 718                 String d = "d";
 719                 String e = "e";
 720                 String f = "f";
 721                 String g = "g";
 722                 String h = "h";
 723                 String j = "j";
 724
 725
 726                 Bag bagabcdefg = null;
 727                 Bag bagbdfhj = null;
 728                 Bag bagace = null;
 729                 Bag bagb = null;
 730                 Bag bagaaaccce = null;
 731                 Bag bagInt = null;
 732                 Bag bagStringInt = null;
 733                 Bag bagEmpty = null;
 734
 735                 FunctionArgumentAttributeValue attrBadType = null;
 736
 737                 try {
 738                         bagabcdefg = new Bag();
 739                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(a));
 740                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(b));
 741                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(c));
 742                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(d));
 743                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(e));
 744                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(f));
 745                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(g));
 746                         bagbdfhj = new Bag();
 747                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(b));
 748                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(d));
 749                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(f));
 750                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(h));
 751                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(j));
 752                         bagace = new Bag();
 753                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(a));
 754                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(c));
 755                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(e));
 756                         bagb = new Bag();
 757                                 bagb.add(DataTypes.DT_STRING.createAttributeValue(b));
 758                         bagaaaccce = new Bag();
 759                                 bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(a));
 760                                 bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(a));
 761                                 bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(a));
 762                                 bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(c));
 763                                 bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(c));
 764                                 bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(c));
 765                                 bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(e));
 766                         bagInt = new Bag();
 767                                 bagInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
 768                         bagStringInt = new Bag();
 769                                 bagStringInt.add(DataTypes.DT_STRING.createAttributeValue(a));
 770                                 bagStringInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
 771                         bagEmpty = new Bag();
 772
 773                         attrBadType = new FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(1.1));
 774                 } catch (Exception ex) {
 775                         fail("creating attribute e="+ ex);
 776                 }
 777
 778                 // make into attributes
 779                 FunctionArgumentBag attrBagabcdefg = new FunctionArgumentBag(bagabcdefg);
 780                 FunctionArgumentBag attrBagbdfhj = new FunctionArgumentBag(bagbdfhj);
 781                 FunctionArgumentBag attrBagace = new FunctionArgumentBag(bagace);
 782                 FunctionArgumentBag attrBagb = new FunctionArgumentBag(bagb);
 783                 FunctionArgumentBag attrBagaaaccce = new FunctionArgumentBag(bagaaaccce);
 784                 FunctionArgumentBag attrBagInt = new FunctionArgumentBag(bagInt);
 785                 FunctionArgumentBag attrBagStringInt = new FunctionArgumentBag(bagStringInt);
 786                 FunctionArgumentBag attrBagEmpty = new FunctionArgumentBag(bagEmpty);
 787
 788                 FunctionDefinitionSet<?,?> fd = (FunctionDefinitionSet<?,?>) StdFunctions.FD_STRING_AT_LEAST_ONE_MEMBER_OF;
 789
 790                 // check identity and type of the thing created
 791                 assertEquals(XACML3.ID_FUNCTION_STRING_AT_LEAST_ONE_MEMBER_OF, fd.getId());
 792                 assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
 793
 794                 // just to be safe...  If tests take too long these can probably be eliminated
 795                 assertFalse(fd.returnsBag());
 796
 797                 // normal intersection (everything in both bags, no duplicates)
 798                 arguments.clear();
 799                 arguments.add(attrBagabcdefg);
 800                 arguments.add(attrBagabcdefg);
 801                 ExpressionResult res = fd.evaluate(null, arguments);
 802                 assertTrue(res.isOk());
 803                 Boolean resValue = (Boolean)res.getValue().getValue();
 804                 assertTrue(resValue);
 805
 806
 807                 // several but not all intersection
 808                 arguments.clear();
 809                 arguments.add(attrBagabcdefg);
 810                 arguments.add(attrBagbdfhj);
 811                 res = fd.evaluate(null, arguments);
 812                 assertTrue(res.isOk());
 813                 resValue = (Boolean)res.getValue().getValue();
 814                 assertTrue(resValue);
 815
 816                 // no intersection
 817                 arguments.clear();
 818                 arguments.add(attrBagace);
 819                 arguments.add(attrBagbdfhj);
 820                 res = fd.evaluate(null, arguments);
 821                 assertTrue(res.isOk());
 822                 resValue = (Boolean)res.getValue().getValue();
 823                 assertFalse(resValue);
 824
 825                 // one intersection
 826                 arguments.clear();
 827                 arguments.add(attrBagabcdefg);
 828                 arguments.add(attrBagb);
 829                 res = fd.evaluate(null, arguments);
 830                 assertTrue(res.isOk());
 831                 resValue = (Boolean)res.getValue().getValue();
 832                 assertTrue(resValue);
 833
 834                 // bag one has duplicates that do not intersect
 835                 arguments.clear();
 836                 arguments.add(attrBagaaaccce);
 837                 arguments.add(attrBagbdfhj);
 838                 res = fd.evaluate(null, arguments);
 839                 assertTrue(res.isOk());
 840                 resValue = (Boolean)res.getValue().getValue();
 841                 assertFalse(resValue);
 842
 843                 // bag one has duplicates that do intersect
 844                 arguments.clear();
 845                 arguments.add(attrBagaaaccce);
 846                 arguments.add(attrBagace);
 847                 res = fd.evaluate(null, arguments);
 848                 assertTrue(res.isOk());
 849                 resValue = (Boolean)res.getValue().getValue();
 850                 assertTrue(resValue);
 851
 852                 // bag 2 has duplicates that do not intersect
 853                 arguments.clear();
 854                 arguments.add(attrBagbdfhj);
 855                 arguments.add(attrBagaaaccce);
 856                 res = fd.evaluate(null, arguments);
 857                 assertTrue(res.isOk());
 858                 resValue = (Boolean)res.getValue().getValue();
 859                 assertFalse(resValue);
 860
 861                 // bag 2 has duplicates that intersect
 862                 arguments.clear();
 863                 arguments.add(attrBagace);
 864                 arguments.add(attrBagaaaccce);
 865                 res = fd.evaluate(null, arguments);
 866                 assertTrue(res.isOk());
 867                 resValue = (Boolean)res.getValue().getValue();
 868                 assertTrue(resValue);
 869
 870                 // 2 empty bags
 871                 arguments.clear();
 872                 arguments.add(attrBagEmpty);
 873                 arguments.add(attrBagEmpty);
 874                 res = fd.evaluate(null, arguments);
 875                 assertTrue(res.isOk());
 876                 resValue = (Boolean)res.getValue().getValue();
 877                 assertFalse(resValue);
 878
 879                 // first non-empty, 2nd empty
 880                 arguments.clear();
 881                 arguments.add(attrBagaaaccce);
 882                 arguments.add(attrBagEmpty);
 883                 res = fd.evaluate(null, arguments);
 884                 assertTrue(res.isOk());
 885                 resValue = (Boolean)res.getValue().getValue();
 886                 assertFalse(resValue);
 887
 888                 // first empty, 2nd not empty
 889                 arguments.clear();
 890                 arguments.add(attrBagEmpty);
 891                 arguments.add(attrBagaaaccce);
 892                 res = fd.evaluate(null, arguments);
 893                 assertTrue(res.isOk());
 894                 resValue = (Boolean)res.getValue().getValue();
 895                 assertFalse(resValue);
 896
 897                 // bags of different types
 898                 arguments.clear();
 899                 arguments.add(attrBagace);
 900                 arguments.add(attrBagStringInt);
 901                 res = fd.evaluate(null, arguments);
 902                 assertTrue(res.isOk());
 903                 resValue = (Boolean)res.getValue().getValue();
 904                 assertTrue(resValue);
 905
 906                 arguments.clear();
 907                 arguments.add(attrBagace);
 908                 arguments.add(attrBagInt);
 909                 res = fd.evaluate(null, arguments);
 910                 assertTrue(res.isOk());
 911                 resValue = (Boolean)res.getValue().getValue();
 912                 assertFalse(resValue);
 913
 914                 arguments.clear();
 915                 arguments.add(attrBagace);
 916                 arguments.add(attrBagStringInt);
 917                 res = fd.evaluate(null, arguments);
 918                 assertTrue(res.isOk());
 919                 resValue = (Boolean)res.getValue().getValue();
 920                 assertTrue(resValue);
 921
 922                 // first not a bag
 923                 arguments.clear();
 924                 arguments.add(attrBadType);
 925                 arguments.add(attrBagabcdefg);
 926                 res = fd.evaluate(null, arguments);
 927                 assertFalse(res.isOk());
 928                 assertEquals("function:string-at-least-one-member-of Expected a bag, saw a simple value", res.getStatus().getStatusMessage());
 929                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 930
 931                 // second not a bag
 932                 arguments.clear();
 933                 arguments.add(attrBagabcdefg);
 934                 arguments.add(attrBadType);
 935                 res = fd.evaluate(null, arguments);
 936                 assertFalse(res.isOk());
 937                 assertEquals("function:string-at-least-one-member-of Expected a bag, saw a simple value", res.getStatus().getStatusMessage());
 938                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 939
 940
 941                 // first null
 942                 arguments.clear();
 943                 arguments.add(null);
 944                 arguments.add(attrBagabcdefg);
 945                 res = fd.evaluate(null, arguments);
 946                 assertFalse(res.isOk());
 947                 assertEquals("function:string-at-least-one-member-of Got null argument", res.getStatus().getStatusMessage());
 948                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 949
 950                 // second null
 951                 arguments.clear();
 952                 arguments.add(attrBagabcdefg);
 953                 arguments.add(null);
 954                 res = fd.evaluate(null, arguments);
 955                 assertFalse(res.isOk());
 956                 assertEquals("function:string-at-least-one-member-of Got null argument", res.getStatus().getStatusMessage());
 957                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 958
 959                 // too few args
 960                 arguments.clear();
 961                 arguments.add(attrBagabcdefg);
 962                 res = fd.evaluate(null, arguments);
 963                 assertFalse(res.isOk());
 964                 assertEquals("function:string-at-least-one-member-of Expected 2 arguments, got 1", res.getStatus().getStatusMessage());
 965                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 966
 967                 arguments.clear();
 968                 res = fd.evaluate(null, arguments);
 969                 assertFalse(res.isOk());
 970                 assertEquals("function:string-at-least-one-member-of Expected 2 arguments, got 0", res.getStatus().getStatusMessage());
 971                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 972
 973                 // too many args
 974                 arguments.clear();
 975                 arguments.add(attrBagabcdefg);
 976                 arguments.add(attrBagabcdefg);
 977                 arguments.add(attrBagabcdefg);
 978                 res = fd.evaluate(null, arguments);
 979                 assertFalse(res.isOk());
 980                 assertEquals("function:string-at-least-one-member-of Expected 2 arguments, got 3", res.getStatus().getStatusMessage());
 981                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 982
 983         }
 984
 985
 986
 987
 988
 989
 990
 991
 992
 993
 994
 995
 996
 997         //
 998         // UNION tests
 999         //
1000
1001
1002
1003
1004
1005         @Test
1006         public void testString_union() {
1007                 String a = "a";
1008                 String b = "b";
1009                 String c = "c";
1010                 String d = "d";
1011                 String e = "e";
1012                 String f = "f";
1013                 String g = "g";
1014                 String h = "h";
1015                 String j = "j";
1016
1017
1018                 Bag bagabcdefg = null;
1019                 Bag bagbdfhj = null;
1020                 Bag bagace = null;
1021                 Bag bagaaacccef = null;
1022                 Bag bagInt = null;
1023                 Bag bagStringInt = null;
1024                 Bag bagEmpty = null;
1025
1026                 FunctionArgumentAttributeValue attrBadType = null;
1027
1028                 try {
1029                         bagabcdefg = new Bag();
1030                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(a));
1031                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(b));
1032                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(c));
1033                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(d));
1034                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(e));
1035                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(f));
1036                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(g));
1037                         bagbdfhj = new Bag();
1038                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(b));
1039                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(d));
1040                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(f));
1041                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(h));
1042                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(j));
1043                         bagace = new Bag();
1044                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(a));
1045                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(c));
1046                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(e));
1047                         bagaaacccef = new Bag();
1048                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
1049                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
1050                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(a));
1051                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
1052                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
1053                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(c));
1054                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(e));
1055                                 bagaaacccef.add(DataTypes.DT_STRING.createAttributeValue(f));
1056                         bagInt = new Bag();
1057                                 bagInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
1058                         bagStringInt = new Bag();
1059                                 bagStringInt.add(DataTypes.DT_STRING.createAttributeValue(a));
1060                                 bagStringInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
1061                         bagEmpty = new Bag();
1062
1063                         attrBadType = new FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(1.1));
1064                 } catch (Exception ex) {
1065                         fail("creating attribute e="+ ex);
1066                 }
1067
1068                 // make into attributes
1069                 FunctionArgumentBag attrBagabcdefg = new FunctionArgumentBag(bagabcdefg);
1070                 FunctionArgumentBag attrBagbdfhj = new FunctionArgumentBag(bagbdfhj);
1071                 FunctionArgumentBag attrBagace = new FunctionArgumentBag(bagace);
1072                 FunctionArgumentBag attrBagaaacccef = new FunctionArgumentBag(bagaaacccef);
1073                 FunctionArgumentBag attrBagInt = new FunctionArgumentBag(bagInt);
1074                 FunctionArgumentBag attrBagStringInt = new FunctionArgumentBag(bagStringInt);
1075                 FunctionArgumentBag attrBagEmpty = new FunctionArgumentBag(bagEmpty);
1076
1077                 FunctionDefinitionSet<?,?> fd = (FunctionDefinitionSet<?,?>) StdFunctions.FD_STRING_UNION;
1078
1079                 // check identity and type of the thing created
1080                 assertEquals(XACML3.ID_FUNCTION_STRING_UNION, fd.getId());
1081                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeId());
1082
1083                 // just to be safe...  If tests take too long these can probably be eliminated
1084                 assertTrue(fd.returnsBag());
1085
1086                 // normal intersection (everything in both bags, no duplicates)
1087                 arguments.clear();
1088                 arguments.add(attrBagabcdefg);
1089                 arguments.add(attrBagabcdefg);
1090                 ExpressionResult res = fd.evaluate(null, arguments);
1091                 assertTrue(res.isOk());
1092                 Bag bag = res.getBag();
1093                 assertNotNull(bag);
1094                 Iterator<AttributeValue<?>> it = bag.getAttributeValues();
1095                 assertEquals(7, bag.size());
1096                 AttributeValue<?> attrValueObject = it.next();
1097                 assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
1098                 assertEquals(a, attrValueObject.getValue() );
1099
1100                 // several but not all union
1101                 arguments.clear();
1102                 arguments.add(attrBagace);
1103                 arguments.add(attrBagbdfhj);
1104                 res = fd.evaluate(null, arguments);
1105                 assertTrue(res.isOk());
1106                 bag = res.getBag();
1107                 assertNotNull(bag);
1108                 it = bag.getAttributeValues();
1109                 assertEquals(8, bag.size());
1110                 attrValueObject = it.next();
1111                 assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
1112                 assertEquals(a, attrValueObject.getValue() );
1113
1114                 // bag one has duplicates that do not match first bag
1115                 arguments.clear();
1116                 arguments.add(attrBagaaacccef);
1117                 arguments.add(attrBagbdfhj);
1118                 res = fd.evaluate(null, arguments);
1119                 assertTrue(res.isOk());
1120                 bag = res.getBag();
1121                 assertNotNull(bag);
1122                 it = bag.getAttributeValues();
1123                 assertEquals(8, bag.size());
1124                 attrValueObject = it.next();
1125                 assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
1126                 assertEquals(a, attrValueObject.getValue() );
1127
1128                 // bag one has duplicates that do match first bag
1129                 arguments.clear();
1130                 arguments.add(attrBagaaacccef);
1131                 arguments.add(attrBagace);
1132                 res = fd.evaluate(null, arguments);
1133                 assertTrue(res.isOk());
1134                 bag = res.getBag();
1135                 assertNotNull(bag);
1136                 it = bag.getAttributeValues();
1137                 assertEquals(4, bag.size());
1138                 attrValueObject = it.next();
1139                 assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
1140                 assertEquals(a, attrValueObject.getValue() );
1141                 attrValueObject = it.next();
1142                 assertEquals(c, attrValueObject.getValue() );
1143                 attrValueObject = it.next();
1144                 assertEquals(e, attrValueObject.getValue() );
1145
1146                 // bag 2 has duplicates that do not match first bag
1147                 arguments.clear();
1148                 arguments.add(attrBagbdfhj);
1149                 arguments.add(attrBagaaacccef);
1150                 res = fd.evaluate(null, arguments);
1151                 assertTrue(res.isOk());
1152                 bag = res.getBag();
1153                 assertNotNull(bag);
1154                 it = bag.getAttributeValues();
1155                 assertEquals(8, bag.size());
1156                 attrValueObject = it.next();
1157                 assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
1158                 assertEquals(b, attrValueObject.getValue() );
1159
1160                 // bag 2 has duplicates that do match first bag
1161                 arguments.clear();
1162                 arguments.add(attrBagace);
1163                 arguments.add(attrBagaaacccef);
1164                 res = fd.evaluate(null, arguments);
1165                 assertTrue(res.isOk());
1166                 bag = res.getBag();
1167                 assertNotNull(bag);
1168                 it = bag.getAttributeValues();
1169                 assertEquals(4, bag.size());
1170                 attrValueObject = it.next();
1171                 assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
1172                 assertEquals(a, attrValueObject.getValue() );
1173                 attrValueObject = it.next();
1174                 assertEquals(c, attrValueObject.getValue() );
1175                 attrValueObject = it.next();
1176                 assertEquals(e, attrValueObject.getValue() );
1177
1178                 // two empty bags
1179                 arguments.clear();
1180                 arguments.add(attrBagEmpty);
1181                 arguments.add(attrBagEmpty);
1182                 res = fd.evaluate(null, arguments);
1183                 assertTrue(res.isOk());
1184                 bag = res.getBag();
1185                 assertNotNull(bag);
1186                 it = bag.getAttributeValues();
1187                 assertEquals(0, bag.size());
1188
1189                 // first bag empty, 2nd not empty
1190                 arguments.clear();
1191                 arguments.add(attrBagEmpty);
1192                 arguments.add(attrBagaaacccef);
1193                 res = fd.evaluate(null, arguments);
1194                 assertTrue(res.isOk());
1195                 bag = res.getBag();
1196                 assertNotNull(bag);
1197                 it = bag.getAttributeValues();
1198                 assertEquals(4, bag.size());
1199
1200                 // first bag not empty, 2nd empty
1201                 arguments.clear();
1202                 arguments.add(attrBagaaacccef);
1203                 arguments.add(attrBagEmpty);
1204                 res = fd.evaluate(null, arguments);
1205                 assertTrue(res.isOk());
1206                 bag = res.getBag();
1207                 assertNotNull(bag);
1208                 it = bag.getAttributeValues();
1209                 assertEquals(4, bag.size());
1210
1211                 // bags of different types
1212                 arguments.clear();
1213                 arguments.add(attrBagace);
1214                 arguments.add(attrBagStringInt);
1215                 res = fd.evaluate(null, arguments);
1216                 assertTrue(res.isOk());
1217                 bag = res.getBag();
1218                 assertNotNull(bag);
1219                 it = bag.getAttributeValues();
1220                 assertEquals(4, bag.size());
1221                 attrValueObject = it.next();
1222                 assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
1223                 assertEquals(a, attrValueObject.getValue() );
1224
1225                 arguments.clear();
1226                 arguments.add(attrBagace);
1227                 arguments.add(attrBagInt);
1228                 res = fd.evaluate(null, arguments);
1229                 assertTrue(res.isOk());
1230                 bag = res.getBag();
1231                 assertNotNull(bag);
1232                 it = bag.getAttributeValues();
1233                 assertEquals(4, bag.size());
1234                 attrValueObject = it.next();
1235                 assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
1236                 assertEquals(a, attrValueObject.getValue() );
1237
1238                 // first not a bag
1239                 arguments.clear();
1240                 arguments.add(attrBadType);
1241                 arguments.add(attrBagabcdefg);
1242                 res = fd.evaluate(null, arguments);
1243                 assertFalse(res.isOk());
1244                 assertEquals("function:string-union Expected a bag, saw a simple value", res.getStatus().getStatusMessage());
1245                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1246
1247                 // second not a bag
1248                 arguments.clear();
1249                 arguments.add(attrBagabcdefg);
1250                 arguments.add(attrBadType);
1251                 res = fd.evaluate(null, arguments);
1252                 assertFalse(res.isOk());
1253                 assertEquals("function:string-union Expected a bag, saw a simple value", res.getStatus().getStatusMessage());
1254                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1255
1256
1257                 // first null
1258                 arguments.clear();
1259                 arguments.add(null);
1260                 arguments.add(attrBagabcdefg);
1261                 res = fd.evaluate(null, arguments);
1262                 assertFalse(res.isOk());
1263                 assertEquals("function:string-union Got null argument", res.getStatus().getStatusMessage());
1264                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1265
1266                 // second null
1267                 arguments.clear();
1268                 arguments.add(attrBagabcdefg);
1269                 arguments.add(null);
1270                 res = fd.evaluate(null, arguments);
1271                 assertFalse(res.isOk());
1272                 assertEquals("function:string-union Got null argument", res.getStatus().getStatusMessage());
1273                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1274
1275                 // too few args
1276                 arguments.clear();
1277                 arguments.add(attrBagabcdefg);
1278                 res = fd.evaluate(null, arguments);
1279                 assertFalse(res.isOk());
1280                 assertEquals("function:string-union Expected 2 arguments, got 1", res.getStatus().getStatusMessage());
1281                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1282
1283                 arguments.clear();
1284                 res = fd.evaluate(null, arguments);
1285                 assertFalse(res.isOk());
1286                 assertEquals("function:string-union Expected 2 arguments, got 0", res.getStatus().getStatusMessage());
1287                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1288
1289                 // too many args
1290                 arguments.clear();
1291                 arguments.add(attrBagabcdefg);
1292                 arguments.add(attrBagabcdefg);
1293                 arguments.add(attrBagabcdefg);
1294                 res = fd.evaluate(null, arguments);
1295                 assertFalse(res.isOk());
1296                 assertEquals("function:string-union Expected 2 arguments, got 3", res.getStatus().getStatusMessage());
1297                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1298
1299         }
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310         //
1311         // SUBSET tests
1312         //
1313
1314         @Test
1315         public void testString_subset() {
1316                 String a = "a";
1317                 String b = "b";
1318                 String c = "c";
1319                 String d = "d";
1320                 String e = "e";
1321                 String f = "f";
1322                 String g = "g";
1323                 String h = "h";
1324                 String j = "j";
1325
1326
1327                 Bag bagabcdefg = null;
1328                 Bag bagbdfhj = null;
1329                 Bag bagace = null;
1330                 Bag bagb = null;
1331                 Bag bagaaaccce = null;
1332                 Bag bagInt = null;
1333                 Bag bagStringInt = null;
1334                 Bag bagEmpty = null;
1335
1336                 FunctionArgumentAttributeValue attrBadType = null;
1337
1338                 try {
1339                         bagabcdefg = new Bag();
1340                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(a));
1341                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(b));
1342                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(c));
1343                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(d));
1344                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(e));
1345                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(f));
1346                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(g));
1347                         bagbdfhj = new Bag();
1348                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(b));
1349                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(d));
1350                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(f));
1351                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(h));
1352                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(j));
1353                         bagace = new Bag();
1354                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(a));
1355                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(c));
1356                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(e));
1357                         bagb = new Bag();
1358                                 bagb.add(DataTypes.DT_STRING.createAttributeValue(b));
1359                         bagaaaccce = new Bag();
1360                                 bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(a));
1361                                 bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(a));
1362                                 bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(a));
1363                                 bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(c));
1364                                 bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(c));
1365                                 bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(c));
1366                                 bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(e));
1367                         bagInt = new Bag();
1368                                 bagInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
1369                         bagStringInt = new Bag();
1370                                 bagStringInt.add(DataTypes.DT_STRING.createAttributeValue(a));
1371                                 bagStringInt.add(DataTypes.DT_STRING.createAttributeValue(b));
1372                                 bagStringInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
1373                         bagEmpty = new Bag();
1374
1375                         attrBadType = new FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(1.1));
1376                 } catch (Exception ex) {
1377                         fail("creating attribute e="+ ex);
1378                 }
1379
1380                 // make into attributes
1381                 FunctionArgumentBag attrBagabcdefg = new FunctionArgumentBag(bagabcdefg);
1382                 FunctionArgumentBag attrBagbdfhj = new FunctionArgumentBag(bagbdfhj);
1383                 FunctionArgumentBag attrBagace = new FunctionArgumentBag(bagace);
1384                 FunctionArgumentBag attrBagb = new FunctionArgumentBag(bagb);
1385                 FunctionArgumentBag attrBagaaaccce = new FunctionArgumentBag(bagaaaccce);
1386                 FunctionArgumentBag attrBagInt = new FunctionArgumentBag(bagInt);
1387                 FunctionArgumentBag attrBagStringInt = new FunctionArgumentBag(bagStringInt);
1388                 FunctionArgumentBag attrBagEmpty = new FunctionArgumentBag(bagEmpty);
1389
1390                 FunctionDefinitionSet<?,?> fd = (FunctionDefinitionSet<?,?>) StdFunctions.FD_STRING_SUBSET;
1391
1392                 // check identity and type of the thing created
1393                 assertEquals(XACML3.ID_FUNCTION_STRING_SUBSET, fd.getId());
1394                 assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
1395
1396                 // just to be safe...  If tests take too long these can probably be eliminated
1397                 assertFalse(fd.returnsBag());
1398
1399                 // normal intersection (everything in both bags, no duplicates)
1400                 arguments.clear();
1401                 arguments.add(attrBagabcdefg);
1402                 arguments.add(attrBagabcdefg);
1403                 ExpressionResult res = fd.evaluate(null, arguments);
1404                 assertTrue(res.isOk());
1405                 Boolean resValue = (Boolean)res.getValue().getValue();
1406                 assertTrue(resValue);
1407
1408
1409                 // not subset
1410                 arguments.clear();
1411                 arguments.add(attrBagabcdefg);
1412                 arguments.add(attrBagbdfhj);
1413                 res = fd.evaluate(null, arguments);
1414                 assertTrue(res.isOk());
1415                 resValue = (Boolean)res.getValue().getValue();
1416                 assertFalse(resValue);
1417
1418                 // subset
1419                 arguments.clear();
1420                 arguments.add(attrBagace);
1421                 arguments.add(attrBagabcdefg);
1422                 res = fd.evaluate(null, arguments);
1423                 assertTrue(res.isOk());
1424                 resValue = (Boolean)res.getValue().getValue();
1425                 assertTrue(resValue);
1426
1427
1428                 // no intersection
1429                 arguments.clear();
1430                 arguments.add(attrBagace);
1431                 arguments.add(attrBagbdfhj);
1432                 res = fd.evaluate(null, arguments);
1433                 assertTrue(res.isOk());
1434                 resValue = (Boolean)res.getValue().getValue();
1435                 assertFalse(resValue);
1436
1437                 // Not
1438                 arguments.clear();
1439                 arguments.add(attrBagabcdefg);
1440                 arguments.add(attrBagb);
1441                 res = fd.evaluate(null, arguments);
1442                 assertTrue(res.isOk());
1443                 resValue = (Boolean)res.getValue().getValue();
1444                 assertFalse(resValue);
1445
1446                 // Subset
1447                 arguments.clear();
1448                 arguments.add(attrBagb);
1449                 arguments.add(attrBagabcdefg);
1450                 res = fd.evaluate(null, arguments);
1451                 assertTrue(res.isOk());
1452                 resValue = (Boolean)res.getValue().getValue();
1453                 assertTrue(resValue);
1454
1455                 // bag one has duplicates that do not intersect
1456                 arguments.clear();
1457                 arguments.add(attrBagaaaccce);
1458                 arguments.add(attrBagbdfhj);
1459                 res = fd.evaluate(null, arguments);
1460                 assertTrue(res.isOk());
1461                 resValue = (Boolean)res.getValue().getValue();
1462                 assertFalse(resValue);
1463
1464                 // bag one has duplicates that do intersect
1465                 arguments.clear();
1466                 arguments.add(attrBagaaaccce);
1467                 arguments.add(attrBagace);
1468                 res = fd.evaluate(null, arguments);
1469                 assertTrue(res.isOk());
1470                 resValue = (Boolean)res.getValue().getValue();
1471                 assertTrue(resValue);
1472
1473                 // bag 2 has duplicates that do not intersect
1474                 arguments.clear();
1475                 arguments.add(attrBagbdfhj);
1476                 arguments.add(attrBagaaaccce);
1477                 res = fd.evaluate(null, arguments);
1478                 assertTrue(res.isOk());
1479                 resValue = (Boolean)res.getValue().getValue();
1480                 assertFalse(resValue);
1481
1482                 // bag 2 has duplicates that intersect
1483                 arguments.clear();
1484                 arguments.add(attrBagace);
1485                 arguments.add(attrBagaaaccce);
1486                 res = fd.evaluate(null, arguments);
1487                 assertTrue(res.isOk());
1488                 resValue = (Boolean)res.getValue().getValue();
1489                 assertTrue(resValue);
1490
1491                 // 2 empty bags
1492                 arguments.clear();
1493                 arguments.add(attrBagEmpty);
1494                 arguments.add(attrBagEmpty);
1495                 res = fd.evaluate(null, arguments);
1496                 assertTrue(res.isOk());
1497                 resValue = (Boolean)res.getValue().getValue();
1498                 assertTrue(resValue);
1499
1500                 // first non-empty, 2nd empty
1501                 arguments.clear();
1502                 arguments.add(attrBagaaaccce);
1503                 arguments.add(attrBagEmpty);
1504                 res = fd.evaluate(null, arguments);
1505                 assertTrue(res.isOk());
1506                 resValue = (Boolean)res.getValue().getValue();
1507                 assertFalse(resValue);
1508
1509                 // first empty, 2nd not empty
1510                 arguments.clear();
1511                 arguments.add(attrBagEmpty);
1512                 arguments.add(attrBagaaaccce);
1513                 res = fd.evaluate(null, arguments);
1514                 assertTrue(res.isOk());
1515                 resValue = (Boolean)res.getValue().getValue();
1516                 assertTrue(resValue);
1517
1518                 // bags of different types
1519                 arguments.clear();
1520                 arguments.add(attrBagace);
1521                 arguments.add(attrBagStringInt);
1522                 res = fd.evaluate(null, arguments);
1523                 assertTrue(res.isOk());
1524                 resValue = (Boolean)res.getValue().getValue();
1525                 assertFalse(resValue);
1526
1527                 arguments.clear();
1528                 arguments.add(attrBagb);
1529                 arguments.add(attrBagStringInt);
1530                 res = fd.evaluate(null, arguments);
1531                 assertTrue(res.isOk());
1532                 resValue = (Boolean)res.getValue().getValue();
1533                 assertTrue(resValue);
1534
1535                 arguments.clear();
1536                 arguments.add(attrBagace);
1537                 arguments.add(attrBagInt);
1538                 res = fd.evaluate(null, arguments);
1539                 assertTrue(res.isOk());
1540                 resValue = (Boolean)res.getValue().getValue();
1541                 assertFalse(resValue);
1542
1543                 // first not a bag
1544                 arguments.clear();
1545                 arguments.add(attrBadType);
1546                 arguments.add(attrBagabcdefg);
1547                 res = fd.evaluate(null, arguments);
1548                 assertFalse(res.isOk());
1549                 assertEquals("function:string-subset Expected a bag, saw a simple value", res.getStatus().getStatusMessage());
1550                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1551
1552                 // second not a bag
1553                 arguments.clear();
1554                 arguments.add(attrBagabcdefg);
1555                 arguments.add(attrBadType);
1556                 res = fd.evaluate(null, arguments);
1557                 assertFalse(res.isOk());
1558                 assertEquals("function:string-subset Expected a bag, saw a simple value", res.getStatus().getStatusMessage());
1559                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1560
1561
1562                 // first null
1563                 arguments.clear();
1564                 arguments.add(null);
1565                 arguments.add(attrBagabcdefg);
1566                 res = fd.evaluate(null, arguments);
1567                 assertFalse(res.isOk());
1568                 assertEquals("function:string-subset Got null argument", res.getStatus().getStatusMessage());
1569                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1570
1571                 // second null
1572                 arguments.clear();
1573                 arguments.add(attrBagabcdefg);
1574                 arguments.add(null);
1575                 res = fd.evaluate(null, arguments);
1576                 assertFalse(res.isOk());
1577                 assertEquals("function:string-subset Got null argument", res.getStatus().getStatusMessage());
1578                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1579
1580                 // too few args
1581                 arguments.clear();
1582                 arguments.add(attrBagabcdefg);
1583                 res = fd.evaluate(null, arguments);
1584                 assertFalse(res.isOk());
1585                 assertEquals("function:string-subset Expected 2 arguments, got 1", res.getStatus().getStatusMessage());
1586                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1587
1588                 arguments.clear();
1589                 res = fd.evaluate(null, arguments);
1590                 assertFalse(res.isOk());
1591                 assertEquals("function:string-subset Expected 2 arguments, got 0", res.getStatus().getStatusMessage());
1592                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1593
1594                 // too many args
1595                 arguments.clear();
1596                 arguments.add(attrBagabcdefg);
1597                 arguments.add(attrBagabcdefg);
1598                 arguments.add(attrBagabcdefg);
1599                 res = fd.evaluate(null, arguments);
1600                 assertFalse(res.isOk());
1601                 assertEquals("function:string-subset Expected 2 arguments, got 3", res.getStatus().getStatusMessage());
1602                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1603
1604         }
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616         //
1617         // SET_EQUALS tests
1618         //
1619
1620         @Test
1621         public void testString_set_equals() {
1622                 String a = "a";
1623                 String b = "b";
1624                 String c = "c";
1625                 String d = "d";
1626                 String e = "e";
1627                 String f = "f";
1628                 String g = "g";
1629                 String h = "h";
1630                 String j = "j";
1631
1632
1633                 Bag bagabcdefg = null;
1634                 Bag bagbdfhj = null;
1635                 Bag bagace = null;
1636                 Bag bagb = null;
1637                 Bag bagaaaccce = null;
1638                 Bag bagInt = null;
1639                 Bag bagStringInt = null;
1640                 Bag bagEmpty = null;
1641
1642                 FunctionArgumentAttributeValue attrBadType = null;
1643
1644                 try {
1645                         bagabcdefg = new Bag();
1646                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(a));
1647                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(b));
1648                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(c));
1649                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(d));
1650                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(e));
1651                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(f));
1652                                 bagabcdefg.add(DataTypes.DT_STRING.createAttributeValue(g));
1653                         bagbdfhj = new Bag();
1654                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(b));
1655                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(d));
1656                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(f));
1657                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(h));
1658                                 bagbdfhj.add(DataTypes.DT_STRING.createAttributeValue(j));
1659                         bagace = new Bag();
1660                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(a));
1661                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(c));
1662                                 bagace.add(DataTypes.DT_STRING.createAttributeValue(e));
1663                         bagb = new Bag();
1664                                 bagb.add(DataTypes.DT_STRING.createAttributeValue(b));
1665                         bagaaaccce = new Bag();
1666                                 bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(a));
1667                                 bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(a));
1668                                 bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(a));
1669                                 bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(c));
1670                                 bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(c));
1671                                 bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(c));
1672                                 bagaaaccce.add(DataTypes.DT_STRING.createAttributeValue(e));
1673                         bagInt = new Bag();
1674                                 bagInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
1675                         bagStringInt = new Bag();
1676                                 bagStringInt.add(DataTypes.DT_STRING.createAttributeValue(a));
1677                                 bagStringInt.add(DataTypes.DT_INTEGER.createAttributeValue(123));
1678                         bagEmpty = new Bag();
1679
1680                         attrBadType = new FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(1.1));
1681                 } catch (Exception ex) {
1682                         fail("creating attribute e="+ ex);
1683                 }
1684
1685                 // make into attributes
1686                 FunctionArgumentBag attrBagabcdefg = new FunctionArgumentBag(bagabcdefg);
1687                 FunctionArgumentBag attrBagbdfhj = new FunctionArgumentBag(bagbdfhj);
1688                 FunctionArgumentBag attrBagace = new FunctionArgumentBag(bagace);
1689                 FunctionArgumentBag attrBagb = new FunctionArgumentBag(bagb);
1690                 FunctionArgumentBag attrBagaaaccce = new FunctionArgumentBag(bagaaaccce);
1691                 FunctionArgumentBag attrBagInt = new FunctionArgumentBag(bagInt);
1692                 FunctionArgumentBag attrBagStringInt = new FunctionArgumentBag(bagStringInt);
1693                 FunctionArgumentBag attrBagEmpty = new FunctionArgumentBag(bagEmpty);
1694
1695                 FunctionDefinitionSet<?,?> fd = (FunctionDefinitionSet<?,?>) StdFunctions.FD_STRING_SET_EQUALS;
1696
1697                 // check identity and type of the thing created
1698                 assertEquals(XACML3.ID_FUNCTION_STRING_SET_EQUALS, fd.getId());
1699                 assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
1700
1701                 // just to be safe...  If tests take too long these can probably be eliminated
1702                 assertFalse(fd.returnsBag());
1703
1704                 // normal intersection (everything in both bags, no duplicates)
1705                 arguments.clear();
1706                 arguments.add(attrBagabcdefg);
1707                 arguments.add(attrBagabcdefg);
1708                 ExpressionResult res = fd.evaluate(null, arguments);
1709                 assertTrue(res.isOk());
1710                 Boolean resValue = (Boolean)res.getValue().getValue();
1711                 assertTrue(resValue);
1712
1713
1714                 // several but not all intersection
1715                 arguments.clear();
1716                 arguments.add(attrBagabcdefg);
1717                 arguments.add(attrBagbdfhj);
1718                 res = fd.evaluate(null, arguments);
1719                 assertTrue(res.isOk());
1720                 resValue = (Boolean)res.getValue().getValue();
1721                 assertFalse(resValue);
1722
1723                 // no intersection
1724                 arguments.clear();
1725                 arguments.add(attrBagace);
1726                 arguments.add(attrBagbdfhj);
1727                 res = fd.evaluate(null, arguments);
1728                 assertTrue(res.isOk());
1729                 resValue = (Boolean)res.getValue().getValue();
1730                 assertFalse(resValue);
1731
1732                 // one intersection
1733                 arguments.clear();
1734                 arguments.add(attrBagabcdefg);
1735                 arguments.add(attrBagb);
1736                 res = fd.evaluate(null, arguments);
1737                 assertTrue(res.isOk());
1738                 resValue = (Boolean)res.getValue().getValue();
1739                 assertFalse(resValue);
1740
1741                 // bag one has duplicates that do not intersect
1742                 arguments.clear();
1743                 arguments.add(attrBagaaaccce);
1744                 arguments.add(attrBagbdfhj);
1745                 res = fd.evaluate(null, arguments);
1746                 assertTrue(res.isOk());
1747                 resValue = (Boolean)res.getValue().getValue();
1748                 assertFalse(resValue);
1749
1750                 // bag one has duplicates that do intersect
1751                 arguments.clear();
1752                 arguments.add(attrBagaaaccce);
1753                 arguments.add(attrBagace);
1754                 res = fd.evaluate(null, arguments);
1755                 assertTrue(res.isOk());
1756                 resValue = (Boolean)res.getValue().getValue();
1757                 assertTrue(resValue);
1758
1759                 // bag 2 has duplicates that do not intersect
1760                 arguments.clear();
1761                 arguments.add(attrBagbdfhj);
1762                 arguments.add(attrBagaaaccce);
1763                 res = fd.evaluate(null, arguments);
1764                 assertTrue(res.isOk());
1765                 resValue = (Boolean)res.getValue().getValue();
1766                 assertFalse(resValue);
1767
1768                 // bag 2 has duplicates that intersect
1769                 arguments.clear();
1770                 arguments.add(attrBagace);
1771                 arguments.add(attrBagaaaccce);
1772                 res = fd.evaluate(null, arguments);
1773                 assertTrue(res.isOk());
1774                 resValue = (Boolean)res.getValue().getValue();
1775                 assertTrue(resValue);
1776
1777                 // 2 empty bags
1778                 arguments.clear();
1779                 arguments.add(attrBagEmpty);
1780                 arguments.add(attrBagEmpty);
1781                 res = fd.evaluate(null, arguments);
1782                 assertTrue(res.isOk());
1783                 resValue = (Boolean)res.getValue().getValue();
1784                 assertTrue(resValue);
1785
1786                 // first non-empty, 2nd empty
1787                 arguments.clear();
1788                 arguments.add(attrBagaaaccce);
1789                 arguments.add(attrBagEmpty);
1790                 res = fd.evaluate(null, arguments);
1791                 assertTrue(res.isOk());
1792                 resValue = (Boolean)res.getValue().getValue();
1793                 assertFalse(resValue);
1794
1795                 // first empty, 2nd not empty
1796                 arguments.clear();
1797                 arguments.add(attrBagEmpty);
1798                 arguments.add(attrBagaaaccce);
1799                 res = fd.evaluate(null, arguments);
1800                 assertTrue(res.isOk());
1801                 resValue = (Boolean)res.getValue().getValue();
1802                 assertFalse(resValue);
1803
1804                 // bags of different types
1805                 arguments.clear();
1806                 arguments.add(attrBagace);
1807                 arguments.add(attrBagStringInt);
1808                 res = fd.evaluate(null, arguments);
1809                 assertTrue(res.isOk());
1810                 resValue = (Boolean)res.getValue().getValue();
1811                 assertFalse(resValue);
1812
1813                 arguments.clear();
1814                 arguments.add(attrBagace);
1815                 arguments.add(attrBagInt);
1816                 res = fd.evaluate(null, arguments);
1817                 assertTrue(res.isOk());
1818                 resValue = (Boolean)res.getValue().getValue();
1819                 assertFalse(resValue);
1820
1821                 // first not a bag
1822                 arguments.clear();
1823                 arguments.add(attrBadType);
1824                 arguments.add(attrBagabcdefg);
1825                 res = fd.evaluate(null, arguments);
1826                 assertFalse(res.isOk());
1827                 assertEquals("function:string-set-equals Expected a bag, saw a simple value", res.getStatus().getStatusMessage());
1828                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1829
1830                 // second not a bag
1831                 arguments.clear();
1832                 arguments.add(attrBagabcdefg);
1833                 arguments.add(attrBadType);
1834                 res = fd.evaluate(null, arguments);
1835                 assertFalse(res.isOk());
1836                 assertEquals("function:string-set-equals Expected a bag, saw a simple value", res.getStatus().getStatusMessage());
1837                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1838
1839
1840                 // first null
1841                 arguments.clear();
1842                 arguments.add(null);
1843                 arguments.add(attrBagabcdefg);
1844                 res = fd.evaluate(null, arguments);
1845                 assertFalse(res.isOk());
1846                 assertEquals("function:string-set-equals Got null argument", res.getStatus().getStatusMessage());
1847                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1848
1849                 // second null
1850                 arguments.clear();
1851                 arguments.add(attrBagabcdefg);
1852                 arguments.add(null);
1853                 res = fd.evaluate(null, arguments);
1854                 assertFalse(res.isOk());
1855                 assertEquals("function:string-set-equals Got null argument", res.getStatus().getStatusMessage());
1856                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1857
1858                 // too few args
1859                 arguments.clear();
1860                 arguments.add(attrBagabcdefg);
1861                 res = fd.evaluate(null, arguments);
1862                 assertFalse(res.isOk());
1863                 assertEquals("function:string-set-equals Expected 2 arguments, got 1", res.getStatus().getStatusMessage());
1864                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1865
1866                 arguments.clear();
1867                 res = fd.evaluate(null, arguments);
1868                 assertFalse(res.isOk());
1869                 assertEquals("function:string-set-equals Expected 2 arguments, got 0", res.getStatus().getStatusMessage());
1870                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1871
1872                 // too many args
1873                 arguments.clear();
1874                 arguments.add(attrBagabcdefg);
1875                 arguments.add(attrBagabcdefg);
1876                 arguments.add(attrBagabcdefg);
1877                 res = fd.evaluate(null, arguments);
1878                 assertFalse(res.isOk());
1879                 assertEquals("function:string-set-equals Expected 2 arguments, got 3", res.getStatus().getStatusMessage());
1880                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1881
1882         }
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893         //
1894         //
1895         //  REST OF DATA TYPES OMITTED
1896         //      because they "should" all work the same
1897         //
1898         //
1899
1900
1901
1902
1903 }