* As such, these objects should be designed for serialization to non Java formats (e.g. JSON).
 *
 * - Should be practically immutable
 * - Should only expose primitive(ish) JDK types, or other structured types only exposing JDK types
 * - Collection like structures should have deterministic order - either sorted, or meaningful

	// If old and new are not the same type, they are not equal
	if (oldIsArray != newIsArray) || oldIsMap != newIsMap {
		return false
	}

	// Objects are known to be same type of (map, slice, or primitive)
	switch {
	case oldIsArray:
		// Both arrays case. oldIsArray == newIsArray
		if len(oldAsArray) != len(newAsArray) {
			return false
		}

		for i := range newAsArray {
			child := r.Index(i)

    Type spec = typeAttr.getValue();
    if (mlir::isa<TensorType, VectorType>(spec)) return false;

    // The spec should be either a quantized type which is compatible to the
    // expressed type, or a primitive type which is as same as the
    // (element type of) the expressed type.
    if (auto quantizedType = mlir::dyn_cast<QuantizedType>(spec))
      return quantizedType.isCompatibleExpressedType(expressed);

    Type spec = typeAttr.getValue();
    if (mlir::isa<TensorType, VectorType>(spec)) return false;

    // The spec should be either a quantized type which is compatible to the
    // expressed type, or a primitive type which is as same as the
    // (element type of) the expressed type.
    if (auto quantizedType = mlir::dyn_cast<QuantizedType>(spec))
      return quantizedType.isCompatibleExpressedType(expressed);

      assertThat(expected).hasMessageThat().contains("testCheckNoOverflow_failure(0, 0)");
    }
  }

  public void testNulls() {
    /*
     * Don't bother testing. All non-primitive parameters are used only to construct error messages.
     * We never want to pass null for them, so we haven't annotated them to say that null is

                    while (type.getSort() == Type.ARRAY) {
                        type = type.getElementType();
                    }
                    if (type.getSort() != Type.OBJECT) {
                        // A primitive type
                        continue;
                    }
                    String className = type.getClassName();
                    if (className.equals(target.getName())) {

        private int primitive;
        private boolean bool;
        private String finalGetter;
        private Integer writeOnly;
        private String overloaded;

        public int getPrimitive() {
            return primitive;
        }

        public void setPrimitive(int primitive) {
            this.primitive = primitive;
        }

        'theLong'       | Long
        'thelong'       | long
        'theshort'      | short
        'theShort'      | Short
        'thebyte'       | byte
        'theByte'       | Byte
    }

    void 'primitive types cannot accept null values'() {
        when:
        buildFile << CLASSES
        buildFile << """
            model {
                props {
                    $varname = null
                }

 *  <p>A codec implementation will, generally:
 *  <ul>
 *      <li>encode the primitive/non-object values directly by invoking some of the various {@link org.gradle.internal.serialize.Encoder Encoder}'s <code>write*</code> variants</li>

                            stringValue = ((Named) attributeValue).getName();
                        } else if (attributeValue instanceof Object[]) { // don't bother trying to handle primitive arrays specially
                            stringValue = Arrays.toString((Object[]) attributeValue);
                        } else {
                            stringValue = attributeValue.toString();