Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   *
   *  * Copyright 2010,  Unitils.org
   *  *
   *  * Licensed under the Apache License, Version 2.0 (the "License");
   *  * you may not use this file except in compliance with the License.
   *  * You may obtain a copy of the License at
   *  *
   *  *     http://www.apache.org/licenses/LICENSE-2.0
  *  *
  *  * Unless required by applicable law or agreed to in writing, software
  *  * distributed under the License is distributed on an "AS IS" BASIS,
  *  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  * See the License for the specific language governing permissions and
  *  * limitations under the License.
  *
  */
 package org.unitils.mock.core.matching;
 
 
 import java.util.List;
 
 import static org.unitils.core.util.ObjectFormatter.MOCK_NAME_CHAIN_SEPARATOR;
 import static org.unitils.mock.argumentmatcher.ArgumentMatcherPositionFinder.getArgumentMatcherIndexes;
 import static org.unitils.mock.core.proxy.ProxyFactory.createUninitializedProxy;
 import static org.unitils.mock.core.proxy.StackTraceUtils.getInvocationStackTrace;
 import static org.unitils.mock.core.proxy.StackTraceUtils.getStackTraceStartingFrom;

Author(s):
Filip Neven
Tim Ducheyne
 
 public class MatchingInvocationBuilder {
 
     protected String currentMockName;
     protected String definingMethodName;
     protected StackTraceElement[] invokedAt;
 
 
     public synchronized <T> T startMatchingInvocation(String mockNameClass<T> mockedTypeMatchingInvocationHandler matchingInvocationHandler) {
         assertNotExpectingInvocation();
         this. = mockName;
         this. = matchingInvocationHandler;
 
         this. = getInvocationStackTrace(Mock.class);
         this. = [0].getMethodName();
         ArgumentMatcherRepository.getInstance().registerStartOfMatchingInvocation([1].getLineNumber());
         return createUninitializedProxy(mockNamenew InvocationHandler(matchingInvocationHandler), mockedType);
     }
 
     public synchronized void reset() {
         this. = null;
         this. = null;
         this. = null;
     }
 
     public synchronized void assertNotExpectingInvocation() {
         if ( != null && !isChainedMock()) {
             UnitilsException exception = new UnitilsException("Invalid syntax. " +  + "." +  + "() must be followed by a method invocation on the returned proxy. E.g. " +  + "." +  + "().myMethod();");
             exception.setStackTrace(getStackTraceStartingFrom(, 1));
             reset();
             throw exception;
         }
         reset();
     }
 
 
     protected boolean isChainedMock() {
     }
 
     protected Object handleProxyInvocation(ProxyInvocation proxyInvocationMatchingInvocationHandler matchingInvocationHandlerthrows Throwable {
         ArgumentMatcherRepository.getInstance().registerEndOfMatchingInvocation(proxyInvocation.getLineNumber(), proxyInvocation.getMethod().getName());
         reset();
 
         List<ArgumentMatcherargumentMatchers = createArgumentMatchers(proxyInvocation);
         Object result = matchingInvocationHandler.handleInvocation(proxyInvocationargumentMatchers);
         ArgumentMatcherRepository.getInstance().reset();
         return result;
     }
 
     protected List<ArgumentMatchercreateArgumentMatchers(ProxyInvocation proxyInvocation) {
         List<ArgumentMatcherresult = new ArrayList<ArgumentMatcher>();
 
         ArgumentMatcherRepository argumentMatcherRepository = ArgumentMatcherRepository.getInstance();
         int matchInvocationStartLineNr = argumentMatcherRepository.getMatchInvocationStartLineNr();
         int matchInvocationEndLineNr = argumentMatcherRepository.getMatchInvocationEndLineNr();
         int matchInvocationIndex = argumentMatcherRepository.getMatchInvocationIndex();
         List<IntegerargumentMatcherIndexes = getArgumentMatcherIndexes(proxyInvocationmatchInvocationStartLineNrmatchInvocationEndLineNrmatchInvocationIndex);
        int argumentIndex = 0;
        Iterator<ArgumentMatcherargumentMatcherIterator = ArgumentMatcherRepository.getInstance().getArgumentMatchers().iterator();
        for (Object argument : proxyInvocation.getArguments()) {
            if (argumentMatcherIndexes.contains(argumentIndex++)) {
                result.add(argumentMatcherIterator.next());
            } else {
                result.add(new DefaultArgumentMatcher(argument));
            }
        }
        argumentMatcherRepository.reset();
        return result;
    }
    protected class InvocationHandler implements ProxyInvocationHandler {
        public InvocationHandler(MatchingInvocationHandler matchingInvocationHandler) {
            this. = matchingInvocationHandler;
        }
        public Object handleInvocation(ProxyInvocation proxyInvocationthrows Throwable {
            return handleProxyInvocation(proxyInvocation);
        }
    }
New to GrepCode? Check out our FAQ X