private int value;

  Count(int value) {
    this.value = value;
  }

  public int get() {
    return value;
  }

  public void add(int delta) {
    value += delta;
  }

  public int addAndGet(int delta) {
    return value += delta;
  }

  public void set(int newValue) {
    value = newValue;
  }

  public int getAndSet(int newValue) {
    int result = value;
    value = newValue;

  }

  public void testIntWriteBytesTo() {
    byte[] dest = new byte[4];
    HashCode.fromInt(42).writeBytesTo(dest, 0, 4);
    assertThat(dest).isEqualTo(HashCode.fromInt(42).asBytes());
  }

  public void testLongWriteBytesTo() {
    byte[] dest = new byte[8];
    HashCode.fromLong(42).writeBytesTo(dest, 0, 8);
    assertThat(dest).isEqualTo(HashCode.fromLong(42).asBytes());
  }

        // Test with empty source array
        dest = new byte[8];
        nextOffset = NtlmMessage.writeSecurityBuffer(dest, 0, new byte[0]);
        assertEquals(4, nextOffset, "Should return correct next offset for empty source.");
        assertEquals(0, NtlmMessage.readUShort(dest, 0), "Length should be 0 for empty source.");

        byte[] data = { 0x01, 0x02, 0x03, 0x04, 0x05 };
        ByteEncodable encodable = new ByteEncodable(data, 0, 3);
        byte[] dest = new byte[5]; // {0,0,0,0,0}
        dest[0] = (byte) 0xFF; // Add some initial data to dest

        int encodedLen = encodable.encode(dest, 1);

        // Verify encoded length
        assertEquals(3, encodedLen, "Encoded length should be equal to the specified length");

				if rows, err := db.Statement.ConnPool.QueryContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...); db.AddError(err) == nil {
					dest := db.Statement.Dest
					db.Statement.Dest = db.Statement.ReflectValue.Addr().Interface()
					gorm.Scan(rows, db, mode)
					db.Statement.Dest = dest
					db.AddError(rows.Close())

					if db.Statement.Result != nil {
						db.Statement.Result.RowsAffected = db.RowsAffected
					}
				}

        assertArrayEquals(before, dest, "Zero length should leave dest unchanged");
    }

    @Test
    @DisplayName("writeSecurityBuffer copies data and sets fields")
    void testWriteSecurityBufferNonZero() {
        byte[] dest = new byte[8 + 4];
        byte[] payload = { 0x55, 0x66, 0x77 };
        NtlmMessage.writeSecurityBuffer(dest, 0, 8, payload);

Mas em nosso código já estamos utilizando o `secrets.compare_digest()`.

Resumindo, levará o mesmo tempo para comparar `stanleyjobsox` com `stanleyjobson` do que comparar `johndoe` com `stanleyjobson`. E o mesmo para a senha.

Deste modo, ao utilizar `secrets.compare_digest()` no código de sua aplicação, ela estará a salvo contra toda essa gama de ataques de segurança.

### Retorne o erro { #return-the-error }

  }

  public void testIntWriteBytesTo() {
    byte[] dest = new byte[4];
    HashCode.fromInt(42).writeBytesTo(dest, 0, 4);
    assertThat(dest).isEqualTo(HashCode.fromInt(42).asBytes());
  }

  public void testLongWriteBytesTo() {
    byte[] dest = new byte[8];
    HashCode.fromLong(42).writeBytesTo(dest, 0, 8);
    assertThat(dest).isEqualTo(HashCode.fromLong(42).asBytes());
  }

      ) {
        var index = index
        addHeader(entry)

        var delta = entry.hpackSize
        if (index != -1) { // Index -1 == new header.
          delta -= dynamicTable[dynamicTableIndex(index)]!!.hpackSize
        }

        // if the new or replacement header is too big, drop all entries.
        if (delta > maxDynamicTableByteCount) {
          clearDynamicTable()
          return
        }

			}
		}
	}

	db.RowsAffected = 0

	switch dest := db.Statement.Dest.(type) {
	case map[string]interface{}, *map[string]interface{}:
		if initialized || rows.Next() {
			columnTypes, _ := rows.ColumnTypes()
			prepareValues(values, db, columnTypes, columns)

			db.RowsAffected++
			db.AddError(rows.Scan(values...))

			mapValue, ok := dest.(map[string]interface{})
			if !ok {