// Create a LockGraphNode for each enum value.
    for (E key : keys) {
      LockGraphNode node = new LockGraphNode(getLockName(key));
      nodes.add(node);
      map.put(key, node);
    }
    // Pre-populate all allowedPriorLocks with nodes of smaller ordinal.
    for (int i = 1; i < numKeys; i++) {

        nestedMap.put("nestedKey", "nestedValue");
        doc.put("nested", nestedMap);

        List<Map<String, Object>> listOfMaps = new ArrayList<>();
        listOfMaps.add(nestedMap);
        doc.put("listOfMaps", listOfMaps);

        assertEquals("nestedValue", DocumentUtil.getValue(nestedMap, "nestedKey", String.class));

      assertThat(UnsignedLongs.parseUnsignedLong(maxAsString, radix)).isEqualTo(max.longValue());

      assertThrows(
          NumberFormatException.class,
          () -> {
            BigInteger overflow = max.add(ONE);
            String overflowAsString = overflow.toString(radix);
            UnsignedLongs.parseUnsignedLong(overflowAsString, radix);
          });
    }

    assertThrows(

}

public final class okhttp3/Headers$Builder {
	public fun <init> ()V
	public final fun add (Ljava/lang/String;)Lokhttp3/Headers$Builder;
	public final fun add (Ljava/lang/String;Ljava/lang/String;)Lokhttp3/Headers$Builder;
	public final fun add (Ljava/lang/String;Ljava/time/Instant;)Lokhttp3/Headers$Builder;
	public final fun add (Ljava/lang/String;Ljava/util/Date;)Lokhttp3/Headers$Builder;

        if (functionsLambda != null) {
            functionsLambda.callback((cqLambda, scoreFunctionBuilder) -> {
                GroupCQ cf = new GroupCQ();
                cqLambda.callback(cf);
                list.add(new FilterFunctionBuilder(cf.getQuery(), scoreFunctionBuilder));
            });
        }
        final FunctionScoreQueryBuilder builder = regFunctionScoreQ(cq.getQuery(), list);
        if (opLambda != null) {

```

#### What is OpenAPI for { #what-is-openapi-for }

The OpenAPI schema is what powers the two interactive documentation systems included.

And there are dozens of alternatives, all based on OpenAPI. You could easily add any of those alternatives to your application built with **FastAPI**.

You could also use it to generate code automatically, for clients that communicate with your API. For example, frontend, mobile or IoT applications.

		languages = append(languages, language)
	}

	user := User{}
	db.Create(&user)
	db.Preload("Languages").FirstOrCreate(&user)

	var wg sync.WaitGroup
	for i := 0; i < count; i++ {
		wg.Add(1)
		go func(user User, language Language) {
			err := db.Model(&user).Association("Languages").Append(&language)
			AssertEqual(t, err, nil)

			wg.Done()
		}(user, languages[i])
	}
	wg.Wait()

	for _, bs := range bucketStats {
		qs.Nodes = append(qs.Nodes, bs.QueueStats.Nodes...)
	}
	qs.Uptime = UTCNow().Unix() - globalBootTime.Unix()

	var ps ProxyMetric
	for _, bs := range bucketStats {
		ps.add(bs.ProxyStats)
	}
	bs = BucketStats{
		ReplicationStats: s,
		QueueStats:       qs,
		ProxyStats:       ps,
	}
	r.mostRecentStatsMu.Lock()
	if len(r.mostRecentStats.Stats) == 0 {

        // Initial empty map
        Map<String, Object> map1 = new HashMap<>();
        event.setSourceMap(map1);
        assertEquals(0, event.toSource().size());

        // Add elements to the map
        map1.put("key1", "value1");
        assertEquals(1, event.toSource().size());

        // Replace the map
        Map<String, Object> map2 = new HashMap<>();

      if (n > Int.MAX_VALUE - deltaN) return false // Prevent overflow.
      n += deltaN
      i %= (codePoints.size + 1)

      if (n > 0x10ffff) return false // Not a valid code point.

      codePoints.add(i, n)

      i++
    }

    for (codePoint in codePoints) {
      result.writeUtf8CodePoint(codePoint)
    }

    return true
  }

  /** Returns a new bias. */
  private fun adapt(