"self.m.size() == 2",
				"'a' in self.m",
				"type(self.m['a']) == null_type", // null check using runtime type checking
				//"self.m['a'] == null",

				"self.l.size() == 2",
				"type(self.l[0]) == null_type",
				//"self.l[0] == null",

				"self.s.size() == 2",
				"type(self.s[0]) == null_type",
				//"self.s[0] == null",
			},
			errors: map[string]string{

    return absl::StrCat("SetAttr", toUpperCamel(attr_.full_type()));
  } else {
    return absl::StrCat("SetAttr", toUpperCamel(attr_.base_type()), "List");
  }
}

std::vector<string> AttrView::SetterArgs() const {
  if (attr_.full_type() == "string") {
    return {AttrNameString(), VariableName(), VariableStrLen()};
  } else if (attr_.full_type() == "list(string)") {

 */

package org.gradle.declarative.dsl.schema

import org.gradle.tooling.ToolingModelContract
import java.io.Serializable


@ToolingModelContract(subTypes = [
    DataType.NullType::class,
    DataType.UnitType::class,
    DataType.ConstantType::class,
    DataType.IntDataType::class,
    DataType.LongDataType::class,
    DataType.StringDataType::class,
    DataType.BooleanDataType::class,

    is DataType.IntDataType -> right is DataType.IntDataType
    is DataType.LongDataType -> right is DataType.LongDataType
    is DataType.StringDataType -> right is DataType.StringDataType
    is DataType.NullType -> right is DataType.NullType
    is DataType.UnitType -> right is DataType.UnitType
}


internal
fun TypeRefContext.getDataType(objectOrigin: ObjectOrigin): DataType = when (objectOrigin) {

        override fun toString(): String = "Boolean"
        private
        fun readResolve(): Any = DefaultBooleanDataType
    }

    @Serializable
    @SerialName("null")
    data object DefaultNullType : DataType.NullType {
        override fun toString(): String = "Null"
        private
        fun readResolve(): Any = DefaultNullType
    }

    @Serializable
    @SerialName("unit")

        is DataType.ConstantType<*> -> ObjectReflection.DefaultValue(type, objectOrigin)
        is DataClass -> reflectData(OperationId(-1L, DefaultOperationGenerationId.preExisting), type, objectOrigin, context)
        is DataType.NullType -> error("Null type can't appear in property types")
        is DataType.UnitType -> error("Unit can't appear in property types")
        else -> { error("Unhandled data type: ${type.javaClass.simpleName}") }
    }
}

		t.Errorf("error = %q; want %q", err, want)
	}
}

type nullTestRow struct {
	nullParam    any
	notNullParam any
	scanNullVal  any
}

type nullTestSpec struct {
	nullType    string
	notNullType string
	rows        [6]nullTestRow
}

func TestNullStringParam(t *testing.T) {
	spec := nullTestSpec{"nullstring", "string", [6]nullTestRow{

*   Fixes an integer overflow in math ops ([CVE-2022-36015](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-36015))
*   Fixes a `CHECK`-fail in `tensorflow::full_type::SubstituteFromAttrs` ([CVE-2022-36016](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-36016))