1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
package renderers.html
import org.jetbrains.dokka.base.DokkaBase
import org.jetbrains.dokka.base.renderers.html.HtmlRenderer
import org.jetbrains.dokka.base.resolvers.DefaultLocationProviderFactory
import org.jetbrains.dokka.base.resolvers.LocationProvider
import org.jetbrains.dokka.base.resolvers.LocationProviderFactory
import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter
import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder
import org.jetbrains.dokka.links.DRI
import org.jetbrains.dokka.model.Documentable
import org.jetbrains.dokka.model.doc.DocTag
import org.jetbrains.dokka.pages.*
import org.jetbrains.dokka.testApi.context.MockContext
import org.jetbrains.dokka.utilities.DokkaConsoleLogger
import org.junit.Test
import utils.TestOutputWriter
class GroupWrappingTest {
val files = TestOutputWriter()
val context = MockContext(
DokkaBase().outputWriter to { _ -> files },
DokkaBase().locationProviderFactory to ::DefaultLocationProviderFactory
)
@Test
fun notWrapped() {
val page = createPage {
group {
text("a")
text("b")
}
text("c")
}
HtmlRenderer(context).render(page)
assert(linesAfterContentTag().contains("abc"))
}
@Test
fun paragraphWrapped() {
val page = createPage {
group(styles = setOf(TextStyle.Paragraph)) {
text("a")
text("b")
}
text("c")
}
HtmlRenderer(context).render(page)
assert(linesAfterContentTag().contains("<p>ab</p>c"))
}
@Test
fun blockWrapped() {
val page = createPage {
group(styles = setOf(TextStyle.Block)) {
text("a")
text("b")
}
text("c")
}
HtmlRenderer(context).render(page)
assert(linesAfterContentTag().contains("<div>ab</div>c"))
}
@Test
fun nested() {
val page = createPage {
group(styles = setOf(TextStyle.Block)) {
text("a")
group(styles = setOf(TextStyle.Block)) {
group(styles = setOf(TextStyle.Block)) {
text("b")
text("c")
}
}
text("d")
}
}
HtmlRenderer(context).render(page)
assert(linesAfterContentTag().contains("<div>a<div><div>bc</div></div>d</div>"))
}
private fun linesAfterContentTag() =
files.contents.getValue("test-page.html").lines()
.dropWhile { !it.contains("""<div id="content">""") }
.joinToString(separator = "") { it.trim() }
}
// TODO: may be useful for other tests, consider extracting
private fun createPage(
callback: PageContentBuilder.DocumentableContentBuilder.() -> Unit
) = object : RootPageNode(), ContentPage {
override val dri: Set<DRI> = setOf(DRI.topLevel)
override val documentable: Documentable? = null
override val embeddedResources: List<String> = emptyList()
override val name: String
get() = "testPage"
override val children: List<PageNode>
get() = emptyList()
override val content: ContentNode = PageContentBuilder(EmptyCommentConverter, DokkaConsoleLogger).contentFor(
DRI.topLevel,
emptySet(),
block = callback
)
override fun modified(
name: String,
content: ContentNode,
dri: Set<DRI>,
embeddedResources: List<String>,
children: List<PageNode>
) = this
override fun modified(name: String, children: List<PageNode>) = this
}
private object EmptyCommentConverter : CommentsToContentConverter {
override fun buildContent(
docTag: DocTag,
dci: DCI,
platforms: Set<PlatformData>,
styles: Set<Style>,
extras: Set<Extra>
): List<ContentNode> = emptyList()
}
private object EmptyLocationProviderFactory: LocationProviderFactory {
override fun getLocationProvider(pageNode: RootPageNode) = object : LocationProvider {
override fun resolve(dri: DRI, platforms: List<PlatformData>, context: PageNode?): String = ""
override fun resolve(node: PageNode, context: PageNode?, skipExtension: Boolean): String = node.name
override fun resolveRoot(node: PageNode): String {
TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
}
override fun ancestors(node: PageNode): List<PageNode> {
TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
}
}
}
|
