diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/ChartRenderer.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/ChartRenderer.java index 31da4dd..30282ad 100644 --- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/ChartRenderer.java +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/ChartRenderer.java @@ -14,6 +14,8 @@ import java.awt.geom.RoundRectangle2D; import java.awt.image.BufferedImage; import java.util.ArrayList; import java.util.List; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; /** * Рендер графика DrawingML в растр. Кадрирование (рамка chartSpace), @@ -26,6 +28,8 @@ import java.util.List; */ final class ChartRenderer { + private static final Logger LOG = LoggerFactory.getLogger(ChartRenderer.class); + /** Разрешение растра: 300 dpi, чтобы подписи не мылились при печати. */ static final int DPI = 300; @@ -113,7 +117,7 @@ final class ChartRenderer { Surface2dPainter.paint(g, spec, box, palette); case AREA3D, LINE3D, BAR3D -> Cartesian3dPainter.paint(g, spec, box, palette); - default -> { /* UNSUPPORTED: вызывающий не должен сюда доходить */ } + default -> LOG.warn("тип графика {} не поддерживается — пустой PNG", spec.type); } if (legend != null && spec.legendOverlay) { double y = "t".equals(spec.legendPos) @@ -405,6 +409,14 @@ final class ChartRenderer { } /** + * Границы оси + шаг. Враждебные {@code c:min}/{@code c:max} (размах до 1e300, + * не-конечные границы, переполнение stacked-сумм в Infinity) не должны давать + * вечные циклы делений: шаг пересчитывается по ФАКТИЧЕСКОМУ интервалу, так что + * {@code (hi - lo) / unit <= MAX_TICKS + 1} при любых входах — все циклы + * {@code for (v = lo; v <= hi + unit/2; v += unit)} у художников завершаются. + * Регрессия — ChartRendererTest#axisBounds_explicitHugeRange_reunitsToMaxTicks, + * WordPdfConverterTest#hostileChartAxis_convertsNotHangs. + * * @param padMax для декартовых осей Word поднимает верхнюю границу за * максимум данных: «первое деление выше Ymax + (Ymax − Ymin)/20» * (KB101939). Без этого линия упёрта в верхнюю границу области @@ -414,6 +426,12 @@ final class ChartRenderer { */ static double[] axisBounds(ChartSpec.AxisSpec axis, double dataMin, double dataMax, boolean padMax) { + if (!Double.isFinite(dataMin)) { + dataMin = 0; + } + if (!Double.isFinite(dataMax)) { + dataMax = 0; + } double unit = axis != null && axis.majorUnit != null && usableMajorUnit(axis.majorUnit, dataMax - dataMin) ? axis.majorUnit @@ -433,6 +451,21 @@ final class ChartRenderer { if (hi <= lo) { hi = lo + unit; } + double span = hi - lo; + if (!Double.isFinite(span)) { + // Явные min/max дали не-конечный размах — откат к границам данных. + lo = Math.min(0, dataMin); + hi = Math.max(0, dataMax); + if (!(hi > lo)) { + lo = 0; + hi = 1; + } + unit = niceUnit((hi - lo) / 5.0); + } else if (span / unit > MAX_TICKS) { + // Явные min/max конечны, но интервал гигантский при мелком шаге — + // укрупняем шаг до приемлемого числа делений. + unit = niceUnit(span / MAX_TICKS); + } return new double[]{lo, hi, unit}; } diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/ChartSpec.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/ChartSpec.java index 0aeab98..36f7cb5 100644 --- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/ChartSpec.java +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/ChartSpec.java @@ -807,7 +807,7 @@ final class ChartSpec { spPr = c.getSpPr(); numFmt = c.getNumFmt() != null ? c.getNumFmt().getFormatCode() : "General"; if (c.getMajorUnit() != null) { - a.majorUnit = c.getMajorUnit().getVal(); + a.majorUnit = finite(c.getMajorUnit().getVal()); } } else if (ax instanceof CTSerAx c) { scaling = c.getScaling(); @@ -833,10 +833,10 @@ final class ChartSpec { a.numFmt = numFmt; if (scaling != null) { if (scaling.getMin() != null) { - a.min = scaling.getMin().getVal(); + a.min = finite(scaling.getMin().getVal()); } if (scaling.getMax() != null) { - a.max = scaling.getMax().getVal(); + a.max = finite(scaling.getMax().getVal()); } if (scaling.getOrientation() != null && scaling.getOrientation().getVal() != null) { a.reversed = scaling.getOrientation().getVal() == STOrientation.MAX_MIN; @@ -868,6 +868,16 @@ final class ChartSpec { return a; } + /** + * Не-конечные {@code c:min}/{@code c:max}/{@code c:majorUnit} (NaN/Infinity — + * ST_Double допускает их литерально) отбрасываются до предвыделения циклов + * делений: враждебный chart-XML не должен доходить до осевых циклов + * художников. Регрессия — ChartSpecTest#nonFiniteScalingBounds_dropped. + */ + private static Double finite(Double v) { + return v != null && Double.isFinite(v) ? v : null; + } + private static String seriesName(CTSerTx tx) { if (tx == null) { return null; diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/DrawMlText.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/DrawMlText.java index eb0c532..ab4f727 100644 --- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/DrawMlText.java +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/DrawMlText.java @@ -218,38 +218,44 @@ final class DrawMlText { } } - /** Жадный перенос по пробелам; длинные слова режутся по символам. */ - private static List wrapLines(String text, GlyphFont f, double sizePt, - double maxWidth) { + /** + * Жадный перенос по пробелам; длинные слова режутся по символам. + * Ширина набирается инкрементально ({@link GlyphFont#advance} аддитивен — + * сумма ширин глифов без кернинга), а рез слова ищет границу экспоненциальным + * удвоением с бинарным сужением — O(L log L) на строку вместо кубической + * деградации на гигантских словах. Регрессия — DrawMlTextTest#hugeWord_wrapsLinearly. + */ + static List wrapLines(String text, GlyphFont f, double sizePt, double maxWidth) { List out = new ArrayList<>(); double limit = Math.max(1, maxWidth); + double spaceW = f.advance(" ", sizePt); for (String hard : text.split("\\n")) { if (hard.isEmpty()) { out.add(""); continue; } StringBuilder cur = new StringBuilder(); - double curWidth; + double curWidth = 0; for (String word : hard.split(" ")) { if (word.isEmpty()) { continue; } - String candidate = cur.length() == 0 ? word : cur + " " + word; - double w = f.advance(candidate, sizePt); - if (w <= limit || cur.length() == 0) { + double wordW = f.advance(word, sizePt); + if (cur.length() > 0 && curWidth + spaceW + wordW > limit) { + out.add(cur.toString()); cur.setLength(0); - cur.append(candidate); - continue; + curWidth = 0; + } + if (cur.length() > 0) { + cur.append(' '); + curWidth += spaceW; } - out.add(cur.toString()); - cur.setLength(0); cur.append(word); - curWidth = f.advance(word, sizePt); + curWidth += wordW; + // Слово шире лимита — режется по символам (в т.ч. первое в + // абзаце: иначе гигантское слово переполняло бокс). while (curWidth > limit && cur.length() > 1) { - int cut = cur.length() - 1; - while (cut > 1 && f.advance(cur.substring(0, cut), sizePt) > limit) { - cut--; - } + int cut = fitCut(cur, f, sizePt, limit); out.add(cur.substring(0, cut)); cur.delete(0, cut); curWidth = f.advance(cur.toString(), sizePt); @@ -262,6 +268,37 @@ final class DrawMlText { return out; } + /** + * Макс. k ∈ [1, s.length()], что advance(s[0,k)) ≤ limit; иначе 1 (прогресс + * гарантирован). Экспоненциальный поиск останавливается на первом переборе, + * поэтому окно поиска ограничено размером вписывающегося префикса, а не + * длиной строки. + */ + private static int fitCut(CharSequence s, GlyphFont f, double sizePt, double limit) { + int n = s.length(); + if (n <= 1) { + return n; + } + int lo = 1; + int hi = 2; + while (hi < n && f.advance(s.subSequence(0, hi).toString(), sizePt) <= limit) { + lo = hi; + hi = Math.min(n, hi * 2); + } + if (hi == n && f.advance(s.subSequence(0, n).toString(), sizePt) <= limit) { + return n; + } + while (hi - lo > 1) { + int mid = (lo + hi) >>> 1; + if (f.advance(s.subSequence(0, mid).toString(), sizePt) <= limit) { + lo = mid; + } else { + hi = mid; + } + } + return lo; + } + /** Ширина строки в тех же единицах, что и размер шрифта. */ static double textWidth(String text, Style style) { return fontFor(style).advance(text, style.sizePt()); diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/DrawingPreRenderer.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/DrawingPreRenderer.java index 8000a4d..1fc6983 100644 --- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/DrawingPreRenderer.java +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/chart/DrawingPreRenderer.java @@ -74,6 +74,14 @@ public final class DrawingPreRenderer { private static final String DIAGRAM_DRAWING_REL = "http://schemas.microsoft.com/office/2007/relationships/diagramDrawing"; + /** + * Верхняя граница {@code wp:extent} в EMU: максимальная страница Word — + * 22″ (≈20.1M EMU), берём 24″ с запасом. Больше — враждебный docx: растр при + * 300 dpi дал бы десятки тысяч пикселей в стороне (OOM при BufferedImage и + * ImageIO). Регрессия — WordPdfConverterTest#hugeExtentChart_removedNotOom. + */ + private static final long MAX_EXTENT_EMU = 22_000_000L; + private DrawingPreRenderer() { } @@ -182,36 +190,38 @@ public final class DrawingPreRenderer { if (graphic == null || graphic.getGraphicData() == null) { continue; } - if (cx <= 0 || cy <= 0) { - LOG.warn("drawing без wp:extent — оставлен как есть"); + GraphicData gd = graphic.getGraphicData(); + if (PICTURE_URI.equals(gd.getUri()) || gd.getAny().isEmpty()) { + continue; // уже картинка / пусто + } + // Детект payload и проверка error-флагов — ДО extent-guard'а: + // error-флаг обязан сработать и для drawing без/с враждебным extent. + Object payload = gd.getAny().get(0); + String name = payload instanceof JAXBElement el && el.getName() != null + ? el.getName().toString() : ""; + boolean isChart = CHART_ELEMENT.equals(name); + boolean isDiagram = DIAGRAM_ELEMENT.equals(name); + if (isChart && options.errorOnCharts()) { + throw new DrawingFoundException(DrawingFoundException.Kind.CHARTS); + } + if (isDiagram && options.errorOnSmartArt()) { + throw new DrawingFoundException(DrawingFoundException.Kind.SMARTART); + } + if (cx <= 0 || cy <= 0 || cx > MAX_EXTENT_EMU || cy > MAX_EXTENT_EMU) { + LOG.warn("drawing вне допустимого wp:extent (cx={}, cy={}) — объект оставлен как есть", + cx, cy); continue; } - GraphicData gd = graphic.getGraphicData(); - String uri = gd.getUri(); BufferedImage img = null; String label = null; - if (PICTURE_URI.equals(uri)) { - continue; // уже картинка - } - if (gd.getAny().isEmpty()) { - continue; - } - Object payload = gd.getAny().get(0); - if (payload instanceof JAXBElement el) { - String name = el.getName() == null ? "" : el.getName().toString(); - if (CHART_ELEMENT.equals(name)) { - if (options.errorOnCharts()) { - throw new DrawingFoundException(DrawingFoundException.Kind.CHARTS); - } - img = renderChart(part, (CTRelId) el.getValue(), colors, cx, cy); - label = "график"; - } else if (DIAGRAM_ELEMENT.equals(name)) { - if (options.errorOnSmartArt()) { - throw new DrawingFoundException(DrawingFoundException.Kind.SMARTART); - } - img = renderDiagram(part, (CTRelIds) el.getValue(), colors, cx, cy); - label = "SmartArt"; - } + if (isChart) { + img = renderChart(part, (CTRelId) ((JAXBElement) payload).getValue(), + colors, cx, cy); + label = "график"; + } else if (isDiagram) { + img = renderDiagram(part, (CTRelIds) ((JAXBElement) payload).getValue(), + colors, cx, cy); + label = "SmartArt"; } if (img == null) { if (label != null) { @@ -234,7 +244,9 @@ public final class DrawingPreRenderer { try { ChartSpec spec = ChartSpec.parse(space, colors); return ChartRenderer.render(spec, cx / 12700.0, cy / 12700.0, colors); - } catch (RuntimeException e) { + } catch (RuntimeException | OutOfMemoryError e) { + // OOM — второй эшелон после MAX_EXTENT_EMU/MAX_POINTS: враждебный + // chart-XML не должен валить всю конвертацию, деградация = объект удалён. LOG.warn("рендер графика r:id={} упал: {}", ref.getId(), e.toString()); return null; } @@ -255,7 +267,7 @@ public final class DrawingPreRenderer { } try { return SmartArtRenderer.render(drawing, data, colors, cx / 12700.0, cy / 12700.0); - } catch (RuntimeException e) { + } catch (RuntimeException | OutOfMemoryError e) { LOG.warn("рендер SmartArt упал: {}", e.toString()); return null; } @@ -299,6 +311,7 @@ public final class DrawingPreRenderer { png = bos.toByteArray(); } catch (Exception e) { LOG.warn("PNG не собран: {}", e.toString()); + gd.getAny().clear(); // контракт: упавший рендер — объект удалён return; } BinaryPartAbstractImage imagePart; @@ -306,11 +319,13 @@ public final class DrawingPreRenderer { imagePart = BinaryPartAbstractImage.createImagePart(pkg, part, png); } catch (Exception e) { LOG.warn("ImagePart не создан: {}", e.toString()); + gd.getAny().clear(); return; } String relId = relIdFor(part, imagePart); if (relId == null) { LOG.warn("r:id для ImagePart {} не найден", imagePart.getPartName()); + gd.getAny().clear(); return; } diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfConverterTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfConverterTest.java index e598fe9..b9ebdeb 100644 --- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfConverterTest.java +++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfConverterTest.java @@ -743,4 +743,132 @@ class WordPdfConverterTest { zos.write(xml.getBytes(StandardCharsets.UTF_8)); zos.closeEntry(); } + + /** Штатный c:valAx для in-memory chart-фикстур (без явных min/max). */ + private static final String PLAIN_VALAX = + "" + + ""; + + /** + * Минимальный in-memory docx: абзац-маркер + один линейный график (ряд 0..100) + * с указанным {@code wp:extent} и полным содержимым {@code c:valAx} + * (valAxXml — дети c:valAx в порядке ECMA-376 §21.2.2.219). Конвенция + * враждебного XML in-memory — WordPdfValidatorTest. + */ + private static byte[] chartDocx(long cx, long cy, String valAxXml) throws IOException { + String w = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"; + String c = "http://schemas.openxmlformats.org/drawingml/2006/chart"; + StringBuilder pts = new StringBuilder(); + for (int i = 0; i <= 10; i++) { + pts.append("") + .append(i * 10).append(""); + } + ByteArrayOutputStream out = new ByteArrayOutputStream(); + try (ZipOutputStream zos = new ZipOutputStream(out)) { + putZip(zos, "[Content_Types].xml", + "" + + "" + + "" + + "" + + "" + + "" + + ""); + putZip(zos, "_rels/.rels", + "" + + "" + + "" + + ""); + putZip(zos, "word/document.xml", + "" + + "" + + "" + + "ГРАФИКМАРКЕР" + + "" + + "" + + "" + + "" + + "" + + "" + + "" + + "" + + "" + + ""); + putZip(zos, "word/_rels/document.xml.rels", + "" + + "" + + "" + + ""); + putZip(zos, "word/charts/chart1.xml", + "" + + "" + + "" + + "" + + "" + + "General" + + "" + pts + "" + + "" + + "" + + "" + + "" + + "" + + "" + + "" + valAxXml + "" + + ""); + } + return out.toByteArray(); + } + + /** + * Враждебные c:min/c:max (размах 2e300) при явном c:majorUnit=1: шаг делений + * пересчитывается по фактическому интервалу — конвертация завершается за + * секунды, график становится растром (до фикса — вечный цикл делений оси). + * Регрессия — ChartRenderer#axisBounds. + */ + @Test + void hostileChartAxis_convertsNotHangs() throws Exception { + byte[] docx = chartDocx(4_000_000L, 3_000_000L, + "" + + "" + + "" + + "" + + ""); + Path pdf = convertPdf(docx, "hostile-axis"); + assertTrue(norm(pdfText(pdf)).contains("ГРАФИКМАРКЕР"), "пропал текст"); + assertTrue(imageCount(pdf) >= 1, "график должен стать растром"); + } + + /** + * Враждебный wp:extent (122M EMU ≈ 133″): график не рендерится (кап + * MAX_EXTENT_EMU), документ конвертируется без OOM (до фикса — + * BufferedImage на десятки тысяч пикселей в стороне). + * Регрессия — DrawingPreRenderer#MAX_EXTENT_EMU. + */ + @Test + void hugeExtentChart_removedNotOom() throws Exception { + byte[] docx = chartDocx(122_000_000L, 122_000_000L, PLAIN_VALAX); + Path pdf = convertPdf(docx, "huge-extent"); + assertTrue(norm(pdfText(pdf)).contains("ГРАФИКМАРКЕР"), "пропал текст"); + assertEquals(0, imageCount(pdf), "график вне extent-капа не должен рендериться"); + } + + /** + * Error-флаг обязан сработать и для drawing без wp:extent: детект payload + * идёт до extent-guard'а (иначе обход — DrawingFoundException(CHARTS)). + * Регрессия — DrawingPreRenderer#replaceDrawing. + */ + @Test + void chartWithoutExtent_errorFlagRejects() throws Exception { + byte[] docx = chartDocx(0, 0, PLAIN_VALAX); + ConversionException ex = assertThrows(ConversionException.class, () -> + convertPdf(docx, "no-extent", + new ConvertOptions(true, false, false, + WordPdfSettings.MAX_INPUT_MB, WordPdfSettings.MAX_PAGES))); + assertTrue(ex instanceof DrawingFoundException dfe + && dfe.kind() == DrawingFoundException.Kind.CHARTS, + "ожидался DrawingFoundException(CHARTS), получено: " + ex); + } } 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 a876f90..84935d4 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 @@ -217,6 +217,36 @@ class ChartRendererTest { assertEquals(12.0, b[1], 0.001, "hi<=lo — поднимаем до lo+unit"); } + /** + * Враждебные явные c:min/c:max (размах 2e300 при явном шаге 1): шаг + * пересчитывается по фактическому интервалу — число делений ≤ MAX_TICKS+1, + * все циклы делений у художников завершаются. + * Регрессия — ChartRendererTest#axisBounds_explicitHugeRange_reunitsToMaxTicks. + */ + @Test + void axisBounds_explicitHugeRange_reunitsToMaxTicks() { + ChartSpec.AxisSpec ax = new ChartSpec.AxisSpec(); + ax.min = -1e300; + ax.max = 1e300; + ax.majorUnit = 1.0; + double[] r = ChartRenderer.axisBounds(ax, 0, 10); + assertTrue(Double.isFinite(r[0]) && Double.isFinite(r[1]) && Double.isFinite(r[2]), + "границы/шаг обязаны остаться конечными"); + assertTrue((r[1] - r[0]) / r[2] <= 1001, + "слишком много делений: " + (r[1] - r[0]) / r[2]); + } + + /** Не-конечные границы (переполнение размаха) — откат к границам данных. */ + @Test + void axisBounds_infiniteSpan_fallsBackToData() { + ChartSpec.AxisSpec ax = new ChartSpec.AxisSpec(); + ax.min = -1e308; + ax.max = 1e308; + double[] r = ChartRenderer.axisBounds(ax, 0, 10); + assertTrue(r[0] >= 0 && r[1] <= 12 && (r[1] - r[0]) / r[2] <= 1001, + "ожидаем откат к данным: " + r[0] + ".." + r[1] + " шаг " + r[2]); + } + /** formatValue: 0.00/0.0/General/null. */ @Test void formatValueFormats() { 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 4ad1ede..91c8a7b 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 @@ -636,6 +636,35 @@ class ChartSpecTest { assertEquals("General", spec.serAxis.numFmt); } + /** + * Не-конечные c:min/c:max/c:majorUnit (NaN/Infinity — ST_Double допускает) + * отбрасываются на разборе: враждебный chart-XML не должен протаскивать + * их в циклы делений. Регрессия — ChartSpecTest#nonFiniteScalingBounds_dropped. + */ + @Test + void nonFiniteScalingBounds_dropped() { + CTChart chart = new CTChart(); + CTPlotArea pa = new CTPlotArea(); + CTValAx val = new CTValAx(); + CTScaling scaling = new CTScaling(); + CTDouble min = new CTDouble(); + min.setVal(Double.NaN); + CTDouble max = new CTDouble(); + max.setVal(Double.POSITIVE_INFINITY); + scaling.setMin(min); + scaling.setMax(max); + val.setScaling(scaling); + CTAxisUnit unit = new CTAxisUnit(); + unit.setVal(Double.NaN); + val.setMajorUnit(unit); + pa.getValAxOrCatAxOrDateAx().add(val); + chart.setPlotArea(pa); + ChartSpec spec = ChartSpec.parse(spaceWith(chart), new DrawMlColor(null)); + assertNull(spec.valAxis.min, "NaN c:min должен быть отброшен"); + assertNull(spec.valAxis.max, "Infinity c:max должен быть отброшен"); + assertNull(spec.valAxis.majorUnit, "NaN c:majorUnit должен быть отброшен"); + } + @Test void numericCategoriesSparsePadded() { CTBarChart bar = new CTBarChart(); 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 ddb865e..b3d010a 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 @@ -286,4 +286,23 @@ class DrawMlTextTest { assertEquals(3, DrawMlText.lineCount( "альфа бета гамма дельта эпсилон зета эта йота капа лямбда", s, 100)); } + + /** + * Слово из 50 000 символов: перенос завершается за O(L log L) (инкрементальная + * ширина + экспоненциальный поиск границы реза) и каждая строка влезает в + * лимит ширины. Регрессия — DrawMlTextTest#hugeWord_wrapsLinearly. + */ + @Test + void hugeWord_wrapsLinearly() { + BundledFonts.init(); + var f = DrawMlText.fontFor(style("Carlito", false, false)); + String huge = "A".repeat(50_000); + double limit = 120; + List lines = DrawMlText.wrapLines(huge, f, 12, limit); + assertTrue(lines.size() > 1, "гигантское слово должно быть порезано"); + for (String line : lines) { + assertTrue(line.length() == 1 || f.advance(line, 12) <= limit, + "строка шире лимита: " + line.length() + " симв."); + } + } }