Merged work on Temp_SpaceResolution branch into trunk (-r 320826:327988).

Source: http://svn.apache.org/repos/asf/xmlgraphics/fop/branches/Temp_SpaceResolution/

git-svn-id: https://svn.apache.org/repos/asf/xmlgraphics/fop/trunk@328010 13f79535-47bb-0310-9956-ffa450edef68

src/java/org/apache/fop/datatypes/SimplePercentBaseContext.java

@@ -31,7 +31,8 @@ public class SimplePercentBaseContext implements PercentBaseContext {
 
     /**
      * @param parentContext the context to be used for all percentages other than lengthBase
-     * @param lengthBase the particular percentage length base for which this context provides a value
+     * @param lengthBase the particular percentage length base for which this context provides 
+     *                   a value
      * @param lengthBaseValue the value to be returned for requests to the given lengthBase
      */
     public SimplePercentBaseContext(PercentBaseContext parentContext,

src/java/org/apache/fop/datatypes/ValidationPercentBaseContext.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* $Id: SimplePercentBaseContext.java 279656 2005-09-08 22:06:48Z pietsch $ */
+
+package org.apache.fop.datatypes;
+
+import org.apache.fop.fo.FObj;
+
+/**
+ * This base context is used during validation when the actual base values are still unknown
+ * but should still already be checked. The actual value returned is not so important in this
+ * case. But it's important that zero and non-zero values can be distinguished.
+ * <p>
+ * Example: A table with collapsing border model has no padding. The Table FO should be able 
+ * to check if non-zero values (even percentages) have been specified.
+ */
+public final class ValidationPercentBaseContext implements PercentBaseContext {
+    
+    /**
+     * Main constructor.
+     */
+    private ValidationPercentBaseContext() {
+    }
+
+    /**
+     * Returns the value for the given lengthBase.
+     * @see org.apache.fop.datatypes.PercentBaseContext#getBaseLength(int, FObj)
+     */
+    public int getBaseLength(int lengthBase, FObj fobj) {
+        //Simply return a dummy value which produces a non-zero value when a non-zero percentage
+        //was specified.
+        return 100000;
+    }
+
+    private static PercentBaseContext pseudoContextForValidation = null;
+    
+    /** @return a base context for validation purposes. See class description. */
+    public static PercentBaseContext getPseudoContextForValidationPurposes() {
+        if (pseudoContextForValidation == null) {
+            pseudoContextForValidation = new ValidationPercentBaseContext();
+        }
+        return pseudoContextForValidation;
+    }
+    
+}

src/java/org/apache/fop/fo/FONode.java

@@ -311,7 +311,7 @@ public abstract class FONode implements Cloneable {
      * @param problem text to display that indicates the problem
      */
     protected void attributeWarning(String problem) {
-        log.warn(errorText(locator) + getName() + ", " + problem);
+        log.warn(warningText(locator) + getName() + ", " + problem);
     }
 
     /**
@@ -437,7 +437,7 @@ public abstract class FONode implements Cloneable {
      * @param loc org.xml.sax.Locator object
      * @return String the formatted text
      */
-    protected static String getLocatorString(Locator loc) {
+    public static String getLocatorString(Locator loc) {
         if (loc == null) {
             return "Unknown location";
         } else {

src/java/org/apache/fop/fo/flow/Table.java

@@ -24,9 +24,8 @@ import java.util.List;
 import org.xml.sax.Locator;
 
 import org.apache.fop.apps.FOPException;
-import org.apache.fop.datatypes.Numeric;
+import org.apache.fop.datatypes.ValidationPercentBaseContext;
 import org.apache.fop.fo.FONode;
-import org.apache.fop.fo.FObj;
 import org.apache.fop.fo.PropertyList;
 import org.apache.fop.fo.StaticPropertyList;
 import org.apache.fop.fo.ValidationException;
@@ -129,17 +128,19 @@ public class Table extends TableFObj {
         colPList.setWritingMode();
         defaultColumn.bind(colPList);
 
-        /*if (borderCollapse != EN_SEPARATE && commonBorderPaddingBackground.hasPadding()) {
-            //See "17.6.2 The collapsing border model" in CSS2
-            getLogger().warn("Table may not have padding when using the collapsing "
-                    + "border model. Padding will be ignored.");
-        }*/
         if (borderCollapse != EN_SEPARATE) {
-            getLogger().warn("The collapsing border model on an fo:table "
+            attributeWarning("The collapsing border model on an fo:table "
                     + "is currently not supported by FOP");
         }
         if (tableLayout == EN_AUTO) {
-            getLogger().warn("table-layout=\"auto\" is currently not supported by FOP");
+            attributeWarning("table-layout=\"auto\" is currently not supported by FOP");
+        }
+        if (!isSeparateBorderModel() && getCommonBorderPaddingBackground().hasPadding(
+                ValidationPercentBaseContext.getPseudoContextForValidationPurposes())) {
+            //See "17.6.2 The collapsing border model" in CSS2
+            attributeWarning("In collapsing border model a table does not have padding"
+                    + " (see http://www.w3.org/TR/REC-CSS2/tables.html#collapsing-borders)"
+                    + ", but a non-zero value for padding was found. The padding will be ignored.");
         }
     }
 
@@ -217,11 +218,11 @@ public class Table extends TableFObj {
      * @see org.apache.fop.fo.FONode#addChildNode(FONode)
      */
     protected void addChildNode(FONode child) throws FOPException {
-        if (child.getName().equals("fo:table-column")) {
+        if ("fo:table-column".equals(child.getName())) {
             addColumnNode((TableColumn) child);
-        } else if (child.getName().equals("fo:table-footer")) {
+        } else if ("fo:table-footer".equals(child.getName())) {
             tableFooter = (TableBody)child;
-        } else if (child.getName().equals("fo:table-header")) {
+        } else if ("fo:table-header".equals(child.getName())) {
             tableHeader = (TableBody)child;
         } else {
             // add bodies

src/java/org/apache/fop/fo/flow/TableFObj.java

@@ -20,6 +20,7 @@ package org.apache.fop.fo.flow;
 
 import org.apache.fop.apps.FOPException;
 import org.apache.fop.datatypes.Numeric;
+import org.apache.fop.datatypes.ValidationPercentBaseContext;
 import org.apache.fop.fo.FONode;
 import org.apache.fop.fo.FObj;
 import org.apache.fop.fo.PropertyList;
@@ -27,9 +28,7 @@ import org.apache.fop.fo.properties.CommonBorderPaddingBackground;
 
 /**
  * Superclass for table-related FOs
- *
  */
-
 public abstract class TableFObj extends FObj {
 
     private Numeric borderAfterPrecedence;
@@ -82,8 +81,17 @@ public abstract class TableFObj extends FObj {
         if (getNameId() != FO_TABLE && getNameId() != FO_TABLE_CELL
                 && getTable().isSeparateBorderModel()
                 && getCommonBorderPaddingBackground().hasBorderInfo()) {
-            getLogger().warn("Borders on " + getName() 
-                    + " non-applicable for table with border-collapse=\"separate\"");
+            attributeWarning("In the separate border model (border-collapse=\"separate\")"
+                    + ", borders cannot be specified on a " + getName() 
+                    + ", but a non-zero value for border was found. The border will be ignored. ");
+        }
+        if (getNameId() != FO_TABLE //Separate check for fo:table in Table.java
+                && getNameId() != FO_TABLE_CELL
+                && getCommonBorderPaddingBackground().hasPadding(
+                        ValidationPercentBaseContext.getPseudoContextForValidationPurposes())) {
+            attributeWarning(getName() + " does not have padding"
+                    + " (see the property list for " + getName() + " in XSL 1.0)"
+                    + ", but a non-zero value for padding was found. The padding will be ignored.");
         }
     }
     

src/java/org/apache/fop/layoutmgr/AbstractBreaker.java

@@ -76,8 +76,8 @@ public abstract class AbstractBreaker {
             return this.startOn;
         }
 
-        public BlockSequence endBlockSequence() {
-            KnuthSequence temp = super.endSequence();
+        public BlockSequence endBlockSequence(Position breakPosition) {
+            KnuthSequence temp = super.endSequence(breakPosition);
             if (temp != null) {
                 BlockSequence returnSequence = new BlockSequence(startOn);
                 returnSequence.addAll(temp);
@@ -273,6 +273,7 @@ public abstract class AbstractBreaker {
         ListIterator effectiveListIterator = effectiveList.listIterator();
         int startElementIndex = 0;
         int endElementIndex = 0;
+        int lastBreak = -1;
         for (int p = 0; p < partCount; p++) {
             PageBreakPosition pbp = (PageBreakPosition) alg.getPageBreaks().get(p);
 
@@ -307,6 +308,10 @@ public abstract class AbstractBreaker {
             
             int displayAlign = getCurrentDisplayAlign();
             
+            //The following is needed by SpaceResolver.performConditionalsNotification()
+            //further down as there may be important Position elements in the element list trailer
+            int notificationEndElementIndex = endElementIndex;
+
             // ignore the last elements added by the
             // PageSequenceLayoutManager
             endElementIndex -= (endElementIndex == (originalList.size() - 1)) 
@@ -328,12 +333,13 @@ public abstract class AbstractBreaker {
             while (effectiveListIterator.hasNext()
                     && !(firstElement = (KnuthElement) effectiveListIterator.next())
                             .isBox()) {
-                if (firstElement.isGlue()) {
+                /*
+                if (firstElement.isGlue() && firstElement.getLayoutManager() != null) {
                     // discard the space representd by the glue element
                     ((BlockLevelLayoutManager) firstElement
                             .getLayoutManager())
                             .discardSpace((KnuthGlue) firstElement);
-                }
+                }*/
                 startElementIndex++;
             }
 
@@ -377,6 +383,11 @@ public abstract class AbstractBreaker {
                 }
                 /* *** *** non-standard extension *** *** */
 
+                // Handle SpaceHandling(Break)Positions, see SpaceResolver!
+                SpaceResolver.performConditionalsNotification(effectiveList, 
+                        startElementIndex, notificationEndElementIndex, lastBreak);
+                
+                // Add areas now!
                 addAreas(new KnuthPossPosIter(effectiveList,
                         startElementIndex, endElementIndex + 1), childLC);
             } else {
@@ -386,10 +397,18 @@ public abstract class AbstractBreaker {
 
             finishPart(alg, pbp);
 
+            lastBreak = endElementIndex;
             startElementIndex = pbp.getLeafPos() + 1;
         }
     }
-    
+    /**
+     * Notifies the layout managers about the space and conditional length situation based on
+     * the break decisions.
+     * @param effectiveList Element list to be painted
+     * @param startElementIndex start index of the part
+     * @param endElementIndex end index of the part
+     * @param lastBreak index of the last break element
+     */
     /**
      * Handles span changes reported through the <code>LayoutContext</code>. 
      * Only used by the PSLM and called by <code>getNextBlockList()</code>.
@@ -425,10 +444,12 @@ public abstract class AbstractBreaker {
             //Only implemented by the PSLM
             nextSequenceStartsOn = handleSpanChange(childLC, nextSequenceStartsOn);
             
+            Position breakPosition = null;
             if (((KnuthElement) returnedList.getLast()).isPenalty()
                     && ((KnuthPenalty) returnedList.getLast()).getP() == -KnuthElement.INFINITE) {
                 KnuthPenalty breakPenalty = (KnuthPenalty) returnedList
                         .removeLast();
+                breakPosition = breakPenalty.getPosition();
                 switch (breakPenalty.getBreakClass()) {
                 case Constants.EN_PAGE:
                     log.debug("PLM> break - PAGE");
@@ -454,7 +475,7 @@ public abstract class AbstractBreaker {
             }
             blockList.addAll(returnedList);
             BlockSequence seq = null;
-            seq = blockList.endBlockSequence();
+            seq = blockList.endBlockSequence(breakPosition);
             if (seq != null) {
                 blockLists.add(seq);
             }

src/java/org/apache/fop/layoutmgr/AreaAdditionUtil.java

@@ -21,6 +21,11 @@ package org.apache.fop.layoutmgr;
 import java.util.Iterator;
 import java.util.LinkedList;
 
+import org.apache.fop.layoutmgr.SpaceResolver.SpaceHandlingBreakPosition;
+
+/**
+ * Utility class which provides common code for the addAreas stage.
+ */
 public class AreaAdditionUtil {
 
     private static class StackingIter extends PositionIterator {
@@ -37,6 +42,12 @@ public class AreaAdditionUtil {
         }
     }
 
+    /**
+     * Creates the child areas for the given layout manager.
+     * @param bslm the BlockStackingLayoutManager instance for which "addAreas" is performed.
+     * @param parentIter the position iterator
+     * @param layoutContext the layout context
+     */
     public static void addAreas(BlockStackingLayoutManager bslm, 
             PositionIterator parentIter, LayoutContext layoutContext) {
         LayoutManager childLM = null;
@@ -52,6 +63,9 @@ public class AreaAdditionUtil {
         Position pos;
         while (parentIter.hasNext()) {
             pos = (Position)parentIter.next();
+            if (pos == null) {
+                continue;
+            }
             if (pos.getIndex() >= 0) {
                 if (firstPos == null) {
                     firstPos = pos;
@@ -65,12 +79,14 @@ public class AreaAdditionUtil {
                 if (firstLM == null) {
                     firstLM = lastLM;
                 }
+            } else if (pos instanceof SpaceHandlingBreakPosition) {
+                positionList.add(pos);
             } else {
                 // pos was created by this LM, so it must be ignored
             }
         }
         
-        if (bslm.markers != null) {
+        if (bslm != null && bslm.markers != null) {
             bslm.getCurrentPV().addMarkers(bslm.markers, true, 
                     bslm.isFirst(firstPos), bslm.isLast(lastPos));
         }
@@ -91,7 +107,7 @@ public class AreaAdditionUtil {
             lc.setStackLimit(layoutContext.getStackLimit());
             childLM.addAreas(childPosIter, lc);
         }
-        if (bslm.markers != null) {
+        if (bslm != null && bslm.markers != null) {
             bslm.getCurrentPV().addMarkers(bslm.markers, false, 
                     bslm.isFirst(firstPos), bslm.isLast(lastPos));
         }

src/java/org/apache/fop/layoutmgr/BlockContainerLayoutManager.java

@@ -39,7 +39,8 @@ import org.apache.fop.traits.SpaceVal;
 /**
  * LayoutManager for a block-container FO.
  */
-public class BlockContainerLayoutManager extends BlockStackingLayoutManager {
+public class BlockContainerLayoutManager extends BlockStackingLayoutManager 
+                implements ConditionalElementListener {
     
     private BlockViewport viewportBlockArea;
     private Block referenceArea;
@@ -68,6 +69,14 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager {
     private MinOptMax foBlockSpaceBefore;
     private MinOptMax foBlockSpaceAfter;
     
+    private boolean discardBorderBefore;
+    private boolean discardBorderAfter;
+    private boolean discardPaddingBefore;
+    private boolean discardPaddingAfter;
+    private MinOptMax effSpaceBefore;
+    private MinOptMax effSpaceAfter;
+
+    
     /**
      * Create a new block container layout manager.
      * @param node block-container node to create the layout manager for.
@@ -76,6 +85,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager {
         super(node);
     }
     
+    /** @see org.apache.fop.layoutmgr.LayoutManager#initialize() */
     public void initialize() {
         abProps = getBlockContainerFO().getCommonAbsolutePosition();
         foBlockSpaceBefore = new SpaceVal(getBlockContainerFO().getCommonMarginBlock()
@@ -111,6 +121,15 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager {
                 .spaceAfter.getSpace().getMinimum(this).getLength().getValue(this);
         }
     }
+    
+    private void resetSpaces() {
+        this.discardBorderBefore = false;        
+        this.discardBorderAfter = false;        
+        this.discardPaddingBefore = false;        
+        this.discardPaddingAfter = false;
+        this.effSpaceBefore = foSpaceBefore;
+        this.effSpaceAfter = foSpaceAfter;
+    }
 
     /** @return the content IPD */
     protected int getRotatedIPD() {
@@ -151,6 +170,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager {
     
     /** @see org.apache.fop.layoutmgr.LayoutManager */
     public LinkedList getNextKnuthElements(LayoutContext context, int alignment) {
+        resetSpaces();
         if (isAbsoluteOrFixed()) {
             return getNextKnuthElementsAbsolute(context, alignment);
         }
@@ -201,7 +221,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager {
         
         if (!bBreakBeforeServed) {
             try {
-                if (addKnuthElementsForBreakBefore(returnList)) {
+                if (addKnuthElementsForBreakBefore(returnList, context)) {
                     return returnList;
                 }
             } finally {
@@ -209,18 +229,20 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager {
             }
         }
 
-        if (!bSpaceBeforeServed) {
-            addKnuthElementsForSpaceBefore(returnList, alignment);
-            bSpaceBeforeServed = true;
-        }
+        addKnuthElementsForSpaceBefore(returnList, alignment);
         
-        addKnuthElementsForBorderPaddingBefore(returnList);
+        addKnuthElementsForBorderPaddingBefore(returnList, !firstVisibleMarkServed);
+        firstVisibleMarkServed = true;
 
         if (autoHeight) {
+            //Spaces, border and padding to be repeated at each break
+            addPendingMarks(context);
+
             BlockLevelLayoutManager curLM; // currently active LM
             BlockLevelLayoutManager prevLM = null; // previously active LM
             while ((curLM = (BlockLevelLayoutManager) getChildLM()) != null) {
                 LayoutContext childLC = new LayoutContext(0);
+                childLC.copyPendingMarksFrom(context);
                 // curLM is a ?
                 childLC.setStackLimit(MinOptMax.subtract(context
                         .getStackLimit(), stackLimit));
@@ -230,10 +252,9 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager {
                 // get elements from curLM
                 returnedList = curLM.getNextKnuthElements(childLC, alignment);
                 if (returnedList.size() == 1
-                        && ((KnuthElement)returnedList.getFirst()).isPenalty()
-                        && ((KnuthPenalty)returnedList.getFirst()).getP() 
-                                == -KnuthElement.INFINITE) {
+                        && ((KnuthElement)returnedList.getFirst()).isForcedBreak()) {
                     // a descendant of this block has break-before
+                    /*
                     if (returnList.size() == 0) {
                         // the first child (or its first child ...) has
                         // break-before;
@@ -241,7 +262,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager {
                         // the
                         // following page
                         bSpaceBeforeServed = false;
-                    }
+                    }*/
                     contentList.addAll(returnedList);
 
                     // "wrap" the Position inside each element
@@ -259,13 +280,17 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager {
                                 || curLM.mustKeepWithPrevious()) {
                             // add an infinite penalty to forbid a break between
                             // blocks
-                            contentList.add(new KnuthPenalty(0,
-                                    KnuthElement.INFINITE, false,
-                                    new Position(this), false));
+                            contentList.add(new BreakElement(
+                                    new Position(this), KnuthElement.INFINITE, context));
+                            //contentList.add(new KnuthPenalty(0,
+                            //        KnuthElement.INFINITE, false,
+                            //        new Position(this), false));
                         } else if (!((KnuthElement) contentList.getLast()).isGlue()) {
                             // add a null penalty to allow a break between blocks
-                            contentList.add(new KnuthPenalty(0, 0, false,
-                                    new Position(this), false));
+                            contentList.add(new BreakElement(
+                                    new Position(this), 0, context));
+                            //contentList.add(new KnuthPenalty(0, 0, false,
+                            //        new Position(this), false));
                         } else {
                             // the last element in contentList is a glue;
                             // it is a feasible breakpoint, there is no need to add
@@ -277,9 +302,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager {
                         //Avoid NoSuchElementException below (happens with empty blocks)
                         continue;
                     }
-                    if (((KnuthElement) returnedList.getLast()).isPenalty()
-                            && ((KnuthPenalty) returnedList.getLast()).getP() 
-                                    == -KnuthElement.INFINITE) {
+                    if (((ListElement)returnedList.getLast()).isForcedBreak()) {
                         // a descendant of this block has break-after
                         if (curLM.isFinished()) {
                             // there is no other content in this block;
@@ -328,9 +351,9 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager {
                 }
             }
         }
-        addKnuthElementsForBorderPaddingAfter(returnList);
+        addKnuthElementsForBorderPaddingAfter(returnList, true);
         addKnuthElementsForSpaceAfter(returnList, alignment);
-        addKnuthElementsForBreakAfter(returnList);
+        addKnuthElementsForBreakAfter(returnList, context);
 
         setFinished(true);
         return returnList;
@@ -422,7 +445,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager {
         contentRectOffsetX += getBlockContainerFO()
                 .getCommonMarginBlock().startIndent.getValue(this);
         double contentRectOffsetY = offset.getY();
-        contentRectOffsetY += getSpaceBefore();
+        contentRectOffsetY += getSpaceBefore(); //TODO Uhm, is that necessary?
         contentRectOffsetY += getBlockContainerFO()
                 .getCommonBorderPaddingBackground().getBorderBeforeWidth(false);
         contentRectOffsetY += getBlockContainerFO()
@@ -544,9 +567,9 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager {
                 }
                 if (returnedList != null) {
                     bclm.wrapPositionElements(returnedList, returnList);
-                    //returnList.addAll(returnedList);
                 }
             }
+            SpaceResolver.resolveElementList(returnList);
             setFinished(true);
             return returnList;
         }
@@ -605,9 +628,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager {
         return new Point(x, y);
     }
     
-    /**
-     * @see org.apache.fop.layoutmgr.LayoutManager#addAreas(org.apache.fop.layoutmgr.PositionIterator, org.apache.fop.layoutmgr.LayoutContext)
-     */
+    /** @see org.apache.fop.layoutmgr.LayoutManager */
     public void addAreas(PositionIterator parentIter,
             LayoutContext layoutContext) {
         getParentArea(null);
@@ -766,11 +787,6 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager {
                 //}
             }
     
-            // if adjusted space before
-            if (bSpaceBefore) {
-                addBlockSpacing(0, new MinOptMax(adjustedSpaceBefore));
-            }
-    
             while ((childLM = childPosIter.getNextChildLM()) != null) {
                 // set last area flag
                 lc.setFlags(LayoutContext.LAST_AREA,
@@ -780,30 +796,21 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager {
                 childLM.addAreas(childPosIter, lc);
             }
         } else {
-            // if adjusted space before
-            if (bSpaceBefore) {
-                addBlockSpacing(0, new MinOptMax(adjustedSpaceBefore));
-            }
             //Add child areas inside the reference area
             bcpos.getBreaker().addContainedAreas();
         }
 
-        //int bIndents = getBlockContainerFO().getCommonBorderPaddingBackground()
-        //    .getBPPaddingAndBorder(false);
-
         if (markers != null) {
             getCurrentPV().addMarkers(markers, false, isFirst(firstPos), isLast(lastPos));
         }
 
+        TraitSetter.addSpaceBeforeAfter(viewportBlockArea, layoutContext.getSpaceAdjust(), 
+                effSpaceBefore, effSpaceAfter);
         flush();
 
-        // if adjusted space after
-        if (bSpaceAfter) {
-            addBlockSpacing(0, new MinOptMax(adjustedSpaceAfter));
-        }
-
         viewportBlockArea = null;
         referenceArea = null;
+        resetSpaces();
     }
     
     /**
@@ -826,7 +833,11 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager {
 
             TraitSetter.setProducerID(viewportBlockArea, getBlockContainerFO().getId());
             TraitSetter.addBorders(viewportBlockArea, 
-                    getBlockContainerFO().getCommonBorderPaddingBackground(), this);
+                    getBlockContainerFO().getCommonBorderPaddingBackground(), 
+                    discardBorderBefore, discardBorderAfter, false, false, this);
+            TraitSetter.addPadding(viewportBlockArea, 
+                    getBlockContainerFO().getCommonBorderPaddingBackground(), 
+                    discardPaddingBefore, discardPaddingAfter, false, false, this);
             // TraitSetter.addBackground(viewportBlockArea, 
             //        getBlockContainerFO().getCommonBorderPaddingBackground(),
             //        this);
@@ -918,17 +929,13 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager {
         }
     }
 
-    /**
-     * @see org.apache.fop.layoutmgr.BlockLevelLayoutManager#negotiateBPDAdjustment(int, org.apache.fop.layoutmgr.KnuthElement)
-     */
+    /** @see org.apache.fop.layoutmgr.BlockLevelLayoutManager */
     public int negotiateBPDAdjustment(int adj, KnuthElement lastElement) {
         // TODO Auto-generated method stub
         return 0;
     }
 
-    /**
-     * @see org.apache.fop.layoutmgr.BlockLevelLayoutManager#discardSpace(org.apache.fop.layoutmgr.KnuthGlue)
-     */
+    /** @see org.apache.fop.layoutmgr.BlockLevelLayoutManager */
     public void discardSpace(KnuthGlue spaceGlue) {
         // TODO Auto-generated method stub
         
@@ -982,6 +989,51 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager {
     public boolean getGeneratesBlockArea() {
         return true;
     }
-   
+
+    /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+    public void notifySpace(RelSide side, MinOptMax effectiveLength) {
+        if (RelSide.BEFORE == side) {
+            if (log.isDebugEnabled()) {
+                log.debug(this + ": Space " + side + ", " 
+                        + this.effSpaceBefore + "-> " + effectiveLength);
+            }
+            this.effSpaceBefore = effectiveLength;
+        } else {
+            if (log.isDebugEnabled()) {
+                log.debug(this + ": Space " + side + ", " 
+                        + this.effSpaceAfter + "-> " + effectiveLength);
+            }
+            this.effSpaceAfter = effectiveLength;
+        }
+    }
+
+    /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+    public void notifyBorder(RelSide side, MinOptMax effectiveLength) {
+        if (effectiveLength == null) {
+            if (RelSide.BEFORE == side) {
+                this.discardBorderBefore = true;
+            } else {
+                this.discardBorderAfter = true;
+            }
+        }
+        if (log.isDebugEnabled()) {
+            log.debug(this + ": Border " + side + " -> " + effectiveLength);
+        }
+    }
+
+    /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+    public void notifyPadding(RelSide side, MinOptMax effectiveLength) {
+        if (effectiveLength == null) {
+            if (RelSide.BEFORE == side) {
+                this.discardPaddingBefore = true;
+            } else {
+                this.discardPaddingAfter = true;
+            }
+        }
+        if (log.isDebugEnabled()) {
+            log.debug(this + ": Padding " + side + " -> " + effectiveLength);
+        }
+    }
+
 }
 

src/java/org/apache/fop/layoutmgr/BlockLayoutManager.java

@@ -35,7 +35,8 @@ import org.apache.fop.traits.SpaceVal;
 /**
  * LayoutManager for a block FO.
  */
-public class BlockLayoutManager extends BlockStackingLayoutManager {
+public class BlockLayoutManager extends BlockStackingLayoutManager 
+            implements ConditionalElementListener {
     
     private Block curBlockArea;
 
@@ -46,6 +47,13 @@ public class BlockLayoutManager extends BlockStackingLayoutManager {
     private Length lineHeight;
     private int follow = 2000;
     private int middleShift = 0;
+    
+    private boolean discardBorderBefore;
+    private boolean discardBorderAfter;
+    private boolean discardPaddingBefore;
+    private boolean discardPaddingAfter;
+    private MinOptMax effSpaceBefore;
+    private MinOptMax effSpaceAfter;
 
     /** The list of child BreakPoss instances. */
     protected List childBreaks = new java.util.ArrayList();
@@ -87,6 +95,21 @@ public class BlockLayoutManager extends BlockStackingLayoutManager {
         }
     }
 
+    /** @see org.apache.fop.layoutmgr.BlockStackingLayoutManager */
+    public LinkedList getNextKnuthElements(LayoutContext context, int alignment) {
+        resetSpaces(); 
+        return super.getNextKnuthElements(context, alignment);
+    }
+   
+    private void resetSpaces() {
+        this.discardBorderBefore = false;        
+        this.discardBorderAfter = false;        
+        this.discardPaddingBefore = false;        
+        this.discardPaddingAfter = false;
+        this.effSpaceBefore = foSpaceBefore;
+        this.effSpaceAfter = foSpaceAfter;
+    }
+    
     /**
      * Proxy iterator for Block LM.
      * This iterator creates and holds the complete list
@@ -277,12 +300,6 @@ public class BlockLayoutManager extends BlockStackingLayoutManager {
         }
 
         getPSLM().addIDToPage(getBlockFO().getId());
-        /* TODO remove when markers are really ok
-        log.debug("Checking on " + this);
-        log.debug("Checking first=" + firstPos);
-        log.debug("Checking last=" + lastPos);
-        log.debug("->" + isFirst(firstPos) + "/" + isLast(lastPos));
-        */
         if (markers != null) {
             getCurrentPV().addMarkers(markers, true, isFirst(firstPos), isLast(lastPos));
         }
@@ -361,14 +378,6 @@ public class BlockLayoutManager extends BlockStackingLayoutManager {
             //}
         }
 
-        // if adjusted space before
-        double adjust = layoutContext.getSpaceAdjust();
-        addBlockSpacing(adjust, foSpaceBefore);
-        foSpaceBefore = null;
-        //if (bSpaceBefore) {
-        //    addBlockSpacing(0, new MinOptMax(adjustedSpaceBefore));
-        //}
-
         while ((childLM = childPosIter.getNextChildLM()) != null) {
             // set last area flag
             lc.setFlags(LayoutContext.LAST_AREA,
@@ -378,22 +387,16 @@ public class BlockLayoutManager extends BlockStackingLayoutManager {
             childLM.addAreas(childPosIter, lc);
         }
 
-        //int bIndents = getBlockFO().getCommonBorderPaddingBackground()
-        //                        .getBPPaddingAndBorder(false);
-
         if (markers != null) {
             getCurrentPV().addMarkers(markers, false, isFirst(firstPos), isLast(lastPos));
         }
 
+        TraitSetter.addSpaceBeforeAfter(curBlockArea, layoutContext.getSpaceAdjust(), 
+                effSpaceBefore, effSpaceAfter);
         flush();
 
-        // if adjusted space after
-        addBlockSpacing(adjust, foSpaceAfter);
-        //if (bSpaceAfter) {
-        //    addBlockSpacing(0, new MinOptMax(adjustedSpaceAfter));
-        //}
-
         curBlockArea = null;
+        resetSpaces();
     }
 
     /**
@@ -426,30 +429,16 @@ public class BlockLayoutManager extends BlockStackingLayoutManager {
             // set traits
             TraitSetter.setProducerID(curBlockArea, getBlockFO().getId());
             TraitSetter.addBorders(curBlockArea, 
-                    getBlockFO().getCommonBorderPaddingBackground(), this);
+                    getBlockFO().getCommonBorderPaddingBackground(), 
+                    discardBorderBefore, discardBorderAfter, false, false, this);
+            TraitSetter.addPadding(curBlockArea, 
+                    getBlockFO().getCommonBorderPaddingBackground(), 
+                    discardPaddingBefore, discardPaddingAfter, false, false, this);
             TraitSetter.addMargins(curBlockArea,
                     getBlockFO().getCommonBorderPaddingBackground(), 
                     getBlockFO().getCommonMarginBlock(),
                     this);
 
-            // Set up dimensions
-            // Get reference IPD from parentArea
-            //int referenceIPD = parentArea.getIPD();
-            //curBlockArea.setIPD(referenceIPD);
-
-            // Set the width of the block based on the parent block
-            // Need to be careful though, if parent is BC then width may not be set
-            /* TODO remove if really not used anymore
-            int parentwidth = 0;
-            if (parentArea instanceof BlockParent) {
-                parentwidth = ((BlockParent) parentArea).getIPD();
-            }
-            if (parentwidth == 0) {
-                parentwidth = referenceIPD;
-            }
-            parentwidth -= getIPIndents();
-            */
-
             setCurrentArea(curBlockArea); // ??? for generic operations
         }
         return curBlockArea;
@@ -533,6 +522,51 @@ public class BlockLayoutManager extends BlockStackingLayoutManager {
     public boolean getGeneratesBlockArea() {
         return true;
     }
-   
+
+    /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+    public void notifySpace(RelSide side, MinOptMax effectiveLength) {
+        if (RelSide.BEFORE == side) {
+            if (log.isDebugEnabled()) {
+                log.debug(this + ": Space " + side + ", " 
+                        + this.effSpaceBefore + "-> " + effectiveLength);
+            }
+            this.effSpaceBefore = effectiveLength;
+        } else {
+            if (log.isDebugEnabled()) {
+                log.debug(this + ": Space " + side + ", " 
+                        + this.effSpaceAfter + "-> " + effectiveLength);
+            }
+            this.effSpaceAfter = effectiveLength;
+        }
+    }
+
+    /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+    public void notifyBorder(RelSide side, MinOptMax effectiveLength) {
+        if (effectiveLength == null) {
+            if (RelSide.BEFORE == side) {
+                this.discardBorderBefore = true;
+            } else {
+                this.discardBorderAfter = true;
+            }
+        }
+        if (log.isDebugEnabled()) {
+            log.debug(this + ": Border " + side + " -> " + effectiveLength);
+        }
+    }
+
+    /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+    public void notifyPadding(RelSide side, MinOptMax effectiveLength) {
+        if (effectiveLength == null) {
+            if (RelSide.BEFORE == side) {
+                this.discardPaddingBefore = true;
+            } else {
+                this.discardPaddingAfter = true;
+            }
+        }
+        if (log.isDebugEnabled()) {
+            log.debug(this + ": Padding " + side + " -> " + effectiveLength);
+        }
+    }
+
 }
 

src/java/org/apache/fop/layoutmgr/BlockStackingLayoutManager.java

@@ -53,12 +53,10 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
     protected int adjustedSpaceAfter = 0;
     /** Only used to store the original list when createUnitElements is called */
     protected LinkedList storedList = null;
-    /** FO node */
-    protected FObj fobj;
     /** Indicates whether break before has been served or not */
     protected boolean bBreakBeforeServed = false;
-    /** Indicates whether space before has been served or not */
-    protected boolean bSpaceBeforeServed = false;
+    /** Indicates whether the first visible mark has been returned by this LM, yet */
+    protected boolean firstVisibleMarkServed = false;
     /** Reference IPD available */
     protected int referenceIPD = 0;
     /**
@@ -84,7 +82,6 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
     public BlockStackingLayoutManager(FObj node) {
         super(node);
         setGeneratesBlockArea(true);
-        fobj = node;
     }
 
     /** 
@@ -103,16 +100,6 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
         this.parentArea = parentArea;
     }
 
-    protected MinOptMax resolveSpaceSpecifier(Area nextArea) {
-        SpaceSpecifier spaceSpec = new SpaceSpecifier(false);
-        // Area prevArea = getCurrentArea().getLast();
-        // if (prevArea != null) {
-        //     spaceSpec.addSpace(prevArea.getSpaceAfter());
-        // }
-        // spaceSpec.addSpace(nextArea.getSpaceBefore());
-        return spaceSpec.resolve(false);
-    }
-
     /**
      * Add a block spacer for space before and space after a block.
      * This adds an empty Block area that acts as a block space.
@@ -121,15 +108,7 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
      * @param minoptmax the min/opt/max value of the spacing
      */
     public void addBlockSpacing(double adjust, MinOptMax minoptmax) {
-        if (minoptmax == null) {
-            return;
-        }
-        int sp = minoptmax.opt;
-        if (adjust > 0) {
-            sp = sp + (int)(adjust * (minoptmax.max - minoptmax.opt));
-        } else {
-            sp = sp + (int)(adjust * (minoptmax.opt - minoptmax.min));
-        }
+        int sp = TraitSetter.getEffectiveSpace(adjust, minoptmax);
         if (sp != 0) {
             Block spacer = new Block();
             spacer.setBPD(sp);
@@ -153,7 +132,6 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
             //log.error("Child not a Block in BlockStackingLM!");
         }
 
-        MinOptMax spaceBefore = resolveSpaceSpecifier(childArea);
         parentArea.addBlock((Block) childArea);
         flush(); // hand off current area to parent
     }
@@ -232,7 +210,7 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
 
         if (!bBreakBeforeServed) {
             try {
-                if (addKnuthElementsForBreakBefore(returnList)) {
+                if (addKnuthElementsForBreakBefore(returnList, context)) {
                     return returnList;
                 }
             } finally {
@@ -240,15 +218,17 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
             }
         }
 
-        if (!bSpaceBeforeServed) {
-            addKnuthElementsForSpaceBefore(returnList, alignment);
-            bSpaceBeforeServed = true;
-        }
+        addKnuthElementsForSpaceBefore(returnList, alignment);
         
-        addKnuthElementsForBorderPaddingBefore(returnList);
+        addKnuthElementsForBorderPaddingBefore(returnList, !firstVisibleMarkServed);
+        firstVisibleMarkServed = true;
+
+        //Spaces, border and padding to be repeated at each break
+        addPendingMarks(context);
         
         while ((curLM = (BlockLevelLayoutManager) getChildLM()) != null) {
             LayoutContext childLC = new LayoutContext(0);
+            childLC.copyPendingMarksFrom(context);
             if (curLM instanceof LineLayoutManager) {
                 // curLM is a LineLayoutManager
                 // set stackLimit for lines
@@ -273,9 +253,9 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
             }
             if (returnedList != null
                     && returnedList.size() == 1
-                    && ((KnuthElement) returnedList.getFirst()).isPenalty()
-                    && ((KnuthPenalty) returnedList.getFirst()).getP() == -KnuthElement.INFINITE) {
+                    && ((ListElement) returnedList.getFirst()).isForcedBreak()) {
                 // a descendant of this block has break-before
+                /*
                 if (returnList.size() == 0) {
                     // the first child (or its first child ...) has
                     // break-before;
@@ -283,7 +263,7 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
                     // the
                     // following page
                     bSpaceBeforeServed = false;
-                }
+                }*/
                 contentList.addAll(returnedList);
 
                 /* extension: conversione di tutta la sequenza fin'ora ottenuta */
@@ -311,17 +291,27 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
                         childLC.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING, false);
                         // add an infinite penalty to forbid a break between
                         // blocks
+                        contentList.add(new BreakElement(
+                                new Position(this), KnuthElement.INFINITE, context));
+                        /*
                         contentList.add(new KnuthPenalty(0,
                                 KnuthElement.INFINITE, false,
                                 new Position(this), false));
-                    } else if (!((KnuthElement) contentList.getLast()).isGlue()) {
+                        */
+                    } else if (!((ListElement) contentList.getLast()).isGlue()) {
                         // add a null penalty to allow a break between blocks
+                        contentList.add(new BreakElement(
+                                new Position(this), 0, context));
+                        /*
                         contentList.add(new KnuthPenalty(0, 0, false,
-                                new Position(this), false));
+                                new Position(this), false));*/
                     } else {
                         // the last element in contentList is a glue;
                         // it is a feasible breakpoint, there is no need to add
                         // a penalty
+                        log.warn("glue-type break possibility not handled properly, yet");
+                        //TODO Does this happen? If yes, need to deal with border and padding
+                        //at the break possibility
                     }
                 }
                 if (returnedList == null || returnedList.size() == 0) {
@@ -329,9 +319,7 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
                     continue;
                 }
                 contentList.addAll(returnedList);
-                if (((KnuthElement) returnedList.getLast()).isPenalty()
-                        && ((KnuthPenalty) returnedList.getLast()).getP() 
-                                == -KnuthElement.INFINITE) {
+                if (((ListElement) returnedList.getLast()).isForcedBreak()) {
                     // a descendant of this block has break-after
                     if (curLM.isFinished()) {
                         // there is no other content in this block;
@@ -380,9 +368,9 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
             returnList.add(new KnuthBox(0, notifyPos(new Position(this)), true));
         }
 
-        addKnuthElementsForBorderPaddingAfter(returnList);
+        addKnuthElementsForBorderPaddingAfter(returnList, true);
         addKnuthElementsForSpaceAfter(returnList, alignment);
-        addKnuthElementsForBreakAfter(returnList);
+        addKnuthElementsForBreakAfter(returnList, context);
 
         if (mustKeepWithNext()) {
             context.setFlags(LayoutContext.KEEP_WITH_NEXT_PENDING);
@@ -741,27 +729,159 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
     }
 
     /**
-     * Creates Knuth elements for before border padding and adds them to the return list.
-     * @param returnList return list to add the additional elements to
+     * Adds the unresolved elements for border and padding to a layout context so break
+     * possibilities can be properly constructed.
+     * @param context the layout context
      */
-    protected void addKnuthElementsForBorderPaddingBefore(LinkedList returnList/*, 
-            Position returnPosition*/) {
-        //Border and Padding (before)
-        CommonBorderPaddingBackground borderAndPadding = null;
+    protected void addPendingMarks(LayoutContext context) {
+        SpaceProperty spaceBefore = getSpaceBeforeProperty();
+        if (spaceBefore != null
+                   && !(spaceBefore.getMinimum(this).getLength().getValue(this) == 0 
+                        && spaceBefore.getMaximum(this).getLength().getValue(this) == 0)) {
+            context.addPendingBeforeMark(new SpaceElement(getAuxiliaryPosition(), spaceBefore,
+                    RelSide.BEFORE, 
+                    true, false, this));
+        }
+        SpaceProperty spaceAfter = getSpaceAfterProperty();
+        if (spaceAfter != null
+                && !(spaceAfter.getMinimum(this).getLength().getValue(this) == 0 
+                     && spaceAfter.getMaximum(this).getLength().getValue(this) == 0)) {
+            context.addPendingAfterMark(new SpaceElement(getAuxiliaryPosition(), spaceAfter,
+                    RelSide.AFTER, 
+                    false, true, this));
+        }
+        CommonBorderPaddingBackground borderAndPadding = getBorderPaddingBackground();
+        if (borderAndPadding != null) {
+            if (borderAndPadding.getBorderBeforeWidth(false) > 0) {
+                context.addPendingBeforeMark(new BorderElement(
+                        getAuxiliaryPosition(), 
+                        borderAndPadding.getBorderInfo(
+                                CommonBorderPaddingBackground.BEFORE).getWidth(),
+                                RelSide.BEFORE,
+                                false, false, this));
+            }
+            if (borderAndPadding.getPaddingBefore(false, this) > 0) {
+                context.addPendingBeforeMark(new PaddingElement(
+                        getAuxiliaryPosition(),
+                        borderAndPadding.getPaddingLengthProperty(
+                                CommonBorderPaddingBackground.BEFORE),
+                                RelSide.BEFORE, 
+                                false, false, this));
+            }
+            if (borderAndPadding.getBorderAfterWidth(false) > 0) {
+                context.addPendingAfterMark(new BorderElement(
+                        getAuxiliaryPosition(), 
+                        borderAndPadding.getBorderInfo(
+                                CommonBorderPaddingBackground.AFTER).getWidth(),
+                                RelSide.AFTER, 
+                                false, false, this));
+            }
+            if (borderAndPadding.getPaddingAfter(false, this) > 0) {
+                context.addPendingAfterMark(new PaddingElement(
+                        getAuxiliaryPosition(),
+                        borderAndPadding.getPaddingLengthProperty(
+                                CommonBorderPaddingBackground.AFTER),
+                                RelSide.AFTER, 
+                                false, false, this));
+            }
+        }
+    }
+    
+    /** @return the border, padding and background info structure */
+    private CommonBorderPaddingBackground getBorderPaddingBackground() {
         if (fobj instanceof org.apache.fop.fo.flow.Block) {
-            borderAndPadding = ((org.apache.fop.fo.flow.Block)fobj)
+            return ((org.apache.fop.fo.flow.Block)fobj)
                 .getCommonBorderPaddingBackground();
         } else if (fobj instanceof org.apache.fop.fo.flow.BlockContainer) {
-            borderAndPadding = ((org.apache.fop.fo.flow.BlockContainer)fobj)
+            return ((org.apache.fop.fo.flow.BlockContainer)fobj)
+                .getCommonBorderPaddingBackground();
+        } else if (fobj instanceof org.apache.fop.fo.flow.ListBlock) {
+            return ((org.apache.fop.fo.flow.ListBlock)fobj)
                 .getCommonBorderPaddingBackground();
+        } else if (fobj instanceof org.apache.fop.fo.flow.ListItem) {
+            return ((org.apache.fop.fo.flow.ListItem)fobj)
+                .getCommonBorderPaddingBackground();
+        } else if (fobj instanceof org.apache.fop.fo.flow.Table) {
+            return ((org.apache.fop.fo.flow.Table)fobj)
+                .getCommonBorderPaddingBackground();
+        } else {
+            return null;
+        }
+    }
+    
+    /** @return the space-before property */
+    private SpaceProperty getSpaceBeforeProperty() {
+        if (fobj instanceof org.apache.fop.fo.flow.Block) {
+            return ((org.apache.fop.fo.flow.Block)fobj)
+                .getCommonMarginBlock().spaceBefore;
+        } else if (fobj instanceof org.apache.fop.fo.flow.BlockContainer) {
+            return ((org.apache.fop.fo.flow.BlockContainer)fobj)
+                .getCommonMarginBlock().spaceBefore;
+        } else if (fobj instanceof org.apache.fop.fo.flow.ListBlock) {
+            return ((org.apache.fop.fo.flow.ListBlock)fobj)
+                .getCommonMarginBlock().spaceBefore;
+        } else if (fobj instanceof org.apache.fop.fo.flow.ListItem) {
+            return ((org.apache.fop.fo.flow.ListItem)fobj)
+                .getCommonMarginBlock().spaceBefore;
+        } else if (fobj instanceof org.apache.fop.fo.flow.Table) {
+            return ((org.apache.fop.fo.flow.Table)fobj)
+                .getCommonMarginBlock().spaceBefore;
+        } else {
+            return null;
+        }
+    }
+    
+    /** @return the space-after property */
+    private SpaceProperty getSpaceAfterProperty() {
+        if (fobj instanceof org.apache.fop.fo.flow.Block) {
+            return ((org.apache.fop.fo.flow.Block)fobj)
+                .getCommonMarginBlock().spaceAfter;
+        } else if (fobj instanceof org.apache.fop.fo.flow.BlockContainer) {
+            return ((org.apache.fop.fo.flow.BlockContainer)fobj)
+                .getCommonMarginBlock().spaceAfter;
+        } else if (fobj instanceof org.apache.fop.fo.flow.ListBlock) {
+            return ((org.apache.fop.fo.flow.ListBlock)fobj)
+                .getCommonMarginBlock().spaceAfter;
+        } else if (fobj instanceof org.apache.fop.fo.flow.ListItem) {
+            return ((org.apache.fop.fo.flow.ListItem)fobj)
+                .getCommonMarginBlock().spaceAfter;
+        } else if (fobj instanceof org.apache.fop.fo.flow.Table) {
+            return ((org.apache.fop.fo.flow.Table)fobj)
+                .getCommonMarginBlock().spaceAfter;
+        } else {
+            return null;
         }
+    }
+    
+    /**
+     * Creates Knuth elements for before border padding and adds them to the return list.
+     * @param returnList return list to add the additional elements to
+     */
+    protected void addKnuthElementsForBorderPaddingBefore(LinkedList returnList, boolean isFirst) {
+        //Border and Padding (before)
+        CommonBorderPaddingBackground borderAndPadding = getBorderPaddingBackground();
         if (borderAndPadding != null) {
+            if (borderAndPadding.getBorderBeforeWidth(false) > 0) {
+                returnList.add(new BorderElement(
+                        getAuxiliaryPosition(), 
+                        borderAndPadding.getBorderInfo(CommonBorderPaddingBackground.BEFORE)
+                                .getWidth(),
+                        RelSide.BEFORE, isFirst, false, this));
+            }
+            if (borderAndPadding.getPaddingBefore(false, this) > 0) {
+                returnList.add(new PaddingElement(
+                        getAuxiliaryPosition(),
+                        borderAndPadding.getPaddingLengthProperty(
+                                CommonBorderPaddingBackground.BEFORE), 
+                        RelSide.BEFORE, isFirst, false, this));
+            }
             //TODO Handle conditionality
+            /*
             int bpBefore = borderAndPadding.getBorderBeforeWidth(false)
                          + borderAndPadding.getPaddingBefore(false, this);
             if (bpBefore > 0) {
                 returnList.add(new KnuthBox(bpBefore, getAuxiliaryPosition(), true));
-            }
+            }*/
         }
     }
 
@@ -769,24 +889,31 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
      * Creates Knuth elements for after border padding and adds them to the return list.
      * @param returnList return list to add the additional elements to
      */
-    protected void addKnuthElementsForBorderPaddingAfter(LinkedList returnList/*, 
-            Position returnPosition*/) {
+    protected void addKnuthElementsForBorderPaddingAfter(LinkedList returnList, boolean isLast) {
         //Border and Padding (after)
-        CommonBorderPaddingBackground borderAndPadding = null;
-        if (fobj instanceof org.apache.fop.fo.flow.Block) {
-            borderAndPadding = ((org.apache.fop.fo.flow.Block)fobj)
-                .getCommonBorderPaddingBackground();
-        } else if (fobj instanceof org.apache.fop.fo.flow.BlockContainer) {
-            borderAndPadding = ((org.apache.fop.fo.flow.BlockContainer)fobj)
-                .getCommonBorderPaddingBackground();
-        }
+        CommonBorderPaddingBackground borderAndPadding = getBorderPaddingBackground();
         if (borderAndPadding != null) {
+            if (borderAndPadding.getPaddingAfter(false, this) > 0) {
+                returnList.add(new PaddingElement(
+                        getAuxiliaryPosition(),
+                        borderAndPadding.getPaddingLengthProperty(
+                                CommonBorderPaddingBackground.AFTER),
+                        RelSide.AFTER, false, isLast, this));
+            }
+            if (borderAndPadding.getBorderAfterWidth(false) > 0) {
+                returnList.add(new BorderElement(
+                        getAuxiliaryPosition(), 
+                        borderAndPadding.getBorderInfo(CommonBorderPaddingBackground.AFTER)
+                                .getWidth(),
+                        RelSide.AFTER, false, isLast, this));
+            }
             //TODO Handle conditionality
+            /*
             int bpAfter = borderAndPadding.getBorderAfterWidth(false)
                         + borderAndPadding.getPaddingAfter(false, this);
             if (bpAfter > 0) {
                 returnList.add(new KnuthBox(bpAfter, getAuxiliaryPosition(), true));
-            }
+            }*/
         }
     }
 
@@ -795,8 +922,8 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
      * @param returnList return list to add the additional elements to
      * @return true if an element has been added due to a break-before.
      */
-    protected boolean addKnuthElementsForBreakBefore(LinkedList returnList/*, 
-            Position returnPosition*/) {
+    protected boolean addKnuthElementsForBreakBefore(LinkedList returnList, 
+            LayoutContext context) {
         int breakBefore = -1;
         if (fobj instanceof org.apache.fop.fo.flow.Block) {
             breakBefore = ((org.apache.fop.fo.flow.Block) fobj).getBreakBefore();
@@ -810,8 +937,10 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
                 || breakBefore == EN_EVEN_PAGE 
                 || breakBefore == EN_ODD_PAGE) {
             // return a penalty element, representing a forced page break
-            returnList.add(new KnuthPenalty(0, -KnuthElement.INFINITE, false,
-                    breakBefore, getAuxiliaryPosition(), false));
+            returnList.add(new BreakElement(getAuxiliaryPosition(), 
+                    0, -KnuthElement.INFINITE, breakBefore, context));
+            //returnList.add(new KnuthPenalty(0, -KnuthElement.INFINITE, false,
+            //        breakBefore, getAuxiliaryPosition(), false));
             return true;
         } else {
             return false;
@@ -823,8 +952,8 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
      * @param returnList return list to add the additional elements to
      * @return true if an element has been added due to a break-after.
      */
-    protected boolean addKnuthElementsForBreakAfter(LinkedList returnList/*, 
-            Position returnPosition*/) {
+    protected boolean addKnuthElementsForBreakAfter(LinkedList returnList, 
+            LayoutContext context) {
         int breakAfter = -1;
         if (fobj instanceof org.apache.fop.fo.flow.Block) {
             breakAfter = ((org.apache.fop.fo.flow.Block) fobj).getBreakAfter();
@@ -838,8 +967,10 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
                 || breakAfter == EN_EVEN_PAGE
                 || breakAfter == EN_ODD_PAGE) {
             // add a penalty element, representing a forced page break
-            returnList.add(new KnuthPenalty(0, -KnuthElement.INFINITE, false,
-                    breakAfter, getAuxiliaryPosition(), false));
+            returnList.add(new BreakElement(getAuxiliaryPosition(), 
+                    0, -KnuthElement.INFINITE, breakAfter, context));
+            //returnList.add(new KnuthPenalty(0, -KnuthElement.INFINITE, false,
+            //        breakAfter, getAuxiliaryPosition(), false));
             return true;
         } else {
             return false;
@@ -853,21 +984,16 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
      */
     protected void addKnuthElementsForSpaceBefore(LinkedList returnList/*, 
             Position returnPosition*/, int alignment) {
-        SpaceProperty spaceBefore = null;
-        if (fobj instanceof org.apache.fop.fo.flow.Block) {
-            spaceBefore = ((org.apache.fop.fo.flow.Block)fobj)
-                .getCommonMarginBlock().spaceBefore;
-        } else if (fobj instanceof org.apache.fop.fo.flow.BlockContainer) {
-            spaceBefore = ((org.apache.fop.fo.flow.BlockContainer)fobj)
-                .getCommonMarginBlock().spaceBefore;
-        } else if (fobj instanceof org.apache.fop.fo.flow.ListBlock) {
-            spaceBefore = ((org.apache.fop.fo.flow.ListBlock)fobj)
-                .getCommonMarginBlock().spaceBefore;
-        } else if (fobj instanceof org.apache.fop.fo.flow.ListItem) {
-            spaceBefore = ((org.apache.fop.fo.flow.ListItem)fobj)
-                .getCommonMarginBlock().spaceBefore;
-        }
+        SpaceProperty spaceBefore = getSpaceBeforeProperty();
         // append elements representing space-before
+        if (spaceBefore != null
+                   && !(spaceBefore.getMinimum(this).getLength().getValue(this) == 0 
+                        && spaceBefore.getMaximum(this).getLength().getValue(this) == 0)) {
+            returnList.add(new SpaceElement(getAuxiliaryPosition(), spaceBefore,
+                    RelSide.BEFORE, 
+                    true, false, this));
+        }
+        /*
         if (bpUnit > 0
                 || spaceBefore != null
                    && !(spaceBefore.getMinimum(this).getLength().getValue(this) == 0 
@@ -882,7 +1008,7 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
                 returnList.add(new KnuthGlue(0, 0, 0,
                         BlockLevelLayoutManager.SPACE_BEFORE_ADJUSTMENT, 
                         getAuxiliaryPosition(), true));
-            } else /*if (alignment == EN_JUSTIFY)*/ {
+            } else { //if (alignment == EN_JUSTIFY) {
                 returnList.add(new KnuthGlue(
                         spaceBefore.getOptimum(this).getLength().getValue(this),
                         spaceBefore.getMaximum(this).getLength().getValue(this)
@@ -891,13 +1017,13 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
                                 - spaceBefore.getMinimum(this).getLength().getValue(this),
                         BlockLevelLayoutManager.SPACE_BEFORE_ADJUSTMENT, 
                         getAuxiliaryPosition(), true));
-            } /*else {
-                returnList.add(new KnuthGlue(
-                        spaceBefore.getOptimum().getLength().getValue(this), 
-                        0, 0, BlockLevelLayoutManager.SPACE_BEFORE_ADJUSTMENT,
-                        returnPosition, true));
-            }*/
-        }
+//            } else {
+//                returnList.add(new KnuthGlue(
+//                        spaceBefore.getOptimum().getLength().getValue(this), 
+//                        0, 0, BlockLevelLayoutManager.SPACE_BEFORE_ADJUSTMENT,
+//                        returnPosition, true));
+            }
+        }*/
     }
 
     /**
@@ -907,21 +1033,16 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
      */
     protected void addKnuthElementsForSpaceAfter(LinkedList returnList/*, Position returnPosition*/, 
                 int alignment) {
-        SpaceProperty spaceAfter = null;
-        if (fobj instanceof org.apache.fop.fo.flow.Block) {
-            spaceAfter = ((org.apache.fop.fo.flow.Block)fobj)
-                .getCommonMarginBlock().spaceAfter;
-        } else if (fobj instanceof org.apache.fop.fo.flow.BlockContainer) {
-            spaceAfter = ((org.apache.fop.fo.flow.BlockContainer)fobj)
-                .getCommonMarginBlock().spaceAfter;
-        } else if (fobj instanceof org.apache.fop.fo.flow.ListBlock) {
-            spaceAfter = ((org.apache.fop.fo.flow.ListBlock)fobj)
-                .getCommonMarginBlock().spaceAfter;
-        } else if (fobj instanceof org.apache.fop.fo.flow.ListItem) {
-            spaceAfter = ((org.apache.fop.fo.flow.ListItem)fobj)
-                .getCommonMarginBlock().spaceAfter;
-        }
+        SpaceProperty spaceAfter = getSpaceAfterProperty();
         // append elements representing space-after
+        if (spaceAfter != null
+                && !(spaceAfter.getMinimum(this).getLength().getValue(this) == 0 
+                     && spaceAfter.getMaximum(this).getLength().getValue(this) == 0)) {
+            returnList.add(new SpaceElement(getAuxiliaryPosition(), spaceAfter,
+                    RelSide.AFTER, 
+                    false, true, this));
+        }
+        /*
         if (bpUnit > 0
                 || spaceAfter != null
                    && !(spaceAfter.getMinimum(this).getLength().getValue(this) == 0 
@@ -934,7 +1055,7 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
                 returnList.add(new KnuthGlue(0, 0, 0, 
                         BlockLevelLayoutManager.SPACE_AFTER_ADJUSTMENT,
                         getAuxiliaryPosition(), true));
-            } else /*if (alignment == EN_JUSTIFY)*/ {
+            } else { //if (alignment == EN_JUSTIFY) {
                 returnList.add(new KnuthGlue(
                         spaceAfter.getOptimum(this).getLength().getValue(this),
                         spaceAfter.getMaximum(this).getLength().getValue(this)
@@ -943,16 +1064,16 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
                                 - spaceAfter.getMinimum(this).getLength().getValue(this),
                         BlockLevelLayoutManager.SPACE_AFTER_ADJUSTMENT, getAuxiliaryPosition(),
                         (!spaceAfter.getSpace().isDiscard()) ? false : true));
-            } /*else {
-                returnList.add(new KnuthGlue(
-                        spaceAfter.getOptimum().getLength().getValue(this), 0, 0,
-                        BlockLevelLayoutManager.SPACE_AFTER_ADJUSTMENT, returnPosition,
-                        (!spaceAfter.getSpace().isDiscard()) ? false : true));
-            }*/
+//            } else {
+//                returnList.add(new KnuthGlue(
+//                        spaceAfter.getOptimum().getLength().getValue(this), 0, 0,
+//                        BlockLevelLayoutManager.SPACE_AFTER_ADJUSTMENT, returnPosition,
+//                        (!spaceAfter.getSpace().isDiscard()) ? false : true));
+            }
             if (spaceAfter != null && !spaceAfter.getSpace().isDiscard()) {
                 returnList.add(new KnuthBox(0, getAuxiliaryPosition(), true));
             }
-        }
+        }*/
     }
 
     protected LinkedList createUnitElements(LinkedList oldList) {
@@ -1330,8 +1451,8 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager
           
         ListIterator listIter = sourceList.listIterator();
         while (listIter.hasNext()) {
-            KnuthElement tempElement;
-            tempElement = (KnuthElement) listIter.next();
+            ListElement tempElement;
+            tempElement = (ListElement) listIter.next();
             if (force || tempElement.getLayoutManager() != this) {
                 tempElement.setPosition(notifyPos(new NonLeafPosition(this,
                         tempElement.getPosition())));

src/java/org/apache/fop/layoutmgr/BorderElement.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* $Id$ */
+
+package org.apache.fop.layoutmgr;
+
+import org.apache.fop.datatypes.PercentBaseContext;
+import org.apache.fop.fo.properties.CondLengthProperty;
+import org.apache.fop.traits.MinOptMax;
+
+/**
+ * This represents an unresolved border element.
+ */
+public class BorderElement extends BorderOrPaddingElement {
+
+    /**
+     * Main constructor
+     * @param position the Position instance needed by the addAreas stage of the LMs.
+     * @param side the side to which this space element applies.
+     * @param condLength the length-conditional property for a border or padding specification
+     * @param isFirst true if this is a padding- or border-before of the first area generated.
+     * @param isLast true if this is a padding- or border-after of the last area generated.
+     * @param context the property evaluation context
+     */
+    public BorderElement(Position position, CondLengthProperty condLength,
+            RelSide side,
+            boolean isFirst, boolean isLast, PercentBaseContext context) {
+        super(position, condLength, side, isFirst, isLast, context);
+    }
+    
+    /** @see org.apache.fop.layoutmgr.UnresolvedListElementWithLength */
+    public void notifyLayoutManager(MinOptMax effectiveLength) {
+        LayoutManager lm = getOriginatingLayoutManager();
+        if (lm instanceof ConditionalElementListener) {
+            ((ConditionalElementListener)lm).notifyBorder(
+                    getSide(), effectiveLength);
+        } else {
+            log.warn("Cannot notify LM. It does not implement ConditionalElementListener: "
+                    + lm.getClass().getName());
+        }
+    }
+    
+    /** @see java.lang.Object#toString() */
+    public String toString() {
+        StringBuffer sb = new StringBuffer("Border[");
+        sb.append(super.toString());
+        sb.append("]");
+        return sb.toString();
+    }
+    
+}

src/java/org/apache/fop/layoutmgr/BorderOrPaddingElement.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* $Id$ */
+
+package org.apache.fop.layoutmgr;
+
+import org.apache.fop.datatypes.PercentBaseContext;
+import org.apache.fop.fo.properties.CondLengthProperty;
+import org.apache.fop.traits.MinOptMax;
+
+/**
+ * This class represents an unresolved border or padding element.
+ */
+public abstract class BorderOrPaddingElement extends UnresolvedListElementWithLength {
+
+    /**
+     * Main constructor
+     * @param position the Position instance needed by the addAreas stage of the LMs.
+     * @param side the side to which this space element applies.
+     * @param condLength the length-conditional property for a border or padding specification
+     * @param isFirst true if this is a padding- or border-before of the first area generated.
+     * @param isLast true if this is a padding- or border-after of the last area generated.
+     * @param context the property evaluation context
+     */
+    public BorderOrPaddingElement(Position position, CondLengthProperty condLength,
+            RelSide side,
+            boolean isFirst, boolean isLast, PercentBaseContext context) {
+        super(position,
+                new MinOptMax(condLength.getLength().getValue(context)), side, 
+                        condLength.isDiscard(), isFirst, isLast);
+    }
+    
+    /** @see org.apache.fop.layoutmgr.UnresolvedListElementWithLength */
+    public abstract void notifyLayoutManager(MinOptMax effectiveLength);
+        
+}

src/java/org/apache/fop/layoutmgr/BreakElement.java

@@ -0,0 +1,149 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* $Id$ */
+
+package org.apache.fop.layoutmgr;
+
+import java.util.List;
+
+import org.apache.fop.fo.Constants;
+
+/**
+ * This class represents an unresolved break possibility.
+ */
+public class BreakElement extends UnresolvedListElement {
+
+    private int penaltyWidth;
+    private int penaltyValue;
+    private int breakClass = -1;
+    private List pendingBeforeMarks;
+    private List pendingAfterMarks;
+    
+    /**
+     * Main constructor
+     * @param position the Position instance needed by the addAreas stage of the LMs.
+     * @param penaltyValue the penalty value for the penalty element to be constructed
+     * @param context the layout context which contains the pending conditional elements
+     */
+    public BreakElement(Position position, int penaltyValue, LayoutContext context) {
+        this(position, 0, penaltyValue, -1, context);
+    }
+    
+    /**
+     * Constructor for hard breaks.
+     * @param position the Position instance needed by the addAreas stage of the LMs.
+     * @param penaltyWidth the penalty width
+     * @param penaltyValue the penalty value for the penalty element to be constructed
+     * @param breakClass the break class of this penalty (one of the break-* constants)
+     * @param context the layout context which contains the pending conditional elements
+     */
+    public BreakElement(Position position, int penaltyWidth, int penaltyValue, 
+                int breakClass, LayoutContext context) {
+        super(position);
+        this.penaltyWidth = penaltyWidth;
+        this.penaltyValue = penaltyValue;
+        this.breakClass = breakClass;
+        this.pendingBeforeMarks = context.getPendingBeforeMarks();
+        this.pendingAfterMarks = context.getPendingAfterMarks();
+    }
+    
+    /** @see org.apache.fop.layoutmgr.UnresolvedListElement#isConditional() */
+    public boolean isConditional() {
+        return false; //Does not really apply here
+    }
+
+    /** @see org.apache.fop.layoutmgr.ListElement#isPenalty() */
+    /*
+    public boolean isPenalty() {
+        return true; //not entirely true but a BreakElement will generate a penalty later
+    }*/
+
+    /** @return the penalty width */
+    public int getPenaltyWidth() {
+        return this.penaltyWidth;
+    }
+    
+    /** @return the penalty value */
+    public int getPenaltyValue() {
+        return this.penaltyValue;
+    }
+    
+    /**
+     * Sets the penalty value.
+     * @param p the new penalty value
+     */
+    public void setPenaltyValue(int p) {
+        this.penaltyValue = p;
+    }
+    
+    /** @see org.apache.fop.layoutmgr.ListElement#isForcedBreak() */
+    public boolean isForcedBreak() {
+        return penaltyValue == -KnuthElement.INFINITE;
+    }
+    
+    /** @return the break class of this penalty (one of the break-* constants) */
+    public int getBreakClass() {
+        return breakClass;
+    }
+    
+    /**
+     * Sets the break class.
+     * @param breakClass the new break class
+     */
+    public void setBreakClass(int breakClass) {
+        this.breakClass = breakClass;
+    }
+    
+    /** @return the pending border and padding elements at the before edge */
+    public List getPendingBeforeMarks() {
+        return this.pendingBeforeMarks;
+    }
+    
+    /** @return the pending border and padding elements at the after edge */
+    public List getPendingAfterMarks() {
+        return this.pendingAfterMarks;
+    }
+    
+    /** @see java.lang.Object#toString() */
+    public String toString() {
+        StringBuffer sb = new StringBuffer();
+        sb.append("BreakPossibility[p:");
+        sb.append(this.penaltyValue);
+        if (isForcedBreak()) {
+            sb.append(" (forced break");
+            switch (getBreakClass()) {
+            case Constants.EN_PAGE:
+                sb.append(", page");
+                break;
+            case Constants.EN_COLUMN:
+                sb.append(", column");
+                break;
+            case Constants.EN_EVEN_PAGE:
+                sb.append(", even page");
+                break;
+            case Constants.EN_ODD_PAGE:
+                sb.append(", odd page");
+                break;
+            default:
+            }
+            sb.append(")");
+        }
+        sb.append("]");
+        return sb.toString();
+    }
+
+}

src/java/org/apache/fop/layoutmgr/ConditionalElementListener.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* $Id$ */
+
+package org.apache.fop.layoutmgr;
+
+import org.apache.fop.traits.MinOptMax;
+
+/**
+ * This interface is used to notify layout managers about the situation around spaces, borders
+ * and padding just before the addArea() method is called when a part is being painted.
+ */
+public interface ConditionalElementListener {
+
+    /**
+     * Notifies the layout manager about the effective length of its space.
+     * @param side the side to which the space applies
+     * @param effectiveLength the effective length after space-resolution (null means zero length)
+     */
+    void notifySpace(RelSide side, MinOptMax effectiveLength);
+
+    /**
+     * Notifies the layout manager about the effective length/width of its border.
+     * @param side the side to which the border applies
+     * @param effectiveLength the effective length in the current break situation
+     *                        (null means zero length)
+     */
+    void notifyBorder(RelSide side, MinOptMax effectiveLength);
+
+    /**
+     * Notifies the layout manager about the effective length/width of its padding.
+     * @param side the side to which the padding applies
+     * @param effectiveLength the effective length in the current break situation
+     *                        (null means zero length)
+     */
+    void notifyPadding(RelSide side, MinOptMax effectiveLength);
+    
+}

src/java/org/apache/fop/layoutmgr/ElementListUtils.java

@@ -36,13 +36,16 @@ public class ElementListUtils {
     public static void removeLegalBreaks(LinkedList elements) {
         ListIterator i = elements.listIterator();
         while (i.hasNext()) {
-            KnuthElement el = (KnuthElement)i.next();
+            ListElement el = (ListElement)i.next();
             if (el.isPenalty()) {
-                KnuthPenalty penalty = (KnuthPenalty)el;
+                BreakElement breakPoss = (BreakElement)el;
                 //Convert all penalties no break inhibitors
-                if (penalty.getP() < KnuthPenalty.INFINITE) {
+                if (breakPoss.getPenaltyValue() < KnuthPenalty.INFINITE) {
+                    breakPoss.setPenaltyValue(KnuthPenalty.INFINITE);
+                    /*
                     i.set(new KnuthPenalty(penalty.getW(), KnuthPenalty.INFINITE, 
                             penalty.isFlagged(), penalty.getPosition(), penalty.isAuxiliary()));
+                    */
                 }
             } else if (el.isGlue()) {
                 i.previous();
@@ -106,11 +109,11 @@ public class ElementListUtils {
         int count = end - start + 1;
         int len = 0;
         while (iter.hasNext()) {
-            KnuthElement el = (KnuthElement)iter.next();
+            ListElement el = (ListElement)iter.next();
             if (el.isBox()) {
-                len += el.getW();
+                len += ((KnuthElement)el).getW();
             } else if (el.isGlue()) {
-                len += el.getW();
+                len += ((KnuthElement)el).getW();
             } else {
                 //log.debug("Ignoring penalty: " + el);
                 //ignore penalties
@@ -133,4 +136,14 @@ public class ElementListUtils {
         return calcContentLength(elems, 0, elems.size() - 1);
     }
     
+    /**
+     * Indicates whether the given element list ends with a forced break.
+     * @param elems the element list
+     * @return true if the list ends with a forced break
+     */
+    public static boolean endsWithForcedBreak(LinkedList elems) {
+        ListElement last = (ListElement)elems.getLast();
+        return last.isForcedBreak();
+    }
+    
 }

src/java/org/apache/fop/layoutmgr/FlowLayoutManager.java

@@ -36,7 +36,6 @@ import java.util.ListIterator;
  */
 public class FlowLayoutManager extends BlockStackingLayoutManager
                                implements BlockLevelLayoutManager {
-    private Flow fobj;
     
     /** Array of areas currently being filled stored by area class */
     private BlockParent[] currentAreas = new BlockParent[Area.CLASS_MAX];
@@ -51,7 +50,6 @@ public class FlowLayoutManager extends BlockStackingLayoutManager
      */
     public FlowLayoutManager(PageSequenceLayoutManager pslm, Flow node) {
         super(node);
-        fobj = node;
         setParent(pslm);
     }
 
@@ -84,6 +82,7 @@ public class FlowLayoutManager extends BlockStackingLayoutManager
                 log.debug("span change from " + currentSpan + " to " + span);
                 context.signalSpanChange(span);
                 currentSpan = span;
+                SpaceResolver.resolveElementList(returnList);
                 return returnList;
             }
             
@@ -109,10 +108,10 @@ public class FlowLayoutManager extends BlockStackingLayoutManager
             wrapPositionElements(tempList, returnedList);
 
             if (returnedList.size() == 1
-                && ((KnuthElement)returnedList.getFirst()).isPenalty()
-                && ((KnuthPenalty)returnedList.getFirst()).getP() == -KnuthElement.INFINITE) {
+                && ElementListUtils.endsWithForcedBreak(returnedList)) {
                 // a descendant of this flow has break-before
                 returnList.addAll(returnedList);
+                SpaceResolver.resolveElementList(returnList);
                 return returnList;
             } else {
                 if (returnList.size() > 0) {
@@ -123,20 +122,19 @@ public class FlowLayoutManager extends BlockStackingLayoutManager
                         context.setFlags(LayoutContext.KEEP_WITH_NEXT_PENDING, false);
                         childLC.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING, false);
                         // add an infinite penalty to forbid a break between blocks
-                        returnList.add(new KnuthPenalty(0, KnuthElement.INFINITE, false, 
-                                new Position(this), false));
-                    } else if (!((KnuthElement) returnList.getLast()).isGlue()) {
+                        returnList.add(new BreakElement(
+                                new Position(this), KnuthElement.INFINITE, context));
+                    } else if (!((ListElement) returnList.getLast()).isGlue()) {
                         // add a null penalty to allow a break between blocks
-                        returnList.add(new KnuthPenalty(0, 0, false, 
-                                new Position(this), false));
+                        returnList.add(new BreakElement(
+                                new Position(this), 0, context));
                     }
                 }
-                if (returnedList.size() > 0) { // controllare!
+                if (returnedList.size() > 0) {
                     returnList.addAll(returnedList);
-                    if (((KnuthElement)returnedList.getLast()).isPenalty()
-                        && ((KnuthPenalty)returnedList.getLast()).getP() 
-                                == -KnuthElement.INFINITE) {
+                    if (ElementListUtils.endsWithForcedBreak(returnList)) {
                         // a descendant of this flow has break-after
+                        SpaceResolver.resolveElementList(returnList);
                         return returnList;
                     }
                 }
@@ -148,6 +146,7 @@ public class FlowLayoutManager extends BlockStackingLayoutManager
             }
         }
 
+        SpaceResolver.resolveElementList(returnList);
         setFinished(true);
 
         if (returnList.size() > 0) {

src/java/org/apache/fop/layoutmgr/FootnoteBodyLayoutManager.java

@@ -23,12 +23,20 @@ import org.apache.fop.fo.flow.FootnoteBody;
 
 import java.util.LinkedList;
 
+/**
+ * Layout manager for footnote bodies.
+ */
 public class FootnoteBodyLayoutManager extends BlockStackingLayoutManager {
 
+    /**
+     * Creates a new FootnoteBodyLayoutManager.
+     * @param body the footnote-body element
+     */
     public FootnoteBodyLayoutManager(FootnoteBody body) {
         super(body);
     }
 
+    /** @see org.apache.fop.layoutmgr.LayoutManager */
     public void addAreas(PositionIterator parentIter, LayoutContext layoutContext) {
         LayoutManager childLM = null;
         LayoutManager lastLM = null;
@@ -38,8 +46,6 @@ public class FootnoteBodyLayoutManager extends BlockStackingLayoutManager {
         // and put them in a new list;
         LinkedList positionList = new LinkedList();
         Position pos;
-        boolean bSpaceBefore = false;
-        boolean bSpaceAfter = false;
         while (parentIter.hasNext()) {
             pos = (Position) parentIter.next();
             //log.trace("pos = " + pos.getClass().getName() + "; " + pos);
@@ -73,14 +79,13 @@ public class FootnoteBodyLayoutManager extends BlockStackingLayoutManager {
         }
     }
 
+    /** @see org.apache.fop.layoutmgr.LayoutManager#addChildArea(org.apache.fop.area.Area) */
     public void addChildArea(Area childArea) {
         childArea.setAreaClass(Area.CLASS_FOOTNOTE);
         parentLM.addChildArea(childArea);
     }
 
-    /**
-     * convenience method that returns the FootnoteBody node
-     */
+    /** @return the FootnoteBody node */
     protected FootnoteBody getFootnodeBodyFO() {
         return (FootnoteBody) fobj;
     }

src/java/org/apache/fop/layoutmgr/KnuthElement.java

@@ -26,12 +26,12 @@ package org.apache.fop.layoutmgr;
  * special feature (for example, the additional elements used to represent
  * a space when text alignment is right, left or center).
  */
-public abstract class KnuthElement {
+public abstract class KnuthElement extends ListElement {
 
+    /** The value used as an infinite indicator. */
     public static final int INFINITE = 1000;
 
     private int width;
-    private Position position;
     private boolean bIsAuxiliary;
 
     /**
@@ -43,84 +43,39 @@ public abstract class KnuthElement {
      * @param bAux is this an auxiliary element?
      */
     protected KnuthElement(int w, Position pos, boolean bAux) {
+        super(pos);
         width = w;
-        position = pos;
         bIsAuxiliary = bAux;
     }
 
-    /**
-     * Return true if this element is a KnuthBox.
-     */
-    public boolean isBox() {
-        return false;
-    }
-
-    /**
-     * Return true if this element is a KnuthGlue.
-     */
-    public boolean isGlue() {
-        return false;
-    }
-
-    /**
-     * Return true if this element is a KnuthPenalty.
-     */
-    public boolean isPenalty() {
-        return false;
-    }
-
-    /**
-     * Return true if this element is an auxiliary one.
-     */
+    /** @return true if this element is an auxiliary one. */
     public boolean isAuxiliary() {
         return bIsAuxiliary;
     }
 
-    /**
-     * Return the width of this element.
-     */
+    /** @return the width of this element. */
     public int getW() {
         return width;
     }
 
+    /** @return the penalty value of this element, if applicable. */ 
     public int getP() {
         throw new RuntimeException("Element is not a penalty");
     }
 
+    /** @return the stretch value of this element, if applicable. */ 
     public int getY() {
         throw new RuntimeException("Element is not a glue");
     }
 
+    /** @return the shrink value of this element, if applicable. */ 
     public int getZ() {
         throw new RuntimeException("Element is not a glue");
     }
-
-    public boolean isForcedBreak() {
+    
+    /** @see org.apache.fop.layoutmgr.ListElement#isUnresolvedElement() */
+    public boolean isUnresolvedElement() {
         return false;
     }
 
-    /**
-     * Return the Position stored in this element.
-     */
-    public Position getPosition() {
-        return position;
-    }
-
-    /**
-     * Change the Position stored in this element.
-     */
-    public void setPosition(Position pos) {
-        position = pos;
-    }
-
-    /**
-     * Return the LayoutManager responsible for this element.
-     */
-    public LayoutManager getLayoutManager() {
-        if (position != null) {
-            return position.getLM();
-        } else {
-            return null;
-        }
-    }
 }

src/java/org/apache/fop/layoutmgr/KnuthPossPosIter.java

@@ -65,15 +65,15 @@ public class KnuthPossPosIter extends PositionIterator {
         return super.next();
     }
 
-    public KnuthElement getKE() {
-        return (KnuthElement) peekNext();
+    public ListElement getKE() {
+        return (ListElement) peekNext();
     }
 
     protected LayoutManager getLM(Object nextObj) {
-        return ((KnuthElement) nextObj).getLayoutManager();
+        return ((ListElement) nextObj).getLayoutManager();
     }
 
     protected Position getPos(Object nextObj) {
-        return ((KnuthElement) nextObj).getPosition();
+        return ((ListElement) nextObj).getPosition();
     }
 }

src/java/org/apache/fop/layoutmgr/KnuthSequence.java

@@ -53,9 +53,19 @@ public class KnuthSequence extends ArrayList {
     }
 
     /**
+     * Finalizes a Knuth sequence.
      * @return a finalized sequence.
      */
     public KnuthSequence endSequence() {
+        return endSequence(null);
+    }
+    
+    /**
+     * Finalizes a Knuth sequence.
+     * @param breakPosition a Position instance for the last penalty (may be null)
+     * @return a finalized sequence.
+     */
+    public KnuthSequence endSequence(Position breakPosition) {
         // remove glue and penalty item at the end of the paragraph
         while (this.size() > ignoreAtStart
                && !((KnuthElement)this.get(this.size() - 1)).isBox()) {
@@ -66,7 +76,7 @@ public class KnuthSequence extends ArrayList {
             // and the forced break
             this.add(new KnuthPenalty(0, KnuthElement.INFINITE, false, null, false));
             this.add(new KnuthGlue(0, 10000000, 0, null, false));
-            this.add(new KnuthPenalty(0, -KnuthElement.INFINITE, false, null, false));
+            this.add(new KnuthPenalty(0, -KnuthElement.INFINITE, false, breakPosition, false));
             ignoreAtEnd = 3;
             return this;
         } else {

src/java/org/apache/fop/layoutmgr/LayoutContext.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 1999-2004 The Apache Software Foundation.
+ * Copyright 1999-2005 The Apache Software Foundation.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,6 +18,9 @@
 
 package org.apache.fop.layoutmgr;
 
+import java.util.Collections;
+import java.util.List;
+
 import org.apache.fop.fo.Constants;
 import org.apache.fop.layoutmgr.inline.HyphContext;
 import org.apache.fop.traits.MinOptMax;
@@ -25,7 +28,7 @@ import org.apache.fop.layoutmgr.inline.AlignmentContext;
 
 
 /**
- * This class is used to pass information to the getNextBreakPoss()
+ * This class is used to pass information to the getNextKnuthElements()
  * method. It is set up by higher level LM and used by lower level LM.
  */
 public class LayoutContext {
@@ -91,6 +94,18 @@ public class LayoutContext {
 
     /** Current pending space-before or space-start from ancestor areas */
     SpaceSpecifier leadingSpace;
+    
+    /**
+     * A list of pending marks (border and padding) on the after edge when a page break occurs. 
+     * May be null.
+     */
+    private List pendingAfterMarks;
+    
+    /**
+     * A list of pending marks (border and padding) on the before edge when a page break occurs. 
+     * May be null.
+     */
+    private List pendingBeforeMarks;
 
     /** Current hyphenation context. May be null. */
     private HyphContext hyphContext = null;
@@ -117,6 +132,10 @@ public class LayoutContext {
     /** Amount of space to reserve at the end of each line */
     private int lineEndBorderAndPaddingWidth = 0;
 
+    /**
+     * Copy constructor for creating child layout contexts.
+     * @param parentLC the parent layout context to copy from
+     */
     public LayoutContext(LayoutContext parentLC) {
         this.flags = parentLC.flags;
         this.refIPD = parentLC.refIPD;
@@ -131,9 +150,14 @@ public class LayoutContext {
         this.alignmentContext = parentLC.alignmentContext;
         this.lineStartBorderAndPaddingWidth = parentLC.lineStartBorderAndPaddingWidth;
         this.lineEndBorderAndPaddingWidth = parentLC.lineEndBorderAndPaddingWidth;
-        // Copy other fields as necessary. Use clone???
+        copyPendingMarksFrom(parentLC);
+        // Copy other fields as necessary.
     }
 
+    /**
+     * Main constructor.
+     * @param flags the initial flags
+     */
     public LayoutContext(int flags) {
         this.flags = flags;
         this.refIPD = 0;
@@ -142,6 +166,15 @@ public class LayoutContext {
         trailingSpace = null;
     }
 
+    public void copyPendingMarksFrom(LayoutContext source) {
+        if (source.pendingAfterMarks != null) {
+            this.pendingAfterMarks = new java.util.ArrayList(source.pendingAfterMarks); 
+        }
+        if (source.pendingBeforeMarks != null) {
+            this.pendingBeforeMarks = new java.util.ArrayList(source.pendingBeforeMarks); 
+        }
+    }
+    
     public void setFlags(int flags) {
         setFlags(flags, true);
     }
@@ -206,6 +239,56 @@ public class LayoutContext {
         return trailingSpace;
     }
 
+    /**
+     * Adds a border or padding element to the pending list which will be used to generate
+     * the right element list for break possibilities. Conditionality resolution will be done
+     * elsewhere.
+     * @param element the border, padding or space element
+     */
+    public void addPendingAfterMark(UnresolvedListElementWithLength element) {
+        if (this.pendingAfterMarks == null) {
+            this.pendingAfterMarks = new java.util.ArrayList();
+        }
+        this.pendingAfterMarks.add(element);
+    }
+    
+    /**
+     * @return the pending border and padding elements at the after edge
+     * @see addPendingAfterMark(BorderOrPaddingElement)
+     */
+    public List getPendingAfterMarks() {
+        if (this.pendingAfterMarks != null) {
+            return Collections.unmodifiableList(this.pendingAfterMarks);
+        } else {
+            return null;
+        }
+    }
+    
+    /**
+     * Adds a border or padding element to the pending list which will be used to generate
+     * the right element list for break possibilities. Conditionality resolution will be done
+     * elsewhere.
+     * @param element the border, padding or space element
+     */
+    public void addPendingBeforeMark(UnresolvedListElementWithLength element) {
+        if (this.pendingBeforeMarks == null) {
+            this.pendingBeforeMarks = new java.util.ArrayList();
+        }
+        this.pendingBeforeMarks.add(element);
+    }
+    
+    /**
+     * @return the pending border and padding elements at the before edge
+     * @see addPendingBeforeMark(BorderOrPaddingElement)
+     */
+    public List getPendingBeforeMarks() {
+        if (this.pendingBeforeMarks != null) {
+            return Collections.unmodifiableList(this.pendingBeforeMarks);
+        } else {
+            return null;
+        }
+    }
+    
     public void setStackLimit(MinOptMax limit) {
         stackLimit = limit;
     }

src/java/org/apache/fop/layoutmgr/ListElement.java

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* $Id$ */
+
+package org.apache.fop.layoutmgr;
+
+/**
+ * This class is the base class for all kinds of elements that are added to element lists. There
+ * are basically two kinds of list elements: Knuth elements and unresolved elements like spaces,
+ * border and padding elements which are converted to Knuth elements prior to the breaking
+ * process. 
+ */
+public abstract class ListElement {
+
+    private Position position;
+    
+    /**
+     * Main constructor
+     * @param position the Position instance needed by the addAreas stage of the LMs.
+     */
+    public ListElement(Position position) {
+        this.position = position;
+    }
+    
+    /**
+     * @return the Position instance for this element.
+     */
+    public Position getPosition() {
+        return this.position;
+    }
+    
+    /**
+     * Change the Position stored in this element.
+     * @param position the Position instance
+     */
+    public void setPosition(Position position) {
+        this.position = position;
+    }
+
+    /**
+     * @return the LayoutManager responsible for this element.
+     */
+    public LayoutManager getLayoutManager() {
+        if (position != null) {
+            return position.getLM();
+        } else {
+            return null;
+        }
+    }
+
+    /** @return true if this element is a KnuthBox. */
+    public boolean isBox() {
+        return false;
+    }
+
+    /** @return true if this element is a KnuthGlue. */
+    public boolean isGlue() {
+        return false;
+    }
+
+    /** @return true if this element is a KnuthPenalty. */
+    public boolean isPenalty() {
+        return false;
+    }
+
+    /** @return true if the element is a penalty and represents a forced break. */ 
+    public boolean isForcedBreak() {
+        return false;
+    }
+
+    /** @return true if the element is an unresolved element such as a space or a border. */ 
+    public boolean isUnresolvedElement() {
+        return true;
+    }
+    
+}

src/java/org/apache/fop/layoutmgr/PaddingElement.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* $Id$ */
+
+package org.apache.fop.layoutmgr;
+
+import org.apache.fop.datatypes.PercentBaseContext;
+import org.apache.fop.fo.properties.CondLengthProperty;
+import org.apache.fop.traits.MinOptMax;
+
+/**
+ * This represents an unresolved padding element.
+ */
+public class PaddingElement extends BorderOrPaddingElement {
+
+    /**
+     * Main constructor
+     * @param position the Position instance needed by the addAreas stage of the LMs.
+     * @param side the side to which this space element applies.
+     * @param condLength the length-conditional property for a border or padding specification
+     * @param isFirst true if this is a padding- or border-before of the first area generated.
+     * @param isLast true if this is a padding- or border-after of the last area generated.
+     * @param context the property evaluation context
+     */
+    public PaddingElement(Position position, CondLengthProperty condLength,
+            RelSide side,
+            boolean isFirst, boolean isLast, PercentBaseContext context) {
+        super(position, condLength, side, isFirst, isLast, context);
+    }
+    
+    /** @see org.apache.fop.layoutmgr.UnresolvedListElementWithLength */
+    public void notifyLayoutManager(MinOptMax effectiveLength) {
+        LayoutManager lm = getOriginatingLayoutManager(); 
+        if (lm instanceof ConditionalElementListener) {
+            ((ConditionalElementListener)lm).notifyPadding(
+                    getSide(), effectiveLength);
+        } else {
+            log.warn("Cannot notify LM. It does not implement ConditionalElementListene: "
+                    + lm.getClass().getName());
+        }
+    }
+
+    /** @see java.lang.Object#toString() */
+    public String toString() {
+        StringBuffer sb = new StringBuffer("Padding[");
+        sb.append(super.toString());
+        sb.append("]");
+        return sb.toString();
+    }
+    
+}

src/java/org/apache/fop/layoutmgr/PageBreakingAlgorithm.java

@@ -201,6 +201,11 @@ class PageBreakingAlgorithm extends BreakingAlgorithm {
         ListIterator elementListsIterator = elementLists.listIterator();
         while (elementListsIterator.hasNext()) {
             LinkedList noteList = (LinkedList) elementListsIterator.next();
+            
+            //Space resolution (Note: this does not respect possible stacking constraints 
+            //between footnotes!)
+            SpaceResolver.resolveElementList(noteList);
+            
             int noteLength = 0;
             footnotesList.add(noteList);
             ListIterator noteListIterator = noteList.listIterator();

src/java/org/apache/fop/layoutmgr/PageSequenceLayoutManager.java

@@ -227,7 +227,7 @@ public class PageSequenceLayoutManager extends AbstractLayoutManager {
             if (contentList != null) {
                 ListIterator contentListIterator = contentList.listIterator();
                 while (contentListIterator.hasNext()) {
-                    KnuthElement element = (KnuthElement) contentListIterator.next();
+                    ListElement element = (ListElement) contentListIterator.next();
                     if (element instanceof KnuthBlockBox
                         && ((KnuthBlockBox) element).hasAnchors()) {
                         // element represents a line with footnote citations
@@ -402,10 +402,11 @@ public class PageSequenceLayoutManager extends AbstractLayoutManager {
                     int lastIndex = (i == pbp.footnoteLastListIndex 
                             ? pbp.footnoteLastElementIndex : elementList.size() - 1);
 
-                    FootnoteBodyLayoutManager fblm = (FootnoteBodyLayoutManager)
-                            ((KnuthElement) elementList.getFirst()).getLayoutManager();
+                    SpaceResolver.performConditionalsNotification(elementList, 
+                            firstIndex, lastIndex, -1);
                     LayoutContext childLC = new LayoutContext(0);
-                    fblm.addAreas(new KnuthPossPosIter(elementList, firstIndex, lastIndex + 1), 
+                    AreaAdditionUtil.addAreas(null, 
+                            new KnuthPossPosIter(elementList, firstIndex, lastIndex + 1), 
                             childLC);
                 }
                 // set the offset from the top margin
@@ -424,6 +425,12 @@ public class PageSequenceLayoutManager extends AbstractLayoutManager {
             return childFLM;
         }
         
+        /** @see org.apache.fop.layoutmgr.AbstractBreaker#observeElementList(java.util.List) */
+        protected void observeElementList(List elementList) {
+            ElementListObserver.observe(elementList, "breaker", 
+                    ((PageSequence)pslm.getFObj()).getId());
+        }
+        
     }
     
     /**

src/java/org/apache/fop/layoutmgr/PositionIterator.java

@@ -60,7 +60,7 @@ public abstract class PositionIterator implements Iterator {
         LayoutManager lm = getLM(nextObj);
         if (childLM == null) {
             childLM = lm;
-        } else if (childLM != lm) {
+        } else if (childLM != lm && lm != null) {
             // End of this sub-sequence with same child LM
             bHasNext = false;
             childLM = null;

src/java/org/apache/fop/layoutmgr/RelSide.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* $Id$ */
+
+package org.apache.fop.layoutmgr;
+
+/** Enum class for relative sides. */
+public final class RelSide {
+
+    /** the before side */
+    public static final RelSide BEFORE = new RelSide("before");
+    /** the after side */
+    public static final RelSide AFTER = new RelSide("after");
+    /** the start side */
+    public static final RelSide START = new RelSide("start");
+    /** the end side */
+    public static final RelSide END = new RelSide("end");
+    
+    private String name;
+
+    /**
+     * Constructor to add a new named item.
+     * @param name Name of the item.
+     */
+    private RelSide(String name) {
+        this.name = name;
+    }
+
+    /** @return the name of the enum */
+    public String getName() {
+        return this.name;
+    }
+    
+    /** @see java.lang.Object#toString() */
+    public String toString() {
+        return "RelSide:" + name;
+    }
+    
+}

src/java/org/apache/fop/layoutmgr/SpaceElement.java

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* $Id$ */
+
+package org.apache.fop.layoutmgr;
+
+import org.apache.fop.datatypes.PercentBaseContext;
+import org.apache.fop.fo.Constants;
+import org.apache.fop.fo.properties.SpaceProperty;
+import org.apache.fop.traits.MinOptMax;
+
+/**
+ * This class represents an unresolved space element.
+ */
+public class SpaceElement extends UnresolvedListElementWithLength {
+
+    private int precedence;
+    
+    /**
+     * Main constructor
+     * @param position the Position instance needed by the addAreas stage of the LMs.
+     * @param space the space property
+     * @param side the side to which this space element applies.
+     * @param isFirst true if this is a space-before of the first area generated.
+     * @param isLast true if this is a space-after of the last area generated.
+     * @param context the property evaluation context
+     */
+    public SpaceElement(Position position, SpaceProperty space, RelSide side, 
+            boolean isFirst, boolean isLast,
+            PercentBaseContext context) {
+        super(position, 
+                MinOptMaxUtil.toMinOptMax(
+                        space.getSpace().getLengthRange(), 
+                context), side, space.isDiscard(), isFirst, isLast);
+        int en = space.getSpace().getPrecedence().getEnum();
+        if (en == Constants.EN_FORCE) {
+            this.precedence = Integer.MAX_VALUE;
+        } else {
+            this.precedence = space.getSpace().getPrecedence().getNumber().intValue(); 
+        }
+    }
+    
+    /** @return true if the space is forcing. */
+    public boolean isForcing() {
+        return this.precedence == Integer.MAX_VALUE;
+    }
+
+    /** @return the precedence of the space */
+    public int getPrecedence() {
+        return this.precedence;
+    }
+    
+    /** @see org.apache.fop.layoutmgr.UnresolvedListElementWithLength */
+    public void notifyLayoutManager(MinOptMax effectiveLength) {
+        LayoutManager lm = getOriginatingLayoutManager();
+        if (lm instanceof ConditionalElementListener) {
+            ((ConditionalElementListener)lm).notifySpace(
+                    getSide(), effectiveLength);
+        } else {
+            log.warn("Cannot notify LM. It does not implement ConditionalElementListener:" 
+                    + lm.getClass().getName());
+        }
+    }
+    
+    /** @see java.lang.Object#toString() */
+    public String toString() {
+        StringBuffer sb = new StringBuffer("Space[");
+        sb.append(super.toString());
+        sb.append(", precedence=");
+        if (isForcing()) {
+            sb.append("forcing");
+        } else {
+            sb.append(getPrecedence());
+        }
+        sb.append("]");
+        return sb.toString();
+    }
+
+}

src/java/org/apache/fop/layoutmgr/SpaceResolver.java

@@ -0,0 +1,737 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* $Id$ */
+
+package org.apache.fop.layoutmgr;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.ListIterator;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.fop.traits.MinOptMax;
+
+/**
+ * This class resolves spaces and conditional borders and paddings by replacing the
+ * UnresolvedListElements descendants by the right combination of KnuthElements on an element
+ * list.
+ */
+public class SpaceResolver {
+
+    /** Logger instance */
+    protected static Log log = LogFactory.getLog(SpaceResolver.class);
+    
+    private UnresolvedListElementWithLength[] firstPart;
+    private BreakElement breakPoss;
+    private UnresolvedListElementWithLength[] secondPart;
+    private UnresolvedListElementWithLength[] noBreak;
+    
+    private MinOptMax[] firstPartLengths;
+    private MinOptMax[] secondPartLengths;
+    private MinOptMax[] noBreakLengths;
+    
+    private boolean isFirst;
+    private boolean isLast;
+    
+    /**
+     * Main constructor.
+     * @param first Element list before a break (optional)
+     * @param breakPoss Break possibility (optional)
+     * @param second Element list after a break (or if no break possibility in vicinity)
+     * @param isFirst Resolution at the beginning of a (full) element list
+     * @param isLast Resolution at the end of a (full) element list
+     */
+    public SpaceResolver(List first, BreakElement breakPoss, List second, 
+            boolean isFirst, boolean isLast) {
+        this.isFirst = isFirst;
+        this.isLast = isLast;
+        //Create combined no-break list
+        int c = 0;
+        if (first != null) {
+            c += first.size();
+        }
+        if (second != null) {
+            c += second.size();
+        }
+        noBreak = new UnresolvedListElementWithLength[c];
+        noBreakLengths = new MinOptMax[c];
+        int i = 0;
+        ListIterator iter;
+        if (first != null) {
+            iter = first.listIterator();
+            while (iter.hasNext()) {
+                noBreak[i] = (UnresolvedListElementWithLength)iter.next();
+                noBreakLengths[i] = noBreak[i].getLength();
+                i++;
+            }
+        }
+        if (second != null) {
+            iter = second.listIterator();
+            while (iter.hasNext()) {
+                noBreak[i] = (UnresolvedListElementWithLength)iter.next();
+                noBreakLengths[i] = noBreak[i].getLength();
+                i++;
+            }
+        }
+
+        //Add pending elements from higher level FOs
+        if (breakPoss != null) {
+            if (breakPoss.getPendingAfterMarks() != null) {
+                if (log.isTraceEnabled()) {
+                    log.trace("    adding pending before break: " 
+                            + breakPoss.getPendingAfterMarks());
+                }
+                first.addAll(0, breakPoss.getPendingAfterMarks());
+            }
+            if (breakPoss.getPendingBeforeMarks() != null) {
+                if (log.isTraceEnabled()) {
+                    log.trace("    adding pending after break: " 
+                            + breakPoss.getPendingBeforeMarks());
+                }
+                second.addAll(0, breakPoss.getPendingBeforeMarks());
+            }
+        }
+        if (log.isTraceEnabled()) {
+            log.trace("before: " + first);
+            log.trace("  break: " + breakPoss);
+            log.trace("after: " + second);
+            log.trace("NO-BREAK: " + toString(noBreak, noBreakLengths));
+        }
+
+        if (first != null) {
+            firstPart = new UnresolvedListElementWithLength[first.size()];
+            firstPartLengths = new MinOptMax[firstPart.length];
+            first.toArray(firstPart);
+            for (i = 0; i < firstPart.length; i++) {
+                firstPartLengths[i] = firstPart[i].getLength();
+            }
+        }
+        this.breakPoss = breakPoss;
+        if (second != null) {
+            secondPart = new UnresolvedListElementWithLength[second.size()];
+            secondPartLengths = new MinOptMax[secondPart.length];
+            second.toArray(secondPart);
+            for (i = 0; i < secondPart.length; i++) {
+                secondPartLengths[i] = secondPart[i].getLength();
+            }
+        }
+        resolve();
+    }
+    
+    private String toString(Object[] arr1, Object[] arr2) {
+        if (arr1.length != arr2.length) {
+            new IllegalArgumentException("The length of both arrays must be equal");
+        }
+        StringBuffer sb = new StringBuffer("[");
+        for (int i = 0; i < arr1.length; i++) {
+            if (i > 0) {
+                sb.append(", ");
+            }
+            sb.append(String.valueOf(arr1[i]));
+            sb.append("/");
+            sb.append(String.valueOf(arr2[i]));
+        }
+        sb.append("]");
+        return sb.toString();
+    }
+    
+    private void removeConditionalBorderAndPadding(
+                UnresolvedListElement[] elems, MinOptMax[] lengths, boolean reverse) {
+        for (int i = 0; i < elems.length; i++) {
+            int effIndex;
+            if (reverse) {
+                effIndex = elems.length - 1 - i;
+            } else {
+                effIndex = i;
+            }
+            if (elems[effIndex] instanceof BorderOrPaddingElement) {
+                BorderOrPaddingElement bop = (BorderOrPaddingElement)elems[effIndex];
+                if (bop.isConditional() && !(bop.isFirst() || bop.isLast())) {
+                    if (log.isDebugEnabled()) {
+                        log.debug("Nulling conditional element: " + bop);
+                    }
+                    lengths[effIndex] = null;
+                }
+            }
+        }
+        if (log.isTraceEnabled() && elems.length > 0) {
+            log.trace("-->Resulting list: " + toString(elems, lengths));
+        }
+    }
+    
+    private void performSpaceResolutionRule1(UnresolvedListElement[] elems, MinOptMax[] lengths,
+                    boolean reverse) {
+        for (int i = 0; i < elems.length; i++) {
+            int effIndex;
+            if (reverse) {
+                effIndex = elems.length - 1 - i;
+            } else {
+                effIndex = i;
+            }
+            if (lengths[effIndex] == null) {
+                //Zeroed border or padding doesn't create a fence
+                continue;
+            } else if (elems[effIndex] instanceof BorderOrPaddingElement) {
+                //Border or padding form fences!
+                break;
+            } else if (!elems[effIndex].isConditional()) {
+                break;
+            }
+            if (log.isDebugEnabled()) {
+                log.debug("Nulling conditional element using 4.3.1, rule 1: " + elems[effIndex]);
+            }
+            lengths[effIndex] = null;
+        }
+        if (log.isTraceEnabled() && elems.length > 0) {
+            log.trace("-->Resulting list: " + toString(elems, lengths));
+        }
+    }
+
+    private void performSpaceResolutionRules2to3(UnresolvedListElement[] elems, 
+            MinOptMax[] lengths, int start, int end) {
+        if (log.isTraceEnabled()) {
+            log.trace("rule 2-3: " + start + "-" + end);
+        }
+        SpaceElement space;
+        int remaining;
+        
+        //Rule 2 (4.3.1, XSL 1.0)
+        boolean hasForcing = false;
+        remaining = 0;
+        for (int i = start; i <= end; i++) {
+            if (lengths[i] == null) {
+                continue;
+            }
+            remaining++;
+            space = (SpaceElement)elems[i];
+            if (space.isForcing()) {
+                hasForcing = true;
+                break;
+            }
+        }
+        if (remaining == 0) {
+            return; //shortcut
+        }
+        if (hasForcing) {
+            for (int i = start; i <= end; i++) {
+                if (lengths[i] == null) {
+                    continue;
+                }
+                space = (SpaceElement)elems[i];
+                if (!space.isForcing()) {
+                    if (log.isDebugEnabled()) {
+                        log.debug("Nulling non-forcing space-specifier using 4.3.1, rule 2: " 
+                                + elems[i]);
+                    }
+                    lengths[i] = null;
+                }
+            }
+            return; //If rule is triggered skip rule 3
+        }
+        
+        //Rule 3 (4.3.1, XSL 1.0)
+        //Determine highes precedence
+        int highestPrecedence = Integer.MIN_VALUE;
+        for (int i = start; i <= end; i++) {
+            if (lengths[i] == null) {
+                continue;
+            }
+            space = (SpaceElement)elems[i];
+            highestPrecedence = Math.max(highestPrecedence, space.getPrecedence());
+        }
+        if (highestPrecedence != 0 && log.isDebugEnabled()) {
+            log.debug("Highest precedence is " + highestPrecedence);
+        }
+        //Suppress space-specifiers with lower precedence
+        remaining = 0;
+        int greatestOptimum = Integer.MIN_VALUE;
+        for (int i = start; i <= end; i++) {
+            if (lengths[i] == null) {
+                continue;
+            }
+            space = (SpaceElement)elems[i];
+            if (space.getPrecedence() != highestPrecedence) {
+                if (log.isDebugEnabled()) {
+                    log.debug("Nulling space-specifier with precedence " 
+                            + space.getPrecedence() + " using 4.3.1, rule 3: " 
+                            + elems[i]);
+                }
+                lengths[i] = null;
+            } else {
+                greatestOptimum = Math.max(greatestOptimum, space.getLength().opt);
+                remaining++;
+            }
+        }
+        if (log.isDebugEnabled()) {
+            log.debug("Greatest optimum: " + greatestOptimum);
+        }
+        if (remaining <= 1) {
+            return;
+        }
+        //Suppress space-specifiers with smaller optimum length
+        remaining = 0;
+        for (int i = start; i <= end; i++) {
+            if (lengths[i] == null) {
+                continue;
+            }
+            space = (SpaceElement)elems[i];
+            if (space.getLength().opt < greatestOptimum) {
+                if (log.isDebugEnabled()) {
+                    log.debug("Nulling space-specifier with smaller optimum length "
+                            + "using 4.3.1, rule 3: " 
+                            + elems[i]);
+                }
+                lengths[i] = null;
+            } else {
+                remaining++;
+            }
+        }
+        if (remaining <= 1) {
+            return;
+        }
+        //Construct resolved space-specifier from the remaining spaces
+        int min = Integer.MIN_VALUE;
+        int max = Integer.MAX_VALUE;
+        for (int i = start; i <= end; i++) {
+            if (lengths[i] == null) {
+                continue;
+            }
+            space = (SpaceElement)elems[i];
+            min = Math.max(min, space.getLength().min);
+            max = Math.min(max, space.getLength().max);
+            if (remaining > 1) {
+                if (log.isDebugEnabled()) {
+                    log.debug("Nulling non-last space-specifier using 4.3.1, rule 3, second part: " 
+                            + elems[i]);
+                }
+                lengths[i] = null;
+                remaining--;
+            } else {
+                lengths[i].min = min;
+                lengths[i].max = max;
+            }
+        }
+
+        if (log.isTraceEnabled() && elems.length > 0) {
+            log.trace("Remaining spaces: " + remaining);
+            log.trace("-->Resulting list: " + toString(elems, lengths));
+        }
+    }
+    
+    private void performSpaceResolutionRules2to3(UnresolvedListElement[] elems,
+            MinOptMax[] lengths) {
+        int start = 0;
+        int i = start;
+        while (i < elems.length) {
+            if (elems[i] instanceof SpaceElement) {
+                while (i < elems.length) {
+                    if (elems[i] == null || elems[i] instanceof SpaceElement) {
+                        i++;
+                    } else {
+                        break;
+                    }
+                }
+                performSpaceResolutionRules2to3(elems, lengths, start, i - 1);
+            }
+            i++;
+            start = i;
+        }
+    }
+    
+    private boolean hasFirstPart() {
+        return firstPart != null && firstPart.length > 0;
+    }
+    
+    private boolean hasSecondPart() {
+        return secondPart != null && secondPart.length > 0;
+    }
+    
+    private void resolve() {
+        if (breakPoss != null) {
+            if (hasFirstPart()) {
+                removeConditionalBorderAndPadding(firstPart, firstPartLengths, true);
+                performSpaceResolutionRule1(firstPart, firstPartLengths, true);
+                performSpaceResolutionRules2to3(firstPart, firstPartLengths);
+            }
+            if (hasSecondPart()) {
+                removeConditionalBorderAndPadding(secondPart, secondPartLengths, false);
+                performSpaceResolutionRule1(secondPart, secondPartLengths, false);
+                performSpaceResolutionRules2to3(secondPart, secondPartLengths);
+            }
+            if (noBreak != null) {
+                performSpaceResolutionRules2to3(noBreak, noBreakLengths);
+            }
+        } else {
+            if (isFirst) {
+                removeConditionalBorderAndPadding(secondPart, secondPartLengths, false);
+                performSpaceResolutionRule1(secondPart, secondPartLengths, false);
+            }
+            if (isLast) {
+                removeConditionalBorderAndPadding(firstPart, firstPartLengths, true);
+                performSpaceResolutionRule1(firstPart, firstPartLengths, true);
+            }
+            
+            if (hasFirstPart()) {
+                //Now that we've handled isFirst/isLast conditions, we need to look at the
+                //active part in its normal order so swap it back.
+                log.trace("Swapping first and second parts.");
+                UnresolvedListElementWithLength[] tempList;
+                MinOptMax[] tempLengths;
+                tempList = secondPart;
+                tempLengths = secondPartLengths;
+                secondPart = firstPart;
+                secondPartLengths = firstPartLengths;
+                firstPart = tempList;
+                firstPartLengths = tempLengths;
+                if (hasFirstPart()) {
+                    throw new IllegalStateException("Didn't expect more than one parts in a"
+                            + "no-break condition.");
+                }
+            }
+            performSpaceResolutionRules2to3(secondPart, secondPartLengths);
+        }
+    }
+    
+    private MinOptMax sum(MinOptMax[] lengths) {
+        MinOptMax sum = new MinOptMax();
+        for (int i = 0; i < lengths.length; i++) {
+            if (lengths[i] != null) {
+                sum.add(lengths[i]);
+            }
+        }
+        return sum;
+    }
+    
+    private void generate(ListIterator iter) {
+        MinOptMax noBreakLength = new MinOptMax();
+        MinOptMax glue1; //space before break possibility if break occurs
+        //MinOptMax glue2; //difference between glue 1 and 3 when no break occurs
+        MinOptMax glue3; //space after break possibility if break occurs
+        glue1 = sum(firstPartLengths);
+        glue3 = sum(secondPartLengths);
+        noBreakLength = sum(noBreakLengths);
+        
+        //This doesn't produce the right glue2
+        //glue2 = new MinOptMax(noBreakLength);
+        //glue2.subtract(glue1);
+        //glue2.subtract(glue3);
+        
+        int glue2w = noBreakLength.opt - glue1.opt - glue3.opt;
+        int glue2stretch = (noBreakLength.max - noBreakLength.opt);
+        int glue2shrink = (noBreakLength.opt - noBreakLength.min);
+        glue2stretch -= glue1.max - glue1.opt;
+        glue2stretch -= glue3.max - glue3.opt;
+        glue2shrink -= glue1.opt - glue1.min;
+        glue2shrink -= glue3.opt - glue3.min;
+        
+        boolean hasPrecedingNonBlock = false;
+        if (log.isDebugEnabled()) {
+            log.debug("noBreakLength=" + noBreakLength 
+                    + ", glue1=" + glue1 
+                    + ", glue2=" + glue2w + "+" + glue2stretch + "-" + glue2shrink 
+                    + ", glue3=" + glue3);
+        }
+        if (breakPoss != null) {
+            if (glue1.isNonZero()) {
+                iter.add(new KnuthPenalty(0, KnuthPenalty.INFINITE, 
+                        false, (Position)null, true));
+                iter.add(new KnuthGlue(glue1.opt, glue1.max - glue1.opt, glue1.opt - glue1.min, 
+                        (Position)null, true));
+            }
+            iter.add(new KnuthPenalty(breakPoss.getPenaltyWidth(), breakPoss.getPenaltyValue(), 
+                    false, breakPoss.getBreakClass(), 
+                    new SpaceHandlingBreakPosition(this, breakPoss), false));
+            //if (glue2.isNonZero()) {
+            if (glue2w != 0 || glue2stretch != 0 || glue2shrink != 0) {
+                /*
+                iter.add(new KnuthGlue(glue2.opt, glue2.max - glue2.opt, glue2.opt - glue2.min, 
+                        (Position)null, true));
+                        */
+                iter.add(new KnuthGlue(glue2w, glue2stretch, glue2shrink, 
+                        (Position)null, true));
+            }
+        } else {
+            if (glue1.isNonZero()) {
+                throw new IllegalStateException("glue1 should be 0 in this case");
+            }
+        }
+        Position pos = null;
+        if (breakPoss == null) {
+            pos = new SpaceHandlingPosition(this);
+        }
+        if (glue3.isNonZero() || pos != null) {
+            iter.add(new KnuthBox(0, pos, true));
+        }
+        if (glue3.isNonZero()) {
+            iter.add(new KnuthPenalty(0, KnuthPenalty.INFINITE, 
+                    false, (Position)null, true));
+            iter.add(new KnuthGlue(glue3.opt, glue3.max - glue3.opt, glue3.opt - glue3.min, 
+                    (Position)null, true));
+            hasPrecedingNonBlock = true;
+        }
+        if (isLast && hasPrecedingNonBlock) {
+            //Otherwise, the preceding penalty and glue will be cut off
+            iter.add(new KnuthBox(0, (Position)null, true));
+        }
+    }
+    
+    /**
+     * Position class for break possibilities. It is used to notify layout manager about the
+     * effective spaces and conditional lengths.
+     */
+    public class SpaceHandlingBreakPosition extends Position {
+
+        private SpaceResolver resolver;
+        private Position originalPosition;
+        
+        /**
+         * Main constructor.
+         * @param resolver the space resolver that provides the info about the actual situation
+         */
+        public SpaceHandlingBreakPosition(SpaceResolver resolver, BreakElement breakPoss) {
+            super(null);
+            this.resolver = resolver;
+            this.originalPosition = breakPoss.getPosition();
+            //Unpack since the SpaceHandlingBreakPosition is a non-wrapped Position, too
+            while (this.originalPosition instanceof NonLeafPosition) {
+                this.originalPosition = this.originalPosition.getPosition();
+            }
+        }
+        
+        /** @return the space resolver */
+        public SpaceResolver getSpaceResolver() {
+            return this.resolver;
+        }
+        
+        /**
+         * Notifies all affected layout managers about the current situation in the part to be
+         * handled for area generation.
+         * @param isBreakSituation true if this is a break situation.
+         * @param side defines to notify about the situation whether before or after the break.
+         *             May be null if isBreakSituation is null. 
+         */
+        public void notifyBreakSituation(boolean isBreakSituation, RelSide side) {
+            if (isBreakSituation) {
+                if (RelSide.BEFORE == side) {
+                    for (int i = 0; i < resolver.secondPart.length; i++) {
+                        resolver.secondPart[i].notifyLayoutManager(resolver.secondPartLengths[i]);
+                    }
+                } else {
+                    for (int i = 0; i < resolver.firstPart.length; i++) {
+                        resolver.firstPart[i].notifyLayoutManager(resolver.firstPartLengths[i]);
+                    }
+                }
+            } else {
+                for (int i = 0; i < resolver.noBreak.length; i++) {
+                    resolver.noBreak[i].notifyLayoutManager(resolver.noBreakLengths[i]);
+                }
+            }
+        }
+        
+        /** @see java.lang.Object#toString() */
+        public String toString() {
+            StringBuffer sb = new StringBuffer();
+            sb.append("SpaceHandlingBreakPosition(");
+            sb.append(this.originalPosition);
+            sb.append(")");
+            return sb.toString();
+        }
+
+        /** 
+         * @return the original Position instance set at the BreakElement that this Position was
+         *         created for.
+         */
+        public Position getOriginalBreakPosition() {
+            return this.originalPosition;
+        }
+    }
+    
+    /**
+     * Position class for no-break situations. It is used to notify layout manager about the
+     * effective spaces and conditional lengths.
+     */
+    public class SpaceHandlingPosition extends Position {
+
+        private SpaceResolver resolver;
+        
+        /**
+         * Main constructor.
+         * @param resolver the space resolver that provides the info about the actual situation
+         */
+        public SpaceHandlingPosition(SpaceResolver resolver) {
+            super(null);
+            this.resolver = resolver;
+        }
+        
+        /** @return the space resolver */
+        public SpaceResolver getSpaceResolver() {
+            return this.resolver;
+        }
+        
+        /**
+         * Notifies all affected layout managers about the current situation in the part to be
+         * handled for area generation.
+         */
+        public void notifySpaceSituation() {
+            if (resolver.breakPoss != null) {
+                throw new IllegalStateException("Only applicable to no-break situations");
+            }
+            for (int i = 0; i < resolver.secondPart.length; i++) {
+                resolver.secondPart[i].notifyLayoutManager(resolver.secondPartLengths[i]);
+            }
+        }
+        
+        /** @see java.lang.Object#toString() */
+        public String toString() {
+            StringBuffer sb = new StringBuffer();
+            sb.append("SpaceHandlingPosition");
+            return sb.toString();
+        }
+    }
+    
+    /**
+     * Resolves unresolved elements applying the space resolution rules defined in 4.3.1.
+     * @param elems the element list
+     */
+    public static void resolveElementList(LinkedList elems) {
+        if (log.isTraceEnabled()) {
+            log.trace(elems);
+        }
+        boolean first = true;
+        boolean last = false;
+        boolean skipNextElement = false;
+        List unresolvedFirst = new java.util.ArrayList();
+        List unresolvedSecond = new java.util.ArrayList();
+        List currentGroup;
+        ListIterator iter = elems.listIterator();
+        while (iter.hasNext()) {
+            ListElement el = (ListElement)iter.next();
+            if (el.isUnresolvedElement()) {
+                if (log.isTraceEnabled()) {
+                    log.trace("unresolved found: " + el + " " + first + "/" + last);
+                }
+                BreakElement breakPoss = null;
+                //Clear temp lists
+                unresolvedFirst.clear();
+                unresolvedSecond.clear();
+                //Collect groups
+                if (el instanceof BreakElement) {
+                    breakPoss = (BreakElement)el;
+                    currentGroup = unresolvedSecond;
+                } else {
+                    currentGroup = unresolvedFirst;
+                    currentGroup.add(el);
+                }
+                iter.remove();
+                last = true;
+                skipNextElement = true;
+                while (iter.hasNext()) {
+                    el = (ListElement)iter.next();
+                    if (el instanceof BreakElement && breakPoss != null) {
+                        skipNextElement = false;
+                        last = false;
+                        break;
+                    } else if (currentGroup == unresolvedFirst && (el instanceof BreakElement)) {
+                        breakPoss = (BreakElement)el;
+                        iter.remove();
+                        currentGroup = unresolvedSecond;
+                    } else if (el.isUnresolvedElement()) {
+                        currentGroup.add(el);
+                        iter.remove();
+                    } else {
+                        last = false;
+                        break;
+                    }
+                }
+                //last = !iter.hasNext();
+                if (breakPoss == null && unresolvedSecond.size() == 0 && !last) {
+                    log.trace("Swap first and second parts in no-break condition,"
+                            + " second part is empty.");
+                    //The first list is reversed, so swap if this shouldn't happen
+                    List swapList = unresolvedSecond;
+                    unresolvedSecond = unresolvedFirst;
+                    unresolvedFirst = swapList;
+                }
+                
+                log.debug("----start space resolution (first=" + first + ", last=" + last + ")...");
+                SpaceResolver resolver = new SpaceResolver(
+                        unresolvedFirst, breakPoss, unresolvedSecond, first, last);
+                if (!last) {
+                    iter.previous();
+                }
+                resolver.generate(iter);
+                if (!last && skipNextElement) {
+                    iter.next();
+                }
+                log.debug("----end space resolution.");
+            }
+            first = false;
+        }
+    }
+    
+    /**
+     * Inspects an effective element list and notifies all layout managers about the state of
+     * the spaces and conditional lengths.
+     * @param effectiveList the effective element list
+     * @param startElementIndex index of the first element in the part to be processed
+     * @param endElementIndex index of the last element in the part to be processed
+     * @param lastBreak index of the the break possibility just before this part (used to
+     *                  identify a break condition, lastBreak <= 0 represents a no-break condition)
+     */
+    public static void performConditionalsNotification(List effectiveList, 
+            int startElementIndex, int endElementIndex, int lastBreak) {
+        KnuthElement el = null;
+        if (lastBreak > 0) {
+            el = (KnuthElement)effectiveList.get(lastBreak);
+        }
+        SpaceResolver.SpaceHandlingBreakPosition beforeBreak = null;
+        SpaceResolver.SpaceHandlingBreakPosition afterBreak = null;
+        if (el != null && el.isPenalty()) {
+            Position pos = el.getPosition();
+            if (pos instanceof SpaceResolver.SpaceHandlingBreakPosition) {
+                beforeBreak = (SpaceResolver.SpaceHandlingBreakPosition)pos; 
+                beforeBreak.notifyBreakSituation(true, RelSide.BEFORE);
+            }
+        }
+        el = (KnuthElement)effectiveList.get(endElementIndex);
+        if (el != null && el.isPenalty()) {
+            Position pos = el.getPosition();
+            if (pos instanceof SpaceResolver.SpaceHandlingBreakPosition) {
+                afterBreak = (SpaceResolver.SpaceHandlingBreakPosition)pos; 
+                afterBreak.notifyBreakSituation(true, RelSide.AFTER);
+            }
+        }
+        for (int i = startElementIndex; i <= endElementIndex; i++) {
+            Position pos = ((KnuthElement)effectiveList.get(i)).getPosition();
+            if (pos instanceof SpaceResolver.SpaceHandlingPosition) {
+                ((SpaceResolver.SpaceHandlingPosition)pos).notifySpaceSituation();
+            } else if (pos instanceof SpaceResolver.SpaceHandlingBreakPosition) {
+                SpaceResolver.SpaceHandlingBreakPosition noBreak;
+                noBreak = (SpaceResolver.SpaceHandlingBreakPosition)pos;
+                if (noBreak != beforeBreak && noBreak != afterBreak) {
+                    noBreak.notifyBreakSituation(false, null);
+                }
+            }
+        }
+    }
+    
+    
+
+}

src/java/org/apache/fop/layoutmgr/StaticContentLayoutManager.java

@@ -19,11 +19,13 @@
 package org.apache.fop.layoutmgr;
 
 import java.util.LinkedList;
+import java.util.List;
 import java.util.ListIterator;
 
 import org.apache.fop.area.RegionReference;
 import org.apache.fop.area.Area;
 import org.apache.fop.area.Block;
+import org.apache.fop.fo.pagination.PageSequence;
 import org.apache.fop.fo.pagination.SideRegion;
 import org.apache.fop.fo.pagination.StaticContent;
 import org.apache.fop.layoutmgr.inline.InlineLevelLayoutManager;
@@ -251,6 +253,16 @@ public class StaticContentLayoutManager extends BlockStackingLayoutManager {
             this.displayAlign = displayAlign;
         }
 
+        /** @see org.apache.fop.layoutmgr.AbstractBreaker#observeElementList(java.util.List) */
+        protected void observeElementList(List elementList) {
+            String elementListID = getStaticContentFO().getFlowName();
+            String pageSequenceID = ((PageSequence)lm.getParent().getFObj()).getId();
+            if (pageSequenceID != null && pageSequenceID.length() > 0) {
+                elementListID += "-" + pageSequenceID;
+            }
+            ElementListObserver.observe(elementList, "static-content", elementListID);
+        }
+        
         /** @see org.apache.fop.layoutmgr.AbstractBreaker#isPartOverflowRecoveryActivated() */
         protected boolean isPartOverflowRecoveryActivated() {
             //For side regions, this must be disabled because of wanted overflow.
@@ -287,9 +299,9 @@ public class StaticContentLayoutManager extends BlockStackingLayoutManager {
                 }
                 if (returnedList != null) {
                     lm.wrapPositionElements(returnedList, returnList);
-                    //returnList.addAll(returnedList);
                 }
             }
+            SpaceResolver.resolveElementList(returnList);
             setFinished(true);
             return returnList;
         }

src/java/org/apache/fop/layoutmgr/TraitSetter.java

@@ -21,6 +21,7 @@ package org.apache.fop.layoutmgr;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.apache.fop.traits.BorderProps;
+import org.apache.fop.traits.MinOptMax;
 import org.apache.fop.area.Area;
 import org.apache.fop.area.Trait;
 import org.apache.fop.datatypes.LengthBase;
@@ -105,12 +106,13 @@ public class TraitSetter {
     }
 
     /**
-     * Add borders to an area.
+     * Add borders to an area. Note: this method also adds unconditional padding. Don't use!
      * Layout managers that create areas with borders can use this to
      * add the borders to the area.
      * @param area the area to set the traits on.
      * @param bordProps border properties
      * @param context Property evaluation context
+     * @deprecated Call the other addBorders() method and addPadding separately.
      */
     public static void addBorders(Area area, CommonBorderPaddingBackground bordProps,
                                 PercentBaseContext context) {
@@ -134,6 +136,40 @@ public class TraitSetter {
         addPadding(area, bordProps, context);
     }
 
+    /**
+     * Add borders to an area.
+     * Layout managers that create areas with borders can use this to
+     * add the borders to the area.
+     * @param area the area to set the traits on.
+     * @param bordProps border properties
+     * @param discardBefore true if the before border should be discarded
+     * @param discardAfter true if the after border should be discarded
+     * @param discardStart true if the start border should be discarded
+     * @param discardEnd true if the end border should be discarded
+     * @param context Property evaluation context
+     */
+    public static void addBorders(Area area, CommonBorderPaddingBackground bordProps,
+                boolean discardBefore, boolean discardAfter,
+                boolean discardStart, boolean discardEnd,
+                PercentBaseContext context) {
+        BorderProps bps = getBorderProps(bordProps, CommonBorderPaddingBackground.BEFORE);
+        if (bps != null && !discardBefore) {
+            area.addTrait(Trait.BORDER_BEFORE, bps);
+        }
+        bps = getBorderProps(bordProps, CommonBorderPaddingBackground.AFTER);
+        if (bps != null && !discardAfter) {
+            area.addTrait(Trait.BORDER_AFTER, bps);
+        }
+        bps = getBorderProps(bordProps, CommonBorderPaddingBackground.START);
+        if (bps != null && !discardStart) {
+            area.addTrait(Trait.BORDER_START, bps);
+        }
+        bps = getBorderProps(bordProps, CommonBorderPaddingBackground.END);
+        if (bps != null && !discardEnd) {
+            area.addTrait(Trait.BORDER_END, bps);
+        }
+    }
+
     /**
      * Add borders to an area for the collapsing border model in tables.
      * Layout managers that create areas with borders can use this to
@@ -174,25 +210,49 @@ public class TraitSetter {
 
     private static void addPadding(Area area, CommonBorderPaddingBackground bordProps, 
                                 PercentBaseContext context) {
-        int padding = bordProps.getPadding(CommonBorderPaddingBackground.START, false, context);
+        addPadding(area, bordProps, false, false, false, false, context);
+    }
+
+    /**
+     * Add padding to an area.
+     * Layout managers that create areas with padding can use this to
+     * add the borders to the area.
+     * @param area the area to set the traits on.
+     * @param bordProps border and padding properties
+     * @param discardBefore true if the before padding should be discarded
+     * @param discardAfter true if the after padding should be discarded
+     * @param discardStart true if the start padding should be discarded
+     * @param discardEnd true if the end padding should be discarded
+     * @param context Property evaluation context
+     */
+    public static void addPadding(Area area, CommonBorderPaddingBackground bordProps,
+                boolean discardBefore, boolean discardAfter,
+                boolean discardStart, boolean discardEnd,
+                PercentBaseContext context) {
+        int padding = bordProps.getPadding(CommonBorderPaddingBackground.BEFORE, 
+                discardBefore, context);
         if (padding != 0) {
-            area.addTrait(Trait.PADDING_START, new java.lang.Integer(padding));
+            area.addTrait(Trait.PADDING_BEFORE, new java.lang.Integer(padding));
         }
 
-        padding = bordProps.getPadding(CommonBorderPaddingBackground.END, false, context);
+        padding = bordProps.getPadding(CommonBorderPaddingBackground.AFTER, 
+                discardAfter, context);
         if (padding != 0) {
-            area.addTrait(Trait.PADDING_END, new java.lang.Integer(padding));
+            area.addTrait(Trait.PADDING_AFTER, new java.lang.Integer(padding));
         }
 
-        padding = bordProps.getPadding(CommonBorderPaddingBackground.BEFORE, false, context);
+        padding = bordProps.getPadding(CommonBorderPaddingBackground.START, 
+                discardStart, context);
         if (padding != 0) {
-            area.addTrait(Trait.PADDING_BEFORE, new java.lang.Integer(padding));
+            area.addTrait(Trait.PADDING_START, new java.lang.Integer(padding));
         }
 
-        padding = bordProps.getPadding(CommonBorderPaddingBackground.AFTER, false, context);
+        padding = bordProps.getPadding(CommonBorderPaddingBackground.END, 
+                discardEnd, context);
         if (padding != 0) {
-            area.addTrait(Trait.PADDING_AFTER, new java.lang.Integer(padding));
+            area.addTrait(Trait.PADDING_END, new java.lang.Integer(padding));
         }
+
     }
     
     private static BorderProps getBorderProps(CommonBorderPaddingBackground bordProps, int side) {
@@ -254,9 +314,9 @@ public class TraitSetter {
                         width += backProps.getPaddingEnd(false, context);
                         back.setHoriz(backProps.backgroundPositionHorizontal.getValue(
                                 new SimplePercentBaseContext(context, 
-                                                             LengthBase.IMAGE_BACKGROUND_POSITION_HORIZONTAL,
-                                                             (width - back.getFopImage().getIntrinsicWidth())
-                                                            )
+                                    LengthBase.IMAGE_BACKGROUND_POSITION_HORIZONTAL,
+                                    (width - back.getFopImage().getIntrinsicWidth())
+                                )
                             ));
                     } else {
                         //TODO Area IPD has to be set for this to work
@@ -275,9 +335,9 @@ public class TraitSetter {
                         height += backProps.getPaddingAfter(false, context);
                         back.setVertical(backProps.backgroundPositionVertical.getValue(
                                 new SimplePercentBaseContext(context, 
-                                                             LengthBase.IMAGE_BACKGROUND_POSITION_VERTICAL,
-                                                             (height - back.getFopImage().getIntrinsicHeight())
-                                                            )
+                                     LengthBase.IMAGE_BACKGROUND_POSITION_VERTICAL,
+                                     (height - back.getFopImage().getIntrinsicHeight())
+                                )
                             ));
                     } else {
                         //TODO Area BPD has to be set for this to work
@@ -329,6 +389,32 @@ public class TraitSetter {
         }
     }
 
+    public static int getEffectiveSpace(double adjust, MinOptMax space) {
+        if (space == null) {
+            return 0;
+        }
+        int sp = space.opt;
+        if (adjust > 0) {
+            sp = sp + (int)(adjust * (space.max - space.opt));
+        } else {
+            sp = sp + (int)(adjust * (space.opt - space.min));
+        }
+        return sp;
+    }
+    
+    public static void addSpaceBeforeAfter(Area area, double adjust, 
+            MinOptMax spaceBefore, MinOptMax spaceAfter) {
+        int space;
+        space = getEffectiveSpace(adjust, spaceBefore);
+        if (space != 0) {
+            area.addTrait(Trait.SPACE_BEFORE, new Integer(space));
+        }
+        space = getEffectiveSpace(adjust, spaceAfter);
+        if (space != 0) {
+            area.addTrait(Trait.SPACE_AFTER, new Integer(space));
+        }
+    }
+    
     /**
      * Sets the traits for breaks on an area.
      * @param area the area to set the traits on.

src/java/org/apache/fop/layoutmgr/UnresolvedListElement.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* $Id$ */
+
+package org.apache.fop.layoutmgr;
+
+/**
+ * This class represents an unresolved list element.
+ */
+public abstract class UnresolvedListElement extends ListElement {
+
+    /**
+     * Main constructor
+     * @param position the Position instance needed by the addAreas stage of the LMs.
+     */
+    public UnresolvedListElement(Position position) {
+        super(position);
+    }
+    
+    /** @return true if the element is conditional (conditionality="discard") */
+    public abstract boolean isConditional();
+    
+    /** @return the layout manager that created this ListElement */
+    protected LayoutManager getOriginatingLayoutManager() {
+        Position pos = getPosition();
+        while (pos instanceof NonLeafPosition && pos.getPosition() != null) {
+            pos = pos.getPosition();
+        }
+        return pos.getLM();
+    }
+    
+}

src/java/org/apache/fop/layoutmgr/UnresolvedListElementWithLength.java

@@ -0,0 +1,112 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* $Id$ */
+
+package org.apache.fop.layoutmgr;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.fop.traits.MinOptMax;
+
+/**
+ * This class represents an unresolved list element element with a (conditional) length. This
+ * is the base class for spaces, borders and paddings.
+ */
+public abstract class UnresolvedListElementWithLength extends UnresolvedListElement {
+
+    /** Logger instance */
+    protected static Log log = LogFactory.getLog(UnresolvedListElementWithLength.class);
+    
+    private MinOptMax length;
+    private boolean conditional;
+    private RelSide side;
+    private boolean isFirst;
+    private boolean isLast;
+    
+    /**
+     * Main constructor
+     * @param position the Position instance needed by the addAreas stage of the LMs.
+     * @param length the length of the element
+     * @param side the side to which this element applies
+     * @param conditional true if it's a conditional element (conditionality=discard)
+     * @param isFirst true if this is a space-before of the first area generated.
+     * @param isLast true if this is a space-after of the last area generated.
+     */
+    public UnresolvedListElementWithLength(Position position, MinOptMax length, 
+            RelSide side,
+            boolean conditional, boolean isFirst, boolean isLast) {
+        super(position);
+        this.length = length;
+        this.side = side;
+        this.conditional = conditional;
+        this.isFirst = isFirst;
+        this.isLast = isLast;
+    }
+    
+    /** @see org.apache.fop.layoutmgr.UnresolvedListElement#isConditional() */
+    public boolean isConditional() {
+        return this.conditional;
+    }
+    
+    /** @return the space as resolved MinOptMax instance */
+    public MinOptMax getLength() {
+        return this.length;
+    }
+    
+    /** @return the side this element was generated for */
+    public RelSide getSide() {
+        return this.side;
+    }
+    
+    /** @return true if this is a space-before of the first area generated. */
+    public boolean isFirst() {
+        return this.isFirst;
+    }
+    
+    /** @return true if this is a space-after of the last area generated. */
+    public boolean isLast() {
+        return this.isLast;
+    }
+    
+    /**
+     * Called to notify the affected layout manager about the effective length after resolution.
+     * This method is called once before each call to the layout manager's addAreas() method.
+     * @param effectiveLength the effective length after resolution (may be null which equals to
+     *                        zero effective length)
+     */
+    public abstract void notifyLayoutManager(MinOptMax effectiveLength);
+    
+    /** @see java.lang.Object#toString() */
+    public String toString() {
+        StringBuffer sb = new StringBuffer();
+        sb.append(getSide().getName()).append(", ");
+        sb.append(this.length.toString());
+        if (isConditional()) {
+            sb.append("[discard]");
+        } else {
+            sb.append("[RETAIN]");
+        }
+        if (isFirst()) {
+            sb.append("[first]");
+        }
+        if (isLast()) {
+            sb.append("[last]");
+        }
+        return sb.toString();
+    }
+    
+}

src/java/org/apache/fop/layoutmgr/inline/LineLayoutManager.java

@@ -25,6 +25,7 @@ import org.apache.fop.fo.properties.CommonHyphenation;
 import org.apache.fop.hyphenation.Hyphenation;
 import org.apache.fop.hyphenation.Hyphenator;
 import org.apache.fop.layoutmgr.BlockLevelLayoutManager;
+import org.apache.fop.layoutmgr.BreakElement;
 import org.apache.fop.layoutmgr.BreakingAlgorithm;
 import org.apache.fop.layoutmgr.ElementListObserver;
 import org.apache.fop.layoutmgr.KnuthBlockBox;
@@ -642,7 +643,7 @@ public class LineLayoutManager extends InlineStackingLayoutManager
         }
 
         //PHASE 2: Create line breaks
-        return createLineBreaks(context.getBPAlignment());
+        return createLineBreaks(context.getBPAlignment(), context);
         /*
         LineBreakPosition lbp = null;
         if (breakpoints == null) {
@@ -979,9 +980,10 @@ public class LineLayoutManager extends InlineStackingLayoutManager
     /**
      * Phase 2 of Knuth algorithm: find optimal break points.
      * @param alignment alignment in BP direction of the paragraph
+     * @param context the layout context
      * @return a list of Knuth elements representing broken lines
      */
-    private LinkedList createLineBreaks(int alignment) {
+    private LinkedList createLineBreaks(int alignment, LayoutContext context) {
 
         // find the optimal line breaking points for each paragraph
         ListIterator paragraphsIterator
@@ -1000,7 +1002,7 @@ public class LineLayoutManager extends InlineStackingLayoutManager
         setFinished(true);
     
         //Post-process the line breaks found
-        return postProcessLineBreaks(alignment);
+        return postProcessLineBreaks(alignment, context);
     }
 
     /**
@@ -1143,17 +1145,19 @@ public class LineLayoutManager extends InlineStackingLayoutManager
     /**
      * Creates the element list in BP direction for the broken lines.
      * @param alignment the currently applicable vertical alignment
+     * @param context the layout context
      * @return the newly built element list
      */
-    private LinkedList postProcessLineBreaks(int alignment) {
+    private LinkedList postProcessLineBreaks(int alignment, LayoutContext context) {
     
         LinkedList returnList = new LinkedList();
         
         for (int p = 0; p < knuthParagraphs.size(); p++) {
             // null penalty between paragraphs
-            if (p > 0
-                && !((BlockLevelLayoutManager) parentLM).mustKeepTogether()) {
-                returnList.add(new KnuthPenalty(0, 0, false, new Position(this), false));
+            if (p > 0 && !((BlockLevelLayoutManager) parentLM).mustKeepTogether()) {
+                returnList.add(new BreakElement(
+                        new Position(this), 0, context));
+                //returnList.add(new KnuthPenalty(0, 0, false, new Position(this), false));
             }
         
             lineLayouts = (LineLayoutPossibilities)lineLayoutsList.get(p);
@@ -1187,11 +1191,13 @@ public class LineLayoutManager extends InlineStackingLayoutManager
                         i < lineLayouts.getChosenLineCount();
                         i++) {
                     if (!((BlockLevelLayoutManager) parentLM).mustKeepTogether()
-                        && i >= fobj.getOrphans()
-                        && i <= lineLayouts.getChosenLineCount() - fobj.getWidows()
-                        && returnList.size() > 0) {
+                            && i >= fobj.getOrphans()
+                            && i <= lineLayouts.getChosenLineCount() - fobj.getWidows()
+                            && returnList.size() > 0) {
                         // null penalty allowing a page break between lines
-                        returnList.add(new KnuthPenalty(0, 0, false, returnPosition, false));
+                        returnList.add(new BreakElement(
+                                returnPosition, 0, context));
+                        //returnList.add(new KnuthPenalty(0, 0, false, returnPosition, false));
                     }
                     int endIndex = ((LineBreakPosition) lineLayouts.getChosenPosition(i)).getLeafPos();
                     // create a list of the FootnoteBodyLM handling footnotes 

src/java/org/apache/fop/layoutmgr/list/ListBlockLayoutManager.java

@@ -21,11 +21,13 @@ package org.apache.fop.layoutmgr.list;
 import org.apache.fop.fo.flow.ListBlock;
 import org.apache.fop.layoutmgr.BlockLevelLayoutManager;
 import org.apache.fop.layoutmgr.BlockStackingLayoutManager;
+import org.apache.fop.layoutmgr.ConditionalElementListener;
 import org.apache.fop.layoutmgr.LayoutManager;
 import org.apache.fop.layoutmgr.LayoutContext;
 import org.apache.fop.layoutmgr.PositionIterator;
 import org.apache.fop.layoutmgr.Position;
 import org.apache.fop.layoutmgr.NonLeafPosition;
+import org.apache.fop.layoutmgr.RelSide;
 import org.apache.fop.layoutmgr.TraitSetter;
 import org.apache.fop.area.Area;
 import org.apache.fop.area.Block;
@@ -41,11 +43,17 @@ import java.util.List;
  * A list block contains list items which are stacked within
  * the list block area..
  */
-public class ListBlockLayoutManager extends BlockStackingLayoutManager {
+public class ListBlockLayoutManager extends BlockStackingLayoutManager 
+                implements ConditionalElementListener {
 
     private Block curBlockArea;
 
-    //TODO space-before|after: handle space-resolution rules
+    private boolean discardBorderBefore;
+    private boolean discardBorderAfter;
+    private boolean discardPaddingBefore;
+    private boolean discardPaddingAfter;
+    private MinOptMax effSpaceBefore;
+    private MinOptMax effSpaceAfter;
 
     private static class StackingIter extends PositionIterator {
         StackingIter(Iterator parentIter) {
@@ -86,11 +94,23 @@ public class ListBlockLayoutManager extends BlockStackingLayoutManager {
         return (ListBlock)fobj;
     }
 
+    /** @see org.apache.fop.layoutmgr.LayoutManager#initialize() */
     public void initialize() {
-        foSpaceBefore = new SpaceVal(getListBlockFO().getCommonMarginBlock().spaceBefore, this).getSpace();
-        foSpaceAfter = new SpaceVal(getListBlockFO().getCommonMarginBlock().spaceAfter, this).getSpace();
+        foSpaceBefore = new SpaceVal(
+                getListBlockFO().getCommonMarginBlock().spaceBefore, this).getSpace();
+        foSpaceAfter = new SpaceVal(
+                getListBlockFO().getCommonMarginBlock().spaceAfter, this).getSpace();
     }
 
+    private void resetSpaces() {
+        this.discardBorderBefore = false;        
+        this.discardBorderAfter = false;        
+        this.discardPaddingBefore = false;        
+        this.discardPaddingAfter = false;
+        this.effSpaceBefore = foSpaceBefore;
+        this.effSpaceAfter = foSpaceAfter;
+    }
+    
     private int getIPIndents() {
         int iIndents = 0;
         iIndents += getListBlockFO().getCommonMarginBlock().startIndent.getValue(this);
@@ -98,6 +118,12 @@ public class ListBlockLayoutManager extends BlockStackingLayoutManager {
         return iIndents;
     }
     
+    /** @see org.apache.fop.layoutmgr.BlockStackingLayoutManager */
+    public LinkedList getNextKnuthElements(LayoutContext context, int alignment) {
+        resetSpaces(); 
+        return super.getNextKnuthElements(context, alignment);
+    }
+   
     /** @see org.apache.fop.layoutmgr.LayoutManager#getChangedKnuthElements(java.util.List, int) */
     public LinkedList getChangedKnuthElements(List oldList, int alignment) {
         //log.debug("LBLM.getChangedKnuthElements>");
@@ -121,11 +147,6 @@ public class ListBlockLayoutManager extends BlockStackingLayoutManager {
             addBlockSpacing(0.0, new MinOptMax(layoutContext.getSpaceBefore()));
         }
 
-        // if adjusted space before
-        double adjust = layoutContext.getSpaceAdjust();
-        addBlockSpacing(adjust, foSpaceBefore);
-        foSpaceBefore = null;
-        
         getPSLM().addIDToPage(getListBlockFO().getId());
 
         // the list block contains areas stacked from each list item
@@ -184,13 +205,13 @@ public class ListBlockLayoutManager extends BlockStackingLayoutManager {
         TraitSetter.addBackground(curBlockArea, 
                 getListBlockFO().getCommonBorderPaddingBackground(),
                 this);
+        TraitSetter.addSpaceBeforeAfter(curBlockArea, layoutContext.getSpaceAdjust(), 
+                effSpaceBefore, effSpaceAfter);
 
         flush();
 
-        // if adjusted space after
-        addBlockSpacing(adjust, foSpaceAfter);
-        
         curBlockArea = null;
+        resetSpaces();
     }
 
     /**
@@ -217,7 +238,11 @@ public class ListBlockLayoutManager extends BlockStackingLayoutManager {
             // set traits
             TraitSetter.setProducerID(curBlockArea, getListBlockFO().getId());
             TraitSetter.addBorders(curBlockArea, 
-            getListBlockFO().getCommonBorderPaddingBackground(), this);
+                    getListBlockFO().getCommonBorderPaddingBackground(), 
+                    discardBorderBefore, discardBorderAfter, false, false, this);
+            TraitSetter.addPadding(curBlockArea, 
+                    getListBlockFO().getCommonBorderPaddingBackground(), 
+                    discardPaddingBefore, discardPaddingAfter, false, false, this);
             TraitSetter.addMargins(curBlockArea,
                     getListBlockFO().getCommonBorderPaddingBackground(), 
                     getListBlockFO().getCommonMarginBlock(),
@@ -278,5 +303,50 @@ public class ListBlockLayoutManager extends BlockStackingLayoutManager {
                 || !getListBlockFO().getKeepWithNext().getWithinColumn().isAuto();
     }
 
+    /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+    public void notifySpace(RelSide side, MinOptMax effectiveLength) {
+        if (RelSide.BEFORE == side) {
+            if (log.isDebugEnabled()) {
+                log.debug(this + ": Space " + side + ", " 
+                        + this.effSpaceBefore + "-> " + effectiveLength);
+            }
+            this.effSpaceBefore = effectiveLength;
+        } else {
+            if (log.isDebugEnabled()) {
+                log.debug(this + ": Space " + side + ", " 
+                        + this.effSpaceAfter + "-> " + effectiveLength);
+            }
+            this.effSpaceAfter = effectiveLength;
+        }
+    }
+
+    /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+    public void notifyBorder(RelSide side, MinOptMax effectiveLength) {
+        if (effectiveLength == null) {
+            if (RelSide.BEFORE == side) {
+                this.discardBorderBefore = true;
+            } else {
+                this.discardBorderAfter = true;
+            }
+        }
+        if (log.isDebugEnabled()) {
+            log.debug(this + ": Border " + side + " -> " + effectiveLength);
+        }
+    }
+
+    /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+    public void notifyPadding(RelSide side, MinOptMax effectiveLength) {
+        if (effectiveLength == null) {
+            if (RelSide.BEFORE == side) {
+                this.discardPaddingBefore = true;
+            } else {
+                this.discardPaddingAfter = true;
+            }
+        }
+        if (log.isDebugEnabled()) {
+            log.debug(this + ": Padding " + side + " -> " + effectiveLength);
+        }
+    }
+
 }
 

src/java/org/apache/fop/layoutmgr/list/ListItemLayoutManager.java

@@ -23,11 +23,17 @@ import org.apache.fop.fo.flow.ListItemBody;
 import org.apache.fop.fo.flow.ListItemLabel;
 import org.apache.fop.layoutmgr.BlockLevelLayoutManager;
 import org.apache.fop.layoutmgr.BlockStackingLayoutManager;
+import org.apache.fop.layoutmgr.BreakElement;
+import org.apache.fop.layoutmgr.ConditionalElementListener;
+import org.apache.fop.layoutmgr.ElementListObserver;
+import org.apache.fop.layoutmgr.ElementListUtils;
 import org.apache.fop.layoutmgr.LayoutManager;
 import org.apache.fop.layoutmgr.LayoutContext;
 import org.apache.fop.layoutmgr.PositionIterator;
 import org.apache.fop.layoutmgr.Position;
 import org.apache.fop.layoutmgr.NonLeafPosition;
+import org.apache.fop.layoutmgr.RelSide;
+import org.apache.fop.layoutmgr.SpaceResolver;
 import org.apache.fop.layoutmgr.TraitSetter;
 import org.apache.fop.layoutmgr.KnuthElement;
 import org.apache.fop.layoutmgr.KnuthBox;
@@ -35,6 +41,7 @@ import org.apache.fop.layoutmgr.KnuthPenalty;
 import org.apache.fop.layoutmgr.KnuthPossPosIter;
 import org.apache.fop.area.Area;
 import org.apache.fop.area.Block;
+import org.apache.fop.traits.MinOptMax;
 import org.apache.fop.traits.SpaceVal;
 
 import java.util.ArrayList;
@@ -46,7 +53,8 @@ import java.util.ListIterator;
  * LayoutManager for a list-item FO.
  * The list item contains a list item label and a list item body.
  */
-public class ListItemLayoutManager extends BlockStackingLayoutManager {
+public class ListItemLayoutManager extends BlockStackingLayoutManager 
+                    implements ConditionalElementListener {
     private ListItemContentLayoutManager label;
     private ListItemContentLayoutManager body;
 
@@ -57,20 +65,16 @@ public class ListItemLayoutManager extends BlockStackingLayoutManager {
 
     private int listItemHeight;
     
-    //TODO space-before|after: handle space-resolution rules
+    private boolean discardBorderBefore;
+    private boolean discardBorderAfter;
+    private boolean discardPaddingBefore;
+    private boolean discardPaddingAfter;
+    private MinOptMax effSpaceBefore;
+    private MinOptMax effSpaceAfter;
     
     private boolean keepWithNextPendingOnLabel;
     private boolean keepWithNextPendingOnBody;
-    
-    /*
-    private class ItemPosition extends LeafPosition {
-        protected List cellBreaks;
-        protected ItemPosition(LayoutManager lm, int pos, List l) {
-            super(lm, pos);
-            cellBreaks = l;
-        }
-    }*/
-
+  
     private class ListItemPosition extends Position {
         private int iLabelFirstIndex;
         private int iLabelLastIndex;
@@ -149,11 +153,23 @@ public class ListItemLayoutManager extends BlockStackingLayoutManager {
         body.setParent(this);
     }
 
+    /** @see org.apache.fop.layoutmgr.LayoutManager#initialize() */
     public void initialize() {
-        foSpaceBefore = new SpaceVal(getListItemFO().getCommonMarginBlock().spaceBefore, this).getSpace();
-        foSpaceAfter = new SpaceVal(getListItemFO().getCommonMarginBlock().spaceAfter, this).getSpace();
+        foSpaceBefore = new SpaceVal(
+                getListItemFO().getCommonMarginBlock().spaceBefore, this).getSpace();
+        foSpaceAfter = new SpaceVal(
+                getListItemFO().getCommonMarginBlock().spaceAfter, this).getSpace();
     }
 
+    private void resetSpaces() {
+        this.discardBorderBefore = false;        
+        this.discardBorderAfter = false;        
+        this.discardPaddingBefore = false;        
+        this.discardPaddingAfter = false;
+        this.effSpaceBefore = foSpaceBefore;
+        this.effSpaceAfter = foSpaceAfter;
+    }
+    
     private int getIPIndents() {
         int iIndents = 0;
         iIndents += getListItemFO().getCommonMarginBlock().startIndent.getValue(this);
@@ -168,16 +184,22 @@ public class ListItemLayoutManager extends BlockStackingLayoutManager {
         
         LinkedList returnList = new LinkedList();
         
-        if (!bSpaceBeforeServed) {
-            addKnuthElementsForSpaceBefore(returnList, alignment);
-            bSpaceBeforeServed = true;
-        }
+        addKnuthElementsForSpaceBefore(returnList, alignment);
         
+        //Spaces, border and padding to be repeated at each break
+        addPendingMarks(context);
+
         // label
         childLC = new LayoutContext(0);
         childLC.setRefIPD(context.getRefIPD());
         label.initialize();
         labelList = label.getNextKnuthElements(childLC, alignment);
+        
+        //Space resolution as if the contents were placed in a new reference area
+        //(see 6.8.3, XSL 1.0, section on Constraints, last paragraph)
+        SpaceResolver.resolveElementList(labelList);
+        ElementListObserver.observe(labelList, "list-item-label", label.getPartFO().getId());
+        
         if (childLC.isKeepWithPreviousPending()) {
             context.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING);
         }
@@ -188,13 +210,19 @@ public class ListItemLayoutManager extends BlockStackingLayoutManager {
         childLC.setRefIPD(context.getRefIPD());
         body.initialize();
         bodyList = body.getNextKnuthElements(childLC, alignment);
+
+        //Space resolution as if the contents were placed in a new reference area
+        //(see 6.8.3, XSL 1.0, section on Constraints, last paragraph)
+        SpaceResolver.resolveElementList(bodyList);
+        ElementListObserver.observe(bodyList, "list-item-body", body.getPartFO().getId());
+        
         if (childLC.isKeepWithPreviousPending()) {
             context.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING);
         }
         this.keepWithNextPendingOnBody = childLC.isKeepWithNextPending();
 
         // create a combined list
-        LinkedList returnedList = getCombinedKnuthElementsForListItem(labelList, bodyList);
+        LinkedList returnedList = getCombinedKnuthElementsForListItem(labelList, bodyList, context);
 
         // "wrap" the Position inside each element
         wrapPositionElements(returnedList, returnList, true);
@@ -209,16 +237,18 @@ public class ListItemLayoutManager extends BlockStackingLayoutManager {
         }
 
         setFinished(true);
+        resetSpaces();
         return returnList;
     }
 
     private LinkedList getCombinedKnuthElementsForListItem(LinkedList labelElements,
-                                                           LinkedList bodyElements) {
+                                                           LinkedList bodyElements,
+                                                           LayoutContext context) {
         //Copy elements to array lists to improve element access performance
         List[] elementLists = {new ArrayList(labelElements),
                                new ArrayList(bodyElements)};
-        int[] fullHeights = {calcItemHeightFromContents(elementLists[0]),
-                            calcItemHeightFromContents(elementLists[1])};
+        int[] fullHeights = {ElementListUtils.calcContentLength(elementLists[0]),
+                ElementListUtils.calcContentLength(elementLists[1])};
         int[] partialHeights = {0, 0};
         int[] start = {-1, -1};
         int[] end = {-1, -1};
@@ -259,39 +289,14 @@ public class ListItemLayoutManager extends BlockStackingLayoutManager {
                 if (keepWithNextActive || mustKeepTogether()) {
                     p = KnuthPenalty.INFINITE;
                 }
-                returnList.add(new KnuthPenalty(penaltyHeight, p, false, stepPosition, false));
+                //returnList.add(new KnuthPenalty(penaltyHeight, p, false, stepPosition, false));
+                returnList.add(new BreakElement(stepPosition, penaltyHeight, p, 0, context));
             }
         }
 
         return returnList;
     }
 
-    private int calcItemHeightFromContents(List elements, int start, int end) {
-        ListIterator iter = elements.listIterator(start);
-        int count = end - start + 1;
-        int len = 0;
-        while (iter.hasNext()) {
-            KnuthElement el = (KnuthElement)iter.next();
-            if (el.isBox()) {
-                len += el.getW();
-            } else if (el.isGlue()) {
-                len += el.getW();
-            } else {
-                log.debug("Ignoring penalty: " + el);
-                //ignore penalties
-            }
-            count--;
-            if (count == 0) {
-                break;
-            }
-        }
-        return len;
-    }
-    
-    private int calcItemHeightFromContents(List elements) {
-        return calcItemHeightFromContents(elements, 0, elements.size() - 1);
-    }
-
     private int getNextStep(List[] elementLists, int[] start, int[] end, int[] partialHeights) {
         // backup of partial heights
         int[] backupHeights = {partialHeights[0], partialHeights[1]};
@@ -422,11 +427,6 @@ public class ListItemLayoutManager extends BlockStackingLayoutManager {
                          LayoutContext layoutContext) {
         getParentArea(null);
 
-        // if adjusted space before
-        double adjust = layoutContext.getSpaceAdjust();
-        addBlockSpacing(adjust, foSpaceBefore);
-        foSpaceBefore = null;
-
         getPSLM().addIDToPage(getListItemFO().getId());
 
         LayoutContext lc = new LayoutContext(0);
@@ -461,6 +461,31 @@ public class ListItemLayoutManager extends BlockStackingLayoutManager {
         int bodyFirstIndex = ((ListItemPosition) positionList.getFirst()).getBodyFirstIndex();
         int bodyLastIndex = ((ListItemPosition) positionList.getLast()).getBodyLastIndex();
 
+        int lastBreak;
+        //Determine last break if any
+        lastBreak = labelFirstIndex - 1;
+        while (lastBreak >= 0) {
+            KnuthElement el = (KnuthElement)labelList.get(lastBreak);
+            if (el.isPenalty() && el.getP() < KnuthElement.INFINITE) {
+                break;
+            }
+            lastBreak--;
+        }
+        SpaceResolver.performConditionalsNotification(labelList, 
+                labelFirstIndex, labelLastIndex, lastBreak);
+
+        //Determine last break if any
+        lastBreak = bodyFirstIndex - 1;
+        while (lastBreak >= 0) {
+            KnuthElement el = (KnuthElement)bodyList.get(lastBreak);
+            if (el.isPenalty() && el.getP() < KnuthElement.INFINITE) {
+                break;
+            }
+            lastBreak--;
+        }
+        SpaceResolver.performConditionalsNotification(bodyList, 
+                bodyFirstIndex, bodyLastIndex, lastBreak);
+        
         // add label areas
         if (labelFirstIndex <= labelLastIndex) {
             KnuthPossPosIter labelIter = new KnuthPossPosIter(labelList, 
@@ -508,13 +533,13 @@ public class ListItemLayoutManager extends BlockStackingLayoutManager {
         TraitSetter.addBackground(curBlockArea, 
                 getListItemFO().getCommonBorderPaddingBackground(),
                 this);
+        TraitSetter.addSpaceBeforeAfter(curBlockArea, layoutContext.getSpaceAdjust(), 
+                effSpaceBefore, effSpaceAfter);
 
         flush();
 
-        // if adjusted space after
-        addBlockSpacing(adjust, foSpaceAfter);
-        
         curBlockArea = null;
+        resetSpaces();
     }
 
     /**
@@ -550,7 +575,11 @@ public class ListItemLayoutManager extends BlockStackingLayoutManager {
             // set traits
             TraitSetter.setProducerID(curBlockArea, getListItemFO().getId());
             TraitSetter.addBorders(curBlockArea, 
-                    getListItemFO().getCommonBorderPaddingBackground(), this);
+                    getListItemFO().getCommonBorderPaddingBackground(), 
+                    discardBorderBefore, discardBorderAfter, false, false, this);
+            TraitSetter.addPadding(curBlockArea, 
+                    getListItemFO().getCommonBorderPaddingBackground(), 
+                    discardPaddingBefore, discardPaddingAfter, false, false, this);
             TraitSetter.addMargins(curBlockArea,
                     getListItemFO().getCommonBorderPaddingBackground(), 
                     getListItemFO().getCommonMarginBlock(), this);
@@ -610,5 +639,51 @@ public class ListItemLayoutManager extends BlockStackingLayoutManager {
                 || !getListItemFO().getKeepWithNext().getWithinColumn().isAuto();
     }
 
+    /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+    public void notifySpace(RelSide side, MinOptMax effectiveLength) {
+        if (RelSide.BEFORE == side) {
+            if (log.isDebugEnabled()) {
+                log.debug(this + ": Space " + side + ", " 
+                        + this.effSpaceBefore + "-> " + effectiveLength);
+            }
+            this.effSpaceBefore = effectiveLength;
+        } else {
+            if (log.isDebugEnabled()) {
+                log.debug(this + ": Space " + side + ", " 
+                        + this.effSpaceAfter + "-> " + effectiveLength);
+            }
+            this.effSpaceAfter = effectiveLength;
+        }
+    }
+
+    /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+    public void notifyBorder(RelSide side, MinOptMax effectiveLength) {
+        if (effectiveLength == null) {
+            if (RelSide.BEFORE == side) {
+                this.discardBorderBefore = true;
+            } else {
+                this.discardBorderAfter = true;
+            }
+        }
+        if (log.isDebugEnabled()) {
+            log.debug(this + ": Border " + side + " -> " + effectiveLength);
+        }
+    }
+
+    /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+    public void notifyPadding(RelSide side, MinOptMax effectiveLength) {
+        if (effectiveLength == null) {
+            if (RelSide.BEFORE == side) {
+                this.discardPaddingBefore = true;
+            } else {
+                this.discardPaddingAfter = true;
+            }
+        }
+        if (log.isDebugEnabled()) {
+            log.debug(this + ": Padding " + side + " -> " + effectiveLength);
+        }
+    }
+
+    
 }
 

src/java/org/apache/fop/layoutmgr/table/TableCellLayoutManager.java

@@ -27,12 +27,14 @@ import org.apache.fop.fo.properties.CommonBorderPaddingBackground;
 import org.apache.fop.layoutmgr.AreaAdditionUtil;
 import org.apache.fop.layoutmgr.BlockLevelLayoutManager;
 import org.apache.fop.layoutmgr.BlockStackingLayoutManager;
+import org.apache.fop.layoutmgr.BreakElement;
 import org.apache.fop.layoutmgr.KnuthElement;
 import org.apache.fop.layoutmgr.KnuthGlue;
-import org.apache.fop.layoutmgr.KnuthPenalty;
 import org.apache.fop.layoutmgr.LayoutContext;
+import org.apache.fop.layoutmgr.ListElement;
 import org.apache.fop.layoutmgr.PositionIterator;
 import org.apache.fop.layoutmgr.Position;
+import org.apache.fop.layoutmgr.SpaceResolver;
 import org.apache.fop.layoutmgr.TraitSetter;
 import org.apache.fop.area.Area;
 import org.apache.fop.area.Block;
@@ -43,9 +45,9 @@ import org.apache.fop.traits.MinOptMax;
  * LayoutManager for a table-cell FO.
  * A cell contains blocks. These blocks fill the cell.
  */
-public class TableCellLayoutManager extends BlockStackingLayoutManager implements BlockLevelLayoutManager {
+public class TableCellLayoutManager extends BlockStackingLayoutManager 
+            implements BlockLevelLayoutManager {
     
-    private TableCell fobj;
     private PrimaryGridUnit gridUnit;
     
     private Block curBlockArea;
@@ -75,22 +77,27 @@ public class TableCellLayoutManager extends BlockStackingLayoutManager implement
 
     /** @return the table-cell FO */
     public TableCell getTableCell() {
-        return this.fobj;
+        return (TableCell)this.fobj;
     }
     
     private boolean isSeparateBorderModel() {
-        return fobj.isSeparateBorderModel();
+        return getTableCell().isSeparateBorderModel();
     }
     
+    /** @see org.apache.fop.layoutmgr.LayoutManager#initialize() */
     public void initialize() {
         borderAndPaddingBPD = 0;
-        borderAndPaddingBPD += fobj.getCommonBorderPaddingBackground().getBorderBeforeWidth(false);
-        borderAndPaddingBPD += fobj.getCommonBorderPaddingBackground().getBorderAfterWidth(false);
+        borderAndPaddingBPD += getTableCell()
+            .getCommonBorderPaddingBackground().getBorderBeforeWidth(false);
+        borderAndPaddingBPD += getTableCell()
+            .getCommonBorderPaddingBackground().getBorderAfterWidth(false);
         if (!isSeparateBorderModel()) {
             borderAndPaddingBPD /= 2;
         }
-        borderAndPaddingBPD += fobj.getCommonBorderPaddingBackground().getPaddingBefore(false, this);
-        borderAndPaddingBPD += fobj.getCommonBorderPaddingBackground().getPaddingAfter(false, this);
+        borderAndPaddingBPD += getTableCell().getCommonBorderPaddingBackground()
+                .getPaddingBefore(false, this);
+        borderAndPaddingBPD += getTableCell().getCommonBorderPaddingBackground()
+                .getPaddingAfter(false, this);
     }
     
     /**
@@ -115,8 +122,8 @@ public class TableCellLayoutManager extends BlockStackingLayoutManager implement
         if (!isSeparateBorderModel()) {
             iIndents /= 2;
         }
-        iIndents += fobj.getCommonBorderPaddingBackground().getPaddingStart(false, this);
-        iIndents += fobj.getCommonBorderPaddingBackground().getPaddingEnd(false, this);
+        iIndents += getTableCell().getCommonBorderPaddingBackground().getPaddingStart(false, this);
+        iIndents += getTableCell().getCommonBorderPaddingBackground().getPaddingEnd(false, this);
         return iIndents;
     }
     
@@ -130,7 +137,7 @@ public class TableCellLayoutManager extends BlockStackingLayoutManager implement
         cellIPD = referenceIPD;
         cellIPD -= getIPIndents();
         if (isSeparateBorderModel()) {
-            int borderSep = fobj.getBorderSeparation().getLengthPair()
+            int borderSep = getTableCell().getBorderSeparation().getLengthPair()
                     .getIPD().getLength().getValue(this);
             cellIPD -= borderSep;
         }
@@ -159,8 +166,7 @@ public class TableCellLayoutManager extends BlockStackingLayoutManager implement
             }
             
             if (returnedList.size() == 1
-                    && ((KnuthElement) returnedList.getFirst()).isPenalty()
-                    && ((KnuthPenalty) returnedList.getFirst()).getP() == -KnuthElement.INFINITE) {
+                    && ((ListElement)returnedList.getFirst()).isForcedBreak()) {
                 // a descendant of this block has break-before
                 if (returnList.size() == 0) {
                     // the first child (or its first child ...) has
@@ -176,6 +182,9 @@ public class TableCellLayoutManager extends BlockStackingLayoutManager implement
                 returnedList = new LinkedList();
                 wrapPositionElements(contentList, returnList);
 
+                //Space resolution
+                SpaceResolver.resolveElementList(returnList);
+                
                 return returnList;
             } else {
                 if (prevLM != null) {
@@ -189,13 +198,17 @@ public class TableCellLayoutManager extends BlockStackingLayoutManager implement
                         childLC.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING, false);
                         // add an infinite penalty to forbid a break between
                         // blocks
-                        contentList.add(new KnuthPenalty(0,
-                                KnuthElement.INFINITE, false,
-                                new Position(this), false));
+                        contentList.add(new BreakElement(
+                                new Position(this), KnuthElement.INFINITE, context));
+                        //contentList.add(new KnuthPenalty(0,
+                        //        KnuthElement.INFINITE, false,
+                        //        new Position(this), false));
                     } else if (!((KnuthElement) contentList.getLast()).isGlue()) {
                         // add a null penalty to allow a break between blocks
-                        contentList.add(new KnuthPenalty(0, 0, false,
-                                new Position(this), false));
+                        contentList.add(new BreakElement(
+                                new Position(this), 0, context));
+                        //contentList.add(new KnuthPenalty(0, 0, false,
+                        //        new Position(this), false));
                     } else {
                         // the last element in contentList is a glue;
                         // it is a feasible breakpoint, there is no need to add
@@ -207,9 +220,7 @@ public class TableCellLayoutManager extends BlockStackingLayoutManager implement
                     //Avoid NoSuchElementException below (happens with empty blocks)
                     continue;
                 }
-                if (((KnuthElement) returnedList.getLast()).isPenalty()
-                        && ((KnuthPenalty) returnedList.getLast()).getP() 
-                                == -KnuthElement.INFINITE) {
+                if (((ListElement)returnedList.getLast()).isForcedBreak()) {
                     // a descendant of this block has break-after
                     if (curLM.isFinished()) {
                         // there is no other content in this block;
@@ -220,6 +231,9 @@ public class TableCellLayoutManager extends BlockStackingLayoutManager implement
                     returnedList = new LinkedList();
                     wrapPositionElements(contentList, returnList);
 
+                    //Space resolution
+                    SpaceResolver.resolveElementList(returnList);
+                    
                     return returnList;
                 }
             }
@@ -234,6 +248,9 @@ public class TableCellLayoutManager extends BlockStackingLayoutManager implement
         returnedList = new LinkedList();
         wrapPositionElements(contentList, returnList);
         
+        //Space resolution
+        SpaceResolver.resolveElementList(returnList);
+        
         setFinished(true);
         return returnList;
     }
@@ -314,11 +331,12 @@ public class TableCellLayoutManager extends BlockStackingLayoutManager implement
                          LayoutContext layoutContext) {
         getParentArea(null);
 
-        getPSLM().addIDToPage(fobj.getId());
+        getPSLM().addIDToPage(getTableCell().getId());
 
         if (isSeparateBorderModel()) {
-            if (!emptyCell || fobj.showEmptyCells()) {
-                TraitSetter.addBorders(curBlockArea, fobj.getCommonBorderPaddingBackground(), this);
+            if (!emptyCell || getTableCell().showEmptyCells()) {
+                TraitSetter.addBorders(curBlockArea, 
+                        getTableCell().getCommonBorderPaddingBackground(), this);
             }
         } else {
             boolean[] outer = new boolean[] {
@@ -384,11 +402,11 @@ public class TableCellLayoutManager extends BlockStackingLayoutManager implement
         //Handle display-align
         int contentBPD = getContentHeight(rowHeight, gridUnit);
         if (usedBPD < contentBPD) {
-            if (fobj.getDisplayAlign() == EN_CENTER) {
+            if (getTableCell().getDisplayAlign() == EN_CENTER) {
                 Block space = new Block();
                 space.setBPD((contentBPD - usedBPD) / 2);
                 curBlockArea.addBlock(space);
-            } else if (fobj.getDisplayAlign() == EN_AFTER) {
+            } else if (getTableCell().getDisplayAlign() == EN_AFTER) {
                 Block space = new Block();
                 space.setBPD((contentBPD - usedBPD));
                 curBlockArea.addBlock(space);
@@ -401,15 +419,15 @@ public class TableCellLayoutManager extends BlockStackingLayoutManager implement
 
         // Add background after we know the BPD
         if (isSeparateBorderModel()) {
-            if (!emptyCell || fobj.showEmptyCells()) {
+            if (!emptyCell || getTableCell().showEmptyCells()) {
                 TraitSetter.addBackground(curBlockArea,
-                                          fobj.getCommonBorderPaddingBackground(),
-                                          this);
+                        getTableCell().getCommonBorderPaddingBackground(),
+                        this);
             }
         } else {
             TraitSetter.addBackground(curBlockArea,
-                                      fobj.getCommonBorderPaddingBackground(),
-                                      this);
+                    getTableCell().getCommonBorderPaddingBackground(),
+                    this);
         }
         
         flush();
@@ -434,18 +452,19 @@ public class TableCellLayoutManager extends BlockStackingLayoutManager implement
         if (curBlockArea == null) {
             curBlockArea = new Block();
             curBlockArea.addTrait(Trait.IS_REFERENCE_AREA, Boolean.TRUE);
-            TraitSetter.setProducerID(curBlockArea, fobj.getId());
+            TraitSetter.setProducerID(curBlockArea, getTableCell().getId());
             curBlockArea.setPositioning(Block.ABSOLUTE);
             int indent = 0;
             indent += startBorderWidth;
             if (!isSeparateBorderModel()) {
                 indent /= 2;
             }
-            indent += fobj.getCommonBorderPaddingBackground().getPaddingStart(false, this);
+            indent += getTableCell()
+                    .getCommonBorderPaddingBackground().getPaddingStart(false, this);
             // set position
             int halfBorderSep = 0;
             if (isSeparateBorderModel()) {
-                halfBorderSep = fobj.getBorderSeparation().getLengthPair()
+                halfBorderSep = getTableCell().getBorderSeparation().getLengthPair()
                         .getIPD().getLength().getValue(this) / 2;
             }
             int borderAdjust = 0;

src/java/org/apache/fop/layoutmgr/table/TableContentLayoutManager.java

@@ -36,6 +36,7 @@ import org.apache.fop.fo.flow.TableBody;
 import org.apache.fop.fo.flow.TableRow;
 import org.apache.fop.fo.properties.CommonBorderPaddingBackground;
 import org.apache.fop.fo.properties.LengthRangeProperty;
+import org.apache.fop.layoutmgr.BreakElement;
 import org.apache.fop.layoutmgr.ElementListObserver;
 import org.apache.fop.layoutmgr.ElementListUtils;
 import org.apache.fop.layoutmgr.KnuthBox;
@@ -44,10 +45,12 @@ import org.apache.fop.layoutmgr.KnuthPenalty;
 import org.apache.fop.layoutmgr.KnuthPossPosIter;
 import org.apache.fop.layoutmgr.LayoutContext;
 import org.apache.fop.layoutmgr.LayoutManager;
+import org.apache.fop.layoutmgr.ListElement;
 import org.apache.fop.layoutmgr.MinOptMaxUtil;
 import org.apache.fop.layoutmgr.Position;
 import org.apache.fop.layoutmgr.PositionIterator;
 import org.apache.fop.layoutmgr.TraitSetter;
+import org.apache.fop.layoutmgr.SpaceResolver.SpaceHandlingBreakPosition;
 import org.apache.fop.traits.MinOptMax;
 
 /**
@@ -199,16 +202,22 @@ public class TableContentLayoutManager implements PercentBaseContext {
             if (rowFO != null && rowFO.getBreakBefore() != Constants.EN_AUTO) {
                 log.info("break-before found");
                 if (returnList.size() > 0) {
-                    KnuthElement last = (KnuthElement)returnList.getLast();
+                    ListElement last = (ListElement)returnList.getLast();
                     if (last.isPenalty()) {
                         KnuthPenalty pen = (KnuthPenalty)last;
                         pen.setP(-KnuthPenalty.INFINITE);
                         pen.setBreakClass(rowFO.getBreakBefore());
+                    } else if (last instanceof BreakElement) {
+                        BreakElement breakPoss = (BreakElement)last;
+                        breakPoss.setPenaltyValue(-KnuthPenalty.INFINITE);
+                        breakPoss.setBreakClass(rowFO.getBreakBefore());
                     }
                 } else {
                     if (!firstBreakBeforeServed) {
-                        returnList.add(new KnuthPenalty(0, -KnuthPenalty.INFINITE, 
-                                false, rowFO.getBreakBefore(), new Position(getTableLM()), true));
+                        //returnList.add(new KnuthPenalty(0, -KnuthPenalty.INFINITE, 
+                        //        false, rowFO.getBreakBefore(), new Position(getTableLM()), true));
+                        returnList.add(new BreakElement(new Position(getTableLM()),
+                                0, -KnuthPenalty.INFINITE, rowFO.getBreakBefore(), context));
                         iter.backToPreviousRow();
                         firstBreakBeforeServed = true;
                         break;
@@ -234,12 +243,12 @@ public class TableContentLayoutManager implements PercentBaseContext {
                 log.debug("child LM (row group) signals pending keep-with-previous");
                 if (returnList.size() > 0) {
                     //Modify last penalty
-                    KnuthElement last = (KnuthElement)returnList.getLast();
+                    ListElement last = (ListElement)returnList.getLast();
                     if (last.isPenalty()) {
-                        KnuthPenalty pen = (KnuthPenalty)last;
+                        BreakElement breakPoss = (BreakElement)last;
                         //Only honor keep if there's no forced break
-                        if (!pen.isForcedBreak()) {
-                            pen.setP(KnuthPenalty.INFINITE);
+                        if (!breakPoss.isForcedBreak()) {
+                            breakPoss.setPenaltyValue(KnuthPenalty.INFINITE);
                         }
                     }
                 }
@@ -250,11 +259,15 @@ public class TableContentLayoutManager implements PercentBaseContext {
             if (rowFO != null && rowFO.getBreakAfter() != Constants.EN_AUTO) {
                 log.info("break-after found");
                 if (returnList.size() > 0) {
-                    KnuthElement last = (KnuthElement)returnList.getLast();
-                    if (last.isPenalty()) {
+                    ListElement last = (ListElement)returnList.getLast();
+                    if (last instanceof KnuthPenalty) {
                         KnuthPenalty pen = (KnuthPenalty)last;
                         pen.setP(-KnuthPenalty.INFINITE);
                         pen.setBreakClass(rowFO.getBreakAfter());
+                    } else if (last instanceof BreakElement) {
+                        BreakElement breakPoss = (BreakElement)last;
+                        breakPoss.setPenaltyValue(-KnuthPenalty.INFINITE);
+                        breakPoss.setBreakClass(rowFO.getBreakAfter());
                     }
                 }
             }
@@ -262,10 +275,9 @@ public class TableContentLayoutManager implements PercentBaseContext {
         
         if (returnList.size() > 0) {
             //Remove last penalty
-            KnuthElement last = (KnuthElement)returnList.getLast();
-            if (last.isPenalty()) {
-                KnuthPenalty pen = (KnuthPenalty)last;
-                if (!pen.isForcedBreak()) {
+            ListElement last = (ListElement)returnList.getLast();
+            if (last.isPenalty() || last instanceof BreakElement) {
+                if (!last.isForcedBreak()) {
                     //Only remove if we don't signal a forced break
                     returnList.removeLast();
                 }
@@ -461,9 +473,7 @@ public class TableContentLayoutManager implements PercentBaseContext {
                         ElementListObserver.observe(elems, "table-cell", primary.getCell().getId());
 
                         if ((elems.size() > 0) 
-                                && ((KnuthElement)elems.getLast()).isPenalty()
-                                && ((KnuthPenalty)elems.getLast()).getP() 
-                                        == -KnuthElement.INFINITE) {
+                                && ((KnuthElement)elems.getLast()).isForcedBreak()) {
                             // a descendant of this block has break-after
                             log.warn("Descendant of table-cell signals break: " 
                                     + primary.getCellLM().isFinished());
@@ -587,12 +597,24 @@ public class TableContentLayoutManager implements PercentBaseContext {
         List footerElements = null;
         Position firstPos = null;
         Position lastPos = null;
+        Position lastCheckPos = null;
         while (parentIter.hasNext()) {
             Position pos = (Position)parentIter.next();
+            if (pos instanceof SpaceHandlingBreakPosition) {
+                //This position has only been needed before addAreas was called, now we need the
+                //original one created by the layout manager.
+                pos = ((SpaceHandlingBreakPosition)pos).getOriginalBreakPosition();
+            }
+            if (pos == null) {
+                continue;
+            }
             if (firstPos == null) {
                 firstPos = pos;
             }
             lastPos = pos;
+            if (pos.getIndex() >= 0) {
+                lastCheckPos = pos;
+            }
             if (pos instanceof TableHeaderFooterPosition) {
                 TableHeaderFooterPosition thfpos = (TableHeaderFooterPosition)pos;
                 //these positions need to be unpacked
@@ -627,7 +649,7 @@ public class TableContentLayoutManager implements PercentBaseContext {
         Map markers = getTableLM().getTable().getMarkers();
         if (markers != null) {
             getTableLM().getCurrentPV().addMarkers(markers, 
-                    true, getTableLM().isFirst(firstPos), getTableLM().isLast(lastPos));
+                    true, getTableLM().isFirst(firstPos), getTableLM().isLast(lastCheckPos));
         }
         
         if (headerElements != null) {
@@ -655,7 +677,7 @@ public class TableContentLayoutManager implements PercentBaseContext {
 
         if (markers != null) {
             getTableLM().getCurrentPV().addMarkers(markers, 
-                    false, getTableLM().isFirst(firstPos), getTableLM().isLast(lastPos));
+                    false, getTableLM().isFirst(firstPos), getTableLM().isLast(lastCheckPos));
         }
     }
     

src/java/org/apache/fop/layoutmgr/table/TableLayoutManager.java

@@ -24,12 +24,14 @@ import org.apache.fop.fo.flow.TableColumn;
 import org.apache.fop.fo.properties.TableColLength;
 import org.apache.fop.layoutmgr.BlockLevelLayoutManager;
 import org.apache.fop.layoutmgr.BlockStackingLayoutManager;
+import org.apache.fop.layoutmgr.ConditionalElementListener;
 import org.apache.fop.layoutmgr.KnuthElement;
 import org.apache.fop.layoutmgr.KnuthGlue;
-import org.apache.fop.layoutmgr.KnuthPenalty;
 import org.apache.fop.layoutmgr.LayoutContext;
+import org.apache.fop.layoutmgr.ListElement;
 import org.apache.fop.layoutmgr.PositionIterator;
 import org.apache.fop.layoutmgr.Position;
+import org.apache.fop.layoutmgr.RelSide;
 import org.apache.fop.layoutmgr.TraitSetter;
 import org.apache.fop.area.Area;
 import org.apache.fop.area.Block;
@@ -50,8 +52,7 @@ import org.apache.fop.fo.FObj;
  * the render background.
  */
 public class TableLayoutManager extends BlockStackingLayoutManager 
-                implements BlockLevelLayoutManager {
-    private Table fobj;
+                implements ConditionalElementListener {
     
     private TableContentLayoutManager contentLM; 
     private ColumnSetup columns = null;
@@ -63,9 +64,12 @@ public class TableLayoutManager extends BlockStackingLayoutManager
     private double tableUnits;
     private boolean autoLayout = true;
 
-    //TODO space-before|after: handle space-resolution rules
-    private MinOptMax spaceBefore;
-    private MinOptMax spaceAfter;
+    private boolean discardBorderBefore;
+    private boolean discardBorderAfter;
+    private boolean discardPaddingBefore;
+    private boolean discardPaddingAfter;
+    private MinOptMax effSpaceBefore;
+    private MinOptMax effSpaceAfter;
     
     /**
      * Create a new table layout manager.
@@ -73,13 +77,12 @@ public class TableLayoutManager extends BlockStackingLayoutManager
      */
     public TableLayoutManager(Table node) {
         super(node);
-        fobj = node;
         this.columns = new ColumnSetup(node);
     }
 
     /** @return the table FO */
     public Table getTable() {
-        return this.fobj;
+        return (Table)this.fobj;
     }
     
     /**
@@ -91,19 +94,31 @@ public class TableLayoutManager extends BlockStackingLayoutManager
     
     /** @see org.apache.fop.layoutmgr.LayoutManager#initialize() */
     public void initialize() {
-        spaceBefore = new SpaceVal(fobj.getCommonMarginBlock().spaceBefore, this).getSpace();
-        spaceAfter = new SpaceVal(fobj.getCommonMarginBlock().spaceAfter, this).getSpace();
+        foSpaceBefore = new SpaceVal(
+                getTable().getCommonMarginBlock().spaceBefore, this).getSpace();
+        foSpaceAfter = new SpaceVal(
+                getTable().getCommonMarginBlock().spaceAfter, this).getSpace();
         
-        if (!fobj.isAutoLayout() 
-                && fobj.getInlineProgressionDimension().getOptimum(this).getEnum() != EN_AUTO) {
+        if (!getTable().isAutoLayout() 
+                && getTable().getInlineProgressionDimension().getOptimum(this).getEnum() 
+                    != EN_AUTO) {
             autoLayout = false;
         }
     }
 
+    private void resetSpaces() {
+        this.discardBorderBefore = false;        
+        this.discardBorderAfter = false;        
+        this.discardPaddingBefore = false;        
+        this.discardPaddingAfter = false;
+        this.effSpaceBefore = foSpaceBefore;
+        this.effSpaceAfter = foSpaceAfter;
+    }
+    
     private int getIPIndents() {
         int iIndents = 0;
-        iIndents += fobj.getCommonMarginBlock().startIndent.getValue(this);
-        iIndents += fobj.getCommonMarginBlock().endIndent.getValue(this);
+        iIndents += getTable().getCommonMarginBlock().startIndent.getValue(this);
+        iIndents += getTable().getCommonMarginBlock().endIndent.getValue(this);
         return iIndents;
     }
     
@@ -114,7 +129,7 @@ public class TableLayoutManager extends BlockStackingLayoutManager
         
         if (!bBreakBeforeServed) {
             try {
-                if (addKnuthElementsForBreakBefore(returnList)) {
+                if (addKnuthElementsForBreakBefore(returnList, context)) {
                     return returnList;
                 }
             } finally {
@@ -125,12 +140,12 @@ public class TableLayoutManager extends BlockStackingLayoutManager
         referenceBPD = context.getStackLimit().opt;
         referenceIPD = context.getRefIPD();
 
-        if (fobj.getInlineProgressionDimension().getOptimum(this).getEnum() != EN_AUTO) {
-            referenceIPD = fobj.getInlineProgressionDimension().getOptimum(this)
+        if (getTable().getInlineProgressionDimension().getOptimum(this).getEnum() != EN_AUTO) {
+            referenceIPD = getTable().getInlineProgressionDimension().getOptimum(this)
                     .getLength().getValue(this);
             contentIPD = referenceIPD;
         } else {
-            if (!fobj.isAutoLayout()) {
+            if (!getTable().isAutoLayout()) {
                 log.info("table-layout=\"fixed\" and width=\"auto\", "
                         + "but auto-layout not supported " 
                         + "=> assuming width=\"100%\"");
@@ -141,15 +156,6 @@ public class TableLayoutManager extends BlockStackingLayoutManager
             log.warn("Allocated IPD exceeds available reference IPD");
         }
 
-        MinOptMax stackSize = new MinOptMax();
-        //Add spacing
-        if (spaceAfter != null) {
-            stackSize.add(spaceAfter);
-        }
-        if (spaceBefore != null) {
-            stackSize.add(spaceBefore);
-        }
-
         // either works out table of column widths or if proportional-column-width function
         // is used works out total factor, so that value of single unit can be computed.
         int sumCols = 0;
@@ -172,16 +178,28 @@ public class TableLayoutManager extends BlockStackingLayoutManager
             }
         }
 
+        addKnuthElementsForSpaceBefore(returnList, alignment);
+        
+        if (getTable().isSeparateBorderModel()) {
+            addKnuthElementsForBorderPaddingBefore(returnList, !firstVisibleMarkServed);
+            firstVisibleMarkServed = true;
+        }
+
+        //Spaces, border and padding to be repeated at each break
+        addPendingMarks(context);
+
         LinkedList returnedList = null;
         LinkedList contentList = new LinkedList();
         //Position returnPosition = new NonLeafPosition(this, null);
         //Body prevLM = null;
 
         LayoutContext childLC = new LayoutContext(0);
+        /*
         childLC.setStackLimit(
               MinOptMax.subtract(context.getStackLimit(),
-                                 stackSize));
+                                 stackSize));*/
         childLC.setRefIPD(context.getRefIPD());
+        childLC.copyPendingMarksFrom(context);
 
         if (contentLM == null) {
             contentLM = new TableContentLayoutManager(this);
@@ -199,14 +217,13 @@ public class TableLayoutManager extends BlockStackingLayoutManager
         //Set index values on elements coming from the content LM
         Iterator iter = returnedList.iterator();
         while (iter.hasNext()) {
-            KnuthElement el = (KnuthElement)iter.next();
+            ListElement el = (ListElement)iter.next();
             notifyPos(el.getPosition());
         }
         log.debug(returnedList);
         
         if (returnedList.size() == 1
-                && ((KnuthElement) returnedList.getFirst()).isPenalty()
-                && ((KnuthPenalty) returnedList.getFirst()).getP() == -KnuthElement.INFINITE) {
+                && ((ListElement)returnedList.getFirst()).isForcedBreak()) {
             // a descendant of this block has break-before
             if (returnList.size() == 0) {
                 // the first child (or its first child ...) has
@@ -250,8 +267,7 @@ public class TableLayoutManager extends BlockStackingLayoutManager
             }*/
             contentList.addAll(returnedList);
             if (returnedList.size() > 0) {
-                if (((KnuthElement) returnedList.getLast()).isPenalty()
-                        && ((KnuthPenalty) returnedList.getLast()).getP() == -KnuthElement.INFINITE) {
+                if (((ListElement)returnedList.getLast()).isForcedBreak()) {
                     // a descendant of this block has break-after
                     if (false /*curLM.isFinished()*/) {
                         // there is no other content in this block;
@@ -267,8 +283,13 @@ public class TableLayoutManager extends BlockStackingLayoutManager
             }
         }
         wrapPositionElements(contentList, returnList);
-        addKnuthElementsForBreakAfter(returnList);
+        if (getTable().isSeparateBorderModel()) {
+            addKnuthElementsForBorderPaddingAfter(returnList, true);
+        }
+        addKnuthElementsForSpaceAfter(returnList, alignment);
+        addKnuthElementsForBreakAfter(returnList, context);
         setFinished(true);
+        resetSpaces();
         return returnList;
     }
     
@@ -282,14 +303,9 @@ public class TableLayoutManager extends BlockStackingLayoutManager
     public void addAreas(PositionIterator parentIter,
                          LayoutContext layoutContext) {
         getParentArea(null);
-        getPSLM().addIDToPage(fobj.getId());
+        getPSLM().addIDToPage(getTable().getId());
 
-        // if adjusted space before
-        double adjust = layoutContext.getSpaceAdjust();
-        addBlockSpacing(adjust, spaceBefore);
-        spaceBefore = null;
-
-        int startXOffset = fobj.getCommonMarginBlock().startIndent.getValue(this);
+        int startXOffset = getTable().getCommonMarginBlock().startIndent.getValue(this);
         
         // add column, body then row areas
 
@@ -305,25 +321,29 @@ public class TableLayoutManager extends BlockStackingLayoutManager
 
         curBlockArea.setBPD(tableHeight);
 
-        if (fobj.isSeparateBorderModel()) {
-            TraitSetter.addBorders(curBlockArea, fobj.getCommonBorderPaddingBackground(), this);
+        if (getTable().isSeparateBorderModel()) {
+            TraitSetter.addBorders(curBlockArea, 
+                    getTable().getCommonBorderPaddingBackground(), 
+                    discardBorderBefore, discardBorderAfter, false, false, this);
+            TraitSetter.addPadding(curBlockArea, 
+                    getTable().getCommonBorderPaddingBackground(), 
+                    discardPaddingBefore, discardPaddingAfter, false, false, this);
         }
         TraitSetter.addBackground(curBlockArea, 
-                fobj.getCommonBorderPaddingBackground(),
+                getTable().getCommonBorderPaddingBackground(),
                 this);
         TraitSetter.addMargins(curBlockArea,
-                fobj.getCommonBorderPaddingBackground(), 
-                fobj.getCommonMarginBlock(),
+                getTable().getCommonBorderPaddingBackground(), 
+                getTable().getCommonMarginBlock(),
                 this);
         TraitSetter.addBreaks(curBlockArea, 
-                fobj.getBreakBefore(), fobj.getBreakAfter());
+                getTable().getBreakBefore(), getTable().getBreakAfter());
+        TraitSetter.addSpaceBeforeAfter(curBlockArea, layoutContext.getSpaceAdjust(), 
+                effSpaceBefore, effSpaceAfter);
 
         flush();
 
-        // if adjusted space after
-        addBlockSpacing(adjust, spaceAfter);
-
-        //bodyBreaks.clear();
+        resetSpaces();
         curBlockArea = null;
     }
 
@@ -378,17 +398,13 @@ public class TableLayoutManager extends BlockStackingLayoutManager
         }
     }
 
-    /**
-     * @see org.apache.fop.layoutmgr.BlockLevelLayoutManager#negotiateBPDAdjustment(int, org.apache.fop.layoutmgr.KnuthElement)
-     */
+    /** @see org.apache.fop.layoutmgr.BlockLevelLayoutManager */
     public int negotiateBPDAdjustment(int adj, KnuthElement lastElement) {
         // TODO Auto-generated method stub
         return 0;
     }
 
-    /**
-     * @see org.apache.fop.layoutmgr.BlockLevelLayoutManager#discardSpace(org.apache.fop.layoutmgr.KnuthGlue)
-     */
+    /** @see org.apache.fop.layoutmgr.BlockLevelLayoutManager */
     public void discardSpace(KnuthGlue spaceGlue) {
         // TODO Auto-generated method stub
         
@@ -400,24 +416,24 @@ public class TableLayoutManager extends BlockStackingLayoutManager
     public boolean mustKeepTogether() {
         //TODO Keeps will have to be more sophisticated sooner or later
         return ((BlockLevelLayoutManager)getParent()).mustKeepTogether() 
-                || !fobj.getKeepTogether().getWithinPage().isAuto()
-                || !fobj.getKeepTogether().getWithinColumn().isAuto();
+                || !getTable().getKeepTogether().getWithinPage().isAuto()
+                || !getTable().getKeepTogether().getWithinColumn().isAuto();
     }
 
     /**
      * @see org.apache.fop.layoutmgr.BlockLevelLayoutManager#mustKeepWithPrevious()
      */
     public boolean mustKeepWithPrevious() {
-        return !fobj.getKeepWithPrevious().getWithinPage().isAuto()
-                || !fobj.getKeepWithPrevious().getWithinColumn().isAuto();
+        return !getTable().getKeepWithPrevious().getWithinPage().isAuto()
+                || !getTable().getKeepWithPrevious().getWithinColumn().isAuto();
     }
 
     /**
      * @see org.apache.fop.layoutmgr.BlockLevelLayoutManager#mustKeepWithNext()
      */
     public boolean mustKeepWithNext() {
-        return !fobj.getKeepWithNext().getWithinPage().isAuto()
-                || !fobj.getKeepWithNext().getWithinColumn().isAuto();
+        return !getTable().getKeepWithNext().getWithinPage().isAuto()
+                || !getTable().getKeepWithNext().getWithinColumn().isAuto();
     }
 
     // --------- Property Resolution related functions --------- //
@@ -461,4 +477,49 @@ public class TableLayoutManager extends BlockStackingLayoutManager
         return referenceBPD;
     }
     
+    /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+    public void notifySpace(RelSide side, MinOptMax effectiveLength) {
+        if (RelSide.BEFORE == side) {
+            if (log.isDebugEnabled()) {
+                log.debug(this + ": Space " + side + ", " 
+                        + this.effSpaceBefore + "-> " + effectiveLength);
+            }
+            this.effSpaceBefore = effectiveLength;
+        } else {
+            if (log.isDebugEnabled()) {
+                log.debug(this + ": Space " + side + ", " 
+                        + this.effSpaceAfter + "-> " + effectiveLength);
+            }
+            this.effSpaceAfter = effectiveLength;
+        }
+    }
+
+    /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+    public void notifyBorder(RelSide side, MinOptMax effectiveLength) {
+        if (effectiveLength == null) {
+            if (RelSide.BEFORE == side) {
+                this.discardBorderBefore = true;
+            } else {
+                this.discardBorderAfter = true;
+            }
+        }
+        if (log.isDebugEnabled()) {
+            log.debug(this + ": Border " + side + " -> " + effectiveLength);
+        }
+    }
+
+    /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+    public void notifyPadding(RelSide side, MinOptMax effectiveLength) {
+        if (effectiveLength == null) {
+            if (RelSide.BEFORE == side) {
+                this.discardPaddingBefore = true;
+            } else {
+                this.discardPaddingAfter = true;
+            }
+        }
+        if (log.isDebugEnabled()) {
+            log.debug(this + ": Padding " + side + " -> " + effectiveLength);
+        }
+    }
+    
 }

src/java/org/apache/fop/layoutmgr/table/TableStepper.java

@@ -27,6 +27,7 @@ import org.apache.commons.logging.LogFactory;
 import org.apache.fop.fo.Constants;
 import org.apache.fop.fo.flow.TableRow;
 import org.apache.fop.fo.properties.CommonBorderPaddingBackground;
+import org.apache.fop.layoutmgr.BreakElement;
 import org.apache.fop.layoutmgr.ElementListUtils;
 import org.apache.fop.layoutmgr.KnuthBox;
 import org.apache.fop.layoutmgr.KnuthElement;
@@ -162,7 +163,7 @@ public class TableStepper {
     private void setupElementList(int column) {
         GridUnit gu = getActiveGridUnit(column);
         EffRow row = getActiveRow();
-        if (gu.isEmpty()){
+        if (gu.isEmpty()) {
             elementLists[column] = null;
             start[column] = 0;
             end[column] = -1;
@@ -296,14 +297,6 @@ public class TableStepper {
             
             //Create elements for step
             int effPenaltyLen = penaltyLen;
-            if (isSeparateBorderModel()) {
-                CommonBorderPaddingBackground borders 
-                    = getTableLM().getTable().getCommonBorderPaddingBackground(); 
-                effPenaltyLen += borders.getBorderBeforeWidth(false); 
-                effPenaltyLen += borders.getBorderAfterWidth(false); 
-                effPenaltyLen += borders.getPaddingBefore(false, getTableLM()); 
-                effPenaltyLen += borders.getPaddingAfter(false, getTableLM()); 
-            }
             TableContentPosition tcpos = new TableContentPosition(getTableLM(), 
                     gridUnitParts, getActiveRow());
             if (returnList.size() == 0) {
@@ -345,7 +338,8 @@ public class TableStepper {
                 p = -KnuthPenalty.INFINITE; //Overrides any keeps (see 4.8 in XSL 1.0)
                 clearBreakCondition();
             }
-            returnList.add(new KnuthPenalty(effPenaltyLen, p, false, penaltyPos, false));
+            //returnList.add(new KnuthPenalty(effPenaltyLen, p, false, penaltyPos, false));
+            returnList.add(new BreakElement(penaltyPos, effPenaltyLen, p, 0, context));
 
             log.debug("step=" + step + " (+" + increase + ")"
                     + " box=" + boxLen 
@@ -364,7 +358,7 @@ public class TableStepper {
             context.setFlags(LayoutContext.KEEP_WITH_NEXT_PENDING);
         }
         if (isBreakCondition()) {
-            ((KnuthPenalty)returnList.getLast()).setP(-KnuthPenalty.INFINITE);
+            ((BreakElement)returnList.getLast()).setPenaltyValue(-KnuthPenalty.INFINITE);
         }
         lastTCPos.setFlag(TableContentPosition.LAST_IN_ROWGROUP, true);
         return returnList;

src/java/org/apache/fop/render/AbstractRenderer.java

@@ -530,8 +530,9 @@ public abstract class AbstractRenderer
             int saveBP = currentBPPosition;
 
             if (block.getPositioning() == Block.ABSOLUTE) {
-                currentIPPosition = containingIPPosition + block.getXOffset();
-                currentBPPosition = containingBPPosition + block.getYOffset();
+                currentIPPosition += block.getXOffset();
+                currentBPPosition += block.getYOffset();
+                currentBPPosition += block.getSpaceBefore();
 
                 handleBlockTraits(block);
 
@@ -545,6 +546,7 @@ public abstract class AbstractRenderer
                 // relative blocks are offset
                 currentIPPosition += block.getXOffset();
                 currentBPPosition += block.getYOffset();
+                currentBPPosition += block.getSpaceBefore();
 
                 handleBlockTraits(block);
 

src/java/org/apache/fop/traits/MinOptMax.java

@@ -162,6 +162,11 @@ public class MinOptMax implements java.io.Serializable, Cloneable {
         opt -= op.opt;
         max -= op.min;
     }
+    
+    /** @return true if this instance represents a zero-width length (min=opt=max=0) */
+    public boolean isNonZero() {
+        return (min != 0 || max != 0);
+    }
 
     /** @see java.lang.Object#toString() */
     public String toString() {

test/fotree/testcases/shorthand-prop-mix.fo

@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Copyright 2005 The Apache Software Foundation
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<!-- $Id$ -->
+<!-- This test verifies what happens if shorthand and normal properties are mixed. -->
+<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:test="http://xmlgraphics.apache.org/fop/test">
+  <fo:layout-master-set>
+    <fo:simple-page-master master-name="A4" page-height="29.7cm" page-width="21cm" margin="2cm">
+      <fo:region-body/>
+    </fo:simple-page-master>
+  </fo:layout-master-set>
+  <fo:page-sequence master-reference="A4">
+    <fo:flow flow-name="xsl-region-body">
+      <fo:block border="solid 5pt"
+            border-before-width.conditionality="retain" border-after-width.conditionality="retain" 
+            padding="5pt"
+            padding-before.conditionality="retain" padding-after.conditionality="retain">
+        <test:assert property="border-before-width" expected="CondLength[1000mpt, RETAIN]"/>
+        <test:assert property="border-after-width" expected="CondLength[1000mpt, RETAIN]"/>
+        <test:assert property="padding-before" expected="CondLength[0mpt, RETAIN]"/>
+        <test:assert property="padding-after" expected="CondLength[0mpt, RETAIN]"/>
+        <!-- Discussion: see http://marc.theaimsgroup.com/?t=112607409300001&r=1&w=2 -->
+        <fo:block background-color="yellow">Hello World!</fo:block>
+        <fo:block>Hello World!</fo:block>
+        <fo:block>Hello World!</fo:block>
+        <fo:block background-color="orange">Hello World!</fo:block>
+      </fo:block>
+    </fo:flow>
+  </fo:page-sequence>
+</fo:root>

test/fotree/testcases/table_border-separation.fo

@@ -0,0 +1,79 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Copyright 2005 The Apache Software Foundation
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<!-- $Id$ -->
+<!-- This test verifies the correct values of border-separation and its shorthand, border-spacing. -->
+<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:test="http://xmlgraphics.apache.org/fop/test">
+  <fo:layout-master-set>
+    <fo:simple-page-master master-name="A4" page-height="29.7cm" page-width="21cm">
+      <fo:region-body/>
+    </fo:simple-page-master>
+  </fo:layout-master-set>
+  <fo:page-sequence master-reference="A4">
+    <fo:flow flow-name="xsl-region-body">
+      <fo:table table-layout="fixed" border-collapse="separate" border-spacing="5pt 2pt">
+        <test:assert property="border-separation.inline-progression-direction" expected="5000mpt"/>
+        <test:assert property="border-separation.block-progression-direction" expected="2000mpt"/>
+        <fo:table-column column-width="160pt"/>
+        <fo:table-column column-width="160pt"/>
+        <fo:table-body>
+          <fo:table-row>
+            <fo:table-cell>
+              <fo:block>cell1</fo:block>
+            </fo:table-cell>
+            <fo:table-cell border="solid 5pt black">
+              <fo:block>cell2</fo:block>
+            </fo:table-cell>
+          </fo:table-row>
+          <fo:table-row>
+            <fo:table-cell border="solid 5pt">
+              <fo:block>cell3</fo:block>
+            </fo:table-cell>
+            <fo:table-cell height="20pt" border="solid 10pt red">
+              <fo:block>cell4</fo:block>
+            </fo:table-cell>
+          </fo:table-row>
+        </fo:table-body>
+      </fo:table>
+      <fo:table table-layout="fixed" border-collapse="separate" 
+            border-separation.inline-progression-direction="5pt" 
+            border-separation.block-progression-direction="2pt">
+        <test:assert property="border-separation.inline-progression-direction" expected="5000mpt"/>
+        <test:assert property="border-separation.block-progression-direction" expected="2000mpt"/>
+        <fo:table-column column-width="160pt"/>
+        <fo:table-column column-width="160pt"/>
+        <fo:table-body start-indent="0pt" end-indent="0pt">
+          <fo:table-row>
+            <fo:table-cell>
+              <fo:block>cell1</fo:block>
+            </fo:table-cell>
+            <fo:table-cell border="solid 5pt black">
+              <fo:block>cell2</fo:block>
+            </fo:table-cell>
+          </fo:table-row>
+          <fo:table-row>
+            <fo:table-cell border="solid 5pt">
+              <fo:block>cell3</fo:block>
+            </fo:table-cell>
+            <fo:table-cell height="20pt" border="solid 10pt red">
+              <fo:block>cell4</fo:block>
+            </fo:table-cell>
+          </fo:table-row>
+        </fo:table-body>
+      </fo:table>
+    </fo:flow>
+  </fo:page-sequence>
+</fo:root>

test/java/org/apache/fop/fotreetest/ext/AssertElement.java

@@ -23,6 +23,7 @@ import org.apache.fop.apps.FOPException;
 import org.apache.fop.fo.FONode;
 import org.apache.fop.fo.FOPropertyMapping;
 import org.apache.fop.fo.PropertyList;
+import org.apache.fop.fo.properties.LengthPairProperty;
 import org.apache.fop.fo.properties.Property;
 import org.apache.fop.fotreetest.ResultCollector;
 
@@ -51,13 +52,29 @@ public class AssertElement extends TestObj {
         //super.processNode(elementName, locator, attlist, propertyList);
 
         ResultCollector collector = ResultCollector.getInstance();
-        String propName = attlist.getValue("property"); 
+        String propName = attlist.getValue("property");
+        String component = null;
+        int dotIndex = propName.indexOf('.');
+        if (dotIndex >= 0) {
+            component = propName.substring(dotIndex + 1);
+            propName = propName.substring(0, dotIndex);
+        }
         int propID = FOPropertyMapping.getPropertyId(propName);
         if (propID < 0) {
             collector.notifyException(new IllegalArgumentException(
                     "Property not found: " + propName));
         } else {
-            Property prop = propertyList.getParentPropertyList().get(propID);
+            Property prop;
+            prop = propertyList.getParentPropertyList().get(propID);
+            if (component != null) {
+                //Access subcomponent
+                Property mainProp = prop;
+                prop = null;
+                LengthPairProperty lpp = mainProp.getLengthPair();
+                if (lpp != null) {
+                    prop = lpp.getComponent(FOPropertyMapping.getSubPropertyId(component));
+                }
+            }
             String s = String.valueOf(prop);
             String expected = attlist.getValue("expected");
             if (!expected.equals(s)) {

test/java/org/apache/fop/logging/LoggingElementListObserver.java

@@ -23,7 +23,7 @@ import java.util.ListIterator;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
-import org.apache.fop.layoutmgr.KnuthElement;
+import org.apache.fop.layoutmgr.ListElement;
 import org.apache.fop.layoutmgr.ElementListObserver.Observer;
 
 /**
@@ -49,9 +49,9 @@ public class LoggingElementListObserver implements Observer {
             return;
         }
         ListIterator tempIter = elementList.listIterator();
-        KnuthElement temp;
+        ListElement temp;
         while (tempIter.hasNext()) {
-            temp = (KnuthElement) tempIter.next();
+            temp = (ListElement) tempIter.next();
             if (temp.isBox()) {
                 log.debug(tempIter.previousIndex()
                         + ") " + temp);

test/layoutengine/disabled-testcases.txt

@@ -1,11 +1,12 @@
 block-container_reference-orientation_bug36391.xml
+block-container_space-before_space-after_3.xml
 block_font-stretch.xml
 block_padding_2.xml
-block_space-before_space-after_2.xml
-block_space-before_space-after_3.xml
+block_space-before_space-after_8.xml
 block_word-spacing.xml
 block_word-spacing_text-align_justify.xml
 external-graphic_oversized.xml
+footnote_space-resolution.xml
 inline-block_keep-together.xml
 inline_block_nested_3.xml
 inline-container_block_nested.xml
@@ -16,7 +17,6 @@ inline_word-spacing_text-align_justify.xml
 leader-alignment.xml
 list-block_keep-with-previous.xml
 list-item_block_keep-with-previous.xml
-list-item_space-before_space-after_2.xml
 page-breaking_4.xml
 page-breaking_6.xml
 page-height_indefinite_simple.xml
@@ -31,6 +31,7 @@ table_border-collapse_collapse_1.xml
 table_border-collapse_collapse_2.xml
 table_border_padding.xml
 table-cell_block_keep-with-previous.xml
+table-cell_border_padding_conditionality.xml
 table-column_first-row-width.xml
 table-header_background-image.xml
 table-row_keep-with-previous.xml

test/layoutengine/testcases/block-container_display-align_space-before.xml

@@ -52,77 +52,77 @@
   </fo>
   <checks>
     <!-- first block-container -->
-    <true xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@is-viewport-area"/>
-    <eval expected="[1.0 0.0 0.0 1.0 0.0 0.0]" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@ctm"/>
-    <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@ipd"/>
-    <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@ipda"/>
-    <eval expected="80000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@bpd"/>
-    <eval expected="80000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@bpda"/>
+    <true xpath="//flow/block[1]/@is-viewport-area"/>
+    <eval expected="[1.0 0.0 0.0 1.0 0.0 0.0]" xpath="//flow/block[1]/@ctm"/>
+    <eval expected="120000" xpath="//flow/block[1]/@ipd"/>
+    <eval expected="120000" xpath="//flow/block[1]/@ipda"/>
+    <eval expected="80000" xpath="//flow/block[1]/@bpd"/>
+    <eval expected="80000" xpath="//flow/block[1]/@bpda"/>
     <!--   -> reference area -->
-    <true xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@is-reference-area"/>
-    <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@ipd"/>
-    <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@ipda"/>
-    <eval expected="28800" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@bpd"/>
-    <eval expected="28800" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@bpda"/>
+    <true xpath="//flow/block[1]/block[1]/@is-reference-area"/>
+    <eval expected="120000" xpath="//flow/block[1]/block[1]/@ipd"/>
+    <eval expected="120000" xpath="//flow/block[1]/block[1]/@ipda"/>
+    <eval expected="28800" xpath="//flow/block[1]/block[1]/@bpd"/>
+    <eval expected="28800" xpath="//flow/block[1]/block[1]/@bpda"/>
 
     <!-- space-before of second block-container -->
-    <eval expected="10000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@bpda"/>
+    <eval expected="10000" xpath="//flow/block[2]/@space-before"/>
     
     <!-- second block-container -->
-    <true xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/@is-viewport-area"/>
-    <eval expected="[0.0 -1.0 1.0 0.0 0.0 80000.0]" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/@ctm"/>
-    <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/@ipd"/>
-    <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/@ipda"/>
-    <eval expected="80000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/@bpd"/>
-    <eval expected="80000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/@bpda"/>
+    <true xpath="//flow/block[2]/@is-viewport-area"/>
+    <eval expected="[0.0 -1.0 1.0 0.0 0.0 80000.0]" xpath="//flow/block[2]/@ctm"/>
+    <eval expected="120000" xpath="//flow/block[2]/@ipd"/>
+    <eval expected="120000" xpath="//flow/block[2]/@ipda"/>
+    <eval expected="80000" xpath="//flow/block[2]/@bpd"/>
+    <eval expected="100000" xpath="//flow/block[2]/@bpda"/>
     <!--   -> reference area -->
-    <true xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/block[1]/@is-reference-area"/>
-    <eval expected="80000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/block[1]/@ipd"/>
-    <eval expected="80000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/block[1]/@ipda"/>
-    <eval expected="43200" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/block[1]/@bpd"/>
-    <eval expected="43200" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/block[1]/@bpda"/>
+    <true xpath="//flow/block[2]/block[1]/@is-reference-area"/>
+    <eval expected="80000" xpath="//flow/block[2]/block[1]/@ipd"/>
+    <eval expected="80000" xpath="//flow/block[2]/block[1]/@ipda"/>
+    <eval expected="43200" xpath="//flow/block[2]/block[1]/@bpd"/>
+    <eval expected="43200" xpath="//flow/block[2]/block[1]/@bpda"/>
 
     <!-- space-after of second block-container -->
-    <eval expected="10000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@bpda"/>
+    <eval expected="10000" xpath="//flow/block[2]/@space-after"/>
 
     <!-- third block-container -->
-    <true xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@is-viewport-area"/>
-    <eval expected="[-1.0 -0.0 0.0 -1.0 120000.0 80000.0]" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@ctm"/>
-    <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@ipd"/>
-    <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@ipda"/>
-    <eval expected="80000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@bpd"/>
-    <eval expected="80000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@bpda"/>
+    <true xpath="//flow/block[3]/@is-viewport-area"/>
+    <eval expected="[-1.0 -0.0 0.0 -1.0 120000.0 80000.0]" xpath="//flow/block[3]/@ctm"/>
+    <eval expected="120000" xpath="//flow/block[3]/@ipd"/>
+    <eval expected="120000" xpath="//flow/block[3]/@ipda"/>
+    <eval expected="80000" xpath="//flow/block[3]/@bpd"/>
+    <eval expected="80000" xpath="//flow/block[3]/@bpda"/>
     <!--   -> reference area -->
-    <true xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/block[1]/@is-reference-area"/>
-    <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/block[1]/@ipd"/>
-    <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/block[1]/@ipda"/>
-    <eval expected="61600" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/block[1]/@bpd"/>
-    <eval expected="61600" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/block[1]/@bpda"/>
+    <true xpath="//flow/block[3]/block[1]/@is-reference-area"/>
+    <eval expected="120000" xpath="//flow/block[3]/block[1]/@ipd"/>
+    <eval expected="120000" xpath="//flow/block[3]/block[1]/@ipda"/>
+    <eval expected="61600" xpath="//flow/block[3]/block[1]/@bpd"/>
+    <eval expected="61600" xpath="//flow/block[3]/block[1]/@bpda"/>
     <!-- contents (spacer first, then three lines) -->
-    <eval expected="18400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/block[1]/block[1]/@bpda"/>
-    <eval expected="28800" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/block[1]/block[2]/@bpda"/>
-    <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/block[1]/block[3]/@bpda"/>
+    <eval expected="18400" xpath="//flow/block[3]/block[1]/block[1]/@bpda"/>
+    <eval expected="28800" xpath="//flow/block[3]/block[1]/block[2]/@bpda"/>
+    <eval expected="14400" xpath="//flow/block[3]/block[1]/block[3]/@bpda"/>
 
     <!-- space-before of fourth block-container -->
-    <eval expected="10000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@bpda"/>
+    <eval expected="10000" xpath="//flow/block[4]/@space-before"/>
     
     <!-- fourth block-container -->
-    <true xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/@is-viewport-area"/>
-    <eval expected="[0.0 1.0 -1.0 0.0 120000.0 0.0]" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/@ctm"/>
-    <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/@ipd"/>
-    <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/@ipda"/>
-    <eval expected="80000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/@bpd"/>
-    <eval expected="80000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/@bpda"/>
+    <true xpath="//flow/block[4]/@is-viewport-area"/>
+    <eval expected="[0.0 1.0 -1.0 0.0 120000.0 0.0]" xpath="//flow/block[4]/@ctm"/>
+    <eval expected="120000" xpath="//flow/block[4]/@ipd"/>
+    <eval expected="120000" xpath="//flow/block[4]/@ipda"/>
+    <eval expected="80000" xpath="//flow/block[4]/@bpd"/>
+    <eval expected="90000" xpath="//flow/block[4]/@bpda"/>
     <!--   -> reference area -->
-    <true xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/block[1]/@is-reference-area"/>
-    <eval expected="80000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/block[1]/@ipd"/>
-    <eval expected="80000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/block[1]/@ipda"/>
-    <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/block[1]/@bpd"/>
-    <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/block[1]/@bpda"/>
+    <true xpath="//flow/block[4]/block[1]/@is-reference-area"/>
+    <eval expected="80000" xpath="//flow/block[4]/block[1]/@ipd"/>
+    <eval expected="80000" xpath="//flow/block[4]/block[1]/@ipda"/>
+    <eval expected="120000" xpath="//flow/block[4]/block[1]/@bpd"/>
+    <eval expected="120000" xpath="//flow/block[4]/block[1]/@bpda"/>
     <!-- contents (spacer first, then three lines) -->
-    <eval expected="76800" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/block[1]/block[1]/@bpda"/>
-    <eval expected="28800" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/block[1]/block[2]/@bpda"/>
-    <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/block[1]/block[3]/@bpda"/>
+    <eval expected="76800" xpath="//flow/block[4]/block[1]/block[1]/@bpda"/>
+    <eval expected="28800" xpath="//flow/block[4]/block[1]/block[2]/@bpda"/>
+    <eval expected="14400" xpath="//flow/block[4]/block[1]/block[3]/@bpda"/>
 
   </checks>
 </testcase>

test/layoutengine/testcases/block-container_space-before_space-after_1.xml

@@ -0,0 +1,160 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Copyright 2005 The Apache Software Foundation
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<!-- $Id$ -->
+<testcase>
+  <info>
+    <p>
+      This test checks space properties on block-container.
+    </p>
+  </info>
+  <fo>
+    <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+      <fo:layout-master-set>
+        <fo:simple-page-master master-name="normal" page-width="5in" page-height="5in">
+          <fo:region-body/>
+        </fo:simple-page-master>
+      </fo:layout-master-set>
+      <fo:page-sequence master-reference="normal" id="retain">
+        <fo:flow flow-name="xsl-region-body">
+          <fo:block-container space-before.optimum="20pt" space-before.conditionality="retain" space-after.optimum="10pt" space-after.conditionality="retain">
+            <fo:block text-align="justify">
+In olden times when wishing still helped one, there lived a king whose daughters 
+were all beautiful; and the youngest was so beautiful that the sun itself, which 
+has seen so much, was astonished whenever it shone in her face. Close by the king's 
+castle lay a great dark forest, and under an old lime-tree in the forest was a well, 
+and when the day was very warm, the king's child went out into the forest and sat 
+down by the side of the cool fountain; and when she was bored she took a golden ball, 
+and threw it up on high and caught it; and this ball was her favorite plaything.
+            </fo:block>
+          </fo:block-container>
+          <fo:block space-before.optimum="10pt" space-before.conditionality="retain" space-after.optimum="20pt" space-after.conditionality="retain">
+Two blocks, testing conditionality="retain".
+          </fo:block>
+        </fo:flow>
+      </fo:page-sequence>
+      <fo:page-sequence master-reference="normal" id="discard">
+        <fo:flow flow-name="xsl-region-body">
+          <fo:block-container space-before.optimum="20pt" space-before.conditionality="discard" space-after.optimum="10pt" space-after.conditionality="discard">
+            <fo:block text-align="justify">
+In olden times when wishing still helped one, there lived a king whose daughters 
+were all beautiful; and the youngest was so beautiful that the sun itself, which 
+has seen so much, was astonished whenever it shone in her face. Close by the king's 
+castle lay a great dark forest, and under an old lime-tree in the forest was a well, 
+and when the day was very warm, the king's child went out into the forest and sat 
+down by the side of the cool fountain; and when she was bored she took a golden ball, 
+and threw it up on high and caught it; and this ball was her favorite plaything.
+            </fo:block>
+          </fo:block-container>
+          <fo:block space-before.optimum="10pt" space-before.conditionality="discard" space-after.optimum="20pt" space-after.conditionality="discard">
+Two blocks, testing conditionality="discard".
+          </fo:block>
+        </fo:flow>
+      </fo:page-sequence>
+    </fo:root>
+  </fo>
+  <checks>
+    <element-list category="breaker" id="retain">
+      <box w="0"/> <!-- Helper box bearing the SpaceHandlingPosition and making sure the glue gets processed -->
+      <penalty w="0" p="INF"/>
+      <glue w="20000" y="0" z="20000"/>
+      
+      <box w="14400"/>
+      <box w="14400"/>
+      
+      <penalty w="0" p="INF"/>
+      <glue w="10000" y="0" z="10000"/>
+      <penalty w="0" p="0"/>
+      <glue w="-30000" y="0" z="-30000"/>
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="20000" y="0" z="20000"/>
+      
+      <box w="14400"/>
+      
+      <penalty w="0" p="INF"/>
+      <glue w="10000" y="0" z="10000"/>
+      <penalty w="0" p="0"/>
+      <glue w="-30000" y="0" z="-30000"/>
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="20000" y="0" z="20000"/>
+      
+      <box w="14400"/>
+      
+      <!-- skip three more lines -->
+      <skip>8</skip>
+      <skip>8</skip>
+      <skip>8</skip>
+      
+      <penalty w="0" p="INF"/>
+      <glue w="10000" y="0" z="10000"/>
+      <penalty w="0" p="0"/>
+      <glue w="-30000" y="0" z="-30000"/>
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="20000" y="0" z="20000"/>
+      
+      <box w="14400"/>
+      <box w="14400"/>
+      
+      <penalty w="0" p="INF" aux="true"/>
+      <glue w="10000" aux="true"/>
+      <penalty w="0" p="0"/>
+      <glue w="-10000" aux="true"/>
+      
+      <box w="0" aux="true"/>
+      <penalty w="0" p="INF" aux="true"/>
+      <glue w="10000" aux="true"/>
+      
+      <box w="14400"/> <!-- second block -->
+      
+      <box w="0" aux="true"/>
+      <penalty w="0" p="INF" aux="true"/>
+      <glue w="20000" aux="true"/>
+      
+      <box w="0" aux="true"/> <!-- This is used to make sure the preceding glue is not cut off -->
+      
+      <skip>3</skip>
+    </element-list>
+    <element-list category="breaker" id="discard">
+      <box w="0"/> <!-- Helper box used to notify the LM for the addAreas stage about the discarded spaces -->
+      <box w="14400"/>
+      <box w="14400"/>
+      <penalty w="0" p="0"/>
+      <box w="14400"/>
+      <penalty w="0" p="0"/>
+      <box w="14400"/>
+      <penalty w="0" p="0"/>
+      <box w="14400"/>
+      <penalty w="0" p="0"/>
+      <box w="14400"/>
+      <penalty w="0" p="0"/>
+      <box w="14400"/>
+      <penalty w="0" p="0"/>
+      <box w="14400"/>
+      <box w="14400"/>
+      <penalty w="0" p="0"/>
+      <glue w="10000"/>
+      
+      <box w="14400"/> <!-- second block -->
+      
+      <box w="0"/> <!-- SpaceHandlingPosition-bearing helper box -->
+      
+      <skip>3</skip>
+    </element-list>
+  </checks>
+</testcase>

test/layoutengine/testcases/block-container_space-before_space-after_2.xml

@@ -0,0 +1,93 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Copyright 2005 The Apache Software Foundation
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<!-- $Id$ -->
+<testcase>
+  <info>
+    <p>
+      This test checks block-level space properties. Demonstrates that spaces are repeated on every generated area.
+    </p>
+  </info>
+  <fo>
+    <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+      <fo:layout-master-set>
+        <fo:simple-page-master master-name="normal" page-width="5in" page-height="30pt">
+          <fo:region-body/>
+        </fo:simple-page-master>
+      </fo:layout-master-set>
+      <fo:page-sequence master-reference="normal" white-space-collapse="true">
+        <fo:flow flow-name="xsl-region-body" line-height="10pt" font-size="9pt">
+          <fo:block-container space-before="5pt" space-before.conditionality="retain" background-color="yellow">
+             <fo:block>line 1</fo:block>
+             <fo:block>line 2</fo:block>
+             <fo:block>line 3</fo:block>
+             <fo:block>line 4</fo:block>
+             <fo:block>line 5</fo:block>
+          </fo:block-container>
+        </fo:flow>
+      </fo:page-sequence>
+    </fo:root>
+  </fo>
+  <checks>
+    <element-list category="breaker">
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="5000"/>
+      <box w="10000"/>
+      <penalty w="0" p="0"/>
+      <glue w="-5000"/>
+      
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="5000"/>
+      <box w="10000"/>
+      <penalty w="0" p="0"/>
+      <glue w="-5000"/>
+      
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="5000"/>
+      <box w="10000"/>
+      <penalty w="0" p="0"/>
+      <glue w="-5000"/>
+      
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="5000"/>
+      <box w="10000"/>
+      <penalty w="0" p="0"/>
+      <glue w="-5000"/>
+      
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="5000"/>
+      <box w="10000"/>
+      
+      <skip>3</skip>
+    </element-list>
+    <eval expected="3" xpath="count(//pageViewport)"/>
+    <eval expected="5000" xpath="//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before"/>
+    <eval expected="5000" xpath="//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before"/>
+    <eval expected="5000" xpath="//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before"/>
+    <eval expected="1" xpath="count(//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block)"/>
+    <eval expected="1" xpath="count(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block)"/>
+    <eval expected="1" xpath="count(//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block)"/>
+    <eval expected="2" xpath="count(//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/block)"/>
+    <eval expected="2" xpath="count(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/block)"/>
+    <eval expected="1" xpath="count(//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/block)"/>
+    
+  </checks>
+</testcase>

test/layoutengine/testcases/block-container_space-before_space-after_3.xml

@@ -0,0 +1,126 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Copyright 2005 The Apache Software Foundation
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<!-- $Id$ -->
+<testcase>
+  <info>
+    <p>
+      This test checks space properties on block-containers. The focus is on space properties on content inside the block-containers.
+    </p>
+  </info>
+  <fo>
+    <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+      <fo:layout-master-set>
+        <fo:simple-page-master master-name="normal" page-width="5in" page-height="2in">
+          <fo:region-body/>
+        </fo:simple-page-master>
+      </fo:layout-master-set>
+      <fo:page-sequence master-reference="normal" id="no-height">
+        <fo:flow flow-name="xsl-region-body" line-height="10pt" font-size="9pt">
+          <fo:block-container space-before="1em" background-color="yellow" id="page1-bc1">
+            <fo:block space-before="1em">line 1</fo:block>
+            <fo:block>line 2</fo:block>
+          </fo:block-container>
+          <fo:block>A block between block-containers.</fo:block>
+          <fo:block-container background-color="yellow" id="page1-bc2">
+            <!-- ATM, the block-container without height behaves like a block which is wrong. It generates a viewport/reference pair. -->
+            <fo:block space-before="1em">line 1</fo:block>
+            <fo:block>line 2</fo:block>
+          </fo:block-container>
+        </fo:flow>
+      </fo:page-sequence>
+      <fo:page-sequence master-reference="normal" id="with-height">
+        <fo:flow flow-name="xsl-region-body" line-height="10pt" font-size="9pt">
+          <fo:block-container space-before="1em" height="50pt" background-color="yellow" id="page2-bc1">
+            <fo:block space-before="1em">line 1</fo:block>
+            <fo:block>line 2</fo:block>
+          </fo:block-container>
+          <fo:block>A block between block-containers.</fo:block>
+          <fo:block-container height="50pt" background-color="yellow" id="page2-bc2">
+            <fo:block space-before="1em">line 1</fo:block>
+            <fo:block>line 2</fo:block>
+          </fo:block-container>
+        </fo:flow>
+      </fo:page-sequence>
+    </fo:root>
+  </fo>
+  <checks>
+    <element-list category="breaker" id="no-height">
+      <box w="0"/> <!-- SpaceHandlingPosition -->
+      
+      <box w="10000"/>
+      <penalty w="0" p="0"/>
+      <box w="10000"/>
+      
+      <penalty w="0" p="0"/>
+      <box w="10000"/> <!-- block between block-containers -->
+      <penalty w="0" p="0"/>
+      
+      <box w="10000"/>
+      <penalty w="0" p="0"/>
+      <box w="10000"/>
+      
+      <skip>3</skip>
+    </element-list>
+    <element-list category="block-container" id="page1-bc1">
+      <box w="0"/> <!-- SpaceHandlingPosition -->
+      
+      <box w="10000"/>
+      <penalty w="0" p="0"/>
+      <box w="10000"/>
+      
+      <skip>3</skip>
+    </element-list>
+    <element-list category="block-container" id="page1-bc2">
+      <box w="0"/> <!-- SpaceHandlingPosition -->
+      
+      <box w="10000"/>
+      <penalty w="0" p="0"/>
+      <box w="10000"/>
+      
+      <skip>3</skip>
+    </element-list>
+    <element-list category="breaker" id="no-height">
+      <box w="0"/> <!-- SpaceHandlingPosition -->
+      
+      <box w="50000"/>
+      
+      <penalty w="0" p="0"/>
+      <box w="10000"/> <!-- block between block-containers -->
+      <penalty w="0" p="0"/>
+      
+      <box w="50000"/>
+      
+      <skip>3</skip>
+    </element-list>
+    <element-list category="block-container" id="page2-bc1">
+      <box w="0"/> <!-- SpaceHandlingPosition -->
+      
+      <box w="10000"/>
+      <box w="10000"/>
+      
+      <skip>3</skip>
+    </element-list>
+    <element-list category="block-container" id="page2-bc2">
+      <box w="0"/> <!-- SpaceHandlingPosition -->
+      
+      <box w="10000"/>
+      <box w="10000"/>
+      
+      <skip>3</skip>
+    </element-list>
+  </checks>
+</testcase>

test/layoutengine/testcases/block_border_padding.xml

@@ -48,107 +48,107 @@
   </fo>
   <checks>
     <!-- First block, no gap -->
-    <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@border-start"/>
-    <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@border-end"/>
-    <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@border-before"/>
-    <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@border-after"/>
-    <eval expected="5000 5000 5000 5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@bap"/>
-    <eval expected="350000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@ipd"/>
-    <eval expected="360000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@ipda"/>
-    <eval expected="24400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@bpd"/>
-    <eval expected="34400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@bpda"/>
+    <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[1]/@border-start"/>
+    <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[1]/@border-end"/>
+    <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[1]/@border-before"/>
+    <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[1]/@border-after"/>
+    <eval expected="5000 5000 5000 5000" xpath="//flow/block[1]/@bap"/>
+    <eval expected="350000" xpath="//flow/block[1]/@ipd"/>
+    <eval expected="360000" xpath="//flow/block[1]/@ipda"/>
+    <eval expected="24400" xpath="//flow/block[1]/@bpd"/>
+    <eval expected="34400" xpath="//flow/block[1]/@bpda"/>
     <!-- Nested block of first block -->
-    <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@border-start"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@border-end"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@border-before"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@border-after"/>
-    <eval expected="5000 5000 5000 5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@bap"/>
-    <eval expected="340000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@ipd"/>
-    <eval expected="350000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@ipda"/>
-    <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@bpd"/>
-    <eval expected="24400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@bpda"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[1]/block[1]/@border-start"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[1]/block[1]/@border-end"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[1]/block[1]/@border-before"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[1]/block[1]/@border-after"/>
+    <eval expected="5000 5000 5000 5000" xpath="//flow/block[1]/block[1]/@bap"/>
+    <eval expected="340000" xpath="//flow/block[1]/block[1]/@ipd"/>
+    <eval expected="350000" xpath="//flow/block[1]/block[1]/@ipda"/>
+    <eval expected="14400" xpath="//flow/block[1]/block[1]/@bpd"/>
+    <eval expected="24400" xpath="//flow/block[1]/block[1]/@bpda"/>
 
     <!-- Second block, 5pt gap -->
-    <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@border-start"/>
-    <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@border-end"/>
-    <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@border-before"/>
-    <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@border-after"/>
-    <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@padding-start"/>
-    <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@padding-end"/>
-    <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@padding-before"/>
-    <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@padding-after"/>
-    <eval expected="10000 10000 10000 10000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@bap"/>
-    <eval expected="340000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@ipd"/>
-    <eval expected="360000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@ipda"/>
-    <eval expected="24400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@bpd"/>
-    <eval expected="44400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@bpda"/>
+    <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[2]/@border-start"/>
+    <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[2]/@border-end"/>
+    <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[2]/@border-before"/>
+    <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[2]/@border-after"/>
+    <eval expected="5000" xpath="//flow/block[2]/@padding-start"/>
+    <eval expected="5000" xpath="//flow/block[2]/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[2]/@padding-before"/>
+    <eval expected="5000" xpath="//flow/block[2]/@padding-after"/>
+    <eval expected="10000 10000 10000 10000" xpath="//flow/block[2]/@bap"/>
+    <eval expected="340000" xpath="//flow/block[2]/@ipd"/>
+    <eval expected="360000" xpath="//flow/block[2]/@ipda"/>
+    <eval expected="24400" xpath="//flow/block[2]/@bpd"/>
+    <eval expected="44400" xpath="//flow/block[2]/@bpda"/>
     <!-- Nested block of second block -->
-    <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/block[1]/@border-start"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/block[1]/@border-end"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/block[1]/@border-before"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/block[1]/@border-after"/>
-    <eval expected="5000 5000 5000 5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/block[1]/@bap"/>
-    <eval expected="330000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/block[1]/@ipd"/>
-    <eval expected="340000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/block[1]/@ipda"/>
-    <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/block[1]/@bpd"/>
-    <eval expected="24400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/block[1]/@bpda"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/block[1]/@border-start"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/block[1]/@border-end"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/block[1]/@border-before"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/block[1]/@border-after"/>
+    <eval expected="5000 5000 5000 5000" xpath="//flow/block[2]/block[1]/@bap"/>
+    <eval expected="330000" xpath="//flow/block[2]/block[1]/@ipd"/>
+    <eval expected="340000" xpath="//flow/block[2]/block[1]/@ipda"/>
+    <eval expected="14400" xpath="//flow/block[2]/block[1]/@bpd"/>
+    <eval expected="24400" xpath="//flow/block[2]/block[1]/@bpda"/>
 
     <!-- third block, no gap between borders but margin around outer block -->
     <!--     space before block -->
-    <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/@bpd"/>
+    <eval expected="5000" xpath="//flow/block[3]/@space-before"/>
     <!--     actual block -->
-    <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@space-start"/>
-    <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@space-end"/>
-    <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@border-start"/>
-    <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@border-end"/>
-    <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@border-before"/>
-    <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@border-after"/>
-    <eval expected="5000 5000 5000 5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@bap"/>
-    <eval expected="340000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@ipd"/>
-    <eval expected="350000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@ipda"/>
-    <eval expected="24400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@bpd"/>
-    <eval expected="34400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@bpda"/>
+    <eval expected="5000" xpath="//flow/block[3]/@space-start"/>
+    <eval expected="5000" xpath="//flow/block[3]/@space-end"/>
+    <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[3]/@border-start"/>
+    <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[3]/@border-end"/>
+    <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[3]/@border-before"/>
+    <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[3]/@border-after"/>
+    <eval expected="5000 5000 5000 5000" xpath="//flow/block[3]/@bap"/>
+    <eval expected="340000" xpath="//flow/block[3]/@ipd"/>
+    <eval expected="350000" xpath="//flow/block[3]/@ipda"/>
+    <eval expected="24400" xpath="//flow/block[3]/@bpd"/>
+    <eval expected="44400" xpath="//flow/block[3]/@bpda"/>
     <!--     space after block -->
-    <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@bpd"/>
+    <eval expected="5000" xpath="//flow/block[3]/@space-after"/>
 
     <!-- Nested block of third block -->
-    <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/block[1]/@border-start"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/block[1]/@border-end"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/block[1]/@border-before"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/block[1]/@border-after"/>
-    <eval expected="5000 5000 5000 5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/block[1]/@bap"/>
-    <eval expected="330000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/block[1]/@ipd"/>
-    <eval expected="340000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/block[1]/@ipda"/>
-    <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/block[1]/@bpd"/>
-    <eval expected="24400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/block[1]/@bpda"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[3]/block[1]/@border-start"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[3]/block[1]/@border-end"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[3]/block[1]/@border-before"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[3]/block[1]/@border-after"/>
+    <eval expected="5000 5000 5000 5000" xpath="//flow/block[3]/block[1]/@bap"/>
+    <eval expected="330000" xpath="//flow/block[3]/block[1]/@ipd"/>
+    <eval expected="340000" xpath="//flow/block[3]/block[1]/@ipda"/>
+    <eval expected="14400" xpath="//flow/block[3]/block[1]/@bpd"/>
+    <eval expected="24400" xpath="//flow/block[3]/block[1]/@bpda"/>
 
     <!-- Fourth block, looks like the second block, but using margin on inner block instead of padding on outer block -->
-    <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@border-start"/>
-    <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@border-end"/>
-    <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@border-before"/>
-    <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@border-after"/>
-    <eval expected="5000 5000 5000 5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@bap"/>
-    <eval expected="350000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@ipd"/>
-    <eval expected="360000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@ipda"/>
-    <eval expected="34400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@bpd"/>
-    <eval expected="44400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@bpda"/>
+    <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[4]/@border-start"/>
+    <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[4]/@border-end"/>
+    <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[4]/@border-before"/>
+    <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[4]/@border-after"/>
+    <eval expected="5000 5000 5000 5000" xpath="//flow/block[4]/@bap"/>
+    <eval expected="350000" xpath="//flow/block[4]/@ipd"/>
+    <eval expected="360000" xpath="//flow/block[4]/@ipda"/>
+    <eval expected="34400" xpath="//flow/block[4]/@bpd"/>
+    <eval expected="44400" xpath="//flow/block[4]/@bpda"/>
     <!-- Nested block of second block -->
     <!--     space before block -->
-    <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[1]/@bpd"/>
+    <eval expected="5000" xpath="//flow/block[4]/block[1]/@space-before"/>
     <!--     actual block -->
-    <eval expected="10000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[2]/@space-start"/>
-    <eval expected="10000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[2]/@space-end"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[2]/@border-start"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[2]/@border-end"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[2]/@border-before"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[2]/@border-after"/>
-    <eval expected="5000 5000 5000 5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[2]/@bap"/>
-    <eval expected="330000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[2]/@ipd"/>
-    <eval expected="340000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[2]/@ipda"/>
-    <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[2]/@bpd"/>
-    <eval expected="24400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[2]/@bpda"/>
+    <eval expected="10000" xpath="//flow/block[4]/block[1]/@space-start"/>
+    <eval expected="10000" xpath="//flow/block[4]/block[1]/@space-end"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/block[1]/@border-start"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/block[1]/@border-end"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/block[1]/@border-before"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/block[1]/@border-after"/>
+    <eval expected="5000 5000 5000 5000" xpath="//flow/block[4]/block[1]/@bap"/>
+    <eval expected="330000" xpath="//flow/block[4]/block[1]/@ipd"/>
+    <eval expected="340000" xpath="//flow/block[4]/block[1]/@ipda"/>
+    <eval expected="14400" xpath="//flow/block[4]/block[1]/@bpd"/>
+    <eval expected="34400" xpath="//flow/block[4]/block[1]/@bpda"/>
     <!--     space after block -->
-    <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[3]/@bpd"/>
+    <eval expected="5000" xpath="//flow/block[4]/block[1]/@space-after"/>
 
   </checks>
 </testcase>

test/layoutengine/testcases/block_margin.xml

@@ -40,33 +40,35 @@
     </fo:root>
   </fo>
   <checks>
-    <!-- padding-left -->
-    <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-start"/>
-    <eval expected="0 0 0 0" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@bap"/>
-    <eval expected="355000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@ipd"/>
-    <eval expected="355000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@ipda"/>
-    <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@bpd"/>
-    <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@bpda"/>
-    <!-- padding-right -->
-    <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@space-end"/>
-    <eval expected="0 0 0 0" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@bap"/>
-    <eval expected="355000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@ipd"/>
-    <eval expected="355000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@ipda"/>
-    <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@bpd"/>
-    <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@bpda"/>
-    <!-- padding-top -->
+    <!-- margin-left -->
+    <eval expected="5000" xpath="//flow/block[1]/@space-start"/>
+    <eval expected="0 0 0 0" xpath="//flow/block[1]/@bap"/>
+    <eval expected="355000" xpath="//flow/block[1]/@ipd"/>
+    <eval expected="355000" xpath="//flow/block[1]/@ipda"/>
+    <eval expected="14400" xpath="//flow/block[1]/@bpd"/>
+    <eval expected="14400" xpath="//flow/block[1]/@bpda"/>
+    <!-- margin-right -->
+    <eval expected="5000" xpath="//flow/block[2]/@space-end"/>
+    <eval expected="0 0 0 0" xpath="//flow/block[2]/@bap"/>
+    <eval expected="355000" xpath="//flow/block[2]/@ipd"/>
+    <eval expected="355000" xpath="//flow/block[2]/@ipda"/>
+    <eval expected="14400" xpath="//flow/block[2]/@bpd"/>
+    <eval expected="14400" xpath="//flow/block[2]/@bpda"/>
+    <!-- margin-top -->
     <!--     space before block -->
-    <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/@bpd"/>
+    <eval expected="5000" xpath="//flow/block[3]/@space-before"/>
     <!--     actual block -->
-    <eval expected="0 0 0 0" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@bap"/>
-    <eval expected="360000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@ipda"/>
-    <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@bpda"/>
-    <!-- padding-bottom -->
+    <eval expected="0 0 0 0" xpath="//flow/block[3]/@bap"/>
+    <eval expected="360000" xpath="//flow/block[3]/@ipda"/>
+    <eval expected="14400" xpath="//flow/block[3]/@bpd"/>
+    <eval expected="19400" xpath="//flow/block[3]/@bpda"/>
+    <!-- margin-bottom -->
     <!--     actual block -->
-    <eval expected="0 0 0 0" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@bap"/>
-    <eval expected="360000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@ipda"/>
-    <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@bpda"/>
+    <eval expected="0 0 0 0" xpath="//flow/block[4]/@bap"/>
+    <eval expected="360000" xpath="//flow/block[4]/@ipda"/>
+    <eval expected="14400" xpath="//flow/block[4]/@bpd"/>
+    <eval expected="19400" xpath="//flow/block[4]/@bpda"/>
     <!--     space after block -->
-    <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@bpd"/>
+    <eval expected="5000" xpath="//flow/block[4]/@space-after"/>
   </checks>
 </testcase>

test/layoutengine/testcases/block_margin_inherit.xml

@@ -41,23 +41,36 @@
     </fo:root>
   </fo>
   <checks>
-    <eval expected="0" xpath="//flow/block[1]/@ipd"/>
-    <eval expected="18000" xpath="//flow/block[1]/@bpd"/>
-    <eval expected="324000" xpath="//flow/block[2]/@ipd"/>
-    <eval expected="18000" xpath="//flow/block[2]/@start-indent"/>
-    <eval expected="18000" xpath="//flow/block[2]/@end-indent"/>
-    <eval expected="18000" xpath="//flow/block[2]/@space-start"/>
-    <eval expected="18000" xpath="//flow/block[2]/@space-end"/>
-    <eval expected="0" xpath="//flow/block[2]/block[1]/@ipd"/>
-    <eval expected="18000" xpath="//flow/block[2]/block[1]/@bpd"/>
-    <eval expected="288000" xpath="//flow/block[2]/block[2]/@ipd"/>
-    <eval expected="36000" xpath="//flow/block[2]/block[2]/@start-indent"/>
-    <eval expected="36000" xpath="//flow/block[2]/block[2]/@end-indent"/>
-    <eval expected="36000" xpath="//flow/block[2]/block[2]/@space-start"/>
-    <eval expected="36000" xpath="//flow/block[2]/block[2]/@space-end"/>
-    <eval expected="0" xpath="//flow/block[2]/block[3]/@ipd"/>
-    <eval expected="18000" xpath="//flow/block[2]/block[3]/@bpd"/>
-    <eval expected="0" xpath="//flow/block[3]/@ipd"/>
-    <eval expected="18000" xpath="//flow/block[3]/@bpd"/>
+    <element-list category="breaker">
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="18000" y="0" z="0"/>
+      <box w="14400"/>
+      <box w="14400"/>
+      <penalty w="0" p="INF"/>
+      <glue w="18000" y="0" z="0"/>
+      <penalty w="0" p="0"/>
+      <box w="14400"/>
+      <box w="14400"/>
+      <skip>3</skip>
+    </element-list>
+  
+    <true xpath="not(boolean(//flow/block[1]/@space-before))"/> <!-- space collapsed under space resolution rules -->
+    <eval expected="324000" xpath="//flow/block[1]/@ipd"/>
+    <eval expected="18000" xpath="//flow/block[1]/@start-indent"/>
+    <eval expected="18000" xpath="//flow/block[1]/@end-indent"/>
+    <eval expected="18000" xpath="//flow/block[1]/@space-start"/>
+    <eval expected="18000" xpath="//flow/block[1]/@space-end"/>
+    
+    <eval expected="18000" xpath="//flow/block[1]/block[1]/@space-before"/>
+    <eval expected="288000" xpath="//flow/block[1]/block[1]/@ipd"/>
+    <eval expected="36000" xpath="//flow/block[1]/block[1]/@start-indent"/>
+    <eval expected="36000" xpath="//flow/block[1]/block[1]/@end-indent"/>
+    <eval expected="36000" xpath="//flow/block[1]/block[1]/@space-start"/>
+    <eval expected="36000" xpath="//flow/block[1]/block[1]/@space-end"/>
+    <true xpath="not(boolean(//flow/block[1]/block[1]/@space-after))"/>  <!-- space collapsed under space resolution rules -->
+    <true xpath="not(boolean(//flow/block[1]/block[2]))"/>
+    
+    <eval expected="18000" xpath="//flow/block[1]/@space-after"/>
   </checks>
 </testcase>

test/layoutengine/testcases/block_margin_percentages.xml

@@ -41,23 +41,36 @@
     </fo:root>
   </fo>
   <checks>
-    <eval expected="0" xpath="//flow/block[1]/@ipd"/>
-    <eval expected="18000" xpath="//flow/block[1]/@bpd"/>
-    <eval expected="324000" xpath="//flow/block[2]/@ipd"/>
-    <eval expected="18000" xpath="//flow/block[2]/@start-indent"/>
-    <eval expected="18000" xpath="//flow/block[2]/@end-indent"/>
-    <eval expected="18000" xpath="//flow/block[2]/@space-start"/>
-    <eval expected="18000" xpath="//flow/block[2]/@space-end"/>
-    <eval expected="0" xpath="//flow/block[2]/block[1]/@ipd"/>
-    <eval expected="16200" xpath="//flow/block[2]/block[1]/@bpd"/>
-    <eval expected="291600" xpath="//flow/block[2]/block[2]/@ipd"/>
-    <eval expected="34200" xpath="//flow/block[2]/block[2]/@start-indent"/>
-    <eval expected="34200" xpath="//flow/block[2]/block[2]/@end-indent"/>
-    <eval expected="34200" xpath="//flow/block[2]/block[2]/@space-start"/>
-    <eval expected="34200" xpath="//flow/block[2]/block[2]/@space-end"/>
-    <eval expected="0" xpath="//flow/block[2]/block[3]/@ipd"/>
-    <eval expected="16200" xpath="//flow/block[2]/block[3]/@bpd"/>
-    <eval expected="0" xpath="//flow/block[3]/@ipd"/>
-    <eval expected="18000" xpath="//flow/block[3]/@bpd"/>
+    <element-list category="breaker">
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="18000" y="0" z="0"/>
+      <box w="14400"/>
+      <box w="14400"/>
+      <penalty w="0" p="INF"/>
+      <glue w="18000" y="0" z="0"/>
+      <penalty w="0" p="0"/>
+      <box w="14400"/>
+      <box w="14400"/>
+      <skip>3</skip>
+    </element-list>
+  
+    <eval expected="18000" xpath="//flow/block[1]/@space-before"/>
+    <eval expected="324000" xpath="//flow/block[1]/@ipd"/>
+    <eval expected="18000" xpath="//flow/block[1]/@start-indent"/>
+    <eval expected="18000" xpath="//flow/block[1]/@end-indent"/>
+    <eval expected="18000" xpath="//flow/block[1]/@space-start"/>
+    <eval expected="18000" xpath="//flow/block[1]/@space-end"/>
+    
+    <true xpath="not(boolean(//flow/block[1]/block[1]/@space-before))"/>  <!-- space collapsed under space resolution rules -->
+    <eval expected="291600" xpath="//flow/block[1]/block[1]/@ipd"/>
+    <eval expected="34200" xpath="//flow/block[1]/block[1]/@start-indent"/>
+    <eval expected="34200" xpath="//flow/block[1]/block[1]/@end-indent"/>
+    <eval expected="34200" xpath="//flow/block[1]/block[1]/@space-start"/>
+    <eval expected="34200" xpath="//flow/block[1]/block[1]/@space-end"/>
+    <true xpath="not(boolean(//flow/block[1]/block[1]/@space-after))"/>  <!-- space collapsed under space resolution rules -->
+    <true xpath="not(boolean(//flow/block[1]/block[2]))"/>
+    
+    <eval expected="18000" xpath="//flow/block[1]/@space-after"/>
   </checks>
 </testcase>

test/layoutengine/testcases/block_margin_shorthands.xml

@@ -30,10 +30,15 @@
       </fo:layout-master-set>
       <fo:page-sequence master-reference="normal" white-space-collapse="true">
         <fo:flow flow-name="xsl-region-body">
+          <fo:block border-before-style="solid" border-before-width="1pt"/> <!-- These are to avoid stacking constraints between tests -->
           <fo:block margin="5pt">all</fo:block>
+          <fo:block border-before-style="solid" border-before-width="1pt"/>
           <fo:block margin="0pt 5pt">left/right</fo:block>
+          <fo:block border-before-style="solid" border-before-width="1pt"/>
           <fo:block margin="5pt 0pt">top/bottom</fo:block>
+          <fo:block border-before-style="solid" border-before-width="1pt"/>
           <fo:block margin="1pt 2pt 3pt">three values</fo:block>
+          <fo:block border-before-style="solid" border-before-width="1pt"/>
           <fo:block>EOF</fo:block>
         </fo:flow>
       </fo:page-sequence>
@@ -42,45 +47,48 @@
   <checks>
     <!-- *** all *** -->
     <!--     space before block -->
-    <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@bpd"/>
+    <eval expected="5000" xpath="//flow/block[2]/@space-before"/>
     <!--     actual block -->
-    <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@space-start"/>
-    <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@space-end"/>
-    <eval expected="0 0 0 0" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@bap"/>
-    <eval expected="350000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@ipda"/>
-    <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@bpda"/>
+    <eval expected="5000" xpath="//flow/block[2]/@space-start"/>
+    <eval expected="5000" xpath="//flow/block[2]/@space-end"/>
+    <eval expected="0 0 0 0" xpath="//flow/block[2]/@bap"/>
+    <eval expected="350000" xpath="//flow/block[2]/@ipda"/>
+    <eval expected="14400" xpath="//flow/block[2]/@bpd"/>
+    <eval expected="24400" xpath="//flow/block[2]/@bpda"/>
     <!--     space after block -->
-    <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/@bpd"/>
+    <eval expected="5000" xpath="//flow/block[2]/@space-after"/>
     
     <!-- *** left/right *** -->
-    <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@space-start"/>
-    <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@space-end"/>
-    <eval expected="0 0 0 0" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@bap"/>
-    <eval expected="350000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@ipda"/>
-    <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@bpda"/>
+    <eval expected="5000" xpath="//flow/block[4]/@space-start"/>
+    <eval expected="5000" xpath="//flow/block[4]/@space-end"/>
+    <eval expected="0 0 0 0" xpath="//flow/block[4]/@bap"/>
+    <eval expected="350000" xpath="//flow/block[4]/@ipda"/>
+    <eval expected="14400" xpath="//flow/block[4]/@bpda"/>
     
     <!-- *** top/bottom *** -->
     <!--     space before block -->
-    <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@bpd"/>
+    <eval expected="5000" xpath="//flow/block[6]/@space-before"/>
     <!--     actual block -->
-    <true xpath="not(/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@space-start)"/>
-    <true xpath="not(/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@space-end)"/>
-    <eval expected="0 0 0 0" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@bap"/>
-    <eval expected="360000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@ipda"/>
-    <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@bpda"/>
+    <true xpath="not(//flow/block[6]/@space-start)"/>
+    <true xpath="not(//flow/block[6]/@space-end)"/>
+    <eval expected="0 0 0 0" xpath="//flow/block[6]/@bap"/>
+    <eval expected="360000" xpath="//flow/block[6]/@ipda"/>
+    <eval expected="14400" xpath="//flow/block[6]/@bpd"/>
+    <eval expected="24400" xpath="//flow/block[6]/@bpda"/>
     <!--     space after block -->
-    <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/@bpd"/>
+    <eval expected="5000" xpath="//flow/block[6]/@space-after"/>
     
     <!-- *** three values *** -->
     <!--     space before block -->
-    <eval expected="1000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[8]/@bpd"/>
+    <eval expected="1000" xpath="//flow/block[8]/@space-before"/>
     <!--     actual block -->
-    <eval expected="2000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[9]/@space-start"/>
-    <eval expected="2000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[9]/@space-end"/>
-    <eval expected="0 0 0 0" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[9]/@bap"/>
-    <eval expected="356000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[9]/@ipda"/>
-    <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[9]/@bpda"/>
+    <eval expected="2000" xpath="//flow/block[8]/@space-start"/>
+    <eval expected="2000" xpath="//flow/block[8]/@space-end"/>
+    <eval expected="0 0 0 0" xpath="//flow/block[8]/@bap"/>
+    <eval expected="356000" xpath="//flow/block[8]/@ipda"/>
+    <eval expected="14400" xpath="//flow/block[8]/@bpd"/>
+    <eval expected="18400" xpath="//flow/block[8]/@bpda"/>
     <!--     space after block -->
-    <eval expected="3000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[10]/@bpd"/>
+    <eval expected="3000" xpath="//flow/block[8]/@space-after"/>
   </checks>
 </testcase>

test/layoutengine/testcases/block_padding_2.xml

@@ -44,39 +44,61 @@
   </fo>
   <checks>
     <element-list category="breaker">
-      <box w="30000"/>
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="30000" aux="true"/>
+      
       <box w="14400"/>
-      <penalty w="30000" p="0"/> <!-- w="30000" is for the padding-after -->
-      <glue w="-30000" aux="true"/> <!-- get's discarded if a break happens on the penalty above -->
+      
+      <glue w="30000" aux="true"/> <!-- w="30000" is for the padding-after -->
+      <penalty w="0" p="0"/>
+      <glue w="-60000" aux="true"/> <!-- difference between break and no-break situation -->
       <box w="0"/>
       <penalty w="0" p="INF"/>
       <glue w="30000" aux="true"/> <!-- w="30000" is for the padding-before -->
+      
       <box w="14400"/>
-      <penalty w="30000" p="0"/>
-      <glue w="-30000" aux="true"/>
+      
+      <glue w="30000" aux="true"/>
+      <penalty w="0" p="0"/>
+      <glue w="-60000" aux="true"/>
       <box w="0"/>
       <penalty w="0" p="INF"/>
       <glue w="30000" aux="true"/>
+      
       <box w="14400"/>
-      <penalty w="30000" p="0"/>
-      <glue w="-30000" aux="true"/>
+
+      <glue w="30000" aux="true"/>
+      <penalty w="0" p="0"/>
+      <glue w="-60000" aux="true"/>
       <box w="0"/>
       <penalty w="0" p="INF"/>
       <glue w="30000" aux="true"/>
+      
       <box w="14400"/>
-      <penalty w="30000" p="0"/>
-      <glue w="-30000" aux="true"/>
+
+      <glue w="30000" aux="true"/>
+      <penalty w="0" p="0"/>
+      <glue w="-60000" aux="true"/>
       <box w="0"/>
       <penalty w="0" p="INF"/>
       <glue w="30000" aux="true"/>
+      
       <box w="14400"/>
-      <penalty w="30000" p="0"/>
-      <glue w="-30000" aux="true"/>
+
+      <glue w="30000" aux="true"/>
+      <penalty w="0" p="0"/>
+      <glue w="-60000" aux="true"/>
       <box w="0"/>
       <penalty w="0" p="INF"/>
       <glue w="30000" aux="true"/>
+      
       <box w="14400"/>
-      <box w="30000"/>
+      
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="30000" aux="true"/>
+      
       <skip>3</skip>
     </element-list>
   </checks>

test/layoutengine/testcases/block_space-before_space-after_1.xml

@@ -42,30 +42,34 @@
   </fo>
   <checks>
     <!-- overlapping block1 -->
-    <eval expected="360000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@ipda"/>
-    <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@bpda"/>
+    <eval expected="360000" xpath="//flow/block[1]/@ipda"/>
+    <eval expected="14400" xpath="//flow/block[1]/@bpd"/>
+    <eval expected="6400" xpath="//flow/block[1]/@bpda"/>
     <!-- space after overlapping block1 -->
-    <eval expected="-8000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@bpd"/>
+    <eval expected="-8000" xpath="//flow/block[1]/@space-after"/>
     <!-- normal block1 -->
-    <eval expected="360000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/@ipda"/>
-    <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/@bpda"/>
+    <eval expected="360000" xpath="//flow/block[2]/@ipda"/>
+    <eval expected="14400" xpath="//flow/block[2]/@bpda"/>
     <!-- space before spaced block1 -->
-    <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@bpd"/>
+    <eval expected="5000" xpath="//flow/block[3]/@space-before"/>
     <!-- spaced block1 -->
-    <eval expected="360000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@ipda"/>
-    <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@bpda"/>
+    <eval expected="360000" xpath="//flow/block[3]/@ipda"/>
+    <eval expected="14400" xpath="//flow/block[3]/@bpd"/>
+    <eval expected="19400" xpath="//flow/block[3]/@bpda"/>
     <!-- spaced block2 -->
-    <eval expected="360000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@ipda"/>
-    <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@bpda"/>
+    <eval expected="360000" xpath="//flow/block[4]/@ipda"/>
+    <eval expected="14400" xpath="//flow/block[4]/@bpd"/>
+    <eval expected="19400" xpath="//flow/block[4]/@bpda"/>
     <!-- space after spaced block2 -->
-    <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/@bpd"/>
+    <eval expected="5000" xpath="//flow/block[4]/@space-after"/>
     <!-- normal block2 -->
-    <eval expected="360000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[8]/@ipda"/>
-    <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[8]/@bpda"/>
+    <eval expected="360000" xpath="//flow/block[5]/@ipda"/>
+    <eval expected="14400" xpath="//flow/block[5]/@bpda"/>
     <!-- space before overlapping block2 -->
-    <eval expected="-8000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[9]/@bpd"/>
+    <eval expected="-8000" xpath="//flow/block[6]/@space-before"/>
     <!-- overlapping block2 -->
-    <eval expected="360000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[10]/@ipda"/>
-    <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[10]/@bpda"/>
+    <eval expected="360000" xpath="//flow/block[6]/@ipda"/>
+    <eval expected="14400" xpath="//flow/block[6]/@bpd"/>
+    <eval expected="6400" xpath="//flow/block[6]/@bpda"/>
   </checks>
 </testcase>

test/layoutengine/testcases/block_space-before_space-after_2.xml

@@ -28,7 +28,7 @@
           <fo:region-body/>
         </fo:simple-page-master>
       </fo:layout-master-set>
-      <fo:page-sequence master-reference="normal" white-space-collapse="true">
+      <fo:page-sequence master-reference="normal" id="retain">
         <fo:flow flow-name="xsl-region-body">
           <fo:block space-before.optimum="20pt" space-before.conditionality="retain" space-after.optimum="10pt" space-after.conditionality="retain" text-align="justify">
 In olden times when wishing still helped one, there lived a king whose daughters 
@@ -44,7 +44,7 @@ Two blocks, testing conditionality="retain".
           </fo:block>
         </fo:flow>
       </fo:page-sequence>
-      <fo:page-sequence master-reference="normal" white-space-collapse="true">
+      <fo:page-sequence master-reference="normal" id="discard">
         <fo:flow flow-name="xsl-region-body">
           <fo:block space-before.optimum="20pt" space-before.conditionality="discard" space-after.optimum="10pt" space-after.conditionality="discard" text-align="justify">
 In olden times when wishing still helped one, there lived a king whose daughters 
@@ -63,5 +63,94 @@ Two blocks, testing conditionality="discard".
     </fo:root>
   </fo>
   <checks>
+    <element-list category="breaker" id="retain">
+      <box w="0"/> <!-- Helper box bearing the SpaceHandlingPosition and making sure the glue gets processed -->
+      <penalty w="0" p="INF"/>
+      <glue w="20000" y="0" z="20000"/>
+      
+      <box w="14400"/>
+      <box w="14400"/>
+      
+      <penalty w="0" p="INF"/>
+      <glue w="10000" y="0" z="10000"/>
+      <penalty w="0" p="0"/>
+      <glue w="-30000" y="0" z="-30000"/>
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="20000" y="0" z="20000"/>
+      
+      <box w="14400"/>
+      
+      <penalty w="0" p="INF"/>
+      <glue w="10000" y="0" z="10000"/>
+      <penalty w="0" p="0"/>
+      <glue w="-30000" y="0" z="-30000"/>
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="20000" y="0" z="20000"/>
+      
+      <box w="14400"/>
+      
+      <!-- skip three more lines -->
+      <skip>8</skip>
+      <skip>8</skip>
+      <skip>8</skip>
+      
+      <penalty w="0" p="INF"/>
+      <glue w="10000" y="0" z="10000"/>
+      <penalty w="0" p="0"/>
+      <glue w="-30000" y="0" z="-30000"/>
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="20000" y="0" z="20000"/>
+      
+      <box w="14400"/>
+      <box w="14400"/>
+      
+      <penalty w="0" p="INF" aux="true"/>
+      <glue w="10000" aux="true"/>
+      <penalty w="0" p="0"/>
+      <glue w="-10000" aux="true"/>
+      
+      <box w="0" aux="true"/>
+      <penalty w="0" p="INF" aux="true"/>
+      <glue w="10000" aux="true"/>
+      
+      <box w="14400"/> <!-- second block -->
+      
+      <box w="0" aux="true"/>
+      <penalty w="0" p="INF" aux="true"/>
+      <glue w="20000" aux="true"/>
+      
+      <box w="0" aux="true"/> <!-- This is used to make sure the preceding glue is not cut off -->
+      
+      <skip>3</skip>
+    </element-list>
+    <element-list category="breaker" id="discard">
+      <box w="0"/> <!-- Helper box used to notify the LM for the addAreas stage about the discarded spaces -->
+      <box w="14400"/>
+      <box w="14400"/>
+      <penalty w="0" p="0"/>
+      <box w="14400"/>
+      <penalty w="0" p="0"/>
+      <box w="14400"/>
+      <penalty w="0" p="0"/>
+      <box w="14400"/>
+      <penalty w="0" p="0"/>
+      <box w="14400"/>
+      <penalty w="0" p="0"/>
+      <box w="14400"/>
+      <penalty w="0" p="0"/>
+      <box w="14400"/>
+      <box w="14400"/>
+      <penalty w="0" p="0"/>
+      <glue w="10000"/>
+      
+      <box w="14400"/> <!-- second block -->
+      
+      <box w="0"/> <!-- SpaceHandlingPosition-bearing helper box -->
+      
+      <skip>3</skip>
+    </element-list>
   </checks>
 </testcase>

test/layoutengine/testcases/block_space-before_space-after_3.xml

@@ -46,7 +46,7 @@
     <element-list category="breaker">
       <box w="0"/>
       <penalty w="0" p="INF"/>
-      <glue w="5000" aux="true"/>
+      <glue w="5000"/>
       <box w="14400"/>
       <box w="14400"/>
       <skip>3</skip>

test/layoutengine/testcases/block_space-before_space-after_4.xml

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Copyright 2005 The Apache Software Foundation
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<!-- $Id$ -->
+<testcase>
+  <info>
+    <p>
+      This test checks block-level space properties. Demonstrates that spaces are repeated on every generated area.
+    </p>
+  </info>
+  <fo>
+    <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+      <fo:layout-master-set>
+        <fo:simple-page-master master-name="normal" page-width="5in" page-height="30pt">
+          <fo:region-body/>
+        </fo:simple-page-master>
+      </fo:layout-master-set>
+      <fo:page-sequence master-reference="normal" white-space-collapse="true">
+        <fo:flow flow-name="xsl-region-body" line-height="10pt" font-size="9pt">
+          <fo:block space-before="5pt" space-before.conditionality="retain" background-color="yellow">
+             <fo:block>line 1</fo:block>
+             <fo:block>line 2</fo:block>
+             <fo:block>line 3</fo:block>
+             <fo:block>line 4</fo:block>
+             <fo:block>line 5</fo:block>
+          </fo:block>
+        </fo:flow>
+      </fo:page-sequence>
+    </fo:root>
+  </fo>
+  <checks>
+    <element-list category="breaker">
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="5000"/>
+      <box w="10000"/>
+      <penalty w="0" p="0"/>
+      <glue w="-5000"/>
+      
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="5000"/>
+      <box w="10000"/>
+      <penalty w="0" p="0"/>
+      <glue w="-5000"/>
+
+      <!-- skip two more lines -->
+      <skip>6</skip>
+      <skip>6</skip>
+      
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="5000"/>
+      <box w="10000"/>
+      
+      <skip>3</skip>
+    </element-list>
+    <eval expected="3" xpath="count(//pageViewport)"/>
+    <eval expected="5000" xpath="//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before"/>
+    <eval expected="5000" xpath="//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before"/>
+    <eval expected="5000" xpath="//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before"/>
+    <eval expected="1" xpath="count(//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block)"/>
+    <eval expected="1" xpath="count(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block)"/>
+    <eval expected="1" xpath="count(//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block)"/>
+    <eval expected="2" xpath="count(//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block)"/>
+    <eval expected="2" xpath="count(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block)"/>
+    <eval expected="1" xpath="count(//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block)"/>
+    
+  </checks>
+</testcase>

test/layoutengine/testcases/block_space-before_space-after_5.xml

@@ -0,0 +1,96 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Copyright 2005 The Apache Software Foundation
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<!-- $Id$ -->
+<testcase>
+  <info>
+    <p>
+      This test checks block-level space properties. These here are the 
+      <a href="http://wiki.apache.org/xmlgraphics-fop/SpaceResolution/Examples">examples 3 to 5 on the Wiki</a>.
+    </p>
+  </info>
+  <fo>
+    <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+      <fo:layout-master-set>
+        <fo:simple-page-master master-name="normal" page-width="5in" page-height="1in">
+          <fo:region-body background-color="lightgray"/>
+        </fo:simple-page-master>
+      </fo:layout-master-set>
+      <fo:page-sequence master-reference="normal" id="cond-cond">
+        <fo:flow flow-name="xsl-region-body">
+          <fo:block space-after="11pt">block 1: space-after conditional</fo:block>
+          <fo:block space-before="12pt">block 2: space-before conditional</fo:block>
+        </fo:flow>
+      </fo:page-sequence>
+      <fo:page-sequence master-reference="normal" id="retain-cond">
+        <fo:flow flow-name="xsl-region-body">
+          <fo:block space-after="11pt" space-after.conditionality="retain">block 1: space-after retained</fo:block>
+          <fo:block space-before="12pt">block 2: space-before: conditional</fo:block>
+        </fo:flow>
+      </fo:page-sequence>
+      <fo:page-sequence master-reference="normal" id="retain-cond-2">
+        <fo:flow flow-name="xsl-region-body">
+          <fo:block space-after="10pt" space-after.conditionality="retain">block 1: space-after retained</fo:block>
+          <fo:block space-before="10pt">block 2: space-before: conditional</fo:block>
+        </fo:flow>
+      </fo:page-sequence>
+      <fo:page-sequence master-reference="normal" id="retain-retain">
+        <fo:flow flow-name="xsl-region-body">
+          <fo:block space-after="11pt" space-after.conditionality="retain">block 1: space-after retained</fo:block>
+          <fo:block space-before="12pt" space-before.conditionality="retain">block 2: space-before retained</fo:block>
+        </fo:flow>
+      </fo:page-sequence>
+    </fo:root>
+  </fo>
+  <checks>
+    <element-list category="breaker" id="cond-cond">
+      <box w="14400"/>
+      <penalty w="0" p="0"/>
+      <glue w="12000"/>
+      <box w="14400"/>
+      <skip>3</skip>
+    </element-list>
+    <element-list category="breaker" id="retain-cond">
+      <box w="14400"/>
+      <penalty w="0" p="INF"/>
+      <glue w="11000"/>
+      <penalty w="0" p="0"/>
+      <glue w="1000"/>
+      <box w="14400"/>
+      <skip>3</skip>
+    </element-list>
+    <element-list category="breaker" id="retain-cond-2">
+      <box w="14400"/>
+      <penalty w="0" p="INF"/>
+      <glue w="10000"/>
+      <penalty w="0" p="0"/>
+      <box w="14400"/>
+      <skip>3</skip>
+    </element-list>
+    <element-list category="breaker" id="retain-retain">
+      <box w="14400"/>
+      <penalty w="0" p="INF"/>
+      <glue w="11000"/>
+      <penalty w="0" p="0"/>
+      <glue w="-11000"/>
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="12000"/>
+      <box w="14400"/>
+      <skip>3</skip>
+    </element-list>
+  </checks>
+</testcase>

test/layoutengine/testcases/block_space-before_space-after_6.xml

@@ -0,0 +1,92 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Copyright 2005 The Apache Software Foundation
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<!-- $Id$ -->
+<testcase>
+  <info>
+    <p>
+      This test checks block-level space properties. These here are the 
+      <a href="http://wiki.apache.org/xmlgraphics-fop/SpaceResolution/Examples">examples 1 and 2 on the Wiki</a>.
+    </p>
+  </info>
+  <fo>
+    <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+      <fo:layout-master-set>
+        <fo:simple-page-master master-name="normal" page-width="5in" page-height="1in">
+          <fo:region-body background-color="lightgray"/>
+        </fo:simple-page-master>
+      </fo:layout-master-set>
+      <fo:page-sequence master-reference="normal" id="ex1">
+        <fo:flow flow-name="xsl-region-body">
+          <fo:block>first line</fo:block>
+          <fo:block space-before="10pt">
+            <fo:block>before break</fo:block>
+            <fo:block>after break</fo:block>
+          </fo:block>
+        </fo:flow>
+      </fo:page-sequence>
+      <fo:page-sequence master-reference="normal" id="ex2">
+        <fo:flow flow-name="xsl-region-body">
+          <fo:block>first line</fo:block>
+          <fo:block space-before="10pt" space-before.conditionality="retain">
+            <fo:block>before break</fo:block>
+            <fo:block>after break</fo:block>
+          </fo:block>
+        </fo:flow>
+      </fo:page-sequence>
+    </fo:root>
+  </fo>
+  <checks>
+    <element-list category="breaker" id="ex1">
+      <box w="14400"/>
+      
+      <penalty w="0" p="0"/>
+      
+      <glue w="10000"/>
+      <box w="14400"/>
+      
+      <penalty w="0" p="0"/>
+      
+      <box w="14400"/>
+      
+      <skip>3</skip>
+    </element-list>
+    
+    <element-list category="breaker" id="ex2">
+      <box w="14400"/>
+      
+      <penalty w="0" p="0"/>
+      
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="10000"/>
+      
+      <box w="14400"/>
+
+      <penalty w="0" p="0"/>
+
+      <glue w="-10000"/>
+      
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="10000"/>
+
+      <box w="14400"/>
+      
+      <skip>3</skip>
+    </element-list>
+  </checks>
+</testcase>

test/layoutengine/testcases/block_space-before_space-after_7.xml

@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Copyright 2005 The Apache Software Foundation
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<!-- $Id$ -->
+<testcase>
+  <info>
+    <p>
+      This test checks block-level space properties. These here are the 
+      <a href="http://wiki.apache.org/xmlgraphics-fop/SpaceResolution/Examples">examples 1 and 2 on the Wiki</a>.
+    </p>
+  </info>
+  <fo>
+    <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+      <fo:layout-master-set>
+        <fo:simple-page-master master-name="normal" page-width="5in" page-height="1in">
+          <fo:region-body background-color="lightgray"/>
+        </fo:simple-page-master>
+      </fo:layout-master-set>
+      <fo:page-sequence master-reference="normal" id="ex8">
+        <fo:flow flow-name="xsl-region-body">
+          <fo:block space-before="10pt" padding-before="5pt" border-before-style="solid" border-before-width="2pt">
+            first line
+            <fo:block space-before="6pt">second line</fo:block>
+          </fo:block>
+        </fo:flow>
+      </fo:page-sequence>
+    </fo:root>
+  </fo>
+  <checks>
+    <element-list category="breaker" id="ex8">
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="7000"/>
+      <box w="14400"/>
+      
+      <penalty w="0" p="0"/>
+      
+      <glue w="6000"/>
+      <box w="14400"/>
+      <skip>3</skip>
+    </element-list>
+  </checks>
+</testcase>

test/layoutengine/testcases/block_space-before_space-after_8.xml

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Copyright 2005 The Apache Software Foundation
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<!-- $Id$ -->
+<testcase>
+  <info>
+    <p>
+      This test checks if the special case is properly handled when an empty block is between two 
+      space-specifiers which should form a stacking constraint.
+    </p>
+  </info>
+  <fo>
+    <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+      <fo:layout-master-set>
+        <fo:simple-page-master master-name="normal" page-width="5in" page-height="1in">
+          <fo:region-body/>
+        </fo:simple-page-master>
+      </fo:layout-master-set>
+      <fo:page-sequence master-reference="normal" id="ex8">
+        <fo:flow flow-name="xsl-region-body">
+          <fo:block space-after="10pt">
+            first line
+          </fo:block>
+          <fo:block id="empty-block"/>
+          <fo:block space-before="10pt">
+            second line
+          </fo:block>
+        </fo:flow>
+      </fo:page-sequence>
+    </fo:root>
+  </fo>
+  <checks>
+    <true xpath="not(boolean(//flow/block[1]/@space-after))"/>
+    <eval expected="10000" xpath="//flow/block[2]/@space-before"/>
+  </checks>
+</testcase>

test/layoutengine/testcases/block_space-before_space-after_9.xml

@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Copyright 2005 The Apache Software Foundation
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<!-- $Id$ -->
+<testcase>
+  <info>
+    <p>
+      This test checks if the isLast case is properly handled. In this case the part list has to be 
+      reversed to do the conditionals removal, but then has to be reversed again to its natural order 
+      so space resolution rules 2 and 3 are properly performed.
+    </p>
+  </info>
+  <fo>
+    <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+      <fo:layout-master-set>
+        <fo:simple-page-master master-name="normal" page-width="5in" page-height="1in">
+          <fo:region-body/>
+        </fo:simple-page-master>
+      </fo:layout-master-set>
+      <fo:page-sequence master-reference="normal">
+        <fo:flow flow-name="xsl-region-body">
+          <fo:block space-before="11pt" space-after="11pt">
+            <fo:block space-before="12pt" space-after="12pt">
+              <fo:block space-before="13pt" space-after="13pt" border="solid 1pt">
+                Apache FOP!
+              </fo:block>
+            </fo:block>
+          </fo:block>
+        </fo:flow>
+      </fo:page-sequence>
+    </fo:root>
+  </fo>
+  <checks>
+    <element-list category="breaker">
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="1000"/>
+      
+      <box w="14400"/>
+      
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="1000"/>
+      
+      <box w="0"/>
+      <skip>3</skip>
+    </element-list>
+    <true xpath="not(boolean(//flow/block[1]/@space-before))"/>
+    <true xpath="not(boolean(//flow/block[1]/@space-after))"/>
+    <true xpath="not(boolean(//flow/block[1]/block[1]/@space-before))"/>
+    <true xpath="not(boolean(//flow/block[1]/block[1]/@space-after))"/>
+    <true xpath="not(boolean(//flow/block[1]/block[1]/block[1]/@space-before))"/>
+    <true xpath="not(boolean(//flow/block[1]/block[1]/block[1]/@space-after))"/>
+    <eval expected="1000 1000 1000 1000" xpath="//flow/block[1]/block[1]/block[1]/@bap"/>
+  </checks>
+</testcase>

test/layoutengine/testcases/block_space-before_space-after_9a.xml

@@ -0,0 +1,90 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Copyright 2005 The Apache Software Foundation
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<!-- $Id$ -->
+<testcase>
+  <info>
+    <p>
+      This test checks if the isLast case is properly handled. In this case the part list has to be 
+      reversed to do the conditionals removal, but then has to be reversed again to its natural order 
+      so space resolution rules 2 and 3 are properly performed.
+    </p>
+  </info>
+  <fo>
+    <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+      <fo:layout-master-set>
+        <fo:simple-page-master master-name="normal" page-width="5in" page-height="1in">
+          <fo:region-body/>
+        </fo:simple-page-master>
+      </fo:layout-master-set>
+      <fo:page-sequence master-reference="normal">
+        <fo:flow flow-name="xsl-region-body">
+          <fo:block space-before="11pt" space-after="11pt">
+            <fo:block space-before="12pt" space-after="12pt">
+              <fo:block space-before="13pt" space-after="13pt" border="solid 1pt">
+                Apache FOP!
+                <fo:block break-before="page"/>
+                Apache FOP!!!
+              </fo:block>
+            </fo:block>
+          </fo:block>
+        </fo:flow>
+      </fo:page-sequence>
+    </fo:root>
+  </fo>
+  <checks>
+    <element-list category="breaker" index="0">
+      <box w="0"/> <!-- SpaceHandlingPosition -->
+      <penalty w="0" p="INF"/>
+      <glue w="1000"/>
+      
+      <box w="14400"/>
+      
+      <skip>3</skip> <!-- the last of the three holds a SpaceHandlingBreakPosition -->
+    </element-list>
+    <element-list category="breaker" index="1">
+      <box w="0"/> <!-- SpaceHandlingPosition -->
+      
+      <box w="0"/> <!-- empty block used to cause the break-before -->
+      <penalty w="0" p="0"/>
+      
+      <box w="14400"/>
+      
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="1000"/>
+      <box w="0"/> <!-- SpaceHandlingPosition -->
+
+      <skip>3</skip>
+    </element-list>
+    
+    <true xpath="not(boolean(//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before))"/>
+    <true xpath="not(boolean(//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-after))"/>
+    <true xpath="not(boolean(//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@space-before))"/>
+    <true xpath="not(boolean(//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@space-after))"/>
+    <true xpath="not(boolean(//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/block[1]/@space-before))"/>
+    <true xpath="not(boolean(//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/block[1]/@space-after))"/>
+    <eval expected="1000 1000 1000 0" xpath="//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/block[1]/@bap"/>
+
+    <true xpath="not(boolean(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before))"/>
+    <true xpath="not(boolean(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-after))"/>
+    <true xpath="not(boolean(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@space-before))"/>
+    <true xpath="not(boolean(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@space-after))"/>
+    <true xpath="not(boolean(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/block[1]/@space-before))"/>
+    <true xpath="not(boolean(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/block[1]/@space-after))"/>
+    <eval expected="1000 1000 0 1000" xpath="//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/block[1]/@bap"/>
+  </checks>
+</testcase>

test/layoutengine/testcases/character_border_padding.xml

@@ -47,52 +47,52 @@
     </fo:root>
   </fo>
   <checks>
+    <eval expected="7180" xpath="//flow/block[1]/lineArea/char/@baseline"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea/char/@offset"/>
+    <eval expected="5560" xpath="//flow/block[1]/lineArea/char/@ipd"/>
+    <eval expected="7560" xpath="//flow/block[1]/lineArea/char/@ipda"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea/char/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea/char/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea/char/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea/char/@border-start"/>
+
     <eval expected="7180" xpath="//flow/block[2]/lineArea/char/@baseline"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea/char/@offset"/>
     <eval expected="5560" xpath="//flow/block[2]/lineArea/char/@ipd"/>
-    <eval expected="7560" xpath="//flow/block[2]/lineArea/char/@ipda"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea/char/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea/char/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea/char/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea/char/@border-start"/>
-
-    <eval expected="7180" xpath="//flow/block[5]/lineArea/char/@baseline"/>
-    <eval expected="0" xpath="//flow/block[5]/lineArea/char/@offset"/>
-    <eval expected="5560" xpath="//flow/block[5]/lineArea/char/@ipd"/>
-    <eval expected="25560" xpath="//flow/block[5]/lineArea/char/@ipda"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[5]/lineArea/char/@border-after"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[5]/lineArea/char/@border-before"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[5]/lineArea/char/@border-end"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[5]/lineArea/char/@border-start"/>
-    <eval expected="5000" xpath="//flow/block[5]/lineArea/char/@padding-after"/>
-    <eval expected="5000" xpath="//flow/block[5]/lineArea/char/@padding-before"/>
-    <eval expected="5000" xpath="//flow/block[5]/lineArea/char/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[5]/lineArea/char/@padding-start"/>
+    <eval expected="25560" xpath="//flow/block[2]/lineArea/char/@ipda"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/lineArea/char/@border-after"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/lineArea/char/@border-before"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/lineArea/char/@border-end"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/lineArea/char/@border-start"/>
+    <eval expected="5000" xpath="//flow/block[2]/lineArea/char/@padding-after"/>
+    <eval expected="5000" xpath="//flow/block[2]/lineArea/char/@padding-before"/>
+    <eval expected="5000" xpath="//flow/block[2]/lineArea/char/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[2]/lineArea/char/@padding-start"/>
 
-    <eval expected="7180" xpath="//flow/block[8]/lineArea/char/@baseline"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea/char/@offset"/>
-    <eval expected="5000" xpath="//flow/block[8]/lineArea/char/@ipd"/>
-    <eval expected="17000" xpath="//flow/block[8]/lineArea/char/@ipda"/>
-    <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[8]/lineArea/char/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea/char/@border-before"/>
-    <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[8]/lineArea/char/@border-end"/>
-    <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[8]/lineArea/char/@border-start"/>
-    <eval expected="3000" xpath="//flow/block[8]/lineArea/char/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[8]/lineArea/char/@padding-before"/>
-    <eval expected="2000" xpath="//flow/block[8]/lineArea/char/@padding-end"/>
-    <eval expected="4000" xpath="//flow/block[8]/lineArea/char/@padding-start"/>
+    <eval expected="7180" xpath="//flow/block[3]/lineArea/char/@baseline"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea/char/@offset"/>
+    <eval expected="5000" xpath="//flow/block[3]/lineArea/char/@ipd"/>
+    <eval expected="17000" xpath="//flow/block[3]/lineArea/char/@ipda"/>
+    <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[3]/lineArea/char/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea/char/@border-before"/>
+    <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[3]/lineArea/char/@border-end"/>
+    <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[3]/lineArea/char/@border-start"/>
+    <eval expected="3000" xpath="//flow/block[3]/lineArea/char/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea/char/@padding-before"/>
+    <eval expected="2000" xpath="//flow/block[3]/lineArea/char/@padding-end"/>
+    <eval expected="4000" xpath="//flow/block[3]/lineArea/char/@padding-start"/>
 
-    <eval expected="5744" xpath="//flow/block[11]/lineArea/char/@baseline"/>
-    <eval expected="8616" xpath="//flow/block[11]/lineArea/char/@offset"/>
-    <eval expected="4448" xpath="//flow/block[11]/lineArea/char/@ipd"/>
-    <eval expected="24448" xpath="//flow/block[11]/lineArea/char/@ipda"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[11]/lineArea/char/@border-after"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[11]/lineArea/char/@border-before"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[11]/lineArea/char/@border-end"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[11]/lineArea/char/@border-start"/>
-    <eval expected="5000" xpath="//flow/block[11]/lineArea/char/@padding-after"/>
-    <eval expected="5000" xpath="//flow/block[11]/lineArea/char/@padding-before"/>
-    <eval expected="5000" xpath="//flow/block[11]/lineArea/char/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[11]/lineArea/char/@padding-start"/>
+    <eval expected="5744" xpath="//flow/block[4]/lineArea/char/@baseline"/>
+    <eval expected="8616" xpath="//flow/block[4]/lineArea/char/@offset"/>
+    <eval expected="4448" xpath="//flow/block[4]/lineArea/char/@ipd"/>
+    <eval expected="24448" xpath="//flow/block[4]/lineArea/char/@ipda"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/lineArea/char/@border-after"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/lineArea/char/@border-before"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/lineArea/char/@border-end"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/lineArea/char/@border-start"/>
+    <eval expected="5000" xpath="//flow/block[4]/lineArea/char/@padding-after"/>
+    <eval expected="5000" xpath="//flow/block[4]/lineArea/char/@padding-before"/>
+    <eval expected="5000" xpath="//flow/block[4]/lineArea/char/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[4]/lineArea/char/@padding-start"/>
   </checks>
 </testcase>

test/layoutengine/testcases/character_vertical-align.xml

@@ -50,10 +50,10 @@
     </fo:root>
   </fo>
   <checks>
+    <eval expected="7180" xpath="//flow/block[1]/lineArea/char/@offset"/>
     <eval expected="7180" xpath="//flow/block[2]/lineArea/char/@offset"/>
-    <eval expected="7180" xpath="//flow/block[5]/lineArea/char/@offset"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea/char/@offset"/>
-    <eval expected="4565" xpath="//flow/block[11]/lineArea/char/@offset"/>
-    <eval expected="9250" xpath="//flow/block[14]/lineArea/char/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea/char/@offset"/>
+    <eval expected="4565" xpath="//flow/block[4]/lineArea/char/@offset"/>
+    <eval expected="9250" xpath="//flow/block[5]/lineArea/char/@offset"/>
   </checks>
 </testcase>

test/layoutengine/testcases/footnote_space-resolution.xml

@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Copyright 2005 The Apache Software Foundation
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<!-- $Id$ -->
+<testcase>
+  <info>
+    <p>
+      This test checks space-resolution inside the footnotes area.
+    </p>
+  </info>
+  <fo>
+    <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+      <fo:layout-master-set>
+        <fo:simple-page-master master-name="normal" page-width="5in" page-height="3in">
+          <fo:region-body/>
+        </fo:simple-page-master>
+      </fo:layout-master-set>
+      <fo:page-sequence master-reference="normal" white-space-collapse="true">
+        <fo:flow flow-name="xsl-region-body">
+          <fo:block>region-body<fo:footnote>
+              <fo:inline font-size="50%" vertical-align="super">1</fo:inline>
+              <fo:footnote-body>
+                <fo:block space-before="1em" space-after="1em">
+                  <fo:inline font-size="50%" vertical-align="super">1</fo:inline>I'm a footnote!</fo:block>
+              </fo:footnote-body>
+            </fo:footnote>
+            blah<fo:footnote>
+              <fo:inline font-size="50%" vertical-align="super">2</fo:inline>
+              <fo:footnote-body>
+                <fo:block space-before="1em" space-after="1em">
+                  <fo:inline font-size="50%" vertical-align="super">2</fo:inline>I'm a footnote!</fo:block>
+              </fo:footnote-body>
+            </fo:footnote>
+          </fo:block>
+        </fo:flow>
+      </fo:page-sequence>
+    </fo:root>
+  </fo>
+  <checks>
+    <true xpath="not(boolean(//footnotes/block[1]/@space-before))"/>
+    <true xpath="not(boolean(//footnotes/block[1]/@space-after))"/>
+    <eval expected="12000" xpath="//footnotes/block[2]/@space-before"/>
+    <true xpath="not(boolean(//footnotes/block[2]/@space-after))"/>
+  </checks>
+</testcase>

test/layoutengine/testcases/inline_alignment-adjust_1.xml

@@ -86,22 +86,22 @@
     </fo:root>
   </fo>
   <checks>
+    <eval expected="2872" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="2872" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="2872" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="2872" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="10052" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="2872" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="10052" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="10052" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="5427" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="5487" xpath="//flow/block[7]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="802" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="802" xpath="//flow/block[9]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="802" xpath="//flow/block[10]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="2872" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="8616" xpath="//flow/block[12]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="6462" xpath="//flow/block[13]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="10052" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="5427" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="5487" xpath="//flow/block[20]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="802" xpath="//flow/block[23]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="802" xpath="//flow/block[26]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="802" xpath="//flow/block[29]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="2872" xpath="//flow/block[32]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="8616" xpath="//flow/block[35]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="6462" xpath="//flow/block[38]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="10052" xpath="//flow/block[41]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="802" xpath="//flow/block[44]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="10052" xpath="//flow/block[47]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="802" xpath="//flow/block[50]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="802" xpath="//flow/block[15]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="10052" xpath="//flow/block[16]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="802" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
   </checks>
 </testcase>

test/layoutengine/testcases/inline_alignment-adjust_2.xml

@@ -53,6 +53,13 @@
     </fo:root>
   </fo>
   <checks>
+    <eval expected="12950" xpath="//flow/block[1]/lineArea[1]/@bpd"/>
+    <eval expected="1925" xpath="//flow/block[1]/lineArea[1]/@space-before"/>
+    <eval expected="1925" xpath="//flow/block[1]/lineArea[1]/@space-after"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="2872" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[2]/@offset"/>
+    
     <eval expected="12950" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
     <eval expected="1925" xpath="//flow/block[2]/lineArea[1]/@space-before"/>
     <eval expected="1925" xpath="//flow/block[2]/lineArea[1]/@space-after"/>
@@ -60,39 +67,32 @@
     <eval expected="2872" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[2]/@offset"/>
     
-    <eval expected="12950" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
-    <eval expected="1925" xpath="//flow/block[5]/lineArea[1]/@space-before"/>
-    <eval expected="1925" xpath="//flow/block[5]/lineArea[1]/@space-after"/>
-    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="2872" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
-    
-    <eval expected="13078" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
-    <eval expected="1925" xpath="//flow/block[8]/lineArea[1]/@space-before"/>
-    <eval expected="1925" xpath="//flow/block[8]/lineArea[1]/@space-after"/>
-    <eval expected="128" xpath="//flow/block[8]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="128" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="13078" xpath="//flow/block[3]/lineArea[1]/@bpd"/>
+    <eval expected="1925" xpath="//flow/block[3]/lineArea[1]/@space-before"/>
+    <eval expected="1925" xpath="//flow/block[3]/lineArea[1]/@space-after"/>
+    <eval expected="128" xpath="//flow/block[3]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="128" xpath="//flow/block[3]/lineArea[1]/text[2]/@offset"/>
     
-    <eval expected="15122" xpath="//flow/block[11]/lineArea[1]/@bpd"/>
-    <eval expected="1925" xpath="//flow/block[11]/lineArea[1]/@space-before"/>
-    <eval expected="1925" xpath="//flow/block[11]/lineArea[1]/@space-after"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="5872" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="15122" xpath="//flow/block[4]/lineArea[1]/@bpd"/>
+    <eval expected="1925" xpath="//flow/block[4]/lineArea[1]/@space-before"/>
+    <eval expected="1925" xpath="//flow/block[4]/lineArea[1]/@space-after"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="5872" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[2]/@offset"/>
     
-    <eval expected="13678" xpath="//flow/block[14]/lineArea[1]/@bpd"/>
-    <eval expected="1925" xpath="//flow/block[14]/lineArea[1]/@space-before"/>
-    <eval expected="1925" xpath="//flow/block[14]/lineArea[1]/@space-after"/>
-    <eval expected="728" xpath="//flow/block[14]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="728" xpath="//flow/block[14]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="13678" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
+    <eval expected="1925" xpath="//flow/block[5]/lineArea[1]/@space-before"/>
+    <eval expected="1925" xpath="//flow/block[5]/lineArea[1]/@space-after"/>
+    <eval expected="728" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="728" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
     
-    <eval expected="15722" xpath="//flow/block[17]/lineArea[1]/@bpd"/>
-    <eval expected="1925" xpath="//flow/block[17]/lineArea[1]/@space-before"/>
-    <eval expected="1925" xpath="//flow/block[17]/lineArea[1]/@space-after"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="6472" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="15722" xpath="//flow/block[6]/lineArea[1]/@bpd"/>
+    <eval expected="1925" xpath="//flow/block[6]/lineArea[1]/@space-before"/>
+    <eval expected="1925" xpath="//flow/block[6]/lineArea[1]/@space-after"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="6472" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/text[2]/@offset"/>
   </checks>
 </testcase>

test/layoutengine/testcases/inline_alignment-baseline_1.xml

@@ -86,22 +86,22 @@
     </fo:root>
   </fo>
   <checks>
+    <eval expected="2872" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="2872" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="2872" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="2872" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="2872" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="1850" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="1826" xpath="//flow/block[7]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="3700" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="3700" xpath="//flow/block[9]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="3700" xpath="//flow/block[10]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="2872" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="574" xpath="//flow/block[12]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="1436" xpath="//flow/block[13]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="1850" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="1826" xpath="//flow/block[20]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="3700" xpath="//flow/block[23]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="3700" xpath="//flow/block[26]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="3700" xpath="//flow/block[29]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="2872" xpath="//flow/block[32]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="574" xpath="//flow/block[35]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="1436" xpath="//flow/block[38]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[41]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="3700" xpath="//flow/block[44]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[47]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="3700" xpath="//flow/block[50]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="3700" xpath="//flow/block[15]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[16]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="3700" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
   </checks>
 </testcase>

test/layoutengine/testcases/inline_alignment-baseline_2.xml

@@ -86,55 +86,55 @@
     </fo:root>
   </fo>
   <checks>
+    <eval expected="2872" xpath="//flow/block[1]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="2872" xpath="//flow/block[1]/lineArea[1]/text[2]/@offset"/>
+
     <eval expected="2872" xpath="//flow/block[2]/lineArea[1]/text[1]/@offset"/>
     <eval expected="2872" xpath="//flow/block[2]/lineArea[1]/text[2]/@offset"/>
 
-    <eval expected="2872" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="2872" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
-
-    <eval expected="2872" xpath="//flow/block[8]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="2872" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="2872" xpath="//flow/block[3]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="2872" xpath="//flow/block[3]/lineArea[1]/text[2]/@offset"/>
 
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[2]/@offset"/>
 
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
 
-    <eval expected="1850" xpath="//flow/block[17]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="1850" xpath="//flow/block[17]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="1850" xpath="//flow/block[6]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="1850" xpath="//flow/block[6]/lineArea[1]/text[2]/@offset"/>
 
-    <eval expected="1826" xpath="//flow/block[20]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="1826" xpath="//flow/block[20]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="1826" xpath="//flow/block[7]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="1826" xpath="//flow/block[7]/lineArea[1]/text[2]/@offset"/>
 
-    <eval expected="0" xpath="//flow/block[23]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[23]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
 
-    <eval expected="3700" xpath="//flow/block[26]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="3700" xpath="//flow/block[26]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="3700" xpath="//flow/block[9]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="3700" xpath="//flow/block[9]/lineArea[1]/text[2]/@offset"/>
 
-    <eval expected="3700" xpath="//flow/block[29]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="3700" xpath="//flow/block[29]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="3700" xpath="//flow/block[10]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="3700" xpath="//flow/block[10]/lineArea[1]/text[2]/@offset"/>
 
-    <eval expected="2872" xpath="//flow/block[32]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="2872" xpath="//flow/block[32]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="2872" xpath="//flow/block[11]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="2872" xpath="//flow/block[11]/lineArea[1]/text[2]/@offset"/>
 
-    <eval expected="574" xpath="//flow/block[35]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="574" xpath="//flow/block[35]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="574" xpath="//flow/block[12]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="574" xpath="//flow/block[12]/lineArea[1]/text[2]/@offset"/>
 
-    <eval expected="1436" xpath="//flow/block[38]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="1436" xpath="//flow/block[38]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="1436" xpath="//flow/block[13]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="1436" xpath="//flow/block[13]/lineArea[1]/text[2]/@offset"/>
 
-    <eval expected="0" xpath="//flow/block[41]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[41]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[2]/@offset"/>
 
-    <eval expected="0" xpath="//flow/block[44]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[44]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="0" xpath="//flow/block[15]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[15]/lineArea[1]/text[2]/@offset"/>
 
-    <eval expected="0" xpath="//flow/block[47]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[47]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="0" xpath="//flow/block[16]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[16]/lineArea[1]/text[2]/@offset"/>
 
-    <eval expected="3700" xpath="//flow/block[50]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="3700" xpath="//flow/block[50]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="3700" xpath="//flow/block[17]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="3700" xpath="//flow/block[17]/lineArea[1]/text[2]/@offset"/>
   </checks>
 </testcase>

test/layoutengine/testcases/inline_alignment-baseline_3.xml

@@ -86,22 +86,22 @@
     </fo:root>
   </fo>
   <checks>
+    <eval expected="2872" xpath="//flow/block[1]/lineArea[1]/inlineparent[2]/@offset"/>
     <eval expected="2872" xpath="//flow/block[2]/lineArea[1]/inlineparent[2]/@offset"/>
-    <eval expected="2872" xpath="//flow/block[5]/lineArea[1]/inlineparent[2]/@offset"/>
-    <eval expected="2872" xpath="//flow/block[8]/lineArea[1]/inlineparent[2]/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent[2]/@offset"/>
-    <eval expected="1436" xpath="//flow/block[14]/lineArea[1]/inlineparent[2]/@offset"/>
-    <eval expected="2361" xpath="//flow/block[17]/lineArea[1]/inlineparent[2]/@offset"/>
-    <eval expected="2349" xpath="//flow/block[20]/lineArea[1]/inlineparent[2]/@offset"/>
-    <eval expected="3700" xpath="//flow/block[23]/lineArea[1]/inlineparent[2]/@offset"/>
-    <eval expected="3286" xpath="//flow/block[26]/lineArea[1]/inlineparent[2]/@offset"/>
-    <eval expected="3286" xpath="//flow/block[29]/lineArea[1]/inlineparent[2]/@offset"/>
-    <eval expected="2872" xpath="//flow/block[32]/lineArea[1]/inlineparent[2]/@offset"/>
-    <eval expected="1723" xpath="//flow/block[35]/lineArea[1]/inlineparent[2]/@offset"/>
-    <eval expected="2154" xpath="//flow/block[38]/lineArea[1]/inlineparent[2]/@offset"/>
-    <eval expected="0" xpath="//flow/block[41]/lineArea[1]/inlineparent[2]/@offset"/>
-    <eval expected="3700" xpath="//flow/block[44]/lineArea[1]/inlineparent[2]/@offset"/>
-    <eval expected="1436" xpath="//flow/block[47]/lineArea[1]/inlineparent[2]/@offset"/>
-    <eval expected="3286" xpath="//flow/block[50]/lineArea[1]/inlineparent[2]/@offset"/>
+    <eval expected="2872" xpath="//flow/block[3]/lineArea[1]/inlineparent[2]/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent[2]/@offset"/>
+    <eval expected="1436" xpath="//flow/block[5]/lineArea[1]/inlineparent[2]/@offset"/>
+    <eval expected="2361" xpath="//flow/block[6]/lineArea[1]/inlineparent[2]/@offset"/>
+    <eval expected="2349" xpath="//flow/block[7]/lineArea[1]/inlineparent[2]/@offset"/>
+    <eval expected="3700" xpath="//flow/block[8]/lineArea[1]/inlineparent[2]/@offset"/>
+    <eval expected="3286" xpath="//flow/block[9]/lineArea[1]/inlineparent[2]/@offset"/>
+    <eval expected="3286" xpath="//flow/block[10]/lineArea[1]/inlineparent[2]/@offset"/>
+    <eval expected="2872" xpath="//flow/block[11]/lineArea[1]/inlineparent[2]/@offset"/>
+    <eval expected="1723" xpath="//flow/block[12]/lineArea[1]/inlineparent[2]/@offset"/>
+    <eval expected="2154" xpath="//flow/block[13]/lineArea[1]/inlineparent[2]/@offset"/>
+    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent[2]/@offset"/>
+    <eval expected="3700" xpath="//flow/block[15]/lineArea[1]/inlineparent[2]/@offset"/>
+    <eval expected="1436" xpath="//flow/block[16]/lineArea[1]/inlineparent[2]/@offset"/>
+    <eval expected="3286" xpath="//flow/block[17]/lineArea[1]/inlineparent[2]/@offset"/>
   </checks>
 </testcase>

test/layoutengine/testcases/inline_alignment-baseline_4.xml

@@ -132,6 +132,15 @@
     </fo:root>
   </fo>
   <checks>
+    <eval expected="22200" xpath="//flow/block[1]/lineArea[1]/@bpd"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="8616" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/text[1]/@offset"/>
+    <eval expected="-4308" xpath="//flow/block[1]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/text[2]/@offset"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[2]/@offset"/>
+
     <eval expected="22200" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[1]/@offset"/>
     <eval expected="8616" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
@@ -141,91 +150,82 @@
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/text[2]/@offset"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[2]/@offset"/>
 
+    <eval expected="22200" xpath="//flow/block[3]/lineArea[1]/@bpd"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="1723" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/text[1]/@offset"/>
+    <eval expected="6494" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/text[2]/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/text[2]/@offset"/>
+
+    <eval expected="22200" xpath="//flow/block[4]/lineArea[1]/@bpd"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="1723" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/text[1]/@offset"/>
+    <eval expected="2739" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/text[2]/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[2]/@offset"/>
+
     <eval expected="22200" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="8616" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="-4308" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="5550" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/@offset"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/text[2]/@offset"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
 
-    <eval expected="22200" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="1723" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="6494" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/text[2]/@offset"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
-
-    <eval expected="22200" xpath="//flow/block[11]/lineArea[1]/@bpd"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="1723" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="2739" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/text[2]/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[2]/@offset"/>
-
-    <eval expected="22200" xpath="//flow/block[14]/lineArea[1]/@bpd"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="5550" xpath="//flow/block[14]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/text[2]/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="27750" xpath="//flow/block[6]/lineArea[1]/@bpd"/>
+    <eval expected="5550" xpath="//flow/block[6]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="5550" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/text[1]/@offset"/>
+    <eval expected="-5550" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/text[2]/@offset"/>
+    <eval expected="5550" xpath="//flow/block[6]/lineArea[1]/text[2]/@offset"/>
 
-    <eval expected="27750" xpath="//flow/block[17]/lineArea[1]/@bpd"/>
-    <eval expected="5550" xpath="//flow/block[17]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="5550" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="-5550" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/text[2]/@offset"/>
-    <eval expected="5550" xpath="//flow/block[17]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="22200" xpath="//flow/block[7]/lineArea[1]/@bpd"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="8325" xpath="//flow/block[7]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[1]/inlineparent/text[1]/@offset"/>
+    <eval expected="-8325" xpath="//flow/block[7]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
+    <eval expected="4308" xpath="//flow/block[7]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[1]/inlineparent/inlineparent/text[2]/@offset"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[1]/text[2]/@offset"/>
 
-    <eval expected="22200" xpath="//flow/block[20]/lineArea[1]/@bpd"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="8325" xpath="//flow/block[20]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="-8325" xpath="//flow/block[20]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
-    <eval expected="4308" xpath="//flow/block[20]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[1]/inlineparent/inlineparent/text[2]/@offset"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[1]/text[2]/@offset"/>
-
-    <eval expected="22491" xpath="//flow/block[23]/lineArea[1]/@bpd"/>
-    <eval expected="291" xpath="//flow/block[23]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="8616" xpath="//flow/block[23]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
-    <eval expected="-8616" xpath="//flow/block[23]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/inlineparent/text[2]/@offset"/>
-    <eval expected="291" xpath="//flow/block[23]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="22491" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
+    <eval expected="291" xpath="//flow/block[8]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="8616" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
+    <eval expected="-8616" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/text[2]/@offset"/>
+    <eval expected="291" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
 
-    <eval expected="22200" xpath="//flow/block[26]/lineArea[1]/@bpd"/>
-    <eval expected="0" xpath="//flow/block[26]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="8325" xpath="//flow/block[26]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[26]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[26]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[26]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
-    <eval expected="-6462" xpath="//flow/block[26]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[26]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="0" xpath="//flow/block[26]/lineArea[1]/inlineparent/inlineparent/text[2]/@offset"/>
-    <eval expected="0" xpath="//flow/block[26]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="22200" xpath="//flow/block[9]/lineArea[1]/@bpd"/>
+    <eval expected="0" xpath="//flow/block[9]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="8325" xpath="//flow/block[9]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[9]/lineArea[1]/inlineparent/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[9]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[9]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
+    <eval expected="-6462" xpath="//flow/block[9]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[9]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="0" xpath="//flow/block[9]/lineArea[1]/inlineparent/inlineparent/text[2]/@offset"/>
+    <eval expected="0" xpath="//flow/block[9]/lineArea[1]/text[2]/@offset"/>
 
-    <eval expected="27750" xpath="//flow/block[29]/lineArea[1]/@bpd"/>
-    <eval expected="5550" xpath="//flow/block[29]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[29]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[29]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="-5550" xpath="//flow/block[29]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[29]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="0" xpath="//flow/block[29]/lineArea[1]/inlineparent/text[2]/@offset"/>
-    <eval expected="5550" xpath="//flow/block[29]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="27750" xpath="//flow/block[10]/lineArea[1]/@bpd"/>
+    <eval expected="5550" xpath="//flow/block[10]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[10]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[10]/lineArea[1]/inlineparent/text[1]/@offset"/>
+    <eval expected="-5550" xpath="//flow/block[10]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[10]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="0" xpath="//flow/block[10]/lineArea[1]/inlineparent/text[2]/@offset"/>
+    <eval expected="5550" xpath="//flow/block[10]/lineArea[1]/text[2]/@offset"/>
   </checks>
 </testcase>

test/layoutengine/testcases/inline_background-color.xml

@@ -82,51 +82,51 @@
     </fo:root>
   </fo>
   <checks>
+    <eval expected="90040" xpath="//flow/block[1]/lineArea/inlineparent/@ipd"/>
+    <eval expected="color=#ffff00" xpath="//flow/block[1]/lineArea/inlineparent/@background"/>
+
     <eval expected="90040" xpath="//flow/block[2]/lineArea/inlineparent/@ipd"/>
     <eval expected="color=#ffff00" xpath="//flow/block[2]/lineArea/inlineparent/@background"/>
 
-    <eval expected="90040" xpath="//flow/block[5]/lineArea/inlineparent/@ipd"/>
-    <eval expected="color=#ffff00" xpath="//flow/block[5]/lineArea/inlineparent/@background"/>
-
-    <eval expected="90040" xpath="//flow/block[8]/lineArea/inlineparent/@ipd"/>
-    <eval expected="color=#ffff00" xpath="//flow/block[8]/lineArea/inlineparent/@background"/>
+    <eval expected="90040" xpath="//flow/block[3]/lineArea/inlineparent/@ipd"/>
+    <eval expected="color=#ffff00" xpath="//flow/block[3]/lineArea/inlineparent/@background"/>
 
-    <eval expected="90040" xpath="//flow/block[11]/lineArea/inlineparent/@ipd"/>
-    <eval expected="color=#ffff00" xpath="//flow/block[11]/lineArea/inlineparent/@background"/>
+    <eval expected="90040" xpath="//flow/block[4]/lineArea/inlineparent/@ipd"/>
+    <eval expected="color=#ffff00" xpath="//flow/block[4]/lineArea/inlineparent/@background"/>
 
-    <eval expected="188950" xpath="//flow/block[14]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="color=#ffff00" xpath="//flow/block[14]/lineArea[1]/inlineparent/@background"/>
-    <eval expected="313470" xpath="//flow/block[14]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="color=#ffff00" xpath="//flow/block[14]/lineArea[2]/inlineparent/@background"/>
-    <eval expected="145610" xpath="//flow/block[14]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="color=#ffff00" xpath="//flow/block[14]/lineArea[3]/inlineparent/@background"/>
+    <eval expected="188950" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="color=#ffff00" xpath="//flow/block[5]/lineArea[1]/inlineparent/@background"/>
+    <eval expected="313470" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="color=#ffff00" xpath="//flow/block[5]/lineArea[2]/inlineparent/@background"/>
+    <eval expected="145610" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="color=#ffff00" xpath="//flow/block[5]/lineArea[3]/inlineparent/@background"/>
 
-    <eval expected="188950" xpath="//flow/block[17]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="color=#ffff00" xpath="//flow/block[17]/lineArea[1]/inlineparent/@background"/>
-    <eval expected="313470" xpath="//flow/block[17]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="color=#ffff00" xpath="//flow/block[17]/lineArea[2]/inlineparent/@background"/>
-    <eval expected="109650" xpath="//flow/block[17]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="color=#ffff00" xpath="//flow/block[17]/lineArea[3]/inlineparent/@background"/>
+    <eval expected="188950" xpath="//flow/block[6]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="color=#ffff00" xpath="//flow/block[6]/lineArea[1]/inlineparent/@background"/>
+    <eval expected="313470" xpath="//flow/block[6]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="color=#ffff00" xpath="//flow/block[6]/lineArea[2]/inlineparent/@background"/>
+    <eval expected="109650" xpath="//flow/block[6]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="color=#ffff00" xpath="//flow/block[6]/lineArea[3]/inlineparent/@background"/>
 
-    <eval expected="199793" xpath="//flow/block[20]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="color=#ffff00" xpath="//flow/block[20]/lineArea[1]/inlineparent/@background"/>
-    <eval expected="350000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="color=#ffff00" xpath="//flow/block[20]/lineArea[2]/inlineparent/@background"/>
-    <eval expected="118530" xpath="//flow/block[20]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="color=#ffff00" xpath="//flow/block[20]/lineArea[3]/inlineparent/@background"/>
+    <eval expected="199793" xpath="//flow/block[7]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="color=#ffff00" xpath="//flow/block[7]/lineArea[1]/inlineparent/@background"/>
+    <eval expected="350000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="color=#ffff00" xpath="//flow/block[7]/lineArea[2]/inlineparent/@background"/>
+    <eval expected="118530" xpath="//flow/block[7]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="color=#ffff00" xpath="//flow/block[7]/lineArea[3]/inlineparent/@background"/>
 
-    <eval expected="128370" xpath="//flow/block[23]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="color=#ffff00" xpath="//flow/block[23]/lineArea[1]/inlineparent/@background"/>
-    <eval expected="269560" xpath="//flow/block[23]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="color=#ffff00" xpath="//flow/block[23]/lineArea[2]/inlineparent/@background"/>
-    <eval expected="225250" xpath="//flow/block[23]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="color=#ffff00" xpath="//flow/block[23]/lineArea[3]/inlineparent/@background"/>
+    <eval expected="128370" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="color=#ffff00" xpath="//flow/block[8]/lineArea[1]/inlineparent/@background"/>
+    <eval expected="269560" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="color=#ffff00" xpath="//flow/block[8]/lineArea[2]/inlineparent/@background"/>
+    <eval expected="225250" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="color=#ffff00" xpath="//flow/block[8]/lineArea[3]/inlineparent/@background"/>
 
-    <eval expected="151184" xpath="//flow/block[26]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="color=#ffff00" xpath="//flow/block[26]/lineArea[1]/inlineparent/@background"/>
-    <eval expected="81704" xpath="//flow/block[26]/lineArea[1]/inlineparent/inlineparent/@ipd"/>
-    <eval expected="161644" xpath="//flow/block[26]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="color=#ffff00" xpath="//flow/block[26]/lineArea[2]/inlineparent/@background"/>
-    <eval expected="67704" xpath="//flow/block[26]/lineArea[2]/inlineparent/inlineparent/@ipd"/>
+    <eval expected="151184" xpath="//flow/block[9]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="color=#ffff00" xpath="//flow/block[9]/lineArea[1]/inlineparent/@background"/>
+    <eval expected="81704" xpath="//flow/block[9]/lineArea[1]/inlineparent/inlineparent/@ipd"/>
+    <eval expected="161644" xpath="//flow/block[9]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="color=#ffff00" xpath="//flow/block[9]/lineArea[2]/inlineparent/@background"/>
+    <eval expected="67704" xpath="//flow/block[9]/lineArea[2]/inlineparent/inlineparent/@ipd"/>
   </checks>
 </testcase>

test/layoutengine/testcases/inline_baseline-shift_1.xml

@@ -98,67 +98,67 @@
     </fo:root>
   </fo>
   <checks>
-    <eval expected="12950" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
+    <eval expected="12950" xpath="//flow/block[1]/lineArea[1]/@bpd"/>
+    <eval expected="1925" xpath="//flow/block[1]/lineArea[1]/@space-before"/>
+    <eval expected="1925" xpath="//flow/block[1]/lineArea[1]/@space-after"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="2872" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[2]/@offset"/>
+    
+    <eval expected="14737" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
     <eval expected="1925" xpath="//flow/block[2]/lineArea[1]/@space-before"/>
     <eval expected="1925" xpath="//flow/block[2]/lineArea[1]/@space-after"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="2872" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="5487" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[2]/@offset"/>
     
-    <eval expected="14737" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
+    <eval expected="17400" xpath="//flow/block[3]/lineArea[1]/@bpd"/>
+    <eval expected="1925" xpath="//flow/block[3]/lineArea[1]/@space-before"/>
+    <eval expected="1925" xpath="//flow/block[3]/lineArea[1]/@space-after"/>
+    <eval expected="4450" xpath="//flow/block[3]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="4450" xpath="//flow/block[3]/lineArea[1]/text[2]/@offset"/>
+    
+    <eval expected="12950" xpath="//flow/block[4]/lineArea[1]/@bpd"/>
+    <eval expected="1925" xpath="//flow/block[4]/lineArea[1]/@space-before"/>
+    <eval expected="1925" xpath="//flow/block[4]/lineArea[1]/@space-after"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="2872" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[2]/@offset"/>
+    
+    <eval expected="12950" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
     <eval expected="1925" xpath="//flow/block[5]/lineArea[1]/@space-before"/>
     <eval expected="1925" xpath="//flow/block[5]/lineArea[1]/@space-after"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="5487" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="2872" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
     
-    <eval expected="17400" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
+    <eval expected="13078" xpath="//flow/block[6]/lineArea[1]/@bpd"/>
+    <eval expected="1925" xpath="//flow/block[6]/lineArea[1]/@space-before"/>
+    <eval expected="1925" xpath="//flow/block[6]/lineArea[1]/@space-after"/>
+    <eval expected="128" xpath="//flow/block[6]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="128" xpath="//flow/block[6]/lineArea[1]/text[2]/@offset"/>
+    
+    <eval expected="15122" xpath="//flow/block[7]/lineArea[1]/@bpd"/>
+    <eval expected="1925" xpath="//flow/block[7]/lineArea[1]/@space-before"/>
+    <eval expected="1925" xpath="//flow/block[7]/lineArea[1]/@space-after"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="5872" xpath="//flow/block[7]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[1]/text[2]/@offset"/>
+    
+    <eval expected="15118" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
     <eval expected="1925" xpath="//flow/block[8]/lineArea[1]/@space-before"/>
     <eval expected="1925" xpath="//flow/block[8]/lineArea[1]/@space-after"/>
-    <eval expected="4450" xpath="//flow/block[8]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="2168" xpath="//flow/block[8]/lineArea[1]/text[1]/@offset"/>
     <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="4450" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
-    
-    <eval expected="12950" xpath="//flow/block[11]/lineArea[1]/@bpd"/>
-    <eval expected="1925" xpath="//flow/block[11]/lineArea[1]/@space-before"/>
-    <eval expected="1925" xpath="//flow/block[11]/lineArea[1]/@space-after"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="2872" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[2]/@offset"/>
-    
-    <eval expected="12950" xpath="//flow/block[14]/lineArea[1]/@bpd"/>
-    <eval expected="1925" xpath="//flow/block[14]/lineArea[1]/@space-before"/>
-    <eval expected="1925" xpath="//flow/block[14]/lineArea[1]/@space-after"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="2872" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[2]/@offset"/>
-    
-    <eval expected="13078" xpath="//flow/block[17]/lineArea[1]/@bpd"/>
-    <eval expected="1925" xpath="//flow/block[17]/lineArea[1]/@space-before"/>
-    <eval expected="1925" xpath="//flow/block[17]/lineArea[1]/@space-after"/>
-    <eval expected="128" xpath="//flow/block[17]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="128" xpath="//flow/block[17]/lineArea[1]/text[2]/@offset"/>
-    
-    <eval expected="15122" xpath="//flow/block[20]/lineArea[1]/@bpd"/>
-    <eval expected="1925" xpath="//flow/block[20]/lineArea[1]/@space-before"/>
-    <eval expected="1925" xpath="//flow/block[20]/lineArea[1]/@space-after"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="5872" xpath="//flow/block[20]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[1]/text[2]/@offset"/>
-    
-    <eval expected="15118" xpath="//flow/block[23]/lineArea[1]/@bpd"/>
-    <eval expected="1925" xpath="//flow/block[23]/lineArea[1]/@space-before"/>
-    <eval expected="1925" xpath="//flow/block[23]/lineArea[1]/@space-after"/>
-    <eval expected="2168" xpath="//flow/block[23]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="2168" xpath="//flow/block[23]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="2168" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
     
-    <eval expected="17162" xpath="//flow/block[26]/lineArea[1]/@bpd"/>
-    <eval expected="1925" xpath="//flow/block[26]/lineArea[1]/@space-before"/>
-    <eval expected="1925" xpath="//flow/block[26]/lineArea[1]/@space-after"/>
-    <eval expected="0" xpath="//flow/block[26]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="7912" xpath="//flow/block[26]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[26]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="17162" xpath="//flow/block[9]/lineArea[1]/@bpd"/>
+    <eval expected="1925" xpath="//flow/block[9]/lineArea[1]/@space-before"/>
+    <eval expected="1925" xpath="//flow/block[9]/lineArea[1]/@space-after"/>
+    <eval expected="0" xpath="//flow/block[9]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="7912" xpath="//flow/block[9]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[9]/lineArea[1]/text[2]/@offset"/>
   </checks>
 </testcase>

test/layoutengine/testcases/inline_baseline-shift_2.xml

@@ -111,61 +111,62 @@
     </fo:root>
   </fo>
   <checks>
-    <eval expected="16415" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
+    <eval expected="16415" xpath="//flow/block[1]/lineArea[1]/@bpd"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="5487" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/text[1]/@offset"/>
+    <eval expected="3528" xpath="//flow/block[1]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/text[2]/@offset"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[2]/@offset"/>
+    
+    <eval expected="14737" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[1]/@offset"/>
     <eval expected="5487" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="3528" xpath="//flow/block[2]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="-3794" xpath="//flow/block[2]/lineArea[1]/inlineparent/inlineparent/@offset"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/text[2]/@offset"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[2]/@offset"/>
     
-    <eval expected="14737" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
-    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="5487" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="21194" xpath="//flow/block[3]/lineArea[1]/@bpd"/>
+    <eval expected="8244" xpath="//flow/block[3]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="3794" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/text[1]/@offset"/>
+    <eval expected="-3794" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/text[2]/@offset"/>
+    <eval expected="8244" xpath="//flow/block[3]/lineArea[1]/text[2]/@offset"/>
+    
+    <eval expected="17400" xpath="//flow/block[4]/lineArea[1]/@bpd"/>
+    <eval expected="4450" xpath="//flow/block[4]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/text[1]/@offset"/>
+    <eval expected="3528" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/text[2]/@offset"/>
+    <eval expected="4450" xpath="//flow/block[4]/lineArea[1]/text[2]/@offset"/>
+    
+    <eval expected="15118" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
+    <eval expected="2168" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="-3794" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="7436" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/@offset"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/text[2]/@offset"/>
-    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
-    
-    <eval expected="21194" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
-    <eval expected="8244" xpath="//flow/block[8]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="3794" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="-3794" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/text[2]/@offset"/>
-    <eval expected="8244" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="2168" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
     
-    <eval expected="17400" xpath="//flow/block[11]/lineArea[1]/@bpd"/>
-    <eval expected="4450" xpath="//flow/block[11]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="3528" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/text[2]/@offset"/>
-    <eval expected="4450" xpath="//flow/block[11]/lineArea[1]/text[2]/@offset"/>
-    
-    <eval expected="15118" xpath="//flow/block[14]/lineArea[1]/@bpd"/>
-    <eval expected="2168" xpath="//flow/block[14]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="7436" xpath="//flow/block[14]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/text[2]/@offset"/>
-    <eval expected="2168" xpath="//flow/block[14]/lineArea[1]/text[2]/@offset"/>
-    
-    <eval expected="39060" xpath="//flow/block[17]/lineArea[1]/@bpd"/>
-    <eval expected="25086" xpath="//flow/block[17]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="14892" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="1968" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
-    <eval expected="-16860" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/text[2]/@offset"/>
-    <eval expected="25086" xpath="//flow/block[17]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="39060" xpath="//flow/block[6]/lineArea[1]/@bpd"/>
+    <eval expected="25086" xpath="//flow/block[6]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="14892" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/text[1]/@offset"/>
+    <eval expected="1968" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
+    <eval expected="-16860" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/text[2]/@offset"/>
+    <eval expected="25086" xpath="//flow/block[6]/lineArea[1]/text[2]/@offset"/>
   </checks>
 </testcase>
+

test/layoutengine/testcases/inline_baseline-shift_3.xml

@@ -135,76 +135,76 @@
     </fo:root>
   </fo>
   <checks>
-    <eval expected="14846" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
+    <eval expected="14846" xpath="//flow/block[1]/lineArea[1]/@bpd"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="1826" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/text[1]/@offset"/>
+    <eval expected="5620" xpath="//flow/block[1]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/text[2]/@offset"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[2]/@offset"/>
+    
+    <eval expected="12950" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[1]/@offset"/>
     <eval expected="1826" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="5620" xpath="//flow/block[2]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="-1702" xpath="//flow/block[2]/lineArea[1]/inlineparent/inlineparent/@offset"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/text[2]/@offset"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[2]/@offset"/>
+
+    <eval expected="12950" xpath="//flow/block[3]/lineArea[1]/@bpd"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="3700" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/text[1]/@offset"/>
+    <eval expected="-1750" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/text[2]/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/text[2]/@offset"/>
+    
+    <eval expected="13400" xpath="//flow/block[4]/lineArea[1]/@bpd"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/text[1]/@offset"/>
+    <eval expected="6000" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/text[2]/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[2]/@offset"/>
     
     <eval expected="12950" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
     <eval expected="1826" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="-1702" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="3528" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/@offset"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/text[2]/@offset"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
-
-    <eval expected="12950" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
+    
+    <eval expected="14918" xpath="//flow/block[6]/lineArea[1]/@bpd"/>
+    <eval expected="1968" xpath="//flow/block[6]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="3794" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/text[1]/@offset"/>
+    <eval expected="-3794" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/text[2]/@offset"/>
+    <eval expected="1968" xpath="//flow/block[6]/lineArea[1]/text[2]/@offset"/>
+    
+    <eval expected="12950" xpath="//flow/block[7]/lineArea[1]/@bpd"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="3700" xpath="//flow/block[7]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[1]/inlineparent/text[1]/@offset"/>
+    <eval expected="-2992" xpath="//flow/block[7]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[1]/inlineparent/text[2]/@offset"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[1]/text[2]/@offset"/>
+    
+    <eval expected="17708" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
     <eval expected="0" xpath="//flow/block[8]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="3700" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="-1750" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="10308" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/@offset"/>
     <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
     <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/text[2]/@offset"/>
     <eval expected="0" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
-    
-    <eval expected="13400" xpath="//flow/block[11]/lineArea[1]/@bpd"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="6000" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/text[2]/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[2]/@offset"/>
-    
-    <eval expected="12950" xpath="//flow/block[14]/lineArea[1]/@bpd"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="1826" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="3528" xpath="//flow/block[14]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/text[2]/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[2]/@offset"/>
-    
-    <eval expected="14918" xpath="//flow/block[17]/lineArea[1]/@bpd"/>
-    <eval expected="1968" xpath="//flow/block[17]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="3794" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="-3794" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/text[2]/@offset"/>
-    <eval expected="1968" xpath="//flow/block[17]/lineArea[1]/text[2]/@offset"/>
-    
-    <eval expected="12950" xpath="//flow/block[20]/lineArea[1]/@bpd"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="3700" xpath="//flow/block[20]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="-2992" xpath="//flow/block[20]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[1]/inlineparent/text[2]/@offset"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[1]/text[2]/@offset"/>
-    
-    <eval expected="17708" xpath="//flow/block[23]/lineArea[1]/@bpd"/>
-    <eval expected="0" xpath="//flow/block[23]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="10308" xpath="//flow/block[23]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/text[2]/@offset"/>
-    <eval expected="0" xpath="//flow/block[23]/lineArea[1]/text[2]/@offset"/>
   </checks>
 </testcase>

test/layoutengine/testcases/inline_baseline-shift_4.xml

@@ -121,64 +121,64 @@
     </fo:root>
   </fo>
   <checks>
+    <eval expected="17100" xpath="//flow/block[1]/lineArea[1]/@bpd"/>
+    <eval expected="2300" xpath="//flow/block[1]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent[1]/text[1]/@offset"/>
+    <eval expected="6000" xpath="//flow/block[1]/lineArea[1]/inlineparent[2]/@offset"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent[2]/text[1]/@offset"/>
+    <eval expected="2300" xpath="//flow/block[1]/lineArea[1]/text[2]/@offset"/>
+    
     <eval expected="17100" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
-    <eval expected="2300" xpath="//flow/block[2]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="9700" xpath="//flow/block[2]/lineArea[1]/inlineparent[1]/@offset"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent[1]/text[1]/@offset"/>
-    <eval expected="6000" xpath="//flow/block[2]/lineArea[1]/inlineparent[2]/@offset"/>
+    <eval expected="3700" xpath="//flow/block[2]/lineArea[1]/inlineparent[2]/@offset"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent[2]/text[1]/@offset"/>
-    <eval expected="2300" xpath="//flow/block[2]/lineArea[1]/text[2]/@offset"/>
-    
-    <eval expected="17100" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
-    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="9700" xpath="//flow/block[5]/lineArea[1]/inlineparent[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent[1]/text[1]/@offset"/>
-    <eval expected="3700" xpath="//flow/block[5]/lineArea[1]/inlineparent[2]/@offset"/>
-    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent[2]/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[2]/@offset"/>
     
-    <eval expected="16892" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="5792" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="1436" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/text[2]/@offset"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="16892" xpath="//flow/block[3]/lineArea[1]/@bpd"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="5792" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="1436" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/text[2]/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/text[2]/@offset"/>
     
-    <eval expected="23168" xpath="//flow/block[11]/lineArea[1]/@bpd"/>
-    <eval expected="8368" xpath="//flow/block[11]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="3700" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="-3700" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="5136" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/text[2]/@offset"/>
-    <eval expected="8368" xpath="//flow/block[11]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="23168" xpath="//flow/block[4]/lineArea[1]/@bpd"/>
+    <eval expected="8368" xpath="//flow/block[4]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="3700" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/text[1]/@offset"/>
+    <eval expected="-3700" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="5136" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/text[2]/@offset"/>
+    <eval expected="8368" xpath="//flow/block[4]/lineArea[1]/text[2]/@offset"/>
     
-    <eval expected="14800" xpath="//flow/block[14]/lineArea[1]/@bpd"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="5792" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="-2872" xpath="//flow/block[14]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/text[2]/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="14800" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
+    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="5792" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/text[1]/@offset"/>
+    <eval expected="-2872" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/text[2]/@offset"/>
+    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
     
-    <eval expected="22340" xpath="//flow/block[17]/lineArea[1]/@bpd"/>
-    <eval expected="7540" xpath="//flow/block[17]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="2872" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="-2872" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="5550" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/text[2]/@offset"/>
-    <eval expected="7540" xpath="//flow/block[17]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="22340" xpath="//flow/block[6]/lineArea[1]/@bpd"/>
+    <eval expected="7540" xpath="//flow/block[6]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="2872" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/text[1]/@offset"/>
+    <eval expected="-2872" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="5550" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/text[2]/@offset"/>
+    <eval expected="7540" xpath="//flow/block[6]/lineArea[1]/text[2]/@offset"/>
   </checks>
 </testcase>

test/layoutengine/testcases/inline_border_padding.xml

@@ -59,82 +59,82 @@
     </fo:root>
   </fo>
   <checks>
-    <eval expected="48350" xpath="//flow/block[2]/lineArea/inlineparent/@ipd"/>
-    <eval expected="50350" xpath="//flow/block[2]/lineArea/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[2]/lineArea/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea/inlineparent/@border-start"/>
+    <eval expected="48350" xpath="//flow/block[1]/lineArea/inlineparent/@ipd"/>
+    <eval expected="50350" xpath="//flow/block[1]/lineArea/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea/inlineparent/@border-start"/>
     
-    <eval expected="208190" xpath="//flow/block[5]/lineArea/inlineparent/@ipd"/>
-    <eval expected="228190" xpath="//flow/block[5]/lineArea/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[5]/lineArea/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[5]/lineArea/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[5]/lineArea/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[5]/lineArea/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[5]/lineArea/inlineparent/@border-start"/>
-    <eval expected="5000" xpath="//flow/block[5]/lineArea/inlineparent/@padding-after"/>
-    <eval expected="5000" xpath="//flow/block[5]/lineArea/inlineparent/@padding-before"/>
-    <eval expected="5000" xpath="//flow/block[5]/lineArea/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[5]/lineArea/inlineparent/@padding-start"/>
+    <eval expected="208190" xpath="//flow/block[2]/lineArea/inlineparent/@ipd"/>
+    <eval expected="228190" xpath="//flow/block[2]/lineArea/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[2]/lineArea/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/lineArea/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/lineArea/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/lineArea/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/lineArea/inlineparent/@border-start"/>
+    <eval expected="5000" xpath="//flow/block[2]/lineArea/inlineparent/@padding-after"/>
+    <eval expected="5000" xpath="//flow/block[2]/lineArea/inlineparent/@padding-before"/>
+    <eval expected="5000" xpath="//flow/block[2]/lineArea/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[2]/lineArea/inlineparent/@padding-start"/>
     
-    <eval expected="151170" xpath="//flow/block[8]/lineArea/inlineparent/@ipd"/>
-    <eval expected="163170" xpath="//flow/block[8]/lineArea/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[8]/lineArea/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[8]/lineArea/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[8]/lineArea/inlineparent/@border-start"/>
-    <eval expected="3000" xpath="//flow/block[8]/lineArea/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[8]/lineArea/inlineparent/@padding-before"/>
-    <eval expected="2000" xpath="//flow/block[8]/lineArea/inlineparent/@padding-end"/>
-    <eval expected="4000" xpath="//flow/block[8]/lineArea/inlineparent/@padding-start"/>
+    <eval expected="151170" xpath="//flow/block[3]/lineArea/inlineparent/@ipd"/>
+    <eval expected="163170" xpath="//flow/block[3]/lineArea/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[3]/lineArea/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[3]/lineArea/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[3]/lineArea/inlineparent/@border-start"/>
+    <eval expected="3000" xpath="//flow/block[3]/lineArea/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea/inlineparent/@padding-before"/>
+    <eval expected="2000" xpath="//flow/block[3]/lineArea/inlineparent/@padding-end"/>
+    <eval expected="4000" xpath="//flow/block[3]/lineArea/inlineparent/@padding-start"/>
     
-    <eval expected="64464" xpath="//flow/block[11]/lineArea/inlineparent/@ipd"/>
-    <eval expected="84464" xpath="//flow/block[11]/lineArea/inlineparent/@ipda"/>
-    <eval expected="8616" xpath="//flow/block[11]/lineArea/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[11]/lineArea/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[11]/lineArea/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[11]/lineArea/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[11]/lineArea/inlineparent/@border-start"/>
-    <eval expected="5000" xpath="//flow/block[11]/lineArea/inlineparent/@padding-after"/>
-    <eval expected="5000" xpath="//flow/block[11]/lineArea/inlineparent/@padding-before"/>
-    <eval expected="5000" xpath="//flow/block[11]/lineArea/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[11]/lineArea/inlineparent/@padding-start"/>
+    <eval expected="64464" xpath="//flow/block[4]/lineArea/inlineparent/@ipd"/>
+    <eval expected="84464" xpath="//flow/block[4]/lineArea/inlineparent/@ipda"/>
+    <eval expected="8616" xpath="//flow/block[4]/lineArea/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/lineArea/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/lineArea/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/lineArea/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/lineArea/inlineparent/@border-start"/>
+    <eval expected="5000" xpath="//flow/block[4]/lineArea/inlineparent/@padding-after"/>
+    <eval expected="5000" xpath="//flow/block[4]/lineArea/inlineparent/@padding-before"/>
+    <eval expected="5000" xpath="//flow/block[4]/lineArea/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[4]/lineArea/inlineparent/@padding-start"/>
     
-    <eval expected="340710" xpath="//flow/block[14]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="343710" xpath="//flow/block[14]/lineArea[3]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[3]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-start"/>
-    <eval expected="2000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-start"/>
-    <eval expected="193840" xpath="//flow/block[14]/lineArea[4]/inlineparent/@ipd"/>
-    <eval expected="196840" xpath="//flow/block[14]/lineArea[4]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[4]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[4]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[4]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[4]/inlineparent/@border-end"/>
-    <eval expected="2000" xpath="//flow/block[14]/lineArea[4]/inlineparent/@padding-end"/>
+    <eval expected="340710" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="343710" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[5]/lineArea[3]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-start"/>
+    <eval expected="2000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-start"/>
+    <eval expected="193840" xpath="//flow/block[5]/lineArea[4]/inlineparent/@ipd"/>
+    <eval expected="196840" xpath="//flow/block[5]/lineArea[4]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[5]/lineArea[4]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[4]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[4]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[4]/inlineparent/@border-end"/>
+    <eval expected="2000" xpath="//flow/block[5]/lineArea[4]/inlineparent/@padding-end"/>
     
-    <eval expected="118830" xpath="//flow/block[17]/lineArea/inlineparent/@ipd"/>
-    <eval expected="126830" xpath="//flow/block[17]/lineArea/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[17]/lineArea/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[17]/lineArea/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[17]/lineArea/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[17]/lineArea/inlineparent/@border-start"/>
-    <eval expected="2000" xpath="//flow/block[17]/lineArea/inlineparent/@padding-end"/>
-    <eval expected="2000" xpath="//flow/block[17]/lineArea/inlineparent/@padding-start"/>
-    <eval expected="78930" xpath="//flow/block[17]/lineArea/inlineparent/inlineparent/@ipd"/>
-    <eval expected="84930" xpath="//flow/block[17]/lineArea/inlineparent/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea/inlineparent/inlineparent/@offset"/>
-    <eval expected="(solid,#008000,1000)" xpath="//flow/block[17]/lineArea/inlineparent/inlineparent/@border-after"/>
-    <eval expected="(solid,#008000,1000)" xpath="//flow/block[17]/lineArea/inlineparent/inlineparent/@border-before"/>
-    <eval expected="(solid,#008000,1000)" xpath="//flow/block[17]/lineArea/inlineparent/inlineparent/@border-end"/>
-    <eval expected="(solid,#008000,1000)" xpath="//flow/block[17]/lineArea/inlineparent/inlineparent/@border-start"/>
-    <eval expected="2000" xpath="//flow/block[17]/lineArea/inlineparent/inlineparent/@padding-end"/>
-    <eval expected="2000" xpath="//flow/block[17]/lineArea/inlineparent/inlineparent/@padding-start"/>
+    <eval expected="118830" xpath="//flow/block[6]/lineArea/inlineparent/@ipd"/>
+    <eval expected="126830" xpath="//flow/block[6]/lineArea/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[6]/lineArea/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[6]/lineArea/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[6]/lineArea/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[6]/lineArea/inlineparent/@border-start"/>
+    <eval expected="2000" xpath="//flow/block[6]/lineArea/inlineparent/@padding-end"/>
+    <eval expected="2000" xpath="//flow/block[6]/lineArea/inlineparent/@padding-start"/>
+    <eval expected="78930" xpath="//flow/block[6]/lineArea/inlineparent/inlineparent/@ipd"/>
+    <eval expected="84930" xpath="//flow/block[6]/lineArea/inlineparent/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea/inlineparent/inlineparent/@offset"/>
+    <eval expected="(solid,#008000,1000)" xpath="//flow/block[6]/lineArea/inlineparent/inlineparent/@border-after"/>
+    <eval expected="(solid,#008000,1000)" xpath="//flow/block[6]/lineArea/inlineparent/inlineparent/@border-before"/>
+    <eval expected="(solid,#008000,1000)" xpath="//flow/block[6]/lineArea/inlineparent/inlineparent/@border-end"/>
+    <eval expected="(solid,#008000,1000)" xpath="//flow/block[6]/lineArea/inlineparent/inlineparent/@border-start"/>
+    <eval expected="2000" xpath="//flow/block[6]/lineArea/inlineparent/inlineparent/@padding-end"/>
+    <eval expected="2000" xpath="//flow/block[6]/lineArea/inlineparent/inlineparent/@padding-start"/>
   </checks>
 </testcase>

test/layoutengine/testcases/inline_border_padding_block_nested_1.xml

@@ -62,65 +62,65 @@
     </fo:root>
   </fo>
   <checks>
+    <eval expected="347000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@ipd"/>
+    <eval expected="350000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@ipda"/>
+    <eval expected="3000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@border-start"/>
+    <eval expected="2000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@padding-after"/>
+    <eval expected="2000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@padding-before"/>
+    <eval expected="2000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@padding-start"/>
+    <eval expected="46130" xpath="//flow/block[1]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="49130" xpath="//flow/block[1]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="2000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-after"/>
+    <eval expected="2000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-before"/>
+    <eval expected="2000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-end"/>
+
+    <eval expected="54470" xpath="//flow/block[2]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="57470" xpath="//flow/block[2]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="3000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[1]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[1]/inlineparent/@border-start"/>
+    <eval expected="2000" xpath="//flow/block[2]/lineArea[1]/inlineparent/@padding-after"/>
+    <eval expected="2000" xpath="//flow/block[2]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="2000" xpath="//flow/block[2]/lineArea[1]/inlineparent/@padding-start"/>
     <eval expected="347000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@ipd"/>
     <eval expected="350000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@ipda"/>
-    <eval expected="3000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@offset"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@border-after"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@border-start"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@border-end"/>
     <eval expected="2000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@padding-after"/>
     <eval expected="2000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@padding-before"/>
-    <eval expected="2000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@padding-start"/>
-    <eval expected="46130" xpath="//flow/block[2]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="49130" xpath="//flow/block[2]/lineArea[3]/inlineparent/@ipda"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[3]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[3]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="2000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-after"/>
-    <eval expected="2000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-before"/>
-    <eval expected="2000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-end"/>
-
-    <eval expected="54470" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="57470" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipda"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-start"/>
-    <eval expected="2000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-after"/>
-    <eval expected="2000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="2000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="347000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@ipd"/>
-    <eval expected="350000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@ipda"/>
-    <eval expected="3000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@border-end"/>
-    <eval expected="2000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@padding-after"/>
-    <eval expected="2000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@padding-before"/>
-    <eval expected="2000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@padding-end"/>
+    <eval expected="2000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@padding-end"/>
     
-    <eval expected="54470" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="57470" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipda"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="2000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="350000" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@ipd"/>
-    <eval expected="350000" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@ipda"/>
-    <eval expected="2000" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@border-before"/>
-    <eval expected="1000" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@padding-before"/>
-    <eval expected="46130" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="49130" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipda"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="1000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-before"/>
-    <eval expected="2000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-end"/>
+    <eval expected="54470" xpath="//flow/block[3]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="57470" xpath="//flow/block[3]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="2000" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="2000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-start"/>
+    <eval expected="350000" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@ipd"/>
+    <eval expected="350000" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@ipda"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@border-before"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@padding-before"/>
+    <eval expected="46130" xpath="//flow/block[3]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="49130" xpath="//flow/block[3]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-before"/>
+    <eval expected="2000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-end"/>
     
   </checks>
 </testcase>

test/layoutengine/testcases/inline_border_padding_block_nested_2.xml

@@ -1,168 +1,168 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  Copyright 2005 The Apache Software Foundation
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
--->
-<!-- $Id$ -->
-<testcase>
-  <info>
-    <p>
-      This test checks fo:inlines with border and padding properties and nested inner blocks.
-    </p>
-  </info>
-  <fo>
-    <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
-      <fo:layout-master-set>
-        <fo:simple-page-master master-name="normal" page-width="5in" page-height="5in" margin="5pt">
-          <fo:region-body/>
-        </fo:simple-page-master>
-      </fo:layout-master-set>
-      <fo:page-sequence master-reference="normal" white-space-collapse="true" language="en">
-        <fo:flow flow-name="xsl-region-body" font-size="10pt">
-          <fo:block background-color="silver" margin="3pt 0pt 3pt 0pt">
-            Before inline
-            <fo:inline 
-              border="solid 1pt red" 
-              border-start-width.length="1pt" 
-              border-start-width.conditionality="retain" 
-              border-end-width.length="1pt" 
-              border-end-width.conditionality="retain" 
-              padding="2pt"
-              padding-start.length="2pt" 
-              padding-start.conditionality="retain" 
-              padding-end.length="2pt" 
-              padding-end.conditionality="retain" 
-              background-color="yellow"><fo:block>starting with a block</fo:block>
-              after block</fo:inline>
-            After inline with conditionality="retain"
-          </fo:block>
-          <fo:block background-color="silver" margin="3pt 0pt 3pt 0pt">
-            Before inline
-            <fo:inline 
-              border="solid 1pt red" 
-              border-start-width.length="1pt" 
-              border-start-width.conditionality="retain" 
-              border-end-width.length="1pt" 
-              border-end-width.conditionality="retain" 
-              padding="2pt"
-              padding-start.length="2pt" 
-              padding-start.conditionality="retain" 
-              padding-end.length="2pt" 
-              padding-end.conditionality="retain" 
-              background-color="yellow">before block
-              <fo:block>having a block at the end of an inline</fo:block></fo:inline>
-            After inline with conditionality="retain"
-          </fo:block>
-          <fo:block background-color="silver" margin="3pt 0pt 3pt 0pt">
-            Before inline
-            <fo:inline 
-              border="solid 1pt red"
-              border-start-width.length="1pt" 
-              border-start-width.conditionality="retain" 
-              border-end-width.length="1pt" 
-              border-end-width.conditionality="retain" 
-              padding="2pt"
-              padding-start.length="2pt" 
-              padding-start.conditionality="retain" 
-              padding-end.length="2pt" 
-              padding-end.conditionality="retain" 
-              background-color="yellow">before block
-              <fo:block>As far as the laws of mathematics refer to reality, they are not certain,
-            and as far as they are certain, they do not refer to reality - Albert Einstein</fo:block>
-            after block</fo:inline>
-            After inline with conditionality="retain"
-          </fo:block>
-        </fo:flow>
-      </fo:page-sequence>
-    </fo:root>
-  </fo>
-  <checks>
-    <eval expected="344000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@ipd"/>
-    <eval expected="350000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@ipda"/>
-    <eval expected="3000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@border-start"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@border-end"/>
-    <eval expected="2000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@padding-after"/>
-    <eval expected="2000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@padding-before"/>
-    <eval expected="2000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@padding-start"/>
-    <eval expected="2000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@padding-end"/>
-    <eval expected="46130" xpath="//flow/block[2]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="52130" xpath="//flow/block[2]/lineArea[3]/inlineparent/@ipda"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[3]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[3]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[3]/inlineparent/@border-start"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="2000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-after"/>
-    <eval expected="2000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-before"/>
-    <eval expected="2000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-start"/>
-    <eval expected="2000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-end"/>
-
-    <eval expected="54470" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="60470" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipda"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-start"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-end"/>
-    <eval expected="2000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-after"/>
-    <eval expected="2000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="2000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="2000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-end"/>
-    <eval expected="344000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@ipd"/>
-    <eval expected="350000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@ipda"/>
-    <eval expected="3000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@border-start"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@border-end"/>
-    <eval expected="2000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@padding-after"/>
-    <eval expected="2000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@padding-before"/>
-    <eval expected="2000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@padding-start"/>
-    <eval expected="2000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@padding-end"/>
-    
-    <eval expected="54470" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="60470" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipda"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-start"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-end"/>
-    <eval expected="2000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-after"/>
-    <eval expected="2000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="2000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="2000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-end"/>
-    <eval expected="344000" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@ipd"/>
-    <eval expected="350000" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@ipda"/>
-    <eval expected="3000" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@border-start"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@border-end"/>
-    <eval expected="2000" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@padding-after"/>
-    <eval expected="2000" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@padding-before"/>
-    <eval expected="2000" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@padding-start"/>
-    <eval expected="2000" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@padding-end"/>
-    <eval expected="46130" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="52130" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipda"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-start"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="2000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-after"/>
-    <eval expected="2000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-before"/>
-    <eval expected="2000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-start"/>
-    <eval expected="2000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-end"/>
-    
-  </checks>
-</testcase>
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Copyright 2005 The Apache Software Foundation
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<!-- $Id$ -->
+<testcase>
+  <info>
+    <p>
+      This test checks fo:inlines with border and padding properties and nested inner blocks.
+    </p>
+  </info>
+  <fo>
+    <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+      <fo:layout-master-set>
+        <fo:simple-page-master master-name="normal" page-width="5in" page-height="5in" margin="5pt">
+          <fo:region-body/>
+        </fo:simple-page-master>
+      </fo:layout-master-set>
+      <fo:page-sequence master-reference="normal" white-space-collapse="true" language="en">
+        <fo:flow flow-name="xsl-region-body" font-size="10pt">
+          <fo:block background-color="silver" margin="3pt 0pt 3pt 0pt">
+            Before inline
+            <fo:inline 
+              border="solid 1pt red" 
+              border-start-width.length="1pt" 
+              border-start-width.conditionality="retain" 
+              border-end-width.length="1pt" 
+              border-end-width.conditionality="retain" 
+              padding="2pt"
+              padding-start.length="2pt" 
+              padding-start.conditionality="retain" 
+              padding-end.length="2pt" 
+              padding-end.conditionality="retain" 
+              background-color="yellow"><fo:block>starting with a block</fo:block>
+              after block</fo:inline>
+            After inline with conditionality="retain"
+          </fo:block>
+          <fo:block background-color="silver" margin="3pt 0pt 3pt 0pt">
+            Before inline
+            <fo:inline 
+              border="solid 1pt red" 
+              border-start-width.length="1pt" 
+              border-start-width.conditionality="retain" 
+              border-end-width.length="1pt" 
+              border-end-width.conditionality="retain" 
+              padding="2pt"
+              padding-start.length="2pt" 
+              padding-start.conditionality="retain" 
+              padding-end.length="2pt" 
+              padding-end.conditionality="retain" 
+              background-color="yellow">before block
+              <fo:block>having a block at the end of an inline</fo:block></fo:inline>
+            After inline with conditionality="retain"
+          </fo:block>
+          <fo:block background-color="silver" margin="3pt 0pt 3pt 0pt">
+            Before inline
+            <fo:inline 
+              border="solid 1pt red"
+              border-start-width.length="1pt" 
+              border-start-width.conditionality="retain" 
+              border-end-width.length="1pt" 
+              border-end-width.conditionality="retain" 
+              padding="2pt"
+              padding-start.length="2pt" 
+              padding-start.conditionality="retain" 
+              padding-end.length="2pt" 
+              padding-end.conditionality="retain" 
+              background-color="yellow">before block
+              <fo:block>As far as the laws of mathematics refer to reality, they are not certain,
+            and as far as they are certain, they do not refer to reality - Albert Einstein</fo:block>
+            after block</fo:inline>
+            After inline with conditionality="retain"
+          </fo:block>
+        </fo:flow>
+      </fo:page-sequence>
+    </fo:root>
+  </fo>
+  <checks>
+    <eval expected="344000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@ipd"/>
+    <eval expected="350000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@ipda"/>
+    <eval expected="3000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@border-start"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@border-end"/>
+    <eval expected="2000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@padding-after"/>
+    <eval expected="2000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@padding-before"/>
+    <eval expected="2000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@padding-start"/>
+    <eval expected="2000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@padding-end"/>
+    <eval expected="46130" xpath="//flow/block[1]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="52130" xpath="//flow/block[1]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-start"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="2000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-after"/>
+    <eval expected="2000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-before"/>
+    <eval expected="2000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-start"/>
+    <eval expected="2000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-end"/>
+
+    <eval expected="54470" xpath="//flow/block[2]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="60470" xpath="//flow/block[2]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[1]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[1]/inlineparent/@border-start"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[1]/inlineparent/@border-end"/>
+    <eval expected="2000" xpath="//flow/block[2]/lineArea[1]/inlineparent/@padding-after"/>
+    <eval expected="2000" xpath="//flow/block[2]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="2000" xpath="//flow/block[2]/lineArea[1]/inlineparent/@padding-start"/>
+    <eval expected="2000" xpath="//flow/block[2]/lineArea[1]/inlineparent/@padding-end"/>
+    <eval expected="344000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@ipd"/>
+    <eval expected="350000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@ipda"/>
+    <eval expected="3000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@border-start"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@border-end"/>
+    <eval expected="2000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@padding-after"/>
+    <eval expected="2000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@padding-before"/>
+    <eval expected="2000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@padding-start"/>
+    <eval expected="2000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@padding-end"/>
+    
+    <eval expected="54470" xpath="//flow/block[3]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="60470" xpath="//flow/block[3]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-start"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-end"/>
+    <eval expected="2000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-after"/>
+    <eval expected="2000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="2000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-start"/>
+    <eval expected="2000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-end"/>
+    <eval expected="344000" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@ipd"/>
+    <eval expected="350000" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@ipda"/>
+    <eval expected="3000" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@border-start"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@border-end"/>
+    <eval expected="2000" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@padding-after"/>
+    <eval expected="2000" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@padding-before"/>
+    <eval expected="2000" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@padding-start"/>
+    <eval expected="2000" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@padding-end"/>
+    <eval expected="46130" xpath="//flow/block[3]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="52130" xpath="//flow/block[3]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-start"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="2000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-after"/>
+    <eval expected="2000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-before"/>
+    <eval expected="2000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-start"/>
+    <eval expected="2000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-end"/>
+    
+  </checks>
+</testcase>

test/layoutengine/testcases/inline_border_padding_conditionality_1.xml

@@ -155,6 +155,40 @@
     </fo:root>
   </fo>
   <checks>
+    <eval expected="255100" xpath="//flow/block[1]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="265100" xpath="//flow/block[1]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-start"/>
+    <eval expected="335720" xpath="//flow/block[1]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="345720" xpath="//flow/block[1]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[2]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[1]/lineArea[2]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[1]/lineArea[2]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[1]/lineArea[2]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[1]/lineArea[2]/inlineparent/@padding-start"/>
+    <eval expected="35570" xpath="//flow/block[1]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="45570" xpath="//flow/block[1]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[3]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-start"/>
+    
     <eval expected="255100" xpath="//flow/block[2]/lineArea[1]/inlineparent/@ipd"/>
     <eval expected="265100" xpath="//flow/block[2]/lineArea[1]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
@@ -189,210 +223,176 @@
     <eval expected="3000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-end"/>
     <eval expected="5000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-start"/>
     
+    <eval expected="259229" xpath="//flow/block[3]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="269229" xpath="//flow/block[3]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-start"/>
+    <eval expected="340000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="350000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[2]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@padding-start"/>
+    <eval expected="35570" xpath="//flow/block[3]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="45570" xpath="//flow/block[3]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[3]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-start"/>
+    
+    <eval expected="216190" xpath="//flow/block[4]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="226190" xpath="//flow/block[4]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-start"/>
+    <eval expected="299050" xpath="//flow/block[4]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="309050" xpath="//flow/block[4]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[2]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[2]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[2]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[2]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[2]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[4]/lineArea[2]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[4]/lineArea[2]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[4]/lineArea[2]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[4]/lineArea[2]/inlineparent/@padding-start"/>
+    <eval expected="111150" xpath="//flow/block[4]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="121150" xpath="//flow/block[4]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[3]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-start"/>
+    
     <eval expected="255100" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="265100" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="261100" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-after"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-end"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-start"/>
     <eval expected="1000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-after"/>
     <eval expected="1000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-end"/>
     <eval expected="5000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-start"/>
     <eval expected="335720" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="345720" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="335720" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[2]/inlineparent/@offset"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-after"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-start"/>
     <eval expected="1000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-after"/>
     <eval expected="1000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-start"/>
     <eval expected="35570" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="45570" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="39570" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[3]/inlineparent/@offset"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-after"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-before"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-start"/>
     <eval expected="1000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-after"/>
     <eval expected="1000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-before"/>
     <eval expected="3000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-start"/>
     
-    <eval expected="259229" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="269229" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="255100" xpath="//flow/block[6]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="261100" xpath="//flow/block[6]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="5000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-start"/>
+    <eval expected="335720" xpath="//flow/block[6]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="335720" xpath="//flow/block[6]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[2]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[2]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[2]/inlineparent/@border-before"/>
+    <eval expected="1000" xpath="//flow/block[6]/lineArea[2]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[6]/lineArea[2]/inlineparent/@padding-before"/>
+    <eval expected="35570" xpath="//flow/block[6]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="39570" xpath="//flow/block[6]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[3]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="1000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-end"/>
+    
+    <eval expected="262613" xpath="//flow/block[7]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="268613" xpath="//flow/block[7]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[1]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[1]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[7]/lineArea[1]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[7]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="5000" xpath="//flow/block[7]/lineArea[1]/inlineparent/@padding-start"/>
+    <eval expected="350000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="350000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[2]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[2]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[2]/inlineparent/@border-before"/>
+    <eval expected="1000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@padding-before"/>
+    <eval expected="35570" xpath="//flow/block[7]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="39570" xpath="//flow/block[7]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[3]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[3]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[3]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="1000" xpath="//flow/block[7]/lineArea[3]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[7]/lineArea[3]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[7]/lineArea[3]/inlineparent/@padding-end"/>
+    
+    <eval expected="216190" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="222190" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-after"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-end"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-start"/>
     <eval expected="1000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-after"/>
     <eval expected="1000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-end"/>
     <eval expected="5000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="340000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="350000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="310170" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="310170" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[8]/lineArea[2]/inlineparent/@offset"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-after"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-start"/>
     <eval expected="1000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-after"/>
     <eval expected="1000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-start"/>
-    <eval expected="35570" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="45570" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="100030" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="104030" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[8]/lineArea[3]/inlineparent/@offset"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-after"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-before"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-start"/>
     <eval expected="1000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-after"/>
     <eval expected="1000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-before"/>
     <eval expected="3000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-start"/>
-    
-    <eval expected="216190" xpath="//flow/block[11]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="226190" xpath="//flow/block[11]/lineArea[1]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="299050" xpath="//flow/block[11]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="309050" xpath="//flow/block[11]/lineArea[2]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[2]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[2]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[2]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[2]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[2]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[11]/lineArea[2]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[11]/lineArea[2]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[11]/lineArea[2]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[11]/lineArea[2]/inlineparent/@padding-start"/>
-    <eval expected="111150" xpath="//flow/block[11]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="121150" xpath="//flow/block[11]/lineArea[3]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[3]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-start"/>
-    
-    <eval expected="255100" xpath="//flow/block[14]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="261100" xpath="//flow/block[14]/lineArea[1]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="5000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="335720" xpath="//flow/block[14]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="335720" xpath="//flow/block[14]/lineArea[2]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[2]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-before"/>
-    <eval expected="1000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-before"/>
-    <eval expected="35570" xpath="//flow/block[14]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="39570" xpath="//flow/block[14]/lineArea[3]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[3]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="1000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-end"/>
-    
-    <eval expected="255100" xpath="//flow/block[17]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="261100" xpath="//flow/block[17]/lineArea[1]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="5000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="335720" xpath="//flow/block[17]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="335720" xpath="//flow/block[17]/lineArea[2]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[2]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[2]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[2]/inlineparent/@border-before"/>
-    <eval expected="1000" xpath="//flow/block[17]/lineArea[2]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[17]/lineArea[2]/inlineparent/@padding-before"/>
-    <eval expected="35570" xpath="//flow/block[17]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="39570" xpath="//flow/block[17]/lineArea[3]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[3]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="1000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-end"/>
-    
-    <eval expected="262613" xpath="//flow/block[20]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="268613" xpath="//flow/block[20]/lineArea[1]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[1]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[1]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[20]/lineArea[1]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[20]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="5000" xpath="//flow/block[20]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="350000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="350000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[2]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[2]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[2]/inlineparent/@border-before"/>
-    <eval expected="1000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@padding-before"/>
-    <eval expected="35570" xpath="//flow/block[20]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="39570" xpath="//flow/block[20]/lineArea[3]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[3]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[3]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[3]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="1000" xpath="//flow/block[20]/lineArea[3]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[20]/lineArea[3]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[20]/lineArea[3]/inlineparent/@padding-end"/>
-    
-    <eval expected="216190" xpath="//flow/block[23]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="222190" xpath="//flow/block[23]/lineArea[1]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[1]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[1]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[23]/lineArea[1]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[23]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="5000" xpath="//flow/block[23]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="310170" xpath="//flow/block[23]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="310170" xpath="//flow/block[23]/lineArea[2]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[23]/lineArea[2]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[2]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[2]/inlineparent/@border-before"/>
-    <eval expected="1000" xpath="//flow/block[23]/lineArea[2]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[23]/lineArea[2]/inlineparent/@padding-before"/>
-    <eval expected="100030" xpath="//flow/block[23]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="104030" xpath="//flow/block[23]/lineArea[3]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[23]/lineArea[3]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[3]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[3]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="1000" xpath="//flow/block[23]/lineArea[3]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[23]/lineArea[3]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[23]/lineArea[3]/inlineparent/@padding-end"/>
   </checks>
 </testcase>

test/layoutengine/testcases/inline_border_padding_conditionality_2.xml

@@ -128,6 +128,36 @@
     </fo:root>
   </fo>
   <checks>
+    <eval expected="255100" xpath="//flow/block[1]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="264100" xpath="//flow/block[1]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-start"/>
+    <eval expected="335720" xpath="//flow/block[1]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="343720" xpath="//flow/block[1]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[2]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineparent/@border-before"/>
+    <eval expected="1000" xpath="//flow/block[1]/lineArea[2]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[1]/lineArea[2]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[1]/lineArea[2]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[1]/lineArea[2]/inlineparent/@padding-start"/>
+    <eval expected="35570" xpath="//flow/block[1]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="44570" xpath="//flow/block[1]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[3]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="1000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-start"/>
+
     <eval expected="255100" xpath="//flow/block[2]/lineArea[1]/inlineparent/@ipd"/>
     <eval expected="264100" xpath="//flow/block[2]/lineArea[1]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
@@ -158,154 +188,124 @@
     <eval expected="3000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-end"/>
     <eval expected="5000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-start"/>
 
-    <eval expected="255100" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="264100" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="260075" xpath="//flow/block[3]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="269075" xpath="//flow/block[3]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-start"/>
+    <eval expected="342000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="350000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[2]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineparent/@border-before"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@padding-start"/>
+    <eval expected="35570" xpath="//flow/block[3]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="44570" xpath="//flow/block[3]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[3]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-start"/>
+
+    <eval expected="237870" xpath="//flow/block[4]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="246870" xpath="//flow/block[4]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-start"/>
+    <eval expected="317940" xpath="//flow/block[4]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="325940" xpath="//flow/block[4]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[2]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[2]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[2]/inlineparent/@border-before"/>
+    <eval expected="1000" xpath="//flow/block[4]/lineArea[2]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[4]/lineArea[2]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[4]/lineArea[2]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[4]/lineArea[2]/inlineparent/@padding-start"/>
+    <eval expected="70580" xpath="//flow/block[4]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="79580" xpath="//flow/block[4]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[3]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="1000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-start"/>
+
+    <eval expected="183960" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="193960" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-after"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-end"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-start"/>
     <eval expected="1000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-after"/>
     <eval expected="1000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-before"/>
     <eval expected="3000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-end"/>
     <eval expected="5000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="335720" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="343720" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="255680" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="265680" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[2]/inlineparent/@offset"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-after"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-start"/>
     <eval expected="1000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-after"/>
     <eval expected="1000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-before"/>
     <eval expected="3000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-end"/>
     <eval expected="5000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-start"/>
-    <eval expected="35570" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="44570" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="186750" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="196750" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[3]/inlineparent/@offset"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-after"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-before"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-start"/>
     <eval expected="1000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-after"/>
     <eval expected="1000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-before"/>
     <eval expected="3000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-end"/>
     <eval expected="5000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-start"/>
 
-    <eval expected="260075" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="269075" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="342000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="350000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[2]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-before"/>
-    <eval expected="1000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-start"/>
-    <eval expected="35570" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="44570" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[3]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="1000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-start"/>
-
-    <eval expected="237870" xpath="//flow/block[11]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="246870" xpath="//flow/block[11]/lineArea[1]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="317940" xpath="//flow/block[11]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="325940" xpath="//flow/block[11]/lineArea[2]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[2]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[2]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[2]/inlineparent/@border-before"/>
-    <eval expected="1000" xpath="//flow/block[11]/lineArea[2]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[11]/lineArea[2]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[11]/lineArea[2]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[11]/lineArea[2]/inlineparent/@padding-start"/>
-    <eval expected="70580" xpath="//flow/block[11]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="79580" xpath="//flow/block[11]/lineArea[3]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[3]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="1000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-start"/>
-
-    <eval expected="183960" xpath="//flow/block[14]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="193960" xpath="//flow/block[14]/lineArea[1]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="255680" xpath="//flow/block[14]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="265680" xpath="//flow/block[14]/lineArea[2]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[2]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-start"/>
-    <eval expected="186750" xpath="//flow/block[14]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="196750" xpath="//flow/block[14]/lineArea[3]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[3]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-start"/>
-
-    <eval expected="172840" xpath="//flow/block[17]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="178840" xpath="//flow/block[17]/lineArea[1]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="5000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="266800" xpath="//flow/block[17]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="266800" xpath="//flow/block[17]/lineArea[2]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[2]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[2]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[2]/inlineparent/@border-before"/>
-    <eval expected="1000" xpath="//flow/block[17]/lineArea[2]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[17]/lineArea[2]/inlineparent/@padding-before"/>
-    <eval expected="186750" xpath="//flow/block[17]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="190750" xpath="//flow/block[17]/lineArea[3]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[3]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="1000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-end"/>
+    <eval expected="172840" xpath="//flow/block[6]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="178840" xpath="//flow/block[6]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="5000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-start"/>
+    <eval expected="266800" xpath="//flow/block[6]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="266800" xpath="//flow/block[6]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[2]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[2]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[2]/inlineparent/@border-before"/>
+    <eval expected="1000" xpath="//flow/block[6]/lineArea[2]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[6]/lineArea[2]/inlineparent/@padding-before"/>
+    <eval expected="186750" xpath="//flow/block[6]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="190750" xpath="//flow/block[6]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[3]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="1000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-end"/>
   </checks>
 </testcase>

test/layoutengine/testcases/inline_border_padding_hyphenate.xml

@@ -156,6 +156,32 @@
     </fo:root>
   </fo>
   <checks>
+    <eval expected="255100" xpath="//flow/block[1]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="261100" xpath="//flow/block[1]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="5000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-start"/>
+    <eval expected="335720" xpath="//flow/block[1]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="335720" xpath="//flow/block[1]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[2]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineparent/@border-before"/>
+    <eval expected="1000" xpath="//flow/block[1]/lineArea[2]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[1]/lineArea[2]/inlineparent/@padding-before"/>
+    <eval expected="35570" xpath="//flow/block[1]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="39570" xpath="//flow/block[1]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[3]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="1000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-end"/>
+    
     <eval expected="255100" xpath="//flow/block[2]/lineArea[1]/inlineparent/@ipd"/>
     <eval expected="261100" xpath="//flow/block[2]/lineArea[1]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
@@ -182,218 +208,192 @@
     <eval expected="1000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-before"/>
     <eval expected="3000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-end"/>
     
+    <eval expected="262613" xpath="//flow/block[3]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="268613" xpath="//flow/block[3]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="5000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-start"/>
+    <eval expected="350000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="350000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[2]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineparent/@border-before"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@padding-before"/>
+    <eval expected="35570" xpath="//flow/block[3]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="39570" xpath="//flow/block[3]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[3]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-end"/>
+    
+    <eval expected="216190" xpath="//flow/block[4]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="222190" xpath="//flow/block[4]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="5000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-start"/>
+    <eval expected="310170" xpath="//flow/block[4]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="310170" xpath="//flow/block[4]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[2]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[2]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[2]/inlineparent/@border-before"/>
+    <eval expected="1000" xpath="//flow/block[4]/lineArea[2]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[4]/lineArea[2]/inlineparent/@padding-before"/>
+    <eval expected="100030" xpath="//flow/block[4]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="104030" xpath="//flow/block[4]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[3]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="1000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-end"/>
+
     <eval expected="255100" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="261100" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="265100" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-after"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-end"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-start"/>
     <eval expected="1000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-after"/>
     <eval expected="1000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-end"/>
     <eval expected="5000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-start"/>
     <eval expected="335720" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="335720" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="345720" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[2]/inlineparent/@offset"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-after"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-start"/>
     <eval expected="1000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-after"/>
     <eval expected="1000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-start"/>
     <eval expected="35570" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="39570" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="45570" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[3]/inlineparent/@offset"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-after"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-before"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-start"/>
     <eval expected="1000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-after"/>
     <eval expected="1000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-before"/>
     <eval expected="3000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-start"/>
+    
+    <eval expected="255100" xpath="//flow/block[6]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="265100" xpath="//flow/block[6]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-start"/>
+    <eval expected="335720" xpath="//flow/block[6]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="345720" xpath="//flow/block[6]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[2]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[2]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[2]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[2]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[2]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[6]/lineArea[2]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[6]/lineArea[2]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[6]/lineArea[2]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[6]/lineArea[2]/inlineparent/@padding-start"/>
+    <eval expected="35570" xpath="//flow/block[6]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="45570" xpath="//flow/block[6]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[3]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-start"/>
+    
+    <eval expected="259229" xpath="//flow/block[7]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="269229" xpath="//flow/block[7]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[1]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[1]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[1]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[7]/lineArea[1]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[7]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[7]/lineArea[1]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[7]/lineArea[1]/inlineparent/@padding-start"/>
+    <eval expected="340000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="350000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[2]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[2]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[2]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[2]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[2]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@padding-start"/>
+    <eval expected="35570" xpath="//flow/block[7]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="45570" xpath="//flow/block[7]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[3]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[3]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[3]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[3]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[7]/lineArea[3]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[7]/lineArea[3]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[7]/lineArea[3]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[7]/lineArea[3]/inlineparent/@padding-start"/>
     
-    <eval expected="262613" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="268613" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="216190" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="226190" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-after"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-end"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-start"/>
     <eval expected="1000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-after"/>
     <eval expected="1000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-end"/>
     <eval expected="5000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="350000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="350000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="299050" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="309050" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[8]/lineArea[2]/inlineparent/@offset"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-after"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-start"/>
     <eval expected="1000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-after"/>
     <eval expected="1000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-before"/>
-    <eval expected="35570" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="39570" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="3000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-start"/>
+    <eval expected="111150" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="121150" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[8]/lineArea[3]/inlineparent/@offset"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-after"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-before"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-start"/>
     <eval expected="1000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-after"/>
     <eval expected="1000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-before"/>
     <eval expected="3000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-end"/>
-    
-    <eval expected="216190" xpath="//flow/block[11]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="222190" xpath="//flow/block[11]/lineArea[1]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="5000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="310170" xpath="//flow/block[11]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="310170" xpath="//flow/block[11]/lineArea[2]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[2]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[2]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[2]/inlineparent/@border-before"/>
-    <eval expected="1000" xpath="//flow/block[11]/lineArea[2]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[11]/lineArea[2]/inlineparent/@padding-before"/>
-    <eval expected="100030" xpath="//flow/block[11]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="104030" xpath="//flow/block[11]/lineArea[3]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[3]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="1000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-end"/>
-
-    <eval expected="255100" xpath="//flow/block[14]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="265100" xpath="//flow/block[14]/lineArea[1]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="335720" xpath="//flow/block[14]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="345720" xpath="//flow/block[14]/lineArea[2]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[2]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-start"/>
-    <eval expected="35570" xpath="//flow/block[14]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="45570" xpath="//flow/block[14]/lineArea[3]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[3]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-start"/>
-    
-    <eval expected="255100" xpath="//flow/block[17]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="265100" xpath="//flow/block[17]/lineArea[1]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="335720" xpath="//flow/block[17]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="345720" xpath="//flow/block[17]/lineArea[2]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[2]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[2]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[2]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[2]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[2]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[17]/lineArea[2]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[17]/lineArea[2]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[17]/lineArea[2]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[17]/lineArea[2]/inlineparent/@padding-start"/>
-    <eval expected="35570" xpath="//flow/block[17]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="45570" xpath="//flow/block[17]/lineArea[3]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[3]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-start"/>
-    
-    <eval expected="259229" xpath="//flow/block[20]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="269229" xpath="//flow/block[20]/lineArea[1]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[1]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[1]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[1]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[20]/lineArea[1]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[20]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[20]/lineArea[1]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[20]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="340000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="350000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[2]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[2]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[2]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[2]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[2]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@padding-start"/>
-    <eval expected="35570" xpath="//flow/block[20]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="45570" xpath="//flow/block[20]/lineArea[3]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[3]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[3]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[3]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[3]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[20]/lineArea[3]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[20]/lineArea[3]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[20]/lineArea[3]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[20]/lineArea[3]/inlineparent/@padding-start"/>
-    
-    <eval expected="216190" xpath="//flow/block[23]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="226190" xpath="//flow/block[23]/lineArea[1]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[1]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[1]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[1]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[23]/lineArea[1]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[23]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[23]/lineArea[1]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[23]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="299050" xpath="//flow/block[23]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="309050" xpath="//flow/block[23]/lineArea[2]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[23]/lineArea[2]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[2]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[2]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[2]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[2]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[23]/lineArea[2]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[23]/lineArea[2]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[23]/lineArea[2]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[23]/lineArea[2]/inlineparent/@padding-start"/>
-    <eval expected="111150" xpath="//flow/block[23]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="121150" xpath="//flow/block[23]/lineArea[3]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[23]/lineArea[3]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[3]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[3]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[3]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[23]/lineArea[3]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[23]/lineArea[3]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[23]/lineArea[3]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[23]/lineArea[3]/inlineparent/@padding-start"/>
+    <eval expected="5000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-start"/>
   </checks>
 </testcase>

test/layoutengine/testcases/inline_border_padding_hyphenate_de.xml

@@ -156,6 +156,32 @@
     </fo:root>
   </fo>
   <checks>
+    <eval expected="250110" xpath="//flow/block[1]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="256110" xpath="//flow/block[1]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="5000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-start"/>
+    <eval expected="348490" xpath="//flow/block[1]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="348490" xpath="//flow/block[1]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[2]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineparent/@border-before"/>
+    <eval expected="1000" xpath="//flow/block[1]/lineArea[2]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[1]/lineArea[2]/inlineparent/@padding-before"/>
+    <eval expected="91710" xpath="//flow/block[1]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="95710" xpath="//flow/block[1]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[3]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="1000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-end"/>
+    
     <eval expected="250110" xpath="//flow/block[2]/lineArea[1]/inlineparent/@ipd"/>
     <eval expected="256110" xpath="//flow/block[2]/lineArea[1]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
@@ -182,218 +208,192 @@
     <eval expected="1000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-before"/>
     <eval expected="3000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-end"/>
     
+    <eval expected="250110" xpath="//flow/block[3]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="256110" xpath="//flow/block[3]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="5000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-start"/>
+    <eval expected="349999" xpath="//flow/block[3]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="349999" xpath="//flow/block[3]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[2]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineparent/@border-before"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@padding-before"/>
+    <eval expected="91710" xpath="//flow/block[3]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="95710" xpath="//flow/block[3]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[3]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-end"/>
+    
+    <eval expected="238440" xpath="//flow/block[4]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="244440" xpath="//flow/block[4]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="5000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-start"/>
+    <eval expected="320690" xpath="//flow/block[4]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="320690" xpath="//flow/block[4]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[2]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[2]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[2]/inlineparent/@border-before"/>
+    <eval expected="1000" xpath="//flow/block[4]/lineArea[2]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[4]/lineArea[2]/inlineparent/@padding-before"/>
+    <eval expected="131180" xpath="//flow/block[4]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="135180" xpath="//flow/block[4]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[3]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="1000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-end"/>
+
     <eval expected="250110" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="256110" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="260110" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-after"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-end"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-start"/>
     <eval expected="1000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-after"/>
     <eval expected="1000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-end"/>
     <eval expected="5000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="348490" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="348490" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="336820" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="346820" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[2]/inlineparent/@offset"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-after"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-start"/>
     <eval expected="1000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-after"/>
     <eval expected="1000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-before"/>
-    <eval expected="91710" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="95710" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="3000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-start"/>
+    <eval expected="103380" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="113380" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[3]/inlineparent/@offset"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-after"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-before"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-start"/>
     <eval expected="1000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-after"/>
     <eval expected="1000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-before"/>
     <eval expected="3000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-start"/>
+    
+    <eval expected="250110" xpath="//flow/block[6]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="260110" xpath="//flow/block[6]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-start"/>
+    <eval expected="336820" xpath="//flow/block[6]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="346820" xpath="//flow/block[6]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[2]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[2]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[2]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[2]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[2]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[6]/lineArea[2]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[6]/lineArea[2]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[6]/lineArea[2]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[6]/lineArea[2]/inlineparent/@padding-start"/>
+    <eval expected="103380" xpath="//flow/block[6]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="113380" xpath="//flow/block[6]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[3]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-start"/>
+    
+    <eval expected="250110" xpath="//flow/block[7]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="260110" xpath="//flow/block[7]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[1]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[1]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[1]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[7]/lineArea[1]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[7]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[7]/lineArea[1]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[7]/lineArea[1]/inlineparent/@padding-start"/>
+    <eval expected="340000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="350000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[2]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[2]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[2]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[2]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[2]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@padding-start"/>
+    <eval expected="103380" xpath="//flow/block[7]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="113380" xpath="//flow/block[7]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[3]/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[3]/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[3]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[3]/inlineparent/@border-start"/>
+    <eval expected="1000" xpath="//flow/block[7]/lineArea[3]/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[7]/lineArea[3]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[7]/lineArea[3]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[7]/lineArea[3]/inlineparent/@padding-start"/>
     
-    <eval expected="250110" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="256110" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipda"/>
+    <eval expected="238440" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipd"/>
+    <eval expected="248440" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-after"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-end"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-start"/>
     <eval expected="1000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-after"/>
     <eval expected="1000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-before"/>
+    <eval expected="3000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-end"/>
     <eval expected="5000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="349999" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="349999" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipda"/>
+    <eval expected="320690" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipd"/>
+    <eval expected="330690" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[8]/lineArea[2]/inlineparent/@offset"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-after"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-start"/>
     <eval expected="1000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-after"/>
     <eval expected="1000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-before"/>
-    <eval expected="91710" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="95710" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipda"/>
+    <eval expected="3000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-start"/>
+    <eval expected="131180" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipd"/>
+    <eval expected="141180" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipda"/>
     <eval expected="0" xpath="//flow/block[8]/lineArea[3]/inlineparent/@offset"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-after"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-before"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-start"/>
     <eval expected="1000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-after"/>
     <eval expected="1000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-before"/>
     <eval expected="3000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-end"/>
-    
-    <eval expected="238440" xpath="//flow/block[11]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="244440" xpath="//flow/block[11]/lineArea[1]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="5000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="320690" xpath="//flow/block[11]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="320690" xpath="//flow/block[11]/lineArea[2]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[2]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[2]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[2]/inlineparent/@border-before"/>
-    <eval expected="1000" xpath="//flow/block[11]/lineArea[2]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[11]/lineArea[2]/inlineparent/@padding-before"/>
-    <eval expected="131180" xpath="//flow/block[11]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="135180" xpath="//flow/block[11]/lineArea[3]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[3]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="1000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-end"/>
-
-    <eval expected="250110" xpath="//flow/block[14]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="260110" xpath="//flow/block[14]/lineArea[1]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="336820" xpath="//flow/block[14]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="346820" xpath="//flow/block[14]/lineArea[2]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[2]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-start"/>
-    <eval expected="103380" xpath="//flow/block[14]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="113380" xpath="//flow/block[14]/lineArea[3]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[3]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-start"/>
-    
-    <eval expected="250110" xpath="//flow/block[17]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="260110" xpath="//flow/block[17]/lineArea[1]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="336820" xpath="//flow/block[17]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="346820" xpath="//flow/block[17]/lineArea[2]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[2]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[2]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[2]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[2]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[2]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[17]/lineArea[2]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[17]/lineArea[2]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[17]/lineArea[2]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[17]/lineArea[2]/inlineparent/@padding-start"/>
-    <eval expected="103380" xpath="//flow/block[17]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="113380" xpath="//flow/block[17]/lineArea[3]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[3]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-start"/>
-    
-    <eval expected="250110" xpath="//flow/block[20]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="260110" xpath="//flow/block[20]/lineArea[1]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[1]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[1]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[1]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[20]/lineArea[1]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[20]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[20]/lineArea[1]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[20]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="340000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="350000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[2]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[2]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[2]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[2]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[2]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@padding-start"/>
-    <eval expected="103380" xpath="//flow/block[20]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="113380" xpath="//flow/block[20]/lineArea[3]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[3]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[3]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[3]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[3]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[20]/lineArea[3]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[20]/lineArea[3]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[20]/lineArea[3]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[20]/lineArea[3]/inlineparent/@padding-start"/>
-    
-    <eval expected="238440" xpath="//flow/block[23]/lineArea[1]/inlineparent/@ipd"/>
-    <eval expected="248440" xpath="//flow/block[23]/lineArea[1]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[1]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[1]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[1]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[1]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[23]/lineArea[1]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[23]/lineArea[1]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[23]/lineArea[1]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[23]/lineArea[1]/inlineparent/@padding-start"/>
-    <eval expected="320690" xpath="//flow/block[23]/lineArea[2]/inlineparent/@ipd"/>
-    <eval expected="330690" xpath="//flow/block[23]/lineArea[2]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[23]/lineArea[2]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[2]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[2]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[2]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[2]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[23]/lineArea[2]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[23]/lineArea[2]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[23]/lineArea[2]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[23]/lineArea[2]/inlineparent/@padding-start"/>
-    <eval expected="131180" xpath="//flow/block[23]/lineArea[3]/inlineparent/@ipd"/>
-    <eval expected="141180" xpath="//flow/block[23]/lineArea[3]/inlineparent/@ipda"/>
-    <eval expected="0" xpath="//flow/block[23]/lineArea[3]/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[3]/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[3]/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[3]/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[3]/inlineparent/@border-start"/>
-    <eval expected="1000" xpath="//flow/block[23]/lineArea[3]/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[23]/lineArea[3]/inlineparent/@padding-before"/>
-    <eval expected="3000" xpath="//flow/block[23]/lineArea[3]/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[23]/lineArea[3]/inlineparent/@padding-start"/>
+    <eval expected="5000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-start"/>
   </checks>
 </testcase>

test/layoutengine/testcases/inline_dominant-baseline_1.xml

@@ -65,64 +65,64 @@
     </fo:root>
   </fo>
   <checks>
+    <eval expected="12950" xpath="//flow/block[1]/lineArea[1]/@bpd"/>
+    <eval expected="1925" xpath="//flow/block[1]/lineArea[1]/@space-before"/>
+    <eval expected="1925" xpath="//flow/block[1]/lineArea[1]/@space-after"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="2872" xpath="//flow/block[1]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+
     <eval expected="12950" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
     <eval expected="1925" xpath="//flow/block[2]/lineArea[1]/@space-before"/>
     <eval expected="1925" xpath="//flow/block[2]/lineArea[1]/@space-after"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="2872" xpath="//flow/block[2]/lineArea[1]/inlineparent/inlineparent/@offset"/>
 
+    <eval expected="12950" xpath="//flow/block[3]/lineArea[1]/@bpd"/>
+    <eval expected="1925" xpath="//flow/block[3]/lineArea[1]/@space-before"/>
+    <eval expected="1925" xpath="//flow/block[3]/lineArea[1]/@space-after"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="3700" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+
+    <eval expected="12950" xpath="//flow/block[4]/lineArea[1]/@bpd"/>
+    <eval expected="1925" xpath="//flow/block[4]/lineArea[1]/@space-before"/>
+    <eval expected="1925" xpath="//flow/block[4]/lineArea[1]/@space-after"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="2872" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+
     <eval expected="12950" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
     <eval expected="1925" xpath="//flow/block[5]/lineArea[1]/@space-before"/>
     <eval expected="1925" xpath="//flow/block[5]/lineArea[1]/@space-after"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="2872" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="574" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+
+    <eval expected="12950" xpath="//flow/block[6]/lineArea[1]/@bpd"/>
+    <eval expected="1925" xpath="//flow/block[6]/lineArea[1]/@space-before"/>
+    <eval expected="1925" xpath="//flow/block[6]/lineArea[1]/@space-after"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="1436" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+
+    <eval expected="12950" xpath="//flow/block[7]/lineArea[1]/@bpd"/>
+    <eval expected="1925" xpath="//flow/block[7]/lineArea[1]/@space-before"/>
+    <eval expected="1925" xpath="//flow/block[7]/lineArea[1]/@space-after"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="1850" xpath="//flow/block[7]/lineArea[1]/inlineparent/inlineparent/@offset"/>
 
     <eval expected="12950" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
     <eval expected="1925" xpath="//flow/block[8]/lineArea[1]/@space-before"/>
     <eval expected="1925" xpath="//flow/block[8]/lineArea[1]/@space-after"/>
     <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="3700" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-
-    <eval expected="12950" xpath="//flow/block[11]/lineArea[1]/@bpd"/>
-    <eval expected="1925" xpath="//flow/block[11]/lineArea[1]/@space-before"/>
-    <eval expected="1925" xpath="//flow/block[11]/lineArea[1]/@space-after"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="2872" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-
-    <eval expected="12950" xpath="//flow/block[14]/lineArea[1]/@bpd"/>
-    <eval expected="1925" xpath="//flow/block[14]/lineArea[1]/@space-before"/>
-    <eval expected="1925" xpath="//flow/block[14]/lineArea[1]/@space-after"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="574" xpath="//flow/block[14]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-
-    <eval expected="12950" xpath="//flow/block[17]/lineArea[1]/@bpd"/>
-    <eval expected="1925" xpath="//flow/block[17]/lineArea[1]/@space-before"/>
-    <eval expected="1925" xpath="//flow/block[17]/lineArea[1]/@space-after"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="1436" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-
-    <eval expected="12950" xpath="//flow/block[20]/lineArea[1]/@bpd"/>
-    <eval expected="1925" xpath="//flow/block[20]/lineArea[1]/@space-before"/>
-    <eval expected="1925" xpath="//flow/block[20]/lineArea[1]/@space-after"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="1850" xpath="//flow/block[20]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-
-    <eval expected="12950" xpath="//flow/block[23]/lineArea[1]/@bpd"/>
-    <eval expected="1925" xpath="//flow/block[23]/lineArea[1]/@space-before"/>
-    <eval expected="1925" xpath="//flow/block[23]/lineArea[1]/@space-after"/>
-    <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="1826" xpath="//flow/block[23]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="1826" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/@offset"/>
 
-    <eval expected="12950" xpath="//flow/block[26]/lineArea[1]/@bpd"/>
-    <eval expected="1925" xpath="//flow/block[26]/lineArea[1]/@space-before"/>
-    <eval expected="1925" xpath="//flow/block[26]/lineArea[1]/@space-after"/>
-    <eval expected="0" xpath="//flow/block[26]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="3700" xpath="//flow/block[26]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="12950" xpath="//flow/block[9]/lineArea[1]/@bpd"/>
+    <eval expected="1925" xpath="//flow/block[9]/lineArea[1]/@space-before"/>
+    <eval expected="1925" xpath="//flow/block[9]/lineArea[1]/@space-after"/>
+    <eval expected="0" xpath="//flow/block[9]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="3700" xpath="//flow/block[9]/lineArea[1]/inlineparent/inlineparent/@offset"/>
 
-    <eval expected="12950" xpath="//flow/block[29]/lineArea[1]/@bpd"/>
-    <eval expected="1925" xpath="//flow/block[29]/lineArea[1]/@space-before"/>
-    <eval expected="1925" xpath="//flow/block[29]/lineArea[1]/@space-after"/>
-    <eval expected="0" xpath="//flow/block[29]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[29]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="12950" xpath="//flow/block[10]/lineArea[1]/@bpd"/>
+    <eval expected="1925" xpath="//flow/block[10]/lineArea[1]/@space-before"/>
+    <eval expected="1925" xpath="//flow/block[10]/lineArea[1]/@space-after"/>
+    <eval expected="0" xpath="//flow/block[10]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[10]/lineArea[1]/inlineparent/inlineparent/@offset"/>
   </checks>
 </testcase>

test/layoutengine/testcases/inline_dominant-baseline_2.xml

@@ -65,64 +65,64 @@
     </fo:root>
   </fo>
   <checks>
+    <eval expected="12950" xpath="//flow/block[1]/lineArea[1]/@bpd"/>
+    <eval expected="1375" xpath="//flow/block[1]/lineArea[1]/@space-before"/>
+    <eval expected="1375" xpath="//flow/block[1]/lineArea[1]/@space-after"/>
+    <eval expected="2872" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="-2872" xpath="//flow/block[1]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+
     <eval expected="12950" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
     <eval expected="1375" xpath="//flow/block[2]/lineArea[1]/@space-before"/>
     <eval expected="1375" xpath="//flow/block[2]/lineArea[1]/@space-after"/>
     <eval expected="2872" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="-2872" xpath="//flow/block[2]/lineArea[1]/inlineparent/inlineparent/@offset"/>
 
+    <eval expected="12950" xpath="//flow/block[3]/lineArea[1]/@bpd"/>
+    <eval expected="1375" xpath="//flow/block[3]/lineArea[1]/@space-before"/>
+    <eval expected="1375" xpath="//flow/block[3]/lineArea[1]/@space-after"/>
+    <eval expected="3700" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="-3700" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+
+    <eval expected="12950" xpath="//flow/block[4]/lineArea[1]/@bpd"/>
+    <eval expected="1375" xpath="//flow/block[4]/lineArea[1]/@space-before"/>
+    <eval expected="1375" xpath="//flow/block[4]/lineArea[1]/@space-after"/>
+    <eval expected="2872" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="-2872" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+
     <eval expected="12950" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
     <eval expected="1375" xpath="//flow/block[5]/lineArea[1]/@space-before"/>
     <eval expected="1375" xpath="//flow/block[5]/lineArea[1]/@space-after"/>
-    <eval expected="2872" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="-2872" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="574" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="-574" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+
+    <eval expected="12950" xpath="//flow/block[6]/lineArea[1]/@bpd"/>
+    <eval expected="1375" xpath="//flow/block[6]/lineArea[1]/@space-before"/>
+    <eval expected="1375" xpath="//flow/block[6]/lineArea[1]/@space-after"/>
+    <eval expected="1436" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="-1436" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+
+    <eval expected="12950" xpath="//flow/block[7]/lineArea[1]/@bpd"/>
+    <eval expected="1375" xpath="//flow/block[7]/lineArea[1]/@space-before"/>
+    <eval expected="1375" xpath="//flow/block[7]/lineArea[1]/@space-after"/>
+    <eval expected="1850" xpath="//flow/block[7]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="-1850" xpath="//flow/block[7]/lineArea[1]/inlineparent/inlineparent/@offset"/>
 
     <eval expected="12950" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
     <eval expected="1375" xpath="//flow/block[8]/lineArea[1]/@space-before"/>
     <eval expected="1375" xpath="//flow/block[8]/lineArea[1]/@space-after"/>
-    <eval expected="3700" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="-3700" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-
-    <eval expected="12950" xpath="//flow/block[11]/lineArea[1]/@bpd"/>
-    <eval expected="1375" xpath="//flow/block[11]/lineArea[1]/@space-before"/>
-    <eval expected="1375" xpath="//flow/block[11]/lineArea[1]/@space-after"/>
-    <eval expected="2872" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="-2872" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-
-    <eval expected="12950" xpath="//flow/block[14]/lineArea[1]/@bpd"/>
-    <eval expected="1375" xpath="//flow/block[14]/lineArea[1]/@space-before"/>
-    <eval expected="1375" xpath="//flow/block[14]/lineArea[1]/@space-after"/>
-    <eval expected="574" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="-574" xpath="//flow/block[14]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-
-    <eval expected="12950" xpath="//flow/block[17]/lineArea[1]/@bpd"/>
-    <eval expected="1375" xpath="//flow/block[17]/lineArea[1]/@space-before"/>
-    <eval expected="1375" xpath="//flow/block[17]/lineArea[1]/@space-after"/>
-    <eval expected="1436" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="-1436" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-
-    <eval expected="12950" xpath="//flow/block[20]/lineArea[1]/@bpd"/>
-    <eval expected="1375" xpath="//flow/block[20]/lineArea[1]/@space-before"/>
-    <eval expected="1375" xpath="//flow/block[20]/lineArea[1]/@space-after"/>
-    <eval expected="1850" xpath="//flow/block[20]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="-1850" xpath="//flow/block[20]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-
-    <eval expected="12950" xpath="//flow/block[23]/lineArea[1]/@bpd"/>
-    <eval expected="1375" xpath="//flow/block[23]/lineArea[1]/@space-before"/>
-    <eval expected="1375" xpath="//flow/block[23]/lineArea[1]/@space-after"/>
-    <eval expected="1826" xpath="//flow/block[23]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="-1826" xpath="//flow/block[23]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="1826" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="-1826" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/@offset"/>
 
-    <eval expected="12950" xpath="//flow/block[26]/lineArea[1]/@bpd"/>
-    <eval expected="1375" xpath="//flow/block[26]/lineArea[1]/@space-before"/>
-    <eval expected="1375" xpath="//flow/block[26]/lineArea[1]/@space-after"/>
-    <eval expected="3700" xpath="//flow/block[26]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="-3700" xpath="//flow/block[26]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="12950" xpath="//flow/block[9]/lineArea[1]/@bpd"/>
+    <eval expected="1375" xpath="//flow/block[9]/lineArea[1]/@space-before"/>
+    <eval expected="1375" xpath="//flow/block[9]/lineArea[1]/@space-after"/>
+    <eval expected="3700" xpath="//flow/block[9]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="-3700" xpath="//flow/block[9]/lineArea[1]/inlineparent/inlineparent/@offset"/>
 
-    <eval expected="12950" xpath="//flow/block[29]/lineArea[1]/@bpd"/>
-    <eval expected="1375" xpath="//flow/block[29]/lineArea[1]/@space-before"/>
-    <eval expected="1375" xpath="//flow/block[29]/lineArea[1]/@space-after"/>
-    <eval expected="0" xpath="//flow/block[29]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[29]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="12950" xpath="//flow/block[10]/lineArea[1]/@bpd"/>
+    <eval expected="1375" xpath="//flow/block[10]/lineArea[1]/@space-before"/>
+    <eval expected="1375" xpath="//flow/block[10]/lineArea[1]/@space-after"/>
+    <eval expected="0" xpath="//flow/block[10]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[10]/lineArea[1]/inlineparent/inlineparent/@offset"/>
   </checks>
 </testcase>

test/layoutengine/testcases/inline_dominant-baseline_3.xml

@@ -80,36 +80,36 @@
     </fo:root>
   </fo>
   <checks>
+    <eval expected="14800" xpath="//flow/block[1]/lineArea[1]/@bpd"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="5744" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/text[1]/@offset"/>
+    <eval expected="1850" xpath="//flow/block[1]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[2]/@offset"/>
+
     <eval expected="14800" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[1]/@offset"/>
     <eval expected="5744" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="1850" xpath="//flow/block[2]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/inlineparent/@offset"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[2]/@offset"/>
 
-    <eval expected="14800" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
-    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="5744" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
-
-    <eval expected="14800" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="5744" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="-3700" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="14800" xpath="//flow/block[3]/lineArea[1]/@bpd"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="5744" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/text[1]/@offset"/>
+    <eval expected="-3700" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/text[2]/@offset"/>
 
-    <eval expected="15018" xpath="//flow/block[11]/lineArea[1]/@bpd"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="5744" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/text[1]/@offset"/>
-    <eval expected="-1826" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="15018" xpath="//flow/block[4]/lineArea[1]/@bpd"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="5744" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/text[1]/@offset"/>
+    <eval expected="-1826" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[2]/@offset"/>
   </checks>
 </testcase>

test/layoutengine/testcases/inline_vertical-align_1.xml

@@ -68,6 +68,13 @@
     </fo:root>
   </fo>
   <checks>
+    <eval expected="18500" xpath="//flow/block[1]/lineArea[1]/@bpd"/>
+    <eval expected="2750" xpath="//flow/block[1]/lineArea[1]/@space-before"/>
+    <eval expected="2750" xpath="//flow/block[1]/lineArea[1]/@space-after"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="7180" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[2]/@offset"/>
+
     <eval expected="18500" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
     <eval expected="2750" xpath="//flow/block[2]/lineArea[1]/@space-before"/>
     <eval expected="2750" xpath="//flow/block[2]/lineArea[1]/@space-after"/>
@@ -75,74 +82,67 @@
     <eval expected="7180" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[2]/@offset"/>
 
+    <eval expected="18500" xpath="//flow/block[3]/lineArea[1]/@bpd"/>
+    <eval expected="2750" xpath="//flow/block[3]/lineArea[1]/@space-before"/>
+    <eval expected="2750" xpath="//flow/block[3]/lineArea[1]/@space-after"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[1]/text[2]/@offset"/>
+
+    <eval expected="18500" xpath="//flow/block[4]/lineArea[1]/@bpd"/>
+    <eval expected="2750" xpath="//flow/block[4]/lineArea[1]/@space-before"/>
+    <eval expected="2750" xpath="//flow/block[4]/lineArea[1]/@space-after"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[2]/@offset"/>
+
     <eval expected="18500" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
     <eval expected="2750" xpath="//flow/block[5]/lineArea[1]/@space-before"/>
     <eval expected="2750" xpath="//flow/block[5]/lineArea[1]/@space-after"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="7180" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="4565" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
 
-    <eval expected="18500" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
+    <eval expected="18500" xpath="//flow/block[6]/lineArea[1]/@bpd"/>
+    <eval expected="2750" xpath="//flow/block[6]/lineArea[1]/@space-before"/>
+    <eval expected="2750" xpath="//flow/block[6]/lineArea[1]/@space-after"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="9250" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[6]/lineArea[1]/text[2]/@offset"/>
+
+    <eval expected="18500" xpath="//flow/block[7]/lineArea[1]/@bpd"/>
+    <eval expected="2750" xpath="//flow/block[7]/lineArea[1]/@space-before"/>
+    <eval expected="2750" xpath="//flow/block[7]/lineArea[1]/@space-after"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="9250" xpath="//flow/block[7]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[7]/lineArea[1]/text[2]/@offset"/>
+
+    <eval expected="21780" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
     <eval expected="2750" xpath="//flow/block[8]/lineArea[1]/@space-before"/>
     <eval expected="2750" xpath="//flow/block[8]/lineArea[1]/@space-after"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="3280" xpath="//flow/block[8]/lineArea[1]/text[1]/@offset"/>
     <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
+    <eval expected="3280" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
+
+    <eval expected="19045" xpath="//flow/block[9]/lineArea[1]/@bpd"/>
+    <eval expected="2750" xpath="//flow/block[9]/lineArea[1]/@space-before"/>
+    <eval expected="2750" xpath="//flow/block[9]/lineArea[1]/@space-after"/>
+    <eval expected="0" xpath="//flow/block[9]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="9795" xpath="//flow/block[9]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="0" xpath="//flow/block[9]/lineArea[1]/text[2]/@offset"/>
+
+    <eval expected="28960" xpath="//flow/block[10]/lineArea[1]/@bpd"/>
+    <eval expected="2750" xpath="//flow/block[10]/lineArea[1]/@space-before"/>
+    <eval expected="2750" xpath="//flow/block[10]/lineArea[1]/@space-after"/>
+    <eval expected="10460" xpath="//flow/block[10]/lineArea[1]/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[10]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="10460" xpath="//flow/block[10]/lineArea[1]/text[2]/@offset"/>
 
-    <eval expected="18500" xpath="//flow/block[11]/lineArea[1]/@bpd"/>
+    <eval expected="23730" xpath="//flow/block[11]/lineArea[1]/@bpd"/>
     <eval expected="2750" xpath="//flow/block[11]/lineArea[1]/@space-before"/>
     <eval expected="2750" xpath="//flow/block[11]/lineArea[1]/@space-after"/>
     <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
+    <eval expected="5230" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
     <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[2]/@offset"/>
-
-    <eval expected="18500" xpath="//flow/block[14]/lineArea[1]/@bpd"/>
-    <eval expected="2750" xpath="//flow/block[14]/lineArea[1]/@space-before"/>
-    <eval expected="2750" xpath="//flow/block[14]/lineArea[1]/@space-after"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="4565" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[2]/@offset"/>
-
-    <eval expected="18500" xpath="//flow/block[17]/lineArea[1]/@bpd"/>
-    <eval expected="2750" xpath="//flow/block[17]/lineArea[1]/@space-before"/>
-    <eval expected="2750" xpath="//flow/block[17]/lineArea[1]/@space-after"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="9250" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[17]/lineArea[1]/text[2]/@offset"/>
-
-    <eval expected="18500" xpath="//flow/block[20]/lineArea[1]/@bpd"/>
-    <eval expected="2750" xpath="//flow/block[20]/lineArea[1]/@space-before"/>
-    <eval expected="2750" xpath="//flow/block[20]/lineArea[1]/@space-after"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="9250" xpath="//flow/block[20]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[20]/lineArea[1]/text[2]/@offset"/>
-
-    <eval expected="21780" xpath="//flow/block[23]/lineArea[1]/@bpd"/>
-    <eval expected="2750" xpath="//flow/block[23]/lineArea[1]/@space-before"/>
-    <eval expected="2750" xpath="//flow/block[23]/lineArea[1]/@space-after"/>
-    <eval expected="3280" xpath="//flow/block[23]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="3280" xpath="//flow/block[23]/lineArea[1]/text[2]/@offset"/>
-
-    <eval expected="19045" xpath="//flow/block[26]/lineArea[1]/@bpd"/>
-    <eval expected="2750" xpath="//flow/block[26]/lineArea[1]/@space-before"/>
-    <eval expected="2750" xpath="//flow/block[26]/lineArea[1]/@space-after"/>
-    <eval expected="0" xpath="//flow/block[26]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="9795" xpath="//flow/block[26]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[26]/lineArea[1]/text[2]/@offset"/>
-
-    <eval expected="28960" xpath="//flow/block[29]/lineArea[1]/@bpd"/>
-    <eval expected="2750" xpath="//flow/block[29]/lineArea[1]/@space-before"/>
-    <eval expected="2750" xpath="//flow/block[29]/lineArea[1]/@space-after"/>
-    <eval expected="10460" xpath="//flow/block[29]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[29]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="10460" xpath="//flow/block[29]/lineArea[1]/text[2]/@offset"/>
-
-    <eval expected="23730" xpath="//flow/block[32]/lineArea[1]/@bpd"/>
-    <eval expected="2750" xpath="//flow/block[32]/lineArea[1]/@space-before"/>
-    <eval expected="2750" xpath="//flow/block[32]/lineArea[1]/@space-after"/>
-    <eval expected="0" xpath="//flow/block[32]/lineArea[1]/text[1]/@offset"/>
-    <eval expected="5230" xpath="//flow/block[32]/lineArea[1]/inlineparent/@offset"/>
-    <eval expected="0" xpath="//flow/block[32]/lineArea[1]/text[2]/@offset"/>
   </checks>
 </testcase>

test/layoutengine/testcases/inline_vertical-align_2.xml

@@ -70,52 +70,52 @@
     </fo:root>
   </fo>
   <checks>
-    <eval expected="48812" xpath="//flow/block[2]/lineArea[2]/text[1]/@offset"/>
+    <eval expected="48812" xpath="//flow/block[1]/lineArea[2]/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[2]/viewport[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[2]/viewport[2]/@offset"/>
+    <eval expected="48812" xpath="//flow/block[1]/lineArea[2]/text[2]/@offset"/>
+    <eval expected="35995" xpath="//flow/block[1]/lineArea[2]/viewport[3]/@offset"/>
+    <eval expected="17998" xpath="//flow/block[1]/lineArea[2]/viewport[4]/@offset"/>
+    <eval expected="48812" xpath="//flow/block[1]/lineArea[2]/text[3]/@offset"/>
+    <eval expected="34379" xpath="//flow/block[1]/lineArea[2]/viewport[5]/@offset"/>
+    <eval expected="48812" xpath="//flow/block[1]/lineArea[2]/text[4]/@offset"/>
+    <eval expected="0" xpath="//flow/block[1]/lineArea[2]/viewport[6]/@offset"/>
+    <eval expected="48812" xpath="//flow/block[1]/lineArea[2]/text[5]/@offset"/>
+
+    <eval expected="14433" xpath="//flow/block[2]/lineArea[2]/text[1]/@offset"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[2]/viewport[1]/@offset"/>
     <eval expected="0" xpath="//flow/block[2]/lineArea[2]/viewport[2]/@offset"/>
-    <eval expected="48812" xpath="//flow/block[2]/lineArea[2]/text[2]/@offset"/>
+    <eval expected="14433" xpath="//flow/block[2]/lineArea[2]/text[2]/@offset"/>
     <eval expected="35995" xpath="//flow/block[2]/lineArea[2]/viewport[3]/@offset"/>
     <eval expected="17998" xpath="//flow/block[2]/lineArea[2]/viewport[4]/@offset"/>
-    <eval expected="48812" xpath="//flow/block[2]/lineArea[2]/text[3]/@offset"/>
-    <eval expected="34379" xpath="//flow/block[2]/lineArea[2]/viewport[5]/@offset"/>
-    <eval expected="48812" xpath="//flow/block[2]/lineArea[2]/text[4]/@offset"/>
-    <eval expected="0" xpath="//flow/block[2]/lineArea[2]/viewport[6]/@offset"/>
-    <eval expected="48812" xpath="//flow/block[2]/lineArea[2]/text[5]/@offset"/>
+    <eval expected="14433" xpath="//flow/block[2]/lineArea[2]/text[3]/@offset"/>
+    <eval expected="0" xpath="//flow/block[2]/lineArea[2]/viewport[5]/@offset"/>
+    <eval expected="14433" xpath="//flow/block[2]/lineArea[2]/text[4]/@offset"/>
+
+    <eval expected="0" xpath="//flow/block[3]/lineArea[2]/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[2]/viewport[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[2]/viewport[2]/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[2]/text[2]/@offset"/>
+    <eval expected="35995" xpath="//flow/block[3]/lineArea[2]/viewport[3]/@offset"/>
+    <eval expected="17998" xpath="//flow/block[3]/lineArea[2]/viewport[4]/@offset"/>
+    <eval expected="0" xpath="//flow/block[3]/lineArea[2]/text[3]/@offset"/>
+
+    <eval expected="0" xpath="//flow/block[4]/lineArea[2]/text[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[2]/viewport[1]/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[2]/viewport[2]/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[2]/text[2]/@offset"/>
+    <eval expected="35995" xpath="//flow/block[4]/lineArea[2]/viewport[3]/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[2]/viewport[4]/@offset"/>
+    <eval expected="0" xpath="//flow/block[4]/lineArea[2]/text[3]/@offset"/>
 
     <eval expected="14433" xpath="//flow/block[5]/lineArea[2]/text[1]/@offset"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[2]/viewport[1]/@offset"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[2]/viewport[2]/@offset"/>
     <eval expected="14433" xpath="//flow/block[5]/lineArea[2]/text[2]/@offset"/>
     <eval expected="35995" xpath="//flow/block[5]/lineArea[2]/viewport[3]/@offset"/>
-    <eval expected="17998" xpath="//flow/block[5]/lineArea[2]/viewport[4]/@offset"/>
+    <eval expected="0" xpath="//flow/block[5]/lineArea[2]/viewport[4]/@offset"/>
     <eval expected="14433" xpath="//flow/block[5]/lineArea[2]/text[3]/@offset"/>
     <eval expected="0" xpath="//flow/block[5]/lineArea[2]/viewport[5]/@offset"/>
     <eval expected="14433" xpath="//flow/block[5]/lineArea[2]/text[4]/@offset"/>
-
-    <eval expected="0" xpath="//flow/block[8]/lineArea[2]/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[2]/viewport[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[2]/viewport[2]/@offset"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[2]/text[2]/@offset"/>
-    <eval expected="35995" xpath="//flow/block[8]/lineArea[2]/viewport[3]/@offset"/>
-    <eval expected="17998" xpath="//flow/block[8]/lineArea[2]/viewport[4]/@offset"/>
-    <eval expected="0" xpath="//flow/block[8]/lineArea[2]/text[3]/@offset"/>
-
-    <eval expected="0" xpath="//flow/block[11]/lineArea[2]/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[2]/viewport[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[2]/viewport[2]/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[2]/text[2]/@offset"/>
-    <eval expected="35995" xpath="//flow/block[11]/lineArea[2]/viewport[3]/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[2]/viewport[4]/@offset"/>
-    <eval expected="0" xpath="//flow/block[11]/lineArea[2]/text[3]/@offset"/>
-
-    <eval expected="14433" xpath="//flow/block[14]/lineArea[2]/text[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[2]/viewport[1]/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[2]/viewport[2]/@offset"/>
-    <eval expected="14433" xpath="//flow/block[14]/lineArea[2]/text[2]/@offset"/>
-    <eval expected="35995" xpath="//flow/block[14]/lineArea[2]/viewport[3]/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[2]/viewport[4]/@offset"/>
-    <eval expected="14433" xpath="//flow/block[14]/lineArea[2]/text[3]/@offset"/>
-    <eval expected="0" xpath="//flow/block[14]/lineArea[2]/viewport[5]/@offset"/>
-    <eval expected="14433" xpath="//flow/block[14]/lineArea[2]/text[4]/@offset"/>
   </checks>
 </testcase>

test/layoutengine/testcases/leader_border_padding.xml

@@ -141,116 +141,116 @@
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea/space/@border-end"/>
     <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea/space/@border-start"/>
 
+    <eval expected="11100" xpath="//flow/block[6]/lineArea/@bpd"/>
+    <eval expected="360000" xpath="//flow/block[6]/lineArea/@ipd"/>
+    <eval expected="16000" xpath="//flow/block[6]/lineArea/inlineparent/@ipd"/>
+    <eval expected="36000" xpath="//flow/block[6]/lineArea/inlineparent/@ipda"/>
+    <eval expected="5280" xpath="//flow/block[6]/lineArea/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[6]/lineArea/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[6]/lineArea/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[6]/lineArea/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[6]/lineArea/inlineparent/@border-start"/>
+    <eval expected="5000" xpath="//flow/block[6]/lineArea/inlineparent/@padding-after"/>
+    <eval expected="5000" xpath="//flow/block[6]/lineArea/inlineparent/@padding-before"/>
+    <eval expected="5000" xpath="//flow/block[6]/lineArea/inlineparent/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[6]/lineArea/inlineparent/@padding-start"/>
+
     <eval expected="11100" xpath="//flow/block[7]/lineArea/@bpd"/>
     <eval expected="360000" xpath="//flow/block[7]/lineArea/@ipd"/>
-    <eval expected="16000" xpath="//flow/block[7]/lineArea/inlineparent/@ipd"/>
-    <eval expected="36000" xpath="//flow/block[7]/lineArea/inlineparent/@ipda"/>
-    <eval expected="5280" xpath="//flow/block[7]/lineArea/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[7]/lineArea/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[7]/lineArea/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[7]/lineArea/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[7]/lineArea/inlineparent/@border-start"/>
-    <eval expected="5000" xpath="//flow/block[7]/lineArea/inlineparent/@padding-after"/>
-    <eval expected="5000" xpath="//flow/block[7]/lineArea/inlineparent/@padding-before"/>
-    <eval expected="5000" xpath="//flow/block[7]/lineArea/inlineparent/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[7]/lineArea/inlineparent/@padding-start"/>
+    <eval expected="16000" xpath="//flow/block[7]/lineArea/leader/@ipd"/>
+    <eval expected="36000" xpath="//flow/block[7]/lineArea/leader/@ipda"/>
+    <eval expected="7616" xpath="//flow/block[7]/lineArea/leader/@offset"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[7]/lineArea/leader/@border-after"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[7]/lineArea/leader/@border-before"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[7]/lineArea/leader/@border-end"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[7]/lineArea/leader/@border-start"/>
+    <eval expected="5000" xpath="//flow/block[7]/lineArea/leader/@padding-after"/>
+    <eval expected="5000" xpath="//flow/block[7]/lineArea/leader/@padding-before"/>
+    <eval expected="5000" xpath="//flow/block[7]/lineArea/leader/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[7]/lineArea/leader/@padding-start"/>
+
+    <eval expected="11100" xpath="//flow/block[8]/lineArea/@bpd"/>
+    <eval expected="360000" xpath="//flow/block[8]/lineArea/@ipd"/>
+    <eval expected="16000" xpath="//flow/block[8]/lineArea/leader/@ipd"/>
+    <eval expected="36000" xpath="//flow/block[8]/lineArea/leader/@ipda"/>
+    <eval expected="7616" xpath="//flow/block[8]/lineArea/leader/@offset"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[8]/lineArea/leader/@border-after"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[8]/lineArea/leader/@border-before"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[8]/lineArea/leader/@border-end"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[8]/lineArea/leader/@border-start"/>
+    <eval expected="5000" xpath="//flow/block[8]/lineArea/leader/@padding-after"/>
+    <eval expected="5000" xpath="//flow/block[8]/lineArea/leader/@padding-before"/>
+    <eval expected="5000" xpath="//flow/block[8]/lineArea/leader/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[8]/lineArea/leader/@padding-start"/>
+
+    <eval expected="11100" xpath="//flow/block[9]/lineArea/@bpd"/>
+    <eval expected="360000" xpath="//flow/block[9]/lineArea/@ipd"/>
+    <eval expected="16000" xpath="//flow/block[9]/lineArea/space/@ipd"/>
+    <eval expected="36000" xpath="//flow/block[9]/lineArea/space/@ipda"/>
+    <eval expected="8615" xpath="//flow/block[9]/lineArea/space/@offset"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[9]/lineArea/space/@border-after"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[9]/lineArea/space/@border-before"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[9]/lineArea/space/@border-end"/>
+    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[9]/lineArea/space/@border-start"/>
+    <eval expected="5000" xpath="//flow/block[9]/lineArea/space/@padding-after"/>
+    <eval expected="5000" xpath="//flow/block[9]/lineArea/space/@padding-before"/>
+    <eval expected="5000" xpath="//flow/block[9]/lineArea/space/@padding-end"/>
+    <eval expected="5000" xpath="//flow/block[9]/lineArea/space/@padding-start"/>
+
+    <eval expected="11100" xpath="//flow/block[11]/lineArea/@bpd"/>
+    <eval expected="360000" xpath="//flow/block[11]/lineArea/@ipd"/>
+    <eval expected="24000" xpath="//flow/block[11]/lineArea/inlineparent/@ipd"/>
+    <eval expected="36000" xpath="//flow/block[11]/lineArea/inlineparent/@ipda"/>
+    <eval expected="5280" xpath="//flow/block[11]/lineArea/inlineparent/@offset"/>
+    <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[11]/lineArea/inlineparent/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea/inlineparent/@border-before"/>
+    <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[11]/lineArea/inlineparent/@border-end"/>
+    <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[11]/lineArea/inlineparent/@border-start"/>
+    <eval expected="3000" xpath="//flow/block[11]/lineArea/inlineparent/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[11]/lineArea/inlineparent/@padding-before"/>
+    <eval expected="2000" xpath="//flow/block[11]/lineArea/inlineparent/@padding-end"/>
+    <eval expected="4000" xpath="//flow/block[11]/lineArea/inlineparent/@padding-start"/>
 
-    <eval expected="11100" xpath="//flow/block[10]/lineArea/@bpd"/>
-    <eval expected="360000" xpath="//flow/block[10]/lineArea/@ipd"/>
-    <eval expected="16000" xpath="//flow/block[10]/lineArea/leader/@ipd"/>
-    <eval expected="36000" xpath="//flow/block[10]/lineArea/leader/@ipda"/>
-    <eval expected="7616" xpath="//flow/block[10]/lineArea/leader/@offset"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[10]/lineArea/leader/@border-after"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[10]/lineArea/leader/@border-before"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[10]/lineArea/leader/@border-end"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[10]/lineArea/leader/@border-start"/>
-    <eval expected="5000" xpath="//flow/block[10]/lineArea/leader/@padding-after"/>
-    <eval expected="5000" xpath="//flow/block[10]/lineArea/leader/@padding-before"/>
-    <eval expected="5000" xpath="//flow/block[10]/lineArea/leader/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[10]/lineArea/leader/@padding-start"/>
+    <eval expected="11100" xpath="//flow/block[12]/lineArea/@bpd"/>
+    <eval expected="360000" xpath="//flow/block[12]/lineArea/@ipd"/>
+    <eval expected="24000" xpath="//flow/block[12]/lineArea/leader/@ipd"/>
+    <eval expected="36000" xpath="//flow/block[12]/lineArea/leader/@ipda"/>
+    <eval expected="7616" xpath="//flow/block[12]/lineArea/leader/@offset"/>
+    <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[12]/lineArea/leader/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[12]/lineArea/leader/@border-before"/>
+    <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[12]/lineArea/leader/@border-end"/>
+    <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[12]/lineArea/leader/@border-start"/>
+    <eval expected="3000" xpath="//flow/block[12]/lineArea/leader/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[12]/lineArea/leader/@padding-before"/>
+    <eval expected="2000" xpath="//flow/block[12]/lineArea/leader/@padding-end"/>
+    <eval expected="4000" xpath="//flow/block[12]/lineArea/leader/@padding-start"/>
 
     <eval expected="11100" xpath="//flow/block[13]/lineArea/@bpd"/>
     <eval expected="360000" xpath="//flow/block[13]/lineArea/@ipd"/>
-    <eval expected="16000" xpath="//flow/block[13]/lineArea/leader/@ipd"/>
+    <eval expected="24000" xpath="//flow/block[13]/lineArea/leader/@ipd"/>
     <eval expected="36000" xpath="//flow/block[13]/lineArea/leader/@ipda"/>
     <eval expected="7616" xpath="//flow/block[13]/lineArea/leader/@offset"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[13]/lineArea/leader/@border-after"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[13]/lineArea/leader/@border-before"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[13]/lineArea/leader/@border-end"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[13]/lineArea/leader/@border-start"/>
-    <eval expected="5000" xpath="//flow/block[13]/lineArea/leader/@padding-after"/>
-    <eval expected="5000" xpath="//flow/block[13]/lineArea/leader/@padding-before"/>
-    <eval expected="5000" xpath="//flow/block[13]/lineArea/leader/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[13]/lineArea/leader/@padding-start"/>
-
-    <eval expected="11100" xpath="//flow/block[16]/lineArea/@bpd"/>
-    <eval expected="360000" xpath="//flow/block[16]/lineArea/@ipd"/>
-    <eval expected="16000" xpath="//flow/block[16]/lineArea/space/@ipd"/>
-    <eval expected="36000" xpath="//flow/block[16]/lineArea/space/@ipda"/>
-    <eval expected="8615" xpath="//flow/block[16]/lineArea/space/@offset"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[16]/lineArea/space/@border-after"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[16]/lineArea/space/@border-before"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[16]/lineArea/space/@border-end"/>
-    <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[16]/lineArea/space/@border-start"/>
-    <eval expected="5000" xpath="//flow/block[16]/lineArea/space/@padding-after"/>
-    <eval expected="5000" xpath="//flow/block[16]/lineArea/space/@padding-before"/>
-    <eval expected="5000" xpath="//flow/block[16]/lineArea/space/@padding-end"/>
-    <eval expected="5000" xpath="//flow/block[16]/lineArea/space/@padding-start"/>
-
-    <eval expected="11100" xpath="//flow/block[22]/lineArea/@bpd"/>
-    <eval expected="360000" xpath="//flow/block[22]/lineArea/@ipd"/>
-    <eval expected="24000" xpath="//flow/block[22]/lineArea/inlineparent/@ipd"/>
-    <eval expected="36000" xpath="//flow/block[22]/lineArea/inlineparent/@ipda"/>
-    <eval expected="5280" xpath="//flow/block[22]/lineArea/inlineparent/@offset"/>
-    <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[22]/lineArea/inlineparent/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[22]/lineArea/inlineparent/@border-before"/>
-    <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[22]/lineArea/inlineparent/@border-end"/>
-    <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[22]/lineArea/inlineparent/@border-start"/>
-    <eval expected="3000" xpath="//flow/block[22]/lineArea/inlineparent/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[22]/lineArea/inlineparent/@padding-before"/>
-    <eval expected="2000" xpath="//flow/block[22]/lineArea/inlineparent/@padding-end"/>
-    <eval expected="4000" xpath="//flow/block[22]/lineArea/inlineparent/@padding-start"/>
-
-    <eval expected="11100" xpath="//flow/block[25]/lineArea/@bpd"/>
-    <eval expected="360000" xpath="//flow/block[25]/lineArea/@ipd"/>
-    <eval expected="24000" xpath="//flow/block[25]/lineArea/leader/@ipd"/>
-    <eval expected="36000" xpath="//flow/block[25]/lineArea/leader/@ipda"/>
-    <eval expected="7616" xpath="//flow/block[25]/lineArea/leader/@offset"/>
-    <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[25]/lineArea/leader/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[25]/lineArea/leader/@border-before"/>
-    <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[25]/lineArea/leader/@border-end"/>
-    <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[25]/lineArea/leader/@border-start"/>
-    <eval expected="3000" xpath="//flow/block[25]/lineArea/leader/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[25]/lineArea/leader/@padding-before"/>
-    <eval expected="2000" xpath="//flow/block[25]/lineArea/leader/@padding-end"/>
-    <eval expected="4000" xpath="//flow/block[25]/lineArea/leader/@padding-start"/>
-
-    <eval expected="11100" xpath="//flow/block[28]/lineArea/@bpd"/>
-    <eval expected="360000" xpath="//flow/block[28]/lineArea/@ipd"/>
-    <eval expected="24000" xpath="//flow/block[28]/lineArea/leader/@ipd"/>
-    <eval expected="36000" xpath="//flow/block[28]/lineArea/leader/@ipda"/>
-    <eval expected="7616" xpath="//flow/block[28]/lineArea/leader/@offset"/>
-    <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[28]/lineArea/leader/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[28]/lineArea/leader/@border-before"/>
-    <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[28]/lineArea/leader/@border-end"/>
-    <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[28]/lineArea/leader/@border-start"/>
-    <eval expected="3000" xpath="//flow/block[28]/lineArea/leader/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[28]/lineArea/leader/@padding-before"/>
-    <eval expected="2000" xpath="//flow/block[28]/lineArea/leader/@padding-end"/>
-    <eval expected="4000" xpath="//flow/block[28]/lineArea/leader/@padding-start"/>
+    <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[13]/lineArea/leader/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[13]/lineArea/leader/@border-before"/>
+    <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[13]/lineArea/leader/@border-end"/>
+    <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[13]/lineArea/leader/@border-start"/>
+    <eval expected="3000" xpath="//flow/block[13]/lineArea/leader/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[13]/lineArea/leader/@padding-before"/>
+    <eval expected="2000" xpath="//flow/block[13]/lineArea/leader/@padding-end"/>
+    <eval expected="4000" xpath="//flow/block[13]/lineArea/leader/@padding-start"/>
 
-    <eval expected="11100" xpath="//flow/block[31]/lineArea/@bpd"/>
-    <eval expected="360000" xpath="//flow/block[31]/lineArea/@ipd"/>
-    <eval expected="24000" xpath="//flow/block[31]/lineArea/space/@ipd"/>
-    <eval expected="36000" xpath="//flow/block[31]/lineArea/space/@ipda"/>
-    <eval expected="8615" xpath="//flow/block[31]/lineArea/space/@offset"/>
-    <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[31]/lineArea/space/@border-after"/>
-    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[31]/lineArea/space/@border-before"/>
-    <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[31]/lineArea/space/@border-end"/>
-    <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[31]/lineArea/space/@border-start"/>
-    <eval expected="3000" xpath="//flow/block[31]/lineArea/space/@padding-after"/>
-    <eval expected="1000" xpath="//flow/block[31]/lineArea/space/@padding-before"/>
-    <eval expected="2000" xpath="//flow/block[31]/lineArea/space/@padding-end"/>
-    <eval expected="4000" xpath="//flow/block[31]/lineArea/space/@padding-start"/>
+    <eval expected="11100" xpath="//flow/block[14]/lineArea/@bpd"/>
+    <eval expected="360000" xpath="//flow/block[14]/lineArea/@ipd"/>
+    <eval expected="24000" xpath="//flow/block[14]/lineArea/space/@ipd"/>
+    <eval expected="36000" xpath="//flow/block[14]/lineArea/space/@ipda"/>
+    <eval expected="8615" xpath="//flow/block[14]/lineArea/space/@offset"/>
+    <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[14]/lineArea/space/@border-after"/>
+    <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea/space/@border-before"/>
+    <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[14]/lineArea/space/@border-end"/>
+    <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[14]/lineArea/space/@border-start"/>
+    <eval expected="3000" xpath="//flow/block[14]/lineArea/space/@padding-after"/>
+    <eval expected="1000" xpath="//flow/block[14]/lineArea/space/@padding-before"/>
+    <eval expected="2000" xpath="//flow/block[14]/lineArea/space/@padding-end"/>
+    <eval expected="4000" xpath="//flow/block[14]/lineArea/space/@padding-start"/>
   </checks>
 </testcase>

test/layoutengine/testcases/list-block_border_padding.xml

@@ -66,124 +66,124 @@
     <eval expected="360000" xpath="//flow/@ipd"/>
     
     <!-- spacer block for space-before on list-block -->
-    <eval expected="5000" xpath="//flow/block[2]/@bpd"/>
+    <eval expected="5000" xpath="//flow/block[2]/@space-before"/>
     
     <!-- list-block -->
-    <eval expected="360000" xpath="//flow/block[3]/@ipda"/>
-    <eval expected="340000" xpath="//flow/block[3]/@ipd"/>
-    <!--eval expected="??" xpath="//flow/block[3]/@bpda"/>
-    <eval expected="??" xpath="//flow/block[3]/@bpd"/-->
-    <eval expected="10000 10000 10000 10000" xpath="//flow/block[3]/@bap"/>
-    <eval expected="5000" xpath="//flow/block[3]/@padding-before"/>
-    <eval expected="5000" xpath="//flow/block[3]/@padding-after"/>
-    <eval expected="5000" xpath="//flow/block[3]/@padding-start"/>
-    <eval expected="5000" xpath="//flow/block[3]/@padding-end"/>
-    <eval expected="10000" xpath="//flow/block[3]/@start-indent"/>
-    <eval expected="10000" xpath="//flow/block[3]/@end-indent"/>
+    <eval expected="360000" xpath="//flow/block[2]/@ipda"/>
+    <eval expected="340000" xpath="//flow/block[2]/@ipd"/>
+    <!--eval expected="??" xpath="//flow/block[2]/@bpda"/>
+    <eval expected="??" xpath="//flow/block[2]/@bpd"/-->
+    <eval expected="10000 10000 10000 10000" xpath="//flow/block[2]/@bap"/>
+    <eval expected="5000" xpath="//flow/block[2]/@padding-before"/>
+    <eval expected="5000" xpath="//flow/block[2]/@padding-after"/>
+    <eval expected="5000" xpath="//flow/block[2]/@padding-start"/>
+    <eval expected="5000" xpath="//flow/block[2]/@padding-end"/>
+    <eval expected="10000" xpath="//flow/block[2]/@start-indent"/>
+    <eval expected="10000" xpath="//flow/block[2]/@end-indent"/>
     
     <!-- first list-item -->
-    <eval expected="340000" xpath="//flow/block[3]/block[1]/@ipda"/>
-    <eval expected="340000" xpath="//flow/block[3]/block[1]/@ipd"/>
-    <eval expected="14400" xpath="//flow/block[3]/block[1]/@bpda"/>
-    <eval expected="14400" xpath="//flow/block[3]/block[1]/@bpd"/>
-    <eval expected="10000" xpath="//flow/block[3]/block[1]/@start-indent"/>
-    <eval expected="10000" xpath="//flow/block[3]/block[1]/@end-indent"/>
+    <eval expected="340000" xpath="//flow/block[2]/block[1]/@ipda"/>
+    <eval expected="340000" xpath="//flow/block[2]/block[1]/@ipd"/>
+    <eval expected="14400" xpath="//flow/block[2]/block[1]/@bpda"/>
+    <eval expected="14400" xpath="//flow/block[2]/block[1]/@bpd"/>
+    <eval expected="10000" xpath="//flow/block[2]/block[1]/@start-indent"/>
+    <eval expected="10000" xpath="//flow/block[2]/block[1]/@end-indent"/>
 
-    <eval expected="340000" xpath="//flow/block[3]/block[1]/block[1]/@ipd"/>
-    <eval expected="14400" xpath="//flow/block[3]/block[1]/block[1]/@bpd"/>
-    <eval expected="40000" xpath="//flow/block[3]/block[1]/block[1]/block[1]/@ipda"/>
-    <eval expected="40000" xpath="//flow/block[3]/block[1]/block[1]/block[1]/@ipd"/>
-    <eval expected="14400" xpath="//flow/block[3]/block[1]/block[1]/block[1]/@bpda"/>
-    <eval expected="14400" xpath="//flow/block[3]/block[1]/block[1]/block[1]/@bpda"/>
-    <eval expected="10000" xpath="//flow/block[3]/block[1]/block[1]/block[1]/@start-indent"/>
-    <eval expected="310000" xpath="//flow/block[3]/block[1]/block[1]/block[1]/@end-indent"/>
-    <eval expected="10000" xpath="//flow/block[3]/block[1]/block[1]/block[1]/@space-start"/>
-    <eval expected="310000" xpath="//flow/block[3]/block[1]/block[1]/block[1]/@space-end"/>
+    <eval expected="340000" xpath="//flow/block[2]/block[1]/block[1]/@ipd"/>
+    <eval expected="14400" xpath="//flow/block[2]/block[1]/block[1]/@bpd"/>
+    <eval expected="40000" xpath="//flow/block[2]/block[1]/block[1]/block[1]/@ipda"/>
+    <eval expected="40000" xpath="//flow/block[2]/block[1]/block[1]/block[1]/@ipd"/>
+    <eval expected="14400" xpath="//flow/block[2]/block[1]/block[1]/block[1]/@bpda"/>
+    <eval expected="14400" xpath="//flow/block[2]/block[1]/block[1]/block[1]/@bpda"/>
+    <eval expected="10000" xpath="//flow/block[2]/block[1]/block[1]/block[1]/@start-indent"/>
+    <eval expected="310000" xpath="//flow/block[2]/block[1]/block[1]/block[1]/@end-indent"/>
+    <eval expected="10000" xpath="//flow/block[2]/block[1]/block[1]/block[1]/@space-start"/>
+    <eval expected="310000" xpath="//flow/block[2]/block[1]/block[1]/block[1]/@space-end"/>
     
-    <eval expected="340000" xpath="//flow/block[3]/block[1]/block[2]/@ipd"/>
-    <eval expected="14400" xpath="//flow/block[3]/block[1]/block[2]/@bpd"/>
-    <eval expected="290000" xpath="//flow/block[3]/block[1]/block[2]/block[1]/@ipda"/>
-    <eval expected="280000" xpath="//flow/block[3]/block[1]/block[2]/block[1]/@ipd"/>
-    <eval expected="14400" xpath="//flow/block[3]/block[1]/block[2]/block[1]/@bpda"/>
-    <eval expected="14400" xpath="//flow/block[3]/block[1]/block[2]/block[1]/@bpda"/>
-    <eval expected="65000" xpath="//flow/block[3]/block[1]/block[2]/block[1]/@start-indent"/>
-    <eval expected="15000" xpath="//flow/block[3]/block[1]/block[2]/block[1]/@end-indent"/>
-    <eval expected="60000" xpath="//flow/block[3]/block[1]/block[2]/block[1]/@space-start"/>
-    <eval expected="10000" xpath="//flow/block[3]/block[1]/block[2]/block[1]/@space-end"/>
+    <eval expected="340000" xpath="//flow/block[2]/block[1]/block[2]/@ipd"/>
+    <eval expected="14400" xpath="//flow/block[2]/block[1]/block[2]/@bpd"/>
+    <eval expected="290000" xpath="//flow/block[2]/block[1]/block[2]/block[1]/@ipda"/>
+    <eval expected="280000" xpath="//flow/block[2]/block[1]/block[2]/block[1]/@ipd"/>
+    <eval expected="14400" xpath="//flow/block[2]/block[1]/block[2]/block[1]/@bpda"/>
+    <eval expected="14400" xpath="//flow/block[2]/block[1]/block[2]/block[1]/@bpda"/>
+    <eval expected="65000" xpath="//flow/block[2]/block[1]/block[2]/block[1]/@start-indent"/>
+    <eval expected="15000" xpath="//flow/block[2]/block[1]/block[2]/block[1]/@end-indent"/>
+    <eval expected="60000" xpath="//flow/block[2]/block[1]/block[2]/block[1]/@space-start"/>
+    <eval expected="10000" xpath="//flow/block[2]/block[1]/block[2]/block[1]/@space-end"/>
     
     <!-- spacer block for space-before on second list-item -->
-    <eval expected="5000" xpath="//flow/block[3]/block[2]/@bpd"/>
+    <eval expected="5000" xpath="//flow/block[2]/block[2]/@space-before"/>
 
     <!-- second list-item -->
-    <eval expected="340000" xpath="//flow/block[3]/block[3]/@ipda"/>
-    <eval expected="340000" xpath="//flow/block[3]/block[3]/@ipd"/>
-    <eval expected="14400" xpath="//flow/block[3]/block[3]/@bpda"/>
-    <eval expected="14400" xpath="//flow/block[3]/block[3]/@bpd"/>
-    <eval expected="10000" xpath="//flow/block[3]/block[3]/@start-indent"/>
-    <eval expected="10000" xpath="//flow/block[3]/block[3]/@end-indent"/>
+    <eval expected="340000" xpath="//flow/block[2]/block[2]/@ipda"/>
+    <eval expected="340000" xpath="//flow/block[2]/block[2]/@ipd"/>
+    <eval expected="29400" xpath="//flow/block[2]/block[2]/@bpda"/>
+    <eval expected="14400" xpath="//flow/block[2]/block[2]/@bpd"/>
+    <eval expected="10000" xpath="//flow/block[2]/block[2]/@start-indent"/>
+    <eval expected="10000" xpath="//flow/block[2]/block[2]/@end-indent"/>
 
-    <eval expected="340000" xpath="//flow/block[3]/block[3]/block[1]/@ipd"/>
-    <eval expected="14400" xpath="//flow/block[3]/block[3]/block[1]/@bpd"/>
-    <eval expected="40000" xpath="//flow/block[3]/block[3]/block[1]/block[1]/@ipda"/>
-    <eval expected="40000" xpath="//flow/block[3]/block[3]/block[1]/block[1]/@ipd"/>
-    <eval expected="14400" xpath="//flow/block[3]/block[3]/block[1]/block[1]/@bpda"/>
-    <eval expected="14400" xpath="//flow/block[3]/block[3]/block[1]/block[1]/@bpda"/>
-    <eval expected="10000" xpath="//flow/block[3]/block[3]/block[1]/block[1]/@start-indent"/>
-    <eval expected="310000" xpath="//flow/block[3]/block[3]/block[1]/block[1]/@end-indent"/>
-    <eval expected="10000" xpath="//flow/block[3]/block[3]/block[1]/block[1]/@space-start"/>
-    <eval expected="310000" xpath="//flow/block[3]/block[3]/block[1]/block[1]/@space-end"/>
+    <eval expected="340000" xpath="//flow/block[2]/block[2]/block[1]/@ipd"/>
+    <eval expected="14400" xpath="//flow/block[2]/block[2]/block[1]/@bpd"/>
+    <eval expected="40000" xpath="//flow/block[2]/block[2]/block[1]/block[1]/@ipda"/>
+    <eval expected="40000" xpath="//flow/block[2]/block[2]/block[1]/block[1]/@ipd"/>
+    <eval expected="14400" xpath="//flow/block[2]/block[2]/block[1]/block[1]/@bpda"/>
+    <eval expected="14400" xpath="//flow/block[2]/block[2]/block[1]/block[1]/@bpda"/>
+    <eval expected="10000" xpath="//flow/block[2]/block[2]/block[1]/block[1]/@start-indent"/>
+    <eval expected="310000" xpath="//flow/block[2]/block[2]/block[1]/block[1]/@end-indent"/>
+    <eval expected="10000" xpath="//flow/block[2]/block[2]/block[1]/block[1]/@space-start"/>
+    <eval expected="310000" xpath="//flow/block[2]/block[2]/block[1]/block[1]/@space-end"/>
     
-    <eval expected="340000" xpath="//flow/block[3]/block[3]/block[2]/@ipd"/>
-    <eval expected="14400" xpath="//flow/block[3]/block[3]/block[2]/@bpd"/>
-    <eval expected="295000" xpath="//flow/block[3]/block[3]/block[2]/block[1]/@ipda"/>
-    <eval expected="285000" xpath="//flow/block[3]/block[3]/block[2]/block[1]/@ipd"/>
-    <eval expected="14400" xpath="//flow/block[3]/block[3]/block[2]/block[1]/@bpda"/>
-    <eval expected="14400" xpath="//flow/block[3]/block[3]/block[2]/block[1]/@bpda"/>
-    <eval expected="60000" xpath="//flow/block[3]/block[3]/block[2]/block[1]/@start-indent"/>
-    <eval expected="15000" xpath="//flow/block[3]/block[3]/block[2]/block[1]/@end-indent"/>
-    <eval expected="55000" xpath="//flow/block[3]/block[3]/block[2]/block[1]/@space-start"/>
-    <eval expected="10000" xpath="//flow/block[3]/block[3]/block[2]/block[1]/@space-end"/>
+    <eval expected="340000" xpath="//flow/block[2]/block[2]/block[2]/@ipd"/>
+    <eval expected="14400" xpath="//flow/block[2]/block[2]/block[2]/@bpd"/>
+    <eval expected="295000" xpath="//flow/block[2]/block[2]/block[2]/block[1]/@ipda"/>
+    <eval expected="285000" xpath="//flow/block[2]/block[2]/block[2]/block[1]/@ipd"/>
+    <eval expected="14400" xpath="//flow/block[2]/block[2]/block[2]/block[1]/@bpda"/>
+    <eval expected="14400" xpath="//flow/block[2]/block[2]/block[2]/block[1]/@bpda"/>
+    <eval expected="60000" xpath="//flow/block[2]/block[2]/block[2]/block[1]/@start-indent"/>
+    <eval expected="15000" xpath="//flow/block[2]/block[2]/block[2]/block[1]/@end-indent"/>
+    <eval expected="55000" xpath="//flow/block[2]/block[2]/block[2]/block[1]/@space-start"/>
+    <eval expected="10000" xpath="//flow/block[2]/block[2]/block[2]/block[1]/@space-end"/>
 
     <!-- spacer block for space-after on second list-item -->
-    <eval expected="10000" xpath="//flow/block[3]/block[4]/@bpd"/>
+    <eval expected="10000" xpath="//flow/block[2]/block[2]/@space-after"/>
 
     <!-- third list-item -->
-    <eval expected="340000" xpath="//flow/block[3]/block[5]/@ipda"/>
-    <eval expected="320000" xpath="//flow/block[3]/block[5]/@ipd"/>
-    <eval expected="34400" xpath="//flow/block[3]/block[5]/@bpda"/>
-    <eval expected="14400" xpath="//flow/block[3]/block[5]/@bpd"/>
-    <eval expected="10000 10000 10000 10000" xpath="//flow/block[3]/block[5]/@bap"/>
-    <eval expected="5000" xpath="//flow/block[3]/block[5]/@padding-before"/>
-    <eval expected="5000" xpath="//flow/block[3]/block[5]/@padding-after"/>
-    <eval expected="5000" xpath="//flow/block[3]/block[5]/@padding-start"/>
-    <eval expected="5000" xpath="//flow/block[3]/block[5]/@padding-end"/>
-    <eval expected="20000" xpath="//flow/block[3]/block[5]/@start-indent"/>
-    <eval expected="20000" xpath="//flow/block[3]/block[5]/@end-indent"/>
+    <eval expected="340000" xpath="//flow/block[2]/block[3]/@ipda"/>
+    <eval expected="320000" xpath="//flow/block[2]/block[3]/@ipd"/>
+    <eval expected="34400" xpath="//flow/block[2]/block[3]/@bpda"/>
+    <eval expected="14400" xpath="//flow/block[2]/block[3]/@bpd"/>
+    <eval expected="10000 10000 10000 10000" xpath="//flow/block[2]/block[3]/@bap"/>
+    <eval expected="5000" xpath="//flow/block[2]/block[3]/@padding-before"/>
+    <eval expected="5000" xpath="//flow/block[2]/block[3]/@padding-after"/>
+    <eval expected="5000" xpath="//flow/block[2]/block[3]/@padding-start"/>
+    <eval expected="5000" xpath="//flow/block[2]/block[3]/@padding-end"/>
+    <eval expected="20000" xpath="//flow/block[2]/block[3]/@start-indent"/>
+    <eval expected="20000" xpath="//flow/block[2]/block[3]/@end-indent"/>
 
-    <eval expected="320000" xpath="//flow/block[3]/block[5]/block[1]/@ipd"/>
-    <eval expected="14400" xpath="//flow/block[3]/block[5]/block[1]/@bpd"/>
-    <eval expected="40000" xpath="//flow/block[3]/block[5]/block[1]/block[1]/@ipda"/>
-    <eval expected="40000" xpath="//flow/block[3]/block[5]/block[1]/block[1]/@ipd"/>
-    <eval expected="14400" xpath="//flow/block[3]/block[5]/block[1]/block[1]/@bpda"/>
-    <eval expected="14400" xpath="//flow/block[3]/block[5]/block[1]/block[1]/@bpda"/>
-    <eval expected="20000" xpath="//flow/block[3]/block[5]/block[1]/block[1]/@start-indent"/>
-    <eval expected="300000" xpath="//flow/block[3]/block[5]/block[1]/block[1]/@end-indent"/>
-    <eval expected="20000" xpath="//flow/block[3]/block[5]/block[1]/block[1]/@space-start"/>
-    <eval expected="300000" xpath="//flow/block[3]/block[5]/block[1]/block[1]/@space-end"/>
+    <eval expected="320000" xpath="//flow/block[2]/block[3]/block[1]/@ipd"/>
+    <eval expected="14400" xpath="//flow/block[2]/block[3]/block[1]/@bpd"/>
+    <eval expected="40000" xpath="//flow/block[2]/block[3]/block[1]/block[1]/@ipda"/>
+    <eval expected="40000" xpath="//flow/block[2]/block[3]/block[1]/block[1]/@ipd"/>
+    <eval expected="14400" xpath="//flow/block[2]/block[3]/block[1]/block[1]/@bpda"/>
+    <eval expected="14400" xpath="//flow/block[2]/block[3]/block[1]/block[1]/@bpda"/>
+    <eval expected="20000" xpath="//flow/block[2]/block[3]/block[1]/block[1]/@start-indent"/>
+    <eval expected="300000" xpath="//flow/block[2]/block[3]/block[1]/block[1]/@end-indent"/>
+    <eval expected="20000" xpath="//flow/block[2]/block[3]/block[1]/block[1]/@space-start"/>
+    <eval expected="300000" xpath="//flow/block[2]/block[3]/block[1]/block[1]/@space-end"/>
     
-    <eval expected="320000" xpath="//flow/block[3]/block[5]/block[2]/@ipd"/>
-    <eval expected="14400" xpath="//flow/block[3]/block[5]/block[2]/@bpd"/>
-    <eval expected="280000" xpath="//flow/block[3]/block[5]/block[2]/block[1]/@ipda"/>
-    <eval expected="270000" xpath="//flow/block[3]/block[5]/block[2]/block[1]/@ipd"/>
-    <eval expected="14400" xpath="//flow/block[3]/block[5]/block[2]/block[1]/@bpda"/>
-    <eval expected="14400" xpath="//flow/block[3]/block[5]/block[2]/block[1]/@bpda"/>
-    <eval expected="70000" xpath="//flow/block[3]/block[5]/block[2]/block[1]/@start-indent"/>
-    <eval expected="20000" xpath="//flow/block[3]/block[5]/block[2]/block[1]/@end-indent"/>
-    <eval expected="65000" xpath="//flow/block[3]/block[5]/block[2]/block[1]/@space-start"/>
-    <eval expected="15000" xpath="//flow/block[3]/block[5]/block[2]/block[1]/@space-end"/>
+    <eval expected="320000" xpath="//flow/block[2]/block[3]/block[2]/@ipd"/>
+    <eval expected="14400" xpath="//flow/block[2]/block[3]/block[2]/@bpd"/>
+    <eval expected="280000" xpath="//flow/block[2]/block[3]/block[2]/block[1]/@ipda"/>
+    <eval expected="270000" xpath="//flow/block[2]/block[3]/block[2]/block[1]/@ipd"/>
+    <eval expected="14400" xpath="//flow/block[2]/block[3]/block[2]/block[1]/@bpda"/>
+    <eval expected="14400" xpath="//flow/block[2]/block[3]/block[2]/block[1]/@bpda"/>
+    <eval expected="70000" xpath="//flow/block[2]/block[3]/block[2]/block[1]/@start-indent"/>
+    <eval expected="20000" xpath="//flow/block[2]/block[3]/block[2]/block[1]/@end-indent"/>
+    <eval expected="65000" xpath="//flow/block[2]/block[3]/block[2]/block[1]/@space-start"/>
+    <eval expected="15000" xpath="//flow/block[2]/block[3]/block[2]/block[1]/@space-end"/>
 
     <!-- spacer block for space-after on list-block -->
-    <eval expected="10000" xpath="//flow/block[4]/@bpd"/>
+    <eval expected="10000" xpath="//flow/block[2]/@space-after"/>
     
   </checks>
 </testcase>

test/layoutengine/testcases/list-block_space-before_space-after_1.xml

@@ -0,0 +1,221 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Copyright 2005 The Apache Software Foundation
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<!-- $Id$ -->
+<testcase>
+  <info>
+    <p>
+      This test checks spaces on tables.
+    </p>
+  </info>
+  <fo>
+    <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+      <fo:layout-master-set>
+        <fo:simple-page-master master-name="normal" page-width="5in" page-height="1.7in">
+          <fo:region-body/>
+        </fo:simple-page-master>
+      </fo:layout-master-set>
+      <fo:page-sequence master-reference="normal" id="retain">
+        <fo:flow flow-name="xsl-region-body">
+          <fo:list-block provisional-distance-between-starts="8pt" provisional-label-separation="5pt" 
+              space-before="20pt" space-before.conditionality="retain" 
+              space-after="10pt" space-after.conditionality="retain">
+            <fo:list-item space-before="1em">
+              <fo:list-item-label end-indent="label-end()">
+                <fo:block>•</fo:block>
+              </fo:list-item-label>
+              <fo:list-item-body start-indent="body-start()">
+                <fo:block text-align="justify">
+In olden times when wishing still helped one, there lived a king whose daughters 
+were all beautiful; and the youngest was so beautiful that the sun itself, which 
+has seen so much, was astonished whenever it shone in her face. Close by the king's 
+castle lay a great dark forest, and under an old lime-tree in the forest was a well, 
+and when the day was very warm, the king's child went out into the forest and sat 
+down by the side of the cool fountain; and when she was bored she took a golden ball, 
+and threw it up on high and caught it; and this ball was her favorite plaything.
+                </fo:block>
+              </fo:list-item-body>
+            </fo:list-item>
+            <fo:list-item>
+              <fo:list-item-label end-indent="label-end()">
+                <fo:block>•</fo:block>
+              </fo:list-item-label>
+              <fo:list-item-body start-indent="body-start()">
+                <fo:block>here is text in the list item body</fo:block>
+              </fo:list-item-body>
+            </fo:list-item>
+          </fo:list-block>
+          <fo:block space-before.optimum="10pt" space-before.conditionality="retain" space-after.optimum="20pt" space-after.conditionality="retain">
+Two blocks, testing conditionality="retain".
+          </fo:block>
+        </fo:flow>
+      </fo:page-sequence>
+      <fo:page-sequence master-reference="normal" id="discard">
+        <fo:flow flow-name="xsl-region-body">
+          <fo:list-block provisional-distance-between-starts="8pt" provisional-label-separation="5pt" 
+              space-before="20pt" space-before.conditionality="discard" 
+              space-after="10pt" space-after.conditionality="discard">
+            <fo:list-item space-before="1em">
+              <fo:list-item-label end-indent="label-end()">
+                <fo:block>•</fo:block>
+              </fo:list-item-label>
+              <fo:list-item-body start-indent="body-start()">
+                <fo:block text-align="justify">
+In olden times when wishing still helped one, there lived a king whose daughters 
+were all beautiful; and the youngest was so beautiful that the sun itself, which 
+has seen so much, was astonished whenever it shone in her face. Close by the king's 
+castle lay a great dark forest, and under an old lime-tree in the forest was a well, 
+and when the day was very warm, the king's child went out into the forest and sat 
+down by the side of the cool fountain; and when she was bored she took a golden ball, 
+and threw it up on high and caught it; and this ball was her favorite plaything.
+                </fo:block>
+              </fo:list-item-body>
+            </fo:list-item>
+            <fo:list-item>
+              <fo:list-item-label end-indent="label-end()">
+                <fo:block>•</fo:block>
+              </fo:list-item-label>
+              <fo:list-item-body start-indent="body-start()">
+                <fo:block>here is text in the list item body</fo:block>
+              </fo:list-item-body>
+            </fo:list-item>
+          </fo:list-block>
+          <fo:block space-before.optimum="10pt" space-before.conditionality="discard" space-after.optimum="20pt" space-after.conditionality="discard">
+Two blocks, testing conditionality="discard".
+          </fo:block>
+        </fo:flow>
+      </fo:page-sequence>
+    </fo:root>
+  </fo>
+  <checks>
+    <element-list category="breaker" id="retain">
+      <box w="0"/> <!-- Helper box bearing the SpaceHandlingPosition and making sure the glue gets processed -->
+      <penalty w="0" p="INF"/>
+      <glue w="20000"/>
+      
+      <box w="28800"/>
+      
+      <penalty w="0" p="INF"/>
+      <glue w="10000"/>
+      <penalty w="0" p="0"/>
+      <glue w="-30000"/>
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="20000"/>
+      
+      <box w="14400"/>
+      
+      <penalty w="0" p="INF"/>
+      <glue w="10000"/>
+      <penalty w="0" p="0"/>
+      <glue w="-30000"/>
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="20000"/>
+      
+      <box w="14400"/>
+      
+      <!-- skip three more lines -->
+      <skip>8</skip>
+      <skip>8</skip>
+      <skip>8</skip>
+      
+      <penalty w="0" p="INF"/>
+      <glue w="10000"/>
+      <penalty w="0" p="0"/>
+      <glue w="-30000"/>
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="20000"/>
+      
+      <box w="28800"/> <!-- end of first list item -->
+      
+      <penalty w="0" p="INF"/>
+      <glue w="10000"/>
+      <penalty w="0" p="0"/>
+      <glue w="-30000"/>
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="20000"/>
+      
+      <box w="14400"/> <!-- second list-item -->
+      
+      <penalty w="0" p="INF" aux="true"/>
+      <glue w="10000"/>
+      <penalty w="0" p="0"/>
+      <glue w="-10000"/>
+      
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="10000"/>
+      
+      <box w="14400"/> <!-- second block -->
+      
+      <box w="0"/>
+      <penalty w="0" p="INF"/>
+      <glue w="20000"/>
+      
+      <box w="0"/> <!-- This is used to make sure the preceding glue is not cut off -->
+      
+      <skip>3</skip>
+    </element-list>
+    <element-list category="breaker" id="discard">
+      <box w="0"/> <!-- Helper box used to notify the LM for the addAreas stage about the discarded spaces -->
+      <box w="28800"/>
+      <penalty w="0" p="0"/>
+      <box w="14400"/>
+      <penalty w="0" p="0"/>
+      <box w="14400"/>
+      <penalty w="0" p="0"/>
+      <box w="14400"/>
+      <penalty w="0" p="0"/>
+      <box w="14400"/>
+      <penalty w="0" p="0"/>
+      <box w="14400"/>
+      <penalty w="0" p="0"/>
+      <box w="28800"/>
+      <penalty w="0" p="0"/>
+      <box w="14400"/>
+      <penalty w="0" p="0"/>
+      <glue w="10000"/>
+      
+      <box w="14400"/> <!-- second block -->
+      
+      <box w="0"/> <!-- SpaceHandlingPosition-bearing helper box -->
+      
+      <skip>3</skip>
+    </element-list>
+
+    <eval expected="4" xpath="count(//pageViewport)"/>
+    
+    <!-- 1: retain -->
+    <eval expected="20000" xpath="//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before"/>
+    <eval expected="10000" xpath="//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-after"/>
+    <eval expected="20000" xpath="//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before"/>
+    <!-- the following space is eliminated/collapsed through space resolution -->
+    <true xpath="not(boolean(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-after))"/>
+    <eval expected="10000" xpath="//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[2]/@space-before"/>
+    <eval expected="20000" xpath="//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[2]/@space-after"/>
+    
+    <!-- 2: discard -->
+    <true xpath="not(boolean(//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before))"/>
+    <true xpath="not(boolean(//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before))"/>
+    <true xpath="not(boolean(//pageViewport[@nr=4]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before))"/>
+    <true xpath="not(boolean(//pageViewport[@nr=4]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-after))"/>
+    <eval expected="10000" xpath="//pageViewport[@nr=4]/page/regionViewport/regionBody/mainReference/span/flow/block[2]/@space-before"/>
+    <true xpath="not(boolean(//pageViewport[@nr=4]/page/regionViewport/regionBody/mainReference/span/flow/block[2]/@space-after))"/>
+  </checks>
+</testcase>

test/layoutengine/testcases/list-block_space-before_space-after_2.xml

@@ -0,0 +1,114 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Copyright 2005 The Apache Software Foundation
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<!-- $Id$ -->
+<testcase>
+  <info>
+    <p>
+      This test checks lists. Checks space-before and space-after on list-block.
+    </p>
+  </info>
+  <fo>
+    <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+      <fo:layout-master-set>
+        <fo:simple-page-master master-name="normal" page-width="5in" page-height="2in" 
+              margin="20pt">
+          <fo:region-body background-color="yellow"/>
+        </fo:simple-page-master>
+      </fo:layout-master-set>
+      <fo:page-sequence master-reference="normal" white-space-collapse="true">
+        <fo:flow flow-name="xsl-region-body">
+          <fo:block>test</fo:block>
+          <fo:list-block provisional-distance-between-starts="50pt" provisional-label-separation="5pt">
+            <fo:list-item space-before="1em">
+              <fo:list-item-label end-indent="label-end()">
+                <fo:block>•</fo:block>
+              </fo:list-item-label>
+              <fo:list-item-body start-indent="body-start()">
+                <fo:block>here is text in the list item body</fo:block>
+              </fo:list-item-body>
+            </fo:list-item>
+            <fo:list-item space-before="1em">
+              <fo:list-item-label end-indent="label-end()">
+                <fo:block>•</fo:block>
+              </fo:list-item-label>
+              <fo:list-item-body start-indent="body-start()">
+                <fo:block>here is text in the list item body</fo:block>
+              </fo:list-item-body>
+            </fo:list-item>
+            <fo:list-item space-before="1em" space-after="1em">
+              <fo:list-item-label end-indent="label-end()">
+                <fo:block>•</fo:block>
+              </fo:list-item-label>
+              <fo:list-item-body start-indent="body-start()">
+                <fo:block>here is text in the list item body</fo:block>
+              </fo:list-item-body>
+            </fo:list-item>
+            <fo:list-item space-after="1em">
+              <fo:list-item-label end-indent="label-end()">
+                <fo:block>•</fo:block>
+              </fo:list-item-label>
+              <fo:list-item-body start-indent="body-start()">
+                <fo:block>here is text in the list item body</fo:block>
+              </fo:list-item-body>
+            </fo:list-item>
+            <fo:list-item>
+              <fo:list-item-label end-indent="label-end()">
+                <fo:block>•</fo:block>
+              </fo:list-item-label>
+              <fo:list-item-body start-indent="body-start()">
+                <fo:block>here is text in the list item body</fo:block>
+              </fo:list-item-body>
+            </fo:list-item>
+          </fo:list-block>
+        </fo:flow>
+      </fo:page-sequence>
+    </fo:root>
+  </fo>
+  <checks>
+    <eval expected="2" xpath="count(//pageViewport)"/>
+    <element-list category="breaker">
+      <box w="14400"/>
+      
+      <penalty w="0" p="0"/>
+      
+      <glue w="12000"/>
+      <box w="14400"/>
+      
+      <penalty w="0" p="0"/>
+      
+      <glue w="12000"/>
+      <box w="14400"/>
+      
+      <penalty w="0" p="0"/>
+      
+      <glue w="12000"/>
+      <box w="14400"/>
+      
+      <penalty w="0" p="0"/>
+      
+      <glue w="12000"/>
+      <box w="14400"/>
+      
+      <penalty w="0" p="0"/>
+      
+      <glue w="12000"/>
+      <box w="14400"/>
+      
+      <skip>3</skip>
+    </element-list>
+  </checks>
+</testcase>

test/layoutengine/testcases/list-item_space-before_space-after_1.xml

@@ -82,19 +82,32 @@
     <eval expected="2" xpath="count(//pageViewport)"/>
     <element-list category="breaker">
       <box w="14400"/>
+      
       <penalty w="0" p="0"/>
+      
       <glue w="12000"/>
       <box w="14400"/>
+      
       <penalty w="0" p="0"/>
+      
       <glue w="12000"/>
       <box w="14400"/>
+      
       <penalty w="0" p="0"/>
+      
       <glue w="12000"/>
       <box w="14400"/>
+      
+      <penalty w="0" p="0"/>
+      
       <glue w="12000"/>
       <box w="14400"/>
+      
+      <penalty w="0" p="0"/>
+      
       <glue w="12000"/>
       <box w="14400"/>
+      
       <skip>3</skip>
     </element-list>
   </checks>

test/layoutengine/testcases/list-item_space-before_space-after_2.xml

@@ -89,21 +89,37 @@
       instead of optimum and the addAreas stage doesn't create smaller space-before/after 
       spacers. -->
     
+    <!-- We don't check the exact effective space-before value, but simply make sure it's smaller than 12pt=1em in this test case -->
+    <true xpath="//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[2]/block[1]/@space-before &lt; 12000"/>
+    
     <element-list category="breaker">
       <box w="14400"/>
+      
       <penalty w="0" p="0"/>
-      <glue w="12000"/> <!-- TODO Check shrink/stretch -->
+      
+      <glue w="12000" y="0" z="12000"/>
       <box w="14400"/>
+      
       <penalty w="0" p="0"/>
-      <glue w="12000"/>
+      
+      <glue w="12000"  y="0" z="12000"/>
       <box w="14400"/>
+      
       <penalty w="0" p="0"/>
-      <glue w="12000"/>
+      
+      <glue w="12000" y="0" z="12000"/>
       <box w="14400"/>
-      <glue w="12000"/>
+      
+      <penalty w="0" p="0"/>
+      
+      <glue w="12000" y="0" z="12000"/>
       <box w="14400"/>
-      <glue w="12000"/>
+      
+      <penalty w="0" p="0"/>
+      
+      <glue w="12000" y="0" z="12000"/>
       <box w="14400"/>
+      
       <skip>3</skip>
     </element-list>
   </checks>