ECOMP-PDP/src/test/java/org/openecomp/policy/pdp/test/FunctionDefinitionStringConversionTest.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.assertNotEquals;
  26 import static org.junit.Assert.assertTrue;
  27 import static org.junit.Assert.fail;
  28
  29 import java.math.BigInteger;
  30 import java.net.URI;
  31 import java.net.URISyntaxException;
  32 import java.text.ParseException;
  33 import java.util.ArrayList;
  34 import java.util.List;
  35
  36 import javax.security.auth.x500.X500Principal;
  37
  38 import org.junit.Test;
  39
  40 import com.att.research.xacml.api.XACML3;
  41 import com.att.research.xacml.std.datatypes.DataTypes;
  42 import com.att.research.xacml.std.datatypes.IPAddress;
  43 import com.att.research.xacml.std.datatypes.IPv4Address;
  44 import com.att.research.xacml.std.datatypes.IPv6Address;
  45 import com.att.research.xacml.std.datatypes.ISO8601Date;
  46 import com.att.research.xacml.std.datatypes.ISO8601DateTime;
  47 import com.att.research.xacml.std.datatypes.ISO8601Time;
  48 import com.att.research.xacml.std.datatypes.ISO8601TimeZone;
  49 import com.att.research.xacml.std.datatypes.PortRange;
  50 import com.att.research.xacml.std.datatypes.RFC2396DomainName;
  51 import com.att.research.xacml.std.datatypes.RFC822Name;
  52 import com.att.research.xacml.std.datatypes.XPathDayTimeDuration;
  53 import com.att.research.xacml.std.datatypes.XPathYearMonthDuration;
  54 import com.att.research.xacmlatt.pdp.policy.ExpressionResult;
  55 import com.att.research.xacmlatt.pdp.policy.FunctionArgument;
  56 import com.att.research.xacmlatt.pdp.policy.FunctionArgumentAttributeValue;
  57 import com.att.research.xacmlatt.pdp.std.StdFunctions;
  58 import com.att.research.xacmlatt.pdp.std.functions.*;
  59
  60 /**
  61  * Tests for converting objects to/from Strings.
  62  *
  63  * TO RUN - use jUnit
  64  * In Eclipse select this file or the enclosing directory, right-click and select Run As/JUnit Test
  65  *
  66  *
  67  */
  68 public class FunctionDefinitionStringConversionTest {
  69
  70         /*
  71          * variables useful in the following tests
  72          */
  73         List<FunctionArgument> arguments = new ArrayList<>();
  74
  75
  76         /**
  77          * Boolean
  78          */
  79         @Test
  80         public void testBoolean_from_string() {
  81                 FunctionArgumentAttributeValue attrString1 = null;
  82                 FunctionArgumentAttributeValue attrStringBadValue = null;
  83                 FunctionArgumentAttributeValue attrStringBadType = null;
  84                 try {
  85                         attrString1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("true"));
  86                         attrStringBadValue = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("not valid obj value"));
  87                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
  88
  89                 } catch (Exception e) {
  90                         fail("creating attribute e="+ e);
  91                 }
  92
  93                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_BOOLEAN_FROM_STRING;
  94
  95                 // check identity and type of the thing created
  96                 assertEquals(XACML3.ID_FUNCTION_BOOLEAN_FROM_STRING, fd.getId());
  97                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeArgs().getId());
  98                 assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
  99
 100                 // just to be safe...  If tests take too long these can probably be eliminated
 101                 assertFalse(fd.returnsBag());
 102                 assertEquals(new Integer(1), fd.getNumArgs());
 103
 104                 // test normal
 105                 arguments.clear();
 106                 arguments.add(attrString1);
 107                 ExpressionResult res = fd.evaluate(null, arguments);
 108                 assertTrue(res.isOk());
 109                 Boolean resValue = (Boolean)res.getValue().getValue();
 110                 assertEquals(new Boolean(true), resValue);
 111
 112                 // bad value
 113                 arguments.clear();
 114                 arguments.add(attrStringBadValue);
 115                 res = fd.evaluate(null, arguments);
 116                 assertFalse(res.isOk());
 117                 assertEquals("function:boolean-from-string Cannot convert from \"java.lang.String\" with value \"not valid obj value\" to boolean", res.getStatus().getStatusMessage());
 118                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 119
 120                 // bad arg type
 121                 arguments.clear();
 122                 arguments.add(attrStringBadType);
 123                 res = fd.evaluate(null, arguments);
 124                 assertFalse(res.isOk());
 125                 assertEquals("function:boolean-from-string Expected data type 'string' saw 'integer' at arg index 0", res.getStatus().getStatusMessage());
 126                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 127         }
 128
 129         @Test
 130         public void testString_from_boolean() {
 131                 FunctionArgumentAttributeValue attrObj1 = null;
 132                 FunctionArgumentAttributeValue attrStringBadType = null;
 133                 String objValueString = "false";
 134                 try {
 135                         attrObj1 = new FunctionArgumentAttributeValue(DataTypes.DT_BOOLEAN.createAttributeValue(objValueString));
 136                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
 137
 138                 } catch (Exception e) {
 139                         fail("creating attribute e="+ e);
 140                 }
 141
 142                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_STRING_FROM_BOOLEAN;
 143
 144                 // check identity and type of the thing created
 145                 assertEquals(XACML3.ID_FUNCTION_STRING_FROM_BOOLEAN, fd.getId());
 146                 assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeArgs().getId());
 147                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeId());
 148
 149                 // just to be safe...  If tests take too long these can probably be eliminated
 150                 assertFalse(fd.returnsBag());
 151                 assertEquals(new Integer(1), fd.getNumArgs());
 152
 153                 // test normal
 154                 arguments.clear();
 155                 arguments.add(attrObj1);
 156                 ExpressionResult res = fd.evaluate(null, arguments);
 157                 assertTrue(res.isOk());
 158                 assertEquals(objValueString, res.getValue().getValue());
 159
 160                 // bad arg type
 161                 arguments.clear();
 162                 arguments.add(attrStringBadType);
 163                 res = fd.evaluate(null, arguments);
 164                 assertFalse(res.isOk());
 165                 assertEquals("function:string-from-boolean Expected data type 'boolean' saw 'integer' at arg index 0", 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         /**
 173          * Integer
 174          */
 175         @Test
 176         public void testInteger_from_string() {
 177                 FunctionArgumentAttributeValue attrString1 = null;
 178                 FunctionArgumentAttributeValue attrStringBadValue = null;
 179                 FunctionArgumentAttributeValue attrStringBadType = null;
 180                 try {
 181                         attrString1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("123456"));
 182                         attrStringBadValue = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("not valid obj value"));
 183                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
 184
 185                 } catch (Exception e) {
 186                         fail("creating attribute e="+ e);
 187                 }
 188
 189                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_INTEGER_FROM_STRING;
 190
 191                 // check identity and type of the thing created
 192                 assertEquals(XACML3.ID_FUNCTION_INTEGER_FROM_STRING, fd.getId());
 193                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeArgs().getId());
 194                 assertEquals(DataTypes.DT_INTEGER.getId(), fd.getDataTypeId());
 195
 196                 // just to be safe...  If tests take too long these can probably be eliminated
 197                 assertFalse(fd.returnsBag());
 198                 assertEquals(new Integer(1), fd.getNumArgs());
 199
 200                 // test normal
 201                 arguments.clear();
 202                 arguments.add(attrString1);
 203                 ExpressionResult res = fd.evaluate(null, arguments);
 204                 assertTrue(res.isOk());
 205                 BigInteger resValue = (BigInteger)res.getValue().getValue();
 206                 assertEquals(new BigInteger("123456"), resValue);
 207
 208                 // bad value
 209                 arguments.clear();
 210                 arguments.add(attrStringBadValue);
 211                 res = fd.evaluate(null, arguments);
 212                 assertFalse(res.isOk());
 213                 assertEquals("function:integer-from-string For input string: \"n\"", res.getStatus().getStatusMessage());
 214                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 215
 216                 // bad arg type
 217                 arguments.clear();
 218                 arguments.add(attrStringBadType);
 219                 res = fd.evaluate(null, arguments);
 220                 assertFalse(res.isOk());
 221                 assertEquals("function:integer-from-string Expected data type 'string' saw 'integer' at arg index 0", res.getStatus().getStatusMessage());
 222                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 223         }
 224
 225         @Test
 226         public void testString_from_integer() {
 227                 FunctionArgumentAttributeValue attrObj1 = null;
 228                 FunctionArgumentAttributeValue attrStringBadType = null;
 229                 String objValueString = "1234";
 230                 try {
 231                         attrObj1 = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(objValueString));
 232                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(123));
 233
 234                 } catch (Exception e) {
 235                         fail("creating attribute e="+ e);
 236                 }
 237
 238                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_STRING_FROM_INTEGER;
 239
 240                 // check identity and type of the thing created
 241                 assertEquals(XACML3.ID_FUNCTION_STRING_FROM_INTEGER, fd.getId());
 242                 assertEquals(DataTypes.DT_INTEGER.getId(), fd.getDataTypeArgs().getId());
 243                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeId());
 244
 245                 // just to be safe...  If tests take too long these can probably be eliminated
 246                 assertFalse(fd.returnsBag());
 247                 assertEquals(new Integer(1), fd.getNumArgs());
 248
 249                 // test normal
 250                 arguments.clear();
 251                 arguments.add(attrObj1);
 252                 ExpressionResult res = fd.evaluate(null, arguments);
 253                 assertTrue(res.isOk());
 254                 assertEquals(objValueString, res.getValue().getValue());
 255
 256                 // bad arg type
 257                 arguments.clear();
 258                 arguments.add(attrStringBadType);
 259                 res = fd.evaluate(null, arguments);
 260                 assertFalse(res.isOk());
 261                 assertEquals("function:string-from-integer Expected data type 'integer' saw 'double' at arg index 0", res.getStatus().getStatusMessage());
 262                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 263         }
 264
 265
 266
 267         /**
 268          * Double
 269          */
 270         @Test
 271         public void testDouble_from_string() {
 272                 FunctionArgumentAttributeValue attrString1 = null;
 273                 FunctionArgumentAttributeValue attrStringBadValue = null;
 274                 FunctionArgumentAttributeValue attrStringBadType = null;
 275                 try {
 276                         attrString1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("5.432"));
 277                         attrStringBadValue = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("not valid obj value"));
 278                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
 279
 280                 } catch (Exception e) {
 281                         fail("creating attribute e="+ e);
 282                 }
 283
 284                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_DOUBLE_FROM_STRING;
 285
 286                 // check identity and type of the thing created
 287                 assertEquals(XACML3.ID_FUNCTION_DOUBLE_FROM_STRING, fd.getId());
 288                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeArgs().getId());
 289                 assertEquals(DataTypes.DT_DOUBLE.getId(), fd.getDataTypeId());
 290
 291                 // just to be safe...  If tests take too long these can probably be eliminated
 292                 assertFalse(fd.returnsBag());
 293                 assertEquals(new Integer(1), fd.getNumArgs());
 294
 295                 // test normal
 296                 arguments.clear();
 297                 arguments.add(attrString1);
 298                 ExpressionResult res = fd.evaluate(null, arguments);
 299                 assertTrue(res.isOk());
 300                 Double resValue = (Double)res.getValue().getValue();
 301                 assertEquals(new Double(5.432), resValue);
 302
 303                 // bad value
 304                 arguments.clear();
 305                 arguments.add(attrStringBadValue);
 306                 res = fd.evaluate(null, arguments);
 307                 assertFalse(res.isOk());
 308                 assertEquals("function:double-from-string For input string: \"not valid obj value\"", res.getStatus().getStatusMessage());
 309                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 310
 311                 // bad arg type
 312                 arguments.clear();
 313                 arguments.add(attrStringBadType);
 314                 res = fd.evaluate(null, arguments);
 315                 assertFalse(res.isOk());
 316                 assertEquals("function:double-from-string Expected data type 'string' saw 'integer' at arg index 0", res.getStatus().getStatusMessage());
 317                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 318         }
 319
 320         @Test
 321         public void testString_from_double() {
 322                 FunctionArgumentAttributeValue attrObj1 = null;
 323                 FunctionArgumentAttributeValue attrObjBig = null;
 324                 FunctionArgumentAttributeValue attrStringBadType = null;
 325                 String objValueString = "5.432";
 326                 String objValueStringBig = "55555555555555555555.123455";
 327                 try {
 328                         attrObj1 = new FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(objValueString));
 329                         attrObjBig = new FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(objValueStringBig));
 330                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
 331
 332                 } catch (Exception e) {
 333                         fail("creating attribute e="+ e);
 334                 }
 335
 336                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_STRING_FROM_DOUBLE;
 337
 338                 // check identity and type of the thing created
 339                 assertEquals(XACML3.ID_FUNCTION_STRING_FROM_DOUBLE, fd.getId());
 340                 assertEquals(DataTypes.DT_DOUBLE.getId(), fd.getDataTypeArgs().getId());
 341                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeId());
 342
 343                 // just to be safe...  If tests take too long these can probably be eliminated
 344                 assertFalse(fd.returnsBag());
 345                 assertEquals(new Integer(1), fd.getNumArgs());
 346
 347                 // test normal
 348                 arguments.clear();
 349                 arguments.add(attrObj1);
 350                 ExpressionResult res = fd.evaluate(null, arguments);
 351                 assertTrue(res.isOk());
 352                 assertEquals(objValueString, res.getValue().getValue());
 353
 354                 arguments.clear();
 355                 arguments.add(attrObjBig);
 356                 res = fd.evaluate(null, arguments);
 357                 assertTrue(res.isOk());
 358                 assertEquals("5.555555555555556E19", res.getValue().getValue());
 359
 360
 361                 // bad arg type
 362                 arguments.clear();
 363                 arguments.add(attrStringBadType);
 364                 res = fd.evaluate(null, arguments);
 365                 assertFalse(res.isOk());
 366                 assertEquals("function:string-from-double Expected data type 'double' saw 'integer' at arg index 0", res.getStatus().getStatusMessage());
 367                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 368         }
 369
 370
 371
 372
 373
 374         /**
 375          * Time
 376          */
 377         @Test
 378         public void testTime_from_string() {
 379                 FunctionArgumentAttributeValue attrString1 = null;
 380                 FunctionArgumentAttributeValue attrString2 = null;
 381                 FunctionArgumentAttributeValue attrString3 = null;
 382                 FunctionArgumentAttributeValue attrString4 = null;
 383                 FunctionArgumentAttributeValue attrStringTimeZone = null;
 384                 FunctionArgumentAttributeValue attrStringBadValue = null;
 385                 FunctionArgumentAttributeValue attrStringBadType = null;
 386                 try {
 387                         attrString1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("05:12:34.323"));
 388                         attrString2 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("5:12:34.323"));
 389                         attrString3 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("05:12"));
 390                         attrString4 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("05:12:34"));
 391                         attrStringTimeZone = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("05:12:34.323+03:00"));
 392                         attrStringBadValue = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("not valid obj value"));
 393                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
 394
 395                 } catch (Exception e) {
 396                         fail("creating attribute e="+ e);
 397                 }
 398
 399                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_TIME_FROM_STRING;
 400
 401                 // check identity and type of the thing created
 402                 assertEquals(XACML3.ID_FUNCTION_TIME_FROM_STRING, fd.getId());
 403                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeArgs().getId());
 404                 assertEquals(DataTypes.DT_TIME.getId(), fd.getDataTypeId());
 405
 406                 // just to be safe...  If tests take too long these can probably be eliminated
 407                 assertFalse(fd.returnsBag());
 408                 assertEquals(new Integer(1), fd.getNumArgs());
 409
 410                 // test normal
 411                 arguments.clear();
 412                 arguments.add(attrString1);
 413                 ExpressionResult res = fd.evaluate(null, arguments);
 414                 assertTrue(res.isOk());
 415                 ISO8601Time resValue = (ISO8601Time)res.getValue().getValue();
 416                 assertEquals(new ISO8601Time(5, 12, 34, 323), resValue);
 417
 418                 // check missing 0 in front
 419                 arguments.clear();
 420                 arguments.add(attrString2);
 421                 res = fd.evaluate(null, arguments);
 422                 assertFalse(res.isOk());
 423                 assertEquals("function:time-from-string Invalid hour of day", res.getStatus().getStatusMessage());
 424                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 425
 426                 // check missing seconds/msecs
 427                 arguments.clear();
 428                 arguments.add(attrString3);
 429                 res = fd.evaluate(null, arguments);
 430                 assertFalse(res.isOk());
 431                 assertEquals("function:time-from-string Time string too short", res.getStatus().getStatusMessage());
 432                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 433
 434                 // check missing just msecs
 435                 arguments.clear();
 436                 arguments.add(attrString4);
 437                 res = fd.evaluate(null, arguments);
 438                 assertTrue(res.isOk());
 439                 resValue = (ISO8601Time)res.getValue().getValue();
 440                 assertEquals(new ISO8601Time(5, 12, 34, 0), resValue);
 441
 442                 // check TimeZone
 443                 arguments.clear();
 444                 arguments.add(attrStringTimeZone);
 445                 res = fd.evaluate(null, arguments);
 446                 assertTrue(res.isOk());
 447                 resValue = (ISO8601Time)res.getValue().getValue();
 448                 assertEquals(new ISO8601Time(new ISO8601TimeZone(180), 5, 12, 34, 323), resValue);
 449
 450                 // bad value
 451                 arguments.clear();
 452                 arguments.add(attrStringBadValue);
 453                 res = fd.evaluate(null, arguments);
 454                 assertFalse(res.isOk());
 455                 assertEquals("function:time-from-string Invalid hour of day", res.getStatus().getStatusMessage());
 456                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 457
 458                 // bad arg type
 459                 arguments.clear();
 460                 arguments.add(attrStringBadType);
 461                 res = fd.evaluate(null, arguments);
 462                 assertFalse(res.isOk());
 463                 assertEquals("function:time-from-string Expected data type 'string' saw 'integer' at arg index 0", res.getStatus().getStatusMessage());
 464                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 465         }
 466
 467         @Test
 468         public void testString_from_time() {
 469                 FunctionArgumentAttributeValue attrObj1 = null;
 470                 FunctionArgumentAttributeValue attrObj2 = null;
 471                 FunctionArgumentAttributeValue attrObjTimeZone = null;
 472                 FunctionArgumentAttributeValue attrStringBadType = null;
 473                 try {
 474                         attrObj1 = new FunctionArgumentAttributeValue(DataTypes.DT_TIME.createAttributeValue("05:12:34.323"));
 475                         attrObj2 = new FunctionArgumentAttributeValue(DataTypes.DT_TIME.createAttributeValue("05:01:02.323"));
 476                         attrObjTimeZone = new FunctionArgumentAttributeValue(DataTypes.DT_TIME.createAttributeValue("05:12:34.323+03:00"));
 477                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
 478
 479                 } catch (Exception e) {
 480                         fail("creating attribute e="+ e);
 481                 }
 482
 483                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_STRING_FROM_TIME;
 484
 485                 // check identity and type of the thing created
 486                 assertEquals(XACML3.ID_FUNCTION_STRING_FROM_TIME, fd.getId());
 487                 assertEquals(DataTypes.DT_TIME.getId(), fd.getDataTypeArgs().getId());
 488                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeId());
 489
 490                 // just to be safe...  If tests take too long these can probably be eliminated
 491                 assertFalse(fd.returnsBag());
 492                 assertEquals(new Integer(1), fd.getNumArgs());
 493
 494                 // test normal
 495                 arguments.clear();
 496                 arguments.add(attrObj1);
 497                 ExpressionResult res = fd.evaluate(null, arguments);
 498                 assertTrue(res.isOk());
 499                 assertEquals("05:12:34.323", res.getValue().getValue());
 500
 501                 // missing digits in string value?
 502                 arguments.clear();
 503                 arguments.add(attrObj2);
 504                 res = fd.evaluate(null, arguments);
 505                 assertTrue(res.isOk());
 506                 assertEquals("05:01:02.323", res.getValue().getValue());
 507
 508                 // include TimeZone
 509                 arguments.clear();
 510                 arguments.add(attrObjTimeZone);
 511                 res = fd.evaluate(null, arguments);
 512                 assertTrue(res.isOk());
 513                 assertEquals("05:12:34.323+03:00", res.getValue().getValue());
 514
 515                 // bad arg type
 516                 arguments.clear();
 517                 arguments.add(attrStringBadType);
 518                 res = fd.evaluate(null, arguments);
 519                 assertFalse(res.isOk());
 520                 assertEquals("function:string-from-time Expected data type 'time' saw 'integer' at arg index 0", res.getStatus().getStatusMessage());
 521                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 522         }
 523
 524
 525
 526
 527
 528         /**
 529          * Date
 530          */
 531         @Test
 532         public void testDate_from_string() {
 533                 FunctionArgumentAttributeValue attrString1 = null;
 534                 FunctionArgumentAttributeValue attrString2 = null;
 535                 FunctionArgumentAttributeValue attrString3 = null;
 536                 FunctionArgumentAttributeValue attrString4 = null;
 537                 FunctionArgumentAttributeValue attrString5 = null;
 538                 FunctionArgumentAttributeValue attrString6 = null;
 539                 FunctionArgumentAttributeValue attrString7 = null;
 540                 FunctionArgumentAttributeValue attrString8 = null;
 541                 FunctionArgumentAttributeValue attrString9 = null;
 542                 FunctionArgumentAttributeValue attrStringDateZone = null;
 543                 FunctionArgumentAttributeValue attrStringBadValue = null;
 544                 FunctionArgumentAttributeValue attrStringBadType = null;
 545                 try {
 546                         attrString1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("2013-05-12"));
 547                         attrString2 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("-2013-05-12"));
 548                         attrString3 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("1232013-05-12"));
 549                         attrString4 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("-1232013-05-12"));
 550                         attrString5 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("213-05-12"));
 551                         attrString6 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("2013-5-12"));
 552                         attrString7 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("2013-05-2"));
 553                         attrString8 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("2013-32-12"));
 554                         attrString9 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("2013-05-45"));
 555                         attrStringDateZone = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("2013-05-12+03:00"));
 556                         attrStringBadValue = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("not valid obj value"));
 557                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
 558
 559                 } catch (Exception e) {
 560                         fail("creating attribute e="+ e);
 561                 }
 562
 563                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_DATE_FROM_STRING;
 564
 565                 // check identity and type of the thing created
 566                 assertEquals(XACML3.ID_FUNCTION_DATE_FROM_STRING, fd.getId());
 567                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeArgs().getId());
 568                 assertEquals(DataTypes.DT_DATE.getId(), fd.getDataTypeId());
 569
 570                 // just to be safe...  If tests take too long these can probably be eliminated
 571                 assertFalse(fd.returnsBag());
 572                 assertEquals(new Integer(1), fd.getNumArgs());
 573
 574                 // test normal
 575                 arguments.clear();
 576                 arguments.add(attrString1);
 577                 ExpressionResult res = fd.evaluate(null, arguments);
 578                 assertTrue(res.isOk());
 579                 ISO8601Date resValue = (ISO8601Date)res.getValue().getValue();
 580                 assertEquals(new ISO8601Date(2013, 5, 12), resValue);
 581
 582                 // check negative
 583                 arguments.clear();
 584                 arguments.add(attrString2);
 585                 res = fd.evaluate(null, arguments);
 586                 assertTrue(res.isOk());
 587                 resValue = (ISO8601Date)res.getValue().getValue();
 588                 assertEquals(new ISO8601Date(-2013, 5, 12), resValue);
 589
 590                 // check big
 591                 arguments.clear();
 592                 arguments.add(attrString3);
 593                 res = fd.evaluate(null, arguments);
 594                 assertTrue(res.isOk());
 595                 resValue = (ISO8601Date)res.getValue().getValue();
 596                 assertEquals(new ISO8601Date(1232013, 5, 12), resValue);
 597
 598                 // check big negative
 599                 arguments.clear();
 600                 arguments.add(attrString4);
 601                 res = fd.evaluate(null, arguments);
 602                 assertTrue(res.isOk());
 603                 resValue = (ISO8601Date)res.getValue().getValue();
 604                 assertEquals(new ISO8601Date(-1232013, 5, 12), resValue);
 605
 606                 // bad year
 607                 arguments.clear();
 608                 arguments.add(attrString5);
 609                 res = fd.evaluate(null, arguments);
 610                 assertFalse(res.isOk());
 611                 assertEquals("function:date-from-string Invalid year (must be at least 4 digits)", res.getStatus().getStatusMessage());
 612                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 613
 614                 // bad month
 615                 arguments.clear();
 616                 arguments.add(attrString6);
 617                 res = fd.evaluate(null, arguments);
 618                 assertFalse(res.isOk());
 619                 assertEquals("function:date-from-string Invalid month", res.getStatus().getStatusMessage());
 620                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 621
 622                 // bad day format
 623                 arguments.clear();
 624                 arguments.add(attrString7);
 625                 res = fd.evaluate(null, arguments);
 626                 assertFalse(res.isOk());
 627                 assertEquals("function:date-from-string Invalid day", res.getStatus().getStatusMessage());
 628                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 629
 630                 // month out of range
 631                 arguments.clear();
 632                 arguments.add(attrString8);
 633                 res = fd.evaluate(null, arguments);
 634                 assertFalse(res.isOk());
 635                 assertEquals("function:date-from-string Invalid month", res.getStatus().getStatusMessage());
 636                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 637
 638                 // day out of range
 639                 arguments.clear();
 640                 arguments.add(attrString9);
 641                 res = fd.evaluate(null, arguments);
 642                 assertFalse(res.isOk());
 643                 assertEquals("function:date-from-string Invalid day", res.getStatus().getStatusMessage());
 644                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 645
 646
 647                 // check TimeZone
 648                 arguments.clear();
 649                 arguments.add(attrStringDateZone);
 650                 res = fd.evaluate(null, arguments);
 651                 assertTrue(res.isOk());
 652                 resValue = (ISO8601Date)res.getValue().getValue();
 653                 assertEquals(new ISO8601Date(new ISO8601TimeZone(180), 2013, 5, 12), resValue);
 654
 655                 // bad value
 656                 arguments.clear();
 657                 arguments.add(attrStringBadValue);
 658                 res = fd.evaluate(null, arguments);
 659                 assertFalse(res.isOk());
 660                 assertEquals("function:date-from-string Invalid year", res.getStatus().getStatusMessage());
 661                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 662
 663                 // bad arg type
 664                 arguments.clear();
 665                 arguments.add(attrStringBadType);
 666                 res = fd.evaluate(null, arguments);
 667                 assertFalse(res.isOk());
 668                 assertEquals("function:date-from-string Expected data type 'string' saw 'integer' at arg index 0", res.getStatus().getStatusMessage());
 669                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 670         }
 671
 672         @Test
 673         public void testString_from_date() {
 674                 FunctionArgumentAttributeValue attrObj1 = null;
 675                 FunctionArgumentAttributeValue attrObj2 = null;
 676                 FunctionArgumentAttributeValue attrObjDateZone = null;
 677                 FunctionArgumentAttributeValue attrStringBadType = null;
 678                 try {
 679                         attrObj1 = new FunctionArgumentAttributeValue(DataTypes.DT_DATE.createAttributeValue("2013-05-12"));
 680                         attrObj2 = new FunctionArgumentAttributeValue(DataTypes.DT_DATE.createAttributeValue("0001-01-01"));
 681                         attrObjDateZone = new FunctionArgumentAttributeValue(DataTypes.DT_DATE.createAttributeValue("2013-05-12+03:00"));
 682                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
 683
 684                 } catch (Exception e) {
 685                         fail("creating attribute e="+ e);
 686                 }
 687
 688                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_STRING_FROM_DATE;
 689
 690                 // check identity and type of the thing created
 691                 assertEquals(XACML3.ID_FUNCTION_STRING_FROM_DATE, fd.getId());
 692                 assertEquals(DataTypes.DT_DATE.getId(), fd.getDataTypeArgs().getId());
 693                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeId());
 694
 695                 // just to be safe...  If tests take too long these can probably be eliminated
 696                 assertFalse(fd.returnsBag());
 697                 assertEquals(new Integer(1), fd.getNumArgs());
 698
 699                 // test normal
 700                 arguments.clear();
 701                 arguments.add(attrObj1);
 702                 ExpressionResult res = fd.evaluate(null, arguments);
 703                 assertTrue(res.isOk());
 704                 assertEquals("2013-05-12", res.getValue().getValue());
 705
 706                 // missing digits in string value?
 707                 arguments.clear();
 708                 arguments.add(attrObj2);
 709                 res = fd.evaluate(null, arguments);
 710                 assertTrue(res.isOk());
 711                 assertEquals("1-01-01", res.getValue().getValue());
 712
 713                 // include DateZone
 714                 arguments.clear();
 715                 arguments.add(attrObjDateZone);
 716                 res = fd.evaluate(null, arguments);
 717                 assertTrue(res.isOk());
 718                 assertEquals("2013-05-12+03:00", res.getValue().getValue());
 719
 720                 // bad arg type
 721                 arguments.clear();
 722                 arguments.add(attrStringBadType);
 723                 res = fd.evaluate(null, arguments);
 724                 assertFalse(res.isOk());
 725                 assertEquals("function:string-from-date Expected data type 'date' saw 'integer' at arg index 0", res.getStatus().getStatusMessage());
 726                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 727         }
 728
 729
 730
 731
 732
 733
 734         /**
 735          * DateTime
 736          */
 737         @Test
 738         public void testDateTime_from_string() {
 739                 FunctionArgumentAttributeValue attrString1 = null;
 740                 FunctionArgumentAttributeValue attrString2 = null;
 741                 FunctionArgumentAttributeValue attrString3 = null;
 742                 FunctionArgumentAttributeValue attrString4 = null;
 743                 FunctionArgumentAttributeValue attrString5 = null;
 744                 FunctionArgumentAttributeValue attrString6 = null;
 745                 FunctionArgumentAttributeValue attrString7 = null;
 746                 FunctionArgumentAttributeValue attrString8 = null;
 747                 FunctionArgumentAttributeValue attrString9 = null;
 748                 FunctionArgumentAttributeValue attrStringDateTimeZone = null;
 749                 FunctionArgumentAttributeValue attrStringBadValue = null;
 750                 FunctionArgumentAttributeValue attrStringBadType = null;
 751                 try {
 752                         attrString1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("2013-05-12T12:14:15.323"));
 753                         attrString2 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("-2013-05-12T12:14:15.323"));
 754                         attrString3 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("1232013-05-12T12:14:15.323"));
 755                         attrString4 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("-1232013-05-12T12:14:15.323"));
 756                         attrString5 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("213-05-12T12:14:15.323"));
 757                         attrString6 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("2013-5-12T12:14:15.323"));
 758                         attrString7 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("2013-05-2T12:14:15.323"));
 759                         attrString8 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("2013-32-12T12:14:15.323"));
 760                         attrString9 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("2013-05-45T12:14:15.323"));
 761                         attrStringDateTimeZone = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("2013-05-12T12:14:15.323+03:00"));
 762                         attrStringBadValue = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("not valid obj value"));
 763                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
 764
 765                 } catch (Exception e) {
 766                         fail("creating attribute e="+ e);
 767                 }
 768
 769                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_DATETIME_FROM_STRING;
 770
 771                 // check identity and type of the thing created
 772                 assertEquals(XACML3.ID_FUNCTION_DATETIME_FROM_STRING, fd.getId());
 773                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeArgs().getId());
 774                 assertEquals(DataTypes.DT_DATETIME.getId(), fd.getDataTypeId());
 775
 776                 // just to be safe...  If tests take too long these can probably be eliminated
 777                 assertFalse(fd.returnsBag());
 778                 assertEquals(new Integer(1), fd.getNumArgs());
 779
 780                 // test normal
 781                 arguments.clear();
 782                 arguments.add(attrString1);
 783                 ExpressionResult res = fd.evaluate(null, arguments);
 784                 assertTrue(res.isOk());
 785                 ISO8601DateTime resValue = (ISO8601DateTime)res.getValue().getValue();
 786                 assertEquals(new ISO8601DateTime(null, new ISO8601Date(2013, 5, 12), new ISO8601Time(12, 14, 15, 323)), resValue);
 787
 788                 // check negative
 789                 arguments.clear();
 790                 arguments.add(attrString2);
 791                 res = fd.evaluate(null, arguments);
 792                 assertTrue(res.isOk());
 793                 resValue = (ISO8601DateTime)res.getValue().getValue();
 794                 assertEquals(new ISO8601DateTime(null, new ISO8601Date(-2013, 5, 12), new ISO8601Time(12, 14, 15, 323)), resValue);
 795
 796
 797                 // check big
 798                 arguments.clear();
 799                 arguments.add(attrString3);
 800                 res = fd.evaluate(null, arguments);
 801                 assertTrue(res.isOk());
 802                 resValue = (ISO8601DateTime)res.getValue().getValue();
 803                 assertEquals(new ISO8601DateTime(null, new ISO8601Date(1232013, 5, 12), new ISO8601Time(12, 14, 15, 323)), resValue);
 804
 805                 // check big negative
 806                 arguments.clear();
 807                 arguments.add(attrString4);
 808                 res = fd.evaluate(null, arguments);
 809                 assertTrue(res.isOk());
 810                 resValue = (ISO8601DateTime)res.getValue().getValue();
 811                 assertEquals(new ISO8601DateTime(null, new ISO8601Date(-1232013, 5, 12), new ISO8601Time(12, 14, 15, 323)), resValue);
 812
 813                 // bad year
 814                 arguments.clear();
 815                 arguments.add(attrString5);
 816                 res = fd.evaluate(null, arguments);
 817                 assertFalse(res.isOk());
 818                 assertEquals("function:dateTime-from-string Invalid year (must be at least 4 digits)", res.getStatus().getStatusMessage());
 819                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 820
 821                 // bad month
 822                 arguments.clear();
 823                 arguments.add(attrString6);
 824                 res = fd.evaluate(null, arguments);
 825                 assertFalse(res.isOk());
 826                 assertEquals("function:dateTime-from-string Invalid month", res.getStatus().getStatusMessage());
 827                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 828
 829                 // bad day format
 830                 arguments.clear();
 831                 arguments.add(attrString7);
 832                 res = fd.evaluate(null, arguments);
 833                 assertFalse(res.isOk());
 834                 assertEquals("function:dateTime-from-string Invalid day", res.getStatus().getStatusMessage());
 835                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 836
 837                 // month out of range
 838                 arguments.clear();
 839                 arguments.add(attrString8);
 840                 res = fd.evaluate(null, arguments);
 841                 assertFalse(res.isOk());
 842                 assertEquals("function:dateTime-from-string Invalid month", res.getStatus().getStatusMessage());
 843                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 844
 845                 // day out of range
 846                 arguments.clear();
 847                 arguments.add(attrString9);
 848                 res = fd.evaluate(null, arguments);
 849                 assertFalse(res.isOk());
 850                 assertEquals("function:dateTime-from-string Invalid day", res.getStatus().getStatusMessage());
 851                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 852
 853
 854                 // check TimeZone
 855                 arguments.clear();
 856                 arguments.add(attrStringDateTimeZone);
 857                 res = fd.evaluate(null, arguments);
 858                 assertTrue(res.isOk());
 859                 resValue = (ISO8601DateTime)res.getValue().getValue();
 860                 assertEquals(new ISO8601DateTime(new ISO8601TimeZone(180), new ISO8601Date(new ISO8601TimeZone(180), 2013, 5, 12), new ISO8601Time(new ISO8601TimeZone(180),12, 14, 15, 323)), resValue);
 861
 862                 // bad value
 863                 arguments.clear();
 864                 arguments.add(attrStringBadValue);
 865                 res = fd.evaluate(null, arguments);
 866                 assertFalse(res.isOk());
 867                 assertEquals("function:dateTime-from-string Invalid year", res.getStatus().getStatusMessage());
 868                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 869
 870                 // bad arg type
 871                 arguments.clear();
 872                 arguments.add(attrStringBadType);
 873                 res = fd.evaluate(null, arguments);
 874                 assertFalse(res.isOk());
 875                 assertEquals("function:dateTime-from-string Expected data type 'string' saw 'integer' at arg index 0", res.getStatus().getStatusMessage());
 876                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 877         }
 878
 879         @Test
 880         public void testString_from_dateTime() {
 881                 FunctionArgumentAttributeValue attrObj1 = null;
 882                 FunctionArgumentAttributeValue attrObj2 = null;
 883                 FunctionArgumentAttributeValue attrObjDateTimeZone = null;
 884                 FunctionArgumentAttributeValue attrStringBadType = null;
 885                 try {
 886                         attrObj1 = new FunctionArgumentAttributeValue(DataTypes.DT_DATETIME.createAttributeValue("2013-05-12T12:14:15.323"));
 887                         attrObj2 = new FunctionArgumentAttributeValue(DataTypes.DT_DATETIME.createAttributeValue("0001-01-01T12:14:15.323"));
 888                         attrObjDateTimeZone = new FunctionArgumentAttributeValue(DataTypes.DT_DATETIME.createAttributeValue("2013-05-12T12:14:15.323+03:00"));
 889                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
 890
 891                 } catch (Exception e) {
 892                         fail("creating attribute e="+ e);
 893                 }
 894
 895                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_STRING_FROM_DATETIME;
 896
 897                 // check identity and type of the thing created
 898                 assertEquals(XACML3.ID_FUNCTION_STRING_FROM_DATETIME, fd.getId());
 899                 assertEquals(DataTypes.DT_DATETIME.getId(), fd.getDataTypeArgs().getId());
 900                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeId());
 901
 902                 // just to be safe...  If tests take too long these can probably be eliminated
 903                 assertFalse(fd.returnsBag());
 904                 assertEquals(new Integer(1), fd.getNumArgs());
 905
 906                 // test normal
 907                 arguments.clear();
 908                 arguments.add(attrObj1);
 909                 ExpressionResult res = fd.evaluate(null, arguments);
 910                 assertTrue(res.isOk());
 911                 assertEquals("2013-05-12T12:14:15.323", res.getValue().getValue());
 912
 913                 // missing digits in string value?
 914                 arguments.clear();
 915                 arguments.add(attrObj2);
 916                 res = fd.evaluate(null, arguments);
 917                 assertTrue(res.isOk());
 918                 assertEquals("1-01-01T12:14:15.323", res.getValue().getValue());
 919
 920                 // include DateTimeZone
 921                 arguments.clear();
 922                 arguments.add(attrObjDateTimeZone);
 923                 res = fd.evaluate(null, arguments);
 924                 assertTrue(res.isOk());
 925                 assertEquals("2013-05-12T12:14:15.323+03:00", res.getValue().getValue());
 926
 927                 // bad arg type
 928                 arguments.clear();
 929                 arguments.add(attrStringBadType);
 930                 res = fd.evaluate(null, arguments);
 931                 assertFalse(res.isOk());
 932                 assertEquals("function:string-from-dateTime Expected data type 'dateTime' saw 'integer' at arg index 0", res.getStatus().getStatusMessage());
 933                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 934         }
 935
 936
 937
 938
 939
 940         /**
 941          * URI
 942          */
 943         @Test
 944         public void testURI_from_string() {
 945                 FunctionArgumentAttributeValue attrString1 = null;
 946                 FunctionArgumentAttributeValue attrStringBadValue = null;
 947                 FunctionArgumentAttributeValue attrStringBadType = null;
 948                 try {
 949                         attrString1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("http://someMachine.com/subdir"));
 950                         attrStringBadValue = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("not valid obj value"));
 951                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
 952
 953                 } catch (Exception e) {
 954                         fail("creating attribute e="+ e);
 955                 }
 956
 957                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_ANYURI_FROM_STRING;
 958
 959                 // check identity and type of the thing created
 960                 assertEquals(XACML3.ID_FUNCTION_ANYURI_FROM_STRING, fd.getId());
 961                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeArgs().getId());
 962                 assertEquals(DataTypes.DT_ANYURI.getId(), fd.getDataTypeId());
 963
 964                 // just to be safe...  If tests take too long these can probably be eliminated
 965                 assertFalse(fd.returnsBag());
 966                 assertEquals(new Integer(1), fd.getNumArgs());
 967
 968                 // test normal
 969                 arguments.clear();
 970                 arguments.add(attrString1);
 971                 ExpressionResult res = fd.evaluate(null, arguments);
 972                 assertTrue(res.isOk());
 973                 URI resValue = (URI)res.getValue().getValue();
 974                 try {
 975                         assertEquals(new URI("http://someMachine.com/subdir"), resValue);
 976                 } catch (URISyntaxException e) {
 977                         fail("uri generation e="+e);
 978                 }
 979
 980                 // bad value
 981                 arguments.clear();
 982                 arguments.add(attrStringBadValue);
 983                 res = fd.evaluate(null, arguments);
 984                 assertFalse(res.isOk());
 985                 assertEquals("function:anyURI-from-string Illegal character in path at index 3: not valid obj value", res.getStatus().getStatusMessage());
 986                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 987
 988                 // bad arg type
 989                 arguments.clear();
 990                 arguments.add(attrStringBadType);
 991                 res = fd.evaluate(null, arguments);
 992                 assertFalse(res.isOk());
 993                 assertEquals("function:anyURI-from-string Expected data type 'string' saw 'integer' at arg index 0", res.getStatus().getStatusMessage());
 994                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 995         }
 996
 997         @Test
 998         public void testString_from_anyURI() {
 999                 FunctionArgumentAttributeValue attrObj1 = null;
1000                 FunctionArgumentAttributeValue attrStringBadType = null;
1001                 String objValueString = "http://aMachine.com:8080/aRef";
1002                 try {
1003                         attrObj1 = new FunctionArgumentAttributeValue(DataTypes.DT_ANYURI.createAttributeValue(objValueString));
1004                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
1005
1006                 } catch (Exception e) {
1007                         fail("creating attribute e="+ e);
1008                 }
1009
1010                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_STRING_FROM_ANYURI;
1011
1012                 // check identity and type of the thing created
1013                 assertEquals(XACML3.ID_FUNCTION_STRING_FROM_ANYURI, fd.getId());
1014                 assertEquals(DataTypes.DT_ANYURI.getId(), fd.getDataTypeArgs().getId());
1015                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeId());
1016
1017                 // just to be safe...  If tests take too long these can probably be eliminated
1018                 assertFalse(fd.returnsBag());
1019                 assertEquals(new Integer(1), fd.getNumArgs());
1020
1021                 // test normal
1022                 arguments.clear();
1023                 arguments.add(attrObj1);
1024                 ExpressionResult res = fd.evaluate(null, arguments);
1025                 assertTrue(res.isOk());
1026                 assertEquals(objValueString, res.getValue().getValue());
1027
1028                 // bad arg type
1029                 arguments.clear();
1030                 arguments.add(attrStringBadType);
1031                 res = fd.evaluate(null, arguments);
1032                 assertFalse(res.isOk());
1033                 assertEquals("function:string-from-anyURI Expected data type 'anyURI' saw 'integer' at arg index 0", res.getStatus().getStatusMessage());
1034                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1035         }
1036
1037
1038
1039         /**
1040          * XPathDayTimeDuration
1041          */
1042         @Test
1043         public void testXPathDayTimeDuration_from_string() {
1044                 FunctionArgumentAttributeValue attrString1 = null;
1045                 FunctionArgumentAttributeValue attrStringNeg1 = null;
1046                 FunctionArgumentAttributeValue attrStringNeg2 = null;
1047                 FunctionArgumentAttributeValue attrStringNoDay = null;
1048                 FunctionArgumentAttributeValue attrStringNoHour = null;
1049                 FunctionArgumentAttributeValue attrStringNoMin = null;
1050                 FunctionArgumentAttributeValue attrStringNoSec = null;
1051                 FunctionArgumentAttributeValue attrStringNoP = null;
1052                 FunctionArgumentAttributeValue attrStringSecondsDot = null;
1053                 FunctionArgumentAttributeValue attrStringMissingTOk = null;
1054                 FunctionArgumentAttributeValue attrStringMissingTBad = null;
1055                 FunctionArgumentAttributeValue attrStringBadValue = null;
1056                 FunctionArgumentAttributeValue attrStringBadType = null;
1057                 try {
1058                         attrString1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("P3DT10H30M23S"));
1059                         attrStringNeg1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("-P3DT10H30M23S"));
1060                         attrStringNeg2 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("P-3DT10H30M23S"));
1061                         attrStringNoDay = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("PT10H30M23S"));
1062                         attrStringNoHour = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("P3DT30M23S"));
1063                         attrStringNoMin = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("P3DT10H23S"));
1064                         attrStringNoSec = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("P3DT10H30M"));
1065                         attrStringNoP = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("3DT10H30M"));
1066                         attrStringSecondsDot = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("P3DT10H30M23.456S"));
1067                         attrStringMissingTOk = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("P3D"));
1068                         attrStringMissingTBad = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("P3D10H30M23S"));
1069
1070                         attrStringBadValue = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("not valid obj value"));
1071                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
1072
1073                 } catch (Exception e) {
1074                         fail("creating attribute e="+ e);
1075                 }
1076
1077                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_DAYTIMEDURATION_FROM_STRING;
1078
1079                 // check identity and type of the thing created
1080                 assertEquals(XACML3.ID_FUNCTION_DAYTIMEDURATION_FROM_STRING, fd.getId());
1081                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeArgs().getId());
1082                 assertEquals(DataTypes.DT_DAYTIMEDURATION.getId(), fd.getDataTypeId());
1083
1084                 // just to be safe...  If tests take too long these can probably be eliminated
1085                 assertFalse(fd.returnsBag());
1086                 assertEquals(new Integer(1), fd.getNumArgs());
1087
1088                 // test normal
1089                 arguments.clear();
1090                 arguments.add(attrString1);
1091                 ExpressionResult res = fd.evaluate(null, arguments);
1092                 assertTrue(res.isOk());
1093                 XPathDayTimeDuration resValue = (XPathDayTimeDuration)res.getValue().getValue();
1094                 assertEquals(new XPathDayTimeDuration(1, 3, 10, 30, 23), resValue);
1095
1096
1097                 //              negative values in front is allowed
1098                 arguments.clear();
1099                 arguments.add(attrStringNeg1);
1100                 res = fd.evaluate(null, arguments);
1101                 assertTrue(res.isOk());
1102                 resValue = (XPathDayTimeDuration)res.getValue().getValue();
1103                 assertEquals(new XPathDayTimeDuration(-1, 3, 10, 30, 23), resValue);
1104
1105                 // negative in middle of string not ok
1106                 arguments.clear();
1107                 arguments.add(attrStringNeg2);
1108                 res = fd.evaluate(null, arguments);
1109                 assertFalse(res.isOk());
1110                 assertEquals("function:dayTimeDuration-from-string Invalid chunk \"P-3DT10H30M23S\" at position 1", res.getStatus().getStatusMessage());
1111                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1112
1113
1114                 //      omit parts that are 0
1115                 arguments.clear();
1116                 arguments.add(attrStringNoDay);
1117                 res = fd.evaluate(null, arguments);
1118                 assertTrue(res.isOk());
1119                 resValue = (XPathDayTimeDuration)res.getValue().getValue();
1120                 assertEquals(new XPathDayTimeDuration(1, 0, 10, 30, 23), resValue);
1121
1122                 arguments.clear();
1123                 arguments.add(attrStringNoHour);
1124                 res = fd.evaluate(null, arguments);
1125                 assertTrue(res.isOk());
1126                 resValue = (XPathDayTimeDuration)res.getValue().getValue();
1127                 assertEquals(new XPathDayTimeDuration(1, 3, 0, 30, 23), resValue);
1128
1129                 arguments.clear();
1130                 arguments.add(attrStringNoMin);
1131                 res = fd.evaluate(null, arguments);
1132                 assertTrue(res.isOk());
1133                 resValue = (XPathDayTimeDuration)res.getValue().getValue();
1134                 assertEquals(new XPathDayTimeDuration(1, 3, 10, 0, 23), resValue);
1135
1136                 arguments.clear();
1137                 arguments.add(attrStringNoSec);
1138                 res = fd.evaluate(null, arguments);
1139                 assertTrue(res.isOk());
1140                 resValue = (XPathDayTimeDuration)res.getValue().getValue();
1141                 assertEquals(new XPathDayTimeDuration(1, 3, 10, 30, 0), resValue);
1142
1143                 //              P must always be present
1144                 arguments.clear();
1145                 arguments.add(attrStringNoP);
1146                 res = fd.evaluate(null, arguments);
1147                 assertFalse(res.isOk());
1148                 assertEquals("function:dayTimeDuration-from-string Invalid ISO8601 duration string \"3DT10H30M\" at position 0", res.getStatus().getStatusMessage());
1149                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1150
1151                 //              seconds may contain decimal
1152                 arguments.clear();
1153                 arguments.add(attrStringSecondsDot);
1154                 res = fd.evaluate(null, arguments);
1155                 assertTrue(res.isOk());
1156                 resValue = (XPathDayTimeDuration)res.getValue().getValue();
1157                 assertEquals(new XPathDayTimeDuration(1, 3, 10, 30, 23.456), resValue);
1158
1159                 //              T must be absent iff all time items are absent
1160                 arguments.clear();
1161                 arguments.add(attrStringMissingTOk);
1162                 res = fd.evaluate(null, arguments);
1163                 assertTrue(res.isOk());
1164                 resValue = (XPathDayTimeDuration)res.getValue().getValue();
1165                 assertEquals(new XPathDayTimeDuration(1, 3, 0, 0, 0), resValue);
1166
1167                 // negative in middle of string not ok
1168                 arguments.clear();
1169                 arguments.add(attrStringMissingTBad);
1170                 res = fd.evaluate(null, arguments);
1171                 assertFalse(res.isOk());
1172                 assertEquals("function:dayTimeDuration-from-string Invalid ISO8601 duration string \"P3D10H30M23S\" at position 6: out of order component", res.getStatus().getStatusMessage());
1173                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1174
1175
1176                 // bad value
1177                 arguments.clear();
1178                 arguments.add(attrStringBadValue);
1179                 res = fd.evaluate(null, arguments);
1180                 assertFalse(res.isOk());
1181                 assertEquals("function:dayTimeDuration-from-string Invalid ISO8601 duration string \"not valid obj value\" at position 0", res.getStatus().getStatusMessage());
1182                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1183
1184                 // bad arg type
1185                 arguments.clear();
1186                 arguments.add(attrStringBadType);
1187                 res = fd.evaluate(null, arguments);
1188                 assertFalse(res.isOk());
1189                 assertEquals("function:dayTimeDuration-from-string Expected data type 'string' saw 'integer' at arg index 0", res.getStatus().getStatusMessage());
1190                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1191         }
1192
1193         @Test
1194         public void testString_from_dayTimeDuration() {
1195                 FunctionArgumentAttributeValue attrObj1 = null;
1196                 FunctionArgumentAttributeValue attrStringBadType = null;
1197                 String objValueString = "P3DT10H30M23S";
1198                 try {
1199                         attrObj1 = new FunctionArgumentAttributeValue(DataTypes.DT_DAYTIMEDURATION.createAttributeValue(objValueString));
1200                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
1201
1202                 } catch (Exception e) {
1203                         fail("creating attribute e="+ e);
1204                 }
1205
1206                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_STRING_FROM_DAYTIMEDURATION;
1207
1208                 // check identity and type of the thing created
1209                 assertEquals(XACML3.ID_FUNCTION_STRING_FROM_DAYTIMEDURATION, fd.getId());
1210                 assertEquals(DataTypes.DT_DAYTIMEDURATION.getId(), fd.getDataTypeArgs().getId());
1211                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeId());
1212
1213                 // just to be safe...  If tests take too long these can probably be eliminated
1214                 assertFalse(fd.returnsBag());
1215                 assertEquals(new Integer(1), fd.getNumArgs());
1216
1217                 // test normal
1218                 arguments.clear();
1219                 arguments.add(attrObj1);
1220                 ExpressionResult res = fd.evaluate(null, arguments);
1221                 assertTrue(res.isOk());
1222                 assertEquals(objValueString, res.getValue().getValue());
1223
1224                 // bad arg type
1225                 arguments.clear();
1226                 arguments.add(attrStringBadType);
1227                 res = fd.evaluate(null, arguments);
1228                 assertFalse(res.isOk());
1229                 assertEquals("function:string-from-dayTimeDuration Expected data type 'dayTimeDuration' saw 'integer' at arg index 0", res.getStatus().getStatusMessage());
1230                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1231         }
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241         /**
1242          * XPathYearMonthDuration
1243          */
1244         @Test
1245         public void testXPathYearMonthDuration_from_string() {
1246                 FunctionArgumentAttributeValue attrString1 = null;
1247                 FunctionArgumentAttributeValue attrStringNeg1 = null;
1248                 FunctionArgumentAttributeValue attrStringNeg2 = null;
1249                 FunctionArgumentAttributeValue attrStringNoYear1 = null;
1250                 FunctionArgumentAttributeValue attrStringNoYear2 = null;
1251                 FunctionArgumentAttributeValue attrStringNoMonth1 = null;
1252                 FunctionArgumentAttributeValue attrStringNoMonth2 = null;
1253                 FunctionArgumentAttributeValue attrStringNoValue = null;
1254                 FunctionArgumentAttributeValue attrStringNoP = null;
1255                 FunctionArgumentAttributeValue attrStringBigMonths = null;
1256                 FunctionArgumentAttributeValue attrStringMissingTOk = null;
1257                 FunctionArgumentAttributeValue attrStringMissingTBad = null;
1258                 FunctionArgumentAttributeValue attrStringZeroMonths = null;
1259                 FunctionArgumentAttributeValue attrStringBadValue = null;
1260                 FunctionArgumentAttributeValue attrStringBadType = null;
1261                 try {
1262                         attrString1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("P1Y2M"));
1263                         attrStringNeg1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("-P1Y2M"));
1264                         attrStringNeg2 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("P-1Y2M"));
1265                         attrStringNoYear1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("P2M"));
1266                         attrStringNoYear2 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("PY2M"));
1267                         attrStringNoMonth1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("P1Y"));
1268                         attrStringNoMonth2 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("P1YM"));
1269                         attrStringNoValue = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("P"));
1270                         attrStringNoP = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("1Y2M"));
1271                         attrStringBigMonths = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("P1Y12M"));
1272                         attrStringMissingTOk = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("P3D"));
1273                         attrStringMissingTBad = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("P3D10H30M23S"));
1274                         attrStringZeroMonths = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("P0M"));
1275
1276                         attrStringBadValue = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("not valid obj value"));
1277                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
1278
1279                 } catch (Exception e) {
1280                         fail("creating attribute e="+ e);
1281                 }
1282
1283                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_YEARMONTHDURATION_FROM_STRING;
1284
1285                 // check identity and type of the thing created
1286                 assertEquals(XACML3.ID_FUNCTION_YEARMONTHDURATION_FROM_STRING, fd.getId());
1287                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeArgs().getId());
1288                 assertEquals(DataTypes.DT_YEARMONTHDURATION.getId(), fd.getDataTypeId());
1289
1290                 // just to be safe...  If tests take too long these can probably be eliminated
1291                 assertFalse(fd.returnsBag());
1292                 assertEquals(new Integer(1), fd.getNumArgs());
1293
1294                 // test normal
1295                 arguments.clear();
1296                 arguments.add(attrString1);
1297                 ExpressionResult res = fd.evaluate(null, arguments);
1298                 assertTrue(res.isOk());
1299                 XPathYearMonthDuration resValue = (XPathYearMonthDuration)res.getValue().getValue();
1300                 assertEquals(new XPathYearMonthDuration(1,1, 2), resValue);
1301
1302
1303                 //              negative values in front is allowed
1304                 arguments.clear();
1305                 arguments.add(attrStringNeg1);
1306                 res = fd.evaluate(null, arguments);
1307                 assertTrue(res.isOk());
1308                 resValue = (XPathYearMonthDuration)res.getValue().getValue();
1309                 assertEquals(new XPathYearMonthDuration(-1, 1, 2), resValue);
1310
1311                 // negative in middle of string not ok
1312                 arguments.clear();
1313                 arguments.add(attrStringNeg2);
1314                 res = fd.evaluate(null, arguments);
1315                 assertFalse(res.isOk());
1316                 assertEquals("function:yearMonthDuration-from-string Invalid chunk \"P-1Y2M\" at position 1", res.getStatus().getStatusMessage());
1317                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1318
1319
1320                 //      omit parts that are 0
1321                 arguments.clear();
1322                 arguments.add(attrStringNoYear1);
1323                 res = fd.evaluate(null, arguments);
1324                 assertTrue(res.isOk());
1325                 resValue = (XPathYearMonthDuration)res.getValue().getValue();
1326                 assertEquals(new XPathYearMonthDuration(1, 0, 2), resValue);
1327
1328                 arguments.clear();
1329                 arguments.add(attrStringNoYear2);
1330                 res = fd.evaluate(null, arguments);
1331                 assertFalse(res.isOk());
1332                 assertEquals("function:yearMonthDuration-from-string Invalid chunk \"PY2M\" at position 1", res.getStatus().getStatusMessage());
1333                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1334
1335
1336                 arguments.clear();
1337                 arguments.add(attrStringNoMonth1);
1338                 res = fd.evaluate(null, arguments);
1339                 assertTrue(res.isOk());
1340                 resValue = (XPathYearMonthDuration)res.getValue().getValue();
1341                 assertEquals(new XPathYearMonthDuration(1, 1, 0), resValue);
1342
1343                 arguments.clear();
1344                 arguments.add(attrStringNoMonth2);
1345                 res = fd.evaluate(null, arguments);
1346                 assertFalse(res.isOk());
1347                 assertEquals("function:yearMonthDuration-from-string Invalid chunk \"P1YM\" at position 3", res.getStatus().getStatusMessage());
1348                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1349
1350
1351                 // No field with a value
1352                 arguments.clear();
1353                 arguments.add(attrStringNoValue);
1354                 res = fd.evaluate(null, arguments);
1355                 assertFalse(res.isOk());
1356                 assertEquals("function:yearMonthDuration-from-string Invalid ISO8601 duration string \"P\": No duration components following P", res.getStatus().getStatusMessage());
1357                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1358
1359
1360                 //              P must always be present
1361                 arguments.clear();
1362                 arguments.add(attrStringNoP);
1363                 res = fd.evaluate(null, arguments);
1364                 assertFalse(res.isOk());
1365                 assertEquals("function:yearMonthDuration-from-string Invalid ISO8601 duration string \"1Y2M\" at position 0", res.getStatus().getStatusMessage());
1366                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1367
1368                 //              Canonical Form of output may not have more than 12 months, but input as string is ok?
1369                 arguments.clear();
1370                 arguments.add(attrStringBigMonths);
1371                 res = fd.evaluate(null, arguments);
1372                 assertTrue(res.isOk());
1373                 resValue = (XPathYearMonthDuration)res.getValue().getValue();
1374                 assertEquals(new XPathYearMonthDuration(1, 1, 12), resValue);
1375
1376                 // Canonical representation of 0 Months
1377                 arguments.clear();
1378                 arguments.add(attrStringZeroMonths);
1379                 res = fd.evaluate(null, arguments);
1380                 assertTrue(res.isOk());
1381                 resValue = (XPathYearMonthDuration)res.getValue().getValue();
1382                 assertEquals(new XPathYearMonthDuration(1, 0, 0), resValue);
1383
1384                 //              T must be absent iff all time items are absent
1385                 arguments.clear();
1386                 arguments.add(attrStringMissingTOk);
1387                 res = fd.evaluate(null, arguments);
1388                 assertFalse(res.isOk());
1389                 assertEquals("function:yearMonthDuration-from-string Invalid XPath yearMonthDuraiton \"{durationSign=1years=0months=0days=3hours=0minutes=0seconds=0millis=0}\": includes days, hours, minutes, or seconds", res.getStatus().getStatusMessage());
1390                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1391
1392                 // negative in middle of string not ok
1393                 arguments.clear();
1394                 arguments.add(attrStringMissingTBad);
1395                 res = fd.evaluate(null, arguments);
1396                 assertFalse(res.isOk());
1397                 assertEquals("function:yearMonthDuration-from-string Invalid ISO8601 duration string \"P3D10H30M23S\" at position 6: out of order component", res.getStatus().getStatusMessage());
1398                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1399
1400
1401                 // bad value
1402                 arguments.clear();
1403                 arguments.add(attrStringBadValue);
1404                 res = fd.evaluate(null, arguments);
1405                 assertFalse(res.isOk());
1406                 assertEquals("function:yearMonthDuration-from-string Invalid ISO8601 duration string \"not valid obj value\" at position 0", res.getStatus().getStatusMessage());
1407                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1408
1409                 // bad arg type
1410                 arguments.clear();
1411                 arguments.add(attrStringBadType);
1412                 res = fd.evaluate(null, arguments);
1413                 assertFalse(res.isOk());
1414                 assertEquals("function:yearMonthDuration-from-string Expected data type 'string' saw 'integer' at arg index 0", res.getStatus().getStatusMessage());
1415                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1416         }
1417
1418         @Test
1419         public void testString_from_yearMonthDuration() {
1420                 FunctionArgumentAttributeValue attrObj1 = null;
1421                 FunctionArgumentAttributeValue attrStringBadType = null;
1422                 String objValueString = "P1Y2M";
1423                 try {
1424                         attrObj1 = new FunctionArgumentAttributeValue(DataTypes.DT_YEARMONTHDURATION.createAttributeValue(objValueString));
1425                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
1426
1427                 } catch (Exception e) {
1428                         fail("creating attribute e="+ e);
1429                 }
1430
1431                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_STRING_FROM_YEARMONTHDURATION;
1432
1433                 // check identity and type of the thing created
1434                 assertEquals(XACML3.ID_FUNCTION_STRING_FROM_YEARMONTHDURATION, fd.getId());
1435                 assertEquals(DataTypes.DT_YEARMONTHDURATION.getId(), fd.getDataTypeArgs().getId());
1436                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeId());
1437
1438                 // just to be safe...  If tests take too long these can probably be eliminated
1439                 assertFalse(fd.returnsBag());
1440                 assertEquals(new Integer(1), fd.getNumArgs());
1441
1442                 // test normal
1443                 arguments.clear();
1444                 arguments.add(attrObj1);
1445                 ExpressionResult res = fd.evaluate(null, arguments);
1446                 assertTrue(res.isOk());
1447                 assertEquals(objValueString, res.getValue().getValue());
1448
1449                 // bad arg type
1450                 arguments.clear();
1451                 arguments.add(attrStringBadType);
1452                 res = fd.evaluate(null, arguments);
1453                 assertFalse(res.isOk());
1454                 assertEquals("function:string-from-yearMonthDuration Expected data type 'yearMonthDuration' saw 'integer' at arg index 0", res.getStatus().getStatusMessage());
1455                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1456         }
1457
1458
1459
1460
1461
1462
1463         /**
1464          * X500Principal
1465          *
1466          * See http://www.ietf.org/rfc/rfc2253.txt and http://www.ietf.org/rfc/rfc2251.txt
1467          */
1468         @Test
1469         public void testX500Principal_from_string() {
1470                 FunctionArgumentAttributeValue attrString1 = null;
1471                 FunctionArgumentAttributeValue attrStringNoComma = null;
1472                 FunctionArgumentAttributeValue attrStringEmpty = null;
1473                 FunctionArgumentAttributeValue attrStringNoValue = null;
1474                 FunctionArgumentAttributeValue attrStringOrder = null;
1475                 FunctionArgumentAttributeValue attrStringDottedDecimalOID = null;
1476                 FunctionArgumentAttributeValue attrStringBadValue = null;
1477                 FunctionArgumentAttributeValue attrStringBadType = null;
1478                 try {
1479                         attrString1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("CN=Name, L=local, ST=NJ, O=ATT, C=USA"));
1480                         attrStringNoComma = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("CN=Name, L=local ST=NJ, O=ATT, C=USA"));
1481                         attrStringEmpty = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(""));
1482                         attrStringNoValue = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("CN=Name, L=, ST=NJ, O=ATT, C=USA"));
1483                         attrStringOrder = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("L=local, ST=NJ, O=ATT, CN=Name, C=USA"));
1484                         attrStringDottedDecimalOID = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("2.5.4.3=A. N. Other"));
1485
1486                         attrStringBadValue = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("not valid obj value"));
1487                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
1488
1489                 } catch (Exception e) {
1490                         fail("creating attribute e="+ e);
1491                 }
1492
1493
1494                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_X500NAME_FROM_STRING;
1495
1496                 // check identity and type of the thing created
1497                 assertEquals(XACML3.ID_FUNCTION_X500NAME_FROM_STRING, fd.getId());
1498                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeArgs().getId());
1499                 assertEquals(DataTypes.DT_X500NAME.getId(), fd.getDataTypeId());
1500
1501                 // just to be safe...  If tests take too long these can probably be eliminated
1502                 assertFalse(fd.returnsBag());
1503                 assertEquals(new Integer(1), fd.getNumArgs());
1504
1505                 // test normal
1506                 arguments.clear();
1507                 arguments.add(attrString1);
1508                 ExpressionResult res = fd.evaluate(null, arguments);
1509                 assertTrue(res.isOk());
1510                 X500Principal resValue = (X500Principal)res.getValue().getValue();
1511                 assertEquals(new X500Principal("CN=Name, L=local, ST=NJ, O=ATT, C=USA"), resValue);
1512
1513                 // no comma between components => next attribute/value is included as part of first value
1514                 arguments.clear();
1515                 arguments.add(attrStringNoComma);
1516                 res = fd.evaluate(null, arguments);
1517                 assertTrue(res.isOk());
1518                 resValue = (X500Principal)res.getValue().getValue();
1519                 assertEquals(new X500Principal("CN=Name, L=local ST=NJ, O=ATT, C=USA"), resValue);
1520
1521                 // nothing in name (fail)
1522                 arguments.clear();
1523                 arguments.add(attrStringEmpty);
1524                 res = fd.evaluate(null, arguments);
1525                 assertTrue(res.isOk());
1526                 resValue = (X500Principal)res.getValue().getValue();
1527                 assertEquals(new X500Principal(""), resValue);
1528
1529                 // type value with no =
1530                 arguments.clear();
1531                 arguments.add(attrStringNoValue);
1532                 res = fd.evaluate(null, arguments);
1533                 assertTrue(res.isOk());
1534                 resValue = (X500Principal)res.getValue().getValue();
1535                 assertEquals(new X500Principal("CN=Name, L=, ST=NJ, O=ATT, C=USA"), resValue);
1536
1537                 // different order
1538                 arguments.clear();
1539                 arguments.add(attrStringOrder);
1540                 res = fd.evaluate(null, arguments);
1541                 assertTrue(res.isOk());
1542                 resValue = (X500Principal)res.getValue().getValue();
1543                 assertNotEquals(new X500Principal("CN=Name, L=local, ST=NJ, O=ATT, C=USA"), resValue);
1544
1545                 // dotted-decimal name with numbers
1546                 arguments.clear();
1547                 arguments.add(attrStringDottedDecimalOID);
1548                 res = fd.evaluate(null, arguments);
1549                 assertTrue(res.isOk());
1550                 resValue = (X500Principal)res.getValue().getValue();
1551                 assertEquals(new X500Principal("2.5.4.3=A. N. Other"), resValue);
1552
1553
1554
1555                 // bad value
1556                 arguments.clear();
1557                 arguments.add(attrStringBadValue);
1558                 res = fd.evaluate(null, arguments);
1559                 assertFalse(res.isOk());
1560                 assertEquals("function:x500Name-from-string improperly specified input name: not valid obj value", res.getStatus().getStatusMessage());
1561                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1562
1563                 // bad arg type
1564                 arguments.clear();
1565                 arguments.add(attrStringBadType);
1566                 res = fd.evaluate(null, arguments);
1567                 assertFalse(res.isOk());
1568                 assertEquals("function:x500Name-from-string Expected data type 'string' saw 'integer' at arg index 0", res.getStatus().getStatusMessage());
1569                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1570         }
1571
1572         @Test
1573         public void testString_from_x500Name() {
1574                 FunctionArgumentAttributeValue attrObj1 = null;
1575                 FunctionArgumentAttributeValue attrStringBadType = null;
1576                 String objValueString = "CN=Name, L=local, ST=NJ, O=ATT, C=USA";
1577                 try {
1578                         attrObj1 = new FunctionArgumentAttributeValue(DataTypes.DT_X500NAME.createAttributeValue(objValueString));
1579                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
1580
1581                 } catch (Exception e) {
1582                         fail("creating attribute e="+ e);
1583                 }
1584
1585                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_STRING_FROM_X500NAME;
1586
1587                 // check identity and type of the thing created
1588                 assertEquals(XACML3.ID_FUNCTION_STRING_FROM_X500NAME, fd.getId());
1589                 assertEquals(DataTypes.DT_X500NAME.getId(), fd.getDataTypeArgs().getId());
1590                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeId());
1591
1592                 // just to be safe...  If tests take too long these can probably be eliminated
1593                 assertFalse(fd.returnsBag());
1594                 assertEquals(new Integer(1), fd.getNumArgs());
1595
1596                 // test normal
1597                 arguments.clear();
1598                 arguments.add(attrObj1);
1599                 ExpressionResult res = fd.evaluate(null, arguments);
1600                 assertTrue(res.isOk());
1601                 assertEquals(objValueString, res.getValue().getValue());
1602
1603                 // bad arg type
1604                 arguments.clear();
1605                 arguments.add(attrStringBadType);
1606                 res = fd.evaluate(null, arguments);
1607                 assertFalse(res.isOk());
1608                 assertEquals("function:string-from-x500Name Expected data type 'x500Name' saw 'integer' at arg index 0", res.getStatus().getStatusMessage());
1609                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1610         }
1611
1612
1613
1614
1615         /**
1616          * RFC822Name
1617          */
1618         @Test
1619         public void testRFC822Name_from_string() {
1620                 FunctionArgumentAttributeValue attrString1 = null;
1621                 FunctionArgumentAttributeValue attrStringCapsDomain = null;
1622                 FunctionArgumentAttributeValue attrStringCapsLocal = null;
1623                 FunctionArgumentAttributeValue attrStringMissingAt = null;
1624                 FunctionArgumentAttributeValue attrStringMissingLocal = null;
1625                 FunctionArgumentAttributeValue attrStringMissingDomain = null;
1626                 FunctionArgumentAttributeValue attrStringEmpty = null;
1627                 FunctionArgumentAttributeValue attrStringBadValue = null;
1628                 FunctionArgumentAttributeValue attrStringBadType = null;
1629                 try {
1630                         attrString1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("local@Domain"));
1631                         attrStringCapsDomain = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("local@DOMAIN"));
1632                         attrStringCapsLocal = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("LOCAL@Domain"));
1633                         attrStringMissingAt = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("localDomain"));
1634                         attrStringMissingLocal = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("@Domain"));
1635                         attrStringMissingDomain = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("local@"));
1636                         attrStringEmpty = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(""));
1637
1638                         attrStringBadValue = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("not valid obj value"));
1639                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
1640
1641                 } catch (Exception e) {
1642                         fail("creating attribute e="+ e);
1643                 }
1644
1645                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_RFC822NAME_FROM_STRING;
1646
1647                 // check identity and type of the thing created
1648                 assertEquals(XACML3.ID_FUNCTION_RFC822NAME_FROM_STRING, fd.getId());
1649                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeArgs().getId());
1650                 assertEquals(DataTypes.DT_RFC822NAME.getId(), fd.getDataTypeId());
1651
1652                 // just to be safe...  If tests take too long these can probably be eliminated
1653                 assertFalse(fd.returnsBag());
1654                 assertEquals(new Integer(1), fd.getNumArgs());
1655
1656                 // test normal
1657                 arguments.clear();
1658                 arguments.add(attrString1);
1659                 ExpressionResult res = fd.evaluate(null, arguments);
1660                 assertTrue(res.isOk());
1661                 RFC822Name resValue = (RFC822Name)res.getValue().getValue();
1662                 assertEquals(new RFC822Name("local", "domain"), resValue);
1663
1664                 // caps domain
1665                 arguments.clear();
1666                 arguments.add(attrStringCapsDomain);
1667                 res = fd.evaluate(null, arguments);
1668                 assertTrue(res.isOk());
1669                 resValue = (RFC822Name)res.getValue().getValue();
1670                 assertEquals(new RFC822Name("local", "domain"), resValue);
1671
1672                 // caps local
1673                 arguments.clear();
1674                 arguments.add(attrStringCapsLocal);
1675                 res = fd.evaluate(null, arguments);
1676                 assertTrue(res.isOk());
1677                 resValue = (RFC822Name)res.getValue().getValue();
1678                 assertNotEquals(new RFC822Name("local", "domain"), resValue);
1679
1680                 // missing at
1681                 arguments.clear();
1682                 arguments.add(attrStringMissingAt);
1683                 res = fd.evaluate(null, arguments);
1684                 assertFalse(res.isOk());
1685                 assertEquals("function:rfc822Name-from-string Invalid RFC822Name \"localDomain\": missing local part", res.getStatus().getStatusMessage());
1686                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1687
1688                 // missing local
1689                 arguments.clear();
1690                 arguments.add(attrStringMissingLocal);
1691                 res = fd.evaluate(null, arguments);
1692                 assertFalse(res.isOk());
1693                 assertEquals("function:rfc822Name-from-string Invalid RFC822Name \"@Domain\": empty parts", res.getStatus().getStatusMessage());
1694                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1695
1696                 // missing domain
1697                 arguments.clear();
1698                 arguments.add(attrStringMissingDomain);
1699                 res = fd.evaluate(null, arguments);
1700                 assertFalse(res.isOk());
1701                 assertEquals("function:rfc822Name-from-string Invalid RFC822Name \"local@\": empty parts", res.getStatus().getStatusMessage());
1702                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1703
1704                 // empty
1705                 arguments.clear();
1706                 arguments.add(attrStringEmpty);
1707                 res = fd.evaluate(null, arguments);
1708                 assertFalse(res.isOk());
1709                 assertEquals("function:rfc822Name-from-string Invalid RFC822Name \"\": missing local part", res.getStatus().getStatusMessage());
1710                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1711
1712
1713                 // bad value
1714                 arguments.clear();
1715                 arguments.add(attrStringBadValue);
1716                 res = fd.evaluate(null, arguments);
1717                 assertFalse(res.isOk());
1718                 assertEquals("function:rfc822Name-from-string Invalid RFC822Name \"not valid obj value\": missing local part", res.getStatus().getStatusMessage());
1719                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1720
1721                 // bad arg type
1722                 arguments.clear();
1723                 arguments.add(attrStringBadType);
1724                 res = fd.evaluate(null, arguments);
1725                 assertFalse(res.isOk());
1726                 assertEquals("function:rfc822Name-from-string Expected data type 'string' saw 'integer' at arg index 0", res.getStatus().getStatusMessage());
1727                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1728         }
1729
1730         @Test
1731         public void testString_from_rfc822Name() {
1732                 FunctionArgumentAttributeValue attrObj1 = null;
1733                 FunctionArgumentAttributeValue attrStringBadType = null;
1734                 String objValueString = "local@DOMAIN";
1735                 try {
1736                         attrObj1 = new FunctionArgumentAttributeValue(DataTypes.DT_RFC822NAME.createAttributeValue(objValueString));
1737                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
1738
1739                 } catch (Exception e) {
1740                         fail("creating attribute e="+ e);
1741                 }
1742
1743                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_STRING_FROM_RFC822NAME;
1744
1745                 // check identity and type of the thing created
1746                 assertEquals(XACML3.ID_FUNCTION_STRING_FROM_RFC822NAME, fd.getId());
1747                 assertEquals(DataTypes.DT_RFC822NAME.getId(), fd.getDataTypeArgs().getId());
1748                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeId());
1749
1750                 // just to be safe...  If tests take too long these can probably be eliminated
1751                 assertFalse(fd.returnsBag());
1752                 assertEquals(new Integer(1), fd.getNumArgs());
1753
1754                 // test normal
1755                 arguments.clear();
1756                 arguments.add(attrObj1);
1757                 ExpressionResult res = fd.evaluate(null, arguments);
1758                 assertTrue(res.isOk());
1759                 assertEquals("local@domain", res.getValue().getValue());
1760
1761                 // bad arg type
1762                 arguments.clear();
1763                 arguments.add(attrStringBadType);
1764                 res = fd.evaluate(null, arguments);
1765                 assertFalse(res.isOk());
1766                 assertEquals("function:string-from-rfc822Name Expected data type 'rfc822Name' saw 'integer' at arg index 0", res.getStatus().getStatusMessage());
1767                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1768         }
1769
1770
1771
1772
1773         /**
1774          * IPAddress
1775          */
1776         @Test
1777         public void testIPAddress_from_string() {
1778                 FunctionArgumentAttributeValue attrString1 = null;
1779                 FunctionArgumentAttributeValue attrStringFull = null;
1780                 FunctionArgumentAttributeValue attrStringMissingElement = null;
1781                 FunctionArgumentAttributeValue attrStringTooManyElement = null;
1782                 FunctionArgumentAttributeValue attrStringIllegalElement = null;
1783                 FunctionArgumentAttributeValue attrStringOutOfOrder = null;
1784
1785                 FunctionArgumentAttributeValue attrStringMask = null;
1786                 FunctionArgumentAttributeValue attrStringMissingMaskElement = null;
1787                 FunctionArgumentAttributeValue attrStringTooManyMaskElement = null;
1788                 FunctionArgumentAttributeValue attrStringIllegalMaskElement = null;
1789                 FunctionArgumentAttributeValue attrStringMaskNoValue = null;
1790
1791                 FunctionArgumentAttributeValue attrStringMinusPort = null;
1792                 FunctionArgumentAttributeValue attrStringPortMinus = null;
1793                 FunctionArgumentAttributeValue attrStringPortPort = null;
1794                 FunctionArgumentAttributeValue attrStringNoPort = null;
1795                 FunctionArgumentAttributeValue attrStringBadPort = null;
1796                 FunctionArgumentAttributeValue attrStringTooManyPorts = null;
1797                 FunctionArgumentAttributeValue attrStringBadValue = null;
1798                 FunctionArgumentAttributeValue attrStringBadType = null;
1799
1800                 // set up for v4 address tests - this setup and the tests are repeated for V6
1801                 short[] addrShorts= {123, 134, 156, 255 };
1802                 short[] addrMaskShorts= {255, 255, 255, 255 };
1803                 try {
1804                         attrString1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("123.134.156.255"));
1805                         attrStringFull = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("123.134.156.255/255.255.255.255:123-456"));
1806                         attrStringMissingElement = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("123.134.255"));
1807                         attrStringTooManyElement = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("123.134.255.111.222"));
1808                         attrStringIllegalElement = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("123.134.256.255"));
1809                         attrStringOutOfOrder = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("123.134.256.255:123-456/255.255.255.255"));
1810
1811                         attrStringMask = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("123.134.156.255/255.255.255.255"));
1812                         attrStringMissingMaskElement = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("123.134.156.255/123.134.255"));
1813                         attrStringTooManyMaskElement = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("123.134.156.255/122.134.155.111.222"));
1814                         attrStringIllegalMaskElement = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("123.134.156.255/123.134.256.255"));
1815                         attrStringMaskNoValue = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("123.134.156.255/"));
1816                         // optional mask
1817                         // "/" with no mask (fail)
1818
1819                         attrStringMinusPort = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("123.134.156.255:-123"));
1820                         attrStringPortMinus = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("123.134.156.255:123-"));
1821                         attrStringPortPort = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("123.134.156.255:1234567-432"));
1822                         attrStringNoPort = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("123.134.156.255:"));
1823                         attrStringBadPort = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("123.134.156.255:12.34"));
1824                         attrStringTooManyPorts = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("123.134.156.255:-123-456"));
1825
1826
1827
1828                         attrStringBadValue = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("not valid obj value"));
1829                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
1830
1831                 } catch (Exception e) {
1832                         fail("creating attribute e="+ e);
1833                 }
1834
1835                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_IPADDRESS_FROM_STRING;
1836
1837                 // check identity and type of the thing created
1838                 assertEquals(XACML3.ID_FUNCTION_IPADDRESS_FROM_STRING, fd.getId());
1839                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeArgs().getId());
1840                 assertEquals(DataTypes.DT_IPADDRESS.getId(), fd.getDataTypeId());
1841
1842                 // just to be safe...  If tests take too long these can probably be eliminated
1843                 assertFalse(fd.returnsBag());
1844                 assertEquals(new Integer(1), fd.getNumArgs());
1845
1846                 // test normal
1847                 arguments.clear();
1848                 arguments.add(attrString1);
1849                 ExpressionResult res = fd.evaluate(null, arguments);
1850                 assertTrue(res.isOk());
1851                 IPAddress resValue = (IPAddress)res.getValue().getValue();
1852                 assertEquals(new IPv4Address(addrShorts, null, null), resValue);
1853
1854                 // fully-loaded address
1855                 arguments.clear();
1856                 arguments.add(attrStringFull);
1857                 res = fd.evaluate(null, arguments);
1858                 assertTrue(res.isOk());
1859                 resValue = (IPAddress)res.getValue().getValue();
1860                 try {
1861                         assertEquals(new IPv4Address(addrShorts, addrMaskShorts, PortRange.newInstance("123-456")), resValue);
1862                 } catch (Exception e) {
1863                         fail("port error e="+e);
1864                 }
1865
1866                 // missing element
1867                 arguments.clear();
1868                 arguments.add(attrStringMissingElement);
1869                 res = fd.evaluate(null, arguments);
1870                 assertFalse(res.isOk());
1871                 assertEquals("function:ipAddress-from-string Invalid IPv4 address string \"123.134.255\": invalid address", res.getStatus().getStatusMessage());
1872                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1873
1874                 // too many elements
1875                 arguments.clear();
1876                 arguments.add(attrStringTooManyElement);
1877                 res = fd.evaluate(null, arguments);
1878                 assertFalse(res.isOk());
1879                 assertEquals("function:ipAddress-from-string Invalid IPv4 address string \"123.134.255.111.222\": invalid address", res.getStatus().getStatusMessage());
1880                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1881
1882                 // illegal element
1883                 arguments.clear();
1884                 arguments.add(attrStringIllegalElement);
1885                 res = fd.evaluate(null, arguments);
1886                 assertFalse(res.isOk());
1887                 assertEquals("function:ipAddress-from-string Invalid IPv4 address string \"123.134.256.255\": invalid octet: \"256", res.getStatus().getStatusMessage());
1888                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1889
1890                 // Out of order
1891                 arguments.clear();
1892                 arguments.add(attrStringOutOfOrder);
1893                 res = fd.evaluate(null, arguments);
1894                 assertFalse(res.isOk());
1895                 assertEquals("function:ipAddress-from-string Invalid IPv4 address string \"123.134.256.255:123-456/255.255.255.255\": out of order components", res.getStatus().getStatusMessage());
1896                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1897
1898
1899                 // simple mask
1900                 arguments.clear();
1901                 arguments.add(attrStringMask);
1902                 res = fd.evaluate(null, arguments);
1903                 assertTrue(res.isOk());
1904                 resValue = (IPAddress)res.getValue().getValue();
1905                 try {
1906                         assertEquals(new IPv4Address(addrShorts, addrMaskShorts, null), resValue);
1907                 } catch (Exception e) {
1908                         fail("port error e="+e);
1909                 }
1910
1911                 // missing mask element
1912                 arguments.clear();
1913                 arguments.add(attrStringMissingMaskElement);
1914                 res = fd.evaluate(null, arguments);
1915                 assertFalse(res.isOk());
1916                 assertEquals("function:ipAddress-from-string Invalid IPv4 address string \"123.134.255\": invalid address", res.getStatus().getStatusMessage());
1917                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1918
1919                 // too many mask elements
1920                 arguments.clear();
1921                 arguments.add(attrStringTooManyMaskElement);
1922                 res = fd.evaluate(null, arguments);
1923                 assertFalse(res.isOk());
1924                 assertEquals("function:ipAddress-from-string Invalid IPv4 address string \"122.134.155.111.222\": invalid address", res.getStatus().getStatusMessage());
1925                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1926
1927                 // illegal Mask element
1928                 arguments.clear();
1929                 arguments.add(attrStringIllegalMaskElement);
1930                 res = fd.evaluate(null, arguments);
1931                 assertFalse(res.isOk());
1932                 assertEquals("function:ipAddress-from-string Invalid IPv4 address string \"123.134.256.255\": invalid octet: \"256", res.getStatus().getStatusMessage());
1933                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1934
1935                 //mask indicator without value
1936                 arguments.clear();
1937                 arguments.add(attrStringMaskNoValue);
1938                 res = fd.evaluate(null, arguments);
1939                 assertFalse(res.isOk());
1940                 assertEquals("function:ipAddress-from-string Invalid IPv4 address string \"\": invalid address", res.getStatus().getStatusMessage());
1941                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1942
1943
1944                 // portrange (-port, port-, port-port)
1945                 arguments.clear();
1946                 arguments.add(attrStringMinusPort);
1947                 res = fd.evaluate(null, arguments);
1948                 assertTrue(res.isOk());
1949                 resValue = (IPAddress)res.getValue().getValue();
1950                 try {
1951                         assertEquals(new IPv4Address(addrShorts, null, PortRange.newInstance("-123")), resValue);
1952                 } catch (ParseException e) {
1953                         fail("port error e="+e);
1954                 }
1955
1956                 arguments.clear();
1957                 arguments.add(attrStringPortMinus);
1958                 res = fd.evaluate(null, arguments);
1959                 assertTrue(res.isOk());
1960                 resValue = (IPAddress)res.getValue().getValue();
1961                 try {
1962                         assertEquals(new IPv4Address(addrShorts, null, PortRange.newInstance("123-")), resValue);
1963                 } catch (ParseException e) {
1964                         fail("port error e="+e);
1965                 }
1966
1967                 arguments.clear();
1968                 arguments.add(attrStringPortPort);
1969                 res = fd.evaluate(null, arguments);
1970                 assertTrue(res.isOk());
1971                 resValue = (IPAddress)res.getValue().getValue();
1972                 try {
1973                         assertEquals(new IPv4Address(addrShorts, null, PortRange.newInstance("1234567-432")), resValue);
1974                 } catch (ParseException e) {
1975                         fail("port error e="+e);
1976                 }
1977
1978                 // ":" without port
1979                 arguments.clear();
1980                 arguments.add(attrStringNoPort);
1981                 res = fd.evaluate(null, arguments);
1982                 assertFalse(res.isOk());
1983                 assertEquals("function:ipAddress-from-string Invalid IPv4 address string \"123.134.156.255:\": no portrange given after ':'", res.getStatus().getStatusMessage());
1984                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1985
1986
1987                 // bad port number
1988                 arguments.clear();
1989                 arguments.add(attrStringBadPort);
1990                 res = fd.evaluate(null, arguments);
1991                 assertFalse(res.isOk());
1992                 assertEquals("function:ipAddress-from-string Invalid PortRange \"12.34\": invalid port number", res.getStatus().getStatusMessage());
1993                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
1994
1995                 // bad port range
1996                 arguments.clear();
1997                 arguments.add(attrStringTooManyPorts);
1998                 res = fd.evaluate(null, arguments);
1999                 assertFalse(res.isOk());
2000                 assertEquals("function:ipAddress-from-string Invalid PortRange \"-123-456\": too many ranges", res.getStatus().getStatusMessage());
2001                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2002
2003
2004                 // bad value
2005                 arguments.clear();
2006                 arguments.add(attrStringBadValue);
2007                 res = fd.evaluate(null, arguments);
2008                 assertFalse(res.isOk());
2009                 assertEquals("function:ipAddress-from-string Unknown IPAddress type for \"not valid obj value\"", res.getStatus().getStatusMessage());
2010                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2011
2012                 // bad arg type
2013                 arguments.clear();
2014                 arguments.add(attrStringBadType);
2015                 res = fd.evaluate(null, arguments);
2016                 assertFalse(res.isOk());
2017                 assertEquals("function:ipAddress-from-string Expected data type 'string' saw 'integer' at arg index 0", res.getStatus().getStatusMessage());
2018                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2019
2020
2021                 //
2022                 // V6 IP Addresses
2023                 //
2024
2025                 // reset the variable for IPv6 tests
2026                 FunctionArgumentAttributeValue attrStringAlternateFull = null;
2027                 FunctionArgumentAttributeValue attrStringEmptyElement = null;
2028                 FunctionArgumentAttributeValue attrString2xEmptyElement = null;
2029                 FunctionArgumentAttributeValue attrStringNoStartBracket = null;
2030                 FunctionArgumentAttributeValue attrStringNoEndBracket = null;
2031                 short[] addrv6Shorts = {(short)0x2001, (short)0xdb8, (short)0x85a3, (short)0x0, (short)0x0, (short)0x8a2e, (short)0x370, (short)0x1};
2032                 Short prefix = new Short((short) 121);
2033                 try {
2034                         attrString1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("[2001:db8:85a3:0:0:8a2e:370:1]"));
2035                         attrStringFull = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("[2001:db8:85a3:0:0:8a2e:370:1/121]:123-456"));
2036                         attrStringAlternateFull = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("[2001:db8:85a3:0:0:8a2e:370:1]/121:123-456"));
2037                         attrStringEmptyElement = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("[2001:db8:85a3::8a2e:370:1]"));
2038                         attrString2xEmptyElement = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("[2001:db8:85a3::8a2e::1]"));
2039                         attrStringNoStartBracket = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("2002:db8:85a3::8a2e::1]"));
2040                         attrStringNoEndBracket = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("[2001:db8:85a3::8a2e::1"));
2041
2042                         attrStringMissingElement = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("[2001:db8:85a3:0:0:8a2e:1]"));
2043                         attrStringTooManyElement = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("[2001:db8:85a3:0:0:8a2e:370:1:123]"));
2044                         attrStringIllegalElement = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("[2001:mnop:85a3:0:0:8a2e:370:1]"));
2045                         attrStringOutOfOrder = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("[2001:mnop:85a3:0:0:8a2e:370:1:123-456/121]"));
2046
2047                         attrStringMask = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("[2001:db8:85a3:0:0:8a2e:370:1/21]"));
2048                         attrStringIllegalMaskElement = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("[2001:db8:85a3:0:0:8a2e:370:1/130]"));
2049                         attrStringMaskNoValue = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("[2001:db8:85a3:0:0:8a2e:370:1/]"));
2050
2051                         attrStringMinusPort = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("[2001:db8:85a3:0:0:8a2e:370:1]:-123"));
2052                         attrStringPortMinus = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("[2001:db8:85a3:0:0:8a2e:370:1]:123-"));
2053                         attrStringPortPort = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("[2001:db8:85a3:0:0:8a2e:370:1]:1234567-432"));
2054                         attrStringNoPort = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("[2001:db8:85a3:0:0:8a2e:370:1]:"));
2055                         attrStringBadPort = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("[2001:db8:85a3:0:0:8a2e:370:1]:12.34"));
2056                         attrStringTooManyPorts = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("[2001:db8:85a3:0:0:8a2e:370:1]:-123-456"));
2057
2058                         attrStringBadValue = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("not valid obj value"));
2059                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
2060
2061                 } catch (Exception e) {
2062                         fail("creating attribute e="+ e);
2063                 }
2064
2065
2066                 // test normal
2067                 arguments.clear();
2068                 arguments.add(attrString1);
2069                 res = fd.evaluate(null, arguments);
2070                 assertTrue(res.isOk());
2071                 resValue = (IPAddress)res.getValue().getValue();
2072                 assertEquals(new IPv6Address(addrv6Shorts, null, null), resValue);
2073
2074                 // fully-loaded address - "prefix" is inside the brackets (not clear if this is correct)
2075                 arguments.clear();
2076                 arguments.add(attrStringFull);
2077                 res = fd.evaluate(null, arguments);
2078                 assertTrue(res.isOk());
2079                 resValue = (IPAddress)res.getValue().getValue();
2080                 try {
2081                         assertEquals(new IPv6Address(addrv6Shorts, new Short(prefix), PortRange.newInstance("123-456")), resValue);
2082                 } catch (Exception e) {
2083                         fail("port error e="+e);
2084                 }
2085
2086                 // Alternate way of identifying "prefix" - outside the brackets
2087                 arguments.clear();
2088                 arguments.add(attrStringAlternateFull);
2089                 res = fd.evaluate(null, arguments);
2090                 assertTrue(res.isOk());
2091                 resValue = (IPAddress)res.getValue().getValue();
2092                 try {
2093                         assertEquals(new IPv6Address(addrv6Shorts, prefix, PortRange.newInstance("123-456")), resValue);
2094                 } catch (Exception e) {
2095                         fail("port error e="+e);
2096                 }
2097
2098
2099                 // consecutive zero elements removed
2100                 arguments.clear();
2101                 arguments.add(attrStringEmptyElement);
2102                 res = fd.evaluate(null, arguments);
2103                 assertTrue(res.isOk());
2104                 resValue = (IPAddress)res.getValue().getValue();
2105                 try {
2106                         assertEquals(new IPv6Address(addrv6Shorts, prefix, null), resValue);
2107                 } catch (Exception e) {
2108                         fail("port error e="+e);
2109                 }
2110
2111                 // consecutive zero elements removed in two locations (no-no)
2112                 arguments.clear();
2113                 arguments.add(attrString2xEmptyElement);
2114                 res = fd.evaluate(null, arguments);
2115                 assertFalse(res.isOk());
2116                 assertEquals("function:ipAddress-from-string Invalid IPv6Address string \"2001:db8:85a3::8a2e::1\": multiple zero runs", res.getStatus().getStatusMessage());
2117                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2118
2119                 // address must have [] on it
2120                 arguments.clear();
2121                 arguments.add(attrStringNoStartBracket);
2122                 res = fd.evaluate(null, arguments);
2123                 assertFalse(res.isOk());
2124                 assertEquals("function:ipAddress-from-string Invalid IPv6Address string \"2002:db8:85a3::8a2e::1]\": missing opening bracket", res.getStatus().getStatusMessage());
2125                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2126
2127                 arguments.clear();
2128                 arguments.add(attrStringNoEndBracket);
2129                 res = fd.evaluate(null, arguments);
2130                 assertFalse(res.isOk());
2131                 assertEquals("function:ipAddress-from-string Invalid IPv6Address string \"[2001:db8:85a3::8a2e::1\": missing closing bracket", res.getStatus().getStatusMessage());
2132                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2133
2134
2135                 // missing element
2136                 arguments.clear();
2137                 arguments.add(attrStringMissingElement);
2138                 res = fd.evaluate(null, arguments);
2139                 assertFalse(res.isOk());
2140                 assertEquals("function:ipAddress-from-string Invalid IPv6Address string \"2001:db8:85a3:0:0:8a2e:1\": not enough address fields", res.getStatus().getStatusMessage());
2141                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2142
2143                 // too many elements
2144                 arguments.clear();
2145                 arguments.add(attrStringTooManyElement);
2146                 res = fd.evaluate(null, arguments);
2147                 assertFalse(res.isOk());
2148                 assertEquals("function:ipAddress-from-string Invalid IPv6Address string \"2001:db8:85a3:0:0:8a2e:370:1:123\"", res.getStatus().getStatusMessage());
2149                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2150
2151                 // illegal element
2152                 arguments.clear();
2153                 arguments.add(attrStringIllegalElement);
2154                 res = fd.evaluate(null, arguments);
2155                 assertFalse(res.isOk());
2156                 assertEquals("function:ipAddress-from-string Invalid IPv6Address component \"mnop\": invalid hex", res.getStatus().getStatusMessage());
2157                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2158
2159                 // Out of order
2160                 arguments.clear();
2161                 arguments.add(attrStringOutOfOrder);
2162                 res = fd.evaluate(null, arguments);
2163                 assertFalse(res.isOk());
2164                 assertEquals("function:ipAddress-from-string Invalid IPv6Address string \"2001:mnop:85a3:0:0:8a2e:370:1:123-456\"", res.getStatus().getStatusMessage());
2165                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2166
2167
2168                 // simple mask
2169                 arguments.clear();
2170                 arguments.add(attrStringMask);
2171                 res = fd.evaluate(null, arguments);
2172                 assertTrue(res.isOk());
2173                 resValue = (IPAddress)res.getValue().getValue();
2174                 try {
2175                         assertEquals(new IPv6Address(addrv6Shorts, prefix, null), resValue);
2176                 } catch (Exception e) {
2177                         fail("port error e="+e);
2178                 }
2179
2180                 // illegal Mask element
2181                 arguments.clear();
2182                 arguments.add(attrStringIllegalMaskElement);
2183                 res = fd.evaluate(null, arguments);
2184                 assertFalse(res.isOk());
2185                 assertEquals("function:ipAddress-from-string Invalid Ipv6Address string \"[2001:db8:85a3:0:0:8a2e:370:1/130]\": prefix is larger than 128", res.getStatus().getStatusMessage());
2186                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2187
2188                 //mask indicator without value
2189                 arguments.clear();
2190                 arguments.add(attrStringMaskNoValue);
2191                 res = fd.evaluate(null, arguments);
2192                 assertFalse(res.isOk());
2193                 assertEquals("function:ipAddress-from-string Invalid Ipv6Address string \"[2001:db8:85a3:0:0:8a2e:370:1/]\": prefix designation without value", res.getStatus().getStatusMessage());
2194                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2195
2196
2197                 // portrange (-port, port-, port-port)
2198                 arguments.clear();
2199                 arguments.add(attrStringMinusPort);
2200                 res = fd.evaluate(null, arguments);
2201                 assertTrue(res.isOk());
2202                 resValue = (IPAddress)res.getValue().getValue();
2203                 try {
2204                         assertEquals(new IPv6Address(addrv6Shorts, null, PortRange.newInstance("-123")), resValue);
2205                 } catch (ParseException e) {
2206                         fail("port error e="+e);
2207                 }
2208
2209                 arguments.clear();
2210                 arguments.add(attrStringPortMinus);
2211                 res = fd.evaluate(null, arguments);
2212                 assertTrue(res.isOk());
2213                 resValue = (IPAddress)res.getValue().getValue();
2214                 try {
2215                         assertEquals(new IPv6Address(addrv6Shorts, null, PortRange.newInstance("123-")), resValue);
2216                 } catch (ParseException e) {
2217                         fail("port error e="+e);
2218                 }
2219
2220                 arguments.clear();
2221                 arguments.add(attrStringPortPort);
2222                 res = fd.evaluate(null, arguments);
2223                 assertTrue(res.isOk());
2224                 resValue = (IPAddress)res.getValue().getValue();
2225                 try {
2226                         assertEquals(new IPv6Address(addrv6Shorts, null, PortRange.newInstance("1234567-432")), resValue);
2227                 } catch (ParseException e) {
2228                         fail("port error e="+e);
2229                 }
2230
2231                 // ":" without port
2232                 arguments.clear();
2233                 arguments.add(attrStringNoPort);
2234                 res = fd.evaluate(null, arguments);
2235                 assertFalse(res.isOk());
2236                 assertEquals("function:ipAddress-from-string Invalid IPv6 address string \"[2001:db8:85a3:0:0:8a2e:370:1]:\": no portrange given after ':'", res.getStatus().getStatusMessage());
2237                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2238
2239
2240                 // bad port number
2241                 arguments.clear();
2242                 arguments.add(attrStringBadPort);
2243                 res = fd.evaluate(null, arguments);
2244                 assertFalse(res.isOk());
2245                 assertEquals("function:ipAddress-from-string Invalid PortRange \"12.34\": invalid port number", res.getStatus().getStatusMessage());
2246                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2247
2248                 // bad port range
2249                 arguments.clear();
2250                 arguments.add(attrStringTooManyPorts);
2251                 res = fd.evaluate(null, arguments);
2252                 assertFalse(res.isOk());
2253                 assertEquals("function:ipAddress-from-string Invalid PortRange \"-123-456\": too many ranges", res.getStatus().getStatusMessage());
2254                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2255
2256
2257
2258
2259
2260         }
2261
2262         @Test
2263         public void testString_from_ipAddress() {
2264                 FunctionArgumentAttributeValue attrObj1 = null;
2265                 FunctionArgumentAttributeValue attrObjV6 = null;
2266                 FunctionArgumentAttributeValue attrStringBadType = null;
2267                 String objValueString = "123.145.255.255";
2268                 String objValueStringV6 = "[FEDC:BA98:7654:3210:FEDC:BA98:7654:3210]";
2269                 try {
2270                         attrObj1 = new FunctionArgumentAttributeValue(DataTypes.DT_IPADDRESS.createAttributeValue(objValueString));
2271                         attrObjV6 = new FunctionArgumentAttributeValue(DataTypes.DT_IPADDRESS.createAttributeValue(objValueStringV6));
2272
2273                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
2274
2275                 } catch (Exception e) {
2276                         fail("creating attribute e="+ e);
2277                 }
2278
2279                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_STRING_FROM_IPADDRESS;
2280
2281                 // check identity and type of the thing created
2282                 assertEquals(XACML3.ID_FUNCTION_STRING_FROM_IPADDRESS, fd.getId());
2283                 assertEquals(DataTypes.DT_IPADDRESS.getId(), fd.getDataTypeArgs().getId());
2284                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeId());
2285
2286                 // just to be safe...  If tests take too long these can probably be eliminated
2287                 assertFalse(fd.returnsBag());
2288                 assertEquals(new Integer(1), fd.getNumArgs());
2289
2290                 // test normal V4
2291                 arguments.clear();
2292                 arguments.add(attrObj1);
2293                 ExpressionResult res = fd.evaluate(null, arguments);
2294                 assertTrue(res.isOk());
2295                 assertEquals(objValueString, res.getValue().getValue());
2296
2297                 // test normal V6
2298                 arguments.clear();
2299                 arguments.add(attrObjV6);
2300                 res = fd.evaluate(null, arguments);
2301                 assertTrue(res.isOk());
2302                 assertEquals(objValueStringV6.toLowerCase(), res.getValue().getValue());
2303
2304                 // bad arg type
2305                 arguments.clear();
2306                 arguments.add(attrStringBadType);
2307                 res = fd.evaluate(null, arguments);
2308                 assertFalse(res.isOk());
2309                 assertEquals("function:string-from-ipAddress Expected data type 'ipAddress' saw 'integer' at arg index 0", res.getStatus().getStatusMessage());
2310                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2311         }
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322         /**
2323          * RFC2396DomainName
2324          */
2325         @Test
2326         public void testRFC2396DomainName_from_string() {
2327                 FunctionArgumentAttributeValue attrString1 = null;
2328                 FunctionArgumentAttributeValue attrString2 = null;
2329                 FunctionArgumentAttributeValue attrStringMinusPort = null;
2330                 FunctionArgumentAttributeValue attrStringPortMinus = null;
2331                 FunctionArgumentAttributeValue attrStringPortPort = null;
2332                 FunctionArgumentAttributeValue attrStringNoPort = null;
2333                 FunctionArgumentAttributeValue attrStringBadPort = null;
2334                 FunctionArgumentAttributeValue attrStringTooManyPorts = null;
2335
2336                 FunctionArgumentAttributeValue attrStringBadValue = null;
2337                 FunctionArgumentAttributeValue attrStringBadType = null;
2338                 try {
2339                         attrString1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("host"));
2340                         attrString2 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("host.host"));
2341
2342                         attrStringMinusPort = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("host.host:-123"));
2343                         attrStringPortMinus = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("host.host:123-"));
2344                         attrStringPortPort = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("host.host:1234567-432"));
2345                         attrStringNoPort = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("host.host:"));
2346                         attrStringBadPort = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("host.host:12.34"));
2347                         attrStringTooManyPorts = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("host.host:-123-456"));
2348
2349                         attrStringBadValue = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("not valid obj value"));
2350                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
2351
2352                 } catch (Exception e) {
2353                         fail("creating attribute e="+ e);
2354                 }
2355
2356                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_DNSNAME_FROM_STRING;
2357
2358                 // check identity and type of the thing created
2359                 assertEquals(XACML3.ID_FUNCTION_DNSNAME_FROM_STRING, fd.getId());
2360                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeArgs().getId());
2361                 assertEquals(DataTypes.DT_DNSNAME.getId(), fd.getDataTypeId());
2362
2363                 // just to be safe...  If tests take too long these can probably be eliminated
2364                 assertFalse(fd.returnsBag());
2365                 assertEquals(new Integer(1), fd.getNumArgs());
2366
2367                 // test normal
2368                 arguments.clear();
2369                 arguments.add(attrString1);
2370                 ExpressionResult res = fd.evaluate(null, arguments);
2371                 assertTrue(res.isOk());
2372                 RFC2396DomainName resValue = (RFC2396DomainName)res.getValue().getValue();
2373                 assertEquals(new RFC2396DomainName("host", null), resValue);
2374
2375                 arguments.clear();
2376                 arguments.add(attrString2);
2377                 res = fd.evaluate(null, arguments);
2378                 assertTrue(res.isOk());
2379                 resValue = (RFC2396DomainName)res.getValue().getValue();
2380                 assertEquals(new RFC2396DomainName("host.host", null), resValue);
2381
2382
2383                 // portrange (-port, port-, port-port)
2384                 arguments.clear();
2385                 arguments.add(attrStringMinusPort);
2386                 res = fd.evaluate(null, arguments);
2387                 assertTrue(res.isOk());
2388                 resValue = (RFC2396DomainName)res.getValue().getValue();
2389                 try {
2390                         assertEquals(new RFC2396DomainName("host.host", PortRange.newInstance("-123")), resValue);
2391                 } catch (ParseException e) {
2392                         fail("port error e="+e);
2393                 }
2394
2395                 arguments.clear();
2396                 arguments.add(attrStringPortMinus);
2397                 res = fd.evaluate(null, arguments);
2398                 assertTrue(res.isOk());
2399                 resValue = (RFC2396DomainName)res.getValue().getValue();
2400                 try {
2401                         assertEquals(new RFC2396DomainName("host.host", PortRange.newInstance("123-")), resValue);
2402                 } catch (ParseException e) {
2403                         fail("port error e="+e);
2404                 }
2405
2406                 arguments.clear();
2407                 arguments.add(attrStringPortPort);
2408                 res = fd.evaluate(null, arguments);
2409                 assertTrue(res.isOk());
2410                 resValue = (RFC2396DomainName)res.getValue().getValue();
2411                 try {
2412                         assertEquals(new RFC2396DomainName("host.host", PortRange.newInstance("1234567-432")), resValue);
2413                 } catch (ParseException e) {
2414                         fail("port error e="+e);
2415                 }
2416
2417                 // ":" without port
2418                 arguments.clear();
2419                 arguments.add(attrStringNoPort);
2420                 res = fd.evaluate(null, arguments);
2421                 assertFalse(res.isOk());
2422                 assertEquals("function:dnsName-from-string Invalid RFC 2396 port range \"host.host:\": no port numbers", res.getStatus().getStatusMessage());
2423                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2424
2425                 // bad port number
2426                 arguments.clear();
2427                 arguments.add(attrStringBadPort);
2428                 res = fd.evaluate(null, arguments);
2429                 assertFalse(res.isOk());
2430                 assertEquals("function:dnsName-from-string Invalid RFC 2396 port range \"12.34\"", res.getStatus().getStatusMessage());
2431                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2432
2433                 // bad port range
2434                 arguments.clear();
2435                 arguments.add(attrStringTooManyPorts);
2436                 res = fd.evaluate(null, arguments);
2437                 assertFalse(res.isOk());
2438                 assertEquals("function:dnsName-from-string Invalid RFC 2396 port range \"-123-456\"", res.getStatus().getStatusMessage());
2439                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2440
2441                 // bad value
2442                 arguments.clear();
2443                 arguments.add(attrStringBadValue);
2444                 res = fd.evaluate(null, arguments);
2445                 assertFalse(res.isOk());
2446                 assertEquals("function:dnsName-from-string Invalid RFC 2396 host name \"not valid obj value\"", res.getStatus().getStatusMessage());
2447                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:syntax-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2448
2449                 // bad arg type
2450                 arguments.clear();
2451                 arguments.add(attrStringBadType);
2452                 res = fd.evaluate(null, arguments);
2453                 assertFalse(res.isOk());
2454                 assertEquals("function:dnsName-from-string Expected data type 'string' saw 'integer' at arg index 0", res.getStatus().getStatusMessage());
2455                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2456         }
2457
2458         @Test
2459         public void testString_from_dnsName() {
2460                 FunctionArgumentAttributeValue attrObj1 = null;
2461                 FunctionArgumentAttributeValue attrStringBadType = null;
2462                 String objValueString = "someName.com";
2463                 try {
2464                         attrObj1 = new FunctionArgumentAttributeValue(DataTypes.DT_DNSNAME.createAttributeValue(objValueString));
2465                         attrStringBadType = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(123));
2466
2467                 } catch (Exception e) {
2468                         fail("creating attribute e="+ e);
2469                 }
2470
2471                 FunctionDefinitionStringConversion<?, ?> fd = (FunctionDefinitionStringConversion<?, ?>) StdFunctions.FD_STRING_FROM_DNSNAME;
2472
2473                 // check identity and type of the thing created
2474                 assertEquals(XACML3.ID_FUNCTION_STRING_FROM_DNSNAME, fd.getId());
2475                 assertEquals(DataTypes.DT_DNSNAME.getId(), fd.getDataTypeArgs().getId());
2476                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeId());
2477
2478                 // just to be safe...  If tests take too long these can probably be eliminated
2479                 assertFalse(fd.returnsBag());
2480                 assertEquals(new Integer(1), fd.getNumArgs());
2481
2482                 // test normal
2483                 arguments.clear();
2484                 arguments.add(attrObj1);
2485                 ExpressionResult res = fd.evaluate(null, arguments);
2486                 assertTrue(res.isOk());
2487                 assertEquals(objValueString, res.getValue().getValue());
2488
2489                 // bad arg type
2490                 arguments.clear();
2491                 arguments.add(attrStringBadType);
2492                 res = fd.evaluate(null, arguments);
2493                 assertFalse(res.isOk());
2494                 assertEquals("function:string-from-dnsName Expected data type 'dnsName' saw 'integer' at arg index 0", res.getStatus().getStatusMessage());
2495                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
2496         }
2497
2498
2499
2500
2501
2502
2503
2504 }