Home | History | Annotate | Download | only in easymock 
      1 /*
      2  * Copyright 2001-2009 OFFIS, Tammo Freese
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *     http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 package org.easymock;
     17 
     18 import java.io.Serializable;
     19 
     20 import org.easymock.internal.ArgumentToString;
     21 
     22 /**
     23  * A convenience implementation of {@link ArgumentsMatcher}. A subclass that
     24  * does not redefine any method will behave like
     25  * {@link MockControl#EQUALS_MATCHER}.
     26  *
     27  * @deprecated Since EasyMock 2.0, <code>ArgumentsMatcher</code>s are only supported
     28  * for the legacy <code>MockControl</code>. For mock objects generated by the methods
     29  * on <code>EasyMock</code>, there are per-argument matchers available. For more
     30  * information, see the EasyMock documentation.
     31  */
     32 @Deprecated
     33 public abstract class AbstractMatcher implements ArgumentsMatcher, Serializable {
     34 
     35     private static final long serialVersionUID = -5463061331694985383L;
     36 
     37     /**
     38      * Checks whether an expected argument matches an actual argument; the method
     39      * is used by
     40      * {@link AbstractMatcher#matches(Object[], Object[])}. The arguments
     41      * provided to this method are always not <code>null</code>.
     42      *
     43      * @param expected
     44      *            the expected argument.
     45      * @param actual
     46      *            the actual argument.
     47      * @return true if the arguments match, false otherwise.
     48      */
     49     protected boolean argumentMatches(Object expected, Object actual) {
     50         return expected.equals(actual);
     51     }
     52 
     53     /**
     54      * Converts an argument to a String, used by
     55      * {@link AbstractMatcher#toString(Object[])}.
     56      *
     57      * @param argument
     58      *            the argument to convert to a String.
     59      * @return a <code>String</code> representation of the argument.
     60      */
     61     protected String argumentToString(Object argument) {
     62         StringBuffer result = new StringBuffer();
     63         ArgumentToString.appendArgument(argument, result);
     64         return result.toString();
     65     }
     66 
     67     /**
     68      * Checks whether an expected argument array matches an actual argument array.
     69      * This convenience implementation uses
     70      * <code>argumentMatches(Object, Object)</code> to check whether arguments
     71      * pairs match. If all the arguments match, true is returned, otherwise
     72      * false. In two cases, <code>argumentMatches(Object, Object)</code> is
     73      * not called: If both argument arrays are null, they match; if one and only
     74      * one is null, they do not match.
     75      *
     76      * @param expected
     77      *            the expected arguments.
     78      * @param actual
     79      *            the actual arguments.
     80      * @return true if the arguments match, false otherwise.
     81      */
     82     public boolean matches(Object[] expected, Object[] actual) {
     83         if (expected == actual) {
     84             return true;
     85         }
     86         if (expected == null || actual == null) {
     87             return false;
     88         }
     89         if (expected.length != actual.length) {
     90             return false;
     91         }
     92         for (int i = 0; i < expected.length; i++) {
     93             Object expectedObject = expected[i];
     94             Object actualObject = actual[i];
     95 
     96             if (expectedObject == null && actualObject == null) {
     97                 continue;
     98             }
     99 
    100             if (expectedObject == null && actualObject != null) {
    101                 return false;
    102             }
    103 
    104             if (expectedObject != null && actualObject == null) {
    105                 return false;
    106             }
    107 
    108             if (!argumentMatches(expectedObject, actualObject)) {
    109                 return false;
    110             }
    111         }
    112         return true;
    113     }
    114 
    115     /**
    116      * Returns a string representation of the matcher. This convenience
    117      * implementation calls {@link AbstractMatcher#argumentToString(Object)}
    118      * for every argument in the given array and returns the string representations
    119      * of the arguments separated by commas.
    120      *
    121      * @param arguments
    122      *            the arguments to be used in the string representation.
    123      * @return a string representation of the matcher.
    124      */
    125     public String toString(Object[] arguments) {
    126         if (arguments == null)
    127             arguments = new Object[0];
    128 
    129         StringBuilder result = new StringBuilder();
    130 
    131         for (int i = 0; i < arguments.length; i++) {
    132             if (i > 0) {
    133                 result.append(", ");
    134             }
    135             result.append(argumentToString(arguments[i]));
    136         }
    137         return result.toString();
    138     }
    139 }
    140