* Validate **complex structures**:
    * Use of hierarchical Pydantic models, Python `typing`’s `List` and `Dict`, etc.
    * And validators allow complex data schemas to be clearly and easily defined, checked and documented as JSON Schema.
    * You can have deeply **nested JSON** objects and have them all validated and annotated.
* **Extensible**:

		})

		for _, pet := range users2[2].Pets[0:2] {
			if pet.Toy.Name != "" {
				t.Errorf("No toy should for user %v's pet %v but got %v", 3, pet.Name, pet.Toy.Name)
			}
		}

		CheckPet(t, *users2[2].Pets[2], *users[2].Pets[2])
	}
}

func TestPreloadEmptyData(t *testing.T) {
	user := *GetUser("user_without_associations", Config{})
	DB.Create(&user)

     *
     * <p><b>Note:</b> in general, code should assume that the string form returned by {@code
     * ToStringHelper} for a given object may change. In particular, the list of types which are
     * checked for emptiness is subject to change. We currently check {@code CharSequence}s, {@code
     * Collection}s, {@code Map}s, optionals (including Guava's), and arrays.
     *
     * @since 33.4.0
     */

          ? delegate.keySet().toArray()
          : ObjectArrays.copyAsObjectArray(requireKeys(), 0, size);
    }

    @Override
    @SuppressWarnings("nullness") // b/192354773 in our checker affects toArray declarations
    public <T extends @Nullable Object> T[] toArray(T[] a) {
      if (needsAllocArrays()) {
        if (a.length > 0) {
          @Nullable Object[] unsoundlyCovariantArray = a;

     *
     * <p><b>Note:</b> in general, code should assume that the string form returned by {@code
     * ToStringHelper} for a given object may change. In particular, the list of types which are
     * checked for emptiness is subject to change. We currently check {@code CharSequence}s, {@code
     * Collection}s, {@code Map}s, optionals (including Guava's), and arrays.
     *
     * @since 33.4.0
     */

   * true when removing a connection from the pool; otherwise a racing caller might get it from the
   * pool when it shouldn't. Symmetrically, this must always be checked before returning a
   * connection from the pool.
   *
   * Once true this is always true. Guarded by this.
   */
  var noNewExchanges = false

  /**

    // check from distribution to core (ie this should only be run on java projects)
    /**
     * A collection of jar files that should be checked.
     */
    private FileCollection dependencies;

    /**
     * The directory to find the license and sha files in.
     */
    private File licensesDir = new File(getProject().getProjectDir(), "licenses");

	var pets []Pet
	DB.Model(&user).Where("name = ?", user.Pets[0].Name).Association("Pets").Find(&pets)

	if len(pets) != 1 {
		t.Fatalf("should only find one pets, but got %v", len(pets))
	}

	CheckPet(t, pets[0], *user.Pets[0])

	if count := DB.Model(&user).Where("name = ?", user.Pets[1].Name).Association("Pets").Count(); count != 1 {
		t.Fatalf("should only find one pets, but got %v", count)
	}

  }

  @Override
  public final @Nullable V getOrDefault(@Nullable Object key, @Nullable V defaultValue) {
    V result = get(key);
    // TODO(b/192579700): Use a ternary once it no longer confuses our nullness checker.
    if (result != null) {
      return result;
    } else {
      return defaultValue;
    }
  }

  private transient @Nullable ImmutableSet<Entry<K, V>> cachedEntrySet = null;

  @Override

		return nil
	})
}

// listPath will return the requested entries.
// If no more entries are in the listing io.EOF is returned,
// otherwise nil or an unexpected error is returned.
// The listPathOptions given will be checked and modified internally.
// Required important fields are Bucket, Prefix, Separator.
// Other important fields are Limit, Marker.
// List ID always derived from the Marker.