This is an automated email from the ASF dual-hosted git repository.
jimin pushed a commit to branch 2.x
in repository https://gitbox.apache.org/repos/asf/incubator-seata.git
The following commit(s) were added to refs/heads/2.x by this push:
new dc9bf007aa test: add UT test for compressor module (#7725)
dc9bf007aa is described below
commit dc9bf007aae79689d9834a9842a6935a4782e1fe
Author: Eric Wang <[email protected]>
AuthorDate: Fri Oct 24 05:03:02 2025 +0300
test: add UT test for compressor module (#7725)
---
changes/en-us/2.x.md | 1 +
changes/zh-cn/2.x.md | 1 +
.../compressor/bzip2/BZip2CompressorTest.java | 112 +++++++++++++++++++++
.../seata/compressor/bzip2/BZip2UtilTest.java | 96 +++++++++++++++++-
.../deflater/DeflaterCompressorTest.java | 112 +++++++++++++++++++++
.../compressor/deflater/DeflaterUtilTest.java | 90 ++++++++++++++++-
.../seata/compressor/gzip/GzipCompressorTest.java | 112 +++++++++++++++++++++
.../apache/seata/compressor/gzip/GzipUtilTest.java | 83 ++++++++++++++-
.../seata/compressor/lz4/Lz4CompressorTest.java | 111 ++++++++++++++++++++
.../apache/seata/compressor/lz4/Lz4UtilTest.java | 90 +++++++++++++++++
.../seata/compressor/zip/ZipCompressorTest.java | 111 ++++++++++++++++++++
.../apache/seata/compressor/zip/ZipUtilTest.java | 94 ++++++++++++++++-
.../seata/compressor/zstd/ZstdCompressorTest.java | 111 ++++++++++++++++++++
.../apache/seata/compressor/zstd/ZstdUtilTest.java | 17 +++-
14 files changed, 1126 insertions(+), 15 deletions(-)
diff --git a/changes/en-us/2.x.md b/changes/en-us/2.x.md
index a764e41f19..5613384abf 100644
--- a/changes/en-us/2.x.md
+++ b/changes/en-us/2.x.md
@@ -88,6 +88,7 @@ Add changes here for all PR submitted to the 2.x branch.
- [[#7679](https://github.com/apache/incubator-seata/pull/7679)] fix old
version connect timeout
- [[#7638](https://github.com/apache/incubator-seata/pull/7638)]Add unit tests
for the `seata-common` module and remove a todo
- [[#7709](https://github.com/apache/incubator-seata/pull/7709)] add UT for dm
module
+- [[#7725](https://github.com/apache/incubator-seata/pull/7725)] add UT for
compressor module
- [[#7718](https://github.com/apache/incubator-seata/pull/7718)] add UT for
config module
- [[#7723](https://github.com/apache/incubator-seata/pull/7723)] add UT for
fastjson2 to test PostgreSQL Array type
diff --git a/changes/zh-cn/2.x.md b/changes/zh-cn/2.x.md
index b46e00f981..5b71604880 100644
--- a/changes/zh-cn/2.x.md
+++ b/changes/zh-cn/2.x.md
@@ -87,6 +87,7 @@
- [[#7679](https://github.com/apache/incubator-seata/pull/7679)] 修复旧版本协议测试超时问题
- [[#7638](https://github.com/apache/incubator-seata/pull/7638)] 增加了
`seata-common` 模块的测试用例,删去了一个todo
- [[#7709](https://github.com/apache/incubator-seata/pull/7709)] 为dm模块增加单测
+- [[#7725](https://github.com/apache/incubator-seata/pull/7725)]
为compressor模块增加单测
- [[#7718](https://github.com/apache/incubator-seata/pull/7718)] 为config模块增加单测
- [[#7723](https://github.com/apache/incubator-seata/pull/7723)] 添加 fastjson2
的 UT 来测试 PostgreSQL 数组类型
diff --git
a/compressor/seata-compressor-bzip2/src/test/java/org/apache/seata/compressor/bzip2/BZip2CompressorTest.java
b/compressor/seata-compressor-bzip2/src/test/java/org/apache/seata/compressor/bzip2/BZip2CompressorTest.java
index 44a0db4934..1321008477 100644
---
a/compressor/seata-compressor-bzip2/src/test/java/org/apache/seata/compressor/bzip2/BZip2CompressorTest.java
+++
b/compressor/seata-compressor-bzip2/src/test/java/org/apache/seata/compressor/bzip2/BZip2CompressorTest.java
@@ -19,6 +19,9 @@ package org.apache.seata.compressor.bzip2;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import java.nio.charset.StandardCharsets;
+import java.util.Random;
+
/**
* the BZip2 Compressor test
*
@@ -33,4 +36,113 @@ public class BZip2CompressorTest {
bytes = compressor.decompress(bytes);
Assertions.assertEquals(new String(bytes), "aa");
}
+
+ @Test
+ public void testCompressNull() {
+ BZip2Compressor compressor = new BZip2Compressor();
+ Assertions.assertThrows(NullPointerException.class, () -> {
+ compressor.compress(null);
+ });
+ }
+
+ @Test
+ public void testDecompressNull() {
+ BZip2Compressor compressor = new BZip2Compressor();
+ Assertions.assertThrows(NullPointerException.class, () -> {
+ compressor.decompress(null);
+ });
+ }
+
+ @Test
+ public void testCompressEmptyArray() {
+ BZip2Compressor compressor = new BZip2Compressor();
+ byte[] empty = new byte[0];
+ byte[] compressed = compressor.compress(empty);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertArrayEquals(empty, decompressed);
+ }
+
+ @Test
+ public void testCompressSingleByte() {
+ BZip2Compressor compressor = new BZip2Compressor();
+ byte[] singleByte = {42};
+ byte[] compressed = compressor.compress(singleByte);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertArrayEquals(singleByte, decompressed);
+ }
+
+ @Test
+ public void testCompressLargeData() {
+ BZip2Compressor compressor = new BZip2Compressor();
+ byte[] largeData = new byte[1024 * 1024];
+ new Random().nextBytes(largeData);
+ byte[] compressed = compressor.compress(largeData);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertArrayEquals(largeData, decompressed);
+ }
+
+ @Test
+ public void testCompressTextData() {
+ BZip2Compressor compressor = new BZip2Compressor();
+ String text = "The quick brown fox jumps over the lazy dog";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = compressor.compress(original);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressSpecialCharacters() {
+ BZip2Compressor compressor = new BZip2Compressor();
+ String text = "Hello World! @#$%^&*()_+-=[]{}|;':\",./<>?";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = compressor.compress(original);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressUnicodeData() {
+ BZip2Compressor compressor = new BZip2Compressor();
+ String text = "Hello World in Chinese: 你好世界, Japanese: こんにちは世界,
Korean: 안녕하세요 세계";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = compressor.compress(original);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressionRatio() {
+ BZip2Compressor compressor = new BZip2Compressor();
+ String repeatedText = new String(new char[1000]).replace("\0", "a");
+ byte[] original = repeatedText.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = compressor.compress(original);
+ Assertions.assertTrue(
+ compressed.length < original.length,
+ "Compressed size should be smaller than original for
repetitive data");
+ }
+
+ @Test
+ public void testDecompressInvalidData() {
+ BZip2Compressor compressor = new BZip2Compressor();
+ byte[] invalidData = {0x1, 0x2, 0x3, 0x4};
+ Assertions.assertThrows(RuntimeException.class, () -> {
+ compressor.decompress(invalidData);
+ });
+ }
+
+ @Test
+ public void testMultipleCompressionCycles() {
+ BZip2Compressor compressor = new BZip2Compressor();
+ String text = "Test multiple compression cycles";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+
+ byte[] firstCompressed = compressor.compress(original);
+ byte[] firstDecompressed = compressor.decompress(firstCompressed);
+
+ byte[] secondCompressed = compressor.compress(firstDecompressed);
+ byte[] secondDecompressed = compressor.decompress(secondCompressed);
+
+ Assertions.assertEquals(text, new String(secondDecompressed,
StandardCharsets.UTF_8));
+ }
}
diff --git
a/compressor/seata-compressor-bzip2/src/test/java/org/apache/seata/compressor/bzip2/BZip2UtilTest.java
b/compressor/seata-compressor-bzip2/src/test/java/org/apache/seata/compressor/bzip2/BZip2UtilTest.java
index 268c86fa64..5692f52a21 100644
---
a/compressor/seata-compressor-bzip2/src/test/java/org/apache/seata/compressor/bzip2/BZip2UtilTest.java
+++
b/compressor/seata-compressor-bzip2/src/test/java/org/apache/seata/compressor/bzip2/BZip2UtilTest.java
@@ -19,6 +19,9 @@ package org.apache.seata.compressor.bzip2;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import java.nio.charset.StandardCharsets;
+import java.util.Random;
+
/**
* the BZip2 Util test
*
@@ -26,16 +29,105 @@ import org.junit.jupiter.api.Test;
public class BZip2UtilTest {
@Test
- public void test_compress() {
+ public void testCompress() {
Assertions.assertThrows(NullPointerException.class, () -> {
BZip2Util.compress(null);
});
}
@Test
- public void test_decompress() {
+ public void testDecompress() {
Assertions.assertThrows(NullPointerException.class, () -> {
BZip2Util.decompress(null);
});
}
+
+ @Test
+ public void testCompressEqualDecompress() {
+ byte[] compress = BZip2Util.compress("aa".getBytes());
+ byte[] decompress = BZip2Util.decompress(compress);
+ Assertions.assertEquals("aa", new String(decompress));
+ }
+
+ @Test
+ public void testCompressEmptyArray() {
+ byte[] empty = new byte[0];
+ byte[] compressed = BZip2Util.compress(empty);
+ byte[] decompressed = BZip2Util.decompress(compressed);
+ Assertions.assertArrayEquals(empty, decompressed);
+ }
+
+ @Test
+ public void testCompressSingleByte() {
+ byte[] singleByte = {42};
+ byte[] compressed = BZip2Util.compress(singleByte);
+ byte[] decompressed = BZip2Util.decompress(compressed);
+ Assertions.assertArrayEquals(singleByte, decompressed);
+ }
+
+ @Test
+ public void testCompressLargeData() {
+ byte[] largeData = new byte[1024 * 1024];
+ new Random().nextBytes(largeData);
+ byte[] compressed = BZip2Util.compress(largeData);
+ byte[] decompressed = BZip2Util.decompress(compressed);
+ Assertions.assertArrayEquals(largeData, decompressed);
+ }
+
+ @Test
+ public void testCompressTextData() {
+ String text = "The quick brown fox jumps over the lazy dog";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = BZip2Util.compress(original);
+ byte[] decompressed = BZip2Util.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressUnicodeData() {
+ String text = "测试中文数据压缩解压";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = BZip2Util.compress(original);
+ byte[] decompressed = BZip2Util.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressionRatio() {
+ String repeatedText = new String(new char[1000]).replace("\0", "a");
+ byte[] original = repeatedText.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = BZip2Util.compress(original);
+ Assertions.assertTrue(
+ compressed.length < original.length,
+ "Compressed size should be smaller than original for
repetitive data");
+ }
+
+ @Test
+ public void testDecompressInvalidData() {
+ byte[] invalidData = {0x1, 0x2, 0x3, 0x4, 0x5};
+ Assertions.assertThrows(RuntimeException.class, () -> {
+ BZip2Util.decompress(invalidData);
+ });
+ }
+
+ @Test
+ public void testDecompressEmptyArray() {
+ Assertions.assertThrows(RuntimeException.class, () -> {
+ BZip2Util.decompress(new byte[0]);
+ });
+ }
+
+ @Test
+ public void testMultipleCompressionCycles() {
+ String text = "Test multiple compression cycles";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+
+ byte[] firstCompressed = BZip2Util.compress(original);
+ byte[] firstDecompressed = BZip2Util.decompress(firstCompressed);
+
+ byte[] secondCompressed = BZip2Util.compress(firstDecompressed);
+ byte[] secondDecompressed = BZip2Util.decompress(secondCompressed);
+
+ Assertions.assertEquals(text, new String(secondDecompressed,
StandardCharsets.UTF_8));
+ }
}
diff --git
a/compressor/seata-compressor-deflater/src/test/java/org/apache/seata/compressor/deflater/DeflaterCompressorTest.java
b/compressor/seata-compressor-deflater/src/test/java/org/apache/seata/compressor/deflater/DeflaterCompressorTest.java
index b09ce834b4..1094e6a526 100644
---
a/compressor/seata-compressor-deflater/src/test/java/org/apache/seata/compressor/deflater/DeflaterCompressorTest.java
+++
b/compressor/seata-compressor-deflater/src/test/java/org/apache/seata/compressor/deflater/DeflaterCompressorTest.java
@@ -19,6 +19,9 @@ package org.apache.seata.compressor.deflater;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import java.nio.charset.StandardCharsets;
+import java.util.Random;
+
public class DeflaterCompressorTest {
@Test
@@ -29,4 +32,113 @@ public class DeflaterCompressorTest {
bytes = compressor.decompress(bytes);
Assertions.assertEquals(new String(bytes), "seata");
}
+
+ @Test
+ public void testCompressNull() {
+ DeflaterCompressor compressor = new DeflaterCompressor();
+ Assertions.assertThrows(NullPointerException.class, () -> {
+ compressor.compress(null);
+ });
+ }
+
+ @Test
+ public void testDecompressNull() {
+ DeflaterCompressor compressor = new DeflaterCompressor();
+ Assertions.assertThrows(NullPointerException.class, () -> {
+ compressor.decompress(null);
+ });
+ }
+
+ @Test
+ public void testCompressEmptyArray() {
+ DeflaterCompressor compressor = new DeflaterCompressor();
+ byte[] empty = new byte[0];
+ byte[] compressed = compressor.compress(empty);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertArrayEquals(empty, decompressed);
+ }
+
+ @Test
+ public void testCompressSingleByte() {
+ DeflaterCompressor compressor = new DeflaterCompressor();
+ byte[] singleByte = {42};
+ byte[] compressed = compressor.compress(singleByte);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertArrayEquals(singleByte, decompressed);
+ }
+
+ @Test
+ public void testCompressLargeData() {
+ DeflaterCompressor compressor = new DeflaterCompressor();
+ byte[] largeData = new byte[1024 * 1024];
+ new Random().nextBytes(largeData);
+ byte[] compressed = compressor.compress(largeData);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertArrayEquals(largeData, decompressed);
+ }
+
+ @Test
+ public void testCompressTextData() {
+ DeflaterCompressor compressor = new DeflaterCompressor();
+ String text = "The quick brown fox jumps over the lazy dog";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = compressor.compress(original);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressSpecialCharacters() {
+ DeflaterCompressor compressor = new DeflaterCompressor();
+ String text = "Hello World! @#$%^&*()_+-=[]{}|;':\",./<>?";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = compressor.compress(original);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressUnicodeData() {
+ DeflaterCompressor compressor = new DeflaterCompressor();
+ String text = "Hello World in Chinese: 你好世界, Japanese: こんにちは世界,
Korean: 안녕하세요 세계";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = compressor.compress(original);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressionRatio() {
+ DeflaterCompressor compressor = new DeflaterCompressor();
+ String repeatedText = new String(new char[1000]).replace("\0", "a");
+ byte[] original = repeatedText.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = compressor.compress(original);
+ Assertions.assertTrue(
+ compressed.length < original.length,
+ "Compressed size should be smaller than original for
repetitive data");
+ }
+
+ @Test
+ public void testDecompressInvalidData() {
+ DeflaterCompressor compressor = new DeflaterCompressor();
+ byte[] invalidData = {0x1, 0x2, 0x3, 0x4};
+ Assertions.assertThrows(RuntimeException.class, () -> {
+ compressor.decompress(invalidData);
+ });
+ }
+
+ @Test
+ public void testMultipleCompressionCycles() {
+ DeflaterCompressor compressor = new DeflaterCompressor();
+ String text = "Test multiple compression cycles";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+
+ byte[] firstCompressed = compressor.compress(original);
+ byte[] firstDecompressed = compressor.decompress(firstCompressed);
+
+ byte[] secondCompressed = compressor.compress(firstDecompressed);
+ byte[] secondDecompressed = compressor.decompress(secondCompressed);
+
+ Assertions.assertEquals(text, new String(secondDecompressed,
StandardCharsets.UTF_8));
+ }
}
diff --git
a/compressor/seata-compressor-deflater/src/test/java/org/apache/seata/compressor/deflater/DeflaterUtilTest.java
b/compressor/seata-compressor-deflater/src/test/java/org/apache/seata/compressor/deflater/DeflaterUtilTest.java
index 5bd94306ea..06e4003a7b 100644
---
a/compressor/seata-compressor-deflater/src/test/java/org/apache/seata/compressor/deflater/DeflaterUtilTest.java
+++
b/compressor/seata-compressor-deflater/src/test/java/org/apache/seata/compressor/deflater/DeflaterUtilTest.java
@@ -19,26 +19,110 @@ package org.apache.seata.compressor.deflater;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import java.nio.charset.StandardCharsets;
+import java.util.Random;
+
public class DeflaterUtilTest {
@Test
- public void test_compress() {
+ public void testCompress() {
Assertions.assertThrows(NullPointerException.class, () -> {
DeflaterUtil.compress(null);
});
}
@Test
- public void test_decompress() {
+ public void testDecompress() {
Assertions.assertThrows(NullPointerException.class, () -> {
DeflaterUtil.decompress(null);
});
}
@Test
- public void test_compressEqualDecompress() {
+ public void testCompressEqualDecompress() {
byte[] compress = DeflaterUtil.compress("seata".getBytes());
byte[] decompress = DeflaterUtil.decompress(compress);
Assertions.assertEquals("seata", new String(decompress));
}
+
+ @Test
+ public void testCompressEmptyArray() {
+ byte[] empty = new byte[0];
+ byte[] compressed = DeflaterUtil.compress(empty);
+ byte[] decompressed = DeflaterUtil.decompress(compressed);
+ Assertions.assertArrayEquals(empty, decompressed);
+ }
+
+ @Test
+ public void testCompressSingleByte() {
+ byte[] singleByte = {42};
+ byte[] compressed = DeflaterUtil.compress(singleByte);
+ byte[] decompressed = DeflaterUtil.decompress(compressed);
+ Assertions.assertArrayEquals(singleByte, decompressed);
+ }
+
+ @Test
+ public void testCompressLargeData() {
+ byte[] largeData = new byte[1024 * 1024];
+ new Random().nextBytes(largeData);
+ byte[] compressed = DeflaterUtil.compress(largeData);
+ byte[] decompressed = DeflaterUtil.decompress(compressed);
+ Assertions.assertArrayEquals(largeData, decompressed);
+ }
+
+ @Test
+ public void testCompressTextData() {
+ String text = "The quick brown fox jumps over the lazy dog";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = DeflaterUtil.compress(original);
+ byte[] decompressed = DeflaterUtil.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressUnicodeData() {
+ String text = "测试中文数据压缩解压";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = DeflaterUtil.compress(original);
+ byte[] decompressed = DeflaterUtil.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressionRatio() {
+ String repeatedText = new String(new char[1000]).replace("\0", "a");
+ byte[] original = repeatedText.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = DeflaterUtil.compress(original);
+ Assertions.assertTrue(
+ compressed.length < original.length,
+ "Compressed size should be smaller than original for
repetitive data");
+ }
+
+ @Test
+ public void testDecompressInvalidData() {
+ byte[] invalidData = {0x1, 0x2, 0x3, 0x4, 0x5};
+ Assertions.assertThrows(RuntimeException.class, () -> {
+ DeflaterUtil.decompress(invalidData);
+ });
+ }
+
+ @Test
+ public void testDecompressEmptyArray() {
+ byte[] result = DeflaterUtil.decompress(new byte[0]);
+ Assertions.assertArrayEquals(new byte[0], result);
+ }
+
+ @Test
+ public void testMultipleCompressionCycles() {
+ String text = "Test multiple compression cycles";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+
+ byte[] firstCompressed = DeflaterUtil.compress(original);
+ byte[] firstDecompressed = DeflaterUtil.decompress(firstCompressed);
+
+ byte[] secondCompressed = DeflaterUtil.compress(firstDecompressed);
+ byte[] secondDecompressed = DeflaterUtil.decompress(secondCompressed);
+
+ Assertions.assertEquals(text, new String(secondDecompressed,
StandardCharsets.UTF_8));
+ }
}
diff --git
a/compressor/seata-compressor-gzip/src/test/java/org/apache/seata/compressor/gzip/GzipCompressorTest.java
b/compressor/seata-compressor-gzip/src/test/java/org/apache/seata/compressor/gzip/GzipCompressorTest.java
index 4c1dff4f9f..eeead38295 100644
---
a/compressor/seata-compressor-gzip/src/test/java/org/apache/seata/compressor/gzip/GzipCompressorTest.java
+++
b/compressor/seata-compressor-gzip/src/test/java/org/apache/seata/compressor/gzip/GzipCompressorTest.java
@@ -19,6 +19,9 @@ package org.apache.seata.compressor.gzip;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import java.nio.charset.StandardCharsets;
+import java.util.Random;
+
public class GzipCompressorTest {
@Test
@@ -29,4 +32,113 @@ public class GzipCompressorTest {
bytes = compressor.decompress(bytes);
Assertions.assertEquals(new String(bytes), "aa");
}
+
+ @Test
+ public void testCompressNull() {
+ GzipCompressor compressor = new GzipCompressor();
+ Assertions.assertThrows(NullPointerException.class, () -> {
+ compressor.compress(null);
+ });
+ }
+
+ @Test
+ public void testDecompressNull() {
+ GzipCompressor compressor = new GzipCompressor();
+ Assertions.assertThrows(NullPointerException.class, () -> {
+ compressor.decompress(null);
+ });
+ }
+
+ @Test
+ public void testCompressEmptyArray() {
+ GzipCompressor compressor = new GzipCompressor();
+ byte[] empty = new byte[0];
+ byte[] compressed = compressor.compress(empty);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertArrayEquals(empty, decompressed);
+ }
+
+ @Test
+ public void testCompressSingleByte() {
+ GzipCompressor compressor = new GzipCompressor();
+ byte[] singleByte = {42};
+ byte[] compressed = compressor.compress(singleByte);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertArrayEquals(singleByte, decompressed);
+ }
+
+ @Test
+ public void testCompressLargeData() {
+ GzipCompressor compressor = new GzipCompressor();
+ byte[] largeData = new byte[1024 * 1024];
+ new Random().nextBytes(largeData);
+ byte[] compressed = compressor.compress(largeData);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertArrayEquals(largeData, decompressed);
+ }
+
+ @Test
+ public void testCompressTextData() {
+ GzipCompressor compressor = new GzipCompressor();
+ String text = "The quick brown fox jumps over the lazy dog";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = compressor.compress(original);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressSpecialCharacters() {
+ GzipCompressor compressor = new GzipCompressor();
+ String text = "Hello World! @#$%^&*()_+-=[]{}|;':\",./<>?";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = compressor.compress(original);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressUnicodeData() {
+ GzipCompressor compressor = new GzipCompressor();
+ String text = "Hello World in Chinese: 你好世界, Japanese: こんにちは世界,
Korean: 안녕하세요 세계";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = compressor.compress(original);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressionRatio() {
+ GzipCompressor compressor = new GzipCompressor();
+ String repeatedText = new String(new char[1000]).replace("\0", "a");
+ byte[] original = repeatedText.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = compressor.compress(original);
+ Assertions.assertTrue(
+ compressed.length < original.length,
+ "Compressed size should be smaller than original for
repetitive data");
+ }
+
+ @Test
+ public void testDecompressInvalidData() {
+ GzipCompressor compressor = new GzipCompressor();
+ byte[] invalidData = {0x1, 0x2, 0x3, 0x4};
+ Assertions.assertThrows(RuntimeException.class, () -> {
+ compressor.decompress(invalidData);
+ });
+ }
+
+ @Test
+ public void testMultipleCompressionCycles() {
+ GzipCompressor compressor = new GzipCompressor();
+ String text = "Test multiple compression cycles";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+
+ byte[] firstCompressed = compressor.compress(original);
+ byte[] firstDecompressed = compressor.decompress(firstCompressed);
+
+ byte[] secondCompressed = compressor.compress(firstDecompressed);
+ byte[] secondDecompressed = compressor.decompress(secondCompressed);
+
+ Assertions.assertEquals(text, new String(secondDecompressed,
StandardCharsets.UTF_8));
+ }
}
diff --git
a/compressor/seata-compressor-gzip/src/test/java/org/apache/seata/compressor/gzip/GzipUtilTest.java
b/compressor/seata-compressor-gzip/src/test/java/org/apache/seata/compressor/gzip/GzipUtilTest.java
index 3ad8dd965a..7787068b6b 100644
---
a/compressor/seata-compressor-gzip/src/test/java/org/apache/seata/compressor/gzip/GzipUtilTest.java
+++
b/compressor/seata-compressor-gzip/src/test/java/org/apache/seata/compressor/gzip/GzipUtilTest.java
@@ -19,12 +19,14 @@ package org.apache.seata.compressor.gzip;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import java.nio.charset.StandardCharsets;
+import java.util.Random;
import java.util.zip.GZIPInputStream;
public class GzipUtilTest {
@Test
- public void test_compress() {
+ public void testCompress() {
Assertions.assertThrows(NullPointerException.class, () -> {
GzipUtil.compress(null);
});
@@ -35,7 +37,7 @@ public class GzipUtilTest {
}
@Test
- public void test_decompress() {
+ public void testDecompress() {
Assertions.assertThrows(NullPointerException.class, () -> {
GzipUtil.decompress(null);
@@ -52,7 +54,7 @@ public class GzipUtilTest {
}
@Test
- public void test_compressEqualDecompress() {
+ public void testCompressEqualDecompress() {
byte[] compress = GzipUtil.compress("aa".getBytes());
@@ -60,4 +62,79 @@ public class GzipUtilTest {
Assertions.assertEquals("aa", new String(decompress));
}
+
+ @Test
+ public void testCompressEmptyArray() {
+ byte[] empty = new byte[0];
+ byte[] compressed = GzipUtil.compress(empty);
+ byte[] decompressed = GzipUtil.decompress(compressed);
+ Assertions.assertArrayEquals(empty, decompressed);
+ }
+
+ @Test
+ public void testCompressSingleByte() {
+ byte[] singleByte = {42};
+ byte[] compressed = GzipUtil.compress(singleByte);
+ byte[] decompressed = GzipUtil.decompress(compressed);
+ Assertions.assertArrayEquals(singleByte, decompressed);
+ }
+
+ @Test
+ public void testCompressLargeData() {
+ byte[] largeData = new byte[1024 * 1024];
+ new Random().nextBytes(largeData);
+ byte[] compressed = GzipUtil.compress(largeData);
+ byte[] decompressed = GzipUtil.decompress(compressed);
+ Assertions.assertArrayEquals(largeData, decompressed);
+ }
+
+ @Test
+ public void testCompressTextData() {
+ String text = "The quick brown fox jumps over the lazy dog";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = GzipUtil.compress(original);
+ byte[] decompressed = GzipUtil.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressUnicodeData() {
+ String text = "测试中文数据压缩解压";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = GzipUtil.compress(original);
+ byte[] decompressed = GzipUtil.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressionRatio() {
+ String repeatedText = new String(new char[1000]).replace("\0", "a");
+ byte[] original = repeatedText.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = GzipUtil.compress(original);
+ Assertions.assertTrue(
+ compressed.length < original.length,
+ "Compressed size should be smaller than original for
repetitive data");
+ }
+
+ @Test
+ public void testDecompressInvalidData() {
+ byte[] invalidData = {0x1, 0x2, 0x3, 0x4, 0x5};
+ Assertions.assertThrows(RuntimeException.class, () -> {
+ GzipUtil.decompress(invalidData);
+ });
+ }
+
+ @Test
+ public void testMultipleCompressionCycles() {
+ String text = "Test multiple compression cycles";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+
+ byte[] firstCompressed = GzipUtil.compress(original);
+ byte[] firstDecompressed = GzipUtil.decompress(firstCompressed);
+
+ byte[] secondCompressed = GzipUtil.compress(firstDecompressed);
+ byte[] secondDecompressed = GzipUtil.decompress(secondCompressed);
+
+ Assertions.assertEquals(text, new String(secondDecompressed,
StandardCharsets.UTF_8));
+ }
}
diff --git
a/compressor/seata-compressor-lz4/src/test/java/org/apache/seata/compressor/lz4/Lz4CompressorTest.java
b/compressor/seata-compressor-lz4/src/test/java/org/apache/seata/compressor/lz4/Lz4CompressorTest.java
index 8a560c4c8d..35221d404f 100644
---
a/compressor/seata-compressor-lz4/src/test/java/org/apache/seata/compressor/lz4/Lz4CompressorTest.java
+++
b/compressor/seata-compressor-lz4/src/test/java/org/apache/seata/compressor/lz4/Lz4CompressorTest.java
@@ -19,6 +19,9 @@ package org.apache.seata.compressor.lz4;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import java.nio.charset.StandardCharsets;
+import java.util.Random;
+
public class Lz4CompressorTest {
@Test
public void testCompressAndDecompress() {
@@ -29,4 +32,112 @@ public class Lz4CompressorTest {
byte[] result = compressor.decompress(bytes);
Assertions.assertEquals(new String(result), content);
}
+
+ @Test
+ public void testCompressNull() {
+ Lz4Compressor compressor = new Lz4Compressor();
+ Assertions.assertThrows(NullPointerException.class, () -> {
+ compressor.compress(null);
+ });
+ }
+
+ @Test
+ public void testDecompressNull() {
+ Lz4Compressor compressor = new Lz4Compressor();
+ Assertions.assertThrows(NullPointerException.class, () -> {
+ compressor.decompress(null);
+ });
+ }
+
+ @Test
+ public void testCompressEmptyArray() {
+ Lz4Compressor compressor = new Lz4Compressor();
+ byte[] empty = new byte[0];
+ byte[] compressed = compressor.compress(empty);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertArrayEquals(empty, decompressed);
+ }
+
+ @Test
+ public void testCompressSingleByte() {
+ Lz4Compressor compressor = new Lz4Compressor();
+ byte[] singleByte = {42};
+ byte[] compressed = compressor.compress(singleByte);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertArrayEquals(singleByte, decompressed);
+ }
+
+ @Test
+ public void testCompressLargeData() {
+ Lz4Compressor compressor = new Lz4Compressor();
+ byte[] largeData = new byte[1024 * 1024];
+ new Random().nextBytes(largeData);
+ byte[] compressed = compressor.compress(largeData);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertArrayEquals(largeData, decompressed);
+ }
+
+ @Test
+ public void testCompressTextData() {
+ Lz4Compressor compressor = new Lz4Compressor();
+ String text = "The quick brown fox jumps over the lazy dog";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = compressor.compress(original);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressSpecialCharacters() {
+ Lz4Compressor compressor = new Lz4Compressor();
+ String text = "Hello World! @#$%^&*()_+-=[]{}|;':\",./<>?";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = compressor.compress(original);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressUnicodeData() {
+ Lz4Compressor compressor = new Lz4Compressor();
+ String text = "Hello World in Chinese: 你好世界, Japanese: こんにちは世界,
Korean: 안녕하세요 세계";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = compressor.compress(original);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressionRatio() {
+ Lz4Compressor compressor = new Lz4Compressor();
+ String repeatedText = new String(new char[1000]).replace("\0", "a");
+ byte[] original = repeatedText.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = compressor.compress(original);
+ Assertions.assertTrue(
+ compressed.length < original.length,
+ "Compressed size should be smaller than original for
repetitive data");
+ }
+
+ @Test
+ public void testDecompressInvalidData() {
+ Lz4Compressor compressor = new Lz4Compressor();
+ byte[] invalidData = {0x1, 0x2, 0x3, 0x4};
+ byte[] result = compressor.decompress(invalidData);
+ Assertions.assertArrayEquals(new byte[0], result);
+ }
+
+ @Test
+ public void testMultipleCompressionCycles() {
+ Lz4Compressor compressor = new Lz4Compressor();
+ String text = "Test multiple compression cycles";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+
+ byte[] firstCompressed = compressor.compress(original);
+ byte[] firstDecompressed = compressor.decompress(firstCompressed);
+
+ byte[] secondCompressed = compressor.compress(firstDecompressed);
+ byte[] secondDecompressed = compressor.decompress(secondCompressed);
+
+ Assertions.assertEquals(text, new String(secondDecompressed,
StandardCharsets.UTF_8));
+ }
}
diff --git
a/compressor/seata-compressor-lz4/src/test/java/org/apache/seata/compressor/lz4/Lz4UtilTest.java
b/compressor/seata-compressor-lz4/src/test/java/org/apache/seata/compressor/lz4/Lz4UtilTest.java
index 485db7f242..6a38c2cc61 100644
---
a/compressor/seata-compressor-lz4/src/test/java/org/apache/seata/compressor/lz4/Lz4UtilTest.java
+++
b/compressor/seata-compressor-lz4/src/test/java/org/apache/seata/compressor/lz4/Lz4UtilTest.java
@@ -19,6 +19,9 @@ package org.apache.seata.compressor.lz4;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import java.nio.charset.StandardCharsets;
+import java.util.Random;
+
class Lz4UtilTest {
@Test
public void testCompress() {
@@ -33,4 +36,91 @@ class Lz4UtilTest {
Lz4Util.decompress(null);
});
}
+
+ @Test
+ public void testCompressEqualDecompress() {
+ byte[] compress = Lz4Util.compress("aa".getBytes());
+ byte[] decompress = Lz4Util.decompress(compress);
+ Assertions.assertEquals("aa", new String(decompress));
+ }
+
+ @Test
+ public void testCompressEmptyArray() {
+ byte[] empty = new byte[0];
+ byte[] compressed = Lz4Util.compress(empty);
+ byte[] decompressed = Lz4Util.decompress(compressed);
+ Assertions.assertArrayEquals(empty, decompressed);
+ }
+
+ @Test
+ public void testCompressSingleByte() {
+ byte[] singleByte = {42};
+ byte[] compressed = Lz4Util.compress(singleByte);
+ byte[] decompressed = Lz4Util.decompress(compressed);
+ Assertions.assertArrayEquals(singleByte, decompressed);
+ }
+
+ @Test
+ public void testCompressLargeData() {
+ byte[] largeData = new byte[1024 * 1024];
+ new Random().nextBytes(largeData);
+ byte[] compressed = Lz4Util.compress(largeData);
+ byte[] decompressed = Lz4Util.decompress(compressed);
+ Assertions.assertArrayEquals(largeData, decompressed);
+ }
+
+ @Test
+ public void testCompressTextData() {
+ String text = "The quick brown fox jumps over the lazy dog";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = Lz4Util.compress(original);
+ byte[] decompressed = Lz4Util.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressUnicodeData() {
+ String text = "测试中文数据压缩解压";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = Lz4Util.compress(original);
+ byte[] decompressed = Lz4Util.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressionRatio() {
+ String repeatedText = new String(new char[1000]).replace("\0", "a");
+ byte[] original = repeatedText.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = Lz4Util.compress(original);
+ Assertions.assertTrue(
+ compressed.length < original.length,
+ "Compressed size should be smaller than original for
repetitive data");
+ }
+
+ @Test
+ public void testDecompressInvalidData() {
+ byte[] invalidData = {0x1, 0x2, 0x3, 0x4, 0x5};
+ byte[] result = Lz4Util.decompress(invalidData);
+ Assertions.assertArrayEquals(new byte[0], result);
+ }
+
+ @Test
+ public void testDecompressEmptyArray() {
+ byte[] result = Lz4Util.decompress(new byte[0]);
+ Assertions.assertArrayEquals(new byte[0], result);
+ }
+
+ @Test
+ public void testMultipleCompressionCycles() {
+ String text = "Test multiple compression cycles";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+
+ byte[] firstCompressed = Lz4Util.compress(original);
+ byte[] firstDecompressed = Lz4Util.decompress(firstCompressed);
+
+ byte[] secondCompressed = Lz4Util.compress(firstDecompressed);
+ byte[] secondDecompressed = Lz4Util.decompress(secondCompressed);
+
+ Assertions.assertEquals(text, new String(secondDecompressed,
StandardCharsets.UTF_8));
+ }
}
diff --git
a/compressor/seata-compressor-zip/src/test/java/org/apache/seata/compressor/zip/ZipCompressorTest.java
b/compressor/seata-compressor-zip/src/test/java/org/apache/seata/compressor/zip/ZipCompressorTest.java
index 7ceb608d42..b6e3a3f79d 100644
---
a/compressor/seata-compressor-zip/src/test/java/org/apache/seata/compressor/zip/ZipCompressorTest.java
+++
b/compressor/seata-compressor-zip/src/test/java/org/apache/seata/compressor/zip/ZipCompressorTest.java
@@ -19,6 +19,9 @@ package org.apache.seata.compressor.zip;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import java.nio.charset.StandardCharsets;
+import java.util.Random;
+
/**
* the Zip Compressor test
*
@@ -33,4 +36,112 @@ public class ZipCompressorTest {
bytes = compressor.decompress(bytes);
Assertions.assertEquals(new String(bytes), "aa");
}
+
+ @Test
+ public void testCompressNull() {
+ ZipCompressor compressor = new ZipCompressor();
+ Assertions.assertThrows(NullPointerException.class, () -> {
+ compressor.compress(null);
+ });
+ }
+
+ @Test
+ public void testDecompressNull() {
+ ZipCompressor compressor = new ZipCompressor();
+ Assertions.assertThrows(NullPointerException.class, () -> {
+ compressor.decompress(null);
+ });
+ }
+
+ @Test
+ public void testCompressEmptyArray() {
+ ZipCompressor compressor = new ZipCompressor();
+ byte[] empty = new byte[0];
+ byte[] compressed = compressor.compress(empty);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertArrayEquals(empty, decompressed);
+ }
+
+ @Test
+ public void testCompressSingleByte() {
+ ZipCompressor compressor = new ZipCompressor();
+ byte[] singleByte = {42};
+ byte[] compressed = compressor.compress(singleByte);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertArrayEquals(singleByte, decompressed);
+ }
+
+ @Test
+ public void testCompressLargeData() {
+ ZipCompressor compressor = new ZipCompressor();
+ byte[] largeData = new byte[1024 * 1024];
+ new Random().nextBytes(largeData);
+ byte[] compressed = compressor.compress(largeData);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertArrayEquals(largeData, decompressed);
+ }
+
+ @Test
+ public void testCompressTextData() {
+ ZipCompressor compressor = new ZipCompressor();
+ String text = "The quick brown fox jumps over the lazy dog";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = compressor.compress(original);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressSpecialCharacters() {
+ ZipCompressor compressor = new ZipCompressor();
+ String text = "Hello World! @#$%^&*()_+-=[]{}|;':\",./<>?";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = compressor.compress(original);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressUnicodeData() {
+ ZipCompressor compressor = new ZipCompressor();
+ String text = "Hello World in Chinese: 你好世界, Japanese: こんにちは世界,
Korean: 안녕하세요 세계";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = compressor.compress(original);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressionRatio() {
+ ZipCompressor compressor = new ZipCompressor();
+ String repeatedText = new String(new char[1000]).replace("\0", "a");
+ byte[] original = repeatedText.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = compressor.compress(original);
+ Assertions.assertTrue(
+ compressed.length < original.length,
+ "Compressed size should be smaller than original for
repetitive data");
+ }
+
+ @Test
+ public void testDecompressInvalidData() {
+ ZipCompressor compressor = new ZipCompressor();
+ byte[] invalidData = {0x1, 0x2, 0x3, 0x4};
+ byte[] result = compressor.decompress(invalidData);
+ Assertions.assertArrayEquals(new byte[0], result);
+ }
+
+ @Test
+ public void testMultipleCompressionCycles() {
+ ZipCompressor compressor = new ZipCompressor();
+ String text = "Test multiple compression cycles";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+
+ byte[] firstCompressed = compressor.compress(original);
+ byte[] firstDecompressed = compressor.decompress(firstCompressed);
+
+ byte[] secondCompressed = compressor.compress(firstDecompressed);
+ byte[] secondDecompressed = compressor.decompress(secondCompressed);
+
+ Assertions.assertEquals(text, new String(secondDecompressed,
StandardCharsets.UTF_8));
+ }
}
diff --git
a/compressor/seata-compressor-zip/src/test/java/org/apache/seata/compressor/zip/ZipUtilTest.java
b/compressor/seata-compressor-zip/src/test/java/org/apache/seata/compressor/zip/ZipUtilTest.java
index 48a880f542..09f59d30e8 100644
---
a/compressor/seata-compressor-zip/src/test/java/org/apache/seata/compressor/zip/ZipUtilTest.java
+++
b/compressor/seata-compressor-zip/src/test/java/org/apache/seata/compressor/zip/ZipUtilTest.java
@@ -19,6 +19,9 @@ package org.apache.seata.compressor.zip;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import java.nio.charset.StandardCharsets;
+import java.util.Random;
+
/**
* the Zip Util test
*
@@ -26,16 +29,103 @@ import org.junit.jupiter.api.Test;
public class ZipUtilTest {
@Test
- public void test_compress() {
+ public void testCompress() {
Assertions.assertThrows(NullPointerException.class, () -> {
ZipUtil.compress(null);
});
}
@Test
- public void test_decompress() {
+ public void testDecompress() {
Assertions.assertThrows(NullPointerException.class, () -> {
ZipUtil.decompress(null);
});
}
+
+ @Test
+ public void testCompressEqualDecompress() {
+ byte[] compress = ZipUtil.compress("aa".getBytes());
+ byte[] decompress = ZipUtil.decompress(compress);
+ Assertions.assertEquals("aa", new String(decompress));
+ }
+
+ @Test
+ public void testCompressEmptyArray() {
+ byte[] empty = new byte[0];
+ byte[] compressed = ZipUtil.compress(empty);
+ byte[] decompressed = ZipUtil.decompress(compressed);
+ Assertions.assertArrayEquals(empty, decompressed);
+ }
+
+ @Test
+ public void testCompressSingleByte() {
+ byte[] singleByte = {42};
+ byte[] compressed = ZipUtil.compress(singleByte);
+ byte[] decompressed = ZipUtil.decompress(compressed);
+ Assertions.assertArrayEquals(singleByte, decompressed);
+ }
+
+ @Test
+ public void testCompressLargeData() {
+ byte[] largeData = new byte[1024 * 1024];
+ new Random().nextBytes(largeData);
+ byte[] compressed = ZipUtil.compress(largeData);
+ byte[] decompressed = ZipUtil.decompress(compressed);
+ Assertions.assertArrayEquals(largeData, decompressed);
+ }
+
+ @Test
+ public void testCompressTextCata() {
+ String text = "The quick brown fox jumps over the lazy dog";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = ZipUtil.compress(original);
+ byte[] decompressed = ZipUtil.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressUnicodeData() {
+ String text = "测试中文数据压缩解压";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = ZipUtil.compress(original);
+ byte[] decompressed = ZipUtil.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressionRatio() {
+ String repeatedText = new String(new char[1000]).replace("\0", "a");
+ byte[] original = repeatedText.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = ZipUtil.compress(original);
+ Assertions.assertTrue(
+ compressed.length < original.length,
+ "Compressed size should be smaller than original for
repetitive data");
+ }
+
+ @Test
+ public void testDecompressInvalidData() {
+ byte[] invalidData = {0x1, 0x2, 0x3, 0x4, 0x5};
+ byte[] result = ZipUtil.decompress(invalidData);
+ Assertions.assertArrayEquals(new byte[0], result);
+ }
+
+ @Test
+ public void testDecompressEmptyArray() {
+ byte[] result = ZipUtil.decompress(new byte[0]);
+ Assertions.assertArrayEquals(new byte[0], result);
+ }
+
+ @Test
+ public void testMultipleCompressionCycles() {
+ String text = "Test multiple compression cycles";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+
+ byte[] firstCompressed = ZipUtil.compress(original);
+ byte[] firstDecompressed = ZipUtil.decompress(firstCompressed);
+
+ byte[] secondCompressed = ZipUtil.compress(firstDecompressed);
+ byte[] secondDecompressed = ZipUtil.decompress(secondCompressed);
+
+ Assertions.assertEquals(text, new String(secondDecompressed,
StandardCharsets.UTF_8));
+ }
}
diff --git
a/compressor/seata-compressor-zstd/src/test/java/org/apache/seata/compressor/zstd/ZstdCompressorTest.java
b/compressor/seata-compressor-zstd/src/test/java/org/apache/seata/compressor/zstd/ZstdCompressorTest.java
index f381844327..c0139c0d22 100644
---
a/compressor/seata-compressor-zstd/src/test/java/org/apache/seata/compressor/zstd/ZstdCompressorTest.java
+++
b/compressor/seata-compressor-zstd/src/test/java/org/apache/seata/compressor/zstd/ZstdCompressorTest.java
@@ -16,9 +16,11 @@
*/
package org.apache.seata.compressor.zstd;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.nio.charset.StandardCharsets;
+import java.util.Random;
import java.util.UUID;
/**
@@ -50,4 +52,113 @@ public class ZstdCompressorTest {
bytes = compressor.compress(bytes);
System.out.println("compressed size=" + bytes.length);
}
+
+ @Test
+ public void testCompressNull() {
+ ZstdCompressor compressor = new ZstdCompressor();
+ Assertions.assertThrows(NullPointerException.class, () -> {
+ compressor.compress(null);
+ });
+ }
+
+ @Test
+ public void testDecompressNull() {
+ ZstdCompressor compressor = new ZstdCompressor();
+ Assertions.assertThrows(NullPointerException.class, () -> {
+ compressor.decompress(null);
+ });
+ }
+
+ @Test
+ public void testCompressEmptyArray() {
+ ZstdCompressor compressor = new ZstdCompressor();
+ byte[] empty = new byte[0];
+ byte[] compressed = compressor.compress(empty);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertArrayEquals(empty, decompressed);
+ }
+
+ @Test
+ public void testCompressSingleByte() {
+ ZstdCompressor compressor = new ZstdCompressor();
+ byte[] singleByte = {42};
+ byte[] compressed = compressor.compress(singleByte);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertArrayEquals(singleByte, decompressed);
+ }
+
+ @Test
+ public void testCompressLargeData() {
+ ZstdCompressor compressor = new ZstdCompressor();
+ byte[] largeData = new byte[1024 * 1024];
+ new Random().nextBytes(largeData);
+ byte[] compressed = compressor.compress(largeData);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertArrayEquals(largeData, decompressed);
+ }
+
+ @Test
+ public void testCompressTextData() {
+ ZstdCompressor compressor = new ZstdCompressor();
+ String text = "The quick brown fox jumps over the lazy dog";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = compressor.compress(original);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressSpecialCharacters() {
+ ZstdCompressor compressor = new ZstdCompressor();
+ String text = "Hello World! @#$%^&*()_+-=[]{}|;':\",./<>?";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = compressor.compress(original);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressUnicodeData() {
+ ZstdCompressor compressor = new ZstdCompressor();
+ String text = "Hello World in Chinese: 你好世界, Japanese: こんにちは世界,
Korean: 안녕하세요 세계";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = compressor.compress(original);
+ byte[] decompressed = compressor.decompress(compressed);
+ Assertions.assertEquals(text, new String(decompressed,
StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testCompressionRatio() {
+ ZstdCompressor compressor = new ZstdCompressor();
+ String repeatedText = new String(new char[1000]).replace("\0", "a");
+ byte[] original = repeatedText.getBytes(StandardCharsets.UTF_8);
+ byte[] compressed = compressor.compress(original);
+ Assertions.assertTrue(
+ compressed.length < original.length,
+ "Compressed size should be smaller than original for
repetitive data");
+ }
+
+ @Test
+ public void testDecompressInvalidData() {
+ ZstdCompressor compressor = new ZstdCompressor();
+ byte[] invalidData = {0x1, 0x2, 0x3, 0x4};
+ Assertions.assertThrows(RuntimeException.class, () -> {
+ compressor.decompress(invalidData);
+ });
+ }
+
+ @Test
+ public void testMultipleCompressionCycles() {
+ ZstdCompressor compressor = new ZstdCompressor();
+ String text = "Test multiple compression cycles";
+ byte[] original = text.getBytes(StandardCharsets.UTF_8);
+
+ byte[] firstCompressed = compressor.compress(original);
+ byte[] firstDecompressed = compressor.decompress(firstCompressed);
+
+ byte[] secondCompressed = compressor.compress(firstDecompressed);
+ byte[] secondDecompressed = compressor.decompress(secondCompressed);
+
+ Assertions.assertEquals(text, new String(secondDecompressed,
StandardCharsets.UTF_8));
+ }
}
diff --git
a/compressor/seata-compressor-zstd/src/test/java/org/apache/seata/compressor/zstd/ZstdUtilTest.java
b/compressor/seata-compressor-zstd/src/test/java/org/apache/seata/compressor/zstd/ZstdUtilTest.java
index d46bd48bfb..f458e13861 100644
---
a/compressor/seata-compressor-zstd/src/test/java/org/apache/seata/compressor/zstd/ZstdUtilTest.java
+++
b/compressor/seata-compressor-zstd/src/test/java/org/apache/seata/compressor/zstd/ZstdUtilTest.java
@@ -31,21 +31,28 @@ public class ZstdUtilTest {
private final int MAX_COMPRESSED_SIZE = 4 * 1024 * 1024; // 4MB
@Test
- public void test_compress() {
+ public void testCompress() {
Assertions.assertThrows(NullPointerException.class, () -> {
ZstdUtil.compress(null);
});
}
@Test
- public void test_decompress() {
+ public void testDecompress() {
Assertions.assertThrows(NullPointerException.class, () -> {
ZstdUtil.decompress(null);
});
}
@Test
- public void test_decompress_with_len_illegal() {
+ public void testCompressEqualDecompress() {
+ byte[] compress = ZstdUtil.compress("aa".getBytes());
+ byte[] decompress = ZstdUtil.decompress(compress);
+ Assertions.assertEquals("aa", new String(decompress));
+ }
+
+ @Test
+ public void testDecompressWithLenIllegal() {
Assertions.assertThrows(IllegalArgumentException.class, () -> {
//
https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md#zstandard-frames
List<Byte> bytes = new ArrayList<>();
@@ -63,7 +70,7 @@ public class ZstdUtilTest {
}
@Test
- public void test_decompress_with_len() {
+ public void testDecompressWithLen() {
Assertions.assertDoesNotThrow(() -> {
byte[] data = new byte[MAX_COMPRESSED_SIZE + 1];
for (int i = 0; i < data.length; i++) {
@@ -83,7 +90,7 @@ public class ZstdUtilTest {
}
@Test
- public void test_decompress_with_fake_frame_content_size_oom() {
+ public void testDecompressWithFakeFrameContentSizeOOM() {
// Construct a fake zstd header with the frame content size set to
1GB, while the actual content is only 4MB.
byte[] magic = new byte[] {(byte) 0x28, (byte) 0xB5, (byte) 0x2F,
(byte) 0xFD};
byte[] frameHeaderDescriptor = new byte[magic.length + 1];
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
