return new ElementOrder<>(Type.UNORDERED, null);
  }

  /**
   * Returns an instance which specifies that ordering is guaranteed to be always be the same across
   * iterations, and across releases. Some methods may have stronger guarantees.
   *
   * <p>This instance is only useful in combination with {@code incidentEdgeOrder}, e.g. {@code
   * graphBuilder.incidentEdgeOrder(ElementOrder.stable())}.

			for _, joinSchema := range nestedJoinSchemas {
				fullRels = append(fullRels, joinSchema.Name)
				relValue = joinSchema.ReflectValueOf(db.Statement.Context, currentReflectValue)
				if relValue.Kind() == reflect.Ptr {
					fullRelsName := utils.JoinNestedRelationNames(fullRels)
					// same nested structure
					if _, ok := joinedNestedSchemaMap[fullRelsName]; !ok {

        assertNull(bothNullException.getMessage());
        assertNull(bothNullException.getCause());
    }

    @Test
    @DisplayName("Test deprecated getRootCause method returns the same as getCause")
    @SuppressWarnings("deprecation")
    public void testGetRootCause() {
        // Test with no cause
        TransportException noCauseException = new TransportException("No cause");

    /*
     * 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
     * allowed. But at the same time, it seems wasteful to bother inserting the checkNotNull calls
     * that NullPointerTester wants.
     *
     * (This empty method disables the automatic null testing provided by PackageSanityTests.)
     */
  }

   * for insertions.
   */
  static <E extends @Nullable Object> Set<E> preservesInsertionOrderOnAddsSet() {
    return CompactHashSet.create();
  }

  /**
   * Returns a new array of the given length with the same type as a reference array.
   *
   * @param reference any array of the desired type
   * @param length the length of the new array
   */
  /*

  }

  // Wrapper of EnumMultiset factory methods, because we need to skip create(Class).
  // create(Enum1.class) is equal to create(Enum2.class) but testEquals() expects otherwise.
  // For the same reason, we need to skip create(Iterable, Class).
  private static class EnumMultisetFactory {
    @Keep // used reflectively by testEquals
    public static <E extends Enum<E>> EnumMultiset<E> create(Iterable<E> elements) {

   * them, so the CN is unused.
   */
  @Test fun verifyNonAsciiSubjectAlt() {
    // Expecting actual:
    //  ["bar.com", "花子.co.jp"]
    // to contain exactly (and in same order):
    //  ["bar.com", "������.co.jp"]
    platform.assumeNotBouncyCastle()

    // CN=foo.com, subjectAlt=bar.com, subjectAlt=花子.co.jp
    // (hanako.co.jp in kanji)
    val session =

	checkStructRelation(t, &User{}, Relation{
		Name: "Profiles", Type: schema.Many2Many, Schema: "User", FieldSchema: "Profile",
		JoinTable: JoinTable{Name: "user_profiles", Table: "user_profiles"},
		References: []Reference{
			{"Refer", "User", "UserReferID", "user_profiles", "", true},
			{"UserRefer", "Profile", "ProfileRefer", "user_profiles", "", false},
		},
	}, Relation{

                    from(report)
                    into(rootBuildDir)
                    rename { "report$projectPathName-${report.parentFile.name}-${report.name}" }
                }
            }
    }

    /**
     * Zip a list of files with same root directory to a zip file.
     *
     * @param destZip the target zip file
     * @param srcFiles the mapping of relative path to the file
     */

        bool,
        Doc(
            """
            Pydantic's `exclude_defaults` parameter, passed to Pydantic models to define
            if it should exclude from the output the fields that had the same default
            value, even when they were explicitly set.
            """
        ),
    ] = False,
    exclude_none: Annotated[
        bool,
        Doc(
            """