1package goquery
2
3import (
4	"testing"
5)
6
7func BenchmarkFind(b *testing.B) {
8	var n int
9
10	for i := 0; i < b.N; i++ {
11		if n == 0 {
12			n = DocB().Find("dd").Length()
13
14		} else {
15			DocB().Find("dd")
16		}
17	}
18	if n != 41 {
19		b.Fatalf("want 41, got %d", n)
20	}
21}
22
23func BenchmarkFindWithinSelection(b *testing.B) {
24	var n int
25
26	b.StopTimer()
27	sel := DocW().Find("ul")
28	b.StartTimer()
29	for i := 0; i < b.N; i++ {
30		if n == 0 {
31			n = sel.Find("a[class]").Length()
32		} else {
33			sel.Find("a[class]")
34		}
35	}
36	if n != 39 {
37		b.Fatalf("want 39, got %d", n)
38	}
39}
40
41func BenchmarkFindSelection(b *testing.B) {
42	var n int
43
44	b.StopTimer()
45	sel := DocW().Find("ul")
46	sel2 := DocW().Find("span")
47	b.StartTimer()
48	for i := 0; i < b.N; i++ {
49		if n == 0 {
50			n = sel.FindSelection(sel2).Length()
51		} else {
52			sel.FindSelection(sel2)
53		}
54	}
55	if n != 73 {
56		b.Fatalf("want 73, got %d", n)
57	}
58}
59
60func BenchmarkFindNodes(b *testing.B) {
61	var n int
62
63	b.StopTimer()
64	sel := DocW().Find("ul")
65	sel2 := DocW().Find("span")
66	nodes := sel2.Nodes
67	b.StartTimer()
68	for i := 0; i < b.N; i++ {
69		if n == 0 {
70			n = sel.FindNodes(nodes...).Length()
71		} else {
72			sel.FindNodes(nodes...)
73		}
74	}
75	if n != 73 {
76		b.Fatalf("want 73, got %d", n)
77	}
78}
79
80func BenchmarkContents(b *testing.B) {
81	var n int
82
83	b.StopTimer()
84	sel := DocW().Find(".toclevel-1")
85	b.StartTimer()
86	for i := 0; i < b.N; i++ {
87		if n == 0 {
88			n = sel.Contents().Length()
89		} else {
90			sel.Contents()
91		}
92	}
93	if n != 16 {
94		b.Fatalf("want 16, got %d", n)
95	}
96}
97
98func BenchmarkContentsFiltered(b *testing.B) {
99	var n int
100
101	b.StopTimer()
102	sel := DocW().Find(".toclevel-1")
103	b.StartTimer()
104	for i := 0; i < b.N; i++ {
105		if n == 0 {
106			n = sel.ContentsFiltered("a[href=\"#Examples\"]").Length()
107		} else {
108			sel.ContentsFiltered("a[href=\"#Examples\"]")
109		}
110	}
111	if n != 1 {
112		b.Fatalf("want 1, got %d", n)
113	}
114}
115
116func BenchmarkChildren(b *testing.B) {
117	var n int
118
119	b.StopTimer()
120	sel := DocW().Find(".toclevel-2")
121	b.StartTimer()
122	for i := 0; i < b.N; i++ {
123		if n == 0 {
124			n = sel.Children().Length()
125		} else {
126			sel.Children()
127		}
128	}
129	if n != 2 {
130		b.Fatalf("want 2, got %d", n)
131	}
132}
133
134func BenchmarkChildrenFiltered(b *testing.B) {
135	var n int
136
137	b.StopTimer()
138	sel := DocW().Find("h3")
139	b.StartTimer()
140	for i := 0; i < b.N; i++ {
141		if n == 0 {
142			n = sel.ChildrenFiltered(".editsection").Length()
143		} else {
144			sel.ChildrenFiltered(".editsection")
145		}
146	}
147	if n != 2 {
148		b.Fatalf("want 2, got %d", n)
149	}
150}
151
152func BenchmarkParent(b *testing.B) {
153	var n int
154
155	b.StopTimer()
156	sel := DocW().Find("li")
157	b.StartTimer()
158	for i := 0; i < b.N; i++ {
159		if n == 0 {
160			n = sel.Parent().Length()
161		} else {
162			sel.Parent()
163		}
164	}
165	if n != 55 {
166		b.Fatalf("want 55, got %d", n)
167	}
168}
169
170func BenchmarkParentFiltered(b *testing.B) {
171	var n int
172
173	b.StopTimer()
174	sel := DocW().Find("li")
175	b.StartTimer()
176	for i := 0; i < b.N; i++ {
177		if n == 0 {
178			n = sel.ParentFiltered("ul[id]").Length()
179		} else {
180			sel.ParentFiltered("ul[id]")
181		}
182	}
183	if n != 4 {
184		b.Fatalf("want 4, got %d", n)
185	}
186}
187
188func BenchmarkParents(b *testing.B) {
189	var n int
190
191	b.StopTimer()
192	sel := DocW().Find("th a")
193	b.StartTimer()
194	for i := 0; i < b.N; i++ {
195		if n == 0 {
196			n = sel.Parents().Length()
197		} else {
198			sel.Parents()
199		}
200	}
201	if n != 73 {
202		b.Fatalf("want 73, got %d", n)
203	}
204}
205
206func BenchmarkParentsFiltered(b *testing.B) {
207	var n int
208
209	b.StopTimer()
210	sel := DocW().Find("th a")
211	b.StartTimer()
212	for i := 0; i < b.N; i++ {
213		if n == 0 {
214			n = sel.ParentsFiltered("tr").Length()
215		} else {
216			sel.ParentsFiltered("tr")
217		}
218	}
219	if n != 18 {
220		b.Fatalf("want 18, got %d", n)
221	}
222}
223
224func BenchmarkParentsUntil(b *testing.B) {
225	var n int
226
227	b.StopTimer()
228	sel := DocW().Find("th a")
229	b.StartTimer()
230	for i := 0; i < b.N; i++ {
231		if n == 0 {
232			n = sel.ParentsUntil("table").Length()
233		} else {
234			sel.ParentsUntil("table")
235		}
236	}
237	if n != 52 {
238		b.Fatalf("want 52, got %d", n)
239	}
240}
241
242func BenchmarkParentsUntilSelection(b *testing.B) {
243	var n int
244
245	b.StopTimer()
246	sel := DocW().Find("th a")
247	sel2 := DocW().Find("#content")
248	b.StartTimer()
249	for i := 0; i < b.N; i++ {
250		if n == 0 {
251			n = sel.ParentsUntilSelection(sel2).Length()
252		} else {
253			sel.ParentsUntilSelection(sel2)
254		}
255	}
256	if n != 70 {
257		b.Fatalf("want 70, got %d", n)
258	}
259}
260
261func BenchmarkParentsUntilNodes(b *testing.B) {
262	var n int
263
264	b.StopTimer()
265	sel := DocW().Find("th a")
266	sel2 := DocW().Find("#content")
267	nodes := sel2.Nodes
268	b.StartTimer()
269	for i := 0; i < b.N; i++ {
270		if n == 0 {
271			n = sel.ParentsUntilNodes(nodes...).Length()
272		} else {
273			sel.ParentsUntilNodes(nodes...)
274		}
275	}
276	if n != 70 {
277		b.Fatalf("want 70, got %d", n)
278	}
279}
280
281func BenchmarkParentsFilteredUntil(b *testing.B) {
282	var n int
283
284	b.StopTimer()
285	sel := DocW().Find(".toclevel-1 a")
286	b.StartTimer()
287	for i := 0; i < b.N; i++ {
288		if n == 0 {
289			n = sel.ParentsFilteredUntil(":nth-child(1)", "ul").Length()
290		} else {
291			sel.ParentsFilteredUntil(":nth-child(1)", "ul")
292		}
293	}
294	if n != 2 {
295		b.Fatalf("want 2, got %d", n)
296	}
297}
298
299func BenchmarkParentsFilteredUntilSelection(b *testing.B) {
300	var n int
301
302	b.StopTimer()
303	sel := DocW().Find(".toclevel-1 a")
304	sel2 := DocW().Find("ul")
305	b.StartTimer()
306	for i := 0; i < b.N; i++ {
307		if n == 0 {
308			n = sel.ParentsFilteredUntilSelection(":nth-child(1)", sel2).Length()
309		} else {
310			sel.ParentsFilteredUntilSelection(":nth-child(1)", sel2)
311		}
312	}
313	if n != 2 {
314		b.Fatalf("want 2, got %d", n)
315	}
316}
317
318func BenchmarkParentsFilteredUntilNodes(b *testing.B) {
319	var n int
320
321	b.StopTimer()
322	sel := DocW().Find(".toclevel-1 a")
323	sel2 := DocW().Find("ul")
324	nodes := sel2.Nodes
325	b.StartTimer()
326	for i := 0; i < b.N; i++ {
327		if n == 0 {
328			n = sel.ParentsFilteredUntilNodes(":nth-child(1)", nodes...).Length()
329		} else {
330			sel.ParentsFilteredUntilNodes(":nth-child(1)", nodes...)
331		}
332	}
333	if n != 2 {
334		b.Fatalf("want 2, got %d", n)
335	}
336}
337
338func BenchmarkSiblings(b *testing.B) {
339	var n int
340
341	b.StopTimer()
342	sel := DocW().Find("ul li:nth-child(1)")
343	b.StartTimer()
344	for i := 0; i < b.N; i++ {
345		if n == 0 {
346			n = sel.Siblings().Length()
347		} else {
348			sel.Siblings()
349		}
350	}
351	if n != 293 {
352		b.Fatalf("want 293, got %d", n)
353	}
354}
355
356func BenchmarkSiblingsFiltered(b *testing.B) {
357	var n int
358
359	b.StopTimer()
360	sel := DocW().Find("ul li:nth-child(1)")
361	b.StartTimer()
362	for i := 0; i < b.N; i++ {
363		if n == 0 {
364			n = sel.SiblingsFiltered("[class]").Length()
365		} else {
366			sel.SiblingsFiltered("[class]")
367		}
368	}
369	if n != 46 {
370		b.Fatalf("want 46, got %d", n)
371	}
372}
373
374func BenchmarkNext(b *testing.B) {
375	var n int
376
377	b.StopTimer()
378	sel := DocW().Find("li:nth-child(1)")
379	b.StartTimer()
380	for i := 0; i < b.N; i++ {
381		if n == 0 {
382			n = sel.Next().Length()
383		} else {
384			sel.Next()
385		}
386	}
387	if n != 49 {
388		b.Fatalf("want 49, got %d", n)
389	}
390}
391
392func BenchmarkNextFiltered(b *testing.B) {
393	var n int
394
395	b.StopTimer()
396	sel := DocW().Find("li:nth-child(1)")
397	b.StartTimer()
398	for i := 0; i < b.N; i++ {
399		if n == 0 {
400			n = sel.NextFiltered("[class]").Length()
401		} else {
402			sel.NextFiltered("[class]")
403		}
404	}
405	if n != 6 {
406		b.Fatalf("want 6, got %d", n)
407	}
408}
409
410func BenchmarkNextAll(b *testing.B) {
411	var n int
412
413	b.StopTimer()
414	sel := DocW().Find("li:nth-child(3)")
415	b.StartTimer()
416	for i := 0; i < b.N; i++ {
417		if n == 0 {
418			n = sel.NextAll().Length()
419		} else {
420			sel.NextAll()
421		}
422	}
423	if n != 234 {
424		b.Fatalf("want 234, got %d", n)
425	}
426}
427
428func BenchmarkNextAllFiltered(b *testing.B) {
429	var n int
430
431	b.StopTimer()
432	sel := DocW().Find("li:nth-child(3)")
433	b.StartTimer()
434	for i := 0; i < b.N; i++ {
435		if n == 0 {
436			n = sel.NextAllFiltered("[class]").Length()
437		} else {
438			sel.NextAllFiltered("[class]")
439		}
440	}
441	if n != 33 {
442		b.Fatalf("want 33, got %d", n)
443	}
444}
445
446func BenchmarkPrev(b *testing.B) {
447	var n int
448
449	b.StopTimer()
450	sel := DocW().Find("li:last-child")
451	b.StartTimer()
452	for i := 0; i < b.N; i++ {
453		if n == 0 {
454			n = sel.Prev().Length()
455		} else {
456			sel.Prev()
457		}
458	}
459	if n != 49 {
460		b.Fatalf("want 49, got %d", n)
461	}
462}
463
464func BenchmarkPrevFiltered(b *testing.B) {
465	var n int
466
467	b.StopTimer()
468	sel := DocW().Find("li:last-child")
469	b.StartTimer()
470	for i := 0; i < b.N; i++ {
471		if n == 0 {
472			n = sel.PrevFiltered("[class]").Length()
473		} else {
474			sel.PrevFiltered("[class]")
475		}
476	}
477	// There is one more Prev li with a class, compared to Next li with a class
478	// (confirmed by looking at the HTML, this is ok)
479	if n != 7 {
480		b.Fatalf("want 7, got %d", n)
481	}
482}
483
484func BenchmarkPrevAll(b *testing.B) {
485	var n int
486
487	b.StopTimer()
488	sel := DocW().Find("li:nth-child(4)")
489	b.StartTimer()
490	for i := 0; i < b.N; i++ {
491		if n == 0 {
492			n = sel.PrevAll().Length()
493		} else {
494			sel.PrevAll()
495		}
496	}
497	if n != 78 {
498		b.Fatalf("want 78, got %d", n)
499	}
500}
501
502func BenchmarkPrevAllFiltered(b *testing.B) {
503	var n int
504
505	b.StopTimer()
506	sel := DocW().Find("li:nth-child(4)")
507	b.StartTimer()
508	for i := 0; i < b.N; i++ {
509		if n == 0 {
510			n = sel.PrevAllFiltered("[class]").Length()
511		} else {
512			sel.PrevAllFiltered("[class]")
513		}
514	}
515	if n != 6 {
516		b.Fatalf("want 6, got %d", n)
517	}
518}
519
520func BenchmarkNextUntil(b *testing.B) {
521	var n int
522
523	b.StopTimer()
524	sel := DocW().Find("li:first-child")
525	b.StartTimer()
526	for i := 0; i < b.N; i++ {
527		if n == 0 {
528			n = sel.NextUntil(":nth-child(4)").Length()
529		} else {
530			sel.NextUntil(":nth-child(4)")
531		}
532	}
533	if n != 84 {
534		b.Fatalf("want 84, got %d", n)
535	}
536}
537
538func BenchmarkNextUntilSelection(b *testing.B) {
539	var n int
540
541	b.StopTimer()
542	sel := DocW().Find("h2")
543	sel2 := DocW().Find("ul")
544	b.StartTimer()
545	for i := 0; i < b.N; i++ {
546		if n == 0 {
547			n = sel.NextUntilSelection(sel2).Length()
548		} else {
549			sel.NextUntilSelection(sel2)
550		}
551	}
552	if n != 42 {
553		b.Fatalf("want 42, got %d", n)
554	}
555}
556
557func BenchmarkNextUntilNodes(b *testing.B) {
558	var n int
559
560	b.StopTimer()
561	sel := DocW().Find("h2")
562	sel2 := DocW().Find("p")
563	nodes := sel2.Nodes
564	b.StartTimer()
565	for i := 0; i < b.N; i++ {
566		if n == 0 {
567			n = sel.NextUntilNodes(nodes...).Length()
568		} else {
569			sel.NextUntilNodes(nodes...)
570		}
571	}
572	if n != 12 {
573		b.Fatalf("want 12, got %d", n)
574	}
575}
576
577func BenchmarkPrevUntil(b *testing.B) {
578	var n int
579
580	b.StopTimer()
581	sel := DocW().Find("li:last-child")
582	b.StartTimer()
583	for i := 0; i < b.N; i++ {
584		if n == 0 {
585			n = sel.PrevUntil(":nth-child(4)").Length()
586		} else {
587			sel.PrevUntil(":nth-child(4)")
588		}
589	}
590	if n != 238 {
591		b.Fatalf("want 238, got %d", n)
592	}
593}
594
595func BenchmarkPrevUntilSelection(b *testing.B) {
596	var n int
597
598	b.StopTimer()
599	sel := DocW().Find("h2")
600	sel2 := DocW().Find("ul")
601	b.StartTimer()
602	for i := 0; i < b.N; i++ {
603		if n == 0 {
604			n = sel.PrevUntilSelection(sel2).Length()
605		} else {
606			sel.PrevUntilSelection(sel2)
607		}
608	}
609	if n != 49 {
610		b.Fatalf("want 49, got %d", n)
611	}
612}
613
614func BenchmarkPrevUntilNodes(b *testing.B) {
615	var n int
616
617	b.StopTimer()
618	sel := DocW().Find("h2")
619	sel2 := DocW().Find("p")
620	nodes := sel2.Nodes
621	b.StartTimer()
622	for i := 0; i < b.N; i++ {
623		if n == 0 {
624			n = sel.PrevUntilNodes(nodes...).Length()
625		} else {
626			sel.PrevUntilNodes(nodes...)
627		}
628	}
629	if n != 11 {
630		b.Fatalf("want 11, got %d", n)
631	}
632}
633
634func BenchmarkNextFilteredUntil(b *testing.B) {
635	var n int
636
637	b.StopTimer()
638	sel := DocW().Find("h2")
639	b.StartTimer()
640	for i := 0; i < b.N; i++ {
641		if n == 0 {
642			n = sel.NextFilteredUntil("p", "div").Length()
643		} else {
644			sel.NextFilteredUntil("p", "div")
645		}
646	}
647	if n != 22 {
648		b.Fatalf("want 22, got %d", n)
649	}
650}
651
652func BenchmarkNextFilteredUntilSelection(b *testing.B) {
653	var n int
654
655	b.StopTimer()
656	sel := DocW().Find("h2")
657	sel2 := DocW().Find("div")
658	b.StartTimer()
659	for i := 0; i < b.N; i++ {
660		if n == 0 {
661			n = sel.NextFilteredUntilSelection("p", sel2).Length()
662		} else {
663			sel.NextFilteredUntilSelection("p", sel2)
664		}
665	}
666	if n != 22 {
667		b.Fatalf("want 22, got %d", n)
668	}
669}
670
671func BenchmarkNextFilteredUntilNodes(b *testing.B) {
672	var n int
673
674	b.StopTimer()
675	sel := DocW().Find("h2")
676	sel2 := DocW().Find("div")
677	nodes := sel2.Nodes
678	b.StartTimer()
679	for i := 0; i < b.N; i++ {
680		if n == 0 {
681			n = sel.NextFilteredUntilNodes("p", nodes...).Length()
682		} else {
683			sel.NextFilteredUntilNodes("p", nodes...)
684		}
685	}
686	if n != 22 {
687		b.Fatalf("want 22, got %d", n)
688	}
689}
690
691func BenchmarkPrevFilteredUntil(b *testing.B) {
692	var n int
693
694	b.StopTimer()
695	sel := DocW().Find("h2")
696	b.StartTimer()
697	for i := 0; i < b.N; i++ {
698		if n == 0 {
699			n = sel.PrevFilteredUntil("p", "div").Length()
700		} else {
701			sel.PrevFilteredUntil("p", "div")
702		}
703	}
704	if n != 20 {
705		b.Fatalf("want 20, got %d", n)
706	}
707}
708
709func BenchmarkPrevFilteredUntilSelection(b *testing.B) {
710	var n int
711
712	b.StopTimer()
713	sel := DocW().Find("h2")
714	sel2 := DocW().Find("div")
715	b.StartTimer()
716	for i := 0; i < b.N; i++ {
717		if n == 0 {
718			n = sel.PrevFilteredUntilSelection("p", sel2).Length()
719		} else {
720			sel.PrevFilteredUntilSelection("p", sel2)
721		}
722	}
723	if n != 20 {
724		b.Fatalf("want 20, got %d", n)
725	}
726}
727
728func BenchmarkPrevFilteredUntilNodes(b *testing.B) {
729	var n int
730
731	b.StopTimer()
732	sel := DocW().Find("h2")
733	sel2 := DocW().Find("div")
734	nodes := sel2.Nodes
735	b.StartTimer()
736	for i := 0; i < b.N; i++ {
737		if n == 0 {
738			n = sel.PrevFilteredUntilNodes("p", nodes...).Length()
739		} else {
740			sel.PrevFilteredUntilNodes("p", nodes...)
741		}
742	}
743	if n != 20 {
744		b.Fatalf("want 20, got %d", n)
745	}
746}
747
748func BenchmarkClosest(b *testing.B) {
749	var n int
750
751	b.StopTimer()
752	sel := Doc().Find(".container-fluid")
753	b.StartTimer()
754	for i := 0; i < b.N; i++ {
755		if n == 0 {
756			n = sel.Closest(".pvk-content").Length()
757		} else {
758			sel.Closest(".pvk-content")
759		}
760	}
761	if n != 2 {
762		b.Fatalf("want 2, got %d", n)
763	}
764}
765
766func BenchmarkClosestSelection(b *testing.B) {
767	var n int
768
769	b.StopTimer()
770	sel := Doc().Find(".container-fluid")
771	sel2 := Doc().Find(".pvk-content")
772	b.StartTimer()
773	for i := 0; i < b.N; i++ {
774		if n == 0 {
775			n = sel.ClosestSelection(sel2).Length()
776		} else {
777			sel.ClosestSelection(sel2)
778		}
779	}
780	if n != 2 {
781		b.Fatalf("want 2, got %d", n)
782	}
783}
784
785func BenchmarkClosestNodes(b *testing.B) {
786	var n int
787
788	b.StopTimer()
789	sel := Doc().Find(".container-fluid")
790	nodes := Doc().Find(".pvk-content").Nodes
791	b.StartTimer()
792	for i := 0; i < b.N; i++ {
793		if n == 0 {
794			n = sel.ClosestNodes(nodes...).Length()
795		} else {
796			sel.ClosestNodes(nodes...)
797		}
798	}
799	if n != 2 {
800		b.Fatalf("want 2, got %d", n)
801	}
802}
803