package jnpf.fileStorage.dms;
|
|
import com.google.zxing.BinaryBitmap;
|
import com.google.zxing.MultiFormatReader;
|
import com.google.zxing.RGBLuminanceSource;
|
import com.google.zxing.common.HybridBinarizer;
|
import jnpf.dmsEntity.preview.model.DmsWatermarkPositionSnapshot;
|
import jnpf.dmsEntity.preview.model.DmsWatermarkSnapshot;
|
import jnpf.exception.DataException;
|
import org.junit.Test;
|
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
|
|
import javax.imageio.IIOImage;
|
import javax.imageio.ImageIO;
|
import javax.imageio.ImageWriter;
|
import javax.imageio.stream.MemoryCacheImageOutputStream;
|
import java.awt.Color;
|
import java.awt.Graphics2D;
|
import java.awt.image.BufferedImage;
|
import java.io.ByteArrayInputStream;
|
import java.io.ByteArrayOutputStream;
|
import java.io.InputStream;
|
import java.math.BigDecimal;
|
import java.util.Arrays;
|
import java.util.List;
|
import java.util.concurrent.CountDownLatch;
|
import java.util.concurrent.ExecutorService;
|
import java.util.concurrent.Executors;
|
import java.util.concurrent.Future;
|
import java.util.concurrent.TimeUnit;
|
import java.util.concurrent.atomic.AtomicBoolean;
|
import java.util.zip.CRC32;
|
|
import static org.junit.Assert.assertArrayEquals;
|
import static org.junit.Assert.assertEquals;
|
import static org.junit.Assert.assertFalse;
|
import static org.junit.Assert.assertNotEquals;
|
import static org.junit.Assert.assertThrows;
|
import static org.junit.Assert.assertTrue;
|
import static org.mockito.ArgumentMatchers.any;
|
import static org.mockito.Mockito.doAnswer;
|
import static org.mockito.Mockito.mock;
|
|
public class DmsImageWatermarkServiceTest {
|
private final DmsImageWatermarkService service = new DmsImageWatermarkService(
|
new DmsDocxWatermarkService(mock(DmsCommonFileStorage.class)));
|
|
@Test
|
public void springSelectsProductionConstructor() {
|
try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext()) {
|
context.registerBean(DmsDocxWatermarkService.class,
|
() -> new DmsDocxWatermarkService(mock(DmsCommonFileStorage.class)));
|
context.register(DmsImageWatermarkService.class);
|
context.refresh();
|
|
assertTrue(context.containsBean("dmsImageWatermarkService"));
|
}
|
}
|
|
@Test
|
public void appliesTextWatermarkToPngWithoutMutatingSource() throws Exception {
|
byte[] source = image("png", 640, 360);
|
byte[] original = source.clone();
|
|
byte[] result = service.apply(source, "inspection.PNG", List.of(watermark()));
|
|
assertArrayEquals(original, source);
|
assertNotEquals(Arrays.hashCode(source), Arrays.hashCode(result));
|
BufferedImage rendered = ImageIO.read(new ByteArrayInputStream(result));
|
assertEquals(640, rendered.getWidth());
|
assertEquals(360, rendered.getHeight());
|
assertTrue(countDarkPixels(rendered) > 20);
|
}
|
|
@Test
|
public void keepsJpegEncodingAndDimensions() throws Exception {
|
byte[] source = image("jpeg", 480, 320);
|
|
byte[] result = service.apply(source, "inspection.jpg", List.of(watermark()));
|
|
assertEquals(0xFF, result[0] & 0xFF);
|
assertEquals(0xD8, result[1] & 0xFF);
|
BufferedImage rendered = ImageIO.read(new ByteArrayInputStream(result));
|
assertEquals(480, rendered.getWidth());
|
assertEquals(320, rendered.getHeight());
|
assertTrue(countDarkPixels(rendered) > 20);
|
}
|
|
@Test
|
public void normalizesJpegExifOrientationBeforePlacingWatermark() throws Exception {
|
byte[] source = withExifOrientation(image("jpeg", 600, 400), 6);
|
|
byte[] result = service.apply(source, "phone-photo.jpg", List.of(watermark()));
|
|
BufferedImage rendered = ImageIO.read(new ByteArrayInputStream(result));
|
assertEquals(400, rendered.getWidth());
|
assertEquals(600, rendered.getHeight());
|
assertTrue(countDarkPixels(rendered) > 20);
|
}
|
|
@Test
|
public void keepsBmpAndStaticGifFormats() throws Exception {
|
for (String format : List.of("bmp", "gif")) {
|
byte[] result = service.apply(image(format, 320, 240),
|
"inspection." + format, List.of(watermark()));
|
|
assertEquals("bmp".equals(format) ? 'B' : 'G', result[0]);
|
BufferedImage rendered = ImageIO.read(new ByteArrayInputStream(result));
|
assertEquals(320, rendered.getWidth());
|
assertEquals(240, rendered.getHeight());
|
assertTrue(countDarkPixels(rendered) > 20);
|
}
|
}
|
|
@Test
|
public void highResolutionQrWatermarkRemainsDecodable() throws Exception {
|
DmsWatermarkSnapshot qr = watermark();
|
qr.setWatermarkType("BARCODE");
|
qr.setBarcodeFormat("QR_CODE");
|
qr.setContent("DMS-IMAGE-WATERMARK-001");
|
qr.setRotationAngle(0);
|
qr.setMarkWidthMm(new BigDecimal("80"));
|
qr.setMarkHeightMm(new BigDecimal("80"));
|
|
byte[] result = service.apply(image("png", 2400, 1600),
|
"inspection.png", List.of(qr));
|
|
assertEquals(qr.getContent(), decode(ImageIO.read(new ByteArrayInputStream(result))));
|
}
|
|
@Test
|
public void scalesCode128IntoUserConfiguredBoxWithoutRejectingItsIntrinsicSize() throws Exception {
|
DmsWatermarkSnapshot barcode = watermark();
|
barcode.setWatermarkType("BARCODE");
|
barcode.setBarcodeFormat("CODE_128");
|
barcode.setContent("PIC-SMP100-01000");
|
barcode.setRotationAngle(0);
|
barcode.setMarkWidthMm(new BigDecimal("12"));
|
barcode.setMarkHeightMm(new BigDecimal("5"));
|
|
byte[] result = service.apply(image("png", 640, 360),
|
"inspection.png", List.of(barcode));
|
|
BufferedImage rendered = ImageIO.read(new ByteArrayInputStream(result));
|
assertEquals(640, rendered.getWidth());
|
assertEquals(360, rendered.getHeight());
|
assertTrue(countDarkPixels(rendered) > 0);
|
}
|
|
@Test
|
public void rejectsLongCode128BeforeAllocatingExpandedRaster() throws Exception {
|
DmsWatermarkSnapshot barcode = watermark();
|
barcode.setWatermarkType("BARCODE");
|
barcode.setBarcodeFormat("CODE_128");
|
barcode.setContent("A".repeat(2_000));
|
barcode.setMarkWidthMm(BigDecimal.ONE);
|
|
DataException error = assertThrows(DataException.class, () -> service.apply(
|
image("png", 640, 360), "inspection.png", List.of(barcode)));
|
|
assertTrue(error.getMessage().contains("Code 128 水印内容过长"));
|
}
|
|
@Test
|
public void usesImageMimeTypeWhenFileNameHasNoExtension() throws Exception {
|
byte[] source = image("png", 320, 240);
|
|
byte[] result = service.apply(source, "inspection", "image/png", List.of(watermark()));
|
|
assertEquals(0x89, result[0] & 0xFF);
|
assertEquals("image/png", DmsImageWatermarkService.contentType("inspection", "image/png"));
|
assertTrue(countDarkPixels(ImageIO.read(new ByteArrayInputStream(result))) > 20);
|
}
|
|
@Test
|
public void rejectsUnsupportedImageFormatInsteadOfReturningOriginalBytes() {
|
byte[] source = {1, 2, 3};
|
|
DataException error = assertThrows(DataException.class,
|
() -> service.apply(source, "inspection.webp", "image/webp", List.of(watermark())));
|
|
assertTrue(error.getMessage().contains("不支持动态水印"));
|
}
|
|
@Test
|
public void boundedBufferRejectsBytesPastItsLimit() {
|
DmsBoundedByteArrayOutputStream output = new DmsBoundedByteArrayOutputStream(4, "limit");
|
output.write(new byte[]{1, 2, 3, 4}, 0, 4);
|
|
DataException error = assertThrows(DataException.class, () -> output.write(5));
|
|
assertEquals("limit", error.getMessage());
|
assertEquals(4, output.size());
|
}
|
|
@Test
|
public void boundedBufferReleasesItsBackingStorageAfterExtraction() {
|
DmsBoundedByteArrayOutputStream output = new DmsBoundedByteArrayOutputStream(8, "limit");
|
output.write(new byte[]{1, 2, 3, 4}, 0, 4);
|
|
assertArrayEquals(new byte[]{1, 2, 3, 4}, output.toByteArrayAndRelease());
|
assertEquals(0, output.size());
|
}
|
|
@Test
|
public void rejectsBusyRequestBeforeReadingItsSource() throws Exception {
|
DmsDocxWatermarkService rasterizer = mock(DmsDocxWatermarkService.class);
|
DmsImageWatermarkService guarded = new DmsImageWatermarkService(rasterizer, 10L);
|
CountDownLatch rendering = new CountDownLatch(1);
|
CountDownLatch release = new CountDownLatch(1);
|
doAnswer(invocation -> {
|
rendering.countDown();
|
assertTrue(release.await(5, TimeUnit.SECONDS));
|
return null;
|
}).when(rasterizer).applyImageWatermarks(any(), any());
|
byte[] source = image("png", 320, 240);
|
ExecutorService executor = Executors.newSingleThreadExecutor();
|
try {
|
Future<byte[]> first = executor.submit(() -> guarded.loadAndApply(
|
() -> source, "first.png", "image/png", List.of(watermark())));
|
assertTrue(rendering.await(5, TimeUnit.SECONDS));
|
AtomicBoolean secondSourceRead = new AtomicBoolean(false);
|
|
DataException error = assertThrows(DataException.class, () -> guarded.loadAndApply(() -> {
|
secondSourceRead.set(true);
|
return source;
|
}, "second.png", "image/png", List.of(watermark())));
|
|
assertTrue(error.getMessage().contains("处理繁忙"));
|
assertFalse(secondSourceRead.get());
|
release.countDown();
|
assertTrue(first.get(5, TimeUnit.SECONDS).length > 0);
|
} finally {
|
release.countDown();
|
executor.shutdownNow();
|
}
|
}
|
|
@Test
|
public void rejectsTooManyWatermarksBeforeReadingSource() {
|
AtomicBoolean sourceRead = new AtomicBoolean(false);
|
List<DmsWatermarkSnapshot> watermarks = java.util.stream.IntStream
|
.rangeClosed(1, DmsImageWatermarkService.MAX_WATERMARKS + 1)
|
.mapToObj(index -> watermark())
|
.toList();
|
|
DataException error = assertThrows(DataException.class, () -> service.loadAndApply(() -> {
|
sourceRead.set(true);
|
return new byte[]{1};
|
}, "inspection.png", "image/png", watermarks));
|
|
assertTrue(error.getMessage().contains("最多支持"));
|
assertFalse(sourceRead.get());
|
}
|
|
@Test
|
public void allowsWatermarkLargerThanImageCanvas() throws Exception {
|
DmsWatermarkSnapshot oversized = watermark();
|
oversized.setMarkWidthMm(new BigDecimal("1000"));
|
oversized.setMarkHeightMm(new BigDecimal("1000"));
|
|
byte[] result = service.apply(image("png", 640, 360),
|
"inspection.png", List.of(oversized));
|
|
BufferedImage rendered = ImageIO.read(new ByteArrayInputStream(result));
|
assertEquals(640, rendered.getWidth());
|
assertEquals(360, rendered.getHeight());
|
}
|
|
@Test
|
public void doesNotMoveOutOfBoundsWatermarkBackOntoImage() throws Exception {
|
DmsWatermarkSnapshot outside = watermark();
|
outside.setRotationAngle(0);
|
outside.setMarkWidthMm(new BigDecimal("20"));
|
outside.setMarkHeightMm(new BigDecimal("20"));
|
DmsWatermarkPositionSnapshot position = outside.getPositions().get(0);
|
position.setLandscapeXMm(new BigDecimal("400"));
|
position.setLandscapeYMm(new BigDecimal("50"));
|
|
byte[] result = service.apply(image("png", 640, 360),
|
"inspection.png", List.of(outside));
|
|
assertEquals(0, countDarkPixels(ImageIO.read(new ByteArrayInputStream(result))));
|
}
|
|
@Test
|
public void rejectsOversizedImageWatermarkAssetBeforeDecodingPixels() throws Exception {
|
DmsCommonFileStorage commonStorage = mock(DmsCommonFileStorage.class);
|
doAnswer(invocation -> {
|
java.util.function.Consumer<InputStream> consumer = invocation.getArgument(2);
|
consumer.accept(new ByteArrayInputStream(oversizedPng()));
|
return null;
|
}).when(commonStorage).download(any(), any(), any());
|
DmsImageWatermarkService guarded = new DmsImageWatermarkService(
|
new DmsDocxWatermarkService(commonStorage));
|
DmsWatermarkSnapshot imageMark = watermark();
|
imageMark.setWatermarkType("IMAGE");
|
imageMark.setImageUrl("http://localhost/api/file/Image/watermark/logo.png");
|
|
DataException error = assertThrows(DataException.class, () -> guarded.apply(
|
image("png", 640, 360), "inspection.png", List.of(imageMark)));
|
|
assertTrue(error.getMessage(), error.getMessage().contains("素材尺寸超过处理上限"));
|
}
|
|
@Test
|
public void rejectsWatermarksAssignedToNonexistentImagePages() throws Exception {
|
byte[] source = image("png", 320, 240);
|
DmsWatermarkSnapshot watermark = watermark();
|
watermark.setRenderPages(List.of(2, 3));
|
|
DataException error = assertThrows(DataException.class,
|
() -> service.apply(source, "inspection.png", List.of(watermark)));
|
|
assertTrue(error.getMessage().contains("只有第 1 页"));
|
}
|
|
@Test
|
public void rejectsAnimatedGifInsteadOfDroppingFrames() throws Exception {
|
DataException error = assertThrows(DataException.class,
|
() -> service.apply(animatedGif(), "animation.gif", List.of(watermark())));
|
|
assertTrue(error.getMessage().contains("动态 GIF"));
|
}
|
|
@Test
|
public void rejectsContentWhoseMagicDoesNotMatchItsExtension() throws Exception {
|
DataException error = assertThrows(DataException.class,
|
() -> service.apply(image("png", 100, 100), "renamed.jpg", List.of(watermark())));
|
|
assertTrue(error.getMessage().contains("扩展名与实际格式不一致"));
|
}
|
|
private DmsWatermarkSnapshot watermark() {
|
DmsWatermarkSnapshot watermark = new DmsWatermarkSnapshot();
|
watermark.setWatermarkType("TEXT");
|
watermark.setContent("CONFIDENTIAL");
|
watermark.setFontFamily("SansSerif");
|
watermark.setFontColor("#000000");
|
watermark.setFontSize(18);
|
watermark.setRotationAngle(-20);
|
watermark.setOpacity(100);
|
watermark.setLayoutMode("POSITION");
|
watermark.setMarkWidthMm(new BigDecimal("80"));
|
watermark.setMarkHeightMm(new BigDecimal("20"));
|
DmsWatermarkPositionSnapshot position = new DmsWatermarkPositionSnapshot();
|
position.setPaperWidthMm(new BigDecimal("210"));
|
position.setPaperHeightMm(new BigDecimal("297"));
|
position.setPortraitXMm(new BigDecimal("65"));
|
position.setPortraitYMm(new BigDecimal("138"));
|
position.setLandscapeXMm(new BigDecimal("108"));
|
position.setLandscapeYMm(new BigDecimal("95"));
|
watermark.setPositions(List.of(position));
|
return watermark;
|
}
|
|
private byte[] image(String format, int width, int height) throws Exception {
|
BufferedImage image = new BufferedImage(width, height,
|
"png".equals(format) ? BufferedImage.TYPE_INT_ARGB : BufferedImage.TYPE_INT_RGB);
|
Graphics2D graphics = image.createGraphics();
|
try {
|
graphics.setColor(Color.WHITE);
|
graphics.fillRect(0, 0, width, height);
|
} finally {
|
graphics.dispose();
|
}
|
ByteArrayOutputStream output = new ByteArrayOutputStream();
|
assertTrue(ImageIO.write(image, format, output));
|
return output.toByteArray();
|
}
|
|
private byte[] animatedGif() throws Exception {
|
ImageWriter writer = ImageIO.getImageWritersByFormatName("gif").next();
|
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
|
try (MemoryCacheImageOutputStream output = new MemoryCacheImageOutputStream(bytes)) {
|
writer.setOutput(output);
|
writer.prepareWriteSequence(null);
|
writer.writeToSequence(new IIOImage(frame(Color.WHITE), null, null), writer.getDefaultWriteParam());
|
writer.writeToSequence(new IIOImage(frame(Color.LIGHT_GRAY), null, null), writer.getDefaultWriteParam());
|
writer.endWriteSequence();
|
output.flush();
|
} finally {
|
writer.dispose();
|
}
|
return bytes.toByteArray();
|
}
|
|
private byte[] withExifOrientation(byte[] jpeg, int orientation) {
|
byte[] payload = new byte[32];
|
payload[0] = 'E';
|
payload[1] = 'x';
|
payload[2] = 'i';
|
payload[3] = 'f';
|
int tiff = 6;
|
payload[tiff] = 'I';
|
payload[tiff + 1] = 'I';
|
putShort(payload, tiff + 2, 42);
|
putInt(payload, tiff + 4, 8);
|
putShort(payload, tiff + 8, 1);
|
int entry = tiff + 10;
|
putShort(payload, entry, 0x0112);
|
putShort(payload, entry + 2, 3);
|
putInt(payload, entry + 4, 1);
|
putShort(payload, entry + 8, orientation);
|
|
int segmentLength = payload.length + 2;
|
byte[] result = new byte[jpeg.length + payload.length + 4];
|
result[0] = jpeg[0];
|
result[1] = jpeg[1];
|
result[2] = (byte) 0xFF;
|
result[3] = (byte) 0xE1;
|
result[4] = (byte) (segmentLength >>> 8);
|
result[5] = (byte) segmentLength;
|
System.arraycopy(payload, 0, result, 6, payload.length);
|
System.arraycopy(jpeg, 2, result, 6 + payload.length, jpeg.length - 2);
|
return result;
|
}
|
|
private byte[] oversizedPng() throws Exception {
|
byte[] png = image("png", 1, 1);
|
putBigEndianInt(png, 16, 10_000);
|
putBigEndianInt(png, 20, 10_000);
|
CRC32 crc = new CRC32();
|
crc.update(png, 12, 17);
|
putBigEndianInt(png, 29, (int) crc.getValue());
|
return png;
|
}
|
|
private void putBigEndianInt(byte[] data, int offset, int value) {
|
data[offset] = (byte) (value >>> 24);
|
data[offset + 1] = (byte) (value >>> 16);
|
data[offset + 2] = (byte) (value >>> 8);
|
data[offset + 3] = (byte) value;
|
}
|
|
private void putShort(byte[] data, int offset, int value) {
|
data[offset] = (byte) value;
|
data[offset + 1] = (byte) (value >>> 8);
|
}
|
|
private void putInt(byte[] data, int offset, int value) {
|
data[offset] = (byte) value;
|
data[offset + 1] = (byte) (value >>> 8);
|
data[offset + 2] = (byte) (value >>> 16);
|
data[offset + 3] = (byte) (value >>> 24);
|
}
|
|
private BufferedImage frame(Color color) {
|
BufferedImage image = new BufferedImage(80, 60, BufferedImage.TYPE_INT_RGB);
|
Graphics2D graphics = image.createGraphics();
|
try {
|
graphics.setColor(color);
|
graphics.fillRect(0, 0, image.getWidth(), image.getHeight());
|
} finally {
|
graphics.dispose();
|
}
|
return image;
|
}
|
|
private long countDarkPixels(BufferedImage image) {
|
long count = 0;
|
for (int y = 0; y < image.getHeight(); y++) {
|
for (int x = 0; x < image.getWidth(); x++) {
|
Color color = new Color(image.getRGB(x, y), true);
|
if (color.getAlpha() > 0 && color.getRed() < 100
|
&& color.getGreen() < 100 && color.getBlue() < 100) {
|
count++;
|
}
|
}
|
}
|
return count;
|
}
|
|
private String decode(BufferedImage image) throws Exception {
|
int width = image.getWidth();
|
int height = image.getHeight();
|
int[] pixels = image.getRGB(0, 0, width, height, null, 0, width);
|
BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(
|
new RGBLuminanceSource(width, height, pixels)));
|
return new MultiFormatReader().decode(bitmap).getText();
|
}
|
}
|
