diff --git a/wordpdf-core/pom.xml b/wordpdf-core/pom.xml
index 1b79aac..3774bb6 100644
--- a/wordpdf-core/pom.xml
+++ b/wordpdf-core/pom.xml
@@ -87,6 +87,37 @@
+
+
+ org.jacoco
+ jacoco-maven-plugin
+
+
+ check
+
+
+
+ BUNDLE
+
+
+ LINE
+ COVEREDRATIO
+ 0.90
+
+
+ BRANCH
+ COVEREDRATIO
+ 0.85
+
+
+
+
+
+
+
+
diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/CartesianPainter.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/CartesianPainter.java
index ae6a4f9..a8af367 100644
--- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/CartesianPainter.java
+++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/CartesianPainter.java
@@ -71,9 +71,14 @@ final class CartesianPainter {
for (double v = lo; v <= hi + unit / 2; v += unit) {
valLabels.add(ChartRenderer.formatValue(v, valAxis.numFmt));
}
+ // valAxis=null (в диаграмме нет c:valAx) — valStyle null: подписей оси значений
+ // нет, gutter остаётся одним отступом. Без guard textWidth бросал NPE на
+ // null-style. Регрессия — CartesianPainterTest#nullValAxisSkipsValueLabels.
double valGutter = 0;
- for (String l : valLabels) {
- valGutter = Math.max(valGutter, DrawMlText.textWidth(l, valStyle));
+ if (valStyle != null) {
+ for (String l : valLabels) {
+ valGutter = Math.max(valGutter, DrawMlText.textWidth(l, valStyle));
+ }
}
valGutter += 8; // auto-layout Word: отступ от подписей до области (Word-эмпирика)
diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfValidatorTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfValidatorTest.java
index c3432db..6fce498 100644
--- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfValidatorTest.java
+++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfValidatorTest.java
@@ -424,4 +424,127 @@ class WordPdfValidatorTest {
() -> WordPdfValidator.checkPageCount(docx, 3));
assertTrue(ex.getMessage().contains("не менее 4"), ex.getMessage());
}
+ // ---- ветви lightweight-сканера и контейнера ----
+
+ private static final String TRANSITIONAL_W =
+ "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+
+ private static byte[] rawDocx(java.util.Map parts) throws Exception {
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+ try (ZipOutputStream zos = new ZipOutputStream(out)) {
+ for (java.util.Map.Entry e : parts.entrySet()) {
+ zos.putNextEntry(new ZipEntry(e.getKey()));
+ zos.write(e.getValue().getBytes(StandardCharsets.UTF_8));
+ zos.closeEntry();
+ }
+ }
+ return out.toByteArray();
+ }
+
+ private static String docPart(String body) {
+ return "" + body + "";
+ }
+
+ /**
+ * Разрывы вне {@code w:p}, {@code pageBreakBefore} с falsy-значением и
+ * {@code sectPr} внутри {@code w:pPr} не создают страниц.
+ */
+ @Test
+ void pageCount_strayAndFalsyBreaksNotCounted() throws Exception {
+ String body = ""
+ + ""
+ + ""
+ + ""
+ + ""
+ + ""
+ + "";
+ byte[] docx = rawDocx(java.util.Map.of(DOCUMENT_PART, docPart(body)));
+ ValidationException ex = assertThrows(ValidationException.class,
+ () -> WordPdfValidator.checkPageCount(docx, 0));
+ assertTrue(ex.getMessage().endsWith("не менее 1"),
+ "мусорные разрывы засчитаны: " + ex.getMessage());
+ String withReal = body + "";
+ byte[] docx2 = rawDocx(java.util.Map.of(DOCUMENT_PART, docPart(withReal)));
+ ValidationException ex2 = assertThrows(ValidationException.class,
+ () -> WordPdfValidator.checkPageCount(docx2, 1));
+ assertTrue(ex2.getMessage().endsWith("не менее 2"),
+ "настоящий разрыв не засчитан: " + ex2.getMessage());
+ }
+
+ /** Истинные значения {@code pageBreakBefore} (нет val/true/1/on) считают страницу. */
+ @Test
+ void pageCount_truthyPageBreakBeforeCounted() throws Exception {
+ String body = ""
+ + ""
+ + ""
+ + "";
+ byte[] docx = rawDocx(java.util.Map.of(DOCUMENT_PART, docPart(body)));
+ ValidationException ex = assertThrows(ValidationException.class,
+ () -> WordPdfValidator.checkPageCount(docx, 4));
+ assertTrue(ex.getMessage().contains("не менее 5"), ex.getMessage());
+ }
+
+ /** Колонтитулы считаются, .rels колонтитула — нет; записи-каталоги не пугают сканер. */
+ @Test
+ void pageCount_headerCountedRelsAndDirsNot() throws Exception {
+ String header = ""
+ + ""
+ + "";
+ String rels = ""
+ + "";
+ byte[] docx = rawDocx(java.util.Map.of(
+ DOCUMENT_PART, docPart(""),
+ "word/header1.xml", header,
+ "word/header1.xml.rels", rels,
+ "word/media/", ""));
+ assertDoesNotThrow(() -> WordPdfValidator.checkPageCount(docx, 3));
+ ValidationException ex = assertThrows(ValidationException.class,
+ () -> WordPdfValidator.checkPageCount(docx, 2));
+ assertTrue(ex.getMessage().contains("не менее 3"),
+ "2 разрыва колонтитула + первая страница: " + ex.getMessage());
+ }
+
+ /** Нет {@code word/document.xml} — оценка по колонтитулам, без падения. */
+ @Test
+ void pageCount_missingDocumentFallsToFooters() throws Exception {
+ String footer = ""
+ + "";
+ byte[] docx = rawDocx(java.util.Map.of("word/footer1.xml", footer));
+ ValidationException ex = assertThrows(ValidationException.class,
+ () -> WordPdfValidator.checkPageCount(docx, 1));
+ assertTrue(ex.getMessage().contains("не менее 2"), ex.getMessage());
+ }
+
+ /** [Content_Types].xml больше 8 МБ — отказ до разбора. */
+ @Test
+ void validate_hugeContentTypesRejected() throws Exception {
+ String ct = "";
+ byte[] docx = rawDocx(java.util.Map.of(
+ "[Content_Types].xml", ct,
+ DOCUMENT_PART, docPart("")));
+ ValidationException ex = assertThrows(ValidationException.class,
+ () -> WordPdfValidator.validate(docx,
+ options(WordPdfSettings.MAX_INPUT_MB, PAGE_LIMIT)));
+ assertTrue(ex.getMessage().contains("8 МБ"), ex.getMessage());
+ }
+
+ /** Короткий префикс и битая подпись PK — «не zip» без разбора архива. */
+ @Test
+ void validate_shortAndBrokenPkPrefixRejected() {
+ ValidationException ex = assertThrows(ValidationException.class,
+ () -> WordPdfValidator.validate(new byte[]{'P', 'K'},
+ ConvertOptions.defaults()));
+ assertTrue(ex.getMessage().contains("не zip"), ex.getMessage());
+ assertThrows(ValidationException.class,
+ () -> WordPdfValidator.validate(new byte[]{'P', 'K', 3, 9},
+ ConvertOptions.defaults()));
+ assertThrows(ValidationException.class,
+ () -> WordPdfValidator.validate(new byte[]{'P', 'K', 0, 4},
+ ConvertOptions.defaults()));
+ }
}
diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/fonts/BundledFontMapperTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/fonts/BundledFontMapperTest.java
new file mode 100644
index 0000000..7e25e31
--- /dev/null
+++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/fonts/BundledFontMapperTest.java
@@ -0,0 +1,119 @@
+package ru.pjandro.wordpdf.fonts;
+
+import org.docx4j.fonts.PhysicalFont;
+import org.docx4j.wml.Fonts;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Field;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Маппинг имён шрифтов из docx на бандл-семейства (BundledFontMapper).
+ * Состояние «бандл не инициализирован» моделируется сохранением
+ * и восстановлением статического реестра BundledFonts.
+ */
+class BundledFontMapperTest {
+
+ /** Тело теста, кидающее checked-исключение (populateFontMappings throws Exception). */
+ private interface TestBody {
+ void run() throws Exception;
+ }
+
+ /** Выполнить body в состоянии «шрифты бандла не зарегистрированы», затем восстановить. */
+ private static void withoutBundledInit(TestBody body) throws Exception {
+ Field variantsField = BundledFonts.class.getDeclaredField("VARIANTS");
+ variantsField.setAccessible(true);
+ Field initedField = BundledFonts.class.getDeclaredField("inited");
+ initedField.setAccessible(true);
+ @SuppressWarnings("unchecked")
+ Map> variants =
+ (Map>) variantsField.get(null);
+ Map> savedVariants = new HashMap<>(variants);
+ boolean savedInited = initedField.getBoolean(null);
+ variants.clear();
+ initedField.setBoolean(null, false);
+ try {
+ body.run();
+ } finally {
+ variants.clear();
+ variants.putAll(savedVariants);
+ initedField.setBoolean(null, savedInited);
+ }
+ }
+
+ /** Алиас + зарегистрированное семейство -> бандл-семейство (имя в любом регистре). */
+ @Test
+ void bundledFamilyKnownAliasMapsToBundle() {
+ BundledFonts.init();
+ assertEquals("carlito", BundledFontMapper.bundledFamily("Calibri"));
+ assertEquals("tinos", BundledFontMapper.bundledFamily("Times New Roman"));
+ assertEquals("dejavu sans", BundledFontMapper.bundledFamily("DejaVu Sans"));
+ }
+
+ /** Имени нет в таблице алиасов -> финальный fallback. */
+ @Test
+ void bundledFamilyUnknownFallsBack() {
+ BundledFonts.init();
+ assertEquals("dejavu sans", BundledFontMapper.bundledFamily("Zzz Not A Font"));
+ }
+
+ /** Алиас есть, но бандл не зарегистрирован (init() не вызван) -> fallback. */
+ @Test
+ void bundledFamilyWithoutInitFallsBack() throws Exception {
+ withoutBundledInit(() ->
+ assertEquals("dejavu sans", BundledFontMapper.bundledFamily("Calibri")));
+ }
+
+ /**
+ * Имя документа == SYMBOL_FONT маппится сразу (до родительского поиска),
+ * алиасы — на бандл, нераспознанное — в fallback DejaVu Sans.
+ */
+ @Test
+ void populateMapsSymbolFontAliasesAndFallback() throws Exception {
+ BundledFonts.init();
+ BundledFontMapper mapper = new BundledFontMapper();
+ Set names = new HashSet<>(List.of(
+ "Segoe UI Symbol", "Calibri", "UnknownExoticFont"));
+
+ mapper.populateFontMappings(names, new Fonts());
+
+ assertEquals(BundledFonts.regular("dejavu sans"), mapper.get("Segoe UI Symbol"),
+ "виртуальный Segoe UI Symbol обязан маппиться на fallback-семейство");
+ assertEquals(BundledFonts.regular("carlito"), mapper.get("Calibri"),
+ "Calibri -> Carlito");
+ assertEquals(BundledFonts.regular("dejavu sans"), mapper.get("UnknownExoticFont"),
+ "нераспознанный шрифт обязан упасть в DejaVu Sans");
+ }
+
+ /**
+ * Бандл не зарегистрирован: SYMBOL_FONT не маппится, алиасованный шрифт
+ * остаётся без маппинга (родитель без Panose его не находит, fallback null).
+ */
+ @Test
+ void populateWithoutInitLeavesEverythingUnmapped() throws Exception {
+ BundledFontMapper mapper = new BundledFontMapper();
+ Set names = new HashSet<>(List.of("Segoe UI Symbol", "Calibri Light"));
+
+ withoutBundledInit(() -> {
+ mapper.populateFontMappings(names, new Fonts());
+ assertNull(mapper.get("Segoe UI Symbol"),
+ "без init() виртуальный шрифт символов маппить нечем");
+ assertNull(mapper.get("Calibri Light"),
+ "без init() алиасованный шрифт не должен попасть и в fallback");
+ });
+ }
+
+ /** Имя бандл-семейства для w:rFonts: отображаемое имя или само семейство. */
+ @Test
+ void documentFontNameMapsDisplayNames() {
+ assertEquals("DejaVu Sans", BundledFontMapper.documentFontName("dejavu sans"));
+ assertEquals("carlito", BundledFontMapper.documentFontName("carlito"),
+ "семейство без отображаемого имени возвращается как есть");
+ }
+}
diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/fonts/BundledFontsTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/fonts/BundledFontsTest.java
index 2c8b86f..3041732 100644
--- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/fonts/BundledFontsTest.java
+++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/fonts/BundledFontsTest.java
@@ -12,6 +12,15 @@ import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
+import org.docx4j.fonts.PhysicalFonts;
+import org.docx4j.fonts.fop.apps.io.InternalResourceResolver;
+import org.docx4j.fonts.fop.fonts.EmbedFontInfo;
+import org.docx4j.fonts.fop.fonts.FontTriplet;
+import org.docx4j.fonts.fop.fonts.FontUris;
+
+import java.lang.reflect.Field;
+import java.net.URI;
+
import static org.junit.jupiter.api.Assertions.*;
/**
@@ -110,4 +119,69 @@ class BundledFontsTest {
assertNotNull(mapper.get("UnknownExoticFont"),
"неизвестный шрифт без маппинга");
}
+
+ /** font() для неизвестного семейства — null (нет карты начертаний). */
+ @Test
+ void fontUnknownFamilyReturnsNull() {
+ assertNull(BundledFonts.font("no-such-family", BundledFonts.V_REGULAR));
+ assertNull(BundledFonts.regular("no-such-family"));
+ }
+
+ /** font() для неизвестного начертания известного семейства — null. */
+ @Test
+ void fontUnknownVariantReturnsNull() {
+ BundledFonts.init();
+ assertNotNull(BundledFonts.regular("carlito"), "преусловие: семейство зарегистрировано");
+ assertNull(BundledFonts.font("carlito", "no-such-variant"));
+ }
+
+ /** restrictToBundled() до init() — no-op: реестр не трогается. */
+ @Test
+ void restrictToBundledBeforeInitIsNoOp() throws Exception {
+ PhysicalFont foreign = fakeFont("WordPdfTestForeign",
+ URI.create("file:///opt/fonts/foreign.ttf"));
+ PhysicalFonts.getPhysicalFonts().put("WordPdfTestForeign", foreign);
+ Field inited = BundledFonts.class.getDeclaredField("inited");
+ inited.setAccessible(true);
+ boolean saved = inited.getBoolean(null);
+ inited.setBoolean(null, false);
+ try {
+ BundledFonts.restrictToBundled();
+ assertSame(foreign, PhysicalFonts.getPhysicalFonts().get("WordPdfTestForeign"),
+ "до init() реестр чистить нельзя");
+ } finally {
+ inited.setBoolean(null, saved);
+ PhysicalFonts.getPhysicalFonts().remove("WordPdfTestForeign");
+ }
+ }
+
+ /** restrictToBundled() удаляет из реестра шрифт без URI и шрифт вне бандл-каталога. */
+ @Test
+ void restrictToBundledDropsForeignAndNullUriFonts() throws Exception {
+ BundledFonts.init();
+ PhysicalFont nullUri = fakeFont("WordPdfTestNullUri", null);
+ PhysicalFont foreign = fakeFont("WordPdfTestForeign",
+ URI.create("file:///opt/fonts/foreign.ttf"));
+ PhysicalFonts.getPhysicalFonts().put("WordPdfTestNullUri", nullUri);
+ PhysicalFonts.getPhysicalFonts().put("WordPdfTestForeign", foreign);
+
+ BundledFonts.restrictToBundled();
+
+ assertFalse(PhysicalFonts.getPhysicalFonts().containsKey("WordPdfTestNullUri"),
+ "шрифт без embeddedURI обязан быть удалён");
+ assertFalse(PhysicalFonts.getPhysicalFonts().containsKey("WordPdfTestForeign"),
+ "шрифт вне бандл-каталога обязан быть удалён");
+ assertTrue(PhysicalFonts.getPhysicalFonts().containsValue(BundledFonts.regular("carlito")),
+ "бандл-шрифт обязан остаться в реестре");
+ }
+
+ /** Тестовый PhysicalFont docx4j с заданным embeddedURI (допускается null). */
+ private static PhysicalFont fakeFont(String name, URI uri) throws Exception {
+ EmbedFontInfo info = new EmbedFontInfo(new FontUris(uri, null), false, false,
+ List.of(new FontTriplet(name, "normal", 0)), name);
+ var ctor = PhysicalFont.class.getDeclaredConstructor(String.class,
+ EmbedFontInfo.class, InternalResourceResolver.class);
+ ctor.setAccessible(true);
+ return ctor.newInstance(name, info, null);
+ }
}
diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/FieldNormalizerTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/FieldNormalizerTest.java
index a538532..62a5fb7 100644
--- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/FieldNormalizerTest.java
+++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/FieldNormalizerTest.java
@@ -123,4 +123,111 @@ class FieldNormalizerTest {
+ "1"
+ "", page);
}
+
+ /** Маркер begin без единого до него — поле-контейнер не найти, пропускаем. */
+ @Test
+ void beginWithoutAnyRun_skipped() {
+ assertNull(FieldNormalizer.rewrite("fldCharType=\"begin\""));
+ }
+
+ /** begin после закрытого рана: ран-контейнер не найден — пропускаем. */
+ @Test
+ void beginOutsideRun_skipped() {
+ assertNull(FieldNormalizer.rewrite(
+ "доfldCharType=\"begin\""));
+ }
+
+ /** Ран с begin не закрыт — битое поле, пропускаем. */
+ @Test
+ void beginRunUnclosed_skipped() {
+ assertNull(FieldNormalizer.rewrite(
+ ""
+ + "";
+ assertNull(FieldNormalizer.rewrite(xml));
+ }
+
+ /** PAGE без separate: кэша нет — fldSimple пустой, число нарисует обработчик. */
+ @Test
+ void fieldWithoutSeparate_emptyFldSimple() {
+ String xml = ""
+ + " PAGE "
+ + "";
+ assertEquals("",
+ FieldNormalizer.rewrite(xml));
+ }
+
+ /** separate другого поля после end: кэшем этого поля оно быть не может. */
+ @Test
+ void separateAfterFieldEnd_notCapturedAsCache() {
+ String xml = ""
+ + " PAGE "
+ + ""
+ + "";
+ String out = FieldNormalizer.rewrite(xml);
+
+ assertTrue(out.startsWith(""), out);
+ assertTrue(out.endsWith(""), out);
+ }
+
+ /** end вне рана: начало его рана не найти — кэш не берём, поле переписываем пустым. */
+ @Test
+ void endMarkerOutsideRun_noCacheCaptured() {
+ String xml = ""
+ + " PAGE "
+ + ""
+ + "2"
+ + "fldCharType=\"end\""
+ + "после";
+ assertEquals("",
+ FieldNormalizer.rewrite(xml));
+ }
+
+ /** separate и end в одном ране: «кэш» лежал бы раньше маркера — не берём. */
+ @Test
+ void separateAndEndInOneRun_noCacheCaptured() {
+ String xml = ""
+ + " PAGE "
+ + ""
+ + "";
+ assertEquals("",
+ FieldNormalizer.rewrite(xml));
+ }
+
+ /** instrText без закрывающего тега: инструкцию не собрать — поле остаётся. */
+ @Test
+ void unclosedInstrText_fieldSkipped() {
+ String xml = ""
+ + " PAGE "
+ + "";
+ assertNull(FieldNormalizer.rewrite(xml));
+ }
+
+ /** Ран с атрибутами () — корректное открытие рана, поле переписывается. */
+ @Test
+ void runWithAttributes_fieldRewritten() {
+ String xml = ""
+ + " PAGE "
+ + ""
+ + "2"
+ + "";
+ String out = FieldNormalizer.rewrite(xml);
+
+ assertTrue(out.startsWith(""), out);
+ assertTrue(out.contains("2"), "кэш потерян: " + out);
+ }
+
+ /** Ран с end не закрыт — поле битое, пропускаем. */
+ @Test
+ void endRunUnclosed_fieldSkipped() {
+ String xml = ""
+ + " PAGE "
+ + " f.getFontTriplet().stream())
+ .anyMatch(t -> name.equals(t.getName()));
+ }
+
+ /** Имя tripleta деклараций — имя regular-варианта из реестра docx4j. */
+ private static String declaredFamilyName() {
+ return BundledFonts.regular(BundledFonts.FALLBACK_FAMILY).getName();
+ }
+
+ /** Конфиг без рендеров — декларация пропускается без исключения. */
+ @Test
+ void declareWithoutRenderersIsNoOp() {
+ BundledFonts.init();
+ FOSettings settings = settingsWith();
+
+ assertDoesNotThrow(() -> FopFallbackFonts.declare(settings));
+ assertTrue(settings.getFopConfig().getRenderers().getRenderer().isEmpty());
+ }
+
+ /** Рендер с mime PDF предпочитается прочим. */
+ @Test
+ void declarePrefersPdfRenderer() {
+ BundledFonts.init();
+ Fonts pngFonts = new ObjectFactory().createFonts();
+ Fonts pdfFonts = new ObjectFactory().createFonts();
+
+ FopFallbackFonts.declare(settingsWith(
+ renderer(MIME_PNG, pngFonts), renderer(MIME_PDF, pdfFonts)));
+
+ assertTrue(hasTripletNamed(pdfFonts, declaredFamilyName()),
+ "PDF-рендер обязан получить декларации шрифтов");
+ assertTrue(pngFonts.getFont().isEmpty(),
+ "прочие рендеры трогать нельзя");
+ }
+
+ /** PDF-рендер без списка шрифтов — декларация в первый рендер со шрифтами. */
+ @Test
+ void declareFallsThroughToFirstRendererWithFonts() {
+ BundledFonts.init();
+ Fonts pngFonts = new ObjectFactory().createFonts();
+
+ FopFallbackFonts.declare(settingsWith(
+ renderer(MIME_PDF, null), renderer(MIME_PNG, pngFonts)));
+
+ assertTrue(hasTripletNamed(pngFonts, declaredFamilyName()),
+ "декларация обязана уйти рендеру, у которого есть шрифты");
+ }
+
+ /** Ни у одного рендера нет списка шрифтов — декларация пропускается. */
+ @Test
+ void declareWithoutAnyFontsIsNoOp() {
+ BundledFonts.init();
+ FOSettings settings = settingsWith(
+ renderer(MIME_PDF, null), renderer(MIME_PNG, null));
+
+ assertDoesNotThrow(() -> FopFallbackFonts.declare(settings));
+ for (Fop.Renderers.Renderer r
+ : settings.getFopConfig().getRenderers().getRenderer()) {
+ assertNull(r.getFonts(), "декларировать было некуда");
+ }
+ }
+
+ /** Бандл не инициализирован: семейства перечисляются, но декларировать нечего. */
+ @Test
+ void declareWithoutInitDeclaresNothing() throws Exception {
+ Field variantsField = BundledFonts.class.getDeclaredField("VARIANTS");
+ variantsField.setAccessible(true);
+ @SuppressWarnings("unchecked")
+ Map> variants =
+ (Map>) variantsField.get(null);
+ Map> saved =
+ new java.util.HashMap<>(variants);
+ variants.clear();
+ Fonts pdfFonts = new ObjectFactory().createFonts();
+ try {
+ FopFallbackFonts.declare(settingsWith(renderer(MIME_PDF, pdfFonts)));
+ assertTrue(pdfFonts.getFont().isEmpty(),
+ "без init() декларировать нечего");
+ } finally {
+ variants.clear();
+ variants.putAll(saved);
+ }
+ }
+}
diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/GlyphCoverageNormalizerTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/GlyphCoverageNormalizerTest.java
index f6fde7b..2a283a9 100644
--- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/GlyphCoverageNormalizerTest.java
+++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/GlyphCoverageNormalizerTest.java
@@ -203,6 +203,132 @@ class GlyphCoverageNormalizerTest {
assertEquals("dejavu sans", segments.get(1).family);
}
+ /** Битый баланс тегов: закрывающий не балансирует открывающий — ран остаётся. */
+ @Test
+ void unbalancedRunNesting_leftAsIs() {
+ assertNull(GlyphCoverageNormalizer.rewrite(""));
+ }
+
+ /** Висячий открывающий тег после разобранного блока: проход останавливается, текст цел. */
+ @Test
+ void danglingOpenTagAfterBlock_leftAsIs() {
+ assertNull(GlyphCoverageNormalizer.rewrite(""));
+ }
+
+ /** Обрыв на имени тега (" + timesRPr()
+ + "" + ROMAN + "";
+
+ String out = GlyphCoverageNormalizer.rewrite(xml);
+
+ assertNotNull(out);
+ assertTrue(out.contains(""), "самозакрывающийся ран потерян: " + out);
+ assertTrue(out.contains("DejaVu Serif"), "следующий ран не разрезан: " + out);
+ }
+
+ /** Табуляция/перевод строки после имени w:r — всё ещё открывающий тег рана. */
+ @Test
+ void whitespaceAfterRunTagName_recognizedAsRunOpen() {
+ for (String ws : new String[]{"\t", "\n", "\r"}) {
+ String xml = NS + "" + timesRPr()
+ + "" + ROMAN + "";
+
+ String out = GlyphCoverageNormalizer.rewrite(xml);
+
+ assertNotNull(out, "ран с не-пробельным разделителем атрибута не разрезан");
+ assertTrue(out.contains("DejaVu Serif"), "нет подстановки: " + out);
+ assertTrue(out.contains(""),
+ "открывающий тег рана испорчен: " + out);
+ }
+ }
+
+ /** Незакрытый w:rPr — ран остаётся как есть. */
+ @Test
+ void unclosedRunPr_leftAsIs() {
+ assertNull(GlyphCoverageNormalizer.rewrite(NS + ""
+ + ""
+ + ""));
+ }
+
+ /** null-семейство не покрывает ни один знак. */
+ @Test
+ void nullFamilyCoversNothing() {
+ assertFalse(GlyphCoverageNormalizer.covers(null, 'A'));
+ }
+
+ /** Семейства нет в бандле (шрифт не загрузить) и отрицательный код — не покрыты. */
+ @Test
+ void unknownFamilyAndNegativeCodeNotCovered() {
+ assertFalse(GlyphCoverageNormalizer.covers("нет-такого-семейства", 'A'));
+ assertFalse(GlyphCoverageNormalizer.covers("dejavu sans", -1));
+ }
+
+ /** w:rFonts без w:ascii/w:hAnsi — семейство рана неизвестно, ран не трогаем. */
+ @Test
+ void rFontsWithoutAsciiOrHAnsi_untouched() {
+ assertNull(GlyphCoverageNormalizer.rewrite(
+ run("",
+ "" + ROMAN + "")));
+ }
+
+ /** Контейнерная форма w:rFonts ... заменяется самозакрывающимся тегом. */
+ @Test
+ void containerRFonts_replacedWithSelfClosed() {
+ String out = GlyphCoverageNormalizer.rewrite(
+ run(""
+ + "", "" + ROMAN + ""));
+
+ assertNotNull(out);
+ assertTrue(out.contains(""), out);
+ assertFalse(out.contains(""), "контейнер не удалён: " + out);
+ }
+
+ /** Контейнерная форма w:rFonts, после которой в rPr нет больше самозакрывающихся тегов. */
+ @Test
+ void containerRFontsAsOnlyChild_replaced() {
+ String out = GlyphCoverageNormalizer.rewrite(
+ run("",
+ "" + ROMAN + ""));
+
+ assertNotNull(out);
+ assertTrue(out.contains(""), out);
+ }
+
+ /** Битый w:rFonts без закрытия: подставить шрифт нельзя, ран остаётся как есть. */
+ @Test
+ void malformedRFontsTag_leftAsIs() {
+ assertNull(GlyphCoverageNormalizer.rewrite(
+ run("",
+ "" + ROMAN + "")));
+ }
+
+ /** Шестнадцатеричные числовые сущности разбираются так же, как десятичные. */
+ @Test
+ void decodesHexNumericEntities() {
+ String out = GlyphCoverageNormalizer.rewrite(
+ run(timesRPr(), "ↁ"));
+
+ assertNotNull(out, "hex-сущность не разобрана: U+2181 требует подстановки");
+ assertTrue(out.contains("DejaVu Serif"), "нет подстановки: " + out);
+ assertTrue(out.contains(ROMAN), "знак потерян: " + out);
+ }
+
private static int occurrences(String s, String needle) {
int count = 0;
for (int i = s.indexOf(needle); i >= 0; i = s.indexOf(needle, i + 1)) {
diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/OleObjectNormalizerTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/OleObjectNormalizerTest.java
index 7eb520b..8cce1ea 100644
--- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/OleObjectNormalizerTest.java
+++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/OleObjectNormalizerTest.java
@@ -220,4 +220,215 @@ class OleObjectNormalizerTest {
assertFalse(rels.contains("_embedded/ole.bin"),
"rel на OLE-часть обязан исчезнуть: " + rels);
}
+
+ /** zip без [Content_Types].xml — типы искать нечем, документ возвращается как есть. */
+ @Test
+ void zipWithoutContentTypesReturnsOriginal() throws Exception {
+ Map m = new LinkedHashMap<>();
+ m.put("_rels/.rels", utf8(ROOT_RELS));
+ m.put("word/document.xml", utf8(DOC_PLAIN));
+ byte[] docx = zip(m);
+
+ assertSame(docx, OleObjectNormalizer.normalize(docx, false));
+ }
+
+ /** .bin без content type (ни Override, ни Default) OLE-частью не считается. */
+ @Test
+ void binWithoutKnownTypeKept() throws Exception {
+ String ct = ""
+ + ""
+ + ""
+ + ""
+ + ""
+ + "";
+ Map m = new LinkedHashMap<>();
+ m.put("[Content_Types].xml", utf8(ct));
+ m.put("_rels/.rels", utf8(ROOT_RELS));
+ m.put("word/document.xml", utf8(DOC_PLAIN));
+ m.put("word/_embedded/ole.bin", BIN);
+ m.put("word/media/data.bin", BIN);
+
+ Map entries = unzip(OleObjectNormalizer.normalize(zip(m), false));
+ assertFalse(entries.containsKey("word/_embedded/ole.bin"),
+ "часть с честным oleObject-типом обязана быть удалена");
+ assertTrue(entries.containsKey("word/media/data.bin"),
+ "часть без content type удалять нельзя");
+ }
+
+ /** rels вне каталога _rels/: база пуста, Target резолвится от корня, «..» в пустоте игнорируется. */
+ @Test
+ void relsOutsideRelsDirResolvesFromRoot() throws Exception {
+ String rels = ""
+ + ""
+ + ""
+ + ""
+ + "";
+ Map m = new LinkedHashMap<>();
+ m.put("[Content_Types].xml", utf8(CT_OLE));
+ m.put("_rels/.rels", utf8(ROOT_RELS));
+ m.put("word/document.xml", utf8(DOC_PLAIN));
+ m.put("word/_embedded/ole.bin", BIN);
+ m.put("word/extra.rels", utf8(rels));
+
+ String fixed = readEntry(OleObjectNormalizer.normalize(zip(m), false), "word/extra.rels");
+ assertFalse(fixed.contains("rId1"), "прямой Target обязан быть удалён: " + fixed);
+ assertFalse(fixed.contains("rId2"), "Target с «..» при пустой базе обязан быть удалён: " + fixed);
+ }
+
+ /** .rels без подстроки « m = new LinkedHashMap<>();
+ m.put("[Content_Types].xml", utf8(CT_LIE));
+ m.put("_rels/.rels", utf8(ROOT_RELS));
+ m.put("word/document.xml", utf8(DOC_PLAIN));
+ m.put("word/_embedded/ole.bin", BIN);
+ m.put("word/_rels/document.xml.rels", utf8(rels));
+ byte[] docx = zip(m);
+
+ Map entries = unzip(OleObjectNormalizer.normalize(docx, false));
+ assertFalse(entries.containsKey("word/_embedded/ole.bin"));
+ assertArrayEquals(unzip(docx).get("word/_rels/document.xml.rels"),
+ entries.get("word/_rels/document.xml.rels"),
+ "rels без Relationship обязан пройти без изменений");
+ }
+
+ /** Relationship без атрибута Target — не удаляется. */
+ @Test
+ void relWithoutTargetAttributeKept() throws Exception {
+ String rels = ""
+ + ""
+ + ""
+ + ""
+ + "";
+ Map m = new LinkedHashMap<>();
+ m.put("[Content_Types].xml", utf8(CT_OLE));
+ m.put("_rels/.rels", utf8(ROOT_RELS));
+ m.put("word/document.xml", utf8(DOC_PLAIN));
+ m.put("word/_embedded/ole.bin", BIN);
+ m.put("word/_rels/document.xml.rels", utf8(rels));
+
+ String fixed = readEntry(OleObjectNormalizer.normalize(zip(m), false),
+ "word/_rels/document.xml.rels");
+ assertTrue(fixed.contains("rId9"), "rel без Target обязан остаться: " + fixed);
+ assertFalse(fixed.contains("rId1"), "rel на OLE-часть обязан исчезнуть: " + fixed);
+ }
+
+ /** Абсолютный Target, пути с «..», «.» и пустым сегментом — все резолвятся в OLE-часть. */
+ @Test
+ void absoluteAndDottedTargetsResolveToOlePart() throws Exception {
+ String rels = ""
+ + ""
+ + ""
+ + ""
+ + ""
+ + ""
+ + "";
+ Map m = new LinkedHashMap<>();
+ m.put("[Content_Types].xml", utf8(CT_OLE));
+ m.put("_rels/.rels", utf8(ROOT_RELS));
+ m.put("word/document.xml", utf8(DOC_PLAIN));
+ m.put("word/_embedded/ole.bin", BIN);
+ m.put("word/_rels/document.xml.rels", utf8(rels));
+
+ String fixed = readEntry(OleObjectNormalizer.normalize(zip(m), false),
+ "word/_rels/document.xml.rels");
+ assertFalse(fixed.contains("rIdAbs"), "абсолютный Target обязан быть удалён: " + fixed);
+ assertFalse(fixed.contains("rIdUp"), "Target с «..» обязан быть удалён: " + fixed);
+ assertFalse(fixed.contains("rIdDot"), "Target с «.» и пустым сегментом обязан быть удалён: " + fixed);
+ assertTrue(fixed.contains("rIdOther"), "rel на не-OLE-часть обязан остаться: " + fixed);
+ }
+
+ /** Пустой сегмент в середине базы rels («word//a/_rels/») при резолвинге пропускается. */
+ @Test
+ void relsWithEmptyBaseSegmentResolves() throws Exception {
+ String ct = ""
+ + ""
+ + ""
+ + ""
+ + ""
+ + "";
+ String rels = ""
+ + ""
+ + ""
+ + "";
+ Map m = new LinkedHashMap<>();
+ m.put("[Content_Types].xml", utf8(ct));
+ m.put("_rels/.rels", utf8(ROOT_RELS));
+ m.put("word/document.xml", utf8(DOC_PLAIN));
+ m.put("word/a/_embedded/ole.bin", BIN);
+ m.put("word//a/_rels/x.rels", utf8(rels));
+
+ String fixed = readEntry(OleObjectNormalizer.normalize(zip(m), false),
+ "word//a/_rels/x.rels");
+ assertFalse(fixed.contains("_embedded/ole.bin"),
+ "rel обязан разрешиться в word/a/_embedded/ole.bin и исчезнуть: " + fixed);
+ }
+
+ /** Незакрытый «"
+ + "текст с литералом ";
+ Map m = new LinkedHashMap<>();
+ m.put("[Content_Types].xml", utf8(CT_OLE));
+ m.put("_rels/.rels", utf8(ROOT_RELS));
+ m.put("word/document.xml", utf8(doc));
+ m.put("word/_embedded/ole.bin", BIN);
+
+ Map entries = unzip(OleObjectNormalizer.normalize(zip(m), false));
+ assertArrayEquals(utf8(doc), entries.get("word/document.xml"),
+ "документ без совпавшего элемента w:object обязан остаться нетронутым");
+ assertFalse(entries.containsKey("word/_embedded/ole.bin"));
+ }
+
+ /** Override с парным закрывающим тегом: сканер знает только самозакрытие и останавливается. */
+ @Test
+ void pairedTagOverrideStopsScan() throws Exception {
+ String ct = ""
+ + ""
+ + ""
+ + ""
+ + ""
+ + "";
+ Map m = new LinkedHashMap<>();
+ m.put("[Content_Types].xml", utf8(ct));
+ m.put("_rels/.rels", utf8(ROOT_RELS));
+ m.put("word/document.xml", utf8(DOC_PLAIN));
+ m.put("word/_embedded/ole.bin", BIN);
+ byte[] docx = zip(m);
+
+ byte[] result = OleObjectNormalizer.normalize(docx, false);
+ assertFalse(unzip(result).containsKey("word/_embedded/ole.bin"),
+ "часть обязана быть удалена по Default-типу");
+ String outCt = readEntry(result, "[Content_Types].xml");
+ assertTrue(outCt.contains(""),
+ "парный Override сканеру не по зубам и обязан остаться: " + outCt);
+ }
+
+ /** Override без PartName остаётся; Override без ведущего «/» резолвится и удаляется. */
+ @Test
+ void overridePartNameWithoutSlashRemovedPlainKept() throws Exception {
+ String ct = ""
+ + ""
+ + ""
+ + ""
+ + ""
+ + ""
+ + "";
+ Map m = new LinkedHashMap<>();
+ m.put("[Content_Types].xml", utf8(ct));
+ m.put("_rels/.rels", utf8(ROOT_RELS));
+ m.put("word/document.xml", utf8(DOC_PLAIN));
+ m.put("word/_embedded/ole.bin", BIN);
+
+ String outCt = readEntry(OleObjectNormalizer.normalize(zip(m), false),
+ "[Content_Types].xml");
+ assertTrue(outCt.contains("application/x-test"),
+ "Override без PartName обязан остаться: " + outCt);
+ assertFalse(outCt.contains("word/_embedded/ole.bin"),
+ "Override без ведущего слэша обязан быть удалён: " + outCt);
+ }
}
diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/StrictOoxmlNormalizerTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/StrictOoxmlNormalizerTest.java
index 92c694f..4f4c267 100644
--- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/StrictOoxmlNormalizerTest.java
+++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/StrictOoxmlNormalizerTest.java
@@ -197,4 +197,45 @@ class StrictOoxmlNormalizerTest {
assertTrue(numbering.contains(""), numbering);
assertTrue(numbering.contains(""), numbering);
}
+
+ /** Только закрывающий (без открывающего) — тоже переименовывается. */
+ @Test
+ void closingStartWithoutOpenRenamed() {
+ String r = StrictOoxmlNormalizer.rewrite("");
+ assertNotNull(r);
+ assertTrue(r.contains(""), r);
+ assertFalse(r.contains("w:start"), r);
+ }
+
+ /** Только закрывающий (без открывающего) — тоже переименовывается. */
+ @Test
+ void closingEndWithoutOpenRenamed() {
+ String r = StrictOoxmlNormalizer.rewrite("");
+ assertNotNull(r);
+ assertTrue(r.contains(""), r);
+ assertFalse(r.contains("w:end"), r);
+ }
+
+ /** Только атрибут w:end (без w:start) — переименовывается. */
+ @Test
+ void endAttributeOnlyRenamed() {
+ String r = StrictOoxmlNormalizer.rewrite("");
+ assertNotNull(r);
+ assertTrue(r.contains("w:right=\"36pt\""), r);
+ }
+
+ /** Только w:val="end" (без start) у w:jc — переименовывается. */
+ @Test
+ void jcEndValueOnlyRenamed() {
+ String r = StrictOoxmlNormalizer.rewrite("");
+ assertNotNull(r);
+ assertTrue(r.contains(""), r);
+ }
+
+ /** start/end в w:val у чужих элементов (не w:jc/w:tab) — не трогаем. */
+ @Test
+ void valStartOnForeignElementUntouched() {
+ assertNull(StrictOoxmlNormalizer.rewrite(""));
+ assertNull(StrictOoxmlNormalizer.rewrite(""));
+ }
}
diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/SymbolFontNormalizerTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/SymbolFontNormalizerTest.java
index 6c342d2..fc56820 100644
--- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/SymbolFontNormalizerTest.java
+++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/SymbolFontNormalizerTest.java
@@ -179,4 +179,164 @@ class SymbolFontNormalizerTest {
assertTrue(out.contains(""),
"каркас внешнего рана повреждён: " + out);
}
+
+ /** Нет кодов из PUA, но есть w:sym — быстрый путь не отсекает, символ заменяется. */
+ @Test
+ void symWithoutPuaStillRewritten() {
+ String out = SymbolFontNormalizer.rewrite(
+ ""
+ + "a");
+ assertNotNull(out, "ран с w:sym без PUA пропущен");
+ assertTrue(out.contains("♥"), "w:sym без w:font не взят из шрифта рана: " + out);
+ assertTrue(out.contains("w:ascii=\"" + SymbolFontNormalizer.REPLACEMENT_FAMILY + "\""),
+ "нет fallback-семейства у символа: " + out);
+ assertTrue(out.contains("a"), "текст до w:sym потерян: " + out);
+ }
+
+ /** Битые/незакрытые конструкции не правим (контракт: null = не трогать). */
+ @Test
+ void malformedRunsUntouched() {
+ // открывающий есть, закрывающего нет
+ assertNull(SymbolFontNormalizer.rewrite("\uF0B7"));
+ // открывающий тег без '>'
+ assertNull(SymbolFontNormalizer.rewrite("\uF0B7\uF0B7"
+ + "\uF0B7"
+ + "\uF0B7");
+ assertNotNull(out, "ран с табуляцией/переносом в теге пропущен");
+ assertTrue(out.contains("•"), "PUA не стал Unicode: " + out);
+ assertFalse(out.contains("=\"Symbol\""), "имя шрифта не заменено: " + out);
+ }
+
+ /** Самозакрывающийся — не блок, поиск продолжается со следующего рана. */
+ @Test
+ void selfClosingRunSkipped() {
+ String out = SymbolFontNormalizer.rewrite(
+ ""
+ + "\uF0B7");
+ assertNotNull(out, "ран после не переписан");
+ assertTrue(out.contains(""), "самозакрывающийся ран повреждён: " + out);
+ assertTrue(out.contains("•"), "PUA не стал Unicode: " + out);
+ }
+
+ /** Два открывающих, один закрывающий: блок берётся до единственного . */
+ @Test
+ void unbalancedNestedRuns_blockUpToSoleClose() {
+ String out = SymbolFontNormalizer.rewrite(
+ ""
+ + "\uF0B7");
+ assertNotNull(out, "несбалансированный блок не переписан");
+ assertTrue(out.contains("•"), "PUA не стал Unicode: " + out);
+ assertFalse(out.contains("=\"Symbol\""), "имя шрифта не заменено: " + out);
+ }
+
+ /** Хвост после единственного без собственного рана — не трогаем. */
+ @Test
+ void danglingTailAfterCloseUntouched() {
+ assertNull(SymbolFontNormalizer.rewrite("\uF0B7"));
+ }
+
+ /** Коды вне U+F000–U+F0FF — обычная часть символьного шрифта, не переписываются. */
+ @Test
+ void puaAboveBlockKept() {
+ assertNull(SymbolFontNormalizer.rewrite(
+ "\uF100"));
+ String out = SymbolFontNormalizer.rewrite(
+ "\uF0B7\uF100");
+ assertNotNull(out);
+ assertTrue(out.contains("•\uF100"), "F0B7/F100 обработаны неверно: " + out);
+ }
+
+ /** PUA-код без соответствия в таблице остаётся как был, шрифт всё равно меняется. */
+ @Test
+ void unmappedPuaSlotKeepsCode() {
+ String out = SymbolFontNormalizer.rewrite(
+ "\uF000");
+ assertNotNull(out);
+ assertTrue(out.contains("\uF000"), "код без маппинга потерян: " + out);
+ assertFalse(out.contains("=\"Symbol\""), "имя шрифта не заменено: " + out);
+ }
+
+ /** w:sym в блоке w:lvl (не ран) — не разрезаем. */
+ @Test
+ void symInLevelBlockNotSplit() {
+ assertNull(SymbolFontNormalizer.rewrite(
+ ""));
+ }
+
+ /** Открытый без перед w:sym — битый ран не правим. */
+ @Test
+ void unclosedRPrBeforeSymUntouched() {
+ assertNull(SymbolFontNormalizer.rewrite(
+ ""));
+ }
+
+ /** w:sym без w:char / без w:font в ране без символьного шрифта / код вне PUA /
+ * слот без маппинга — элемент удаляется, соседний текст сохраняется. */
+ @Test
+ void unresolvableSymElementDropped() {
+ String noChar = SymbolFontNormalizer.rewrite(
+ "a");
+ assertNotNull(noChar);
+ assertFalse(noChar.contains("a"), "текст потерян: " + noChar);
+
+ String noFontNoMap = SymbolFontNormalizer.rewrite(
+ "a");
+ assertNotNull(noFontNoMap);
+ assertFalse(noFontNoMap.contains("a");
+ assertNotNull(asciiChar);
+ assertFalse(asciiChar.contains("a");
+ assertNotNull(unmappedChar);
+ assertFalse(unmappedChar.contains("a"));
+ }
+
+ /** rPr без w:rFonts: fallback-семейство вставляется первым ребёнком. */
+ @Test
+ void forceFontInsertsRFontsWhenAbsent() {
+ String out = SymbolFontNormalizer.rewrite(
+ ""
+ + "");
+ assertNotNull(out);
+ assertTrue(out.contains(""),
+ "w:rFonts не вставлен в rPr: " + out);
+ assertTrue(out.contains("♥"), "символ потерян: " + out);
+ }
+
+ /** В обработанном блоке несимвольные имена шрифтов остаются как были. */
+ @Test
+ void nonSymbolFontAttrKept() {
+ String out = SymbolFontNormalizer.rewrite(
+ ""
+ + "\uF0B7");
+ assertNotNull(out);
+ assertTrue(out.contains("w:eastAsia=\"Arial\""), "несимвольный шрифт изменён: " + out);
+ assertTrue(out.contains("w:ascii=\"" + SymbolFontNormalizer.REPLACEMENT_FAMILY + "\""),
+ "символьный шрифт не заменён: " + out);
+ assertTrue(out.contains("•"), "PUA не стал Unicode: " + out);
+ }
}
diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/CartesianPainterTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/CartesianPainterTest.java
index c30707b..30d5661 100644
--- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/CartesianPainterTest.java
+++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/CartesianPainterTest.java
@@ -176,4 +176,278 @@ class CartesianPainterTest {
+ " px, ожидается " + String.format("%.0f", expected)
+ " px (отклонение " + String.format("%.1f", deviation * 100) + "%)");
}
+
+ // ---- ветви отрисовки, не затронутые геометрическими регрессиями ----
+
+ /** c:valAx=null — подписей оси значений нет. */
+ @Test
+ void nullValAxisSkipsValueLabels() {
+ ChartSpec spec = barSpec(150, 0, 1);
+ BufferedImage withLabels = ChartRenderer.render(spec, 219.23, 149.08,
+ new DrawMlColor(null));
+ spec.valAxis = null;
+ BufferedImage without = ChartRenderer.render(spec, 219.23, 149.08,
+ new DrawMlColor(null));
+ assertTrue(countDark(withLabels) > countDark(without),
+ "без c:valAx подписей оси значений стать не должно");
+ }
+
+ /** Ряд без значений — область построения пуста. */
+ @Test
+ void emptyValuesPaintNothing() {
+ ChartSpec spec = barSpec(150, 0, 1);
+ spec.series.get(0).values.clear();
+ assertFalse(anySaturated(ChartRenderer.render(spec, 219.23, 149.08,
+ new DrawMlColor(null))), "нет значений — столбцов нет");
+ }
+
+ /** c:majorGridlines рисуются; удалённая ось сетку не рисует. */
+ @Test
+ void gridlinesDrawnAndDeletedAxisSkipsThem() {
+ ChartSpec spec = barSpec(150, 0, 1);
+ spec.valAxis.gridlines = true;
+ BufferedImage grid = ChartRenderer.render(spec, 219.23, 149.08, new DrawMlColor(null));
+ spec.valAxis.deleted = true;
+ BufferedImage deleted = ChartRenderer.render(spec, 219.23, 149.08, new DrawMlColor(null));
+ assertTrue(countGrid(grid) > 0, "c:majorGridlines не нарисованы");
+ assertTrue(countGrid(deleted) < countGrid(grid),
+ "удалённая ось не должна рисовать сетку");
+ }
+
+ /** Явный c:majorUnit крупнее расчётного — линий сетки меньше. */
+ @Test
+ void explicitMajorUnitCoarsensGrid() {
+ ChartSpec spec = barSpec(150, 0, 1);
+ spec.valAxis.gridlines = true;
+ BufferedImage auto = ChartRenderer.render(spec, 219.23, 149.08, new DrawMlColor(null));
+ spec.valAxis.majorUnit = 10.0;
+ BufferedImage coarse = ChartRenderer.render(spec, 219.23, 149.08, new DrawMlColor(null));
+ assertTrue(countGrid(coarse) < countGrid(auto),
+ "c:majorUnit=10 не укрупнил шаг сетки");
+ }
+
+ /** Низкий бокс: подписи не влезают — шаг делений укрупняется (цикл auto-layout). */
+ @Test
+ void tinyBoxEnlargesTickStep() {
+ ChartSpec spec = lineLikeSpec();
+ spec.series.get(0).values.add(0.0);
+ spec.series.get(0).values.add(50.0);
+ spec.series.get(0).values.add(100.0);
+ BufferedImage tall = ChartRenderer.render(spec, 219.23, 149.08, new DrawMlColor(null));
+ BufferedImage tiny = ChartRenderer.render(spec, 219.23, 40, new DrawMlColor(null));
+ assertTrue(countDark(tall) > countDark(tiny),
+ "в узком боксе шаг делений не укрупнён — подписей больше, чем в высоком");
+ }
+
+ /** Линия категории: рисуется, исчезает при c:delete и при axisLineColor=null. */
+ @Test
+ void catAxisLineDeletedAndNull() {
+ ChartSpec spec = barSpec(150, 0, 1);
+ spec.catAxis.axisLineColor = Color.RED;
+ BufferedImage line = ChartRenderer.render(spec, 219.23, 149.08, new DrawMlColor(null));
+ assertTrue(countPureRed(line) > 0, "линия категории не нарисована");
+ spec.catAxis.deleted = true;
+ BufferedImage deleted = ChartRenderer.render(spec, 219.23, 149.08, new DrawMlColor(null));
+ assertEquals(0, countPureRed(deleted), "удалённая ось не рисует линию категории");
+ spec.catAxis.deleted = false;
+ spec.catAxis.axisLineColor = null;
+ BufferedImage noColor = ChartRenderer.render(spec, 219.23, 149.08, new DrawMlColor(null));
+ assertEquals(0, countPureRed(noColor), "axisLineColor=null — линии нет");
+ }
+
+ /** Подпись категории шире слота прячется (Word так же); общие категории приоритетнее рядовых. */
+ @Test
+ void longCategoryLabelHidden() {
+ ChartSpec spec = barSpec(150, 0, 1);
+ spec.categories.add("WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW");
+ BufferedImage longLabel = ChartRenderer.render(spec, 120, 100, new DrawMlColor(null));
+ spec.categories.clear();
+ spec.categories.add("W");
+ BufferedImage shortLabel = ChartRenderer.render(spec, 120, 100, new DrawMlColor(null));
+ assertTrue(countDark(shortLabel) > countDark(longLabel),
+ "непомещающаяся подпись категории не скрыта");
+ }
+
+ /** LINE: null-дыра пропускается, из одной точки линия не рисуется (только маркер). */
+ @Test
+ void lineNullGapAndSinglePoint() {
+ ChartSpec spec = lineLikeSpec();
+ spec.series.get(0).values.add(1.0);
+ spec.series.get(0).values.add(null);
+ spec.series.get(0).values.add(3.0);
+ BufferedImage gap = ChartRenderer.render(spec, 219.23, 149.08, new DrawMlColor(null));
+ spec.series.get(0).values.clear();
+ spec.series.get(0).values.add(2.0);
+ BufferedImage single = ChartRenderer.render(spec, 219.23, 149.08, new DrawMlColor(null));
+ assertTrue(countSaturated(gap) > countSaturated(single),
+ "из одной точки линия не рисуется — пикселей меньше");
+ }
+
+ /** AREA: явный c:fill ряда, null-дыра, одиночная точка не заполняется. */
+ @Test
+ void areaExplicitFillNullsAndSinglePoint() {
+ ChartSpec spec = lineLikeSpec();
+ spec.type = ChartSpec.Type.AREA;
+ spec.series.get(0).fill = Color.RED;
+ spec.series.get(0).values.add(1.0);
+ spec.series.get(0).values.add(null);
+ spec.series.get(0).values.add(3.0);
+ BufferedImage img = ChartRenderer.render(spec, 219.23, 149.08, new DrawMlColor(null));
+ assertTrue(countRedFill(img) > 0, "явный c:fill ряда не применён к области");
+ spec.series.get(0).values.clear();
+ spec.series.get(0).values.add(2.0);
+ BufferedImage single = ChartRenderer.render(spec, 219.23, 149.08, new DrawMlColor(null));
+ assertEquals(0, countRedFill(single), "AREA из одной точки не заполняется");
+ }
+
+ /** overlap=-100 при gapWidth=0: шаг рядов ограничен слотом — группа не расползается. */
+ @Test
+ void negativeOverlapKeepsGroupInSlot() {
+ ChartSpec spec = barSpec(0, -100, 2);
+ spec.series.get(0).values.add(5.0);
+ spec.series.get(1).values.add(5.0);
+ spec.series.get(1).values.set(0, 2.0);
+ spec.series.get(1).values.set(1, 2.0);
+ spec.series.get(1).values.set(2, 2.0);
+ BufferedImage img = ChartRenderer.render(spec, 219.23, 149.08, new DrawMlColor(null));
+ List runs = runsInRow(img, (int) (img.getHeight() * 0.75));
+ assertEquals(1, runs.size(),
+ "overlap=-100 при gapWidth=0: шаг ограничен слотом — все столбцы в одном слитном прогоне");
+ }
+
+ /** null-значение в ряду столбцов не рисует столбец. */
+ @Test
+ void barNullValueSkipped() {
+ ChartSpec spec = barSpec(150, 0, 1);
+ spec.series.get(0).values.set(1, null);
+ List runs = runsInRow(
+ ChartRenderer.render(spec, 219.23, 149.08, new DrawMlColor(null)),
+ (int) (149.08 * 300 / 72 * 0.8));
+ assertEquals(1, runs.size(), "null-значение не рисуется — прогон один");
+ }
+
+ private static ChartSpec lineLikeSpec() {
+ ChartSpec spec = new ChartSpec();
+ spec.type = ChartSpec.Type.LINE;
+ spec.legendPos = null;
+ DrawMlText.Style style = new DrawMlText.Style(9, false, false,
+ new Color(0x59, 0x59, 0x59), "carlito");
+ spec.catAxis = new ChartSpec.AxisSpec();
+ spec.catAxis.labelStyle = style;
+ spec.valAxis = new ChartSpec.AxisSpec();
+ spec.valAxis.labelStyle = style;
+ spec.series.add(new ChartSpec.Series());
+ return spec;
+ }
+
+ /** Прогоны залитых пикселей в заданной строке. */
+ private static List runsInRow(BufferedImage img, int y) {
+ List runs = new ArrayList<>();
+ int runStart = -1;
+ for (int x = 0; x <= img.getWidth(); x++) {
+ boolean filled = x < img.getWidth() && saturated(img.getRGB(x, y));
+ if (filled) {
+ if (runStart < 0) {
+ runStart = x;
+ }
+ } else if (runStart >= 0) {
+ runs.add(new int[]{runStart, x - 1});
+ runStart = -1;
+ }
+ }
+ return runs;
+ }
+
+ private static boolean anySaturated(BufferedImage img) {
+ for (int y = 0; y < img.getHeight(); y++) {
+ for (int x = 0; x < img.getWidth(); x++) {
+ if (saturated(img.getRGB(x, y))) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ private static int countSaturated(BufferedImage img) {
+ int n = 0;
+ for (int y = 0; y < img.getHeight(); y++) {
+ for (int x = 0; x < img.getWidth(); x++) {
+ if (saturated(img.getRGB(x, y))) {
+ n++;
+ }
+ }
+ }
+ return n;
+ }
+
+ /** Тёмные ахроматичные пиксели (подписи осей). */
+ private static int countDark(BufferedImage img) {
+ int n = 0;
+ for (int y = 0; y < img.getHeight(); y++) {
+ for (int x = 0; x < img.getWidth(); x++) {
+ int rgb = img.getRGB(x, y);
+ int a = rgb >>> 24;
+ int r = (rgb >> 16) & 0xFF;
+ int g = (rgb >> 8) & 0xFF;
+ int b = rgb & 0xFF;
+ if (a > 128 && Math.max(Math.max(r, g), b) - Math.min(Math.min(r, g), b) <= 25
+ && r < 0x80) {
+ n++;
+ }
+ }
+ }
+ return n;
+ }
+
+ /** Пиксели цвета сетки по умолчанию (0xD9D9D9). */
+ private static int countGrid(BufferedImage img) {
+ int n = 0;
+ for (int y = 0; y < img.getHeight(); y++) {
+ for (int x = 0; x < img.getWidth(); x++) {
+ int rgb = img.getRGB(x, y);
+ int r = (rgb >> 16) & 0xFF;
+ int g = (rgb >> 8) & 0xFF;
+ int b = rgb & 0xFF;
+ if (Math.abs(r - 0xD9) <= 8 && Math.abs(g - 0xD9) <= 8 && Math.abs(b - 0xD9) <= 8) {
+ n++;
+ }
+ }
+ }
+ return n;
+ }
+
+ /** Чистый красный (255,0,0) — линия оси. */
+ private static int countPureRed(BufferedImage img) {
+ int n = 0;
+ for (int y = 0; y < img.getHeight(); y++) {
+ for (int x = 0; x < img.getWidth(); x++) {
+ int rgb = img.getRGB(x, y);
+ int r = (rgb >> 16) & 0xFF;
+ int g = (rgb >> 8) & 0xFF;
+ int b = rgb & 0xFF;
+ if (r > 200 && g < 60 && b < 60) {
+ n++;
+ }
+ }
+ }
+ return n;
+ }
+
+ /** Красная заливка с альфа 0.55 на белом: (255,115,115). */
+ private static int countRedFill(BufferedImage img) {
+ int n = 0;
+ for (int y = 0; y < img.getHeight(); y++) {
+ for (int x = 0; x < img.getWidth(); x++) {
+ int rgb = img.getRGB(x, y);
+ int r = (rgb >> 16) & 0xFF;
+ int g = (rgb >> 8) & 0xFF;
+ int b = rgb & 0xFF;
+ if (r > 200 && g > 80 && g < 170 && b > 80 && b < 170) {
+ n++;
+ }
+ }
+ }
+ return n;
+ }
}
diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/ChartRendererTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/ChartRendererTest.java
index 5bd201b..3f98309 100644
--- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/ChartRendererTest.java
+++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/ChartRendererTest.java
@@ -1,6 +1,7 @@
package ru.pjandro.wordpdf.internal.chart;
import org.junit.jupiter.api.Test;
+import java.util.List;
import java.awt.Color;
import java.awt.image.BufferedImage;
@@ -99,4 +100,328 @@ class ChartRendererTest {
int b = rgb & 0xFF;
return Math.max(Math.max(r, g), b) - Math.min(Math.min(r, g), b) > 25;
}
+
+ // ---- ветви компоновки, не затронутые регрессией overlay ----
+
+ /** valueRange: null-дыры, все отрицательные, все нули. */
+ @Test
+ void valueRangeEdgeCases() {
+ ChartSpec spec = new ChartSpec();
+ assertArrayEquals(new double[]{0, 1}, ChartRenderer.valueRange(spec),
+ "нет значений — дефолтный диапазон");
+ ChartSpec.Series s = new ChartSpec.Series();
+ s.values.add(null);
+ spec.series.add(s);
+ assertArrayEquals(new double[]{0, 1}, ChartRenderer.valueRange(spec),
+ "одни null — дефолтный диапазон");
+ s.values.add(-5.0);
+ s.values.add(-2.0);
+ assertArrayEquals(new double[]{-5, 0}, ChartRenderer.valueRange(spec),
+ "отрицательные значения — верх на нуле");
+ ChartSpec zeros = new ChartSpec();
+ ChartSpec.Series z = new ChartSpec.Series();
+ z.values.add(0.0);
+ z.values.add(0.0);
+ zeros.series.add(z);
+ assertArrayEquals(new double[]{0, 1}, ChartRenderer.valueRange(zeros),
+ "нулевой размах — расширяем до 1");
+ }
+
+ /** niceUnit/nextUnit: границы 1/2/5·10ⁿ и невалидный вход. */
+ @Test
+ void niceAndNextUnitBoundaries() {
+ assertEquals(1, ChartRenderer.niceUnit(-1), 0.001);
+ assertEquals(1, ChartRenderer.niceUnit(Double.POSITIVE_INFINITY), 0.001);
+ assertEquals(500, ChartRenderer.niceUnit(500), 0.001);
+ assertEquals(1000, ChartRenderer.niceUnit(700), 0.001);
+ assertEquals(2, ChartRenderer.nextUnit(1), 0.001);
+ assertEquals(5, ChartRenderer.nextUnit(2), 0.001);
+ assertEquals(10, ChartRenderer.nextUnit(5), 0.001);
+ }
+
+ /** axisBounds: null-ось, явные min/max, непригодный majorUnit, hi<=lo. */
+ @Test
+ void axisBoundsExplicitAndDegenerate() {
+ assertArrayEquals(new double[]{0, 10, 2}, ChartRenderer.axisBounds(null, 0, 10));
+ ChartSpec.AxisSpec ax = new ChartSpec.AxisSpec();
+ ax.min = 5.0;
+ ax.max = 6.0;
+ assertArrayEquals(new double[]{5, 6, 2}, ChartRenderer.axisBounds(ax, 0, 10));
+ ChartSpec.AxisSpec zeroUnit = new ChartSpec.AxisSpec();
+ zeroUnit.majorUnit = 0.0;
+ assertArrayEquals(new double[]{0, 10, 2}, ChartRenderer.axisBounds(zeroUnit, 0, 10),
+ "majorUnit=0 — непригоден, считаем свой шаг");
+ ChartSpec.AxisSpec tinyUnit = new ChartSpec.AxisSpec();
+ tinyUnit.majorUnit = 0.001;
+ assertArrayEquals(new double[]{0, 10, 2}, ChartRenderer.axisBounds(tinyUnit, 0, 10),
+ "шаг даёт больше MAX_TICKS делений — непригоден");
+ ChartSpec.AxisSpec inverted = new ChartSpec.AxisSpec();
+ inverted.min = 10.0;
+ inverted.max = 5.0;
+ double[] b = ChartRenderer.axisBounds(inverted, 0, 10);
+ assertEquals(10.0, b[0], 0.001);
+ assertEquals(12.0, b[1], 0.001, "hi<=lo — поднимаем до lo+unit");
+ }
+
+ /** formatValue: 0.00/0.0/General/null. */
+ @Test
+ void formatValueFormats() {
+ assertEquals("1.50", ChartRenderer.formatValue(1.5, "0.00"));
+ assertEquals("1.5", ChartRenderer.formatValue(1.5, "0.0"));
+ assertEquals("2", ChartRenderer.formatValue(2.0, "General"));
+ assertEquals("2.35", ChartRenderer.formatValue(2.345, "General"));
+ assertEquals("2", ChartRenderer.formatValue(2.0, null));
+ }
+
+ /** polyline(close=true) замыкает контур сегментом SEG_CLOSE. */
+ @Test
+ void polylineClosed() {
+ java.awt.geom.Path2D p = ChartRenderer.polyline(
+ List.of(0.0, 1.0, 1.0), List.of(0.0, 0.0, 1.0), true);
+ java.awt.geom.PathIterator it = p.getPathIterator(null);
+ boolean closed = false;
+ float[] coords = new float[6];
+ while (!it.isDone()) {
+ if (it.currentSegment(coords) == java.awt.geom.PathIterator.SEG_CLOSE) {
+ closed = true;
+ }
+ it.next();
+ }
+ assertTrue(closed, "close=true должен добавлять SEG_CLOSE");
+ }
+
+ /** Легенда с c:legendPos=t рисуется в верхней полосе. */
+ @Test
+ void topLegendDrawnAtTop() {
+ ChartSpec spec = lineSpec(false);
+ spec.legendPos = "t";
+ BufferedImage img = ChartRenderer.render(spec, 219.23, 149.08, new DrawMlColor(null));
+ assertTrue(hasSaturated(img, img.getWidth() / 2, 0, img.getHeight() / 4),
+ "легенда с c:legendPos=t не в верхней полосе");
+ }
+
+ /** chartFill=null — фон остаётся прозрачным. */
+ @Test
+ void nullChartFillKeepsBackgroundTransparent() {
+ ChartSpec spec = lineSpec(false);
+ spec.chartFill = null;
+ spec.chartBorder = null;
+ BufferedImage img = ChartRenderer.render(spec, 120, 80, new DrawMlColor(null));
+ assertEquals(0, img.getRGB(1, 1) >>> 24, "chartFill=null — угол прозрачен");
+ }
+
+ /** Длинный заголовок в узком боксе переносится — тёмных пикселей больше. */
+ @Test
+ void longTitleWrapsToTwoLines() {
+ DrawMlText.Style style = new DrawMlText.Style(9, false, false, Color.DARK_GRAY, "carlito");
+ ChartSpec longT = lineSpec(false);
+ longT.title = "Очень длинный заголовок диаграммы который точно не влезет в узкий бокс";
+ longT.titleStyle = style;
+ ChartSpec shortT = lineSpec(false);
+ shortT.title = "Заголовок";
+ shortT.titleStyle = style;
+ int darkLong = countDark(ChartRenderer.render(longT, 90, 120, new DrawMlColor(null)));
+ int darkShort = countDark(ChartRenderer.render(shortT, 90, 120, new DrawMlColor(null)));
+ assertTrue(darkLong > darkShort,
+ "длинный заголовок не перенесён: darkLong=" + darkLong + ", darkShort=" + darkShort);
+ }
+
+ /** PIE без рядов — ничего не рисуется; круг с значениями без категорий — квадратики легенды. */
+ @Test
+ void pieLegendDegenerateCases() {
+ ChartSpec noSeries = new ChartSpec();
+ noSeries.type = ChartSpec.Type.PIE;
+ noSeries.legendPos = "b";
+ assertFalse(anySaturated(ChartRenderer.render(noSeries, 100, 80, new DrawMlColor(null))),
+ "нет рядов — рисовать нечего");
+
+ ChartSpec noCats = new ChartSpec();
+ noCats.type = ChartSpec.Type.DOUGHNUT;
+ noCats.legendPos = "b";
+ ChartSpec.Series s = new ChartSpec.Series();
+ s.values.add(1.0);
+ s.values.add(2.0);
+ noCats.series.add(s);
+ BufferedImage img = ChartRenderer.render(noCats, 100, 80, new DrawMlColor(null));
+ noCats.legendPos = null;
+ BufferedImage plain = ChartRenderer.render(noCats, 100, 80, new DrawMlColor(null));
+ assertTrue(saturatedBottom(img) < saturatedBottom(plain),
+ "легенда без подписей не забрала место у диаграммы");
+ }
+
+ /** Surface3D: все null — ни полос, ни легенды; с bandColors — легенда в цветах полос. */
+ @Test
+ void surfaceLegendVariants() {
+ ChartSpec allNull = new ChartSpec();
+ allNull.type = ChartSpec.Type.SURFACE3D;
+ allNull.legendPos = "b";
+ ChartSpec.Series n = new ChartSpec.Series();
+ n.values.add(null);
+ allNull.series.add(n);
+ assertFalse(anySaturated(ChartRenderer.render(allNull, 120, 90, new DrawMlColor(null))),
+ "значений нет — полос и легенды нет");
+
+ ChartSpec withBands = new ChartSpec();
+ withBands.type = ChartSpec.Type.SURFACE3D;
+ withBands.legendPos = "b";
+ ChartSpec.Series s1 = new ChartSpec.Series();
+ s1.values.add(1.0);
+ s1.values.add(2.0);
+ ChartSpec.Series s2 = new ChartSpec.Series();
+ s2.values.add(3.0);
+ s2.values.add(null);
+ withBands.series.add(s1);
+ withBands.series.add(s2);
+ withBands.bandColors.add(Color.MAGENTA);
+ assertTrue(anySaturated(ChartRenderer.render(withBands, 160, 120, new DrawMlColor(null))),
+ "surface с данными и полосами должен рисоваться");
+ }
+
+ /** BAR: легенда без имени ряда — квадратик; без рядов — легенды нет. */
+ @Test
+ void barLegendDefaultSquareAndNameless() {
+ ChartSpec bar = new ChartSpec();
+ bar.type = ChartSpec.Type.BAR;
+ bar.legendPos = "b";
+ bar.catAxis = new ChartSpec.AxisSpec();
+ bar.catAxis.labelStyle = new DrawMlText.Style(9, false, false,
+ new Color(0x59, 0x59, 0x59), "carlito");
+ bar.valAxis = bar.catAxis;
+ ChartSpec.Series s = new ChartSpec.Series();
+ s.values.add(1.0);
+ s.categories.add("Q1");
+ bar.series.add(s);
+ BufferedImage img = ChartRenderer.render(bar, 140, 100, new DrawMlColor(null));
+ bar.legendPos = null;
+ BufferedImage plain = ChartRenderer.render(bar, 140, 100, new DrawMlColor(null));
+ int strip = (int) (img.getHeight() * 0.85);
+ assertTrue(anySaturatedInStrip(img, strip), "легенда BAR без имени — квадратик цвета ряда");
+ assertFalse(anySaturatedInStrip(plain, strip), "без легенды в нижней полосе пусто");
+
+ ChartSpec empty = new ChartSpec();
+ empty.type = ChartSpec.Type.BAR;
+ empty.legendPos = "b";
+ assertFalse(anySaturated(ChartRenderer.render(empty, 140, 100, new DrawMlColor(null))),
+ "нет рядов — нечего показывать в легенде");
+ }
+
+ /** LINE с явной толщиной: линия легенды и кривая толще дефолта. */
+ @Test
+ void lineLegendUsesSeriesLineWidth() {
+ ChartSpec spec = lineSpec(false);
+ spec.series.get(0).lineWidth = 4.0;
+ BufferedImage thick = ChartRenderer.render(spec, 219.23, 149.08, new DrawMlColor(null));
+ BufferedImage thin = ChartRenderer.render(lineSpec(false), 219.23, 149.08,
+ new DrawMlColor(null));
+ assertTrue(countSaturated(thick) > countSaturated(thin),
+ "lineWidth=4 не толще дефолта: thick=" + countSaturated(thick)
+ + ", thin=" + countSaturated(thin));
+ }
+
+ /** UNSUPPORTED и BAR_HORIZONTAL проходят компоновку без падения. */
+ @Test
+ void unsupportedAndHorizontalBarRender() {
+ ChartSpec unsupported = new ChartSpec();
+ unsupported.type = ChartSpec.Type.UNSUPPORTED;
+ assertFalse(anySaturated(ChartRenderer.render(unsupported, 60, 40, new DrawMlColor(null))),
+ "UNSUPPORTED не должен рисовать содержимое");
+
+ ChartSpec horizontal = new ChartSpec();
+ horizontal.type = ChartSpec.Type.BAR_HORIZONTAL;
+ horizontal.catAxis = new ChartSpec.AxisSpec();
+ horizontal.catAxis.labelStyle = new DrawMlText.Style(9, false, false,
+ new Color(0x59, 0x59, 0x59), "carlito");
+ horizontal.valAxis = horizontal.catAxis;
+ ChartSpec.Series s = new ChartSpec.Series();
+ s.values.add(1.0);
+ s.values.add(2.0);
+ s.categories.add("A");
+ s.categories.add("B");
+ horizontal.series.add(s);
+ assertTrue(anySaturated(ChartRenderer.render(horizontal, 140, 100, new DrawMlColor(null))),
+ "BAR_HORIZONTAL не нарисовался");
+ }
+
+ /** PIE с overlay: легенда поверх, секторы рисуются. */
+ @Test
+ void pieWithOverlayLegend() {
+ ChartSpec spec = new ChartSpec();
+ spec.type = ChartSpec.Type.PIE;
+ spec.legendPos = "b";
+ spec.legendOverlay = true;
+ ChartSpec.Series s = new ChartSpec.Series();
+ s.values.add(1.0);
+ s.values.add(1.0);
+ s.categories.add("A");
+ s.categories.add("B");
+ spec.series.add(s);
+ assertTrue(anySaturated(ChartRenderer.render(spec, 120, 120, new DrawMlColor(null))),
+ "pie с overlay-легендой не нарисовался");
+ }
+
+ private static boolean anySaturated(BufferedImage img) {
+ for (int y = 0; y < img.getHeight(); y++) {
+ for (int x = 0; x < img.getWidth(); x++) {
+ if (saturated(img.getRGB(x, y))) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ private static int countSaturated(BufferedImage img) {
+ int n = 0;
+ for (int y = 0; y < img.getHeight(); y++) {
+ for (int x = 0; x < img.getWidth(); x++) {
+ if (saturated(img.getRGB(x, y))) {
+ n++;
+ }
+ }
+ }
+ return n;
+ }
+
+ /** Тёмные ахроматичные пиксели (текст заголовка). */
+ private static int countDark(BufferedImage img) {
+ int n = 0;
+ for (int y = 0; y < img.getHeight(); y++) {
+ for (int x = 0; x < img.getWidth(); x++) {
+ int rgb = img.getRGB(x, y);
+ int a = rgb >>> 24;
+ int r = (rgb >> 16) & 0xFF;
+ int g = (rgb >> 8) & 0xFF;
+ int b = rgb & 0xFF;
+ if (a > 128 && Math.max(Math.max(r, g), b) - Math.min(Math.min(r, g), b) <= 25
+ && r < 0x80) {
+ n++;
+ }
+ }
+ }
+ return n;
+ }
+
+ /** Нижняя насыщенная строка; -1 — нет таких. */
+ private static int saturatedBottom(BufferedImage img) {
+ for (int y = img.getHeight() - 1; y >= 0; y--) {
+ for (int x = 0; x < img.getWidth(); x++) {
+ if (saturated(img.getRGB(x, y))) {
+ return y;
+ }
+ }
+ }
+ return -1;
+ }
+
+ /** Есть ли насыщенный пиксель ниже строки y0. */
+ private static boolean anySaturatedInStrip(BufferedImage img, int y0) {
+ for (int y = y0; y < img.getHeight(); y++) {
+ for (int x = 0; x < img.getWidth(); x++) {
+ if (saturated(img.getRGB(x, y))) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
}
diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/ChartSpecTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/ChartSpecTest.java
index e2989cd..c7ec0dd 100644
--- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/ChartSpecTest.java
+++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/ChartSpecTest.java
@@ -18,6 +18,7 @@ import org.docx4j.dml.chart.CTBandFmts;
import org.docx4j.dml.chart.CTBarChart;
import org.docx4j.dml.chart.CTBarDir;
import org.docx4j.dml.chart.CTBarSer;
+import org.docx4j.dml.chart.CTCatAx;
import org.docx4j.dml.chart.CTBoolean;
import org.docx4j.dml.chart.CTChart;
import org.docx4j.dml.chart.CTChartLines;
@@ -54,6 +55,7 @@ import org.docx4j.dml.chart.CTStrData;
import org.docx4j.dml.chart.CTStrRef;
import org.docx4j.dml.chart.CTStrVal;
import org.docx4j.dml.chart.CTSurface3DChart;
+import org.docx4j.dml.chart.CTSurfaceSer;
import org.docx4j.dml.chart.CTTitle;
import org.docx4j.dml.chart.CTTx;
import org.docx4j.dml.chart.CTUnsignedInt;
@@ -741,4 +743,380 @@ class ChartSpecTest {
chart.setAutoTitleDeleted(keep);
return chart;
}
+
+ // ---- ветви разбора, не затронутые основными тестами ----
+
+ /** a:ln без noFill/solidFill/w и пустой solidFill — дефолты рамки сохраняются. */
+ @Test
+ void chartFramePartialLineKeepsDefaults() {
+ CTChartSpace space = spaceWith(new CTChart());
+ CTShapeProperties sp = new CTShapeProperties();
+ sp.setSolidFill(new CTSolidColorFillProperties());
+ CTLineProperties ln = new CTLineProperties();
+ ln.setSolidFill(new CTSolidColorFillProperties());
+ sp.setLn(ln);
+ space.setSpPr(sp);
+ ChartSpec spec = ChartSpec.parse(space, new DrawMlColor(null));
+ assertEquals(Color.WHITE, spec.chartFill, "нерезолвленный fill — дефолт");
+ assertEquals(new Color(0xBF, 0xBF, 0xBF), spec.chartBorder, "a:ln без цвета — дефолтная рамка");
+ assertEquals(0.75, spec.chartBorderWidth, 0.001);
+ }
+
+ /** spPr chartSpace без a:ln — рамка не трогается. */
+ @Test
+ void chartFrameFillOnlyKeepsBorder() {
+ CTChartSpace space = spaceWith(new CTChart());
+ CTShapeProperties sp = new CTShapeProperties();
+ sp.setSolidFill(fill("FFFFFF"));
+ space.setSpPr(sp);
+ ChartSpec spec = ChartSpec.parse(space, new DrawMlColor(null));
+ assertEquals(Color.WHITE, spec.chartFill);
+ assertNotNull(spec.chartBorder);
+ }
+
+ /** c:view3D без дочерних элементов — все дефолты. */
+ @Test
+ void emptyView3DKeepsDefaults() {
+ CTChart chart = new CTChart();
+ chart.setView3D(new CTView3D());
+ ChartSpec spec = ChartSpec.parse(spaceWith(chart), new DrawMlColor(null));
+ assertEquals(30, spec.rotX);
+ assertEquals(0, spec.rotY);
+ assertTrue(spec.rightAngledAxes);
+ }
+
+ /** c:marker без c:symbol — маркер есть, символ не задан; symbol=circle — маркер есть. */
+ @Test
+ void lineMarkerSymbolVariants() {
+ CTLineChart line = new CTLineChart();
+ CTLineSer noSymbol = new CTLineSer();
+ noSymbol.setMarker(new CTMarker());
+ CTLineSer circle = new CTLineSer();
+ CTMarker m = new CTMarker();
+ CTMarkerStyle sym = new CTMarkerStyle();
+ sym.setVal(STMarkerStyle.CIRCLE);
+ m.setSymbol(sym);
+ circle.setMarker(m);
+ CTLineSer bare = new CTLineSer();
+ line.getSer().add(noSymbol);
+ line.getSer().add(circle);
+ line.getSer().add(bare);
+ ChartSpec spec = new ChartSpec();
+ ChartSpec.readGroup(line, spec, new DrawMlColor(null), List.of());
+ assertTrue(spec.series.get(0).marker);
+ assertNull(spec.series.get(0).markerSymbol);
+ assertTrue(spec.series.get(1).marker);
+ assertEquals("circle", spec.series.get(1).markerSymbol);
+ assertTrue(spec.series.get(2).marker);
+ }
+
+ /** c:barDir без c:val и barDir=col — вертикальные столбцы. */
+ @Test
+ void barDirWithoutValAndColStayVertical() {
+ CTBarChart noVal = new CTBarChart();
+ noVal.setBarDir(new CTBarDir());
+ ChartSpec spec1 = new ChartSpec();
+ ChartSpec.readGroup(noVal, spec1, new DrawMlColor(null), List.of());
+ assertEquals(ChartSpec.Type.BAR, spec1.type);
+
+ CTBarChart col = new CTBarChart();
+ CTBarDir dir = new CTBarDir();
+ dir.setVal(STBarDir.COL);
+ col.setBarDir(dir);
+ ChartSpec spec2 = new ChartSpec();
+ ChartSpec.readGroup(col, spec2, new DrawMlColor(null), List.of());
+ assertEquals(ChartSpec.Type.BAR, spec2.type);
+ }
+
+ /** c:spPr ряда без c:solidFill (bar/area), a:ln без цвета и неизвестная группа. */
+ @Test
+ void seriesShapeWithoutFillAndUnknownGroup() {
+ CTBarChart bar = new CTBarChart();
+ CTBarSer barSer = new CTBarSer();
+ barSer.setSpPr(new CTShapeProperties());
+ bar.getSer().add(barSer);
+ ChartSpec barSpec = new ChartSpec();
+ ChartSpec.readGroup(bar, barSpec, new DrawMlColor(null), List.of());
+ assertNull(barSpec.series.get(0).fill);
+
+ CTAreaChart area = new CTAreaChart();
+ CTAreaSer areaSer = new CTAreaSer();
+ areaSer.setSpPr(new CTShapeProperties());
+ areaSer.getSpPr().setLn(new CTLineProperties());
+ area.getSer().add(areaSer);
+ ChartSpec areaSpec = new ChartSpec();
+ ChartSpec.readGroup(area, areaSpec, new DrawMlColor(null), List.of());
+ assertNull(areaSpec.series.get(0).fill);
+ assertNull(areaSpec.series.get(0).lineColor);
+ assertEquals(-1, areaSpec.series.get(0).lineWidth, 0.001);
+
+ ChartSpec unknown = new ChartSpec();
+ ChartSpec.readGroup("не-группа", unknown, new DrawMlColor(null), List.of());
+ assertEquals(ChartSpec.Type.UNSUPPORTED, unknown.type);
+ }
+
+ /** surface3D: ряд со своим цветом, bandFmt с пустым spPr и с нерезолвленным цветом. */
+ @Test
+ void surfaceSeriesFillAndPartialBandFmt() {
+ ChartSpec bare = new ChartSpec();
+ ChartSpec.readGroup(new CTSurface3DChart(), bare, new DrawMlColor(null), List.of());
+ assertEquals(ChartSpec.Type.SURFACE3D, bare.type, "surface без bandFmts — тип не теряется");
+
+ CTSurface3DChart surf = new CTSurface3DChart();
+ CTSurfaceSer ser = new CTSurfaceSer();
+ CTShapeProperties sp = new CTShapeProperties();
+ sp.setSolidFill(fill("0A0B0C"));
+ ser.setSpPr(sp);
+ surf.getSer().add(ser);
+ CTBandFmts fmts = new CTBandFmts();
+ CTBandFmt emptySpPr = new CTBandFmt();
+ emptySpPr.setIdx(uint(0));
+ emptySpPr.setSpPr(new CTShapeProperties());
+ CTBandFmt unresolvable = new CTBandFmt();
+ unresolvable.setIdx(uint(1));
+ CTShapeProperties badSp = new CTShapeProperties();
+ badSp.setSolidFill(new CTSolidColorFillProperties());
+ unresolvable.setSpPr(badSp);
+ fmts.getBandFmt().add(emptySpPr);
+ fmts.getBandFmt().add(unresolvable);
+ surf.setBandFmts(fmts);
+ ChartSpec spec = new ChartSpec();
+ ChartSpec.readGroup(surf, spec, new DrawMlColor(null), List.of(Color.RED, Color.BLUE));
+ assertEquals(new Color(0x0A, 0x0B, 0x0C), spec.series.get(0).fill);
+ assertEquals(List.of(Color.RED, Color.BLUE), spec.bandColors);
+ }
+
+ /** c:pie ser spPr без a:ln и a:ln без цвета — аутлайн не задан. */
+ @Test
+ void pieOutlinePartialVariants() {
+ CTPieChart pie = new CTPieChart();
+ CTPieSer noLn = new CTPieSer();
+ CTShapeProperties sp1 = new CTShapeProperties();
+ sp1.setSolidFill(fill("010203"));
+ noLn.setSpPr(sp1);
+ CTPieSer emptyLn = new CTPieSer();
+ CTShapeProperties sp2 = new CTShapeProperties();
+ sp2.setLn(new CTLineProperties());
+ emptyLn.setSpPr(sp2);
+ pie.getSer().add(noLn);
+ pie.getSer().add(emptyLn);
+ ChartSpec spec = new ChartSpec();
+ ChartSpec.readGroup(pie, spec, new DrawMlColor(null), List.of());
+ assertNull(spec.series.get(0).outlineColor);
+ assertFalse(spec.series.get(0).outlineNoFill);
+ assertNull(spec.series.get(1).outlineColor);
+ }
+
+ /** c:val без кэша — значений нет; неполные/нерезолвленные c:dPt пропускаются. */
+ @Test
+ void missingValueCacheAndIncompleteDataPoints() {
+ CTBarChart bar = new CTBarChart();
+ CTBarSer ser = new CTBarSer();
+ ser.setVal(new CTNumDataSource());
+ CTDPt noFillSpPr = new CTDPt();
+ noFillSpPr.setIdx(uint(0));
+ noFillSpPr.setSpPr(new CTShapeProperties());
+ CTDPt noIdx = new CTDPt();
+ CTShapeProperties sp = new CTShapeProperties();
+ sp.setSolidFill(fill("FF0000"));
+ noIdx.setSpPr(sp);
+ CTDPt badColor = new CTDPt();
+ badColor.setIdx(uint(1));
+ CTShapeProperties badSp = new CTShapeProperties();
+ badSp.setSolidFill(new CTSolidColorFillProperties());
+ badColor.setSpPr(badSp);
+ ser.getDPt().add(noFillSpPr);
+ ser.getDPt().add(noIdx);
+ ser.getDPt().add(badColor);
+ bar.getSer().add(ser);
+ ChartSpec spec = new ChartSpec();
+ ChartSpec.readGroup(bar, spec, new DrawMlColor(null), List.of());
+ ChartSpec.Series s = spec.series.get(0);
+ assertTrue(s.values.isEmpty(), "c:val без numCache — значений нет");
+ assertTrue(s.pointFills.isEmpty(), "неполные c:dPt пропускаются");
+ }
+
+ /** c:title: strRef без кэша/без точек не даёт текст, strRef приоритетнее a:rich. */
+ @Test
+ void titleStrRefWithoutCacheFallsThroughAndWinsOverRich() {
+ CTChart chart = new CTChart();
+ CTTitle title = new CTTitle();
+ CTTx tx = new CTTx();
+ tx.setStrRef(new CTStrRef());
+ title.setTx(tx);
+ chart.setTitle(title);
+ ChartSpec spec = new ChartSpec();
+ ChartSpec.readTitle(chart, spec, new DrawMlColor(null));
+ assertEquals(ChartSpec.AUTO_TITLE, spec.title, "пустой strRef — автозаголовок");
+
+ CTChart chart2 = new CTChart();
+ CTTitle title2 = new CTTitle();
+ CTTx tx2 = new CTTx();
+ tx2.setStrRef(strRef("Главный"));
+ CTTextBody rich = new CTTextBody();
+ CTTextParagraph p = new CTTextParagraph();
+ CTRegularTextRun run = new CTRegularTextRun();
+ run.setT("Второстепенный");
+ p.getEGTextRun().add(run);
+ rich.getP().add(p);
+ tx2.setRich(rich);
+ title2.setTx(tx2);
+ chart2.setTitle(title2);
+ ChartSpec spec2 = new ChartSpec();
+ ChartSpec.readTitle(chart2, spec2, new DrawMlColor(null));
+ assertEquals("Главный", spec2.title, "c:strRef приоритетнее a:rich");
+
+ CTChart chart3 = new CTChart();
+ CTTitle title3 = new CTTitle();
+ CTTx tx3 = new CTTx();
+ CTStrRef emptyRef = new CTStrRef();
+ emptyRef.setStrCache(new CTStrData());
+ tx3.setStrRef(emptyRef);
+ title3.setTx(tx3);
+ chart3.setTitle(title3);
+ ChartSpec spec3 = new ChartSpec();
+ ChartSpec.readTitle(chart3, spec3, new DrawMlColor(null));
+ assertEquals(ChartSpec.AUTO_TITLE, spec3.title, "strCache без точек — автозаголовок");
+ }
+
+ /** Пробельный текст заголовка — тот же автозаголовок, что и пустой. */
+ @Test
+ void blankTitleFallsBackToAutoTitle() {
+ CTChart chart = emptyTitleChart();
+ CTTitle title = chart.getTitle();
+ CTTx tx = new CTTx();
+ CTTextBody body = new CTTextBody();
+ CTTextParagraph p = new CTTextParagraph();
+ CTRegularTextRun run = new CTRegularTextRun();
+ run.setT(" ");
+ p.getEGTextRun().add(run);
+ body.getP().add(p);
+ tx.setRich(body);
+ title.setTx(tx);
+ ChartSpec spec = new ChartSpec();
+ ChartSpec.readTitle(chart, spec, new DrawMlColor(null));
+ assertEquals(ChartSpec.AUTO_TITLE, spec.title);
+ }
+
+ /** Пустой заголовок круговой диаграммы без рядов — плейсхолдер; ряд без имени — заголовка нет. */
+ @Test
+ void circularAutoTitleEdgeCases() {
+ ChartSpec doughnut = new ChartSpec();
+ doughnut.type = ChartSpec.Type.DOUGHNUT;
+ ChartSpec.readTitle(emptyTitleChart(), doughnut, new DrawMlColor(null));
+ assertEquals(ChartSpec.AUTO_TITLE, doughnut.title, "круговая без рядов — плейсхолдер");
+
+ ChartSpec pie = new ChartSpec();
+ pie.type = ChartSpec.Type.PIE;
+ pie.series.add(new ChartSpec.Series());
+ ChartSpec.readTitle(emptyTitleChart(), pie, new DrawMlColor(null));
+ assertNull(pie.title, "ряд без имени — заголовок не ставится");
+ }
+
+ /** c:catAx разбирается полностью; c:valAx без c:numFmt — General; dateAx со своим numFmt. */
+ @Test
+ void catAxisParsedAndAxesWithoutNumFmtDefault() {
+ CTChart chart = new CTChart();
+ CTPlotArea pa = new CTPlotArea();
+ CTCatAx cat = new CTCatAx();
+ CTNumFmt fmt = new CTNumFmt();
+ fmt.setFormatCode("0");
+ cat.setNumFmt(fmt);
+ cat.setAxPos(new CTAxPos());
+ CTShapeProperties spPr = new CTShapeProperties();
+ CTLineProperties ln = new CTLineProperties();
+ ln.setSolidFill(fill("123456"));
+ ln.setW(12700);
+ spPr.setLn(ln);
+ cat.setSpPr(spPr);
+ CTChartLines grid = new CTChartLines();
+ CTShapeProperties gsp = new CTShapeProperties();
+ CTLineProperties gln = new CTLineProperties();
+ gln.setSolidFill(new CTSolidColorFillProperties());
+ gsp.setLn(gln);
+ grid.setSpPr(gsp);
+ cat.setMajorGridlines(grid);
+ pa.getValAxOrCatAxOrDateAx().add(cat);
+ pa.getValAxOrCatAxOrDateAx().add(new CTValAx());
+ CTDateAx date = new CTDateAx();
+ CTNumFmt dfmt = new CTNumFmt();
+ dfmt.setFormatCode("dd.mm");
+ date.setNumFmt(dfmt);
+ pa.getValAxOrCatAxOrDateAx().add(date);
+ chart.setPlotArea(pa);
+ ChartSpec spec = ChartSpec.parse(spaceWith(chart), new DrawMlColor(null));
+ assertEquals("0", spec.catAxis.numFmt);
+ assertEquals("b", spec.catAxis.pos, "c:axPos без c:val — дефолт");
+ assertEquals(new Color(0x12, 0x34, 0x56), spec.catAxis.axisLineColor);
+ assertEquals(1.0, spec.catAxis.axisLineWidth, 0.001);
+ assertEquals(new Color(0xD9, 0xD9, 0xD9), spec.catAxis.gridColor,
+ "нерезолвленный цвет сетки — дефолт");
+ assertEquals("General", spec.valAxis.numFmt);
+ }
+
+ /** c:tx/c:strRef без кэша — имени ряда нет. */
+ @Test
+ void seriesNameStrRefWithoutCache() {
+ CTBarChart bar = new CTBarChart();
+ CTBarSer ser = new CTBarSer();
+ CTSerTx tx = new CTSerTx();
+ tx.setStrRef(new CTStrRef());
+ ser.setTx(tx);
+ bar.getSer().add(ser);
+ ChartSpec spec = new ChartSpec();
+ ChartSpec.readGroup(bar, spec, new DrawMlColor(null), List.of());
+ assertNull(spec.series.get(0).name);
+ }
+
+ /** Категории: c:strLit/c:numLit с пустым c:v и пустой источник. */
+ @Test
+ void categorySourceVariants() {
+ CTAxDataSource strLit = new CTAxDataSource();
+ CTStrData sd = new CTStrData();
+ CTStrVal nullV = new CTStrVal();
+ nullV.setIdx(0);
+ sd.getPt().add(nullV);
+ strLit.setStrLit(sd);
+
+ CTAxDataSource numLit = new CTAxDataSource();
+ CTNumData nd = new CTNumData();
+ CTNumVal npt = new CTNumVal();
+ npt.setIdx(1);
+ nd.getPt().add(npt);
+ numLit.setNumLit(nd);
+
+ CTAxDataSource empty = new CTAxDataSource();
+
+ CTBarChart bar = new CTBarChart();
+ for (CTAxDataSource cat : List.of(strLit, numLit, empty)) {
+ CTBarSer ser = new CTBarSer();
+ ser.setCat(cat);
+ bar.getSer().add(ser);
+ }
+ ChartSpec spec = new ChartSpec();
+ ChartSpec.readGroup(bar, spec, new DrawMlColor(null), List.of());
+ assertEquals(List.of(""), spec.series.get(0).categories);
+ assertEquals(List.of("", ""), spec.series.get(1).categories);
+ assertTrue(spec.series.get(2).categories.isEmpty());
+ }
+
+ /** c:v пустая строка — null (дыра), а не 0. */
+ @Test
+ void blankValuePointBecomesNull() {
+ CTNumData cache = new CTNumData();
+ cache.getPt().add(numPt(0, " "));
+ CTChart chart = barChartWithVal(numSource(cache));
+ ChartSpec spec = ChartSpec.parse(spaceWith(chart), new DrawMlColor(null));
+ assertNull(spec.series.get(0).values.get(0));
+ }
+
+ /** c:dPt перекрывает c:fill ряда, c:fill перекрывает палитру. */
+ @Test
+ void explicitSeriesFillWinsOverPalette() {
+ ChartSpec.Series s = new ChartSpec.Series();
+ s.fill = Color.MAGENTA;
+ s.pointFills.put(0, Color.BLUE);
+ assertEquals(Color.BLUE, s.fillAt(0, List.of(Color.RED)), "c:dPt приоритетнее c:fill");
+ assertEquals(Color.MAGENTA, s.fillAt(1, List.of(Color.RED)), "c:fill приоритетнее палитры");
+ }
}
diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/DrawMlTextTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/DrawMlTextTest.java
index 703d3c4..fc4bd6d 100644
--- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/DrawMlTextTest.java
+++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/DrawMlTextTest.java
@@ -11,14 +11,18 @@ import org.docx4j.dml.TextFont;
import org.junit.jupiter.api.Test;
import ru.pjandro.wordpdf.fonts.BundledFonts;
+import org.docx4j.dml.CTTextLineBreak;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.util.List;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
+import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
@@ -161,4 +165,115 @@ class DrawMlTextTest {
new Rectangle2D.Double(0, 0, 20, 120), null, "t");
assertTrue(inkBands(img) >= 3, "длинное слово режется по символам");
}
+ /** Пустое тело a:txPr — фолбэк-стиль. */
+ @Test
+ void defaultStyleEmptyBodyFallsBack() {
+ DrawMlText.Style def = DrawMlText.defaultStyle(new CTTextBody(),
+ new DrawMlColor(null), "DejaVu Sans", 9, Color.GRAY);
+ assertEquals(9, def.sizePt());
+ assertEquals(Color.GRAY, def.color());
+ }
+
+ /** a:br и пустой запуск пропускаются; pPr без algn и без pPr — align null; latin без typeface — без эффекта. */
+ @Test
+ void paragraphsSkipsBreaksAndEmptyRuns() {
+ DrawMlColor colors = new DrawMlColor(null);
+ CTTextBody body = new CTTextBody();
+ CTTextParagraph p = new CTTextParagraph();
+ p.setPPr(new CTTextParagraphProperties());
+ p.getEGTextRun().add(new CTTextLineBreak());
+ CTRegularTextRun empty = new CTRegularTextRun();
+ CTTextCharacterProperties noFace = new CTTextCharacterProperties();
+ noFace.setLatin(new TextFont());
+ empty.setRPr(noFace);
+ p.getEGTextRun().add(empty);
+ CTRegularTextRun run = new CTRegularTextRun();
+ run.setT("Текст");
+ p.getEGTextRun().add(run);
+ body.getP().add(p);
+ CTTextParagraph bare = new CTTextParagraph();
+ CTRegularTextRun bareRun = new CTRegularTextRun();
+ bareRun.setT("x");
+ bare.getEGTextRun().add(bareRun);
+ body.getP().add(bare);
+ List paras = DrawMlText.paragraphs(body, colors,
+ "DejaVu Sans", 9, Color.GRAY);
+ assertEquals(2, paras.size());
+ assertEquals("Текст", paras.get(0).text());
+ assertNull(paras.get(0).align(), "pPr без algn — выравнивание наследует defAlign");
+ assertEquals("x", paras.get(1).text());
+ assertNull(paras.get(1).align());
+ }
+
+ /** «+mn-lt» без темы — фолбэк-семейство; литеральный typeface — алиас бандла. */
+ @Test
+ void paragraphsResolveThemeAndLiteralTypefaces() {
+ DrawMlColor colors = new DrawMlColor(null);
+ CTTextBody body = new CTTextBody();
+ CTTextParagraph p = new CTTextParagraph();
+ CTRegularTextRun minor = new CTRegularTextRun();
+ CTTextCharacterProperties rPr = new CTTextCharacterProperties();
+ TextFont mn = new TextFont();
+ mn.setTypeface("+mn-lt");
+ rPr.setLatin(mn);
+ minor.setRPr(rPr);
+ minor.setT("m");
+ p.getEGTextRun().add(minor);
+ CTRegularTextRun literal = new CTRegularTextRun();
+ CTTextCharacterProperties litPr = new CTTextCharacterProperties();
+ TextFont tinos = new TextFont();
+ tinos.setTypeface("Tinos");
+ litPr.setLatin(tinos);
+ literal.setRPr(litPr);
+ literal.setT("t");
+ p.getEGTextRun().add(literal);
+ body.getP().add(p);
+ List paras = DrawMlText.paragraphs(body, colors,
+ "DejaVu Sans", 9, Color.GRAY);
+ assertEquals(1, paras.size());
+ assertEquals("tinos", paras.get(0).style().family(),
+ "литеральный typeface проходит через алиасы бандла");
+ }
+
+ /** bold/italic/bold+italic — разные начертания бандла, bold шире regular. */
+ @Test
+ void fontForSelectsVariant() {
+ BundledFonts.init();
+ DrawMlText.Style reg = style("Carlito", false, false);
+ DrawMlText.Style bold = style("Carlito", true, false);
+ DrawMlText.Style ital = style("Carlito", false, true);
+ DrawMlText.Style both = style("Carlito", true, true);
+ assertNotSame(DrawMlText.fontFor(reg), DrawMlText.fontFor(bold));
+ assertNotSame(DrawMlText.fontFor(reg), DrawMlText.fontFor(ital));
+ assertNotSame(DrawMlText.fontFor(bold), DrawMlText.fontFor(both));
+ assertTrue(DrawMlText.textWidth("Hello", bold) > DrawMlText.textWidth("Hello", reg),
+ "полужирное Carlito не шире обычного");
+ }
+
+ /** align="far" эквивалентен "r". */
+ @Test
+ void paintFarAlignEqualsRight() {
+ BufferedImage far = paint(List.of(new DrawMlText.Paragraph("Ab", STYLE, "far")),
+ new Rectangle2D.Double(0, 0, 120, 40), null, "t");
+ BufferedImage right = paint(List.of(new DrawMlText.Paragraph("Ab", STYLE, "r")),
+ new Rectangle2D.Double(0, 0, 120, 40), null, "t");
+ int[] a = new int[far.getWidth() * far.getHeight()];
+ far.getRGB(0, 0, far.getWidth(), far.getHeight(), a, 0, far.getWidth());
+ int[] b = new int[right.getWidth() * right.getHeight()];
+ right.getRGB(0, 0, right.getWidth(), right.getHeight(), b, 0, right.getWidth());
+ assertArrayEquals(b, a, "«far» рисуется не как «r»");
+ }
+
+ /** Крошечный бокс: символ шире лимита вклеивается по одному; пробельная строка не даёт полос. */
+ @Test
+ void paintTinyBoxKeepsSingleWideChar() {
+ BufferedImage img = paint(
+ List.of(new DrawMlText.Paragraph("A WWWW", STYLE, null)),
+ new Rectangle2D.Double(0, 0, 5, 200), null, "t");
+ assertTrue(inkBands(img) >= 4, "символы не вклеиваются по одному");
+ BufferedImage blank = paint(
+ List.of(new DrawMlText.Paragraph(" ", STYLE, null)),
+ new Rectangle2D.Double(0, 0, 50, 40), null, "t");
+ assertEquals(0, inkBands(blank), "пробельный абзац — чернил нет");
+ }
}
diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/PiePainterTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/PiePainterTest.java
index d5946e1..4530327 100644
--- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/PiePainterTest.java
+++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/PiePainterTest.java
@@ -225,4 +225,207 @@ class PiePainterTest {
+ " px, в эталоне Word " + String.format("%.0f", expected)
+ " px (отклонение " + String.format("%.1f", deviation * 100) + "%)");
}
+ /** null/отрицательные/нулевые значения не дают секторов: набор [null,-1,0,2] = [2]. */
+ @Test
+ void nonPositiveAndNullValuesIgnored() {
+ DrawMlColor colors = new DrawMlColor(null);
+ ChartSpec spec = pieSpec(ChartSpec.Type.PIE);
+ ChartSpec.Series s = spec.series.get(0);
+ s.fill = java.awt.Color.BLUE;
+ s.values.clear();
+ s.values.add(null);
+ s.values.add(-1.0);
+ s.values.add(0.0);
+ s.values.add(2.0);
+ BufferedImage mixed = ChartRenderer.render(spec, 219.23, 149.08, colors);
+ s.values.clear();
+ s.values.add(2.0);
+ BufferedImage single = ChartRenderer.render(spec, 219.23, 149.08, colors);
+ assertArrayEquals(toArray(single), toArray(mixed),
+ "секторы из null/-1/0 не должны менять картинку");
+ }
+
+ /** Все значения <= 0 — пирог не рисуется. */
+ @Test
+ void allNonPositiveDrawsNothing() {
+ ChartSpec spec = pieSpec(ChartSpec.Type.PIE);
+ ChartSpec.Series s = spec.series.get(0);
+ s.values.clear();
+ s.values.add(-1.0);
+ s.values.add(0.0);
+ BufferedImage img = ChartRenderer.render(spec, 219.23, 149.08, new DrawMlColor(null));
+ for (int y = 0; y < img.getHeight(); y++) {
+ for (int x = 0; x < img.getWidth(); x++) {
+ assertFalse(saturated(img.getRGB(x, y)), "нет положительных значений — нет секторов");
+ }
+ }
+ }
+
+ /** c:spPr без обводки — разделителей нет; кастомный цвет/толщина — рисуются. */
+ @Test
+ void outlineNoFillAndCustomOutline() {
+ DrawMlColor colors = new DrawMlColor(null);
+ ChartSpec spec = pieSpec(ChartSpec.Type.PIE);
+ BufferedImage def = ChartRenderer.render(spec, 219.23, 149.08, colors);
+ int whiteDefault = whiteOnMiddleBand(def);
+ assertTrue(whiteDefault > 0, "по умолчанию сектора разделены белой обводкой");
+ spec.series.get(0).outlineNoFill = true;
+ BufferedImage noLine = ChartRenderer.render(spec, 219.23, 149.08, colors);
+ assertTrue(whiteOnMiddleBand(noLine) < whiteDefault,
+ "обводка не отключается");
+ spec.series.get(0).outlineNoFill = false;
+ spec.series.get(0).outlineColor = java.awt.Color.RED;
+ spec.series.get(0).outlineWidth = 3;
+ BufferedImage red = ChartRenderer.render(spec, 219.23, 149.08, colors);
+ int redPx = 0;
+ for (int y = 0; y < red.getHeight(); y++) {
+ for (int x = 0; x < red.getWidth(); x++) {
+ int rgb = red.getRGB(x, y);
+ int r = (rgb >> 16) & 0xFF;
+ int g = (rgb >> 8) & 0xFF;
+ int b = rgb & 0xFF;
+ if (r > 200 && g < 60 && b < 60) {
+ redPx++;
+ }
+ }
+ }
+ assertTrue(redPx > 0, "кастомная обводка не нарисована");
+ }
+
+ /** Та же обводка в 3D: без c:ln — белых рёбер на гранях нет. */
+ @Test
+ void pie3dOutlineNoFillRemovesStrokes() {
+ DrawMlColor colors = new DrawMlColor(null);
+ BufferedImage def = ChartRenderer.render(pie3dSpec(), 219.23, 149.08, colors);
+ ChartSpec spec = pie3dSpec();
+ spec.series.get(0).outlineNoFill = true;
+ BufferedImage noLine = ChartRenderer.render(spec, 219.23, 149.08, colors);
+ assertTrue(whiteInSilhouette(def) > whiteInSilhouette(noLine),
+ "белая обводка 3D-секторов не отключается");
+ }
+
+ /** c:perspective=0 — ортография (камера в бесконечности), силуэт отличается. */
+ @Test
+ void pie3dOrthoDiffersFromPerspective() {
+ DrawMlColor colors = new DrawMlColor(null);
+ ChartSpec ortho = pie3dSpec();
+ ortho.perspective = 0;
+ int orthoPx = countSaturated(ChartRenderer.render(ortho, 219.23, 149.08, colors));
+ ChartSpec persp = pie3dSpec();
+ persp.perspective = 30;
+ int perspPx = countSaturated(ChartRenderer.render(persp, 219.23, 149.08, colors));
+ assertTrue(orthoPx > 0, "орто-пирог не нарисован");
+ assertNotEquals(orthoPx, perspPx, "перспектива не влияет на силуэт");
+ }
+
+ /** rotY=180: пирог развёрнут — торцы на месте, картинка отличается от rotY=0. */
+ @Test
+ void pie3dRotY180FlipsEndFaceOwner() {
+ DrawMlColor colors = new DrawMlColor(null);
+ BufferedImage rot0 = ChartRenderer.render(pie3dSpec(), 219.23, 149.08, colors);
+ ChartSpec spec = pie3dSpec();
+ spec.rotY = 180;
+ BufferedImage rot180 = ChartRenderer.render(spec, 219.23, 149.08, colors);
+ int[] c0 = endFaceColors(rot0);
+ int[] c180 = endFaceColors(rot180);
+ assertTrue(c0[0] > 0, "исходная ориентация: торцов нет");
+ assertTrue(c180[0] + c180[1] > 0, "при rotY=180 торцы не нарисованы");
+ assertFalse(java.util.Arrays.equals(toArray(rot0), toArray(rot180)),
+ "rotY не влияет на картинку");
+ }
+
+ /** {синий торец, оранжевый торец} — как в pie3dSharedEdgeShowsOnlyCameraFacingEnd. */
+ private static int[] endFaceColors(BufferedImage img) {
+ int blue = 0;
+ int orange = 0;
+ for (int y = 0; y < img.getHeight(); y++) {
+ for (int x = 0; x < img.getWidth(); x++) {
+ int rgb = img.getRGB(x, y);
+ int r = (rgb >> 16) & 0xFF;
+ int g = (rgb >> 8) & 0xFF;
+ int b = rgb & 0xFF;
+ if (b > r + 40 && b > 90 && b < 180 && r < 90) {
+ blue++;
+ }
+ if (r > g + 40 && g > b + 20 && r > 120 && r < 210) {
+ orange++;
+ }
+ }
+ }
+ return new int[]{blue, orange};
+ }
+
+ private static int[] toArray(BufferedImage img) {
+ int[] a = new int[img.getWidth() * img.getHeight()];
+ img.getRGB(0, 0, img.getWidth(), img.getHeight(), a, 0, img.getWidth());
+ return a;
+ }
+
+ /**
+ * Белые пиксели в колонке центра пирога в его вертикальном протяжении:
+ * при значениях [1,1] оба радиуса-границы вертикальны, и обводка лежит
+ * ровно на этой колонке.
+ */
+ private static int whiteOnMiddleBand(BufferedImage img) {
+ int y = img.getHeight() / 2;
+ int left = -1;
+ int right = -1;
+ for (int x = 0; x < img.getWidth(); x++) {
+ if (saturated(img.getRGB(x, y))) {
+ if (left < 0) {
+ left = x;
+ }
+ right = x;
+ }
+ }
+ if (left < 0) {
+ return 0;
+ }
+ int cx = (left + right) / 2;
+ int rx = (right - left) / 2;
+ int n = 0;
+ for (int yy = Math.max(0, y - rx); yy <= Math.min(img.getHeight() - 1, y + rx); yy++) {
+ int rgb = img.getRGB(cx, yy);
+ if (((rgb >> 16) & 0xFF) >= 250 && ((rgb >> 8) & 0xFF) >= 250 && (rgb & 0xFF) >= 250) {
+ n++;
+ }
+ }
+ return n;
+ }
+
+ /** Белые пиксели внутри силуэта (между крайними залитыми пикселями каждой строки). */
+ private static int whiteInSilhouette(BufferedImage img) {
+ int n = 0;
+ for (int y = 0; y < img.getHeight(); y++) {
+ int first = -1;
+ int last = -1;
+ for (int x = 0; x < img.getWidth(); x++) {
+ if (saturated(img.getRGB(x, y))) {
+ if (first < 0) {
+ first = x;
+ }
+ last = x;
+ }
+ }
+ for (int x = Math.max(0, first); first >= 0 && x <= last; x++) {
+ int rgb = img.getRGB(x, y);
+ if (((rgb >> 16) & 0xFF) >= 250 && ((rgb >> 8) & 0xFF) >= 250 && (rgb & 0xFF) >= 250) {
+ n++;
+ }
+ }
+ }
+ return n;
+ }
+
+ private static int countSaturated(BufferedImage img) {
+ int n = 0;
+ for (int y = 0; y < img.getHeight(); y++) {
+ for (int x = 0; x < img.getWidth(); x++) {
+ if (saturated(img.getRGB(x, y))) {
+ n++;
+ }
+ }
+ }
+ return n;
+ }
}
diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/Surface3dPainterTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/Surface3dPainterTest.java
index db1e949..8087b67 100644
--- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/Surface3dPainterTest.java
+++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/chart/Surface3dPainterTest.java
@@ -467,4 +467,168 @@ class Surface3dPainterTest {
}
spec.series.add(s);
}
+ // ---- ветви: вырожденные данные, каркас, сетка, ортография ----
+
+ /** Один ряд — поверхности не из чего строить. */
+ @Test
+ void singleSeriesDrawsNothing() {
+ ChartSpec spec = surfaceSpec();
+ spec.series.subList(1, spec.series.size()).clear();
+ assertEquals(0, painted(paintSurface(spec)), "при одном ряде граней нет");
+ }
+
+ /** Ряд короче других — недостающие точки считаются нулём (картинка совпадает). */
+ @Test
+ void raggedSeriesTreatedAsZeros() {
+ ChartSpec ragged = surfaceSpec();
+ ragged.series.get(0).values.add(3.5);
+ ragged.series.get(1).values.remove(3);
+ ragged.series.get(2).values.remove(3);
+ ChartSpec zeros = surfaceSpec();
+ zeros.series.get(0).values.add(3.5);
+ zeros.series.get(1).values.set(3, 0.0);
+ zeros.series.get(1).values.add(0.0);
+ zeros.series.get(2).values.set(3, 0.0);
+ zeros.series.get(2).values.add(0.0);
+ assertArrayEquals(toArray(paintSurface(zeros)), toArray(paintSurface(ragged)),
+ "оборванный ряд должен рисоваться как дополненный нулями");
+ }
+
+ /** c:wireframe — поверх граней серая сетка рёбер. */
+ @Test
+ void wireframeAddsSeams() {
+ ChartSpec spec = surfaceSpec();
+ BufferedImage solid = paintSurface(spec);
+ spec.wireframe = true;
+ BufferedImage wire = paintSurface(spec);
+ assertTrue(countDarkGray(wire) > countDarkGray(solid),
+ "c:wireframe не добавил каркас");
+ }
+
+ /** gridlines=false — напольной/стеновой сетки нет. */
+ @Test
+ void gridlinesOffRemovesFloorGrid() {
+ ChartSpec spec = surfaceSpec();
+ BufferedImage grid = paintSurface(spec);
+ spec.valAxis.gridlines = false;
+ spec.catAxis.gridlines = false;
+ spec.serAxis.gridlines = false;
+ BufferedImage plain = paintSurface(spec);
+ assertTrue(countLightGray(grid) > countLightGray(plain),
+ "сетка не исчезла при gridlines=false");
+ }
+
+ /** Оси отсутствуют — поверхность рисуется, подписей нет. */
+ @Test
+ void nullAxesDrawFacetsWithoutLabels() {
+ ChartSpec spec = surfaceSpec();
+ BufferedImage named = paintSurface(spec);
+ spec.catAxis = null;
+ spec.valAxis = null;
+ spec.serAxis = null;
+ BufferedImage bare = paintSurface(spec);
+ assertTrue(painted(bare) > 3000, "поверхность без осей не нарисована");
+ assertTrue(painted(bare) < painted(named), "подписи осей остались");
+ }
+
+ /** Ряд без имени — его подпись на оси рядов не рисуется. */
+ @Test
+ void nullSeriesNameSkipsLabel() {
+ ChartSpec spec = surfaceSpec();
+ spec.serAxis.labelStyle = new DrawMlText.Style(9, false, false,
+ new Color(0x59, 0x59, 0x59), "carlito");
+ BufferedImage named = paintSurface(spec);
+ spec.series.get(0).name = null;
+ spec.series.get(1).name = "";
+ assertTrue(painted(paintSurface(spec)) < painted(named),
+ "подпись безымянного ряда не убрана");
+ }
+
+ /** c:perspective=0 — ортография, силуэт отличается от перспективного. */
+ @Test
+ void orthoSurfaceDiffersFromPerspective() {
+ ChartSpec spec = surfaceSpec();
+ spec.perspective = 0;
+ int ortho = painted(paintSurface(spec));
+ spec.perspective = 30;
+ int persp = painted(paintSurface(spec));
+ assertTrue(ortho > 3000, "орто-поверхность не нарисована");
+ assertNotEquals(ortho, persp, "перспектива не влияет на силуэт");
+ }
+
+ private static BufferedImage paintSurface(ChartSpec spec) {
+ BufferedImage img = new BufferedImage(700, 400, BufferedImage.TYPE_INT_ARGB);
+ Graphics2D g = img.createGraphics();
+ try {
+ Surface3dPainter.paint(g, spec, new Rectangle2D.Double(10, 10, 680, 380),
+ ChartSpec.palette(new DrawMlColor(null)));
+ } finally {
+ g.dispose();
+ }
+ return img;
+ }
+
+ private static int painted(BufferedImage img) {
+ int n = 0;
+ for (int y = 0; y < img.getHeight(); y++) {
+ for (int x = 0; x < img.getWidth(); x++) {
+ int argb = img.getRGB(x, y);
+ if (((argb >>> 24) & 0xFF) < PAINTED_ALPHA_MIN) {
+ continue;
+ }
+ Color c = new Color(argb);
+ if (c.getRed() > 245 && c.getGreen() > 245 && c.getBlue() > 245) {
+ continue;
+ }
+ n++;
+ }
+ }
+ return n;
+ }
+
+ /** Каркасные рёбра 0x808080. */
+ private static int countDarkGray(BufferedImage img) {
+ int n = 0;
+ for (int y = 0; y < img.getHeight(); y++) {
+ for (int x = 0; x < img.getWidth(); x++) {
+ int argb = img.getRGB(x, y);
+ if (((argb >>> 24) & 0xFF) < PAINTED_ALPHA_MIN) {
+ continue;
+ }
+ Color c = new Color(argb);
+ int spread = Math.max(Math.max(c.getRed(), c.getGreen()), c.getBlue())
+ - Math.min(Math.min(c.getRed(), c.getGreen()), c.getBlue());
+ if (spread <= 15 && Math.abs(c.getRed() - 0x80) <= 25) {
+ n++;
+ }
+ }
+ }
+ return n;
+ }
+
+ /** Линии сетки 0xD9D9D9. */
+ private static int countLightGray(BufferedImage img) {
+ int n = 0;
+ for (int y = 0; y < img.getHeight(); y++) {
+ for (int x = 0; x < img.getWidth(); x++) {
+ int argb = img.getRGB(x, y);
+ if (((argb >>> 24) & 0xFF) < PAINTED_ALPHA_MIN) {
+ continue;
+ }
+ Color c = new Color(argb);
+ int spread = Math.max(Math.max(c.getRed(), c.getGreen()), c.getBlue())
+ - Math.min(Math.min(c.getRed(), c.getGreen()), c.getBlue());
+ if (spread <= 10 && Math.abs(c.getRed() - 0xD9) <= 10) {
+ n++;
+ }
+ }
+ }
+ return n;
+ }
+
+ private static int[] toArray(BufferedImage img) {
+ int[] a = new int[img.getWidth() * img.getHeight()];
+ img.getRGB(0, 0, img.getWidth(), img.getHeight(), a, 0, img.getWidth());
+ return a;
+ }
}