#747

Committed 10 Mar 2026 08:32AM UTC coverage: 85.345% (-0.2%) from 85.581%

Build # #747

Build Type

push

Committed by

Commit Message

Merge pull request #288 from pkiraly/dependabot/maven/org.apache.maven.plugins-maven-shade-plugin-3.6.2

build(deps-dev): bump org.apache.maven.plugins:maven-shade-plugin from 3.6.1 to 3.6.2

Coverage Stats

5707 of 6687 relevant lines covered (85.34%)

0.85 hits per line

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

40.54

/src/main/java/de/gwdg/metadataqa/api/rule/logical/OrChecker.java

package de.gwdg.metadataqa.api.rule.logical;

import de.gwdg.metadataqa.api.counter.FieldCounter;
import de.gwdg.metadataqa.api.json.DataElement;
import de.gwdg.metadataqa.api.model.XmlFieldInstance;
import de.gwdg.metadataqa.api.model.selector.Selector;
import de.gwdg.metadataqa.api.rule.RuleChecker;
import de.gwdg.metadataqa.api.rule.RuleCheckerOutput;
import de.gwdg.metadataqa.api.rule.RuleCheckingOutputStatus;
import de.gwdg.metadataqa.api.rule.RuleCheckingOutputType;
import de.gwdg.metadataqa.api.rule.singlefieldchecker.DependencyChecker;
import de.gwdg.metadataqa.api.rule.singlefieldchecker.MinCountChecker;
import de.gwdg.metadataqa.api.util.ParentCheckManager;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import java.util.logging.Logger;

public class OrChecker extends LogicalChecker {

  private static final Logger LOGGER = Logger.getLogger(OrChecker.class.getCanonicalName());

  private static final long serialVersionUID = 1114999259831619599L;
  public static final String PREFIX = "or";

  /**
   * @param field The field
   * @param checkers The list of checkers
   */
  public OrChecker(DataElement field, List<RuleChecker> checkers) {
    this(field, field.getLabel(), checkers);
  }

  public OrChecker(DataElement field, String header, List<RuleChecker> checkers) {
    super(field, header + ":" + PREFIX + ":" + getChildrenHeader(checkers));
    this.checkers = checkers;
  }

  @Override
  public void update(Selector selector, FieldCounter<RuleCheckerOutput> results, RuleCheckingOutputType outputType) {
    update(selector, results, outputType, null);
  }

  public void update(Selector selector,
                     FieldCounter<RuleCheckerOutput> results,
                     RuleCheckingOutputType outputType,
                     FieldCounter<RuleCheckerOutput> globalResults) {
    if (isDebug())
      LOGGER.info(this.getClass().getSimpleName() + " " + this.id + ", alwaysCheckDependencies: " + alwaysCheckDependencies + ", priorityOnFail: " + priorityOnFail + " - " + results);

    if (globalResults == null) {
      globalResults = results;
    }

    // if NA and dependency checker FAILED -> FAILED
    var allPassed = false;
    var isNA = false;
    RuleCheckerOutput output = null;
    List<RuleCheckingOutputStatus> statuses = new ArrayList<>();
    boolean parentCheckPassed = true;
    boolean hasParent = false;
    ParentCheckManager parentCheckManager = new ParentCheckManager(isNaIfNoParent());

    List<XmlFieldInstance> instances = selector.get(field);
    if (instances != null && !instances.isEmpty()) {
      if (isDebug())
        LOGGER.info("non empty - naIfNoParent: " + isNaIfNoParent());
      FieldCounter<RuleCheckerOutput> localResults2 = new FieldCounter<>();
      for (RuleChecker checker : checkers) {
        boolean isParentChecker = false;
        if (checker instanceof DependencyChecker) {
          ((DependencyChecker) checker).update(selector, localResults2, outputType, results);
          isParentChecker = ((DependencyChecker) checker).getParentCheck();
        } else if (checker instanceof AndChecker) {
          ((AndChecker) checker).update(selector, localResults2, outputType, results);
        } else {
          checker.update(selector, localResults2, outputType);
        }
        String key = outputType.equals(RuleCheckingOutputType.BOTH)
                   ? checker.getIdOrHeader(RuleCheckingOutputType.SCORE)
                   : checker.getIdOrHeader();
        RuleCheckingOutputStatus status = localResults2.get(key).getStatus();
        if (!isParentChecker)
          statuses.add(status);
        if (!priorityOnFail && status.equals(RuleCheckingOutputStatus.PASSED)) {
          allPassed = true;
          break;
        }
      }
    } else {
      if (isDebug())
        LOGGER.info("empty branch - naIfNoParent: " + isNaIfNoParent());
      isNA = true;
      for (RuleChecker checker : checkers) {
        if (checker instanceof MinCountChecker) {
          MinCountChecker minCountChecker = (MinCountChecker) checker;
          if (!minCountChecker.isEmptyInstancesAllowed() || minCountChecker.getMinCount() > 0)
            allPassed = false;
        }
        else if (alwaysCheckDependencies && checker instanceof DependencyChecker) {
          DependencyChecker dependencyChecker = (DependencyChecker) checker;
          Map<String, Boolean> localResult = dependencyChecker.getResult(outputType, results);
          boolean dependenciesPassed = localResult.get("allPassed");
          var localIsNA = localResult.get("isNA");
          // LOGGER.info("ParentCheck: " + dependencyChecker.getParentCheck() + ", passed: " + dependenciesPassed
          //  + ", localIsNA: " + localIsNA + ", dependencies: " + dependencyChecker.getDependencies());
          if (dependencyChecker.getParentCheck())
            parentCheckManager.add(dependenciesPassed);
          if (dependencyChecker.getParentCheck() && !dependenciesPassed) {
            if (parentCheckPassed)
              parentCheckPassed = false;
            // if (!localIsNA)
            //  isNA = false;
            // break;
            if (!localIsNA && !hasParent)
              hasParent = true;
          }
          if (localIsNA) {
            output = new RuleCheckerOutput(this, RuleCheckingOutputStatus.NA);
          } else {
            if (dependenciesPassed)
              output = new RuleCheckerOutput(this, RuleCheckingOutputStatus.PASSED);
            else
              output = new RuleCheckerOutput(this, RuleCheckingOutputStatus.FAILED);
          }
          if (!dependencyChecker.getParentCheck() || !localIsNA) {
            statuses.add(output.getStatus());
          }
        }
        // if (!allPassed)
        //   break;
      }
    }

    /*
    LOGGER.info("priorityOnFail: " + priorityOnFail + ", isNaIfNoParent: " + isNaIfNoParent() + ", isNA: " + isNA + ", hasParent: " + hasParent + ", parentCheckPassed: " + parentCheckManager.hasParent() + ", statuses: " + statuses);
    LOGGER.info(parentCheckManager.toString());
    */

    boolean caseHandled = false;
    if (isNA && parentCheckManager.getNaIfNoParent() && !parentCheckManager.hasParent()) {
      output = new RuleCheckerOutput(this, RuleCheckingOutputStatus.NA); // NA
      caseHandled = true;
    }

    if (!caseHandled && priorityOnFail) {
      output = null;
      if (isDebug())
        LOGGER.info("priorityOnFail (1)! isNA: " + isNA + ", statuses: " + statuses + ", parentCheckPassed: " + parentCheckManager.hasParent());
      // allPassed = statuses.contains(RuleCheckingOutputStatus.PASSED);
      allPassed = !statuses.contains(RuleCheckingOutputStatus.FAILED);
      if (!allPassed && hasParent)
        isNA = false;

      if (!statuses.isEmpty()
          && !containsOnlyNAs(statuses)
          && (!allPassed || statuses.contains(RuleCheckingOutputStatus.PASSED))
          && parentCheckManager.hasParent())
        isNA = false;

      if (isNaIfNoParent() && isNA && parentCheckManager.hasParent()) {
        isNA = false;
      }

      if (!isNaIfNoParent() && isNA && !parentCheckManager.hasParent() && !allPassed) {
        isNA = false;
      }
    }


    if (output != null) {
      addOutput(results, output, outputType);
    } else {
      addOutput(results, isNA, allPassed, outputType);
    }

    if (isDebug()) {
      RuleCheckingOutputStatus status = output != null
        ? output.getStatus()
        : RuleCheckingOutputStatus.create(isNA, allPassed, isMandatory());
      LOGGER.info(String.format("%s %s) isNA: %s, allPassed: %s, result: %s",
        this.getClass().getSimpleName(), this.id, isNA, allPassed, status));
    }
  }

  public Map<RuleCheckingOutputType, Object> getResult(RuleCheckingOutputType outputType,
                                                       FieldCounter<RuleCheckerOutput> globalResults) {
    Map<RuleCheckingOutputType, Object> result = new HashMap();
    if (outputType.equals(RuleCheckingOutputType.STATUS)) {
      result.put(RuleCheckingOutputType.STATUS, globalResults.get(getIdOrHeader()));
    } else if (outputType.equals(RuleCheckingOutputType.SCORE)) {
      result.put(RuleCheckingOutputType.SCORE, globalResults.get(getIdOrHeader()));
    } else if (outputType.equals(RuleCheckingOutputType.BOTH)) {
      result.put(RuleCheckingOutputType.STATUS, globalResults.get(getIdOrHeader() + ":status"));
      result.put(RuleCheckingOutputType.SCORE, globalResults.get(getIdOrHeader() + ":score"));
    }
    return result;
  }
}

1	package de.gwdg.metadataqa.api.rule.logical;
2
3	import de.gwdg.metadataqa.api.counter.FieldCounter;
4	import de.gwdg.metadataqa.api.json.DataElement;
5	import de.gwdg.metadataqa.api.model.XmlFieldInstance;
6	import de.gwdg.metadataqa.api.model.selector.Selector;
7	import de.gwdg.metadataqa.api.rule.RuleChecker;
8	import de.gwdg.metadataqa.api.rule.RuleCheckerOutput;
9	import de.gwdg.metadataqa.api.rule.RuleCheckingOutputStatus;
10	import de.gwdg.metadataqa.api.rule.RuleCheckingOutputType;
11	import de.gwdg.metadataqa.api.rule.singlefieldchecker.DependencyChecker;
12	import de.gwdg.metadataqa.api.rule.singlefieldchecker.MinCountChecker;
13	import de.gwdg.metadataqa.api.util.ParentCheckManager;
14
15	import java.util.ArrayList;
16	import java.util.List;
17	import java.util.Map;
18	import java.util.HashMap;
19	import java.util.logging.Logger;
20
21	public class OrChecker extends LogicalChecker {
22
23	private static final Logger LOGGER = Logger.getLogger(OrChecker.class.getCanonicalName());	1✔
24
25	private static final long serialVersionUID = 1114999259831619599L;
26	public static final String PREFIX = "or";
27
28	/**
29	* @param field The field
30	* @param checkers The list of checkers
31	*/
32	public OrChecker(DataElement field, List<RuleChecker> checkers) {
33	this(field, field.getLabel(), checkers);	1✔
34	}	1✔
35
36	public OrChecker(DataElement field, String header, List<RuleChecker> checkers) {
37	super(field, header + ":" + PREFIX + ":" + getChildrenHeader(checkers));	1✔
38	this.checkers = checkers;	1✔
39	}	1✔
40
41	@Override
42	public void update(Selector selector, FieldCounter<RuleCheckerOutput> results, RuleCheckingOutputType outputType) {
43	update(selector, results, outputType, null);	1✔
44	}	1✔
45
46	public void update(Selector selector,
47	FieldCounter<RuleCheckerOutput> results,
48	RuleCheckingOutputType outputType,
49	FieldCounter<RuleCheckerOutput> globalResults) {
50	if (isDebug())	1✔
51	LOGGER.info(this.getClass().getSimpleName() + " " + this.id + ", alwaysCheckDependencies: " + alwaysCheckDependencies + ", priorityOnFail: " + priorityOnFail + " - " + results);	×
52
53	if (globalResults == null) {	1✔
54	globalResults = results;	1✔
55	}
56
57	// if NA and dependency checker FAILED -> FAILED
58	var allPassed = false;	1✔
59	var isNA = false;	1✔
60	RuleCheckerOutput output = null;	1✔
61	List<RuleCheckingOutputStatus> statuses = new ArrayList<>();	1✔
62	boolean parentCheckPassed = true;	1✔
63	boolean hasParent = false;	1✔
64	ParentCheckManager parentCheckManager = new ParentCheckManager(isNaIfNoParent());	1✔
65
66	List<XmlFieldInstance> instances = selector.get(field);	1✔
67	if (instances != null && !instances.isEmpty()) {	1✔
68	if (isDebug())	1✔
69	LOGGER.info("non empty - naIfNoParent: " + isNaIfNoParent());	×
70	FieldCounter<RuleCheckerOutput> localResults2 = new FieldCounter<>();	1✔
71	for (RuleChecker checker : checkers) {	1✔
72	boolean isParentChecker = false;	1✔
73	if (checker instanceof DependencyChecker) {	1✔
74	((DependencyChecker) checker).update(selector, localResults2, outputType, results);	×
75	isParentChecker = ((DependencyChecker) checker).getParentCheck();	×
76	} else if (checker instanceof AndChecker) {	1✔
77	((AndChecker) checker).update(selector, localResults2, outputType, results);	×
78	} else {
79	checker.update(selector, localResults2, outputType);	1✔
80	}
81	String key = outputType.equals(RuleCheckingOutputType.BOTH)	1✔
82	? checker.getIdOrHeader(RuleCheckingOutputType.SCORE)	1✔
83	: checker.getIdOrHeader();	1✔
84	RuleCheckingOutputStatus status = localResults2.get(key).getStatus();	1✔
85	if (!isParentChecker)	1✔
86	statuses.add(status);	1✔
87	if (!priorityOnFail && status.equals(RuleCheckingOutputStatus.PASSED)) {	1✔
88	allPassed = true;	1✔
89	break;	1✔
90	}
91	}	1✔
92	} else {	1✔
93	if (isDebug())	×
94	LOGGER.info("empty branch - naIfNoParent: " + isNaIfNoParent());	×
95	isNA = true;	×
96	for (RuleChecker checker : checkers) {	×
97	if (checker instanceof MinCountChecker) {	×
98	MinCountChecker minCountChecker = (MinCountChecker) checker;	×
99	if (!minCountChecker.isEmptyInstancesAllowed() \|\| minCountChecker.getMinCount() > 0)	×
100	allPassed = false;	×
101	}	×
102	else if (alwaysCheckDependencies && checker instanceof DependencyChecker) {	×
103	DependencyChecker dependencyChecker = (DependencyChecker) checker;	×
104	Map<String, Boolean> localResult = dependencyChecker.getResult(outputType, results);	×
105	boolean dependenciesPassed = localResult.get("allPassed");	×
106	var localIsNA = localResult.get("isNA");	×
107	// LOGGER.info("ParentCheck: " + dependencyChecker.getParentCheck() + ", passed: " + dependenciesPassed
108	// + ", localIsNA: " + localIsNA + ", dependencies: " + dependencyChecker.getDependencies());
109	if (dependencyChecker.getParentCheck())	×
110	parentCheckManager.add(dependenciesPassed);	×
111	if (dependencyChecker.getParentCheck() && !dependenciesPassed) {	×
112	if (parentCheckPassed)	×
113	parentCheckPassed = false;	×
114	// if (!localIsNA)
115	// isNA = false;
116	// break;
117	if (!localIsNA && !hasParent)	×
118	hasParent = true;	×
119	}
120	if (localIsNA) {	×
121	output = new RuleCheckerOutput(this, RuleCheckingOutputStatus.NA);	×
122	} else {
123	if (dependenciesPassed)	×
124	output = new RuleCheckerOutput(this, RuleCheckingOutputStatus.PASSED);	×
125	else
126	output = new RuleCheckerOutput(this, RuleCheckingOutputStatus.FAILED);	×
127	}
128	if (!dependencyChecker.getParentCheck() \|\| !localIsNA) {	×
129	statuses.add(output.getStatus());	×
130	}
131	}
132	// if (!allPassed)
133	// break;
134	}	×
135	}
136
137	/*
138	LOGGER.info("priorityOnFail: " + priorityOnFail + ", isNaIfNoParent: " + isNaIfNoParent() + ", isNA: " + isNA + ", hasParent: " + hasParent + ", parentCheckPassed: " + parentCheckManager.hasParent() + ", statuses: " + statuses);
139	LOGGER.info(parentCheckManager.toString());
140	*/
141
142	boolean caseHandled = false;	1✔
143	if (isNA && parentCheckManager.getNaIfNoParent() && !parentCheckManager.hasParent()) {	1✔
144	output = new RuleCheckerOutput(this, RuleCheckingOutputStatus.NA); // NA	×
145	caseHandled = true;	×
146	}
147
148	if (!caseHandled && priorityOnFail) {	1✔
149	output = null;	×
150	if (isDebug())	×
151	LOGGER.info("priorityOnFail (1)! isNA: " + isNA + ", statuses: " + statuses + ", parentCheckPassed: " + parentCheckManager.hasParent());	×
152	// allPassed = statuses.contains(RuleCheckingOutputStatus.PASSED);
153	allPassed = !statuses.contains(RuleCheckingOutputStatus.FAILED);	×
154	if (!allPassed && hasParent)	×
155	isNA = false;	×
156
157	if (!statuses.isEmpty()	×
158	&& !containsOnlyNAs(statuses)	×
159	&& (!allPassed \|\| statuses.contains(RuleCheckingOutputStatus.PASSED))	×
160	&& parentCheckManager.hasParent())	×
161	isNA = false;	×
162
163	if (isNaIfNoParent() && isNA && parentCheckManager.hasParent()) {	×
164	isNA = false;	×
165	}
166
167	if (!isNaIfNoParent() && isNA && !parentCheckManager.hasParent() && !allPassed) {	×
168	isNA = false;	×
169	}
170	}
171
172
173	if (output != null) {	1✔
174	addOutput(results, output, outputType);	×
175	} else {
176	addOutput(results, isNA, allPassed, outputType);	1✔
177	}
178
179	if (isDebug()) {	1✔
180	RuleCheckingOutputStatus status = output != null	×
181	? output.getStatus()	×
182	: RuleCheckingOutputStatus.create(isNA, allPassed, isMandatory());	×
183	LOGGER.info(String.format("%s %s) isNA: %s, allPassed: %s, result: %s",	×
184	this.getClass().getSimpleName(), this.id, isNA, allPassed, status));	×
185	}
186	}	1✔
187
188	public Map<RuleCheckingOutputType, Object> getResult(RuleCheckingOutputType outputType,
189	FieldCounter<RuleCheckerOutput> globalResults) {
190	Map<RuleCheckingOutputType, Object> result = new HashMap();	×
191	if (outputType.equals(RuleCheckingOutputType.STATUS)) {	×
192	result.put(RuleCheckingOutputType.STATUS, globalResults.get(getIdOrHeader()));	×
193	} else if (outputType.equals(RuleCheckingOutputType.SCORE)) {	×
194	result.put(RuleCheckingOutputType.SCORE, globalResults.get(getIdOrHeader()));	×
195	} else if (outputType.equals(RuleCheckingOutputType.BOTH)) {	×
196	result.put(RuleCheckingOutputType.STATUS, globalResults.get(getIdOrHeader() + ":status"));	×
197	result.put(RuleCheckingOutputType.SCORE, globalResults.get(getIdOrHeader() + ":score"));	×
198	}
199	return result;	×
200	}
201	}

pkiraly / metadata-qa-api / #747

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