/*******************************************************************************
 * Copyright (c) 2010, 2016 GK Software AG and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Stephan Herrmann - initial API and implementation
 *     Till Brychcy <register.eclipse@brychcy.de> - Contribution for
 *								Bug 415413 - [compiler][null] NullpointerException in Null Analysis caused by interaction of LoopingFlowContext and FinallyFlowContext
 *								Bug 415269 - [compiler][null] NonNullByDefault is not always inherited to nested classes
 *     IBM Corporation - additional tests
 *******************************************************************************/
package org.eclipse.jdt.core.tests.compiler.regression;


import java.io.File;
import java.util.HashMap;
import java.util.Map;

import junit.framework.Test;

import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;

// see bug 186342 - [compiler][null] Using annotations for null checking
@SuppressWarnings({ "unchecked", "rawtypes" })
public class NullAnnotationTest extends AbstractNullAnnotationTest {

private String TEST_JAR_SUFFIX = ".jar";

public NullAnnotationTest(String name) {
	super(name);
}

// Static initializer to specify tests subset using TESTS_* static variables
// All specified tests which do not belong to the class are skipped...
static {
//		TESTS_NAMES = new String[] { "test_default_nullness_003a" };
//		TESTS_NUMBERS = new int[] { 561 };
//		TESTS_RANGE = new int[] { 1, 2049 };
}

public static Test suite() {
	return buildComparableTestSuite(testClass());
}

public static Class testClass() {
	return NullAnnotationTest.class;
}

String mismatch_NonNull_Nullable(String type) {
	return 	(this.complianceLevel < ClassFileConstants.JDK1_8) 
			? "Null type mismatch: required \'@NonNull "+type+"\' but the provided value is specified as @Nullable\n" 
			: "Null type mismatch (type annotations): required '@NonNull "+type+"' but this expression has type '@Nullable "+type+"'\n";
}
String nullTypeSafety() {
	return (this.complianceLevel < ClassFileConstants.JDK1_8)
			? "Null type safety: "
			: "Null type safety (type annotations): ";
}
String variableMayBeNull(String var) {
	return 	(this.complianceLevel < ClassFileConstants.JDK1_8) 
			? "Potential null pointer access: The variable "+var+" may be null at this location\n" 
			: "Potential null pointer access: this expression has a '@Nullable' type\n";
}
String redundant_check_nonnull(String expr, String type) {
	return this.complianceLevel < ClassFileConstants.JDK1_8
			? "Redundant null check: "+expr+" is specified as @NonNull\n"
			: "Redundant null check: comparing '"+type+"' against null\n";
}
String redundantCheck_method_cannot_return_null(String method, String type) {
	return this.complianceLevel < ClassFileConstants.JDK1_8
			? "Redundant null check: The method "+method+" cannot return null\n"
			: "Redundant null check: comparing '@NonNull "+type+"' against null\n";
}
String checkAlwaysFalse_method_cannot_return_null(String method, String type) {
	return this.complianceLevel < ClassFileConstants.JDK1_8
			? "Null comparison always yields false: The method "+method+" cannot return null\n"
			: "Redundant null check: comparing '@NonNull "+type+"' against null\n";
}
String redundant_check_canonlynull(String expr, String type) {
	return this.complianceLevel < ClassFileConstants.JDK1_8
			? "Redundant null check: "+expr+" can only be null at this location\n"
			: "Redundant null check: comparing '@NonNull "+type+"' against null\n";
}

String checkAlwaysFalse_nonnull(String expr, String type) {
	return (this.complianceLevel < ClassFileConstants.JDK1_8)
		? "Null comparison always yields false: "+expr+" is specified as @NonNull\n"
		: "Redundant null check: comparing '@NonNull "+type+"' against null\n";
}
String potNPE_nullable(String expr) {
	return (this.complianceLevel < ClassFileConstants.JDK1_8)
		? "Potential null pointer access: "+expr+" is specified as @Nullable\n"
		: "Potential null pointer access: this expression has a '@Nullable' type\n";
}
String potNPE_nullable_maybenull(String expr) {
	return (this.complianceLevel < ClassFileConstants.JDK1_8)
		? "Potential null pointer access: "+expr+" may be null at this location\n"
		: "Potential null pointer access: this expression has a '@Nullable' type\n";
}
String nonNullArrayOf(String string) {
	return (this.complianceLevel < ClassFileConstants.JDK1_8)
			? "@NonNull Object[]"
			: "Object @NonNull[]";
}


String targetTypeUseIfAvailable() {
	return this.complianceLevel >= ClassFileConstants.JDK1_8
				? "@Target(ElementType.TYPE_USE)\n"
				: "";
}

String cancenNonNullByDefault() {
	return this.complianceLevel < ClassFileConstants.JDK1_8
				? "    @NonNullByDefault(false)\n"
				: "    @NonNullByDefault({})\n";
}

/**
 * @deprecated
 */
protected void setUp() throws Exception {
	super.setUp();
	if (this.complianceLevel >= ClassFileConstants.JDK1_8)
		this.TEST_JAR_SUFFIX = "_1.8.jar";
	if (this.LIBS == null) {
		this.LIBS = getLibsWithNullAnnotations(this.complianceLevel);
	}
}

// a nullable argument is dereferenced without a check
public void test_nullable_paramter_001() {
	runNegativeTest(
		new String[] {
			"X.java",
			  "import org.eclipse.jdt.annotation.*;\n" +
			  "public class X {\n" +
			  "    void foo(@Nullable Object o) {\n" +
			  "        System.out.print(o.toString());\n" +
			  "    }\n" +
			  "}\n"},
	    "----------\n" +
		"1. ERROR in X.java (at line 4)\n" +
		"	System.out.print(o.toString());\n" +
		"	                 ^\n" +
		variableMayBeNull("o") +
		"----------\n",
		this.LIBS,
		true /* shouldFlush*/);
}

// a null value is passed to a nullable argument
public void test_nullable_paramter_002() {
	runConformTest(
		new String[] {
			"X.java",
			  "import org.eclipse.jdt.annotation.*;\n" +
			  "public class X {\n" +
			  "    void foo(@Nullable Object o) {\n" +
			  "        // nop\n" +
			  "    }\n" +
			  "    void bar() {\n" +
			  "        foo(null);\n" +
			  "    }\n" +
			  "}\n"},
	    "",
	    this.LIBS,
	    false/*shouldFlush*/,
	    null/*vmArgs*/,
	    null /*customOptions*/,
	    null /*clientRequester*/,
	    false/*skipJavac*/,
	    JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}

// a non-null argument is checked for null
public void test_nonnull_parameter_001() {
	runNegativeTest(
		new String[] {
			"X.java",
			  "import org.eclipse.jdt.annotation.*;\n" +
			  "public class X {\n" +
			  "    void foo(@NonNull Object o) {\n" +
			  "        if (o != null)\n" +
			  "              System.out.print(o.toString());\n" +
			  "    }\n" +
			  "}\n"},
	    "----------\n" +
		"1. ERROR in X.java (at line 4)\n" +
		"	if (o != null)\n" +
		"	    ^\n" +
		redundant_check_nonnull("The variable o", "@NonNull Object") +
		"----------\n",
		this.LIBS,
		true /* shouldFlush*/);
}
// a non-null argument is dereferenced without a check
public void test_nonnull_parameter_002() {
	runConformTest(
		new String[] {
			"X.java",
			  "import org.eclipse.jdt.annotation.*;\n" +
			  "public class X {\n" +
			  "    void foo(@NonNull Object o) {\n" +
			  "        System.out.print(o.toString());\n" +
			  "    }\n" +
			  "    public static void main(String... args) {\n" +
			  "        new X().foo(\"OK\");\n" +
			  "    }\n" +
			  "}\n"},
	    "OK",
	    this.LIBS,
	    false/*shouldFlush*/,
	    null/*vmArgs*/,
	    null /*customOptions*/,
	    null /*clientRequester*/,
	    false/*skipJavac*/,
	    JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}
// passing null to nonnull parameter - many fields in enclosing class
public void test_nonnull_parameter_003() {
	runNegativeTest(
		new String[] {
			"X.java",
			  "import org.eclipse.jdt.annotation.*;\n" +
			  "public class X {\n" +
			  "    int i00, i01, i02, i03, i04, i05, i06, i07, i08, i09;" +
			  "    int i10, i11, i12, i13, i14, i15, i16, i17, i18, i19;" +
			  "    int i20, i21, i22, i23, i24, i25, i26, i27, i28, i29;" +
			  "    int i30, i31, i32, i33, i34, i35, i36, i37, i38, i39;" +
			  "    int i40, i41, i42, i43, i44, i45, i46, i47, i48, i49;" +
			  "    int i50, i51, i52, i53, i54, i55, i56, i57, i58, i59;" +
			  "    int i60, i61, i62, i63, i64, i65, i66, i67, i68, i69;" +
			  "    void foo(@NonNull Object o) {\n" +
			  "        System.out.print(o.toString());\n" +
			  "    }\n" +
			  "    void bar() {\n" +
			  "        foo(null);\n" +
			  "    }\n" +
			  "}\n"},
		"----------\n" +
		"1. ERROR in X.java (at line 7)\n" +
		"	foo(null);\n" +
		"	    ^^^^\n" +
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" +
		"----------\n",
		this.LIBS,
		true /* shouldFlush*/);
}
// passing potential null to nonnull parameter - target method is consumed from .class
public void test_nonnull_parameter_004() {
	runConformTestWithLibs(
			new String[] {
				"Lib.java",
					"import org.eclipse.jdt.annotation.*;\n" +
				"public class Lib {\n" +
				"    void setObject(@NonNull Object o) { }\n" +
				"}\n"
			},
			null /*customOptions*/,
			"");
	runNegativeTestWithLibs(
		false, // don't flush
		new String[] {
			"X.java",
			  "public class X {\n" +
			  "    void bar(Lib l, boolean b) {\n" +
			  "        Object o = null;\n" +
			  "        if (b) o = new Object();\n" +
			  "        l.setObject(o);\n" +
			  "    }\n" +
			  "}\n"},
		null /*customOptions*/,
		"----------\n" +
		"1. ERROR in X.java (at line 5)\n" +
		"	l.setObject(o);\n" +
		"	            ^\n" +
		"Null type mismatch: required \'@NonNull Object\' but the provided value is inferred as @Nullable\n" +
		"----------\n");
}
// passing unknown value to nonnull parameter  - target method is consumed from .class
public void test_nonnull_parameter_005() {
	runConformTestWithLibs(
			new String[] {
				"Lib.java",
				"import org.eclipse.jdt.annotation.*;\n" +
				"public class Lib {\n" +
				"    void setObject(@NonNull Object o) { }\n" +
				"}\n"
			},
			null /*customOptions*/,
			"");
	runConformTestWithLibs(
		false, // don't flush
		new String[] {
			"X.java",
			  "public class X {\n" +
			  "    void bar(Lib l, Object o) {\n" +
			  "        l.setObject(o);\n" +
			  "    }\n" +
			  "}\n"},
		null /* options */,
		"----------\n" +
		"1. WARNING in X.java (at line 3)\n" +
		"	l.setObject(o);\n" +
		"	            ^\n" +
		nullTypeSafety() + "The expression of type 'Object' needs unchecked conversion to conform to \'@NonNull Object\'\n" +
		"----------\n");
}
// a ternary non-null expression is passed to a nonnull parameter
public void test_nonnull_parameter_006() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_NULL_UNCHECKED_CONVERSION, JavaCore.ERROR);
	runConformTestWithLibs(
		new String[] {
			"X.java",
			  "import org.eclipse.jdt.annotation.*;\n" +
			  "public class X {\n" +
			  "    	void m1(@NonNull String a) {}\n" +
			  "		void m2(@Nullable String b) {\n" +
			  "			m1(b == null ? \"\" : b);\n" +
			  "		}\n" +
			  "}\n"},
		customOptions,
		""  /* compiler output */);
}
// nullable value passed to a non-null parameter in a super-call
public void test_nonnull_parameter_007() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_NULL_UNCHECKED_CONVERSION, JavaCore.ERROR);
	runNegativeTestWithLibs(
		new String[] {
			"XSub.java",
			  "import org.eclipse.jdt.annotation.*;\n" +
			  "public class XSub extends XSuper {\n" +
			  "    	XSub(@Nullable String b) {\n" +
			  "			super(b);\n" +
			  "		}\n" +
			  "}\n",
			"XSuper.java",
			  "import org.eclipse.jdt.annotation.*;\n" +
			  "public class XSuper {\n" +
			  "    	XSuper(@NonNull String b) {\n" +
			  "		}\n" +
			  "}\n"
		},
		customOptions,
		"----------\n" +
		"1. ERROR in XSub.java (at line 4)\n" +
		"	super(b);\n" +
		"	      ^\n" +
		mismatch_NonNull_Nullable("String") +
		"----------\n");
}
// a nullable value is passed to a non-null parameter in an allocation expression
public void test_nonnull_parameter_008() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_NULL_UNCHECKED_CONVERSION, JavaCore.ERROR);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			  "import org.eclipse.jdt.annotation.*;\n" +
			  "public class X {\n" +
			  "    	X(@NonNull String a) {}\n" +
			  "		static X create(@Nullable String b) {\n" +
			  "			return new X(b);\n" +
			  "		}\n" +
			  "}\n"},
		customOptions,
		"----------\n" +
		"1. ERROR in X.java (at line 5)\n" +
		"	return new X(b);\n" +
		"	             ^\n" +
		mismatch_NonNull_Nullable("String") +
		"----------\n"  /* compiler output */);
}
// a nullable value is passed to a non-null parameter in a qualified allocation expression
public void test_nonnull_parameter_009() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_NULL_UNCHECKED_CONVERSION, JavaCore.ERROR);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			  "import org.eclipse.jdt.annotation.*;\n" +
			  "public class X {\n" +
			  "    class Local {\n" +
			  "    	   Local(@NonNull String a) {}\n" +
			  "    }\n" +
			  "	   Local create(@Nullable String b) {\n" +
			  "	       return this.new Local(b);\n" +
			  "    }\n" +
			  "}\n"},
		customOptions,
		"----------\n" +
		"1. ERROR in X.java (at line 7)\n" +
		"	return this.new Local(b);\n" +
		"	                      ^\n" +
		mismatch_NonNull_Nullable("String") +
		"----------\n"  /* compiler output */);
}
// null is passed to a non-null parameter in a qualified allocation expression, across CUs
public void test_nonnull_parameter_010() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_NULL_UNCHECKED_CONVERSION, JavaCore.ERROR);
	runNegativeTestWithLibs(
		new String[] {
			"ContainingInner2.java",
			"public class ContainingInner2 {\n" + 
			"    public ContainingInner2 (@org.eclipse.jdt.annotation.NonNull Object o) {\n" + 
			"    }\n" + 
			"    public class Inner {\n" + 
			"        public Inner (@org.eclipse.jdt.annotation.NonNull Object o) {\n" + 
			"        }\n" + 
			"    }\n" + 
			"}\n",
			"X.java",
			"public class X {\n" +
			"	 void create() {\n" +
			"          ContainingInner2 container = new ContainingInner2(null);\n" +
			"	       ContainingInner2.Inner inner = container.new Inner(null);\n" +
			"    }\n" +
		  	"}\n"},
		customOptions,
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	ContainingInner2 container = new ContainingInner2(null);\n" + 
		"	                                                  ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 4)\n" + 
		"	ContainingInner2.Inner inner = container.new Inner(null);\n" + 
		"	                                                   ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n"  /* compiler output */);
}
// null is passed to a non-null parameter in a qualified allocation expression, target class read from .class
public void test_nonnull_parameter_011() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_NULL_UNCHECKED_CONVERSION, JavaCore.ERROR);
	runConformTestWithLibs(
			new String[] {
				"ContainingInner2.java",
				"public class ContainingInner2 {\n" + 
				"    public ContainingInner2 (@org.eclipse.jdt.annotation.NonNull Object o) {\n" + 
				"    }\n" + 
				"    public class Inner {\n" + 
				"        public Inner (@org.eclipse.jdt.annotation.NonNull Object o) {\n" + 
				"        }\n" + 
				"    }\n" + 
				"}\n",
			},
			null /*customOptions*/,
			"");
	runNegativeTestWithLibs(
		false, // flush directory
		new String[] {
			"X.java",
			"public class X {\n" +
			"	 void create() {\n" +
			"          ContainingInner2 container = new ContainingInner2(null);\n" +
			"	       ContainingInner2.Inner inner = container.new Inner(null);\n" +
			"    }\n" +
		  	"}\n"},
		customOptions,
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	ContainingInner2 container = new ContainingInner2(null);\n" + 
		"	                                                  ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 4)\n" + 
		"	ContainingInner2.Inner inner = container.new Inner(null);\n" + 
		"	                                                   ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n"  /* compiler output */);
}
// null is passed to a non-null parameter in a qualified allocation expression, generic constructor, target class read from .class
// Note: in new type inference we infer the parameter of the Inner ctor to NullTypeBinding.
// This needs special treatment in ctor of ParameterizedGenericMethodBinding and in Statement.analyseOneArgument18
// as to propagate nonnull info, although the NullTypeBinding cannot transport this info.
public void test_nonnull_parameter_012() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_NULL_UNCHECKED_CONVERSION, JavaCore.ERROR);
	runConformTestWithLibs(
			new String[] {
				"ContainingInner2.java",
				"public class ContainingInner2 {\n" + 
				"    public ContainingInner2 (@org.eclipse.jdt.annotation.NonNull Object o) {\n" + 
				"    }\n" + 
				"    public class Inner {\n" + 
				"        public <T> Inner (@org.eclipse.jdt.annotation.NonNull T o) {\n" + 
				"        }\n" + 
				"    }\n" + 
				"}\n",
			},
			null /*customOptions*/,
			"");
	runNegativeTestWithLibs(
		false, // flush directory
		new String[] {
			"X.java",
			"public class X {\n" +
			"	 void create() {\n" +
			"          ContainingInner2 container = new ContainingInner2(null);\n" +
			"	       ContainingInner2.Inner inner = container.new Inner(null);\n" +
			"    }\n" +
		  	"}\n"},
		customOptions,
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	ContainingInner2 container = new ContainingInner2(null);\n" + 
		"	                                                  ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 4)\n" + 
		"	ContainingInner2.Inner inner = container.new Inner(null);\n" + 
		"	                                                   ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object' but the provided value is null\n"  +
		"----------\n");
}
// a method of a local class has a non-null parameter, client passes null
public void test_nonnull_parameter_013() {
	runNegativeTestWithLibs(
		new String[] {
			"B.java",
			"class B {\n" +
			"    void bar () {\n" +
			"        class Local {\n" +
			"            void callMe(@org.eclipse.jdt.annotation.NonNull Object o){\n" +
			"            }\n" +
			"        }\n" +
			"        Local l = new Local();\n" +
			"        l.callMe(null);\n" +
			"    } \n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in B.java (at line 8)\n" + 
		"	l.callMe(null);\n" + 
		"	         ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n");
}
// non-null varargs (message send)
public void test_nonnull_parameter_015() {
	runNegativeTest(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			((this.complianceLevel < ClassFileConstants.JDK1_8)
			 ? "    void foo(@NonNull Object ... o) {\n"
			 : "    void foo(Object @NonNull... o) {\n") +
			"        if (o != null)\n" +
			"              System.out.print(o.toString());\n" +
			"    }\n" +
			((this.complianceLevel < ClassFileConstants.JDK1_8)
			? "    void foo2(int i, @NonNull Object ... o) {\n"
			: "    void foo2(int i, Object @NonNull ... o) {\n"
			) +
			"        if (o.length > 0 && o[0] != null)\n" +
			"              System.out.print(o[0].toString());\n" +
			"    }\n" +
			"    void bar() {\n" +
			"        foo((Object)null);\n" +		// unchecked: single plain argument
			"        Object[] objs = null;\n" +
			"        foo(objs);\n" +				// error
			"        foo(this, null);\n" +			// unchecked: multiple plain arguments
			"        foo2(2, (Object)null);\n" +    // unchecked: single plain argument
			"        foo2(2, null, this);\n" +      // unchecked: multiple plain arguments
			"        foo2(2, null);\n" +  			// error
			"    }\n" +
			"}\n"},
			"----------\n" + 
			"1. ERROR in X.java (at line 4)\n" + 
			"	if (o != null)\n" + 
			"	    ^\n" + 
			redundant_check_nonnull("The variable o", "Object @NonNull[]") + 
			"----------\n" + 
			"2. ERROR in X.java (at line 14)\n" + 
			"	foo(objs);\n" + 
			"	    ^^^^\n" + 
			"Null type mismatch: required \'"+nonNullArrayOf("Object")+"\' but the provided value is null\n" + 
			"----------\n" + 
			"3. WARNING in X.java (at line 18)\n" + 
			"	foo2(2, null);\n" + 
			"	^^^^^^^^^^^^^\n" + 
			"Type null of the last argument to method foo2(int, Object...) doesn't exactly match the vararg parameter type. Cast to Object[] to confirm the non-varargs invocation, or pass individual arguments of type Object for a varargs invocation.\n" + 
			"----------\n" + 
			"4. ERROR in X.java (at line 18)\n" + 
			"	foo2(2, null);\n" + 
			"	        ^^^^\n" + 
			"Null type mismatch: required \'"+nonNullArrayOf("Object")+"\' but the provided value is null\n" + 
			"----------\n",
		this.LIBS,
		true /* shouldFlush*/);
}
// non-null varargs (allocation and explicit constructor calls)
public void test_nonnull_parameter_016() {
	runNegativeTest(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			((this.complianceLevel < ClassFileConstants.JDK1_8)
			 ? "    X(@NonNull Object ... o) {\n"
			 : "    X(Object @NonNull... o) {\n") +
			"        if (o != null)\n" +
			"              System.out.print(o.toString());\n" +
			"    }\n" +
			"    class Y extends X {\n" +
			((this.complianceLevel < ClassFileConstants.JDK1_8)
			 ? "    Y(int i, @NonNull Object ... o) {\n"
			 : "    Y(int i, Object @NonNull... o) {\n") +
			"        	super(i, (Object)null);\n" +
			"        }\n" +
			((this.complianceLevel < ClassFileConstants.JDK1_8)
			 ? "    Y(char c, @NonNull Object ... o) {\n"
			 : "    Y(char c, Object @NonNull... o) {\n") +
			"        	this(1, new Object(), null);\n" +
			"        }\n" +
			"    }\n" +
			"    void bar() {\n" +
			"        new X((Object[])null);\n" +
			"        new X(this, null);\n" +
			"        X x = new X(null, this);\n" +
			"        x.new Y(2, (Object)null);\n" +
			"        this.new Y(2, null, this);\n" +
			"        this.new Y(2, (Object[])null);\n" +
			"    }\n" +
			"}\n"},
			"----------\n" +
			"1. ERROR in X.java (at line 4)\n" +
			"	if (o != null)\n" +
			"	    ^\n" +
			redundant_check_nonnull("The variable o", "Object @NonNull[]") + 
			"----------\n" +
			"2. ERROR in X.java (at line 16)\n" +
			"	new X((Object[])null);\n" +
			"	      ^^^^^^^^^^^^^^\n" +
			"Null type mismatch: required \'"+nonNullArrayOf("Object")+"\' but the provided value is null\n" +
			"----------\n" +
			"3. ERROR in X.java (at line 21)\n" +
			"	this.new Y(2, (Object[])null);\n" +
			"	              ^^^^^^^^^^^^^^\n" +
			"Null type mismatch: required \'"+nonNullArrayOf("Object")+"\' but the provided value is null\n" +
			"----------\n",
		this.LIBS,
		true /* shouldFlush*/);
}
// Bug 367203 - [compiler][null] detect assigning null to nonnull argument
public void test_nonnull_argument_001() {
	runNegativeTestWithLibs(
			new String[] {
				"ShowNPE2.java",
				"import org.eclipse.jdt.annotation.NonNullByDefault;\n" + 
				"@NonNullByDefault\n" + 
				"public class ShowNPE2 {\n" + 
				"     public Object foo(Object o1, final boolean b) {\n" + 
				"         o1 = null;   // expect NPE error\n" + 
				"         System.out.println(o1.toString());   \n" + 
				"         return null;  // expect NPE error\n" + 
				"    }\n" + 
				"}"
			},
			"----------\n" + 
			"1. ERROR in ShowNPE2.java (at line 5)\n" + 
			"	o1 = null;   // expect NPE error\n" + 
			"	     ^^^^\n" + 
			"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
			"----------\n" + 
			"2. ERROR in ShowNPE2.java (at line 7)\n" + 
			"	return null;  // expect NPE error\n" + 
			"	       ^^^^\n" + 
			"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
			"----------\n");
}
// Bug 367203 - [compiler][null] detect assigning null to nonnull argument
public void test_nonnull_argument_002() {
	runNegativeTestWithLibs(
			new String[] {
				"ShowNPE2.java",
				"import org.eclipse.jdt.annotation.NonNullByDefault;\n" + 
				"@NonNullByDefault\n" + 
				"public class ShowNPE2 {\n" + 
				"    public Object foo(Object o1, final boolean b) {\n" + 
				"        bar(o1); // expecting no problem\n" + 
				"        return null;  // expect NPE error\n" + 
				"    }\n" +
				"    void bar(Object o2) {}\n" + 
				"}"
			},
			"----------\n" + 
			"1. ERROR in ShowNPE2.java (at line 6)\n" + 
			"	return null;  // expect NPE error\n" + 
			"	       ^^^^\n" + 
			"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
			"----------\n");
}
// a method of a local class has a non-null parameter, client passes potential null (msg send)
public void test_nonnull_parameter_014() {
	runNegativeTestWithLibs(
		new String[] {
			"B.java",
			"class B {\n" +
			"    void bar () {\n" +
			"        class Local {\n" +
			"            void callMe(@org.eclipse.jdt.annotation.NonNull Object o){\n" +
			"            }\n" +
			"        }\n" +
			"        Local l = new Local();\n" +
			"        l.callMe(getNull());\n" +
			"    }\n" +
			"    @org.eclipse.jdt.annotation.Nullable Object getNull() { return null; }" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in B.java (at line 8)\n" + 
		"	l.callMe(getNull());\n" + 
		"	         ^^^^^^^^^\n" +
		mismatch_NonNull_Nullable("Object") +
		"----------\n");
}
// assigning potential null to a nonnull local variable
public void test_nonnull_local_001() {
	runNegativeTest(
		new String[] {
			"X.java",
			  "import org.eclipse.jdt.annotation.*;\n" +
			  "public class X {\n" +
			  "    void foo(boolean b, Object p) {\n" +
			  "        @NonNull Object o1 = b ? null : new Object();\n" +
			  "        @NonNull String o2 = \"\";\n" +
			  "        o2 = null;\n" +
			  "        @NonNull Object o3 = p;\n" +
			  "    }\n" +
			  "}\n"},
		"----------\n" +
		"1. ERROR in X.java (at line 4)\n" +
		"	@NonNull Object o1 = b ? null : new Object();\n" +
		(this.complianceLevel < ClassFileConstants.JDK1_8 ?
		"	                     ^^^^^^^^^^^^^^^^^^^^^^^\n" +
		"Null type mismatch: required \'@NonNull Object\' but the provided value is inferred as @Nullable\n"
		:
		"	                         ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n") + 
		"----------\n" +
		"2. ERROR in X.java (at line 6)\n" +
		"	o2 = null;\n" +
		"	     ^^^^\n" +
		"Null type mismatch: required \'@NonNull String\' but the provided value is null\n" +
		"----------\n" +
		"3. WARNING in X.java (at line 7)\n" +
		"	@NonNull Object o3 = p;\n" +
		"	                     ^\n" +
		nullTypeSafety() + "The expression of type 'Object' needs unchecked conversion to conform to \'@NonNull Object\'\n" +
		"----------\n",
		this.LIBS,
		true /* shouldFlush*/);
}

// assigning potential null to a nonnull local variable - separate decl and assignment
public void test_nonnull_local_002() {
	runNegativeTest(
		new String[] {
			"X.java",
			  "import org.eclipse.jdt.annotation.*;\n" +
			  "public class X {\n" +
			  "    void foo(boolean b, Object p) {\n" +
			  "        @NonNull Object o1;\n" +
			  "        o1 = b ? null : new Object();\n" +
			  "        @NonNull String o2;\n" +
			  "        o2 = \"\";\n" +
			  "        o2 = null;\n" +
			  "        @NonNull Object o3;\n" +
			  "        o3 = p;\n" +
			  "    }\n" +
			  "}\n"},
		"----------\n" +
		"1. ERROR in X.java (at line 5)\n" +
		"	o1 = b ? null : new Object();\n" +
		(this.complianceLevel < ClassFileConstants.JDK1_8 ?
		"	     ^^^^^^^^^^^^^^^^^^^^^^^\n" +
		"Null type mismatch: required \'@NonNull Object\' but the provided value is inferred as @Nullable\n"
		:
		"	         ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n") + 
		"----------\n" +
		"2. ERROR in X.java (at line 8)\n" +
		"	o2 = null;\n" +
		"	     ^^^^\n" +
		"Null type mismatch: required \'@NonNull String\' but the provided value is null\n" +
		"----------\n" +
		"3. WARNING in X.java (at line 10)\n" +
		"	o3 = p;\n" +
		"	     ^\n" +
		nullTypeSafety() + "The expression of type 'Object' needs unchecked conversion to conform to \'@NonNull Object\'\n" +
		"----------\n",
		this.LIBS,
		true /* shouldFlush*/);
}

// a method tries to tighten the type specification, super declares parameter o as @Nullable
// other parameters: s is redefined from not constrained to @Nullable which is OK
//                   third is redefined from not constrained to @NonNull which is bad, too
public void test_parameter_specification_inheritance_001() {
	runConformTestWithLibs(
		new String[] {
			"Lib.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Lib {\n" +
			"    void foo(String s, @Nullable Object o, Object third) { }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
	runNegativeTestWithLibs(
		false, // don't flush
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X extends Lib {\n" +
			"    @Override\n" +
			"    void foo(@Nullable String s, @NonNull Object o, @NonNull Object third) { System.out.print(o.toString()); }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" +
		"1. ERROR in X.java (at line 4)\n" +
		"	void foo(@Nullable String s, @NonNull Object o, @NonNull Object third) { System.out.print(o.toString()); }\n" +
		"	                             ^^^^^^^^^^^^^^^\n" +
		"Illegal redefinition of parameter o, inherited method from Lib declares this parameter as @Nullable\n" +
		"----------\n" +
		"2. ERROR in X.java (at line 4)\n" +
		"	void foo(@Nullable String s, @NonNull Object o, @NonNull Object third) { System.out.print(o.toString()); }\n" +
		"	                                                ^^^^^^^^^^^^^^^\n" +
		"Illegal redefinition of parameter third, inherited method from Lib does not constrain this parameter\n" +
		"----------\n");
}
// a method body fails to redeclare the inherited null annotation, super declares parameter as @Nullable
public void test_parameter_specification_inheritance_002() {
	runConformTest(
		new String[] {
			"Lib.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Lib {\n" +
			"    void foo(@Nullable Object o) { }\n" +
			"}\n"
		},
		"",
	    this.LIBS,
	    false/*shouldFlush*/,
	    null/*vmArgs*/,
	    null /*customOtions*/,
	    null /*clientRequester*/,
	    false/*skipJavac*/,
	    JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
	runNegativeTestWithLibs(
		false, // don't flush
		new String[] {
			"X.java",
			"public class X extends Lib {\n" +
			"    @Override\n" +
			"    void foo(Object o) {\n" +
			"        System.out.print(o.toString());\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" +
		"1. ERROR in X.java (at line 3)\n" +
		"	void foo(Object o) {\n" +
		"	         ^^^^^^\n" +
		"Missing nullable annotation: inherited method from Lib specifies this parameter as @Nullable\n" +
		"----------\n");
}
// a method relaxes the parameter null specification, super interface declares parameter o as @NonNull
// other (first) parameter just repeats the inherited @NonNull
public void test_parameter_specification_inheritance_003() {
	runConformTest(
		new String[] {
			"IX.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public interface IX {\n" +
			"    void foo(@NonNull String s, @NonNull Object o);\n" +
			"}\n",
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X implements IX {\n" +
			"    public void foo(@NonNull String s, @Nullable Object o) { ; }\n" +
			"    void bar() { foo(\"OK\", null); }\n" +
			"}\n"
		},
		"",
	    this.LIBS,
	    false/*shouldFlush*/,
	    null/*vmArgs*/,
	    null /*customOptions*/,
	    null /*clientRequester*/,
	    false/*skipJavac*/,
	    JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}
// a method adds a @NonNull annotation, super interface has no null annotation
// changing other from unconstrained to @Nullable is OK
public void test_parameter_specification_inheritance_004() {
	runConformTestWithLibs(
		new String[] {
			"IX.java",
			"public interface IX {\n" +
			"    void foo(Object o, Object other);\n" +
			"}\n"
		},
		getCompilerOptions(),
		"");
	runNegativeTestWithLibs(
		false, // don't flush
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X implements IX {\n" +
			"    public void foo(@NonNull Object o, @Nullable Object other) { System.out.print(o.toString()); }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" +
		"1. ERROR in X.java (at line 3)\n" +
		"	public void foo(@NonNull Object o, @Nullable Object other) { System.out.print(o.toString()); }\n" +
		"	                ^^^^^^^^^^^^^^^\n" +
		"Illegal redefinition of parameter o, inherited method from IX does not constrain this parameter\n" +
		"----------\n");
}
// a method tries to relax the null contract, super declares @NonNull return
public void test_parameter_specification_inheritance_005() {
	runConformTestWithLibs(
		new String[] {
			"Lib.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Lib {\n" +
			"    @NonNull Object getObject() { return new Object(); }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
	runNegativeTestWithLibs(
		false, //dont' flush
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X extends Lib {\n" +
			"    @Override\n" +
			"    @Nullable Object getObject() { return null; }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" +
		"1. ERROR in X.java (at line 4)\n" +
		"	@Nullable Object getObject() { return null; }\n" +
		"	^^^^^^^^^^^^^^^^\n" +
		"The return type is incompatible with '@NonNull Object' returned from Lib.getObject() (mismatching null constraints)\n" +
		"----------\n");
}

// super has no constraint for return, sub method confirms the null contract as @Nullable
public void test_parameter_specification_inheritance_006() {
	runConformTestWithLibs(
		new String[] {
			"Lib.java",
			"public class Lib {\n" +
			"    Object getObject() { return null; }\n" +
			"}\n"
		},
		getCompilerOptions(),
		"");
	runConformTestWithLibs(
		false, // don't flush
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X extends Lib {\n" +
			"    @Override\n" +
			"    @Nullable Object getObject() { return null; }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
}
// a method body violates the inherited null specification, super declares @NonNull return, missing redeclaration
public void test_parameter_specification_inheritance_007() {
	runConformTestWithLibs(
		new String[] {
			"Lib.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Lib {\n" +
			"    @NonNull Object getObject() { return new Object(); }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
	runNegativeTestWithLibs(
		false, // don't flush
		new String[] {
			"X.java",
			"public class X extends Lib {\n" +
			"    @Override\n" +
			"    Object getObject() { return null; }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" +
		"1. ERROR in X.java (at line 3)\n" +
		"	Object getObject() { return null; }\n" +
		"	^^^^^^\n" +
		"The return type is incompatible with '@NonNull Object' returned from Lib.getObject() (mismatching null constraints)\n" +
		"----------\n");
}
//a method body violates the @NonNull return specification (repeated from super)
public void test_parameter_specification_inheritance_007a() {
	runConformTestWithLibs(
		new String[] {
			"Lib.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Lib {\n" +
			"    @NonNull Object getObject() { return new Object(); }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
	runNegativeTestWithLibs(
		false, // don't flush
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X extends Lib {\n" +
			"    @Override\n" +
			"    @NonNull Object getObject() { return null; }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" +
		"1. ERROR in X.java (at line 4)\n" +
		"	@NonNull Object getObject() { return null; }\n" +
		"	                                     ^^^^\n" +
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" +
		"----------\n");
}
// a client potentially violates the inherited null specification, super interface declares @NonNull parameter
public void test_parameter_specification_inheritance_008() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_NULL_UNCHECKED_CONVERSION, JavaCore.ERROR);
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    void printObject(@NonNull Object o) { System.out.print(o.toString()); }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
	runNegativeTestWithLibs(
		false, // don't flush
		new String[] {
			"XSub.java",
			"public class XSub extends X {\n" +
			"    @Override\n" +
			"    public void printObject(Object o) { super.printObject(o); }\n" +
			"}\n",
			"M.java",
			"public class M{\n" +
			"    void foo(X x, Object o) {\n" +
			"        x.printObject(o);\n" +
			"    }\n" +
			"}\n"
		},
		options,
		"----------\n" +
		"1. WARNING in XSub.java (at line 3)\n" + 
		"	public void printObject(Object o) { super.printObject(o); }\n" + 
		"	                        ^^^^^^\n" + 
		"Missing non-null annotation: inherited method from X specifies this parameter as @NonNull\n" + 
		"----------\n" + 
		"2. ERROR in XSub.java (at line 3)\n" +
		"	public void printObject(Object o) { super.printObject(o); }\n" +
		"	                                                      ^\n" +
		nullTypeSafety() + "The expression of type 'Object' needs unchecked conversion to conform to \'@NonNull Object\'\n" +
		"----------\n" +
		"----------\n" +
		"1. ERROR in M.java (at line 3)\n" +
		"	x.printObject(o);\n" +
		"	              ^\n" +
		nullTypeSafety() + "The expression of type 'Object' needs unchecked conversion to conform to \'@NonNull Object\'\n" +
		"----------\n");
}
// a static method has a more relaxed null contract than a like method in the super class, but no overriding.
public void test_parameter_specification_inheritance_009() {
	runConformTestWithLibs(
		new String[] {
			"Lib.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Lib {\n" +
			"    @NonNull static Object getObject() { return new Object(); }\n" +
			"}\n",
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X extends Lib {\n" +
			"    @Nullable static Object getObject() { return null; }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
}
// class default is nonnull, method and its super both use the default
public void test_parameter_specification_inheritance_010() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_NULL_UNCHECKED_CONVERSION, JavaCore.ERROR);
	runConformTestWithLibs(
		new String[] {
	"p1/X.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    protected String getString(String s) {\n" +
			"        if (Character.isLowerCase(s.charAt(0)))\n" +
			"	        return getString(s);\n" +
			"	     return s;\n" +
			"    }\n" +
			"}\n",
	"p1/Y.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class Y extends X {\n" +
			"    @Override\n" +
			"    protected String getString(String s) {\n" +
			"	     return super.getString(s);\n" +
			"    }\n" +
			"}\n",
		},
		customOptions,
		"");
}
// class default is nonnull, method and its super both use the default, super-call passes null
public void test_parameter_specification_inheritance_011() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_NULL_UNCHECKED_CONVERSION, JavaCore.ERROR);
	runNegativeTestWithLibs(
		new String[] {
	"p1/X.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    protected String getString(String s) {\n" +
			"        if (Character.isLowerCase(s.charAt(0)))\n" +
			"	        return getString(s);\n" +
			"	     return s;\n" +
			"    }\n" +
			"}\n",
	"p1/Y.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class Y extends X {\n" +
			"    @Override\n" +
			"    protected String getString(String s) {\n" +
			"	     return super.getString(null);\n" +
			"    }\n" +
			"}\n",
		},
		customOptions,
		"----------\n" +
		"1. ERROR in p1\\Y.java (at line 7)\n" +
		"	return super.getString(null);\n" +
		"	                       ^^^^\n" +
		"Null type mismatch: required \'@NonNull String\' but the provided value is null\n" +
		"----------\n");
}
// methods from two super types have different null contracts.
// sub-class merges both using the weakest common contract
public void test_parameter_specification_inheritance_012() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_NULL_UNCHECKED_CONVERSION, JavaCore.ERROR);
	runConformTestWithLibs(
		new String[] {
	"p1/X.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    public @Nullable String getString(String s1, @Nullable String s2, @NonNull String s3) {\n" +
			"	     return s1;\n" +
			"    }\n" +
			"}\n",
	"p1/IY.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public interface IY {\n" +
			"    @NonNull String getString(@NonNull String s1, @NonNull String s2, @Nullable String s3);\n" +
			"}\n",
	"p1/Y.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Y extends X implements IY {\n" +
			"    @Override\n" +
			"    public @NonNull String getString(@Nullable String s1, @Nullable String s2, @Nullable String s3) {\n" +
			"	     return \"\";\n" +
			"    }\n" +
			"}\n",
		},
		customOptions,
		"");
}
// methods from two super types have different null contracts.
// sub-class overrides this method in non-conforming ways
public void test_parameter_specification_inheritance_013() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_NULL_UNCHECKED_CONVERSION, JavaCore.ERROR);
	customOptions.put(JavaCore.COMPILER_PB_NONNULL_PARAMETER_ANNOTATION_DROPPED, JavaCore.IGNORE);
	runNegativeTestWithLibs(
		new String[] {
	"p1/X.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    public @Nullable String getString(String s1, @Nullable String s2, @NonNull String s3) {\n" +
			"	     return s1;\n" +
			"    }\n" +
			"}\n",
	"p1/IY.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public interface IY {\n" +
			"    @NonNull String getString(@NonNull String s1, @NonNull String s2, @Nullable String s3);\n" +
			"}\n",
	"p1/Y.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Y extends X implements IY {\n" +
			"    @Override\n" +
			"    public @Nullable String getString(String s1, @NonNull String s2, @NonNull String s3) {\n" +
			"	     return \"\";\n" +
			"    }\n" +
			"}\n",
		},
		customOptions,
		"----------\n" +
		"1. ERROR in p1\\Y.java (at line 5)\n" +
		"	public @Nullable String getString(String s1, @NonNull String s2, @NonNull String s3) {\n" +
		"	       ^^^^^^^^^^^^^^^^\n" +
		"The return type is incompatible with '@NonNull String' returned from IY.getString(String, String, String) (mismatching null constraints)\n" +
		// no problem regarding s1: widening @NonNull to unannotated
		"----------\n" +
		"2. ERROR in p1\\Y.java (at line 5)\n" +
		"	public @Nullable String getString(String s1, @NonNull String s2, @NonNull String s3) {\n" +
		"	                                             ^^^^^^^^^^^^^^^\n" +
		"Illegal redefinition of parameter s2, inherited method from X declares this parameter as @Nullable\n" +
		"----------\n" +
		"3. ERROR in p1\\Y.java (at line 5)\n" +
		"	public @Nullable String getString(String s1, @NonNull String s2, @NonNull String s3) {\n" +
		"	                                                                 ^^^^^^^^^^^^^^^\n" +
		"Illegal redefinition of parameter s3, inherited method from IY declares this parameter as @Nullable\n" +
		"----------\n");
}
// methods from two super types have different null contracts.
// sub-class does not override, but should to bridge the incompatibility
public void test_parameter_specification_inheritance_014() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_NULL_UNCHECKED_CONVERSION, JavaCore.ERROR);
	runNegativeTestWithLibs(
		new String[] {
	"p1/IY.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public interface IY {\n" +
			"    public @NonNull String getString1(String s);\n" +
			"    public @NonNull String getString2(String s);\n" +
			"    public String getString3(@Nullable String s);\n" +
			"    public @NonNull String getString4(@Nullable String s);\n" +
			"    public @NonNull String getString5(@Nullable String s);\n" +
			"    public @Nullable String getString6(@NonNull String s);\n" +
			"}\n",
	"p1/X.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    public @Nullable String getString1(String s) {\n" + // incomp. return
			"	     return s;\n" +
			"    }\n" +
			"    public String getString2(String s) {\n" +			 // incomp. return
			"	     return s;\n" +
			"    }\n" +
			"    public String getString3(String s) {\n" +			 // incomp. arg
			"	     return \"\";\n" +
			"    }\n" +
			"    public @NonNull String getString4(@Nullable String s) {\n" +
			"	     return \"\";\n" +
			"    }\n" +
			"    public @NonNull String getString5(@NonNull String s) {\n" + // incomp. arg
			"	     return s;\n" +
			"    }\n" +
			"    public @NonNull String getString6(@Nullable String s) {\n" +
			"	     return \"\";\n" +
			"    }\n" +
			"}\n",
	"p1/Y.java",
			"package p1;\n" +
			"public class Y extends X implements IY {\n" +
			"}\n",
		},
		customOptions,
		(this.complianceLevel < ClassFileConstants.JDK1_8 ?
		"----------\n" +
		"1. ERROR in p1\\Y.java (at line 2)\n" +
		"	public class Y extends X implements IY {\n" +
		"	             ^\n" +
		"The method getString1(String) from X cannot implement the corresponding method from IY due to incompatible nullness constraints\n" +
		"----------\n" +
		"2. ERROR in p1\\Y.java (at line 2)\n" +
		"	public class Y extends X implements IY {\n" +
		"	             ^\n" +
		"The method getString2(String) from X cannot implement the corresponding method from IY due to incompatible nullness constraints\n" +
		"----------\n" +
		"3. ERROR in p1\\Y.java (at line 2)\n" +
		"	public class Y extends X implements IY {\n" +
		"	             ^\n" +
		"The method getString5(String) from X cannot implement the corresponding method from IY due to incompatible nullness constraints\n" +
		"----------\n" +
		"4. ERROR in p1\\Y.java (at line 2)\n" +
		"	public class Y extends X implements IY {\n" +
		"	             ^\n" +
		"The method getString3(String) from X cannot implement the corresponding method from IY due to incompatible nullness constraints\n" +
		"----------\n"
		: // at 1.8 we show null type annotations in the message:
		"----------\n" + 
		"1. ERROR in p1\\Y.java (at line 2)\n" + 
		"	public class Y extends X implements IY {\n" + 
		"	             ^\n" + 
		"The method @Nullable String getString1(String) from X cannot implement the corresponding method from IY due to incompatible nullness constraints\n" + 
		"----------\n" + 
		"2. ERROR in p1\\Y.java (at line 2)\n" + 
		"	public class Y extends X implements IY {\n" + 
		"	             ^\n" + 
		"The method String getString2(String) from X cannot implement the corresponding method from IY due to incompatible nullness constraints\n" + 
		"----------\n" + 
		"3. ERROR in p1\\Y.java (at line 2)\n" + 
		"	public class Y extends X implements IY {\n" + 
		"	             ^\n" + 
		"The method getString5(@NonNull String) from X cannot implement the corresponding method from IY due to incompatible nullness constraints\n" + 
		"----------\n" + 
		"4. ERROR in p1\\Y.java (at line 2)\n" + 
		"	public class Y extends X implements IY {\n" + 
		"	             ^\n" + 
		"The method getString3(String) from X cannot implement the corresponding method from IY due to incompatible nullness constraints\n" + 
		"----------\n"));
}
// a method relaxes the parameter null specification from @NonNull to un-annotated
// see https://bugs.eclipse.org/381443
public void test_parameter_specification_inheritance_015() {
	runConformTest(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    void foo(@NonNull String s) { System.out.println(s); }\n" +
			"}\n",
			"XSub.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class XSub extends X {\n" +
			"    public void foo(String s) { if (s != null) super.foo(s); }\n" +
			"    void bar() { foo(null); }\n" +
			"}\n"
		},
		"",
	    this.LIBS,
	    false/*shouldFlush*/,
	    null/*vmArgs*/,
	    null /*customOptions*/,
	    null /*clientRequester*/,
	    false/*skipJavac*/,
	    JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}

// a method relaxes the parameter null specification from @NonNull to un-annotated
// see https://bugs.eclipse.org/381443
// issue configured as error
public void test_parameter_specification_inheritance_016() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_NONNULL_PARAMETER_ANNOTATION_DROPPED, JavaCore.ERROR);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    void foo(@NonNull String s) { System.out.println(s); }\n" +
			"}\n",
			"XSub.java",
			"public class XSub extends X {\n" +
			"    @Override\n" +
			"    public void foo(String s) { if (s != null) super.foo(s); }\n" +
			"    void bar() { foo(null); }\n" +
			"}\n"
		},
		options,
		"----------\n" +
		"1. ERROR in XSub.java (at line 3)\n" +
		"	public void foo(String s) { if (s != null) super.foo(s); }\n" +
		"	                ^^^^^^\n" +
		"Missing non-null annotation: inherited method from X specifies this parameter as @NonNull\n" +
		"----------\n");
}

// a class inherits two methods with different spec: one non-null param & one unannotated param
// widening reported as warning by default
// see https://bugs.eclipse.org/381443
public void test_parameter_specification_inheritance_017() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"public class X {\n" +
			"    public void foo(String s) { System.out.println(s); }\n" +
			"}\n",
			"IX.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public interface IX {\n" +
			"    void foo(@NonNull String s);\n" +
			"}\n",
			"XSub.java",
			"public class XSub extends X implements IX {\n" +
			"    void bar() { foo(null); }\n" +
			"    static void zork(XSub sub) {\n" +
			"        sub.foo(null);\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. WARNING in XSub.java (at line 1)\n" + 
		"	public class XSub extends X implements IX {\n" + 
		"	             ^^^^\n" + 
		"Missing non-null annotation: inherited method from IX specifies this parameter as @NonNull\n" + 
		"----------\n");
}

// a class inherits two methods with different spec: one non-null param & one unannotated param
// opt to accept this widening
// see https://bugs.eclipse.org/381443
public void test_parameter_specification_inheritance_018() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_NONNULL_PARAMETER_ANNOTATION_DROPPED, JavaCore.IGNORE);
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"public class X {\n" +
			"    public void foo(String s) { System.out.println(s); }\n" +
			"}\n",
			"IX.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public interface IX {\n" +
			"    void foo(@NonNull String s);\n" +
			"}\n",
			"XSub.java",
			"public class XSub extends X implements IX {\n" +
			"    void bar() { foo(null); }\n" +
			"    static void zork(XSub sub) {\n" +
			"        sub.foo(null);\n" +
			"    }\n" +
			"}\n"
		},
		options,
		"");
}

// a nullable return value is dereferenced without a check
public void test_nullable_return_001() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable Object getObject() { return null; }\n" +
			"    void foo() {\n" +
			"        Object o = getObject();\n" +
			"        System.out.print(o.toString());\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" +
		"1. ERROR in X.java (at line 6)\n" +
		"	System.out.print(o.toString());\n" +
		"	                 ^\n" +
		"Potential null pointer access: The variable o may be null at this location\n" +
		"----------\n");
}
// a nullable return value is dereferenced without a check, method is read from .class file
public void test_nullable_return_002() {
	runConformTestWithLibs(
		new String[] {
			"Lib.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Lib {\n" +
			"    @Nullable Object getObject() { return null; }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
	runNegativeTestWithLibs(
		false, // don't flush
		new String[] {
			"X.java",
			"public class X {\n" +
			"    void foo(Lib l) {\n" +
			"        Object o = l.getObject();\n" +
			"        System.out.print(o.toString());\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" +
		"1. ERROR in X.java (at line 4)\n" +
		"	System.out.print(o.toString());\n" +
		"	                 ^\n" +
		"Potential null pointer access: The variable o may be null at this location\n" +
		"----------\n");
}
// a non-null return value is checked for null, method is read from .class file
public void test_nonnull_return_001() {
	runConformTestWithLibs(
		new String[] {
			"Lib.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Lib {\n" +
			"    @NonNull Object getObject() { return new Object(); }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
	runNegativeTestWithLibs(
		false, // don't flush
		new String[] {
			"X.java",
			"public class X {\n" +
			"    void foo(Lib l) {\n" +
			"        Object o = l.getObject();\n" +
			"        if (o != null)\n" +
			"            System.out.print(o.toString());\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" +
		"1. ERROR in X.java (at line 4)\n" +
		"	if (o != null)\n" +
		"	    ^\n" +
		"Redundant null check: The variable o cannot be null at this location\n" + // no immediate type annotation
		"----------\n");
}
// a non-null method returns null
public void test_nonnull_return_003() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @NonNull Object getObject(boolean b) {\n" +
			"        if (b)\n" +
			"            return null;\n" + // definite specification violation despite enclosing "if"
			"        return new Object();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" +
		"1. ERROR in X.java (at line 5)\n" +
		"	return null;\n" +
		"	       ^^^^\n" +
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" +
		"----------\n");
}
// a non-null method potentially returns null
public void test_nonnull_return_004() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @NonNull Object getObject(@Nullable Object o) {\n" +
			"        return o;\n" + // 'o' is only potentially null
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" +
		"1. ERROR in X.java (at line 4)\n" +
		"	return o;\n" +
		"	       ^\n" +
		mismatch_NonNull_Nullable("Object") +
		"----------\n");
}
// a non-null method returns its non-null argument
public void test_nonnull_return_005() {
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @NonNull Object getObject(@NonNull Object o) {\n" +
			"        return o;\n" +
			"    }\n" +
			"}\n"
		},
		null, // options
		"");
}
//a non-null method has insufficient nullness info for its return value
public void test_nonnull_return_006() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @NonNull Object getObject(Object o) {\n" +
			"        return o;\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" +
		"1. WARNING in X.java (at line 4)\n" +
		"	return o;\n" +
		"	       ^\n" +
		nullTypeSafety() + "The expression of type 'Object' needs unchecked conversion to conform to \'@NonNull Object\'\n" +
		"----------\n");
}
// a result from a nullable method is directly dereferenced
public void test_nonnull_return_007() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable Object getObject() {\n" +
			"        return null;\n" +
			"    }\n" +
			"    void test() {\n" +
			"        getObject().toString();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" +
		"1. ERROR in X.java (at line 7)\n" +
		"	getObject().toString();\n" +
		"	^^^^^^^^^^^\n" +
		"Potential null pointer access: The method getObject() may return null\n" +
		"----------\n");
}
// a result from a nonnull method is directly checked for null: redundant
public void test_nonnull_return_008() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK, JavaCore.ERROR);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @NonNull Object getObject() {\n" +
			"        return new Object();\n" +
			"    }\n" +
			"    void test() {\n" +
			"        if (getObject() == null)\n" +
			"		     throw new RuntimeException();\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"----------\n" +
		"1. ERROR in X.java (at line 7)\n" +
		"	if (getObject() == null)\n" +
		"	    ^^^^^^^^^^^\n" +
		checkAlwaysFalse_method_cannot_return_null("getObject()", "Object") +
		"----------\n" + 
		"2. WARNING in X.java (at line 8)\n" + 
		"	throw new RuntimeException();\n" + 
		"	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Dead code\n" + 
		"----------\n");
}
// a result from a nonnull method is directly checked for null (from local): redundant
public void test_nonnull_return_009() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK, JavaCore.ERROR);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @NonNull Object getObject() {\n" +
			"        return new Object();\n" +
			"    }\n" +
			"    void test() {\n" +
			"        Object left = null;\n" +
			"        if (left != getObject())\n" +
			"		     throw new RuntimeException();\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"----------\n" +
		"1. ERROR in X.java (at line 8)\n" +
		"	if (left != getObject())\n" +
		"	    ^^^^\n" +
		"Redundant null check: The variable left can only be null at this location\n" +
		"----------\n" +
		"2. ERROR in X.java (at line 8)\n" +
		"	if (left != getObject())\n" +
		"	            ^^^^^^^^^^^\n" +
		redundantCheck_method_cannot_return_null("getObject()", "Object") +
		"----------\n");
}
// a result from a nonnull method is directly checked for null (from local): not redundant due to loop
public void test_nonnull_return_009a() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK, JavaCore.ERROR);
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @NonNull Object getObject() {\n" +
			"        return new Object();\n" +
			"    }\n" +
			"    void test() {\n" +
			"        Object left = null;\n" +
			"        for (int i=0; i<3; i++) {\n" +
			"            if (left != getObject())\n" +
			"	    	     throw new RuntimeException();\n" +
			"            left = new Object();\n" +
			"        }\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"");
}
// a result from a nonnull method is directly checked for null (from local): redundant despite loop
// disabled because only one of two desirable errors is raised
// need to integrate @NonNull expressions (MessageSend and more) into deferred analysis by FlowContext
public void _test_nonnull_return_009b() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK, JavaCore.ERROR);
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @NonNull Object getObject() {\n" +
			"        return new Object();\n" +
			"    }\n" +
			"    void test() {\n" +
			"        Object left = null;\n" +
			"        for (int i=0; i<3; i++) {\n" +
			"            if (left != getObject())\n" +
			"	    	     throw new RuntimeException();\n" +
			"            // left remains null\n" +
			"        }\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"----------\n" +
		"1. ERROR in X.java (at line 9)\n" +
		"	if (left != getObject())\n" +
		"	    ^^^^\n" +
		redundant_check_canonlynull("The variable left", "Object") +
		"----------\n" +
		"2. ERROR in X.java (at line 9)\n" +
		"	if (left != getObject())\n" +
		"	            ^^^^^^^^^^^\n" +
		"Redundant null check: The method getObject() cannot return null\n" +
		"----------\n");
}
// a result from a nullable method is assigned and checked for null (from local): not redundant
// see also Bug 336428 - [compiler][null] bogus warning "redundant null check" in condition of do {} while() loop
public void test_nonnull_return_010() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK, JavaCore.ERROR);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable X getX() {\n" +
			"        return new X();\n" +
			"    }\n" +
			"    void test() {\n" +
			"        X left = this;\n" +
			"        do {\n" +
			"            if (left == null) \n" +
			"	   	         throw new RuntimeException();\n" +
			"        } while ((left = left.getX()) != null);\n" + // no warning/error here!
			"    }\n" +
			"}\n"
		},
		customOptions,
		"----------\n" +
		"1. ERROR in X.java (at line 9)\n" +
		"	if (left == null) \n" +
		"	    ^^^^\n" +
		"Null comparison always yields false: The variable left cannot be null at this location\n" +
		"----------\n");
}
// a non-null method returns a checked-for null value, but that branch is dead code
public void test_nonnull_return_011() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_NULL_UNCHECKED_CONVERSION, JavaCore.ERROR);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    Object getObject(Object dubious) {\n" +
			"        if (dubious == null)\n" + // redundant
			"            return dubious;\n" + // definitely null, but not reported inside dead code
			"        return new Object();\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"----------\n" +
		"1. ERROR in X.java (at line 5)\n" +
		"	if (dubious == null)\n" +
		"	    ^^^^^^^\n" +
		((this.complianceLevel < ClassFileConstants.JDK1_8)
			? "Null comparison always yields false: The variable dubious is specified as @NonNull\n"
			: "Redundant null check: comparing '@NonNull Object' against null\n" ) +
		"----------\n" +
		"2. WARNING in X.java (at line 6)\n" +
		"	return dubious;\n" +
		"	^^^^^^^^^^^^^^^\n" +
		"Dead code\n" +
		"----------\n");
}
// a non-null method returns a definite null from a conditional expression
// requires the fix for Bug 354554 - [null] conditional with redundant condition yields weak error message
// TODO(SH): ENABLE!
public void _test_nonnull_return_012() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_NULL_UNCHECKED_CONVERSION, JavaCore.ERROR);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    Object getObject(Object dubious) {\n" +
			"        return dubious == null ? dubious : null;\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"----------\n" +
		"1. ERROR in X.java (at line 5)\n" +
		"	return dubious == null ? dubious : null;\n" +
		"	       ^^^^^^^\n" +
		"Null comparison always yields false: The variable dubious cannot be null at this location\n" +
		"----------\n" +
		"2. ERROR in X.java (at line 5)\n" +
		"	return dubious == null ? dubious : null;\n" +
		"	       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" +
		"----------\n");
}
// don't apply any default annotations to return void
public void test_nonnull_return_013() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_NULL_UNCHECKED_CONVERSION, JavaCore.ERROR);
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    void getObject() {}\n" +
			"}\n",
			"Y.java",
			"public class Y extends X {\n" +
			"    @Override\n" +
			"    void getObject() {}\n" + // don't complain, void takes no (default) annotation
			"}\n"
		},
		customOptions,
		"");
}
// bug 365835: [compiler][null] inconsistent error reporting.
public void test_nonnull_return_014() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.NonNull;\n" + 
			"\n" + 
			"public class X {\n" + 
			"	@NonNull\n" + 
			"	public Object foo(Object x, int y) {\n" + 
			"		@NonNull Object local;\n" + 
			"		while (true) {\n" + 
			"			if (y == 4) {\n" + 
			"				local = x;  // error\n" + 
			"				return x;   // only a warning.\n" + 
			"			}\n" + 
			"			x = null;\n" + 
			"		}\n" + 
			"	}\n" + 
			"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 9)\n" + 
		"	local = x;  // error\n" + 
		"	        ^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is inferred as @Nullable\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 10)\n" + 
		"	return x;   // only a warning.\n" + 
		"	       ^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is inferred as @Nullable\n" + 
		"----------\n");
}
// suppress an error regarding null-spec violation
public void test_suppress_001() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_SUPPRESS_OPTIONAL_ERRORS, JavaCore.ENABLED);
	runConformTestWithLibs(
			new String[] {
				"X.java",
				"import org.eclipse.jdt.annotation.*;\n" +
				"public class X {\n" +
				"    @SuppressWarnings(\"null\")\n" +
				"    @NonNull Object getObject(@Nullable Object o) {\n" +
				"        return o;\n" + // 'o' is only potentially null
				"    }\n" +
				"}\n"
			},
			customOptions,
			"");
}
// mixed use of fully qualified name / explicit import
public void test_annotation_import_001() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_NULLABLE_ANNOTATION_NAME, "org.foo.Nullable");
	customOptions.put(JavaCore.COMPILER_NONNULL_ANNOTATION_NAME, "org.foo.NonNull");
	runConformTestWithLibs(
		new String[] {
			CUSTOM_NULLABLE_NAME,
			CUSTOM_NULLABLE_CONTENT,
			CUSTOM_NONNULL_NAME,
			CUSTOM_NONNULL_CONTENT,
			"Lib.java",
			"public class Lib {\n" +
			"    @org.foo.NonNull Object getObject() { return new Object(); }\n" + 	// FQN
			"}\n",
			"X.java",
			"import org.foo.NonNull;\n" +											// explicit import
			"public class X {\n" +
			"    @NonNull Object getObject(@NonNull Lib l) {\n" +
			"        return l.getObject();\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"");
}

// use of explicit imports throughout
public void test_annotation_import_002() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_NULLABLE_ANNOTATION_NAME, "org.foo.Nullable");
	customOptions.put(JavaCore.COMPILER_NONNULL_ANNOTATION_NAME, "org.foo.NonNull");
	runConformTest(
		new String[] {
			CUSTOM_NULLABLE_NAME,
			CUSTOM_NULLABLE_CONTENT,
			CUSTOM_NONNULL_NAME,
			CUSTOM_NONNULL_CONTENT,
			"Lib.java",
			"import org.foo.NonNull;\n" +
			"public class Lib {\n" +
			"    @NonNull Object getObject() { return new Object(); }\n" +
			"}\n",
			"X.java",
			"import org.foo.NonNull;\n" +
			"public class X {\n" +
			"    @NonNull Object getObject(@org.foo.Nullable String dummy, @NonNull Lib l) {\n" +
			"        Object o = l.getObject();" +
			"        return o;\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"");
}
// explicit import of existing annotation types
// using a Lib without null specifications
public void test_annotation_import_005() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_NULL_UNCHECKED_CONVERSION, JavaCore.ERROR);
	customOptions.put(JavaCore.COMPILER_NULLABLE_ANNOTATION_NAME, "org.foo.MayBeNull");
	customOptions.put(JavaCore.COMPILER_NONNULL_ANNOTATION_NAME, "org.foo.MustNotBeNull");
	runNegativeTest(
		true/*shouldFlushOutputDirectory*/,
		new String[] {
			"org/foo/MayBeNull.java",
			"package org.foo;\n" +
			"import java.lang.annotation.*;\n" +
			"@Retention(RetentionPolicy.CLASS)\n" +
			targetTypeUseIfAvailable() +
			"public @interface MayBeNull {}\n",

			"org/foo/MustNotBeNull.java",
			"package org.foo;\n" +
			"import java.lang.annotation.*;\n" +
			"@Retention(RetentionPolicy.CLASS)\n" +
			targetTypeUseIfAvailable() +
			"public @interface MustNotBeNull {}\n",

			"Lib.java",
			"public class Lib {\n" +
			"    public Object getObject() { return new Object(); }\n" +
			"}\n",
			"X.java",
			"import org.foo.*;\n" +
			"public class X {\n" +
			"    @MustNotBeNull Object getObject(@MustNotBeNull Lib l) {\n" +
			"        return l.getObject();\n" +
			"    }\n" +
			"}\n",

		},
		null /*no libs*/,
		customOptions,
		"----------\n" +
		"1. ERROR in X.java (at line 4)\n" +
		"	return l.getObject();\n" +
		"	       ^^^^^^^^^^^^^\n" +
		nullTypeSafety() + "The expression of type 'Object' needs unchecked conversion to conform to \'@MustNotBeNull Object\'\n" +
		"----------\n",
		JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}
// a non-null method returns a value obtained from an unannotated method, missing annotation types
public void test_annotation_import_006() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_NULL_UNCHECKED_CONVERSION, JavaCore.ERROR);
	customOptions.put(JavaCore.COMPILER_NULLABLE_ANNOTATION_NAME, "org.foo.MayBeNull");
	customOptions.put(JavaCore.COMPILER_NONNULL_ANNOTATION_NAME, "org.foo.MustNotBeNull");
	runNegativeTest(
		true/*shouldFlushOutputDirectory*/,
		new String[] {
			"Lib.java",
			"public class Lib {\n" +
			"    Object getObject() { return new Object(); }\n" +
			"}\n",
			"X.java",
			"public class X {\n" +
			"    @MustNotBeNull Object getObject(@MustNotBeNull Lib l) {\n" +
			"        return l.getObject();\n" +
			"    }\n" +
			"}\n"
		},
		null /* no libs */,
		customOptions,
		"----------\n" +
		"1. ERROR in X.java (at line 2)\n" +
		"	@MustNotBeNull Object getObject(@MustNotBeNull Lib l) {\n" +
		"	 ^^^^^^^^^^^^^\n" +
		"MustNotBeNull cannot be resolved to a type\n" +
		"----------\n" +
		"2. ERROR in X.java (at line 2)\n" +
		"	@MustNotBeNull Object getObject(@MustNotBeNull Lib l) {\n" +
		"	                                 ^^^^^^^^^^^^^\n" +
		"MustNotBeNull cannot be resolved to a type\n" +
		"----------\n",
		JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}

// a null annotation is illegally used on a class:
public void test_illegal_annotation_001() {
	runNegativeTest(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNull public class X {\n" +
			"}\n"
		},
		"----------\n" +
		"1. ERROR in X.java (at line 2)\n" +
		"	@NonNull public class X {\n" +
		"	^^^^^^^^\n" +
		((this.complianceLevel < ClassFileConstants.JDK1_8)
		? "The annotation @NonNull is disallowed for this location\n"
		: "The nullness annotation 'NonNull' is not applicable at this location\n") +
		"----------\n",
		this.LIBS,
		false/*shouldFlush*/);
}
// this test has been removed:
// setting default to nullable, default applies to a parameter
// public void test_default_nullness_001()

// a null annotation is illegally defined by its simple name
// disabled because specific error is not currently raised
public void _test_illegal_annotation_002() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_NONNULL_ANNOTATION_NAME, "NichtNull");
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"public class X {\n" +
			"}\n"
		},
		customOptions,
		"----------\n" +
		"1. ERROR in X.java (at line 1)\n" +
		"	public class X {\n" +
		"	^\n" +
		"Cannot use the unqualified name \'NichtNull\' as an annotation name for null specification\n" +
		"----------\n");
}

// a null annotation is illegally used on a void method:
public void test_illegal_annotation_003() {
	runNegativeTest(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"	@NonNull void foo() {}\n" +
			"}\n"
		},
		"----------\n" +
		"1. ERROR in X.java (at line 3)\n" +
		"	@NonNull void foo() {}\n" +
		"	^^^^^^^^\n" + 
		((this.complianceLevel < ClassFileConstants.JDK1_8)
			? "The nullness annotation @NonNull is not applicable for the primitive type void\n"
			: "Type annotation is illegal for a method that returns void\n") +
		"----------\n",
		this.LIBS,
		false/*shouldFlush*/);
}

// a null annotation is illegally used on an int method:
public void test_illegal_annotation_003b() {
	runNegativeTest(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"	@NonNull int foo() { return 1; }\n" +
			"}\n"
		},
		"----------\n" +
		"1. ERROR in X.java (at line 3)\n" +
		"	@NonNull int foo() { return 1; }\n" +
		"	^^^^^^^^\n" + 
		"The nullness annotation @NonNull is not applicable for the primitive type int\n" +
		"----------\n",
		this.LIBS,
		false/*shouldFlush*/);
}

// a null annotation is illegally used on a primitive type parameter
public void test_illegal_annotation_004() {
	runNegativeTest(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"	void foo(@Nullable int i) {}\n" +
			"}\n"
		},
		"----------\n" +
		"1. ERROR in X.java (at line 3)\n" +
		"	void foo(@Nullable int i) {}\n" +
		"	         ^^^^^^^^^\n" +
		"The nullness annotation @Nullable is not applicable for the primitive type int\n" +
		"----------\n",
		this.LIBS,
		false/*shouldFlush*/);
}

// a null annotation is illegally used on a primitive type local var
public void test_illegal_annotation_005() {
	runNegativeTest(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"	int foo() {\n" +
			"       @Nullable int i = 3;\n" +
			"       return i;\n" +
			"   }\n" +
			"}\n"
		},
		"----------\n" +
		"1. ERROR in X.java (at line 4)\n" +
		"	@Nullable int i = 3;\n" +
		"	^^^^^^^^^\n" +
		"The nullness annotation @Nullable is not applicable for the primitive type int\n" +
		"----------\n",
		this.LIBS,
		false/*shouldFlush*/);
}

// a configured annotation type does not exist
// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=186342#c133
public void test_illegal_annotation_006() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_NULLABLE_ANNOTATION_NAME, "nullAnn.Nullable");
	runNegativeTestWithLibs(
		new String[] {
			"p/Test.java",
			"package p;\n" +
			"import nullAnn.*;  // 1 \n" +
			"\n" +
			"public class Test { \n" +
			"\n" +
			"        void foo(@nullAnn.Nullable  Object o) {   // 2\n" +
			"            o.toString();           \n" +
			"        }\n" +
			"}"
		},
		customOptions,
		"----------\n" +
		"1. ERROR in p\\Test.java (at line 2)\n" +
		"	import nullAnn.*;  // 1 \n" +
		"	       ^^^^^^^\n" +
		"The import nullAnn cannot be resolved\n" +
		"----------\n" +
		"2. ERROR in p\\Test.java (at line 6)\n" +
		"	void foo(@nullAnn.Nullable  Object o) {   // 2\n" +
		"	          ^^^^^^^\n" +
		"nullAnn cannot be resolved to a type\n" +
		"----------\n");
}

// a configured annotation type does not exist
// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=186342#c186
public void test_illegal_annotation_007() {
	Map customOptions = getCompilerOptions();
	runNegativeTestWithLibs(
		new String[] {
			"p/Test.java",
			"package p;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"interface TestInt{\n" +
			"	@NonNull Object foo();\n" +
			"}\n" +
			"\n" +
			"public class Test { \n" +
			"	void bar() {" +
			"		new TestInt() {\n" +
			"        	@org public Object foo() {\n" +
			"        	}\n" +
			"		};\n" +
			"	}\n" +
			"}"
		},
		customOptions,
		"----------\n" + 
		"1. ERROR in p\\Test.java (at line 9)\n" + 
		"	@org public Object foo() {\n" + 
		"	 ^^^\n" + 
		"org cannot be resolved to a type\n" + 
		"----------\n" + 
		"2. ERROR in p\\Test.java (at line 9)\n" + 
		"	@org public Object foo() {\n" + 
		"	            ^^^^^^\n" + 
		"The return type is incompatible with '@NonNull Object' returned from TestInt.foo() (mismatching null constraints)\n" + 
		"----------\n");
}

// a null annotation is illegally used on a constructor:
public void test_illegal_annotation_008() {
	runNegativeTest(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"	@NonNull X() {}\n" +
			"}\n"
		},
		"----------\n" +
		"1. ERROR in X.java (at line 3)\n" +
		"	@NonNull X() {}\n" +
		"	^^^^^^^^\n" +
		((this.complianceLevel < ClassFileConstants.JDK1_8)
		 ? "The annotation @NonNull is disallowed for this location\n"
		 : "The nullness annotation 'NonNull' is not applicable at this location\n" ) +
		"----------\n",
		this.LIBS,
		false/*shouldFlush*/);
}

public void test_default_nullness_002() {
	Map customOptions = getCompilerOptions();
//	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, JavaCore.ERROR);
// This option currently does nothing:
//	customOptions.put(JavaCore.COMPILER_NONNULL_IS_DEFAULT, JavaCore.ENABLED);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    Object getObject(@Nullable Object o) {\n" +
			"        return new Object();\n" +
			"    }\n" +
			"}\n",
			"Y.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class Y extends X {\n" +
			"    @Override\n" +
			"    @Nullable Object getObject(Object o) {\n" + // complain illegal return redef and inherited annot is not repeated
			"        return o;\n" +
			"    }\n" +
			"}\n",
		},
		customOptions,
		// main error:
		"----------\n" +
		"1. ERROR in Y.java (at line 5)\n" +
		"	@Nullable Object getObject(Object o) {\n" +
		"	^^^^^^^^^^^^^^^^\n" +
		"The return type is incompatible with '@NonNull Object' returned from X.getObject(Object) (mismatching null constraints)\n" +
		"----------\n" +
		// additional error:
		"2. ERROR in Y.java (at line 5)\n" +
		"	@Nullable Object getObject(Object o) {\n" +
		"	                           ^^^^^^\n" +
		"Illegal redefinition of parameter o, inherited method from X declares this parameter as @Nullable\n" +
		"----------\n");
}
// package default is non-null
public void test_default_nullness_003() {
	Map customOptions = getCompilerOptions();
//	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, JavaCore.ERROR);
	runNegativeTestWithLibs(
		new String[] {
	"p1/X.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    protected Object getObject(@Nullable Object o) {\n" +
			"        return new Object();\n" +
			"    }\n" +
			"}\n",
	"p2/package-info.java",
			"@org.eclipse.jdt.annotation.NonNullByDefault\n" +
			"package p2;\n",
	"p2/Y.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Y extends p1.X {\n" +
			"    @Override\n" +
			"    protected @Nullable Object getObject(@Nullable Object o) {\n" +
			"        bar(o);\n" +
			"        return o;\n" +
			"    }\n" +
			"	 void bar(Object o2) { }\n" + // parameter is nonnull per package default
			"}\n"
		},
		customOptions,
		"----------\n" +
		"1. ERROR in p2\\Y.java (at line 5)\n" +
		"	protected @Nullable Object getObject(@Nullable Object o) {\n" +
		"	          ^^^^^^^^^^^^^^^^\n" +
		"The return type is incompatible with '@NonNull Object' returned from X.getObject(Object) (mismatching null constraints)\n" +
		"----------\n" +
		"2. ERROR in p2\\Y.java (at line 6)\n" +
		"	bar(o);\n" +
		"	    ^\n" +
		mismatch_NonNull_Nullable("Object") +
		"----------\n");
}
// package level default is consumed from package-info.class, similarly for type level default
public void test_default_nullness_003a() {
	Map customOptions = getCompilerOptions();
//	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, JavaCore.ERROR);
	runConformTestWithLibs(
		new String[] {
	"p1/X.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    protected Object getObject(@Nullable Object o) {\n" +
			"        return new Object();\n" +
			"    }\n" +
			"	 protected void bar(Object o2) { }\n" + // parameter is nonnull per type default
			"}\n",
	"p2/package-info.java",
			"@org.eclipse.jdt.annotation.NonNullByDefault\n" +
			"package p2;\n",
			},
			customOptions,
			"");
	// check if default is visible from package-info.class.
	runNegativeTestWithLibs(
		false, // don't flush
		new String[] {
	"p2/Y.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Y extends p1.X {\n" +
			"    @Override\n" +
			"    protected @Nullable Object getObject(@Nullable Object o) {\n" + // can't override inherited default nonnull
			"        bar(o);\n" + // parameter is nonnull in super class's .class file
			"        accept(o);\n" +
			"        return o;\n" +
			"    }\n" +
			"    void accept(Object a) {}\n" + // governed by package level default
			"}\n"
		},
		customOptions,
		"----------\n" +
		"1. ERROR in p2\\Y.java (at line 5)\n" +
		"	protected @Nullable Object getObject(@Nullable Object o) {\n" +
		"	          ^^^^^^^^^^^^^^^^\n" +
		"The return type is incompatible with '@NonNull Object' returned from X.getObject(Object) (mismatching null constraints)\n" +
		"----------\n" +
		"2. ERROR in p2\\Y.java (at line 6)\n" +
		"	bar(o);\n" +
		"	    ^\n" +
		mismatch_NonNull_Nullable("Object") +
		"----------\n" +
		"3. ERROR in p2\\Y.java (at line 7)\n" +
		"	accept(o);\n" +
		"	       ^\n" +
		mismatch_NonNull_Nullable("Object") +
		"----------\n");
}
// same as test_default_nullness_003a, but default-induced annotations are combined with explicit ones (not null related)
public void test_default_nullness_003b() {
	Map customOptions = getCompilerOptions();
	runConformTestWithLibs(
		new String[] {
	"p1/Annot.java",
			"package p1;\n" +
			"import static java.lang.annotation.ElementType.*;\n" +
			"import java.lang.annotation.*;\n" +
			"@Retention(RetentionPolicy.CLASS)\n" +
			"@Target({METHOD,PARAMETER})\n" +
			"public @interface Annot {}\n",
	"p1/X.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    protected @Annot Object getObject(@Annot @Nullable Object o) {\n" +
			"        return new Object();\n" +
			"    }\n" +
			"	 protected @Annot void bar(@Annot Object o2) { }\n" + // parameter is nonnull per type default
			"}\n",
	"p2/package-info.java",
			"@org.eclipse.jdt.annotation.NonNullByDefault\n" +
			"package p2;\n",
			},
			customOptions,
			"");
	// check if default is visible from package-info.class.
	runNegativeTestWithLibs(
		false, // don't flush
		new String[] {
	"p2/Y.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Y extends p1.X {\n" +
			"    @Override\n" +
			"    protected @Nullable Object getObject(@Nullable Object o) {\n" + // can't override inherited default nonnull
			"        bar(o);\n" + // parameter is nonnull in super class's .class file
			"        accept(o);\n" +
			"        return o;\n" +
			"    }\n" +
			"    void accept(@p1.Annot Object a) {}\n" + // governed by package level default
			"}\n"
		},
		customOptions,
		"----------\n" +
		"1. ERROR in p2\\Y.java (at line 5)\n" +
		"	protected @Nullable Object getObject(@Nullable Object o) {\n" +
		"	          ^^^^^^^^^^^^^^^^\n" +
		"The return type is incompatible with '@NonNull Object' returned from X.getObject(Object) (mismatching null constraints)\n" +
		"----------\n" +
		"2. ERROR in p2\\Y.java (at line 6)\n" +
		"	bar(o);\n" +
		"	    ^\n" +
		mismatch_NonNull_Nullable("Object") +
		"----------\n" +
		"3. ERROR in p2\\Y.java (at line 7)\n" +
		"	accept(o);\n" +
		"	       ^\n" +
		mismatch_NonNull_Nullable("Object") +
		"----------\n");
}
// package level default is consumed from package-info.class, similarly for type level default - fine tuned default
public void test_default_nullness_003c() {
	if (this.complianceLevel < ClassFileConstants.JDK1_8) return; // uses version 2.0 of @NonNullByDefault
	Map customOptions = getCompilerOptions();
	runConformTestWithLibs(
		new String[] {
	"p1/X.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    protected Object getObject(@Nullable Object o) {\n" +
			"        return new Object();\n" +
			"    }\n" +
			"	 protected void bar(Object o2) { }\n" + // parameter is nonnull per type default
			"}\n",
	"p2/package-info.java",
			"@org.eclipse.jdt.annotation.NonNullByDefault({org.eclipse.jdt.annotation.DefaultLocation.PARAMETER})\n" +
			"package p2;\n",
			},
			customOptions,
			"");
	// check if default is visible from package-info.class.
	runNegativeTestWithLibs(
		false, // don't flush
		new String[] {
	"p2/Y.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Y extends p1.X {\n" +
			"    @Override\n" +
			"    protected @Nullable Object getObject(@Nullable Object o) {\n" + // can't override inherited default nonnull
			"        bar(o);\n" + // parameter is nonnull in super class's .class file
			"        @NonNull Object nno = accept(o); // 2xERR\n" +
			"        return o;\n" +
			"    }\n" +
			"    Object accept(Object a) { return a; }\n" + // governed by package level default (only the parameter!)
			"}\n"
		},
		customOptions,
		"----------\n" +
		"1. ERROR in p2\\Y.java (at line 5)\n" + 
		"	protected @Nullable Object getObject(@Nullable Object o) {\n" + 
		"	          ^^^^^^^^^^^^^^^^\n" + 
		"The return type is incompatible with '@NonNull Object' returned from X.getObject(Object) (mismatching null constraints)\n" + 
		"----------\n" + 
		"2. ERROR in p2\\Y.java (at line 6)\n" + 
		"	bar(o);\n" + 
		"	    ^\n" + 
		"Null type mismatch (type annotations): required \'@NonNull Object\' but this expression has type \'@Nullable Object\'\n" + 
		"----------\n" + 
		"3. WARNING in p2\\Y.java (at line 7)\n" + 
		"	@NonNull Object nno = accept(o); // 2xERR\n" + 
		"	                      ^^^^^^^^^\n" + 
		"Null type safety (type annotations): The expression of type \'Object\' needs unchecked conversion to conform to \'@NonNull Object\'\n" + 
		"----------\n" + 
		"4. ERROR in p2\\Y.java (at line 7)\n" + 
		"	@NonNull Object nno = accept(o); // 2xERR\n" + 
		"	                             ^\n" + 
		"Null type mismatch (type annotations): required \'@NonNull Object\' but this expression has type \'@Nullable Object\'\n" + 
		"----------\n");
}
// don't apply type-level default to non-reference type
public void test_default_nullness_004() {
	Map customOptions = getCompilerOptions();
//	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, JavaCore.ERROR);
	runConformTestWithLibs(
		new String[] {
	"p1/X.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    protected Object getObject(boolean o) {\n" +
			"        return new Object();\n" +
			"    }\n" +
			"}\n",
	"p2/Y.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Y extends p1.X {\n" +
			"    @Override\n" +
			"    protected @NonNull Object getObject(boolean o) {\n" +
			"        return o ? this : new Object();\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"");
}
// package default is non-null
// see also Bug 354536 - compiling package-info.java still depends on the order of compilation units
public void test_default_nullness_005() {
	Map customOptions = getCompilerOptions();
//	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, JavaCore.ERROR);
	customOptions.put(JavaCore.COMPILER_NONNULL_ANNOTATION_NAME, "org.foo.NonNull");
	customOptions.put(JavaCore.COMPILER_NULLABLE_ANNOTATION_NAME, "org.foo.Nullable");
	runNegativeTestWithLibs(
		new String[] {
	"p1/X.java",
			"package p1;\n" +
			"public class X {\n" +
			"    class Inner {" +
			"        protected Object getObject(String s) {\n" +
			"            return null;\n" +
			"        }\n" +
			"    }\n" +
			"}\n",
	"p1/package-info.java",
			"@org.eclipse.jdt.annotation.NonNullByDefault\n" +
			"package p1;\n",
	CUSTOM_NONNULL_NAME,
			CUSTOM_NONNULL_CONTENT,
	CUSTOM_NULLABLE_NAME,
			CUSTOM_NULLABLE_CONTENT
		},
		customOptions,
		"----------\n" +
		"1. ERROR in p1\\X.java (at line 4)\n" +
		"	return null;\n" +
		"	       ^^^^\n" +
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" +
		"----------\n");
}
// package default is non-null, package-info.java read before the annotation type
// compile order: beginToCompile(X.Inner) triggers reading of package-info.java before the annotation type was read
public void test_default_nullness_006() {
	Map customOptions = getCompilerOptions();
//	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, JavaCore.ERROR);
	customOptions.put(JavaCore.COMPILER_NONNULL_ANNOTATION_NAME, "org.foo.NonNull");
	customOptions.put(JavaCore.COMPILER_NULLABLE_ANNOTATION_NAME, "org.foo.Nullable");
	runNegativeTestWithLibs(
		new String[] {
	"p1/package-info.java",
			"@org.eclipse.jdt.annotation.NonNullByDefault\n" +
			"package p1;\n",
	"p1/X.java",
			"package p1;\n" +
			"public class X {\n" +
			"    class Inner {" +
			"        protected Object getObject(String s) {\n" +
			"            return null;\n" +
			"        }\n" +
			"    }\n" +
			"}\n",
	CUSTOM_NONNULL_NAME,
			CUSTOM_NONNULL_CONTENT,
	CUSTOM_NULLABLE_NAME,
			CUSTOM_NULLABLE_CONTENT
		},
		customOptions,
		"----------\n" +
		"1. ERROR in p1\\X.java (at line 4)\n" +
		"	return null;\n" +
		"	       ^^^^\n" +
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" +
		"----------\n");
}
// global default nonnull, but return may be null
// DISABLED due to dysfunctional global default after Bug 366063 - Compiler should not add synthetic @NonNull annotations
public void _test_default_nullness_007() {
	Map customOptions = getCompilerOptions();
//	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, JavaCore.ERROR);
//	customOptions.put(JavaCore.COMPILER_NONNULL_IS_DEFAULT, JavaCore.ENABLED);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable Object dangerous() {\n" +
			"        return null;\n" +
			"    }\n" +
			"    Object broken() {\n" +
			"        return dangerous();\n" +
			"    }\n" +
			"}\n",

		},
		customOptions,
		"----------\n" +
		"1. ERROR in X.java (at line 7)\n" +
		"	return dangerous();\n" +
		"	       ^^^^^^^^^^^\n" +
		"Null type mismatch: required \'@NonNull Object\' but the provided value is inferred as @Nullable\n" +
		"----------\n");
}

// cancel type level default to comply with super specification
public void test_default_nullness_008() {
	Map customOptions = getCompilerOptions();
//	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, JavaCore.ERROR);
	runConformTestWithLibs(
		new String[] {
	"p1/X.java",
			"package p1;\n" +
			"public class X {\n" +
			"    protected Object getObject(Object o) {\n" +
			"        return new Object();\n" +
			"    }\n" +
			"}\n",
	"p2/Y.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class Y extends p1.X {\n" +
			"    @Override\n" +
			cancenNonNullByDefault() +
			"    protected Object getObject(Object o) {\n" +
			"        if (o.toString().length() == 0)\n" + // dereference without a warning
			"	        return null;\n" + // return null without a warning
			"        return o.toString();\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"");
}

// cancel outer type level default to comply with super specification
public void test_default_nullness_009() {
	Map customOptions = getCompilerOptions();
//	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, JavaCore.ERROR);
	runNegativeTestWithLibs(
		new String[] {
	"p1/X.java",
			"package p1;\n" +
			"public class X {\n" +
			"    protected Object getObject(Object o) {\n" +
			"        return new Object();\n" +
			"    }\n" +
			"}\n",
	"p2/Y.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class Y { \n" +
			cancenNonNullByDefault() +
			"    static class Z extends p1.X {\n" +
			"        @Override\n" +
			"        protected Object getObject(Object o) {\n" +
			"            if (o.toString().length() == 0) {\n" +
			"                o = null;\n" + // assign null without a warning
			"                bar(o); // error: arg is declared @NonNull\n" +
			"	             return null;\n" +
			"            }\n" +
			"            return o.toString();\n" +
			"        }\n" +
			"        String bar(@NonNull Object o) {\n" +
			"            return getObject(o).toString();" +
			"        }\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"----------\n" +
		"1. ERROR in p2\\Y.java (at line 11)\n" +
		"	bar(o); // error: arg is declared @NonNull\n" +
		"	    ^\n" +
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" +
		"----------\n");
}
// non-null declarations are redundant within a default scope.
public void test_default_nullness_010() {
	Map customOptions = getCompilerOptions();
//	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, JavaCore.ERROR);
	runConformTestWithLibs(
		new String[] {
	"p2/Y.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class Y {\n" +
			"    protected @NonNull Object getObject(@NonNull Object o) {\n" +
			"        return o;\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"----------\n" +
		"1. WARNING in p2\\Y.java (at line 5)\n" +
		"	protected @NonNull Object getObject(@NonNull Object o) {\n" +
		"	          ^^^^^^^^^^^^^^^\n" +
		"The nullness annotation is redundant with a default that applies to this location\n" +
		"----------\n" +
		"2. WARNING in p2\\Y.java (at line 5)\n" +
		"	protected @NonNull Object getObject(@NonNull Object o) {\n" +
		"	                                    ^^^^^^^^^^^^^^^^^\n" +
		"The nullness annotation is redundant with a default that applies to this location\n" +
		"----------\n");
}
// package-info declares nonnull-by-default
// special compile order due to import of type from that package
// cf. https://bugs.eclipse.org/bugs/show_bug.cgi?id=186342#add_comment
public void test_default_nullness_011() {
	runNegativeTestWithLibs(
		new String[] {
			"Main.java",
			"import p1.C;\n" +
			"public class Main {\n" +
			"    void test(@org.eclipse.jdt.annotation.NonNull Object o) {\n" +
			"        o = null;\n" +
			"        new C(null);\n" +
			"    }\n" +
			"}\n",
			"p1/C.java",
			"package p1;\n" +
			"@org.eclipse.jdt.annotation.NonNullByDefault\n" +
			"public class C {\n" +
			"    public C (Object o) {}\n" +
			"}\n",
			"p1/package-info.java",
			"@org.eclipse.jdt.annotation.NonNullByDefault\n" +
			"package p1;\n"
		},
		"----------\n" + 
		"1. ERROR in Main.java (at line 4)\n" + 
		"	o = null;\n" + 
		"	    ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n" + 
		"2. ERROR in Main.java (at line 5)\n" + 
		"	new C(null);\n" + 
		"	      ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n" + 
		"----------\n" + 
		"1. WARNING in p1\\C.java (at line 2)\n" + 
		"	@org.eclipse.jdt.annotation.NonNullByDefault\n" + 
		"	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Nullness default is redundant with a default specified for the enclosing package p1\n" + 
		"----------\n");
}
// Bug 365836 - [compiler][null] Incomplete propagation of null defaults.
public void test_default_nullness_012() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.NonNullByDefault;\n" + 
			"import org.eclipse.jdt.annotation.Nullable;\n" + 
			"\n" + 
			"public class X {\n" + 
			"    @NonNullByDefault \n" + 
			"    public void foo(@Nullable String [] args) {\n" + 
			"        class local {\n" + 
			"            void zoo(Object o) {\n" + 
			"            }\n" + 
			"        };\n" + 
			"        new local().zoo(null); // defaults applying from foo\n" + 
			"    }\n" + 
			"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 11)\n" + 
		"	new local().zoo(null); // defaults applying from foo\n" + 
		"	                ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n");
}
// Bug 365836 - [compiler][null] Incomplete propagation of null defaults.
public void test_default_nullness_013() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.NonNullByDefault;\n" + 
			"import org.eclipse.jdt.annotation.Nullable;\n" + 
			"\n" +
			"@SuppressWarnings(\"unused\")\n" +
			"public class X {\n" + 
			"    @NonNullByDefault \n" + 
			"    public void foo(@Nullable String [] args) {\n" + 
			"        class local {\n" +
			"            class Deeply {\n" + 
			"                Object zoo() {\n" +
			"                    return null; // defaults applying from foo\n" +
			"                }\n" + 
			"            }\n" + 
			"        };\n" + 
			"    }\n" + 
			"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 11)\n" + 
		"	return null; // defaults applying from foo\n" + 
		"	       ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n");
}
// bug 367154 - [compiler][null] Problem in propagating null defaults.
public void test_default_nullness_014() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.NonNullByDefault;\n" + 
			"import org.eclipse.jdt.annotation.Nullable;\n" + 
			"\n" + 
			"@SuppressWarnings(\"unused\")\n" + 
			"public class X {\n" + 
			"\n" + 
			"    public void foo(@Nullable String [] args) {\n" + 
			"        @NonNullByDefault\n" + 
			"        class local {\n" + 
			"            class Deeply {\n" + 
			"                Object zoo() {\n" + 
			"                    return null;  // expect error here\n" + 
			"                }\n" + 
			"            }\n" + 
			"        };\n" + 
			"    }\n" + 
			"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 12)\n" + 
		"	return null;  // expect error here\n" + 
		"	       ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n");
}
// bug 367154 - [compiler][null] Problem in propagating null defaults.
// initializer involved
public void test_default_nullness_015() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.NonNullByDefault;\n" + 
			"import org.eclipse.jdt.annotation.Nullable;\n" + 
			"\n" + 
			"@SuppressWarnings(\"unused\")\n" + 
			"@NonNullByDefault\n" + 
			"public class X {\n" + 
			"    {\n" + 
			"        class local {\n" + 
			"            class Deeply {\n" + 
			"                Object zoo() {\n" + 
			"                    return null;  // expect error here\n" + 
			"                }\n" + 
			"            }\n" + 
			"        };\n" + 
			"    }\n" + 
			"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 11)\n" + 
		"	return null;  // expect error here\n" + 
		"	       ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n");
}

// default nullness applied to fields, class-level:
public void test_default_nullness_016() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    Object foo;\n" +
			"    void doFoo() {\n" +
			"        foo = null;\n" +
			"    }\n" +
			"    class Inner {\n" +
			"        Object iFoo;\n" +
			"        void diFoo(@Nullable Object arg) {\n" +
			"            iFoo = arg;\n" +
			"        }\n" +
			"    }\n" +
			"}\n",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	Object foo;\n" + 
		"	       ^^^\n" + 
		"The @NonNull field foo may not have been initialized\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 6)\n" + 
		"	foo = null;\n" + 
		"	      ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 9)\n" + 
		"	Object iFoo;\n" + 
		"	       ^^^^\n" + 
		"The @NonNull field iFoo may not have been initialized\n" + 
		"----------\n" + 
		"4. ERROR in X.java (at line 11)\n" + 
		"	iFoo = arg;\n" + 
		"	       ^^^\n" + 
		mismatch_NonNull_Nullable("Object") + 
		"----------\n");
}

// default nullness applied to fields, method level applied to local class + redundant annotation
public void test_default_nullness_017() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNUSED_PRIVATE_MEMBER, JavaCore.IGNORE);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @NonNullByDefault\n" +
			"    Object doFoo() {\n" +
			"        class Local {\n" +
			"            Object foo;\n" +
			"            @NonNull Object goo;\n" +
			"        };" +
			"        return new Local();\n" +
			"    }\n" +
			"}\n",
		},
		options,
		"----------\n" + 
		"1. ERROR in X.java (at line 6)\n" + 
		"	Object foo;\n" + 
		"	       ^^^\n" + 
		"The @NonNull field foo may not have been initialized\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 7)\n" + 
		"	@NonNull Object goo;\n" + 
		"	^^^^^^^^^^^^^^^\n" + 
		"The nullness annotation is redundant with a default that applies to this location\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 7)\n" + 
		"	@NonNull Object goo;\n" + 
		"	                ^^^\n" + 
		"The @NonNull field goo may not have been initialized\n" + 
		"----------\n");
}

// package case
public void test_nullness_default_018() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_MISSING_NONNULL_BY_DEFAULT_ANNOTATION, JavaCore.WARNING);
	customOptions.put(JavaCore.COMPILER_PB_UNUSED_WARNING_TOKEN, JavaCore.ERROR);
	runConformTestWithLibs(
		new String[] {
			"pack/NullWarn.java",
			"package pack;\n" +
			"@SuppressWarnings(\"null\")\n" + 
			"public class NullWarn {\n" + 
			"\n" + 
			"    // Some code\n" + 
			"\n" + 
			"}\n"
		},
		customOptions,
		"");
	
}

// type case (inside default package)
public void test_nullness_default_018b() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_MISSING_NONNULL_BY_DEFAULT_ANNOTATION, JavaCore.WARNING);
	customOptions.put(JavaCore.COMPILER_PB_UNUSED_WARNING_TOKEN, JavaCore.ERROR);
	runConformTestWithLibs(
		new String[] {
			"NullWarn.java",
			"@SuppressWarnings(\"null\")\n" + 
			"public class NullWarn {\n" + 
			"\n" + 
			"    // Some code\n" + 
			"\n" + 
			"}\n"
		},
		customOptions,
		"");
	
}

// redundant default annotations - class vs. inner class
public void test_redundant_annotation_01() {
	Map customOptions = getCompilerOptions();
//	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, JavaCore.ERROR);
	runConformTestWithLibs(
		new String[] {
			"p2/Y.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class Y {\n" +
			"    @NonNullByDefault class Inner {\n" +
			"        @NonNullByDefault class DeepInner {}\n" +
			"    }\n" +
			"    class Inner2 {\n" +
			"        @NonNullByDefault class DeepInner2 {\n" +
			"        }\n" +
			"        void foo() {\n" +
			"            @SuppressWarnings(\"unused\") @NonNullByDefault class Local {}\n" +
			"        }\n" +
			"    }\n" +
			"}\n" +
			"@NonNullByDefault class V {}\n",
			"p3/package-info.java",
			"@org.eclipse.jdt.annotation.NonNullByDefault package p3;\n",
			"p3/Z.java",
			"package p3;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class Z {\n" +
			"}\n" +
			"class X {\n" +
			"    @NonNullByDefault class Inner {}\n" +
			"    class Inner2 {\n" +
			"        @NonNullByDefault class DeepInner {}\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"----------\n" + 
		"1. WARNING in p2\\Y.java (at line 5)\n" +
		"	@NonNullByDefault class Inner {\n" +
		"	^^^^^^^^^^^^^^^^^\n" +
		"Nullness default is redundant with a default specified for the enclosing type Y\n" +
		"----------\n" +
		"2. WARNING in p2\\Y.java (at line 6)\n" +
		"	@NonNullByDefault class DeepInner {}\n" +
		"	^^^^^^^^^^^^^^^^^\n" +
		"Nullness default is redundant with a default specified for the enclosing type Y.Inner\n" +
		"----------\n" +
		"3. WARNING in p2\\Y.java (at line 9)\n" +
		"	@NonNullByDefault class DeepInner2 {\n" +
		"	^^^^^^^^^^^^^^^^^\n" +
		"Nullness default is redundant with a default specified for the enclosing type Y\n" +
		"----------\n" +
		"4. WARNING in p2\\Y.java (at line 12)\n" +
		"	@SuppressWarnings(\"unused\") @NonNullByDefault class Local {}\n" +
		"	                            ^^^^^^^^^^^^^^^^^\n" +
		"Nullness default is redundant with a default specified for the enclosing type Y\n" +
		"----------\n" +
		"----------\n" +
		"1. WARNING in p3\\Z.java (at line 3)\n" +
		"	@NonNullByDefault\n" +
		"	^^^^^^^^^^^^^^^^^\n" +
		"Nullness default is redundant with a default specified for the enclosing package p3\n" +
		"----------\n" +
		"2. WARNING in p3\\Z.java (at line 7)\n" +
		"	@NonNullByDefault class Inner {}\n" +
		"	^^^^^^^^^^^^^^^^^\n" +
		"Nullness default is redundant with a default specified for the enclosing package p3\n" +
		"----------\n" +
		"3. WARNING in p3\\Z.java (at line 9)\n" +
		"	@NonNullByDefault class DeepInner {}\n" +
		"	^^^^^^^^^^^^^^^^^\n" +
		"Nullness default is redundant with a default specified for the enclosing package p3\n" +
		"----------\n");
}

// redundant default annotations - class vs. method
public void test_redundant_annotation_02() {
	Map customOptions = getCompilerOptions();
	runConformTestWithLibs(
		new String[] {
			"p2/Y.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class Y {\n" +
			"    @NonNullByDefault void foo() {}\n" +
			"}\n" +
			"class Z {\n" +
			"    @NonNullByDefault void bar() {\n" +
			"         @NonNullByDefault @SuppressWarnings(\"unused\") class Zork {\n" +
			"             @NonNullByDefault void fubar() {}\n" +
			"         }\n" +
			"    }\n" +
			"    @NonNullByDefault void zink() {\n" +
			"         @SuppressWarnings(\"unused\") class Bork {\n" +
			"             @NonNullByDefault void jubar() {}\n" +
			"         }\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"----------\n" +
		"1. WARNING in p2\\Y.java (at line 5)\n" +
		"	@NonNullByDefault void foo() {}\n" +
		"	^^^^^^^^^^^^^^^^^\n" +
		"Nullness default is redundant with a default specified for the enclosing type Y\n" +
		"----------\n" +
		"2. WARNING in p2\\Y.java (at line 9)\n" +
		"	@NonNullByDefault @SuppressWarnings(\"unused\") class Zork {\n" +
		"	^^^^^^^^^^^^^^^^^\n" +
		"Nullness default is redundant with a default specified for the enclosing method bar()\n" +
		"----------\n" +
		"3. WARNING in p2\\Y.java (at line 10)\n" +
		"	@NonNullByDefault void fubar() {}\n" +
		"	^^^^^^^^^^^^^^^^^\n" +
		"Nullness default is redundant with a default specified for the enclosing type Zork\n" +
		"----------\n" +
		"4. WARNING in p2\\Y.java (at line 15)\n" +
		"	@NonNullByDefault void jubar() {}\n" +
		"	^^^^^^^^^^^^^^^^^\n" +
		"Nullness default is redundant with a default specified for the enclosing method zink()\n" +
		"----------\n");
}

//redundant default annotations - class vs. method - generics
public void test_redundant_annotation_02g() {
	Map customOptions = getCompilerOptions();
	runConformTestWithLibs(
		new String[] {
			"p2/Y.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class Y<TY> {\n" +
			"    @NonNullByDefault <TF> void foo(TF arg) {}\n" +
			"}\n" +
			"class Z {\n" +
			"    @NonNullByDefault <TB> void bar() {\n" +
			"         @NonNullByDefault @SuppressWarnings(\"unused\") class Zork {\n" +
			"             @NonNullByDefault void fubar(TB arg) {}\n" +
			"         }\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"----------\n" + 
		"1. WARNING in p2\\Y.java (at line 5)\n" + 
		"	@NonNullByDefault <TF> void foo(TF arg) {}\n" + 
		"	^^^^^^^^^^^^^^^^^\n" + 
		"Nullness default is redundant with a default specified for the enclosing type Y<TY>\n" + 
		"----------\n" + 
		"2. WARNING in p2\\Y.java (at line 9)\n" + 
		"	@NonNullByDefault @SuppressWarnings(\"unused\") class Zork {\n" + 
		"	^^^^^^^^^^^^^^^^^\n" + 
		"Nullness default is redundant with a default specified for the enclosing method bar()\n" + 
		"----------\n" + 
		"3. WARNING in p2\\Y.java (at line 10)\n" + 
		"	@NonNullByDefault void fubar(TB arg) {}\n" + 
		"	^^^^^^^^^^^^^^^^^\n" + 
		"Nullness default is redundant with a default specified for the enclosing type Zork\n" + 
		"----------\n");
}

// test missing default nullness annotation for types in default package
public void test_missing_default_annotation_01() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_MISSING_NONNULL_BY_DEFAULT_ANNOTATION, JavaCore.ERROR);
	runNegativeTestWithLibs(
		new String[] {
			"Lib.java",
			"public class Lib {\n" +
			"    Object getObject() { return new Object(); }\n" +
			"}\n",
			"X.java",
			"public class X {\n" +
			"	 class XInner{}\n" +  // don't warn for inner types
			"    Object getObject(Lib l) {\n" +
			"        return l.getObject();\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"----------\n" + 
		"1. ERROR in Lib.java (at line 1)\n" + 
		"	public class Lib {\n" + 
		"	             ^^^\n" + 
		"A default nullness annotation has not been specified for the type Lib\n" + 
		"----------\n" + 
		"----------\n" + 
		"1. ERROR in X.java (at line 1)\n" + 
		"	public class X {\n" + 
		"	             ^\n" + 
		"A default nullness annotation has not been specified for the type X\n" + 
		"----------\n");
}

// test missing default nullness annotation for a package with package-info
public void test_missing_default_annotation_02() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_MISSING_NONNULL_BY_DEFAULT_ANNOTATION, JavaCore.ERROR);
	runNegativeTestWithLibs(
		new String[] {
			"p2/package-info.java",
			"package p2;\n",
			"p2/Y.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class Y {\n" +
			"   void foo() {}\n" +
			"}\n",
			"p3/package-info.java",
			"@org.eclipse.jdt.annotation.NonNullByDefault package p3;\n",
			"p3/Z.java",
			"package p3;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Z {\n" +
			"    @NonNullByDefault void bar() {}\n" +
			"}\n",
		},
		customOptions,
		"----------\n" + 
		"1. ERROR in p2\\package-info.java (at line 1)\n" + 
		"	package p2;\n" + 
		"	        ^^\n" + 
		"A default nullness annotation has not been specified for the package p2\n" + 
		"----------\n" + 
		"----------\n" + 
		"1. WARNING in p3\\Z.java (at line 4)\n" + 
		"	@NonNullByDefault void bar() {}\n" + 
		"	^^^^^^^^^^^^^^^^^\n" + 
		"Nullness default is redundant with a default specified for the enclosing package p3\n" + 
		"----------\n");
}

// redundant default annotations - class vs. inner class
// ensure that disabling null annotations also disables this diagnostic
public void test_redundant_annotation_04() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_ANNOTATION_NULL_ANALYSIS, JavaCore.DISABLED);
	runConformTestWithLibs(
		new String[] {
			"p2/Y.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class Y {\n" +
			"    @NonNullByDefault class Inner {\n" +
			"        @NonNullByDefault class DeepInner {}\n" +
			"    }\n" +
			"    class Inner2 {\n" +
			"        @NonNullByDefault class DeepInner2 {\n" +
			"        }\n" +
			"        @NonNullByDefault void foo(@Nullable @NonNull Object arg) {\n" +
			"            @NonNullByDefault class Local {}\n" +
			"        }\n" +
			"    }\n" +
			"}\n" +
			"@NonNullByDefault class V {}\n",
			"p3/package-info.java",
			"@org.eclipse.jdt.annotation.NonNullByDefault package p3;\n",
			"p3/Z.java",
			"package p3;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class Z {\n" +
			"}\n" +
			"class X {\n" +
			"    @NonNullByDefault class Inner {}\n" +
			"    class Inner2 {\n" +
			"        @NonNullByDefault class DeepInner {}\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"");
}

// contradictory null annotations
public void test_contradictory_annotations_01() {
	Map customOptions = getCompilerOptions();
	runNegativeTestWithLibs(
		new String[] {
			"p2/Y.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Y {\n" +
			"    void foo(@NonNull @Nullable Object o) {}\n" +
			"    @Nullable @NonNull Object bar() {\n" +
			"        @NonNull @Nullable Object o = null;\n" +
			"        return o;\n" +
			"    }\n" +
			"}\n" +
			"class Z {\n" +
			"    @NonNullByDefault void bar() {}\n" +
			"}\n"
		},
		customOptions,
		"----------\n" + 
		"1. ERROR in p2\\Y.java (at line 4)\n" + 
		"	void foo(@NonNull @Nullable Object o) {}\n" + 
		"	                  ^^^^^^^^^\n" + 
		"Contradictory null specification; only one of @NonNull and @Nullable can be specified at any location\n" + 
		"----------\n" + 
		"2. ERROR in p2\\Y.java (at line 5)\n" + 
		"	@Nullable @NonNull Object bar() {\n" + 
		"	          ^^^^^^^^\n" + 
		"Contradictory null specification; only one of @NonNull and @Nullable can be specified at any location\n" + 
		"----------\n" + 
		"3. ERROR in p2\\Y.java (at line 6)\n" + 
		"	@NonNull @Nullable Object o = null;\n" + 
		"	         ^^^^^^^^^\n" + 
		"Contradictory null specification; only one of @NonNull and @Nullable can be specified at any location\n" + 
		"----------\n");
}

// contradictory null annotations on a field
public void test_contradictory_annotations_02() {
	Map customOptions = getCompilerOptions();
	runNegativeTestWithLibs(
		new String[] {
			"p2/Y.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Y {\n" +
			"    @NonNull @Nullable Object o;\n" +
			"}\n"
		},
		customOptions,
		"----------\n" + 
		"1. ERROR in p2\\Y.java (at line 4)\n" + 
		"	@NonNull @Nullable Object o;\n" + 
		"	         ^^^^^^^^^\n" + 
		"Contradictory null specification; only one of @NonNull and @Nullable can be specified at any location\n" + 
		"----------\n");
}

// contradictory null annotations on a field - array type
public void test_contradictory_annotations_03() {
	Map customOptions = getCompilerOptions();
	runNegativeTestWithLibs(
		new String[] {
			"p2/Y.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Y {\n" +
			"    @NonNull @Nullable Object[] o;\n" +
			"}\n"
		},
		customOptions,
		"----------\n" + 
		"1. ERROR in p2\\Y.java (at line 4)\n" + 
		"	@NonNull @Nullable Object[] o;\n" + 
		"	         ^^^^^^^^^\n" + 
		"Contradictory null specification; only one of @NonNull and @Nullable can be specified at any location\n" + 
		"----------\n");
}

// a nonnull variable is dereferenced in a loop
public void test_nonnull_var_in_constrol_structure_1() {
	Map customOptions = getCompilerOptions();
//	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, JavaCore.ERROR);
// This option currently does nothing:
//	customOptions.put(JavaCore.COMPILER_NONNULL_IS_DEFAULT, JavaCore.ENABLED);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    void print4(@NonNull String s) {\n" +
			"        for (int i=0; i<4; i++)\n" +
			"             print(s);\n" +
			"    }\n" +
			"    void print5(@Nullable String s) {\n" +
			"        for (int i=0; i<5; i++)\n" +
			"             print(s);\n" +
			"    }\n" +
			"    void print6(boolean b) {\n" +
			"        String s = b ? null : \"\";\n" +
			"        for (int i=0; i<5; i++)\n" +
			"             print(s);\n" +
			"    }\n" +
			"    void print(@NonNull String s) {\n" +
			"        System.out.print(s);\n" +
			"    }\n" +
			"}\n",

		},
		customOptions,
		"----------\n" +
		"1. WARNING in X.java (at line 4)\n" +
		"	void print4(@NonNull String s) {\n" +
		"	            ^^^^^^^^^^^^^^^^^\n" +
		"The nullness annotation is redundant with a default that applies to this location\n" +
		"----------\n" +
		"2. ERROR in X.java (at line 10)\n" +
		"	print(s);\n" +
		"	      ^\n" +
		mismatch_NonNull_Nullable("String") +
		"----------\n" +
		"3. ERROR in X.java (at line 15)\n" +
		"	print(s);\n" +
		"	      ^\n" +
		"Null type mismatch: required \'@NonNull String\' but the provided value is inferred as @Nullable\n" +
		"----------\n" +
		"4. WARNING in X.java (at line 17)\n" +
		"	void print(@NonNull String s) {\n" +
		"	           ^^^^^^^^^^^^^^^^^\n" +
		"The nullness annotation is redundant with a default that applies to this location\n" +
		"----------\n");
}
// a nonnull variable is dereferenced in a finally block
public void test_nonnull_var_in_constrol_structure_2() {
	Map customOptions = getCompilerOptions();
//	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, JavaCore.ERROR);
// This option currently does nothing:
//	customOptions.put(JavaCore.COMPILER_NONNULL_IS_DEFAULT, JavaCore.ENABLED);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    void print4(String s) {\n" +
			"        try { /*empty*/ } finally {\n" +
			"             print(s);\n" +
			"        }\n" +
			"    }\n" +
			"    void print5(@Nullable String s) {\n" +
			"        try { /*empty*/ } finally {\n" +
			"             print(s);\n" +
			"        }\n" +
			"    }\n" +
			"    void print6(boolean b) {\n" +
			"        String s = b ? null : \"\";\n" +
			"        try { /*empty*/ } finally {\n" +
			"             print(s);\n" +
			"        }\n" +
			"    }\n" +
			"    void print(String s) {\n" +
			"        System.out.print(s);\n" +
			"    }\n" +
			"}\n",

		},
		customOptions,
		"----------\n" +
		"1. ERROR in X.java (at line 10)\n" +
		"	print(s);\n" +
		"	      ^\n" +
		mismatch_NonNull_Nullable("String") +
		"----------\n" +
		"2. ERROR in X.java (at line 16)\n" +
		"	print(s);\n" +
		"	      ^\n" +
		"Null type mismatch: required \'@NonNull String\' but the provided value is inferred as @Nullable\n" +
		"----------\n");
}
// a nonnull variable is dereferenced in a finally block inside a loop
public void test_nonnull_var_in_constrol_structure_3() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_REDUNDANT_NULL_ANNOTATION, JavaCore.IGNORE);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    void print4(@NonNull String s) {\n" +
			"        for (int i=0; i<4; i++)\n" +
			"            try { /*empty*/ } finally {\n" +
			"                 print(s);\n" +
			"            }\n" +
			"    }\n" +
			"    void print5(@Nullable String s) {\n" +
			"        for (int i=0; i<5; i++)\n" +
			"            try { /*empty*/ } finally {\n" +
			"                 print(s);\n" +
			"            }\n" +
			"    }\n" +
			"    void print6(boolean b) {\n" +
			"        String s = b ? null : \"\";\n" +
			"        for (int i=0; i<4; i++)\n" +
			"            try { /*empty*/ } finally {\n" +
			"                 print(s);\n" +
			"            }\n" +
			"    }\n" +
			"    void print(@NonNull String s) {\n" +
			"        System.out.print(s);\n" +
			"    }\n" +
			"}\n",

		},
		customOptions,
		"----------\n" +
		"1. ERROR in X.java (at line 12)\n" +
		"	print(s);\n" +
		"	      ^\n" +
		mismatch_NonNull_Nullable("String") +
		"----------\n" +
		"2. ERROR in X.java (at line 19)\n" +
		"	print(s);\n" +
		"	      ^\n" +
		"Null type mismatch: required \'@NonNull String\' but the provided value is inferred as @Nullable\n" +
		"----------\n");
}
// witness for an AIOOBE in FlowContext.recordExpectedType()
public void test_message_send_in_control_structure_01() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_NULL_UNCHECKED_CONVERSION, JavaCore.IGNORE);
	customOptions.put(JavaCore.COMPILER_PB_POTENTIAL_NULL_REFERENCE, JavaCore.WARNING);
	runNegativeTestWithLibs(
		new String[] {
			"p/Scope.java",
			"package p;\n" +
			"@org.eclipse.jdt.annotation.NonNullByDefault\n" +
			"public abstract class Scope {\n" +
			"	public ReferenceBinding findMemberType(char[] typeName, ReferenceBinding enclosingType) {\n" +
			"		ReferenceBinding enclosingSourceType = enclosingSourceType();\n" +
			"		PackageBinding currentPackage = getCurrentPackage();\n" +
			"		CompilationUnitScope unitScope = compilationUnitScope();\n" +
			"		ReferenceBinding memberType = enclosingType.getMemberType(typeName);\n" +
			"		ReferenceBinding currentType = enclosingType;\n" +
			"		ReferenceBinding[] interfacesToVisit = null;\n" +
			"		while (true) {\n" +
			"			ReferenceBinding[] itsInterfaces = currentType.superInterfaces();\n" +
			"			if (itsInterfaces != null) {\n" +
			"				if (interfacesToVisit == null) {\n" +
			"					interfacesToVisit = itsInterfaces;\n" +
			"				}\n" +
			"			}\n" +
			"			unitScope.recordReference(currentType, typeName);\n" +
			"			\n" +
			"			if ((memberType = currentType.getMemberType(typeName)) != null) {\n" +
			"				if (enclosingSourceType == null\n" +
			"					? memberType.canBeSeenBy(currentPackage)\n" +
			"					: memberType.canBeSeenBy(enclosingType, enclosingSourceType)) {\n" +
			"						return memberType;\n" +
			"				}\n" +
			"			}\n" +
			"		}\n" +
			"	}\n" +
			"	private CompilationUnitScope compilationUnitScope() {\n" +
			"		return compilationUnitScope();\n" +
			"	}\n" +
			"	private PackageBinding getCurrentPackage() {\n" +
			"		return getCurrentPackage();\n" +
			"	}\n" +
			"	private ReferenceBinding enclosingSourceType() {\n" +
			"		return enclosingSourceType();\n" +
			"	}\n" +
			"}\n",
			"p/CompilationUnitScope.java",
			"package p;\n" +
			"@org.eclipse.jdt.annotation.NonNullByDefault\n" +
			"public class CompilationUnitScope {\n" +
			"    void recordReference(ReferenceBinding rb, char[] name) {}\n" +
			"}\n",
			"p/PackageBinding.java",
			"package p;\n" +
			"@org.eclipse.jdt.annotation.NonNullByDefault\n" +
			"public class PackageBinding {\n" +
			"}\n",
			"p/ReferenceBinding.java",
			"package p;\n" +
			"@org.eclipse.jdt.annotation.NonNullByDefault\n" +
			"public class ReferenceBinding {\n" +
			"    ReferenceBinding getMemberType(char[] name) { return this; }\n" +
			"    ReferenceBinding[] superInterfaces() { return new ReferenceBinding[0]; }\n" +
			"    boolean canBeSeenBy(PackageBinding ob) { return true; }\n" +
			"    boolean canBeSeenBy(ReferenceBinding rb, ReferenceBinding rb2) { return true; }\n" +
			"}\n"
		},
		customOptions,
		"----------\n" +
		"1. ERROR in p\\Scope.java (at line 13)\n" +
		"	if (itsInterfaces != null) {\n" +
		"	    ^^^^^^^^^^^^^\n" +
		"Redundant null check: The variable itsInterfaces cannot be null at this location\n" +
		"----------\n" +
		"2. ERROR in p\\Scope.java (at line 20)\n" +
		"	if ((memberType = currentType.getMemberType(typeName)) != null) {\n" +
		"	    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
		"Redundant null check: The variable memberType cannot be null at this location\n" +
		"----------\n" +
		"3. ERROR in p\\Scope.java (at line 21)\n" +
		"	if (enclosingSourceType == null\n" +
		"	    ^^^^^^^^^^^^^^^^^^^\n" +
		"Null comparison always yields false: The variable enclosingSourceType cannot be null at this location\n" +
		"----------\n");
}

// Bug 370930 - NonNull annotation not considered for enhanced for loops
public void test_message_send_in_control_structure_02() {
	runNegativeTestWithLibs(
		new String[] {
			"Bug370930.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"import java.util.*;\n" +
			"public class Bug370930 {\n" +
			"	void loop(Collection<String> list) {\n" + 
			"		for(@NonNull String s: list) { // warning here: insufficient info on elements\n" + 
			"			expectNonNull(s); // no warning here\n" + 
			"		}\n" + 
			"	}\n" + 
			"	\n" + 
			"	void expectNonNull(@NonNull String s) {}\n" +
			"}\n"
		},
		"----------\n" + 
		"1. WARNING in Bug370930.java (at line 5)\n" + 
		"	for(@NonNull String s: list) { // warning here: insufficient info on elements\n" + 
		"	                       ^^^^\n" +
		nullTypeSafety() + "The expression of type 'String' needs unchecked conversion to conform to \'@NonNull String\'\n" +
		"----------\n");
}
//Bug 370930 - NonNull annotation not considered for enhanced for loops over array
public void test_message_send_in_control_structure_02a() {
	runNegativeTestWithLibs(
		new String[] {
			"Bug370930.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Bug370930 {\n" +
			"	void loop(String[] array) {\n" + 
			"		for(@NonNull String s: array) { // warning here: insufficient info on elements\n" + 
			"			expectNonNull(s); // no warning here\n" + 
			"		}\n" + 
			"	}\n" + 
			"	\n" + 
			"	void expectNonNull(@NonNull String s) {}\n" +
			"}\n"
		},
		"----------\n" + 
		"1. WARNING in Bug370930.java (at line 4)\n" + 
		"	for(@NonNull String s: array) { // warning here: insufficient info on elements\n" + 
		"	                       ^^^^^\n" + 
		nullTypeSafety() + "The expression of type 'String' needs unchecked conversion to conform to \'@NonNull String\'\n" +
		"----------\n");
}
//Bug 370930 - NonNull annotation not considered for enhanced for loops
public void test_message_send_in_control_structure_03() {
	runNegativeTestWithLibs(
		new String[] {
			"Bug370930.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"import java.util.*;\n" +
			"public class Bug370930 {\n" +
			"	void loop(Collection<String> list) {\n" + 
			"		for(@Nullable String s: list) {\n" + 
			"			expectNonNull(s); // warning here\n" + 
			"		}\n" + 
			"	}\n" + 
			"	\n" + 
			"	void expectNonNull(@NonNull String s) {}\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in Bug370930.java (at line 6)\n" + 
		"	expectNonNull(s); // warning here\n" + 
		"	              ^\n" + 
		mismatch_NonNull_Nullable("String") + 
		"----------\n");
}
public void test_assignment_expression_1() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK, JavaCore.ERROR);
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"	@Nullable Object foo() {\n" +
			"		Object o = null;\n" +
			"		boolean keepLooking = true;\n" +
			"		while(keepLooking) {\n" +
			"			if ((o=getO()) != null) {\n" +
			"				return o;\n" +
			"			}\n" +
			"		}\n" +
			"		return null;\n" +
			"	}\n" +
			"\n" +
			"	private @Nullable Object getO() {\n" +
			"		return new Object();\n" +
			"	}\n" +
			"}\n",

		},
		customOptions,
		"");	
}
// a nonnull variable is dereferenced in a method of a nested type
public void test_nesting_1() {
	Map customOptions = getCompilerOptions();
//	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, JavaCore.ERROR);
// This option currently does nothing:
//	customOptions.put(JavaCore.COMPILER_NONNULL_IS_DEFAULT, JavaCore.ENABLED);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    void print4(final String s1) {\n" +
			"        for (int i=0; i<3; i++)\n" +
			"            new Runnable() {\n" +
			"                public void run() {\n" +
			"                     print(s1);\n" +
			"                }\n" +
			"            }.run();\n" +
			"    }\n" +
			"    void print8(final @Nullable String s2) {\n" +
			"        for (int i=0; i<3; i++)\n" +
			"            new Runnable() {\n" +
			"                public void run() {\n" +
			"                     print(s2);\n" +
			"                }\n" +
			"            }.run();\n" +
			"    }\n" +
			"    void print16(boolean b) {\n" +
			"        final String s3 = b ? null : \"\";\n" +
			"        for (int i=0; i<3; i++)\n" +
			"            new Runnable() {\n" +
			"                public void run() {\n" +
			"                     @NonNull String s3R = s3;\n" +
			"                }\n" +
			"            }.run();\n" +
			"    }\n" +
			"    void print(String s) {\n" +
			"        System.out.print(s);\n" +
			"    }\n" +
			"}\n",

		},
		customOptions,
		"----------\n" +
		"1. ERROR in X.java (at line 16)\n" +
		"	print(s2);\n" +
		"	      ^^\n" +
		mismatch_NonNull_Nullable("String") +
		"----------\n" +
		"2. ERROR in X.java (at line 25)\n" +
		"	@NonNull String s3R = s3;\n" +
		"	                      ^^\n" +
		"Null type mismatch: required \'@NonNull String\' but the provided value is inferred as @Nullable\n" +
		"----------\n");
}
// Test a regression incurred to the OT/J based implementation
// by the fix in Bug 360328 - [compiler][null] detect null problems in nested code (local class inside a loop)
public void test_constructor_with_nested_class() {
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"public class X {\n" +
			"    final Object o1;\n" +
			"    final Object o2;\n" +
			"    public X() {\n" +
			"         this.o1 = new Object() {\n" +
			"             @Override\n" +
			"             public String toString() { return \"O1\"; }\n" +
			"         };\n" +
			"         this.o2 = new Object();" +
			"    }\n" +
			"}\n"
		},
		null,//options
		"");
}
// test analysis disablement, binary type contains annotation
public void test_options_01() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_NULL_UNCHECKED_CONVERSION, JavaCore.ERROR);
	runConformTestWithLibs(
			new String[] {
				"ContainingInner2.java",
				"public class ContainingInner2 {\n" + 
				"    public ContainingInner2 (@org.eclipse.jdt.annotation.NonNull Object o) {\n" + 
				"    }\n" + 
				"    public class Inner {\n" + 
				"        public <T> Inner (@org.eclipse.jdt.annotation.NonNull T o) {\n" + 
				"        }\n" + 
				"    }\n" + 
				"}\n",
			},
			null /*customOptions*/,
			"");
	customOptions.put(JavaCore.COMPILER_ANNOTATION_NULL_ANALYSIS, JavaCore.DISABLED);
	runConformTestWithLibs(
		false, // flush directory
		new String[] {
			"X.java",
			"public class X {\n" +
			"	 void create() {\n" +
			"          ContainingInner2 container = new ContainingInner2(null);\n" +
			"	       ContainingInner2.Inner inner = container.new Inner(null);\n" +
			"    }\n" +
		  	"}\n"},
		customOptions,
		""  /* compiler output */);
}
// test illegally trying to ignore null spec violations
public void test_options_02() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_NULL_SPECIFICATION_VIOLATION, JavaCore.IGNORE); // has no effect
	runNegativeTestWithLibs(
		new String[] {
			"Test.java",
			"public class Test {\n" +
			"    public void foo(@org.eclipse.jdt.annotation.NonNull Object o) {\n" +
			"        o = null;\n" +
			"        Object p = o;\n" +
			"        if (p == null)\n" +
			"            p.toString();\n" +
			"    }\n" + 
			"}\n",
		},
		customOptions,
		"----------\n" + 
		"1. ERROR in Test.java (at line 3)\n" + 
		"	o = null;\n" + 
		"	    ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n" + 
		"2. ERROR in Test.java (at line 5)\n" + 
		"	if (p == null)\n" + 
		"	    ^\n" + 
		"Null comparison always yields false: The variable p cannot be null at this location\n" + 
		"----------\n" + 
		"3. WARNING in Test.java (at line 6)\n" + 
		"	p.toString();\n" + 
		"	^^^^^^^^^^^^\n" + 
		"Dead code\n" + 
		"----------\n");
}
// test setting null spec violations to "warning"
public void test_options_03() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_NULL_SPECIFICATION_VIOLATION, JavaCore.WARNING); // OK
	runNegativeTestWithLibs(
		new String[] {
			"Test.java",
			"public class Test {\n" +
			"    public void foo(@org.eclipse.jdt.annotation.NonNull Object o) {\n" +
			"        o = null;\n" +
			"        Object p = o;\n" +
			"        if (p == null)\n" +
			"            p.toString();\n" +
			"    }\n" + 
			"}\n",
		},
		customOptions,
		"----------\n" + 
		"1. WARNING in Test.java (at line 3)\n" + 
		"	o = null;\n" + 
		"	    ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n" + 
		"2. ERROR in Test.java (at line 5)\n" + 
		"	if (p == null)\n" + 
		"	    ^\n" + 
		"Null comparison always yields false: The variable p cannot be null at this location\n" + 
		"----------\n" + 
		"3. WARNING in Test.java (at line 6)\n" + 
		"	p.toString();\n" + 
		"	^^^^^^^^^^^^\n" + 
		"Dead code\n" + 
		"----------\n");
}
// access to a non-null field
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nonnull_field_1() {
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @NonNull Object o = new Object();\n" +
			"    public String oString() {\n" +
			"         return o.toString();\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
}

// a non-null field is not properly initialized
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nonnull_field_2() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @NonNull Object o;\n" +
			"    public String oString() {\n" +
			"         return o.toString();\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" +
		"1. ERROR in X.java (at line 3)\n" +
		"	@NonNull Object o;\n" +
		"	                ^\n" +
		"The @NonNull field o may not have been initialized\n" +
		"----------\n");
}

// a non-null field is not properly initialized - explicit constructor
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nonnull_field_2a() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @NonNull Object o;\n" +
			"    X (boolean b) { // only potentially initialized\n" +
			"        if (b)\n" +
			"            o = this;\n" +
			"    }\n" +
			"    X (@NonNull Object other) {\n" + // no problem
			"        o = other;\n" +
			"    }\n" +
			"    public String oString() {\n" +
			"        return o.toString();\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	X (boolean b) { // only potentially initialized\n" + 
		"	^^^^^^^^^^^^^\n" + 
		"The @NonNull field o may not have been initialized\n" + 
		"----------\n");
}

// a non-null field is not properly initialized - explicit constructor - incomplete switch
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nonnull_field_2b() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"enum Color { BLACK, GREEN }\n" +
			"public class X {\n" +
			"    @NonNull Object o;\n" +
			"    X (Color c) { // only potentially initialized\n" +
			"        switch (c) {\n" +
			"            case BLACK: o = this; break;\n" +
			"            case GREEN: o = new Object(); break;\n" +
			"        }\n" +
			"    }\n" +
			"    public String oString() {\n" +
			"        return o.toString();\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	X (Color c) { // only potentially initialized\n" + 
		"	^^^^^^^^^^^\n" + 
		"The @NonNull field o may not have been initialized. Note that a problem regarding missing \'default:\' on \'switch\' has been suppressed, which is perhaps related to this problem\n" + 
		"----------\n");
}

// a non-null static field is not properly initialized
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nonnull_field_2c() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    static @NonNull Object o;\n" +
			"    static {\n" +
			"        if (new Object().hashCode() == 42)\n" +
			"            o = new Object();\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	static @NonNull Object o;\n" + 
		"	                       ^\n" + 
		"The @NonNull field o may not have been initialized\n" + 
		"----------\n");
}

// a non-null static field is properly initialized
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nonnull_field_2d() {
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    static @NonNull Object o;\n" +
			"    static {\n" +
			"         o = new Object();\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
}

// a non-null field is properly initialized - using this.f reference
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nonnull_field_2e() {
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X<T> {\n" +
			"    @NonNull Object f;\n" +
			"    {\n" +
			"         this.f = new Object();\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
}

// a non-null field is initialized to null
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nonnull_field_3() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @NonNull Object o = null;\n" +
			"    public String oString() {\n" +
			"         return o.toString();\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	@NonNull Object o = null;\n" + 
		"	                    ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n");
}
// a non-null field is assigned to null
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nonnull_field_4() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @NonNull Object o = new Object();\n" +
			"    void breakIt1() {\n" +
			"         o = null;\n" +
			"    }\n" +
			"    void breakIt2() {\n" +
			"         this.o = null;\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	o = null;\n" + 
		"	    ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 8)\n" + 
		"	this.o = null;\n" + 
		"	         ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n");
}
// a non-null field is checked for null
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nonnull_field_5() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @NonNull Object o = new Object();\n" +
			"    boolean checkIt1() {\n" +
			"         return o == null;\n" +
			"    }\n" +
			"    boolean checkIt() {\n" +
			"         return this.o != null;\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	return o == null;\n" + 
		"	       ^\n" + 
		checkAlwaysFalse_nonnull("The field o", "Object") +
		"----------\n" + 
		"2. ERROR in X.java (at line 8)\n" + 
		"	return this.o != null;\n" + 
		"	            ^\n" +
		redundant_check_nonnull("The field o", "@NonNull Object") +
		"----------\n");
}

// a non-null field is checked for null twice - method call inbetween
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nonnull_field_6() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @NonNull Object o = new Object();\n" +
			"    boolean checkIt1() {\n" +
			"         if (o != null)\n" +
			"             System.out.print(\"not null\");\n" +
			"         System.out.print(\"continue\");\n" +
			"         return this.o == null;\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	if (o != null)\n" + 
		"	    ^\n" + 
		redundant_check_nonnull("The field o", "@NonNull Object") + 
		"----------\n" + 
		"2. ERROR in X.java (at line 8)\n" + 
		"	return this.o == null;\n" + 
		"	            ^\n" + 
		checkAlwaysFalse_nonnull("The field o", "Object") +
		"----------\n");
}

// a non-null field is accessed via a qualified name reference - static field
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nonnull_field_7() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"class Objects {\n" +
			"    static @NonNull Object o = new Object();\n" +
			"}\n" +
			"public class X {\n" +
			"    @NonNull Object getIt1() {\n" +
			"         if (Objects.o != null) // redundant\n" +
			"             System.out.print(\"not null\");\n" +
			"         System.out.print(\"continue\");\n" +
			"         return Objects.o;\n" +
			"    }\n" +
			"    @NonNull Object getIt2() {\n" +
			"         if (null != Objects.o) // redundant\n" +
			"             System.out.print(\"not null\");\n" +
			"         System.out.print(\"continue\");\n" +
			"         return Objects.o;\n" +
			"    }\n" +
			"    String getIt3() {\n" +
			"         return Objects.o.toString();\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	if (Objects.o != null) // redundant\n" + 
		"	            ^\n" + 
		redundant_check_nonnull("The field o", "@NonNull Object") + 
		"----------\n" + 
		"2. ERROR in X.java (at line 13)\n" + 
		"	if (null != Objects.o) // redundant\n" + 
		"	                    ^\n" + 
		redundant_check_nonnull("The field o", "@NonNull Object") + 
		"----------\n");
}

// a non-null field is accessed via a qualified name reference - instance field
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nonnull_field_8() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"class Objects {\n" +
			"    @NonNull Object o = new Object();\n" +
			"}\n" +
			"public class X {\n" +
			"    @NonNull Object getIt1(@NonNull Objects objs) {\n" +
			"         if (objs.o == null) // always false\n" +
			"             System.out.print(\"not null\");\n" +
			"         System.out.print(\"continue\");\n" +
			"         return objs.o;\n" +
			"    }\n" +
			"    String getIt2(@NonNull Objects objs) {\n" +
			"         return objs.o.toString();\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	if (objs.o == null) // always false\n" + 
		"	         ^\n" + 
		checkAlwaysFalse_nonnull("The field o", "Object") + 
		"----------\n" + 
		"2. WARNING in X.java (at line 8)\n" + 
		"	System.out.print(\"not null\");\n" + 
		"	^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Dead code\n" + 
		"----------\n");
}

// a non-null field is accessed via an indirect field reference - instance field
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nonnull_field_9() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"class Objects {\n" +
			"    @NonNull Object o = new Object();\n" +
			"}\n" +
			"public class X {\n" +
			"    Objects objs = new Objects();\n" +
			"    @NonNull Object getIt1() {\n" +
			"         if (this.objs.o != null) // redundant\n" +
			"             System.out.print(\"not null\");\n" +
			"         System.out.print(\"continue\");\n" +
			"         if (getObjs().o != null) // redundant\n" +
			"             System.out.print(\"not null\");\n" +
			"         return this.objs.o;\n" +
			"    }\n" +
			"    Objects getObjs() { return this.objs; }\n" +
			"    String getIt2() {\n" +
			"         return this.objs.o.toString();\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 8)\n" + 
		"	if (this.objs.o != null) // redundant\n" + 
		"	              ^\n" + 
		redundant_check_nonnull("The field o", "@NonNull Object") + 
		"----------\n" + 
		"2. ERROR in X.java (at line 11)\n" + 
		"	if (getObjs().o != null) // redundant\n" + 
		"	              ^\n" +
		redundant_check_nonnull("The field o", "@NonNull Object") + 
		"----------\n");
}

// trying to assign null to a nonnull field via a single / a qualified name reference
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nonnull_field_11() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"class Objects {\n" +
			"    @NonNull Object o = new Object();\n" +
			"    void test0(@Nullable Object x) {\n" +
			"         o = x;\n" +
			"    }\n" +
			"}\n" +
			"public class X {\n" +
			"    void test(@NonNull Objects objs) {\n" +
			"         objs.o = null;\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	o = x;\n" + 
		"	    ^\n" + 
		mismatch_NonNull_Nullable("Object") + 
		"----------\n" + 
		"2. ERROR in X.java (at line 10)\n" + 
		"	objs.o = null;\n" + 
		"	         ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n");
}

// @NonNull is applied to a field with primitive type
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nonnull_field_12() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @NonNull int o = 1;\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	@NonNull int o = 1;\n" + 
		"	^^^^^^^^\n" + 
		"The nullness annotation @NonNull is not applicable for the primitive type int\n" + 
		"----------\n");
}

// A final field is initialized to non-null, treat as effectively @NonNull
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void _test_nonnull_field_13() {
	// withdrawn as of https://bugs.eclipse.org/331649#c75
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    final String s1 = \"\";\n" +
			"    @NonNull String s2;\n" +
			"    X() {\n" +
			"        s2 = s1;\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
}

// A field in a different CU is implicitly @NonNull (by type default) - that class is read from binary
// Assignment to other @NonNull field should not raise a warning
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nonnull_field_14() {
	runConformTestWithLibs(
		new String[] {
			"p1/X.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    public String s1 = \"\";\n" +
			"}\n",
		},
		null /*customOptions*/,
		"");
	runConformTestWithLibs(
			new String[] {
			"p2/Y.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"import p1.X;\n" +
			"public class Y {\n" +
			"    @NonNull String s2 = \"\";\n" +
			"    void foo(X other) {\n" +
			"        s2 = other.s1;\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
}

// A field in a different CU is implicitly @NonNull (by package default) - that class is read from binary
// Assignment to other @NonNull field should not raise a warning
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nonnull_field_14b() {
	runConformTestWithLibs(
		new String[] {
			"p1/package-info.java",
			"@org.eclipse.jdt.annotation.NonNullByDefault\n" +
			"package p1;\n",
			"p1/X.java",
			"package p1;\n" +
			"public class X {\n" +
			"    public String s1 = \"\";\n" +
			"}\n",
		},
		null /*customOptions*/,
		"");
	runConformTestWithLibs(
			new String[] {
			"p2/Y.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"import p1.X;\n" +
			"public class Y {\n" +
			"    @NonNull String s2 = \"\";\n" +
			"    void foo(X other) {\n" +
			"        s2 = other.s1;\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
}

// A @NonNull field is assumed to be initialized by the injection framework
// [compiler] Null analysis for fields does not take @com.google.inject.Inject into account
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=400421
public void test_nonnull_field_15() {
	runConformTestWithLibs(
		new String[] {
			GOOGLE_INJECT_NAME,
			GOOGLE_INJECT_CONTENT,
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"import com.google.inject.Inject;\n" +
			"public class X {\n" +
			"    @NonNull @Inject Object o;\n" +
			"    @NonNullByDefault class Inner {\n" +
			"        @Inject String s;\n" +
			"    }\n" +
			"}\n",
		},
		null /*customOptions*/,
		"");
}

// Injection is optional, don't rely on the framework
// [compiler] Null analysis for fields does not take @com.google.inject.Inject into account
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=400421
public void test_nonnull_field_16() {
	runNegativeTestWithLibs(
		new String[] {
			GOOGLE_INJECT_NAME,
			GOOGLE_INJECT_CONTENT,
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"import com.google.inject.Inject;\n" +
			"public class X {\n" +
			"    @Inject(optional=true) @NonNull Object o;\n" +
			"    @NonNullByDefault class Inner {\n" +
			"        @Inject(optional=true) String s;\n" +
			"        @Inject(optional=false) String t;\n" + // don't complain here
			"    }\n" +
			"}\n",
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	@Inject(optional=true) @NonNull Object o;\n" + 
		"	                                       ^\n" + 
		"The @NonNull field o may not have been initialized\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 6)\n" + 
		"	@Inject(optional=true) String s;\n" + 
		"	                              ^\n" + 
		"The @NonNull field s may not have been initialized\n" + 
		"----------\n");
}

// Using javax.inject.Inject, slight variations
// [compiler] Null analysis for fields does not take @com.google.inject.Inject into account
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=400421
public void test_nonnull_field_17() {
	runNegativeTestWithLibs(
		new String[] {
			JAVAX_INJECT_NAME,
			JAVAX_INJECT_CONTENT,
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"import javax.inject.Inject;\n" +
			"public class X {\n" +
			"    @NonNull @Inject static String s; // warn since injection of static field is less reliable\n" + // variation: static field
			"    @NonNull @Inject @Deprecated Object o;\n" +
			"    public X() {}\n" + // variation: with explicit constructor
			"}\n",
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	@NonNull @Inject static String s; // warn since injection of static field is less reliable\n" + 
		"	                               ^\n" + 
		"The @NonNull field s may not have been initialized\n" + 
		"----------\n");
}

// access to a nullable field - field reference
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nullable_field_1() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable Object o = new Object();\n" +
			"    public String oString() {\n" +
			"         return this.o.toString();\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	return this.o.toString();\n" + 
		"	            ^\n" +
		potNPE_nullable("The field o") + 
		"----------\n");
}
// access to a nullable field - single name reference
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nullable_field_2() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable Object o = new Object();\n" +
			"    public String oString() {\n" +
			"         return o.toString();\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	return o.toString();\n" + 
		"	       ^\n" + 
		potNPE_nullable("The field o") +
		"----------\n");
}
// access to a nullable field - qualified name reference
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nullable_field_3() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable Object o = new Object();\n" +
			"    @Nullable X other;\n" +
			"    public String oString() {\n" +
			"         return other.o.toString();\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" +
		"1. ERROR in X.java (at line 6)\n" +
		"	return other.o.toString();\n" +
		"	       ^^^^^\n" +
		potNPE_nullable("The field other") +
		"----------\n" +
		"2. ERROR in X.java (at line 6)\n" +
		"	return other.o.toString();\n" +
		"	             ^\n" +
		potNPE_nullable("The field o") +
		"----------\n");
}
// access to a nullable field - qualified name reference - multiple segments
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nullable_field_3m() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable Object o = new Object();\n" +
			"    @Nullable X other;\n" +
			"    public String oString() {\n" +
			"         return other.other.o.toString();\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" +
		"1. ERROR in X.java (at line 6)\n" +
		"	return other.other.o.toString();\n" +
		"	       ^^^^^\n" +
		potNPE_nullable("The field other") +
		"----------\n" +
		"2. ERROR in X.java (at line 6)\n" +
		"	return other.other.o.toString();\n" +
		"	             ^^^^^\n" +
		potNPE_nullable("The field other") +
		"----------\n" +
		"3. ERROR in X.java (at line 6)\n" +
		"	return other.other.o.toString();\n" +
		"	                   ^\n" +
		potNPE_nullable("The field o") +
		"----------\n");
}
// access to a nullable field - dereference after check
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nullable_field_4() {
	// currently no flow analysis for fields is implemented,
	// but the direct sequence of null-check + dereference is optionally supported as a special case
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS, JavaCore.ENABLED);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable Object o = new Object();\n" +
			"    public String oString() {\n" +
			"         if (this.o != null)\n" +
			"             return this.o.toString();\n" + // silent after check
			"         if (o != null)\n" +
			"             return o.toString();\n" + // silent after check
			"         return \"\";\n" +
			"    }\n" +
			"    public String oString2() {\n" +
			"         String local = o.toString();\n" +
			"         if (this.o != null) {\n" +
			"             this.toString();\n" + // method call wipes null info
			"             return this.o.toString(); // warn here\n" +
			"         }\n" +
			"         return \"\";\n" +
			"    }\n" +
			"}\n"
		},
		options /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 12)\n" + 
		"	String local = o.toString();\n" + 
		"	               ^\n" + 
		potNPE_nullable("The field o") + 
		"----------\n" + 
		"2. ERROR in X.java (at line 15)\n" + 
		"	return this.o.toString(); // warn here\n" + 
		"	            ^\n" + 
		potNPE_nullable("The field o") + 
		"----------\n");
}

// access to a nullable field - intermediate component in a QNR
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nullable_field_5() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @NonNull Y y = new Y();\n" +
			"    public String oString() {\n" +
			"         return y.z.o.toString(); // pot.NPE on z\n" +
			"    }\n" +
			"}\n",
			"Y.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Y {\n" +
			"    @Nullable Z z = new Z();\n" +
			"}\n",
			"Z.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Z {\n" +
			"    @NonNull Object o = new Object();\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	return y.z.o.toString(); // pot.NPE on z\n" + 
		"	         ^\n" +
		potNPE_nullable("The field z") + 
		"----------\n");
}

// access to a nullable field - intermediate component in a QNR - inverse of test_nullable_field_5
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nullable_field_6() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable Y y = new Y();\n" +
			"    public String oString() {\n" +
			"         return y.z.o.toString(); // pot.NPE on y and o\n" +
			"    }\n" +
			"}\n",
			"Y.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Y {\n" +
			"    @NonNull Z z = new Z();\n" +
			"}\n",
			"Z.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Z {\n" +
			"    Object dummy;\n" + // ensure different interal fieldId
			"    @Nullable Object o = new Object();\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	return y.z.o.toString(); // pot.NPE on y and o\n" + 
		"	       ^\n" + 
		potNPE_nullable("The field y") + 
		"----------\n" + 
		"2. ERROR in X.java (at line 5)\n" + 
		"	return y.z.o.toString(); // pot.NPE on y and o\n" + 
		"	           ^\n" + 
		potNPE_nullable("The field o") + 
		"----------\n");
}

// access to a nullable field - intermediate component in a double field reference
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nullable_field_7() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable Y y = new Y();\n" +
			"    public String oString() {\n" +
			"         return this.y.o.toString(); // pot.NPE on y and o\n" +
			"    }\n" +
			"}\n",
			"Y.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Y {\n" +
			"    @Nullable Object o = new Object();\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	return this.y.o.toString(); // pot.NPE on y and o\n" + 
		"	            ^\n" +
		potNPE_nullable("The field y") + 
		"----------\n" + 
		"2. ERROR in X.java (at line 5)\n" + 
		"	return this.y.o.toString(); // pot.NPE on y and o\n" + 
		"	              ^\n" +
		potNPE_nullable("The field o") + 
		"----------\n");
}

// static access to a nullable field - qualified name reference
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nullable_field_8() {
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable static final Object o = null;\n" +
			"    public void foo() {\n" +
			"         if (X.o == null){\n" +
			"				System.out.println(X.o);\n" +
			"		  }\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
}

// illegal use of @Nullable for a field of primitive type
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nullable_field_9() {
	runNegativeTestWithLibs(
			new String[] {
				"X.java",
				"import org.eclipse.jdt.annotation.*;\n" +
				"public class X {\n" +
				"    @Nullable int i;\n" +
				"}\n"
			},
			null /*customOptions*/,
			"----------\n" + 
			"1. ERROR in X.java (at line 3)\n" + 
			"	@Nullable int i;\n" + 
			"	^^^^^^^^^\n" + 
			"The nullness annotation @Nullable is not applicable for the primitive type int\n" + 
			"----------\n");	
}

// protected access to nullable fields - different kinds of references
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nullable_field_10a() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS, JavaCore.ENABLED);
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable Object o1, o2, o3;\n" +
			"    @NonNull X x = new X();\n" +
			"    public void foo(X other) {\n" +
			"         if (other.o1 != null){\n" +						// qualified reference -> block
			"             System.out.println(other.o1.toString());\n" +
			"         }\n" +
			"         if (this.o2 != null)\n" + 						// field reference -> statement
			"             System.out.println(o2.toString());\n" +
			"         if (this.o2 != null)\n" + 						// identical field references
			"             System.out.println(this.o2.toString());\n" +
			"         System.out.println (null != o3 ? o3.toString() : \"nothing\");\n" + // ternary
			"         if (this.x.o1 != null)\n" +						// nested field reference ...
			"             System.out.println(x.o1.toString());\n" + 	// ... equiv qualified name reference
			"         if (x.o1 != null)\n" +							// qualified name reference ...
			"             System.out.println(this.x.o1.toString());\n" +// ... equiv nested field reference
			"         if (this.x.o1 != null)\n" +						// identical nested field references
			"             System.out.println(this.x.o1.toString());\n" +
			"    }\n" +
			"}\n"
		},
		options,
		"");
}

// protected access to nullable fields - different kinds of references - option not enabled
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nullable_field_10b() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS, JavaCore.DISABLED);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable Object o1, o2, o3;\n" +
			"    @NonNull X x = new X();\n" +
			"    public void foo(X other) {\n" +
			"         if (other.o1 != null){\n" +						// qualified reference -> block
			"             System.out.println(other.o1.toString());\n" +
			"         }\n" +
			"         if (this.o2 != null)\n" + 						// field reference -> statement
			"             System.out.println(o2.toString());\n" +
			"         if (this.o2 != null)\n" + 						// identical field references
			"             System.out.println(this.o2.toString());\n" +
			"         System.out.println (null != o3 ? o3.toString() : \"nothing\");\n" + // ternary
			"         if (this.x.o1 != null)\n" +						// nested field reference ...
			"             System.out.println(x.o1.toString());\n" + 	// ... equiv qualified name reference
			"         if (x.o1 != null)\n" +							// qualified name reference ...
			"             System.out.println(this.x.o1.toString());\n" +// ... equiv nested field reference
			"         if (this.x.o1 != null)\n" +						// identical nested field references
			"             System.out.println(this.x.o1.toString());\n" +
			"    }\n" +
			"}\n"
		},
		options,
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	System.out.println(other.o1.toString());\n" + 
		"	                         ^^\n" + 
		potNPE_nullable("The field o1") + 
		"----------\n" + 
		"2. ERROR in X.java (at line 10)\n" + 
		"	System.out.println(o2.toString());\n" + 
		"	                   ^^\n" + 
		potNPE_nullable("The field o2") + 
		"----------\n" + 
		"3. ERROR in X.java (at line 12)\n" + 
		"	System.out.println(this.o2.toString());\n" + 
		"	                        ^^\n" + 
		potNPE_nullable("The field o2") + 
		"----------\n" + 
		"4. ERROR in X.java (at line 13)\n" + 
		"	System.out.println (null != o3 ? o3.toString() : \"nothing\");\n" + 
		"	                                 ^^\n" + 
		potNPE_nullable("The field o3") + 
		"----------\n" + 
		"5. ERROR in X.java (at line 15)\n" + 
		"	System.out.println(x.o1.toString());\n" + 
		"	                     ^^\n" + 
		potNPE_nullable("The field o1") + 
		"----------\n" + 
		"6. ERROR in X.java (at line 17)\n" + 
		"	System.out.println(this.x.o1.toString());\n" + 
		"	                          ^^\n" + 
		potNPE_nullable("The field o1") + 
		"----------\n" + 
		"7. ERROR in X.java (at line 19)\n" + 
		"	System.out.println(this.x.o1.toString());\n" + 
		"	                          ^^\n" + 
		potNPE_nullable("The field o1") + 
		"----------\n");
}

// protected access to nullable fields - different boolean operators
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nullable_field_10c() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS, JavaCore.ENABLED);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable Object o1, o2, o3;\n" +
			"    public void foo(X other) {\n" +
			"         if (o1 != null && o2 != null & o3 != null) \n" + // conjunction: OK
			"             System.out.println(o2.toString());\n" +
			"         if (o1 != null || o2 != null || o3 != null) \n" +
			"             System.out.println(o2.toString()); // warn here: disjunktion is no protection\n" +
			"         if (!(o1 != null)) \n" +
			"             System.out.println(o1.toString()); // warn here: negated inequality is no protection\n" +
			"         if (!(o1 == null || o2 == null)) \n" +
			"             System.out.println(o1.toString()); // don't warn here\n" +
			"         if (!(o1 == null && o2 == null)) \n" +
			"             System.out.println(o2.toString()); // warn here: negated conjunction is no protection\n" +
			"         if (!(!(o1 == null))) \n" +
			"             System.out.println(o1.toString()); // warn here: double negation is no protection\n" +
			"         if (!(!(o1 != null && o2 != null))) \n" +
			"             System.out.println(o1.toString()); // don't warn here\n" +
			"    }\n" +
			"}\n"
		},
		options,
		"----------\n" +
		"1. ERROR in X.java (at line 8)\n" +
		"	System.out.println(o2.toString()); // warn here: disjunktion is no protection\n" +
		"	                   ^^\n" +
		potNPE_nullable("The field o2") +
		"----------\n" +
		"2. ERROR in X.java (at line 10)\n" +
		"	System.out.println(o1.toString()); // warn here: negated inequality is no protection\n" +
		"	                   ^^\n" +
		potNPE_nullable("The field o1") +
		"----------\n" +
		"3. ERROR in X.java (at line 14)\n" +
		"	System.out.println(o2.toString()); // warn here: negated conjunction is no protection\n" +
		"	                   ^^\n" +
		potNPE_nullable("The field o2") +
		"----------\n" +
		"4. ERROR in X.java (at line 16)\n" +
		"	System.out.println(o1.toString()); // warn here: double negation is no protection\n" +
		"	                   ^^\n" +
		potNPE_nullable("The field o1") +
		"----------\n");
}

// protected access to nullable fields - assignment as expression
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nullable_field_10d() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS, JavaCore.ENABLED);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable Object o1;\n" +
			"    public void foo(@NonNull X other, X last) {\n" +
			"         o1 = other;\n" +		// reference test case: assignment as statement
			"         if (o1 == last) \n" +	// no expiry
			"             System.out.println(o1.toString());\n" +
			"         if ((o1 = other) == last) \n" + // no expiry
			"             System.out.println(o1.toString());\n" +
			"         if ((o1 = other) == last) {\n" +
			"             o1 = null;\n" + // expire here
			"             System.out.println(o1.toString()); // info is expired\n" +
			"         }\n" +
			"    }\n" +
			"}\n"
		},
		options,
		"----------\n" + 
		"1. ERROR in X.java (at line 12)\n" + 
		"	System.out.println(o1.toString()); // info is expired\n" + 
		"	                   ^^\n" + 
		potNPE_nullable("The field o1") + 
		"----------\n");
}

// protected access to nullable fields - distinguish local and field
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nullable_field_10e() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS, JavaCore.ENABLED);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"class Y {\n" +
			"    @Nullable Object o2;\n" +
			"    void bar(Object o2) {\n" +
			"        if (o2 != null)\n" +
			"            System.out.println(this.o2.toString()); // field access is not protected\n" +
			"    }\n" +
			"}\n" +
			"public class X {\n" +
			"    @NonNull Y o1 = new Y();\n" +
			"    public void foo() {\n" +
			"         Y o1 = new Y();\n" +
			"         if (o1.o2 != null) \n" +	// check via local
			"             System.out.println(this.o1.o2.toString()); // field access via other field not protected\n" +
			"         if (this.o1.o2 != null) \n" +	// check via field
			"             System.out.println(o1.o2.toString()); // field access via local not protected\n" +
			"    }\n" +
			"}\n"
		},
		options,
		"----------\n" + 
		"1. WARNING in X.java (at line 4)\n" + 
		"	void bar(Object o2) {\n" + 
		"	                ^^\n" + 
		"The parameter o2 is hiding a field from type Y\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 6)\n" + 
		"	System.out.println(this.o2.toString()); // field access is not protected\n" + 
		"	                        ^^\n" + 
		potNPE_nullable("The field o2") + 
		"----------\n" + 
		"3. WARNING in X.java (at line 12)\n" + 
		"	Y o1 = new Y();\n" + 
		"	  ^^\n" + 
		"The local variable o1 is hiding a field from type X\n" + 
		"----------\n" + 
		"4. ERROR in X.java (at line 14)\n" + 
		"	System.out.println(this.o1.o2.toString()); // field access via other field not protected\n" + 
		"	                           ^^\n" + 
		potNPE_nullable("The field o2") + 
		"----------\n" + 
		"5. ERROR in X.java (at line 16)\n" + 
		"	System.out.println(o1.o2.toString()); // field access via local not protected\n" + 
		"	                      ^^\n" + 
		potNPE_nullable("The field o2") + 
		"----------\n");
}

// protected access to nullable fields - duplicate comparison
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nullable_field_10f() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS, JavaCore.ENABLED);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable Object o1;\n" +
			"    public void foo(X other) {\n" +
			"         if (o1 != null && o1 != null) // second term is redundant\n" +
			"             System.out.println(o1.toString());\n" +
			"         if (o1 != null)\n" +
			"             if (o1 != null) // this if is redundant\n" +
			"                 System.out.println(o1.toString());\n" +
			"    }\n" +
			"}\n"
		},
		options,
		"----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	if (o1 != null && o1 != null) // second term is redundant\n" + 
		"	                  ^^\n" + 
		"Redundant null check: The field o1 cannot be null at this location (ignoring concurrency)\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 8)\n" + 
		"	if (o1 != null) // this if is redundant\n" + 
		"	    ^^\n" + 
		"Redundant null check: The field o1 cannot be null at this location (ignoring concurrency)\n" + 
		"----------\n");
}

// combined test from comment 20 in https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nullable_field_11() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS, JavaCore.ENABLED);
	runConformTestWithLibs(
			new String[] {
				"X.java",
				"import org.eclipse.jdt.annotation.*;\n" +
				"class X {\n" + 
				"    @Nullable Object o;\n" + 
				"    public @NonNull Object foo(X x) {\n" + 
				"    	return  x.o != null ? x.o : new Object();\n" + 
				"	 }\n" + 
				"    public void goo(X x) {\n" + 
				"    	if (x.o != null) {\n" + 
				"    		x.o.toString();\n" + 
				"    	}\n" + 
				"    }\n" + 
				"    public void boo(X x) {\n" + 
				"    	if (x.o instanceof String) {\n" + 
				"    		x.o.toString();\n" + 
				"    	}\n" + 
				"    }\n" + 
				"    public void zoo(X x) {\n" + 
				"    	x.o = new Object();\n" + 
				"    	System.out.println(\"hashCode of new Object = \" + x.o.hashCode());\n" + 
				"    }\n" + 
				"    public void doo(X x) {\n" + 
				"    	x.o = foo(x); // foo is guaranteed to return @NonNull Object.\n" + 
				"    	System.out.println(\"hashCode of new Object = \" + x.o.hashCode());\n" + 
				"    }\n" + 
				"}\n"
			},
			options,
			"");
}

// combined test from comment 20 in https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
//  - version with 'this' field references
public void test_nullable_field_11a() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS, JavaCore.ENABLED);
	runConformTestWithLibs(
			new String[] {
				"X.java",
				"import org.eclipse.jdt.annotation.*;\n" +
				"class X {\n" + 
				"    @Nullable Object o;\n" + 
				"    public @NonNull Object foo() {\n" + 
				"    	return  o != null ? o : new Object();\n" + 
				"    }\n" + 
				"    public void goo() {\n" + 
				"    	if (o != null) {\n" + 
				"    		o.toString();\n" + 
				"    	}\n" + 
				"    }\n" + 
				"    public void boo() {\n" + 
				"    	if (o instanceof String) {\n" + 
				"    		o.toString();\n" + 
				"    	}\n" + 
				"    }\n" + 
				"    public void zoo() {\n" + 
				"    	o = new Object();\n" + 
				"    	System.out.println(\"hashCode of new Object = \" + o.hashCode());\n" + 
				"    }\n" + 
				"    public void doo() {\n" + 
				"    	o = foo(); // foo is guaranteed to return @NonNull Object.\n" + 
				"    	System.out.println(\"hashCode of new Object = \" + o.hashCode());\n" + 
				"    }\n" + 
				"}\n"
			},
			options,
			"");
}

// protected access to nullable field - expiration of information
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nullable_field_12() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS, JavaCore.ENABLED);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable Object o1, o2, o3, o4;\n" +
			"    public void foo(X other) {\n" +
			"         if (other.o1 != null){\n" +
			"				System.out.println(goo()+other.o1.toString()); // warn here: expired by call to goo()\n" +
			"		  }\n" +
			"         Object x = o2 != null ? o2 : o1;\n" +
			"         System.out.println(o2.toString()); // warn here: not protected\n" +
			"         if (o3 != null) /*nop*/;\n" +
			"         System.out.println(o3.toString()); // warn here: expired by empty statement\n" +
			"         if (o4 != null && hoo())\n" +
			"             System.out.println(o4.toString()); // warn here: expired by call to hoo()\n" +
			"    }\n" +
			"    String goo() { return \"\"; }\n" +
			"    boolean hoo() { return false; }\n" +
			"}\n"
		},
		options,
		"----------\n" + 
		"1. ERROR in X.java (at line 6)\n" + 
		"	System.out.println(goo()+other.o1.toString()); // warn here: expired by call to goo()\n" + 
		"	                               ^^\n" + 
		potNPE_nullable("The field o1") + 
		"----------\n" + 
		"2. ERROR in X.java (at line 9)\n" + 
		"	System.out.println(o2.toString()); // warn here: not protected\n" +
		"	                   ^^\n" + 
		potNPE_nullable("The field o2") +
		"----------\n" +
		"3. ERROR in X.java (at line 11)\n" + 
		"	System.out.println(o3.toString()); // warn here: expired by empty statement\n" + 
		"	                   ^^\n" + 
		potNPE_nullable("The field o3") + 
		"----------\n" + 
		"4. ERROR in X.java (at line 13)\n" + 
		"	System.out.println(o4.toString()); // warn here: expired by call to hoo()\n" + 
		"	                   ^^\n" + 
		potNPE_nullable("The field o4") + 
		"----------\n");
}

// example from comment 47
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nullable_field_13() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS, JavaCore.ENABLED);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable Object o1;\n" +
			"    @NonNull Object o2 = new Object();\n" +
			"    public void foo(X other) {\n" +
			"         if (other.o1 == null){\n" +
			"				this.o2 = other.o1; // warn here: assign @Nullable to @NonNull\n" +
			"		  }\n" +
			"    }\n" +
			"}\n"
		},
		options,
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	this.o2 = other.o1; // warn here: assign @Nullable to @NonNull\n" + 
		"	          ^^^^^^^^\n" + 
		mismatch_NonNull_Nullable("Object") + 
		"----------\n");
}

// access to a nullable field - protected by check against a @NonNull value
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nullable_field_14() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS, JavaCore.ENABLED);
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable Object o = new Object();\n" +
			"    public String oString(@NonNull Object a) {\n" +
			"         if (this.o == a)\n" +
			"             return this.o.toString();\n" + // silent after check
			"         return \"\";\n" +
			"    }\n" +
			"}\n"
		},
		options,
		"");
}

// access to a nullable field - not protected by negative check against a @NonNull value
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=331649
public void test_nullable_field_14a() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS, JavaCore.ENABLED);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable Object o = new Object();\n" +
			"    public String oString(@NonNull Object a) {\n" +
			"         if (this.o != a)\n" +
			"             return this.o.toString(); // warn here, check has no effect\n" +
			"         return \"\";\n" +
			"    }\n" +
			"}\n"
		},
		options,
		"----------\n" + 
		"1. ERROR in X.java (at line 6)\n" + 
		"	return this.o.toString(); // warn here, check has no effect\n" + 
		"	            ^\n" + 
		potNPE_nullable("The field o") + 
		"----------\n");
}

// https://bugs.eclipse.org/401017: [compiler][null] casted reference to @Nullable field lacks a warning
public void test_nullable_field_15() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable\n" + 
			"    private Object nullable;\n" + 
			"\n" + 
			"    public void test() {\n" + 
			"        if (nullable instanceof Number) {\n" + 
			"            ((Number)nullable).intValue(); // A\n" + 
			"        }\n" + 
			"        if (nullable != null) {\n" + 
			"            nullable.toString(); // B\n" + 
			"        }\n" + 
			"        nullable.toString(); // C\n" + 
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 8)\n" + 
		"	((Number)nullable).intValue(); // A\n" + 
		"	         ^^^^^^^^\n" + 
		potNPE_nullable("The field nullable") + 
		"----------\n" + 
		"2. ERROR in X.java (at line 11)\n" + 
		"	nullable.toString(); // B\n" + 
		"	^^^^^^^^\n" + 
		potNPE_nullable("The field nullable") + 
		"----------\n" + 
		"3. ERROR in X.java (at line 13)\n" + 
		"	nullable.toString(); // C\n" + 
		"	^^^^^^^^\n" + 
		potNPE_nullable("The field nullable") + 
		"----------\n");
}
// an enum is declared within the scope of a null-default
// https://bugs.eclipse.org/331649#c61
public void test_enum_field_01() {
	runConformTestWithLibs(
		new String[] {
			"tests/X.java",
			"package tests;\n" +
			"@org.eclipse.jdt.annotation.NonNullByDefault\n" +
			"public class X {\n" +
			"    enum A { B }\n" +
			"    public static void main(String ... args) {\n" +
			"         System.out.println(A.B);\n" +
			"    }\n" +
			"}\n"
		},
		null,
		"",
		"B");
}

// Bug 380896 - Enum constants not recognised as being NonNull.
// see also https://bugs.eclipse.org/331649#c61
public void test_enum_field_02() {
	runConformTestWithLibs(
		new String[] {
			"tests/X.java",
			"package tests;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    enum A { B }\n" +
			"    public static void main(String ... args) {\n" +
			"         test(A.B);\n" +
			"    }\n" +
			"    static void test(@NonNull A a) {\n" +
			"        System.out.println(a.ordinal());\n" +
			"    }\n" +
			"}\n"
		},
		null,
		"",
		"0");
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=372011
// Test whether @NonNullByDefault on a binary package or an enclosing type is respected from enclosed elements.
public void testBug372011() {
	String path = this.getCompilerTestsPluginDirectoryPath() + File.separator + "workspace" + File.separator + "Test372011.jar";
	String[] libs = new String[this.LIBS.length + 1];
	System.arraycopy(this.LIBS, 0, libs, 0, this.LIBS.length);
	libs[this.LIBS.length] = path;
	runNegativeTest(
		new String[] {
			"X.java",
			  "import p11.T11;\n" +
			  "import p12.T12;\n" + 
			  "import p12.T12a;\n" +
			  "import p12.Public;\n" +
			  "public class X {\n" +
			  "	  void foo() {\n" +
			  "     new T11().t11foo(null);\n" +
			  "     new T12().new T122().foo122(null);\n" +
			  "   }\n" +
			  "	  void trigger1 (Public o){\n" +
			  "			o.bar(null);\n" +
			  "	  }\n" +
			  "	  @org.eclipse.jdt.annotation.NonNull Object foo2() {\n" +
			  "		new T12a().foo12a(new Object());\n" +  // don't complain
			  "     new T12().new T122().new T1222().foo1222(null);\n" +
			  "     return new T11().retSomething();\n" +  // don't complain
			  "   }\n" +
			  "}\n"},
	    "----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	new T11().t11foo(null);\n" + 
		"	                 ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 8)\n" + 
		"	new T12().new T122().foo122(null);\n" + 
		"	                            ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 11)\n" + 
		"	o.bar(null);\n" + 
		"	      ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n" + 
		"4. ERROR in X.java (at line 15)\n" + 
		"	new T12().new T122().new T1222().foo1222(null);\n" + 
		"	                                         ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n",
		libs,
		true /* shouldFlush*/);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=374129  - more tests for bug 372011
// Test whether @NonNullByDefault on a binary package or an enclosing type is respected from enclosed elements.
public void testBug374129() {
	String path = this.getCompilerTestsPluginDirectoryPath() + File.separator + "workspace" + File.separator + "Test374129"+this.TEST_JAR_SUFFIX;
	/* content of Test372129.jar:
	 	p1bin/package-info.java:
	 		@org.eclipse.jdt.annotation.NonNullByDefault
			package p1bin;
		p1bin/C1bin.java:
			package p1bin;
			import org.eclipse.jdt.annotation.Nullable;
			public class C1bin {
				public String getId(String id, @Nullable String n) {
					return id;
				}
				public static class C1binInner {
					public String getId(String id, @Nullable String n) {
						return id;
					}		
				}
			}
		p2bin/C2bin.java:
			package p2bin;
			import org.eclipse.jdt.annotation.NonNullByDefault;
			import org.eclipse.jdt.annotation.Nullable;
			@NonNullByDefault
			public class C2bin {
				public String getId(String id, @Nullable String n) {
					return id;
				}
				@NonNullByDefault(false)
				public static class C2binInner {
					public String getId(String id, @Nullable String n) {
						return id;
					}		
				}
			}
		p2bin/C3bin.java:
			package p2bin;
			import org.eclipse.jdt.annotation.NonNullByDefault;
			import org.eclipse.jdt.annotation.Nullable;
			public class C3bin {
				@NonNullByDefault public String getId(String id, @Nullable String n) {
					return id;
				}			
			}
	 */
	String[] libs = new String[this.LIBS.length + 1];
	System.arraycopy(this.LIBS, 0, libs, 0, this.LIBS.length);
	libs[this.LIBS.length] = path;
	runNegativeTest(
		new String[] {
			"bug374129/Test.java",
				"package bug374129;\n" + 
				"\n" + 
				"import org.eclipse.jdt.annotation.NonNull;\n" + 
				"import org.eclipse.jdt.annotation.Nullable;\n" + 
				"\n" + 
				"import p1bin.C1bin;\n" + 
				"import p1bin.C1bin.C1binInner;\n" + 
				"import p2bin.C2bin;\n" + 
				"import p2bin.C2bin.C2binInner;\n" + 
				"import p2bin.C3bin;\n" + 
				"\n" + 
				"public class Test {\n" + 
				"	static C1bin c1 = new C1bin();\n" + 
				"	static C1binInner c1i = new C1binInner();\n" + 
				"	static C2bin c2 = new C2bin();\n" + 
				"	static C2binInner c2i = new C2binInner();\n" + 
				"	static C3bin c3 = new C3bin();\n" + 
				"	\n" + 
				"	public static void main(String[] args) {\n" + 
				"		@Nullable String n = getN();\n" + 
				"		@NonNull String s;\n" + 
				"		s = c1.getId(n, n); // error on first arg (package default)\n" + 
				"		s = c1i.getId(n, n); // error on first arg (package default propagated into inner)\n" + 
				"		s = c2.getId(n, n); // error on first arg (type default)\n" + 
				"		s = c2i.getId(n, n); // no arg error (canceled default), return requires unchecked conversion\n" + 
				"		s = c3.getId(n, n); // error on first arg (method default)\n" + 
				"	}\n" + 
				"	static String getN() { return null; }\n" + 
				"}\n" + 
				"\n"},
			"----------\n" + 
			"1. ERROR in bug374129\\Test.java (at line 22)\n" + 
			"	s = c1.getId(n, n); // error on first arg (package default)\n" + 
			"	             ^\n" + 
			mismatch_NonNull_Nullable("String") + 
			"----------\n" + 
			"2. ERROR in bug374129\\Test.java (at line 23)\n" + 
			"	s = c1i.getId(n, n); // error on first arg (package default propagated into inner)\n" + 
			"	              ^\n" + 
			mismatch_NonNull_Nullable("String") + 
			"----------\n" + 
			"3. ERROR in bug374129\\Test.java (at line 24)\n" + 
			"	s = c2.getId(n, n); // error on first arg (type default)\n" + 
			"	             ^\n" + 
			mismatch_NonNull_Nullable("String") + 
			"----------\n" + 
			"4. WARNING in bug374129\\Test.java (at line 25)\n" + 
			"	s = c2i.getId(n, n); // no arg error (canceled default), return requires unchecked conversion\n" + 
			"	    ^^^^^^^^^^^^^^^\n" + 
			nullTypeSafety() + "The expression of type 'String' needs unchecked conversion to conform to \'@NonNull String\'\n" + 
			"----------\n" + 
			"5. ERROR in bug374129\\Test.java (at line 26)\n" + 
			"	s = c3.getId(n, n); // error on first arg (method default)\n" + 
			"	             ^\n" + 
			mismatch_NonNull_Nullable("String") + 
			"----------\n",
		libs,
		true /* shouldFlush*/);
}

// Bug 385626 - @NonNull fails across loop boundaries
public void testBug385626_1() {
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"import java.util.ArrayList;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    void test() {\n" +
			"        for (Integer i : new ArrayList<Integer>()) {\n" +
			"            if (i != null) {\n" +
			"                for (Integer j : new ArrayList<Integer>()) {\n" +
			"                    if (j != null) {\n" +
			"                        @NonNull Integer j1 = i; // bogus error was here\n" +
			"                    }\n" +
			"                }\n" + 
			"            }\n" +
			"        }\n" +
			"    }\n" +
			"}\n"
		},
		null,//options
		"");
}

// Bug 385626 - @NonNull fails across loop boundaries
public void testBug385626_2() {
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"import java.util.ArrayList;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    void test(Integer j) {\n" +
			"        for (Integer i : new ArrayList<Integer>()) {\n" +
			"            if (i != null) {\n" +
			"                try {\n" +
			"                    if (j != null) {\n" +
			"                        @NonNull Integer j1 = i;\n" +
			"                    }\n" +
			"                } finally {\n" +
			"                    if (j != null) {\n" +
			"                        @NonNull Integer j1 = i; // bogus error was here\n" +
			"                    }\n" +
			"                }\n" + 
			"            }\n" +
			"        }\n" +
			"    }\n" +
			"}\n"
		},
		null,//options
		"");
}

// Bug 388630 - @NonNull diagnostics at line 0
// synthetic constructor must repeat null annotations of its super
public void testBug388630_1() {
	runConformTestWithLibs(
		new String[] {
			"C0.java",
			"import org.eclipse.jdt.annotation.NonNull;\n" + 
			"public class C0 {\n" + 
			"	C0 (@NonNull Object o) { }\n" + 
			"	void test() { }\n" + 
			"}\n",
			"X.java",
			"public class X {\n" + 
			"	void foo() {\n" + 
			"		new C0(\"\") { }.test();\n" + 
			"	}\n" + 
			"}\n"
		},
		null,
		"");
}

// Bug 388630 - @NonNull diagnostics at line 0
// additionally also references to outer variables must share their nullness
public void testBug388630_2() {
	runNegativeTestWithLibs(
		new String[] {
			"C0.java",
			"import org.eclipse.jdt.annotation.NonNull;\n" + 
			"public class C0 {\n" + 
			"	C0 (@NonNull Object o) { }\n" + 
			"	void test() { }\n" + 
			"}\n",
			"X.java",
			"import org.eclipse.jdt.annotation.Nullable;\n" + 
			"public class X {\n" + 
			"	void foo(final @Nullable Object a) {\n" + 
			"		new C0(\"\") {\n" +
			"           @Override\n" +
			"           void test() {\n" +
			"               System.out.println(a.toString());\n" +
			"               super.test();\n" +
			"           }\n" +
			"       }.test();\n" + 
			"	}\n" + 
			"}\n"
		},
		null,
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	System.out.println(a.toString());\n" + 
		"	                   ^\n" + 
		variableMayBeNull("a") + 
		"----------\n");
}

/* Content of Test388281.jar used in the following tests:

// === package i (explicit annotations): ===
package i;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
public interface I {
    @NonNull Object m1(@Nullable Object a1);
    @Nullable String m2(@NonNull Object a2);
	Object m1(@Nullable Object o1, Object o2);
}

// === package  i2 with package-info.java (default annot, canceled in one type): ===
@org.eclipse.jdt.annotation.NonNullByDefault
package i2;

package i2;
public interface I2 {
    Object m1(Object a1);
    String m2(Object a2);
}

package i2;
public interface II extends i.I {
	String m1(Object o1, Object o2);
}

package i2;
import org.eclipse.jdt.annotation.NonNullByDefault;
@NonNullByDefault({})
public interface I2A {
    Object m1(Object a1);
    String m2(Object a2);
}

// === package c (no null annotations): ===
package c;
public class C1 implements i.I {
	public Object m1(Object a1) {
		System.out.println(a1.toString()); // (1)
		return null; // (2)
	}
	public String m2(Object a2) {
		System.out.println(a2.toString());
		return null;
	}
	public Object m1(Object o1, Object o2) {
		return null;
	}
}

package c;
public class C2 implements i2.I2 {
	public Object m1(Object a1) {
		return a1;
	}
	public String m2(Object a2) {
		return a2.toString();
	}
}
 */
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=388281
// Test whether null annotations from a super interface are respected
// Class and its super interface both read from binary
public void testBug388281_01() {
	String path = this.getCompilerTestsPluginDirectoryPath() + File.separator + "workspace" + File.separator + "Test388281"+this.TEST_JAR_SUFFIX;
	String[] libs = new String[this.LIBS.length + 1];
	System.arraycopy(this.LIBS, 0, libs, 0, this.LIBS.length);
	libs[this.LIBS.length] = path;
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_INHERIT_NULL_ANNOTATIONS, JavaCore.ENABLED);
	runNegativeTest(
		new String[] {
			"Client.java",
			"import c.C1;\n" +
			"public class Client {\n" + 
			"    void test(C1 c) {\n" + 
			"         String s = c.m2(null);               // (3)\n" + 
			"         System.out.println(s.toUpperCase()); // (4)\n" + 
			"    }\n" + 
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in Client.java (at line 4)\n" + 
		"	String s = c.m2(null);               // (3)\n" + 
		"	                ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n" + 
		"2. ERROR in Client.java (at line 5)\n" + 
		"	System.out.println(s.toUpperCase()); // (4)\n" + 
		"	                   ^\n" + 
		"Potential null pointer access: The variable s may be null at this location\n" + 
		"----------\n",
		libs,
		true /* shouldFlush*/,
		options);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=388281
// Test whether null annotations from a super interface are respected
// Class from source, its supers (class + super interface) from binary
public void testBug388281_02() {
	String path = this.getCompilerTestsPluginDirectoryPath() + File.separator + "workspace" + File.separator + "Test388281"+this.TEST_JAR_SUFFIX;
	String[] libs = new String[this.LIBS.length + 1];
	System.arraycopy(this.LIBS, 0, libs, 0, this.LIBS.length);
	libs[this.LIBS.length] = path;
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_INHERIT_NULL_ANNOTATIONS, JavaCore.ENABLED);
	runNegativeTest(
		new String[] {
			"ctest/C.java",
			"package ctest;\n" +
			"public class C extends c.C1 {\n" +
			"    @Override\n" +
			"    public Object m1(Object a1) {\n" + 
			"         System.out.println(a1.toString());   // (1)\n" + 
			"         return null;                         // (2)\n" + 
			"    }\n" +
			"    @Override\n" +
			"    public String m2(Object a2) {\n" + 
			"         System.out.println(a2.toString());\n" + 
			"         return null;\n" + 
			"    }\n" +
			"}\n",
			"Client.java",
			"import ctest.C;\n" +
			"public class Client {\n" + 
			"    void test(C c) {\n" + 
			"         String s = c.m2(null);               // (3)\n" + 
			"         System.out.println(s.toUpperCase()); // (4)\n" + 
			"    }\n" + 
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in ctest\\C.java (at line 5)\n" + 
		"	System.out.println(a1.toString());   // (1)\n" + 
		"	                   ^^\n" +
		potNPE_nullable_maybenull("The variable a1") +
		"----------\n" + 
		"2. ERROR in ctest\\C.java (at line 6)\n" + 
		"	return null;                         // (2)\n" + 
		"	       ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n" + 
		"----------\n" +
		"1. ERROR in Client.java (at line 4)\n" + 
		"	String s = c.m2(null);               // (3)\n" + 
		"	                ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n" + 
		"2. ERROR in Client.java (at line 5)\n" + 
		"	System.out.println(s.toUpperCase()); // (4)\n" + 
		"	                   ^\n" + 
		"Potential null pointer access: The variable s may be null at this location\n" + 
		"----------\n",
		libs,
		true /* shouldFlush*/,
		options);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=388281
// Test whether null annotations from a super interface trigger an error against the overriding implementation
// Class from source, its super interface from binary
public void testBug388281_03() {
	String path = this.getCompilerTestsPluginDirectoryPath() + File.separator + "workspace" + File.separator + "Test388281"+this.TEST_JAR_SUFFIX;
	String[] libs = new String[this.LIBS.length + 1];
	System.arraycopy(this.LIBS, 0, libs, 0, this.LIBS.length);
	libs[this.LIBS.length] = path;
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_INHERIT_NULL_ANNOTATIONS, JavaCore.ENABLED);
	runNegativeTest(
		new String[] {
			"ctest/C.java",
			"package ctest;\n" +
			"public class C implements i.I {\n" +
			"    public Object m1(Object a1) {\n" + 
			"         System.out.println(a1.toString());   // (1)\n" + 
			"         return null;                         // (2)\n" + 
			"    }\n" +
			"    public String m2(Object a2) {\n" + 
			"         System.out.println(a2.toString());\n" + 
			"         return null;\n" + 
			"    }\n" +
			"    public Object m1(Object a1, Object a2) {\n" +
			"        System.out.println(a1.toString());   // (3)\n" +
			"        return null;\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in ctest\\C.java (at line 4)\n" + 
		"	System.out.println(a1.toString());   // (1)\n" + 
		"	                   ^^\n" +
		potNPE_nullable_maybenull("The variable a1") +
		"----------\n" + 
		"2. ERROR in ctest\\C.java (at line 5)\n" + 
		"	return null;                         // (2)\n" + 
		"	       ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n" + 
		"3. ERROR in ctest\\C.java (at line 12)\n" + 
		"	System.out.println(a1.toString());   // (3)\n" + 
		"	                   ^^\n" +
		potNPE_nullable_maybenull("The variable a1") +
		"----------\n",
		libs,		
		true /* shouldFlush*/,
		options);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=388281
// Do inherit even if one parameter/return is annotated
// also features some basic overloading
public void testBug388281_04() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_INHERIT_NULL_ANNOTATIONS, JavaCore.ENABLED);
	runNegativeTestWithLibs(
		true /* shouldFlush*/,
		new String[] {
			"i/I.java",
			"package i;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public interface I {\n" +
			"    @NonNull Object m1(@NonNull Object s1, @Nullable String s2);\n" +
			"    @Nullable Object m1(@Nullable String s1, @NonNull Object s2);\n" +
			"}\n",
			"ctest/C.java",
			"package ctest;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class C implements i.I {\n" +
			"    public Object m1(@Nullable Object o1, String s2) {\n" + 
			"         System.out.println(s2.toString());   // (1)\n" + 
			"         return null;                         // (2)\n" + 
			"    }\n" +
			"    public @NonNull Object m1(String s1, Object o2) {\n" + 
			"         System.out.println(s1.toString());   // (3)\n" + 
			"         return new Object();\n" + 
			"    }\n" +
			"}\n"
		},
		options,
		"----------\n" + 
		"1. ERROR in ctest\\C.java (at line 5)\n" + 
		"	System.out.println(s2.toString());   // (1)\n" + 
		"	                   ^^\n" + 
		variableMayBeNull("s2") +
		"----------\n" + 
		"2. ERROR in ctest\\C.java (at line 6)\n" + 
		"	return null;                         // (2)\n" + 
		"	       ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n" + 
		"3. ERROR in ctest\\C.java (at line 9)\n" + 
		"	System.out.println(s1.toString());   // (3)\n" + 
		"	                   ^^\n" + 
		variableMayBeNull("s1") +
		"----------\n");
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=388281
// Test whether null annotations from a super interface trigger an error against the overriding implementation
// Class from source, its super interface from binary
// Super interface subject to package level @NonNullByDefault
public void testBug388281_05() {
	String path = this.getCompilerTestsPluginDirectoryPath() + File.separator + "workspace" + File.separator + "Test388281"+this.TEST_JAR_SUFFIX;
	String[] libs = new String[this.LIBS.length + 1];
	System.arraycopy(this.LIBS, 0, libs, 0, this.LIBS.length);
	libs[this.LIBS.length] = path;
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_INHERIT_NULL_ANNOTATIONS, JavaCore.ENABLED);
	runNegativeTest(
		new String[] {
			"ctest/C.java",
			"package ctest;\n" +
			"public class C implements i2.I2 {\n" +
			"    public Object m1(Object a1) {\n" + 
			"         System.out.println(a1.toString());   // silent\n" + 
			"         return null;                         // (1)\n" + 
			"    }\n" +
			"    public String m2(Object a2) {\n" + 
			"         System.out.println(a2.toString());\n" + 
			"         return null;						   // (2)\n" + 
			"    }\n" +
			"}\n",
			"Client.java",
			"import ctest.C;\n" +
			"public class Client {\n" + 
			"    void test(C c) {\n" + 
			"         String s = c.m2(null);               // (3)\n" + 
			"    }\n" + 
			"}\n"			
		},
		"----------\n" + 
		"1. ERROR in ctest\\C.java (at line 5)\n" + 
		"	return null;                         // (1)\n" + 
		"	       ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n" + 
		"2. ERROR in ctest\\C.java (at line 9)\n" + 
		"	return null;						   // (2)\n" + 
		"	       ^^^^\n" + 
		"Null type mismatch: required \'@NonNull String\' but the provided value is null\n" + 
		"----------\n" +
		"----------\n" + 
		"1. ERROR in Client.java (at line 4)\n" + 
		"	String s = c.m2(null);               // (3)\n" + 
		"	                ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n",
		libs,		
		true /* shouldFlush*/,
		options);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=388281
// Conflicting annotations from several indirect super interfaces must be detected
public void testBug388281_06() {
	String path = this.getCompilerTestsPluginDirectoryPath() + File.separator + "workspace" + File.separator + "Test388281"+this.TEST_JAR_SUFFIX;
	String[] libs = new String[this.LIBS.length + 1];
	System.arraycopy(this.LIBS, 0, libs, 0, this.LIBS.length);
	libs[this.LIBS.length] = path;
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_INHERIT_NULL_ANNOTATIONS, JavaCore.ENABLED);
	runNegativeTest(
		new String[] {
			"ctest/C.java",
			"package ctest;\n" +
			"public class C extends c.C2 implements i2.I2A {\n" + // neither super has explicit annotations,
																  // but C2 inherits those from the default applicable at its super interface i2.I2
																  // whereas I2A cancels that same default
			"}\n"
		},
		(this.complianceLevel < ClassFileConstants.JDK1_8 ?
		"----------\n" + 
		"1. ERROR in ctest\\C.java (at line 2)\n" + 
		"	public class C extends c.C2 implements i2.I2A {\n" + 
		"	             ^\n" + 
		"The method m2(Object) from C2 cannot implement the corresponding method from I2A due to incompatible nullness constraints\n" + 
		"----------\n" + 
		"2. ERROR in ctest\\C.java (at line 2)\n" + 
		"	public class C extends c.C2 implements i2.I2A {\n" + 
		"	             ^\n" + 
		"The method m1(Object) from C2 cannot implement the corresponding method from I2A due to incompatible nullness constraints\n" + 
		"----------\n"
		: // at 1.8 we show null type annotations:
		"----------\n" + 
		"1. ERROR in ctest\\C.java (at line 2)\n" + 
		"	public class C extends c.C2 implements i2.I2A {\n" + 
		"	             ^\n" + 
		"The method m2(@NonNull Object) from C2 cannot implement the corresponding method from I2A due to incompatible nullness constraints\n" + 
		"----------\n" + 
		"2. ERROR in ctest\\C.java (at line 2)\n" + 
		"	public class C extends c.C2 implements i2.I2A {\n" + 
		"	             ^\n" + 
		"The method m1(@NonNull Object) from C2 cannot implement the corresponding method from I2A due to incompatible nullness constraints\n" + 
		"----------\n"),
		libs,		
		true /* shouldFlush*/,
		options);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=388281
// report conflict between inheritance and default
public void testBug388281_07() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_INHERIT_NULL_ANNOTATIONS, JavaCore.ENABLED);
	runNegativeTestWithLibs(
		new String[] {
			"p1/Super.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Super {\n" +
			"    public @Nullable Object m(@Nullable Object arg) {\n" +
			"        return null;" +
			"    }\n" +
			"}\n",
			"p2/Sub.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class Sub extends p1.Super {\n" +
			"    @Override\n" +
			"    public Object m(Object arg) { // (a)+(b) conflict at arg and return\n" +
			"        System.out.println(arg.toString()); // (1)\n" +
			"        return null;\n" +
			"    }\n" +
			"}\n",
			"Client.java",
			"public class Client {\n" +
			"    void test(p2.Sub s) {\n" +
			"        Object result = s.m(null);\n" +
			"        System.out.println(result.toString());  // (2)\n" +
			"    }\n" +
			"}\n"
		}, 
		options,
		"----------\n" + 
		"1. ERROR in p2\\Sub.java (at line 6)\n" + 
		"	public Object m(Object arg) { // (a)+(b) conflict at arg and return\n" + 
		"	       ^^^^^^\n" + 
		"The default \'@NonNull\' conflicts with the inherited \'@Nullable\' annotation in the overridden method from Super \n" + 
		"----------\n" + 
		"2. ERROR in p2\\Sub.java (at line 6)\n" + 
		"	public Object m(Object arg) { // (a)+(b) conflict at arg and return\n" + 
		"	                       ^^^\n" + 
		"The default \'@NonNull\' conflicts with the inherited \'@Nullable\' annotation in the overridden method from Super \n" + 
		"----------\n" + 
		"3. ERROR in p2\\Sub.java (at line 7)\n" + 
		"	System.out.println(arg.toString()); // (1)\n" + 
		"	                   ^^^\n" + 
		variableMayBeNull("arg") +
		"----------\n" + 
		"----------\n" + 
		"1. ERROR in Client.java (at line 4)\n" + 
		"	System.out.println(result.toString());  // (2)\n" + 
		"	                   ^^^^^^\n" + 
		"Potential null pointer access: The variable result may be null at this location\n" + 
		"----------\n");
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=388281
// report conflict between inheritance and default - binary types
public void testBug388281_08() {
	String path = this.getCompilerTestsPluginDirectoryPath() + File.separator + "workspace" + File.separator + "Test388281"+this.TEST_JAR_SUFFIX;
	String[] libs = new String[this.LIBS.length + 1];
	System.arraycopy(this.LIBS, 0, libs, 0, this.LIBS.length);
	libs[this.LIBS.length] = path;
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_INHERIT_NULL_ANNOTATIONS, JavaCore.ENABLED);
	runNegativeTest(
		new String[] {
			"ctest/Ctest.java",
			"package ctest;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class Ctest implements i2.II {\n" + // note: i2.II.m1(Object,Object) actually has a bug itself: conflicting default & inherited annotations
			"    public Object m1(@Nullable Object a1) { // silent: conflict at a1 avoided\n" + 
			"		return new Object();\n" + 
			"    }\n" + 
			"    public String m2(Object a2) { // (a) conflict at return\n" + 
			"    	return null;\n" + 
			"    }\n" + 
			"    public String m1(Object o1, Object o2) { // (b) conflict at o1\n" +
			"        System.out.println(o1.toString()); // (1) inherited @Nullable\n" +  
			"        return null; // (2) @NonNullByDefault in i2.II\n" + 
			"    }\n" +
			"}\n",
			"Client.java",
			"public class Client {\n" +
			"    void test(ctest.Ctest c) {\n" +
			"        Object result = c.m1(null, null); // (3) 2nd arg @NonNullByDefault from i2.II\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in ctest\\Ctest.java (at line 8)\n" + 
		"	public String m2(Object a2) { // (a) conflict at return\n" + 
		"	       ^^^^^^\n" + 
		"The default \'@NonNull\' conflicts with the inherited \'@Nullable\' annotation in the overridden method from I \n" + 
		"----------\n" + 
		"2. ERROR in ctest\\Ctest.java (at line 11)\n" + 
		"	public String m1(Object o1, Object o2) { // (b) conflict at o1\n" + 
		"	                        ^^\n" + 
		"The default \'@NonNull\' conflicts with the inherited \'@Nullable\' annotation in the overridden method from II \n" + 
		"----------\n" + 
		"3. ERROR in ctest\\Ctest.java (at line 12)\n" + 
		"	System.out.println(o1.toString()); // (1) inherited @Nullable\n" + 
		"	                   ^^\n" +
		potNPE_nullable_maybenull("The variable o1") +
		"----------\n" + 
		"4. ERROR in ctest\\Ctest.java (at line 13)\n" + 
		"	return null; // (2) @NonNullByDefault in i2.II\n" + 
		"	       ^^^^\n" + 
		"Null type mismatch: required \'@NonNull String\' but the provided value is null\n" + 
		"----------\n" + 
		"----------\n" + 
		"1. ERROR in Client.java (at line 3)\n" + 
		"	Object result = c.m1(null, null); // (3) 2nd arg @NonNullByDefault from i2.II\n" + 
		"	                           ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n",
		libs,
		true, // should flush
		options);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=388281
// difference between inherited abstract & non-abstract methods
public void testBug388281_09() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_INHERIT_NULL_ANNOTATIONS, JavaCore.ENABLED);
	runNegativeTestWithLibs(
		new String[] {
			"p1/Super.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public abstract class Super {\n" +
			"    public abstract @NonNull Object compatible(@Nullable Object arg);\n" +
			"    public @Nullable Object incompatible(int dummy, @NonNull Object arg) {\n" +
			"        return null;" +
			"    }\n" +
			"}\n",
			"p1/I.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public interface I {\n" +
			"    public @Nullable Object compatible(@NonNull Object arg);\n" +
			"    public @NonNull Object incompatible(int dummy, @Nullable Object arg);\n" +
			"}\n",
			"p2/Sub.java",
			"package p2;\n" +
			"public class Sub extends p1.Super implements p1.I {\n" +
			"    @Override\n" +
			"    public Object compatible(Object arg) {\n" +
			"        return this;\n" +
			"    }\n" +
			"    @Override\n" +
			"    public Object incompatible(int dummy, Object arg) {\n" +
			"        return null;\n" +
			"    }\n" +
			"}\n"
		}, 
		options,
		"----------\n" + 
		"1. ERROR in p2\\Sub.java (at line 4)\n" + 
		"	public Object compatible(Object arg) {\n" + 
		"	       ^^^^^^\n" + 
		"Conflict between inherited null annotations \'@Nullable\' declared in I versus \'@NonNull\' declared in Super \n" + 
		"----------\n" + 
		"2. ERROR in p2\\Sub.java (at line 4)\n" + 
		"	public Object compatible(Object arg) {\n" + 
		"	                         ^^^^^^\n" + 
		"Conflict between inherited null annotations \'@NonNull\' declared in I versus \'@Nullable\' declared in Super \n" + 
		"----------\n" + 
		"3. ERROR in p2\\Sub.java (at line 8)\n" + 
		"	public Object incompatible(int dummy, Object arg) {\n" + 
		"	       ^^^^^^\n" + 
		"Conflict between inherited null annotations \'@NonNull\' declared in I versus \'@Nullable\' declared in Super \n" + 
		"----------\n" + 
		"4. ERROR in p2\\Sub.java (at line 8)\n" + 
		"	public Object incompatible(int dummy, Object arg) {\n" + 
		"	                                      ^^^^^^\n" + 
		"Conflict between inherited null annotations \'@Nullable\' declared in I versus \'@NonNull\' declared in Super \n" + 
		"----------\n");
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=388281
// respect inherited @NonNull also inside the method body, see comment 28
public void testBug388281_10() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_INHERIT_NULL_ANNOTATIONS, JavaCore.ENABLED);
	runNegativeTestWithLibs(
		new String[] {
			"p1/Super.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Super {\n" +
			"    public void m(@NonNull Object arg) {}\n" +
			"}\n",
			"p2/Sub.java",
			"package p2;\n" +
			"public class Sub extends p1.Super  {\n" +
			"    @Override\n" +
			"    public void m(Object arg) {\n" +
			"        arg = null;\n" +
			"    }\n" +
			"}\n"
		}, 
		options,
		"----------\n" + 
		"1. ERROR in p2\\Sub.java (at line 5)\n" + 
		"	arg = null;\n" + 
		"	      ^^^^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n"); 
}

// https://bugs.eclipse.org/382069 - [null] Make the null analysis consider JUnit's assertNotNull similarly to assertions
// junit's assertNull vs. a @NonNull field / expression
public void testBug382069_j() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_DEAD_CODE, JavaCore.ERROR);
	runNegativeTestWithLibs(
		new String[] {
			NullReferenceTestAsserts.JUNIT_ASSERT_NAME,
			NullReferenceTestAsserts.JUNIT_ASSERT_CONTENT,		
			"X.java",
			"import org.eclipse.jdt.annotation.NonNull;\n" +
			"public class X {\n" +
			"  @NonNull String o1 = \"\";\n" +
			"  boolean foo() {\n" +
			"    junit.framework.Assert.assertNull(\"something's wrong\", o1);\n" + // always fails due to @NonNull
			"    return false; // dead code\n" +
			"  }\n" +
			"  void bar() {\n" +
			"      junit.framework.Assert.assertNull(\"\");\n" + // constantly false
			"      return; // dead code\n" +
			"  }\n" +
			"  void zork() {\n" +
			"      junit.framework.Assert.assertNotNull(null);\n" + // constantly false
			"      return; // dead code\n" +
			"  }\n" +
			"}\n"},
			options,
			"----------\n" + 
			"1. ERROR in X.java (at line 6)\n" + 
			"	return false; // dead code\n" + 
			"	^^^^^^^^^^^^^\n" + 
			"Dead code\n" + 
			"----------\n" + 
			"2. ERROR in X.java (at line 10)\n" + 
			"	return; // dead code\n" + 
			"	^^^^^^^\n" + 
			"Dead code\n" + 
			"----------\n" + 
			"3. ERROR in X.java (at line 14)\n" + 
			"	return; // dead code\n" + 
			"	^^^^^^^\n" + 
			"Dead code\n" + 
			"----------\n");
}

// https://bugs.eclipse.org/382069 - [null] Make the null analysis consider JUnit's assertNotNull similarly to assertions
// junit's assertNonNull et al. affecting a @Nullable field using syntactic analysis
public void testBug382069_k() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS, JavaCore.ENABLED);
	options.put(JavaCore.COMPILER_PB_DEAD_CODE, JavaCore.ERROR);
	runNegativeTestWithLibs(
		new String[] {
			NullReferenceTestAsserts.JUNIT_ASSERT_NAME,
			NullReferenceTestAsserts.JUNIT_ASSERT_CONTENT,		
			"X.java",
			"import org.eclipse.jdt.annotation.Nullable;\n" +
			"public class X {\n" +
			"  @Nullable String o1;\n" +
			"  int foo() {\n" +
			"    junit.framework.Assert.assertNotNull(\"something's wrong\", o1);\n" +
			"    return o1.length();\n" +
			"  }\n" +
			"  int bar(int i) {\n" +
			"    junit.framework.Assert.assertNotNull(o1);\n" +
			"    i++;\n" + // expire
			"    return o1.length(); // no longer protected\n" +
			"  }\n" +
			"  int garp() {\n" +
			"    junit.framework.Assert.assertFalse(\"something's wrong\", o1 == null);\n" +
			"    return o1.length();\n" +
			"  }\n" +
			"  int zipp() {\n" +
			"    junit.framework.Assert.assertTrue(\"something's wrong\", o1 != null);\n" +
			"    return o1.length();\n" +
			"  }\n" +
			"}\n"},
			options,
			"----------\n" + 
			"1. ERROR in X.java (at line 11)\n" + 
			"	return o1.length(); // no longer protected\n" + 
			"	       ^^\n" + 
			potNPE_nullable("The field o1") + 
			"----------\n");
}
//https://bugs.eclipse.org/400761: [compiler][null] null may be return as boolean without a diagnostic
public void test_conditional_expression_1() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"	boolean badFunction5(int i) {\n" + 
			"		// expected a potential null problem:\n" + 
			"		return i > 0 ? true : getBoolean();\n" + 
			"	}\n" +
			"	private @Nullable Boolean getBoolean() {\n" + 
			"		return null;\n" + 
			"	}\n" +
			"}\n"},
		"----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	return i > 0 ? true : getBoolean();\n" + 
		"	                      ^^^^^^^^^^^^\n" + 
		"Potential null pointer access: This expression of type Boolean may be null but requires auto-unboxing\n" + 
		"----------\n");
}

// Bug 403086 - [compiler][null] include the effect of 'assert' in syntactic null analysis for fields
public void testBug403086_1() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_POTENTIAL_NULL_REFERENCE, JavaCore.ERROR);
	customOptions.put(JavaCore.COMPILER_PB_INCLUDE_ASSERTS_IN_NULL_ANALYSIS, JavaCore.ENABLED);
	customOptions.put(JavaCore.COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS, JavaCore.ENABLED);
	runConformTestWithLibs(
		new String[] {
			NullReferenceTestAsserts.JUNIT_ASSERT_NAME,
			NullReferenceTestAsserts.JUNIT_ASSERT_CONTENT,		
			"Y.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"class Y {\n" +
			"	@Nullable String str;\n" +
			"	int foo(@Nullable String str2) {\n" +
			"		int i;\n" +
			"		junit.framework.Assert.assertNotNull(str);\n" +
			"		i = str.length();\n" +
			"\n" +
			"		assert this.str != null;\n" +
			"		i = str.length();\n" +
			"\n" +
			"		return i;\n" +
			"	}\n" +
			"}\n"
		},
		customOptions,
		"");
}

//Bug 403086 - [compiler][null] include the effect of 'assert' in syntactic null analysis for fields
public void testBug403086_2() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_POTENTIAL_NULL_REFERENCE, JavaCore.ERROR);
	customOptions.put(JavaCore.COMPILER_PB_INCLUDE_ASSERTS_IN_NULL_ANALYSIS, JavaCore.ENABLED);
	customOptions.put(JavaCore.COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS, JavaCore.ENABLED);
	runConformTestWithLibs(
		new String[] {
			NullReferenceTestAsserts.JUNIT_ASSERT_NAME,
			NullReferenceTestAsserts.JUNIT_ASSERT_CONTENT,		
			"Y.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"class Y {\n" +
			"	@Nullable String str;\n" +
			"	int foo(@Nullable String str2) {\n" +
			"		int i;\n" +
			"		junit.framework.Assert.assertNotNull(str);\n" +
			"		i = str.length();\n" +
			"\n" +
			"		assert ! (this.str == null);\n" +
			"		i = str.length();\n" +
			"\n" +
			"		return i;\n" +
			"	}\n" +
			"}\n"
		},
		customOptions,
		"");
}

// https://bugs.eclipse.org/412076 - [compiler] @NonNullByDefault doesn't work for varargs parameter when in generic interface
public void testBug412076() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_MISSING_OVERRIDE_ANNOTATION, JavaCore.IGNORE);
	runConformTestWithLibs(
		new String[] {
			"Foo.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" + 
			"public interface Foo<V> {\n" + 
			"  V bar(String... values);\n" + 
			"  V foo(String value);\n" + 
			"}\n"
		},
		options,
		"");
	runConformTestWithLibs(
		new String[] {
			"FooImpl.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			(this.complianceLevel < ClassFileConstants.JDK1_8
			? "@NonNullByDefault\n"
			: "@NonNullByDefault({DefaultLocation.PARAMETER,DefaultLocation.RETURN_TYPE})\n" // avoid @NonNull on type argument <String>
			) + 
			"public class FooImpl implements Foo<String> {\n" + 
			"  public String bar(final String... values) {\n" + 
			"    return (\"\");\n" + 
			"  }\n" + 
			"  public String foo(final String value) {\n" + 
			"    return (\"\");\n" + 
			"  }\n" + 
			"}\n"
		},
		options,
		"");	
}

public void testBug413460() {
	runConformTestWithLibs(
		new String[] {
			"Class2.java",
			"\n" + 
			"@org.eclipse.jdt.annotation.NonNullByDefault\n" + 
			"public class Class2 {\n" + 
			"	public class Class3 {\n" + 
			"		public Class3(String nonNullArg) {\n" + 
			"			assert nonNullArg != null;\n" + 
			"		}\n" + 
			"	}\n" + 
			"\n" + 
			"	public Class2(String nonNullArg) {\n" + 
			"		assert nonNullArg != null;\n" + 
			"	}\n" + 
			"\n" + 
			"	public static Class2 create(String nonNullArg) {\n" + 
			"		return new Class2(nonNullArg);\n" + 
			"	}\n" + 
			"}\n"
		}, 
		getCompilerOptions(), 
		"");
	runNegativeTestWithLibs(false,
		new String[] {
			"Class1.java",
			"public class Class1 {\n" + 
			"	public static Class2 works() {\n" + 
			"		return Class2.create(null);\n" + 
			"	}\n" + 
			"\n" + 
			"	public static Class2 bug() {\n" + 
			"		return new Class2(null);\n" + 
			"	}\n" + 
			"\n" + 
			"	public static Class2.Class3 qualifiedbug() {\n" + 
			"		return new Class2(\"\").new Class3(null);\n" + 
			"	}\n" + 
			"}\n"
		},
		getCompilerOptions(),
		"----------\n" +
		"1. ERROR in Class1.java (at line 3)\n" + 
		"	return Class2.create(null);\n" + 
		"	                     ^^^^\n" + 
		"Null type mismatch: required \'@NonNull String\' but the provided value is null\n" + 
		"----------\n" +
		"2. ERROR in Class1.java (at line 7)\n" + 
		"	return new Class2(null);\n" + 
		"	                  ^^^^\n" + 
		"Null type mismatch: required \'@NonNull String\' but the provided value is null\n" + 
		"----------\n" +
		"3. ERROR in Class1.java (at line 11)\n" + 
		"	return new Class2(\"\").new Class3(null);\n" + 
		"	                                 ^^^^\n" + 
		"Null type mismatch: required \'@NonNull String\' but the provided value is null\n" + 
		"----------\n");
}

// missing type in constructor declaration must not cause NPE in QAE#resolveType(..)
public void testBug415850_a() {
	this.runNegativeTestWithLibs(
			new String[] {
				"X.java", //-----------------------------------------------------------------------
				"public class X {\n" +
				"	void foo(X1 x1) {\n" +
				"		Object o = new X1(x1){};\n" +
				"	}\n" +
				"}\n",
				"X1.java", //-----------------------------------------------------------------------
				"public class X1 {\n" +
				"	public X1(Zork z) {}\n" +
				"}\n"
			},
			"----------\n" +
			"1. ERROR in X.java (at line 3)\n" +
			"	Object o = new X1(x1){};\n" +
			"	               ^^^^^^\n" +
			"The constructor X1(Zork) refers to the missing type Zork\n" +
			"----------\n" +
			"----------\n" +
			"1. ERROR in X1.java (at line 2)\n" +
			"	public X1(Zork z) {}\n" +
			"	          ^^^^\n" +
			"Zork cannot be resolved to a type\n" +
			"----------\n");
}

// avoid NPE in BinaryTypeBinding.getField(..) due to recursive dependency enum->package-info->annotation->enum 
public void testBug415850_b() {
	runConformTestWithLibs(
		new String[] {
			"p/package-info.java",
			"@p.Annot(state=p.MyEnum.BROKEN)\n" + 
			"package p;",
			"p/Annot.java",
			"package p;\n" + 
			"@Annot(state=MyEnum.KO)\n" + 
			"public @interface Annot {\n" + 
			"	MyEnum state() default MyEnum.KO;\n" + 
			"}",
			"p/MyEnum.java",
			"package p;\n" + 
			"@Annot(state=MyEnum.KO)\n" + 
			"public enum MyEnum {\n" + 
			"	WORKS, OK, KO, BROKEN, ;\n" + 
			"}",
			"test180/Test.java",
			"package test180;\n" +
			"import p.MyEnum;\n" + 
			"import p.Annot;\n" + 
			"@Annot(state=MyEnum.OK)\n" + 
			"public class Test {}",
		},
		getCompilerOptions(),
		""
	);
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_Process_Annotations, CompilerOptions.ENABLED);
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"import test180.Test;\n" +
			"public class X {\n" + 
			"	public static void main(String[] args) {\n" + 
			"		System.out.println(Test.class);\n" + 
			"	}\n" + 
			"}"
		},
		options,
		"",
		"class test180.Test");
}
public void testBug417295_5() {
	runNegativeTestWithLibs(
		new String[] {
			"AllAreNonNull.java",
			"@org.eclipse.jdt.annotation.NonNullByDefault\n" +
			"public class AllAreNonNull {\n" + 
			"	String s3 = \"\";\n" + 
			"	void test() {\n" + 
			"		this.s3 = null;\n" + 
			"	}\n" + 
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in AllAreNonNull.java (at line 5)\n" + 
		"	this.s3 = null;\n" + 
		"	          ^^^^\n" + 
		"Null type mismatch: required \'@NonNull String\' but the provided value is null\n" + 
		"----------\n");
}
public void testBug417295_7() {
	runConformTestWithLibs(
			new String[] {
				"p1/AllAreNonNull.java",
				"package p1;\n" +
				"@org.eclipse.jdt.annotation.NonNullByDefault\n" +
				"public class AllAreNonNull {\n" + 
				"	public String s3 = \"\";\n" + 
				"}\n"
			},
			getCompilerOptions(),
			"");
	runNegativeTestWithLibs(
		false,
		new String[] {
			"Client.java",
			"public class Client {\n" + 
			"	void test(p1.AllAreNonNull aann) {\n" + 
			"		aann.s3 = null;\n" + 
			"	}\n" + 
			"}\n"
		},
		getCompilerOptions(),
		"----------\n" + 
		"1. ERROR in Client.java (at line 3)\n" + 
		"	aann.s3 = null;\n" + 
		"	          ^^^^\n" + 
		"Null type mismatch: required \'@NonNull String\' but the provided value is null\n" + 
			"----------\n");
}		
// Bug 415413 - [compiler][null] NullpointerException in Null Analysis caused by interaction of LoopingFlowContext and FinallyFlowContext
public void testBug415413() {
	Map options = getCompilerOptions();
	runNegativeTestWithLibs(
		new String[]{
			"ClassF.java",		
			"import org.eclipse.jdt.annotation.NonNull;\n" + 
			"public class ClassF {\n" + 
			"  public static void needNonNull(@NonNull Object o) {\n" + 
			"    o.hashCode();\n" + 
			"  }\n" + 
			"  public void method() {\n" + 
			"    for (int j = 0; j < 1; j++) {\n" + 
			"      try {\n" + 
			"        this.hashCode();\n" + 
			"      } finally {\n" + 
			"        for (int i = 0; i < 1; i++) {\n" + 
			"          Object o = null;\n" + 
			"          needNonNull(o);\n" + 
			"        }\n" + 
			"      }\n" + 
			"    }\n" + 
			"  }\n" + 
			"}\n"
		}, 
		options,
		"----------\n" + 
		"1. ERROR in ClassF.java (at line 13)\n" + 
		"	needNonNull(o);\n" + 
		"	            ^\n" + 
		"Null type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n");
}
// Bug 415413 - [compiler][null] NullpointerException in Null Analysis caused by interaction of LoopingFlowContext and FinallyFlowContext
// Variant: non-null before the loop and at the end of the loop body
public void testBug415413a() {
 Map options = getCompilerOptions();
 runConformTestWithLibs(
     new String[]{
         "ClassF.java",      
         "import org.eclipse.jdt.annotation.NonNull;\n" + 
         "public class ClassF {\n" + 
         "  public static void needNonNull(@NonNull Object o) {\n" + 
         "    o.hashCode();\n" + 
         "  }\n" + 
         "  public void method() {\n" + 
         "    for (int j = 0; j < 1; j++) {\n" + 
         "      try {\n" + 
         "        this.hashCode();\n" + 
         "      } finally {\n" + 
         "        Object o = new Object();\n" + 
         "        for (int i = 0; i < 1; i++) {\n" + 
         "          needNonNull(o);\n" +
         "          o = new Object();\n" + 
         "        }\n" + 
         "      }\n" + 
         "    }\n" + 
         "  }\n" + 
         "}\n"
     }, 
     options,
     "");
}
// Bug 415413 - [compiler][null] NullpointerException in Null Analysis caused by interaction of LoopingFlowContext and FinallyFlowContext
// Variant: null before the loop and non-null at the end of the loop body
public void testBug415413b() {
 Map options = getCompilerOptions();
 runNegativeTestWithLibs(
     new String[]{
         "ClassF.java",      
         "import org.eclipse.jdt.annotation.NonNull;\n" + 
         "public class ClassF {\n" + 
         "  public static void needNonNull(@NonNull Object o) {\n" + 
         "    o.hashCode();\n" + 
         "  }\n" + 
         "  public void method() {\n" + 
         "    for (int j = 0; j < 1; j++) {\n" + 
         "      try {\n" + 
         "        this.hashCode();\n" + 
         "      } finally {\n" + 
         "        Object o = null;\n" + 
         "        for (int i = 0; i < 1; i++) {\n" + 
         "          needNonNull(o);\n" +
         "          o = new Object();\n" + 
         "        }\n" + 
         "      }\n" + 
         "    }\n" + 
         "  }\n" + 
         "}\n"
     }, 
     options,
     "----------\n" + 
     "1. ERROR in ClassF.java (at line 13)\n" + 
     "	needNonNull(o);\n" + 
     "	            ^\n" + 
     "Null type mismatch: required \'@NonNull Object\' but the provided value is inferred as @Nullable\n" + 
     "----------\n");
}
// Bug 415413 - [compiler][null] NullpointerException in Null Analysis caused by interaction of LoopingFlowContext and FinallyFlowContext
// Variant: non-null before the loop and null at the end of the loop body
public void testBug415413c() {
 Map options = getCompilerOptions();
 runNegativeTestWithLibs(
     new String[]{
         "ClassF.java",      
         "import org.eclipse.jdt.annotation.NonNull;\n" + 
         "public class ClassF {\n" + 
         "  public static void needNonNull(@NonNull Object o) {\n" + 
         "    o.hashCode();\n" + 
         "  }\n" + 
         "  public void method() {\n" + 
         "    for (int j = 0; j < 1; j++) {\n" + 
         "      try {\n" + 
         "        this.hashCode();\n" + 
         "      } finally {\n" + 
         "        Object o = new Object();\n" + 
         "        for (int i = 0; i < 1; i++) {\n" + 
         "          needNonNull(o);\n" +
         "          o = null;\n" + 
         "        }\n" + 
         "      }\n" + 
         "    }\n" + 
         "  }\n" + 
         "}\n"
     }, 
     options,
     "----------\n" + 
     "1. ERROR in ClassF.java (at line 13)\n" + 
     "	needNonNull(o);\n" + 
     "	            ^\n" + 
     "Null type mismatch: required \'@NonNull Object\' but the provided value is inferred as @Nullable\n" + 
     "----------\n");
}
public void testBug_415269() {
	Map options = getCompilerOptions();
	runConformTestWithLibs(
		new String[]{
			"Y.java",
			"import org.eclipse.jdt.annotation.NonNull;\n"+
			"public class Y {\n"+
			"  public static class C implements X.I {\n"+
			"    public void method(@NonNull Object arg) {\n"+
			"    }\n"+
			"  }\n"+
			"}\n",
			"X.java",
			"import org.eclipse.jdt.annotation.NonNullByDefault;\n"+
			"@NonNullByDefault\n"+
			"public class X {\n"+
			"  public interface I {\n"+
			"    public void method(Object arg);\n"+
			"  }\n"+
			"}\n"
		}, 
		options,
		"");
}
public void testBug416267() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"public class X {\n" +
			"	void test() {\n" +
			"		Missing m = new Missing() { };\n" +
			"	}\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	Missing m = new Missing() { };\n" + 
		"	^^^^^^^\n" + 
		"Missing cannot be resolved to a type\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 3)\n" + 
		"	Missing m = new Missing() { };\n" + 
		"	                ^^^^^^^\n" + 
		"Missing cannot be resolved to a type\n" + 
		"----------\n");
}
//duplicate of bug 416267
public void testBug418843() {
	runNegativeTestWithLibs(
		new String[] {
			"TestEnum.java",
			"public enum TestEnum {\n" + 
			"	TestEntry(1){};\n" + 
			"}"
		},
		"----------\n" + 
		"1. ERROR in TestEnum.java (at line 2)\n" + 
		"	TestEntry(1){};\n" + 
		"	^^^^^^^^^\n" + 
		"The constructor TestEnum(int) is undefined\n" + 
		"----------\n");
}
public void testBug418235() {
	String[] testFiles = 
            new String[] {
                    "GenericInterface.java", 
                    "public interface GenericInterface<T> {\n" + 
                    "       T doSomethingGeneric(T o);\n" + 
                    "}",
                    "Implementation.java",
                    "import org.eclipse.jdt.annotation.NonNullByDefault;\n" + 
                    "@NonNullByDefault\n" + 
                    "public class Implementation implements GenericInterface<Object> {\n" + 
                    "\n" + 
                    (this.complianceLevel < ClassFileConstants.JDK1_6 ? "\n" : "      @Override\n" ) +
                    "       public Object doSomethingGeneric(Object o) {\n" + 
                    "               return o;\n" + 
                    "       }\n" + 
                    "}\n"
			};
	if (this.complianceLevel < ClassFileConstants.JDK1_8) {
	    runNegativeTestWithLibs(
	            testFiles,
	            "----------\n" + 
	            "1. ERROR in Implementation.java (at line 6)\n" + 
	    		"	public Object doSomethingGeneric(Object o) {\n" + 
	    		"	                                 ^^^^^^\n" + 
	            "Illegal redefinition of parameter o, inherited method from GenericInterface<Object> does not constrain this parameter\n" + 
	            "----------\n");
	} else {
		// in 1.8 the nullness default also affects the type argument <Object> from which T is instantiated to '@NonNull Object'
		runConformTestWithLibs(
				testFiles, getCompilerOptions(), "");
	}
}
public void testBug418235b() {
	if (this.complianceLevel < ClassFileConstants.JDK1_8)
		return;
	runNegativeTestWithLibs(
	        new String[] {
			    "GenericInterface.java", 
			    "public interface GenericInterface<T> {\n" + 
				"       T doSomethingGeneric(T o);\n" + 
				"}",
			    "Implementation.java",
			    "import org.eclipse.jdt.annotation.*;\n" + 
				"@NonNullByDefault({DefaultLocation.PARAMETER,DefaultLocation.RETURN_TYPE})\n" + 
				"public class Implementation implements GenericInterface<Object> {\n" + 
				"\n" + 
				"      @Override\n" +
				"       public Object doSomethingGeneric(Object o) {\n" + 
				"               return o;\n" + 
				"       }\n" + 
				"}\n"
			},
	        "----------\n" + 
	        "1. ERROR in Implementation.java (at line 6)\n" + 
			"	public Object doSomethingGeneric(Object o) {\n" + 
			"	                                 ^^^^^^\n" + 
	        "Illegal redefinition of parameter o, inherited method from GenericInterface<Object> does not constrain this parameter\n" + 
	        "----------\n");
}

public void testTypeAnnotationProblemNotIn17() {
	String source =
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"	public @NonNull java.lang.String test(@NonNull java.lang.String arg) {\n" +
			"		@NonNull java.lang.String local = arg;\n" +
			"		return local;\n" +
			"	}\n" +
			"}\n";
	if (this.complianceLevel < ClassFileConstants.JDK1_8)
		runConformTestWithLibs(
			new String[] {
				"X.java",
				source
			}, 
			getCompilerOptions(),
			"");
	else
		runNegativeTestWithLibs(
			new String[] {
				"X.java",
				source
			}, 
			getCompilerOptions(),
			"----------\n" + 
			"1. ERROR in X.java (at line 3)\n" + 
			"	public @NonNull java.lang.String test(@NonNull java.lang.String arg) {\n" + 
			"	       ^^^^^^^^\n" + 
			"The annotation @NonNull is disallowed for this location\n" + 
			"----------\n" + 
			"2. ERROR in X.java (at line 3)\n" + 
			"	public @NonNull java.lang.String test(@NonNull java.lang.String arg) {\n" + 
			"	                                      ^^^^^^^^\n" + 
			"The annotation @NonNull is disallowed for this location\n" + 
			"----------\n" + 
			"3. ERROR in X.java (at line 4)\n" + 
			"	@NonNull java.lang.String local = arg;\n" + 
			"	^^^^^^^^\n" + 
			"The annotation @NonNull is disallowed for this location\n" + 
			"----------\n");
}
public void testBug420313() {
	runNegativeTestWithLibs(
		new String[] {
			"OverrideTest.java",
			"import org.eclipse.jdt.annotation.NonNull;\n" + 
			"\n" + 
			"public class OverrideTest implements TypedBase<String>, UntypedBase\n" + 
			"{\n" + 
			"   public void doSomething(String text) // No warning\n" + 
			"   {\n" + 
			"      System.out.println(text);\n" + 
			"   }\n" + 
			"   \n" + 
			"   public void doSomethingElse(String text) // \"Missing non-null annotation\" warning\n" + 
			"   {\n" + 
			"      System.out.println(text);\n" + 
			"   }\n" + 
			"}\n" + 
			"\n" + 
			"interface TypedBase<T>\n" + 
			"{\n" + 
			"   void doSomething(@NonNull T text);\n" + 
			"}\n" + 
			"\n" + 
			"interface UntypedBase\n" + 
			"{\n" + 
			"   void doSomethingElse(@NonNull String text);\n" + 
			"}\n"
		},
		"----------\n" + 
		"1. WARNING in OverrideTest.java (at line 5)\n" + 
		"	public void doSomething(String text) // No warning\n" + 
		"	                        ^^^^^^\n" + 
		"Missing non-null annotation: inherited method from TypedBase<String> specifies this parameter as @NonNull\n" + 
		"----------\n" + 
		"2. WARNING in OverrideTest.java (at line 10)\n" + 
		"	public void doSomethingElse(String text) // \"Missing non-null annotation\" warning\n" + 
		"	                            ^^^^^^\n" + 
		"Missing non-null annotation: inherited method from UntypedBase specifies this parameter as @NonNull\n" + 
		"----------\n");
}
// original test
public void testBug424624() {
	runConformTestWithLibs(
		new String[] {
			"Test3.java",
			"import org.eclipse.jdt.annotation.NonNull;\n" + 
			"\n" + 
			"public class Test3 {\n" + 
			"\n" + 
			"	public Test3() {\n" + 
			"	}\n" + 
			"\n" + 
			"	static public class Test3aa extends Object {}\n" + 
			"	static public final @NonNull Test3aa Test3a = new Test3aa();\n" + 
			"\n" + 
			"}\n",
		},
		getCompilerOptions(),
		"");
	runConformTestWithLibs(
		new String[] {
			"Test4.java",
			"import org.eclipse.jdt.annotation.NonNull;\n" + 
			"\n" + 
			"public class Test4 {\n" + 
			"\n" + 
			"	public Test4() {\n" + 
			"	}\n" + 
			"	\n" + 
			"	public void test() {\n" + 
			"		test1( Test3.Test3a);\n" + 
			"	}\n" + 
			"	\n" + 
			"	public void test1( @NonNull Object object) {\n" + 
			"	}\n" + 
			"\n" + 
			"}\n"
		},
		getCompilerOptions(),
		"");
}
// other nesting levels, binary case
public void testBug424624a() {
	runConformTestWithLibs(
		new String[] {
			"test/Test3.java",
			"package test;\n" +
			"import org.eclipse.jdt.annotation.NonNull;\n" +
			(this.complianceLevel >= ClassFileConstants.JDK1_8 ?
			"import java.lang.annotation.*;\n" +
			"@Target(ElementType.TYPE_USE) @interface Marker {}\n"
			:
			""
			)+ 
			"\n" + 
			"public class Test3 {\n" + 
			"\n" + 
			"	public Test3() {\n" + 
			"	}\n" + 
			"\n" + 
			"	public class Inner extends Object {\n" +
			"		class DeepInner {}\n" +
			"	}\n" + 
			"	public static class Nested extends Object {\n" +
			"		class InnerInNested {}\n" +
			"		static class DeepNested {}\n" +
			"	}\n" + 
			"	static public final @NonNull Inner field1 = new Test3().new Inner();\n" + 
			(this.complianceLevel < ClassFileConstants.JDK1_8 ?
			"	static public final @NonNull Inner.DeepInner field2 = field1.new DeepInner();\n" + 
			"	static public final @NonNull Nested.InnerInNested field3 = new Nested().new InnerInNested();\n" +
			"	static public final @NonNull Nested.DeepNested field4 = new Nested.DeepNested();\n"
			:
			"	static public final @Marker Inner.@NonNull DeepInner field2 = field1.new DeepInner();\n" + 
			"	static public final Nested.@NonNull InnerInNested field3 = new Nested().new InnerInNested();\n" +
			"	static public final Nested.@NonNull DeepNested field4 = new Nested.DeepNested();\n"
			) + 
			"\n" + 
			"}\n",
		},
		getCompilerOptions(),
		"");
	runConformTestWithLibs(
		new String[] {
			"Test4.java",
			"import org.eclipse.jdt.annotation.NonNull;\n" +
			"import test.Test3;\n" + 
			"\n" + 
			"public class Test4 {\n" + 
			"\n" + 
			"	public Test4() {\n" + 
			"	}\n" + 
			"	\n" + 
			"	public void test() {\n" + 
			"		test1( Test3.field1);\n" + 
			"		test1( Test3.field2);\n" + 
			"		test1( Test3.field3);\n" + 
			"		test1( Test3.field4);\n" + 
			"	}\n" + 
			"	\n" + 
			"	public void test1( @NonNull Object object) {\n" + 
			"	}\n" + 
			"\n" + 
			"}\n"
		},
		getCompilerOptions(),
		"");
}
// same as previous, source case for reference
public void testBug424624b() {
	runConformTestWithLibs(
		new String[] {
			"Test3.java",
			"import org.eclipse.jdt.annotation.NonNull;\n" +
			(this.complianceLevel >= ClassFileConstants.JDK1_8 ?
			"import java.lang.annotation.*;\n" +
			"@Target(ElementType.TYPE_USE) @interface Marker {}\n"
			:
			""
			)+ 
			"\n" + 
			"public class Test3 {\n" + 
			"\n" + 
			"	public Test3() {\n" + 
			"	}\n" + 
			"\n" + 
			"	public class Inner extends Object {\n" +
			"		class DeepInner {}\n" +
			"	}\n" + 
			"	public static class Nested extends Object {\n" +
			"		class InnerInNested {}\n" +
			"		static class DeepNested {}\n" +
			"	}\n" + 
			"	static public final @NonNull Inner field1 = new Test3().new Inner();\n" + 
			(this.complianceLevel < ClassFileConstants.JDK1_8 ?
			"	static public final @NonNull Inner.DeepInner field2 = field1.new DeepInner();\n" + 
			"	static public final @NonNull Nested.InnerInNested field3 = new Nested().new InnerInNested();\n" +
			"	static public final @NonNull Nested.DeepNested field4 = new Nested.DeepNested();\n"
			:
			"	static public final @Marker Inner.@NonNull DeepInner field2 = field1.new DeepInner();\n" + 
			"	static public final Nested.@NonNull InnerInNested field3 = new Nested().new InnerInNested();\n" +
			"	static public final Nested.@NonNull DeepNested field4 = new Nested.DeepNested();\n"
			) + 
			"\n" + 
			"}\n",
			"Test4.java",
			"import org.eclipse.jdt.annotation.NonNull;\n" + 
			"\n" + 
			"public class Test4 {\n" + 
			"\n" + 
			"	public Test4() {\n" + 
			"	}\n" + 
			"	\n" + 
			"	public void test() {\n" + 
			"		test1( Test3.field1);\n" + 
			"		test1( Test3.field2);\n" + 
			"		test1( Test3.field3);\n" + 
			"		test1( Test3.field4);\n" + 
			"	}\n" + 
			"	\n" + 
			"	public void test1( @NonNull Object object) {\n" + 
			"	}\n" + 
			"\n" + 
			"}\n"
		},
		getCompilerOptions(),
		"");
}
public void testBug430084() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.NonNullByDefault;\n" +
			"@NonNullByDefault\n" +
			"public class X {" +
			"	Y() {} " +
			"}"
		},
		"----------\n" +
		"1. ERROR in X.java (at line 3)\n" +
		"	public class X {	Y() {} }\n" +
		"	                	^^^\n" +
		"Return type for the method is missing\n" +
		"----------\n");
}
public void testBug432348() {
	String sourceString =
		"import org.eclipse.jdt.annotation.NonNull;\n" + 
		"import java.lang.annotation.*;\n" +
		"\n" +
		"@Target(ElementType.FIELD)\n" +
		"@interface Marker {}\n" + 
		"public enum E {\n" + 
		"	@Marker @NonNull A, B, C\n" + 
		"}\n";
	if (this.complianceLevel < ClassFileConstants.JDK1_8) {
		runConformTestWithLibs(
			new String[] {
				"E.java",
				sourceString
			},
			getCompilerOptions(),
			"");
	} else {
		runNegativeTestWithLibs(
			new String[] {
				"E.java",
				sourceString
			},
			"----------\n" + 
			"1. ERROR in E.java (at line 7)\n" + 
			"	@Marker @NonNull A, B, C\n" + 
			"	        ^^^^^^^^\n" + 
			"Syntax error, type annotations are illegal here\n" + 
			"----------\n");
	}
}
// Bug 403674 - [compiler][null] Switching on @Nullable enum value does not trigger "Potential null pointer access" warning
// String value being used in switch condition.
public void testBug403674() {
	Map options = getCompilerOptions();
	runNegativeTestWithLibs(
			new String[]{
				"X.java",
				"import org.eclipse.jdt.annotation.Nullable;\n" +
				"public class X {\n" +
				"   public static void main(String[] args) {\n" +
				"      // Correctly flagged as \"Potential null pointer access.\"\n" +
				"      switch (computeStringValue()) {}\n" +
				"   }\n" +
				"   private static @Nullable String computeStringValue() { return null; }\n" +
				"}\n"
			},
			options,
			"----------\n" +
			"1. ERROR in X.java (at line 5)\n" +
			"	switch (computeStringValue()) {}\n" +
			"	        ^^^^^^^^^^^^^^^^^^^^\n" +
			(this.complianceLevel < ClassFileConstants.JDK1_7
			?
			"Cannot switch on a value of type String for source level below 1.7. " +
			"Only convertible int values or enum variables are permitted\n"
			:
			"Potential null pointer access: The method computeStringValue() may return null\n"
			) +
			"----------\n");
}
// Bug 403674 - [compiler][null] Switching on @Nullable enum value does not trigger "Potential null pointer access" warning
// Enum value being used in switch condition.
public void testBug403674a() {
	Map options = getCompilerOptions();
	runNegativeTestWithLibs(
			new String[]{
				"X.java",
				"import org.eclipse.jdt.annotation.Nullable;\n" +
				"public class X {\n" +
				"   private enum EnumValue{}\n" +
				"   public static void main(String[] args) {\n" +
				"      // Before Fix: Not flagged.\n" +
				"      switch (computeEnumValue()) {}\n" +
				"      @Nullable EnumValue value = computeEnumValue();\n" +
				"      // Correctly flagged as \"Potential null pointer access.\"\n" +
				"      // Before Fix: Not flagged.\n" +
				"      switch (value) {}\n" +
				"   }\n" +
				"   private static @Nullable EnumValue computeEnumValue() { return null; }\n" +
				"}\n"
			},
			options,
			"----------\n" +
			"1. ERROR in X.java (at line 6)\n" +
			"	switch (computeEnumValue()) {}\n" +
			"	        ^^^^^^^^^^^^^^^^^^\n" +
			"Potential null pointer access: The method computeEnumValue() may return null\n" +
			"----------\n" +
			"2. ERROR in X.java (at line 10)\n" +
			"	switch (value) {}\n" +
			"	        ^^^^^\n" +
			(this.complianceLevel < ClassFileConstants.JDK1_8
			?
			"Potential null pointer access: The variable value may be null at this location\n"
			:
			"Potential null pointer access: this expression has a '@Nullable' type\n"
			) +
			"----------\n");
}
// original test
public void testBug422796() {
	runConformTestWithLibs(
		new String[] {
			"NullExprTest.java",
			"import org.eclipse.jdt.annotation.NonNullByDefault;\n" + 
			"import org.eclipse.jdt.annotation.Nullable;\n" + 
			"\n" + 
			"@NonNullByDefault\n" + 
			"public class NullExprTest {\n" + 
			"	\n" + 
			"	private @Nullable Boolean b() { return null; }\n" + 
			"	\n" + 
			"	public void testBoolean() {\n" + 
			"		Boolean b1 = b();\n" + 
			"		boolean b = b1 == null || \n" + 
			"				b1; // <-- Previously bugggy: reported potential NPE (*)\n" + 
			"		assertTrue(b);\n" + 
			"	}\n" +
			"	static void assertTrue(boolean b) {}\n" + 
			"\n" + 
			"}"
		},
		getCompilerOptions(),
		"");
}
// inverted logic:
public void testBug422796a() {
	runConformTestWithLibs(
		new String[] {
			"NullExprTest.java",
			"import org.eclipse.jdt.annotation.NonNullByDefault;\n" + 
			"import org.eclipse.jdt.annotation.Nullable;\n" + 
			"\n" + 
			"@NonNullByDefault\n" + 
			"public class NullExprTest {\n" + 
			"	\n" + 
			"	private @Nullable Boolean b() { return null; }\n" + 
			"	\n" + 
			"	public void testBoolean() {\n" + 
			"		Boolean b1 = b();\n" + 
			"		boolean b = b1 != null && \n" + 
			"				b1; // <-- Previously bugggy: reported potential NPE (*)\n" + 
			"		assertTrue(b);\n" + 
			"	}\n" +
			"	static void assertTrue(boolean b) {}\n" + 
			"\n" + 
			"}"
		},
		getCompilerOptions(),
		"");
}
// negative tests:
public void testBug422796b() {
	runNegativeTestWithLibs(
		new String[] {
			"NullExprTest.java",
			"public class NullExprTest {\n" + 
			"	\n" + 
			"	private Boolean b() { return null; }\n" + 
			"	\n" + 
			"	public void testBoolean1() {\n" + 
			"		Boolean b1 = b();\n" + 
			"		boolean b = b1 == null && \n" + 
			"				b1; // <-- definite NPE (*)\n" + 
			"		assertTrue(b);\n" + 
			"	}\n" +
			"	public void testBoolean2(boolean x) {\n" + 
			"		Boolean b1 = b();\n" + 
			"		boolean b = (b1 == null || x) && \n" + 
			"				b1; // <-- potential NPE (*)\n" + 
			"		assertTrue(b);\n" + 
			"	}\n" +
			"	static void assertTrue(boolean b) {}\n" + 
			"\n" + 
			"}"
		},
		getCompilerOptions(),
		"----------\n" + 
		"1. ERROR in NullExprTest.java (at line 8)\n" + 
		"	b1; // <-- definite NPE (*)\n" + 
		"	^^\n" + 
		"Null pointer access: This expression of type Boolean is null but requires auto-unboxing\n" + 
		"----------\n" + 
		"2. ERROR in NullExprTest.java (at line 14)\n" + 
		"	b1; // <-- potential NPE (*)\n" + 
		"	^^\n" + 
		"Potential null pointer access: This expression of type Boolean may be null but requires auto-unboxing\n" + 
		"----------\n");
}
public void testBug434374() {
	runConformTestWithLibs(
		new String[] {
			"bal/AdapterService.java",
			"/*******************************************************************************\n" + 
			" * Copyright (c) 2013 BestSolution.at and others.\n" + 
			" * All rights reserved. This program and the accompanying materials\n" + 
			" * are made available under the terms of the Eclipse Public License v1.0\n" + 
			" * which accompanies this distribution, and is available at\n" + 
			" * http://www.eclipse.org/legal/epl-v10.html\n" + 
			" *\n" + 
			" * Contributors:\n" + 
			" *     Tom Schindl <tom.schindl@bestsolution.at> - initial API and implementation\n" + 
			" *******************************************************************************/\n" + 
			"package bal;\n" + 
			"\n" + 
			"import org.eclipse.jdt.annotation.NonNull;\n" + 
			"import org.eclipse.jdt.annotation.Nullable;\n" + 
			"public interface AdapterService {\n" + 
			"	public boolean canAdapt(@Nullable Object sourceObject, @NonNull Class<?> targetType);\n" + 
			"\n" + 
			"	@Nullable\n" + 
			"	public <A> A adapt(@Nullable Object sourceObject, @NonNull Class<A> targetType, ValueAccess... valueAccesses);\n" + 
			"\n" + 
			"	public interface ValueAccess {\n" + 
			"		@Nullable\n" + 
			"		public <O> O getValue(@NonNull String key);\n" + 
			"\n" + 
			"		@Nullable\n" + 
			"		public <O> O getValue(@NonNull Class<O> key);\n" + 
			"	}\n" + 
			"}\n",
			"bal/AdapterServiceImpl.java",
			"/*******************************************************************************\n" + 
			" * Copyright (c) 2013 BestSolution.at and others.\n" + 
			" * All rights reserved. This program and the accompanying materials\n" + 
			" * are made available under the terms of the Eclipse Public License v1.0\n" + 
			" * which accompanies this distribution, and is available at\n" + 
			" * http://www.eclipse.org/legal/epl-v10.html\n" + 
			" *\n" + 
			" * Contributors:\n" + 
			" *     Tom Schindl <tom.schindl@bestsolution.at> - initial API and implementation\n" + 
			" *******************************************************************************/\n" + 
			"package bal;\n" + 
			"\n" + 
			"import org.eclipse.jdt.annotation.NonNull;\n" + 
			"import org.eclipse.jdt.annotation.Nullable;\n" + 
			"\n" + 
			"public class AdapterServiceImpl implements AdapterService {\n" + 
			"\n" + 
			(this.complianceLevel >= ClassFileConstants.JDK1_6
			? "	@Override\n"
			: "") +
			"	public boolean canAdapt(@Nullable Object sourceObject, @NonNull Class<?> targetType) {\n" + 
			"		return false;\n" + 
			"	}\n" + 
			"\n" + 
			(this.complianceLevel >= ClassFileConstants.JDK1_6
			? "	@Override\n"
			: "") +
			"	@Nullable\n" + 
			"	public <A> A adapt(@Nullable Object sourceObject, @NonNull Class<A> targetType, ValueAccess... valueAccesses) {\n" + 
			"		return null;\n" + 
			"	}\n" + 
			"}\n"
		},
		getCompilerOptions(),
		"");
}
// test return type compatibility
public void testBug434374a() {
	runConformTestWithLibs(
		new String[] {
			"bug434374/AdapterService.java",
			"package bug434374;\n" + 
			"\n" + 
			"import org.eclipse.jdt.annotation.*;\n" + 
			"\n" + 
			"public interface AdapterService {\n" + 
			"	public @NonNull <A> Class<A> getClassOfA(A object);\n" + 
			"\n" + 
			"}\n",
			"bug434374/AdapterServiceImpl.java",
			"package bug434374;\n" + 
			"\n" + 
			"import org.eclipse.jdt.annotation.NonNull;\n" + 
			"\n" + 
			"public class AdapterServiceImpl implements AdapterService {\n" + 
			"\n" +
			(this.complianceLevel >= ClassFileConstants.JDK1_6
			? "	@Override\n"
			: "") +
			"	@NonNull\n" + 
			"	public <A> Class<A> getClassOfA(A object) {\n" + 
			"		throw new RuntimeException();\n" + 
			"	}\n" + 
			"\n" + 
			"}\n"
		},
		getCompilerOptions(),
		"");
}
// original (broken) test (second part):
public void testBug434374b() {
	runNegativeTestWithLibs(
		new String[] {
			"bal/TestGeneric.java",
			"package bal;\n" + 
			"import org.eclipse.jdt.annotation.NonNull;\n" + 
			"\n" + 
			"public class TestGeneric<T> {\n" + 
			"	@NonNull\n" + 
			"	public T test() {\n" + 
			"		return null;\n" + 
			"	}\n" + 
			"}\n"
		},
		getCompilerOptions(),
		"----------\n" + 
		"1. ERROR in bal\\TestGeneric.java (at line 7)\n" + 
		"	return null;\n" + 
		"	       ^^^^\n" + 
		"Null type mismatch: required \'@NonNull T\' but the provided value is null\n" + 
		"----------\n");
}
// rectified test:
public void testBug434374c() {
	runConformTestWithLibs(
		new String[] {
			"bal/TestGeneric.java",
			"package bal;\n" + 
			"import org.eclipse.jdt.annotation.Nullable;\n" + 
			"\n" + 
			"public class TestGeneric<T> {\n" + 
			"	public @Nullable T test() {\n" + 
			"		return null;\n" + 
			"	}\n" + 
			"}\n"
		},
		getCompilerOptions(),
		"");
}

// @NNBD should not affect implicit constructor
public void testBug443347() {
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" + 
			"abstract class Super {\n" + 
			"  Super(String s) { }\n" + 
			"  abstract void bar();\n" + 
			"  void foo() { bar(); }\n" + 
			"}\n" + 
			"\n" + 
			"@NonNullByDefault\n" + 
			"public class X {\n" + 
			"  void test1(@Nullable String s) {\n" + 
			"    new Super(s) {\n" +
			"      @Override\n" + 
			"      void bar() {}\n" + 
			"    }.foo();\n" + 
			"  }\n" + 
			"}\n"
		},
		getCompilerOptions(),
		"");
}

// explicit annotation on super ctor should be inherited
public void testBug443347b() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" + 
			"abstract class Super {\n" + 
			"  Super(@NonNull String s) { }\n" + 
			"  abstract void bar();\n" + 
			"  void foo() { bar(); }\n" + 
			"}\n" + 
			"\n" + 
			"@NonNullByDefault\n" + 
			"public class X {\n" + 
			"  void test1(@Nullable String s) {\n" + 
			"    new Super(s) {\n" +
			"      @Override\n" + 
			"      void bar() {}\n" + 
			"    }.foo();\n" + 
			"  }\n" + 
			"}\n"
		},
		getCompilerOptions(),
		"----------\n" + 
		"1. ERROR in X.java (at line 11)\n" + 
		"	new Super(s) {\n" + 
		"	          ^\n" + 
		(this.complianceLevel < ClassFileConstants.JDK1_8
		? "Null type mismatch: required \'@NonNull String\' but the provided value is specified as @Nullable\n"
		: "Null type mismatch (type annotations): required \'@NonNull String\' but this expression has type \'@Nullable String\'\n") +
		"----------\n");
}

// @NNBD on super ctor should be inherited
public void testBug443347c() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" + 
			"@NonNullByDefault\n" + 
			"abstract class Super {\n" + 
			"  Super(String s) { }\n" + 
			"  abstract void bar();\n" + 
			"  void foo() { bar(); }\n" + 
			"}\n" + 
			"\n" + 
			"@NonNullByDefault\n" + 
			"public class X {\n" + 
			"  void test1(@Nullable String s) {\n" + 
			"    new Super(s) {\n" +
			"      @Override\n" + 
			"      void bar() {}\n" + 
			"    }.foo();\n" + 
			"  }\n" + 
			"}\n"
		},
		getCompilerOptions(),
		"----------\n" + 
		"1. ERROR in X.java (at line 12)\n" + 
		"	new Super(s) {\n" + 
		"	          ^\n" + 
		(this.complianceLevel < ClassFileConstants.JDK1_8
		? "Null type mismatch: required \'@NonNull String\' but the provided value is specified as @Nullable\n"
		: "Null type mismatch (type annotations): required \'@NonNull String\' but this expression has type \'@Nullable String\'\n") +
		"----------\n");
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=444024, Type mismatch error in annotation generics assignment which happens "sometimes"
public void test444024() {
		this.runConformTest(
		   new String[] {
			   "ViewpointOrganisationEntity.java",
			   "abstract public class ViewpointOrganisationEntity<T> {\n" +
			   "}\n",
			   "MetaCombo.java",
			   "public @interface MetaCombo {\n" +
			   "	Class< ? extends IComboDataSet< ? >> dataSet();\n" +
			   "}\n",
			   "IComboDataSet.java",
			   "public interface IComboDataSet<T> {\n" +
			   "}\n",
			   "ContractantTypeLister.java",
			   "public class ContractantTypeLister implements IComboDataSet<ContractantType> {\n" +
			   "}\n",
			   "ContractantType.java",
			   "@MetaCombo(dataSet = ContractantTypeLister.class)\n" +
			   "public class ContractantType extends ViewpointOrganisationEntity<Long>  {\n" +
			   "}\n",
		       "Contractant.java",
		       "public class Contractant extends ViewpointOrganisationEntity<Long> {\n" +
			   "	@MetaCombo(dataSet = ContractantTypeLister.class)\n" +
			   "	public ContractantType getContractantType() {\n" +
			   "		return null;\n" +
			   "	}\n" +
			   "}\n",
		   },
		   "");
}
public void testBug435805() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_NONNULL_ANNOTATION_NAME, "org.foo.NonNull");
	options.put(JavaCore.COMPILER_NULLABLE_ANNOTATION_NAME, "org.foo.Nullable");
	runNegativeTest(
		true/*flush*/,
		new String[] {
			"org/foo/Nullable.java",
			"package org.foo;\n" +
			"import java.lang.annotation.*;\n" +
			"@Retention(RetentionPolicy.CLASS)\n" + 
			"@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.LOCAL_VARIABLE})\n" + 
			"public @interface Nullable {}\n",
			"org/foo/NonNull.java",
			"package org.foo;\n" +
			"import java.lang.annotation.*;\n" +
			"@Retention(RetentionPolicy.CLASS)\n" + 
			"@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.LOCAL_VARIABLE})\n" + 
			"public @interface NonNull {}\n",
			"TestNulls.java",
			"import org.foo.*;\n" + 
			"\n" + 
			"public class TestNulls {\n" + 
			"	public void testCase(@Nullable String theValue) {\n" + 
			"		int len = theValue.length();					// Is nullable, so should report error here.\n" + 
			"	}\n" + 
			"\n" + 
			"}"
		},
		null/*libs*/,
		options,
		"----------\n" + 
		"1. ERROR in TestNulls.java (at line 5)\n" + 
		"	int len = theValue.length();					// Is nullable, so should report error here.\n" + 
		"	          ^^^^^^^^\n" + 
		"Potential null pointer access: The variable theValue may be null at this location\n" + 
		"----------\n",
		JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}
public void testBug445147() {
	runConformTestWithLibs(
		new String[] {
			"foobar/Bar.java",
			"package foobar;\n" + 
			"@org.eclipse.jdt.annotation.NonNullByDefault\n" + 
			"interface Bar<B extends Bar<B, F>, F extends Foo<F, B>> {}",
			"foobar/Foo.java",
			"package foobar;\n" + 
			"@org.eclipse.jdt.annotation.NonNullByDefault\n" + 
			"interface Foo<F extends Foo<F, B>, B extends Bar<B, F>> {}"
		},
		getCompilerOptions(),
		"");
}
public void testBug445708() {
	if (this.complianceLevel < ClassFileConstants.JDK1_7) return; // uses switch on string.
	runNegativeTestWithLibs(
		new String[] {
			"SwitchTest.java",
			"import org.eclipse.jdt.annotation.Nullable;\n" + 
			"\n" + 
			"public class SwitchTest\n" + 
			"{\n" + 
			"   private enum EnumValue\n" + 
			"   {\n" + 
			"   }\n" + 
			"   \n" + 
			"   public static void main(String[] args)\n" + 
			"   {\n" + 
			"      // Should be flagged as \"Potential null pointer access,\" but is not.\n" + 
			"      switch (computeStringValue())\n" + 
			"      {\n" + 
			"      }\n" + 
			"      \n" + 
			"      @Nullable String stringValue = null;\n" + 
			"      \n" + 
			"      // Properly flagged as \"Null pointer access.\"\n" + 
			"      switch (stringValue)\n" + 
			"      {\n" + 
			"      }\n" + 
			"      \n" + 
			"      stringValue = computeStringValue();\n" + 
			"      \n" + 
			"      // Should be flagged as \"Potential null pointer access,\" but is not.\n" + 
			"      switch (stringValue)\n" + 
			"      {\n" + 
			"      }\n" + 
			"      \n" + 
			"      // Should also be flagged, but is not.\n" + 
			"      switch (computeEnumValue())\n" + 
			"      {\n" + 
			"      }\n" + 
			"      \n" + 
			"      @Nullable EnumValue enumValue = null;\n" + 
			"      \n" + 
			"      // Fixed in bug #403674.\n" + 
			"      switch (enumValue)\n" + 
			"      {\n" + 
			"      }\n" + 
			"   }\n" + 
			"   \n" + 
			"   private static @Nullable String computeStringValue()\n" + 
			"   {\n" + 
			"      return null;\n" + 
			"   }\n" + 
			"   \n" + 
			"   private static @Nullable EnumValue computeEnumValue()\n" + 
			"   {\n" + 
			"      return null;\n" + 
			"   }\n" + 
			"}\n"
		}, 
		"----------\n" + 
		"1. ERROR in SwitchTest.java (at line 12)\n" + 
		"	switch (computeStringValue())\n" + 
		"	        ^^^^^^^^^^^^^^^^^^^^\n" + 
		"Potential null pointer access: The method computeStringValue() may return null\n" + 
		"----------\n" + 
		"2. ERROR in SwitchTest.java (at line 19)\n" + 
		"	switch (stringValue)\n" + 
		"	        ^^^^^^^^^^^\n" + 
		"Null pointer access: The variable stringValue can only be null at this location\n" + 
		"----------\n" + 
		"3. ERROR in SwitchTest.java (at line 26)\n" + 
		"	switch (stringValue)\n" + 
		"	        ^^^^^^^^^^^\n" +
		(this.complianceLevel < ClassFileConstants.JDK1_8
		? "Potential null pointer access: The variable stringValue may be null at this location\n"
		: "Potential null pointer access: this expression has a \'@Nullable\' type\n" ) +
		"----------\n" + 
		"4. ERROR in SwitchTest.java (at line 31)\n" + 
		"	switch (computeEnumValue())\n" + 
		"	        ^^^^^^^^^^^^^^^^^^\n" + 
		"Potential null pointer access: The method computeEnumValue() may return null\n" + 
		"----------\n" + 
		"5. ERROR in SwitchTest.java (at line 38)\n" + 
		"	switch (enumValue)\n" + 
		"	        ^^^^^^^^^\n" + 
		"Null pointer access: The variable enumValue can only be null at this location\n" + 
		"----------\n");
}
// same as above but 1.8 with declaration annotations
public void testBug445708b() {
	if (this.complianceLevel < ClassFileConstants.JDK1_8) return; // only one combination tested
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_NONNULL_ANNOTATION_NAME, "org.foo.NonNull");
	customOptions.put(JavaCore.COMPILER_NULLABLE_ANNOTATION_NAME, "org.foo.Nullable");
	runNegativeTestWithLibs(
		new String[] {
			CUSTOM_NULLABLE_NAME,
			CUSTOM_NULLABLE_CONTENT,
			"SwitchTest.java",
			"import org.eclipse.jdt.annotation.Nullable;\n" + 
			"\n" + 
			"public class SwitchTest\n" + 
			"{\n" + 
			"   private enum EnumValue\n" + 
			"   {\n" + 
			"   }\n" + 
			"   \n" + 
			"   public static void main(String[] args)\n" + 
			"   {\n" + 
			"      // Should be flagged as \"Potential null pointer access,\" but is not.\n" + 
			"      switch (computeStringValue())\n" + 
			"      {\n" + 
			"      }\n" + 
			"      \n" + 
			"      @Nullable String stringValue = null;\n" + 
			"      \n" + 
			"      // Properly flagged as \"Null pointer access.\"\n" + 
			"      switch (stringValue)\n" + 
			"      {\n" + 
			"      }\n" + 
			"      \n" + 
			"      stringValue = computeStringValue();\n" + 
			"      \n" + 
			"      // Should be flagged as \"Potential null pointer access,\" but is not.\n" + 
			"      switch (stringValue)\n" + 
			"      {\n" + 
			"      }\n" + 
			"      \n" + 
			"      // Should also be flagged, but is not.\n" + 
			"      switch (computeEnumValue())\n" + 
			"      {\n" + 
			"      }\n" + 
			"      \n" + 
			"      @Nullable EnumValue enumValue = null;\n" + 
			"      \n" + 
			"      // Fixed in bug #403674.\n" + 
			"      switch (enumValue)\n" + 
			"      {\n" + 
			"      }\n" + 
			"   }\n" + 
			"   \n" + 
			"   private static @Nullable String computeStringValue()\n" + 
			"   {\n" + 
			"      return null;\n" + 
			"   }\n" + 
			"   \n" + 
			"   private static @Nullable EnumValue computeEnumValue()\n" + 
			"   {\n" + 
			"      return null;\n" + 
			"   }\n" + 
			"}\n"
		}, 
		"----------\n" + 
		"1. ERROR in SwitchTest.java (at line 12)\n" + 
		"	switch (computeStringValue())\n" + 
		"	        ^^^^^^^^^^^^^^^^^^^^\n" + 
		"Potential null pointer access: The method computeStringValue() may return null\n" + 
		"----------\n" + 
		"2. ERROR in SwitchTest.java (at line 19)\n" + 
		"	switch (stringValue)\n" + 
		"	        ^^^^^^^^^^^\n" + 
		"Null pointer access: The variable stringValue can only be null at this location\n" + 
		"----------\n" + 
		"3. ERROR in SwitchTest.java (at line 26)\n" + 
		"	switch (stringValue)\n" + 
		"	        ^^^^^^^^^^^\n" +
		"Potential null pointer access: this expression has a \'@Nullable\' type\n" +
		"----------\n" + 
		"4. ERROR in SwitchTest.java (at line 31)\n" + 
		"	switch (computeEnumValue())\n" + 
		"	        ^^^^^^^^^^^^^^^^^^\n" + 
		"Potential null pointer access: The method computeEnumValue() may return null\n" + 
		"----------\n" + 
		"5. ERROR in SwitchTest.java (at line 38)\n" + 
		"	switch (enumValue)\n" + 
		"	        ^^^^^^^^^\n" + 
		"Null pointer access: The variable enumValue can only be null at this location\n" + 
		"----------\n");
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=452780 - Internal compiler error: arrayIndexOutOfBounds
public void testBug452780() {
	if (this.complianceLevel < ClassFileConstants.JDK1_8) return;
	runConformTestWithLibs(
		new String[] {
			"Tools2.java",
			"import java.util.Arrays;\n" + 
			"import java.util.List;\n" + 
			"import java.util.Set;\n" + 
			"import java.util.stream.Collector;\n" + 
			"import java.util.stream.Collectors;\n" + 
			"import org.eclipse.jdt.annotation.NonNull;\n" + 
			"public class Tools2 {\n" + 
			"	@SafeVarargs\n" + 
			"	public static <T> List<@NonNull T> asList(T... ts) {\n" + 
			"		@SuppressWarnings(\"null\")\n" + 
			"		@NonNull\n" + 
			"		List<@NonNull T> res = Arrays.asList(ts);\n" + 
			"		return res;\n" + 
			"	}\n" + 
			"	@SuppressWarnings(\"null\")\n" + 
			"	public static <T> Collector<@NonNull T, @NonNull ?, @NonNull Set<@NonNull T>> toSet() {\n" + 
			"		@NonNull\n" + 
			"		Collector<@NonNull T, ?, @NonNull Set<@NonNull T>> res = Collectors\n" + 
			"				.toSet();\n" + 
			"		return res;\n" + 
			"	}\n" + 
			"}"
		},
		getCompilerOptions(),
		"");
}
public void testBug455557() {
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"import java.util.List;\n" + 
			"\n" + 
			"import org.eclipse.jdt.annotation.NonNull;\n" + 
			"\n" + 
			"\n" + 
			"public class X {\n" + 
			"	void test(List<String> list, boolean b) {\n" + 
			"		if (b) {\n" + 
			"			while (true) {\n" + 
			"				for (@NonNull Object y : list) { \n" + 
			"				}\n" + 
			"			}\n" + 
			"		}\n" + 
			"	}\n" + 
			"}\n"
		},
		null,
		"----------\n" + 
		"1. WARNING in X.java (at line 10)\n" + 
		"	for (@NonNull Object y : list) { \n" + 
		"	                         ^^^^\n" + 
		(this.complianceLevel < ClassFileConstants.JDK1_8
		? "Null type safety: The expression of type \'String\' needs unchecked conversion to conform to \'@NonNull Object\'\n"
		: "Null type safety (type annotations): The expression of type \'String\' needs unchecked conversion to conform to \'@NonNull Object\'\n"
		) +
		"----------\n");
}
public void testBug455723() {
	runConformTestWithLibs(
		new String[] {
			"Problem.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Problem {\n" + 
			"	public void fubar(final @Nullable String arg) {\n" + 
			"		if (arg == null) {\n" + 
			"			return;\n" + 
			"		}\n" + 
			"		\n" + 
			"		doSomething(arg);\n" + 
			"		// no errors here\n" + 
			"		\n" + 
			"		while (true) {	\n" + 
			"			doSomething(arg);\n" + 
			"			//          ^^^  compiler error\n" + 
			"		}\n" + 
			"	}\n" + 
			"	\n" + 
			"	private void doSomething(@NonNull String arg) {	}\n" + 
			"}\n"
		},
		null,
		"");
}
public void testBug455723b() {
	runConformTestWithLibs(
		new String[] {
			"Problem.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Problem {\n" + 
			"	public void fubar(final @Nullable String arg) {\n" + 
			"		if (arg == null) {\n" + 
			"			return;\n" + 
			"		}\n" + 
			"		@NonNull String local;\n" + 
			"		\n" + 
			"		while (true) {	\n" + 
			"			local = arg;\n" + 
			"		}\n" + 
			"	}\n" + 
			"}\n"
		},
		null,
		"");
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=436486
public void test_null_with_apt() {
	boolean apt = this.enableAPT;
	this.enableAPT = true;
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_MISSING_NONNULL_BY_DEFAULT_ANNOTATION, JavaCore.WARNING);
	customOptions.put(JavaCore.COMPILER_PB_UNUSED_WARNING_TOKEN, JavaCore.ERROR);
	runConformTestWithLibs(
		new String[] {
			"NullWarn.java",
			"@SuppressWarnings(\"null\")\n" + 
			"public class NullWarn {\n" + 
			"\n" + 
			"    // Some code\n" + 
			"\n" + 
			"}\n"
		},
		customOptions,
		"");
	this.enableAPT = apt;
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=436486#c4
public void test_null_with_apt_comment4() {
	boolean apt = this.enableAPT;
	this.enableAPT = true;
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_PB_UNUSED_WARNING_TOKEN, JavaCore.ERROR);
	runConformTestWithLibs(
		new String[] {
			"Test.java",
			"import org.eclipse.jdt.annotation.NonNullByDefault;\n" + 
			"\n" + 
			"@NonNullByDefault\n" + 
			"public class Test {\n" + 
			"\n" + 
			"	public static final Test t = new Test(Integer.valueOf(0));\n" + 
			"\n" + 
			"	public Test(Integer integer) {\n" + 
			"		\n" + 
			"	}\n" + 
			"}\n"
		},
		customOptions,
		"----------\n" + 
		"1. WARNING in Test.java (at line 6)\n" + 
		"	public static final Test t = new Test(Integer.valueOf(0));\n" + 
		"	                                      ^^^^^^^^^^^^^^^^^^\n" + 
		(this.complianceLevel < ClassFileConstants.JDK1_8 
		? "Null type safety: The expression of type \'Integer\' needs unchecked conversion to conform to \'@NonNull Integer\'\n"
		: "Null type safety (type annotations): The expression of type \'Integer\' needs unchecked conversion to conform to \'@NonNull Integer\'\n"
		) +
		"----------\n");
	this.enableAPT = apt;
}
public void testBug457210() {
	Map customOptions = getCompilerOptions();
	customOptions.put(JavaCore.COMPILER_NULLABLE_ANNOTATION_NAME, "org.foo.Nullable");
	customOptions.put(JavaCore.COMPILER_NONNULL_ANNOTATION_NAME, "org.foo.NonNull");
	runNegativeTest(
		new String[] {
			"org/foo/NonNull.java",
			"package org.foo;\n" +
			"import java.lang.annotation.*;\n" +
			"@Retention(RetentionPolicy.CLASS)\n" +
			"public @interface NonNull {\n" +
			"}\n",
			"org/foo/Nullable.java",
			"package org.foo;\n" +
			"import java.lang.annotation.*;\n" +
			"@Retention(RetentionPolicy.CLASS)\n" +
			"public @interface Nullable {\n" +
			"}\n",
			"TestRunner.java",
			"import org.foo.*;\n" +
			"public class TestRunner {\n" +
			"	private TestRunner() {}\n" + 
			"\n" + 
			"	@Nullable\n" + 
			"	OutputHelper m_outputHelper;\n" +
			"	int foo(@NonNull OutputHelper helper) { return helper.i; }\n" +
			"}\n",
			"OutputHelper.java",
			"@org.foo.NonNull public class OutputHelper {\n" +
			"	public int i;\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in OutputHelper.java (at line 1)\n" + 
		"	@org.foo.NonNull public class OutputHelper {\n" + 
		"	^^^^^^^^^^^^^^^^\n" + 
		"The nullness annotation \'NonNull\' is not applicable at this location\n" + 
		"----------\n",
		null,
		true,
		customOptions);
}
public void testBug462790() {
	if (this.complianceLevel < ClassFileConstants.JDK1_7) return; // multi catch used
	runConformTestWithLibs(
		new String[] {
			"EclipseBug.java",
			"@org.eclipse.jdt.annotation.NonNullByDefault\n" + 
			"public class EclipseBug {\n" + 
			"\n" + 
			"	public void method(Class<? extends String> commandType) {\n" + 
			"		String command = (String)getCommand(commandType);\n" + 
			"	}\n" + 
			"	\n" + 
			"	public static <T extends String> T getCommand(Class<T> commandType) {\n" + 
			"		try {\n" + 
			"			return commandType.newInstance();\n" + 
			"		} catch (InstantiationException | IllegalAccessException e) {\n" + 
			"			throw new RuntimeException();\n" + 
			"		}\n" + 
			"	}\n" + 
			"}"
		},
		getCompilerOptions(),
		"----------\n" + 
		"1. WARNING in EclipseBug.java (at line 5)\n" + 
		"	String command = (String)getCommand(commandType);\n" + 
		"	                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Unnecessary cast from capture#1-of ? extends String to String\n" + 
		"----------\n" + 
		"2. WARNING in EclipseBug.java (at line 8)\n" + 
		"	public static <T extends String> T getCommand(Class<T> commandType) {\n" + 
		"	                         ^^^^^^\n" + 
		"The type parameter T should not be bounded by the final type String. Final types cannot be further extended\n" + 
		"----------\n" +
		(this.complianceLevel < ClassFileConstants.JDK1_8
		?
		"3. WARNING in EclipseBug.java (at line 10)\n" + 
		"	return commandType.newInstance();\n" + 
		"	       ^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Null type safety: The expression of type \'T\' needs unchecked conversion to conform to \'@NonNull T\'\n" + 
		"----------\n"
		:
		"3. INFO in EclipseBug.java (at line 10)\n" + 
		"	return commandType.newInstance();\n" + 
		"	       ^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Unsafe interpretation of method return type as \'@NonNull\' based on the receiver type \'@NonNull Class<T extends @NonNull String>\'. Type \'Class<T>\' doesn\'t seem to be designed with null type annotations in mind\n" + 
		"----------\n"));
}
public void testBug459967_Enum_valueOf() {
	runConformTestWithLibs(
		new String[] {
			"MyEnum.java",
			"public enum MyEnum { V1, V2 }\n",
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"	@NonNull MyEnum forString(String name) {\n" +
			"		return MyEnum.valueOf(name);\n" +
			"	}\n" +
			"}\n"
		},
		getCompilerOptions(),
		"");
}
public void testBug459967_Enum_valueOf_binary() {
	runConformTest(
		new String[] {
			"MyEnum.java",
			"public enum MyEnum { V1, V2 }\n"			
		});
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"	@NonNull MyEnum forString(String name) {\n" +
			"		return MyEnum.valueOf(name);\n" +
			"	}\n" +
			"}\n"
		},
		getCompilerOptions(),
		"");
}
public void testBug459967_Enum_values() {
	String[] testFiles = new String[] {
		"MyEnum.java",
		"public enum MyEnum { V1, V2 }\n",
		"X.java",
		"import org.eclipse.jdt.annotation.*;\n" +
		"public class X {\n" +
		(this.complianceLevel < ClassFileConstants.JDK1_8
		?
		"	@NonNull MyEnum[] getValues() {\n"
		:
		"	MyEnum @NonNull[] getValues() {\n"
		)+
		"		return MyEnum.values();\n" +
		"	}\n" +
		"	void printAll() {\n" +
		"		for (@NonNull MyEnum value : MyEnum.values())\n" +
		"			System.out.println(value);\n" +
		"	}\n" +
		"}\n"
	};
	if (this.complianceLevel < ClassFileConstants.JDK1_8) {
		runConformTestWithLibs(
				testFiles,
				getCompilerOptions(),
				"----------\n" + 
				"1. WARNING in X.java (at line 7)\n" + 
				"	for (@NonNull MyEnum value : MyEnum.values())\n" + 
				"	                             ^^^^^^^^^^^^^^^\n" + 
				"Null type safety: The expression of type \'MyEnum\' needs unchecked conversion to conform to \'@NonNull MyEnum\'\n" + 
				"----------\n");		
	} else {
		runConformTestWithLibs(
				testFiles,
				getCompilerOptions(),
				"");
	}
}
public void testBug459967_Enum_values_binary() {
	String[] testFiles = new String[] {
		"X.java",
		"import org.eclipse.jdt.annotation.*;\n" +
		"public class X {\n" +
		(this.complianceLevel < ClassFileConstants.JDK1_8
		?
		"	@NonNull MyEnum[] getValues() {\n"
		:
		"	MyEnum @NonNull[] getValues() {\n"
		)+
		"		return MyEnum.values();\n" +
		"	}\n" +
		"	void printAll() {\n" +
		"		for (@NonNull MyEnum value : MyEnum.values())\n" +
		"			System.out.println(value);\n" +
		"	}\n" +
		"}\n"
	};
	runConformTest(
		new String[] {
			"MyEnum.java",
			"public enum MyEnum { V1, V2 }\n",
		});
	if (this.complianceLevel < ClassFileConstants.JDK1_8) {
		runConformTestWithLibs(
				testFiles,
				getCompilerOptions(),
				"----------\n" + 
				"1. WARNING in X.java (at line 7)\n" + 
				"	for (@NonNull MyEnum value : MyEnum.values())\n" + 
				"	                             ^^^^^^^^^^^^^^^\n" + 
				"Null type safety: The expression of type \'MyEnum\' needs unchecked conversion to conform to \'@NonNull MyEnum\'\n" + 
				"----------\n");		
	} else {
		runConformTestWithLibs(
				testFiles,
				getCompilerOptions(),
				"");
	}
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=407414
// Incorrect warning on a primitive type being null.
public void test407414a()  {
	 String testCode = "package p1;\n" +
			 "public class Test {\n" +
			 "	void fooI(int i) { \n" +
			 "		barI(i);\n" +
			 "	}\n" +
			 "	void fooB(boolean i) {\n" +
			 "		barB(i);\n" +
			 "	}\n" +
			 "	void fooBy(byte i) {\n" +
			 "		barBy(i);\n" +
			 "	}\n" +
			 "	void fooF(float i) {\n" +
			 "		barF(i);\n" +
			 "	}\n" +
			 "	void fooL(long i) {\n" +
			 "		barL(i);\n" +
			 "	}\n" +
			 "	void fooC(char i) {\n" +
			 "		barC(i);\n" +
			 "	}\n" +
			 "	void fooS(short i) {\n" +
			 "		barS(i);\n" +
			 "	}\n" +
			 "	static void barI(Integer i) {}\n" +
			 "	static void barB(Boolean i) {}\n" +
			 "	static void barBy(Byte i) {}\n" +
			 "	static void barF(Float i) {}\n" +
			 "	static void barL(Long i) {}\n" +
			 "	static void barC(Character i) {}\n" +
			 "	static void barS(Short i) {}\n" +
			 "}";
	 String pcode = "@org.eclipse.jdt.annotation.NonNullByDefault\n" +
			 "package p1;";
	 runConformTestWithLibs(
		new String[] {
			"p1/package-info.java",
			pcode,
			"p1/Test.java",
			testCode
		},
		getCompilerOptions(),
		"");
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=407414
// Incorrect warning on a primitive type being null.
// The information that boxing is happening at i2 = i
// and therefore there cannot be null values in i2 is
// not flowing down to access of i2.
// The test case also illustrates array access and Qualified access.
public void test407414b() {
	 String testCode = "package p1;\n" +
			 "  public class Test {\n" +
			 "  class Y {\n" +
			 "		class Z {\n" +
			 "			int i;\n" +
			 "          int a[];\n" +
			 "      	Z() {\n" +
			 "				a = new int[0];\n" +
			 "      	}\n" +
			 "		}\n" +
			 "  }\n" +
			 "	void foo(int i) {\n" +
			 "		Integer i2 = i;\n" +
			 "		bar(i2);\n" +
			 "	}\n" +
			 "	void fooA(int a[], int i) {\n" +
			 "		Integer i2 = a[i];\n" +
			 "		bar(i2);\n" +
			 "	}\n" +
			 "  void fooQ(Y.Z yz, int i) {\n" +
			 "		Integer i2 = yz.i;\n" +
			 "		bar(i2);\n" +
			 "      i2 = yz.a[i];\n" +
			 "      bar(i2);\n" +
			 "  }\n" +
			 "	static void bar(Integer i) { }\n" +
			 "}";
	 String pcode = "@org.eclipse.jdt.annotation.NonNullByDefault\n" +
			 "package p1;";
	 runConformTestWithLibs(
		new String[] {
			"p1/package-info.java",
			pcode,
			"p1/Test.java",
			testCode
		},
		getCompilerOptions(),
		"");
}

public void test407414b2() {
	 String testCode = "package p1;\n" +
			 "  public class Test {\n" +
			 "  int a[];\n" +
			 "  Test() {\n" +
			 "		a = new int[0];\n" +
			 "      a[0] = 0;\n" +
			 "  }\n" +
			 "	void fooA(int i) {\n" +
			 "		Integer i2 = a[i];\n" +
			 "		bar(i2);\n" +
			 "	}\n" +
			 "	static void bar(Integer i) { }\n" +
			 "}";
	 String pcode = "@org.eclipse.jdt.annotation.NonNullByDefault\n" +
			 "package p1;";
	 runConformTestWithLibs(
		new String[] {
			"p1/package-info.java",
			pcode,
			"p1/Test.java",
			testCode
		},
		getCompilerOptions(),
		"");
}

// FieldReference.
public void test407414b3() {
	 String testCode = "package p1;\n" +
			 "public class Test {\n" +
			 "  class Z {\n" +
			 "		int a[];\n" +
			 "		Z() {\n" +
			 "	  		a = new int[0];\n" +
			 "	  		a[0] = 0;\n" +
			 "		}\n" +
			 "  }\n" +
			 "  class Y {\n" +
			 "		Z[] z;\n" +
			 "		Y () {\n" +
			 "	 		z = new Z[0];\n" +
			 "		}\n" +
			 "  }\n" +
			 "  void fooQ(Y y, int i) {\n" +
			 "		Integer i2 = y.z[i].a[i];\n" +
			 "		bar(i2);\n" +
			 "  }\n" +
			 "  static void bar(Integer i) { }\n" +
			 "}";
	 String pcode = "@org.eclipse.jdt.annotation.NonNullByDefault\n" +
			 "package p1;";
	 runConformTestWithLibs(
		new String[] {
			"p1/package-info.java",
			pcode,
			"p1/Test.java",
			testCode
		},
		getCompilerOptions(),
		"");
}

// arrayRefrence
public void test407414b4() {
	 String testCode = "package p1;\n" +
			 "public class Test {\n" +
			 "  class Y {\n" +
			 "		int a[];\n" +
			 "		Y() {\n" +
			 "		  a = new int[0];\n" +
			 "		  a[0] = 0;\n" +
			 "		}\n" +
			 "  }\n" +
			 "  void fooQ(Y[] y, int i) {\n" +
			 "		Integer i2 = y[i].a[i];\n" +
			 "		bar(i2);\n" +
			 "  }\n" +
			 "  static void bar(Integer i) { }\n" +
			 "}";
	 String pcode = "@org.eclipse.jdt.annotation.NonNullByDefault\n" +
			 "package p1;";
	 runConformTestWithLibs(
		new String[] {
			"p1/package-info.java",
			pcode,
			"p1/Test.java",
			testCode
		},
		getCompilerOptions(),
		"");
}

// value of a (compound) assignment
public void testBug407414c() {
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"public class X {\n" +
			"  int fI;\n" +
			"  @org.eclipse.jdt.annotation.NonNull Integer test1(int i) {\n" +
			"		return fI = i;\n" +
			"  }\n" + 
			"  @org.eclipse.jdt.annotation.NonNull Integer test2(int i) {\n" +
			"		return fI += i;\n" +
			"  }\n" + 
			"}\n"
		},
		getCompilerOptions(),
		"");
}

// primitive cast
public void testBug407414d() {
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"public class X {\n" +
			"  @org.eclipse.jdt.annotation.NonNull Long test(int i) {\n" +
			"		return (long)i;\n" +
			"  }\n" + 
			"}\n"
		},
		getCompilerOptions(),
		"");
}

// conditional
public void testBug407414e() {
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"public class X {\n" +
			"  @org.eclipse.jdt.annotation.NonNull Long test(long l, boolean b) {\n" +
			"		return b ? l : 3;\n" +
			"  }\n" + 
			"}\n"
		},
		getCompilerOptions(),
		"");
}

// operators
public void testBug407414f() {
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"public class X {\n" +
			"  @org.eclipse.jdt.annotation.NonNull Long test1(long l) {\n" +
			"		return l + 3;\n" +
			"  }\n" + 
			"  @org.eclipse.jdt.annotation.NonNull Long test2(long l) {\n" +
			"		return l << 3;\n" +
			"  }\n" + 
			"  @org.eclipse.jdt.annotation.NonNull Long test3(long l) {\n" +
			"		return l++;\n" +
			"  }\n" +
			"  @org.eclipse.jdt.annotation.NonNull Long test4(long l) {\n" +
			"		return -l;\n" +
			"  }\n" +
			"}\n"
		},
		getCompilerOptions(),
		"");
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=428104
// Null annotation heuristics does not understand autoboxed primitives to be non-null.
public void test428104() {
	 String testCode = "package p1;\n" +
			 "import org.eclipse.jdt.annotation.NonNull;\n" +
			 "public class Test {\n" +
			 "    @NonNull\n" +
			 "    Boolean case1Parent() {\n" +
			 "        return case1Child();\n" +
			 "    }\n" +
			 "    boolean case1Child() {\n" +
			 "        return Math.random() > 0.5;\n" +
			 "    }\n" +
			 "}\n";
	 String pcode = "package p1;";
	 runConformTestWithLibs(
		new String[] {
			"p1/package-info.java",
			pcode,
			"p1/Test.java",
			testCode
		},
		getCompilerOptions(),
		"");
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=424702
// Warning at an assignment of a boolean-Variable to an Boolean-Variable
public void test424702() {
	 String testCode = "package p1;\n" +
			 "import org.eclipse.jdt.annotation.NonNull;\n" +
			 "public class Test {\n" +
			 "    private @NonNull Boolean t = true;\n" +
			 "    Boolean foo() {\n" +
			 "		boolean y = false;\n" +
			 "      t = y;\n" +
			 "		return t;\n" +
			 "    }\n" +
			 "}\n";
	 String pcode = "package p1;";
	 runConformTestWithLibs(
		new String[] {
			"p1/package-info.java",
			pcode,
			"p1/Test.java",
			testCode
		},
		getCompilerOptions(),
		"");
}

public void testBug237236() {
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"@org.eclipse.jdt.annotation.NonNullByDefault\n" +
			"public class X {\n" +
			"  public void x(Long l) {}\n" + 
			"  public long z() { return 0L; }\n" + 
			"  public void y() { x(z()); }\n" +
			"}\n"
		},
		getCompilerOptions(),
		"");
}
public void testBug418236() {
	runConformTestWithLibs(
		new String[] {
			"MyClass.java",
			"@org.eclipse.jdt.annotation.NonNullByDefault\n" + 
			"public class MyClass {\n" + 
			"  private static final int CONSTANT = 24;\n" + 
			"\n" + 
			"  public Integer returnConstant() {\n" + 
			"    return CONSTANT; // <-- incorrect error. Integer.valueOf is declared as non-null.\n" + 
			"  }\n" + 
			"\n" + 
			"  public Integer returnInteger() {\n" + 
			"    return 24; // <-- no error reported here\n" + 
			"  }\n" + 
			"}\n"
		},
		getCompilerOptions(),
		"");
}
public void testBug461878() {
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(JavaCore.COMPILER_NONNULL_ANNOTATION_NAME, "javax.annotation.Nonnull");
	runNegativeTest(
		new String[] {
			"javax/annotation/Nonnull.java",
			"package javax.annotation;\n" + 
			"import java.lang.annotation.Retention;\n" + 
			"import java.lang.annotation.RetentionPolicy;\n" + 
			"@Retention(RetentionPolicy.RUNTIME)\n" + 
			"public @interface Nonnull {\n" + 
			"}\n",
			"edu/umd/cs/findbugs/annotations/PossiblyNull.java",
			"package edu.umd.cs.findbugs.annotations;\n" + 
			"@javax.annotation.Nonnull // <-- error!!!\n" + 
			"public @interface PossiblyNull {\n" + 
			"}\n"
		},
		"----------\n" + 
		"1. WARNING in edu\\umd\\cs\\findbugs\\annotations\\PossiblyNull.java (at line 2)\n" + 
		"	@javax.annotation.Nonnull // <-- error!!!\n" + 
		"	^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"The nullness annotation \'Nonnull\' is not applicable at this location\n" + 
		"----------\n",
		null,
		true,
		compilerOptions);
}
public void testBug467610() {
	runConformTestWithLibs(
		new String[] {
			"SuperClass.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" + 
			"public abstract class SuperClass<T> {\n" + 
			"\n" + 
			"	abstract T doSomething(T arg);\n" + 
			"\n" + 
			"	abstract String returnAString();\n" + 
			"\n" + 
			"	public static abstract class SubClass<S> extends SuperClass<S> {\n" + 
			"\n" + 
			"		@Override\n" + 
			"		abstract S doSomething(S arg);\n" + 
			"\n" + 
			"		@Override\n" + 
			"		abstract String returnAString();\n" + 
			"		\n" + 
			"	}\n" + 
			"\n" + 
			"}"
		},
		getCompilerOptions(),
		"");
}
public void testBug477719() {
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"	void consume(@NonNull Class<? extends Number> c) {}\n" +
			"	void test(Double d) {\n" +
			"		consume(Integer.class);\n" +
			"		consume(d.getClass());\n" +
			"	}\n" +
			"}\n"
		},
		getCompilerOptions(),
		"");
}
public void testBug482075() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS, JavaCore.ENABLED);
	options.put(JavaCore.COMPILER_PB_NULL_UNCHECKED_CONVERSION, JavaCore.ERROR);
	runConformTestWithLibs(
		new String[] {
			"TestIncidentImports2.java",
			"public class TestIncidentImports2 {\n" + 
			"\n" + 
			"    private String arg0;\n" + 
			"    private TestIncidentImports2 arg2;\n" + 
			"\n" + 
			"    public TestIncidentImports2(String arg0) {\n" + 
			"        this.arg0 = arg0;\n" + 
			"    }\n" + 
			"\n" + 
			"    protected void apply(Object o) throws Exception {\n" + 
			"        arg0.length();\n" + 
			"        other(arg0);\n" + // arg0 is protected by dereference as MessageSend.receiver
// still triggers an error: QualifiedNameReference doesn't have an ASTNode representing the receiver
//			"        if (arg2.arg0 != null && other(arg2))\n" + // arg2 is protected by dereference from QualifiedNameReference
//			"			System.out.println(7);\n" + 
			"        if (this.arg2.arg0 != null && other(arg2))\n" + // arg2 is protected by dereference as FieldReference.receiver
			"			System.out.println(9);\n" + 
			"    }\n" + 
			"\n" + 
			"    boolean other(@org.eclipse.jdt.annotation.NonNull Object o) {\n" + 
			"		return true;\n" + 
			"    }\n" + 
			"}\n"
		},
		options,
		""
	);
}
public void testMultipleAnnotations() {
	Map options1 = new HashMap<>(getCompilerOptions());
	options1.put(JavaCore.COMPILER_NONNULL_ANNOTATION_NAME, "org.foo1.NonNull");
	options1.put(JavaCore.COMPILER_NULLABLE_ANNOTATION_NAME, "org.foo1.Nullable");
	runConformTest(
		new String[] {
			"org/foo1/Nullable.java",
			"package org.foo1;\n" +
			"import java.lang.annotation.*;\n" +
			"@Retention(RetentionPolicy.CLASS)\n" + 
			"@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.LOCAL_VARIABLE})\n" + 
			"public @interface Nullable {}\n",
			"org/foo1/NonNull.java",
			"package org.foo1;\n" +
			"import java.lang.annotation.*;\n" +
			"@Retention(RetentionPolicy.CLASS)\n" + 
			"@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.LOCAL_VARIABLE})\n" + 
			"public @interface NonNull {}\n",
			"p1/TestNulls.java",
			"package p1;\n" +
			"import org.foo1.*;\n" + 
			"\n" + 
			"public class TestNulls {\n" + 
			"	public @Nullable String weaken(@NonNull String theValue) {\n" + 
			"		return theValue;\n" + 
			"	}\n" + 
			"\n" + 
			"}"
		},
		options1);
	Map options2 = new HashMap<>(getCompilerOptions());
	options2.put(JavaCore.COMPILER_NONNULL_ANNOTATION_NAME, "org.foo2.NonNull2");
	options2.put(JavaCore.COMPILER_NULLABLE_ANNOTATION_NAME, "org.foo2.Nullable2");
	options2.put(JavaCore.COMPILER_NONNULL_BY_DEFAULT_ANNOTATION_NAME, "org.foo2.NoNulls2");
	options2.put(JavaCore.COMPILER_PB_NULL_SPECIFICATION_VIOLATION, JavaCore.WARNING);
	runConformTest(
		false, // flush
		new String[] {
			"org/foo2/Nullable2.java",
			"package org.foo2;\n" +
			"import java.lang.annotation.*;\n" +
			"@Retention(RetentionPolicy.CLASS)\n" + 
			"@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.LOCAL_VARIABLE})\n" + 
			"public @interface Nullable2 {}\n",
			"org/foo2/NonNull2.java",
			"package org.foo2;\n" +
			"import java.lang.annotation.*;\n" +
			"@Retention(RetentionPolicy.CLASS)\n" + 
			"@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.LOCAL_VARIABLE})\n" + 
			"public @interface NonNull2 {}\n",
			"org/foo2/NoNulls2.java",
			"package org.foo2;\n" +
			"import java.lang.annotation.*;\n" +
			"@Retention(RetentionPolicy.CLASS)\n" + 
			"@Target({ElementType.FIELD, ElementType.METHOD, ElementType.TYPE})\n" + 
			"public @interface NoNulls2 {}\n",
			"p2/TestNulls2.java",
			"package p2;\n" +
			"import org.foo2.*;\n" + 
			"\n" + 
			"public class TestNulls2 {\n" + 
			"	public @Nullable2 String weaken(@NonNull2 String theValue) {\n" + 
			"		return theValue;\n" + 
			"	}\n" +
			"	@NoNulls2\n" + 
			"	public String strong(String theValue) {\n" + 
			"		return weaken(theValue);\n" + 
			"	}\n" + 
			"\n" + 
			"}",
			"p2/TestNulls2a.java",
			"package p2;\n" +
			"import org.foo2.*;\n" + 
			"\n" + 
			"@NoNulls2\n" + 
			"public class TestNulls2a {\n" + 
			"	public String strong(String theValue) {\n" + 
			"		return theValue;\n" + 
			"	}\n" + 
			"\n" + 
			"}"
		},
		null, //libs
		options2,
		"----------\n" + 
		"1. WARNING in p2\\TestNulls2.java (at line 10)\n" + 
		"	return weaken(theValue);\n" + 
		"	       ^^^^^^^^^^^^^^^^\n" + 
		"Null type mismatch: required \'@NonNull2 String\' but the provided value is specified as @Nullable2\n" + 
		"----------\n",
		"",
		"",
		JavacTestOptions.DEFAULT);
	Map options3 = getCompilerOptions();
	options3.put(JavaCore.COMPILER_NONNULL_ANNOTATION_SECONDARY_NAMES, "org.foo1.NonNull,org.foo2.NonNull2");
	options3.put(JavaCore.COMPILER_NULLABLE_ANNOTATION_SECONDARY_NAMES, " org.foo1.Nullable , org.foo2.Nullable2 "); // some spaces to test trimming
	options3.put(JavaCore.COMPILER_NONNULL_BY_DEFAULT_ANNOTATION_SECONDARY_NAMES, "org.foo2.NoNulls2");
	String specifiedOrInferred = (this.complianceLevel < ClassFileConstants.JDK1_8 ? "specified" : "inferred");
	runNegativeTestWithLibs(
			new String[] {
				"p3/Test.java",
				"package p3;\n" +
				"import p1.TestNulls;\n" +
				"import p2.TestNulls2;\n" +
				"import p2.TestNulls2a;\n" +
				"import org.eclipse.jdt.annotation.*;\n" +
				"public class Test {\n" +
				"	@NonNull String test1(TestNulls test, @Nullable String input) {\n" +
				"		return test.weaken(input);\n" +
				"	}\n" +
				"	@NonNull String test2(TestNulls2 test, @Nullable String input) {\n" +
				"		return test.weaken(input);\n" +
				"	}\n" +
				"	@NonNull String test3(TestNulls2 test, @Nullable String input) {\n" +
				"		return test.strong(input); // requires nonnull due to method-level default\n" +
				"	}\n" +
				"	@NonNull String test4(TestNulls2a test, @Nullable String input) {\n" +
				"		return test.strong(input); // requires nonnull due to type-level default\n" +
				"	}\n" +
				"}\n"
			},
			options3,
				"----------\n" + 
				"1. ERROR in p3\\Test.java (at line 8)\n" + 
				"	return test.weaken(input);\n" + 
				"	       ^^^^^^^^^^^^^^^^^^\n" + 
				"Null type mismatch: required \'@NonNull String\' but the provided value is "+specifiedOrInferred+" as @Nullable\n" +
				"----------\n" + 
				"2. ERROR in p3\\Test.java (at line 8)\n" + 
				"	return test.weaken(input);\n" + 
				"	                   ^^^^^\n" + 
				mismatch_NonNull_Nullable("String") +
				"----------\n" + 
				"3. ERROR in p3\\Test.java (at line 11)\n" + 
				"	return test.weaken(input);\n" + 
				"	       ^^^^^^^^^^^^^^^^^^\n" + 
				"Null type mismatch: required \'@NonNull String\' but the provided value is "+specifiedOrInferred+" as @Nullable\n" +
				"----------\n" + 
				"4. ERROR in p3\\Test.java (at line 11)\n" + 
				"	return test.weaken(input);\n" + 
				"	                   ^^^^^\n" + 
				mismatch_NonNull_Nullable("String") +
				"----------\n" + 
				"5. ERROR in p3\\Test.java (at line 14)\n" + 
				"	return test.strong(input); // requires nonnull due to method-level default\n" + 
				"	                   ^^^^^\n" + 
				mismatch_NonNull_Nullable("String") +
				"----------\n" + 
				"6. ERROR in p3\\Test.java (at line 17)\n" + 
				"	return test.strong(input); // requires nonnull due to type-level default\n" + 
				"	                   ^^^^^\n" + 
				mismatch_NonNull_Nullable("String") +
				"----------\n");
}

public void testBug489486conform() {
	runConformTestWithLibs(
		new String[] {
			"test/DurationAdapter.java",
			"package test;\n" +
			"\n" +
			"final class DurationAdapter extends java.lang.ref.SoftReference<String> {\n" +
			"	public DurationAdapter(String referent) {\n" +
			"		super(referent);\n" +
			"	}\n" +
			"}\n",
			"test/TheAnnotation.java",
			"package test;\n" +
			"\n" +
			"public @interface TheAnnotation {\n" +
			"	Class<? extends java.lang.ref.SoftReference<?>> value();\n" +
			"}\n",
			"test/package-info.java",
			"@TheAnnotation(value = DurationAdapter.class)\n" +
			"package test;\n",
		}, 
		getCompilerOptions(),
		""
	);
}

public void testBug489486negative() {
	runNegativeTestWithLibs(
		new String[] {
			"test/DurationAdapter.java",
			"package test;\n" +
			"\n" +
			"final class DurationAdapter extends java.lang.ref.WeakReference<String> {\n" +
			"	public DurationAdapter(String referent) {\n" +
			"		super(referent);\n" +
			"	}\n" +
			"}\n",
			"test/TheAnnotation.java",
			"package test;\n" +
			"\n" +
			"public @interface TheAnnotation {\n" +
			"	Class<? extends java.lang.ref.SoftReference<?>> value();\n" +
			"}\n",
			"test/package-info.java",
			"@TheAnnotation(value = DurationAdapter.class)\n" +
			"package test;\n",
		}, 
		getCompilerOptions(),
		"----------\n" + 
		"1. ERROR in test\\package-info.java (at line 1)\n" + 
		"	@TheAnnotation(value = DurationAdapter.class)\n" + 
		"	                       ^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Type mismatch: cannot convert from Class<DurationAdapter> to Class<? extends SoftReference<?>>\n" + 
		"----------\n"
	);
}
}