<!DOCTYPE html>
<title>CSS RefTest Reference</title>
<link rel="author" title="Bem Jones-Bey" href="mailto:bjonesbe@adobe.com">
<meta name="flags" content="ahem">
<style>
.container {
    width: 100px;
    height: 75px;
    font: 25px/1 Ahem;
    line-height: 25px;
    border: 10px solid black;
    display: inline-block;
    -webkit-writing-mode: vertical-rl;
}

.left-text {
    text-align: left;
}

.right-text {
    text-align: right;
}

.left {
    float: left;
    width: 75px;
    height: 50px;
}

.right {
    float: right;
    width: 75px;
    height: 50px;
}
</style>
</head>
<body>
    <p>Test passes if you see two black rectangle boxes with a smaller white rectangle in one corner.</p>
    <div class="container left-text">
        <div class="left"></div>
        X<br/>
        X<br/>
        X<br/>
        XXX<br/>
    </div>

    <div class="container right-text">
        <div class="right"></div>
        X<br/>
        X<br/>
        X<br/>
        XXX<br/>
    </div>
</body>
