wordpdf-core: гейт JaCoCo BRANCH 0.85 + тесты до 89.4% ветвей
- execution check в wordpdf-core/pom.xml добавляет BRANCH COVEREDRATIO 0.85 (LINE 0.90 остаётся) - партии тестов: chart-пейнтеры/рендер/DrawMlText, WordPdfValidator lightweight-сканер, нормализаторы (Symbol/Strict/GlyphCoverage/Field/Ole), шрифты (BundledFonts/Mapper, FopFallback) - CartesianPainter: guard valGutter при valAxis=null (NPE при диаграммах без c:valAx) - 327 тестов ядра, BRANCH 1924/2151 (89.4%), LINE 95.4%
This commit is contained in:
@@ -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<String, String> parts) throws Exception {
|
||||
ByteArrayOutputStream out = new ByteArrayOutputStream();
|
||||
try (ZipOutputStream zos = new ZipOutputStream(out)) {
|
||||
for (java.util.Map.Entry<String, String> 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 "<?xml version=\"1.0\" encoding=\"UTF-8\"?><w:document xmlns:w=\""
|
||||
+ TRANSITIONAL_W + "\"><w:body>" + body + "</w:body></w:document>";
|
||||
}
|
||||
|
||||
/**
|
||||
* Разрывы вне {@code w:p}, {@code pageBreakBefore} с falsy-значением и
|
||||
* {@code sectPr} внутри {@code w:pPr} не создают страниц.
|
||||
*/
|
||||
@Test
|
||||
void pageCount_strayAndFalsyBreaksNotCounted() throws Exception {
|
||||
String body = "<w:br w:type=\"page\"/><w:br w:type=\"page\"/><w:br w:type=\"page\"/>"
|
||||
+ "<w:lastRenderedPageBreak/>"
|
||||
+ "<w:p><w:pPr><w:pageBreakBefore w:val=\"false\"/></w:pPr></w:p>"
|
||||
+ "<w:p><w:pPr><w:pageBreakBefore w:val=\"0\"/></w:pPr></w:p>"
|
||||
+ "<w:p><w:pPr><w:pageBreakBefore w:val=\"off\"/></w:pPr></w:p>"
|
||||
+ "<w:p><w:pPr><w:sectPr><w:type w:val=\"nextPage\"/></w:sectPr></w:pPr></w:p>"
|
||||
+ "<w:p><w:pPr><w:sectPr/></w:pPr></w:p>";
|
||||
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 + "<w:p><w:r><w:br w:type=\"page\"/></w:r></w:p>";
|
||||
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 = "<w:p><w:pPr><w:pageBreakBefore/></w:pPr></w:p>"
|
||||
+ "<w:p><w:pPr><w:pageBreakBefore w:val=\"true\"/></w:pPr></w:p>"
|
||||
+ "<w:p><w:pPr><w:pageBreakBefore w:val=\"1\"/></w:pPr></w:p>"
|
||||
+ "<w:p><w:pPr><w:pageBreakBefore w:val=\"on\"/></w:pPr></w:p>";
|
||||
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 = "<?xml version=\"1.0\"?><w:hdr xmlns:w=\"" + TRANSITIONAL_W + "\">"
|
||||
+ "<w:p><w:r><w:br w:type=\"page\"/></w:r></w:p>"
|
||||
+ "<w:p><w:r><w:br w:type=\"page\"/></w:r></w:p></w:hdr>";
|
||||
String rels = "<Relationships><w:br w:type=\"page\"/><w:br w:type=\"page\"/>"
|
||||
+ "<w:br w:type=\"page\"/></Relationships>";
|
||||
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 = "<?xml version=\"1.0\"?><w:ftr xmlns:w=\"" + TRANSITIONAL_W + "\">"
|
||||
+ "<w:p><w:r><w:br w:type=\"page\"/></w:r></w:p></w:ftr>";
|
||||
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 = "<?xml version=\"1.0\"?><Types xmlns=\"http://schemas.openxmlformats.org"
|
||||
+ "/package/2006/content-types\"><Override PartName=\"/word/document.xml\""
|
||||
+ " ContentType=\"application/vnd.openxmlformats-officedocument"
|
||||
+ ".wordprocessingml.document.main+xml\"/><!--"
|
||||
+ "A".repeat(9 * 1024 * 1024) + "--></Types>";
|
||||
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()));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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<String, Map<String, PhysicalFont>> variants =
|
||||
(Map<String, Map<String, PhysicalFont>>) variantsField.get(null);
|
||||
Map<String, Map<String, PhysicalFont>> 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<String> 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<String> 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"),
|
||||
"семейство без отображаемого имени возвращается как есть");
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -123,4 +123,111 @@ class FieldNormalizerTest {
|
||||
+ "<w:r><w:rPr><w:sz w:val=\"20\"/></w:rPr><w:t>1</w:t></w:r>"
|
||||
+ "</w:fldSimple></w:p>", page);
|
||||
}
|
||||
|
||||
/** Маркер begin без единого <w:r> до него — поле-контейнер не найти, пропускаем. */
|
||||
@Test
|
||||
void beginWithoutAnyRun_skipped() {
|
||||
assertNull(FieldNormalizer.rewrite("fldCharType=\"begin\""));
|
||||
}
|
||||
|
||||
/** begin после закрытого рана: ран-контейнер не найден — пропускаем. */
|
||||
@Test
|
||||
void beginOutsideRun_skipped() {
|
||||
assertNull(FieldNormalizer.rewrite(
|
||||
"<w:r><w:t>до</w:t></w:r>fldCharType=\"begin\""));
|
||||
}
|
||||
|
||||
/** Ран с begin не закрыт — битое поле, пропускаем. */
|
||||
@Test
|
||||
void beginRunUnclosed_skipped() {
|
||||
assertNull(FieldNormalizer.rewrite(
|
||||
"<w:r><w:fldChar w:fldCharType=\"begin\""));
|
||||
}
|
||||
|
||||
/** Поле без instrText: инструкция пуста — не поддерживаем, оставляем как есть. */
|
||||
@Test
|
||||
void fieldWithoutInstruction_skipped() {
|
||||
String xml = "<w:r><w:fldChar w:fldCharType=\"begin\"/></w:r>"
|
||||
+ "<w:r><w:fldChar w:fldCharType=\"end\"/></w:r>";
|
||||
assertNull(FieldNormalizer.rewrite(xml));
|
||||
}
|
||||
|
||||
/** PAGE без separate: кэша нет — fldSimple пустой, число нарисует обработчик. */
|
||||
@Test
|
||||
void fieldWithoutSeparate_emptyFldSimple() {
|
||||
String xml = "<w:r><w:fldChar w:fldCharType=\"begin\"/></w:r>"
|
||||
+ "<w:r><w:instrText> PAGE </w:instrText></w:r>"
|
||||
+ "<w:r><w:fldChar w:fldCharType=\"end\"/></w:r>";
|
||||
assertEquals("<w:fldSimple w:instr=\" PAGE \"></w:fldSimple>",
|
||||
FieldNormalizer.rewrite(xml));
|
||||
}
|
||||
|
||||
/** separate другого поля после end: кэшем этого поля оно быть не может. */
|
||||
@Test
|
||||
void separateAfterFieldEnd_notCapturedAsCache() {
|
||||
String xml = "<w:r><w:fldChar w:fldCharType=\"begin\"/></w:r>"
|
||||
+ "<w:r><w:instrText> PAGE </w:instrText></w:r>"
|
||||
+ "<w:r><w:fldChar w:fldCharType=\"end\"/></w:r>"
|
||||
+ "<w:r><w:fldChar w:fldCharType=\"separate\"/></w:r>";
|
||||
String out = FieldNormalizer.rewrite(xml);
|
||||
|
||||
assertTrue(out.startsWith("<w:fldSimple w:instr=\" PAGE \"></w:fldSimple>"), out);
|
||||
assertTrue(out.endsWith("<w:r><w:fldChar w:fldCharType=\"separate\"/></w:r>"), out);
|
||||
}
|
||||
|
||||
/** end вне рана: начало его рана не найти — кэш не берём, поле переписываем пустым. */
|
||||
@Test
|
||||
void endMarkerOutsideRun_noCacheCaptured() {
|
||||
String xml = "<w:r><w:fldChar w:fldCharType=\"begin\"/></w:r>"
|
||||
+ "<w:r><w:instrText> PAGE </w:instrText></w:r>"
|
||||
+ "<w:r><w:fldChar w:fldCharType=\"separate\"/></w:r>"
|
||||
+ "<w:r><w:t>2</w:t></w:r>"
|
||||
+ "fldCharType=\"end\""
|
||||
+ "<w:r><w:t>после</w:t></w:r>";
|
||||
assertEquals("<w:fldSimple w:instr=\" PAGE \"></w:fldSimple>",
|
||||
FieldNormalizer.rewrite(xml));
|
||||
}
|
||||
|
||||
/** separate и end в одном ране: «кэш» лежал бы раньше маркера — не берём. */
|
||||
@Test
|
||||
void separateAndEndInOneRun_noCacheCaptured() {
|
||||
String xml = "<w:r><w:fldChar w:fldCharType=\"begin\"/></w:r>"
|
||||
+ "<w:r><w:instrText> PAGE </w:instrText></w:r>"
|
||||
+ "<w:r><w:fldChar w:fldCharType=\"separate\"/>"
|
||||
+ "<w:fldChar w:fldCharType=\"end\"/></w:r>";
|
||||
assertEquals("<w:fldSimple w:instr=\" PAGE \"></w:fldSimple>",
|
||||
FieldNormalizer.rewrite(xml));
|
||||
}
|
||||
|
||||
/** instrText без закрывающего тега: инструкцию не собрать — поле остаётся. */
|
||||
@Test
|
||||
void unclosedInstrText_fieldSkipped() {
|
||||
String xml = "<w:r><w:fldChar w:fldCharType=\"begin\"/></w:r>"
|
||||
+ "<w:r><w:instrText> PAGE </w:r>"
|
||||
+ "<w:r><w:fldChar w:fldCharType=\"end\"/></w:r>";
|
||||
assertNull(FieldNormalizer.rewrite(xml));
|
||||
}
|
||||
|
||||
/** Ран с атрибутами (<w:r w:rsidR=...>) — корректное открытие рана, поле переписывается. */
|
||||
@Test
|
||||
void runWithAttributes_fieldRewritten() {
|
||||
String xml = "<w:r w:rsidR=\"001E\"><w:fldChar w:fldCharType=\"begin\"/></w:r>"
|
||||
+ "<w:r><w:instrText> PAGE </w:instrText></w:r>"
|
||||
+ "<w:r><w:fldChar w:fldCharType=\"separate\"/></w:r>"
|
||||
+ "<w:r><w:t>2</w:t></w:r>"
|
||||
+ "<w:r><w:fldChar w:fldCharType=\"end\"/></w:r>";
|
||||
String out = FieldNormalizer.rewrite(xml);
|
||||
|
||||
assertTrue(out.startsWith("<w:fldSimple w:instr=\" PAGE \">"), out);
|
||||
assertTrue(out.contains("<w:r><w:t>2</w:t></w:r>"), "кэш потерян: " + out);
|
||||
}
|
||||
|
||||
/** Ран с end не закрыт — поле битое, пропускаем. */
|
||||
@Test
|
||||
void endRunUnclosed_fieldSkipped() {
|
||||
String xml = "<w:r><w:fldChar w:fldCharType=\"begin\"/></w:r>"
|
||||
+ "<w:r><w:instrText> PAGE </w:instrText></w:r>"
|
||||
+ "<w:r><w:fldChar w:fldCharType=\"end\"";
|
||||
assertNull(FieldNormalizer.rewrite(xml));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,130 @@
|
||||
package ru.pjandro.wordpdf.internal;
|
||||
|
||||
import org.docx4j.convert.out.FOSettings;
|
||||
import org.docx4j.convert.out.fopconf.Fop;
|
||||
import org.docx4j.convert.out.fopconf.Fonts;
|
||||
import org.docx4j.convert.out.fopconf.ObjectFactory;
|
||||
import org.docx4j.fonts.PhysicalFont;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import ru.pjandro.wordpdf.fonts.BundledFonts;
|
||||
|
||||
import java.lang.reflect.Field;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
/**
|
||||
* Декларация бандл-шрифтов в FOP-конфиге (FopFallbackFonts):
|
||||
* выбор рендера для декларации и поведение без инициализации бандла.
|
||||
*/
|
||||
class FopFallbackFontsTest {
|
||||
|
||||
private static final String MIME_PDF = "application/pdf";
|
||||
private static final String MIME_PNG = "image/png";
|
||||
|
||||
/** FOSettings с Fop-конфигом, несущим заданные рендеры. */
|
||||
private static FOSettings settingsWith(Fop.Renderers.Renderer... renderers) {
|
||||
ObjectFactory factory = new ObjectFactory();
|
||||
Fop fop = factory.createFop();
|
||||
Fop.Renderers rs = factory.createFopRenderers();
|
||||
rs.getRenderer().addAll(List.of(renderers));
|
||||
fop.setRenderers(rs);
|
||||
FOSettings settings = new FOSettings();
|
||||
settings.setFopConfig(fop);
|
||||
return settings;
|
||||
}
|
||||
|
||||
private static Fop.Renderers.Renderer renderer(String mime, Fonts fonts) {
|
||||
Fop.Renderers.Renderer r = new ObjectFactory().createFopRenderersRenderer();
|
||||
r.setMime(mime);
|
||||
r.setFonts(fonts);
|
||||
return r;
|
||||
}
|
||||
|
||||
private static boolean hasTripletNamed(Fonts fonts, String name) {
|
||||
return fonts.getFont().stream()
|
||||
.flatMap(f -> 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<String, Map<String, PhysicalFont>> variants =
|
||||
(Map<String, Map<String, PhysicalFont>>) variantsField.get(null);
|
||||
Map<String, Map<String, PhysicalFont>> 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);
|
||||
}
|
||||
}
|
||||
}
|
||||
+126
@@ -203,6 +203,132 @@ class GlyphCoverageNormalizerTest {
|
||||
assertEquals("dejavu sans", segments.get(1).family);
|
||||
}
|
||||
|
||||
/** Битый баланс тегов: закрывающий не балансирует открывающий — ран остаётся. */
|
||||
@Test
|
||||
void unbalancedRunNesting_leftAsIs() {
|
||||
assertNull(GlyphCoverageNormalizer.rewrite("<w:r><w:r></w:r>"));
|
||||
}
|
||||
|
||||
/** Висячий открывающий тег после разобранного блока: проход останавливается, текст цел. */
|
||||
@Test
|
||||
void danglingOpenTagAfterBlock_leftAsIs() {
|
||||
assertNull(GlyphCoverageNormalizer.rewrite("<w:r><w:r></w:r><w:r>"));
|
||||
}
|
||||
|
||||
/** Обрыв на имени тега (<w:r в конце строки) — это не тег, менять нечего. */
|
||||
@Test
|
||||
void truncatedRunTag_leftAsIs() {
|
||||
assertNull(GlyphCoverageNormalizer.rewrite("<w:r"));
|
||||
}
|
||||
|
||||
/** Открывающий тег рана без закрывающей скобки — битый XML остаётся как есть. */
|
||||
@Test
|
||||
void runTagWithoutClosingBracket_leftAsIs() {
|
||||
assertNull(GlyphCoverageNormalizer.rewrite("<w:r w:rsidR=\"0001\""));
|
||||
}
|
||||
|
||||
/** Пустой самозакрывающийся ран пропускается, следующий за ним разрезается. */
|
||||
@Test
|
||||
void selfClosedRunSkipped_nextRunStillSplit() {
|
||||
String xml = NS + "<w:r/><w:r>" + timesRPr()
|
||||
+ "<w:t>" + ROMAN + "</w:t></w:r></w:body></w:document>";
|
||||
|
||||
String out = GlyphCoverageNormalizer.rewrite(xml);
|
||||
|
||||
assertNotNull(out);
|
||||
assertTrue(out.contains("<w:r/>"), "самозакрывающийся ран потерян: " + out);
|
||||
assertTrue(out.contains("DejaVu Serif"), "следующий ран не разрезан: " + out);
|
||||
}
|
||||
|
||||
/** Табуляция/перевод строки после имени w:r — всё ещё открывающий тег рана. */
|
||||
@Test
|
||||
void whitespaceAfterRunTagName_recognizedAsRunOpen() {
|
||||
for (String ws : new String[]{"\t", "\n", "\r"}) {
|
||||
String xml = NS + "<w:r" + ws + "w:rsidR=\"0001\">" + timesRPr()
|
||||
+ "<w:t>" + ROMAN + "</w:t></w:r></w:body></w:document>";
|
||||
|
||||
String out = GlyphCoverageNormalizer.rewrite(xml);
|
||||
|
||||
assertNotNull(out, "ран с не-пробельным разделителем атрибута не разрезан");
|
||||
assertTrue(out.contains("DejaVu Serif"), "нет подстановки: " + out);
|
||||
assertTrue(out.contains("<w:r" + ws + "w:rsidR=\"0001\">"),
|
||||
"открывающий тег рана испорчен: " + out);
|
||||
}
|
||||
}
|
||||
|
||||
/** Незакрытый w:rPr — ран остаётся как есть. */
|
||||
@Test
|
||||
void unclosedRunPr_leftAsIs() {
|
||||
assertNull(GlyphCoverageNormalizer.rewrite(NS + "<w:r><w:rPr>"
|
||||
+ "<w:rFonts w:ascii=\"Times New Roman\"/></w:r>"
|
||||
+ "</w:body></w:document>"));
|
||||
}
|
||||
|
||||
/** 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("<w:rPr><w:rFonts w:eastAsia=\"SimSun\"/></w:rPr>",
|
||||
"<w:t>" + ROMAN + "</w:t>")));
|
||||
}
|
||||
|
||||
/** Контейнерная форма w:rFonts ... </w:rFonts> заменяется самозакрывающимся тегом. */
|
||||
@Test
|
||||
void containerRFonts_replacedWithSelfClosed() {
|
||||
String out = GlyphCoverageNormalizer.rewrite(
|
||||
run("<w:rPr><w:rFonts w:ascii=\"Times New Roman\"></w:rFonts>"
|
||||
+ "<w:sz w:val=\"28\"/></w:rPr>", "<w:t>" + ROMAN + "</w:t>"));
|
||||
|
||||
assertNotNull(out);
|
||||
assertTrue(out.contains("<w:rPr><w:rFonts w:ascii=\"DejaVu Serif\""
|
||||
+ " w:hAnsi=\"DejaVu Serif\"/><w:sz w:val=\"28\"/></w:rPr>"), out);
|
||||
assertFalse(out.contains("</w:rFonts>"), "контейнер не удалён: " + out);
|
||||
}
|
||||
|
||||
/** Контейнерная форма w:rFonts, после которой в rPr нет больше самозакрывающихся тегов. */
|
||||
@Test
|
||||
void containerRFontsAsOnlyChild_replaced() {
|
||||
String out = GlyphCoverageNormalizer.rewrite(
|
||||
run("<w:rPr><w:rFonts w:ascii=\"Times New Roman\"></w:rFonts></w:rPr>",
|
||||
"<w:t>" + ROMAN + "</w:t>"));
|
||||
|
||||
assertNotNull(out);
|
||||
assertTrue(out.contains("<w:rPr><w:rFonts w:ascii=\"DejaVu Serif\""
|
||||
+ " w:hAnsi=\"DejaVu Serif\"/></w:rPr>"), out);
|
||||
}
|
||||
|
||||
/** Битый w:rFonts без закрытия: подставить шрифт нельзя, ран остаётся как есть. */
|
||||
@Test
|
||||
void malformedRFontsTag_leftAsIs() {
|
||||
assertNull(GlyphCoverageNormalizer.rewrite(
|
||||
run("<w:rPr><w:rFonts w:ascii=\"Times New Roman\"</w:rPr>",
|
||||
"<w:t>" + ROMAN + "</w:t>")));
|
||||
}
|
||||
|
||||
/** Шестнадцатеричные числовые сущности разбираются так же, как десятичные. */
|
||||
@Test
|
||||
void decodesHexNumericEntities() {
|
||||
String out = GlyphCoverageNormalizer.rewrite(
|
||||
run(timesRPr(), "<w:t>ↁ</w:t>"));
|
||||
|
||||
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)) {
|
||||
|
||||
@@ -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<String, byte[]> 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 = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
|
||||
+ "<Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\">"
|
||||
+ "<Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\"/>"
|
||||
+ "<Default Extension=\"xml\" ContentType=\"application/xml\"/>"
|
||||
+ "<Override PartName=\"/word/_embedded/ole.bin\" ContentType=\"application/vnd.openxmlformats-officedocument.oleObject\"/>"
|
||||
+ "</Types>";
|
||||
Map<String, byte[]> 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<String, byte[]> 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 = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
|
||||
+ "<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">"
|
||||
+ "<Relationship Id=\"rId1\" Type=\"t\" Target=\"word/_embedded/ole.bin\"/>"
|
||||
+ "<Relationship Id=\"rId2\" Type=\"t\" Target=\"../word/_embedded/ole.bin\"/>"
|
||||
+ "</Relationships>";
|
||||
Map<String, byte[]> 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 без подстроки «<Relationship» (обнулённая продюсером часть) — не парсится. */
|
||||
@Test
|
||||
void relsWithoutRelationshipElementsUntouched() throws Exception {
|
||||
// пустой файл: даже корня Relationships нет — досрочный выход из stripRels
|
||||
String rels = "";
|
||||
Map<String, byte[]> 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<String, byte[]> 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 = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
|
||||
+ "<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">"
|
||||
+ "<Relationship Id=\"rId9\" Type=\"t\"/>"
|
||||
+ "<Relationship Id=\"rId1\" Type=\"t\" Target=\"_embedded/ole.bin\"/>"
|
||||
+ "</Relationships>";
|
||||
Map<String, byte[]> 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 = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
|
||||
+ "<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">"
|
||||
+ "<Relationship Id=\"rIdAbs\" Type=\"t\" Target=\"/word/_embedded/ole.bin\"/>"
|
||||
+ "<Relationship Id=\"rIdUp\" Type=\"t\" Target=\"../word/_embedded/ole.bin\"/>"
|
||||
+ "<Relationship Id=\"rIdDot\" Type=\"t\" Target=\"./_embedded//ole.bin\"/>"
|
||||
+ "<Relationship Id=\"rIdOther\" Type=\"t\" Target=\"_embedded/other.bin\"/>"
|
||||
+ "</Relationships>";
|
||||
Map<String, byte[]> 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 = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
|
||||
+ "<Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\">"
|
||||
+ "<Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\"/>"
|
||||
+ "<Default Extension=\"xml\" ContentType=\"application/xml\"/>"
|
||||
+ "<Override PartName=\"/word/a/_embedded/ole.bin\" ContentType=\"application/vnd.openxmlformats-officedocument.oleObject\"/>"
|
||||
+ "</Types>";
|
||||
String rels = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
|
||||
+ "<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">"
|
||||
+ "<Relationship Id=\"rId1\" Type=\"t\" Target=\"../a/_embedded/ole.bin\"/>"
|
||||
+ "</Relationships>";
|
||||
Map<String, byte[]> 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);
|
||||
}
|
||||
|
||||
/** Незакрытый «<w:object» (нет ни парного элемента, ни самозакрытия) — документ не трогается. */
|
||||
@Test
|
||||
void unclosedWObjectLeftIntact() throws Exception {
|
||||
String doc = "<w:document xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\">"
|
||||
+ "<w:body><w:p>текст с литералом <w:object без закрытия</w:p></w:body></w:document>";
|
||||
Map<String, byte[]> 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<String, byte[]> 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 = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
|
||||
+ "<Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\">"
|
||||
+ "<Default Extension=\"bin\" ContentType=\"application/vnd.openxmlformats-officedocument.oleObject\"/>"
|
||||
+ "<Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\"/>"
|
||||
+ "<Override PartName=\"/word/_embedded/ole.bin\" ContentType=\"application/vnd.openxmlformats-officedocument.oleObject\"></Override>"
|
||||
+ "</Types>";
|
||||
Map<String, byte[]> 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>"),
|
||||
"парный Override сканеру не по зубам и обязан остаться: " + outCt);
|
||||
}
|
||||
|
||||
/** Override без PartName остаётся; Override без ведущего «/» резолвится и удаляется. */
|
||||
@Test
|
||||
void overridePartNameWithoutSlashRemovedPlainKept() throws Exception {
|
||||
String ct = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
|
||||
+ "<Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\">"
|
||||
+ "<Default Extension=\"bin\" ContentType=\"application/vnd.openxmlformats-officedocument.oleObject\"/>"
|
||||
+ "<Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\"/>"
|
||||
+ "<Override ContentType=\"application/x-test\"/>"
|
||||
+ "<Override PartName=\"word/_embedded/ole.bin\" ContentType=\"application/vnd.openxmlformats-officedocument.oleObject\"/>"
|
||||
+ "</Types>";
|
||||
Map<String, byte[]> 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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -197,4 +197,45 @@ class StrictOoxmlNormalizerTest {
|
||||
assertTrue(numbering.contains("<w:start w:val=\"1\"/>"), numbering);
|
||||
assertTrue(numbering.contains("<w:tab w:val=\"left\"/>"), numbering);
|
||||
}
|
||||
|
||||
/** Только закрывающий </w:start> (без открывающего) — тоже переименовывается. */
|
||||
@Test
|
||||
void closingStartWithoutOpenRenamed() {
|
||||
String r = StrictOoxmlNormalizer.rewrite("<w:pBdr></w:start></w:pBdr>");
|
||||
assertNotNull(r);
|
||||
assertTrue(r.contains("</w:left>"), r);
|
||||
assertFalse(r.contains("w:start"), r);
|
||||
}
|
||||
|
||||
/** Только закрывающий </w:end> (без открывающего) — тоже переименовывается. */
|
||||
@Test
|
||||
void closingEndWithoutOpenRenamed() {
|
||||
String r = StrictOoxmlNormalizer.rewrite("<w:pBdr></w:end></w:pBdr>");
|
||||
assertNotNull(r);
|
||||
assertTrue(r.contains("</w:right>"), r);
|
||||
assertFalse(r.contains("w:end"), r);
|
||||
}
|
||||
|
||||
/** Только атрибут w:end (без w:start) — переименовывается. */
|
||||
@Test
|
||||
void endAttributeOnlyRenamed() {
|
||||
String r = StrictOoxmlNormalizer.rewrite("<w:ind w:end=\"36pt\"/>");
|
||||
assertNotNull(r);
|
||||
assertTrue(r.contains("w:right=\"36pt\""), r);
|
||||
}
|
||||
|
||||
/** Только w:val="end" (без start) у w:jc — переименовывается. */
|
||||
@Test
|
||||
void jcEndValueOnlyRenamed() {
|
||||
String r = StrictOoxmlNormalizer.rewrite("<w:jc w:val=\"end\"/>");
|
||||
assertNotNull(r);
|
||||
assertTrue(r.contains("<w:jc w:val=\"right\"/>"), r);
|
||||
}
|
||||
|
||||
/** start/end в w:val у чужих элементов (не w:jc/w:tab) — не трогаем. */
|
||||
@Test
|
||||
void valStartOnForeignElementUntouched() {
|
||||
assertNull(StrictOoxmlNormalizer.rewrite("<w:ind w:val=\"start\"/>"));
|
||||
assertNull(StrictOoxmlNormalizer.rewrite("<w:lvlText w:val=\"end\"/>"));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -179,4 +179,164 @@ class SymbolFontNormalizerTest {
|
||||
assertTrue(out.contains("<w:r><w:rPr><w:rFonts w:ascii=\"Calibri\"/></w:rPr><w:drawing>"),
|
||||
"каркас внешнего рана повреждён: " + out);
|
||||
}
|
||||
|
||||
/** Нет кодов из PUA, но есть w:sym — быстрый путь не отсекает, символ заменяется. */
|
||||
@Test
|
||||
void symWithoutPuaStillRewritten() {
|
||||
String out = SymbolFontNormalizer.rewrite(
|
||||
"<w:r><w:rPr><w:rFonts w:ascii=\"Symbol\"/></w:rPr>"
|
||||
+ "<w:t>a</w:t><w:sym w:char=\"F0A9\"/></w:r>");
|
||||
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("<w:t>a</w:t>"), "текст до w:sym потерян: " + out);
|
||||
}
|
||||
|
||||
/** Битые/незакрытые конструкции не правим (контракт: null = не трогать). */
|
||||
@Test
|
||||
void malformedRunsUntouched() {
|
||||
// открывающий <w:r> есть, закрывающего нет
|
||||
assertNull(SymbolFontNormalizer.rewrite("<w:r><w:t>\uF0B7</w:t>"));
|
||||
// открывающий тег без '>'
|
||||
assertNull(SymbolFontNormalizer.rewrite("<w:r \uF0B7"));
|
||||
// префикс <w:r на самом конце строки
|
||||
assertNull(SymbolFontNormalizer.rewrite("<w:t>\uF0B7</w:t><w:r"));
|
||||
}
|
||||
|
||||
/** Граница имени тега — любой XML-разделитель, не только пробел. */
|
||||
@Test
|
||||
void runTagDelimiterVariantsAccepted() {
|
||||
String out = SymbolFontNormalizer.rewrite(
|
||||
"<w:r\t><w:rPr><w:rFonts w:ascii=\"Symbol\"/></w:rPr><w:t>\uF0B7</w:t></w:r>"
|
||||
+ "<w:r\n><w:rPr><w:rFonts w:ascii=\"Symbol\"/></w:rPr><w:t>\uF0B7</w:t></w:r>"
|
||||
+ "<w:r\r><w:rPr><w:rFonts w:ascii=\"Symbol\"/></w:rPr><w:t>\uF0B7</w:t></w:r>");
|
||||
assertNotNull(out, "ран с табуляцией/переносом в теге пропущен");
|
||||
assertTrue(out.contains("<w:t>•</w:t>"), "PUA не стал Unicode: " + out);
|
||||
assertFalse(out.contains("=\"Symbol\""), "имя шрифта не заменено: " + out);
|
||||
}
|
||||
|
||||
/** Самозакрывающийся <w:r/> — не блок, поиск продолжается со следующего рана. */
|
||||
@Test
|
||||
void selfClosingRunSkipped() {
|
||||
String out = SymbolFontNormalizer.rewrite(
|
||||
"<w:r w:rsidR=\"0001\"/><w:r><w:rPr><w:rFonts w:ascii=\"Symbol\"/></w:rPr>"
|
||||
+ "<w:t>\uF0B7</w:t></w:r>");
|
||||
assertNotNull(out, "ран после <w:r/> не переписан");
|
||||
assertTrue(out.contains("<w:r w:rsidR=\"0001\"/>"), "самозакрывающийся ран повреждён: " + out);
|
||||
assertTrue(out.contains("<w:t>•</w:t>"), "PUA не стал Unicode: " + out);
|
||||
}
|
||||
|
||||
/** Два открывающих, один закрывающий: блок берётся до единственного </w:r>. */
|
||||
@Test
|
||||
void unbalancedNestedRuns_blockUpToSoleClose() {
|
||||
String out = SymbolFontNormalizer.rewrite(
|
||||
"<w:r><w:r><w:rPr><w:rFonts w:ascii=\"Symbol\"/></w:rPr>"
|
||||
+ "<w:t>\uF0B7</w:t></w:r>");
|
||||
assertNotNull(out, "несбалансированный блок не переписан");
|
||||
assertTrue(out.contains("<w:t>•</w:t>"), "PUA не стал Unicode: " + out);
|
||||
assertFalse(out.contains("=\"Symbol\""), "имя шрифта не заменено: " + out);
|
||||
}
|
||||
|
||||
/** Хвост после единственного </w:r> без собственного рана — не трогаем. */
|
||||
@Test
|
||||
void danglingTailAfterCloseUntouched() {
|
||||
assertNull(SymbolFontNormalizer.rewrite("<w:r><w:r></w:r>\uF0B7"));
|
||||
}
|
||||
|
||||
/** Коды вне U+F000–U+F0FF — обычная часть символьного шрифта, не переписываются. */
|
||||
@Test
|
||||
void puaAboveBlockKept() {
|
||||
assertNull(SymbolFontNormalizer.rewrite(
|
||||
"<w:r><w:rPr><w:rFonts w:ascii=\"Symbol\"/></w:rPr><w:t>\uF100</w:t></w:r>"));
|
||||
String out = SymbolFontNormalizer.rewrite(
|
||||
"<w:r><w:rPr><w:rFonts w:ascii=\"Symbol\"/></w:rPr><w:t>\uF0B7\uF100</w:t></w:r>");
|
||||
assertNotNull(out);
|
||||
assertTrue(out.contains("•\uF100"), "F0B7/F100 обработаны неверно: " + out);
|
||||
}
|
||||
|
||||
/** PUA-код без соответствия в таблице остаётся как был, шрифт всё равно меняется. */
|
||||
@Test
|
||||
void unmappedPuaSlotKeepsCode() {
|
||||
String out = SymbolFontNormalizer.rewrite(
|
||||
"<w:r><w:rPr><w:rFonts w:ascii=\"Symbol\"/></w:rPr><w:t>\uF000</w:t></w:r>");
|
||||
assertNotNull(out);
|
||||
assertTrue(out.contains("\uF000"), "код без маппинга потерян: " + out);
|
||||
assertFalse(out.contains("=\"Symbol\""), "имя шрифта не заменено: " + out);
|
||||
}
|
||||
|
||||
/** w:sym в блоке w:lvl (не ран) — не разрезаем. */
|
||||
@Test
|
||||
void symInLevelBlockNotSplit() {
|
||||
assertNull(SymbolFontNormalizer.rewrite(
|
||||
"<w:lvl><w:sym w:font=\"Wingdings\" w:char=\"F0A7\"/></w:lvl>"));
|
||||
}
|
||||
|
||||
/** Открытый <w:rPr> без </w:rPr> перед w:sym — битый ран не правим. */
|
||||
@Test
|
||||
void unclosedRPrBeforeSymUntouched() {
|
||||
assertNull(SymbolFontNormalizer.rewrite(
|
||||
"<w:r><w:rPr><w:sym w:font=\"Symbol\" w:char=\"F0A9\"/></w:r>"));
|
||||
}
|
||||
|
||||
/** w:sym без w:char / без w:font в ране без символьного шрифта / код вне PUA /
|
||||
* слот без маппинга — элемент удаляется, соседний текст сохраняется. */
|
||||
@Test
|
||||
void unresolvableSymElementDropped() {
|
||||
String noChar = SymbolFontNormalizer.rewrite(
|
||||
"<w:r><w:t>a</w:t><w:sym w:font=\"Symbol\"/></w:r>");
|
||||
assertNotNull(noChar);
|
||||
assertFalse(noChar.contains("<w:sym"), "неразрешимый w:sym остался: " + noChar);
|
||||
assertTrue(noChar.contains("<w:t>a</w:t>"), "текст потерян: " + noChar);
|
||||
|
||||
String noFontNoMap = SymbolFontNormalizer.rewrite(
|
||||
"<w:r><w:t>a</w:t><w:sym w:char=\"F0A9\"/></w:r>");
|
||||
assertNotNull(noFontNoMap);
|
||||
assertFalse(noFontNoMap.contains("<w:sym"), "w:sym без шрифта остался: " + noFontNoMap);
|
||||
|
||||
String asciiChar = SymbolFontNormalizer.rewrite(
|
||||
"<w:r><w:t>a</w:t><w:sym w:font=\"Symbol\" w:char=\"0041\"/></w:r>");
|
||||
assertNotNull(asciiChar);
|
||||
assertFalse(asciiChar.contains("<w:sym"), "w:sym с кодом вне PUA остался: " + asciiChar);
|
||||
|
||||
String unmappedChar = SymbolFontNormalizer.rewrite(
|
||||
"<w:r><w:t>a</w:t><w:sym w:font=\"Symbol\" w:char=\"F000\"/></w:r>");
|
||||
assertNotNull(unmappedChar);
|
||||
assertFalse(unmappedChar.contains("<w:sym"), "w:sym без маппинга остался: " + unmappedChar);
|
||||
}
|
||||
|
||||
/** w:sym не самозакрывающийся — под regex не попадает, ран не трогаем. */
|
||||
@Test
|
||||
void nonSelfClosingSymUntouched() {
|
||||
assertNull(SymbolFontNormalizer.rewrite(
|
||||
"<w:r><w:t>a</w:t><w:sym w:font=\"Symbol\" w:char=\"F0A9\"></w:sym></w:r>"));
|
||||
}
|
||||
|
||||
/** rPr без w:rFonts: fallback-семейство вставляется первым ребёнком. */
|
||||
@Test
|
||||
void forceFontInsertsRFontsWhenAbsent() {
|
||||
String out = SymbolFontNormalizer.rewrite(
|
||||
"<w:r><w:rPr><w:sz w:val=\"28\"/></w:rPr>"
|
||||
+ "<w:sym w:font=\"Symbol\" w:char=\"F0A9\"/></w:r>");
|
||||
assertNotNull(out);
|
||||
assertTrue(out.contains("<w:rPr><w:rFonts w:ascii=\"" + SymbolFontNormalizer.REPLACEMENT_FAMILY
|
||||
+ "\" w:hAnsi=\"" + SymbolFontNormalizer.REPLACEMENT_FAMILY
|
||||
+ "\" w:cs=\"" + SymbolFontNormalizer.REPLACEMENT_FAMILY
|
||||
+ "\"/><w:sz w:val=\"28\"/></w:rPr>"),
|
||||
"w:rFonts не вставлен в rPr: " + out);
|
||||
assertTrue(out.contains("♥"), "символ потерян: " + out);
|
||||
}
|
||||
|
||||
/** В обработанном блоке несимвольные имена шрифтов остаются как были. */
|
||||
@Test
|
||||
void nonSymbolFontAttrKept() {
|
||||
String out = SymbolFontNormalizer.rewrite(
|
||||
"<w:r><w:rPr><w:rFonts w:ascii=\"Symbol\" w:eastAsia=\"Arial\"/></w:rPr>"
|
||||
+ "<w:t>\uF0B7</w:t></w:r>");
|
||||
assertNotNull(out);
|
||||
assertTrue(out.contains("w:eastAsia=\"Arial\""), "несимвольный шрифт изменён: " + out);
|
||||
assertTrue(out.contains("w:ascii=\"" + SymbolFontNormalizer.REPLACEMENT_FAMILY + "\""),
|
||||
"символьный шрифт не заменён: " + out);
|
||||
assertTrue(out.contains("<w:t>•</w:t>"), "PUA не стал Unicode: " + out);
|
||||
}
|
||||
}
|
||||
|
||||
+274
@@ -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<int[]> 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<int[]> 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<int[]> runsInRow(BufferedImage img, int y) {
|
||||
List<int[]> 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;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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 приоритетнее палитры");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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<DrawMlText.Paragraph> 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<DrawMlText.Paragraph> 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), "пробельный абзац — чернил нет");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
+164
@@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user