}
    }

    private static boolean isGetter(Method method) {
        String methodName = method.getName();
        return (isPrefixable(methodName, "get") || isPrefixable(methodName, "is")) && method.getParameterTypes().length == 0 && !method.getReturnType().equals(void.class);
    }

    private static boolean isSetter(Method method) {
        Class<?>[] parameterTypes = method.getParameterTypes();

 * href="https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ConcurrentMap.html">before
 * {@code default} methods were introduced</a>. For newer methods, like {@code forEach}, it inherits
 * their default implementations. When those implementations invoke methods, they invoke methods on
 * the {@code ForwardingConcurrentMap}.
 *
 * @author Charles Fry
 * @since 2.0
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault

 * provided {@code standardPutAll} method.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingSortedMap}.
 *
 * <p>Each of the {@code standard} methods, where appropriate, use the comparator of the map to test

			t.Errorf("Expected %v to be allowed, Got only %#v", test.method, response.Header.Get("Access-Control-Allow-Methods"))
		case !test.allowed && methodAllowed:
			t.Errorf("Unexpected allowed method %v, Expected only %#v", test.method, response.Header.Get("Access-Control-Allow-Methods"))
		}
	}

}

func TestCompileRegex(t *testing.T) {
	uncompiledRegexes := []string{"endsWithMe$", "^startingWithMe"}

   *   <li>If the constructor or factory method used to construct instance takes a parameter that
   *       {@link AbstractPackageSanityTests} doesn't know how to construct, the test will fail.
   *   <li>If there is no visible constructor or visible static factory method declared by {@code
   *       C}, instance methods are skipped for nulls test.

    Class<?> clazz = listener.getClass();
    for (Method method : getAnnotatedMethods(clazz)) {
      Class<?>[] parameterTypes = method.getParameterTypes();
      Class<?> eventType = parameterTypes[0];
      methodsInListener.put(eventType, Subscriber.create(bus, listener, method));
    }
    return methodsInListener;
  }

  private static ImmutableList<Method> getAnnotatedMethods(Class<?> clazz) {
    try {

 * provided {@code standardOffer} method.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingBlockingDeque}.
 *
 * <p>The {@code standard} methods are not guaranteed to be thread-safe, even when all of the

 * href="http://code.google.com/webtoolkit/">Google Web Toolkit</a> (GWT). When applied to a method,
 * the return type of the method is GWT compatible. It's useful to indicate that an instance created
 * by factory methods has a GWT serializable type. In the following example,
 *
 * <pre>
 * {@literal @}GwtCompatible
 * class Lists {
 *   ...

        return includeMethods(cls, Collections.singletonList(method));
    }

    @Override
    public TestSpec includeMethods(String clazz, Collection<String> newMethods) {
        List<String> methods = this.methods.get(clazz);
        if (methods == null) {
            methods = new ArrayList<String>(newMethods.size());
            this.methods.put(clazz, methods);
        }

            namespaces: ["rule[0]-from[1]-ns[0]"]
      to:
        - operation:
            methods: ["rule[0]-to[0]-method[0]"]
    - from:
        - source:
            principals: ["cluster.local/ns/rule[1]/sa/from[0]-principal[0]"]
      to:
        - operation: