<!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: Text-align 'justify' and 'inline-block' elements</title>
        <link rel="author" title="Microsoft" href="http://www.microsoft.com/" />
        <link rel="help" href="http://www.w3.org/TR/CSS21/visuren.html#inline-formatting" />
        <meta name="flags" content="" />
        <meta name="assert" content="If 'text-align' is set to 'justify' the user agent does not stretch spaces and/or words when the 'display' property is set to 'inline-block'." />
        <style type="text/css">
            div
            {
                border: solid black;
                text-align: justify;
                width: 200px;
            }
            span
            {
                display: inline-block;
            }
        </style>
    </head>
    <body>
        <p>Test passes if the width of spaces and/or characters of the first line of "Filler Text" is larger than the second line of "Filler Text".</p>
        <div>
            Filler Text Filler Text
            <span>Filler Text Filler Text</span>
        </div>
    </body>
</html>