/*
* 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.batik.css.engine.value;
import java.util.StringTokenizer;
import org.w3c.css.sac.LexicalUnit;
import org.apache.batik.css.engine.value.svg.MarkerManager;
import org.apache.batik.css.engine.value.svg.OpacityManager;
import org.apache.batik.css.engine.value.svg.SVGColorManager;
import org.apache.batik.css.engine.value.svg.SVGPaintManager;
import org.apache.batik.css.engine.value.svg.SpacingManager;
import org.apache.batik.css.parser.Parser;
import org.apache.batik.test.AbstractTest;
import org.apache.batik.test.DefaultTestReport;
import org.apache.batik.test.TestReport;
import org.apache.batik.util.CSSConstants;
/**
* The class to test the CSS properties's manager.
*
* @author <a href="mailto:Thierry.Kormann@sophia.inria.fr">Thierry Kormann</a>
* @version $Id$
*/
public class PropertyManagerTest extends AbstractTest {
/**
* The error code for the 'is inherited' test.
*/
public static final String ERROR_IS_INHERITED =
"PropertyManagerTest.error.inherited";
/**
* The error code if the property does not support the 'inherit' value.
*/
public static final String ERROR_INHERIT_VALUE =
"PropertyManagerTest.error.inherit.value";
/**
* The error code for the 'default value' test.
*/
public static final String ERROR_INVALID_DEFAULT_VALUE =
"PropertyManagerTest.error.invalid.default.value";
/**
* The error code for an invalid property value.
*/
public static final String ERROR_INVALID_VALUE =
"PropertyManagerTest.error.invalid.value";
/**
* The error code if an exception occured while creating the manager.
*/
public static final String ERROR_INSTANTIATION =
"PropertyManagerTest.error.instantiation";
/**
* The class of the manager.
*/
protected String managerClassName;
/**
* This flag bit indicates whether or not the property is inherited.
*/
protected Boolean isInherited;
/**
* The candidate values of the property.
*/
protected String [] identValues;
/**
* The candidate default value of the property.
*/
protected String defaultValue;
/**
* Constructs a new test for the specified manager classname.
*
* @param managerClassName the classname of the manager to test
* @param isInherited the expected flag to see if the property is inherited
* @param defaultValue the default value
* @param identValueList the list of possible identifiers
*/
public PropertyManagerTest(String managerClassName,
Boolean isInherited,
String defaultValue,
String identValueList) {
this.managerClassName = managerClassName;
this.isInherited = isInherited;
this.defaultValue = defaultValue;
StringTokenizer tokens = new StringTokenizer(identValueList, "|");
int nbIdentValue = tokens.countTokens();
if (nbIdentValue > 0) {
identValues = new String[nbIdentValue];
for (int i=0; tokens.hasMoreTokens(); ++i) {
identValues[i] = tokens.nextToken().trim();
}
}
}
/**
* Creates the value manager.
*/
protected ValueManager createValueManager() throws Exception {
return (ValueManager)Class.forName(managerClassName).newInstance();
}
/**
* Runs this test. This method will only throw exceptions if some aspect of
* the test's internal operation fails.
*/
public TestReport runImpl() throws Exception {
DefaultTestReport report = new DefaultTestReport(this);
ValueManager manager;
try {
manager = createValueManager();
} catch (Exception ex) {
report.setErrorCode(ERROR_INSTANTIATION);
report.setPassed(false);
report.addDescriptionEntry(ERROR_INSTANTIATION, ex.getMessage());
return report;
}
// test default value if any
if (!defaultValue.equals("__USER_AGENT__")) {
String s = manager.getDefaultValue().getCssText();
if (!defaultValue.equalsIgnoreCase(s)) {
report.setErrorCode(ERROR_INVALID_DEFAULT_VALUE);
report.setPassed(false);
report.addDescriptionEntry(ERROR_INVALID_DEFAULT_VALUE,
"should be: "+defaultValue);
}
}
// test if the property is inherited or not
if (isInherited.booleanValue() != manager.isInheritedProperty()) {
report.setErrorCode(ERROR_IS_INHERITED);
report.setPassed(false);
report.addDescriptionEntry(ERROR_IS_INHERITED, "");
}
Parser cssParser = new Parser();
// see if the property supports the value 'inherit'
try {
LexicalUnit lu = cssParser.parsePropertyValue("inherit");
Value v = manager.createValue(lu, null);
String s = v.getCssText();
if (!"inherit".equalsIgnoreCase(s)) {
report.setErrorCode(ERROR_INHERIT_VALUE);
report.setPassed(false);
report.addDescriptionEntry(ERROR_INHERIT_VALUE, "inherit");
}
} catch (Exception ex) {
report.setErrorCode(ERROR_INHERIT_VALUE);
report.setPassed(false);
report.addDescriptionEntry(ERROR_INHERIT_VALUE, ex.getMessage());
}
// test all possible identifiers
if (identValues != null) {
try {
for (int i=0; i < identValues.length; ++i) {
LexicalUnit lu = cssParser.parsePropertyValue(identValues[i]);
Value v = manager.createValue(lu, null);
String s = v.getCssText();
if (!identValues[i].equalsIgnoreCase(s)) {
report.setErrorCode(ERROR_INVALID_VALUE);
report.setPassed(false);
report.addDescriptionEntry(ERROR_INVALID_VALUE,
identValues[i]+ '/' +s);
}
}
} catch (Exception ex) {
report.setErrorCode(ERROR_INVALID_VALUE);
report.setPassed(false);
report.addDescriptionEntry(ERROR_INVALID_VALUE,
ex.getMessage());
}
}
return report;
}
/**
* Manager for 'fill'.
*/
public static class FillManager extends SVGPaintManager {
public FillManager() {
super(CSSConstants.CSS_FILL_PROPERTY);
}
}
/**
* Manager for 'fill-opacity'.
*/
public static class FillOpacityManager extends OpacityManager {
public FillOpacityManager() {
super(CSSConstants.CSS_FILL_OPACITY_PROPERTY, true);
}
}
/**
* Manager for 'flood-color'.
*/
public static class FloodColorManager extends SVGColorManager {
public FloodColorManager() {
super(CSSConstants.CSS_FLOOD_COLOR_PROPERTY);
}
}
/**
* Manager for 'flood-opacity'.
*/
public static class FloodOpacityManager extends OpacityManager {
public FloodOpacityManager() {
super(CSSConstants.CSS_FLOOD_OPACITY_PROPERTY, false);
}
}
/**
* Manager for 'letter-spacing'.
*/
public static class LetterSpacingManager extends SpacingManager {
public LetterSpacingManager() {
super(CSSConstants.CSS_LETTER_SPACING_PROPERTY);
}
}
/**
* Manager for 'lighting-color'.
*/
public static class LightingColorManager extends SVGColorManager {
public LightingColorManager() {
super(CSSConstants.CSS_LIGHTING_COLOR_PROPERTY, ValueConstants.WHITE_RGB_VALUE);
}
}
/**
* Manager for 'marker-end'.
*/
public static class MarkerEndManager extends MarkerManager {
public MarkerEndManager() {
super(CSSConstants.CSS_MARKER_END_PROPERTY);
}
}
/**
* Manager for 'marker-mid'.
*/
public static class MarkerMidManager extends MarkerManager {
public MarkerMidManager() {
super(CSSConstants.CSS_MARKER_MID_PROPERTY);
}
}
/**
* Manager for 'marker-start'.
*/
public static class MarkerStartManager extends MarkerManager {
public MarkerStartManager() {
super(CSSConstants.CSS_MARKER_START_PROPERTY);
}
}
/**
* Manager for 'opacity'.
*/
public static class DefaultOpacityManager extends OpacityManager {
public DefaultOpacityManager() {
super(CSSConstants.CSS_OPACITY_PROPERTY, false);
}
}
/**
* Manager for 'stop-color'.
*/
public static class StopColorManager extends SVGColorManager {
public StopColorManager() {
super(CSSConstants.CSS_STOP_COLOR_PROPERTY);
}
}
/**
* Manager for 'stop-opacity'.
*/
public static class StopOpacityManager extends OpacityManager {
public StopOpacityManager() {
super(CSSConstants.CSS_STOP_OPACITY_PROPERTY, false);
}
}
/**
* Manager for 'stroke'.
*/
public static class StrokeManager extends SVGPaintManager {
public StrokeManager() {
super(CSSConstants.CSS_STROKE_PROPERTY, ValueConstants.NONE_VALUE);
}
}
/**
* Manager for 'stroke-opacity'.
*/
public static class StrokeOpacityManager extends OpacityManager {
public StrokeOpacityManager() {
super(CSSConstants.CSS_STROKE_OPACITY_PROPERTY, true);
}
}
/**
* Manager for 'word-spacing'.
*/
public static class WordSpacingManager extends SpacingManager {
public WordSpacingManager() {
super(CSSConstants.CSS_WORD_SPACING_PROPERTY);
}
}
}