node = head;
while (node != null) {
if (node != head) {
sb.append(", ");
}
sb.append("+")
.append(node.delay)
.append(": ")
.append(node.value);
node = node.next;
}
sb.append("]");
return sb.toString();
}
}
jmock-library-2.12.0/jmock/src/main/java/org/jmock/lib/concurrent/internal/FixedTimeout.java 0000664 0000000 0000000 00000001376 13470025346 0032022 0 ustar 00root root 0000000 0000000 package org.jmock.lib.concurrent.internal;
import java.util.concurrent.TimeoutException;
/**
* A Timeout of fixed duration from the time the FixedTimeout object is
* instantiated.
*
* @author nat
*/
public class FixedTimeout implements Timeout {
private final long duration;
private final long start;
public FixedTimeout(long duration) {
this.duration = duration;
this.start = System.currentTimeMillis();
}
public long timeRemaining() throws TimeoutException {
long now = System.currentTimeMillis();
long timeLeft = duration - (now - start);
if (timeLeft <= 0) {
throw new TimeoutException("timed out after " + duration + " ms");
}
return timeLeft;
}
}
jmock-library-2.12.0/jmock/src/main/java/org/jmock/lib/concurrent/internal/InfiniteTimeout.java 0000664 0000000 0000000 00000000440 13470025346 0032517 0 ustar 00root root 0000000 0000000 package org.jmock.lib.concurrent.internal;
import java.util.concurrent.TimeoutException;
/**
* A Timeout that never times out.
*
* @author nat
*/
public class InfiniteTimeout implements Timeout {
public long timeRemaining() throws TimeoutException {
return 0L;
}
}
jmock-library-2.12.0/jmock/src/main/java/org/jmock/lib/concurrent/internal/Timeout.java 0000664 0000000 0000000 00000000532 13470025346 0031033 0 ustar 00root root 0000000 0000000 package org.jmock.lib.concurrent.internal;
import java.util.concurrent.TimeoutException;
public interface Timeout {
/**
* Returns the time remaining, to be passed to {@link Object#wait(long) wait}
* or throws TimeoutException if the timeout has expired.
*/
public abstract long timeRemaining() throws TimeoutException;
}
jmock-library-2.12.0/jmock/src/main/java/org/jmock/lib/concurrent/package.html 0000664 0000000 0000000 00000000126 13470025346 0027206 0 ustar 00root root 0000000 0000000
Classes to help test concurrent code with jMock.
jmock-library-2.12.0/jmock/src/main/java/org/jmock/lib/package.html 0000664 0000000 0000000 00000000213 13470025346 0025021 0 ustar 00root root 0000000 0000000
Implementations of the core interfaces that are used to adjust or extend jMock's basic
functionality.
jmock-library-2.12.0/jmock/src/main/java/org/jmock/lib/script/ 0000775 0000000 0000000 00000000000 13470025346 0024050 5 ustar 00root root 0000000 0000000 jmock-library-2.12.0/jmock/src/main/java/org/jmock/lib/script/ScriptedAction.java 0000664 0000000 0000000 00000006301 13470025346 0027626 0 ustar 00root root 0000000 0000000 package org.jmock.lib.script;
import org.hamcrest.Description;
import org.jmock.api.Action;
import org.jmock.api.Invocation;
import bsh.EvalError;
import bsh.Interpreter;
import bsh.TargetError;
/**
* An {@link Action} that executes a BeanShell script.
* This makes it easy to implement custom actions, especially those that call back to objects
* passed to the mocked method as parameters.
*
* To use a scripted action in an expectation, statically import the {@link #perform(String) perform}
* method and call it within the will(...) clause of the expectation.
*
* The script can refer to the parameters of the mocked method by the names $0 (the first parameter), $1, $2, etc,
* and to the mock object that has been invoked by the name $this.
* You can define other script variables by calling the action's {@link #where(String, Object) where} method.
*
* For example:
*
* allowing (sheep).accept(with(a(Visitor.class)));
* will(perform("$0.visitSheep($this)");
*
*
* is equivalent to:
*
*
* allowing (sheep).accept(with(a(Visitor.class)));
* will(perform("$0.visitSheep(s)").where("s", sheep);
*
*
*
* @author nat
*
*/
public class ScriptedAction implements Action {
private final Interpreter interpreter = new Interpreter();
private final String script;
public ScriptedAction(String expression) {
this.script = expression;
this.interpreter.setStrictJava(true);
}
public Object invoke(Invocation invocation) throws Throwable {
try {
defineParameters(interpreter, invocation);
return interpreter.eval(script);
}
catch (TargetError e) {
throw e.getTarget();
}
catch (EvalError e) {
throw new IllegalArgumentException("could not interpret script", e);
}
}
private void defineParameters(Interpreter interpreter, Invocation invocation)
throws EvalError
{
interpreter.set("$this", invocation.getInvokedObject());
for (int i = 0; i < invocation.getParameterCount(); i++) {
interpreter.set("$" + i, invocation.getParameter(i));
}
}
public void describeTo(Description description) {
description.appendText("perform ").appendText(script);
}
/**
* Creates an action that performs the given script.
*
* @param script
* a BeanShell script.
* @return
* the new action.
*/
public static ScriptedAction perform(String script) {
return new ScriptedAction(script);
}
/**
* Defines a variable that can be referred to by the script.
*
* @param name
* the name of the variable
* @param value
* the value of the variable
* @return
* the action, so that more variables can be defined if needed
*/
public ScriptedAction where(String name, Object value) {
try {
interpreter.set(name, value);
}
catch (EvalError e) {
throw new IllegalArgumentException("invalid name binding", e);
}
return this;
}
}
jmock-library-2.12.0/jmock/src/main/java/org/jmock/lib/script/package.html 0000664 0000000 0000000 00000000257 13470025346 0026335 0 ustar 00root root 0000000 0000000
Plugins that make it easier to write custom actions by scripting their
behaviour with BeanShell.
jmock-library-2.12.0/jmock/src/main/java/org/jmock/package.html 0000664 0000000 0000000 00000000130 13470025346 0024251 0 ustar 00root root 0000000 0000000
The jMock "Domain-Specific Embedded Language" API.
jmock-library-2.12.0/jmock/src/main/java/org/jmock/syntax/ 0000775 0000000 0000000 00000000000 13470025346 0023324 5 ustar 00root root 0000000 0000000 jmock-library-2.12.0/jmock/src/main/java/org/jmock/syntax/ActionClause.java 0000664 0000000 0000000 00000000212 13470025346 0026534 0 ustar 00root root 0000000 0000000 package org.jmock.syntax;
import org.jmock.api.Action;
public interface ActionClause {
public abstract void will(Action action);
}
jmock-library-2.12.0/jmock/src/main/java/org/jmock/syntax/ArgumentConstraintPhrases.java 0000664 0000000 0000000 00000000214 13470025346 0031341 0 ustar 00root root 0000000 0000000 package org.jmock.syntax;
import org.hamcrest.Matcher;
public interface ArgumentConstraintPhrases {
T with(Matcher matcher);
}
jmock-library-2.12.0/jmock/src/main/java/org/jmock/syntax/CardinalityClause.java 0000664 0000000 0000000 00000001063 13470025346 0027567 0 ustar 00root root 0000000 0000000 package org.jmock.syntax;
import org.hamcrest.Matcher;
public interface CardinalityClause {
ReceiverClause exactly(int count);
ReceiverClause atLeast(int count);
ReceiverClause between(int minCount, int maxCount);
ReceiverClause atMost(int count);
T oneOf(T mockObject);
T one(T mockObject);
T allowing(T mockObject);
MethodClause allowing(Matcher mockObjectMatcher);
T ignoring(T mockObject);
MethodClause ignoring(Matcher mockObjectMatcher);
T never(T mockObject);
}
jmock-library-2.12.0/jmock/src/main/java/org/jmock/syntax/MethodClause.java 0000664 0000000 0000000 00000000350 13470025346 0026542 0 ustar 00root root 0000000 0000000 package org.jmock.syntax;
import java.lang.reflect.Method;
import org.hamcrest.Matcher;
public interface MethodClause {
ParametersClause method(Matcher methodMatcher);
ParametersClause method(String nameRegex);
}
jmock-library-2.12.0/jmock/src/main/java/org/jmock/syntax/ParametersClause.java 0000664 0000000 0000000 00000000300 13470025346 0027420 0 ustar 00root root 0000000 0000000 package org.jmock.syntax;
import org.hamcrest.Matcher;
public interface ParametersClause extends MethodClause {
void with(Matcher... parameterMatchers);
void withNoArguments();
}
jmock-library-2.12.0/jmock/src/main/java/org/jmock/syntax/ReceiverClause.java 0000664 0000000 0000000 00000000255 13470025346 0027072 0 ustar 00root root 0000000 0000000 package org.jmock.syntax;
import org.hamcrest.Matcher;
public interface ReceiverClause {
T of(T mockObject);
MethodClause of(Matcher objectMatcher);
}
jmock-library-2.12.0/jmock/src/main/java/org/jmock/syntax/StatesClause.java 0000664 0000000 0000000 00000000317 13470025346 0026570 0 ustar 00root root 0000000 0000000 package org.jmock.syntax;
import org.jmock.internal.State;
import org.jmock.internal.StatePredicate;
public interface StatesClause {
State is(String name);
StatePredicate isNot(String name);
}
jmock-library-2.12.0/jmock/src/main/java/org/jmock/syntax/WithClause.java 0000664 0000000 0000000 00000000670 13470025346 0026242 0 ustar 00root root 0000000 0000000 package org.jmock.syntax;
import org.hamcrest.Matcher;
public interface WithClause {
boolean booleanIs(Matcher matcher);
byte byteIs(Matcher matcher);
char charIs(Matcher matcher);
short shortIs(Matcher matcher);
int intIs(Matcher matcher);
long longIs(Matcher matcher);
float floatIs(Matcher matcher);
double doubleIs(Matcher matcher);
T is(Matcher matcher);
}
jmock-library-2.12.0/jmock/src/main/java/org/jmock/syntax/package.html 0000664 0000000 0000000 00000000147 13470025346 0025607 0 ustar 00root root 0000000 0000000
Interfaces that define jMock's Domain Specific Embedded Language.
jmock-library-2.12.0/jmock/src/main/java/overview.html 0000664 0000000 0000000 00000002022 13470025346 0022634 0 ustar 00root root 0000000 0000000
jMock 2 - A Lightweight Mock Object Library for Java
jMock 2 is a library for testing Java code using mock objects.
Mock objects help you design and test the interactions between the
objects in your programs.
jMock 2:
- makes it quick and easy to define mock objects, so you don't
break the rhythm of programming.
- lets you define flexible constraints over object interactions,
reducing the brittleness of your tests.
- acts as a "domain-specific embedded language" for specifying
expectations so it is easy to read and understand the intent of
tests with mock objects.
- uses real method calls to specify expectations, so code can be
easily refactored in modern IDEs.
- is easy to extend.
More information can be found on
the jMock website (www.jmock.org).
jmock-library-2.12.0/jmock/src/test/ 0000775 0000000 0000000 00000000000 13470025346 0017216 5 ustar 00root root 0000000 0000000 jmock-library-2.12.0/jmock/src/test/java/ 0000775 0000000 0000000 00000000000 13470025346 0020137 5 ustar 00root root 0000000 0000000 jmock-library-2.12.0/jmock/src/test/java/org/ 0000775 0000000 0000000 00000000000 13470025346 0020726 5 ustar 00root root 0000000 0000000 jmock-library-2.12.0/jmock/src/test/java/org/jmock/ 0000775 0000000 0000000 00000000000 13470025346 0022031 5 ustar 00root root 0000000 0000000 jmock-library-2.12.0/jmock/src/test/java/org/jmock/test/ 0000775 0000000 0000000 00000000000 13470025346 0023010 5 ustar 00root root 0000000 0000000 jmock-library-2.12.0/jmock/src/test/java/org/jmock/test/acceptance/ 0000775 0000000 0000000 00000000000 13470025346 0025076 5 ustar 00root root 0000000 0000000 jmock-library-2.12.0/jmock/src/test/java/org/jmock/test/acceptance/AnyMethodAcceptanceTests.java 0000664 0000000 0000000 00000001736 13470025346 0032632 0 ustar 00root root 0000000 0000000 package org.jmock.test.acceptance;
import junit.framework.TestCase;
import org.jmock.Expectations;
import org.jmock.Mockery;
public class AnyMethodAcceptanceTests extends TestCase {
public interface AnotherType {
void anotherMethod();
}
Mockery context = new Mockery();
MockedType mock = context.mock(MockedType.class, "mock");
AnotherType anotherMock = context.mock(AnotherType.class, "anotherMock");
public void testElidingTheMethodMeansAnyMethodWithAnyArguments() {
context.checking(new Expectations() {{
allowing (mock);
}});
mock.method1();
mock.method2();
mock.method3();
mock.method4();
}
public void testCanElideMethodsOfMoreThanOneMockObject() {
context.checking(new Expectations() {{
ignoring (mock);
ignoring (anotherMock);
}});
mock.method1();
anotherMock.anotherMethod();
}
}
CascadedFailuresAcceptanceTests.java 0000664 0000000 0000000 00000005321 13470025346 0034037 0 ustar 00root root 0000000 0000000 jmock-library-2.12.0/jmock/src/test/java/org/jmock/test/acceptance package org.jmock.test.acceptance;
import junit.framework.TestCase;
import org.jmock.Expectations;
import org.jmock.Mockery;
import org.jmock.api.ExpectationError;
/* Acceptance test for issue JMOCK-30 (http://jira.codehaus.org/browse/JMOCK-30).
*/
public class CascadedFailuresAcceptanceTests extends TestCase {
public interface MockedType {
void realExpectationFailure(int i);
void invocationCausedByExpectationFailure();
void anotherRealExpectationFailure();
}
private Mockery context = new Mockery();
private MockedType mock = context.mock(MockedType.class, "mock");
private MockedType otherMock = context.mock(MockedType.class, "otherMock");
private void maskedExpectationFailure(MockedType mock1, MockedType mock2) {
try {
mock1.realExpectationFailure(2);
}
finally {
mock2.invocationCausedByExpectationFailure();
}
}
@Override
public void setUp() {
context.checking(new Expectations() {{
allowing (mock).realExpectationFailure(1);
}});
}
public void testMockeryReportsFirstFailedMethod() {
try {
maskedExpectationFailure(mock, mock);
fail("should have thrown ExpectationError");
}
catch (ExpectationError e) {
assertSame("invoked object",
mock, e.invocation.getInvokedObject());
assertEquals("invoked method",
"realExpectationFailure", e.invocation.getInvokedMethod().getName() );
}
}
public void testMockeryReportsFirstFailedObject() {
try {
maskedExpectationFailure(mock, otherMock);
fail("should have thrown ExpectationError");
}
catch (ExpectationError e) {
assertSame("invoked object",
mock, e.invocation.getInvokedObject());
assertEquals("invoked method",
"realExpectationFailure", e.invocation.getInvokedMethod().getName() );
}
}
// See issue JMOCK-183 (http://jira.codehaus.org/browse/JMOCK-183).
public void testVerifyReportsFirstFailure() {
try {
mock.realExpectationFailure(2);
}
catch (ExpectationError e) { /* swallowed */ }
try {
context.assertIsSatisfied();
fail("should have thrown ExpectationError");
}
catch (ExpectationError e) {
assertSame("invoked object",
mock, e.invocation.getInvokedObject());
assertEquals("invoked method",
"realExpectationFailure", e.invocation.getInvokedMethod().getName() );
}
}
}
ConsecutiveCallsAcceptanceTests.java 0000664 0000000 0000000 00000001600 13470025346 0034117 0 ustar 00root root 0000000 0000000 jmock-library-2.12.0/jmock/src/test/java/org/jmock/test/acceptance /* Copyright (c) 2000-2004 jMock.org
*/
package org.jmock.test.acceptance;
import junit.framework.TestCase;
import org.jmock.Expectations;
import org.jmock.Mockery;
public class ConsecutiveCallsAcceptanceTests extends TestCase {
Mockery context = new Mockery();
MockedType mock = context.mock(MockedType.class, "mock");
public void testCanEasilySpecifySequenceOfStubsForSameMethod() {
context.checking(new Expectations() {{
atLeast(1).of (mock).returnString();
will(onConsecutiveCalls(returnValue("hello"),
returnValue("bonjour"),
returnValue("guten Tag")));
}});
assertEquals("hello", mock.returnString());
assertEquals("bonjour", mock.returnString());
assertEquals("guten Tag", mock.returnString());
}
}
DefineExpectationWithinExpectationsAcceptanceTests.java 0000664 0000000 0000000 00000002331 13470025346 0040023 0 ustar 00root root 0000000 0000000 jmock-library-2.12.0/jmock/src/test/java/org/jmock/test/acceptance package org.jmock.test.acceptance;
import junit.framework.TestCase;
import org.jmock.Expectations;
import org.jmock.Mockery;
// See issue JMOCK-184
public class DefineExpectationWithinExpectationsAcceptanceTests extends TestCase {
public interface MockedTypeA {
void a(MockedTypeB b);
}
public interface MockedTypeB {
void b();
}
Mockery context = new Mockery();
MockedTypeA a = context.mock(MockedTypeA.class, "a");
public void testCanDefineExpectationsWithinExpectations() {
context.checking(new Expectations() {{
oneOf (a).a(aNewMockWithExpectations());
}});
}
private MockedTypeB aNewMockWithExpectations() {
final MockedTypeB mock = context.mock(MockedTypeB.class);
context.checking(new Expectations() {{
ignoring (mock);
}});
return mock;
}
public void testCanStillIgnoreEntireMockObjectsBeforeAnotherExpectation() {
final MockedTypeA a2 = context.mock(MockedTypeA.class, "a2");
context.checking(new Expectations() {{
ignoring(a2);
oneOf (a).a(aNewMockWithExpectations());
}});
}
}
jmock-library-2.12.0/jmock/src/test/java/org/jmock/test/acceptance/DoAllAcceptanceTests.java 0000664 0000000 0000000 00000003656 13470025346 0031740 0 ustar 00root root 0000000 0000000 package org.jmock.test.acceptance;
import java.util.ArrayList;
import java.util.Collection;
import junit.framework.TestCase;
import org.hamcrest.Description;
import org.jmock.Expectations;
import org.jmock.Mockery;
import org.jmock.api.Action;
import org.jmock.api.Invocation;
public class DoAllAcceptanceTests extends TestCase {
public interface Collector {
void addThingsTo(Collection collection);
}
Mockery context = new Mockery();
Collector collector = context.mock(Collector.class);
public void testCanSpecifyMultipleStubsForOneInvocation() {
final ArrayList list = new ArrayList();
context.checking(new Expectations() {{
exactly(1).of (collector).addThingsTo(with(same(list)));
will(doAll(addElement("1"),
addElement("2"),
addElement("3"),
addElement("4")));
}});
collector.addThingsTo(list);
assertEquals("list length", 4, list.size());
for (int i = 0; i < list.size(); i++) {
assertEquals("element "+(i+1), Integer.toString(i+1), list.get(i));
}
}
private Action addElement(String newElement) {
return new AddElementAction(newElement);
}
public static class AddElementAction implements Action {
private final String newElement;
public AddElementAction(String newElement) {
this.newElement = newElement;
}
@SuppressWarnings("unchecked")
public Object invoke(Invocation invocation) throws Throwable {
((Collection