// Create a copy of that, with the desired value for each value
      Collection<Entry<K, V>> entries = new ArrayList<>(elements.length);
      int i = 0;
      for (Entry<K, V> entry : originalEntries) {
        entries.add(mapEntry(entry.getKey(), valuesArray[i++]));
      }

      return mapGenerator.create(entries.toArray()).values();
    }

    @Override
    public V[] createArray(int length) {

## Bodies of arbitrary `dict`s { #bodies-of-arbitrary-dicts }

You can also declare a body as a `dict` with keys of some type and values of some other type.

This way, you don't have to know beforehand what the valid field/attribute names are (as would be the case with Pydantic models).

        @Test
        @DisplayName("Should have correct SMB2_READFLAG_READ_UNBUFFERED value")
        void testReadUnbufferedFlag() {
            assertEquals((byte) 0x1, Smb2ReadRequest.SMB2_READFLAG_READ_UNBUFFERED);
        }

        @Test
        @DisplayName("Should have correct SMB2_CHANNEL_NONE value")
        void testChannelNone() {
            assertEquals(0x0, Smb2ReadRequest.SMB2_CHANNEL_NONE);

        // The BigInteger implementation is tested separately, use it as the reference.
        // Promote the int value (rather than using intValue() on the expected value) to avoid
        // any risk of truncation which could lead to a false positive.
        assertEquals(BigIntegerMath.sqrt(valueOf(x), mode), valueOf(IntMath.sqrt(x, mode)));
      }
    }
  }

  /* Relies on the correctness of sqrt(int, FLOOR). */

     * If the property exists in the system, it uses that value with optional append value.
     * Otherwise, it uses the default value if provided.
     *
     * @param cmdList the command list to add the property to
     * @param name the property name
     * @param defaultValue the default value to use if property doesn't exist
     * @param appendValue the value to append to the property value
     */

	}

	DB.Create(&products)

	for idx, value := range []int64{200, 300, 400} {
		if products[idx].Price != value {
			t.Errorf("invalid price for product #%v, expects: %v, got %v", idx, value, products[idx].Price)
		}
	}

	DB.Model(&products).Update("Name", "product-name")

	// will set all product's price to last product's price + 10
	for idx, value := range []int64{410, 410, 410} {

// directory.
//
// The `NormDN` value returned here in the search result may not be equal to the
// input DN, as LDAP equality is not a simple Golang string equality. However,
// we assume the value returned by the LDAP server is canonical. Additionally,
// the attribute type names in the DN are lower-cased.
//
// Return values:
//
// If the DN is found, the normalized (string) value and any requested

  }

  private int entry(int i) {
    return requireEntries()[i];
  }

  private void setElement(int i, E value) {
    requireElements()[i] = value;
  }

  private void setEntry(int i, int value) {
    requireEntries()[i] = value;
  }

public class SortedSetMultimapAsMapTester<K, V>
    extends AbstractMultimapTester<K, V, SortedSetMultimap<K, V>> {
  public void testAsMapValuesImplementSortedSet() {
    for (Collection<V> valueCollection : multimap().asMap().values()) {
      SortedSet<V> valueSet = (SortedSet<V>) valueCollection;
      assertEquals(multimap().valueComparator(), valueSet.comparator());
    }
  }

  public void testAsMapGetImplementsSortedSet() {

                    Arrays.toString(ValidationReportLevel.values()));
            logger.warn("");
        }
    }

    private boolean hasAnythingToReport(
            Map<String, PluginValidationIssues> issuesMap, EnumSet<IssueLocality> issueLocalitiesToReport) {
        for (PluginValidationIssues issues : issuesMap.values()) {