Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2012 The Guava Authors
   *
   * 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 com.google.common.testing;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 
 import java.util.Set;
 
 import  javax.annotation.Nullable;

Generates a dummy interface proxy that simply returns a dummy value for each method.

Author(s):
Ben Yu
 
 abstract class DummyProxy {

  
Returns a new proxy for interfaceType. Proxies of the same interface are equal to each other if the DummyProxy instance that created the proxies are equal.
 
   final <T> T newProxy(TypeToken<T> interfaceType) {
     Set<Class<?>> interfaceClasses = Sets.newLinkedHashSet();
     interfaceClasses.addAll(interfaceType.getTypes().interfaces().rawTypes());
     // Make the proxy serializable to work with SerializableTester
     interfaceClasses.add(Serializable.class);
     Object dummy = Proxy.newProxyInstance(
         interfaceClasses.iterator().next().getClassLoader(),
         interfaceClasses.toArray(new Class<?>[interfaceClasses.size()]),
         new DummyHandler(interfaceType));
     @SuppressWarnings("unchecked"// interfaceType is T
     T result = (T) dummy;
     return result;
   }

  
Returns the dummy return value for returnType.
 
   abstract <R> R dummyReturnValue(TypeToken<R> returnType);
 
   private class DummyHandler extends AbstractInvocationHandler implements Serializable {
     private final TypeToken<?> interfaceType;
 
     DummyHandler(TypeToken<?> interfaceType) {
       this. = interfaceType;
     }
   
     @Override protected Object handleInvocation(
         Object proxyMethod methodObject[] args) {
       Invokable<?, ?> invokable = .method(method);
       ImmutableList<Parameterparams = invokable.getParameters();
       for (int i = 0; i < args.lengthi++) {
         Parameter param = params.get(i);
         if (!param.isAnnotationPresent(Nullable.class)) {
           checkNotNull(args[i]);
         }
       }
     }
 
     @Override public int hashCode() {
       return identity().hashCode();
     }
 
     @Override public boolean equals(Object obj) {
       if (obj instanceof DummyHandler) {
         DummyHandler that = (DummyHandlerobj;
         return identity().equals(that.identity());
       } else {
         return false;
       }
     }
 
     private DummyProxy identity() {
       return DummyProxy.this;
     }
 
    @Override public String toString() {
      return "Dummy proxy for " + ;
    }
    // Since type variables aren't serializable, reduce the type down to raw type before
    // serialization.
    private Object writeReplace() {
      return new DummyHandler(TypeToken.of(.getRawType()));
    }
  }
New to GrepCode? Check out our FAQ X