#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

58.42

/src/main/java/de/gwdg/metadataqa/api/rule/logical/AndChecker.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 java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.logging.Logger;

public class AndChecker extends LogicalChecker {

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

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

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

  public AndChecker(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(String.format("%s %s,  alwaysCheckDependencies: %s, priorityOnFail: %s", this.getClass().getSimpleName(), this.id, alwaysCheckDependencies, priorityOnFail));

    var allPassed = true;
    var isNA = false;
    List<RuleCheckingOutputStatus> statuses = new ArrayList<>();
    boolean parentCheckPassed = true;
    boolean hasParentCheck = false;
    RuleCheckerOutput output = null;
    Boolean isParentNA = null;

    List<XmlFieldInstance> instances = selector.get(field);
    if (instances != null && !instances.isEmpty()) {
      FieldCounter<RuleCheckerOutput> localResults = new FieldCounter<>();
      for (RuleChecker checker : checkers) {
        if (checker instanceof DependencyChecker) {
          ((DependencyChecker) checker).update(selector, localResults, outputType, results);
        } else if (checker instanceof OrChecker) {
          ((OrChecker) checker).update(selector, localResults, outputType, results);
        } else if (checker instanceof NotChecker) {
          ((NotChecker) checker).update(selector, localResults, outputType, results);
        } else {
          checker.update(selector, localResults, outputType);
        }
        String key = outputType.equals(RuleCheckingOutputType.BOTH)
          ? checker.getIdOrHeader(RuleCheckingOutputType.SCORE)
          : checker.getIdOrHeader();
        RuleCheckingOutputStatus status = localResults.get(key).getStatus();
        statuses.add(status);
        if (status.equals(RuleCheckingOutputStatus.NA))
          isNA = true;

        if (!status.equals(RuleCheckingOutputStatus.PASSED) && !priorityOnFail) {
          allPassed = false;
          break;
        }
      }
    } else {
      if (isDebug())
        LOGGER.info("empty branch");
      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) {
          if (checker instanceof DependencyChecker) {
            DependencyChecker dependencyChecker = (DependencyChecker) checker;
            Map<String, Boolean> localResult = dependencyChecker.getResult(outputType, results);
            if (isDebug())
              LOGGER.info(String.format("DependencyChecker result for %s: %s",
                dependencyChecker.getDependencies(), localResult));
            allPassed = localResult.get("allPassed");
            if (!dependencyChecker.getParentCheck())
              isNA = localResult.get("isNA");
            statuses.add(allPassed ? RuleCheckingOutputStatus.PASSED : RuleCheckingOutputStatus.FAILED);
            if (dependencyChecker.getParentCheck()) {
              hasParentCheck = true;
              if (!allPassed) {
                if (parentCheckPassed)
                  parentCheckPassed = false;
              }
              isParentNA = localResult.get("isNA");
            }
          } else if (checker instanceof OrChecker) {
            OrChecker orChecker = (OrChecker) checker;
            boolean hasDependency = false;
            for (RuleChecker current : orChecker.getCheckers()) {
              if (current instanceof DependencyChecker) {
                hasDependency = true;
                break;
              }
            }
            if (hasDependency) {
              orChecker.update(selector, results, outputType);
              Map<RuleCheckingOutputType, Object> orResult = orChecker.getResult(outputType, results);
              RuleCheckerOutput orStatus = (RuleCheckerOutput) orResult.get(RuleCheckingOutputType.STATUS);
              if (orStatus.getStatus().equals(RuleCheckingOutputStatus.FAILED)) {
                allPassed = false;
                isNA = false;
              }
            }
          }
        }

        // if (!allPassed)
        //  break;
      }
    }

    if (isDebug())
      LOGGER.info("hasParentCheck: " + hasParentCheck + ", parentCheckPassed: " + parentCheckPassed
      + ", isParentNA: " + isParentNA);

    if (priorityOnFail) {
      allPassed = !statuses.contains(RuleCheckingOutputStatus.FAILED);
      if (!allPassed || statuses.contains(RuleCheckingOutputStatus.PASSED))
        isNA = false;
    } else {
      if (isNA && hasParentCheck)
        output = isParentNA
               ? new RuleCheckerOutput(this, RuleCheckingOutputStatus.NA)
               : new RuleCheckerOutput(this, RuleCheckingOutputStatus.FAILED);
      /*
      if (isNA && hasParentCheck) {
        allPassed = !parentCheckPassed;
      }
      */
    }

    if (isDebug())
      LOGGER.info(String.format("isNA: %s, allPassed: %s", isNA, allPassed));
    addOutput(results, isNA, allPassed, outputType);

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

    if (isDebug())
      LOGGER.info(this.getClass().getSimpleName() + " " + this.id + ") result: " + RuleCheckingOutputStatus.create(isNA, allPassed, isMandatory()));
  }
}

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
14	import java.util.ArrayList;
15	import java.util.List;
16	import java.util.Map;
17	import java.util.logging.Logger;
18
19	public class AndChecker extends LogicalChecker {
20
21	private static final Logger LOGGER = Logger.getLogger(AndChecker.class.getCanonicalName());	1✔
22
23	private static final long serialVersionUID = 1114999259831619599L;
24	public static final String PREFIX = "and";
25
26	/**
27	* @param field The field
28	* @param checkers The list of checkers
29	*/
30	public AndChecker(DataElement field, List<RuleChecker> checkers) {
31	this(field, field.getLabel(), checkers);	1✔
32	}	1✔
33
34	public AndChecker(DataElement field, String header, List<RuleChecker> checkers) {
35	super(field,header + ":" + PREFIX + ":" + getChildrenHeader(checkers));	1✔
36	this.checkers = checkers;	1✔
37	}	1✔
38
39	@Override
40	public void update(Selector selector, FieldCounter<RuleCheckerOutput> results, RuleCheckingOutputType outputType) {
41	update(selector, results, outputType, null);	1✔
42	}	1✔
43
44
45	public void update(Selector selector,
46	FieldCounter<RuleCheckerOutput> results,
47	RuleCheckingOutputType outputType,
48	FieldCounter<RuleCheckerOutput> globalResults) {
49	if (isDebug())	1✔
50	LOGGER.info(String.format("%s %s, alwaysCheckDependencies: %s, priorityOnFail: %s", this.getClass().getSimpleName(), this.id, alwaysCheckDependencies, priorityOnFail));	1✔
51
52	var allPassed = true;	1✔
53	var isNA = false;	1✔
54	List<RuleCheckingOutputStatus> statuses = new ArrayList<>();	1✔
55	boolean parentCheckPassed = true;	1✔
56	boolean hasParentCheck = false;	1✔
57	RuleCheckerOutput output = null;	1✔
58	Boolean isParentNA = null;	1✔
59
60	List<XmlFieldInstance> instances = selector.get(field);	1✔
61	if (instances != null && !instances.isEmpty()) {	1✔
62	FieldCounter<RuleCheckerOutput> localResults = new FieldCounter<>();	1✔
63	for (RuleChecker checker : checkers) {	1✔
64	if (checker instanceof DependencyChecker) {	1✔
65	((DependencyChecker) checker).update(selector, localResults, outputType, results);	1✔
66	} else if (checker instanceof OrChecker) {	1✔
67	((OrChecker) checker).update(selector, localResults, outputType, results);	×
68	} else if (checker instanceof NotChecker) {	1✔
69	((NotChecker) checker).update(selector, localResults, outputType, results);	×
70	} else {
71	checker.update(selector, localResults, outputType);	1✔
72	}
73	String key = outputType.equals(RuleCheckingOutputType.BOTH)	1✔
74	? checker.getIdOrHeader(RuleCheckingOutputType.SCORE)	1✔
75	: checker.getIdOrHeader();	1✔
76	RuleCheckingOutputStatus status = localResults.get(key).getStatus();	1✔
77	statuses.add(status);	1✔
78	if (status.equals(RuleCheckingOutputStatus.NA))	1✔
79	isNA = true;	×
80
81	if (!status.equals(RuleCheckingOutputStatus.PASSED) && !priorityOnFail) {	1✔
82	allPassed = false;	1✔
83	break;	1✔
84	}
85	}	1✔
86	} else {	1✔
87	if (isDebug())	1✔
88	LOGGER.info("empty branch");	×
89	isNA = true;	1✔
90	for (RuleChecker checker : checkers) {	1✔
91	if (checker instanceof MinCountChecker) {	1✔
92	MinCountChecker minCountChecker = (MinCountChecker) checker;	1✔
93	if (!minCountChecker.isEmptyInstancesAllowed() \|\| minCountChecker.getMinCount() > 0)	1✔
94	allPassed = false;	1✔
95	}	1✔
96	else if (alwaysCheckDependencies) {	1✔
97	if (checker instanceof DependencyChecker) {	×
98	DependencyChecker dependencyChecker = (DependencyChecker) checker;	×
99	Map<String, Boolean> localResult = dependencyChecker.getResult(outputType, results);	×
100	if (isDebug())	×
101	LOGGER.info(String.format("DependencyChecker result for %s: %s",	×
102	dependencyChecker.getDependencies(), localResult));	×
103	allPassed = localResult.get("allPassed");	×
104	if (!dependencyChecker.getParentCheck())	×
105	isNA = localResult.get("isNA");	×
106	statuses.add(allPassed ? RuleCheckingOutputStatus.PASSED : RuleCheckingOutputStatus.FAILED);	×
107	if (dependencyChecker.getParentCheck()) {	×
108	hasParentCheck = true;	×
109	if (!allPassed) {	×
110	if (parentCheckPassed)	×
111	parentCheckPassed = false;	×
112	}
113	isParentNA = localResult.get("isNA");	×
114	}
115	} else if (checker instanceof OrChecker) {	×
116	OrChecker orChecker = (OrChecker) checker;	×
117	boolean hasDependency = false;	×
118	for (RuleChecker current : orChecker.getCheckers()) {	×
119	if (current instanceof DependencyChecker) {	×
120	hasDependency = true;	×
121	break;	×
122	}
123	}	×
124	if (hasDependency) {	×
125	orChecker.update(selector, results, outputType);	×
126	Map<RuleCheckingOutputType, Object> orResult = orChecker.getResult(outputType, results);	×
127	RuleCheckerOutput orStatus = (RuleCheckerOutput) orResult.get(RuleCheckingOutputType.STATUS);	×
128	if (orStatus.getStatus().equals(RuleCheckingOutputStatus.FAILED)) {	×
129	allPassed = false;	×
130	isNA = false;	×
131	}
132	}
133	}
134	}
135
136	// if (!allPassed)
137	// break;
138	}	1✔
139	}
140
141	if (isDebug())	1✔
142	LOGGER.info("hasParentCheck: " + hasParentCheck + ", parentCheckPassed: " + parentCheckPassed	1✔
143	+ ", isParentNA: " + isParentNA);
144
145	if (priorityOnFail) {	1✔
146	allPassed = !statuses.contains(RuleCheckingOutputStatus.FAILED);	×
147	if (!allPassed \|\| statuses.contains(RuleCheckingOutputStatus.PASSED))	×
148	isNA = false;	×
149	} else {
150	if (isNA && hasParentCheck)	1✔
151	output = isParentNA	×
152	? new RuleCheckerOutput(this, RuleCheckingOutputStatus.NA)	×
153	: new RuleCheckerOutput(this, RuleCheckingOutputStatus.FAILED);	×
154	/*
155	if (isNA && hasParentCheck) {
156	allPassed = !parentCheckPassed;
157	}
158	*/
159	}
160
161	if (isDebug())	1✔
162	LOGGER.info(String.format("isNA: %s, allPassed: %s", isNA, allPassed));	1✔
163	addOutput(results, isNA, allPassed, outputType);	1✔
164
165	if (output != null) {	1✔
166	addOutput(results, output, outputType);	×
167	} else {
168	addOutput(results, isNA, allPassed, outputType);	1✔
169	}
170
171	if (isDebug())	1✔
172	LOGGER.info(this.getClass().getSimpleName() + " " + this.id + ") result: " + RuleCheckingOutputStatus.create(isNA, allPassed, isMandatory()));	1✔
173	}	1✔
174	}

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