/** * Prepares the global out parameter <code>Map</code>. * @param outParameters the global out parameter <code>Map</code> */ public void prepareGlobalOutParameter(MockParameterMap outParameters) { globalOutParameter = new MockParameterMap(outParameters); }
public MockParameterMap getIndexedParameterMap() { MockParameterMap indexedParameters = new MockParameterMap(); for(ParameterReference parameterReference : paramObjects.keySet()){ if(parameterReference instanceof ParameterIndex){ indexedParameters.put(parameterReference, paramObjects.get(parameterReference)); } } return new MockUnmodifiableParameterMap(indexedParameters); }
public void clearParameters() throws SQLException { paramObjects.clear(); }
private MockParameterMap createParameterMap(List<Object> parameters) { MockParameterMap params = new MockParameterMap(); for(int ii = 0; ii < parameters.size(); ii++) { params.put(ii + 1, parameters.get(ii)); } return params; } }
public boolean doParameterMatch(MockParameterMap actualParameters, boolean exactMatchParameter) { if(exactMatchParameter) { if(actualParameters.size() != this.size()) return false; for(ParameterReference currentKey : actualParameters.keySet()){ Object expectedObject = this.get(currentKey); if(!ParameterUtil.compareParameter(actualParameters.get(currentKey), expectedObject)) { return false; } } return true; } else { for(ParameterReference currentKey : this.keySet()){ Object actualObject = actualParameters.get(currentKey); if(!ParameterUtil.compareParameter(actualObject, this.get(currentKey))) { return false; } } return true; } }
public MockParameterMap(Object[] parameterArray){ super(); for(int ii = 0; ii < parameterArray.length; ii++){ put(ii + 1, parameterArray[ii]); } }
public Object getObject(String parameterName) throws SQLException { wasNull = false; Object returnValue = null; if(null != lastOutParameters) { returnValue = lastOutParameters.get(parameterName); } if(null == returnValue) wasNull = true; return returnValue; }
private boolean containsPreparedStatementParameter(PreparedStatement statement, int indexOfParameter) { return ((MockPreparedStatement)statement).getParameterMap().containsKey(new ParameterIndex(indexOfParameter)); }
protected <S, T> ParameterWrapper<T> removeMatchingParameterWrapper(S sql, MockParameterMap parameters, Map<S, List<ParameterWrapper<T>>> map, boolean exactMatchParameter) { List<ParameterWrapper<T>> list = map.get(sql); for(ParameterWrapper<T> wrapper : list) { if(wrapper.getParameters().doParameterMatch(parameters, exactMatchParameter)) { list.remove(wrapper); return wrapper; } } return null; }
public Object remove(int index){ return remove(new ParameterIndex(index)); }
@Override public int hashCode() { int hash = 7; hash = 19 * hash + (this.parameters != null ? this.parameters.hashCode() : 0); hash = 19 * hash + (this.wrappedObject != null ? this.wrappedObject.hashCode() : 0); return hash; }
@Override public boolean equals(Object obj) { if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } final ParameterWrapper<?> other = (ParameterWrapper<?>) obj; if (this.parameters != other.parameters && (this.parameters == null || !this.parameters.equals(other.parameters))) { return false; } return !(this.wrappedObject != other.wrappedObject && (this.wrappedObject == null || !this.wrappedObject .equals(other.wrappedObject))); }
/** * Prepare an out parameter <code>Map</code> for a specified SQL string and * the specified parameters. The specified parameters array * must contain the parameters in the correct order starting with index 0 for * the first parameter. Please keep in mind that parameters in * <code>CallableStatement</code> objects start with 1 as the first * parameter. So <code>parameters.get(0)</code> maps to the * parameter with index 1. * Please note that you can modify the match parameters with * {@link #setCaseSensitive}, {@link #setExactMatch} and * {@link #setUseRegularExpressions} and the match parameters for the * specified parameter list with {@link #setExactMatchParameter}. * @param sql the SQL string * @param outParameters the corresponding out parameter <code>Map</code> * @param parameters the parameters */ public void prepareOutParameter(String sql, MockParameterMap outParameters, List<Object> parameters) { MockParameterMap params = new MockParameterMap(); for(int ii = 0; ii < parameters.size(); ii++) { params.put(ii + 1, parameters.get(ii)); } prepareOutParameter(sql, outParameters, params); }
public void setObject(String parameterName, Object object) throws SQLException { paramObjects.put(parameterName, object); }
verifySQLStatementParameterNumber(sql, indexOfParameterSet, parameterMap.size()); MockParameterMap actualParameterMap = verifyAndGetParametersForSQL(sql, indexOfParameterSet); for(ParameterReference key : parameterMap.keySet()){ Object nextExpectedParameter = parameterMap.get(key); Object nextActualParameter = actualParameterMap.get(key); if(null == nextActualParameter)
public Object getParameter(String name) { return paramObjects.get(name); }
private boolean containsCallableStatementParameter(CallableStatement statement, int indexOfParameter) { return ((MockCallableStatement)statement).getParameterMap().containsKey(new ParameterIndex(indexOfParameter)); }
protected <T> ParameterWrapper<T> getMatchingParameterWrapper(String sql, MockParameterMap parameters, Map<PatternMatcher, List<ParameterWrapper<T>>> statementMap, boolean exactMatchParameter) { List<List<ParameterWrapper<T>>> list = getMatchingObjects(statementMap, sql); for(List<ParameterWrapper<T>> wrapperList : list) { for(ParameterWrapper<T> wrapper : wrapperList) { if(wrapper.getParameters().doParameterMatch(parameters, exactMatchParameter)) { return wrapper; } } } return null; }
public Object remove(String name){ return remove(new ParameterName(name)); }
public void addBatch() throws SQLException { batchParameters.add(new MockParameterMap(paramObjects)); }