DB.Table("deleted_users").Create(&user)

	var result UserWithDelete
	if err := DB.Table("deleted_users").First(&result).Error; err != nil {
		t.Errorf("failed to find deleted user, got error %v", err)
	}

	AssertEqual(t, result, user)

	if err := DB.Table("deleted_users").Delete(&result).Error; err != nil {
		t.Errorf("failed to delete user, got error %v", err)
	}

	var result2 UserWithDelete

	}

	var result3 Product2
	if err := DB.First(&result3, "name = ?", "Nice2").Error; err != nil {
		t.Fatalf("Failed to query product, got error: %v", err)
	}

	DB.Model(&result3).Update("Price", 800)
	var result4 Product2
	DB.First(&result4, "name = ?", "Nice2")

	if result4.Price != 600 {
		t.Errorf("Admin product's price should not be changed, expects: %v, got %v", 600, result4.Price)
	}
}

		t.Errorf("Failed to commit transaction, got error %v\n", err)
	}

	if result := db.Where("name=?", "zzjin").Delete(&User{}); result.Error != nil || result.RowsAffected != 1 {
		t.Fatalf("Failed, got error: %v, rows affected: %v", result.Error, result.RowsAffected)
	}

	tx2 := db.Begin()
	if result := tx2.Where("name=?", "zzjin").Delete(&User{}); result.Error != nil || result.RowsAffected != 0 {

            int result1 = response.decode(buffer, 0, 10);
            assertEquals(10, result1);

            // Test at buffer end
            int result2 = response.decode(buffer, 90, 10);
            assertEquals(10, result2);

            // Test full buffer
            int result3 = response.decode(buffer, 0, 100);
            assertEquals(100, result3);
        }

        @Test

    val plan1 = routePlanner.addPlan()
    plan1.connectState = TLS_CONNECTED

    taskRunner.newQueue().execute("connect") {
      val result0 = finder.find()
      assertThat(result0).isEqualTo(plan0.connection)
      val result1 = finder.find()
      assertThat(result1).isEqualTo(plan1.connection)
    }

    taskFaker.runTasks()
    assertEvents(
      "take plan 0",
      "take plan 1",
    )

        String result = popularWordHelper.getCacheKey(seed, tags, roles, fields, excludes);

        assertNotNull(result);
        assertTrue(result.contains("test_seed"));
        assertTrue(result.contains("tag1tag2"));
        assertTrue(result.contains("role1role2"));
        assertTrue(result.contains("field1field2"));
        assertTrue(result.contains("exclude1exclude2"));

        String result1 = provider1.toString();
        String result2 = provider2.toString();

        // Both should have the same format structure
        assertTrue(result1.startsWith("FessUserTimeZoneProcessProvider:{"));
        assertTrue(result2.startsWith("FessUserTimeZoneProcessProvider:{"));

        // But different hash codes
        assertFalse(result1.equals(result2));
    }

        for (byte b : TEST_DATA) {
            hmac2.engineUpdate(b);
        }

        // Both should produce the same result
        byte[] result1 = hmac1.engineDigest();
        byte[] result2 = hmac2.engineDigest();

        assertArrayEquals(result1, result2);
    }

    @Test
    void testHMACT64WithKnownTestVector() throws NoSuchAlgorithmException {
        // Test with known test vector

        User result1 = createTestUser("result1", "Result One");
        User result2 = createTestUser("result2", "Result Two");

        chain.loadResult = result1;
        User returnedUser1 = chain.load(user1);

        chain.loadResult = result2;
        User returnedUser2 = chain.load(user2);

        assertEquals(result1, returnedUser1);
        assertEquals(result2, returnedUser2);

        List<String> results2 = converter2.convert(text, field, "ja");

        assertNotNull(results1);
        assertNotNull(results2);
    }

    @Test
    public void testTransliteratorFunctionality() throws IOException {
        // Test that transliterator converts Hiragana to Katakana
        String text = "ひらがな";
        String field = "content";