<item index="14" class="java.lang.String" itemvalue="org.jetbrains.annotations.Nullable" />
          <item index="15" class="java.lang.String" itemvalue="org.jspecify.annotations.Nullable" />
          <item index="16" class="java.lang.String" itemvalue="android.annotation.Nullable" />
        </list>
      </value>
    </option>
    <option name="myNotNulls">
      <value>

            "org/codehaus/groovy",
            "org/apache/groovy",
            "org/apache/tools/ant",
            "org/apache/commons/logging",
            "org/jetbrains/annotations",
            "org/jspecify/annotations",
            "org/slf4j",
            "org/apache/log4j",
            "org/apache/xerces",
            "org/w3c/dom",
            "org/xml/sax",
            "sun/misc"
        )

After migrating to Java 8, we can use pluggable type checkers to ensure that our annotations are consistent, 
and there are no missing null checks.

## Decision

Use "NullAway" in JSpecify mode to check for null-related errors in Java code.

Consider improper uses of `null` detected by NullAway a compilation error (not a warning, and not a separate CI job to test).

            -->
            <property name="illegalPkgs" value="jdk.internal,com.beust,org.testng.collections"/>
            <!--
                We prefer org.jspecify for nullability annotations.
            -->
            <property name="illegalClasses" value="org.jetbrains.annotations.Nullable,org.jetbrains.annotations.NotNull"/>
        </module>

        <!-- Naming -->

import org.junit.Test

class JSpecifyNullUnmarkedChangesTest : AbstractBinaryCompatibilityTest() {

    private val nullableAnnotationName = "org.jspecify.annotations.Nullable"
    private val nullUnmarkedAnnotationName = "org.jspecify.annotations.NullUnmarked"

    @Test
    fun `from non-null returning to null-unmarked returning is breaking`() {

        checkNotBinaryCompatibleJava(
            v1 = """

 */

package gradlebuild.binarycompatibility

import org.junit.Test

class JSpecifyNullabilityChangesTest : AbstractJavaNullabilityChangesTest() {

    override val nullableAnnotationName: String = "org.jspecify.annotations.Nullable"

    @Test
    fun `from non-null array returning to null returning is breaking`() {

        checkNotBinaryCompatibleJava(
            v1 = """
                import java.util.List;

                        dependencies {
                            "implementation"(gradleApi())
                            "implementation"(kotlin("stdlib"))
                            // TODO remove once JSpecify is part of the Gradle API
                            "implementation"("org.jspecify:jspecify:1.0.0")
                        }
                    }
                    project(":v1") {

    private static final List<String> NULLABLE_ANNOTATIONS = [
        javax.annotation.Nullable,
        org.jetbrains.annotations.Nullable,
        org.jspecify.annotations.Nullable,
    ].collect { it.name }

    private static final String NULL_UNMARKED_ANNOTATION = org.jspecify.annotations.NullUnmarked.class.name

    NullabilityBreakingChangesRule(Map<String, Object> params) {
        super(params)
    }

    @Override

    val jnrConstants = "com.github.jnr:jnr-constants"
    val joda = "joda-time:joda-time"
    val jsch = "com.github.mwiede:jsch"
    val jsr305 = "com.google.code.findbugs:jsr305"
    val jspecify = "org.jspecify:jspecify"
    val julToSlf4j = "org.slf4j:jul-to-slf4j"
    val junit = "junit:junit"
    val junitJupiter = "org.junit.jupiter:junit-jupiter"
    val junit5JupiterApi = "org.junit.jupiter:junit-jupiter-api"

package gorm

import (
	"fmt"
	"regexp"
	"strings"

	"gorm.io/gorm/clause"
	"gorm.io/gorm/utils"
)

// Model specify the model you would like to run db operations
//
//	// update all users's name to `hello`
//	db.Model(&User{}).Update("name", "hello")
//	// if user's primary key is non-blank, will use it as condition, then will only update that user's name to `hello`
//	db.Model(&user).Update("name", "hello")