<!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: Borders. Border-bottom-right-radius using two length values: 0.5in 10mm</title>
		<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
		<meta http-equiv="Content-Style-Type" content="text/css" />
        <meta http-equiv="Content-Script-Type" content="text/javascript" />
        <link rel="author" title="Nokia" href="http://www.nokia.com/" />
        <link rel="help" href="http://www.w3.org/TR/css3-background/#the-border-radius" />
        <meta name="flags" content="" />
        <meta name="assert" content="To verify border-bottom-right-radius property set with two values (with different units), works as expected" />
        <style type="text/css">
        /* <![CDATA[ */
        	div
            {
        		border:2px solid #a1a1a1;
        		background:#dddddd;
        		width:200px;
        		height: 100px;
        		border-bottom-right-radius:  0.5in 10mm;
        	}
        /* ]]> */
        </style>
<!--
        <script type="text/javascript" src="js/css3_test_helper.js"></script>
-->
    </head>
    <body>
    	<p>
			There should be a box with a rounded bottom right corner.
		</p>
		 <!-- PASS AND FAIL CRITERIA ARE IN THE LIST BELOW -->
				<ul>
					<li>PASS if only bottom right corner is rounded.</li>
					<li>FAIL if the output is not as expected.</li>
				</ul>

         <!-- PLACE TEST CONTENT FROM HERE -->
    	<div id="test"></div>
    	<p><br/></p>
<!--
    	<script type="text/javascript">
        /* <![CDATA[ */
        	var expectedBorderRadius = "48px 37px";

        	var testResult = check_CSS_property("border-bottom-right-radius", expectedBorderRadius);

        	// if (testResult.pass)
        	  /* This portion of the code has been removed to ensure that the test case is not automated */
        	// else
        		/* This portion of the code has been removed to ensure that the test case is not automated */



          if (top.FrameEnabled)	top.fnLog(testResult);

        /* ]]> */
        </script>
-->
    </body>
</html>

