Source code

001/*
002 * Copyright (C) 2005 The Guava Authors
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017package com.google.common.testing;
018
019import static com.google.common.base.Preconditions.checkArgument;
020import static com.google.common.base.Preconditions.checkNotNull;
021
022import com.google.common.annotations.GwtIncompatible;
023import com.google.common.annotations.J2ktIncompatible;
024import com.google.common.base.Converter;
025import com.google.common.base.Objects;
026import com.google.common.collect.ClassToInstanceMap;
027import com.google.common.collect.ImmutableList;
028import com.google.common.collect.ImmutableSet;
029import com.google.common.collect.Lists;
030import com.google.common.collect.Maps;
031import com.google.common.collect.MutableClassToInstanceMap;
032import com.google.common.reflect.Invokable;
033import com.google.common.reflect.Parameter;
034import com.google.common.reflect.Reflection;
035import com.google.common.reflect.TypeToken;
036import com.google.errorprone.annotations.CanIgnoreReturnValue;
037import java.lang.annotation.Annotation;
038import java.lang.reflect.AnnotatedType;
039import java.lang.reflect.Constructor;
040import java.lang.reflect.InvocationTargetException;
041import java.lang.reflect.Member;
042import java.lang.reflect.Method;
043import java.lang.reflect.Modifier;
044import java.lang.reflect.ParameterizedType;
045import java.lang.reflect.Type;
046import java.lang.reflect.TypeVariable;
047import java.util.Arrays;
048import java.util.List;
049import java.util.concurrent.ConcurrentMap;
050import junit.framework.Assert;
051import junit.framework.AssertionFailedError;
052import org.checkerframework.checker.nullness.qual.Nullable;
053
054/**
055 * A test utility that verifies that your methods and constructors throw {@link
056 * NullPointerException} or {@link UnsupportedOperationException} whenever null is passed to a
057 * parameter whose declaration or type isn't annotated with an annotation with the simple name
058 * {@code Nullable}, {@code CheckForNull}, {@code NullableType}, or {@code NullableDecl}.
059 *
060 * <p>The tested methods and constructors are invoked -- each time with one parameter being null and
061 * the rest not null -- and the test fails if no expected exception is thrown. {@code
062 * NullPointerTester} uses best effort to pick non-null default values for many common JDK and Guava
063 * types, and also for interfaces and public classes that have public parameter-less constructors.
064 * When the non-null default value for a particular parameter type cannot be provided by {@code
065 * NullPointerTester}, the caller can provide a custom non-null default value for the parameter type
066 * via {@link #setDefault}.
067 *
068 * @author Kevin Bourrillion
069 * @since 10.0
070 */
071@GwtIncompatible
072@J2ktIncompatible
073@ElementTypesAreNonnullByDefault
074public final class NullPointerTester {
075
076  private final ClassToInstanceMap<Object> defaults = MutableClassToInstanceMap.create();
077  private final List<Member> ignoredMembers = Lists.newArrayList();
078
079  private ExceptionTypePolicy policy = ExceptionTypePolicy.NPE_OR_UOE;
080
081  public NullPointerTester() {
082    try {
083      /*
084       * Converter.apply has a non-nullable parameter type but doesn't throw for null arguments. For
085       * more information, see the comments in that class.
086       *
087       * We already know that that's how it behaves, and subclasses of Converter can't change that
088       * behavior. So there's no sense in making all subclass authors exclude the method from any
089       * NullPointerTester tests that they have.
090       */
091      ignoredMembers.add(Converter.class.getMethod("apply", Object.class));
092    } catch (NoSuchMethodException shouldBeImpossible) {
093      // OK, fine: If it doesn't exist, then there's chance that we're going to be asked to test it.
094    }
095  }
096
097  /**
098   * Sets a default value that can be used for any parameter of type {@code type}. Returns this
099   * object.
100   */
101  @CanIgnoreReturnValue
102  public <T> NullPointerTester setDefault(Class<T> type, T value) {
103    defaults.putInstance(type, checkNotNull(value));
104    return this;
105  }
106
107  /**
108   * Ignore {@code method} in the tests that follow. Returns this object.
109   *
110   * @since 13.0
111   */
112  @CanIgnoreReturnValue
113  public NullPointerTester ignore(Method method) {
114    ignoredMembers.add(checkNotNull(method));
115    return this;
116  }
117
118  /**
119   * Ignore {@code constructor} in the tests that follow. Returns this object.
120   *
121   * @since 22.0
122   */
123  @CanIgnoreReturnValue
124  public NullPointerTester ignore(Constructor<?> constructor) {
125    ignoredMembers.add(checkNotNull(constructor));
126    return this;
127  }
128
129  /**
130   * Runs {@link #testConstructor} on every constructor in class {@code c} that has at least {@code
131   * minimalVisibility}.
132   */
133  public void testConstructors(Class<?> c, Visibility minimalVisibility) {
134    for (Constructor<?> constructor : c.getDeclaredConstructors()) {
135      if (minimalVisibility.isVisible(constructor) && !isIgnored(constructor)) {
136        testConstructor(constructor);
137      }
138    }
139  }
140
141  /** Runs {@link #testConstructor} on every public constructor in class {@code c}. */
142  public void testAllPublicConstructors(Class<?> c) {
143    testConstructors(c, Visibility.PUBLIC);
144  }
145
146  /**
147   * Runs {@link #testMethod} on every static method of class {@code c} that has at least {@code
148   * minimalVisibility}, including those "inherited" from superclasses of the same package.
149   */
150  public void testStaticMethods(Class<?> c, Visibility minimalVisibility) {
151    for (Method method : minimalVisibility.getStaticMethods(c)) {
152      if (!isIgnored(method)) {
153        testMethod(null, method);
154      }
155    }
156  }
157
158  /**
159   * Runs {@link #testMethod} on every public static method of class {@code c}, including those
160   * "inherited" from superclasses of the same package.
161   */
162  public void testAllPublicStaticMethods(Class<?> c) {
163    testStaticMethods(c, Visibility.PUBLIC);
164  }
165
166  /**
167   * Runs {@link #testMethod} on every instance method of the class of {@code instance} with at
168   * least {@code minimalVisibility}, including those inherited from superclasses of the same
169   * package.
170   */
171  public void testInstanceMethods(Object instance, Visibility minimalVisibility) {
172    for (Method method : getInstanceMethodsToTest(instance.getClass(), minimalVisibility)) {
173      testMethod(instance, method);
174    }
175  }
176
177  ImmutableList<Method> getInstanceMethodsToTest(Class<?> c, Visibility minimalVisibility) {
178    ImmutableList.Builder<Method> builder = ImmutableList.builder();
179    for (Method method : minimalVisibility.getInstanceMethods(c)) {
180      if (!isIgnored(method)) {
181        builder.add(method);
182      }
183    }
184    return builder.build();
185  }
186
187  /**
188   * Runs {@link #testMethod} on every public instance method of the class of {@code instance},
189   * including those inherited from superclasses of the same package.
190   */
191  public void testAllPublicInstanceMethods(Object instance) {
192    testInstanceMethods(instance, Visibility.PUBLIC);
193  }
194
195  /**
196   * Verifies that {@code method} produces a {@link NullPointerException} or {@link
197   * UnsupportedOperationException} whenever <i>any</i> of its non-nullable parameters are null.
198   *
199   * @param instance the instance to invoke {@code method} on, or null if {@code method} is static
200   */
201  public void testMethod(@Nullable Object instance, Method method) {
202    Class<?>[] types = method.getParameterTypes();
203    for (int nullIndex = 0; nullIndex < types.length; nullIndex++) {
204      testMethodParameter(instance, method, nullIndex);
205    }
206  }
207
208  /**
209   * Verifies that {@code ctor} produces a {@link NullPointerException} or {@link
210   * UnsupportedOperationException} whenever <i>any</i> of its non-nullable parameters are null.
211   */
212  public void testConstructor(Constructor<?> ctor) {
213    Class<?> declaringClass = ctor.getDeclaringClass();
214    checkArgument(
215        Modifier.isStatic(declaringClass.getModifiers())
216            || declaringClass.getEnclosingClass() == null,
217        "Cannot test constructor of non-static inner class: %s",
218        declaringClass.getName());
219    Class<?>[] types = ctor.getParameterTypes();
220    for (int nullIndex = 0; nullIndex < types.length; nullIndex++) {
221      testConstructorParameter(ctor, nullIndex);
222    }
223  }
224
225  /**
226   * Verifies that {@code method} produces a {@link NullPointerException} or {@link
227   * UnsupportedOperationException} when the parameter in position {@code paramIndex} is null. If
228   * this parameter is marked nullable, this method does nothing.
229   *
230   * @param instance the instance to invoke {@code method} on, or null if {@code method} is static
231   */
232  public void testMethodParameter(@Nullable Object instance, Method method, int paramIndex) {
233    method.setAccessible(true);
234    testParameter(instance, invokable(instance, method), paramIndex, method.getDeclaringClass());
235  }
236
237  /**
238   * Verifies that {@code ctor} produces a {@link NullPointerException} or {@link
239   * UnsupportedOperationException} when the parameter in position {@code paramIndex} is null. If
240   * this parameter is marked nullable, this method does nothing.
241   */
242  public void testConstructorParameter(Constructor<?> ctor, int paramIndex) {
243    ctor.setAccessible(true);
244    testParameter(null, Invokable.from(ctor), paramIndex, ctor.getDeclaringClass());
245  }
246
247  /** Visibility of any method or constructor. */
248  public enum Visibility {
249    PACKAGE {
250      @Override
251      boolean isVisible(int modifiers) {
252        return !Modifier.isPrivate(modifiers);
253      }
254    },
255
256    PROTECTED {
257      @Override
258      boolean isVisible(int modifiers) {
259        return Modifier.isPublic(modifiers) || Modifier.isProtected(modifiers);
260      }
261    },
262
263    PUBLIC {
264      @Override
265      boolean isVisible(int modifiers) {
266        return Modifier.isPublic(modifiers);
267      }
268    };
269
270    abstract boolean isVisible(int modifiers);
271
272    /** Returns {@code true} if {@code member} is visible under {@code this} visibility. */
273    final boolean isVisible(Member member) {
274      return isVisible(member.getModifiers());
275    }
276
277    final Iterable<Method> getStaticMethods(Class<?> cls) {
278      ImmutableList.Builder<Method> builder = ImmutableList.builder();
279      for (Method method : getVisibleMethods(cls)) {
280        if (Invokable.from(method).isStatic()) {
281          builder.add(method);
282        }
283      }
284      return builder.build();
285    }
286
287    final Iterable<Method> getInstanceMethods(Class<?> cls) {
288      ConcurrentMap<Signature, Method> map = Maps.newConcurrentMap();
289      for (Method method : getVisibleMethods(cls)) {
290        if (!Invokable.from(method).isStatic()) {
291          map.putIfAbsent(new Signature(method), method);
292        }
293      }
294      return map.values();
295    }
296
297    private ImmutableList<Method> getVisibleMethods(Class<?> cls) {
298      // Don't use cls.getPackage() because it does nasty things like reading
299      // a file.
300      String visiblePackage = Reflection.getPackageName(cls);
301      ImmutableList.Builder<Method> builder = ImmutableList.builder();
302      for (Class<?> type : TypeToken.of(cls).getTypes().rawTypes()) {
303        if (!Reflection.getPackageName(type).equals(visiblePackage)) {
304          break;
305        }
306        for (Method method : type.getDeclaredMethods()) {
307          if (!method.isSynthetic() && isVisible(method)) {
308            builder.add(method);
309          }
310        }
311      }
312      return builder.build();
313    }
314  }
315
316  private static final class Signature {
317    private final String name;
318    private final ImmutableList<Class<?>> parameterTypes;
319
320    Signature(Method method) {
321      this(method.getName(), ImmutableList.copyOf(method.getParameterTypes()));
322    }
323
324    Signature(String name, ImmutableList<Class<?>> parameterTypes) {
325      this.name = name;
326      this.parameterTypes = parameterTypes;
327    }
328
329    @Override
330    public boolean equals(@Nullable Object obj) {
331      if (obj instanceof Signature) {
332        Signature that = (Signature) obj;
333        return name.equals(that.name) && parameterTypes.equals(that.parameterTypes);
334      }
335      return false;
336    }
337
338    @Override
339    public int hashCode() {
340      return Objects.hashCode(name, parameterTypes);
341    }
342  }
343
344  /**
345   * Verifies that {@code invokable} produces a {@link NullPointerException} or {@link
346   * UnsupportedOperationException} when the parameter in position {@code paramIndex} is null. If
347   * this parameter is marked nullable, this method does nothing.
348   *
349   * @param instance the instance to invoke {@code invokable} on, or null if {@code invokable} is
350   *     static
351   */
352  private void testParameter(
353      @Nullable Object instance, Invokable<?, ?> invokable, int paramIndex, Class<?> testedClass) {
354    /*
355     * com.google.common is starting to rely on type-use annotations, which aren't visible under
356     * Android VMs. So we skip testing there.
357     */
358    if (isAndroid() && Reflection.getPackageName(testedClass).startsWith("com.google.common")) {
359      return;
360    }
361    if (isPrimitiveOrNullable(invokable.getParameters().get(paramIndex))) {
362      return; // there's nothing to test
363    }
364    @Nullable Object[] params = buildParamList(invokable, paramIndex);
365    try {
366      @SuppressWarnings("unchecked") // We'll get a runtime exception if the type is wrong.
367      Invokable<Object, ?> unsafe = (Invokable<Object, ?>) invokable;
368      unsafe.invoke(instance, params);
369      Assert.fail(
370          "No exception thrown for parameter at index "
371              + paramIndex
372              + " from "
373              + invokable
374              + Arrays.toString(params)
375              + " for "
376              + testedClass);
377    } catch (InvocationTargetException e) {
378      Throwable cause = e.getCause();
379      if (policy.isExpectedType(cause)) {
380        return;
381      }
382      AssertionFailedError error =
383          new AssertionFailedError(
384              String.format(
385                  "wrong exception thrown from %s when passing null to %s parameter at index %s.%n"
386                      + "Full parameters: %s%n"
387                      + "Actual exception message: %s",
388                  invokable,
389                  invokable.getParameters().get(paramIndex).getType(),
390                  paramIndex,
391                  Arrays.toString(params),
392                  cause));
393      error.initCause(cause);
394      throw error;
395    } catch (IllegalAccessException e) {
396      throw new RuntimeException(e);
397    }
398  }
399
400  private @Nullable Object[] buildParamList(
401      Invokable<?, ?> invokable, int indexOfParamToSetToNull) {
402    ImmutableList<Parameter> params = invokable.getParameters();
403    @Nullable Object[] args = new Object[params.size()];
404
405    for (int i = 0; i < args.length; i++) {
406      Parameter param = params.get(i);
407      if (i != indexOfParamToSetToNull) {
408        args[i] = getDefaultValue(param.getType());
409        Assert.assertTrue(
410            "Can't find or create a sample instance for type '"
411                + param.getType()
412                + "'; please provide one using NullPointerTester.setDefault()",
413            args[i] != null || isNullable(param));
414      }
415    }
416    return args;
417  }
418
419  private <T> @Nullable T getDefaultValue(TypeToken<T> type) {
420    // We assume that all defaults are generics-safe, even if they aren't,
421    // we take the risk.
422    @SuppressWarnings("unchecked")
423    T defaultValue = (T) defaults.getInstance(type.getRawType());
424    if (defaultValue != null) {
425      return defaultValue;
426    }
427    @SuppressWarnings("unchecked") // All arbitrary instances are generics-safe
428    T arbitrary = (T) ArbitraryInstances.get(type.getRawType());
429    if (arbitrary != null) {
430      return arbitrary;
431    }
432    if (type.getRawType() == Class.class) {
433      // If parameter is Class<? extends Foo>, we return Foo.class
434      @SuppressWarnings("unchecked")
435      T defaultClass = (T) getFirstTypeParameter(type.getType()).getRawType();
436      return defaultClass;
437    }
438    if (type.getRawType() == TypeToken.class) {
439      // If parameter is TypeToken<? extends Foo>, we return TypeToken<Foo>.
440      @SuppressWarnings("unchecked")
441      T defaultType = (T) getFirstTypeParameter(type.getType());
442      return defaultType;
443    }
444    if (type.getRawType() == Converter.class) {
445      TypeToken<?> convertFromType = type.resolveType(Converter.class.getTypeParameters()[0]);
446      TypeToken<?> convertToType = type.resolveType(Converter.class.getTypeParameters()[1]);
447      @SuppressWarnings("unchecked") // returns default for both F and T
448      T defaultConverter = (T) defaultConverter(convertFromType, convertToType);
449      return defaultConverter;
450    }
451    if (type.getRawType().isInterface()) {
452      return newDefaultReturningProxy(type);
453    }
454    return null;
455  }
456
457  private <F, T> Converter<F, T> defaultConverter(
458      final TypeToken<F> convertFromType, final TypeToken<T> convertToType) {
459    return new Converter<F, T>() {
460      @Override
461      protected T doForward(F a) {
462        return doConvert(convertToType);
463      }
464
465      @Override
466      protected F doBackward(T b) {
467        return doConvert(convertFromType);
468      }
469
470      private /*static*/ <S> S doConvert(TypeToken<S> type) {
471        return checkNotNull(getDefaultValue(type));
472      }
473    };
474  }
475
476  private static TypeToken<?> getFirstTypeParameter(Type type) {
477    if (type instanceof ParameterizedType) {
478      return TypeToken.of(((ParameterizedType) type).getActualTypeArguments()[0]);
479    } else {
480      return TypeToken.of(Object.class);
481    }
482  }
483
484  private <T> T newDefaultReturningProxy(final TypeToken<T> type) {
485    return new DummyProxy() {
486      @Override
487      <R> @Nullable R dummyReturnValue(TypeToken<R> returnType) {
488        return getDefaultValue(returnType);
489      }
490    }.newProxy(type);
491  }
492
493  private static Invokable<?, ?> invokable(@Nullable Object instance, Method method) {
494    if (instance == null) {
495      return Invokable.from(method);
496    } else {
497      return TypeToken.of(instance.getClass()).method(method);
498    }
499  }
500
501  static boolean isPrimitiveOrNullable(Parameter param) {
502    return param.getType().getRawType().isPrimitive() || isNullable(param);
503  }
504
505  private static final ImmutableSet<String> NULLABLE_ANNOTATION_SIMPLE_NAMES =
506      ImmutableSet.of("CheckForNull", "Nullable", "NullableDecl", "NullableType");
507
508  static boolean isNullable(Invokable<?, ?> invokable) {
509    return NULLNESS_ANNOTATION_READER.isNullable(invokable);
510  }
511
512  static boolean isNullable(Parameter param) {
513    return NULLNESS_ANNOTATION_READER.isNullable(param);
514  }
515
516  private static boolean containsNullable(Annotation[] annotations) {
517    for (Annotation annotation : annotations) {
518      if (NULLABLE_ANNOTATION_SIMPLE_NAMES.contains(annotation.annotationType().getSimpleName())) {
519        return true;
520      }
521    }
522    return false;
523  }
524
525  private boolean isIgnored(Member member) {
526    return member.isSynthetic() || ignoredMembers.contains(member) || isEquals(member);
527  }
528
529  /**
530   * Returns true if the given member is a method that overrides {@link Object#equals(Object)}.
531   *
532   * <p>The documentation for {@link Object#equals} says it should accept null, so don't require an
533   * explicit {@code @NullableDecl} annotation (see <a
534   * href="https://github.com/google/guava/issues/1819">#1819</a>).
535   *
536   * <p>It is not necessary to consider visibility, return type, or type parameter declarations. The
537   * declaration of a method with the same name and formal parameters as {@link Object#equals} that
538   * is not public and boolean-returning, or that declares any type parameters, would be rejected at
539   * compile-time.
540   */
541  private static boolean isEquals(Member member) {
542    if (!(member instanceof Method)) {
543      return false;
544    }
545    Method method = (Method) member;
546    if (!method.getName().contentEquals("equals")) {
547      return false;
548    }
549    Class<?>[] parameters = method.getParameterTypes();
550    if (parameters.length != 1) {
551      return false;
552    }
553    if (!parameters[0].equals(Object.class)) {
554      return false;
555    }
556    return true;
557  }
558
559  /** Strategy for exception type matching used by {@link NullPointerTester}. */
560  private enum ExceptionTypePolicy {
561
562    /**
563     * Exceptions should be {@link NullPointerException} or {@link UnsupportedOperationException}.
564     */
565    NPE_OR_UOE() {
566      @Override
567      public boolean isExpectedType(Throwable cause) {
568        return cause instanceof NullPointerException
569            || cause instanceof UnsupportedOperationException;
570      }
571    },
572
573    /**
574     * Exceptions should be {@link NullPointerException}, {@link IllegalArgumentException}, or
575     * {@link UnsupportedOperationException}.
576     */
577    NPE_IAE_OR_UOE() {
578      @Override
579      public boolean isExpectedType(Throwable cause) {
580        return cause instanceof NullPointerException
581            || cause instanceof IllegalArgumentException
582            || cause instanceof UnsupportedOperationException;
583      }
584    };
585
586    public abstract boolean isExpectedType(Throwable cause);
587  }
588
589  private static boolean annotatedTypeExists() {
590    try {
591      Class.forName("java.lang.reflect.AnnotatedType");
592    } catch (ClassNotFoundException e) {
593      return false;
594    }
595    return true;
596  }
597
598  private static final NullnessAnnotationReader NULLNESS_ANNOTATION_READER =
599      annotatedTypeExists()
600          ? NullnessAnnotationReader.FROM_DECLARATION_AND_TYPE_USE_ANNOTATIONS
601          : NullnessAnnotationReader.FROM_DECLARATION_ANNOTATIONS_ONLY;
602
603  /**
604   * Looks for declaration nullness annotations and, if supported, type-use nullness annotations.
605   *
606   * <p>Under Android VMs, the methods for retrieving type-use annotations don't exist. This means
607   * that {@link NullPointerException} may misbehave under Android when used on classes that rely on
608   * type-use annotations.
609   *
610   * <p>Under j2objc, the necessary APIs exist, but some (perhaps all) return stub values, like
611   * empty arrays. Presumably {@link NullPointerException} could likewise misbehave under j2objc,
612   * but I don't know that anyone uses it there, anyway.
613   */
614  private enum NullnessAnnotationReader {
615    // Usages (which are unsafe only for Android) are guarded by the annotatedTypeExists() check.
616    @SuppressWarnings({"Java7ApiChecker", "AndroidApiChecker", "DoNotCall", "deprecation"})
617    FROM_DECLARATION_AND_TYPE_USE_ANNOTATIONS {
618      @Override
619      @IgnoreJRERequirement
620      boolean isNullable(Invokable<?, ?> invokable) {
621        return FROM_DECLARATION_ANNOTATIONS_ONLY.isNullable(invokable)
622            || containsNullable(invokable.getAnnotatedReturnType().getAnnotations());
623        // TODO(cpovirk): Should we also check isNullableTypeVariable?
624      }
625
626      @Override
627      @IgnoreJRERequirement
628      boolean isNullable(Parameter param) {
629        return FROM_DECLARATION_ANNOTATIONS_ONLY.isNullable(param)
630            || containsNullable(param.getAnnotatedType().getAnnotations())
631            || isNullableTypeVariable(param.getAnnotatedType().getType());
632      }
633
634      @IgnoreJRERequirement
635      boolean isNullableTypeVariable(Type type) {
636        if (!(type instanceof TypeVariable)) {
637          return false;
638        }
639        TypeVariable<?> typeVar = (TypeVariable<?>) type;
640        for (AnnotatedType bound : typeVar.getAnnotatedBounds()) {
641          // Until Java 15, the isNullableTypeVariable case here won't help:
642          // https://bugs.openjdk.java.net/browse/JDK-8202469
643          if (containsNullable(bound.getAnnotations()) || isNullableTypeVariable(bound.getType())) {
644            return true;
645          }
646        }
647        return false;
648      }
649    },
650    FROM_DECLARATION_ANNOTATIONS_ONLY {
651      @Override
652      boolean isNullable(Invokable<?, ?> invokable) {
653        return containsNullable(invokable.getAnnotations());
654      }
655
656      @Override
657      boolean isNullable(Parameter param) {
658        return containsNullable(param.getAnnotations());
659      }
660    };
661
662    abstract boolean isNullable(Invokable<?, ?> invokable);
663
664    abstract boolean isNullable(Parameter param);
665  }
666
667  private static boolean isAndroid() {
668    // Arguably it would make more sense to test "can we see type-use annotations" directly....
669    return checkNotNull(System.getProperty("java.runtime.name", "")).contains("Android");
670  }
671}