<?xml version="1.0" encoding="UTF-8"?>
<!--
  Licensed to the Apache Software Foundation (ASF) under one or more
  contributor license agreements.  See the NOTICE file distributed with
  this work for additional information regarding copyright ownership.
  The ASF licenses this file to You 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 that blocks of texts are re-laid out after a change of the flow ipd.
    </p>
  </info>
  <fo>
<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:fox="http://xmlgraphics.apache.org/fop/extensions" font-family="Helvetica">
  <fo:layout-master-set>
    <fo:simple-page-master page-width="210mm" page-height="297mm" master-name="PageA">
      <fo:region-body margin-right="5mm" margin-left="5mm" margin-bottom="25.4mm" margin-top="25.4mm" region-name="Body"/>

    </fo:simple-page-master>
    <fo:simple-page-master page-width="210mm" page-height="297mm" master-name="PageB">
      <fo:region-body column-count="2" margin-right="15mm" margin-left="15mm" margin-bottom="25.4mm" margin-top="25.4mm" region-name="Body"/>

    </fo:simple-page-master>
    <fo:page-sequence-master master-name="PageSequence">
      <fo:repeatable-page-master-alternatives>
        <fo:conditional-page-master-reference page-position="first" master-reference="PageA"/>
        <fo:conditional-page-master-reference page-position="rest" master-reference="PageB"/>
      </fo:repeatable-page-master-alternatives>
    </fo:page-sequence-master>
  </fo:layout-master-set>
  <fo:page-sequence format="1" id="th_default_sequence1" initial-page-number="auto" force-page-count="auto" master-reference="PageSequence">

    <fo:flow flow-name="Body">
      <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">1. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec vulputate ante interdum malesuada suscipit. Pellentesque in ligula lobortis, ullamcorper ante sed, lacinia nisl. Cras at vestibulum enim. Praesent velit leo, ullamcorper vel velit quis, euismod blandit leo. Maecenas placerat fringilla purus. Sed sit amet justo in tellus laoreet suscipit a ac quam. Praesent elementum ut erat vitae lacinia. Phasellus at congue sapien. In ultrices nec dolor ut pulvinar. Pellentesque eleifend ornare quam, sit amet porttitor odio ultricies in. Maecenas sed diam semper, lacinia enim vitae, volutpat libero.</fo:block>
      <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">2. Phasellus luctus hendrerit pulvinar. Praesent eros sapien, fermentum non lorem quis, ornare elementum arcu. Nam pulvinar nisi ac dictum lacinia. Cras non fermentum libero, tempus euismod nibh. Fusce tincidunt nisl eget eros posuere tincidunt nec eget ipsum. Mauris lobortis at eros ac lobortis. Sed leo ex, molestie eget tortor vel, volutpat ultrices enim. In eu magna dapibus, fringilla velit et, hendrerit lacus. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Ut eget leo sed urna commodo posuere. Ut in tortor massa. Nam tempus augue nec metus tempus congue. Nam vel purus a sem vehicula congue id nec dolor. Sed suscipit vitae enim a scelerisque. Donec molestie vestibulum pellentesque. Ut dignissim libero venenatis facilisis egestas.</fo:block>
      <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">3. Nullam malesuada eros eu dolor suscipit, eu consectetur metus aliquam. Curabitur vestibulum non orci eu ultrices. Proin nisl urna, dictum nec iaculis nec, dictum ac arcu. Ut cursus nibh eu mi scelerisque tincidunt. Pellentesque et hendrerit libero, a porta diam. Ut accumsan mauris eget viverra vulputate. Suspendisse semper tempor eros, at dignissim diam aliquam eu. </fo:block>
      <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">4. Nulla pulvinar est est, eu congue orci gravida quis. Sed at vulputate quam, eget commodo ante. Suspendisse vitae dolor eget nisi consequat lobortis ut vulputate sem. Praesent feugiat nunc lorem, sed ultricies enim accumsan in. Donec auctor dui purus, a finibus sapien ornare ac. Nulla at nisi sed urna tincidunt bibendum. Phasellus tellus enim, pellentesque scelerisque neque nec, vulputate congue augue. In congue risus purus, eget aliquet neque tempus id. Phasellus at lorem a dolor hendrerit rhoncus sit amet semper odio. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Maecenas pellentesque cursus leo non ultrices. Aliquam vitae bibendum velit. Fusce at eleifend ipsum, at laoreet sapien. Nunc scelerisque consectetur eleifend. Nulla a iaculis purus, vitae pharetra sapien.</fo:block>
      <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">5. Phasellus non tellus gravida, feugiat sapien id, eleifend leo. Aenean ut lacinia elit. Donec a augue mauris. Cras at posuere massa, vitae placerat risus. Donec ullamcorper metus a accumsan vestibulum. Integer bibendum laoreet tempor. Mauris pulvinar tortor in turpis suscipit, vel lobortis nisi aliquet. Nulla facilisi.</fo:block>
      <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">6. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec vulputate ante interdum malesuada suscipit. Pellentesque in ligula lobortis, ullamcorper ante sed, lacinia nisl. Cras at vestibulum enim. Praesent velit leo, ullamcorper vel velit quis, euismod blandit leo. Maecenas placerat fringilla purus. Sed sit amet justo in tellus laoreet suscipit a ac quam. Praesent elementum ut erat vitae lacinia. Phasellus at congue sapien. In ultrices nec dolor ut pulvinar. Pellentesque eleifend ornare quam, sit amet porttitor odio ultricies in. Maecenas sed diam semper, lacinia enim vitae, volutpat libero.</fo:block>
      <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">7. Phasellus luctus hendrerit pulvinar. Praesent eros sapien, fermentum non lorem quis, ornare elementum arcu. Nam pulvinar nisi ac dictum lacinia. Cras non fermentum libero, tempus euismod nibh. Fusce tincidunt nisl eget eros posuere tincidunt nec eget ipsum. Mauris lobortis at eros ac lobortis. Sed leo ex, molestie eget tortor vel, volutpat ultrices enim. In eu magna dapibus, fringilla velit et, hendrerit lacus. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Ut eget leo sed urna commodo posuere. Ut in tortor massa. Nam tempus augue nec metus tempus congue. Nam vel purus a sem vehicula congue id nec dolor. Sed suscipit vitae enim a scelerisque. Donec molestie vestibulum pellentesque. Ut dignissim libero venenatis facilisis egestas.</fo:block>
      <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">8. Nullam malesuada eros eu dolor suscipit, eu consectetur metus aliquam. Curabitur vestibulum non orci eu ultrices. Proin nisl urna, dictum nec iaculis nec, dictum ac arcu. Ut cursus nibh eu mi scelerisque tincidunt. Pellentesque et hendrerit libero, a porta diam. Ut accumsan mauris eget viverra vulputate. Suspendisse semper tempor eros, at dignissim diam aliquam eu.</fo:block>
      <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">9. Nulla pulvinar est est, eu congue orci gravida quis. Sed at vulputate quam, eget commodo ante. Suspendisse vitae dolor eget nisi consequat lobortis ut vulputate sem. Praesent feugiat nunc lorem, sed ultricies enim accumsan in. Donec auctor dui purus, a finibus sapien ornare ac. Nulla at nisi sed urna tincidunt bibendum. Phasellus tellus enim, pellentesque scelerisque neque nec, vulputate congue augue. In congue risus purus, eget aliquet neque tempus id. Phasellus at lorem a dolor hendrerit rhoncus sit amet semper odio. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Maecenas pellentesque cursus leo non ultrices. Aliquam vitae bibendum velit. Fusce at eleifend ipsum, at laoreet sapien. Nunc scelerisque consectetur eleifend. Nulla a iaculis purus, vitae pharetra sapien.</fo:block>
      <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">10. Phasellus non tellus gravida, feugiat sapien id, eleifend leo. Aenean ut lacinia elit. Donec a augue mauris. Cras at posuere massa, vitae placerat risus. Donec ullamcorper metus a accumsan vestibulum. Integer bibendum laoreet tempor. Mauris pulvinar tortor in turpis suscipit, vel lobortis nisi aliquet. Nulla facilisi.</fo:block>
      <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">11. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec vulputate ante interdum malesuada suscipit. Pellentesque in ligula lobortis, ullamcorper ante sed, lacinia nisl. Cras at vestibulum enim. Praesent velit leo, ullamcorper vel velit quis, euismod blandit leo. Maecenas placerat fringilla purus. Sed sit amet justo in tellus laoreet suscipit a ac quam. Praesent elementum ut erat vitae lacinia. Phasellus at congue sapien. In ultrices nec dolor ut pulvinar. Pellentesque eleifend ornare quam, sit amet porttitor odio ultricies in. Maecenas sed diam semper, lacinia enim vitae, volutpat libero.</fo:block>
      <fo:block span="all">
        <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">12. Phasellus luctus hendrerit pulvinar. Praesent eros sapien, fermentum non lorem quis, ornare elementum arcu. Nam pulvinar nisi ac dictum lacinia. Cras non fermentum libero, tempus euismod nibh. Fusce tincidunt nisl eget eros posuere tincidunt nec eget ipsum. Mauris lobortis at eros ac lobortis. Sed leo ex, molestie eget tortor vel, volutpat ultrices enim. In eu magna dapibus, fringilla velit et, hendrerit lacus. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Ut eget leo sed urna commodo posuere. Ut in tortor massa. Nam tempus augue nec metus tempus congue. Nam vel purus a sem vehicula congue id nec dolor. Sed suscipit vitae enim a scelerisque. Donec molestie vestibulum pellentesque. Ut dignissim libero venenatis facilisis egestas.</fo:block>
        <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">13. Nullam malesuada eros eu dolor suscipit, eu consectetur metus aliquam. Curabitur vestibulum non orci eu ultrices. Proin nisl urna, dictum nec iaculis nec, dictum ac arcu. Ut cursus nibh eu mi scelerisque tincidunt. Pellentesque et hendrerit libero, a porta diam. Ut accumsan mauris eget viverra vulputate. Suspendisse semper tempor eros, at dignissim diam aliquam eu.</fo:block>
      </fo:block>
      <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">14. Nulla pulvinar est est, eu congue orci gravida quis. Sed at vulputate quam, eget commodo ante. Suspendisse vitae dolor eget nisi consequat lobortis ut vulputate sem. Praesent feugiat nunc lorem, sed ultricies enim accumsan in. Donec auctor dui purus, a finibus sapien ornare ac. Nulla at nisi sed urna tincidunt bibendum. Phasellus tellus enim, pellentesque scelerisque neque nec, vulputate congue augue. In congue risus purus, eget aliquet neque tempus id. Phasellus at lorem a dolor hendrerit rhoncus sit amet semper odio. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Maecenas pellentesque cursus leo non ultrices. Aliquam vitae bibendum velit. Fusce at eleifend ipsum, at laoreet sapien. Nunc scelerisque consectetur eleifend. Nulla a iaculis purus, vitae pharetra sapien.</fo:block>
      <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">15. Phasellus non tellus gravida, feugiat sapien id, eleifend leo. Aenean ut lacinia elit. Donec a augue mauris. Cras at posuere massa, vitae placerat risus. Donec ullamcorper metus a accumsan vestibulum. Integer bibendum laoreet tempor. Mauris pulvinar tortor in turpis suscipit, vel lobortis nisi aliquet. Nulla facilisi.</fo:block>
      <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">16. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec vulputate ante interdum malesuada suscipit. Pellentesque in ligula lobortis, ullamcorper ante sed, lacinia nisl. Cras at vestibulum enim. Praesent velit leo, ullamcorper vel velit quis, euismod blandit leo. Maecenas placerat fringilla purus. Sed sit amet justo in tellus laoreet suscipit a ac quam. Praesent elementum ut erat vitae lacinia. Phasellus at congue sapien. In ultrices nec dolor ut pulvinar. Pellentesque eleifend ornare quam, sit amet porttitor odio ultricies in. Maecenas sed diam semper, lacinia enim vitae, volutpat libero.</fo:block>
      <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">17. Phasellus luctus hendrerit pulvinar. Praesent eros sapien, fermentum non lorem quis, ornare elementum arcu. Nam pulvinar nisi ac dictum lacinia. Cras non fermentum libero, tempus euismod nibh. Fusce tincidunt nisl eget eros posuere tincidunt nec eget ipsum. Mauris lobortis at eros ac lobortis. Sed leo ex, molestie eget tortor vel, volutpat ultrices enim. In eu magna dapibus, fringilla velit et, hendrerit lacus. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Ut eget leo sed urna commodo posuere. Ut in tortor massa. Nam tempus augue nec metus tempus congue. Nam vel purus a sem vehicula congue id nec dolor. Sed suscipit vitae enim a scelerisque. Donec molestie vestibulum pellentesque. Ut dignissim libero venenatis facilisis egestas.</fo:block>
      <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">18. Nullam malesuada eros eu dolor suscipit, eu consectetur metus aliquam. Curabitur vestibulum non orci eu ultrices. Proin nisl urna, dictum nec iaculis nec, dictum ac arcu. Ut cursus nibh eu mi scelerisque tincidunt. Pellentesque et hendrerit libero, a porta diam. Ut accumsan mauris eget viverra vulputate. Suspendisse semper tempor eros, at dignissim diam aliquam eu.</fo:block>
      <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">19. Nulla pulvinar est est, eu congue orci gravida quis. Sed at vulputate quam, eget commodo ante. Suspendisse vitae dolor eget nisi consequat lobortis ut vulputate sem. Praesent feugiat nunc lorem, sed ultricies enim accumsan in. Donec auctor dui purus, a finibus sapien ornare ac. Nulla at nisi sed urna tincidunt bibendum. Phasellus tellus enim, pellentesque scelerisque neque nec, vulputate congue augue. In congue risus purus, eget aliquet neque tempus id. Phasellus at lorem a dolor hendrerit rhoncus sit amet semper odio. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Maecenas pellentesque cursus leo non ultrices. Aliquam vitae bibendum velit. Fusce at eleifend ipsum, at laoreet sapien. Nunc scelerisque consectetur eleifend. Nulla a iaculis purus, vitae pharetra sapien.</fo:block>
      <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">20. Phasellus non tellus gravida, feugiat sapien id, eleifend leo. Aenean ut lacinia elit. Donec a augue mauris. Cras at posuere massa, vitae placerat risus. Donec ullamcorper metus a accumsan vestibulum. Integer bibendum laoreet tempor. Mauris pulvinar tortor in turpis suscipit, vel lobortis nisi aliquet. Nulla facilisi.</fo:block>
      <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">21. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec vulputate ante interdum malesuada suscipit. Pellentesque in ligula lobortis, ullamcorper ante sed, lacinia nisl. Cras at vestibulum enim. Praesent velit leo, ullamcorper vel velit quis, euismod blandit leo. Maecenas placerat fringilla purus. Sed sit amet justo in tellus laoreet suscipit a ac quam. Praesent elementum ut erat vitae lacinia. Phasellus at congue sapien. In ultrices nec dolor ut pulvinar. Pellentesque eleifend ornare quam, sit amet porttitor odio ultricies in. Maecenas sed diam semper, lacinia enim vitae, volutpat libero.</fo:block>
      <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">22. Phasellus luctus hendrerit pulvinar. Praesent eros sapien, fermentum non lorem quis, ornare elementum arcu. Nam pulvinar nisi ac dictum lacinia. Cras non fermentum libero, tempus euismod nibh. Fusce tincidunt nisl eget eros posuere tincidunt nec eget ipsum. Mauris lobortis at eros ac lobortis. Sed leo ex, molestie eget tortor vel, volutpat ultrices enim. In eu magna dapibus, fringilla velit et, hendrerit lacus. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Ut eget leo sed urna commodo posuere. Ut in tortor massa. Nam tempus augue nec metus tempus congue. Nam vel purus a sem vehicula congue id nec dolor. Sed suscipit vitae enim a scelerisque. Donec molestie vestibulum pellentesque. Ut dignissim libero venenatis facilisis egestas.</fo:block>
      <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">23. Nullam malesuada eros eu dolor suscipit, eu consectetur metus aliquam. Curabitur vestibulum non orci eu ultrices. Proin nisl urna, dictum nec iaculis nec, dictum ac arcu. Ut cursus nibh eu mi scelerisque tincidunt. Pellentesque et hendrerit libero, a porta diam. Ut accumsan mauris eget viverra vulputate. Suspendisse semper tempor eros, at dignissim diam aliquam eu.</fo:block>
      <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">24. Nulla pulvinar est est, eu congue orci gravida quis. Sed at vulputate quam, eget commodo ante. Suspendisse vitae dolor eget nisi consequat lobortis ut vulputate sem. Praesent feugiat nunc lorem, sed ultricies enim accumsan in. Donec auctor dui purus, a finibus sapien ornare ac. Nulla at nisi sed urna tincidunt bibendum. Phasellus tellus enim, pellentesque scelerisque neque nec, vulputate congue augue. In congue risus purus, eget aliquet neque tempus id. Phasellus at lorem a dolor hendrerit rhoncus sit amet semper odio. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Maecenas pellentesque cursus leo non ultrices. Aliquam vitae bibendum velit. Fusce at eleifend ipsum, at laoreet sapien. Nunc scelerisque consectetur eleifend. Nulla a iaculis purus, vitae pharetra sapien.</fo:block>
      <fo:block font-family="Helvetica" font-size="12pt" margin-bottom="10pt">25. Phasellus non tellus gravida, feugiat sapien id, eleifend leo. Aenean ut lacinia elit. Donec a augue mauris. Cras at posuere massa, vitae placerat risus. Donec ullamcorper metus a accumsan vestibulum. Integer bibendum laoreet tempor. Mauris pulvinar tortor in turpis suscipit, vel lobortis nisi aliquet. Nulla facilisi.</fo:block>

    </fo:flow>
  </fo:page-sequence>
</fo:root>

  </fo>
  <checks>
    <eval expected="8." xpath="//pageViewport[2]//block[2]//word"/>
    <eval expected="4" xpath="count(//page)"/>
  </checks>
</testcase>
