cd160610-9b67-4752-a2c4-e3a0d82d991e

Committed 21 Apr 2025 11:55AM UTC coverage: 91.756% (-0.02%) from 91.78%

Build # cd160610-9b67-4752-a2c4-e3a0d82d991e

Build Type

push

circleci

Committed by

web-flow

Commit Message

Merge pull request #289 from xmlunit/circleci-project-setup

CircleCI project setup

Run Details

3996 of 4698 branches covered (85.06%)

11754 of 12810 relevant lines covered (91.76%)

2.35 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.45

/xmlunit-matchers/src/main/java/org/xmlunit/matchers/ValidationMatcher.java

/*
  This file is licensed 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.xmlunit.matchers;

import static org.xmlunit.util.Linqy.any;
import static org.xmlunit.util.Linqy.asList;
import static org.xmlunit.util.Linqy.map;

import org.xmlunit.builder.Input;
import org.xmlunit.util.IsNullPredicate;
import org.xmlunit.util.Mapper;
import org.xmlunit.util.Predicate;
import org.xmlunit.validation.JAXPValidator;
import org.xmlunit.validation.Languages;
import org.xmlunit.validation.ValidationProblem;
import org.xmlunit.validation.ValidationResult;
import org.hamcrest.BaseMatcher;
import org.hamcrest.Description;
import org.hamcrest.Factory;

import javax.xml.transform.Source;
import javax.xml.validation.Schema;
import java.util.Arrays;

/**
 * Hamcrest Matcher for XML Validation against W3C XML Schema using
 * {@link JAXPValidator}.
 */
public class ValidationMatcher extends BaseMatcher {

    private final Source[] schemaSource;
    private final Schema schema;
    private Source instance;
    private ValidationResult result;

    /**
     * @param schemaSource schema source document(s)
     */
    public ValidationMatcher(Object... schemaSource) {
        if (schemaSource == null) {
            throw new IllegalArgumentException("schemaSource must not be null");
        }
        Iterable<Object> schemaSourceList = Arrays.asList(schemaSource);
        if (any(schemaSourceList, new IsNullPredicate())) {
            throw new IllegalArgumentException("schemaSource must not contain null values");
        }
        this.schemaSource = asList(map(schemaSourceList,
                                       new Mapper<Object, Source>() {
                                           @Override
                                           public Source apply(Object source) {
                                               return Input.from(source).build();
                                           }
                                       })
                                   ).toArray(new Source[schemaSource.length]);
        schema = null;
    }

    /**
     * @param schema schema source document
     * @since XMLUnit 2.3.0
     */
    public ValidationMatcher(Schema schema) {
        if (schema == null) {
            throw new IllegalArgumentException("schema must not be null");
        }
        this.schemaSource = new Source[0];
        this.schema = schema;
    }

    @Override
    public boolean matches(Object instance) {
        this.instance = Input.from(instance).build();
        JAXPValidator v = new JAXPValidator(Languages.W3C_XML_SCHEMA_NS_URI);
        if (schema != null) {
            v.setSchema(schema);
        } else if (schemaSource.length > 0) {
            v.setSchemaSources(schemaSource);
        }
        this.result = v.validateInstance(this.instance);
        return this.result.isValid();
    }

    @Override
    public void describeTo(Description description) {
        description.appendText(" that ")
            .appendValue(instance != null && instance.getSystemId() != null
                         ? instance.getSystemId() : "instance");
        if (schema == null && any(Arrays.asList(schemaSource), new HasSystemIdPredicate())) {
            description.appendText(" validates against ");
            boolean first = true;
            for (Source schema : Arrays.asList(schemaSource)) {
                if (!first) {
                    description.appendValue(", ");
                }
                first = false;
                description.appendValue(schema.getSystemId() != null
                                        ? schema.getSystemId()
                                        : "schema without systemId");
            }
        } else {
            description.appendText(" validates");
        }
    }

    @Override
    public void describeMismatch(final Object item, final Description mismatchDescription) {
        if (this.result != null && this.result.getProblems() != null) {
            mismatchDescription.appendText(" got validation errors: ");
            for (ValidationProblem problem : this.result.getProblems()) {
                mismatchDescription.appendText(problem.toString());
            }
        } else {
            mismatchDescription.appendText(" got unexpected error!");
        }
    }

    /**
     * Creates a matcher that validates the XML under test.
     * @param schemaSource schema source document
     * @return matcher
     */
    @Factory
    public static ValidationMatcher valid(final Object schemaSource) {
        return new ValidationMatcher(schemaSource);
    }

    /**
     * Creates a matcher that validates the XML under test.
     * @param schema schema source document
     * @return matcher
     * @since XMLUnit 2.3.0
     */
    @Factory
    public static ValidationMatcher valid(final Schema schema) {
        return new ValidationMatcher(schema);
    }

    private static class HasSystemIdPredicate implements Predicate<Source> {
        @Override
        public boolean test(Source s) {
            return s.getSystemId() != null;
        }
    }
}

1	/*
2	This file is licensed to You under the Apache License, Version 2.0
3	(the "License"); you may not use this file except in compliance with
4	the License. You may obtain a copy of the License at
5
6	http://www.apache.org/licenses/LICENSE-2.0
7
8	Unless required by applicable law or agreed to in writing, software
9	distributed under the License is distributed on an "AS IS" BASIS,
10	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11	See the License for the specific language governing permissions and
12	limitations under the License.
13	*/
14	package org.xmlunit.matchers;
15
16	import static org.xmlunit.util.Linqy.any;
17	import static org.xmlunit.util.Linqy.asList;
18	import static org.xmlunit.util.Linqy.map;
19
20	import org.xmlunit.builder.Input;
21	import org.xmlunit.util.IsNullPredicate;
22	import org.xmlunit.util.Mapper;
23	import org.xmlunit.util.Predicate;
24	import org.xmlunit.validation.JAXPValidator;
25	import org.xmlunit.validation.Languages;
26	import org.xmlunit.validation.ValidationProblem;
27	import org.xmlunit.validation.ValidationResult;
28	import org.hamcrest.BaseMatcher;
29	import org.hamcrest.Description;
30	import org.hamcrest.Factory;
31
32	import javax.xml.transform.Source;
33	import javax.xml.validation.Schema;
34	import java.util.Arrays;
35
36	/**
37	* Hamcrest Matcher for XML Validation against W3C XML Schema using
38	* {@link JAXPValidator}.
39	*/
40	public class ValidationMatcher extends BaseMatcher {
41
42	private final Source[] schemaSource;
43	private final Schema schema;
44	private Source instance;
45	private ValidationResult result;
46
47	/**
48	* @param schemaSource schema source document(s)
49	*/
50	public ValidationMatcher(Object... schemaSource) {	1✔
51	if (schemaSource == null) {	1✔
52	throw new IllegalArgumentException("schemaSource must not be null");	1✔
53	}
54	Iterable<Object> schemaSourceList = Arrays.asList(schemaSource);	1✔
55	if (any(schemaSourceList, new IsNullPredicate())) {	1!
56	throw new IllegalArgumentException("schemaSource must not contain null values");	×
57	}
58	this.schemaSource = asList(map(schemaSourceList,	1✔
59	new Mapper<Object, Source>() {	1✔
60	@Override
61	public Source apply(Object source) {
62	return Input.from(source).build();	1✔
63	}
64	})
65	).toArray(new Source[schemaSource.length]);	1✔
66	schema = null;	1✔
67	}	1✔
68
69	/**
70	* @param schema schema source document
71	* @since XMLUnit 2.3.0
72	*/
73	public ValidationMatcher(Schema schema) {	1✔
74	if (schema == null) {	1✔
75	throw new IllegalArgumentException("schema must not be null");	1✔
76	}
77	this.schemaSource = new Source[0];	1✔
78	this.schema = schema;	1✔
79	}	1✔
80
81	@Override
82	public boolean matches(Object instance) {
83	this.instance = Input.from(instance).build();	1✔
84	JAXPValidator v = new JAXPValidator(Languages.W3C_XML_SCHEMA_NS_URI);	1✔
85	if (schema != null) {	1✔
86	v.setSchema(schema);	1✔
87	} else if (schemaSource.length > 0) {	1✔
88	v.setSchemaSources(schemaSource);	1✔
89	}
90	this.result = v.validateInstance(this.instance);	1✔
91	return this.result.isValid();	1✔
92	}
93
94	@Override
95	public void describeTo(Description description) {
96	description.appendText(" that ")	1✔
97	.appendValue(instance != null && instance.getSystemId() != null	1!
98	? instance.getSystemId() : "instance");	1✔
99	if (schema == null && any(Arrays.asList(schemaSource), new HasSystemIdPredicate())) {	1!
100	description.appendText(" validates against ");	1✔
101	boolean first = true;	1✔
102	for (Source schema : Arrays.asList(schemaSource)) {	1✔
103	if (!first) {	1!
104	description.appendValue(", ");	×
105	}
106	first = false;	1✔
107	description.appendValue(schema.getSystemId() != null	1!
108	? schema.getSystemId()	1✔
109	: "schema without systemId");	×
110	}	1✔
111	} else {	1✔
112	description.appendText(" validates");	1✔
113	}
114	}	1✔
115
116	@Override
117	public void describeMismatch(final Object item, final Description mismatchDescription) {
118	if (this.result != null && this.result.getProblems() != null) {	1!
119	mismatchDescription.appendText(" got validation errors: ");	1✔
120	for (ValidationProblem problem : this.result.getProblems()) {	1✔
121	mismatchDescription.appendText(problem.toString());	1✔
122	}	1✔
123	} else {
124	mismatchDescription.appendText(" got unexpected error!");	×
125	}
126	}	1✔
127
128	/**
129	* Creates a matcher that validates the XML under test.
130	* @param schemaSource schema source document
131	* @return matcher
132	*/
133	@Factory
134	public static ValidationMatcher valid(final Object schemaSource) {
135	return new ValidationMatcher(schemaSource);	1✔
136	}
137
138	/**
139	* Creates a matcher that validates the XML under test.
140	* @param schema schema source document
141	* @return matcher
142	* @since XMLUnit 2.3.0
143	*/
144	@Factory
145	public static ValidationMatcher valid(final Schema schema) {
146	return new ValidationMatcher(schema);	1✔
147	}
148
149	private static class HasSystemIdPredicate implements Predicate<Source> {
150	@Override
151	public boolean test(Source s) {
152	return s.getSystemId() != null;	1!
153	}
154	}
155	}

xmlunit / xmlunit / cd160610-9b67-4752-a2c4-e3a0d82d991e

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous