<!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 Multi-column Layout Test: no margin collapsing with its first child block box</title>
  <link rel="author" title="Opera Software ASA" href="http://www.opera.com/" />
  <link rel="reviewer" title="Gérard Talbot" href="http://www.gtalbot.org/BrowserBugsSection/css21testsuite/" /> <!--  2013-07-25  -->
  <link rel="help" href="http://www.w3.org/TR/css3-multicol/#the-multi-column-model" title="2. The multi-column model" />
  <link rel="match" href="multicol-collapsing-001-ref.xht"/>
  <meta name="flags" content="ahem" />
  <meta name="assert" content="This test checks that the top margin of the first child block box of a multicol element does not collapse with the margin top of such multicol element." />
  <style type="text/css"><![CDATA[
  body > div
  {
  background-color: black;
  border: black solid 1px;
  font: 1.25em/1 Ahem;
  width: 10em;
  }

  div > div
  {
  background-color: yellow;
  color: black;
  margin: 1em;
  width: 8em;
  orphans: 1;
  widows: 1;

  column-count: 3;
  column-gap: 1em;
  }

  h4
  {
  font: inherit;
  margin: 1em 0 0;
  }
  ]]></style>
 </head>
 <body>
  <div>
    <div>
	  <h4>ab cd</h4>
      ef gh
      ij kl
      mn oq
    </div>
  </div>
 </body>
</html>