Skip to content

Commit

Permalink
Simplify test
Browse files Browse the repository at this point in the history
  • Loading branch information
@laurmaedje
laurmaedje committed Aug 21, 2023
1 parent 42c1c6e commit 1a33980
Show file tree
Hide file tree
Showing 2 changed files with 107 additions and 212 deletions.
Binary file modified tests/ref/compiler/selector-logical.png
View file
Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
319 changes: 107 additions & 212 deletions tests/typ/compiler/selector-logical.typ
View file
Original file line number Diff line number Diff line change
@@ -1,231 +1,126 @@
//Tests for logical (and/or) selectors

---
// Test `or`

= A
== B
#figure([Cat], kind: "cat", supplement: none)
=== D
= E
#figure([Frog], kind: "frog", supplement: none)
== G
== H

#let refr = ([A], [D], [E])
#locate(loc => {
let q = query(heading.where(level: 1)
.or(heading.where(level: 3)),
loc);
let q = q.map(e => { e.body } )
test(q, refr)
})

#let refr = ([A], [D], [E], [Frog])
#locate(loc => {
let q = query(heading.where(level: 1)
.or(heading.where(level: 3))
.or(figure.where(kind: "frog")),
loc);
let q = q.map( e => e.body)
test(q, refr)
})

#let refr = ([A], [B], [Cat], [E], [Frog], [G], [H])
#locate(loc => {
let q = query(heading.where(level: 1)
.or(heading.where(level: 2))
.or(figure.where(kind: "frog"))
.or(figure.where(kind: "cat")),
loc);
test(q.map(e => e.body), refr)
})

---
// Test empty matches

= A
== B
#figure([Cat], kind: "cat", supplement: none)
=== D
= E
#figure([Frog], kind: "frog", supplement: none)
== G
== H

#let refr = ([D],)
#locate(loc => {
let q = query(figure.where(kind: "dog")
.or(heading.where(level: 3)),
loc);
let q = q.map(e => { e.body } )
test(q, refr)
})

#locate(loc => {
let q = query(figure.where(kind: "dog")
.or(figure.where(kind: "fish")),
loc);
test(q.len(), 0)
})

#locate(loc => {
let q = query(figure.where(kind: "dog")
.and(figure.where(kind: "frog")),
loc);
test(q.len(), 0)
})

---
// Test `or` duplicates removal
= A
= B
== C <C>
= D
== E

#let refr = ([A], [B], [D])
#locate(loc => {
let q = query(heading.where(level: 1).or(heading.where(level: 1)), loc)
let q = q.map(e => { e.body } )
test(q, refr)
})

---
// Test `or` with `before`/`after`

= A
== B
#figure([Cat], kind: "cat", supplement: none)
#figure([Cat], kind: "cat", supplement: [Other])
=== D
= E
<label>
= E <first>
#figure([Frog], kind: "frog", supplement: none)
#figure([Giraffe], kind: "giraffe", supplement: none)
#figure([Giraffe], kind: "giraffe", supplement: none) <second>
#figure([GiraffeCat], kind: "cat", supplement: [Other]) <second>
= H
#figure([Iguana], kind: "iguana", supplement: none)
== I

#let refr = ([A], [B], [Cat], [D], [E])
#locate(loc => {
let q = query(selector(heading).before(<label>)
.or(selector(figure).before(<label>)),
loc);
let q = q.map(e => { e.body } )
test(q, refr)
})

#let refr = ([Frog], [Giraffe], [I])
#locate(loc => {
let q = query(heading.where(level: 2).after(<label>)
.or(selector(figure).after(<label>)),
loc);
let q = q.map( e => e.body)
test(q, refr)
})
#let test(a, b) = assert.eq(a, b)
#let test-selector(selector, ref) = locate(loc => {
let elems = query(selector, loc)
test(elems.map(e => e.body), ref)
})

---
// Test `and` with `after`
// Test `or`.
#test-selector(
heading.where(level: 1).or(heading.where(level: 3)),
([A], [D], [E], [H]),
)

#test-selector(
heading.where(level: 1)
.or(heading.where(level: 3))
.or(figure.where(kind: "frog")),
([A], [D], [E], [Frog], [H]),
)

#test-selector(
heading.where(level: 1)
.or(heading.where(level: 2))
.or(figure.where(kind: "frog"))
.or(figure.where(kind: "cat")),
([A], [B], [Cat], [E], [Frog], [GiraffeCat], [H], [I]),
)

#test-selector(
figure.where(kind: "dog").or(heading.where(level: 3)),
([D],),
)

#test-selector(
figure.where(kind: "dog").or(figure.where(kind: "fish")),
(),
)

// Test `or` duplicates removal.
#test-selector(
heading.where(level: 1).or(heading.where(level: 1)),
([A], [E], [H]),
)

// Test `and`.
#test-selector(
figure.where(kind: "cat").and(figure.where(kind: "frog")),
(),
)

= A
== B
#figure([Cat], kind: "cat", supplement: [Other])
=== D
= E
<first>
#figure([Frog], kind: "frog", supplement: none)
#figure([GiraffeCat], kind: "cat", supplement: [Other])
<second>
= H
== I
// Test `or` with `before`/`after`
#test-selector(
selector(heading)
.before(<first>)
.or(selector(figure).before(<first>)),
([A], [B], [Cat], [D], [E]),
)

#test-selector(
heading.where(level: 2)
.after(<first>)
.or(selector(figure).after(<first>)),
([Frog], [Giraffe], [GiraffeCat], [Iguana], [I]),
)

#let refr = ([GiraffeCat],)
#locate(loc => {
let q = query(figure.where(kind: "cat").and(
figure.where(supplement: [Other])).after(<first>),
loc)
let q = q.map(e => { e.body } )
test(q, refr)
})
// Test `and` with `after`
#test-selector(
figure.where(kind: "cat")
.and(figure.where(supplement: [Other]))
.after(<first>),
([GiraffeCat],),
)

---
// Test `and` (with nested `or`)
#test-selector(
heading.where(level: 2)
.or(heading.where(level: 3))
.and(heading.where(level: 2).or(heading.where(level: 1))),
([B], [I]),
)

#test-selector(
heading.where(level: 2)
.or(heading.where(level: 3))
.or(heading.where(level:1))
.and(heading.where(level: 2).or(heading.where(level: 1)))
.and(heading.where(level: 3).or(heading.where(level: 1))),
([A], [E], [H]),
)

= A
== B
#figure([Cat], kind: "cat", supplement: none)
=== D
= E
#figure([Frog], kind: "frog", supplement: none)
#figure([Giraffe], kind: "giraffe", supplement: none)
= H
== I

#let refr = ([B], [I])
#locate(loc => {
let q = query(
(heading.where(level: 2).or( heading.where(level: 3)))
.and(
heading.where(level: 2).or( heading.where(level: 1)))
, loc)
let q = q.map(e => { e.body } )
test(q, refr)
})

#let refr = ([A], [E], [H])
#locate(loc => {
let q = query(
(heading.where(level: 2).or( heading.where(level: 3))).or(heading.where(level:1))
.and(
heading.where(level: 2).or( heading.where(level: 1))
)
.and(
heading.where(level: 3).or( heading.where(level: 1))
), loc)
let q = q.map(e => { e.body } )
test(q, refr)
})

---
// Test `and` with `or` and `before`/`after`

= A
== B
#figure([Cat], kind: "cat", supplement: none)
=== D
= E
#let refr = ([A], [E])
#locate(loc => {
let q = query(
heading.where(level: 1).before(loc)
.or(
heading.where(level: 3).before(loc))
#test-selector(
heading.where(level: 1).before(<first>)
.or(heading.where(level: 3).before(<first>))
.and(
heading.where(level: 1).before(loc)
.or(
heading.where(level: 2).before(loc))), loc)
let q = q.map(e => { e.body } )
test(q, refr)
})
#let refr = ([Frog], [Iguana])
#locate(loc => {
let q = query(
heading.where(level: 1).before(loc)
.or(
selector(figure).after(loc))
heading.where(level: 1).before(<first>)
.or(heading.where(level: 2).before(<first>))
),
([A], [E]),
)

#test-selector(
heading.where(level: 1).before(<first>, inclusive: false)
.or(selector(figure).after(<first>))
.and(
figure.where(kind: "iguana")
.or(
figure.where(kind: "frog"))
.or(
figure.where(kind: "cat"))
.or(
heading.where(level: 1).after(loc))),
loc)
let q = q.map(e => { e.body } )
test(q, refr)
})
#figure([Frog], kind: "frog", supplement: none)
#figure([Giraffe], kind: "giraffe", supplement: none)
= H
#figure([Iguana], kind: "iguana", supplement: none)
== J
figure.where(kind: "iguana")
.or(figure.where(kind: "frog"))
.or(figure.where(kind: "cat"))
.or(heading.where(level: 1).after(<first>))
),
([Frog], [GiraffeCat], [Iguana])
)

0 comments on commit 1a33980

Please sign in to comment.