<!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-grow - positive number(fill all space)</title>
<link href="http://www.intel.com" rel="author" title="Intel">
<link href="mailto:shiyoux.tan@intel.com" rel="author" title="Shiyou Tan">
<link href="http://www.w3.org/TR/css-flexbox-1/#flex-grow-property" rel="help" title="7.3.1. The 'flex-grow' property">
<link href="reference/ref-filled-green-100px-square.htm" rel="match">
<meta content="" name="flags">
<meta content="Test checks that all space of flex container will be filled when there is only one flex item and 'flex-grow' set any positive number." name="assert">
<style>
  body {
    margin: 0px;
    background-color: white;
    font-family: Roboto;
    font-size: 16px;
  }
  .container {
    background-color: red;
    display: flex;
    height: 50px;
    width: 100px;
  }
  .container > div {
    background-color: green;
    height: 50px;
    width: 25px;
  }
  #test1 {
    flex-grow: 1.5;
  }
  #test2 {
    flex-grow: 2;
  }
</style>
</head><body>
  <span>Test passes if there is a filled green square and no red.</span>
  <div class="container">
    <div id="test1"></div>
  </div>
  <div class="container">
    <div id="test2"></div>
  </div>

</body></html>
