}

    public void raiseRankOf(IReferenceInfo info) {
      if (this.getDestId().equals(info.getSourceId())
          && (this.getDestType().equals(info.getSourceType()) || TypedObject.UNKNOWN_TYPE
              .equals(info.getDestType()))) {
        if (this.getRank() >= info.getRank()) {
          info.setRank(this.getRank() + 1);
        }
      }
    }

    public void resolve(IDataSet dataSet, String groupId, String testId) {
      if (ParserConstants.UNKNOWN.equals(groupId)
          && ParserConstants.UNKNOWN.equals(testId)) {
        doResolution(dataSet);
      } else if (!ParserConstants.UNKNOWN.equals(testId)) {
        IDataSet groupSet = dataSet.get(groupId);
        IDataSet testDataSet = null;
        if (groupSet != null) {
          testDataSet = groupSet.get(testId);
        }
        doResolution(testDataSet);
      } else {
        throw new DDTTestDataException(
            "Do not process group data without testId");
      }
    }

    /**
     * @param dataSet to resolve reference to
     */
    private void doResolution(IDataSet dataSet) {
      TypedObject dest = dataSet.findObject(this.getDestId(),
          this.getDestType());
      TypedObject source = dataSet.getObject(this.getSourceId(),
          this.getSourceType());
      if (source == null && dataSet instanceof TestDataSet) {
        source = ((TestDataSet) dataSet).getAssert(this.getSourceId(),
            this.getSourceType());
      }
      if (dest != null && source != null) {

		IAction rootAction = this.getPrevious();
		if (rootAction != null) {
			String hintValue = rootAction.getHint();

			if (HintTypes.COLLECTION.equals(hintValue)
					|| HintTypes.MAP.equals(hintValue)
					|| HintTypes.ATTRLIST.equals(hintValue)
					|| HintTypes.FIELDS.equals(hintValue)
					|| HintTypes.CONSTRUCTOR.equals(hintValue)
					|| HintTypes.CALL.equals(hintValue)
					|| HintTypes.BEAN.equals(hintValue)
					|| HintTypes.ARRAY.equals(hintValue)
					|| HintTypes.INTERNAL_MAPENTRY.equals(hintValue)) {
				rootAction.processSuccessor(this);
			} else {
				throw new DDTException("Unknown hint (" + hintValue
						+ ")- stop processing.");
			}
		} else {
			if (hasReferenceInfo()) {
				TypedObject destObject;
				if (this.attrMap.get(ParserConstants.XML_ATTR_TYPE) == null) {
					destObject = new TypedObject(getAttribute("refid"));
				} else {
					destObject = new TypedObject(getAttribute("refid"),
							getType());
				}
				IReferenceInfo refInfo = new ObjectReferenceInfo(this
						.getObject(), destObject);
				add(refInfo);
			}

        if (rootAction != null) {
            String hintValue = rootAction.getHint();

            if (HintTypes.COLLECTION.equals(hintValue)) {
                rootAction.processSuccessor(this);
            } else if (HintTypes.MAP.equals(hintValue)) {
                rootAction.processSuccessor(this);
            } else if (HintTypes.ATTRLIST.equals(hintValue)) {
                rootAction.processSuccessor(this);
            } else if (HintTypes.FIELDS.equals(hintValue)) {
                rootAction.processSuccessor(this);
            } else if (HintTypes.CONSTRUCTOR.equals(hintValue)
                    || HintTypes.CALL.equals(hintValue)) {
                rootAction.processSuccessor(this);
            } else if (HintTypes.BEAN.equals(hintValue)) {
                rootAction.processSuccessor(this);
            } else if (HintTypes.ARRAY.equals(hintValue)) {
                rootAction.processSuccessor(this);
            } else if (HintTypes.INTERNAL_MAPENTRY.equals(hintValue)) {
                rootAction.processSuccessor(this);
            } else {
                throw new DDTException("Unknown hint (" + hintValue
                        + ")- stop processing.");
            }
        } else {

        }

        public void resolve(IDataSet dataSet, String groupId, String testId) {
            if (ParserConstants.UNKNOWN.equals(groupId)
                    && ParserConstants.UNKNOWN.equals(testId)) {
                doResolution(dataSet);
            } else if (!ParserConstants.UNKNOWN.equals(testId)) {
                IDataSet groupSet = dataSet.get(groupId);
                IDataSet testDataSet = null;
                if (groupSet != null) {
                    testDataSet = groupSet.get(testId);
                }
                doResolution(testDataSet);
            } else {
                throw new DDTTestDataException(
                        "Do not process group data without testId");
            }
        }

        /**
         * @param dataSet to resolve reference to
         */
        private void doResolution(IDataSet dataSet) {
            TypedObject dest = dataSet.findObject(this.getDestId(), this
                .getDestType());
            TypedObject source = dataSet.getObject(this.getSourceId(), this
                .getSourceType());
            if (source == null && dataSet instanceof TestDataSet) {
                source = ((TestDataSet) dataSet).getAssert(this.getSourceId(),
                    this.getSourceType());
            }
            if (dest != null && source != null) {

            this.eventConsumer.processEndElement(qName, this.levelCount);
        } catch (Exception ex) {
            StringBuffer sb = new StringBuffer(ex.getClass().getName());
            sb.append(ex.getMessage());
            sb.append(LF).append("Resource \'").append(this.resourceName)
                .append("\' line/column ").append(locator.getLineNumber())
                .append("/").append(locator.getColumnNumber());
            DDTException ddtEx = new DDTException(sb.toString(), ex);
            ddtEx.setStackTrace(ex.getStackTrace());
            log.warn(sb.toString(), ddtEx);
            throw ddtEx;
        } finally {

                                    byte[] actual) {
        if (Arrays.equals(expected, actual)) {
            return;
        }

        String formatted = "";
        if (message != null) {
            formatted = message + " ";
        }

        Assert.assertNotNull(formatted + "expected array: <not null> but was <null>", expected);
        Assert.assertNotNull(formatted + "expected array: <null> but was <not null>", actual);
        Assert.assertEquals(formatted + "[array length] ", expected.length, actual.length);
        for (int i = 0; i < actual.length; i++) {
            Assert.assertEquals(formatted + "[position " + i + "]", expected[i], actual[i]);
        }
    }

    /**
     * Asserts that two arrays are equal. Two arrays are considered equal if:
     * <ul>
     * <li>their respective lengths are the same</i>
     * <li>all corresponding pairs of elements are equal
     * <li>both array references are <code>null</code>
     * </ul>
     *
     * @param expected a byte array of expected values
     * @param actual a byte array of actual values
     */
    public static void assertEquals(byte[] expected,

                                    float delta) {
        if (Arrays.equals(expected, actual)) {
            return;
        }

        String formatted = "";
        if (message != null) {
            formatted = message + " ";
        }

        Assert.assertNotNull(formatted + "expected array: <not null> but was <null>", expected);
        Assert.assertNotNull(formatted + "expected array: <null> but was <not null>", actual);
        Assert.assertEquals(formatted + "[array length] ", expected.length, actual.length);
        for (int i = 0; i < actual.length; i++) {
            Assert.assertEquals(formatted + "[position " + i + "]", expected[i], actual[i], delta);
        }
    }

    /**
     * Asserts that two arrays are equal. Two arrays are considered equal if:
     * <ul>
     * <li>their respective lengths are the same</i>
     * <li>all corresponding pairs of elements are equal (within the delta range)
     * <li>both array references are <code>null</code>
     * </ul>
     *
     * @param expected a float array of expected values
     * @param actual a float array of actual values
     * @param delta tolerated delta
     */
    public static void assertEquals(float[] expected,

                new HashMap<String, String>());
        action.inject();
        action.setValue(new Vector());
        this.insert(action);
        action.process();
    }

    /*
     * (non-Javadoc)
     * 
     * @see junitx.ddtunit.parser.ActionBase#inject()
     */
    public IAction inject() {
        String type = (String) this.attrMap.get(ParserConstants.XML_ATTR_TYPE);
        String id = (String) this.attrMap.get(ParserConstants.XML_ATTR_ID);
        this.injectedObject = new TypedObject(id, type);
        return this;
    }

    public void processSuccessor(IAction successor) {
        log.debug("processSuccessor(" + successor + ") - START");
        // create attribute list action and insert after rootAction
        if (HintTypes.ATTRLIST.equals(successor.getHint())) {

                                    long[] actual) {
        if (Arrays.equals(expected, actual)) {
            return;
        }

        String formatted = "";
        if (message != null) {
            formatted = message + " ";
        }

        Assert.assertNotNull(formatted + "expected array: <not null> but was <null>", expected);
        Assert.assertNotNull(formatted + "expected array: <null> but was <not null>", actual);
        Assert.assertEquals(formatted + "[array length] ", expected.length, actual.length);
        for (int i = 0; i < actual.length; i++) {
            Assert.assertEquals(formatted + "[position " + i + "]", expected[i], actual[i]);

            } else {
                throw new DDTException("Unknown hint (" + hintValue
                        + ")- stop processing.");
            }
        } else {
            // process obj element - no rootAction exiats
            if (hasReferenceInfo()) {
                TypedObject destObject;
                if (this.attrMap.get(ParserConstants.XML_ATTR_TYPE) == null) {
                    destObject = new TypedObject(getAttribute("refid"));
                } else {
                    destObject = new TypedObject(getAttribute("refid"),
                            getType());
                }
                IReferenceInfo refInfo = new ObjectReferenceInfo(this
                    .getObject(), destObject);
                add(refInfo);
            }
        }
        this.pop();
        return this;
    }

    /**
     * If no content on tag is provided just instanciate object by default
     * constructor.
     */
    public void processNoSuccessor() {

        if (rootAction != null) {
            String hintValue = rootAction.getHint();

            if (HintTypes.COLLECTION.equals(hintValue)
                    || HintTypes.MAP.equals(hintValue)
                    || HintTypes.ATTRLIST.equals(hintValue)
                    || HintTypes.FIELDS.equals(hintValue)
                    || HintTypes.CONSTRUCTOR.equals(hintValue)
                    || HintTypes.CALL.equals(hintValue)
                    || HintTypes.BEAN.equals(hintValue)
                    || HintTypes.ARRAY.equals(hintValue)
                    || HintTypes.INTERNAL_MAPENTRY.equals(hintValue)) {

    private static boolean filterByPrimitiveParam(Object method, Class[] args,
            int pos) {
        boolean valid = false;
        Class arg;
        Class argOnPos;

        // exit criterion for recursion
        if (pos >= args.length) {
            valid = true;
        } else {
            arg = args[pos];

            if (java.lang.reflect.Constructor.class.isInstance(method)) {
                argOnPos = ((Constructor) method).getParameterTypes()[pos];
            } else {
                argOnPos = ((Method) method).getParameterTypes()[pos];
            }

            // check if primitiv type of argOnPos exists
            if (hasPrimitive(arg) && argOnPos.equals(getPrimitiveClass(arg))) {

            this.producer.setProperty(JAXP_SCHEMA_SOURCE, ParserImpl.XSD_URL);
        } catch (SAXNotRecognizedException e) {
            throw DDTException
                .create(
                    new StringBuffer(
                            "XML ParserImpl does not support schema validation as of JAXP 1.2"),
                    e);
        } catch (ParserConfigurationException e) {
            throw DDTException.create(new StringBuffer(
                    "Error configuring parser."), e);
        } catch (SAXException e) {
            throw DDTException.create(new StringBuffer(
                    "Error configuring parser."), e);
        }

        this.producer.setErrorHandler(new ErrorHandler());
        this.producer.setEntityResolver(new EntityResolver());
        log.debug("DDTParser - constructor END");

    }

    public void validate(String resourceName) {

				Class fieldClazz = field.getValue().getClass();
				Class[] args = new Class[1];
				args[0] = fieldClazz;
				Method setMethod = (Method) ClassAnalyser.findMethodByParams(
						this.getType(), setter.toString(), args);
				setMethod.setAccessible(true);
				Object[] objs = new Object[1];
				objs[0] = field.getValue();
				setMethod.invoke(this.getValue(), objs);
			} catch (Exception ex) {

            }
        }

        /**
         * If this object is referencing to the provided info object then raise
         * rank of referenced object info.<br/> A reference from an
         * ObjectAction to another Action is detected if destination info is
         * equal to the source info of provided info.
         * 
         * @param info to check reference on and raise rank respectivly
         */
        public void raiseRankOf(IReferenceInfo info) {
            if (this.getDestId().equals(info.getSourceId())
                    && (this.getDestType().equals(info.getSourceType()) || TypedObject.UNKNOWN_TYPE
                        .equals(info.getDestType()))) {
                if (this.getRank() >= info.getRank()) {
                    info.setRank(this.getRank() + 1);
                }
            }
        }
    }

}

            } else {
                throw new DDTException("Unknown hint (" + hintValue
                        + ")- stop processing.");
            }
        } else {
            // process obj element - no rootAction exiats
            if (hasReferenceInfo()) {
                TypedObject destObject;
                if (this.attrMap.get(ParserConstants.XML_ATTR_TYPE) == null) {
                    destObject = new TypedObject(getAttribute("refid"));
                } else {
                    destObject = new TypedObject(getAttribute("refid"),
                            getType());
                }
                IReferenceInfo refInfo = new ObjectReferenceInfo(this
                    .getObject(), destObject);
                add(refInfo);
            }

		}

		public void raiseRankOf(IReferenceInfo info) {
			if (this.getDestId().equals(info.getSourceId())
					&& (this.getDestType().equals(info.getSourceType()) || TypedObject.UNKNOWN_TYPE
							.equals(info.getDestType()))) {
				if (this.getRank() >= info.getRank()) {
					info.setRank(this.getRank() + 1);
				}
			}
		}

		private void doResolution(IDataSet dataSet) {
			TypedObject dest = dataSet.findObject(this.getDestId(), this
					.getDestType());
			TypedObject source = dataSet.getObject(this.getSourceId(), this
					.getSourceType());
			if (source == null && dataSet instanceof TestDataSet) {
				source = ((TestDataSet) dataSet).getAssert(this.getSourceId(),
						this.getSourceType());
			}
			if (dest != null && source != null) {

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see junitx.ddtunit.parser.ActionBase#inject()
	 */
	public IAction inject() {
		String type = (String) this.attrMap.get(ParserConstants.XML_ATTR_TYPE);
		String id = (String) this.attrMap.get(ParserConstants.XML_ATTR_ID);
		// check if type is based on java.util.Collection
		try {
			if (type == null && ParserConstants.XML_ELEM_ITEM.equals(id)) {
				type = TypedObject.UNKNOWN_TYPE;
			} else if (HintTypes.ARRAY.equals(this.getHint())) {
				// do nothing
			} else {

            }
        } else {
            // ARRAY successor
            Map attribMap = new HashMap();
            IAction attribListAction = ActionFactory.getAction(
                ActionState.ATTRLIST_CREATION, attribMap);
            this.insert(attribListAction);
            try {
                // create container
                attribListAction.createObject();
                // initialize with first list element
                ((List) attribListAction.getValue()).add(successor.getObject());
            } catch (Exception ex) {
                throw new DDTException("Error on action processing", ex);
            }
        }
        this.successorProcessed = true;
    }

                                    double delta) {
        if (Arrays.equals(expected, actual)) {
            return;
        }

        String formatted = "";
        if (message != null) {
            formatted = message + " ";
        }

        Assert.assertNotNull(formatted + "expected array: <not null> but was <null>", expected);
        Assert.assertNotNull(formatted + "expected array: <null> but was <not null>", actual);
        Assert.assertEquals(formatted + "[array length] ", expected.length, actual.length);
        for (int i = 0; i < actual.length; i++) {

            } else if (ParserConstants.XML_ELEM_ASSERT.equals(qName)
                    && level == LEVEL_TEST_OBJ) {
                this.actionStack = new ActionStack();
                IAction action = pushAction(qName, attrMap);
                String type = (String) attrMap
                    .get(ParserConstants.XML_ATTR_TYPE);
                String id = (String) attrMap.get(ParserConstants.XML_ATTR_ID);
                String actionAttr = (String) attrMap
                    .get(ParserConstants.XML_ATTR_ACTION);
                action.setObject(new ObjectAsserter(id, type, actionAttr));

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see junitx.ddtunit.parser.ActionBase#inject()
	 */
	public IAction inject() {
		String type = (String) this.attrMap.get(ParserConstants.XML_ATTR_TYPE);
		String id = (String) this.attrMap.get(ParserConstants.XML_ATTR_ID);
		this.injectedObject = new TypedObject(id, type);
		return this;
	}

	public void processSuccessor(IAction successor) {
		log.debug("processSuccessor(" + successor + ") - START");
		// create attribute list action and insert after rootAction
		if (HintTypes.CONTENT.equals(successor.getHint())) {

		} else {
			// ARRAY successor
			Map attribMap = new HashMap();
			IAction attribListAction = ActionFactory.getAction(
					ActionState.ATTRLIST_CREATION, attribMap);
			this.insert(attribListAction);
			try {
				// create container
				attribListAction.createObject();
				// initialize with first list element
				((List) attribListAction.getValue()).add(successor.getObject());
			} catch (Exception ex) {
				throw new DDTException("Error on action processing", ex);
			}
		}

        } catch (IOException e) {
            log.error("Error on behalf of xml test resource.", e);
            throw DDTException.create(new StringBuffer(
                    "Error on behalf of xml test resource."), e);
        } catch (SAXException e) {
            StringBuffer sb = new StringBuffer(
                    "Error during parsing of xml testresource");
            if (SAXParseException.class.isInstance(e)) {
                sb.append(LF).append("Resource \'").append(resourceName)

    public static void assertEquivalenceArrays(String message,
                                               Object[] expected,
                                               Object[] actual) {
        if (Arrays.equals(expected, actual)) {
            return;
        }

        String formatted = "";
        if (message != null) {
            formatted = message + " ";
        }

        Assert.assertNotNull(formatted + "expected array: <not null> but was <null>", expected);
        Assert.assertNotNull(formatted + "expected array: <null> but was <not null>", actual);

        } else if (HintTypes.INTERNAL_MAPENTRY.equals(this.getHint())) {
            try {
                PrivilegedAccessor.setFieldValue(this.getValue(), successor
                    .getId(), successor.getObject());
            } catch (Exception ex) {
                throw new DDTTestDataException("Error filling map entry "
                        + this.getId(), ex);
            }
        } else if (HintTypes.CONTENT.equals(successor.getHint())) {

            this.producer.setFeature(XML_NAMESPACE_URI, true);
            
            this.producer.setFeature(XML_VALIDATE_URI, true);
            this.producer.setFeature(XML_XERCES_VALIDATE_URI, true);
            this.producer.setFeature(XML_XERCES_SCHEMA_FULL_CHECK_URI, true);
            this.producer.setProperty(
                XML_XERCES_NONAMESPACE_SCHEMA_LOCATION_URI, ParserImpl.XSD_URL);
            this.producer.setProperty(JAXP_SCHEMA_LANGUAGE, W3C_XML_SCHEMA);
            this.producer.setProperty(JAXP_SCHEMA_SOURCE, ParserImpl.XSD_URL);

                        source = ((TestDataSet) testDataSet).getAssert(this
                            .getSourceId(), this.getSourceType());
                    }
                    if (dest != null && source != null) {
                        source.setValue(dest.getValue());
                        source.setType(dest.getType());
                    } else {
                        throw new DDTTestDataException(
                                "Error on processing references on testdata.");
                    }
                } else {
                    throw new DDTTestDataException(

  }

  public void processSuccessor(IAction successor) {
    log.debug("processSuccessor(" + successor + ") - START");
    if (HintTypes.CONTENT.equals(successor.getHint())) {
      String content = successor.getValue().toString();
      if (!ContentCreatorAction.CONTENT_NULL.equals(content)) {
        throw new DDTException("Only \"!NULL!\" supported in Map type");

			} catch (Exception ex) {
				StringBuffer sb = new StringBuffer("Error executing setter ")
						.append(this.getType())
						.append(".")
						.append(setter)
						.append("(...). ")
						.append(
								"Check if hint and setter are correct (Do not provide set-prefix!).");
				throw new DDTException(sb.toString(), ex);
			}
		} else if (HintTypes.CONTENT.equals(successor.getHint())) {

    }

    /*
     * (non-Javadoc)
     * 
     * @see junitx.ddtunit.parser.ActionBase#inject()
     */
    public IAction inject() {
        String type = (String) this.attrMap.get(ParserConstants.XML_ATTR_TYPE);
        String id = (String) this.attrMap.get(ParserConstants.XML_ATTR_ID);
        // check if type is based on java.util.Collection
        try {
            if (type == null && ParserConstants.XML_ELEM_ITEM.equals(id)) {
                type = TypedObject.UNKNOWN_TYPE;
            } else if (HintTypes.ARRAY.equals(this.getHint())) {

                sb.append(LF).append("Resource \'").append(resourceName)
                    .append("\' line/column ").append(
                        ((SAXParseException) e).getLineNumber()).append("/")
                    .append(((SAXParseException) e).getColumnNumber());
            }
            log.error(sb.toString(), e);
            throw DDTException.create(sb, e);
        } finally {

	}

	public void processSuccessor(IAction successor) {
		log.debug("processSuccessor(" + successor + ") - START");
		// create attribute list action and insert after rootAction
		if (HintTypes.CONTENT.equals(successor.getHint())) {
			String content = successor.getValue().toString();
			if (!ContentCreatorAction.CONTENT_NULL.equals(content)) {

            sb.append("E-(").append(testFailure.getMethodTest()).append(") ")
                .append(testFailure.exceptionMessage());
            if (iter.hasNext()) {
                sb.append(LF);
            }
            if (testError == null) {
                testError = testFailure.thrownException();
            }
        }
        return testError;
    }

                } else if (ASSERT_ACTION_ISNOTLT.equals(this.action
                    .toUpperCase())) {
                    if (((Comparable) this.getActualObject()).compareTo(this
                        .getValue()) >= 0) {
                        Assert.fail("Expected action: " + this.getAction()
                                + ". Got: " + this.getActualObject() + " > "

	protected Object getObject(String objectId, String objectType) {
		Object obj = null;
		TypedObject typedObject;

		if (!this.classDataSet.containsKey(this.getName())) {
			throw new DDTException("No objects defined <" + objectId
					+ "> in method scope");
		}

		typedObject = this.classDataSet.getObject(this.getName(), this
				.getTestName(), objectId, objectType);

                                               Object[] actual) {
        if (Arrays.equals(expected, actual)) {
            return;
        }

        String formatted = "";
        if (message != null) {
            formatted = message + " ";
        }

        Assert.assertNotNull(formatted + "expected array: <not null> but was <null>", expected);
        Assert.assertNotNull(formatted + "expected array: <null> but was <not null>", actual);

    public void processNoSuccessor() {
        // process direct object call providing no parameters (empty tag)
        if (hasReferenceInfo()) {
            TypedObject destObject;
            if (this.attrMap.get(ParserConstants.XML_ATTR_TYPE) == null) {
                destObject = new TypedObject(getAttribute("refid"));
            } else {
                destObject = new TypedObject(getAttribute("refid"), getType());
            }
            IReferenceInfo refInfo;

        return this;
    }

    public void processSuccessor(IAction successor) {
        log.debug("processSuccessor(" + successor + ") - START");
        // create attribute list action and insert after rootAction
        if (HintTypes.ATTRLIST.equals(successor.getHint())) {
            List fields = (List) successor.getObject().getValue();
            TypedObject field = null;

					|| HintTypes.CALL.equals(hintValue)) {
				rootAction.processSuccessor(this);
			} else if (HintTypes.BEAN.equals(hintValue)) {
				rootAction.processSuccessor(this);
			} else if (HintTypes.ARRAY.equals(hintValue)) {
				rootAction.processSuccessor(this);
			} else if (HintTypes.INTERNAL_MAPENTRY.equals(hintValue)) {

				"Specify !NULL! or date. No empty date tag allowed.");
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see junitx.ddtunit.parser.ActionBase#inject()
	 */
	public IAction inject() {
		String type = (String) this.attrMap.get(ParserConstants.XML_ATTR_TYPE);
		String id = (String) this.attrMap.get(ParserConstants.XML_ATTR_ID);
		this.injectedObject = new TypedObject(id, type);
		return this;
	}

		IAction rootAction = getPrevious();
		if (!this.successorProcessed) {
			processNoSuccessor();
		}
		if (rootAction != null) {
			String hintValue = rootAction.getHint();

			if (HintTypes.COLLECTION.equals(hintValue)) {
				rootAction.processSuccessor(this);
			} else if (HintTypes.ARRAY.equals(hintValue)) {

							iSource.getSystemId()).append("\' line/column ")
							.append(((SAXParseException) e).getLineNumber())
							.append("/").append(
									((SAXParseException) e).getColumnNumber());
				}
				log.error(sb.toString(), e);
				throw DDTException.create(sb, e);

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see junitx.ddtunit.parser.ActionBase#inject()
	 */
	public IAction inject() {
		String type = (String) this.attrMap.get(ParserConstants.XML_ATTR_TYPE);
		String id = (String) this.attrMap.get(ParserConstants.XML_ATTR_ID);
		this.injectedObject = new TypedObject(id, type);
		return this;
	}

            try {
                verifyClazz = Class.forName(name
                    .substring(2, name.length() - 1));
            } catch (ClassNotFoundException ex) {
                throw new ClassAnalyserException(
                        "Could not construct base class from array");
            }
        }
        if (verifyClazz.equals(java.lang.Integer.class)

				throw DDTException.create(new StringBuffer(
						"Error on behalf of xml test resource."), e);
			} catch (SAXException e) {
				StringBuffer sb = new StringBuffer(
						"Error during parsing of xml testresource");
				if (SAXParseException.class.isInstance(e)) {
					sb.append(LF).append("Resource \'").append(

				setter.replace(0, setter.length(), "set");
				setter.append(field.getId().substring(0, 1).toUpperCase())
						.append(field.getId().substring(1));
				Class fieldClazz = field.getValue().getClass();

            try {
                this.getType();
                // if TypedObject is not instanciated and it is no call
                // operation
                // create object by default constructor
                if (this.getValue() == null){
//                        && !HintTypes.CALL.equals(this.getHint())) {
                    this.createObject();
                }
                for (int count = 0; count < fields.size(); count++) {
                    field = (TypedObject) fields.get(count);

				if (!found) {
					throw new DDTException("Container class '" + type
							+ "' does not implement java.util.Collection.");
				}
			}
		} catch (Exception ex) {
			throw new DDTException("Container class '" + type
					+ "' does not implement java.util.Collection.", ex);
		}
		this.injectedObject = new TypedObject(id, type);
		return this;
	}

				.add(new DDTTestFailure(test, testName, assertError));

		for (Iterator e = cloneListeners().listIterator(); e.hasNext();) {
			TestListener listener = (TestListener) e.next();

			if (DDTTestListener.class.isInstance(listener)) {
				((DDTTestListener) listener).addMethodTestFailure(test,

			iSource = createInputSource(xmlObjectDef, false);
			this.producer.parse(iSource);
		} catch (IOException e) {
			log.error("Error on behalf of xml test resource.", e);
			throw DDTTestDataException.create(new StringBuffer(
					"Error on behalf of xml test resource."), e);
		} catch (SAXException e) {
			StringBuffer sb = new StringBuffer(

    }

    /*
     * (non-Javadoc)
     * 
     * @see junitx.ddtunit.parser.ActionBase#inject()
     */
    public IAction inject() {
        String type = (String) this.attrMap.get(ParserConstants.XML_ATTR_TYPE);
        String id = (String) this.attrMap.get(ParserConstants.XML_ATTR_ID);
        this.injectedObject = new TypedObject(id, type);

		for (Iterator e = cloneListeners().listIterator(); e.hasNext();) {
			TestListener listener = (TestListener) e.next();

			if (DDTTestListener.class.isInstance(listener)) {
				((DDTTestListener) listener).startMethodTest(test, methodName);

			} else if (HintTypes.FIELDS.equals(hintValue)) {
				rootAction.processSuccessor(this);
			} else if (HintTypes.CONSTRUCTOR.equals(hintValue)
					|| HintTypes.CALL.equals(hintValue)) {
				rootAction.processSuccessor(this);
			} else if (HintTypes.BEAN.equals(hintValue)) {

		log.debug("process DateCreator - START");
		if (!this.successorProcessed) {
			processNoSuccessor();
		}
		IAction rootAction = this.getPrevious();
		if (rootAction != null) {
			String hintValue = rootAction.getHint();

			if (HintTypes.COLLECTION.equals(hintValue)

        log.debug("process SubelementCreator - START");
        IAction rootAction = this.getPrevious();
        if (!this.successorProcessed) {
            processNoSuccessor();
        }
        if (rootAction != null) {
            String hintValue = rootAction.getHint();

            if (HintTypes.COLLECTION.equals(hintValue)

                    if (((IRange) this.getValue()).isInRange((Comparable) this
                        .getActualObject())) {
                        Assert.fail("Expected action: " + this.getAction()
                                + ". Got: " + this.getActualObject() + " in "

    public void addFailure(Test test, AssertionFailedError t) {
        String method = "";

        if (TestCase.class.isInstance(test)) {
            method = ((TestCase) test).getName();
        }

        log.info("[" + test.getClass() + "] Add Faiure method " + method, t);

        } catch (SQLException ex) {
            throw new DDTTestDataException("Could not access db test data", ex);
        } finally {
            if (connect != null) {
                try {
                    connect.close();
                } catch (SQLException ex) {
                    // ignore exception
                }
            }
        }
        return sb;

    public void addError(Test test, Throwable t) {
        String method = "";

        if (TestCase.class.isInstance(test)) {
            method = ((TestCase) test).getName();
        }
        log.info("[" + test.getClass() + "] method " + method + " error:", t);

			} else if (!ParserConstants.UNKNOWN.equals(testId)) {
				IDataSet groupSet = dataSet.get(groupId);
				IDataSet testDataSet = null;
				if (groupSet != null) {
					testDataSet = groupSet.get(testId);
				}

		if (DDTConfiguration.getInstance().isActiveRunMonitor()
				&& !this.cloneListeners().contains(DDTRunMonitor.getInstance())) {
			this.addListener(DDTRunMonitor.getInstance());
		}
	}

	/**
	 * DOCUMENT ME!
	 * 
	 * @param result
	 *            DOCUMENT ME!
	 * 
	 * @return DOCUMENT ME!
	 */
	public TestResult copyContent(TestResult result) {

                    log.info(ctor[i].toString());
                }
            }
        } catch (ClassNotFoundException ex) {
            log.error("No such class: " + qualifiedClassName, ex);
            throw new ClassAnalyserException("No class found of type "
                    + qualifiedClassName, ex);
        }
    }

    /**
     * Find a Constructor/Method of class className by using the argument list
     * args and try to vary arguments which could be of primitive type. <br/>
     * The args list only contains classes.
     * 
     * @param className
     * @param methodName
     * @param args
     * @return Method/Constructor object
     */
    public static Object findMethodByParams(String className,

  }

  /*
   * (non-Javadoc)
   * @see junitx.ddtunit.parser.ActionBase#inject()
   */
  public IAction inject() {
    String type = (String) this.attrMap.get(ParserConstants.XML_ATTR_TYPE);
    String id = (String) this.attrMap.get(ParserConstants.XML_ATTR_ID);
    // check if type is based on java.util.Collection
    try {

    this.createObject();
  }

  /*
   * (non-Javadoc)
   * @see junitx.ddtunit.parser.ActionBase#inject()
   */
  public IAction inject() {
    String type = (String) this.attrMap.get(ParserConstants.XML_ATTR_TYPE);
    String id = (String) this.attrMap.get(ParserConstants.XML_ATTR_ID);

                        + this.getId(), ex);
            }
        } else {
            // ARRAY successor
            Map attribMap = new HashMap();
            IAction attribListAction = ActionFactory.getAction(
                ActionState.ATTRLIST_CREATION, attribMap);
            this.insert(attribListAction);
            try {
                // create container
                attribListAction.createObject();
                // initialize with first list element
                ((List<TypedObject>) attribListAction.getValue()).add(successor

    this.createObject();
  }

  /*
   * (non-Javadoc)
   * @see junitx.ddtunit.parser.ActionBase#inject()
   */
  public IAction inject() {
    String type = (String) this.attrMap.get(ParserConstants.XML_ATTR_TYPE);
    String id = (String) this.attrMap.get(ParserConstants.XML_ATTR_ID);

  }

  /*
   * (non-Javadoc)
   * @see junitx.ddtunit.parser.ActionBase#inject()
   */
  public IAction inject() {
    String type = (String) this.attrMap.get(ParserConstants.XML_ATTR_TYPE);
    String id = (String) this.attrMap.get(ParserConstants.XML_ATTR_ID);
    // check if type is based on java.util.Collection
    try {

            action.process();
        }
    }

    /*
     * (non-Javadoc)
     * 
     * @see junitx.ddtunit.parser.ActionBase#inject()
     */
    public IAction inject() {
        String type = (String) this.attrMap.get(ParserConstants.XML_ATTR_TYPE);
        String id = (String) this.attrMap.get(ParserConstants.XML_ATTR_ID);

        Connection connect = createConnection();
        try {
            String selectData = "select clusterid, groupid, testid, ogroup"
                    + ", otype, id, class_type, action, xml from TESTDATA_VIEW "
                    + "where clusterid=? ";
            PreparedStatement dbData = connect.prepareStatement(selectData);
            dbData.setString(1, clusterId);
            ResultSet resultSet = dbData.executeQuery();

                log.debug(ctor[i].toString());
            }
        } catch (ClassNotFoundException ex) {
            log.error("No such class: " + qualifiedClassName, ex);
            throw new ClassAnalyserException("No class found of type "
                    + qualifiedClassName, ex);
        }
    }

    /**
     * Put all method names of the class qualifiedClassName into a String array
     * and return it.
     * 
     * @param qualifiedClassName Description of the Parameter
     * 
     * @return array of all method names of the class to analyse
     * 
     * @throws RuntimeException ClassAnalyserException if an error occures
     */
    public static String[] getAllMethods(String qualifiedClassName) {

    this.createObject();
  }

  /*
   * (non-Javadoc)
   * @see junitx.ddtunit.parser.ActionBase#inject()
   */
  public IAction inject() {
    String type = (String) this.attrMap.get(ParserConstants.XML_ATTR_TYPE);
    String id = (String) this.attrMap.get(ParserConstants.XML_ATTR_ID);

          String linkType = successor.getAttribute(ParserConstants.XML_ATTR_VALUETYPE);
          if (linkType == null) {
            destObject = new TypedObject(successor.getAttribute("refid"));
          } else {
            destObject = new TypedObject(successor.getAttribute("refid"),
                linkType);
          }
          IReferenceInfo refInfo;

        IAction rootAction = this.getPrevious();
        if (!this.successorProcessed) {
            processNoSuccessor();
        }
        if (rootAction != null) {
            String hintValue = rootAction.getHint();

            if (HintTypes.COLLECTION.equals(hintValue)

            }
        } else {
            // ARRAY successor
            Map attribMap = new HashMap();
            IAction attribListAction = ActionFactory.getAction(
                ActionState.ATTRLIST_CREATION, attribMap);
            this.insert(attribListAction);
            try {
                // create container
                attribListAction.createObject();
                // initialize with first list element
                ((List) attribListAction.getValue()).add(successor.getObject());

      } else if (HintTypes.COLLECTION.equals(hintValue)) {
        rootAction.processSuccessor(this);
      } else if (HintTypes.MAP.equals(hintValue)) {
        rootAction.processSuccessor(this);
      } else {

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see junitx.ddtunit.parser.ActionBase#inject()
	 */
	public IAction inject() {
		String type = (String) this.attrMap.get(ParserConstants.XML_ATTR_TYPE);
		String id = (String) this.attrMap.get(ParserConstants.XML_ATTR_ID);

			if (HintTypes.COLLECTION.equals(hintValue)) {
				rootAction.processSuccessor(this);
			} else if (HintTypes.ARRAY.equals(hintValue)) {
				rootAction.processSuccessor(this);
			} else if (HintTypes.ATTRLIST.equals(hintValue)) {

			} else if (HintTypes.ATTRLIST.equals(hintValue)) {
				rootAction.processSuccessor(this);
			} else if (HintTypes.BEAN.equals(hintValue)) {
				rootAction.processSuccessor(this);
			} else if (HintTypes.FIELDS.equals(hintValue)) {

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see junitx.ddtunit.parser.ActionBase#inject()
	 */
	public IAction inject() {
		String type = (String) this.attrMap.get(ParserConstants.XML_ATTR_TYPE);
		String id = (String) this.attrMap.get(ParserConstants.XML_ATTR_ID);

			} else if (HintTypes.ATTRLIST.equals(hintValue)) {
				rootAction.processSuccessor(this);
			} else if (HintTypes.BEAN.equals(hintValue)) {
				rootAction.processSuccessor(this);
			} else if (HintTypes.FIELDS.equals(hintValue)) {

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see junitx.ddtunit.parser.ActionBase#inject()
	 */
	public IAction inject() {
		String type = (String) this.attrMap.get(ParserConstants.XML_ATTR_TYPE);
		String id = (String) this.attrMap.get(ParserConstants.XML_ATTR_ID);

			} else if (HintTypes.ATTRLIST.equals(hintValue)) {
				rootAction.processSuccessor(this);
			} else if (HintTypes.BEAN.equals(hintValue)) {
				rootAction.processSuccessor(this);
			} else if (HintTypes.FIELDS.equals(hintValue)) {

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see junitx.ddtunit.parser.ActionBase#inject()
	 */
	public IAction inject() {
		String type = (String) this.attrMap.get(ParserConstants.XML_ATTR_TYPE);
		String id = (String) this.attrMap.get(ParserConstants.XML_ATTR_ID);

    public TypedObject get(String id) {
        TypedObject obj = null;
        if (this.objectMap.containsKey(id)) {
            Object value = objectMap.get(id);
            if (MultiTypeMap.class.isInstance(value)) {

		this.pop();
		return this;
	}

	public void processSuccessor(IAction successor) {
		log.debug("processSuccessor(" + successor + ") - START");
		// create attribute list action and insert after rootAction
		if (HintTypes.CONTENT.equals(successor.getHint())) {

    log.debug("process MapCreator Action - START");
    if (!this.successorProcessed) {
      processNoSuccessor();
    }
    IAction rootAction = getPrevious();
    if (rootAction != null) {
      String hintValue = rootAction.getHint();
      if (HintTypes.CONSTRUCTOR.equals(hintValue)

        return this;
    }

    public void processSuccessor(IAction successor) {
        log.debug("processSuccessor(" + successor + ") - START");
        // create attribute list action and insert after rootAction
        if (HintTypes.ATTRLIST.equals(successor.getHint())) {

        } else {
            // ARRAY successor
            Map attribMap = new HashMap();
            IAction attribListAction = ActionFactory.getAction(
                ActionState.ATTRLIST_CREATION, attribMap);
            this.insert(attribListAction);
            try {
                // create container
                attribListAction.createObject();
                // initialize with first list element
                ((List<TypedObject>) attribListAction.getValue()).add(successor

			} else if (HintTypes.FIELDS.equals(hintValue)) {
				rootAction.processSuccessor(this);
			} else {
				throw new UnsupportedOperationException(
						"CollectionCreatorAction does not support hint '"
								+ hintValue + "'");
			}
		} else {
			rootAction = this;
		}
		// if rootAction is null simply return action -> base object is a
		// collection
		pop();

                String oGroup = resultSet.getString("ogroup");

                String id = resultSet.getString("id");
                String type = resultSet.getString("class_type");
                String action = resultSet.getString("action");
                String xml = resultSet.getString("xml");

            while (resultSet.next()) {
                String groupId = resultSet.getString("groupid");
                String testId = resultSet.getString("testid");
                String oType = resultSet.getString("otype");
                String oGroup = resultSet.getString("ogroup");

        } else if (ASSERT_ACTION_ISFALSE.equals(this.action.toUpperCase())) {
            this.markAsProcessed = mark;
            if (Boolean.class.isInstance(getActualObject())) {
                isSameType();
                Assert.assertFalse("Object should be false on assert ("

	private void setUp(TestCase newInstance) throws IllegalArgumentException,
			IllegalAccessException, InvocationTargetException {
		Method[] methods = clazz.getMethods();
		for (Method method : methods) {
			// System.out.println("su " + method.getName() );
			if ((method.isAnnotationPresent(Before.class) && !method

            } else if (HintTypes.INTERNAL_MAPENTRY.equals(this.getPrevious().getHint())){
              // if a map type is processed the subelement must be specified as ARGLIST
              // the reference is processed inside of rootAction
              this.attrMap.put(ParserConstants.XML_ATTR_HINT, HintTypes.ATTRLIST.toString());
            } else {

                for (int countB = countA + 1; countB < this.refList.size(); countB++) {
                    IReferenceInfo infoB = (IReferenceInfo) this.refList
                        .get(countB);

	}

	public void processSuccessor(IAction successor) {
		log.debug("processSuccessor(" + successor + ") - START");
		// create attribute list action and insert after rootAction
		if (HintTypes.CONTENT.equals(successor.getHint())) {

			if (HintTypes.COLLECTION.equals(hintValue)) {
				rootAction.processSuccessor(this);
			} else if (HintTypes.ARRAY.equals(hintValue)) {
				rootAction.processSuccessor(this);
			} else if (HintTypes.ATTRLIST.equals(hintValue)) {

            }
        } catch (Exception ex) {
            throw new DDTException("Container class '" + type
                    + "' does not implement java.util.Collection.", ex);
        }
        this.injectedObject = new TypedObject(id, type);
        return this;
    }

            "MapCreatorAction does not support hint '" + hintValue + "'");
      }
    } else {
      rootAction = this;
    }
    pop();
    return rootAction;
  }

  public void processSuccessor(IAction successor) {
    log.debug("processSuccessor(" + successor + ") - START");

    public void printStackTrace(PrintWriter s) {
        super.printStackTrace(s);
        if (this.cause != null) {
            s.print("Caused by: ");
            this.cause.printStackTrace(s);
        }
    }

				for (Enumeration<TestFailure> en = result.failures(); en
						.hasMoreElements();) {
					TestFailure failure = en.nextElement();
					runNotifier.fireTestFailure(new Failure(testDescription,
							failure.thrownException()));
				}

                    && level == LEVEL_CLUSTER_GLOBAL_OBJ) {
                IAction action = null;
                while (!this.actionStack.isEmpty()) {
                    action = this.actionStack.process();
                }
                // select method-test based dataset and store ObjectRecord
                this.clusterDataSet.putObject(action.getId(), action

            sb.append("        </").append(oldOGroup).append(">" + LF);
            sb.append("      </test>" + LF);
            sb.append("    </group>" + LF);

                } else if (ASSERT_ACTION_ISLT.equals(this.action.toUpperCase())) {
                    if (((Comparable) this.getActualObject()).compareTo(this
                        .getValue()) >= 0) {

            Throwable firstException = null;
            for (Iterator iter = assertMap.entrySet().iterator(); iter
                .hasNext();) {
                Entry assertEntry = (Entry) iter.next();

            String searchTerm) {
        try {
            Class c = Class.forName(qualifiedClassName);
            Method[] m = c.getMethods();
            Constructor[] ctor = c.getConstructors();

            for (int countA = 0; countA < this.refList.size(); countA++) {
                IReferenceInfo infoA = (IReferenceInfo) this.refList
                    .get(countA);

                .equals(qName))
                    && level == LEVEL_TEST_OBJ) {
                IAction action = null;
                while (!this.actionStack.isEmpty()) {
                    action = this.actionStack.process();
                }

                ((List) attribListAction.getValue()).add(successor.getObject());
            } catch (Exception ex) {
                throw new DDTException("Error on action processing", ex);
            }
        }

					|| HintTypes.INTERNAL_MAPENTRY.equals(hintValue)) {
				rootAction.processSuccessor(this);
			} else {
				throw new DDTException("Unknown hint (" + hintValue
						+ ")- stop processing.");
			}
		} else {

		IAction rootAction = this.getPrevious();
		if (rootAction != null) {
			String hintValue = rootAction.getHint();

			if (HintTypes.COLLECTION.equals(hintValue)

                ((List<TypedObject>) attribListAction.getValue()).add(successor
                    .getObject());
            } catch (Exception ex) {
                throw new DDTException("Error on action processing", ex);
            }
        }

        ObjectAsserter newObj = new ObjectAsserter(this.getId(),
                this.getType(), this.getAction());
        newObj.setValue(this.getValue());
        return newObj;
    }

}

					this.fListeners);
			PrivilegedAccessor.setFieldValue(result, "fRunTests", new Integer(
					this.fRunTests));
		} catch (Exception e) {
			e.printStackTrace();
			throw new DDTException(

				} catch (Throwable ex) {
					DDTException ddtEx;
					if (DDTException.class.isInstance(ex)) {
						ddtEx = (DDTException) ex;
					} else {
						ddtEx = new DDTTearDownException(ex.getMessage(), ex);

            }
        } catch (ClassNotFoundException ex) {
            log.error("No such class: " + qualifiedClassName, ex);
            throw new ClassAnalyserException("No class found of type "
                    + qualifiedClassName, ex);
        }
    }

    /**
     * Find a Constructor/Method of class className by using the argument list
     * args and try to vary arguments which could be of primitive type. <br/>
     * The args list only contains classes.
     * 
     * @param className
     * @param methodName
     * @param args
     * @return Method/Constructor object
     */
    public static Object findMethodByParams(String className,

                    log.info(ctor[i].toString());
                }
            }
        } catch (ClassNotFoundException ex) {
            log.error("No such class: " + qualifiedClassName, ex);
            throw new ClassAnalyserException("No class found of type "
                    + qualifiedClassName, ex);
        }
    }

            }
        } catch (ClassNotFoundException ex) {
            log.error("No such class: " + qualifiedClassName, ex);
            throw new ClassAnalyserException("No class found of type "
                    + qualifiedClassName, ex);
        }
    }

    /**
     * Put all method names of the class qualifiedClassName into a String array
     * and return it.
     * 
     * @param qualifiedClassName Description of the Parameter
     * 
     * @return array of all method names of the class to analyse
     * 
     * @throws RuntimeException ClassAnalyserException if an error occures
     */
    public static String[] getAllMethods(String qualifiedClassName) {

                        log.debug("=== End of Check");
                    }
                }
            } catch (ClassNotFoundException ex) {
                log.error("No such class: " + qualifiedClassName, ex);
                throw new ClassAnalyserException("No class found of type "
                        + qualifiedClassName, ex);
            }
        }

        } catch (ClassNotFoundException ex) {
            log.error("No such class: " + qualifiedClassName, ex);
            throw new ClassAnalyserException("No class found of type "
                    + qualifiedClassName, ex);
        }
    }

    /**
     * Display all constructors and methods of qualifiedClassName class which
     * match with searchTerm. <br/>Output is set to Log4J Info level of this
     * classes Logger.
     * 
     * @param qualifiedClassName Name of class to analyse
     * @param searchTerm Match term for methods to display
     * 
     * @throws RuntimeException ClassAnalyserException if an error occures
     */
    public static void showSelectedMethods(String qualifiedClassName,

            }
        } catch (ClassNotFoundException ex) {
            log.error("No such class: " + qualifiedClassName, ex);
            throw new ClassAnalyserException("No class found of type "
                    + qualifiedClassName, ex);
        }
    }

    /**
     * Search for exact match of searchTerm in the list of declared fields of
     * the class qualifiedClassName.
     * 
     * @param qualifiedClassName Description of the Parameter
     * @param searchTerm Description of the Parameter
     * 
     * @return Field that was found or null if field does not exists
     * 
     * @throws RuntimeException ClassAnalyserException if an error occures
     */
    public static Field getSelectedField(String qualifiedClassName,

			if ((method.isAnnotationPresent(Before.class) && !method
					.isAnnotationPresent(Ignore.class))) {
				method.invoke(newInstance, new Object[] {});
			}
		}

	}

		this.injectedObject = new TypedObject(id, type);
		return this;
	}

	public void processSuccessor(IAction successor) {
		log.debug("processSuccessor(" + successor + ") - START");

            for (Iterator iter = assertMap.entrySet().iterator(); iter
                .hasNext();) {
                Entry assertEntry = (Entry) iter.next();

        } catch (ClassNotFoundException ex) {
            log.error("No such class: " + qualifiedClassName, ex);
            throw new ClassAnalyserException("No class found of type "
                    + qualifiedClassName, ex);
        }
    }

    /**
     * Display all constructors and methods of qualifiedClassName class which
     * match with searchTerm. <br/>Output is set to Log4J Info level of this
     * classes Logger.
     * 
     * @param qualifiedClassName Name of class to analyse
     * @param searchTerm Match term for methods to display
     * 
     * @throws RuntimeException ClassAnalyserException if an error occures
     */
    public static void showSelectedMethods(String qualifiedClassName,

            String searchTerm) {
        try {
            Class c = Class.forName(qualifiedClassName);
            Field[] fields = c.getDeclaredFields();
            log.debug("===Class " + qualifiedClassName
                    + " fields selected by '" + searchTerm + "':");

			StringBuffer setter = new StringBuffer();
			try {
				// returned type is never used but method may specify this type
				// internally in injected object
				this.getType();
				if (this.getValue() == null) {
					this.createObject();
				}

					|| HintTypes.INTERNAL_MAPENTRY.equals(hintValue)) {
				rootAction.processSuccessor(this);
			} else {
				throw new DDTException("Unknown hint (" + hintValue
						+ ")- stop processing.");
			}
		} else {

                    "Error during access on db testdata", ex);
        } finally {
            if (connect != null) {
                try {
                    connect.close();
                } catch (SQLException ex) {
                    // ignore exception
                }
            }
        }
        return tObj;

    public void endTest(Test test) {
        String method = "";
        if (TestCase.class.isInstance(test)) {
            method = ((TestCase) test).getName();
        }

            }
        } catch (ClassNotFoundException ex) {
            log.error("No such class: " + qualifiedClassName, ex);
            throw new ClassAnalyserException("No class found of type "
                    + qualifiedClassName, ex);
        }
    }

        } else if (HintTypes.CONTENT.equals(successor.getHint())) {
            String content = successor.getValue().toString();
            if (ContentCreatorAction.CONTENT_EMPTY.equals(content)) {

                    && level == LEVEL_TEST_OBJ) {
                IAction action = null;
                while (!this.actionStack.isEmpty()) {
                    action = this.actionStack.process();
                }
                // select method-test based dataset and store ObjectRecord
                this.actualDataSet

				DDTDateFormat formater = selectDateFormater(format, locale);
				try {
					if (formater.toString().length() == content.length()) {
						date = formater.parse(content);

        } else if (HintTypes.CONTENT.equals(successor.getHint())) {
            String content = successor.getValue().toString();
            if (ContentCreatorAction.CONTENT_EMPTY.equals(content)) {

                                   Object expected,
                                   Object actual) {
       String formatted = "";
       if (message != null) {
           formatted = message + " ";
       }

       Assert.fail(formatted + "expected same as : <" + expected + "> but was <" + actual + ">");

    static private void failSame(String message,
                                 Object expected) {
        String formatted = "";
        if (message != null) {
            formatted = message + " ";
        }

        fail(formatted + "expected not same as: <" + expected + ">");

                                       Object actual) {
        if ((expected == null && actual == null) ||
                (expected != null && expected.equals(actual))) {

        } catch (ClassNotFoundException ex) {
            log.error("No such class: " + qualifiedClassName, ex);
            throw new ClassAnalyserException("No class found of type "
                    + qualifiedClassName, ex);
        }
    }

    public SAXValidator() {
        log.debug("DDTParser - constructor START");
        try {
            // the SAX way
            // this.producer = XMLReaderFactory.createXMLReader();
            // the jaxp1.1 way
            SAXParserFactory factory = SAXParserFactory.newInstance();
            factory.setNamespaceAware(true);
            factory.setValidating(true);

        if (HintTypes.INTERNAL_MAPENTRY.equals(successor.getHint())
            && ((SubelementCreatorAction) successor).hasReferenceInfo()) {
          TypedObject destObject;
          String linkType = successor.getAttribute(ParserConstants.XML_ATTR_VALUETYPE);

        if (this.objectMap.containsKey(id)) {
            Object value = objectMap.get(id);
            if (MultiTypeMap.class.isInstance(value)) {

                                + this.getId() + ")", ((Collection) this
                            .getValue()).contains(getActualObject()));
                }
            }

                        + this.getId() + ")", ((Boolean) getActualObject())
                    .booleanValue());
            } else {
                throw new UnsupportedOperationException(

        for (Iterator iter = this.methodTestError.values().iterator(); iter
            .hasNext();) {
            testFailure = (DDTTestFailure) iter.next();
            sb.append("E-(").append(testFailure.getMethodTest()).append(") ")

            for (int i = 0; i < m.length; i++) {
                log.debug(m[i].toString());

                    && level == LEVEL_RESOURCE_OBJ) {
                IAction action = null;
                while (!this.actionStack.isEmpty()) {
                    action = this.actionStack.process();
                }

    try {
      Class clazz = Class.forName(type);
      Class superclazz = clazz;

      boolean found = false;
      while (!found && superclazz != null) {

				for (int count = 0; count < fields.size(); count++) {
					field = (TypedObject) fields.get(count);

                        startTests = false;
                        sb.append("        </").append(oldOGroup).append(
                            ">" + LF);
                        sb.append("      </test>" + LF);

    public static void assertSimilar(String message,
                                     Throwable expected,
                                     Throwable actual) {
        ObjectAssert.assertInstanceOf(message, expected.getClass(), actual);
        if (expected.getMessage() == null) {

        for (int i = 0; i < actual.length; i++) {
            Assert.assertEquals(formatted + "[position " + i + "]", expected[i], actual[i], delta);

                DDTDataRepository.getInstance().putObject(action.getId(),
                    action.getObject());
                this.processResource = false;
            } else if (ParserConstants.XML_ELEM_OBJ.equals(qName)
                    && level == LEVEL_CLUSTER_GLOBAL_OBJ) {

                ActionState.ATTRLIST_CREATION, attribMap);
            action.inject();
            action.setValue(new Vector());
            this.insert(action);
            action.process();
        }

            ExceptionAsserter asserter = new ExceptionAsserter(id, type, action);
            asserter.setValue(tObj.getValue());
            testDataSet.putAssert(id, asserter);
        } else {

                    .next()).getValue();
            } else if (TypedObject.class.isInstance(value)) {
                obj = (TypedObject) value;
            }
        }

        return obj;
    }

    public Set entrySet() {

        if (TestCase.class.isInstance(test)) {
            method = ((TestCase) test).getName();
        }
        log.debug("[" + test.getClass() + "] Start method \"" + method + "\"");

                                      Object expected) {
       String formatted = "";
       if (message != null) {
           formatted = message + " ";
       }

       Assert.fail(formatted + "expected not same as : <" + expected + ">");

        assertNotSame(null, expected, actual);
    }

    /**
     * Asserts that an object are not the same.  Throws an
     * <tt>AssertionFailedError</tt> if they are.
     */
    public static void assertNotSame(String message, 
                                       Object expected,
                                       Object actual) {
        if (expected != actual) {

                failNotEquals(message, new Float(expected));
            }
        } else if (Math.abs(expected - actual) <= delta) {
            failNotEquals(message, new Float(expected));

    this.attrMap.remove(ParserConstants.XML_ATTR_CONTENT);
    return this;
  }

  public void processSuccessor(IAction successor) {
    log.debug("processSuccessor(" + successor + ") - START");
    // create attribute list action and insert after rootAction
    if (HintTypes.CONTENT.equals(successor.getHint())) {

      } else if (HintTypes.FIELDS.equals(hintValue)) {
        rootAction.processSuccessor(this);
      } else if (HintTypes.COLLECTION.equals(hintValue)) {

          || HintTypes.ARRAY.equals(hintValue)
          || HintTypes.FIELDS.equals(hintValue)
          || HintTypes.COLLECTION.equals(hintValue)
          || HintTypes.MAP.equals(hintValue)

            sb.append("        </").append(oldOGroup).append(">" + LF);
            sb.append("      </test>" + LF);

    public void validate(boolean mark) {
        if (!this.actualObjectSet) {
            throw new DDTException("Actual object for assertion not provided");
        } else if (ASSERT_ACTION_ISEQUAL.equals(this.action.toUpperCase())) {

                                          Class expected) {
        String formatted = "";
        if (message != null) {
            formatted = message + " ";
        }

        Assert.fail(formatted + "expected not instance of class: <" + expected.getName() + ">");

    static private void failNotSame(String message,
                                      Object expected) {
       String formatted = "";
       if (message != null) {
           formatted = message + " ";
       }

			Object value) throws IllegalAccessException, NoSuchFieldException {
		Field field = getField(instance.getClass(), fieldName);
		field.setAccessible(true);

            log.debug("===Class " + qualifiedClassName + " methods:");

            for (int i = 0; i < m.length; i++) {

    private static final String JAXP_SCHEMA_LANGUAGE = "http://java.sun.com/xml/jaxp/properties/schemaLanguage";

    private static final String JAXP_SCHEMA_SOURCE = "http://java.sun.com/xml/jaxp/properties/schemaSource";

    private static final String W3C_XML_SCHEMA = "http://www.w3.org/2001/XMLSchema";

    private static final String LF = System.getProperty("line.separator");

    public void fatalError(SAXParseException exception) throws SAXException {
        log.error(printParseException("Error", exception), exception);

        if ((flags & FATAL_IGNORE) == 0) {

            this.insert(attribListAction);
            try {
                // create container
                attribListAction.createObject();
                // initialize with first list element
                ((List) attribListAction.getValue()).add(successor.getObject());

        return this;
    }

    public void processSuccessor(IAction successor) {
        log.debug("processSuccessor(" + successor + ") - START");
        // create attribute list action and insert after rootAction
        if (HintTypes.ATTRLIST.equals(successor.getHint())) {

  public MapCreatorAction(Map<String, String> attrMap) {
    super(attrMap);
  }

  /*
   * (non-Javadoc)
   * @see junitx.ddtunit.parser.ActionBase#process()
   */
  public IAction process() {
    log.debug("process MapCreator Action - START");

        return this;
    }

    public void processSuccessor(IAction successor) {
        log.debug("processSuccessor(" + successor + ") - START");
        // create attribute list action and insert after rootAction
        if (HintTypes.ATTRLIST.equals(successor.getHint())) {

	public DateCreatorAction(Map<String, String> attrMap) {
		super(attrMap);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see junitx.ddtunit.parser.ActionBase#process()
	 */
	public IAction process() {
		log.debug("process DateCreator - START");

        return this;
    }

    public void processSuccessor(IAction successor) {
        log.debug("processSuccessor(" + successor + ") - START");
        // create attribute list action and insert after rootAction
        if (HintTypes.ATTRLIST.equals(successor.getHint())) {

  public ContentCreatorAction(Map<String, String> attrMap) {
    super(attrMap);
  }

  /**
   * Contract constraints on processing of Content action: <br/>
   * <ul>
   * <li>Content action must be the last on action stack</li>
   * <li>There must be a valid root action distinct from content action.</li>
   * <li>&nbsp;</li>
   * </ul>
   * @see junitx.ddtunit.data.processing.ActionBase#process()
   */
  public IAction process() {
    log.debug("Process ContentCreator - START");

        if (rootAction != null) {
            String hintValue = rootAction.getHint();

            if (HintTypes.COLLECTION.equals(hintValue)

	public ConstantCreatorAction(Map<String, String> attrMap) {
		super(attrMap);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see junitx.ddtunit.parser.ActionBase#process()
	 */
	public IAction process() {
		log.debug("process ConstantCreator - START");

        rootAction.insert(attribListAction);
        try {
          // create container
          attribListAction.createObject();
          // initialize with first list element
          ((List) attribListAction.getValue()).add(this.getObject());

		if (rootAction != null) {
			String hintValue = rootAction.getHint();

			if (HintTypes.COLLECTION.equals(hintValue)

        } catch (ClassNotFoundException ex) {
            StringBuffer sb = new StringBuffer(
                    "Error on setting elements of array.");
            throw new DDTException(sb.toString(), ex);
        }
    }

        rootAction.insert(attribListAction);
        try {
          // create container
          attribListAction.createObject();
          // initialize with first list element
          ((List) attribListAction.getValue()).add(this.getObject());

    public CallCreatorAction(Map<String, String> attrMap) {
        super(attrMap);
    }

    /*
     * (non-Javadoc)
     * 
     * @see junitx.ddtunit.parser.ActionBase#process()
     */
    public IAction process() {
        log.debug("process CallCreator - START");

		}

		public void resolve(IDataSet dataSet, String groupId, String testId) {
			if (ParserConstants.UNKNOWN.equals(groupId)

        if (TestCase.class.isInstance(test)) {
            method = ((TestCase) test).getName();
        }

				throw DDTException.create(new StringBuffer(
						"Error on behalf of xml test resource."), e);
			} catch (SAXException e) {
				StringBuffer sb = new StringBuffer(

        this.consumer = new DefaultHandler();
        Locator locator = new LocatorImpl();
        this.consumer.setDocumentLocator(locator);
        this.producer.setContentHandler(consumer);

            this.producer = factory.newSAXParser().getXMLReader();
            // this.producer = new SAXParser();
            this.producer.setFeature(XML_NAMESPACE_PREFIX_URI, false);
            this.producer.setFeature(XML_NAMESPACE_URI, true);

                } catch (NoSuchFieldException ex) {
                    throw new DDTTestDataException(
                            "Error resolving reference of " + dest
                                    + " to field " + this.field + " on "
                                    + source, ex);
                }

      } else if (HintTypes.COLLECTION.equals(hintValue)) {
        rootAction.processSuccessor(this);
      } else if (HintTypes.MAP.equals(hintValue)) {

                        + this.getId(), ex);
            }
        } else if (HintTypes.CONTENT.equals(successor.getHint())) {

            try {
                this.getType();
                // if TypedObject is not instanciated and it is no call
                // operation
                // create object by default constructor
                if (this.getValue() == null){
//                        && !HintTypes.CALL.equals(this.getHint())) {
                    this.createObject();
                }

    public void promoteLinkChangeListener(IAction action) {
        for (int count = 0; count < this.changeListeners.size(); count++) {

        } else {
            Assert.fail(formatted + "Expected containing <" + expected.getMessage() + "> in <" + actual.getMessage() + "> or <" + actual.getLocalizedMessage() + "> (localized)");

                                      Object expected) {
        String formatted = "";
        if (message != null) {
            formatted = message + " ";
        }

        fail(formatted + "expected not equals to: <" + expected + ">");

            log.debug("===Class " + qualifiedClassName + " methods:");

            for (int i = 0; i < m.length; i++) {
            	if (m[i].getName().endsWith(methodName)){

    public static Method findMethodByName(String qualifiedClassName, String methodName) {
        try {
            Class c = Class.forName(qualifiedClassName);
            Method[] m = c.getMethods();

	}

	public void processSuccessor(IAction successor) {
		log.debug("processSuccessor(" + successor + ") - START");
		if (HintTypes.CONTENT.equals(successor.getHint())) {

        }
        this.pop();
        return this;
    }

    public void processNoSuccessor() {
        // process direct object call providing no parameters (empty tag)
        IAction action = new AttributeListCreatorAction(
                new HashMap<String, String>());

        }
        superclazz = superclazz.getSuperclass();
      }
      if (!found) {
        throw new DDTException("Container class '" + type
            + "' does not implement java.util.Map.");

                        + this.getId(), ex);
            }
        } else if (HintTypes.CONTENT.equals(successor.getHint())) {
            String content = successor.getValue().toString();

            } else {
                // actual type == array type do separate contain check
                if (this.getActualType().startsWith("[L")) {
                    match = isArrayContainedinList(assertEx);
                    if (match) {

                        .getValue()) >= 0) {
                        Assert.fail("Expected action: " + this.getAction()
                                + ". Got: " + this.getActualObject() + " >= "

        } else if (ASSERT_ACTION_ISNOTNULL.equals(this.action.toUpperCase())) {
            this.markAsProcessed = mark;
            isSameType();
            Assert.assertNotNull("Object should not be null on assert ("

            Assert.assertNotSame("Wrong isNotSame assert (" + this.getId()
                    + ")", this.getValue(), getActualObject());
        } else if (ASSERT_ACTION_ISNULL.equals(this.action.toUpperCase())) {

        } else if (ASSERT_ACTION_ISNULL.equals(this.action.toUpperCase())) {
            this.markAsProcessed = mark;
            isSameType();
            Assert.assertNull("Object should be null on assert ("

            Assert.assertSame("Wrong isSame assert (" + this.getId() + ")",
                this.getValue(), getActualObject());
        } else if (ASSERT_ACTION_ISNOTSAME.equals(this.action.toUpperCase())) {

						ddtEx = new DDTTearDownException(ex.getMessage(), ex);
					}
					this.testResult.addMethodTestError(this, testId, ddtEx);
				}

    }

    /**
     * Asserts that an object are not the same.  Throws an
     * <tt>AssertionFailedError</tt> if they are.
     */
    public static void assertNotSame(Object expected,
                                       Object actual) {
        assertNotSame(null, expected, actual);
    }

                                       float delta) {
        assertNotEquals(null, expected, actual, delta);
    }

    /**
     * Asserts that two ints are not equal. Throws an
     * <tt>AssertionFailedError</tt> if they are equal.
     */
    public static void assertNotEquals(String message,

                                    boolean[] actual) {
        assertEquals(null, expected, actual);
    }

    /**
     * Asserts that two arrays are equal. Two arrays are considered equal if:
     * <ul>
     * <li>their respective lengths are the same</i>
     * <li>all corresponding pairs of elements are equal
     * <li>both array references are <code>null</code>
     * </ul>
     *
     * @param message message to display when arrays are not equal
     * @param expected a byte array of expected values
     * @param actual a byte array of actual values
     */
    public static void assertEquals(String message,

                                    float delta) {
        assertEquals(null, expected, actual, delta);
    }

    /**
     * Asserts that two arrays are equal. Two arrays are considered equal if:
     * <ul>
     * <li>their respective lengths are the same</i>
     * <li>all corresponding pairs of elements are equal
     * <li>both array references are <code>null</code>
     * </ul>
     *
     * @param message message to display when arrays are not equal
     * @param expected a long array of expected values
     * @param actual a long array of actual values
     */
    public static void assertEquals(String message,

            } else {
                iSource = new InputSource(in);
                iSource.setSystemId(this.getClass().getResource(resourceName)

                refInfo = new SubelementReferenceInfo(this.getPrevious()
                    .getObject(), this.getId(), destObject);
                add(refInfo);
            }

            this.processResource = true;
            this.actionStack = new ActionStack();
            pushAction(qName, attrMap);
        } else if (ParserConstants.XML_ELEM_CLUSTER.equals(qName)

    IAction rootAction = getPrevious();
    if (rootAction != null) {
      String hintValue = rootAction.getHint();
      if (HintTypes.CONSTRUCTOR.equals(hintValue)

      } else if (HintTypes.FIELDS.equals(hintValue)) {
        rootAction.processSuccessor(this);
      } else if (HintTypes.COLLECTION.equals(hintValue)) {

        sigObjects = new Object[max];
        for (int pos = 0; pos < max; pos++) {
            TypedObject tObject = (TypedObject) objectList.get(pos);

    IAction rootAction = getPrevious();
    if (rootAction != null) {
      String hintValue = rootAction.getHint();
      if (HintTypes.CONSTRUCTOR.equals(hintValue)

    this.attrMap.remove(ParserConstants.XML_ATTR_CONTENT);
    return this;
  }

  public void processSuccessor(IAction successor) {
    log.debug("processSuccessor(" + successor + ") - START");

        if (HintTypes.ATTRLIST.equals(successor.getHint())) {
            List fields = (List) successor.getObject().getValue();
            TypedObject field = null;
            try {

				throw new DDTException(sb.toString(), ex);
			}
		} else if (HintTypes.CONTENT.equals(successor.getHint())) {

        } catch (Exception ex) {
          throw new DDTException("Error on action processing", ex);
        }

      } else if (HintTypes.FIELDS.equals(hintValue)) {

        IAction rootAction = this.getPrevious();
        if (rootAction != null) {
            String hintValue = rootAction.getHint();

            if (HintTypes.COLLECTION.equals(hintValue)) {

                                + " not in " + this.getValue() + " on assert ("
                                + this.getId() + ")");
                    }
                } else if (ASSERT_ACTION_ISNOTINRANGE.equals(this.action

                        .getActualObject())) {
                        Assert.fail("Expected action: " + this.getAction()
                                + ". Got: " + this.getActualObject()
                                + " not in " + this.getValue() + " on assert ("

                                + " not in " + this.getValue() + " on assert ("
                                + this.getId() + ")");
                    }
                } else if (ASSERT_ACTION_ISNOTINRANGE.equals(this.action

                        .getActualObject())) {
                        Assert.fail("Expected action: " + this.getAction()
                                + ". Got: " + this.getActualObject()
                                + " not in " + this.getValue() + " on assert ("

                                + this.getValue() + " on assert ("
                                + this.getId() + ")");
                    }
                } else if (ASSERT_ACTION_ISNOTLT.equals(this.action

                        .getActualObject())) {
                        Assert.fail("Expected action: " + this.getAction()
                                + ". Got: " + this.getActualObject()
                                + " not in " + this.getValue() + " on assert ("

                                            Throwable actual) {
        String formatted = "";
        if (message != null) {
            formatted = message + " ";
        }
        if (actual.getMessage().equals(actual.getLocalizedMessage())) {

                if (ctor[i].toString().indexOf(searchTerm) != -1) {
                    log.info(ctor[i].toString());

                if (this.refProcessor == null) {
                    this.refProcessor = new ReferenceProcessor(
                            this.clusterDataSet);
                }

      if (HintTypes.CONSTRUCTOR.equals(hintValue)
          || HintTypes.CALL.equals(hintValue)) {

        return this;
    }

    public void processSuccessor(IAction successor) {
        log.debug("processSuccessor(" + successor + ") - START");

      if (HintTypes.CONSTRUCTOR.equals(hintValue)
          || HintTypes.CALL.equals(hintValue)) {

                    TypedObject source = testDataSet.getObject(this
                        .getSourceId(), this.getSourceType());
                    if (source == null && testDataSet instanceof TestDataSet) {

            } else if ("value".equals(this.injectedObject.getId())) {
                objectType = rootAction
                    .getAttribute(ParserConstants.XML_ATTR_VALUETYPE);

    private void removeFromLinkChangeListener(IAction action) {
        for (int count = 0; count < this.changeListeners.size(); count++) {

        } else if (ASSERT_ACTION_ISSAME.equals(this.action.toUpperCase())) {
            this.markAsProcessed = mark;
            isSameType();

            ThrowableAssert.assertSimilar("Unexpected exception",
                (Throwable) getValue(), (Throwable) getActualObject());
        } else if (EXCEPTION_ACTION_ISINSTANCEOF.equals(this.action

		} catch (Exception e) {
			e.printStackTrace();
			throw new DDTException(
					"Error on transforming TestResult to DDTResult", e);
		}

					"Error retrieving testdata, could not find object.");
		} else {
			obj = typedObject.getValue();
		}
		return obj;
	}

	/**
	 * Retrieve object with specified identifier on a per class basis. <br/>If
	 * no data exists an exception will be raised.
	 * 
	 * @param objectId
	 *            specifies key for retrieval
	 * 
	 * @return Object that is stored under identifier key
	 */
	protected Object getGlobalObject(String objectId, String objectType) {

		if (!this.classDataSet.containsKey(this.getName())) {
			throw new DDTException("No asserts defined in method scope");

                                            Throwable actual) {
        String formatted = "";
        if (message != null) {
            formatted = message + " ";
        }

                                          Class expected) {
        String formatted = "";
        if (message != null) {
            formatted = message + " ";
        }

                                       short actual) {
        assertNotEquals(null, expected, actual);
    }

    /**
     * Asserts that two boolean are not equal. Throws an
     * <tt>AssertionFailedError</tt> if they are equal.
     */
    public static void assertNotEquals(String message,

    public static void assertEquals(String expected, String actual) {
        assertEquals(null, expected, actual);
    }

    /**
     * Asserts that two strings are equal. Throws an
     * <tt>AssertionFailedError</tt> if not.
     */
    public static void assertEquals(String message, String expected, String actual) {

                packageName = clazz.getPackage().getName().replaceAll(
                    "\\.", pathSeparator);
            }
        }
        return packageName;
    }

            Map attribMap = new HashMap();
            IAction attribListAction = ActionFactory.getAction(
                ActionState.ATTRLIST_CREATION, attribMap);

                this.actionStack = new ActionStack();
                pushAction(qName, attrMap);
            } else if (ParserConstants.XML_ELEM_EXCEPTION.equals(qName)

          || HintTypes.COLLECTION.equals(hintValue)
          || HintTypes.MAP.equals(hintValue)
          || HintTypes.BEAN.equals(hintValue)) {

      } else if (HintTypes.MAP.equals(hintValue)) {
        rootAction.processSuccessor(this);
      } else {
        throw new UnsupportedOperationException(

        Map attribMap = new HashMap();
        IAction attribListAction = ActionFactory.getAction(
            ActionState.ATTRLIST_CREATION, attribMap);

                    .append(". Check if hint is correct.");
                throw new DDTException(sb.toString(), ex);
            }
        } else if (HintTypes.INTERNAL_MAPENTRY.equals(this.getHint())) {

    public SubelementCreatorAction(Map attrMap) {
        super(attrMap);
    }

    /*
     * (non-Javadoc)
     * 
     * @see junitx.ddtunit.parser.ActionBase#process()
     */
    public IAction process() {
        log.debug("process SubelementCreator - START");

      } else if (HintTypes.MAP.equals(hintValue)) {
        rootAction.processSuccessor(this);
      } else {
        throw new UnsupportedOperationException(

			} else if (HintTypes.INTERNAL_MAPENTRY.equals(hintValue)) {
				rootAction.processSuccessor(this);
			} else {

		if (HintTypes.ATTRLIST.equals(successor.getHint())) {
			List fields = (List) successor.getObject().getValue();
			TypedObject field = null;

        Map attribMap = new HashMap();
        IAction attribListAction = ActionFactory.getAction(
            ActionState.ATTRLIST_CREATION, attribMap);

        } else if (HintTypes.ARRAY.equals(hintValue)) {
            rootAction.processSuccessor(this);
        } else {
            throw new UnsupportedOperationException(

                || ASSERT_ACTION_ISNOTINRANGE.equals(this.action.toUpperCase())) {
            this.markAsProcessed = mark;
            // if doing range checks do not check expected and actual types
            if (!(this.getValue() instanceof IRange)) {

        } else if (ASSERT_ACTION_ISNOTSAME.equals(this.action.toUpperCase())) {
            this.markAsProcessed = mark;
            Assert.assertNotSame("Wrong isNotSame assert (" + this.getId()

            Assert.assertNotEquals("Wrong isNotEqual assert (" + this.getId()
                    + ")", this.getValue(), getActualObject());
        } else if (ASSERT_ACTION_ISSAME.equals(this.action.toUpperCase())) {

        } else if (EXCEPTION_ACTION_ISSIMILAR.equals(this.action.toUpperCase())) {
            this.markAsProcessed = mark;
            ThrowableAssert.assertSimilar("Unexpected exception",

        log.debug("filter(" + methodName + ", " + testId + ", "
                + aThrowable.getMessage() + ") found: "

        log.debug("process(" + methodName + ", " + testId + ", "
                + aThrowable.getMessage() + ") - END");

    private static final String LF = System.getProperty("line.separator");

    private Logger log = LoggerFactory.getLogger(ErrorHandler.class);