<!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>Child combinator</title>
  <style type="text/css"><![CDATA[.white { background-color: transparent ! important; }
.red { background-color: red; }
div > p.test { background-color: lime; }]]></style>
  <link rel="author" title="Daniel Glazman" href="http://glazman.org/"/>
  <link rel="author" title="Ian Hickson" href="mailto:ian@hixie.ch"/>
  <link rel="help" href="https://www.w3.org/TR/css3-selectors/#selectors"/> <!-- bogus link to make sure it gets found -->
  <meta name="flags" content="" />
 </head>
 <body>
 <div>
  <p class="red test">This paragraph should have a green background</p>
  <div>
   <p class="red test">This paragraph should have a green background</p>
  </div>
 </div>
 <table>
  <tbody>
   <tr>
    <td>
     <p class="white test">This paragraph should be unstyled.</p>
    </td>
   </tr>
  </tbody>
 </table>
</body>
</html>