<!DOCTYPE html>
<!--
 | Flexbox unit test from csswg.
 |   http://test.csswg.org/suites/css-flexbox-1_dev/nightly-unstable/html/chapter-7.htm
 -->
<html><head><meta charset="utf-8">
<title>CSS Flexbox Test: flex-basis - 50%</title>
<link href="http://www.intel.com" rel="author" title="Intel">
<link href="mailto:shiyoux.tan@intel.com" rel="author" title="Intel">
<link href="http://www.w3.org/TR/css-flexbox-1/#flex-basis-property" rel="help" title="7.3.3. The 'flex-basis' property">
<link href="reference/ref-filled-green-100px-square.htm" rel="match">
<meta content="" name="flags">
<meta content="The 'flex-basis' property set positive percentage, the actual width of tested element same as the percentage of flex container size." name="assert">
<style>
  body {
    margin: 0px;
    background-color: white;
    font-family: Roboto;
    font-size: 16px;
  }
  #container {
    background-color: red;
    display: flex;
    height: 100px;
    width: 100px;
  }
  #container div{
    background-color: green;
    height: 100px;
  }
  #ref {
    width: 40px;
  }
  #test {
    flex-basis: 60%;
  }
</style>
</head><body>
  <span>Test passes if there is a filled green square and no red.</span>
  <div id="container">
    <div id="ref"></div>
    <div id="test"></div>
  </div>

</body></html>
