<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
<html>
<head>
<script src="../../resources/js-test-pre.js"></script>
<script>
if (window.testRunner) {
    window.testRunner.dumpAsText();
}
</script>
</head>
<body>
<div id="unstyled">Unstyled Font Family</div>
<div id="initialFontFamily" style="font-family: initial;">Initial Font Family</div>
<div id="initialFont" style="font: initial;">Initial Font</div>
<hr>
<p id="description"></p>
<div id="console"></div>
<script>
description("Test for <a href=\"https://bugs.webkit.org/show_bug.cgi?id=19085\">Bug 19085: font-family: initial sets font-family differently than font: initial</a>");

var initialFontElement = document.getElementById("initialFont");
var initialFontFamilyElement = document.getElementById("initialFontFamily");
var unstyledElement = document.getElementById("unstyled");

var initialFont = document.defaultView.getComputedStyle(initialFontElement, null).getPropertyValue("font-family");
var initialFontFamily = document.defaultView.getComputedStyle(initialFontFamilyElement, null).getPropertyValue("font-family");
var unstyled = document.defaultView.getComputedStyle(unstyledElement, null).getPropertyValue("font-family");

shouldBe("initialFontFamily", "unstyled");
shouldBe("initialFont", "unstyled");
</script>
<script src="../../resources/js-test-post.js"></script>
</body>
</html>
