layer at (0,0) size 800x600
  RenderView at (0,0) size 800x600
layer at (0,0) size 800x600
  RenderBlock {HTML} at (0,0) size 800x600
    RenderBody {BODY} at (8,8) size 784x576
      RenderBlock {P} at (0,0) size 784x18
        RenderText {#text} at (0,0) size 54x18
          text run at (0,0) width 54: "Test for "
        RenderInline {I} at (0,0) size 647x18
          RenderInline {A} at (0,0) size 305x18 [color=#0000EE]
            RenderText {#text} at (53,0) size 305x18
              text run at (53,0) width 305: "http://bugs.webkit.org/show_bug.cgi?id=14395"
          RenderText {#text} at (357,0) size 343x18
            text run at (357,0) width 5: " "
            text run at (361,0) width 339: "When a <p> is inside <li> two <BR>s are rendered"
        RenderText {#text} at (699,0) size 5x18
          text run at (699,0) width 5: "."
      RenderBlock {P} at (0,34) size 784x18
        RenderText {#text} at (0,0) size 499x18
          text run at (0,0) width 499: "In all of the following, the bullets should be lined up with the first line of text."
      RenderBlock {UL} at (0,68) size 784x18
        RenderListItem {LI} at (40,0) size 744x18
          RenderBlock (anonymous) at (0,0) size 744x0
            RenderInline {SPAN} at (0,0) size 0x0
              RenderText {#text} at (0,0) size 0x0
          RenderBlock (anonymous) at (0,0) size 744x18
            RenderBlock {DIV} at (0,0) size 744x18
              RenderListMarker at (-17,0) size 7x18: bullet
              RenderText {#text} at (0,0) size 29x18
                text run at (0,0) width 29: "item"
          RenderBlock (anonymous) at (0,18) size 744x0
            RenderInline {SPAN} at (0,0) size 0x0
      RenderBlock {UL} at (0,102) size 784x18
        RenderListItem {LI} at (40,0) size 744x18
          RenderBlock (anonymous) at (0,0) size 744x0
            RenderInline {SPAN} at (0,0) size 0x0
              RenderText {#text} at (0,0) size 0x0
            RenderText {#text} at (0,0) size 0x0
          RenderBlock {DIV} at (0,0) size 744x18
            RenderListMarker at (-17,0) size 7x18: bullet
            RenderText {#text} at (0,0) size 29x18
              text run at (0,0) width 29: "item"
      RenderBlock {UL} at (0,136) size 784x18
        RenderListItem {LI} at (40,0) size 744x18
          RenderBlock (anonymous) at (0,0) size 744x0
            RenderInline {SPAN} at (0,0) size 0x0
              RenderText {#text} at (0,0) size 0x0
              RenderInline {I} at (0,0) size 0x0
                RenderText {#text} at (0,0) size 0x0
          RenderBlock (anonymous) at (0,0) size 744x18
            RenderBlock {DIV} at (0,0) size 744x18
              RenderListMarker at (-17,0) size 7x18: bullet
              RenderText {#text} at (0,0) size 28x18
                text run at (0,0) width 28: "item"
          RenderBlock (anonymous) at (0,18) size 744x0
            RenderInline {SPAN} at (0,0) size 0x0
              RenderInline {I} at (0,0) size 0x0
              RenderText {#text} at (0,0) size 0x0
            RenderText {#text} at (0,0) size 0x0
      RenderBlock {UL} at (0,170) size 784x36
        RenderListItem {LI} at (40,0) size 744x36
          RenderBlock (anonymous) at (0,0) size 744x18
            RenderListMarker at (-17,0) size 7x18: bullet
            RenderInline {SPAN} at (0,0) size 41x18
              RenderInline (generated) at (0,0) size 41x18
                RenderText at (0,0) size 41x18
                  text run at (0,0) width 41: "before"
              RenderText {#text} at (0,0) size 0x0
          RenderBlock (anonymous) at (0,18) size 744x18
            RenderBlock {DIV} at (0,0) size 744x18
              RenderText {#text} at (0,0) size 29x18
                text run at (0,0) width 29: "item"
          RenderBlock (anonymous) at (0,36) size 744x0
            RenderInline {SPAN} at (0,0) size 0x0
      RenderBlock {UL} at (0,222) size 784x36
        RenderListItem {LI} at (40,0) size 744x36
          RenderBlock (anonymous) at (0,0) size 744x0
            RenderInline {SPAN} at (0,0) size 0x0
          RenderBlock (anonymous) at (0,0) size 744x18
            RenderBlock {UL} at (0,0) size 744x18
              RenderListItem {LI} at (40,0) size 704x18
                RenderListMarker at (-17,0) size 7x18: white bullet
                RenderListMarker at (-57,0) size 7x18: bullet
                RenderText {#text} at (0,0) size 29x18
                  text run at (0,0) width 29: "item"
          RenderBlock (anonymous) at (0,18) size 744x18
            RenderInline {SPAN} at (0,0) size 0x0
            RenderBR {BR} at (0,0) size 0x18
      RenderBlock {UL} at (0,274) size 784x36
        RenderListItem {LI} at (40,0) size 744x36
          RenderBlock {DIV} at (0,0) size 744x18
            RenderBlock {UL} at (0,0) size 744x18
              RenderListItem {LI} at (40,0) size 704x18
                RenderListMarker at (-17,0) size 7x18: white bullet
                RenderListMarker at (-57,0) size 7x18: bullet
                RenderText {#text} at (0,0) size 29x18
                  text run at (0,0) width 29: "item"
          RenderBlock (anonymous) at (0,18) size 744x18
            RenderBR {BR} at (0,0) size 0x18
      RenderBlock {P} at (0,326) size 784x18
        RenderText {#text} at (0,0) size 534x18
          text run at (0,0) width 534: "In this case, the solid bullet should be one line above the hollow bullet and the text."
      RenderBlock {UL} at (0,360) size 784x54
        RenderListItem {LI} at (40,0) size 744x54
          RenderBlock (anonymous) at (0,0) size 744x18
            RenderListMarker at (-17,0) size 7x18: bullet
          RenderBlock {UL} at (0,18) size 744x18
            RenderListItem {LI} at (40,0) size 704x18
              RenderListMarker at (-17,0) size 7x18: white bullet
              RenderText {#text} at (0,0) size 29x18
                text run at (0,0) width 29: "item"
          RenderBlock (anonymous) at (0,36) size 744x18
            RenderBR {BR} at (0,0) size 0x18
