/**
     * Indicate that this message should retain it's raw payload
     */
    void retainPayload();

    /**
     * Determines whether to retain the message payload.
     *
     * @return whether to retain the message payload
     */
    boolean isRetainPayload();

    /**
     * Gets the raw payload of the message.
     *
     * @return the raw response message
     */
    byte[] getRawPayload();

     */
    private static final Charset UTF16LE = StandardCharsets.UTF_16LE;

    /**
     * Constructs an AvTargetName from raw byte data
     *
     * @param raw the raw byte data for the target name AV pair
     */
    public AvTargetName(final byte[] raw) {
        super(AvPair.MsvAvTargetName, raw);
    }

    /**
     * Constructs an AvTargetName with the specified target name
     *

              exchangeIndex = nextExchangeIndex++,
              socket = MockWebServerSocket(raw),
            )
            processHandshakeFailure(raw)
            return
          }
          val sslSocket =
            sslSocketFactory!!.createSocket(
              raw,
              raw.inetAddress.hostAddress,
              raw.port,
              true,
            ) as SSLSocket

![ambari-login](https://github.com/minio/minio/blob/master/docs/bigdata/images/image3.png?raw=true "ambari login")

### **3.1 Configure Hadoop**

Navigate to **Services** -> **HDFS** -> **CONFIGS** -> **ADVANCED** as shown below

![hdfs-configs](https://github.com/minio/minio/blob/master/docs/bigdata/images/image2.png?raw=true "hdfs advanced configs")

	type result struct {
		Name  string
		Email string
	}

	var results []result
	DB.Raw("SELECT name, age FROM users WHERE name = ? or name = ?", user2.Name, user3.Name).Scan(&results)
	if len(results) != 2 || results[0].Name != user2.Name || results[1].Name != user3.Name {
		t.Errorf("Raw with scan")
	}

	rows, _ := DB.Raw("select name, age from users where name = ?", user3.Name).Rows()
	count := 0
	for rows.Next() {
		count++

	b.ResetTimer()
	for x := 0; x < b.N; x++ {
		DB.Raw("select * from users where id = ?", user.ID).Scan(&u)
	}
}

func BenchmarkScanSlice(b *testing.B) {
	DB.Exec("delete from users")
	for i := 0; i < 10_000; i++ {
		user := *GetUser(fmt.Sprintf("scan-%d", i), Config{})
		DB.Create(&user)
	}

	var u []User
	b.ResetTimer()
	for x := 0; x < b.N; x++ {
		DB.Raw("select * from users").Scan(&u)
	}
}

        Hashing.hmacSha1(keyData).toString());

    assertEquals(
        "Hashing.hmacSha256(Key[algorithm=HmacSHA256, format=RAW])",
        Hashing.hmacSha256(SHA256_KEY).toString());
    assertEquals(
        "Hashing.hmacSha256(Key[algorithm=HmacSHA256, format=RAW])",
        Hashing.hmacSha256(keyData).toString());

    assertEquals(
        "Hashing.hmacSha512(Key[algorithm=HmacSHA512, format=RAW])",

 *
 * @author mbechler
 */
public class AvTimestamp extends AvPair {

    /**
     * Constructs an AvTimestamp from raw byte data
     *
     * @param raw the raw byte data for the timestamp AV pair
     */
    public AvTimestamp(final byte[] raw) {
        super(AvPair.MsvAvTimestamp, raw);
    }

    /**
     * Constructs an AvTimestamp with the specified timestamp value
     *

 * <p>
 * Model transformers allow plugins and extensions to modify the POM model during the build process.
 * Transformations can be applied at three different stages:
 * <ol>
 *   <li>File model - The raw model as read directly from the file</li>
 *   <li>Raw model - The model after inheritance has been applied</li>
 *   <li>Effective model - The fully processed model with all interpolation and inheritance applied</li>
 * </ol>
 * <p>

    void parseSetsMechanismToken() throws IOException {
        TestSpnegoToken t = new TestSpnegoToken();
        byte[] raw = new byte[] { 5, 6 };
        t.parse(raw);
        assertTrue(t.isParsed(), "parse should mark parsed");
        assertArrayEquals(raw, t.getMechanismToken(), "parse should set mechanismToken");
    }

    @Test
    @DisplayName("parse throws IOException on null input")