ExceptionResolvers.java

1 
package pro.verron.officestamper.preset;
2
3 
import org.slf4j.Logger;
4 
import org.slf4j.LoggerFactory;
5 
import pro.verron.officestamper.api.ExceptionResolver;
6 
import pro.verron.officestamper.api.Insert;
7 
import pro.verron.officestamper.api.OfficeStamperException;
8
9 
import static pro.verron.officestamper.utils.wml.WmlFactory.newRun;
10
11
12 
/// The ExceptionResolvers class provides a set of static factory methods to create different types of ExceptionResolver
13 
/// implementations. These resolvers are designed to handle exceptions that occur during the processing of placeholders
14 
/// in text documents. This class is a utility class and cannot be instantiated.
15 
public class ExceptionResolvers {
16
17 
    private static final Logger logger = LoggerFactory.getLogger(ExceptionResolvers.class);
18
19 
    static {
20 
        if (!logger.isTraceEnabled())
21 
            logger.info("Set TRACE log level, to add stacktrace info to resolution exceptions");
22 
    }
23
24 
    private ExceptionResolvers() {
25 
        throw new OfficeStamperException("Utility class");
26 
    }
27
28 
    /// The passing resolver will handle exceptions by returning the placeholder expression. It logs the exception
29 
    /// message and the stack trace if tracing is enabled.
30 
    ///
31 
    /// @return An instance of [ExceptionResolver] that returns the placeholder expression.
32 
    public static ExceptionResolver passing() {
33 
        return new PassingResolver(logger.isTraceEnabled(), "${%s}");
34 
    }
35
36 
    /// The defaulting resolver class will handle exceptions by returning an empty string. It logs the exception message
37 
    /// and the stack trace if tracing is enabled.
38 
    ///
39 
    /// @return An instance of [ExceptionResolver] that returns an empty string.
40 
    public static ExceptionResolver defaulting() {
41 
        return new DefaultingResolver("", logger.isTraceEnabled());
42 
    }
43
44 
    /// The defaulting resolver class will handle exceptions by returning a default value. It logs the exception message
45 
    /// and the stack trace if tracing is enabled.
46 
    ///
47 
    /// @param value The default value to be returned if an exception occurs.
48 
    /// @return An instance of [ExceptionResolver] that returns a default value.
49 
    public static ExceptionResolver defaulting(String value) {
50 
        return new DefaultingResolver(value, logger.isTraceEnabled());
51 
    }
52
53 
    /// The throwing resolver will handle exceptions by immediately throwing an OfficeStamperException. It is used to
54 
    /// propagate errors encountered during the processing of placeholders in text documents.
55 
    ///
56 
    /// @return An instance of [ExceptionResolver] that throws an exception.
57 
    public static ExceptionResolver throwing() {
58 
        return new ThrowingResolver(logger.isTraceEnabled());
59 
    }
60
61 
    private record DefaultingResolver(String value, boolean tracing)
62 
            implements ExceptionResolver {
63
64 
        private static final Logger logger = LoggerFactory.getLogger(DefaultingResolver.class);
65
66 
        @Override
67 
        public Insert resolve(String expression, String message, Exception cause) {
68 
            if (tracing) logger.warn(message, cause);
69 
            else logger.warn(message);
70 1 1. resolve : replaced return value with null for pro/verron/officestamper/preset/ExceptionResolvers$DefaultingResolver::resolve → KILLED
 
            return new Insert(newRun(value));
71 
        }
72 
    }
73
74 
    private record PassingResolver(boolean tracing, String template)
75 
            implements ExceptionResolver {
76
77 
        @Override
78 
        public Insert resolve(String expression, String message, Exception cause) {
79 
            if (tracing) logger.warn(message, cause);
80 
            else logger.warn(message);
81 1 1. resolve : replaced return value with null for pro/verron/officestamper/preset/ExceptionResolvers$PassingResolver::resolve → KILLED
 
            return new Insert(newRun(template.formatted(expression)));
82 
        }
83 
    }
84
85 
    private record ThrowingResolver(boolean tracing)
86 
            implements ExceptionResolver {
87
88 
        @Override
89 
        public Insert resolve(String expression, String message, Exception cause) {
90 1 1. resolve : negated conditional → SURVIVED
 
            if (tracing) throw new OfficeStamperException(message, cause);
91 
            else throw new OfficeStamperException(message);
92 
        }
93 
    }
94 
}

Mutations

70

1.1
Location : resolve
Killed by : pro.verron.officestamper.test.DefaultTests.[engine:junit-jupiter]/[class:pro.verron.officestamper.test.DefaultTests]/[test-template:features(pro.verron.officestamper.api.OfficeStamperConfiguration, java.lang.Object, org.docx4j.openpackaging.packages.WordprocessingMLPackage, java.lang.String)]/[test-template-invocation:#11] replaced return value with null for pro/verron/officestamper/preset/ExceptionResolvers$DefaultingResolver::resolve → KILLED

81

1.1
Location : resolve
Killed by : pro.verron.officestamper.test.DefaultTests.[engine:junit-jupiter]/[class:pro.verron.officestamper.test.DefaultTests]/[test-template:features(pro.verron.officestamper.api.OfficeStamperConfiguration, java.lang.Object, org.docx4j.openpackaging.packages.WordprocessingMLPackage, java.lang.String)]/[test-template-invocation:#20] replaced return value with null for pro/verron/officestamper/preset/ExceptionResolvers$PassingResolver::resolve → KILLED

90

1.1
Location : resolve
Killed by : none negated conditional → SURVIVED Covering tests

Active mutators

Tests examined


Report generated by PIT 1.25.5 support