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 52x17
          text run at (0,0) width 52: "Test for "
        RenderInline {I} at (0,0) size 640x17
          RenderInline {A} at (0,0) size 302x17 [color=#0000EE]
            RenderText {#text} at (51,0) size 302x17
              text run at (51,0) width 302: "http://bugs.webkit.org/show_bug.cgi?id=14395"
          RenderText {#text} at (352,0) size 339x17
            text run at (352,0) width 5: " "
            text run at (356,0) width 335: "When a <p> is inside <li> two <BR>s are rendered"
        RenderText {#text} at (690,0) size 5x17
          text run at (690,0) width 5: "."
      RenderBlock {P} at (0,34) size 784x18
        RenderText {#text} at (0,0) size 487x17
          text run at (0,0) width 487: "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 7x17: bullet
              RenderText {#text} at (0,0) size 27x17
                text run at (0,0) width 27: "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 7x17: bullet
            RenderText {#text} at (0,0) size 27x17
              text run at (0,0) width 27: "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 7x17: bullet
              RenderText {#text} at (0,0) size 27x17
                text run at (0,0) width 27: "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 7x17: bullet
            RenderInline {SPAN} at (0,0) size 40x17
              RenderInline (generated) at (0,0) size 40x17
                RenderText at (0,0) size 40x17
                  text run at (0,0) width 40: "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 27x17
                text run at (0,0) width 27: "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 7x17: white bullet
                RenderListMarker at (-57,0) size 7x17: bullet
                RenderText {#text} at (0,0) size 27x17
                  text run at (0,0) width 27: "item"
          RenderBlock (anonymous) at (0,18) size 744x18
            RenderInline {SPAN} at (0,0) size 0x0
            RenderBR {BR} at (0,0) size 0x17
      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 7x17: white bullet
                RenderListMarker at (-57,0) size 7x17: bullet
                RenderText {#text} at (0,0) size 27x17
                  text run at (0,0) width 27: "item"
          RenderBlock (anonymous) at (0,18) size 744x18
            RenderBR {BR} at (0,0) size 0x17
      RenderBlock {P} at (0,326) size 784x18
        RenderText {#text} at (0,0) size 522x17
          text run at (0,0) width 522: "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 7x17: bullet
          RenderBlock {UL} at (0,18) size 744x18
            RenderListItem {LI} at (40,0) size 704x18
              RenderListMarker at (-17,0) size 7x17: white bullet
              RenderText {#text} at (0,0) size 27x17
                text run at (0,0) width 27: "item"
          RenderBlock (anonymous) at (0,36) size 744x18
            RenderBR {BR} at (0,0) size 0x17
