From 409e94058f07fb65ae2e5c07faa4731fae542b7c Mon Sep 17 00:00:00 2001 From: Martin Angers Date: Fri, 7 Nov 2014 09:20:20 -0500 Subject: [PATCH] make test assert helpers private --- array_test.go | 50 ++++---- bench_example_test.go | 2 +- expand_test.go | 22 ++-- filter_test.go | 58 ++++----- iteration_test.go | 6 +- manipulation.go | 8 +- manipulation_test.go | 116 ++++++++++++------ traversal_test.go | 278 +++++++++++++++++++++--------------------- type_test.go | 30 +++-- 9 files changed, 309 insertions(+), 261 deletions(-) diff --git a/array_test.go b/array_test.go index 721affd..1dda525 100644 --- a/array_test.go +++ b/array_test.go @@ -6,23 +6,23 @@ import ( func TestFirst(t *testing.T) { sel := Doc().Find(".pvk-content").First() - AssertLength(t, sel.Nodes, 1) + assertLength(t, sel.Nodes, 1) } func TestFirstEmpty(t *testing.T) { sel := Doc().Find(".pvk-zzcontentzz").First() - AssertLength(t, sel.Nodes, 0) + assertLength(t, sel.Nodes, 0) } func TestFirstRollback(t *testing.T) { sel := Doc().Find(".pvk-content") sel2 := sel.First().End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestLast(t *testing.T) { sel := Doc().Find(".pvk-content").Last() - AssertLength(t, sel.Nodes, 1) + assertLength(t, sel.Nodes, 1) // Should contain Footer foot := Doc().Find(".footer") @@ -33,23 +33,23 @@ func TestLast(t *testing.T) { func TestLastEmpty(t *testing.T) { sel := Doc().Find(".pvk-zzcontentzz").Last() - AssertLength(t, sel.Nodes, 0) + assertLength(t, sel.Nodes, 0) } func TestLastRollback(t *testing.T) { sel := Doc().Find(".pvk-content") sel2 := sel.Last().End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestEq(t *testing.T) { sel := Doc().Find(".pvk-content").Eq(1) - AssertLength(t, sel.Nodes, 1) + assertLength(t, sel.Nodes, 1) } func TestEqNegative(t *testing.T) { sel := Doc().Find(".pvk-content").Eq(-1) - AssertLength(t, sel.Nodes, 1) + assertLength(t, sel.Nodes, 1) // Should contain Footer foot := Doc().Find(".footer") @@ -60,65 +60,65 @@ func TestEqNegative(t *testing.T) { func TestEqEmpty(t *testing.T) { sel := Doc().Find("something_random_that_does_not_exists").Eq(0) - AssertLength(t, sel.Nodes, 0) + assertLength(t, sel.Nodes, 0) } func TestEqInvalidPositive(t *testing.T) { sel := Doc().Find(".pvk-content").Eq(3) - AssertLength(t, sel.Nodes, 0) + assertLength(t, sel.Nodes, 0) } func TestEqInvalidNegative(t *testing.T) { sel := Doc().Find(".pvk-content").Eq(-4) - AssertLength(t, sel.Nodes, 0) + assertLength(t, sel.Nodes, 0) } func TestEqRollback(t *testing.T) { sel := Doc().Find(".pvk-content") sel2 := sel.Eq(1).End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestSlice(t *testing.T) { sel := Doc().Find(".pvk-content").Slice(0, 2) - AssertLength(t, sel.Nodes, 2) + assertLength(t, sel.Nodes, 2) } func TestSliceOutOfBounds(t *testing.T) { - defer AssertPanic(t) + defer assertPanic(t) Doc().Find(".pvk-content").Slice(2, 12) } func TestNegativeSliceStart(t *testing.T) { sel := Doc().Find(".container-fluid").Slice(-2, 3) - AssertLength(t, sel.Nodes, 1) - AssertSelectionIs(t, sel.Eq(0), "#cf3") + assertLength(t, sel.Nodes, 1) + assertSelectionIs(t, sel.Eq(0), "#cf3") } func TestNegativeSliceEnd(t *testing.T) { sel := Doc().Find(".container-fluid").Slice(1, -1) - AssertLength(t, sel.Nodes, 2) - AssertSelectionIs(t, sel.Eq(0), "#cf2") - AssertSelectionIs(t, sel.Eq(1), "#cf3") + assertLength(t, sel.Nodes, 2) + assertSelectionIs(t, sel.Eq(0), "#cf2") + assertSelectionIs(t, sel.Eq(1), "#cf3") } func TestNegativeSliceBoth(t *testing.T) { sel := Doc().Find(".container-fluid").Slice(-3, -1) - AssertLength(t, sel.Nodes, 2) - AssertSelectionIs(t, sel.Eq(0), "#cf2") - AssertSelectionIs(t, sel.Eq(1), "#cf3") + assertLength(t, sel.Nodes, 2) + assertSelectionIs(t, sel.Eq(0), "#cf2") + assertSelectionIs(t, sel.Eq(1), "#cf3") } func TestNegativeSliceOutOfBounds(t *testing.T) { - defer AssertPanic(t) + defer assertPanic(t) Doc().Find(".container-fluid").Slice(-12, -7) } func TestSliceRollback(t *testing.T) { sel := Doc().Find(".pvk-content") sel2 := sel.Slice(0, 2).End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestGet(t *testing.T) { @@ -138,7 +138,7 @@ func TestGetNegative(t *testing.T) { } func TestGetInvalid(t *testing.T) { - defer AssertPanic(t) + defer assertPanic(t) sel := Doc().Find(".pvk-content") sel.Get(129) } diff --git a/bench_example_test.go b/bench_example_test.go index 3f03ca5..a547431 100644 --- a/bench_example_test.go +++ b/bench_example_test.go @@ -12,7 +12,7 @@ func BenchmarkMetalReviewExample(b *testing.B) { var buf bytes.Buffer b.StopTimer() - doc := LoadDoc("metalreview.html") + doc := loadDoc("metalreview.html") b.StartTimer() for i := 0; i < b.N; i++ { doc.Find(".slider-row:nth-child(1) .slider-item").Each(func(i int, s *Selection) { diff --git a/expand_test.go b/expand_test.go index 89cec8c..cff6996 100644 --- a/expand_test.go +++ b/expand_test.go @@ -6,63 +6,63 @@ import ( func TestAdd(t *testing.T) { sel := Doc().Find("div.row-fluid").Add("a") - AssertLength(t, sel.Nodes, 19) + assertLength(t, sel.Nodes, 19) } func TestAddRollback(t *testing.T) { sel := Doc().Find(".pvk-content") sel2 := sel.Add("a").End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestAddSelection(t *testing.T) { sel := Doc().Find("div.row-fluid") sel2 := Doc().Find("a") sel = sel.AddSelection(sel2) - AssertLength(t, sel.Nodes, 19) + assertLength(t, sel.Nodes, 19) } func TestAddSelectionNil(t *testing.T) { sel := Doc().Find("div.row-fluid") - AssertLength(t, sel.Nodes, 9) + assertLength(t, sel.Nodes, 9) sel = sel.AddSelection(nil) - AssertLength(t, sel.Nodes, 9) + assertLength(t, sel.Nodes, 9) } func TestAddSelectionRollback(t *testing.T) { sel := Doc().Find(".pvk-content") sel2 := sel.Find("a") sel2 = sel.AddSelection(sel2).End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestAddNodes(t *testing.T) { sel := Doc().Find("div.pvk-gutter") sel2 := Doc().Find(".pvk-content") sel = sel.AddNodes(sel2.Nodes...) - AssertLength(t, sel.Nodes, 9) + assertLength(t, sel.Nodes, 9) } func TestAddNodesNone(t *testing.T) { sel := Doc().Find("div.pvk-gutter").AddNodes() - AssertLength(t, sel.Nodes, 6) + assertLength(t, sel.Nodes, 6) } func TestAddNodesRollback(t *testing.T) { sel := Doc().Find(".pvk-content") sel2 := sel.Find("a") sel2 = sel.AddNodes(sel2.Nodes...).End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestAndSelf(t *testing.T) { sel := Doc().Find(".span12").Last().AndSelf() - AssertLength(t, sel.Nodes, 2) + assertLength(t, sel.Nodes, 2) } func TestAndSelfRollback(t *testing.T) { sel := Doc().Find(".pvk-content") sel2 := sel.Find("a").AndSelf().End().End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } diff --git a/filter_test.go b/filter_test.go index ac7f91d..d5978b5 100644 --- a/filter_test.go +++ b/filter_test.go @@ -6,25 +6,25 @@ import ( func TestFilter(t *testing.T) { sel := Doc().Find(".span12").Filter(".alert") - AssertLength(t, sel.Nodes, 1) + assertLength(t, sel.Nodes, 1) } func TestFilterNone(t *testing.T) { sel := Doc().Find(".span12").Filter(".zzalert") - AssertLength(t, sel.Nodes, 0) + assertLength(t, sel.Nodes, 0) } func TestFilterRollback(t *testing.T) { sel := Doc().Find(".pvk-content") sel2 := sel.Filter(".alert").End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestFilterFunction(t *testing.T) { sel := Doc().Find(".pvk-content").FilterFunction(func(i int, s *Selection) bool { return i > 0 }) - AssertLength(t, sel.Nodes, 2) + assertLength(t, sel.Nodes, 2) } func TestFilterFunctionRollback(t *testing.T) { @@ -32,33 +32,33 @@ func TestFilterFunctionRollback(t *testing.T) { sel2 := sel.FilterFunction(func(i int, s *Selection) bool { return i > 0 }).End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestFilterNode(t *testing.T) { sel := Doc().Find(".pvk-content") sel2 := sel.FilterNodes(sel.Nodes[2]) - AssertLength(t, sel2.Nodes, 1) + assertLength(t, sel2.Nodes, 1) } func TestFilterNodeRollback(t *testing.T) { sel := Doc().Find(".pvk-content") sel2 := sel.FilterNodes(sel.Nodes[2]).End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestFilterSelection(t *testing.T) { sel := Doc().Find(".link") sel2 := Doc().Find("a[ng-click]") sel3 := sel.FilterSelection(sel2) - AssertLength(t, sel3.Nodes, 1) + assertLength(t, sel3.Nodes, 1) } func TestFilterSelectionRollback(t *testing.T) { sel := Doc().Find(".link") sel2 := Doc().Find("a[ng-click]") sel2 = sel.FilterSelection(sel2).End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestFilterSelectionNil(t *testing.T) { @@ -66,30 +66,30 @@ func TestFilterSelectionNil(t *testing.T) { sel := Doc().Find(".link") sel3 := sel.FilterSelection(sel2) - AssertLength(t, sel3.Nodes, 0) + assertLength(t, sel3.Nodes, 0) } func TestNot(t *testing.T) { sel := Doc().Find(".span12").Not(".alert") - AssertLength(t, sel.Nodes, 1) + assertLength(t, sel.Nodes, 1) } func TestNotRollback(t *testing.T) { sel := Doc().Find(".span12") sel2 := sel.Not(".alert").End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestNotNone(t *testing.T) { sel := Doc().Find(".span12").Not(".zzalert") - AssertLength(t, sel.Nodes, 2) + assertLength(t, sel.Nodes, 2) } func TestNotFunction(t *testing.T) { sel := Doc().Find(".pvk-content").NotFunction(func(i int, s *Selection) bool { return i > 0 }) - AssertLength(t, sel.Nodes, 1) + assertLength(t, sel.Nodes, 1) } func TestNotFunctionRollback(t *testing.T) { @@ -97,65 +97,65 @@ func TestNotFunctionRollback(t *testing.T) { sel2 := sel.NotFunction(func(i int, s *Selection) bool { return i > 0 }).End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestNotNode(t *testing.T) { sel := Doc().Find(".pvk-content") sel2 := sel.NotNodes(sel.Nodes[2]) - AssertLength(t, sel2.Nodes, 2) + assertLength(t, sel2.Nodes, 2) } func TestNotNodeRollback(t *testing.T) { sel := Doc().Find(".pvk-content") sel2 := sel.NotNodes(sel.Nodes[2]).End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestNotSelection(t *testing.T) { sel := Doc().Find(".link") sel2 := Doc().Find("a[ng-click]") sel3 := sel.NotSelection(sel2) - AssertLength(t, sel3.Nodes, 6) + assertLength(t, sel3.Nodes, 6) } func TestNotSelectionRollback(t *testing.T) { sel := Doc().Find(".link") sel2 := Doc().Find("a[ng-click]") sel2 = sel.NotSelection(sel2).End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestIntersection(t *testing.T) { sel := Doc().Find(".pvk-gutter") sel2 := Doc().Find("div").Intersection(sel) - AssertLength(t, sel2.Nodes, 6) + assertLength(t, sel2.Nodes, 6) } func TestIntersectionRollback(t *testing.T) { sel := Doc().Find(".pvk-gutter") sel2 := Doc().Find("div") sel2 = sel.Intersection(sel2).End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestHas(t *testing.T) { sel := Doc().Find(".container-fluid").Has(".center-content") - AssertLength(t, sel.Nodes, 2) + assertLength(t, sel.Nodes, 2) // Has() returns the high-level .container-fluid div, and the one that is the immediate parent of center-content } func TestHasRollback(t *testing.T) { sel := Doc().Find(".container-fluid") sel2 := sel.Has(".center-content").End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestHasNodes(t *testing.T) { sel := Doc().Find(".container-fluid") sel2 := Doc().Find(".center-content") sel = sel.HasNodes(sel2.Nodes...) - AssertLength(t, sel.Nodes, 2) + assertLength(t, sel.Nodes, 2) // Has() returns the high-level .container-fluid div, and the one that is the immediate parent of center-content } @@ -163,29 +163,29 @@ func TestHasNodesRollback(t *testing.T) { sel := Doc().Find(".container-fluid") sel2 := Doc().Find(".center-content") sel2 = sel.HasNodes(sel2.Nodes...).End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestHasSelection(t *testing.T) { sel := Doc().Find("p") sel2 := Doc().Find("small") sel = sel.HasSelection(sel2) - AssertLength(t, sel.Nodes, 1) + assertLength(t, sel.Nodes, 1) } func TestHasSelectionRollback(t *testing.T) { sel := Doc().Find("p") sel2 := Doc().Find("small") sel2 = sel.HasSelection(sel2).End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestEnd(t *testing.T) { sel := Doc().Find("p").Has("small").End() - AssertLength(t, sel.Nodes, 4) + assertLength(t, sel.Nodes, 4) } func TestEndToTop(t *testing.T) { sel := Doc().Find("p").Has("small").End().End().End() - AssertLength(t, sel.Nodes, 0) + assertLength(t, sel.Nodes, 0) } diff --git a/iteration_test.go b/iteration_test.go index b084fe8..9b6aafb 100644 --- a/iteration_test.go +++ b/iteration_test.go @@ -17,7 +17,7 @@ func TestEach(t *testing.T) { if cnt != 4 { t.Errorf("Expected Each() to call function 4 times, got %v times.", cnt) } - AssertLength(t, sel.Nodes, 6) + assertLength(t, sel.Nodes, 6) } func TestEachWithBreak(t *testing.T) { @@ -32,7 +32,7 @@ func TestEachWithBreak(t *testing.T) { if cnt != 1 { t.Errorf("Expected Each() to call function 1 time, got %v times.", cnt) } - AssertLength(t, sel.Nodes, 6) + assertLength(t, sel.Nodes, 6) } func TestEachEmptySelection(t *testing.T) { @@ -46,7 +46,7 @@ func TestEachEmptySelection(t *testing.T) { t.Error("Expected Each() to not be called on empty Selection.") } sel2 := sel.Find("div") - AssertLength(t, sel2.Nodes, 0) + assertLength(t, sel2.Nodes, 0) } func TestMap(t *testing.T) { diff --git a/manipulation.go b/manipulation.go index 3ee0fec..a6fa258 100644 --- a/manipulation.go +++ b/manipulation.go @@ -175,7 +175,7 @@ func (s *Selection) Before(selector string) *Selection { return s.BeforeMatcher(cascadia.MustCompile(selector)) } -// BeforeSelector applies the matcher from the root document, and inserts the matched +// BeforeMatcher applies the matcher from the root document, and inserts the matched // elements before each element in the set of matched elements. // This follows the same rules as Selection.After. func (s *Selection) BeforeMatcher(m Matcher) *Selection { @@ -214,7 +214,7 @@ func (s *Selection) Clone() *Selection { } // Empty removes all children nodes from the set of matched elements. -// Returns the children nodes in a new Selection on the current Selection stack. +// Returns the children nodes in a new Selection. func (s *Selection) Empty() *Selection { nodes := make([]*html.Node, 0) @@ -240,9 +240,9 @@ func (s *Selection) Remove() *Selection { return s } -// RemoveFilter removes the set of matched elements by selector. +// RemoveFiltered removes the set of matched elements by selector. // Returns the Selection of removed nodes. -func (s *Selection) RemoveFilter(selector string) *Selection { +func (s *Selection) RemoveFiltered(selector string) *Selection { return s.RemoveMatcher(cascadia.MustCompile(selector)) } diff --git a/manipulation_test.go b/manipulation_test.go index 61caa6b..90a623e 100644 --- a/manipulation_test.go +++ b/manipulation_test.go @@ -8,9 +8,20 @@ func TestAfter(t *testing.T) { doc := Doc2Clone() doc.Find("#main").After("#nf6") - AssertLength(t, doc.Find("#main #nf6").Nodes, 0) - AssertLength(t, doc.Find("#foot #nf6").Nodes, 0) - AssertLength(t, doc.Find("#main + #nf6").Nodes, 1) + assertLength(t, doc.Find("#main #nf6").Nodes, 0) + assertLength(t, doc.Find("#foot #nf6").Nodes, 0) + assertLength(t, doc.Find("#main + #nf6").Nodes, 1) + printSel(t, doc.Selection) +} + +func TestAfterMany(t *testing.T) { + doc := Doc2Clone() + doc.Find(".one").After("#nf6") + + assertLength(t, doc.Find("#foot #nf6").Nodes, 1) + assertLength(t, doc.Find("#main #nf6").Nodes, 1) + assertLength(t, doc.Find(".one + #nf6").Nodes, 2) + printSel(t, doc.Selection) } func TestAfterWithRemoved(t *testing.T) { @@ -18,75 +29,94 @@ func TestAfterWithRemoved(t *testing.T) { s := doc.Find("#main").Remove() s.After("#nf6") - AssertLength(t, s.Find("#nf6").Nodes, 0) - AssertLength(t, doc.Find("#nf6").Nodes, 0) + assertLength(t, s.Find("#nf6").Nodes, 0) + assertLength(t, doc.Find("#nf6").Nodes, 0) + printSel(t, doc.Selection) } func TestAfterSelection(t *testing.T) { doc := Doc2Clone() doc.Find("#main").AfterSelection(doc.Find("#nf1, #nf2")) - AssertLength(t, doc.Find("#main #nf1, #main #nf2").Nodes, 0) - AssertLength(t, doc.Find("#foot #nf1, #foot #nf2").Nodes, 0) - AssertLength(t, doc.Find("#main + #nf1, #nf1 + #nf2").Nodes, 2) + assertLength(t, doc.Find("#main #nf1, #main #nf2").Nodes, 0) + assertLength(t, doc.Find("#foot #nf1, #foot #nf2").Nodes, 0) + assertLength(t, doc.Find("#main + #nf1, #nf1 + #nf2").Nodes, 2) + printSel(t, doc.Selection) } func TestAfterHtml(t *testing.T) { doc := Doc2Clone() doc.Find("#main").AfterHtml("new node") - AssertLength(t, doc.Find("#main + strong").Nodes, 1) + assertLength(t, doc.Find("#main + strong").Nodes, 1) + printSel(t, doc.Selection) } func TestAppend(t *testing.T) { doc := Doc2Clone() doc.Find("#main").Append("#nf6") - AssertLength(t, doc.Find("#foot #nf6").Nodes, 0) - AssertLength(t, doc.Find("#main #nf6").Nodes, 1) + assertLength(t, doc.Find("#foot #nf6").Nodes, 0) + assertLength(t, doc.Find("#main #nf6").Nodes, 1) + printSel(t, doc.Selection) } func TestAppendBody(t *testing.T) { doc := Doc2Clone() doc.Find("body").Append("#nf6") - AssertLength(t, doc.Find("#foot #nf6").Nodes, 0) - AssertLength(t, doc.Find("#main #nf6").Nodes, 0) - AssertLength(t, doc.Find("body > #nf6").Nodes, 1) + assertLength(t, doc.Find("#foot #nf6").Nodes, 0) + assertLength(t, doc.Find("#main #nf6").Nodes, 0) + assertLength(t, doc.Find("body > #nf6").Nodes, 1) + printSel(t, doc.Selection) } func TestAppendSelection(t *testing.T) { doc := Doc2Clone() doc.Find("#main").AppendSelection(doc.Find("#nf1, #nf2")) - AssertLength(t, doc.Find("#foot #nf1").Nodes, 0) - AssertLength(t, doc.Find("#foot #nf2").Nodes, 0) - AssertLength(t, doc.Find("#main #nf1").Nodes, 1) - AssertLength(t, doc.Find("#main #nf2").Nodes, 1) + assertLength(t, doc.Find("#foot #nf1").Nodes, 0) + assertLength(t, doc.Find("#foot #nf2").Nodes, 0) + assertLength(t, doc.Find("#main #nf1").Nodes, 1) + assertLength(t, doc.Find("#main #nf2").Nodes, 1) + printSel(t, doc.Selection) +} + +func TestAppendSelectionExisting(t *testing.T) { + doc := Doc2Clone() + doc.Find("#main").AppendSelection(doc.Find("#n1, #n2")) + + assertClass(t, doc.Find("#main :nth-child(1)"), "three") + assertClass(t, doc.Find("#main :nth-child(5)"), "one") + assertClass(t, doc.Find("#main :nth-child(6)"), "two") + printSel(t, doc.Selection) } func TestAppendClone(t *testing.T) { doc := Doc2Clone() doc.Find("#n1").AppendSelection(doc.Find("#nf1").Clone()) - AssertLength(t, doc.Find("#foot #nf1").Nodes, 1) - AssertLength(t, doc.Find("#main #nf1").Nodes, 1) + assertLength(t, doc.Find("#foot #nf1").Nodes, 1) + assertLength(t, doc.Find("#main #nf1").Nodes, 1) + printSel(t, doc.Selection) } func TestAppendHtml(t *testing.T) { doc := Doc2Clone() doc.Find("div").AppendHtml("new node") - AssertLength(t, doc.Find("strong").Nodes, 14) + assertLength(t, doc.Find("strong").Nodes, 14) + printSel(t, doc.Selection) } func TestBefore(t *testing.T) { doc := Doc2Clone() doc.Find("#main").Before("#nf6") - AssertLength(t, doc.Find("#main #nf6").Nodes, 0) - AssertLength(t, doc.Find("#foot #nf6").Nodes, 0) - AssertLength(t, doc.Find("body > #nf6:first-child").Nodes, 1) + assertLength(t, doc.Find("#main #nf6").Nodes, 0) + assertLength(t, doc.Find("#foot #nf6").Nodes, 0) + assertLength(t, doc.Find("body > #nf6:first-child").Nodes, 1) + printSel(t, doc.Selection) } func TestBeforeWithRemoved(t *testing.T) { @@ -94,63 +124,71 @@ func TestBeforeWithRemoved(t *testing.T) { s := doc.Find("#main").Remove() s.Before("#nf6") - AssertLength(t, s.Find("#nf6").Nodes, 0) - AssertLength(t, doc.Find("#nf6").Nodes, 0) + assertLength(t, s.Find("#nf6").Nodes, 0) + assertLength(t, doc.Find("#nf6").Nodes, 0) + printSel(t, doc.Selection) } func TestBeforeSelection(t *testing.T) { doc := Doc2Clone() doc.Find("#main").BeforeSelection(doc.Find("#nf1, #nf2")) - AssertLength(t, doc.Find("#main #nf1, #main #nf2").Nodes, 0) - AssertLength(t, doc.Find("#foot #nf1, #foot #nf2").Nodes, 0) - AssertLength(t, doc.Find("body > #nf1:first-child, #nf1 + #nf2").Nodes, 2) + assertLength(t, doc.Find("#main #nf1, #main #nf2").Nodes, 0) + assertLength(t, doc.Find("#foot #nf1, #foot #nf2").Nodes, 0) + assertLength(t, doc.Find("body > #nf1:first-child, #nf1 + #nf2").Nodes, 2) + printSel(t, doc.Selection) } func TestBeforeHtml(t *testing.T) { doc := Doc2Clone() doc.Find("#main").BeforeHtml("new node") - AssertLength(t, doc.Find("body > strong:first-child").Nodes, 1) + assertLength(t, doc.Find("body > strong:first-child").Nodes, 1) + printSel(t, doc.Selection) } func TestEmpty(t *testing.T) { doc := Doc2Clone() s := doc.Find("#main").Empty() - AssertLength(t, doc.Find("#main").Children().Nodes, 0) - AssertLength(t, s.Filter("div").Nodes, 6) + assertLength(t, doc.Find("#main").Children().Nodes, 0) + assertLength(t, s.Filter("div").Nodes, 6) + printSel(t, doc.Selection) } func TestRemove(t *testing.T) { doc := Doc2Clone() doc.Find("#nf1").Remove() - AssertLength(t, doc.Find("#foot #nf1").Nodes, 0) + assertLength(t, doc.Find("#foot #nf1").Nodes, 0) + printSel(t, doc.Selection) } func TestRemoveAll(t *testing.T) { doc := Doc2Clone() doc.Find("*").Remove() - AssertLength(t, doc.Find("*").Nodes, 0) + assertLength(t, doc.Find("*").Nodes, 0) + printSel(t, doc.Selection) } func TestRemoveRoot(t *testing.T) { doc := Doc2Clone() doc.Find("html").Remove() - AssertLength(t, doc.Find("html").Nodes, 0) + assertLength(t, doc.Find("html").Nodes, 0) + printSel(t, doc.Selection) } -func TestRemoveFilter(t *testing.T) { +func TestRemoveFiltered(t *testing.T) { doc := Doc2Clone() nf6 := doc.Find("#nf6") - s := doc.Find("div").RemoveFilter("#nf6") + s := doc.Find("div").RemoveFiltered("#nf6") - AssertLength(t, doc.Find("#nf6").Nodes, 0) - AssertLength(t, s.Nodes, 1) + assertLength(t, doc.Find("#nf6").Nodes, 0) + assertLength(t, s.Nodes, 1) if nf6.Nodes[0] != s.Nodes[0] { t.Error("Removed node does not match original") } + printSel(t, doc.Selection) } diff --git a/traversal_test.go b/traversal_test.go index d881cd8..00fb5cd 100644 --- a/traversal_test.go +++ b/traversal_test.go @@ -7,672 +7,672 @@ import ( func TestFind(t *testing.T) { sel := Doc().Find("div.row-fluid") - AssertLength(t, sel.Nodes, 9) + assertLength(t, sel.Nodes, 9) } func TestFindRollback(t *testing.T) { sel := Doc().Find("div.row-fluid") sel2 := sel.Find("a").End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestFindNotSelf(t *testing.T) { sel := Doc().Find("h1").Find("h1") - AssertLength(t, sel.Nodes, 0) + assertLength(t, sel.Nodes, 0) } func TestFindInvalidSelector(t *testing.T) { - defer AssertPanic(t) + defer assertPanic(t) Doc().Find(":+ ^") } func TestChainedFind(t *testing.T) { sel := Doc().Find("div.hero-unit").Find(".row-fluid") - AssertLength(t, sel.Nodes, 4) + assertLength(t, sel.Nodes, 4) } func TestChildren(t *testing.T) { sel := Doc().Find(".pvk-content").Children() - AssertLength(t, sel.Nodes, 5) + assertLength(t, sel.Nodes, 5) } func TestChildrenRollback(t *testing.T) { sel := Doc().Find(".pvk-content") sel2 := sel.Children().End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestContents(t *testing.T) { sel := Doc().Find(".pvk-content").Contents() - AssertLength(t, sel.Nodes, 13) + assertLength(t, sel.Nodes, 13) } func TestContentsRollback(t *testing.T) { sel := Doc().Find(".pvk-content") sel2 := sel.Contents().End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestChildrenFiltered(t *testing.T) { sel := Doc().Find(".pvk-content").ChildrenFiltered(".hero-unit") - AssertLength(t, sel.Nodes, 1) + assertLength(t, sel.Nodes, 1) } func TestChildrenFilteredRollback(t *testing.T) { sel := Doc().Find(".pvk-content") sel2 := sel.ChildrenFiltered(".hero-unit").End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestContentsFiltered(t *testing.T) { sel := Doc().Find(".pvk-content").ContentsFiltered(".hero-unit") - AssertLength(t, sel.Nodes, 1) + assertLength(t, sel.Nodes, 1) } func TestContentsFilteredRollback(t *testing.T) { sel := Doc().Find(".pvk-content") sel2 := sel.ContentsFiltered(".hero-unit").End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestChildrenFilteredNone(t *testing.T) { sel := Doc().Find(".pvk-content").ChildrenFiltered("a.btn") - AssertLength(t, sel.Nodes, 0) + assertLength(t, sel.Nodes, 0) } func TestParent(t *testing.T) { sel := Doc().Find(".container-fluid").Parent() - AssertLength(t, sel.Nodes, 3) + assertLength(t, sel.Nodes, 3) } func TestParentRollback(t *testing.T) { sel := Doc().Find(".container-fluid") sel2 := sel.Parent().End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestParentBody(t *testing.T) { sel := Doc().Find("body").Parent() - AssertLength(t, sel.Nodes, 1) + assertLength(t, sel.Nodes, 1) } func TestParentFiltered(t *testing.T) { sel := Doc().Find(".container-fluid").ParentFiltered(".hero-unit") - AssertLength(t, sel.Nodes, 1) - AssertClass(t, sel, "hero-unit") + assertLength(t, sel.Nodes, 1) + assertClass(t, sel, "hero-unit") } func TestParentFilteredRollback(t *testing.T) { sel := Doc().Find(".container-fluid") sel2 := sel.ParentFiltered(".hero-unit").End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestParents(t *testing.T) { sel := Doc().Find(".container-fluid").Parents() - AssertLength(t, sel.Nodes, 8) + assertLength(t, sel.Nodes, 8) } func TestParentsOrder(t *testing.T) { sel := Doc().Find("#cf2").Parents() - AssertLength(t, sel.Nodes, 6) - AssertSelectionIs(t, sel, ".hero-unit", ".pvk-content", "div.row-fluid", "#cf1", "body", "html") + assertLength(t, sel.Nodes, 6) + assertSelectionIs(t, sel, ".hero-unit", ".pvk-content", "div.row-fluid", "#cf1", "body", "html") } func TestParentsRollback(t *testing.T) { sel := Doc().Find(".container-fluid") sel2 := sel.Parents().End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestParentsFiltered(t *testing.T) { sel := Doc().Find(".container-fluid").ParentsFiltered("body") - AssertLength(t, sel.Nodes, 1) + assertLength(t, sel.Nodes, 1) } func TestParentsFilteredRollback(t *testing.T) { sel := Doc().Find(".container-fluid") sel2 := sel.ParentsFiltered("body").End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestParentsUntil(t *testing.T) { sel := Doc().Find(".container-fluid").ParentsUntil("body") - AssertLength(t, sel.Nodes, 6) + assertLength(t, sel.Nodes, 6) } func TestParentsUntilRollback(t *testing.T) { sel := Doc().Find(".container-fluid") sel2 := sel.ParentsUntil("body").End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestParentsUntilSelection(t *testing.T) { sel := Doc().Find(".container-fluid") sel2 := Doc().Find(".pvk-content") sel = sel.ParentsUntilSelection(sel2) - AssertLength(t, sel.Nodes, 3) + assertLength(t, sel.Nodes, 3) } func TestParentsUntilSelectionRollback(t *testing.T) { sel := Doc().Find(".container-fluid") sel2 := Doc().Find(".pvk-content") sel2 = sel.ParentsUntilSelection(sel2).End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestParentsUntilNodes(t *testing.T) { sel := Doc().Find(".container-fluid") sel2 := Doc().Find(".pvk-content, .hero-unit") sel = sel.ParentsUntilNodes(sel2.Nodes...) - AssertLength(t, sel.Nodes, 2) + assertLength(t, sel.Nodes, 2) } func TestParentsUntilNodesRollback(t *testing.T) { sel := Doc().Find(".container-fluid") sel2 := Doc().Find(".pvk-content, .hero-unit") sel2 = sel.ParentsUntilNodes(sel2.Nodes...).End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestParentsFilteredUntil(t *testing.T) { sel := Doc().Find(".container-fluid").ParentsFilteredUntil(".pvk-content", "body") - AssertLength(t, sel.Nodes, 2) + assertLength(t, sel.Nodes, 2) } func TestParentsFilteredUntilRollback(t *testing.T) { sel := Doc().Find(".container-fluid") sel2 := sel.ParentsFilteredUntil(".pvk-content", "body").End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestParentsFilteredUntilSelection(t *testing.T) { sel := Doc().Find(".container-fluid") sel2 := Doc().Find(".row-fluid") sel = sel.ParentsFilteredUntilSelection("div", sel2) - AssertLength(t, sel.Nodes, 3) + assertLength(t, sel.Nodes, 3) } func TestParentsFilteredUntilSelectionRollback(t *testing.T) { sel := Doc().Find(".container-fluid") sel2 := Doc().Find(".row-fluid") sel2 = sel.ParentsFilteredUntilSelection("div", sel2).End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestParentsFilteredUntilNodes(t *testing.T) { sel := Doc().Find(".container-fluid") sel2 := Doc().Find(".row-fluid") sel = sel.ParentsFilteredUntilNodes("body", sel2.Nodes...) - AssertLength(t, sel.Nodes, 1) + assertLength(t, sel.Nodes, 1) } func TestParentsFilteredUntilNodesRollback(t *testing.T) { sel := Doc().Find(".container-fluid") sel2 := Doc().Find(".row-fluid") sel2 = sel.ParentsFilteredUntilNodes("body", sel2.Nodes...).End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestSiblings(t *testing.T) { sel := Doc().Find("h1").Siblings() - AssertLength(t, sel.Nodes, 1) + assertLength(t, sel.Nodes, 1) } func TestSiblingsRollback(t *testing.T) { sel := Doc().Find("h1") sel2 := sel.Siblings().End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestSiblings2(t *testing.T) { sel := Doc().Find(".pvk-gutter").Siblings() - AssertLength(t, sel.Nodes, 9) + assertLength(t, sel.Nodes, 9) } func TestSiblings3(t *testing.T) { sel := Doc().Find("body>.container-fluid").Siblings() - AssertLength(t, sel.Nodes, 0) + assertLength(t, sel.Nodes, 0) } func TestSiblingsFiltered(t *testing.T) { sel := Doc().Find(".pvk-gutter").SiblingsFiltered(".pvk-content") - AssertLength(t, sel.Nodes, 3) + assertLength(t, sel.Nodes, 3) } func TestSiblingsFilteredRollback(t *testing.T) { sel := Doc().Find(".pvk-gutter") sel2 := sel.SiblingsFiltered(".pvk-content").End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestNext(t *testing.T) { sel := Doc().Find("h1").Next() - AssertLength(t, sel.Nodes, 1) + assertLength(t, sel.Nodes, 1) } func TestNextRollback(t *testing.T) { sel := Doc().Find("h1") sel2 := sel.Next().End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestNext2(t *testing.T) { sel := Doc().Find(".close").Next() - AssertLength(t, sel.Nodes, 1) + assertLength(t, sel.Nodes, 1) } func TestNextNone(t *testing.T) { sel := Doc().Find("small").Next() - AssertLength(t, sel.Nodes, 0) + assertLength(t, sel.Nodes, 0) } func TestNextFiltered(t *testing.T) { sel := Doc().Find(".container-fluid").NextFiltered("div") - AssertLength(t, sel.Nodes, 2) + assertLength(t, sel.Nodes, 2) } func TestNextFilteredRollback(t *testing.T) { sel := Doc().Find(".container-fluid") sel2 := sel.NextFiltered("div").End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestNextFiltered2(t *testing.T) { sel := Doc().Find(".container-fluid").NextFiltered("[ng-view]") - AssertLength(t, sel.Nodes, 1) + assertLength(t, sel.Nodes, 1) } func TestPrev(t *testing.T) { sel := Doc().Find(".red").Prev() - AssertLength(t, sel.Nodes, 1) - AssertClass(t, sel, "green") + assertLength(t, sel.Nodes, 1) + assertClass(t, sel, "green") } func TestPrevRollback(t *testing.T) { sel := Doc().Find(".red") sel2 := sel.Prev().End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestPrev2(t *testing.T) { sel := Doc().Find(".row-fluid").Prev() - AssertLength(t, sel.Nodes, 5) + assertLength(t, sel.Nodes, 5) } func TestPrevNone(t *testing.T) { sel := Doc().Find("h2").Prev() - AssertLength(t, sel.Nodes, 0) + assertLength(t, sel.Nodes, 0) } func TestPrevFiltered(t *testing.T) { sel := Doc().Find(".row-fluid").PrevFiltered(".row-fluid") - AssertLength(t, sel.Nodes, 5) + assertLength(t, sel.Nodes, 5) } func TestPrevFilteredRollback(t *testing.T) { sel := Doc().Find(".row-fluid") sel2 := sel.PrevFiltered(".row-fluid").End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestNextAll(t *testing.T) { sel := Doc().Find("#cf2 div:nth-child(1)").NextAll() - AssertLength(t, sel.Nodes, 3) + assertLength(t, sel.Nodes, 3) } func TestNextAllRollback(t *testing.T) { sel := Doc().Find("#cf2 div:nth-child(1)") sel2 := sel.NextAll().End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestNextAll2(t *testing.T) { sel := Doc().Find("div[ng-cloak]").NextAll() - AssertLength(t, sel.Nodes, 1) + assertLength(t, sel.Nodes, 1) } func TestNextAllNone(t *testing.T) { sel := Doc().Find(".footer").NextAll() - AssertLength(t, sel.Nodes, 0) + assertLength(t, sel.Nodes, 0) } func TestNextAllFiltered(t *testing.T) { sel := Doc().Find("#cf2 .row-fluid").NextAllFiltered("[ng-cloak]") - AssertLength(t, sel.Nodes, 2) + assertLength(t, sel.Nodes, 2) } func TestNextAllFilteredRollback(t *testing.T) { sel := Doc().Find("#cf2 .row-fluid") sel2 := sel.NextAllFiltered("[ng-cloak]").End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestNextAllFiltered2(t *testing.T) { sel := Doc().Find(".close").NextAllFiltered("h4") - AssertLength(t, sel.Nodes, 1) + assertLength(t, sel.Nodes, 1) } func TestPrevAll(t *testing.T) { sel := Doc().Find("[ng-view]").PrevAll() - AssertLength(t, sel.Nodes, 2) + assertLength(t, sel.Nodes, 2) } func TestPrevAllOrder(t *testing.T) { sel := Doc().Find("[ng-view]").PrevAll() - AssertLength(t, sel.Nodes, 2) - AssertSelectionIs(t, sel, "#cf4", "#cf3") + assertLength(t, sel.Nodes, 2) + assertSelectionIs(t, sel, "#cf4", "#cf3") } func TestPrevAllRollback(t *testing.T) { sel := Doc().Find("[ng-view]") sel2 := sel.PrevAll().End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestPrevAll2(t *testing.T) { sel := Doc().Find(".pvk-gutter").PrevAll() - AssertLength(t, sel.Nodes, 6) + assertLength(t, sel.Nodes, 6) } func TestPrevAllFiltered(t *testing.T) { sel := Doc().Find(".pvk-gutter").PrevAllFiltered(".pvk-content") - AssertLength(t, sel.Nodes, 3) + assertLength(t, sel.Nodes, 3) } func TestPrevAllFilteredRollback(t *testing.T) { sel := Doc().Find(".pvk-gutter") sel2 := sel.PrevAllFiltered(".pvk-content").End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestNextUntil(t *testing.T) { sel := Doc().Find(".alert a").NextUntil("p") - AssertLength(t, sel.Nodes, 1) - AssertSelectionIs(t, sel, "h4") + assertLength(t, sel.Nodes, 1) + assertSelectionIs(t, sel, "h4") } func TestNextUntil2(t *testing.T) { sel := Doc().Find("#cf2-1").NextUntil("[ng-cloak]") - AssertLength(t, sel.Nodes, 1) - AssertSelectionIs(t, sel, "#cf2-2") + assertLength(t, sel.Nodes, 1) + assertSelectionIs(t, sel, "#cf2-2") } func TestNextUntilOrder(t *testing.T) { sel := Doc().Find("#cf2-1").NextUntil("#cf2-4") - AssertLength(t, sel.Nodes, 2) - AssertSelectionIs(t, sel, "#cf2-2", "#cf2-3") + assertLength(t, sel.Nodes, 2) + assertSelectionIs(t, sel, "#cf2-2", "#cf2-3") } func TestNextUntilRollback(t *testing.T) { sel := Doc().Find("#cf2-1") sel2 := sel.PrevUntil("#cf2-4").End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestNextUntilSelection(t *testing.T) { sel := Doc2().Find("#n2") sel2 := Doc2().Find("#n4") sel2 = sel.NextUntilSelection(sel2) - AssertLength(t, sel2.Nodes, 1) - AssertSelectionIs(t, sel2, "#n3") + assertLength(t, sel2.Nodes, 1) + assertSelectionIs(t, sel2, "#n3") } func TestNextUntilSelectionRollback(t *testing.T) { sel := Doc2().Find("#n2") sel2 := Doc2().Find("#n4") sel2 = sel.NextUntilSelection(sel2).End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestNextUntilNodes(t *testing.T) { sel := Doc2().Find("#n2") sel2 := Doc2().Find("#n5") sel2 = sel.NextUntilNodes(sel2.Nodes...) - AssertLength(t, sel2.Nodes, 2) - AssertSelectionIs(t, sel2, "#n3", "#n4") + assertLength(t, sel2.Nodes, 2) + assertSelectionIs(t, sel2, "#n3", "#n4") } func TestNextUntilNodesRollback(t *testing.T) { sel := Doc2().Find("#n2") sel2 := Doc2().Find("#n5") sel2 = sel.NextUntilNodes(sel2.Nodes...).End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestPrevUntil(t *testing.T) { sel := Doc().Find(".alert p").PrevUntil("a") - AssertLength(t, sel.Nodes, 1) - AssertSelectionIs(t, sel, "h4") + assertLength(t, sel.Nodes, 1) + assertSelectionIs(t, sel, "h4") } func TestPrevUntil2(t *testing.T) { sel := Doc().Find("[ng-cloak]").PrevUntil(":not([ng-cloak])") - AssertLength(t, sel.Nodes, 1) - AssertSelectionIs(t, sel, "[ng-cloak]") + assertLength(t, sel.Nodes, 1) + assertSelectionIs(t, sel, "[ng-cloak]") } func TestPrevUntilOrder(t *testing.T) { sel := Doc().Find("#cf2-4").PrevUntil("#cf2-1") - AssertLength(t, sel.Nodes, 2) - AssertSelectionIs(t, sel, "#cf2-3", "#cf2-2") + assertLength(t, sel.Nodes, 2) + assertSelectionIs(t, sel, "#cf2-3", "#cf2-2") } func TestPrevUntilRollback(t *testing.T) { sel := Doc().Find("#cf2-4") sel2 := sel.PrevUntil("#cf2-1").End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestPrevUntilSelection(t *testing.T) { sel := Doc2().Find("#n4") sel2 := Doc2().Find("#n2") sel2 = sel.PrevUntilSelection(sel2) - AssertLength(t, sel2.Nodes, 1) - AssertSelectionIs(t, sel2, "#n3") + assertLength(t, sel2.Nodes, 1) + assertSelectionIs(t, sel2, "#n3") } func TestPrevUntilSelectionRollback(t *testing.T) { sel := Doc2().Find("#n4") sel2 := Doc2().Find("#n2") sel2 = sel.PrevUntilSelection(sel2).End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestPrevUntilNodes(t *testing.T) { sel := Doc2().Find("#n5") sel2 := Doc2().Find("#n2") sel2 = sel.PrevUntilNodes(sel2.Nodes...) - AssertLength(t, sel2.Nodes, 2) - AssertSelectionIs(t, sel2, "#n4", "#n3") + assertLength(t, sel2.Nodes, 2) + assertSelectionIs(t, sel2, "#n4", "#n3") } func TestPrevUntilNodesRollback(t *testing.T) { sel := Doc2().Find("#n5") sel2 := Doc2().Find("#n2") sel2 = sel.PrevUntilNodes(sel2.Nodes...).End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestNextFilteredUntil(t *testing.T) { sel := Doc2().Find(".two").NextFilteredUntil(".even", ".six") - AssertLength(t, sel.Nodes, 4) - AssertSelectionIs(t, sel, "#n3", "#n5", "#nf3", "#nf5") + assertLength(t, sel.Nodes, 4) + assertSelectionIs(t, sel, "#n3", "#n5", "#nf3", "#nf5") } func TestNextFilteredUntilRollback(t *testing.T) { sel := Doc2().Find(".two") sel2 := sel.NextFilteredUntil(".even", ".six").End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestNextFilteredUntilSelection(t *testing.T) { sel := Doc2().Find(".even") sel2 := Doc2().Find(".five") sel = sel.NextFilteredUntilSelection(".even", sel2) - AssertLength(t, sel.Nodes, 2) - AssertSelectionIs(t, sel, "#n3", "#nf3") + assertLength(t, sel.Nodes, 2) + assertSelectionIs(t, sel, "#n3", "#nf3") } func TestNextFilteredUntilSelectionRollback(t *testing.T) { sel := Doc2().Find(".even") sel2 := Doc2().Find(".five") sel3 := sel.NextFilteredUntilSelection(".even", sel2).End() - AssertEqual(t, sel, sel3) + assertEqual(t, sel, sel3) } func TestNextFilteredUntilNodes(t *testing.T) { sel := Doc2().Find(".even") sel2 := Doc2().Find(".four") sel = sel.NextFilteredUntilNodes(".odd", sel2.Nodes...) - AssertLength(t, sel.Nodes, 4) - AssertSelectionIs(t, sel, "#n2", "#n6", "#nf2", "#nf6") + assertLength(t, sel.Nodes, 4) + assertSelectionIs(t, sel, "#n2", "#n6", "#nf2", "#nf6") } func TestNextFilteredUntilNodesRollback(t *testing.T) { sel := Doc2().Find(".even") sel2 := Doc2().Find(".four") sel3 := sel.NextFilteredUntilNodes(".odd", sel2.Nodes...).End() - AssertEqual(t, sel, sel3) + assertEqual(t, sel, sel3) } func TestPrevFilteredUntil(t *testing.T) { sel := Doc2().Find(".five").PrevFilteredUntil(".odd", ".one") - AssertLength(t, sel.Nodes, 4) - AssertSelectionIs(t, sel, "#n4", "#n2", "#nf4", "#nf2") + assertLength(t, sel.Nodes, 4) + assertSelectionIs(t, sel, "#n4", "#n2", "#nf4", "#nf2") } func TestPrevFilteredUntilRollback(t *testing.T) { sel := Doc2().Find(".four") sel2 := sel.PrevFilteredUntil(".odd", ".one").End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestPrevFilteredUntilSelection(t *testing.T) { sel := Doc2().Find(".odd") sel2 := Doc2().Find(".two") sel = sel.PrevFilteredUntilSelection(".odd", sel2) - AssertLength(t, sel.Nodes, 2) - AssertSelectionIs(t, sel, "#n4", "#nf4") + assertLength(t, sel.Nodes, 2) + assertSelectionIs(t, sel, "#n4", "#nf4") } func TestPrevFilteredUntilSelectionRollback(t *testing.T) { sel := Doc2().Find(".even") sel2 := Doc2().Find(".five") sel3 := sel.PrevFilteredUntilSelection(".even", sel2).End() - AssertEqual(t, sel, sel3) + assertEqual(t, sel, sel3) } func TestPrevFilteredUntilNodes(t *testing.T) { sel := Doc2().Find(".even") sel2 := Doc2().Find(".four") sel = sel.PrevFilteredUntilNodes(".odd", sel2.Nodes...) - AssertLength(t, sel.Nodes, 2) - AssertSelectionIs(t, sel, "#n2", "#nf2") + assertLength(t, sel.Nodes, 2) + assertSelectionIs(t, sel, "#n2", "#nf2") } func TestPrevFilteredUntilNodesRollback(t *testing.T) { sel := Doc2().Find(".even") sel2 := Doc2().Find(".four") sel3 := sel.PrevFilteredUntilNodes(".odd", sel2.Nodes...).End() - AssertEqual(t, sel, sel3) + assertEqual(t, sel, sel3) } func TestClosestItself(t *testing.T) { sel := Doc2().Find(".three") sel2 := sel.Closest(".row") - AssertLength(t, sel2.Nodes, sel.Length()) - AssertSelectionIs(t, sel2, "#n3", "#nf3") + assertLength(t, sel2.Nodes, sel.Length()) + assertSelectionIs(t, sel2, "#n3", "#nf3") } func TestClosestNoDupes(t *testing.T) { sel := Doc().Find(".span12") sel2 := sel.Closest(".pvk-content") - AssertLength(t, sel2.Nodes, 1) - AssertClass(t, sel2, "pvk-content") + assertLength(t, sel2.Nodes, 1) + assertClass(t, sel2, "pvk-content") } func TestClosestNone(t *testing.T) { sel := Doc().Find("h4") sel2 := sel.Closest("a") - AssertLength(t, sel2.Nodes, 0) + assertLength(t, sel2.Nodes, 0) } func TestClosestMany(t *testing.T) { sel := Doc().Find(".container-fluid") sel2 := sel.Closest(".pvk-content") - AssertLength(t, sel2.Nodes, 2) - AssertSelectionIs(t, sel2, "#pc1", "#pc2") + assertLength(t, sel2.Nodes, 2) + assertSelectionIs(t, sel2, "#pc1", "#pc2") } func TestClosestRollback(t *testing.T) { sel := Doc().Find(".container-fluid") sel2 := sel.Closest(".pvk-content").End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestClosestSelectionItself(t *testing.T) { sel := Doc2().Find(".three") sel2 := sel.ClosestSelection(Doc2().Find(".row")) - AssertLength(t, sel2.Nodes, sel.Length()) + assertLength(t, sel2.Nodes, sel.Length()) } func TestClosestSelectionNoDupes(t *testing.T) { sel := Doc().Find(".span12") sel2 := sel.ClosestSelection(Doc().Find(".pvk-content")) - AssertLength(t, sel2.Nodes, 1) - AssertClass(t, sel2, "pvk-content") + assertLength(t, sel2.Nodes, 1) + assertClass(t, sel2, "pvk-content") } func TestClosestSelectionNone(t *testing.T) { sel := Doc().Find("h4") sel2 := sel.ClosestSelection(Doc().Find("a")) - AssertLength(t, sel2.Nodes, 0) + assertLength(t, sel2.Nodes, 0) } func TestClosestSelectionMany(t *testing.T) { sel := Doc().Find(".container-fluid") sel2 := sel.ClosestSelection(Doc().Find(".pvk-content")) - AssertLength(t, sel2.Nodes, 2) - AssertSelectionIs(t, sel2, "#pc1", "#pc2") + assertLength(t, sel2.Nodes, 2) + assertSelectionIs(t, sel2, "#pc1", "#pc2") } func TestClosestSelectionRollback(t *testing.T) { sel := Doc().Find(".container-fluid") sel2 := sel.ClosestSelection(Doc().Find(".pvk-content")).End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestClosestNodesItself(t *testing.T) { sel := Doc2().Find(".three") sel2 := sel.ClosestNodes(Doc2().Find(".row").Nodes...) - AssertLength(t, sel2.Nodes, sel.Length()) + assertLength(t, sel2.Nodes, sel.Length()) } func TestClosestNodesNoDupes(t *testing.T) { sel := Doc().Find(".span12") sel2 := sel.ClosestNodes(Doc().Find(".pvk-content").Nodes...) - AssertLength(t, sel2.Nodes, 1) - AssertClass(t, sel2, "pvk-content") + assertLength(t, sel2.Nodes, 1) + assertClass(t, sel2, "pvk-content") } func TestClosestNodesNone(t *testing.T) { sel := Doc().Find("h4") sel2 := sel.ClosestNodes(Doc().Find("a").Nodes...) - AssertLength(t, sel2.Nodes, 0) + assertLength(t, sel2.Nodes, 0) } func TestClosestNodesMany(t *testing.T) { sel := Doc().Find(".container-fluid") sel2 := sel.ClosestNodes(Doc().Find(".pvk-content").Nodes...) - AssertLength(t, sel2.Nodes, 2) - AssertSelectionIs(t, sel2, "#pc1", "#pc2") + assertLength(t, sel2.Nodes, 2) + assertSelectionIs(t, sel2, "#pc1", "#pc2") } func TestClosestNodesRollback(t *testing.T) { sel := Doc().Find(".container-fluid") sel2 := sel.ClosestNodes(Doc().Find(".pvk-content").Nodes...).End() - AssertEqual(t, sel, sel2) + assertEqual(t, sel, sel2) } func TestIssue26(t *testing.T) { @@ -692,6 +692,6 @@ func TestIssue26(t *testing.T) { t.Fatal(err) } sel := doc.Find("img[src]") - AssertLength(t, sel.Nodes, c.l) + assertLength(t, sel.Nodes, c.l) } } diff --git a/type_test.go b/type_test.go index aeb132d..2ed1e81 100644 --- a/type_test.go +++ b/type_test.go @@ -17,7 +17,7 @@ var docW *Document func Doc() *Document { if doc == nil { - doc = LoadDoc("page.html") + doc = loadDoc("page.html") } return doc } @@ -26,7 +26,7 @@ func DocClone() *Document { } func Doc2() *Document { if doc2 == nil { - doc2 = LoadDoc("page2.html") + doc2 = loadDoc("page2.html") } return doc2 } @@ -35,7 +35,7 @@ func Doc2Clone() *Document { } func DocB() *Document { if docB == nil { - docB = LoadDoc("gotesting.html") + docB = loadDoc("gotesting.html") } return docB } @@ -44,7 +44,7 @@ func DocBClone() *Document { } func DocW() *Document { if docW == nil { - docW = LoadDoc("gowiki.html") + docW = loadDoc("gowiki.html") } return docW } @@ -52,7 +52,7 @@ func DocWClone() *Document { return NewDocumentFromDocument(DocW()) } -func AssertLength(t *testing.T, nodes []*html.Node, length int) { +func assertLength(t *testing.T, nodes []*html.Node, length int) { if len(nodes) != length { t.Errorf("Expected %d nodes, found %d.", length, len(nodes)) for i, n := range nodes { @@ -61,25 +61,25 @@ func AssertLength(t *testing.T, nodes []*html.Node, length int) { } } -func AssertClass(t *testing.T, sel *Selection, class string) { +func assertClass(t *testing.T, sel *Selection, class string) { if !sel.HasClass(class) { t.Errorf("Expected node to have class %s, found %+v.", class, sel.Get(0)) } } -func AssertPanic(t *testing.T) { +func assertPanic(t *testing.T) { if e := recover(); e == nil { t.Error("Expected a panic.") } } -func AssertEqual(t *testing.T, s1 *Selection, s2 *Selection) { +func assertEqual(t *testing.T, s1 *Selection, s2 *Selection) { if s1 != s2 { t.Error("Expected selection objects to be the same.") } } -func AssertSelectionIs(t *testing.T, sel *Selection, is ...string) { +func assertSelectionIs(t *testing.T, sel *Selection, is ...string) { for i := 0; i < sel.Length(); i++ { if !sel.Eq(i).Is(is[i]) { t.Errorf("Expected node %d to be %s, found %+v", i, is[i], sel.Get(i)) @@ -87,7 +87,17 @@ func AssertSelectionIs(t *testing.T, sel *Selection, is ...string) { } } -func LoadDoc(page string) *Document { +func printSel(t *testing.T, sel *Selection) { + if testing.Verbose() { + h, err := sel.Html() + if err != nil { + t.Fatal(err) + } + t.Log(h) + } +} + +func loadDoc(page string) *Document { var f *os.File var e error