zhouxy108/hutool
1
0
Fork 0
mirror of https://gitee.com/chinabugotech/hutool.git synced 2025-07-21 15:09:48 +08:00
Code Issues Packages Projects Releases Wiki Activity

update to junit5

Browse Source
This commit is contained in:
Looly
2023-03-31 02:56:36 +08:00
parent 210fed9621
commit c14390dd6d
507 changed files with 8903 additions and 8847 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
hutool-crypto/src/test/java/cn/hutool/crypto/BCUtilTest.java
View File

@@ -2,8 +2,8 @@ package cn.hutool.crypto;
import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
import org.bouncycastle.crypto.params.ECPublicKeyParameters;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
public class BCUtilTest {
@@ -16,7 +16,7 @@ public class BCUtilTest {
final String y = "F7E938B02EED7280277493B8556E5B01CB436E018A562DFDC53342BF41FDF728";
final ECPublicKeyParameters keyParameters = BCUtil.toSm2Params(x, y);
Assert.assertNotNull(keyParameters);
Assertions.assertNotNull(keyParameters);
}
@Test
@@ -24,6 +24,6 @@ public class BCUtilTest {
final String privateKeyHex = "5F6CA5BB044C40ED2355F0372BF72A5B3AE6943712F9FDB7C1FFBAECC06F3829";
final ECPrivateKeyParameters keyParameters = BCUtil.toSm2Params(privateKeyHex);
Assert.assertNotNull(keyParameters);
Assertions.assertNotNull(keyParameters);
}
}

36
hutool-crypto/src/test/java/cn/hutool/crypto/KeyUtilTest.java
View File

@@ -1,8 +1,8 @@
package cn.hutool.crypto;
import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import java.security.KeyPair;
import java.security.PrivateKey;
@@ -13,12 +13,14 @@ public class KeyUtilTest {
/**
* 测试关闭BouncyCastle支持时是否会正常抛出异常，即关闭是否有效
*/
@Test(expected = CryptoException.class)
@Ignore
@Test
@Disabled
public void generateKeyPairTest() {
GlobalBouncyCastleProvider.setUseBouncyCastle(false);
final KeyPair pair = KeyUtil.generateKeyPair("SM2");
Assert.assertNotNull(pair);
Assertions.assertThrows(CryptoException.class, ()->{
GlobalBouncyCastleProvider.setUseBouncyCastle(false);
final KeyPair pair = KeyUtil.generateKeyPair("SM2");
Assertions.assertNotNull(pair);
});
}
@Test
@@ -26,7 +28,7 @@ public class KeyUtilTest {
final KeyPair keyPair = KeyUtil.generateKeyPair("RSA");
final PrivateKey aPrivate = keyPair.getPrivate();
final PublicKey rsaPublicKey = KeyUtil.getRSAPublicKey(aPrivate);
Assert.assertEquals(rsaPublicKey, keyPair.getPublic());
Assertions.assertEquals(rsaPublicKey, keyPair.getPublic());
}
/**
@@ -35,31 +37,31 @@ public class KeyUtilTest {
@Test
public void generateECIESKeyTest(){
final KeyPair ecies = KeyUtil.generateKeyPair("ECIES");
Assert.assertNotNull(ecies.getPrivate());
Assert.assertNotNull(ecies.getPublic());
Assertions.assertNotNull(ecies.getPrivate());
Assertions.assertNotNull(ecies.getPublic());
final byte[] privateKeyBytes = ecies.getPrivate().getEncoded();
final PrivateKey privateKey = KeyUtil.generatePrivateKey("EC", privateKeyBytes);
Assert.assertEquals(ecies.getPrivate(), privateKey);
Assertions.assertEquals(ecies.getPrivate(), privateKey);
}
@Test
public void generateDHTest(){
final KeyPair dh = KeyUtil.generateKeyPair("DH");
Assert.assertNotNull(dh.getPrivate());
Assert.assertNotNull(dh.getPublic());
Assertions.assertNotNull(dh.getPrivate());
Assertions.assertNotNull(dh.getPublic());
final byte[] privateKeyBytes = dh.getPrivate().getEncoded();
final PrivateKey privateKey = KeyUtil.generatePrivateKey("DH", privateKeyBytes);
Assert.assertEquals(dh.getPrivate(), privateKey);
Assertions.assertEquals(dh.getPrivate(), privateKey);
}
@Test
public void generateSm4KeyTest(){
// https://github.com/dromara/hutool/issues/2150
Assert.assertEquals(16, KeyUtil.generateKey("sm4").getEncoded().length);
Assert.assertEquals(32, KeyUtil.generateKey("sm4", 256).getEncoded().length);
Assertions.assertEquals(16, KeyUtil.generateKey("sm4").getEncoded().length);
Assertions.assertEquals(32, KeyUtil.generateKey("sm4", 256).getEncoded().length);
}
}

6
hutool-crypto/src/test/java/cn/hutool/crypto/OpensslKeyUtilTest.java
View File

@@ -3,8 +3,8 @@ package cn.hutool.crypto;
import cn.hutool.core.io.resource.ResourceUtil;
import cn.hutool.core.util.ByteUtil;
import cn.hutool.crypto.asymmetric.SM2;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.security.PrivateKey;
import java.security.PublicKey;
@@ -49,7 +49,7 @@ public class OpensslKeyUtilTest {
final String content = "我是Hanley.";
final byte[] sign = genSm2.sign(ByteUtil.toUtf8Bytes(content));
final boolean verify = genSm2.verify(ByteUtil.toUtf8Bytes(content), sign);
Assert.assertTrue(verify);
Assertions.assertTrue(verify);
}
}
}

22
hutool-crypto/src/test/java/cn/hutool/crypto/PemUtilTest.java
View File

@@ -6,9 +6,9 @@ import cn.hutool.core.util.ByteUtil;
import cn.hutool.crypto.asymmetric.KeyType;
import cn.hutool.crypto.asymmetric.RSA;
import cn.hutool.crypto.asymmetric.SM2;
import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import java.nio.charset.StandardCharsets;
import java.security.PrivateKey;
@@ -19,19 +19,19 @@ public class PemUtilTest {
@Test
public void readPrivateKeyTest() {
final PrivateKey privateKey = PemUtil.readPemPrivateKey(ResourceUtil.getStream("test_private_key.pem"));
Assert.assertNotNull(privateKey);
Assertions.assertNotNull(privateKey);
}
@Test
public void readPublicKeyTest() {
final PublicKey publicKey = PemUtil.readPemPublicKey(ResourceUtil.getStream("test_public_key.csr"));
Assert.assertNotNull(publicKey);
Assertions.assertNotNull(publicKey);
}
@Test
public void readPemKeyTest() {
final PublicKey publicKey = (PublicKey) PemUtil.readPemKey(ResourceUtil.getStream("test_public_key.csr"));
Assert.assertNotNull(publicKey);
Assertions.assertNotNull(publicKey);
}
@Test
@@ -44,7 +44,7 @@ public class PemUtilTest {
final String encryptStr = rsa.encryptBase64(str, KeyType.PublicKey);
final String decryptStr = rsa.decryptStr(encryptStr, KeyType.PrivateKey);
Assert.assertEquals(str, decryptStr);
Assertions.assertEquals(str, decryptStr);
}
@Test
@@ -58,7 +58,7 @@ public class PemUtilTest {
final byte[] sign = sm2.sign(dataBytes, null);
// 64位签名
Assert.assertEquals(64, sign.length);
Assertions.assertEquals(64, sign.length);
}
@Test
@@ -72,11 +72,11 @@ public class PemUtilTest {
final byte[] sign = sm2.sign(dataBytes, null);
// 64位签名
Assert.assertEquals(64, sign.length);
Assertions.assertEquals(64, sign.length);
}
@Test
@Ignore
@Disabled
public void readECPrivateKeyTest2() {
// https://gitee.com/dromara/hutool/issues/I37Z75
final byte[] d = PemUtil.readPem(FileUtil.getInputStream("d:/test/keys/priv.key"));
@@ -88,6 +88,6 @@ public class PemUtilTest {
final String content = "我是Hanley.";
final byte[] sign = sm2.sign(ByteUtil.toUtf8Bytes(content));
final boolean verify = sm2.verify(ByteUtil.toUtf8Bytes(content), sign);
Assert.assertTrue(verify);
Assertions.assertTrue(verify);
}
}

24
hutool-crypto/src/test/java/cn/hutool/crypto/SmTest.java
View File

@@ -3,8 +3,8 @@ package cn.hutool.crypto;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.crypto.digest.HMac;
import cn.hutool.crypto.symmetric.SM4;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import javax.crypto.SecretKey;
@@ -19,7 +19,7 @@ public class SmTest {
@Test
public void sm3Test() {
final String digestHex = SmUtil.sm3("aaaaa");
Assert.assertEquals("136ce3c86e4ed909b76082055a61586af20b4dab674732ebd4b599eef080c9be", digestHex);
Assertions.assertEquals("136ce3c86e4ed909b76082055a61586af20b4dab674732ebd4b599eef080c9be", digestHex);
}
@Test
@@ -30,7 +30,7 @@ public class SmTest {
final String encryptHex = sm4.encryptHex(content);
final String decryptStr = sm4.decryptStr(encryptHex, CharsetUtil.UTF_8);
Assert.assertEquals(content, decryptStr);
Assertions.assertEquals(content, decryptStr);
}
@Test
@@ -42,18 +42,18 @@ public class SmTest {
final String encryptHex = sm4.encryptHex(content);
final String decryptStr = sm4.decryptStr(encryptHex, CharsetUtil.UTF_8);
Assert.assertEquals(content, decryptStr);
Assertions.assertEquals(content, decryptStr);
}
@Test
public void sm4ECBPKCS5PaddingTest2() {
final String content = "test中文";
final SM4 sm4 = new SM4(Mode.ECB, Padding.PKCS5Padding);
Assert.assertEquals("SM4/ECB/PKCS5Padding", sm4.getCipher().getAlgorithm());
Assertions.assertEquals("SM4/ECB/PKCS5Padding", sm4.getCipher().getAlgorithm());
final String encryptHex = sm4.encryptHex(content);
final String decryptStr = sm4.decryptStr(encryptHex, CharsetUtil.UTF_8);
Assert.assertEquals(content, decryptStr);
Assertions.assertEquals(content, decryptStr);
}
@Test
@@ -63,11 +63,11 @@ public class SmTest {
final SecretKey key = KeyUtil.generateKey(SM4.ALGORITHM_NAME);
final SM4 sm4 = new SM4(Mode.ECB, Padding.PKCS5Padding, key);
Assert.assertEquals("SM4/ECB/PKCS5Padding", sm4.getCipher().getAlgorithm());
Assertions.assertEquals("SM4/ECB/PKCS5Padding", sm4.getCipher().getAlgorithm());
final String encryptHex = sm4.encryptHex(content);
final String decryptStr = sm4.decryptStr(encryptHex, CharsetUtil.UTF_8);
Assert.assertEquals(content, decryptStr);
Assertions.assertEquals(content, decryptStr);
}
@Test
@@ -77,11 +77,11 @@ public class SmTest {
final byte[] key = KeyUtil.generateKey(SM4.ALGORITHM_NAME, 128).getEncoded();
final SM4 sm4 = SmUtil.sm4(key);
Assert.assertEquals("SM4", sm4.getCipher().getAlgorithm());
Assertions.assertEquals("SM4", sm4.getCipher().getAlgorithm());
final String encryptHex = sm4.encryptHex(content);
final String decryptStr = sm4.decryptStr(encryptHex, CharsetUtil.UTF_8);
Assert.assertEquals(content, decryptStr);
Assertions.assertEquals(content, decryptStr);
}
@Test
@@ -89,7 +89,7 @@ public class SmTest {
final String content = "test中文";
final HMac hMac = SmUtil.hmacSm3("password".getBytes());
final String digest = hMac.digestHex(content);
Assert.assertEquals("493e3f9a1896b43075fbe54658076727960d69632ac6b6ed932195857a6840c6", digest);
Assertions.assertEquals("493e3f9a1896b43075fbe54658076727960d69632ac6b6ed932195857a6840c6", digest);
}

6
hutool-crypto/src/test/java/cn/hutool/crypto/asymmetric/ECIESTest.java
View File

@@ -1,8 +1,8 @@
package cn.hutool.crypto.asymmetric;
import cn.hutool.core.text.StrUtil;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
public class ECIESTest {
@@ -39,6 +39,6 @@ public class ECIESTest {
final String encryptStr = cryptoForEncrypt.encryptBase64(text.toString(), KeyType.PublicKey);
final String decryptStr = StrUtil.utf8Str(cryptoForDecrypt.decrypt(encryptStr, KeyType.PrivateKey));
Assert.assertEquals(text.toString(), decryptStr);
Assertions.assertEquals(text.toString(), decryptStr);
}
}

70
hutool-crypto/src/test/java/cn/hutool/crypto/asymmetric/RSATest.java
View File

@@ -9,8 +9,8 @@ import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.crypto.KeyUtil;
import cn.hutool.crypto.SecureUtil;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import javax.crypto.Cipher;
import java.math.BigInteger;
@@ -27,8 +27,8 @@ public class RSATest {
@Test
public void generateKeyPairTest() {
final KeyPair pair = KeyUtil.generateKeyPair("RSA");
Assert.assertNotNull(pair.getPrivate());
Assert.assertNotNull(pair.getPublic());
Assertions.assertNotNull(pair.getPrivate());
Assertions.assertNotNull(pair.getPublic());
}
@Test
@@ -42,12 +42,12 @@ public class RSATest {
// 公钥加密，私钥解密
final byte[] encrypt = rsa.encrypt(ByteUtil.toBytes("我是一段测试aaaa", CharsetUtil.UTF_8), KeyType.PublicKey);
final byte[] decrypt = rsa.decrypt(encrypt, KeyType.PrivateKey);
Assert.assertEquals("我是一段测试aaaa", StrUtil.str(decrypt, CharsetUtil.UTF_8));
Assertions.assertEquals("我是一段测试aaaa", StrUtil.str(decrypt, CharsetUtil.UTF_8));
// 私钥加密，公钥解密
final byte[] encrypt2 = rsa.encrypt(ByteUtil.toBytes("我是一段测试aaaa", CharsetUtil.UTF_8), KeyType.PrivateKey);
final byte[] decrypt2 = rsa.decrypt(encrypt2, KeyType.PublicKey);
Assert.assertEquals("我是一段测试aaaa", StrUtil.str(decrypt2, CharsetUtil.UTF_8));
Assertions.assertEquals("我是一段测试aaaa", StrUtil.str(decrypt2, CharsetUtil.UTF_8));
}
@Test
@@ -55,21 +55,21 @@ public class RSATest {
final RSA rsa = new RSA();
// 获取私钥和公钥
Assert.assertNotNull(rsa.getPrivateKey());
Assert.assertNotNull(rsa.getPrivateKeyBase64());
Assert.assertNotNull(rsa.getPublicKey());
Assert.assertNotNull(rsa.getPrivateKeyBase64());
Assertions.assertNotNull(rsa.getPrivateKey());
Assertions.assertNotNull(rsa.getPrivateKeyBase64());
Assertions.assertNotNull(rsa.getPublicKey());
Assertions.assertNotNull(rsa.getPrivateKeyBase64());
// 公钥加密，私钥解密
final byte[] encrypt = rsa.encrypt(ByteUtil.toBytes("我是一段测试aaaa", CharsetUtil.UTF_8), KeyType.PublicKey);
final byte[] decrypt = rsa.decrypt(encrypt, KeyType.PrivateKey);
Assert.assertEquals("我是一段测试aaaa", StrUtil.str(decrypt, CharsetUtil.UTF_8));
Assertions.assertEquals("我是一段测试aaaa", StrUtil.str(decrypt, CharsetUtil.UTF_8));
// 私钥加密，公钥解密
final byte[] encrypt2 = rsa.encrypt(ByteUtil.toBytes("我是一段测试aaaa", CharsetUtil.UTF_8), KeyType.PrivateKey);
final byte[] decrypt2 = rsa.decrypt(encrypt2, KeyType.PublicKey);
Assert.assertEquals("我是一段测试aaaa", StrUtil.str(decrypt2, CharsetUtil.UTF_8));
Assertions.assertEquals("我是一段测试aaaa", StrUtil.str(decrypt2, CharsetUtil.UTF_8));
}
@Test
@@ -77,21 +77,21 @@ public class RSATest {
final RSA rsa = new RSA(AsymmetricAlgorithm.RSA_ECB.getValue());
// 获取私钥和公钥
Assert.assertNotNull(rsa.getPrivateKey());
Assert.assertNotNull(rsa.getPrivateKeyBase64());
Assert.assertNotNull(rsa.getPublicKey());
Assert.assertNotNull(rsa.getPrivateKeyBase64());
Assertions.assertNotNull(rsa.getPrivateKey());
Assertions.assertNotNull(rsa.getPrivateKeyBase64());
Assertions.assertNotNull(rsa.getPublicKey());
Assertions.assertNotNull(rsa.getPrivateKeyBase64());
// 公钥加密，私钥解密
final byte[] encrypt = rsa.encrypt(ByteUtil.toBytes("我是一段测试aaaa", CharsetUtil.UTF_8), KeyType.PublicKey);
final byte[] decrypt = rsa.decrypt(encrypt, KeyType.PrivateKey);
Assert.assertEquals("我是一段测试aaaa", StrUtil.str(decrypt, CharsetUtil.UTF_8));
Assertions.assertEquals("我是一段测试aaaa", StrUtil.str(decrypt, CharsetUtil.UTF_8));
// 私钥加密，公钥解密
final byte[] encrypt2 = rsa.encrypt(ByteUtil.toBytes("我是一段测试aaaa", CharsetUtil.UTF_8), KeyType.PrivateKey);
final byte[] decrypt2 = rsa.decrypt(encrypt2, KeyType.PublicKey);
Assert.assertEquals("我是一段测试aaaa", StrUtil.str(decrypt2, CharsetUtil.UTF_8));
Assertions.assertEquals("我是一段测试aaaa", StrUtil.str(decrypt2, CharsetUtil.UTF_8));
}
@Test
@@ -99,21 +99,21 @@ public class RSATest {
final RSA rsa = new RSA(AsymmetricAlgorithm.RSA_None.getValue());
// 获取私钥和公钥
Assert.assertNotNull(rsa.getPrivateKey());
Assert.assertNotNull(rsa.getPrivateKeyBase64());
Assert.assertNotNull(rsa.getPublicKey());
Assert.assertNotNull(rsa.getPrivateKeyBase64());
Assertions.assertNotNull(rsa.getPrivateKey());
Assertions.assertNotNull(rsa.getPrivateKeyBase64());
Assertions.assertNotNull(rsa.getPublicKey());
Assertions.assertNotNull(rsa.getPrivateKeyBase64());
// 公钥加密，私钥解密
final byte[] encrypt = rsa.encrypt(ByteUtil.toBytes("我是一段测试aaaa", CharsetUtil.UTF_8), KeyType.PublicKey);
final byte[] decrypt = rsa.decrypt(encrypt, KeyType.PrivateKey);
Assert.assertEquals("我是一段测试aaaa", StrUtil.str(decrypt, CharsetUtil.UTF_8));
Assertions.assertEquals("我是一段测试aaaa", StrUtil.str(decrypt, CharsetUtil.UTF_8));
// 私钥加密，公钥解密
final byte[] encrypt2 = rsa.encrypt(ByteUtil.toBytes("我是一段测试aaaa", CharsetUtil.UTF_8), KeyType.PrivateKey);
final byte[] decrypt2 = rsa.decrypt(encrypt2, KeyType.PublicKey);
Assert.assertEquals("我是一段测试aaaa", StrUtil.str(decrypt2, CharsetUtil.UTF_8));
Assertions.assertEquals("我是一段测试aaaa", StrUtil.str(decrypt2, CharsetUtil.UTF_8));
}
@Test
@@ -122,20 +122,20 @@ public class RSATest {
rsa.setEncryptBlockSize(3);
// 获取私钥和公钥
Assert.assertNotNull(rsa.getPrivateKey());
Assert.assertNotNull(rsa.getPrivateKeyBase64());
Assert.assertNotNull(rsa.getPublicKey());
Assert.assertNotNull(rsa.getPrivateKeyBase64());
Assertions.assertNotNull(rsa.getPrivateKey());
Assertions.assertNotNull(rsa.getPrivateKeyBase64());
Assertions.assertNotNull(rsa.getPublicKey());
Assertions.assertNotNull(rsa.getPrivateKeyBase64());
// 公钥加密，私钥解密
final byte[] encrypt = rsa.encrypt(ByteUtil.toBytes("我是一段测试aaaa", CharsetUtil.UTF_8), KeyType.PublicKey);
final byte[] decrypt = rsa.decrypt(encrypt, KeyType.PrivateKey);
Assert.assertEquals("我是一段测试aaaa", StrUtil.str(decrypt, CharsetUtil.UTF_8));
Assertions.assertEquals("我是一段测试aaaa", StrUtil.str(decrypt, CharsetUtil.UTF_8));
// 私钥加密，公钥解密
final byte[] encrypt2 = rsa.encrypt(ByteUtil.toBytes("我是一段测试aaaa", CharsetUtil.UTF_8), KeyType.PrivateKey);
final byte[] decrypt2 = rsa.decrypt(encrypt2, KeyType.PublicKey);
Assert.assertEquals("我是一段测试aaaa", StrUtil.str(decrypt2, CharsetUtil.UTF_8));
Assertions.assertEquals("我是一段测试aaaa", StrUtil.str(decrypt2, CharsetUtil.UTF_8));
}
@Test
@@ -151,12 +151,12 @@ public class RSATest {
// 公钥加密，私钥解密
final String encryptStr = rsa.encryptBase64(text.toString(), KeyType.PublicKey);
final String decryptStr = StrUtil.utf8Str(rsa.decrypt(encryptStr, KeyType.PrivateKey));
Assert.assertEquals(text.toString(), decryptStr);
Assertions.assertEquals(text.toString(), decryptStr);
// 私钥加密，公钥解密
final String encrypt2 = rsa.encryptBase64(text.toString(), KeyType.PrivateKey);
final String decrypt2 = StrUtil.utf8Str(rsa.decrypt(encrypt2, KeyType.PublicKey));
Assert.assertEquals(text.toString(), decrypt2);
Assertions.assertEquals(text.toString(), decrypt2);
}
@Test
@@ -181,7 +181,7 @@ public class RSATest {
final byte[] aByte = HexUtil.decodeHex(a);
final byte[] decrypt = rsa.decrypt(aByte, KeyType.PrivateKey);
Assert.assertEquals("虎头闯杭州,多抬头看天,切勿只管种地", StrUtil.str(decrypt, CharsetUtil.UTF_8));
Assertions.assertEquals("虎头闯杭州,多抬头看天,切勿只管种地", StrUtil.str(decrypt, CharsetUtil.UTF_8));
}
@Test
@@ -207,7 +207,7 @@ public class RSATest {
rsa.setEncryptBlockSize(128);
final String result2 = rsa.encryptHex(finalData, KeyType.PublicKey);
Assert.assertEquals(result1, result2);
Assertions.assertEquals(result1, result2);
}
@Test
@@ -220,6 +220,6 @@ public class RSATest {
final RSA rsa = new RSA(new BigInteger(modulus, 16), null, new BigInteger(publicExponent));
final String encryptBase64 = rsa.encryptBase64("测试内容", KeyType.PublicKey);
Assert.assertNotNull(encryptBase64);
Assertions.assertNotNull(encryptBase64);
}
}

74
hutool-crypto/src/test/java/cn/hutool/crypto/asymmetric/SM2Test.java
View File

@@ -12,8 +12,8 @@ import cn.hutool.crypto.SmUtil;
import org.bouncycastle.crypto.engines.SM2Engine;
import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
import org.bouncycastle.jcajce.spec.OpenSSHPrivateKeySpec;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.nio.charset.StandardCharsets;
import java.security.KeyPair;
@@ -30,8 +30,8 @@ public class SM2Test {
@Test
public void generateKeyPairTest() {
final KeyPair pair = KeyUtil.generateKeyPair("SM2");
Assert.assertNotNull(pair.getPrivate());
Assert.assertNotNull(pair.getPublic());
Assertions.assertNotNull(pair.getPrivate());
Assertions.assertNotNull(pair.getPublic());
new SM2(pair.getPrivate(), pair.getPublic());
}
@@ -41,8 +41,8 @@ public class SM2Test {
// OBJECT IDENTIFIER 1.2.156.10197.1.301
final String OID = "06082A811CCF5501822D";
final KeyPair pair = KeyUtil.generateKeyPair("SM2");
Assert.assertTrue(HexUtil.encodeHexStr(pair.getPrivate().getEncoded()).toUpperCase().contains(OID));
Assert.assertTrue(HexUtil.encodeHexStr(pair.getPublic().getEncoded()).toUpperCase().contains(OID));
Assertions.assertTrue(HexUtil.encodeHexStr(pair.getPrivate().getEncoded()).toUpperCase().contains(OID));
Assertions.assertTrue(HexUtil.encodeHexStr(pair.getPublic().getEncoded()).toUpperCase().contains(OID));
}
@Test
@@ -57,7 +57,7 @@ public class SM2Test {
// 公钥加密，私钥解密
final byte[] encrypt = sm2.encrypt(ByteUtil.toBytes("我是一段测试aaaa", CharsetUtil.UTF_8), KeyType.PublicKey);
final byte[] decrypt = sm2.decrypt(encrypt, KeyType.PrivateKey);
Assert.assertEquals("我是一段测试aaaa", StrUtil.str(decrypt, CharsetUtil.UTF_8));
Assertions.assertEquals("我是一段测试aaaa", StrUtil.str(decrypt, CharsetUtil.UTF_8));
}
@Test
@@ -65,15 +65,15 @@ public class SM2Test {
final SM2 sm2 = SmUtil.sm2();
// 获取私钥和公钥
Assert.assertNotNull(sm2.getPrivateKey());
Assert.assertNotNull(sm2.getPrivateKeyBase64());
Assert.assertNotNull(sm2.getPublicKey());
Assert.assertNotNull(sm2.getPrivateKeyBase64());
Assertions.assertNotNull(sm2.getPrivateKey());
Assertions.assertNotNull(sm2.getPrivateKeyBase64());
Assertions.assertNotNull(sm2.getPublicKey());
Assertions.assertNotNull(sm2.getPrivateKeyBase64());
// 公钥加密，私钥解密
final byte[] encrypt = sm2.encrypt(ByteUtil.toBytes("我是一段测试aaaa", CharsetUtil.UTF_8), KeyType.PublicKey);
final byte[] decrypt = sm2.decrypt(encrypt, KeyType.PrivateKey);
Assert.assertEquals("我是一段测试aaaa", StrUtil.str(decrypt, CharsetUtil.UTF_8));
Assertions.assertEquals("我是一段测试aaaa", StrUtil.str(decrypt, CharsetUtil.UTF_8));
}
@Test
@@ -89,7 +89,7 @@ public class SM2Test {
// 公钥加密，私钥解密
final String encryptStr = sm2.encryptBase64(text.toString(), KeyType.PublicKey);
final String decryptStr = StrUtil.utf8Str(sm2.decrypt(encryptStr, KeyType.PrivateKey));
Assert.assertEquals(text.toString(), decryptStr);
Assertions.assertEquals(text.toString(), decryptStr);
// 测试自定义密钥后是否生效
final PrivateKey privateKey = sm2.getPrivateKey();
@@ -99,7 +99,7 @@ public class SM2Test {
sm2.setPrivateKey(privateKey);
sm2.setPublicKey(publicKey);
final String decryptStr2 = StrUtil.utf8Str(sm2.decrypt(encryptStr, KeyType.PrivateKey));
Assert.assertEquals(text.toString(), decryptStr2);
Assertions.assertEquals(text.toString(), decryptStr2);
}
@Test
@@ -113,7 +113,7 @@ public class SM2Test {
sm2.usePlainEncoding();
final byte[] sign = sm2.sign(dataBytes, null);
// 64位签名
Assert.assertEquals(64, sign.length);
Assertions.assertEquals(64, sign.length);
}
@Test
@@ -129,7 +129,7 @@ public class SM2Test {
sm2.usePlainEncoding();
final boolean verify = sm2.verify(dataBytes, HexUtil.decodeHex(signHex));
Assert.assertTrue(verify);
Assertions.assertTrue(verify);
}
@Test
@@ -140,7 +140,7 @@ public class SM2Test {
final byte[] sign = sm2.sign(ByteUtil.toUtf8Bytes(content));
final boolean verify = sm2.verify(ByteUtil.toUtf8Bytes(content), sign);
Assert.assertTrue(verify);
Assertions.assertTrue(verify);
}
@Test
@@ -151,7 +151,7 @@ public class SM2Test {
final String sign = sm2.signHex(HexUtil.encodeHexStr(content));
final boolean verify = sm2.verifyHex(HexUtil.encodeHexStr(content), sign);
Assert.assertTrue(verify);
Assertions.assertTrue(verify);
}
@Test
@@ -164,7 +164,7 @@ public class SM2Test {
final byte[] sign = sm2.sign(content.getBytes(StandardCharsets.UTF_8));
final boolean verify = sm2.verify(content.getBytes(StandardCharsets.UTF_8), sign);
Assert.assertTrue(verify);
Assertions.assertTrue(verify);
}
@Test
@@ -180,7 +180,7 @@ public class SM2Test {
final byte[] sign = sm2.sign(content.getBytes(StandardCharsets.UTF_8));
final boolean verify = sm2.verify(content.getBytes(StandardCharsets.UTF_8), sign);
Assert.assertTrue(verify);
Assertions.assertTrue(verify);
}
@Test
@@ -192,8 +192,8 @@ public class SM2Test {
final String encodeB64 = Base64.encode(data);
final PublicKey Hexdecode = KeyUtil.decodeECPoint(encodeHex, KeyUtil.SM2_DEFAULT_CURVE);
final PublicKey B64decode = KeyUtil.decodeECPoint(encodeB64, KeyUtil.SM2_DEFAULT_CURVE);
Assert.assertEquals(HexUtil.encodeHexStr(publicKey.getEncoded()), HexUtil.encodeHexStr(Hexdecode.getEncoded()));
Assert.assertEquals(HexUtil.encodeHexStr(publicKey.getEncoded()), HexUtil.encodeHexStr(B64decode.getEncoded()));
Assertions.assertEquals(HexUtil.encodeHexStr(publicKey.getEncoded()), HexUtil.encodeHexStr(Hexdecode.getEncoded()));
Assertions.assertEquals(HexUtil.encodeHexStr(publicKey.getEncoded()), HexUtil.encodeHexStr(B64decode.getEncoded()));
}
@Test
@@ -207,7 +207,7 @@ public class SM2Test {
final SM2 sm2 = new SM2(d, x, y);
final String sign = sm2.signHex(data, id);
Assert.assertTrue(sm2.verifyHex(data, sign));
Assertions.assertTrue(sm2.verifyHex(data, sign));
}
@Test
@@ -227,10 +227,10 @@ public class SM2Test {
final String sign = "DCA0E80A7F46C93714B51C3EFC55A922BCEF7ECF0FE9E62B53BA6A7438B543A76C145A452CA9036F3CB70D7E6C67D4D9D7FE114E5367A2F6F5A4D39F2B10F3D6";
Assert.assertTrue(sm2.verifyHex(data, sign));
Assertions.assertTrue(sm2.verifyHex(data, sign));
final String sign2 = sm2.signHex(data, id);
Assert.assertTrue(sm2.verifyHex(data, sign2));
Assertions.assertTrue(sm2.verifyHex(data, sign2));
}
@Test
@@ -245,7 +245,7 @@ public class SM2Test {
final String encryptHex = sm2.encryptHex(data, KeyType.PublicKey);
final String decryptStr = sm2.decryptStr(encryptHex, KeyType.PrivateKey);
Assert.assertEquals(data, decryptStr);
Assertions.assertEquals(data, decryptStr);
}
@Test
@@ -256,10 +256,10 @@ public class SM2Test {
final byte[] data = sm2.encrypt(src, KeyType.PublicKey);
final byte[] sign = sm2.sign(src.getBytes(StandardCharsets.UTF_8));
Assert.assertTrue(sm2.verify( src.getBytes(StandardCharsets.UTF_8), sign));
Assertions.assertTrue(sm2.verify( src.getBytes(StandardCharsets.UTF_8), sign));
final byte[] dec = sm2.decrypt(data, KeyType.PrivateKey);
Assert.assertArrayEquals(dec, src.getBytes(StandardCharsets.UTF_8));
Assertions.assertArrayEquals(dec, src.getBytes(StandardCharsets.UTF_8));
}
@Test
@@ -277,10 +277,10 @@ public class SM2Test {
final byte[] data = sm2.encrypt(src, KeyType.PublicKey);
final byte[] sign = sm2.sign(src.getBytes(StandardCharsets.UTF_8));
Assert.assertTrue(sm2.verify( src.getBytes(StandardCharsets.UTF_8), sign));
Assertions.assertTrue(sm2.verify( src.getBytes(StandardCharsets.UTF_8), sign));
final byte[] dec = sm2.decrypt(data, KeyType.PrivateKey);
Assert.assertArrayEquals(dec, src.getBytes(StandardCharsets.UTF_8));
Assertions.assertArrayEquals(dec, src.getBytes(StandardCharsets.UTF_8));
}
@Test
@@ -295,20 +295,20 @@ public class SM2Test {
final byte[] data = sm2.encrypt(src, KeyType.PublicKey);
final byte[] sign = sm2.sign(src.getBytes(StandardCharsets.UTF_8));
Assert.assertTrue(sm2.verify( src.getBytes(StandardCharsets.UTF_8), sign));
Assertions.assertTrue(sm2.verify( src.getBytes(StandardCharsets.UTF_8), sign));
final byte[] dec = sm2.decrypt(data, KeyType.PrivateKey);
Assert.assertArrayEquals(dec, src.getBytes(StandardCharsets.UTF_8));
Assertions.assertArrayEquals(dec, src.getBytes(StandardCharsets.UTF_8));
}
@Test
public void dLengthTest(){
final SM2 sm2 = SmUtil.sm2();
Assert.assertEquals(64, sm2.getDHex().length());
Assert.assertEquals(32, sm2.getD().length);
Assertions.assertEquals(64, sm2.getDHex().length());
Assertions.assertEquals(32, sm2.getD().length);
// 04占位一个字节
Assert.assertEquals(65, sm2.getQ(false).length);
Assertions.assertEquals(65, sm2.getQ(false).length);
}
@Test
@@ -318,7 +318,7 @@ public class SM2Test {
final String q = "04" + x + y;
final SM2 sm1 = new SM2(null, x, y);
final SM2 sm2 = new SM2(null, q);
Assert.assertNotNull(sm1);
Assert.assertNotNull(sm2);
Assertions.assertNotNull(sm1);
Assertions.assertNotNull(sm2);
}
}

20
hutool-crypto/src/test/java/cn/hutool/crypto/asymmetric/SignTest.java
View File

@@ -3,8 +3,8 @@ package cn.hutool.crypto.asymmetric;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.ByteUtil;
import cn.hutool.crypto.SignUtil;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.HashMap;
import java.util.Map;
@@ -22,7 +22,7 @@ public class SignTest {
final String privateKey = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAJ4fG8vJ0tzu7tjXMSJhyNjlE5B7GkTKMKEQlR6LY3IhIhMFVjuA6W+DqH1VMxl9h3GIM4yCKG2VRZEYEPazgVxa5/ifO8W0pfmrzWCPrddUq4t0Slz5u2lLKymLpPjCzboHoDb8VlF+1HOxjKQckAXq9q7U7dV5VxOzJDuZXlz3AgMBAAECgYABo2LfVqT3owYYewpIR+kTzjPIsG3SPqIIWSqiWWFbYlp/BfQhw7EndZ6+Ra602ecYVwfpscOHdx90ZGJwm+WAMkKT4HiWYwyb0ZqQzRBGYDHFjPpfCBxrzSIJ3QL+B8c8YHq4HaLKRKmq7VUF1gtyWaek87rETWAmQoGjt8DyAQJBAOG4OxsT901zjfxrgKwCv6fV8wGXrNfDSViP1t9r3u6tRPsE6Gli0dfMyzxwENDTI75sOEAfyu6xBlemQGmNsfcCQQCzVWQkl9YUoVDWEitvI5MpkvVKYsFLRXKvLfyxLcY3LxpLKBcEeJ/n5wLxjH0GorhJMmM2Rw3hkjUTJCoqqe0BAkATt8FKC0N2O5ryqv1xiUfuxGzW/cX2jzOwDdiqacTuuqok93fKBPzpyhUS8YM2iss7jj6Xs29JzKMOMxK7ZcpfAkAf21lwzrAu9gEgJhYlJhKsXfjJAAYKUwnuaKLs7o65mtp242ZDWxI85eK1+hjzptBJ4HOTXsfufESFY/VBovIBAkAltO886qQRoNSc0OsVlCi4X1DGo6x2RqQ9EsWPrxWEZGYuyEdODrc54b8L+zaUJLfMJdsCIHEUbM7WXxvFVXNv";
Sign sign = SignUtil.sign(SignAlgorithm.SHA1withRSA, privateKey, null);
Assert.assertNull(sign.getPublicKeyBase64());
Assertions.assertNull(sign.getPublicKeyBase64());
// 签名
final byte[] signed = sign.sign(content.getBytes());
@@ -30,7 +30,7 @@ public class SignTest {
sign = SignUtil.sign(SignAlgorithm.SHA1withRSA, null, publicKey);
// 验证签名
final boolean verify = sign.verify(content.getBytes(), signed);
Assert.assertTrue(verify);
Assertions.assertTrue(verify);
}
@Test
@@ -69,7 +69,7 @@ public class SignTest {
// 验证签名
final boolean verify = sign.verify(data, signed);
Assert.assertTrue(verify);
Assertions.assertTrue(verify);
}
/**
@@ -86,7 +86,7 @@ public class SignTest {
// 验证签名
final boolean verify = sign.verify(data, signed);
Assert.assertTrue(verify);
Assertions.assertTrue(verify);
}
@Test
@@ -96,11 +96,11 @@ public class SignTest {
.put("key2", "value2").build();
final String sign1 = SignUtil.signParamsSha1(build);
Assert.assertEquals("9ed30bfe2efbc7038a824b6c55c24a11bfc0dce5", sign1);
Assertions.assertEquals("9ed30bfe2efbc7038a824b6c55c24a11bfc0dce5", sign1);
final String sign2 = SignUtil.signParamsSha1(build, "12345678");
Assert.assertEquals("944b68d94c952ec178c4caf16b9416b6661f7720", sign2);
Assertions.assertEquals("944b68d94c952ec178c4caf16b9416b6661f7720", sign2);
final String sign3 = SignUtil.signParamsSha1(build, "12345678", "abc");
Assert.assertEquals("edee1b477af1b96ebd20fdf08d818f352928d25d", sign3);
Assertions.assertEquals("edee1b477af1b96ebd20fdf08d818f352928d25d", sign3);
}
/**
@@ -117,6 +117,6 @@ public class SignTest {
// 验证签名
final boolean verify = sign.verify(data, signed);
Assert.assertTrue(verify);
Assertions.assertTrue(verify);
}
}

6
hutool-crypto/src/test/java/cn/hutool/crypto/digest/BCryptTest.java
View File

@@ -1,13 +1,13 @@
package cn.hutool.crypto.digest;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
public class BCryptTest {
@Test
public void checkpwTest(){
Assert.assertFalse(BCrypt.checkpw("xxx",
Assertions.assertFalse(BCrypt.checkpw("xxx",
"$2a$2a$10$e4lBTlZ019KhuAFyqAlgB.Jxc6cM66GwkSR/5/xXNQuHUItPLyhzy"));
}
}

8
hutool-crypto/src/test/java/cn/hutool/crypto/digest/CBCBlockCipherMacEngineTest.java
View File

@@ -6,8 +6,8 @@ import cn.hutool.crypto.digest.mac.SM4MacEngine;
import org.bouncycastle.crypto.CipherParameters;
import org.bouncycastle.crypto.params.KeyParameter;
import org.bouncycastle.crypto.params.ParametersWithIV;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
public class CBCBlockCipherMacEngineTest {
@@ -22,7 +22,7 @@ public class CBCBlockCipherMacEngineTest {
final String testStr = "test中文";
final String macHex1 = mac.digestHex(testStr);
Assert.assertEquals("3212e848db7f816a4bd591ad9948debf", macHex1);
Assertions.assertEquals("3212e848db7f816a4bd591ad9948debf", macHex1);
}
@Test
@@ -38,6 +38,6 @@ public class CBCBlockCipherMacEngineTest {
final String testStr = "test中文";
final String macHex1 = mac.digestHex(testStr);
Assert.assertEquals("3212e848db7f816a4bd591ad9948debf", macHex1);
Assertions.assertEquals("3212e848db7f816a4bd591ad9948debf", macHex1);
}
}

26
hutool-crypto/src/test/java/cn/hutool/crypto/digest/DigestTest.java
View File

@@ -1,7 +1,7 @@
package cn.hutool.crypto.digest;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import cn.hutool.core.io.IoUtil;
import cn.hutool.core.util.CharsetUtil;
@@ -19,7 +19,7 @@ public class DigestTest {
final Digester md5 = new Digester(DigestAlgorithm.MD5);
final String digestHex = md5.digestHex(testStr);
Assert.assertEquals("5393554e94bf0eb6436f240a4fd71282", digestHex);
Assertions.assertEquals("5393554e94bf0eb6436f240a4fd71282", digestHex);
}
@Test
@@ -27,10 +27,10 @@ public class DigestTest {
final String testStr = "test中文";
final String md5Hex1 = DigestUtil.md5Hex(testStr);
Assert.assertEquals("5393554e94bf0eb6436f240a4fd71282", md5Hex1);
Assertions.assertEquals("5393554e94bf0eb6436f240a4fd71282", md5Hex1);
final String md5Hex2 = DigestUtil.md5Hex(IoUtil.toStream(testStr, CharsetUtil.UTF_8));
Assert.assertEquals("5393554e94bf0eb6436f240a4fd71282", md5Hex2);
Assertions.assertEquals("5393554e94bf0eb6436f240a4fd71282", md5Hex2);
}
@Test
@@ -42,16 +42,16 @@ public class DigestTest {
//加盐
md5.setSalt("saltTest".getBytes());
final String md5Hex1 = md5.digestHex(testStr);
Assert.assertEquals("762f7335200299dfa09bebbb601a5bc6", md5Hex1);
Assertions.assertEquals("762f7335200299dfa09bebbb601a5bc6", md5Hex1);
final String md5Hex2 = md5.digestHex(IoUtil.toUtf8Stream(testStr));
Assert.assertEquals("762f7335200299dfa09bebbb601a5bc6", md5Hex2);
Assertions.assertEquals("762f7335200299dfa09bebbb601a5bc6", md5Hex2);
//重复2次
md5.setDigestCount(2);
final String md5Hex3 = md5.digestHex(testStr);
Assert.assertEquals("2b0616296f6755d25efc07f90afe9684", md5Hex3);
Assertions.assertEquals("2b0616296f6755d25efc07f90afe9684", md5Hex3);
final String md5Hex4 = md5.digestHex(IoUtil.toUtf8Stream(testStr));
Assert.assertEquals("2b0616296f6755d25efc07f90afe9684", md5Hex4);
Assertions.assertEquals("2b0616296f6755d25efc07f90afe9684", md5Hex4);
}
@Test
@@ -59,23 +59,23 @@ public class DigestTest {
final String testStr = "test中文";
final String sha1Hex1 = DigestUtil.sha1Hex(testStr);
Assert.assertEquals("ecabf586cef0d3b11c56549433ad50b81110a836", sha1Hex1);
Assertions.assertEquals("ecabf586cef0d3b11c56549433ad50b81110a836", sha1Hex1);
final String sha1Hex2 = DigestUtil.sha1Hex(IoUtil.toStream(testStr, CharsetUtil.UTF_8));
Assert.assertEquals("ecabf586cef0d3b11c56549433ad50b81110a836", sha1Hex2);
Assertions.assertEquals("ecabf586cef0d3b11c56549433ad50b81110a836", sha1Hex2);
}
@Test
public void hash256Test() {
final String testStr = "Test中文";
final String hex = DigestUtil.sha256Hex(testStr);
Assert.assertEquals(64, hex.length());
Assertions.assertEquals(64, hex.length());
}
@Test
public void hash512Test() {
final String testStr = "Test中文";
final String hex = DigestUtil.sha512Hex(testStr);
Assert.assertEquals(128, hex.length());
Assertions.assertEquals(128, hex.length());
}
}

22
hutool-crypto/src/test/java/cn/hutool/crypto/digest/HmacTest.java
View File

@@ -5,8 +5,8 @@ import cn.hutool.core.util.CharsetUtil;
import cn.hutool.crypto.KeyUtil;
import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.symmetric.ZUC;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import javax.crypto.spec.IvParameterSpec;
@@ -25,10 +25,10 @@ public class HmacTest {
final HMac mac = new HMac(HmacAlgorithm.HmacMD5, key);
final String macHex1 = mac.digestHex(testStr);
Assert.assertEquals("b977f4b13f93f549e06140971bded384", macHex1);
Assertions.assertEquals("b977f4b13f93f549e06140971bded384", macHex1);
final String macHex2 = mac.digestHex(IoUtil.toStream(testStr, CharsetUtil.UTF_8));
Assert.assertEquals("b977f4b13f93f549e06140971bded384", macHex2);
Assertions.assertEquals("b977f4b13f93f549e06140971bded384", macHex2);
}
@Test
@@ -38,10 +38,10 @@ public class HmacTest {
final HMac mac = SecureUtil.hmacMd5("password");
final String macHex1 = mac.digestHex(testStr);
Assert.assertEquals("b977f4b13f93f549e06140971bded384", macHex1);
Assertions.assertEquals("b977f4b13f93f549e06140971bded384", macHex1);
final String macHex2 = mac.digestHex(IoUtil.toStream(testStr, CharsetUtil.UTF_8));
Assert.assertEquals("b977f4b13f93f549e06140971bded384", macHex2);
Assertions.assertEquals("b977f4b13f93f549e06140971bded384", macHex2);
}
@Test
@@ -50,10 +50,10 @@ public class HmacTest {
final String testStr = "test中文";
final String macHex1 = mac.digestHex(testStr);
Assert.assertEquals("1dd68d2f119d5640f0d416e99d3f42408b88d511", macHex1);
Assertions.assertEquals("1dd68d2f119d5640f0d416e99d3f42408b88d511", macHex1);
final String macHex2 = mac.digestHex(IoUtil.toStream(testStr, CharsetUtil.UTF_8));
Assert.assertEquals("1dd68d2f119d5640f0d416e99d3f42408b88d511", macHex2);
Assertions.assertEquals("1dd68d2f119d5640f0d416e99d3f42408b88d511", macHex2);
}
@Test
@@ -66,7 +66,7 @@ public class HmacTest {
final String testStr = "test中文";
final String macHex1 = mac.digestHex(testStr);
Assert.assertEquals("1e0b9455", macHex1);
Assertions.assertEquals("1e0b9455", macHex1);
}
@Test
@@ -79,7 +79,7 @@ public class HmacTest {
final String testStr = "test中文";
final String macHex1 = mac.digestHex(testStr);
Assert.assertEquals("d9ad618357c1bfb1d9d1200a763d5eaa", macHex1);
Assertions.assertEquals("d9ad618357c1bfb1d9d1200a763d5eaa", macHex1);
}
@Test
@@ -93,6 +93,6 @@ public class HmacTest {
final String testStr = "test中文";
final String macHex1 = mac.digestHex(testStr);
Assert.assertEquals("58a0d231315664af51b858a174eabc21", macHex1);
Assertions.assertEquals("58a0d231315664af51b858a174eabc21", macHex1);
}
}

8
hutool-crypto/src/test/java/cn/hutool/crypto/digest/Md5Test.java
View File

@@ -1,7 +1,7 @@
package cn.hutool.crypto.digest;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
/**
* MD5 单元测试
@@ -14,7 +14,7 @@ public class Md5Test {
@Test
public void md5To16Test() {
final String hex16 = new MD5().digestHex16("中国");
Assert.assertEquals(16, hex16.length());
Assert.assertEquals("cb143acd6c929826", hex16);
Assertions.assertEquals(16, hex16.length());
Assertions.assertEquals("cb143acd6c929826", hex16);
}
}

80
hutool-crypto/src/test/java/cn/hutool/crypto/digest/OTPTest.java
View File

@@ -3,8 +3,8 @@ package cn.hutool.crypto.digest;
import cn.hutool.core.codec.binary.Base32;
import cn.hutool.crypto.digest.otp.HOTP;
import cn.hutool.crypto.digest.otp.TOTP;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.time.Duration;
import java.time.Instant;
@@ -18,49 +18,49 @@ public class OTPTest {
@Test
public void genKeyTest() {
final String key = TOTP.generateSecretKey(8);
Assert.assertEquals(8, Base32.decode(key).length);
Assertions.assertEquals(8, Base32.decode(key).length);
}
@Test
public void validTest() {
final String key = "VYCFSW2QZ3WZO";
// 2021/7/1下午6:29:54 显示code为 106659
//Assert.assertEquals(new TOTP(Base32.decode(key)).generate(Instant.ofEpochSecond(1625135394L)),106659);
//Assertions.assertEquals(new TOTP(Base32.decode(key)).generate(Instant.ofEpochSecond(1625135394L)),106659);
final TOTP totp = new TOTP(Base32.decode(key));
final Instant instant = Instant.ofEpochSecond(1625135394L);
Assert.assertTrue(totp.validate(instant, 0, 106659));
Assert.assertTrue(totp.validate(instant.plusSeconds(30), 1, 106659));
Assert.assertTrue(totp.validate(instant.plusSeconds(60), 2, 106659));
Assertions.assertTrue(totp.validate(instant, 0, 106659));
Assertions.assertTrue(totp.validate(instant.plusSeconds(30), 1, 106659));
Assertions.assertTrue(totp.validate(instant.plusSeconds(60), 2, 106659));
Assert.assertFalse(totp.validate(instant.plusSeconds(60), 1, 106659));
Assert.assertFalse(totp.validate(instant.plusSeconds(90), 2, 106659));
Assertions.assertFalse(totp.validate(instant.plusSeconds(60), 1, 106659));
Assertions.assertFalse(totp.validate(instant.plusSeconds(90), 2, 106659));
}
@Test
public void googleAuthTest() {
final String str = TOTP.generateGoogleSecretKey("xl7@qq.com", 10);
Assert.assertTrue(str.startsWith("otpauth://totp/xl7@qq.com?secret="));
Assertions.assertTrue(str.startsWith("otpauth://totp/xl7@qq.com?secret="));
}
@Test
public void longPasswordLengthTest() {
Assert.assertThrows(IllegalArgumentException.class, () -> new HOTP(9, "123".getBytes()));
Assertions.assertThrows(IllegalArgumentException.class, () -> new HOTP(9, "123".getBytes()));
}
@Test
public void generateHOPTTest(){
final byte[] key = "12345678901234567890".getBytes();
final HOTP hotp = new HOTP(key);
Assert.assertEquals(755224, hotp.generate(0));
Assert.assertEquals(287082, hotp.generate(1));
Assert.assertEquals(359152, hotp.generate(2));
Assert.assertEquals(969429, hotp.generate(3));
Assert.assertEquals(338314, hotp.generate(4));
Assert.assertEquals(254676, hotp.generate(5));
Assert.assertEquals(287922, hotp.generate(6));
Assert.assertEquals(162583, hotp.generate(7));
Assert.assertEquals(399871, hotp.generate(8));
Assert.assertEquals(520489, hotp.generate(9));
Assertions.assertEquals(755224, hotp.generate(0));
Assertions.assertEquals(287082, hotp.generate(1));
Assertions.assertEquals(359152, hotp.generate(2));
Assertions.assertEquals(969429, hotp.generate(3));
Assertions.assertEquals(338314, hotp.generate(4));
Assertions.assertEquals(254676, hotp.generate(5));
Assertions.assertEquals(287922, hotp.generate(6));
Assertions.assertEquals(162583, hotp.generate(7));
Assertions.assertEquals(399871, hotp.generate(8));
Assertions.assertEquals(520489, hotp.generate(9));
}
@Test
@@ -69,7 +69,7 @@ public class OTPTest {
final TOTP totp = new TOTP(timeStep, "123".getBytes());
Assert.assertEquals(timeStep, totp.getTimeStep());
Assertions.assertEquals(timeStep, totp.getTimeStep());
}
@Test
@@ -79,17 +79,17 @@ public class OTPTest {
final TOTP totp = new TOTP(Duration.ofSeconds(30), 8, algorithm, key);
int generate = totp.generate(Instant.ofEpochSecond(59L));
Assert.assertEquals(94287082, generate);
Assertions.assertEquals(94287082, generate);
generate = totp.generate(Instant.ofEpochSecond(1111111109L));
Assert.assertEquals(7081804, generate);
Assertions.assertEquals(7081804, generate);
generate = totp.generate(Instant.ofEpochSecond(1111111111L));
Assert.assertEquals(14050471, generate);
Assertions.assertEquals(14050471, generate);
generate = totp.generate(Instant.ofEpochSecond(1234567890L));
Assert.assertEquals(89005924, generate);
Assertions.assertEquals(89005924, generate);
generate = totp.generate(Instant.ofEpochSecond(2000000000L));
Assert.assertEquals(69279037, generate);
Assertions.assertEquals(69279037, generate);
generate = totp.generate(Instant.ofEpochSecond(20000000000L));
Assert.assertEquals(65353130, generate);
Assertions.assertEquals(65353130, generate);
}
@Test
@@ -99,17 +99,17 @@ public class OTPTest {
final TOTP totp = new TOTP(Duration.ofSeconds(30), 8, algorithm, key);
int generate = totp.generate(Instant.ofEpochSecond(59L));
Assert.assertEquals(46119246, generate);
Assertions.assertEquals(46119246, generate);
generate = totp.generate(Instant.ofEpochSecond(1111111109L));
Assert.assertEquals(68084774, generate);
Assertions.assertEquals(68084774, generate);
generate = totp.generate(Instant.ofEpochSecond(1111111111L));
Assert.assertEquals(67062674, generate);
Assertions.assertEquals(67062674, generate);
generate = totp.generate(Instant.ofEpochSecond(1234567890L));
Assert.assertEquals(91819424, generate);
Assertions.assertEquals(91819424, generate);
generate = totp.generate(Instant.ofEpochSecond(2000000000L));
Assert.assertEquals(90698825, generate);
Assertions.assertEquals(90698825, generate);
generate = totp.generate(Instant.ofEpochSecond(20000000000L));
Assert.assertEquals(77737706, generate);
Assertions.assertEquals(77737706, generate);
}
@Test
@@ -119,16 +119,16 @@ public class OTPTest {
final TOTP totp = new TOTP(Duration.ofSeconds(30), 8, algorithm, key);
int generate = totp.generate(Instant.ofEpochSecond(59L));
Assert.assertEquals(90693936, generate);
Assertions.assertEquals(90693936, generate);
generate = totp.generate(Instant.ofEpochSecond(1111111109L));
Assert.assertEquals(25091201, generate);
Assertions.assertEquals(25091201, generate);
generate = totp.generate(Instant.ofEpochSecond(1111111111L));
Assert.assertEquals(99943326, generate);
Assertions.assertEquals(99943326, generate);
generate = totp.generate(Instant.ofEpochSecond(1234567890L));
Assert.assertEquals(93441116, generate);
Assertions.assertEquals(93441116, generate);
generate = totp.generate(Instant.ofEpochSecond(2000000000L));
Assert.assertEquals(38618901, generate);
Assertions.assertEquals(38618901, generate);
generate = totp.generate(Instant.ofEpochSecond(20000000000L));
Assert.assertEquals(47863826, generate);
Assertions.assertEquals(47863826, generate);
}
}

30
hutool-crypto/src/test/java/cn/hutool/crypto/symmetric/AESTest.java
View File

@@ -6,8 +6,8 @@ import cn.hutool.core.util.RandomUtil;
import cn.hutool.crypto.KeyUtil;
import cn.hutool.crypto.Mode;
import cn.hutool.crypto.Padding;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import javax.crypto.SecretKey;
import javax.crypto.spec.GCMParameterSpec;
@@ -21,7 +21,7 @@ public class AESTest {
final AES aes = new AES(Mode.CBC, Padding.PKCS5Padding,
"1234567890123456".getBytes(), "1234567890123456".getBytes());
final String encryptHex = aes.encryptHex("123456");
Assert.assertEquals("d637735ae9e21ba50cb686b74fab8d2c", encryptHex);
Assertions.assertEquals("d637735ae9e21ba50cb686b74fab8d2c", encryptHex);
}
@Test
@@ -30,7 +30,7 @@ public class AESTest {
final AES aes = new AES(Mode.CTS, Padding.PKCS5Padding,
"0CoJUm6Qyw8W8jue".getBytes(), "0102030405060708".getBytes());
final String encryptHex = aes.encryptHex(content);
Assert.assertEquals("8dc9de7f050e86ca2c8261dde56dfec9", encryptHex);
Assertions.assertEquals("8dc9de7f050e86ca2c8261dde56dfec9", encryptHex);
}
@Test
@@ -39,7 +39,7 @@ public class AESTest {
final AES aes = new AES(Mode.CBC.name(), "pkcs7padding",
"1234567890123456".getBytes(), "1234567890123456".getBytes());
final String encryptHex = aes.encryptHex("123456");
Assert.assertEquals("d637735ae9e21ba50cb686b74fab8d2c", encryptHex);
Assertions.assertEquals("d637735ae9e21ba50cb686b74fab8d2c", encryptHex);
}
/**
@@ -71,32 +71,32 @@ public class AESTest {
// 加密数据为16进制字符串
final String encryptHex = aes.encryptHex(HexUtil.decodeHex("16c5"));
// 加密后的Hex
Assert.assertEquals("25869eb3ff227d9e34b3512d3c3c92ed", encryptHex);
Assertions.assertEquals("25869eb3ff227d9e34b3512d3c3c92ed", encryptHex);
// 加密数据为16进制字符串
final String encryptHex2 = aes.encryptBase64(HexUtil.decodeHex("16c5"));
// 加密后的Base64
Assert.assertEquals("JYaes/8ifZ40s1EtPDyS7Q==", encryptHex2);
Assertions.assertEquals("JYaes/8ifZ40s1EtPDyS7Q==", encryptHex2);
// 解密
Assert.assertEquals("16c5", HexUtil.encodeHexStr(aes.decrypt("25869eb3ff227d9e34b3512d3c3c92ed")));
Assert.assertEquals("16c5", HexUtil.encodeHexStr(aes.decrypt(HexUtil.encodeHexStr(Base64.decode("JYaes/8ifZ40s1EtPDyS7Q==")))));
Assertions.assertEquals("16c5", HexUtil.encodeHexStr(aes.decrypt("25869eb3ff227d9e34b3512d3c3c92ed")));
Assertions.assertEquals("16c5", HexUtil.encodeHexStr(aes.decrypt(HexUtil.encodeHexStr(Base64.decode("JYaes/8ifZ40s1EtPDyS7Q==")))));
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
// 加密数据为字符串(UTF-8)
final String encryptStr = aes.encryptHex("16c5");
// 加密后的Hex
Assert.assertEquals("79c210d3e304932cf9ea6a9c887c6d7c", encryptStr);
Assertions.assertEquals("79c210d3e304932cf9ea6a9c887c6d7c", encryptStr);
// 加密数据为字符串(UTF-8)
final String encryptStr2 = aes.encryptBase64("16c5");
// 加密后的Base64
Assert.assertEquals("ecIQ0+MEkyz56mqciHxtfA==", encryptStr2);
Assertions.assertEquals("ecIQ0+MEkyz56mqciHxtfA==", encryptStr2);
// 解密
Assert.assertEquals("16c5", aes.decryptStr("79c210d3e304932cf9ea6a9c887c6d7c"));
Assert.assertEquals("16c5", aes.decryptStr(Base64.decode("ecIQ0+MEkyz56mqciHxtfA==")));
Assertions.assertEquals("16c5", aes.decryptStr("79c210d3e304932cf9ea6a9c887c6d7c"));
Assertions.assertEquals("16c5", aes.decryptStr(Base64.decode("ecIQ0+MEkyz56mqciHxtfA==")));
// ------------------------------------------------------------------------
}
@@ -110,7 +110,7 @@ public class AESTest {
final String result1 = aes.encryptBase64(content);
final String decryptStr = aes.decryptStr(result1);
Assert.assertEquals(content, decryptStr);
Assertions.assertEquals(content, decryptStr);
}
/**
@@ -130,6 +130,6 @@ public class AESTest {
// 加密
final byte[] encrypt = aes.encrypt(phone);
final String decryptStr = aes.decryptStr(encrypt);
Assert.assertEquals(phone, decryptStr);
Assertions.assertEquals(phone, decryptStr);
}
}

6
hutool-crypto/src/test/java/cn/hutool/crypto/symmetric/ChaCha20Test.java
View File

@@ -2,8 +2,8 @@ package cn.hutool.crypto.symmetric;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.RandomUtil;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
/**
* 见：https://stackoverflow.com/questions/32672241/using-bouncycastles-chacha-for-file-encryption
@@ -25,6 +25,6 @@ public class ChaCha20Test {
// 解密为字符串
final String decryptStr = chacha.decryptStr(encryptHex, CharsetUtil.UTF_8);
Assert.assertEquals(content, decryptStr);
Assertions.assertEquals(content, decryptStr);
}
}

20
hutool-crypto/src/test/java/cn/hutool/crypto/symmetric/DesTest.java
View File

@@ -6,8 +6,8 @@ import cn.hutool.crypto.KeyUtil;
import cn.hutool.crypto.Mode;
import cn.hutool.crypto.Padding;
import cn.hutool.crypto.SecureUtil;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
/**
* DES加密解密单元测试
@@ -24,12 +24,12 @@ public class DesTest {
final byte[] encrypt = des.encrypt(content);
final byte[] decrypt = des.decrypt(encrypt);
Assert.assertEquals(content, StrUtil.utf8Str(decrypt));
Assertions.assertEquals(content, StrUtil.utf8Str(decrypt));
final String encryptHex = des.encryptHex(content);
final String decryptStr = des.decryptStr(encryptHex);
Assert.assertEquals(content, decryptStr);
Assertions.assertEquals(content, decryptStr);
}
@Test
@@ -42,12 +42,12 @@ public class DesTest {
final byte[] encrypt = des.encrypt(content);
final byte[] decrypt = des.decrypt(encrypt);
Assert.assertEquals(content, StrUtil.utf8Str(decrypt));
Assertions.assertEquals(content, StrUtil.utf8Str(decrypt));
final String encryptHex = des.encryptHex(content);
final String decryptStr = des.decryptStr(encryptHex);
Assert.assertEquals(content, decryptStr);
Assertions.assertEquals(content, decryptStr);
}
@Test
@@ -59,12 +59,12 @@ public class DesTest {
final byte[] encrypt = des.encrypt(content);
final byte[] decrypt = des.decrypt(encrypt);
Assert.assertEquals(content, StrUtil.utf8Str(decrypt));
Assertions.assertEquals(content, StrUtil.utf8Str(decrypt));
final String encryptHex = des.encryptHex(content);
final String decryptStr = des.decryptStr(encryptHex);
Assert.assertEquals(content, decryptStr);
Assertions.assertEquals(content, decryptStr);
}
@Test
@@ -75,7 +75,7 @@ public class DesTest {
final String encryptHex = des.encryptHex(content);
final String result = des.decryptStr(encryptHex);
Assert.assertEquals(content, result);
Assertions.assertEquals(content, result);
}
@Test
@@ -91,7 +91,7 @@ public class DesTest {
final String encryptHex = des.encryptHex(content);
final String result = des.decryptStr(encryptHex);
Assert.assertEquals(content, result);
Assertions.assertEquals(content, result);
}
@Test

6
hutool-crypto/src/test/java/cn/hutool/crypto/symmetric/Issue2613Test.java
View File

@@ -1,8 +1,8 @@
package cn.hutool.crypto.symmetric;
import cn.hutool.crypto.Padding;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
public class Issue2613Test {
@@ -14,6 +14,6 @@ public class Issue2613Test {
final String encryptHex = aes.encryptHex("123456");
final String s = aes.decryptStr(encryptHex);
Assert.assertEquals("123456", s);
Assertions.assertEquals("123456", s);
}
}

6
hutool-crypto/src/test/java/cn/hutool/crypto/symmetric/PBKDF2Test.java
View File

@@ -2,14 +2,14 @@ package cn.hutool.crypto.symmetric;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.crypto.SecureUtil;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
public class PBKDF2Test {
@Test
public void encryptTest(){
final String s = SecureUtil.pbkdf2("123456".toCharArray(), RandomUtil.randomBytes(16));
Assert.assertEquals(128, s.length());
Assertions.assertEquals(128, s.length());
}
}

20
hutool-crypto/src/test/java/cn/hutool/crypto/symmetric/RC4Test.java
View File

@@ -1,8 +1,8 @@
package cn.hutool.crypto.symmetric;
import cn.hutool.core.util.CharsetUtil;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
public class RC4Test {
@@ -13,12 +13,12 @@ public class RC4Test {
final String message = "Hello, World!";
final byte[] crypt = rc4.encrypt(message);
final String msg = rc4.decrypt(crypt);
Assert.assertEquals(message, msg);
Assertions.assertEquals(message, msg);
final String message2 = "Hello, World， this is megssage 2";
final byte[] crypt2 = rc4.encrypt(message2);
final String msg2 = rc4.decrypt(crypt2);
Assert.assertEquals(message2, msg2);
Assertions.assertEquals(message2, msg2);
}
@Test
@@ -28,12 +28,12 @@ public class RC4Test {
final RC4 rc4 = new RC4(key);
final byte[] crypt = rc4.encrypt(message);
final String msg = rc4.decrypt(crypt);
Assert.assertEquals(message, msg);
Assertions.assertEquals(message, msg);
final String message2 = "这是第二个中文消息！";
final byte[] crypt2 = rc4.encrypt(message2);
final String msg2 = rc4.decrypt(crypt2);
Assert.assertEquals(message2, msg2);
Assertions.assertEquals(message2, msg2);
}
@Test
@@ -43,12 +43,12 @@ public class RC4Test {
final RC4 rc4 = new RC4(key);
final String encryptHex = rc4.encryptHex(message, CharsetUtil.UTF_8);
final String msg = rc4.decrypt(encryptHex);
Assert.assertEquals(message, msg);
Assertions.assertEquals(message, msg);
final String message2 = "这是第二个用来测试密文为十六进制字符串的消息！";
final String encryptHex2 = rc4.encryptHex(message2);
final String msg2 = rc4.decrypt(encryptHex2);
Assert.assertEquals(message2, msg2);
Assertions.assertEquals(message2, msg2);
}
@@ -59,11 +59,11 @@ public class RC4Test {
final RC4 rc4 = new RC4(key);
final String encryptHex = rc4.encryptBase64(message, CharsetUtil.UTF_8);
final String msg = rc4.decrypt(encryptHex);
Assert.assertEquals(message, msg);
Assertions.assertEquals(message, msg);
final String message2 = "这是第一个用来测试密文为Base64编码的消息！";
final String encryptHex2 = rc4.encryptBase64(message2);
final String msg2 = rc4.decrypt(encryptHex2);
Assert.assertEquals(message2, msg2);
Assertions.assertEquals(message2, msg2);
}
}

6
hutool-crypto/src/test/java/cn/hutool/crypto/symmetric/Sm4StreamTest.java
View File

@@ -1,7 +1,7 @@
package cn.hutool.crypto.symmetric;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.io.InputStream;
@@ -19,7 +19,7 @@ public class Sm4StreamTest {
private static final boolean IS_CLOSE = false;
@Test
@Ignore
@Disabled
public void sm4Test(){
final String source = "d:/test/sm4_1.txt";
final String target = "d:/test/sm4_2.data";

42
hutool-crypto/src/test/java/cn/hutool/crypto/symmetric/SymmetricTest.java
View File

@@ -9,8 +9,8 @@ import cn.hutool.crypto.KeyUtil;
import cn.hutool.crypto.Mode;
import cn.hutool.crypto.Padding;
import cn.hutool.crypto.SecureUtil;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
@@ -37,14 +37,14 @@ public class SymmetricTest {
// 解密
final byte[] decrypt = aes.decrypt(encrypt);
Assert.assertEquals(content, StrUtil.str(decrypt, CharsetUtil.UTF_8));
Assertions.assertEquals(content, StrUtil.str(decrypt, CharsetUtil.UTF_8));
// 加密为16进制表示
final String encryptHex = aes.encryptHex(content);
// 解密为字符串
final String decryptStr = aes.decryptStr(encryptHex, CharsetUtil.UTF_8);
Assert.assertEquals(content, decryptStr);
Assertions.assertEquals(content, decryptStr);
}
@Test
@@ -62,14 +62,14 @@ public class SymmetricTest {
// 解密
final byte[] decrypt = aes.decrypt(encrypt);
Assert.assertEquals(content, StrUtil.utf8Str(decrypt));
Assertions.assertEquals(content, StrUtil.utf8Str(decrypt));
// 加密为16进制表示
final String encryptHex = aes.encryptHex(content);
// 解密为字符串
final String decryptStr = aes.decryptStr(encryptHex, CharsetUtil.UTF_8);
Assert.assertEquals(content, decryptStr);
Assertions.assertEquals(content, decryptStr);
}
@Test
@@ -83,14 +83,14 @@ public class SymmetricTest {
// 解密
final byte[] decrypt = aes.decrypt(encrypt);
Assert.assertEquals(content, StrUtil.utf8Str(decrypt));
Assertions.assertEquals(content, StrUtil.utf8Str(decrypt));
// 加密为16进制表示
final String encryptHex = aes.encryptHex(content);
// 解密为字符串
final String decryptStr = aes.decryptStr(encryptHex, CharsetUtil.UTF_8);
Assert.assertEquals(content, decryptStr);
Assertions.assertEquals(content, decryptStr);
}
@Test
@@ -101,7 +101,7 @@ public class SymmetricTest {
// 加密为16进制表示
final String encryptHex = aes.encryptHex(content);
Assert.assertEquals("cd0e3a249eaf0ed80c330338508898c4bddcfd665a1b414622164a273ca5daf7b4ebd2c00aaa66b84dd0a237708dac8e", encryptHex);
Assertions.assertEquals("cd0e3a249eaf0ed80c330338508898c4bddcfd665a1b414622164a273ca5daf7b4ebd2c00aaa66b84dd0a237708dac8e", encryptHex);
}
@Test
@@ -114,7 +114,7 @@ public class SymmetricTest {
final String encryptHex = crypto.encryptHex(content);
final String data = crypto.decryptStr(encryptHex);
Assert.assertEquals(content, data);
Assertions.assertEquals(content, data);
}
@Test
@@ -127,8 +127,8 @@ public class SymmetricTest {
final String randomData = aes.updateHex(content.getBytes(StandardCharsets.UTF_8));
aes.setMode(CipherMode.encrypt);
final String randomData2 = aes.updateHex(content.getBytes(StandardCharsets.UTF_8));
Assert.assertEquals(randomData2, randomData);
Assert.assertEquals(randomData, "cd0e3a249eaf0ed80c330338508898c4");
Assertions.assertEquals(randomData2, randomData);
Assertions.assertEquals(randomData, "cd0e3a249eaf0ed80c330338508898c4");
}
@@ -141,7 +141,7 @@ public class SymmetricTest {
final String encryptHex = aes.encryptHex(content);
// 解密
final String decryptStr = aes.decryptStr(encryptHex);
Assert.assertEquals(content, decryptStr);
Assertions.assertEquals(content, decryptStr);
}
@Test
@@ -155,7 +155,7 @@ public class SymmetricTest {
final ByteArrayOutputStream contentStream = new ByteArrayOutputStream();
aes.decrypt(IoUtil.toStream(encryptStream), contentStream, true);
Assert.assertEquals(content, StrUtil.utf8Str(contentStream.toByteArray()));
Assertions.assertEquals(content, StrUtil.utf8Str(contentStream.toByteArray()));
}
@Test
@@ -169,7 +169,7 @@ public class SymmetricTest {
final String encryptHex = aes.encryptHex(content);
// 解密
final String decryptStr = aes.decryptStr(encryptHex);
Assert.assertEquals(content, decryptStr);
Assertions.assertEquals(content, decryptStr);
}
@Test
@@ -183,12 +183,12 @@ public class SymmetricTest {
final byte[] encrypt = des.encrypt(content);
final byte[] decrypt = des.decrypt(encrypt);
Assert.assertEquals(content, StrUtil.utf8Str(decrypt));
Assertions.assertEquals(content, StrUtil.utf8Str(decrypt));
final String encryptHex = des.encryptHex(content);
final String decryptStr = des.decryptStr(encryptHex);
Assert.assertEquals(content, decryptStr);
Assertions.assertEquals(content, decryptStr);
}
@Test
@@ -202,12 +202,12 @@ public class SymmetricTest {
final byte[] encrypt = des.encrypt(content);
final byte[] decrypt = des.decrypt(encrypt);
Assert.assertEquals(content, StrUtil.utf8Str(decrypt));
Assertions.assertEquals(content, StrUtil.utf8Str(decrypt));
final String encryptHex = des.encryptHex(content);
final String decryptStr = des.decryptStr(encryptHex);
Assert.assertEquals(content, decryptStr);
Assertions.assertEquals(content, decryptStr);
}
@Test
@@ -216,8 +216,8 @@ public class SymmetricTest {
final String key = "CompleteVictory";
final String encrypt = Vigenere.encrypt(content, key);
Assert.assertEquals("zXScRZ]KIOMhQjc0\\bYRXZOJK[Vi", encrypt);
Assertions.assertEquals("zXScRZ]KIOMhQjc0\\bYRXZOJK[Vi", encrypt);
final String decrypt = Vigenere.decrypt(encrypt, key);
Assert.assertEquals(content, decrypt);
Assertions.assertEquals(content, decrypt);
}
}

10
hutool-crypto/src/test/java/cn/hutool/crypto/symmetric/TEATest.java
View File

@@ -1,7 +1,7 @@
package cn.hutool.crypto.symmetric;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
/**
* TEA（Tiny Encryption Algorithm）和 XTEA算法单元测试
@@ -19,7 +19,7 @@ public class TEATest {
// 解密
final String decryptStr = tea.decryptStr(encrypt);
Assert.assertEquals(data, decryptStr);
Assertions.assertEquals(data, decryptStr);
}
@Test
@@ -33,7 +33,7 @@ public class TEATest {
// 解密
final String decryptStr = tea.decryptStr(encrypt);
Assert.assertEquals(data, decryptStr);
Assertions.assertEquals(data, decryptStr);
}
@Test
@@ -47,6 +47,6 @@ public class TEATest {
// 解密
final String decryptStr = tea.decryptStr(encrypt);
Assert.assertEquals(data, decryptStr);
Assertions.assertEquals(data, decryptStr);
}
}

8
hutool-crypto/src/test/java/cn/hutool/crypto/symmetric/ZucTest.java
View File

@@ -2,8 +2,8 @@ package cn.hutool.crypto.symmetric;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.RandomUtil;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
public class ZucTest {
@@ -16,7 +16,7 @@ public class ZucTest {
final String msg = RandomUtil.randomString(500);
final byte[] crypt2 = zuc.encrypt(msg);
final String msg2 = zuc.decryptStr(crypt2, CharsetUtil.UTF_8);
Assert.assertEquals(msg, msg2);
Assertions.assertEquals(msg, msg2);
}
@Test
@@ -28,6 +28,6 @@ public class ZucTest {
final String msg = RandomUtil.randomString(500);
final byte[] crypt2 = zuc.encrypt(msg);
final String msg2 = zuc.decryptStr(crypt2, CharsetUtil.UTF_8);
Assert.assertEquals(msg, msg2);
Assertions.assertEquals(msg, msg2);
}
}

12
hutool-crypto/src/test/java/cn/hutool/crypto/symmetric/fpe/FPETest.java
View File

@@ -3,8 +3,8 @@ package cn.hutool.crypto.symmetric.fpe;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.crypto.symmetric.FPE;
import org.bouncycastle.crypto.util.BasicAlphabetMapper;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
public class FPETest {
@@ -21,10 +21,10 @@ public class FPETest {
final String phone = RandomUtil.randomString("A0123456789", 13);
final String encrypt = fpe.encrypt(phone);
// 加密后与原密文长度一致
Assert.assertEquals(phone.length(), encrypt.length());
Assertions.assertEquals(phone.length(), encrypt.length());
final String decrypt = fpe.decrypt(encrypt);
Assert.assertEquals(phone, decrypt);
Assertions.assertEquals(phone, decrypt);
}
@Test
@@ -40,9 +40,9 @@ public class FPETest {
final String phone = RandomUtil.randomString("A0123456789", 13);
final String encrypt = fpe.encrypt(phone);
// 加密后与原密文长度一致
Assert.assertEquals(phone.length(), encrypt.length());
Assertions.assertEquals(phone.length(), encrypt.length());
final String decrypt = fpe.decrypt(encrypt);
Assert.assertEquals(phone, decrypt);
Assertions.assertEquals(phone, decrypt);
}
}