/*
|
* CDDL HEADER START
|
*
|
* The contents of this file are subject to the terms of the
|
* Common Development and Distribution License, Version 1.0 only
|
* (the "License"). You may not use this file except in compliance
|
* with the License.
|
*
|
* You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
|
* or http://forgerock.org/license/CDDLv1.0.html.
|
* See the License for the specific language governing permissions
|
* and limitations under the License.
|
*
|
* When distributing Covered Code, include this CDDL HEADER in each
|
* file and include the License file at legal-notices/CDDLv1_0.txt.
|
* If applicable, add the following below this CDDL HEADER, with the
|
* fields enclosed by brackets "[]" replaced with your own identifying
|
* information:
|
* Portions Copyright [yyyy] [name of copyright owner]
|
*
|
* CDDL HEADER END
|
*
|
*
|
* Copyright 2008 Sun Microsystems, Inc.
|
*/
|
|
package org.forgerock.opendj.config;
|
|
import static org.fest.assertions.Assertions.assertThat;
|
import static org.testng.Assert.assertEquals;
|
import static org.testng.Assert.assertNotNull;
|
|
import org.forgerock.opendj.server.config.meta.RootCfgDefn;
|
import org.testng.annotations.DataProvider;
|
import org.testng.annotations.Test;
|
|
@SuppressWarnings("javadoc")
|
public class DurationPropertyDefinitionTest extends ConfigTestCase {
|
|
@Test
|
public void testCreateBuilder() {
|
DurationPropertyDefinition.Builder builder = createTestBuilder();
|
assertNotNull(builder);
|
}
|
|
/**
|
* Creates data for testing string-based limit values
|
*
|
* @return data
|
*/
|
@DataProvider(name = "longLimitData")
|
Object[][] createLongLimitData() {
|
return new Object[][] {
|
{ 1L, 1L },
|
};
|
}
|
|
/**
|
* Creates data for testing limit values
|
*
|
* @return data
|
*/
|
@DataProvider(name = "illegalLongLimitData")
|
Object[][] createIllegalLongLimitData() {
|
return new Object[][] {
|
// lower, upper, lower first
|
{ -1L, 0L, true },
|
{ 0L, -1L, false },
|
{ 2L, 1L, true },
|
{ 2L, 1L, false } };
|
}
|
|
@DataProvider(name = "stringLimitData")
|
Object[][] createStringLimitData() {
|
return new Object[][] {
|
// unit, limit, expected value
|
{ "ms", "123", 123 },
|
{ "ms", "123s", 123000 },
|
{ "s", "123", 123000 },
|
{ "s", "123s", 123000 },
|
{ "m", "10", 600000 },
|
{ "m", "10s", 10000 } };
|
}
|
|
@Test(dataProvider = "longLimitData")
|
public void testLowerLimitWithLong(long lowerLimit, long expectedValue) {
|
DurationPropertyDefinition.Builder builder = createTestBuilder();
|
builder.setLowerLimit(lowerLimit);
|
DurationPropertyDefinition def = buildTestDefinition(builder);
|
assertEquals(def.getLowerLimit(), expectedValue);
|
}
|
|
@Test(dataProvider = "stringLimitData")
|
public void testLowerLimitWithString(String unit, String limitValue, long expected) {
|
DurationPropertyDefinition.Builder builder = createTestBuilder();
|
builder.setBaseUnit(DurationUnit.getUnit(unit));
|
builder.setLowerLimit(limitValue);
|
DurationPropertyDefinition def = buildTestDefinition(builder);
|
assertEquals(def.getLowerLimit(), expected);
|
}
|
|
@Test(dataProvider = "longLimitData")
|
public void testUpperLimitWithLong(long upperLimit, long expectedValue) {
|
DurationPropertyDefinition.Builder builder = createTestBuilder();
|
builder.setUpperLimit(upperLimit);
|
DurationPropertyDefinition def = buildTestDefinition(builder);
|
assertEquals((long) def.getUpperLimit(), expectedValue);
|
}
|
|
@Test(dataProvider = "illegalLongLimitData", expectedExceptions = IllegalArgumentException.class)
|
public void testIllegalLimitsWithLong(long lowerLimit, long upperLimit, boolean isLowerFirst) {
|
DurationPropertyDefinition.Builder builder = createTestBuilder();
|
if (isLowerFirst) {
|
builder.setLowerLimit(lowerLimit);
|
builder.setUpperLimit(upperLimit);
|
} else {
|
builder.setUpperLimit(upperLimit);
|
builder.setLowerLimit(lowerLimit);
|
}
|
}
|
|
@Test
|
public void testAllowUnlimitedIsTrue() {
|
DurationPropertyDefinition.Builder builder = createTestBuilder();
|
builder.setAllowUnlimited(true);
|
DurationPropertyDefinition def = buildTestDefinition(builder);
|
def.decodeValue("unlimited");
|
}
|
|
@Test(expectedExceptions = PropertyException.class)
|
public void testAllowUnlimitedIsFalse() {
|
DurationPropertyDefinition.Builder builder = createTestBuilder();
|
builder.setAllowUnlimited(false);
|
DurationPropertyDefinition def = buildTestDefinition(builder);
|
def.decodeValue("unlimited");
|
}
|
|
@Test(expectedExceptions = PropertyException.class)
|
public void testAllowUnlimitedIsFalseNumValue() {
|
DurationPropertyDefinition.Builder builder = createTestBuilder();
|
builder.setAllowUnlimited(false);
|
DurationPropertyDefinition def = buildTestDefinition(builder);
|
def.validateValue(-1L);
|
}
|
|
@DataProvider(name = "validateValueData")
|
Object[][] createValidateValueData() {
|
return new Object[][] {
|
// low in ms, high in ms, allow unlimited, value in seconds
|
{ 5000L, 10000L, false, 7L },
|
{ 5000L, null, true, -1L },
|
{ 5000L, 10000L, false, 5L },
|
{ 5000L, 10000L, false, 10L },
|
{ 5000L, null, false, 10000L }
|
};
|
}
|
|
@Test(dataProvider = "validateValueData")
|
public void testValidateValue(Long lowerLimitInMillis, Long higherLimitInMillis,
|
boolean isAllowUnlimited, Long valueInSeconds) {
|
DurationPropertyDefinition.Builder builder = createTestBuilder();
|
builder.setLowerLimit(lowerLimitInMillis);
|
builder.setUpperLimit(higherLimitInMillis);
|
builder.setAllowUnlimited(isAllowUnlimited);
|
DurationPropertyDefinition def = buildTestDefinition(builder);
|
def.validateValue(valueInSeconds);
|
}
|
|
@DataProvider(name = "illegalValidateValueData")
|
Object[][] createIllegalValidateValueData() {
|
return new Object[][] {
|
// low in ms, high in ms, allow unlimited, value in seconds
|
{ 5000L, 10000L, false, null },
|
{ 5000L, 10000L, false, 1L },
|
{ 5000L, 10000L, false, 11L },
|
{ 5000L, 10000L, false, -1L } };
|
}
|
|
@Test(dataProvider = "illegalValidateValueData", expectedExceptions = { AssertionError.class,
|
NullPointerException.class, PropertyException.class })
|
public void testValidateValueIllegal(Long lowLimitInMillis, Long highLimitInMillis,
|
boolean isAllowUnlimited, Long valueInSeconds) {
|
DurationPropertyDefinition.Builder builder = createTestBuilder();
|
builder.setLowerLimit(lowLimitInMillis);
|
builder.setUpperLimit(highLimitInMillis);
|
builder.setAllowUnlimited(isAllowUnlimited);
|
DurationPropertyDefinition def = buildTestDefinition(builder);
|
def.validateValue(valueInSeconds);
|
}
|
|
@DataProvider(name = "encodeValueData")
|
Object[][] createEncodeValueData() {
|
return new Object[][] {
|
{ -1L, "unlimited" },
|
{ 0L, "0 s" },
|
{ 1L, "1 s" },
|
{ 2L, "2 s" },
|
{ 999L, "999 s" },
|
{ 1000L, "1000 s" },
|
{ 1001L, "1001 s" },
|
{ 1023L, "1023 s" },
|
{ 1024L, "1024 s" },
|
{ 1025L, "1025 s" },
|
{ 1000L * 1000L, "1000000 s" },
|
};
|
}
|
|
@Test(dataProvider = "encodeValueData")
|
public void testEncodeValue(Long valueToEncode, String expectedValue) {
|
DurationPropertyDefinition.Builder builder = createTestBuilder();
|
builder.setAllowUnlimited(true);
|
DurationPropertyDefinition def = buildTestDefinition(builder);
|
assertEquals(def.encodeValue(valueToEncode), expectedValue);
|
}
|
|
/** Test that accept doesn't throw and exception */
|
@Test
|
public void testAccept() {
|
DurationPropertyDefinition.Builder builder = createTestBuilder();
|
builder.setAllowUnlimited(true);
|
DurationPropertyDefinition def = buildTestDefinition(builder);
|
PropertyDefinitionVisitor<Boolean, Void> v = new PropertyDefinitionVisitor<Boolean, Void>() {
|
public Boolean visitDuration(DurationPropertyDefinition d, Void o) {
|
return true;
|
}
|
@SuppressWarnings("unused")
|
public Boolean visitUnknown(PropertyDefinition<?> d, Void o) throws PropertyException {
|
return false;
|
}
|
};
|
|
assertEquals((boolean) def.accept(v, null), true);
|
}
|
|
/** Make sure toString doesn't barf */
|
@Test
|
public void testToString() {
|
DurationPropertyDefinition.Builder builder = createTestBuilder();
|
builder.setAllowUnlimited(true);
|
DurationPropertyDefinition def = buildTestDefinition(builder);
|
def.toString();
|
}
|
|
/** Make sure toString doesn't barf */
|
@Test
|
public void testToString2() {
|
DurationPropertyDefinition.Builder builder = createTestBuilder();
|
builder.setUpperLimit(10L);
|
DurationPropertyDefinition def = buildTestDefinition(builder);
|
def.toString();
|
}
|
|
@Test
|
public void testCompare() {
|
DurationPropertyDefinition.Builder builder = createTestBuilder();
|
builder.setAllowUnlimited(true);
|
DurationPropertyDefinition def = buildTestDefinition(builder);
|
def.compare(1L, 2L);
|
}
|
|
@Test
|
public void testSetDefaultBehaviorProvider() {
|
DurationPropertyDefinition.Builder builder = createTestBuilder();
|
builder.setAllowUnlimited(true);
|
builder.setDefaultBehaviorProvider(new DefaultBehaviorProvider<Long>() {
|
public <R, P> R accept(DefaultBehaviorProviderVisitor<Long, R, P> v, P p) {
|
return null;
|
}
|
});
|
}
|
|
@Test
|
public void testSetPropertyOption() {
|
DurationPropertyDefinition.Builder builder = createTestBuilder();
|
builder.setOption(PropertyOption.HIDDEN);
|
}
|
|
@DataProvider(name = "decodeValueData")
|
Object[][] createDecodeValueData() {
|
return new Object[][] {
|
// syntax tests
|
{ "unlimited", -1L },
|
{ "0h", 0L },
|
{ "0.0h", 0L },
|
{ "0.00h", 0L },
|
{ "0 h", 0L },
|
{ "0.00 h", 0L },
|
{ "1h", 1L },
|
{ "1 h", 1L },
|
{ "0ms", 0L },
|
{ "1h60m", 2L },
|
{ "1d10h", 34L },
|
{ "4d600m", 106L },
|
|
// conversion tests
|
{ "1 d", 24L }, { "2 d", 48L }, { "0.5 d", 12L } };
|
}
|
|
@Test(dataProvider = "decodeValueData")
|
public void testDecodeValue(String valueToDecode, Long expectedValue) {
|
DurationPropertyDefinition.Builder builder = createTestBuilder();
|
builder.setAllowUnlimited(true);
|
builder.setBaseUnit(DurationUnit.HOURS);
|
builder.setMaximumUnit(DurationUnit.DAYS);
|
DurationPropertyDefinition def = buildTestDefinition(builder);
|
|
assertThat(def.decodeValue(valueToDecode)).
|
isEqualTo(expectedValue);
|
}
|
|
@DataProvider(name = "decodeValueDataIllegal")
|
Object[][] createDecodeValueDataIllegal() {
|
return new Object[][] { { "" }, { "0" }, // no unit
|
{ "123" }, // no unit
|
{ "a s" },
|
{ "1 x" },
|
{ "0.h" },
|
{ "0. h" },
|
{ "1.h" },
|
{ "1. h" },
|
{ "1.1 h" }, // too granular
|
{ "30 m" }, // unit too small violation
|
{ "60 m" }, // unit too small violation
|
{ "1 w" }, // unit too big violation
|
{ "7 w" }, // unit too big violation
|
{ "1 x" }, { "1 d" }, // upper limit violation
|
{ "2 h" }, // lower limit violation
|
{ "-1 h" } // unlimited violation
|
};
|
}
|
|
@Test(dataProvider = "decodeValueDataIllegal", expectedExceptions = { PropertyException.class })
|
public void testDecodeValue(String valueToDecode) {
|
DurationPropertyDefinition.Builder builder = createTestBuilder();
|
builder.setAllowUnlimited(false);
|
builder.setBaseUnit(DurationUnit.HOURS);
|
builder.setMaximumUnit(DurationUnit.DAYS);
|
builder.setLowerLimit(5L);
|
builder.setUpperLimit(10L);
|
DurationPropertyDefinition def = buildTestDefinition(builder);
|
def.decodeValue(valueToDecode);
|
}
|
|
private DurationPropertyDefinition.Builder createTestBuilder() {
|
return DurationPropertyDefinition.createBuilder(RootCfgDefn.getInstance(), "test-property-name");
|
}
|
|
private DurationPropertyDefinition buildTestDefinition(DurationPropertyDefinition.Builder builder) {
|
builder.setDefaultBehaviorProvider(new DefinedDefaultBehaviorProvider<Long>("0"));
|
return builder.getInstance();
|
}
|
|
}
|
