assertEquals(28, bytesConsumed1);

        byte[] resumeKey1 = response.getResumeKey();
        assertNotNull(resumeKey1);
        assertEquals((byte) 0x11, resumeKey1[0]);

        // Second decode - should overwrite
        byte[] buffer2 = new byte[28];
        Arrays.fill(buffer2, 0, 24, (byte) 0x22);

        int bytesConsumed2 = response.decode(buffer2, 0, 28);
        assertEquals(28, bytesConsumed2);

    /* Should recover to be able to remove() after next(). */
    assertEquals("B", peekingIterator.next());
    peekingIterator.remove();
    assertEquals("Should have removed an element", 2, list.size());
    assertFalse("Second element should be gone", list.contains("B"));
  }

  static class ThrowsAtEndException extends RuntimeException {
    /* nothing */
  }

  /**

		Data:    "something else",
	}

	result := DB.Clauses(clause.OnConflict{
		OnConstraint: "some_id_other_id_unique",
		UpdateAll:    true,
	}).Create(&thing2)
	if result.Error != nil {
		t.Errorf("creating second thing: %v", result.Error)
	}

	var things []Thing
	if err := DB.Find(&things).Error; err != nil {
		t.Errorf("Failed, got error: %v", err)
	}

	if len(things) > 1 {

        // Verify time was read correctly (accounting for UTime conversion)
        long readTime = (Long) getFieldValue(response, "lastWriteTime");
        // UTime is seconds since 1970, so we need to compare at second precision
        assertEquals(lastWriteTime / 1000, readTime / 1000);
    }

    @Test
    void testReadParameterWordsWireFormatWithZeroWordCount() {
        // Test reading when wordCount is 0

         * into a repository. In the first case, the result needs to be a proper local repository that one can use for
         * local artifact resolution. In the second case, the result needs to precisely obey the path information of the
         * repository's layout to allow pointing at artifacts within the repository. Unfortunately,

			return nil, fmt.Errorf("unable to initialize the queue store of Redis `%s`: %w", id, err)
		}
	}

	pool := &redis.Pool{
		MaxIdle:     3,
		IdleTimeout: 2 * 60 * time.Second,
		Dial: func() (redis.Conn, error) {
			conn, err := redis.Dial("tcp", args.Addr.String())
			if err != nil {
				return nil, err
			}

			if args.Password != "" {
				if args.User != "" {

            assertEquals(100L, SMBUtil.readInt8(buffer, 0));
            assertEquals(200L, SMBUtil.readInt8(buffer, 8));
            assertEquals(300, SMBUtil.readInt4(buffer, 16));

            // Verify second chunk
            assertEquals(400L, SMBUtil.readInt8(buffer, EXPECTED_SIZE));
            assertEquals(500L, SMBUtil.readInt8(buffer, EXPECTED_SIZE + 8));

					mu.Lock()
					offlineEndpoints = append(offlineEndpoints, fmt.Errorf("%s is unreachable: %w", clnt, grid.ErrDisconnected))
					mu.Unlock()
					return
				}

				ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
				defer cancel()

				err := clnt.Verify(ctx, srcCfg)
				mu.Lock()
				if err != nil {
					bootstrapTraceMsg(fmt.Sprintf("bootstrapVerify: %v, endpoint: %s", err, clnt))
					if !isNetworkError(err) {

	var user1, user2 User
	DB.First(&user1, users[0].ID)
	DB.First(&user2, users[1].ID)
	CheckUser(t, user1, *users[0])
	CheckUser(t, user2, *users[1])

	// update with struct
	time.Sleep(1 * time.Second)
	DB.Table("users").Where("name in ?", []string{users[1].Name}).Updates(User{Name: "updates_02_newname"})

	var user3 User
	if err := DB.First(&user3, "name = ?", "updates_02_newname").Error; err != nil {

			return toObjectErr(err, dataUsageBucket, name)
		}
		if !retry {
			break
		}
		retry, err = load(name+".bkp", 30*time.Second)
		if err == nil && !retry {
			// Only return when we have valid data from the backup
			break
		}
		retries++
		time.Sleep(time.Duration(rand.Int63n(int64(time.Second))))
	}

	if retries == 5 {