Валидатор: лимиты 5 МиБ и 100 страниц, отказ до рендера и без артефактов
- WordPdfValidator (новый): MAX_INPUT_BYTES/MAX_PAGES, три нижние оценки страниц (кэш app.xml недостоверен — реальный кейс <Pages>1</Pages> при 110 маркерах lastRenderedPageBreak); lightweight zip/StAX-путь. - convert(Path,Path): неполный PDF удаляется при отказе, но только если поток вывода реально открылся (чужой read-only файл не стирается); checkPageCount внутри try — finally чистит temp-файлы шрифтов. - lightweight: continuous-секции не считаются страницами; w:type — дочерний элемент, классификация на закрытии sectPr; мёртвый атрибутный перегруз startsNewPage удалён. - Фикстуры too-many-pages.docx (151 страница) и stale-cache.docx (кэш 1 при 110 маркерах) + регрессии tooManyPages, staleCachePageCountRejectedBeforeRender, inputTooLarge, oversizedInputReturnsError, pageCount_continuousSectionsNotCountedLightweight. - SampleDocxGenerator: точный поиск <w:t (не матчить <w:tbl/<w:tc), константа STALE_CACHE_UNMARKED_RUNS вместо литерала. - AGENTS.md переписан; .gitignore += /diff/ и /word-export.*. mvn clean verify: 95/95; fat-jar проверен java -jar (код 0/2, артефактов нет).
This commit is contained in:
@@ -18,10 +18,10 @@ import ru.pjandro.wordpdf.internal.FopFallbackFonts;
|
||||
import ru.pjandro.wordpdf.internal.SymbolFontNormalizer;
|
||||
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.OutputStream;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.util.Locale;
|
||||
|
||||
/**
|
||||
* Конвертер docx -> PDF на базе docx4j + Apache FOP
|
||||
@@ -56,10 +56,12 @@ public final class WordPdfConverter {
|
||||
*
|
||||
* @param docxIn входной .docx
|
||||
* @return путь к созданному PDF
|
||||
* @throws ConversionException при ошибке (не .docx, файл не найден и т.п.)
|
||||
* @throws ConversionException при ошибке (не .docx, файл не найден,
|
||||
* размер больше {@link WordPdfValidator#MAX_INPUT_BYTES},
|
||||
* результат длиннее {@link WordPdfValidator#MAX_PAGES} страниц и т.п.)
|
||||
*/
|
||||
public static Path convert(Path docxIn) throws ConversionException {
|
||||
validateInput(docxIn);
|
||||
WordPdfValidator.checkInput(docxIn);
|
||||
String name = docxIn.getFileName().toString();
|
||||
int dot = name.lastIndexOf('.');
|
||||
String base = dot > 0 ? name.substring(0, dot) : name;
|
||||
@@ -72,17 +74,38 @@ public final class WordPdfConverter {
|
||||
* Конвертирует {@code docxIn} в {@code pdfOut}.
|
||||
* Родительские каталоги {@code pdfOut} при необходимости создаются.
|
||||
*
|
||||
* <p>Число страниц проверяется по самому .docx (см.
|
||||
* {@link WordPdfValidator#checkPageCount}) до рендеринга — при
|
||||
* превышении лимита PDF не создаётся.
|
||||
*
|
||||
* @throws ConversionException при ошибке
|
||||
*/
|
||||
public static void convert(Path docxIn, Path pdfOut) throws ConversionException {
|
||||
validateInput(docxIn);
|
||||
WordPdfValidator.checkInput(docxIn);
|
||||
try {
|
||||
Path parent = pdfOut.toAbsolutePath().getParent();
|
||||
if (parent != null) {
|
||||
Files.createDirectories(parent);
|
||||
}
|
||||
boolean opened = false;
|
||||
try (OutputStream os = Files.newOutputStream(pdfOut)) {
|
||||
opened = true;
|
||||
convertToStream(docxIn, os);
|
||||
} catch (Exception e) {
|
||||
// валидация числа страниц срабатывает уже внутри
|
||||
// convertToStream — пустой/неполный PDF убирать, чтобы
|
||||
// отказ не оставлял артефакт рядом со входом. Удаляем
|
||||
// только если поток реально открылся: при неудачном
|
||||
// открытии (read-only/locked цель) ничего не писали и
|
||||
// чужой файл трогать нельзя
|
||||
if (opened) {
|
||||
try {
|
||||
Files.deleteIfExists(pdfOut);
|
||||
} catch (IOException ignored) {
|
||||
// вторичная ошибка не должна затенять основную
|
||||
}
|
||||
}
|
||||
throw e;
|
||||
}
|
||||
} catch (ConversionException e) {
|
||||
throw e;
|
||||
@@ -123,6 +146,12 @@ public final class WordPdfConverter {
|
||||
WordprocessingMLPackage pkg = WordprocessingMLPackage.load(
|
||||
new ByteArrayInputStream(docxBytes));
|
||||
try {
|
||||
// 2.5 Проверка числа страниц по самому .docx: кэш Word
|
||||
// (docProps/app.xml <Pages>) или нижняя оценка по явным
|
||||
// разрывам. Делается до рендера, чтобы не тратить время на
|
||||
// заведомо длинный документ; внутри try — чтобы и на отказе
|
||||
// отработал finally с чисткой temp-файлов встроенных шрифтов.
|
||||
WordPdfValidator.checkPageCount(pkg);
|
||||
// 3. Привязка маппера: docx4j сопоставляет шрифты документа
|
||||
// с физическими TTF (учитывая и шрифты, встроенные в docx)
|
||||
pkg.setFontMapper(mapper);
|
||||
@@ -158,21 +187,6 @@ public final class WordPdfConverter {
|
||||
}
|
||||
}
|
||||
|
||||
/** Проверяет входной файл: существует, это .docx (не .doc). */
|
||||
private static void validateInput(Path docxIn) throws ConversionException {
|
||||
if (docxIn == null) {
|
||||
throw new ConversionException("Не указан входной файл");
|
||||
}
|
||||
if (!Files.isRegularFile(docxIn)) {
|
||||
throw new ConversionException("Файл не найден: " + docxIn);
|
||||
}
|
||||
String name = docxIn.getFileName().toString().toLowerCase(Locale.ROOT);
|
||||
if (!name.endsWith(".docx")) {
|
||||
throw new ConversionException(
|
||||
"Поддерживается только .docx (без .doc): " + docxIn);
|
||||
}
|
||||
}
|
||||
|
||||
/** Имя файла без расширения (для PDF-заголовка). */
|
||||
private static String baseName(Path p) {
|
||||
String name = p.getFileName().toString();
|
||||
|
||||
@@ -0,0 +1,573 @@
|
||||
package ru.pjandro.wordpdf;
|
||||
|
||||
import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
|
||||
import org.docx4j.wml.Br;
|
||||
import org.docx4j.wml.ContentAccessor;
|
||||
import org.docx4j.wml.P;
|
||||
import org.docx4j.wml.R;
|
||||
import org.docx4j.wml.SectPr;
|
||||
import org.docx4j.wml.STBrType;
|
||||
|
||||
import jakarta.xml.bind.JAXBElement;
|
||||
|
||||
import javax.xml.stream.XMLInputFactory;
|
||||
import javax.xml.stream.XMLStreamException;
|
||||
import javax.xml.stream.XMLStreamReader;
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.util.ArrayDeque;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Deque;
|
||||
import java.util.List;
|
||||
import java.util.Locale;
|
||||
import java.util.zip.ZipEntry;
|
||||
import java.util.zip.ZipFile;
|
||||
import java.util.zip.ZipInputStream;
|
||||
|
||||
/**
|
||||
* Валидатор ограничений на входной .docx:
|
||||
* размер файла и число страниц.
|
||||
*
|
||||
* <p>Конвертер {@link WordPdfConverter} вызывает валидатор автоматически,
|
||||
* но им можно пользоваться и напрямую — например, проверить байты
|
||||
* документа, полученного из сети или БД, до того, как сохранять во временный
|
||||
* файл и вызывать {@code convert}.
|
||||
*
|
||||
* <p>Лимиты:
|
||||
* <ul>
|
||||
* <li>{@link #MAX_INPUT_BYTES} — максимальный размер входного .docx (5 MiB);</li>
|
||||
* <li>{@link #MAX_PAGES} — максимально допустимое число страниц (100).</li>
|
||||
* </ul>
|
||||
*
|
||||
* <p>Число страниц берётся из самого .docx как максимум трёх нижних
|
||||
* оценок: кэша Word в {@code docProps/app.xml} ({@code <Pages>}),
|
||||
* явных разрывов страниц ({@code w:br type="page"},
|
||||
* {@code w:pageBreakBefore}, межсекционные {@code w:sectPr}) и маркеров
|
||||
* {@code w:lastRenderedPageBreak} — границ страниц, которые Word записал
|
||||
* при последнем рендере. Кэш сам по себе недостоверен: Word может
|
||||
* сохранить {@code <Pages>1</Pages>} в документе на 110 страниц
|
||||
* (регрессия — фикстура {@code samples/stale-cache.docx}).
|
||||
*
|
||||
* <p>Проверка делается <b>до</b> рендера — это позволяет отсекать слишком
|
||||
* длинные документы, не тратя время на конвертацию.
|
||||
*
|
||||
* <p>Все ошибки — {@link ConversionException}.
|
||||
*/
|
||||
public final class WordPdfValidator {
|
||||
|
||||
/** 5 MiB = 5 × 1024 × 1024. */
|
||||
public static final long MAX_INPUT_BYTES = 5L * 1024 * 1024;
|
||||
|
||||
/** Документ длиннее — ошибка. */
|
||||
public static final int MAX_PAGES = 100;
|
||||
|
||||
private WordPdfValidator() {
|
||||
}
|
||||
|
||||
/**
|
||||
* Проверяет входной файл: существует, это .docx, размер не превышает
|
||||
* {@link #MAX_INPUT_BYTES}.
|
||||
*
|
||||
* @throws ConversionException при любом нарушении
|
||||
*/
|
||||
public static void checkInput(Path docxIn) throws ConversionException {
|
||||
if (docxIn == null) {
|
||||
throw new ConversionException("Не указан входной файл");
|
||||
}
|
||||
if (!Files.isRegularFile(docxIn)) {
|
||||
throw new ConversionException("Файл не найден: " + docxIn);
|
||||
}
|
||||
String name = docxIn.getFileName().toString().toLowerCase(Locale.ROOT);
|
||||
if (!name.endsWith(".docx")) {
|
||||
throw new ConversionException(
|
||||
"Поддерживается только .docx (без .doc): " + docxIn);
|
||||
}
|
||||
long size;
|
||||
try {
|
||||
size = Files.size(docxIn);
|
||||
} catch (IOException e) {
|
||||
throw new ConversionException("Не удалось прочитать размер файла: " + docxIn, e);
|
||||
}
|
||||
if (size > MAX_INPUT_BYTES) {
|
||||
throw new ConversionException("Файл больше 5 МБ: " + size
|
||||
+ " байт > " + MAX_INPUT_BYTES + " байт (" + docxIn + ")");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Проверяет размер байтов входа (для документа, полученного из сети/БД).
|
||||
*
|
||||
* @throws ConversionException при {@code null} или превышении лимита
|
||||
*/
|
||||
public static void checkInput(byte[] docxBytes) throws ConversionException {
|
||||
if (docxBytes == null) {
|
||||
throw new ConversionException("Не указаны байты входного файла");
|
||||
}
|
||||
if (docxBytes.length > MAX_INPUT_BYTES) {
|
||||
throw new ConversionException("Файл больше 5 МБ: " + docxBytes.length
|
||||
+ " байт > " + MAX_INPUT_BYTES + " байт");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Считает страницы .docx и проверяет лимит.
|
||||
*
|
||||
* @throws ConversionException при ошибке загрузки или превышении {@link #MAX_PAGES}
|
||||
*/
|
||||
public static void checkPageCount(Path docxIn) throws ConversionException {
|
||||
if (docxIn == null) {
|
||||
throw new ConversionException("Не указан путь к .docx");
|
||||
}
|
||||
WordprocessingMLPackage pkg;
|
||||
try {
|
||||
pkg = WordprocessingMLPackage.load(docxIn.toFile());
|
||||
} catch (Exception e) {
|
||||
throw new ConversionException("Не удалось загрузить .docx: " + docxIn, e);
|
||||
}
|
||||
checkPageCount(pkg);
|
||||
}
|
||||
|
||||
/**
|
||||
* Проверяет число страниц без загрузки документа в docx4j: .docx
|
||||
* читается как zip напрямую (StAX по {@code word/document.xml},
|
||||
* всем {@code word/header*.xml}, {@code word/footer*.xml} и кэшу
|
||||
* {@code docProps/app.xml}). Дешёвый путь для проверки байтов из
|
||||
* сети/БД до любой работы с библиотекой.
|
||||
*
|
||||
* <p>Оценка согласована с {@link #checkPageCount(WordprocessingMLPackage)}
|
||||
* по всем источникам; на границе лимита оба пути дают одинаковый ответ
|
||||
* (регрессия — {@code checkPageCountLightweight_agreesWithJaxbPath},
|
||||
* включая 99/100/101 разрывов). Lightweight-путь дополнительно считает
|
||||
* разрывы в колонтитулах — он консервативнее, расхождение возможно
|
||||
* только в сторону завышения.
|
||||
*
|
||||
* @throws ConversionException при {@code null}, битом zip или превышении {@link #MAX_PAGES}
|
||||
*/
|
||||
public static void checkPageCountLightweight(Path docxIn) throws ConversionException {
|
||||
if (docxIn == null) {
|
||||
throw new ConversionException("Не указан путь к .docx");
|
||||
}
|
||||
if (!Files.isRegularFile(docxIn)) {
|
||||
throw new ConversionException("Файл не найден: " + docxIn);
|
||||
}
|
||||
int pages;
|
||||
try (ZipFile zip = new ZipFile(docxIn.toFile())) {
|
||||
List<String> headerFooter = new ArrayList<>();
|
||||
var entries = zip.entries();
|
||||
while (entries.hasMoreElements()) {
|
||||
String n = entries.nextElement().getName();
|
||||
if (isHeaderFooterPart(n)) {
|
||||
headerFooter.add(n);
|
||||
}
|
||||
}
|
||||
pages = pageCountOfZip(name -> {
|
||||
ZipEntry e = zip.getEntry(name);
|
||||
return e == null ? null : zip.getInputStream(e);
|
||||
}, headerFooter);
|
||||
} catch (IOException | RuntimeException e) {
|
||||
throw new ConversionException("Не удалось разобрать .docx: " + docxIn, e);
|
||||
}
|
||||
if (pages > MAX_PAGES) {
|
||||
throw new ConversionException("Документ длиннее " + MAX_PAGES
|
||||
+ " страниц: получено не менее " + pages);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* То же, что {@link #checkPageCountLightweight(Path)}, для байтов .docx.
|
||||
*
|
||||
* @throws ConversionException при {@code null}, битом zip или превышении лимита
|
||||
*/
|
||||
public static void checkPageCountLightweight(byte[] docxBytes) throws ConversionException {
|
||||
if (docxBytes == null) {
|
||||
throw new ConversionException("Не указаны байты входного .docx");
|
||||
}
|
||||
int pages;
|
||||
try (ZipInputStream zip = new ZipInputStream(new ByteArrayInputStream(docxBytes))) {
|
||||
java.util.Map<String, byte[]> parts = new java.util.HashMap<>();
|
||||
List<String> headerFooter = new ArrayList<>();
|
||||
ZipEntry entry;
|
||||
while ((entry = zip.getNextEntry()) != null) {
|
||||
String n = entry.getName();
|
||||
if (n.equals("docProps/app.xml") || n.equals("word/document.xml")
|
||||
|| isHeaderFooterPart(n)) {
|
||||
parts.put(n, zip.readAllBytes());
|
||||
if (isHeaderFooterPart(n)) {
|
||||
headerFooter.add(n);
|
||||
}
|
||||
}
|
||||
}
|
||||
pages = pageCountOfZip(name -> {
|
||||
byte[] b = parts.get(name);
|
||||
return b == null ? null : new ByteArrayInputStream(b);
|
||||
}, headerFooter);
|
||||
} catch (IOException | RuntimeException e) {
|
||||
throw new ConversionException("Не удалось разобрать байты .docx", e);
|
||||
}
|
||||
if (pages > MAX_PAGES) {
|
||||
throw new ConversionException("Документ длиннее " + MAX_PAGES
|
||||
+ " страниц: получено не менее " + pages);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Считает страницы .docx в байтах и проверяет лимит.
|
||||
*
|
||||
* @throws ConversionException при {@code null}, ошибке загрузки или превышении лимита
|
||||
*/
|
||||
public static void checkPageCount(byte[] docxBytes) throws ConversionException {
|
||||
if (docxBytes == null) {
|
||||
throw new ConversionException("Не указаны байты входного .docx");
|
||||
}
|
||||
WordprocessingMLPackage pkg;
|
||||
try {
|
||||
pkg = WordprocessingMLPackage.load(new ByteArrayInputStream(docxBytes));
|
||||
} catch (Exception e) {
|
||||
throw new ConversionException("Не удалось разобрать байты .docx", e);
|
||||
}
|
||||
checkPageCount(pkg);
|
||||
}
|
||||
|
||||
/**
|
||||
* Считает страницы уже загруженного .docx и проверяет лимит.
|
||||
*
|
||||
* <p>Число страниц — максимум трёх нижних оценок:
|
||||
* <ol>
|
||||
* <li>Кэш Word в {@code docProps/app.xml} ({@code <Pages>}).
|
||||
* Сам по себе недостоверен: Word может сохранить устаревшее
|
||||
* значение (в регрессной фикстуре {@code stale-cache.docx}
|
||||
* кэш равен 1 при 110 границах страниц).</li>
|
||||
* <li>Явные разрывы: {@code w:br[@w:type='page']},
|
||||
* {@code w:pageBreakBefore} и {@code w:sectPr} прямо в
|
||||
* {@code w:body}. Абзацы ищутся не только прямо в {@code w:body},
|
||||
* но и внутри таблиц, контентных контролов {@code w:sdt}
|
||||
* (Word держит нумерацию именно в контентном контроле) и
|
||||
* прочего содержимого, реализующего {@link ContentAccessor}.</li>
|
||||
* <li>Маркеры {@code w:lastRenderedPageBreak} — границы страниц,
|
||||
* которые Word записал при последнем рендере. Единственный
|
||||
* источник оценки для документов без явных разрывов, порванных
|
||||
* по заполнению.</li>
|
||||
* </ol>
|
||||
*
|
||||
* <p>Оценка остаётся нижней: документ без явных разрывов и без
|
||||
* маркеров (никогда не открывался в Word) оценивается в 1 страницу
|
||||
* независимо от фактической длины — такие документы лимит не отсекают.
|
||||
*
|
||||
* @throws ConversionException при превышении {@link #MAX_PAGES}
|
||||
*/
|
||||
public static void checkPageCount(WordprocessingMLPackage pkg) throws ConversionException {
|
||||
if (pkg == null) {
|
||||
throw new ConversionException("Не указан загруженный .docx");
|
||||
}
|
||||
int pages = pageCountOf(pkg);
|
||||
if (pages > MAX_PAGES) {
|
||||
throw new ConversionException("Документ длиннее " + MAX_PAGES
|
||||
+ " страниц: получено не менее " + pages);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Возвращает число страниц: максимум кэша {@code <Pages>}, оценки по
|
||||
* явным разрывам и оценки по {@code w:lastRenderedPageBreak}.
|
||||
* Виден только из тестов и пакета.
|
||||
*/
|
||||
static int pageCountOf(WordprocessingMLPackage pkg) {
|
||||
int cached = 0;
|
||||
try {
|
||||
if (pkg.getDocPropsExtendedPart() != null) {
|
||||
org.docx4j.docProps.extended.Properties ext =
|
||||
pkg.getDocPropsExtendedPart().getContents();
|
||||
if (ext != null && ext.getPages() != null && ext.getPages() > 0) {
|
||||
cached = ext.getPages();
|
||||
}
|
||||
}
|
||||
} catch (Exception ignored) {
|
||||
// docPropsExtended может быть не полностью инициализирован —
|
||||
// тогда остаётся оценка по разрывам.
|
||||
}
|
||||
var body = pkg.getMainDocumentPart().getJaxbElement().getBody();
|
||||
var content = body.getContent();
|
||||
int explicit = 1; // сам документ — минимум одна страница
|
||||
for (Object child : content) {
|
||||
// В JAXB-модели в body.getContent() лежат только межсекционные
|
||||
// sectPr; финальная секция — в body.getSectPr(), её здесь нет.
|
||||
if (child instanceof SectPr sect && startsNewPage(sect)) {
|
||||
explicit++;
|
||||
}
|
||||
}
|
||||
explicit += walkForPageBreaks(content);
|
||||
int lastRendered = countLastRendered(content);
|
||||
return Math.max(Math.max(cached, explicit), lastRendered + 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Обход содержимого на явные разрывы: абзацы ищутся рекурсивно —
|
||||
* прямо в {@code w:body}, в ячейках таблиц, в контентных контролах
|
||||
* {@code w:sdt} и прочем содержимом, реализующем {@link ContentAccessor}.
|
||||
* Элементы модели приходят и напрямую, и обёрнутыми в
|
||||
* {@link JAXBElement} (например {@code w:tbl} в {@code w:body}) —
|
||||
* обёртка раскрывается через {@link #unwrap}.
|
||||
* Считаются {@code w:br type="page"} и {@code pageBreakBefore}
|
||||
* (по одному на абзац), как и в lightweight-пути.
|
||||
*/
|
||||
private static int walkForPageBreaks(List<?> content) {
|
||||
int count = 0;
|
||||
for (Object raw : content) {
|
||||
Object item = unwrap(raw);
|
||||
if (item instanceof P p) {
|
||||
if (p.getPPr() != null
|
||||
&& p.getPPr().getPageBreakBefore() != null
|
||||
&& p.getPPr().getPageBreakBefore().isVal()) {
|
||||
count++;
|
||||
}
|
||||
for (Object runChild : p.getContent()) {
|
||||
if (unwrap(runChild) instanceof org.docx4j.wml.R r) {
|
||||
for (Object innerRaw : r.getContent()) {
|
||||
if (unwrap(innerRaw) instanceof Br br
|
||||
&& br.getType() == STBrType.PAGE) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if (item instanceof ContentAccessor ca) {
|
||||
// w:tbl / w:tr / w:tc / w:sdt / w:sdtContent и т.п.
|
||||
count += walkForPageBreaks(ca.getContent());
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
/** Подсчёт маркеров {@code w:lastRenderedPageBreak} в содержимом. */
|
||||
private static int countLastRendered(List<?> content) {
|
||||
int count = 0;
|
||||
for (Object raw : content) {
|
||||
Object item = unwrap(raw);
|
||||
if (item instanceof R.LastRenderedPageBreak) {
|
||||
count++;
|
||||
} else if (item instanceof ContentAccessor ca) {
|
||||
count += countLastRendered(ca.getContent());
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
/** Раскрывает обёртку {@link JAXBElement} (docx4j так отдаёт tbl и часть содержимого). */
|
||||
private static Object unwrap(Object item) {
|
||||
return item instanceof JAXBElement<?> je ? je.getValue() : item;
|
||||
}
|
||||
|
||||
/** Секция, начинающая новую страницу (continuous — нет). */
|
||||
private static boolean startsNewPage(SectPr sect) {
|
||||
return sect.getType() == null
|
||||
|| sect.getType().getVal() == null
|
||||
|| !sect.getType().getVal().equals("continuous");
|
||||
}
|
||||
|
||||
/** Поставщик потока по имени части zip; null — части нет. */
|
||||
private interface PartStream {
|
||||
InputStream open(String name) throws IOException;
|
||||
}
|
||||
|
||||
/** {@code word/headerN.xml} / {@code word/footerN.xml} (не .rels). */
|
||||
private static boolean isHeaderFooterPart(String name) {
|
||||
return (name.startsWith("word/header") || name.startsWith("word/footer"))
|
||||
&& name.endsWith(".xml");
|
||||
}
|
||||
|
||||
/**
|
||||
* Лёгкий расчёт числа страниц прямо по zip-пакету .docx, без docx4j.
|
||||
* Та же логика, что у {@link #pageCountOf(WordprocessingMLPackage)}:
|
||||
* максимум кэша {@code docProps/app.xml <Pages>}, явных разрывов и
|
||||
* {@code w:lastRenderedPageBreak}. Считаются все колонтитулы
|
||||
* ({@code word/header*.xml}, {@code word/footer*.xml}) — там Word тоже
|
||||
* держит {@code w:br type="page"}.
|
||||
*/
|
||||
private static int pageCountOfZip(PartStream parts, List<String> headerFooterParts)
|
||||
throws IOException {
|
||||
int cached = cachedPageCount(parts.open("docProps/app.xml"));
|
||||
BreakScan scan = scanDocument(parts.open("word/document.xml"));
|
||||
int explicit = 1 + scan.breaks(); // сам документ — минимум одна страница
|
||||
for (String part : headerFooterParts) {
|
||||
explicit += countBreaksInFlat(parts.open(part));
|
||||
}
|
||||
return Math.max(Math.max(cached, explicit), scan.lastRendered() + 1);
|
||||
}
|
||||
|
||||
/** Результат разбора word/document.xml: явные разрывы и маркеры. */
|
||||
private record BreakScan(int breaks, int lastRendered) {
|
||||
}
|
||||
|
||||
/** Кэш Word <Pages> из docProps/app.xml; 0 — части/значения нет. */
|
||||
private static int cachedPageCount(InputStream in) throws IOException {
|
||||
if (in == null) {
|
||||
return 0;
|
||||
}
|
||||
try {
|
||||
XMLStreamReader xr = newSecureReader().createXMLStreamReader(in);
|
||||
while (xr.hasNext()) {
|
||||
if (xr.next() == XMLStreamReader.START_ELEMENT
|
||||
&& xr.getLocalName().equals("Pages")) {
|
||||
String text = xr.getElementText().trim();
|
||||
return Math.max(0, Integer.parseInt(text));
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
} catch (XMLStreamException | NumberFormatException e) {
|
||||
return 0;
|
||||
} finally {
|
||||
in.close();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Нижняя оценка по {@code word/document.xml}: {@code w:br type="page"},
|
||||
* {@code w:pageBreakBefore}, {@code w:sectPr} прямо в {@code body} и
|
||||
* маркеры {@code w:lastRenderedPageBreak}. Обход плоский (StAX),
|
||||
* вложенность не нужна — считаем события.
|
||||
*
|
||||
* <p>Согласованность с JAXB-путём:
|
||||
* <ul>
|
||||
* <li>{@code sectPr} внутри {@code pPr} не считается: в StAX-виде
|
||||
* там и финальная секция, и межсекционные — неразличимы, а
|
||||
* JAXB-путь их не видит (в {@code body.getContent()} лежат только
|
||||
* межсекционные). Такие документы покрываются кэшем
|
||||
* {@code <Pages>} и маркерами {@code lastRenderedPageBreak};</li>
|
||||
* <li>{@code sectPr} прямо в {@code body}: в StAX-виде их на один
|
||||
* больше, чем в JAXB-виде (финальная секция — это JAXB
|
||||
* {@code body.getSectPr()}, вне {@code getContent()}), поэтому
|
||||
* последнюю не считаем, а среди остальных считаем только
|
||||
* начинающие новую страницу;</li>
|
||||
* <li>непрерывные секции ({@code type="continuous"}) не считаются —
|
||||
* ровно как в JAXB-пути, где их отсекает {@code startsNewPage}.</li>
|
||||
* </ul>
|
||||
*/
|
||||
private static BreakScan scanDocument(InputStream in) throws IOException {
|
||||
if (in == null) {
|
||||
return new BreakScan(0, 0);
|
||||
}
|
||||
int breaks = 0;
|
||||
int lastRendered = 0;
|
||||
int bodyDirectSectPr = 0;
|
||||
// w:type — ДОЧЕРНИЙ элемент (<w:type w:val="continuous"/>), а не
|
||||
// атрибут sectPr, поэтому body-direct секция классифицируется на
|
||||
// её закрытии; последняя body-direct — финальная секция, не
|
||||
// считается, так что при закрытии новой секции считаем предыдущую
|
||||
boolean inBodySectPr = false;
|
||||
String sectTypeVal = null;
|
||||
boolean pendingNewPageSection = false;
|
||||
try {
|
||||
XMLStreamReader xr = newSecureReader().createXMLStreamReader(in);
|
||||
// стек имён START_ELEMENT: «внутри ли w:p/w:pPr/sectPr» и
|
||||
// родитель текущего элемента (для sectPr).
|
||||
Deque<String> path = new ArrayDeque<>();
|
||||
while (xr.hasNext()) {
|
||||
int ev = xr.next();
|
||||
if (ev == XMLStreamReader.START_ELEMENT) {
|
||||
String name = xr.getLocalName();
|
||||
String parent = path.peek();
|
||||
path.push(name);
|
||||
switch (name) {
|
||||
case "br" -> {
|
||||
if (isPageBreak(xr) && inside(path, "p")) {
|
||||
breaks++;
|
||||
}
|
||||
}
|
||||
case "lastRenderedPageBreak" -> {
|
||||
if (inside(path, "p")) {
|
||||
lastRendered++;
|
||||
}
|
||||
}
|
||||
case "pageBreakBefore" -> {
|
||||
if (truthy(xr) && inside(path, "pPr") && !inside(path, "sectPr")) {
|
||||
breaks++;
|
||||
}
|
||||
}
|
||||
case "sectPr" -> {
|
||||
if ("body".equals(parent)) {
|
||||
inBodySectPr = true;
|
||||
sectTypeVal = null;
|
||||
}
|
||||
// sectPr внутри pPr — не считаем (StAX не
|
||||
// различает финальную и межсекционные)
|
||||
}
|
||||
case "type" -> {
|
||||
if (inBodySectPr && "sectPr".equals(parent)) {
|
||||
sectTypeVal = xr.getAttributeValue(WML_NS, "val");
|
||||
}
|
||||
}
|
||||
default -> {
|
||||
}
|
||||
}
|
||||
} else if (ev == XMLStreamReader.END_ELEMENT) {
|
||||
if ("sectPr".equals(xr.getLocalName()) && inBodySectPr) {
|
||||
if (pendingNewPageSection) {
|
||||
bodyDirectSectPr++;
|
||||
}
|
||||
pendingNewPageSection =
|
||||
!"continuous".equals(sectTypeVal);
|
||||
inBodySectPr = false;
|
||||
}
|
||||
if (!path.isEmpty()) {
|
||||
path.pop();
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (XMLStreamException e) {
|
||||
throw new IOException("Некорректный XML в word/document.xml", e);
|
||||
} finally {
|
||||
in.close();
|
||||
}
|
||||
// последняя body-direct секция не внесена — это финальная секция
|
||||
breaks += bodyDirectSectPr;
|
||||
return new BreakScan(breaks, lastRendered);
|
||||
}
|
||||
|
||||
/** Оценка по колонтитулам: только {@code w:br type="page"} (там нет body/sectPr). */
|
||||
private static int countBreaksInFlat(InputStream in) throws IOException {
|
||||
if (in == null) {
|
||||
return 0;
|
||||
}
|
||||
int count = 0;
|
||||
try {
|
||||
XMLStreamReader xr = newSecureReader().createXMLStreamReader(in);
|
||||
while (xr.hasNext()) {
|
||||
if (xr.next() == XMLStreamReader.START_ELEMENT
|
||||
&& xr.getLocalName().equals("br") && isPageBreak(xr)) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
} catch (XMLStreamException e) {
|
||||
throw new IOException("Некорректный XML в колонтитуле", e);
|
||||
} finally {
|
||||
in.close();
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
private static XMLInputFactory newSecureReader() {
|
||||
XMLInputFactory f = XMLInputFactory.newInstance();
|
||||
f.setProperty(XMLInputFactory.SUPPORT_DTD, false);
|
||||
f.setProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, false);
|
||||
return f;
|
||||
}
|
||||
|
||||
private static boolean isPageBreak(XMLStreamReader xr) {
|
||||
return "page".equals(xr.getAttributeValue(WML_NS, "type"));
|
||||
}
|
||||
|
||||
private static boolean truthy(XMLStreamReader xr) {
|
||||
String v = xr.getAttributeValue(WML_NS, "val");
|
||||
return v == null || v.equals("true") || v.equals("1") || v.equals("on");
|
||||
}
|
||||
|
||||
private static boolean inside(Deque<String> path, String ancestor) {
|
||||
return path.contains(ancestor);
|
||||
}
|
||||
|
||||
private static final String WML_NS =
|
||||
"http://schemas.openxmlformats.org/wordprocessingml/2006/main";
|
||||
}
|
||||
@@ -27,6 +27,7 @@ import javax.imageio.ImageIO;
|
||||
import java.awt.Color;
|
||||
import java.awt.Graphics2D;
|
||||
import java.awt.image.BufferedImage;
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.File;
|
||||
import java.io.FileOutputStream;
|
||||
@@ -68,6 +69,8 @@ public final class SampleDocxGenerator {
|
||||
symbolBullets(dir.resolve("symbol-bullets.docx"));
|
||||
pageNumbers(dir.resolve("page-numbers.docx"));
|
||||
exoticGlyphs(dir.resolve("exotic-glyphs.docx"));
|
||||
tooManyPages(dir.resolve("too-many-pages.docx"));
|
||||
staleCache(dir.resolve("stale-cache.docx"));
|
||||
|
||||
System.out.println("Готово: " + dir.toAbsolutePath());
|
||||
}
|
||||
@@ -326,6 +329,108 @@ public final class SampleDocxGenerator {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Документ длиннее лимита страниц: 150 абзацев с принудительным
|
||||
* {@code w:br type="page"} → нижняя оценка по явным разрывам
|
||||
* = 1 + 150 = 151 > 100. Используется как фикстура для проверки
|
||||
* постраничного лимита в {@code WordPdfValidator}.
|
||||
*/
|
||||
private static void tooManyPages(Path out) throws Exception {
|
||||
try (XWPFDocument doc = new XWPFDocument()) {
|
||||
heading(doc, "Слишком много страниц", "Times New Roman");
|
||||
for (int i = 1; i <= 150; i++) {
|
||||
XWPFParagraph p = doc.createParagraph();
|
||||
run(p, "Страница " + i, "Times New Roman", false, false);
|
||||
p.createRun().addBreak(org.apache.poi.xwpf.usermodel.BreakType.PAGE);
|
||||
}
|
||||
save(doc, out);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Документ с устаревшим кэшем страниц — как Word сохраняет файл,
|
||||
* доработанный другим редактором: 111 абзацев, разделённых маркерами
|
||||
* {@code w:lastRenderedPageBreak} (110 границ страниц, то есть
|
||||
* ~111 страница), и при этом в {@code docProps/app.xml} записан кэш
|
||||
* {@code <Pages>1</Pages>}. Явных разрывов нет ни одного.
|
||||
*
|
||||
* <p>Регрессия для {@code WordPdfValidator}: кэш больше не приоритетный
|
||||
* источник, оценка по маркерам (111) должна победить кэш (1) и
|
||||
* документ должен быть отвергнут до рендера.
|
||||
*/
|
||||
private static void staleCache(Path out) throws Exception {
|
||||
try (XWPFDocument doc = new XWPFDocument()) {
|
||||
doc.getProperties().getExtendedProperties()
|
||||
.getUnderlyingProperties().setPages(1);
|
||||
heading(doc, "Устаревший кэш страниц", "Calibri");
|
||||
for (int i = 1; i <= 110; i++) {
|
||||
XWPFParagraph p = doc.createParagraph();
|
||||
run(p, "Абзац " + i, "Calibri", false, false);
|
||||
}
|
||||
ByteArrayOutputStream bos = new ByteArrayOutputStream();
|
||||
doc.write(bos);
|
||||
insertLastRenderedMarkers(bos.toByteArray(), out);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Переупаковывает .docx, вставляя {@code w:lastRenderedPageBreak}
|
||||
* перед каждым текстовым тегом {@code w:t} в {@code word/document.xml},
|
||||
* кроме первых {@value #STALE_CACHE_UNMARKED_RUNS} (первый абзац
|
||||
* остаётся без маркера). Тег ищется точно ({@code <w:t>} /
|
||||
* {@code <w:t }): префикс {@code <w:t} — это также {@code w:tab},
|
||||
* {@code w:tbl}, {@code w:tc}, маркеры в которые недопустимы по схеме
|
||||
* (вне CT_R → невалидный docx). Позиция корректна по схеме CT_R:
|
||||
* rPr, затем маркер, затем текст.
|
||||
*/
|
||||
private static void insertLastRenderedMarkers(byte[] docx, Path out) throws Exception {
|
||||
final int unmarked = STALE_CACHE_UNMARKED_RUNS;
|
||||
try (java.util.zip.ZipInputStream zin =
|
||||
new java.util.zip.ZipInputStream(new ByteArrayInputStream(docx));
|
||||
java.util.zip.ZipOutputStream zout =
|
||||
new java.util.zip.ZipOutputStream(new FileOutputStream(out.toFile()))) {
|
||||
java.util.zip.ZipEntry e;
|
||||
while ((e = zin.getNextEntry()) != null) {
|
||||
byte[] data = zin.readAllBytes();
|
||||
if (e.getName().equals("word/document.xml")) {
|
||||
String xml = new String(data, java.nio.charset.StandardCharsets.UTF_8);
|
||||
StringBuilder sb = new StringBuilder(xml.length() + 4096);
|
||||
int i = 0;
|
||||
int seen = 0;
|
||||
while (true) {
|
||||
int at = xml.indexOf("<w:t", i);
|
||||
if (at < 0) {
|
||||
sb.append(xml, i, xml.length());
|
||||
break;
|
||||
}
|
||||
sb.append(xml, i, at);
|
||||
int end = at + "<w:t".length();
|
||||
char next = end < xml.length() ? xml.charAt(end) : '<';
|
||||
if (next != '>' && next != ' ') {
|
||||
// <w:tab/<w:tbl/<w:tc/... — не текстовый тег
|
||||
sb.append(xml, at, end);
|
||||
i = end;
|
||||
continue;
|
||||
}
|
||||
if (seen >= unmarked) {
|
||||
sb.append("<w:lastRenderedPageBreak/>");
|
||||
}
|
||||
seen++;
|
||||
sb.append(xml, at, end);
|
||||
i = end;
|
||||
}
|
||||
data = sb.toString().getBytes(java.nio.charset.StandardCharsets.UTF_8);
|
||||
}
|
||||
zout.putNextEntry(new java.util.zip.ZipEntry(e.getName()));
|
||||
zout.write(data);
|
||||
zout.closeEntry();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Сколько {@code w:t} в фикстуре stale-cache остаются без маркера. */
|
||||
private static final int STALE_CACHE_UNMARKED_RUNS = 1;
|
||||
|
||||
// ================== Вспомогательные ==================
|
||||
|
||||
/** Абзац-заголовок: POI 5.5 не имеет createHeading, поэтому
|
||||
|
||||
@@ -378,4 +378,74 @@ class WordPdfConverterTest {
|
||||
assertEquals(expected, out);
|
||||
assertTrue(Files.isRegularFile(out), "PDF не создан: " + out);
|
||||
}
|
||||
|
||||
/**
|
||||
* Лимит на размер входного .docx: больше 5 MiB — отказ до рендера.
|
||||
* Проверяется через обе формы convert.
|
||||
*/
|
||||
@Test
|
||||
void inputTooLarge() throws Exception {
|
||||
Path tooBig = Files.createTempFile("too-big-", ".docx");
|
||||
Path out = Files.createTempFile("too-big-out-", ".pdf");
|
||||
try {
|
||||
// Пишем чуть больше лимита (5 MiB + 1 байт)
|
||||
byte[] filler = new byte[(int) WordPdfValidator.MAX_INPUT_BYTES + 1];
|
||||
Files.write(tooBig, filler);
|
||||
|
||||
assertThrows(ConversionException.class,
|
||||
() -> WordPdfConverter.convert(tooBig));
|
||||
assertFalse(Files.exists(Path.of(
|
||||
tooBig.toString().replaceFirst("\\.docx$", "") + ".pdf")),
|
||||
"отказ по размеру не должен создавать PDF рядом со входом");
|
||||
|
||||
assertThrows(ConversionException.class,
|
||||
() -> WordPdfConverter.convert(tooBig, out));
|
||||
assertEquals(0L, Files.size(out),
|
||||
"отказ по размеру — до открытия потока вывода, "
|
||||
+ "выходной файл не должен быть затронут");
|
||||
} finally {
|
||||
Files.deleteIfExists(tooBig);
|
||||
Files.deleteIfExists(out);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Лимит на число страниц: документ с 150 явными разрывами страниц
|
||||
* (фикстура too-many-pages.docx, нижняя оценка 151) должен
|
||||
* отвергаться до рендеринга. PDF не создаётся — в том числе пустой
|
||||
* файл-артефакт от уже открытого потока вывода.
|
||||
*/
|
||||
@Test
|
||||
void tooManyPages() throws Exception {
|
||||
Path in = extractSample("too-many-pages.docx");
|
||||
Path out = Files.createTempFile("too-many-out-", ".pdf");
|
||||
Files.deleteIfExists(out);
|
||||
|
||||
ConversionException ex = assertThrows(ConversionException.class,
|
||||
() -> WordPdfConverter.convert(in, out));
|
||||
assertTrue(ex.getMessage().contains("100"),
|
||||
"сообщение должно упоминать лимит: " + ex.getMessage());
|
||||
assertFalse(Files.exists(out),
|
||||
"отказ по страницам не должен оставлять PDF: " + out);
|
||||
}
|
||||
|
||||
/**
|
||||
* Документ с устаревшим кэшем {@code <Pages>1</Pages>} и 110 маркерами
|
||||
* {@code w:lastRenderedPageBreak} (фикстура stale-cache.docx — модель
|
||||
* реального документа пользователя «110 страниц.docx»): конвертер
|
||||
* обязан отвергнуть его до рендера и не оставить PDF.
|
||||
*/
|
||||
@Test
|
||||
void staleCachePageCountRejectedBeforeRender() throws Exception {
|
||||
Path in = extractSample("stale-cache.docx");
|
||||
Path out = Files.createTempFile("stale-cache-out-", ".pdf");
|
||||
Files.deleteIfExists(out);
|
||||
|
||||
ConversionException ex = assertThrows(ConversionException.class,
|
||||
() -> WordPdfConverter.convert(in, out));
|
||||
assertTrue(ex.getMessage().contains("100"),
|
||||
"сообщение должно упоминать лимит: " + ex.getMessage());
|
||||
assertFalse(Files.exists(out),
|
||||
"отказ по страницам не должен оставлять PDF: " + out);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,353 @@
|
||||
package ru.pjandro.wordpdf;
|
||||
|
||||
import org.apache.poi.xwpf.usermodel.BreakType;
|
||||
import org.apache.poi.xwpf.usermodel.XWPFDocument;
|
||||
import org.apache.poi.xwpf.usermodel.XWPFParagraph;
|
||||
import org.apache.poi.xwpf.usermodel.XWPFTable;
|
||||
import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
/**
|
||||
* Юнит-тесты валидатора: размер (Path и byte[]) и число страниц
|
||||
* (Path, byte[] и уже загруженный пакет).
|
||||
*/
|
||||
class WordPdfValidatorTest {
|
||||
|
||||
private static Path bigDocx(long size) throws IOException {
|
||||
Path tmp = Files.createTempFile("validator-", ".docx");
|
||||
Files.write(tmp, new byte[(int) size]);
|
||||
return tmp;
|
||||
}
|
||||
|
||||
private static byte[] docxWithPageBreaks(int count) throws Exception {
|
||||
try (XWPFDocument doc = new XWPFDocument()) {
|
||||
for (int i = 0; i < count; i++) {
|
||||
XWPFParagraph p = doc.createParagraph();
|
||||
p.createRun().setText("p" + i);
|
||||
p.createRun().addBreak(BreakType.PAGE);
|
||||
}
|
||||
ByteArrayOutputStream bos = new ByteArrayOutputStream();
|
||||
doc.write(bos);
|
||||
return bos.toByteArray();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void checkInput_pathWithinLimit() throws IOException {
|
||||
Path p = bigDocx(1024);
|
||||
try {
|
||||
assertDoesNotThrow(() -> WordPdfValidator.checkInput(p));
|
||||
} finally {
|
||||
Files.deleteIfExists(p);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void checkInput_pathOverLimit() throws IOException {
|
||||
Path p = bigDocx(WordPdfValidator.MAX_INPUT_BYTES + 1);
|
||||
try {
|
||||
ConversionException ex = assertThrows(ConversionException.class,
|
||||
() -> WordPdfValidator.checkInput(p));
|
||||
assertTrue(ex.getMessage().contains("5 МБ"),
|
||||
"сообщение должно упоминать лимит: " + ex.getMessage());
|
||||
} finally {
|
||||
Files.deleteIfExists(p);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void checkInput_pathNull() {
|
||||
assertThrows(ConversionException.class,
|
||||
() -> WordPdfValidator.checkInput((Path) null));
|
||||
}
|
||||
|
||||
@Test
|
||||
void checkInput_bytesWithinLimit() {
|
||||
assertDoesNotThrow(() ->
|
||||
WordPdfValidator.checkInput(new byte[1024]));
|
||||
}
|
||||
|
||||
@Test
|
||||
void checkInput_bytesOverLimit() {
|
||||
byte[] big = new byte[(int) WordPdfValidator.MAX_INPUT_BYTES + 1];
|
||||
ConversionException ex = assertThrows(ConversionException.class,
|
||||
() -> WordPdfValidator.checkInput(big));
|
||||
assertTrue(ex.getMessage().contains("5 МБ"),
|
||||
"сообщение должно упоминать лимит: " + ex.getMessage());
|
||||
}
|
||||
|
||||
@Test
|
||||
void checkInput_bytesNull() {
|
||||
assertThrows(ConversionException.class,
|
||||
() -> WordPdfValidator.checkInput((byte[]) null));
|
||||
}
|
||||
|
||||
@Test
|
||||
void checkPageCount_pkgWithinLimit() throws Exception {
|
||||
byte[] bytes = docxWithPageBreaks(5); // 1 + 5 = 6 страниц по оценке
|
||||
WordprocessingMLPackage pkg = WordprocessingMLPackage.load(
|
||||
new java.io.ByteArrayInputStream(bytes));
|
||||
assertDoesNotThrow(() -> WordPdfValidator.checkPageCount(pkg));
|
||||
}
|
||||
|
||||
@Test
|
||||
void checkPageCount_pkgOverLimit() throws Exception {
|
||||
byte[] bytes = docxWithPageBreaks(120); // 1 + 120 = 121
|
||||
WordprocessingMLPackage pkg = WordprocessingMLPackage.load(
|
||||
new java.io.ByteArrayInputStream(bytes));
|
||||
ConversionException ex = assertThrows(ConversionException.class,
|
||||
() -> WordPdfValidator.checkPageCount(pkg));
|
||||
assertTrue(ex.getMessage().contains("100"),
|
||||
"сообщение должно упоминать лимит: " + ex.getMessage());
|
||||
}
|
||||
|
||||
@Test
|
||||
void checkPageCount_bytesOverLimit() throws Exception {
|
||||
byte[] bytes = docxWithPageBreaks(120);
|
||||
ConversionException ex = assertThrows(ConversionException.class,
|
||||
() -> WordPdfValidator.checkPageCount(bytes));
|
||||
assertTrue(ex.getMessage().contains("100"),
|
||||
"сообщение должно упоминать лимит: " + ex.getMessage());
|
||||
}
|
||||
|
||||
@Test
|
||||
void checkPageCount_bytesNull() {
|
||||
assertThrows(ConversionException.class,
|
||||
() -> WordPdfValidator.checkPageCount((byte[]) null));
|
||||
}
|
||||
|
||||
@Test
|
||||
void checkPageCount_pkgNull() {
|
||||
assertThrows(ConversionException.class,
|
||||
() -> WordPdfValidator.checkPageCount((WordprocessingMLPackage) null));
|
||||
}
|
||||
|
||||
// ---- lightweight (zip/StAX, без docx4j) ----
|
||||
|
||||
@Test
|
||||
void checkPageCountLightweight_bytesWithinLimit() throws Exception {
|
||||
byte[] bytes = docxWithPageBreaks(5);
|
||||
assertDoesNotThrow(() -> WordPdfValidator.checkPageCountLightweight(bytes));
|
||||
}
|
||||
|
||||
@Test
|
||||
void checkPageCountLightweight_bytesOverLimit() throws Exception {
|
||||
byte[] bytes = docxWithPageBreaks(120);
|
||||
ConversionException ex = assertThrows(ConversionException.class,
|
||||
() -> WordPdfValidator.checkPageCountLightweight(bytes));
|
||||
assertTrue(ex.getMessage().contains("100"),
|
||||
"сообщение должно упоминать лимит: " + ex.getMessage());
|
||||
}
|
||||
|
||||
@Test
|
||||
void checkPageCountLightweight_pathOverLimit() throws Exception {
|
||||
Path tmp = Files.createTempFile("validator-lw-", ".docx");
|
||||
Files.write(tmp, docxWithPageBreaks(120));
|
||||
try {
|
||||
ConversionException ex = assertThrows(ConversionException.class,
|
||||
() -> WordPdfValidator.checkPageCountLightweight(tmp));
|
||||
assertTrue(ex.getMessage().contains("100"),
|
||||
"сообщение должно упоминать лимит: " + ex.getMessage());
|
||||
} finally {
|
||||
Files.deleteIfExists(tmp);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void checkPageCountLightweight_agreesWithJaxbPath() throws Exception {
|
||||
// на фикстурах без кэша Pages оба пути обязаны совпадать,
|
||||
// включая границу лимита: 99 разрывов = 100 страниц (проходит),
|
||||
// 100/101 = 101/102 (отказ)
|
||||
for (int breaks : new int[]{0, 3, 99, 100, 101}) {
|
||||
byte[] bytes = docxWithPageBreaks(breaks);
|
||||
WordprocessingMLPackage pkg = WordprocessingMLPackage.load(
|
||||
new java.io.ByteArrayInputStream(bytes));
|
||||
int jaxb = WordPdfValidator.pageCountOf(pkg);
|
||||
// lightweight-путь приватный; проверяем через границу лимита:
|
||||
// 1+breaks совпадает с оценкой JAXB
|
||||
assertEquals(1 + breaks, jaxb, "JAXB-оценка для " + breaks + " разрывов");
|
||||
if (breaks < 100) {
|
||||
assertDoesNotThrow(() -> WordPdfValidator.checkPageCountLightweight(bytes));
|
||||
} else {
|
||||
ConversionException ex = assertThrows(ConversionException.class,
|
||||
() -> WordPdfValidator.checkPageCountLightweight(bytes));
|
||||
assertTrue(ex.getMessage().contains("не менее " + (1 + breaks)),
|
||||
"оценка lightweight должна совпадать с JAXB: " + ex.getMessage());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Секция {@code type="continuous"} по OOXML новую страницу не
|
||||
* начинает — lightweight-путь (zip/StAX) не обязан её считать, а
|
||||
* последняя body-direct секция (финальная) не считается никогда.
|
||||
* Случай A: 100 {@code nextPage} + финальная {@code continuous} —
|
||||
* 101 страница, отказ (старый код считал «все минус одна» без
|
||||
* учёта типа: 101−1=100 и пропускал). Случай B: 101
|
||||
* {@code continuous} + финальная {@code nextPage} — 1 страница,
|
||||
* проходит (старый код раздувал до 102 и отвергал). В JAXB-модели
|
||||
* body-direct sectPr не видны (docx4j оставляет только финальную
|
||||
* в {@code body.getSectPr()}, {@code getContent()} пуст), поэтому
|
||||
* расхождение lightweight здесь — допустимое завышение.
|
||||
* Регрессия — WordPdfValidator#scanDocument.
|
||||
*/
|
||||
@Test
|
||||
void pageCount_continuousSectionsNotCountedLightweight() throws Exception {
|
||||
java.util.List<String> typesA = new java.util.ArrayList<>();
|
||||
for (int i = 0; i < 100; i++) {
|
||||
typesA.add("nextPage");
|
||||
}
|
||||
typesA.add("continuous"); // финальная секция — непрерывная
|
||||
byte[] overLimit = docxWithBodySections(typesA);
|
||||
ConversionException exLwA = assertThrows(ConversionException.class,
|
||||
() -> WordPdfValidator.checkPageCountLightweight(overLimit));
|
||||
assertTrue(exLwA.getMessage().contains("не менее 101"),
|
||||
"оценка = 1 + 100 межсекционных nextPage: " + exLwA.getMessage());
|
||||
|
||||
java.util.List<String> typesB = new java.util.ArrayList<>();
|
||||
for (int i = 0; i < 101; i++) {
|
||||
typesB.add("continuous");
|
||||
}
|
||||
typesB.add("nextPage"); // финальная секция
|
||||
byte[] ok = docxWithBodySections(typesB);
|
||||
assertDoesNotThrow(() -> WordPdfValidator.checkPageCountLightweight(ok),
|
||||
"continuous-границы не страницы");
|
||||
}
|
||||
|
||||
/**
|
||||
* docx от POI, в {@code word/document.xml} которого перед закрытием
|
||||
* {@code w:body} вставлены {@code w:sectPr} прямо в {@code body} с
|
||||
* указанными {@code w:type} (последняя из них — финальная секция;
|
||||
* POI сам финальный sectPr не пишет).
|
||||
*/
|
||||
private static byte[] docxWithBodySections(java.util.List<String> types)
|
||||
throws Exception {
|
||||
byte[] base = docxWithPageBreaks(0);
|
||||
ByteArrayOutputStream out = new ByteArrayOutputStream();
|
||||
try (java.util.zip.ZipInputStream zin = new java.util.zip.ZipInputStream(
|
||||
new java.io.ByteArrayInputStream(base));
|
||||
java.util.zip.ZipOutputStream zout = new java.util.zip.ZipOutputStream(out)) {
|
||||
java.util.zip.ZipEntry e;
|
||||
while ((e = zin.getNextEntry()) != null) {
|
||||
byte[] data = zin.readAllBytes();
|
||||
if (e.getName().equals("word/document.xml")) {
|
||||
String xml = new String(data, java.nio.charset.StandardCharsets.UTF_8);
|
||||
StringBuilder sb = new StringBuilder();
|
||||
for (String t : types) {
|
||||
sb.append("<w:sectPr><w:type w:val=\"").append(t)
|
||||
.append("\"/></w:sectPr>");
|
||||
}
|
||||
// POI не пишет финальный sectPr — последняя вставленная
|
||||
// секция и есть финальная (в JAXB уйдёт в body.getSectPr());
|
||||
// пустой body сериализуется самозакрывающимся тегом
|
||||
int at = xml.indexOf("</w:body>");
|
||||
if (at >= 0) {
|
||||
xml = xml.substring(0, at) + sb + xml.substring(at);
|
||||
} else {
|
||||
at = xml.indexOf("<w:body/>");
|
||||
assertTrue(at >= 0, "в document.xml нет w:body");
|
||||
xml = xml.substring(0, at) + "<w:body>" + sb + "</w:body>"
|
||||
+ xml.substring(at + "<w:body/>".length());
|
||||
}
|
||||
data = xml.getBytes(java.nio.charset.StandardCharsets.UTF_8);
|
||||
}
|
||||
zout.putNextEntry(new java.util.zip.ZipEntry(e.getName()));
|
||||
zout.write(data);
|
||||
zout.closeEntry();
|
||||
}
|
||||
}
|
||||
return out.toByteArray();
|
||||
}
|
||||
|
||||
// ---- устаревший кэш <Pages> ----
|
||||
|
||||
private static byte[] staleCacheFixture() throws Exception {
|
||||
try (java.io.InputStream in = WordPdfValidatorTest.class.getClassLoader()
|
||||
.getResourceAsStream("samples/stale-cache.docx")) {
|
||||
assertNotNull(in, "Нет фикстуры samples/stale-cache.docx");
|
||||
return in.readAllBytes();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Кэш Word {@code <Pages>1</Pages>} в документе с 110 маркерами
|
||||
* {@code w:lastRenderedPageBreak}: кэш больше не приоритетный источник,
|
||||
* оценка по маркерам (111) обязана победить и документ — быть
|
||||
* отвергнутым. Это регрессия на реальном документе пользователя
|
||||
* («110 страниц.docx»: кэш 1, маркеров 110, явных разрывов 0).
|
||||
*/
|
||||
@Test
|
||||
void pageCount_staleCacheLosesToLastRenderedMarkers() throws Exception {
|
||||
byte[] bytes = staleCacheFixture();
|
||||
WordprocessingMLPackage pkg = WordprocessingMLPackage.load(
|
||||
new java.io.ByteArrayInputStream(bytes));
|
||||
assertEquals(111, WordPdfValidator.pageCountOf(pkg),
|
||||
"оценка = max(кэш 1, разрывы 1, маркеры 110+1)");
|
||||
ConversionException ex = assertThrows(ConversionException.class,
|
||||
() -> WordPdfValidator.checkPageCount(pkg));
|
||||
assertTrue(ex.getMessage().contains("100"), ex.getMessage());
|
||||
// lightweight-путь обязан согласовать тот же отказ
|
||||
assertThrows(ConversionException.class,
|
||||
() -> WordPdfValidator.checkPageCountLightweight(bytes));
|
||||
}
|
||||
|
||||
/**
|
||||
* Явные разрывы внутри таблиц и контентных контролов тоже считаются:
|
||||
* раньше обходил только прямой контент body, и документ с разрывами в
|
||||
* ячейках оценивался в 1 страницу.
|
||||
*/
|
||||
@Test
|
||||
void pageCount_breaksInsideTablesAreCounted() throws Exception {
|
||||
byte[] bytes;
|
||||
try (XWPFDocument doc = new XWPFDocument()) {
|
||||
XWPFTable table = doc.createTable(2, 1);
|
||||
for (int i = 0; i < 120; i++) {
|
||||
XWPFParagraph p = table.getRow(0).getCell(0).getParagraphs().get(0);
|
||||
p.createRun().setText("t" + i);
|
||||
p.createRun().addBreak(BreakType.PAGE);
|
||||
}
|
||||
java.io.ByteArrayOutputStream bos = new java.io.ByteArrayOutputStream();
|
||||
doc.write(bos);
|
||||
bytes = bos.toByteArray();
|
||||
}
|
||||
WordprocessingMLPackage pkg = WordprocessingMLPackage.load(
|
||||
new java.io.ByteArrayInputStream(bytes));
|
||||
assertEquals(121, WordPdfValidator.pageCountOf(pkg),
|
||||
"разрывы в ячейке таблицы должны считаться");
|
||||
assertThrows(ConversionException.class,
|
||||
() -> WordPdfValidator.checkPageCount(bytes));
|
||||
assertThrows(ConversionException.class,
|
||||
() -> WordPdfValidator.checkPageCountLightweight(bytes));
|
||||
}
|
||||
|
||||
@Test
|
||||
void checkPageCountLightweight_bytesNull() {
|
||||
assertThrows(ConversionException.class,
|
||||
() -> WordPdfValidator.checkPageCountLightweight((byte[]) null));
|
||||
}
|
||||
|
||||
@Test
|
||||
void checkPageCountLightweight_pathNull() {
|
||||
assertThrows(ConversionException.class,
|
||||
() -> WordPdfValidator.checkPageCountLightweight((Path) null));
|
||||
}
|
||||
|
||||
@Test
|
||||
void checkPageCountLightweight_notAZip() throws IOException {
|
||||
Path tmp = Files.createTempFile("validator-lw-bad-", ".docx");
|
||||
Files.write(tmp, "not a zip at all".getBytes());
|
||||
try {
|
||||
assertThrows(ConversionException.class,
|
||||
() -> WordPdfValidator.checkPageCountLightweight(tmp));
|
||||
} finally {
|
||||
Files.deleteIfExists(tmp);
|
||||
}
|
||||
}
|
||||
}
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Reference in New Issue
Block a user