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; + } }