Clover Coverage Report - EasyMock 2.4
Coverage timestamp: mer. juil. 2 2008 02:17:38 CEST
Overview   Package   File
    FRAMES   NO FRAMES     
56   168   38   3,5
24   131   0,68   16
16     2,38  
1    
 
 
  Invocation       Line # 15 56 38 100% 1.0
 
  (265)
 
1    /*
2    * Copyright (c) 2001-2008 OFFIS, Tammo Freese.
3    * This program is made available under the terms of the MIT License.
4    */
5    package org.easymock.internal;
6   
7    import static java.lang.Character.*;
8   
9    import java.io.IOException;
10    import java.io.Serializable;
11    import java.lang.reflect.Method;
12   
13    import org.easymock.internal.matchers.ArrayEquals;
14   
 
15    public class Invocation implements Serializable {
16   
17    private static final long serialVersionUID = -2836226970244118495L;
18   
19    private final Object mock;
20   
21    private transient Method method;
22   
23    private final Object[] arguments;
24   
 
25  1135 toggle public Invocation(Object mock, Method method, Object[] args) {
26  1135 this.mock = mock;
27  1135 this.method = method;
28  1135 this.arguments = expandVarArgs(method.isVarArgs(), args);
29    }
30   
 
31  1135 toggle private static Object[] expandVarArgs(final boolean isVarArgs,
32    final Object[] args) {
33  1135 if (!isVarArgs || isVarArgs && args[args.length - 1] != null
34    && !args[args.length - 1].getClass().isArray()) {
35  1093 return args == null ? new Object[0] : args;
36    }
37  42 Object[] varArgs = ArrayEquals.createObjectArray(args[args.length - 1]);
38  42 final int nonVarArgsCount = args.length - 1;
39  42 final int varArgsCount = varArgs.length;
40  42 Object[] newArgs = new Object[nonVarArgsCount + varArgsCount];
41  42 System.arraycopy(args, 0, newArgs, 0, nonVarArgsCount);
42  42 System.arraycopy(varArgs, 0, newArgs, nonVarArgsCount, varArgsCount);
43  42 return newArgs;
44    }
45   
 
46  3210 toggle public Object getMock() {
47  3210 return mock;
48    }
49   
 
50  4979 toggle public Method getMethod() {
51  4979 return method;
52    }
53   
 
54  1949 toggle public Object[] getArguments() {
55  1949 return arguments;
56    }
57   
 
58  686 toggle public boolean equals(Object o) {
59  686 if (o == null || !o.getClass().equals(this.getClass()))
60  2 return false;
61   
62  684 Invocation other = (Invocation) o;
63   
64  684 return this.mock.equals(other.mock) && this.method.equals(other.method)
65    && this.equalArguments(other.arguments);
66    }
67   
 
68  2 toggle public int hashCode() {
69  2 throw new UnsupportedOperationException("hashCode() is not implemented");
70    }
71   
 
72  141 toggle private boolean equalArguments(Object[] arguments) {
73  141 if (this.arguments.length != arguments.length) {
74  11 return false;
75    }
76  185 for (int i = 0; i < this.arguments.length; i++) {
77  134 Object myArgument = this.arguments[i];
78  134 Object otherArgument = arguments[i];
79   
80  134 if (isPrimitiveParameter(i)) {
81  62 if (!myArgument.equals(otherArgument)) {
82  27 return false;
83    }
84    } else {
85  72 if (myArgument != otherArgument) {
86  52 return false;
87    }
88    }
89    }
90  51 return true;
91    }
92   
 
93  134 toggle private boolean isPrimitiveParameter(int parameterPosition) {
94  134 Class<?>[] parameterTypes = method.getParameterTypes();
95  134 if (method.isVarArgs()) {
96  6 parameterPosition = Math.min(parameterPosition,
97    parameterTypes.length - 1);
98    }
99  134 return parameterTypes[parameterPosition].isPrimitive();
100    }
101   
 
102  107 toggle @SuppressWarnings("deprecation")
103    public boolean matches(Invocation actual, org.easymock.ArgumentsMatcher matcher) {
104  107 return this.mock.equals(actual.mock)
105    && this.method.equals(actual.method)
106    && matcher.matches(this.arguments, actual.arguments);
107    }
108   
 
109  62 toggle @SuppressWarnings("deprecation")
110    public String toString(org.easymock.ArgumentsMatcher matcher) {
111  62 return getMockAndMethodName() + "(" + matcher.toString(arguments) + ")";
112    }
113   
 
114  296 toggle public String getMockAndMethodName() {
115  296 String mockName = mock.toString();
116  296 String methodName = method.getName();
117  296 if (toStringIsDefined(mock) && isJavaIdentifier(mockName)) {
118  5 return mockName + "." + methodName;
119    } else {
120  291 return methodName;
121    }
122    }
123   
 
124  296 toggle private boolean toStringIsDefined(Object o) {
125  296 try {
126  296 o.getClass().getDeclaredMethod("toString", (Class[]) null)
127    .getModifiers();
128  296 return true;
129    } catch (SecurityException ignored) {
130    // ///CLOVER:OFF
131    return false;
132    // ///CLOVER:ON
133    } catch (NoSuchMethodException shouldNeverHappen) {
134    // ///CLOVER:OFF
135    throw new RuntimeException("The toString() method could not be found!");
136    // ///CLOVER:ON
137    }
138    }
139   
 
140  301 toggle public static boolean isJavaIdentifier(String mockName) {
141  301 if (mockName.length() == 0 || mockName.indexOf(' ') > -1
142    || !Character.isJavaIdentifierStart(mockName.charAt(0))) {
143  290 return false;
144    }
145  11 for (char c : mockName.substring(1).toCharArray()) {
146  46 if (!isJavaIdentifierPart(c)) {
147  2 return false;
148    }
149    }
150  9 return true;
151    }
152   
 
153  3 toggle private void readObject(java.io.ObjectInputStream stream) throws IOException, ClassNotFoundException {
154  3 stream.defaultReadObject();
155  3 try {
156  3 method = ((MethodSerializationWrapper) stream.readObject()).getMethod();
157    } catch (NoSuchMethodException e) {
158    // ///CLOVER:OFF
159    throw new IOException(e.toString());
160    // ///CLOVER:ON
161    }
162    }
163   
 
164  3 toggle private void writeObject(java.io.ObjectOutputStream stream) throws IOException {
165  3 stream.defaultWriteObject();
166  3 stream.writeObject(new MethodSerializationWrapper(method));
167    }
168    }
 
CloverReport generated by Clover Code Coverage v2.1.0
mer. juil. 2 2008 02:17:39 CEST.		   Clover: Open Source License registered to EasyMock .