Source code
package org.junit.internal;
import org.hamcrest.Description;
import org.hamcrest.Matcher;
import org.hamcrest.SelfDescribing;
import org.hamcrest.StringDescription;
/**
* An exception class used to implement <i>assumptions</i> (state in which a given test
* is meaningful and should or should not be executed). A test for which an assumption
* fails should not generate a test case failure.
*
* @see org.junit.Assume
*
* @deprecated Please use {@link org.junit.AssumptionViolatedException} instead.
*/
@Deprecated
public class AssumptionViolatedException extends RuntimeException implements SelfDescribing {
private static final long serialVersionUID = 2L;
private final String fAssumption;
private final boolean fValueMatcher;
private final Object fValue;
private final Matcher<?> fMatcher;
public AssumptionViolatedException(String assumption, boolean valueMatcher, Object value, Matcher<?> matcher) {
super(value instanceof Throwable ? (Throwable) value : null);
fAssumption = assumption;
fValue = value;
fMatcher = matcher;
fValueMatcher = valueMatcher;
}
/**
* An assumption exception with the given <i>value</i> (String or
* Throwable) and an additional failing {@link Matcher}.
*/
public AssumptionViolatedException(Object value, Matcher<?> matcher) {
this(null, true, value, matcher);
}
/**
* An assumption exception with the given <i>value</i> (String or
* Throwable) and an additional failing {@link Matcher}.
*/
public AssumptionViolatedException(String assumption, Object value, Matcher<?> matcher) {
this(assumption, true, value, matcher);
}
/**
* An assumption exception with the given message only.
*/
public AssumptionViolatedException(String assumption) {
this(assumption, false, null, null);
}
/**
* An assumption exception with the given message and a cause.
*/
public AssumptionViolatedException(String assumption, Throwable e) {
this(assumption, false, e, null);
}
@Override
public String getMessage() {
return StringDescription.asString(this);
}
public void describeTo(Description description) {
if (fAssumption != null) {
description.appendText(fAssumption);
}
if (fValueMatcher) {
if (fAssumption != null) {
description.appendText(": ");
}
description.appendText("got: ");
description.appendValue(fValue);
if (fMatcher != null) {
description.appendText(", expected: ");
description.appendDescriptionOf(fMatcher);
}
}
}
}
Run 1
The code demonstrates strong readability with clear logical organization and consistent naming conventions (Hungarian notation for fields). The class structure is well-defined with a clear responsibility: encapsulating assumption violations. Nesting is minimal — the deepest level is just two levels in describeTo. Intent is explicit through meaningful field names, well-documented constructors, and the Javadoc. Code length is appropriate with no unnecessary methods or duplicated logic. Action granularity is good; each line performs one operation, particularly in describeTo. Reading flow is natural: fields are declared logically, constructors chain sensibly from specific to general, and describeTo follows a coherent conditional progression. Minor deductions: deprecated class might warrant cleanup, the Hungarian notation is slightly dated by modern Java standards, and the serialVersionUID hardcoded to 2L could confuse. Otherwise, the code is quite readable and maintainable.
Run 2
The code is well-structured and readable. It has a clear purpose: representing assumption violations in testing, with minimal nesting and a natural reading flow. Each action is logically separated into its own line. Constructors are concise and properly chain to a central constructor, reducing duplication. Field naming with the 'f' prefix is slightly dated but consistent. The describeTo method is flat and easy to follow. Minor deductions: the ternary in the super() call adds slight cognitive load, and the boolean fValueMatcher could be clearer as something like 'hasValueAndMatcher' to improve intent.
Run 3
The code is well-structured with clear separation of fields, constructors, and methods. It uses minimal nesting (only one level of conditionals in describeTo) and maintains good action granularity with one logical action per line. Intent is clearly documented via Javadoc comments explaining each constructor's purpose. The class is concise for its functionality, avoiding unnecessary verbosity while maintaining readability. Reading flow is natural - fields are defined first, followed by constructors in logical progression, then methods. The deprecation documentation is clear. Minor deductions: the constructor with 4 parameters could benefit from a parameter object if extended further, and the conditional checking of fAssumption twice in describeTo could be slightly restructured. Overall, very readable code that follows established Java conventions well.
Run 1
Code Structure: Fields, constructors, and description methods are logically organized, with constructor delegation centralizing initialization. Nesting: Shallow conditional nesting in describeTo is easy to follow. Clarity of intent: Documentation and descriptive method names explain the exception's purpose, though Hungarian-style field prefixes and the fValueMatcher boolean slightly obscure meaning. Code length: Concise overall; repeated constructor documentation adds minor redundancy. Action granularity: Each statement performs one clear action, with no densely packed operations. Reading flow: Consistent formatting and sequential description assembly make reading natural; positional boolean and null constructor arguments require some cross-referencing.
Run 2
Code Structure: Fields, constructors, and methods are logically grouped; constructor delegation avoids duplicated initialization. Nesting: Conditional nesting is shallow, reaching only two levels in describeTo. Clarity of intent: Class documentation and descriptive method names explain the purpose well, though f-prefixed fields and the valueMatcher boolean require some interpretation. Code length: The implementation is concise; repeated constructor documentation adds minor verbosity. Action granularity: Statements generally perform one action per line, making initialization and message construction easy to follow. Reading flow: Consistent formatting and sequential description assembly provide a natural flow. Delegated boolean/null arguments and the conditional Throwable cast slightly increase the effort needed to understand constructor behavior.
Run 3
Code Structure: Fields, delegating constructors, and description methods are logically organized with little duplication. Nesting: Control flow is shallow, with only two levels of conditional nesting in describeTo. Clarity of intent: Class documentation and constructor comments explain the purpose well, though the f-prefixed fields and valueMatcher boolean are less immediately intuitive. Code length: The implementation is concise; constructor overloads add length but provide useful interfaces. Action granularity: Each statement performs a single clear action, and description construction is broken into readable steps. Reading flow: Execution progresses naturally from initialization to message formatting, with whitespace separating logical sections. Minor drawbacks include repeated constructor documentation, boolean arguments whose meaning requires checking the primary constructor, and the implicit extraction of a Throwable cause from value.