| /* |
| * 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.reflect; |
| |
| import static com.google.common.base.Preconditions.checkNotNull; |
| |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.testing.EqualsTester; |
| import com.google.common.testing.SerializableTester; |
| |
| import junit.framework.TestCase; |
| |
| import java.io.Serializable; |
| import java.lang.reflect.Method; |
| import java.lang.reflect.Proxy; |
| import java.util.List; |
| |
| /** |
| * Tests for {@link AbstractInvocationHandler}. |
| * |
| * @author Ben Yu |
| */ |
| public class AbstractInvocationHandlerTest extends TestCase { |
| |
| private static final ImmutableList<String> LIST1 = ImmutableList.of("one", "two"); |
| private static final ImmutableList<String> LIST2 = ImmutableList.of("three"); |
| |
| public void testDelegate() { |
| assertEquals(LIST1, ImmutableList.copyOf(newDelegatingList(LIST1))); |
| assertEquals(LIST1, ImmutableList.copyOf(newDelegatingListWithEquals(LIST1))); |
| } |
| |
| public void testToString() { |
| List<String> proxy = newDelegatingList(LIST1); |
| assertEquals(Proxy.getInvocationHandler(proxy).toString(), proxy.toString()); |
| } |
| |
| interface A {} |
| interface B{} |
| |
| public void testEquals() { |
| class AB implements A, B {} |
| class BA implements B, A {} |
| AB ab = new AB(); |
| BA ba = new BA(); |
| new EqualsTester() |
| .addEqualityGroup(newDelegatingList(LIST1)) |
| // Actually, this violates List#equals contract. |
| // But whatever, no one is going to proxy List (hopefully). |
| .addEqualityGroup(newDelegatingList(LIST1)) |
| .addEqualityGroup(newDelegatingList(LIST2)) |
| .addEqualityGroup( |
| newProxyWithEqualsForInterfaces(List.class, Runnable.class), |
| newProxyWithEqualsForInterfaces(List.class, Runnable.class)) |
| .addEqualityGroup( |
| newProxyWithEqualsForInterfaces(Runnable.class, List.class)) |
| .addEqualityGroup( |
| newDelegatingListWithEquals(LIST1), |
| newDelegatingListWithEquals(LIST1), |
| SerializableTester.reserialize(newDelegatingListWithEquals(LIST1))) |
| .addEqualityGroup( |
| newDelegatingListWithEquals(LIST2), |
| newProxyWithSubHandler1(LIST2), // Makes sure type of handler doesn't affect equality |
| newProxyWithSubHandler2(LIST2)) |
| .addEqualityGroup(newDelegatingIterableWithEquals(LIST2)) // different interface |
| .testEquals(); |
| } |
| |
| @SuppressWarnings("unchecked") // proxy of List<String> |
| private static List<String> newDelegatingList(List<String> delegate) { |
| return Reflection.newProxy(List.class, new DelegatingInvocationHandler(delegate)); |
| } |
| |
| @SuppressWarnings("unchecked") // proxy of List<String> |
| private static List<String> newDelegatingListWithEquals(List<String> delegate) { |
| return Reflection.newProxy(List.class, new DelegatingInvocationHandlerWithEquals(delegate)); |
| } |
| |
| @SuppressWarnings("unchecked") // proxy of Iterable<String> |
| private static Iterable<String> newDelegatingIterableWithEquals(Iterable<String> delegate) { |
| return Reflection.newProxy(Iterable.class, new DelegatingInvocationHandlerWithEquals(delegate)); |
| } |
| |
| @SuppressWarnings("unchecked") // proxy of List<String> |
| private static List<String> newProxyWithSubHandler1(List<String> delegate) { |
| return Reflection.newProxy(List.class, new SubHandler1(delegate)); |
| } |
| |
| @SuppressWarnings("unchecked") // proxy of List<String> |
| private static List<String> newProxyWithSubHandler2(List<String> delegate) { |
| return Reflection.newProxy(List.class, new SubHandler2(delegate)); |
| } |
| |
| private static Object newProxyWithEqualsForInterfaces( |
| Class<?>... interfaces) { |
| return Proxy.newProxyInstance(AbstractInvocationHandlerTest.class.getClassLoader(), |
| interfaces, new DelegatingInvocationHandlerWithEquals("a string")); |
| } |
| |
| private static class DelegatingInvocationHandler extends AbstractInvocationHandler |
| implements Serializable { |
| final Object delegate; |
| |
| DelegatingInvocationHandler(Object delegate) { |
| this.delegate = checkNotNull(delegate); |
| } |
| |
| @Override protected Object handleInvocation(Object proxy, Method method, Object[] args) |
| throws Throwable { |
| return method.invoke(delegate, args); |
| } |
| |
| @Override public String toString() { |
| return "some arbitrary string"; |
| } |
| } |
| |
| private static class DelegatingInvocationHandlerWithEquals extends DelegatingInvocationHandler { |
| |
| DelegatingInvocationHandlerWithEquals(Object delegate) { |
| super(delegate); |
| } |
| |
| @Override public boolean equals(Object obj) { |
| if (obj instanceof DelegatingInvocationHandlerWithEquals) { |
| DelegatingInvocationHandlerWithEquals that = (DelegatingInvocationHandlerWithEquals) obj; |
| return delegate.equals(that.delegate); |
| } else { |
| return false; |
| } |
| } |
| |
| @Override public int hashCode() { |
| return delegate.hashCode(); |
| } |
| |
| @Override public String toString() { |
| return "another arbitrary string"; |
| } |
| } |
| |
| private static class SubHandler1 extends DelegatingInvocationHandlerWithEquals { |
| SubHandler1(Object delegate) { |
| super(delegate); |
| } |
| } |
| |
| private static class SubHandler2 extends DelegatingInvocationHandlerWithEquals { |
| SubHandler2(Object delegate) { |
| super(delegate); |
| } |
| } |
| } |