<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
    <title>CSS Test: Test for wrapping around floats which are overlapped by the element that must avoid them</title>
    <link rel="author" title="WebKit" href="http://webkit.org/">
    <link rel="help" href="http://www.w3.org/TR/CSS21/visuren.html#floats">
    <style type="text/css">
        body { width: 400px; background: white}
        .container { width: 100px; height: 150px; background: lime;}
        div { background: white; }
        .text:first-line { font-size: 30px;}
        .text { color:red;}
    </style>
</head>
<body>
<!-- Avoid floats on the first line of a container using the font or line height as a hint. -->
<p>There should be no red text visible below.</p>
<div class="container">
    <div style="position: absolute; width: 100px; height: 150px; background: black;"></div>
    <div style="float: left; width: 10px; height: 25px;  background: white"></div>
    <div style="float: left; clear:left; width: 40px; height: 50px; background: white"></div>
    <p class="text">This long text should stay inside the container.</p>
</div>


</body></html>
