<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
 <head>
  <title>CSS Test: Absolutely positioned elements must shrink wrap tables</title>
  <link rel="author" title="Ian Hickson" href="mailto:ian@hixie.ch"/>
  <link rel="reviewer" title="Gérard Talbot" href="http://www.gtalbot.org/BrowserBugsSection/css21testsuite/" /> <!-- 2012-09-11 -->
  <link rel="alternate" href="http://www.hixie.ch/tests/adhoc/css/box/table/positioning/003.html" type="text/html"/>
  <link rel="help" href="http://www.w3.org/TR/CSS21/visuren.html#dis-pos-flo" />
  <link rel="match" href="../reference/ref-if-there-is-no-red.xht" />

  <style type="text/css">
  body {margin-top: 1em; }

   .test { position: absolute; background: red; }
   table { background: white; color: black; margin: auto; border-spacing: 0px; }
   td { padding: 0px; }
  </style>
 </head>
 <body>
  <div class="test">
   <table>
    <tr>
     <td>Test passes if there is <strong>no red</strong>.</td>
    </tr>
   </table>
  </div>
 </body>
</html>
