| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package org.apache.felix.metatype; |
| |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.Map; |
| |
| import junit.framework.TestCase; |
| |
| /** |
| * Test cases for {@link ADValidator}. |
| * |
| * @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a> |
| */ |
| public class ADValidatorTest extends TestCase |
| { |
| /** |
| * Tests the validation of boolean is only done minimally. |
| */ |
| public void testValidateBoolean() |
| { |
| AD ad = new AD(); |
| ad.setType("Boolean"); |
| ad.setRequired(false); |
| |
| // optional value |
| assertEquals("", ADValidator.validate(ad, null)); |
| // adhere minimal value |
| assertEquals("", ADValidator.validate(ad, "true")); |
| // adhere maximal value |
| assertEquals("", ADValidator.validate(ad, "false")); |
| // not a valid value |
| assertEquals(AD.VALIDATE_INVALID_VALUE, ADValidator.validate(ad, "foobar")); |
| |
| ad.setCardinality(3); // up to three values are allowed... |
| |
| // optional value |
| assertEquals("", ADValidator.validate(ad, null)); |
| // 2nd value is missing, but that's ok... |
| assertEquals("", ADValidator.validate(ad, "true,,false")); |
| |
| ad.setRequired(true); |
| |
| // mandatory value |
| assertEquals(AD.VALIDATE_MISSING, ADValidator.validate(ad, null)); |
| // 2nd value is missing |
| assertEquals(AD.VALIDATE_MISSING, ADValidator.validate(ad, "false,,true")); |
| // correct values |
| assertEquals("", ADValidator.validate(ad, "false, true, false")); |
| // correct values |
| assertEquals(AD.VALIDATE_INVALID_VALUE, ADValidator.validate(ad, "false, yessir, false")); |
| |
| ad.setOptions(Collections.singletonMap("true", "Yes!")); |
| |
| assertEquals(null, ADValidator.validate(ad, "false, true, false")); |
| } |
| |
| /** |
| * Tests the validation of bytes works and uses the correct minimum and maximum values. |
| */ |
| public void testValidateByte() |
| { |
| AD ad = new AD(); |
| ad.setType("Byte"); |
| ad.setRequired(false); |
| |
| // optional value |
| assertEquals("", ADValidator.validate(ad, null)); |
| assertEquals("", ADValidator.validate(ad, "")); |
| |
| ad.setRequired(true); |
| |
| // mandatory value |
| assertEquals(AD.VALIDATE_MISSING, ADValidator.validate(ad, "")); |
| // value too small |
| assertEquals(AD.VALIDATE_INVALID_VALUE, ADValidator.validate(ad, "-129")); |
| // value too small |
| assertEquals("", ADValidator.validate(ad, "-128")); |
| // value within bounds |
| assertEquals("", ADValidator.validate(ad, "0")); |
| // value within bounds |
| assertEquals("", ADValidator.validate(ad, "127")); |
| // value is invalid |
| assertEquals(AD.VALIDATE_INVALID_VALUE, ADValidator.validate(ad, "128")); |
| |
| ad.setMin("0"); |
| ad.setMax("128"); // !!! this is an invalid value for maximum, this means that we cannot do this validation... |
| |
| // value too small |
| assertEquals(AD.VALIDATE_LESS_THAN_MINIMUM, ADValidator.validate(ad, "-1")); |
| // value within bounds |
| assertEquals("", ADValidator.validate(ad, "0")); |
| // value within bounds |
| assertEquals("", ADValidator.validate(ad, "127")); |
| // value is invalid |
| assertEquals(AD.VALIDATE_INVALID_VALUE, ADValidator.validate(ad, "128")); |
| } |
| |
| /** |
| * Tests the validation of characters with only limited set of options. |
| */ |
| public void testValidateCharacter() |
| { |
| AD ad = new AD(); |
| ad.setType("Char"); |
| ad.setRequired(false); |
| |
| // optional value |
| assertEquals("", ADValidator.validate(ad, null)); |
| // option too long |
| assertEquals(AD.VALIDATE_GREATER_THAN_MAXIMUM, ADValidator.validate(ad, "ab")); |
| // adhere first option value |
| assertEquals("", ADValidator.validate(ad, "b")); |
| // adhere last option value |
| assertEquals("", ADValidator.validate(ad, "e")); |
| |
| ad.setCardinality(3); // up to three values are allowed... |
| |
| // mandatory value |
| assertEquals("", ADValidator.validate(ad, "")); |
| // 2nd value is missing |
| assertEquals("", ADValidator.validate(ad, "b,,c")); |
| |
| ad.setRequired(true); |
| |
| // mandatory value |
| assertEquals(AD.VALIDATE_MISSING, ADValidator.validate(ad, null)); |
| // 2nd value is missing |
| assertEquals(AD.VALIDATE_MISSING, ADValidator.validate(ad, "b,,c")); |
| // adhere minimal values |
| assertEquals("", ADValidator.validate(ad, "b, c, d")); |
| // adhere maximal values |
| assertEquals("", ADValidator.validate(ad, "c, d, e")); |
| |
| Map<String, String> options = new HashMap<>(); |
| options.put("b", "B"); |
| options.put("c", "C"); |
| options.put("d", "D"); |
| options.put("e", "E"); |
| |
| ad.setOptions(options); |
| // no option given |
| assertEquals(AD.VALIDATE_MISSING, ADValidator.validate(ad, "")); |
| // invalid option |
| assertEquals(AD.VALIDATE_NOT_A_VALID_OPTION, ADValidator.validate(ad, "a")); |
| // too great |
| assertEquals(AD.VALIDATE_NOT_A_VALID_OPTION, ADValidator.validate(ad, "f")); |
| // 2nd value is too less |
| assertEquals(AD.VALIDATE_NOT_A_VALID_OPTION, ADValidator.validate(ad, "b,a,c")); |
| // 3rd value is too great |
| assertEquals(AD.VALIDATE_NOT_A_VALID_OPTION, ADValidator.validate(ad, "d, e, f")); |
| |
| ad.setMin("b"); |
| ad.setMax("c"); |
| ad.setOptions(Collections.emptyMap()); |
| |
| // adhere minimal values |
| assertEquals("", ADValidator.validate(ad, "b, c, b")); |
| // d is too great |
| assertEquals(AD.VALIDATE_GREATER_THAN_MAXIMUM, ADValidator.validate(ad, "b, c, d")); |
| // a is too small |
| assertEquals(AD.VALIDATE_LESS_THAN_MINIMUM, ADValidator.validate(ad, "a, b, c")); |
| } |
| |
| /** |
| * Tests the validation of double value works as expected. |
| */ |
| public void testValidateDouble() |
| { |
| AD ad = new AD(); |
| ad.setType("Double"); |
| ad.setRequired(false); |
| |
| ad.setMin("-123.45"); |
| ad.setMax("+123.45"); |
| |
| // Value is too small... |
| assertEquals(AD.VALIDATE_LESS_THAN_MINIMUM, ADValidator.validate(ad, "-123.4501")); |
| // Value is within range... |
| assertEquals("", ADValidator.validate(ad, "-123.45000")); |
| // Value is within range... |
| assertEquals("", ADValidator.validate(ad, "123.45000")); |
| // Value is too great... |
| assertEquals(AD.VALIDATE_GREATER_THAN_MAXIMUM, ADValidator.validate(ad, "123.4501")); |
| |
| Map options = new HashMap(); |
| options.put("1.1", "B"); |
| options.put("2.2", "C"); |
| options.put("3.3", "D"); |
| options.put("4.4", "E"); |
| |
| ad.setOptions(options); |
| |
| // optional value |
| assertEquals("", ADValidator.validate(ad, null)); |
| // invalid option |
| assertEquals(AD.VALIDATE_NOT_A_VALID_OPTION, ADValidator.validate(ad, "1.0")); |
| // adhere first option value |
| assertEquals("", ADValidator.validate(ad, "1.1")); |
| // adhere last option value |
| assertEquals("", ADValidator.validate(ad, "4.4")); |
| // too great |
| assertEquals(AD.VALIDATE_NOT_A_VALID_OPTION, ADValidator.validate(ad, "4.5")); |
| |
| ad.setCardinality(3); // up to three values are allowed... |
| ad.setRequired(true); |
| |
| // mandatory value |
| assertEquals(AD.VALIDATE_MISSING, ADValidator.validate(ad, null)); |
| // 2nd value is too less |
| assertEquals(AD.VALIDATE_NOT_A_VALID_OPTION, ADValidator.validate(ad, "1.1,1.0,2.2")); |
| // adhere minimal values |
| assertEquals("", ADValidator.validate(ad, "1.1, 2.2, 3.3")); |
| // adhere maximal values |
| assertEquals("", ADValidator.validate(ad, "2.2, 3.3, 4.4")); |
| // 3rd value is too great |
| assertEquals(AD.VALIDATE_NOT_A_VALID_OPTION, ADValidator.validate(ad, "3.3, 4.4, 5.5")); |
| } |
| |
| /** |
| * Tests the validation of integers is based on the minimum and maximum values. |
| */ |
| public void testValidateInteger() |
| { |
| AD ad = new AD(); |
| ad.setType("Integer"); |
| ad.setMin("3"); // only values greater than 2 |
| ad.setMax("6"); // only values less than 7 |
| ad.setRequired(false); |
| |
| // optional value |
| assertEquals("", ADValidator.validate(ad, null)); |
| assertEquals("", ADValidator.validate(ad, "")); |
| // too less |
| assertEquals(AD.VALIDATE_LESS_THAN_MINIMUM, ADValidator.validate(ad, "2")); |
| // adhere minimal value |
| assertEquals("", ADValidator.validate(ad, "3")); |
| // adhere maximal value |
| assertEquals("", ADValidator.validate(ad, "6")); |
| // too great |
| assertEquals(AD.VALIDATE_GREATER_THAN_MAXIMUM, ADValidator.validate(ad, "7")); |
| |
| ad.setCardinality(3); // up to three values are allowed... |
| |
| // mandatory value |
| assertEquals("", ADValidator.validate(ad, null)); |
| // 2nd value is missing |
| assertEquals("", ADValidator.validate(ad, "3,,3")); |
| |
| ad.setRequired(true); |
| |
| // mandatory value |
| assertEquals(AD.VALIDATE_MISSING, ADValidator.validate(ad, null)); |
| // 2nd value is missing |
| assertEquals(AD.VALIDATE_MISSING, ADValidator.validate(ad, "3,,3")); |
| // 2nd value is invalid |
| assertEquals(AD.VALIDATE_INVALID_VALUE, ADValidator.validate(ad, "3,a,3")); |
| // 2nd value is too less |
| assertEquals(AD.VALIDATE_LESS_THAN_MINIMUM, ADValidator.validate(ad, "3,2,3")); |
| // adhere minimal values |
| assertEquals("", ADValidator.validate(ad, "3, 4, 5")); |
| // adhere maximal values |
| assertEquals("", ADValidator.validate(ad, "6, 5, 4")); |
| // 3rd value is too great |
| assertEquals(AD.VALIDATE_GREATER_THAN_MAXIMUM, ADValidator.validate(ad, "5, 6, 7")); |
| } |
| |
| /** |
| * Tests the validation of long values works as expected. |
| */ |
| public void testValidateLong() |
| { |
| AD ad = new AD(); |
| ad.setType("Long"); |
| ad.setRequired(true); |
| |
| ad.setMin("-20"); |
| ad.setMax("-15"); |
| |
| // value too small |
| assertEquals(AD.VALIDATE_LESS_THAN_MINIMUM, ADValidator.validate(ad, "-21")); |
| // value within bounds |
| assertEquals("", ADValidator.validate(ad, "-15")); |
| // value within bounds |
| assertEquals("", ADValidator.validate(ad, "-20")); |
| // value too great |
| assertEquals(AD.VALIDATE_GREATER_THAN_MAXIMUM, ADValidator.validate(ad, "-14")); |
| |
| // Set minimum and maximum beyond the range of plain integers... |
| ad.setMin("2147483650"); |
| ad.setMax("2147483655"); |
| |
| // value too small |
| assertEquals(AD.VALIDATE_LESS_THAN_MINIMUM, ADValidator.validate(ad, "2147483649")); |
| // value within bounds |
| assertEquals("", ADValidator.validate(ad, "2147483650")); |
| // value within bounds |
| assertEquals("", ADValidator.validate(ad, "2147483655")); |
| // value too great |
| assertEquals(AD.VALIDATE_GREATER_THAN_MAXIMUM, ADValidator.validate(ad, "2147483656")); |
| } |
| |
| /** |
| * Tests the validation of strings is based on the minimum and maximum lengths. |
| */ |
| public void testValidateString() |
| { |
| AD ad = new AD(); |
| ad.setType("String"); |
| ad.setRequired(false); |
| |
| // optional value |
| assertEquals("", ADValidator.validate(ad, null)); |
| // any length of input is accepted |
| assertEquals("", ADValidator.validate(ad, "1234567890")); |
| |
| ad.setMin("3"); // minimal length == 3 |
| ad.setMax("6"); // maximum length == 6 |
| |
| // too short |
| assertEquals(AD.VALIDATE_LESS_THAN_MINIMUM, ADValidator.validate(ad, "12")); |
| // adhere minimum length |
| assertEquals("", ADValidator.validate(ad, "123")); |
| // adhere maximum length |
| assertEquals("", ADValidator.validate(ad, "12356")); |
| // too long |
| assertEquals(AD.VALIDATE_GREATER_THAN_MAXIMUM, ADValidator.validate(ad, "1234567")); |
| |
| ad.setCardinality(3); // up to three values are allowed... |
| ad.setMin(""); |
| |
| // optional value |
| assertEquals("", ADValidator.validate(ad, null)); |
| // 2nd value is empty; but that's ok |
| assertEquals("", ADValidator.validate(ad, "321, , 123")); |
| |
| ad.setRequired(true); |
| ad.setMin("3"); |
| |
| |
| // mandatory value |
| assertEquals(AD.VALIDATE_MISSING, ADValidator.validate(ad, null)); |
| // 2nd value is too short |
| assertEquals(AD.VALIDATE_LESS_THAN_MINIMUM, ADValidator.validate(ad, "321,12,123")); |
| // 2nd value is empty and therefore too short |
| assertEquals(AD.VALIDATE_LESS_THAN_MINIMUM, ADValidator.validate(ad, "321, , 123")); |
| // adhere minimum lengths |
| assertEquals("", ADValidator.validate(ad, "123, 123, 123")); |
| // adhere maximum lengths |
| assertEquals("", ADValidator.validate(ad, "12356, 654321, 123456")); |
| // 3rd value is too long |
| assertEquals(AD.VALIDATE_GREATER_THAN_MAXIMUM, ADValidator.validate(ad, "123, 123, 1234567")); |
| |
| ad.setOptions(Collections.singletonMap("123", "foo")); |
| |
| // adhere minimum lengths |
| assertEquals("", ADValidator.validate(ad, "123, 123, 123")); |
| assertEquals(AD.VALIDATE_NOT_A_VALID_OPTION, ADValidator.validate(ad, "2134")); |
| } |
| } |