python-hwpx 1.4__tar.gz → 1.5__tar.gz

{python-hwpx-1.4/src/python_hwpx.egg-info → python-hwpx-1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-hwpx
-Version: 1.4
+Version: 1.5
 Summary: Hancom HWPX 패키지를 로드하고 편집하기 위한 Python 유틸리티 모음
 Author: python-hwpx Maintainers
 License: Non-Commercial License
@@ -38,7 +38,7 @@ Requires-Dist: pytest>=7.4; extra == "test"
 - **문서 편집 API** – `hwpx.document.HwpxDocument`는 문단과 표, 메모, 헤더 속성을 파이썬 객체로 노출하고 새 콘텐츠를 손쉽게 추가합니다. 섹션 머리말·꼬리말을 수정하면 `<hp:headerApply>`/`<hp:footerApply>`와 마스터 페이지 링크도 함께 갱신합니다.
 - **타입이 지정된 본문 모델** – `hwpx.oxml.body`는 표·컨트롤·인라인 도형·변경 추적 태그를 데이터 클래스에 매핑하고, `HwpxOxmlParagraph.model`/`HwpxOxmlRun.model`로 이를 조회·수정한 뒤 XML로 되돌릴 수 있도록 지원합니다.
 - **메모와 필드 앵커** – `add_memo_with_anchor()`로 메모를 생성하면서 MEMO 필드 컨트롤을 자동 삽입해 한/글에서 바로 표시되도록 합니다.
-- **헤더 참조 목록 탐색** – 글머리표, 문단 속성, 스타일, 변경 추적 항목, 작성자 정보를 데이터클래스로 파싱하고 `document.bullets`·`document.styles` 같은 조회 헬퍼로 ID 기반 검색을 단순화했습니다.
+- **헤더 참조 목록 탐색** – 글머리표, 문단 속성, 테두리 채우기, 스타일, 변경 추적 항목, 작성자 정보를 데이터클래스로 파싱하고 `document.border_fills`·`document.bullets`·`document.styles` 같은 조회 헬퍼로 ID 기반 검색을 단순화했습니다.
 - **바탕쪽·이력·버전 파트 제어** – 매니페스트에 포함된 master-page/history/version 파트를 `document.master_pages`, `document.histories`, `document.version`으로 직접 편집하고 저장합니다.
 - **스타일 기반 텍스트 치환** – 런 서식(색상, 밑줄, `charPrIDRef`)으로 필터링해 텍스트를 선택적으로 교체하거나 삭제합니다. 하이라이트
   마커나 태그로 분리된 문자열도 서식을 유지한 채 치환합니다.
@@ -79,6 +79,7 @@ print("sections:", len(document.sections))
 # 2) 문단과 표, 메모 추가
 section = document.sections[0]
 paragraph = document.add_paragraph("자동 생성한 문단", section=section)
+# 표에 사용할 기본 실선 테두리 채우기가 없으면 add_table()이 자동으로 생성합니다.
 table = document.add_table(rows=2, cols=2, section=section)
 table.set_cell_text(0, 0, "항목")
 table.set_cell_text(0, 1, "값")
@@ -90,6 +91,8 @@ document.add_memo_with_anchor("배포 전 검토", paragraph=paragraph, memo_sha
 document.save("output/example.hwpx")
 ```
 
+`HwpxDocument.add_table()`은 문서에 정의된 테두리 채우기가 없으면 헤더 참조 목록에 "기본 실선" `borderFill`을 만들어 표와 모든 셀에 참조를 연결합니다.
+
 더 많은 실전 패턴은 [빠른 시작](docs/quickstart.md)과 [사용 가이드](docs/usage.md)의 "빠른 예제 모음"에서 확인할 수 있습니다.
 
 ## 문서

{python-hwpx-1.4 → python-hwpx-1.5}/README.md

@@ -8,7 +8,7 @@
 - **문서 편집 API** – `hwpx.document.HwpxDocument`는 문단과 표, 메모, 헤더 속성을 파이썬 객체로 노출하고 새 콘텐츠를 손쉽게 추가합니다. 섹션 머리말·꼬리말을 수정하면 `<hp:headerApply>`/`<hp:footerApply>`와 마스터 페이지 링크도 함께 갱신합니다.
 - **타입이 지정된 본문 모델** – `hwpx.oxml.body`는 표·컨트롤·인라인 도형·변경 추적 태그를 데이터 클래스에 매핑하고, `HwpxOxmlParagraph.model`/`HwpxOxmlRun.model`로 이를 조회·수정한 뒤 XML로 되돌릴 수 있도록 지원합니다.
 - **메모와 필드 앵커** – `add_memo_with_anchor()`로 메모를 생성하면서 MEMO 필드 컨트롤을 자동 삽입해 한/글에서 바로 표시되도록 합니다.
-- **헤더 참조 목록 탐색** – 글머리표, 문단 속성, 스타일, 변경 추적 항목, 작성자 정보를 데이터클래스로 파싱하고 `document.bullets`·`document.styles` 같은 조회 헬퍼로 ID 기반 검색을 단순화했습니다.
+- **헤더 참조 목록 탐색** – 글머리표, 문단 속성, 테두리 채우기, 스타일, 변경 추적 항목, 작성자 정보를 데이터클래스로 파싱하고 `document.border_fills`·`document.bullets`·`document.styles` 같은 조회 헬퍼로 ID 기반 검색을 단순화했습니다.
 - **바탕쪽·이력·버전 파트 제어** – 매니페스트에 포함된 master-page/history/version 파트를 `document.master_pages`, `document.histories`, `document.version`으로 직접 편집하고 저장합니다.
 - **스타일 기반 텍스트 치환** – 런 서식(색상, 밑줄, `charPrIDRef`)으로 필터링해 텍스트를 선택적으로 교체하거나 삭제합니다. 하이라이트
   마커나 태그로 분리된 문자열도 서식을 유지한 채 치환합니다.
@@ -49,6 +49,7 @@ print("sections:", len(document.sections))
 # 2) 문단과 표, 메모 추가
 section = document.sections[0]
 paragraph = document.add_paragraph("자동 생성한 문단", section=section)
+# 표에 사용할 기본 실선 테두리 채우기가 없으면 add_table()이 자동으로 생성합니다.
 table = document.add_table(rows=2, cols=2, section=section)
 table.set_cell_text(0, 0, "항목")
 table.set_cell_text(0, 1, "값")
@@ -60,6 +61,8 @@ document.add_memo_with_anchor("배포 전 검토", paragraph=paragraph, memo_sha
 document.save("output/example.hwpx")
 ```
 
+`HwpxDocument.add_table()`은 문서에 정의된 테두리 채우기가 없으면 헤더 참조 목록에 "기본 실선" `borderFill`을 만들어 표와 모든 셀에 참조를 연결합니다.
+
 더 많은 실전 패턴은 [빠른 시작](docs/quickstart.md)과 [사용 가이드](docs/usage.md)의 "빠른 예제 모음"에서 확인할 수 있습니다.
 
 ## 문서

{python-hwpx-1.4 → python-hwpx-1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-hwpx"
-version = "1.4"
+version = "1.5"
 description = "Hancom HWPX 패키지를 로드하고 편집하기 위한 Python 유틸리티 모음"
 readme = { file = "README.md", content-type = "text/markdown" }
 license = { text = "Non-Commercial License" }

{python-hwpx-1.4 → python-hwpx-1.5}/src/hwpx/document.py

@@ -11,6 +11,7 @@ from typing import BinaryIO, Iterator, List, Tuple
 
 from .oxml import (
     Bullet,
+    GenericElement,
     HwpxOxmlDocument,
     HwpxOxmlHeader,
     HwpxOxmlHistory,
@@ -107,6 +108,17 @@ class HwpxDocument:
         """Return the version metadata part if present."""
         return self._root.version
 
+    @property
+    def border_fills(self) -> dict[str, GenericElement]:
+        """Return border fill definitions declared in the headers."""
+
+        return self._root.border_fills
+
+    def border_fill(self, border_fill_id_ref: int | str | None) -> GenericElement | None:
+        """Return the border fill definition referenced by *border_fill_id_ref*."""
+
+        return self._root.border_fill(border_fill_id_ref)
+
     @property
     def memo_shapes(self) -> dict[str, MemoShape]:
         """Return memo shapes available in the header reference lists."""
@@ -529,7 +541,7 @@ class HwpxDocument:
         section_index: int | None = None,
         width: int | None = None,
         height: int | None = None,
-        border_fill_id_ref: str | int = "0",
+        border_fill_id_ref: str | int | None = None,
         para_pr_id_ref: str | int | None = None,
         style_id_ref: str | int | None = None,
         char_pr_id_ref: str | int | None = None,
@@ -538,6 +550,10 @@ class HwpxDocument:
     ) -> HwpxOxmlTable:
         """Create a table in a new paragraph and return it."""
 
+        resolved_border_fill: str | int | None = border_fill_id_ref
+        if resolved_border_fill is None:
+            resolved_border_fill = self._root.ensure_basic_border_fill()
+
         paragraph = self.add_paragraph(
             "",
             section=section,
@@ -553,7 +569,7 @@ class HwpxDocument:
             cols,
             width=width,
             height=height,
-            border_fill_id_ref=border_fill_id_ref,
+            border_fill_id_ref=resolved_border_fill,
             run_attributes=run_attributes,
             char_pr_id_ref=char_pr_id_ref,
         )

{python-hwpx-1.4 → python-hwpx-1.5}/src/hwpx/oxml/document.py

@@ -11,6 +11,7 @@ import xml.etree.ElementTree as ET
 from lxml import etree as LET
 
 from . import body
+from .common import GenericElement
 from .header import (
     Bullet,
     MemoProperties,
@@ -21,6 +22,7 @@ from .header import (
     TrackChangeAuthor,
     memo_shape_from_attributes,
     parse_bullets,
+    parse_border_fills,
     parse_paragraph_properties,
     parse_styles,
     parse_track_change_authors,
@@ -44,6 +46,23 @@ _DEFAULT_PARAGRAPH_ATTRS = {
 _DEFAULT_CELL_WIDTH = 7200
 _DEFAULT_CELL_HEIGHT = 3600
 
+_BASIC_BORDER_FILL_ATTRIBUTES = {
+    "threeD": "0",
+    "shadow": "0",
+    "centerLine": "NONE",
+    "breakCellSeparateLine": "0",
+}
+
+_BASIC_BORDER_CHILDREN: Tuple[Tuple[str, dict[str, str]], ...] = (
+    ("slash", {"type": "NONE", "Crooked": "0", "isCounter": "0"}),
+    ("backSlash", {"type": "NONE", "Crooked": "0", "isCounter": "0"}),
+    ("leftBorder", {"type": "SOLID", "width": "0.12 mm", "color": "#000000"}),
+    ("rightBorder", {"type": "SOLID", "width": "0.12 mm", "color": "#000000"}),
+    ("topBorder", {"type": "SOLID", "width": "0.12 mm", "color": "#000000"}),
+    ("bottomBorder", {"type": "SOLID", "width": "0.12 mm", "color": "#000000"}),
+    ("diagonal", {"type": "SOLID", "width": "0.1 mm", "color": "#000000"}),
+)
+
 T = TypeVar("T")
 
 
@@ -107,6 +126,59 @@ def _element_local_name(node: ET.Element) -> str:
     return tag
 
 
+def _normalize_length(value: str | None) -> str:
+    if value is None:
+        return ""
+    return value.replace(" ", "").lower()
+
+
+def _border_fill_is_basic_solid_line(element: ET.Element) -> bool:
+    if _element_local_name(element) != "borderFill":
+        return False
+
+    for attr, expected in _BASIC_BORDER_FILL_ATTRIBUTES.items():
+        actual = element.get(attr)
+        if attr == "centerLine":
+            if (actual or "").upper() != expected:
+                return False
+        else:
+            if actual != expected:
+                return False
+
+    for child_name, child_attrs in _BASIC_BORDER_CHILDREN:
+        child = element.find(f"{_HH}{child_name}")
+        if child is None:
+            return False
+        for attr, expected in child_attrs.items():
+            actual = child.get(attr)
+            if attr == "type":
+                if (actual or "").upper() != expected:
+                    return False
+            elif attr == "width":
+                if _normalize_length(actual) != _normalize_length(expected):
+                    return False
+            elif attr == "color":
+                if (actual or "").upper() != expected.upper():
+                    return False
+            else:
+                if actual != expected:
+                    return False
+
+    for child in element:
+        if _element_local_name(child) == "fillBrush":
+            return False
+
+    return True
+
+
+def _create_basic_border_fill_element(border_id: str) -> ET.Element:
+    attrs = {"id": border_id, **_BASIC_BORDER_FILL_ATTRIBUTES}
+    element = ET.Element(f"{_HH}borderFill", attrs)
+    for child_name, child_attrs in _BASIC_BORDER_CHILDREN:
+        ET.SubElement(element, f"{_HH}{child_name}", dict(child_attrs))
+    return element
+
+
 def _distribute_size(total: int, parts: int) -> List[int]:
     """Return *parts* integers that sum to *total* and are as even as possible."""
 
@@ -1525,13 +1597,15 @@ class HwpxOxmlTable:
         *,
         width: int | None = None,
         height: int | None = None,
-        border_fill_id_ref: str | int = "0",
+        border_fill_id_ref: str | int | None = None,
     ) -> ET.Element:
         if rows <= 0 or cols <= 0:
             raise ValueError("rows and cols must be positive integers")
 
         table_width = width if width is not None else cols * _DEFAULT_CELL_WIDTH
         table_height = height if height is not None else rows * _DEFAULT_CELL_HEIGHT
+        if border_fill_id_ref is None:
+            raise ValueError("border_fill_id_ref must be provided")
         border_fill = str(border_fill_id_ref)
 
         table_attrs = {
@@ -1864,10 +1938,19 @@ class HwpxOxmlParagraph:
         *,
         width: int | None = None,
         height: int | None = None,
-        border_fill_id_ref: str | int = "0",
+        border_fill_id_ref: str | int | None = None,
         run_attributes: dict[str, str] | None = None,
         char_pr_id_ref: str | int | None = None,
     ) -> HwpxOxmlTable:
+        if border_fill_id_ref is None:
+            document = self.section.document
+            if document is not None:
+                resolved_border_fill: str | int = document.ensure_basic_border_fill()
+            else:
+                resolved_border_fill = "0"
+        else:
+            resolved_border_fill = border_fill_id_ref
+
         run = self._create_run_for_object(
             run_attributes,
             char_pr_id_ref=char_pr_id_ref,
@@ -1877,7 +1960,7 @@ class HwpxOxmlParagraph:
             cols,
             width=width,
             height=height,
-            border_fill_id_ref=border_fill_id_ref,
+            border_fill_id_ref=resolved_border_fill,
         )
         run.append(table_element)
         self.section.mark_dirty()
@@ -2253,6 +2336,16 @@ class HwpxOxmlHeader:
             self.mark_dirty()
         return element
 
+    def _border_fills_element(self, create: bool = False) -> ET.Element | None:
+        ref_list = self._ref_list_element(create=create)
+        if ref_list is None:
+            return None
+        element = ref_list.find(f"{_HH}borderFills")
+        if element is None and create:
+            element = ET.SubElement(ref_list, f"{_HH}borderFills", {"itemCnt": "0"})
+            self.mark_dirty()
+        return element
+
     def _char_properties_element(self, create: bool = False) -> ET.Element | None:
         ref_list = self._ref_list_element(create=create)
         if ref_list is None:
@@ -2267,6 +2360,10 @@ class HwpxOxmlHeader:
         count = len(list(element.findall(f"{_HH}charPr")))
         element.set("itemCnt", str(count))
 
+    def _update_border_fills_item_count(self, element: ET.Element) -> None:
+        count = len(list(element.findall(f"{_HH}borderFill")))
+        element.set("itemCnt", str(count))
+
     def _allocate_char_property_id(
         self,
         element: ET.Element,
@@ -2297,6 +2394,26 @@ class HwpxOxmlHeader:
             candidate = str(next_id)
         return candidate
 
+    def _allocate_border_fill_id(self, element: ET.Element) -> str:
+        existing: set[str] = {
+            child.get("id") or ""
+            for child in element.findall(f"{_HH}borderFill")
+        }
+        existing.discard("")
+
+        numeric_ids: List[int] = []
+        for value in existing:
+            try:
+                numeric_ids.append(int(value))
+            except ValueError:
+                continue
+        next_id = 0 if not numeric_ids else max(numeric_ids) + 1
+        candidate = str(next_id)
+        while candidate in existing:
+            next_id += 1
+            candidate = str(next_id)
+        return candidate
+
     def ensure_char_property(
         self,
         *,
@@ -2386,6 +2503,59 @@ class HwpxOxmlHeader:
             return None
         return ref_list.find(f"{_HH}trackChangeAuthors")
 
+    def find_basic_border_fill_id(self) -> str | None:
+        element = self._border_fills_element()
+        if element is None:
+            return None
+        for child in element.findall(f"{_HH}borderFill"):
+            if _border_fill_is_basic_solid_line(child):
+                identifier = child.get("id")
+                if identifier:
+                    return identifier
+        return None
+
+    def ensure_basic_border_fill(self) -> str:
+        element = self._border_fills_element(create=True)
+        if element is None:  # pragma: no cover - defensive branch
+            raise RuntimeError("failed to create <borderFills> element")
+
+        existing = self.find_basic_border_fill_id()
+        if existing is not None:
+            return existing
+
+        new_id = self._allocate_border_fill_id(element)
+        element.append(_create_basic_border_fill_element(new_id))
+        self._update_border_fills_item_count(element)
+        self.mark_dirty()
+        return new_id
+
+    @property
+    def border_fills(self) -> dict[str, GenericElement]:
+        element = self._border_fills_element()
+        if element is None:
+            return {}
+
+        fill_list = parse_border_fills(self._convert_to_lxml(element))
+        mapping: dict[str, GenericElement] = {}
+        for border_fill in fill_list.fills:
+            raw_id = border_fill.attributes.get("id")
+            keys: List[str] = []
+            if raw_id:
+                keys.append(raw_id)
+                try:
+                    normalized = str(int(raw_id))
+                except ValueError:
+                    normalized = None
+                if normalized and normalized not in keys:
+                    keys.append(normalized)
+            for key in keys:
+                if key not in mapping:
+                    mapping[key] = border_fill
+        return mapping
+
+    def border_fill(self, border_fill_id_ref: int | str | None) -> GenericElement | None:
+        return self._lookup_by_id(self.border_fills, border_fill_id_ref)
+
     @staticmethod
     def _convert_to_lxml(element: ET.Element) -> LET._Element:
         return LET.fromstring(ET.tostring(element, encoding="utf-8"))
@@ -2788,6 +2958,27 @@ class HwpxOxmlDocument:
             raise RuntimeError("charPr element is missing an id")
         return char_id
 
+    @property
+    def border_fills(self) -> dict[str, GenericElement]:
+        mapping: dict[str, GenericElement] = {}
+        for header in self._headers:
+            mapping.update(header.border_fills)
+        return mapping
+
+    def border_fill(self, border_fill_id_ref: int | str | None) -> GenericElement | None:
+        return HwpxOxmlHeader._lookup_by_id(self.border_fills, border_fill_id_ref)
+
+    def ensure_basic_border_fill(self) -> str:
+        if not self._headers:
+            return "0"
+
+        for header in self._headers:
+            existing = header.find_basic_border_fill_id()
+            if existing is not None:
+                return existing
+
+        return self._headers[0].ensure_basic_border_fill()
+
     @property
     def memo_shapes(self) -> dict[str, MemoShape]:
         shapes: dict[str, MemoShape] = {}

{python-hwpx-1.4 → python-hwpx-1.5/src/python_hwpx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-hwpx
-Version: 1.4
+Version: 1.5
 Summary: Hancom HWPX 패키지를 로드하고 편집하기 위한 Python 유틸리티 모음
 Author: python-hwpx Maintainers
 License: Non-Commercial License
@@ -38,7 +38,7 @@ Requires-Dist: pytest>=7.4; extra == "test"
 - **문서 편집 API** – `hwpx.document.HwpxDocument`는 문단과 표, 메모, 헤더 속성을 파이썬 객체로 노출하고 새 콘텐츠를 손쉽게 추가합니다. 섹션 머리말·꼬리말을 수정하면 `<hp:headerApply>`/`<hp:footerApply>`와 마스터 페이지 링크도 함께 갱신합니다.
 - **타입이 지정된 본문 모델** – `hwpx.oxml.body`는 표·컨트롤·인라인 도형·변경 추적 태그를 데이터 클래스에 매핑하고, `HwpxOxmlParagraph.model`/`HwpxOxmlRun.model`로 이를 조회·수정한 뒤 XML로 되돌릴 수 있도록 지원합니다.
 - **메모와 필드 앵커** – `add_memo_with_anchor()`로 메모를 생성하면서 MEMO 필드 컨트롤을 자동 삽입해 한/글에서 바로 표시되도록 합니다.
-- **헤더 참조 목록 탐색** – 글머리표, 문단 속성, 스타일, 변경 추적 항목, 작성자 정보를 데이터클래스로 파싱하고 `document.bullets`·`document.styles` 같은 조회 헬퍼로 ID 기반 검색을 단순화했습니다.
+- **헤더 참조 목록 탐색** – 글머리표, 문단 속성, 테두리 채우기, 스타일, 변경 추적 항목, 작성자 정보를 데이터클래스로 파싱하고 `document.border_fills`·`document.bullets`·`document.styles` 같은 조회 헬퍼로 ID 기반 검색을 단순화했습니다.
 - **바탕쪽·이력·버전 파트 제어** – 매니페스트에 포함된 master-page/history/version 파트를 `document.master_pages`, `document.histories`, `document.version`으로 직접 편집하고 저장합니다.
 - **스타일 기반 텍스트 치환** – 런 서식(색상, 밑줄, `charPrIDRef`)으로 필터링해 텍스트를 선택적으로 교체하거나 삭제합니다. 하이라이트
   마커나 태그로 분리된 문자열도 서식을 유지한 채 치환합니다.
@@ -79,6 +79,7 @@ print("sections:", len(document.sections))
 # 2) 문단과 표, 메모 추가
 section = document.sections[0]
 paragraph = document.add_paragraph("자동 생성한 문단", section=section)
+# 표에 사용할 기본 실선 테두리 채우기가 없으면 add_table()이 자동으로 생성합니다.
 table = document.add_table(rows=2, cols=2, section=section)
 table.set_cell_text(0, 0, "항목")
 table.set_cell_text(0, 1, "값")
@@ -90,6 +91,8 @@ document.add_memo_with_anchor("배포 전 검토", paragraph=paragraph, memo_sha
 document.save("output/example.hwpx")
 ```
 
+`HwpxDocument.add_table()`은 문서에 정의된 테두리 채우기가 없으면 헤더 참조 목록에 "기본 실선" `borderFill`을 만들어 표와 모든 셀에 참조를 연결합니다.
+
 더 많은 실전 패턴은 [빠른 시작](docs/quickstart.md)과 [사용 가이드](docs/usage.md)의 "빠른 예제 모음"에서 확인할 수 있습니다.
 
 ## 문서

{python-hwpx-1.4 → python-hwpx-1.5}/src/python_hwpx.egg-info/SOURCES.txt

@@ -33,4 +33,5 @@ tests/test_integration_hwpx_compatibility.py
 tests/test_memo_and_style_editing.py
 tests/test_oxml_parsing.py
 tests/test_section_headers.py
+tests/test_tables_default_border.py
 tests/test_text_extractor_annotations.py

python-hwpx-1.5/tests/test_tables_default_border.py

@@ -0,0 +1,81 @@
+"""Integration tests for automatic table border fills."""
+
+from __future__ import annotations
+
+import xml.etree.ElementTree as ET
+
+from hwpx.document import HwpxDocument
+
+HP_NS = "http://www.hancom.co.kr/hwpml/2011/paragraph"
+HH_NS = "http://www.hancom.co.kr/hwpml/2011/head"
+HP = f"{{{HP_NS}}}"
+HH = f"{{{HH_NS}}}"
+
+
+def test_add_table_injects_basic_border_fill_when_missing() -> None:
+    document = HwpxDocument.new()
+
+    header = document.headers[0]
+    ref_list = header.element.find(f"{HH}refList")
+    if ref_list is not None:
+        existing = ref_list.find(f"{HH}borderFills")
+        if existing is not None:
+            ref_list.remove(existing)
+    header.reset_dirty()
+
+    section = document.sections[0]
+    section.reset_dirty()
+
+    table = document.add_table(2, 2, section=section)
+    assert table is not None
+
+    updates = document.oxml.serialize()
+
+    assert header.part_name in updates
+    header_root = ET.fromstring(updates[header.part_name])
+
+    border_fills_element = header_root.find(f".//{HH}borderFills")
+    assert border_fills_element is not None
+    assert border_fills_element.get("itemCnt") == "1"
+
+    border_fill_element = border_fills_element.find(f"{HH}borderFill")
+    assert border_fill_element is not None
+    border_id = border_fill_element.get("id")
+    assert border_id == "0"
+    assert border_fill_element.get("threeD") == "0"
+    assert border_fill_element.get("shadow") == "0"
+    assert border_fill_element.get("centerLine") == "NONE"
+    assert border_fill_element.get("breakCellSeparateLine") == "0"
+
+    slash = border_fill_element.find(f"{HH}slash")
+    assert slash is not None
+    assert slash.get("type") == "NONE"
+
+    back_slash = border_fill_element.find(f"{HH}backSlash")
+    assert back_slash is not None
+    assert back_slash.get("type") == "NONE"
+
+    for child_name in ("leftBorder", "rightBorder", "topBorder", "bottomBorder"):
+        child = border_fill_element.find(f"{HH}{child_name}")
+        assert child is not None
+        assert child.get("type") == "SOLID"
+        assert child.get("width") == "0.12 mm"
+        assert child.get("color") == "#000000"
+
+    diagonal = border_fill_element.find(f"{HH}diagonal")
+    assert diagonal is not None
+    assert diagonal.get("type") == "SOLID"
+    assert diagonal.get("width") == "0.1 mm"
+    assert diagonal.get("color") == "#000000"
+
+    assert section.part_name in updates
+    section_root = ET.fromstring(updates[section.part_name])
+
+    table_element = section_root.find(f".//{HP}tbl")
+    assert table_element is not None
+    assert table_element.get("borderFillIDRef") == border_id
+
+    cells = section_root.findall(f".//{HP}tc")
+    assert cells
+    for cell in cells:
+        assert cell.get("borderFillIDRef") == border_id