/*
                         * Some pipes may require that the hostname in the tree connect
                         * be the netbios name. So if we have the netbios server name
                         * from the NTLMSSP type 2 message, and the share is IPC$, we
                         * assert that the tree connect path uses the netbios hostname.
                         */

		t.Fatalf("errors happened when create: %v", err)
	}

	user.Pets = []*Pet{{Name: "pet1"}, {Name: "pet2"}}
	if err := DB.Save(&user).Error; err != nil {
		t.Fatalf("errors happened when update: %v", err)
	}

	var user2 User
	DB.Preload("Pets").Find(&user2, "id = ?", user.ID)
	CheckUser(t, user2, user)

	for _, pet := range user.Pets {
		pet.Name += "new"
	}

	if err := DB.Save(&user).Error; err != nil {

      return this;
    }

    /**
     * Tests {@link Object#equals} and {@link Object#hashCode} against the return values of the
     * static methods, by asserting that when equal parameters are passed to the same static method,
     * the return value should also be equal; and vice versa.
     *
     * <p>Test fails if default value cannot be determined for a constructor or factory method

		return fmt.Sprintf("%q", rune(t))
	}
}

// NewLexer returns a lexer for the named file and the given link context.
func NewLexer(name string) TokenReader {
	input := NewInput(name)
	fd, err := os.Open(name)
	if err != nil {
		log.Fatalf("%s\n", err)
	}
	input.Push(NewTokenizer(name, fd, fd))
	return input
}

// The other files in this directory each contain an implementation of TokenReader.

      headersBuilder.add(header)
    }

  fun addHeader(
    name: String,
    value: Any,
  ) = apply {
    headersBuilder.add(name, value.toString())
  }

  fun addHeaderLenient(
    name: String,
    value: Any,
  ) = apply {
    addHeaderLenient(headersBuilder, name, value.toString())
  }

  fun setHeader(
    name: String,
    value: Any,
  ) = apply {
    removeHeader(name)

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.METHOD})
@Inherited
public @interface Parameter {
    /**
     * name of the bean property used to get/set the field: by default, field name is used.
     * @return the name of the bean property
     */
    @Nonnull
    String name() default "";

    /**
     * alias supported to get parameter value.
     * @return the alias
     */
    @Nonnull

      noCharset.charset(Charsets.UTF_8)!!.name(),
    )
    assertEquals(
      "US-ASCII",
      noCharset.charset(Charsets.US_ASCII)!!.name(),
    )
    val charset = parse("text/plain; charset=iso-8859-1")
    assertEquals(
      "ISO-8859-1",
      charset.charset(Charsets.UTF_8)!!.name(),
    )
    assertEquals(
      "ISO-8859-1",
      charset.charset(Charsets.US_ASCII)!!.name(),
    )
  }

                allowEmpty = false,
            )
            text(
                "gitUserName",
                "",
                label = "Git user.name Configuration",
                description = "Enter the git 'user.name' configuration to commit change under",
                display = ParameterDisplay.PROMPT,
                allowEmpty = true,
            )
        }

        cleanup {

        sourceName.srcHashCode = 12345;

        Name name = new Name(mockConfig, sourceName);

        assertEquals("SOURCENAME", name.name);
        assertEquals(0x1C, name.hexCode);
        assertEquals("source.scope", name.scope);
        assertEquals(12345, name.srcHashCode);
    }

    @Test
    void getName_shouldReturnName() {
        Name name = new Name(mockConfig, "TestName", 0x20, null);

package clause

// Limit limit clause
type Limit struct {
	Limit  *int
	Offset int
}

// Name where clause name
func (limit Limit) Name() string {
	return "LIMIT"
}

// Build build where clause
func (limit Limit) Build(builder Builder) {
	if limit.Limit != nil && *limit.Limit >= 0 {
		builder.WriteString("LIMIT ")
		builder.AddVar(builder, *limit.Limit)
	}
	if limit.Offset > 0 {