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 53x18
          text run at (0,0) width 53: "Test for "
        RenderInline {I} at (0,0) size 641x18
          RenderInline {A} at (0,0) size 301x18 [color=#0000EE]
            RenderText {#text} at (53,0) size 301x18
              text run at (53,0) width 301: "http://bugs.webkit.org/show_bug.cgi?id=14395"
          RenderText {#text} at (354,0) size 340x18
            text run at (354,0) width 4: " "
            text run at (358,0) width 336: "When a <p> is inside <li> two <BR>s are rendered"
        RenderText {#text} at (694,0) size 4x18
          text run at (694,0) width 4: "."
      RenderBlock {P} at (0,34) size 784x18
        RenderText {#text} at (0,0) size 487x18
          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 7x18: bullet
              RenderText {#text} at (0,0) size 27x18
                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 7x18: bullet
            RenderText {#text} at (0,0) size 27x18
              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 7x18: bullet
              RenderText {#text} at (0,0) size 27x18
                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 7x18: bullet
            RenderInline {SPAN} at (0,0) size 40x18
              RenderInline (generated) at (0,0) size 40x18
                RenderText at (0,0) size 40x18
                  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 27x18
                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 7x18: white bullet
                RenderListMarker at (-57,0) size 7x18: bullet
                RenderText {#text} at (0,0) size 27x18
                  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 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 27x18
                  text run at (0,0) width 27: "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 522x18
          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 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 27x18
                text run at (0,0) width 27: "item"
          RenderBlock (anonymous) at (0,36) size 744x18
            RenderBR {BR} at (0,0) size 0x18
