ECOMP-PDP/src/test/java/org/openecomp/policy/pdp/test/FunctionDefinitionStringFunctionsTest.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.assertTrue;
  26 import static org.junit.Assert.fail;
  27
  28 import java.net.URI;
  29 import java.util.ArrayList;
  30 import java.util.List;
  31
  32 import org.junit.Test;
  33
  34 import com.att.research.xacml.api.XACML3;
  35 import com.att.research.xacml.std.datatypes.DataTypes;
  36 import com.att.research.xacmlatt.pdp.policy.ExpressionResult;
  37 import com.att.research.xacmlatt.pdp.policy.FunctionArgument;
  38 import com.att.research.xacmlatt.pdp.policy.FunctionArgumentAttributeValue;
  39 import com.att.research.xacmlatt.pdp.std.StdFunctions;
  40 import com.att.research.xacmlatt.pdp.std.functions.*;
  41
  42 /**
  43  * Test of PDP Functions (See XACML core spec section A.3)
  44  *
  45  * TO RUN - use jUnit
  46  * In Eclipse select this file or the enclosing directory, right-click and select Run As/JUnit Test
  47  *
  48  *
  49  */
  50 public class FunctionDefinitionStringFunctionsTest {
  51
  52
  53         /*
  54          * variables useful in the following tests
  55          */
  56         List<FunctionArgument> arguments = new ArrayList<FunctionArgument>();
  57
  58         ExpressionResult res;
  59
  60
  61         @Test
  62         public void testConcatenate() {
  63                 String v1 = new String("abc");
  64                 String v2 = new String("def");
  65
  66                 FunctionArgumentAttributeValue attrV1 = null;
  67                 FunctionArgumentAttributeValue attrV2 = null;
  68                 FunctionArgumentAttributeValue attrNull = null;
  69                 FunctionArgumentAttributeValue attrBlank = null;
  70                 FunctionArgumentAttributeValue attrInteger = null;
  71                 try {
  72                         attrV1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(v1));
  73                         attrV2 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(v2));
  74                         attrBlank = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(""));
  75                         attrNull = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(null));
  76                         attrInteger = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(1234));
  77                 } catch (Exception e) {
  78                         fail("creating attributes e="+ e);
  79                 }
  80
  81                 FunctionDefinitionStringFunctions<?,?> fd = (FunctionDefinitionStringFunctions<?,?>) StdFunctions.FD_STRING_CONCATENATE;
  82
  83                 // check identity and type of the thing created
  84                 assertEquals(XACML3.ID_FUNCTION_STRING_CONCATENATE, fd.getId());
  85                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeId());
  86
  87                 // just to be safe...  If tests take too long these can probably be eliminated
  88                 assertFalse(fd.returnsBag());
  89
  90
  91                 // match
  92                 arguments.clear();
  93                 arguments.add(attrV1);
  94                 arguments.add(attrV2);
  95                 res = fd.evaluate(null, arguments);
  96                 assertTrue(res.isOk());
  97                 assertEquals(java.lang.String.class, res.getValue().getValue().getClass());
  98                 String resValue = (String)res.getValue().getValue();
  99                 assertEquals(v1 + v2, resValue);
 100
 101                 // empty non-null first arg
 102                 arguments.clear();
 103                 arguments.add(attrBlank);
 104                 arguments.add(attrV2);
 105                 res = fd.evaluate(null, arguments);
 106                 assertTrue(res.isOk());
 107                 assertEquals(java.lang.String.class, res.getValue().getValue().getClass());
 108                 resValue = (String)res.getValue().getValue();
 109                 assertEquals(v2, resValue);
 110
 111                 // empty non-null second arg
 112                 arguments.clear();
 113                 arguments.add(attrV1);
 114                 arguments.add(attrBlank);
 115                 res = fd.evaluate(null, arguments);
 116                 assertTrue(res.isOk());
 117                 assertEquals(java.lang.String.class, res.getValue().getValue().getClass());
 118                 resValue = (String)res.getValue().getValue();
 119                 assertEquals(v1, resValue);
 120
 121                 // two blanks
 122                 arguments.clear();
 123                 arguments.add(attrBlank);
 124                 arguments.add(attrBlank);
 125                 res = fd.evaluate(null, arguments);
 126                 assertTrue(res.isOk());
 127                 assertEquals(java.lang.String.class, res.getValue().getValue().getClass());
 128                 resValue = (String)res.getValue().getValue();
 129                 assertEquals("", resValue);
 130
 131                 // null firat arg
 132                 arguments.clear();
 133                 arguments.add(attrNull);
 134                 arguments.add(attrBlank);
 135                 res = fd.evaluate(null, arguments);
 136                 assertFalse(res.isOk());
 137                 assertEquals("function:string-concatenate Got null attribute", res.getStatus().getStatusMessage());
 138                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 139
 140
 141                 // null second arg
 142                 arguments.clear();
 143                 arguments.add(attrV1);
 144                 arguments.add(attrNull);
 145                 res = fd.evaluate(null, arguments);
 146                 assertFalse(res.isOk());
 147                 assertEquals("function:string-concatenate Got null attribute", res.getStatus().getStatusMessage());
 148                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 149
 150                 // bad arg type
 151                 arguments.clear();
 152                 arguments.add(attrInteger);
 153                 arguments.add(attrV2);
 154                 res = fd.evaluate(null, arguments);
 155                 assertFalse(res.isOk());
 156                 assertEquals("function:string-concatenate Expected data type 'string' saw 'integer'", res.getStatus().getStatusMessage());
 157                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 158
 159                 // null second arg
 160                 arguments.clear();
 161                 arguments.add(attrV1);
 162                 arguments.add(attrNull);
 163                 res = fd.evaluate(null, arguments);
 164                 assertFalse(res.isOk());
 165                 assertEquals("function:string-concatenate Got null attribute", res.getStatus().getStatusMessage());
 166                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 167
 168         }
 169
 170
 171
 172         @Test
 173         public void testStringStartsWith() {
 174                 String v1 = new String("abc");
 175                 String bigger = new String("abc some string");
 176                 String biggerNoMatch = new String(" abc some string");
 177                 String caps = new String("AbC");
 178
 179                 FunctionArgumentAttributeValue attrV1 = null;
 180                 FunctionArgumentAttributeValue attrBigger = null;
 181                 FunctionArgumentAttributeValue attrBiggerNoMatch = null;
 182                 FunctionArgumentAttributeValue attrCaps = null;
 183                 FunctionArgumentAttributeValue attrNull = null;
 184                 FunctionArgumentAttributeValue attrBlank = null;
 185                 FunctionArgumentAttributeValue attrInteger = null;
 186                 try {
 187                         attrV1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(v1));
 188                         attrBigger = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(bigger));
 189                         attrBiggerNoMatch = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(biggerNoMatch));
 190                         attrCaps = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(caps));
 191                         attrBlank = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(""));
 192                         attrNull = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(null));
 193                         attrInteger = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(1234));
 194                 } catch (Exception e) {
 195                         fail("creating attributes e="+ e);
 196                 }
 197
 198                 FunctionDefinitionStringFunctions<?,?> fd = (FunctionDefinitionStringFunctions<?,?>) StdFunctions.FD_STRING_STARTS_WITH;
 199
 200                 // check identity and type of the thing created
 201                 assertEquals(XACML3.ID_FUNCTION_STRING_STARTS_WITH, fd.getId());
 202                 assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
 203
 204                 // just to be safe...  If tests take too long these can probably be eliminated
 205                 assertFalse(fd.returnsBag());
 206
 207
 208                 // match
 209                 arguments.clear();
 210                 arguments.add(attrV1);
 211                 arguments.add(attrBigger);
 212                 res = fd.evaluate(null, arguments);
 213                 assertTrue(res.isOk());
 214                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 215                 Boolean resValue = (Boolean)res.getValue().getValue();
 216                 assertEquals(true, resValue);
 217
 218                 // no match
 219                 arguments.clear();
 220                 arguments.add(attrV1);
 221                 arguments.add(attrBiggerNoMatch);
 222                 res = fd.evaluate(null, arguments);
 223                 assertTrue(res.isOk());
 224                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 225                 resValue = (Boolean)res.getValue().getValue();
 226                 assertEquals(false, resValue);
 227
 228                 // caps no match
 229                 arguments.clear();
 230                 arguments.add(attrCaps);
 231                 arguments.add(attrBigger);
 232                 res = fd.evaluate(null, arguments);
 233                 assertTrue(res.isOk());
 234                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 235                 resValue = (Boolean)res.getValue().getValue();
 236                 assertEquals(false, resValue);
 237
 238                 // bigger on the inside
 239                 arguments.clear();
 240                 arguments.add(attrBigger);
 241                 arguments.add(attrV1);
 242                 res = fd.evaluate(null, arguments);
 243                 assertTrue(res.isOk());
 244                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 245                 resValue = (Boolean)res.getValue().getValue();
 246                 assertEquals(false, resValue);
 247
 248                 // empty non-null first arg
 249                 arguments.clear();
 250                 arguments.add(attrBlank);
 251                 arguments.add(attrBigger);
 252                 res = fd.evaluate(null, arguments);
 253                 assertTrue(res.isOk());
 254                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 255                 resValue = (Boolean)res.getValue().getValue();
 256                 assertEquals(true, resValue);
 257
 258                 // empty non-null second arg
 259                 arguments.clear();
 260                 arguments.add(attrV1);
 261                 arguments.add(attrBlank);
 262                 res = fd.evaluate(null, arguments);
 263                 assertTrue(res.isOk());
 264                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 265                 resValue = (Boolean)res.getValue().getValue();
 266                 assertEquals(false, resValue);
 267
 268                 // two blanks
 269                 arguments.clear();
 270                 arguments.add(attrBlank);
 271                 arguments.add(attrBlank);
 272                 res = fd.evaluate(null, arguments);
 273                 assertTrue(res.isOk());
 274                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 275                 resValue = (Boolean)res.getValue().getValue();
 276                 assertEquals(true, resValue);
 277
 278                 // null firat arg
 279                 arguments.clear();
 280                 arguments.add(attrNull);
 281                 arguments.add(attrBlank);
 282                 res = fd.evaluate(null, arguments);
 283                 assertFalse(res.isOk());
 284                 assertEquals("function:string-starts-with Got null attribute", res.getStatus().getStatusMessage());
 285                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 286
 287                 // null second arg
 288                 arguments.clear();
 289                 arguments.add(attrV1);
 290                 arguments.add(attrNull);
 291                 res = fd.evaluate(null, arguments);
 292                 assertFalse(res.isOk());
 293                 assertEquals("function:string-starts-with Got null attribute", res.getStatus().getStatusMessage());
 294                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 295
 296                 // illegal arg type
 297                 arguments.clear();
 298                 arguments.add(attrInteger);
 299                 arguments.add(attrBigger);
 300                 res = fd.evaluate(null, arguments);
 301                 assertFalse(res.isOk());
 302                 assertEquals("function:string-starts-with Expected data type 'string' saw 'integer'", res.getStatus().getStatusMessage());
 303                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 304
 305         }
 306
 307
 308         @Test
 309         public void testAnyuriStartsWith() {
 310
 311
 312                 FunctionArgumentAttributeValue attrV1 = null;
 313                 FunctionArgumentAttributeValue attrBigger = null;
 314                 FunctionArgumentAttributeValue attrBiggerNoMatch = null;
 315                 FunctionArgumentAttributeValue attrCaps = null;
 316                 FunctionArgumentAttributeValue attrBigString = null;
 317                 FunctionArgumentAttributeValue attrNull = null;
 318                 FunctionArgumentAttributeValue attrBlankString = null;
 319                 FunctionArgumentAttributeValue attrBlankURI = null;
 320                 FunctionArgumentAttributeValue attrInteger = null;
 321                 try {
 322                         String v1 = new String("abc");
 323                         URI bigger = new URI("abc.some.string");
 324                         URI biggerNoMatch = new URI("Zabc.some.string");
 325                         String caps = new String("AbC");
 326                         String bigString = "thisIsSomeReallyBigStringToMatch";
 327
 328                         attrV1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(v1));
 329                         attrBigger = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(bigger));
 330                         attrBiggerNoMatch = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(biggerNoMatch));
 331                         attrCaps = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(caps));
 332                         attrBigString = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(bigString));
 333                         attrBlankString = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(""));
 334                         attrBlankURI = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(""));
 335                         attrNull = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(null));
 336                         attrInteger = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(1234));
 337                 } catch (Exception e) {
 338                         fail("creating attributes e="+ e);
 339                 }
 340
 341                 FunctionDefinitionStringFunctions<?,?> fd = (FunctionDefinitionStringFunctions<?,?>) StdFunctions.FD_ANYURI_STARTS_WITH;
 342
 343                 // check identity and type of the thing created
 344                 assertEquals(XACML3.ID_FUNCTION_ANYURI_STARTS_WITH, fd.getId());
 345                 assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
 346
 347                 // just to be safe...  If tests take too long these can probably be eliminated
 348                 assertFalse(fd.returnsBag());
 349
 350
 351                 // match
 352                 arguments.clear();
 353                 arguments.add(attrV1);
 354                 arguments.add(attrBigger);
 355                 res = fd.evaluate(null, arguments);
 356                 assertTrue(res.isOk());
 357                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 358                 Boolean resValue = (Boolean)res.getValue().getValue();
 359                 assertEquals(true, resValue);
 360
 361                 // no match
 362                 arguments.clear();
 363                 arguments.add(attrV1);
 364                 arguments.add(attrBiggerNoMatch);
 365                 res = fd.evaluate(null, arguments);
 366                 assertTrue(res.isOk());
 367                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 368                 resValue = (Boolean)res.getValue().getValue();
 369                 assertEquals(false, resValue);
 370
 371                 // caps no match
 372                 arguments.clear();
 373                 arguments.add(attrCaps);
 374                 arguments.add(attrBigger);
 375                 res = fd.evaluate(null, arguments);
 376                 assertTrue(res.isOk());
 377                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 378                 resValue = (Boolean)res.getValue().getValue();
 379                 assertEquals(false, resValue);
 380
 381                 // bigger on the inside
 382                 arguments.clear();
 383                 arguments.add(attrBigString);
 384                 arguments.add(attrBigger);
 385                 res = fd.evaluate(null, arguments);
 386                 assertTrue(res.isOk());
 387                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 388                 resValue = (Boolean)res.getValue().getValue();
 389                 assertEquals(false, resValue);
 390
 391                 // empty non-null first arg
 392                 arguments.clear();
 393                 arguments.add(attrBlankString);
 394                 arguments.add(attrBigger);
 395                 res = fd.evaluate(null, arguments);
 396                 assertTrue(res.isOk());
 397                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 398                 resValue = (Boolean)res.getValue().getValue();
 399                 assertEquals(true, resValue);
 400
 401                 // empty non-null second arg
 402                 arguments.clear();
 403                 arguments.add(attrV1);
 404                 arguments.add(attrBlankURI);
 405                 res = fd.evaluate(null, arguments);
 406                 assertTrue(res.isOk());
 407                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 408                 resValue = (Boolean)res.getValue().getValue();
 409                 assertEquals(false, resValue);
 410
 411
 412                 // two blanks
 413                 arguments.clear();
 414                 arguments.add(attrBlankString);
 415                 arguments.add(attrBlankURI);
 416                 res = fd.evaluate(null, arguments);
 417                 assertTrue(res.isOk());
 418                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 419                 resValue = (Boolean)res.getValue().getValue();
 420                 assertEquals(true, resValue);
 421
 422                 // arguments reversed
 423                 arguments.clear();
 424                 arguments.add(attrBigger);
 425                 arguments.add(attrV1);
 426                 res = fd.evaluate(null, arguments);
 427                 assertFalse(res.isOk());
 428                 assertEquals("function:anyURI-starts-with Expected data type 'string' saw 'anyURI'", res.getStatus().getStatusMessage());
 429                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 430
 431
 432                 // null firat arg
 433                 arguments.clear();
 434                 arguments.add(attrNull);
 435                 arguments.add(attrBlankURI);
 436                 res = fd.evaluate(null, arguments);
 437                 assertFalse(res.isOk());
 438                 assertEquals("function:anyURI-starts-with Got null attribute", res.getStatus().getStatusMessage());
 439                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 440
 441                 // null second arg
 442                 arguments.clear();
 443                 arguments.add(attrV1);
 444                 arguments.add(attrNull);
 445                 res = fd.evaluate(null, arguments);
 446                 assertFalse(res.isOk());
 447                 assertEquals("function:anyURI-starts-with Got null attribute", res.getStatus().getStatusMessage());
 448                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 449
 450                 // illegal arg type
 451                 arguments.clear();
 452                 arguments.add(attrInteger);
 453                 arguments.add(attrBigger);
 454                 res = fd.evaluate(null, arguments);
 455                 assertFalse(res.isOk());
 456                 assertEquals("function:anyURI-starts-with Expected data type 'string' saw 'integer'", res.getStatus().getStatusMessage());
 457                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 458
 459         }
 460
 461
 462
 463
 464         @Test
 465         public void testStringEndsWith() {
 466                 String v1 = new String("abc");
 467                 String bigger = new String("abc some string abc");
 468                 String biggerNoMatch = new String(" abc some string abc ");
 469                 String caps = new String("AbC");
 470
 471                 FunctionArgumentAttributeValue attrV1 = null;
 472                 FunctionArgumentAttributeValue attrBigger = null;
 473                 FunctionArgumentAttributeValue attrBiggerNoMatch = null;
 474                 FunctionArgumentAttributeValue attrCaps = null;
 475                 FunctionArgumentAttributeValue attrNull = null;
 476                 FunctionArgumentAttributeValue attrBlank = null;
 477                 FunctionArgumentAttributeValue attrInteger = null;
 478                 try {
 479                         attrV1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(v1));
 480                         attrBigger = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(bigger));
 481                         attrBiggerNoMatch = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(biggerNoMatch));
 482                         attrCaps = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(caps));
 483                         attrBlank = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(""));
 484                         attrNull = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(null));
 485                         attrInteger = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(1234));
 486                 } catch (Exception e) {
 487                         fail("creating attributes e="+ e);
 488                 }
 489
 490                 FunctionDefinitionStringFunctions<?,?> fd = (FunctionDefinitionStringFunctions<?,?>) StdFunctions.FD_STRING_ENDS_WITH;
 491
 492                 // check identity and type of the thing created
 493                 assertEquals(XACML3.ID_FUNCTION_STRING_ENDS_WITH, fd.getId());
 494                 assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
 495
 496                 // just to be safe...  If tests take too long these can probably be eliminated
 497                 assertFalse(fd.returnsBag());
 498
 499
 500                 // match
 501                 arguments.clear();
 502                 arguments.add(attrV1);
 503                 arguments.add(attrBigger);
 504                 res = fd.evaluate(null, arguments);
 505                 assertTrue(res.isOk());
 506                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 507                 Boolean resValue = (Boolean)res.getValue().getValue();
 508                 assertEquals(true, resValue);
 509
 510                 // no match
 511                 arguments.clear();
 512                 arguments.add(attrV1);
 513                 arguments.add(attrBiggerNoMatch);
 514                 res = fd.evaluate(null, arguments);
 515                 assertTrue(res.isOk());
 516                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 517                 resValue = (Boolean)res.getValue().getValue();
 518                 assertEquals(false, resValue);
 519
 520                 // caps no match
 521                 arguments.clear();
 522                 arguments.add(attrCaps);
 523                 arguments.add(attrBigger);
 524                 res = fd.evaluate(null, arguments);
 525                 assertTrue(res.isOk());
 526                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 527                 resValue = (Boolean)res.getValue().getValue();
 528                 assertEquals(false, resValue);
 529
 530                 // bigger on the inside
 531                 arguments.clear();
 532                 arguments.add(attrBigger);
 533                 arguments.add(attrV1);
 534                 res = fd.evaluate(null, arguments);
 535                 assertTrue(res.isOk());
 536                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 537                 resValue = (Boolean)res.getValue().getValue();
 538                 assertEquals(false, resValue);
 539
 540                 // empty non-null first arg
 541                 arguments.clear();
 542                 arguments.add(attrBlank);
 543                 arguments.add(attrBigger);
 544                 res = fd.evaluate(null, arguments);
 545                 assertTrue(res.isOk());
 546                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 547                 resValue = (Boolean)res.getValue().getValue();
 548                 assertEquals(true, resValue);
 549
 550                 // empty non-null second arg
 551                 arguments.clear();
 552                 arguments.add(attrV1);
 553                 arguments.add(attrBlank);
 554                 res = fd.evaluate(null, arguments);
 555                 assertTrue(res.isOk());
 556                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 557                 resValue = (Boolean)res.getValue().getValue();
 558                 assertEquals(false, resValue);
 559
 560                 // two blanks
 561                 arguments.clear();
 562                 arguments.add(attrBlank);
 563                 arguments.add(attrBlank);
 564                 res = fd.evaluate(null, arguments);
 565                 assertTrue(res.isOk());
 566                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 567                 resValue = (Boolean)res.getValue().getValue();
 568                 assertEquals(true, resValue);
 569
 570                 // null firat arg
 571                 arguments.clear();
 572                 arguments.add(attrNull);
 573                 arguments.add(attrBlank);
 574                 res = fd.evaluate(null, arguments);
 575                 assertFalse(res.isOk());
 576                 assertEquals("function:string-ends-with Got null attribute", res.getStatus().getStatusMessage());
 577                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 578
 579                 // null second arg
 580                 arguments.clear();
 581                 arguments.add(attrV1);
 582                 arguments.add(attrNull);
 583                 res = fd.evaluate(null, arguments);
 584                 assertFalse(res.isOk());
 585                 assertEquals("function:string-ends-with Got null attribute", res.getStatus().getStatusMessage());
 586                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 587
 588                 // illegal arg type
 589                 arguments.clear();
 590                 arguments.add(attrInteger);
 591                 arguments.add(attrBigger);
 592                 res = fd.evaluate(null, arguments);
 593                 assertFalse(res.isOk());
 594                 assertEquals("function:string-ends-with Expected data type 'string' saw 'integer'", res.getStatus().getStatusMessage());
 595                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 596
 597         }
 598
 599
 600         @Test
 601         public void testAnyuriEndsWith() {
 602
 603
 604                 FunctionArgumentAttributeValue attrV1 = null;
 605                 FunctionArgumentAttributeValue attrBigger = null;
 606                 FunctionArgumentAttributeValue attrBiggerNoMatch = null;
 607                 FunctionArgumentAttributeValue attrCaps = null;
 608                 FunctionArgumentAttributeValue attrBigString = null;
 609                 FunctionArgumentAttributeValue attrNull = null;
 610                 FunctionArgumentAttributeValue attrBlankString = null;
 611                 FunctionArgumentAttributeValue attrBlankURI = null;
 612                 FunctionArgumentAttributeValue attrInteger = null;
 613                 try {
 614                         String v1 = new String("abc");
 615                         URI bigger = new URI("abc.some.stringabc");
 616                         URI biggerNoMatch = new URI("Zabc.some.stringabcZ");
 617                         String caps = new String("AbC");
 618                         String bigString = "thisIsSomeReallyBigStringToMatch";
 619
 620                         attrV1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(v1));
 621                         attrBigger = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(bigger));
 622                         attrBiggerNoMatch = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(biggerNoMatch));
 623                         attrCaps = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(caps));
 624                         attrBigString = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(bigString));
 625                         attrBlankString = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(""));
 626                         attrBlankURI = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(""));
 627                         attrNull = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(null));
 628                         attrInteger = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(1234));
 629                 } catch (Exception e) {
 630                         fail("creating attributes e="+ e);
 631                 }
 632
 633                 FunctionDefinitionStringFunctions<?,?> fd = (FunctionDefinitionStringFunctions<?,?>) StdFunctions.FD_ANYURI_ENDS_WITH;
 634
 635                 // check identity and type of the thing created
 636                 assertEquals(XACML3.ID_FUNCTION_ANYURI_ENDS_WITH, fd.getId());
 637                 assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
 638
 639                 // just to be safe...  If tests take too long these can probably be eliminated
 640                 assertFalse(fd.returnsBag());
 641
 642
 643                 // match
 644                 arguments.clear();
 645                 arguments.add(attrV1);
 646                 arguments.add(attrBigger);
 647                 res = fd.evaluate(null, arguments);
 648                 assertTrue(res.isOk());
 649                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 650                 Boolean resValue = (Boolean)res.getValue().getValue();
 651                 assertEquals(true, resValue);
 652
 653                 // no match
 654                 arguments.clear();
 655                 arguments.add(attrV1);
 656                 arguments.add(attrBiggerNoMatch);
 657                 res = fd.evaluate(null, arguments);
 658                 assertTrue(res.isOk());
 659                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 660                 resValue = (Boolean)res.getValue().getValue();
 661                 assertEquals(false, resValue);
 662
 663                 // caps no match
 664                 arguments.clear();
 665                 arguments.add(attrCaps);
 666                 arguments.add(attrBigger);
 667                 res = fd.evaluate(null, arguments);
 668                 assertTrue(res.isOk());
 669                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 670                 resValue = (Boolean)res.getValue().getValue();
 671                 assertEquals(false, resValue);
 672
 673                 // bigger on the inside
 674                 arguments.clear();
 675                 arguments.add(attrBigString);
 676                 arguments.add(attrBigger);
 677                 res = fd.evaluate(null, arguments);
 678                 assertTrue(res.isOk());
 679                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 680                 resValue = (Boolean)res.getValue().getValue();
 681                 assertEquals(false, resValue);
 682
 683                 // empty non-null first arg
 684                 arguments.clear();
 685                 arguments.add(attrBlankString);
 686                 arguments.add(attrBigger);
 687                 res = fd.evaluate(null, arguments);
 688                 assertTrue(res.isOk());
 689                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 690                 resValue = (Boolean)res.getValue().getValue();
 691                 assertEquals(true, resValue);
 692
 693                 // empty non-null second arg
 694                 arguments.clear();
 695                 arguments.add(attrV1);
 696                 arguments.add(attrBlankURI);
 697                 res = fd.evaluate(null, arguments);
 698                 assertTrue(res.isOk());
 699                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 700                 resValue = (Boolean)res.getValue().getValue();
 701                 assertEquals(false, resValue);
 702
 703
 704                 // two blanks
 705                 arguments.clear();
 706                 arguments.add(attrBlankString);
 707                 arguments.add(attrBlankURI);
 708                 res = fd.evaluate(null, arguments);
 709                 assertTrue(res.isOk());
 710                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
 711                 resValue = (Boolean)res.getValue().getValue();
 712                 assertEquals(true, resValue);
 713
 714                 // arguments reversed
 715                 arguments.clear();
 716                 arguments.add(attrBigger);
 717                 arguments.add(attrV1);
 718                 res = fd.evaluate(null, arguments);
 719                 assertFalse(res.isOk());
 720                 assertEquals("function:anyURI-ends-with Expected data type 'string' saw 'anyURI'", res.getStatus().getStatusMessage());
 721                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 722
 723
 724                 // null firat arg
 725                 arguments.clear();
 726                 arguments.add(attrNull);
 727                 arguments.add(attrBlankURI);
 728                 res = fd.evaluate(null, arguments);
 729                 assertFalse(res.isOk());
 730                 assertEquals("function:anyURI-ends-with Got null attribute", res.getStatus().getStatusMessage());
 731                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 732
 733                 // null second arg
 734                 arguments.clear();
 735                 arguments.add(attrV1);
 736                 arguments.add(attrNull);
 737                 res = fd.evaluate(null, arguments);
 738                 assertFalse(res.isOk());
 739                 assertEquals("function:anyURI-ends-with Got null attribute", res.getStatus().getStatusMessage());
 740                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 741
 742                 // illegal arg type
 743                 arguments.clear();
 744                 arguments.add(attrInteger);
 745                 arguments.add(attrBigger);
 746                 res = fd.evaluate(null, arguments);
 747                 assertFalse(res.isOk());
 748                 assertEquals("function:anyURI-ends-with Expected data type 'string' saw 'integer'", res.getStatus().getStatusMessage());
 749                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 750
 751         }
 752
 753
 754
 755
 756         @Test
 757         public void testStringSubstring() {
 758                 String bigString = new String("abc some string abc");
 759
 760                 FunctionArgumentAttributeValue attrBigString = null;
 761                 FunctionArgumentAttributeValue attrNull = null;
 762                 FunctionArgumentAttributeValue attrBlank = null;
 763                 FunctionArgumentAttributeValue attrDouble = null;
 764
 765                 FunctionArgumentAttributeValue attrInteger0 = null;
 766                 FunctionArgumentAttributeValue attrInteger1 = null;
 767                 FunctionArgumentAttributeValue attrIntegerM1 = null;
 768                 FunctionArgumentAttributeValue attrInteger8 = null;
 769                 FunctionArgumentAttributeValue attrInteger19 = null;
 770                 FunctionArgumentAttributeValue attrInteger20 = null;
 771
 772
 773
 774                 try {
 775                         attrBigString = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(bigString));
 776                         attrBlank = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(""));
 777                         attrNull = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(null));
 778                         attrInteger0 = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(0));
 779                         attrInteger1 = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(1));
 780                         attrIntegerM1 = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(-1));
 781                         attrInteger8 = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(8));
 782                         attrInteger19 = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(19));
 783                         attrInteger20 = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(20));
 784                         attrDouble = new FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(123.4));
 785                 } catch (Exception e) {
 786                         fail("creating attributes e="+ e);
 787                 }
 788
 789                 FunctionDefinitionStringFunctions<?,?> fd = (FunctionDefinitionStringFunctions<?,?>) StdFunctions.FD_STRING_SUBSTRING;
 790
 791                 // check identity and type of the thing created
 792                 assertEquals(XACML3.ID_FUNCTION_STRING_SUBSTRING, fd.getId());
 793                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeId());
 794
 795                 // just to be safe...  If tests take too long these can probably be eliminated
 796                 assertFalse(fd.returnsBag());
 797
 798
 799                 // match
 800                 arguments.clear();
 801                 arguments.add(attrBigString);
 802                 arguments.add(attrInteger1);
 803                 arguments.add(attrInteger8);
 804                 res = fd.evaluate(null, arguments);
 805                 assertTrue(res.isOk());
 806                 assertEquals(java.lang.String.class, res.getValue().getValue().getClass());
 807                 String resValue = (String)res.getValue().getValue();
 808                 assertEquals("bc some", resValue);
 809
 810                 // edge: start
 811                 arguments.clear();
 812                 arguments.add(attrBigString);
 813                 arguments.add(attrInteger0);
 814                 arguments.add(attrInteger8);
 815                 res = fd.evaluate(null, arguments);
 816                 assertTrue(res.isOk());
 817                 assertEquals(java.lang.String.class, res.getValue().getValue().getClass());
 818                 resValue = (String)res.getValue().getValue();
 819                 assertEquals("abc some", resValue);
 820
 821                 // edge: end
 822                 arguments.clear();
 823                 arguments.add(attrBigString);
 824                 arguments.add(attrInteger8);
 825                 arguments.add(attrInteger19);
 826                 res = fd.evaluate(null, arguments);
 827                 assertTrue(res.isOk());
 828                 assertEquals(java.lang.String.class, res.getValue().getValue().getClass());
 829                 resValue = (String)res.getValue().getValue();
 830                 assertEquals(" string abc", resValue);
 831
 832                 // from index to end of string
 833                 arguments.clear();
 834                 arguments.add(attrBigString);
 835                 arguments.add(attrInteger8);
 836                 arguments.add(attrIntegerM1);
 837                 res = fd.evaluate(null, arguments);
 838                 assertTrue(res.isOk());
 839                 assertEquals(java.lang.String.class, res.getValue().getValue().getClass());
 840                 resValue = (String)res.getValue().getValue();
 841                 assertEquals(" string abc", resValue);
 842
 843                 // first index too low
 844                 arguments.clear();
 845                 arguments.add(attrBigString);
 846                 arguments.add(attrIntegerM1);
 847                 arguments.add(attrInteger8);
 848                 res = fd.evaluate(null, arguments);
 849                 assertFalse(res.isOk());
 850                 assertEquals("function:string-substring Start point '-1' out of range 0-19 for string='abc some string abc'", res.getStatus().getStatusMessage());
 851                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 852
 853
 854                 // second index too big
 855                 arguments.clear();
 856                 arguments.add(attrBigString);
 857                 arguments.add(attrInteger8);
 858                 arguments.add(attrInteger20);
 859                 res = fd.evaluate(null, arguments);
 860                 assertFalse(res.isOk());
 861                 assertEquals("function:string-substring End point '20' out of range 0-19 for string='abc some string abc'", res.getStatus().getStatusMessage());
 862                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 863
 864                 // indexes reversed
 865                 arguments.clear();
 866                 arguments.add(attrBigString);
 867                 arguments.add(attrInteger8);
 868                 arguments.add(attrInteger1);
 869                 res = fd.evaluate(null, arguments);
 870                 assertFalse(res.isOk());
 871                 assertEquals("function:string-substring End point '1' less than start point 'null' for string='abc some string abc'", res.getStatus().getStatusMessage());
 872                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 873
 874                 // indexes the same
 875                 arguments.clear();
 876                 arguments.add(attrBigString);
 877                 arguments.add(attrInteger8);
 878                 arguments.add(attrInteger8);
 879                 res = fd.evaluate(null, arguments);
 880                 assertTrue(res.isOk());
 881                 assertEquals(java.lang.String.class, res.getValue().getValue().getClass());
 882                 resValue = (String)res.getValue().getValue();
 883                 assertEquals("", resValue);
 884
 885                 // blank string with indexes both 0
 886                 arguments.clear();
 887                 arguments.add(attrBlank);
 888                 arguments.add(attrInteger0);
 889                 arguments.add(attrInteger0);
 890                 res = fd.evaluate(null, arguments);
 891                 assertTrue(res.isOk());
 892                 assertEquals(java.lang.String.class, res.getValue().getValue().getClass());
 893                 resValue = (String)res.getValue().getValue();
 894                 assertEquals("", resValue);
 895
 896                 // non-string first attribute
 897                 arguments.clear();
 898                 arguments.add(attrDouble);
 899                 arguments.add(attrInteger8);
 900                 arguments.add(attrInteger1);
 901                 res = fd.evaluate(null, arguments);
 902                 assertFalse(res.isOk());
 903                 assertEquals("function:string-substring Expected data type 'string' saw 'double'", res.getStatus().getStatusMessage());
 904                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 905
 906                 // non-integer 2nd attr
 907                 arguments.clear();
 908                 arguments.add(attrBigString);
 909                 arguments.add(attrDouble);
 910                 arguments.add(attrInteger1);
 911                 res = fd.evaluate(null, arguments);
 912                 assertFalse(res.isOk());
 913                 assertEquals("function:string-substring Expected data type 'integer' saw 'double'", res.getStatus().getStatusMessage());
 914                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 915
 916                 // non-integer 3rd attr
 917                 arguments.clear();
 918                 arguments.add(attrBigString);
 919                 arguments.add(attrInteger8);
 920                 arguments.add(attrDouble);
 921                 res = fd.evaluate(null, arguments);
 922                 assertFalse(res.isOk());
 923                 assertEquals("function:string-substring Expected data type 'integer' saw 'double'", res.getStatus().getStatusMessage());
 924                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 925
 926                 // 4 args
 927                 arguments.clear();
 928                 arguments.add(attrBigString);
 929                 arguments.add(attrInteger8);
 930                 arguments.add(attrInteger1);
 931                 arguments.add(attrInteger1);
 932                 res = fd.evaluate(null, arguments);
 933                 assertFalse(res.isOk());
 934                 assertEquals("function:string-substring Expected 3 arguments, got 4", res.getStatus().getStatusMessage());
 935                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 936
 937                 // 2 args
 938                 arguments.clear();
 939                 arguments.add(attrBigString);
 940                 arguments.add(attrInteger8);
 941                 res = fd.evaluate(null, arguments);
 942                 assertFalse(res.isOk());
 943                 assertEquals("function:string-substring Expected 3 arguments, got 2", res.getStatus().getStatusMessage());
 944                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 945
 946                 // null 1st arg
 947                 arguments.clear();
 948                 arguments.add(attrNull);
 949                 arguments.add(attrInteger8);
 950                 arguments.add(attrInteger1);
 951                 res = fd.evaluate(null, arguments);
 952                 assertFalse(res.isOk());
 953                 assertEquals("function:string-substring Got null attribute", res.getStatus().getStatusMessage());
 954                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 955
 956
 957                 // null 2nd arg
 958                 arguments.clear();
 959                 arguments.add(attrBigString);
 960                 arguments.add(attrNull);
 961                 arguments.add(attrInteger1);
 962                 res = fd.evaluate(null, arguments);
 963                 assertFalse(res.isOk());
 964                 assertEquals("function:string-substring Got null attribute", res.getStatus().getStatusMessage());
 965                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 966
 967
 968         }
 969
 970
 971
 972
 973         @Test
 974         public void testAnyURISubstring() {
 975                 String bigString = new String("http://company.com:8080/this/is/some/long/uri");
 976
 977                 FunctionArgumentAttributeValue attrURI = null;
 978                 FunctionArgumentAttributeValue attrNull = null;
 979                 FunctionArgumentAttributeValue attrBlank = null;
 980                 FunctionArgumentAttributeValue attrDouble = null;
 981
 982                 FunctionArgumentAttributeValue attrInteger0 = null;
 983                 FunctionArgumentAttributeValue attrInteger1 = null;
 984                 FunctionArgumentAttributeValue attrIntegerM1 = null;
 985                 FunctionArgumentAttributeValue attrInteger8 = null;
 986                 FunctionArgumentAttributeValue attrInteger45 = null;
 987                 FunctionArgumentAttributeValue attrInteger46 = null;
 988
 989
 990
 991                 try {
 992                         attrURI = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(bigString));
 993                         attrBlank = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(""));
 994                         attrNull = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(null));
 995                         attrInteger0 = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(0));
 996                         attrInteger1 = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(1));
 997                         attrIntegerM1 = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(-1));
 998                         attrInteger8 = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(8));
 999                         attrInteger45 = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(45));
1000                         attrInteger46 = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(46));
1001                         attrDouble = new FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(123.4));
1002                 } catch (Exception e) {
1003                         fail("creating attributes e="+ e);
1004                 }
1005
1006                 FunctionDefinitionStringFunctions<?,?> fd = (FunctionDefinitionStringFunctions<?,?>) StdFunctions.FD_ANYURI_SUBSTRING;
1007
1008                 // check identity and type of the thing created
1009                 assertEquals(XACML3.ID_FUNCTION_ANYURI_SUBSTRING, fd.getId());
1010                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeId());
1011
1012                 // just to be safe...  If tests take too long these can probably be eliminated
1013                 assertFalse(fd.returnsBag());
1014
1015
1016                 // match
1017                 arguments.clear();
1018                 arguments.add(attrURI);
1019                 arguments.add(attrInteger1);
1020                 arguments.add(attrInteger8);
1021                 res = fd.evaluate(null, arguments);
1022                 assertTrue(res.isOk());
1023                 assertEquals(java.lang.String.class, res.getValue().getValue().getClass());
1024                 String resValue = (String)res.getValue().getValue();
1025                 assertEquals("ttp://c", resValue);
1026
1027                 // edge: start
1028                 arguments.clear();
1029                 arguments.add(attrURI);
1030                 arguments.add(attrInteger0);
1031                 arguments.add(attrInteger8);
1032                 res = fd.evaluate(null, arguments);
1033                 assertTrue(res.isOk());
1034                 assertEquals(java.lang.String.class, res.getValue().getValue().getClass());
1035                 resValue = (String)res.getValue().getValue();
1036                 assertEquals("http://c", resValue);
1037
1038                 // edge: end
1039                 arguments.clear();
1040                 arguments.add(attrURI);
1041                 arguments.add(attrInteger8);
1042                 arguments.add(attrInteger45);
1043                 res = fd.evaluate(null, arguments);
1044                 assertTrue(res.isOk());
1045                 assertEquals(java.lang.String.class, res.getValue().getValue().getClass());
1046                 resValue = (String)res.getValue().getValue();
1047                 assertEquals("ompany.com:8080/this/is/some/long/uri", resValue);
1048
1049                 // from index to end of string
1050                 arguments.clear();
1051                 arguments.add(attrURI);
1052                 arguments.add(attrInteger8);
1053                 arguments.add(attrIntegerM1);
1054                 res = fd.evaluate(null, arguments);
1055                 assertTrue(res.isOk());
1056                 assertEquals(java.lang.String.class, res.getValue().getValue().getClass());
1057                 resValue = (String)res.getValue().getValue();
1058                 assertEquals("ompany.com:8080/this/is/some/long/uri", resValue);
1059
1060                 // first index too low
1061                 arguments.clear();
1062                 arguments.add(attrURI);
1063                 arguments.add(attrIntegerM1);
1064                 arguments.add(attrInteger8);
1065                 res = fd.evaluate(null, arguments);
1066                 assertFalse(res.isOk());
1067                 assertEquals("function:anyURI-substring Start point '-1' out of range 0-45 for string='http://company.com:8080/this/is/some/long/uri'", res.getStatus().getStatusMessage());
1068                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1069
1070
1071                 // second index too big
1072                 arguments.clear();
1073                 arguments.add(attrURI);
1074                 arguments.add(attrInteger8);
1075                 arguments.add(attrInteger46);
1076                 res = fd.evaluate(null, arguments);
1077                 assertFalse(res.isOk());
1078                 assertEquals("function:anyURI-substring End point '46' out of range 0-45 for string='http://company.com:8080/this/is/some/long/uri'", res.getStatus().getStatusMessage());
1079                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1080
1081                 // indexes reversed
1082                 arguments.clear();
1083                 arguments.add(attrURI);
1084                 arguments.add(attrInteger8);
1085                 arguments.add(attrInteger1);
1086                 res = fd.evaluate(null, arguments);
1087                 assertFalse(res.isOk());
1088                 assertEquals("function:anyURI-substring End point '1' less than start point 'null' for string='http://company.com:8080/this/is/some/long/uri'", res.getStatus().getStatusMessage());
1089                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1090
1091                 // indexes the same
1092                 arguments.clear();
1093                 arguments.add(attrURI);
1094                 arguments.add(attrInteger8);
1095                 arguments.add(attrInteger8);
1096                 res = fd.evaluate(null, arguments);
1097                 assertTrue(res.isOk());
1098                 assertEquals(java.lang.String.class, res.getValue().getValue().getClass());
1099                 resValue = (String)res.getValue().getValue();
1100                 assertEquals("", resValue);
1101
1102                 // blank string with indexes both 0
1103                 arguments.clear();
1104                 arguments.add(attrBlank);
1105                 arguments.add(attrInteger0);
1106                 arguments.add(attrInteger0);
1107                 res = fd.evaluate(null, arguments);
1108                 assertTrue(res.isOk());
1109                 assertEquals(java.lang.String.class, res.getValue().getValue().getClass());
1110                 resValue = (String)res.getValue().getValue();
1111                 assertEquals("", resValue);
1112
1113                 // non-string first attribute
1114                 arguments.clear();
1115                 arguments.add(attrDouble);
1116                 arguments.add(attrInteger8);
1117                 arguments.add(attrInteger1);
1118                 res = fd.evaluate(null, arguments);
1119                 assertFalse(res.isOk());
1120                 assertEquals("function:anyURI-substring Expected data type 'anyURI' saw 'double'", res.getStatus().getStatusMessage());
1121                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1122
1123                 // non-integer 2nd attr
1124                 arguments.clear();
1125                 arguments.add(attrURI);
1126                 arguments.add(attrDouble);
1127                 arguments.add(attrInteger1);
1128                 res = fd.evaluate(null, arguments);
1129                 assertFalse(res.isOk());
1130                 assertEquals("function:anyURI-substring Expected data type 'integer' saw 'double'", res.getStatus().getStatusMessage());
1131                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1132
1133                 // non-integer 3rd attr
1134                 arguments.clear();
1135                 arguments.add(attrURI);
1136                 arguments.add(attrInteger8);
1137                 arguments.add(attrDouble);
1138                 res = fd.evaluate(null, arguments);
1139                 assertFalse(res.isOk());
1140                 assertEquals("function:anyURI-substring Expected data type 'integer' saw 'double'", res.getStatus().getStatusMessage());
1141                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1142
1143                 // 4 args
1144                 arguments.clear();
1145                 arguments.add(attrURI);
1146                 arguments.add(attrInteger8);
1147                 arguments.add(attrInteger1);
1148                 arguments.add(attrInteger1);
1149                 res = fd.evaluate(null, arguments);
1150                 assertFalse(res.isOk());
1151                 assertEquals("function:anyURI-substring Expected 3 arguments, got 4", res.getStatus().getStatusMessage());
1152                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1153
1154                 // 2 args
1155                 arguments.clear();
1156                 arguments.add(attrURI);
1157                 arguments.add(attrInteger8);
1158                 res = fd.evaluate(null, arguments);
1159                 assertFalse(res.isOk());
1160                 assertEquals("function:anyURI-substring Expected 3 arguments, got 2", res.getStatus().getStatusMessage());
1161                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1162
1163                 // null 1st arg
1164                 arguments.clear();
1165                 arguments.add(attrNull);
1166                 arguments.add(attrInteger8);
1167                 arguments.add(attrInteger1);
1168                 res = fd.evaluate(null, arguments);
1169                 assertFalse(res.isOk());
1170                 assertEquals("function:anyURI-substring Got null attribute", res.getStatus().getStatusMessage());
1171                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1172
1173
1174                 // null 2nd arg
1175                 arguments.clear();
1176                 arguments.add(attrURI);
1177                 arguments.add(attrNull);
1178                 arguments.add(attrInteger1);
1179                 res = fd.evaluate(null, arguments);
1180                 assertFalse(res.isOk());
1181                 assertEquals("function:anyURI-substring Got null attribute", res.getStatus().getStatusMessage());
1182                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1183
1184         }
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206         @Test
1207         public void testStringContains() {
1208                 String v1 = new String("abc");
1209                 String bigger = new String("abc some string abc");
1210                 String biggerNoMatch = new String(" abc some string abc ");
1211                 String caps = new String("AbC");
1212
1213                 FunctionArgumentAttributeValue attrV1 = null;
1214                 FunctionArgumentAttributeValue attrBigger = null;
1215                 FunctionArgumentAttributeValue attrBiggerNoMatch = null;
1216                 FunctionArgumentAttributeValue attrCaps = null;
1217                 FunctionArgumentAttributeValue attrNull = null;
1218                 FunctionArgumentAttributeValue attrBlank = null;
1219                 FunctionArgumentAttributeValue attrInteger = null;
1220                 try {
1221                         attrV1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(v1));
1222                         attrBigger = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(bigger));
1223                         attrBiggerNoMatch = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(biggerNoMatch));
1224                         attrCaps = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(caps));
1225                         attrBlank = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(""));
1226                         attrNull = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(null));
1227                         attrInteger = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(1234));
1228                 } catch (Exception e) {
1229                         fail("creating attributes e="+ e);
1230                 }
1231
1232                 FunctionDefinitionStringFunctions<?,?> fd = (FunctionDefinitionStringFunctions<?,?>) StdFunctions.FD_STRING_CONTAINS;
1233
1234                 // check identity and type of the thing created
1235                 assertEquals(XACML3.ID_FUNCTION_STRING_CONTAINS, fd.getId());
1236                 assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
1237
1238                 // just to be safe...  If tests take too long these can probably be eliminated
1239                 assertFalse(fd.returnsBag());
1240
1241
1242                 // match
1243                 arguments.clear();
1244                 arguments.add(attrV1);
1245                 arguments.add(attrBigger);
1246                 res = fd.evaluate(null, arguments);
1247                 assertTrue(res.isOk());
1248                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
1249                 Boolean resValue = (Boolean)res.getValue().getValue();
1250                 assertEquals(true, resValue);
1251
1252                 // no match
1253                 arguments.clear();
1254                 arguments.add(attrBiggerNoMatch);
1255                 arguments.add(attrV1);
1256                 res = fd.evaluate(null, arguments);
1257                 assertTrue(res.isOk());
1258                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
1259                 resValue = (Boolean)res.getValue().getValue();
1260                 assertEquals(false, resValue);
1261
1262                 // caps no match
1263                 arguments.clear();
1264                 arguments.add(attrCaps);
1265                 arguments.add(attrBigger);
1266                 res = fd.evaluate(null, arguments);
1267                 assertTrue(res.isOk());
1268                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
1269                 resValue = (Boolean)res.getValue().getValue();
1270                 assertEquals(false, resValue);
1271
1272                 // bigger on the inside
1273                 arguments.clear();
1274                 arguments.add(attrBigger);
1275                 arguments.add(attrV1);
1276                 res = fd.evaluate(null, arguments);
1277                 assertTrue(res.isOk());
1278                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
1279                 resValue = (Boolean)res.getValue().getValue();
1280                 assertEquals(false, resValue);
1281
1282                 // empty non-null first arg
1283                 arguments.clear();
1284                 arguments.add(attrBlank);
1285                 arguments.add(attrBigger);
1286                 res = fd.evaluate(null, arguments);
1287                 assertTrue(res.isOk());
1288                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
1289                 resValue = (Boolean)res.getValue().getValue();
1290                 assertEquals(true, resValue);
1291
1292                 // empty non-null second arg
1293                 arguments.clear();
1294                 arguments.add(attrV1);
1295                 arguments.add(attrBlank);
1296                 res = fd.evaluate(null, arguments);
1297                 assertTrue(res.isOk());
1298                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
1299                 resValue = (Boolean)res.getValue().getValue();
1300                 assertEquals(false, resValue);
1301
1302                 // two blanks
1303                 arguments.clear();
1304                 arguments.add(attrBlank);
1305                 arguments.add(attrBlank);
1306                 res = fd.evaluate(null, arguments);
1307                 assertTrue(res.isOk());
1308                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
1309                 resValue = (Boolean)res.getValue().getValue();
1310                 assertEquals(true, resValue);
1311
1312                 // null firat arg
1313                 arguments.clear();
1314                 arguments.add(attrNull);
1315                 arguments.add(attrBlank);
1316                 res = fd.evaluate(null, arguments);
1317                 assertFalse(res.isOk());
1318                 assertEquals("function:string-contains Got null attribute", res.getStatus().getStatusMessage());
1319                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1320
1321                 // null second arg
1322                 arguments.clear();
1323                 arguments.add(attrV1);
1324                 arguments.add(attrNull);
1325                 res = fd.evaluate(null, arguments);
1326                 assertFalse(res.isOk());
1327                 assertEquals("function:string-contains Got null attribute", res.getStatus().getStatusMessage());
1328                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1329
1330                 // illegal arg type
1331                 arguments.clear();
1332                 arguments.add(attrInteger);
1333                 arguments.add(attrBigger);
1334                 res = fd.evaluate(null, arguments);
1335                 assertFalse(res.isOk());
1336                 assertEquals("function:string-contains Expected data type 'string' saw 'integer'", res.getStatus().getStatusMessage());
1337                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1338
1339         }
1340
1341
1342         @Test
1343         public void testAnyuriContains() {
1344
1345
1346                 FunctionArgumentAttributeValue attrV1 = null;
1347                 FunctionArgumentAttributeValue attrBigger = null;
1348                 FunctionArgumentAttributeValue attrBiggerNoMatch = null;
1349                 FunctionArgumentAttributeValue attrCaps = null;
1350                 FunctionArgumentAttributeValue attrBigString = null;
1351                 FunctionArgumentAttributeValue attrNull = null;
1352                 FunctionArgumentAttributeValue attrBlankString = null;
1353                 FunctionArgumentAttributeValue attrBlankURI = null;
1354                 FunctionArgumentAttributeValue attrInteger = null;
1355                 try {
1356                         String v1 = new String("abc");
1357                         URI bigger = new URI("abc.some.stringabc");
1358                         URI biggerNoMatch = new URI("Zabc.some.stringabcZ");
1359                         String caps = new String("AbC");
1360                         String bigString = "thisIsSomeReallyBigStringToMatch";
1361
1362                         attrV1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(v1));
1363                         attrBigger = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(bigger));
1364                         attrBiggerNoMatch = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(biggerNoMatch));
1365                         attrCaps = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(caps));
1366                         attrBigString = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(bigString));
1367                         attrBlankString = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(""));
1368                         attrBlankURI = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(""));
1369                         attrNull = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(null));
1370                         attrInteger = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(1234));
1371                 } catch (Exception e) {
1372                         fail("creating attributes e="+ e);
1373                 }
1374
1375                 FunctionDefinitionStringFunctions<?,?> fd = (FunctionDefinitionStringFunctions<?,?>) StdFunctions.FD_ANYURI_CONTAINS;
1376
1377                 // check identity and type of the thing created
1378                 assertEquals(XACML3.ID_FUNCTION_ANYURI_CONTAINS, fd.getId());
1379                 assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
1380
1381                 // just to be safe...  If tests take too long these can probably be eliminated
1382                 assertFalse(fd.returnsBag());
1383
1384
1385                 // match
1386                 arguments.clear();
1387                 arguments.add(attrV1);
1388                 arguments.add(attrBigger);
1389                 res = fd.evaluate(null, arguments);
1390                 assertTrue(res.isOk());
1391                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
1392                 Boolean resValue = (Boolean)res.getValue().getValue();
1393                 assertEquals(true, resValue);
1394
1395                 // no match
1396                 arguments.clear();
1397                 arguments.add(attrBigString);
1398                 arguments.add(attrBiggerNoMatch);
1399                 res = fd.evaluate(null, arguments);
1400                 assertTrue(res.isOk());
1401                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
1402                 resValue = (Boolean)res.getValue().getValue();
1403                 assertEquals(false, resValue);
1404
1405                 // caps no match
1406                 arguments.clear();
1407                 arguments.add(attrCaps);
1408                 arguments.add(attrBigger);
1409                 res = fd.evaluate(null, arguments);
1410                 assertTrue(res.isOk());
1411                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
1412                 resValue = (Boolean)res.getValue().getValue();
1413                 assertEquals(false, resValue);
1414
1415                 // bigger on the inside
1416                 arguments.clear();
1417                 arguments.add(attrBigString);
1418                 arguments.add(attrBigger);
1419                 res = fd.evaluate(null, arguments);
1420                 assertTrue(res.isOk());
1421                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
1422                 resValue = (Boolean)res.getValue().getValue();
1423                 assertEquals(false, resValue);
1424
1425                 // empty non-null first arg
1426                 arguments.clear();
1427                 arguments.add(attrBlankString);
1428                 arguments.add(attrBigger);
1429                 res = fd.evaluate(null, arguments);
1430                 assertTrue(res.isOk());
1431                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
1432                 resValue = (Boolean)res.getValue().getValue();
1433                 assertEquals(true, resValue);
1434
1435                 // empty non-null second arg
1436                 arguments.clear();
1437                 arguments.add(attrV1);
1438                 arguments.add(attrBlankURI);
1439                 res = fd.evaluate(null, arguments);
1440                 assertTrue(res.isOk());
1441                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
1442                 resValue = (Boolean)res.getValue().getValue();
1443                 assertEquals(false, resValue);
1444
1445
1446                 // two blanks
1447                 arguments.clear();
1448                 arguments.add(attrBlankString);
1449                 arguments.add(attrBlankURI);
1450                 res = fd.evaluate(null, arguments);
1451                 assertTrue(res.isOk());
1452                 assertEquals(java.lang.Boolean.class, res.getValue().getValue().getClass());
1453                 resValue = (Boolean)res.getValue().getValue();
1454                 assertEquals(true, resValue);
1455
1456                 // arguments reversed
1457                 arguments.clear();
1458                 arguments.add(attrBigger);
1459                 arguments.add(attrV1);
1460                 res = fd.evaluate(null, arguments);
1461                 assertFalse(res.isOk());
1462                 assertEquals("function:anyURI-contains Expected data type 'string' saw 'anyURI'", res.getStatus().getStatusMessage());
1463                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1464
1465
1466                 // null firat arg
1467                 arguments.clear();
1468                 arguments.add(attrNull);
1469                 arguments.add(attrBlankURI);
1470                 res = fd.evaluate(null, arguments);
1471                 assertFalse(res.isOk());
1472                 assertEquals("function:anyURI-contains Got null attribute", res.getStatus().getStatusMessage());
1473                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1474
1475                 // null second arg
1476                 arguments.clear();
1477                 arguments.add(attrV1);
1478                 arguments.add(attrNull);
1479                 res = fd.evaluate(null, arguments);
1480                 assertFalse(res.isOk());
1481                 assertEquals("function:anyURI-contains Got null attribute", res.getStatus().getStatusMessage());
1482                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1483
1484                 // illegal arg type
1485                 arguments.clear();
1486                 arguments.add(attrInteger);
1487                 arguments.add(attrBigger);
1488                 res = fd.evaluate(null, arguments);
1489                 assertFalse(res.isOk());
1490                 assertEquals("function:anyURI-contains Expected data type 'string' saw 'integer'", res.getStatus().getStatusMessage());
1491                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1492
1493         }
1494
1495
1496
1497 }