How to use Siblings method of html Package
Best K6 code snippet using html.Siblings
parentSibling_test.go
Source:parentSibling_test.go 
...385 }386 })387 }388}389func TestFindNextSiblings(t *testing.T) {390 r := strings.NewReader(`391 <html>392 <head></head>393 <body>394 <div id="red" class="box"></div>395 <div id="green" class="box">396 <div class="list-item" id="l1"></div>397 <div class="list-item" id="l2"></div>398 <div class="list-item" id="l3"></div>399 <div class="list-item" id="l4"></div>400 <div class="list-item" id="l5"></div>401 </div>402 <div id="blue" class="box"></div>403 </body>404 </html>405 `)406 root, _ := GetRootElement(r)407 408 elements := []Element{409 {410 &html.Node{411 Type: html.ElementNode,412 Data: "div",413 Attr: []html.Attribute{414 {Key: "class", Val: "list-item"},415 {Key: "id", Val: "l2"},416 },417 },418 },419 {420 &html.Node{421 Type: html.ElementNode,422 Data: "div",423 Attr: []html.Attribute{424 {Key: "class", Val: "list-item"},425 {Key: "id", Val: "l3"},426 },427 },428 },429 {430 &html.Node{431 Type: html.ElementNode,432 Data: "div",433 Attr: []html.Attribute{434 {Key: "class", Val: "list-item"},435 {Key: "id", Val: "l4"},436 },437 },438 },439 {440 &html.Node{441 Type: html.ElementNode,442 Data: "div",443 Attr: []html.Attribute{444 {Key: "class", Val: "list-item"},445 {Key: "id", Val: "l5"},446 },447 },448 },449 {450 &html.Node{451 Type: html.ElementNode,452 Data: "div",453 Attr: []html.Attribute{454 {Key: "class", Val: "box"},455 {Key: "id", Val: "green"},456 },457 },458 },459 {460 &html.Node{461 Type: html.ElementNode,462 Data: "div",463 Attr: []html.Attribute{464 {Key: "class", Val: "box"},465 {Key: "id", Val: "blue"},466 },467 },468 },469 {470 &html.Node{471 Type: html.ElementNode,472 Data: "body",473 },474 },475 }476 477 cases := []struct {478 out []Element479 got []Element480 }{481 // returns non-nil elements482 {483 elements[0:4],484 root.FindOne("div", true, "class", "list-item", "id", "l1").485 FindNextSiblings("div", -1),486 },487 {488 elements[0:2],489 root.FindOne("div", true, "class", "list-item", "id", "l1").490 FindNextSiblings("div", 2),491 },492 {493 elements[0:4],494 root.FindOne("div", true, "class", "list-item", "id", "l1").495 FindNextSiblings("div", -1, "class", "list-item"),496 },497 {498 elements[1:2],499 root.FindOne("div", true, "class", "list-item", "id", "l1").500 FindNextSiblings("div", -1, "id", "l3"),501 },502 {503 elements[4:6],504 root.FindOne("div", true, "class", "box", "id", "red").505 FindNextSiblings("div", -1),506 },507 {508 elements[6:7],509 root.FindOne("head", true).510 FindNextSiblings("body", -1),511 },512 // returns nil elements513 {514 []Element{},515 root.FindOne("body", false).516 FindNextSiblings("body", -1), 517 },518 {519 []Element{},520 root.FindOne("div", true, "class", "box", "id", "blue").521 FindNextSiblings("div", -1, "id", "green"),522 },523 {524 []Element{},525 Element{}.FindNextSiblings("div", -1),526 },527 }528 for i, test := range cases {529 t.Run(fmt.Sprintf("Case #%d\n", i), func(t *testing.T) {530 if len(test.out) != len(test.got) {531 t.Fatalf("len(test.out)=%d, len(test.got)=%d\n", len(test.out), len(test.got))532 }533 for j, el := range test.out {534 t.Run(fmt.Sprintf("el #%d\n", j), func(t *testing.T) {535 if el.compareTo(test.got[j]) == false {536 t.Errorf("expected=%+v, got=%+v\n", test.out[j], test.got[j]) 537 }538 })539 }540 })541 }542}543func TestFindPrevSibling(t *testing.T) {544 r := strings.NewReader(`545 <html>546 <head></head>547 <body>548 <div id="red" class="box"></div>549 <div id="green" class="box">550 <div class="list-item" id="l1"></div>551 <div class="list-item" id="l2"></div>552 <div class="list-item" id="l3"></div>553 <div class="list-item" id="l4"></div>554 <div class="list-item" id="l5"></div>555 </div>556 <div id="blue" class="box"></div>557 </body>558 </html>559 `)560 root, _ := GetRootElement(r)561 562 elements := []Element{563 {564 &html.Node{565 Type: html.ElementNode,566 Data: "div",567 Attr: []html.Attribute{568 {Key: "class", Val: "list-item"},569 {Key: "id", Val: "l4"},570 },571 },572 },573 {574 &html.Node{575 Type: html.ElementNode,576 Data: "div",577 Attr: []html.Attribute{578 {Key: "class", Val: "list-item"},579 {Key: "id", Val: "l1"},580 },581 },582 },583 {584 &html.Node{585 Type: html.ElementNode,586 Data: "div",587 Attr: []html.Attribute{588 {Key: "class", Val: "box"},589 {Key: "id", Val: "green"},590 },591 },592 },593 {594 &html.Node{595 Type: html.ElementNode,596 Data: "div",597 Attr: []html.Attribute{598 {Key: "class", Val: "box"},599 {Key: "id", Val: "red"},600 },601 },602 },603 {604 &html.Node{605 Type: html.ElementNode,606 Data: "head",607 },608 },609 }610 611 cases := []struct {612 out Element613 got Element614 }{615 // returns non-nil elements616 {617 elements[0],618 root.FindOne("div", true, "class", "list-item", "id", "l5").619 FindPrevSibling("div"),620 },621 {622 elements[0],623 root.FindOne("div", true, "class", "list-item", "id", "l5").624 FindPrevSibling("div", "id", "l4"),625 },626 {627 elements[1],628 root.FindOne("div", true, "class", "list-item", "id", "l5").629 FindPrevSibling("div", "id", "l1"),630 },631 {632 elements[2],633 root.FindOne("div", true, "class", "box", "id", "blue").634 FindPrevSibling("div"),635 },636 {637 elements[2],638 root.FindOne("div", true, "class", "box", "id", "blue").639 FindPrevSibling("div", "id", "green"),640 },641 {642 elements[3],643 root.FindOne("div", true, "class", "box", "id", "blue").644 FindPrevSibling("div", "id", "red"),645 },646 {647 elements[4],648 root.FindOne("body", false).649 FindPrevSibling("head"), 650 },651 // returns nil elements652 {653 Element{},654 root.FindOne("head", false).655 FindPrevSibling("head"), 656 },657 {658 Element{},659 root.FindOne("div", true, "class", "box", "id", "red").660 FindPrevSibling("div", "id", "green"),661 },662 {663 Element{},664 Element{}.FindPrevSibling("div", "id", "green"),665 },666 }667 for i, test := range cases {668 t.Run(fmt.Sprintf("Case #%d\n", i), func(t *testing.T) {669 if test.out.compareTo(test.got) == false {670 t.Errorf("expected=%+v, got=%+v\n", test.out, test.got) 671 }672 })673 }674}675func TestFindPrevSiblings(t *testing.T) {676 r := strings.NewReader(`677 <html>678 <head></head>679 <body>680 <div id="red" class="box"></div>681 <div id="green" class="box">682 <div class="list-item" id="l1"></div>683 <div class="list-item" id="l2"></div>684 <div class="list-item" id="l3"></div>685 <div class="list-item" id="l4"></div>686 <div class="list-item" id="l5"></div>687 </div>688 <div id="blue" class="box"></div>689 </body>690 </html>691 `)692 root, _ := GetRootElement(r)693 694 elements := []Element{695 {696 &html.Node{697 Type: html.ElementNode,698 Data: "div",699 Attr: []html.Attribute{700 {Key: "class", Val: "list-item"},701 {Key: "id", Val: "l4"},702 },703 },704 },705 {706 &html.Node{707 Type: html.ElementNode,708 Data: "div",709 Attr: []html.Attribute{710 {Key: "class", Val: "list-item"},711 {Key: "id", Val: "l3"},712 },713 },714 },715 {716 &html.Node{717 Type: html.ElementNode,718 Data: "div",719 Attr: []html.Attribute{720 {Key: "class", Val: "list-item"},721 {Key: "id", Val: "l2"},722 },723 },724 },725 {726 &html.Node{727 Type: html.ElementNode,728 Data: "div",729 Attr: []html.Attribute{730 {Key: "class", Val: "list-item"},731 {Key: "id", Val: "l1"},732 },733 },734 },735 {736 &html.Node{737 Type: html.ElementNode,738 Data: "div",739 Attr: []html.Attribute{740 {Key: "class", Val: "box"},741 {Key: "id", Val: "green"},742 },743 },744 },745 {746 &html.Node{747 Type: html.ElementNode,748 Data: "div",749 Attr: []html.Attribute{750 {Key: "class", Val: "box"},751 {Key: "id", Val: "red"},752 },753 },754 },755 {756 &html.Node{757 Type: html.ElementNode,758 Data: "head",759 },760 },761 }762 763 cases := []struct {764 out []Element765 got []Element766 }{767 // returns non-nil elements768 {769 elements[0:4],770 root.FindOne("div", true, "class", "list-item", "id", "l5").771 FindPrevSiblings("div", -1),772 },773 {774 elements[0:2],775 root.FindOne("div", true, "class", "list-item", "id", "l5").776 FindPrevSiblings("div", 2),777 },778 {779 elements[0:4],780 root.FindOne("div", true, "class", "list-item", "id", "l5").781 FindPrevSiblings("div", -1, "class", "list-item"),782 },783 {784 elements[1:2],785 root.FindOne("div", true, "class", "list-item", "id", "l5").786 FindPrevSiblings("div", -1, "id", "l3"),787 },788 {789 elements[4:6],790 root.FindOne("div", true, "class", "box", "id", "blue").791 FindPrevSiblings("div", -1),792 },793 {794 elements[6:7],795 root.FindOne("body", true).796 FindPrevSiblings("head", -1),797 },798 // returns nil elements799 {800 []Element{},801 root.FindOne("head", false).802 FindPrevSiblings("body", -1), 803 },804 {805 []Element{},806 root.FindOne("div", true, "class", "box", "id", "red").807 FindPrevSiblings("div", -1, "id", "green"),808 },809 {810 []Element{},811 Element{}.FindNextSiblings("div", -1),812 },813 }814 for i, test := range cases {815 t.Run(fmt.Sprintf("Case #%d\n", i), func(t *testing.T) {816 if len(test.out) != len(test.got) {817 t.Fatalf("len(test.out)=%d, len(test.got)=%d\n", len(test.out), len(test.got))818 }819 for j, el := range test.out {820 t.Run(fmt.Sprintf("el #%d\n", j), func(t *testing.T) {821 if el.compareTo(test.got[j]) == false {822 t.Errorf("expected=%+v, got=%+v\n", test.out[j], test.got[j]) 823 }824 })825 }...
tree.go
Source:tree.go
...8 "sync"9 "github.com/bouncepaw/mycorrhiza/hyphae"10 "github.com/bouncepaw/mycorrhiza/util"11)12func findSiblings(hyphaName string) []*sibling {13 parentHyphaName := ""14 if hyphaRawDir := path.Dir(hyphaName); hyphaRawDir != "." {15 parentHyphaName = hyphaRawDir16 }17 var (18 siblingsMap = make(map[string]bool)19 siblingCheck = func(h hyphae.Hypha) iteration.CheckResult {20 switch {21 case h.CanonicalName() == hyphaName, // NonEmptyHypha is no sibling of itself22 h.CanonicalName() == parentHyphaName: // Parent hypha is no sibling of its child23 return iteration.CheckContinue24 }25 if (parentHyphaName != "" && strings.HasPrefix(h.CanonicalName(), parentHyphaName+"/")) ||26 (parentHyphaName == "") {27 var (28 rawSubPath = strings.TrimPrefix(h.CanonicalName(), parentHyphaName)[1:]29 slashIdx = strings.IndexRune(rawSubPath, '/')30 )31 if slashIdx > -1 {32 var sibPath = h.CanonicalName()[:slashIdx+len(parentHyphaName)+1]33 if _, exists := siblingsMap[sibPath]; !exists {34 siblingsMap[sibPath] = false35 }36 } else { // it is a straight sibling37 siblingsMap[h.CanonicalName()] = true38 }39 }40 return iteration.CheckContinue41 }42 i7n = iteration.NewIteration()43 )44 siblingsMap[hyphaName] = true45 i7n.AddCheck(siblingCheck)46 i7n.Ignite()47 siblings := make([]*sibling, len(siblingsMap))48 sibIdx := 049 for sibName, exists := range siblingsMap {50 siblings[sibIdx] = &sibling{sibName, 0, 0, exists}51 sibIdx++52 }53 sort.Slice(siblings, func(i, j int) bool {54 return siblings[i].name < siblings[j].name55 })56 return siblings57}58func countSubhyphae(siblings []*sibling) {59 var (60 subhyphaCheck = func(h hyphae.Hypha) iteration.CheckResult {61 for _, s := range siblings {62 if path.Dir(h.CanonicalName()) == s.name {63 s.directSubhyphaeCount++64 return iteration.CheckContinue65 } else if strings.HasPrefix(h.CanonicalName(), s.name+"/") {66 s.indirectSubhyphaeCount++67 return iteration.CheckContinue68 }69 }70 return iteration.CheckContinue71 }72 i7n = iteration.NewIteration()73 )74 i7n.AddCheck(subhyphaCheck)75 i7n.Ignite()76}77// Tree generates a tree for `hyphaName` as html and returns next and previous hyphae if any.78func Tree(hyphaName string) (siblingsHTML, childrenHTML, prev, next string) {79 children := make([]child, 0)80 I := 081 // The tree is generated in two iterations of hyphae storage:82 // 1. Find all siblings (sorted)83 // 2. Count how many subhyphae siblings have84 //85 // We also have to figure out what is going on with the descendants: who is a child of whom. We do that in parallel with (2) because we can.86 // One of the siblings is the hypha with name `hyphaName`87 var siblings []*sibling88 wg := sync.WaitGroup{}89 wg.Add(2)90 go func() {91 siblings = findSiblings(hyphaName)92 countSubhyphae(siblings)93 wg.Done()94 }()95 go func() {96 children = figureOutChildren(hyphaName).children97 wg.Done()98 }()99 wg.Wait()100 for i, s := range siblings {101 if s.name == hyphaName {102 I = i103 siblingsHTML += fmt.Sprintf(`<li class="sibling-hyphae__entry sibling-hyphae__entry_this"><span>%s</span></li>`, util.BeautifulName(path.Base(hyphaName)))104 } else {105 siblingsHTML += siblingHTML(s)...
html.go
Source:html.go
...23}24func NewTagFinder(predicate func(html.Node) bool) *TagFinder {25 return &TagFinder{predicate}26}27func findSiblings(node html.Node) []html.Node {28 var siblings []html.Node29 if node.PrevSibling != nil {30 panic("this method only accepts the first sibling in the node")31 }32 for sibling := &node; sibling != nil; sibling = sibling.NextSibling {33 siblings = append(siblings, *sibling)34 }35 return siblings36}37func (f *TagFinder) walk(nodes []html.Node) *html.Node {38 for _, node := range nodes {39 if f.predicate(node) {40 return &node41 }42 }43 for _, node := range nodes {44 if child := node.FirstChild; child != nil {45 if result := f.walk(findSiblings(*child)); result != nil {46 return result47 }48 }49 }50 return nil51}52func (f *TagFinder) Find(node *html.Node) *html.Node {53 if child := node.FirstChild; child != nil {54 return f.walk(findSiblings(*child))55 }56 return nil57}...
Siblings
Using AI Code Generation
1import (2func main() {3 doc, err := html.Parse(os.Stdin)4 if err != nil {5 fmt.Fprintf(os.Stderr, "findlinks1: %v6 os.Exit(1)7 }8 for _, link := range visit(nil, doc) {9 fmt.Println(link)10 }11}12func visit(links []string, n *html.Node) []string {13 if n.Type == html.ElementNode && n.Data == "a" {14 for _, a := range n.Attr {15 if a.Key == "href" {16 links = append(links, a.Val)17 }18 }19 }20 for c := n.FirstChild; c != nil; c = c.NextSibling {21 links = visit(links, c)22 }23}24import (25func main() {26 doc, err := html.Parse(os.Stdin)27 if err != nil {28 fmt.Fprintf(os.Stderr, "findlinks1: %v29 os.Exit(1)30 }31 for _, link := range visit(nil, doc) {32 fmt.Println(link)33 }34}35func visit(links []string, n *html.Node) []string {36 if n.Type == html.ElementNode && n.Data == "a" {37 for _, a := range n.Attr {38 if a.Key == "href" {39 links = append(links, a.Val)40 }41 }42 }43 for c := n.FirstChild; c != nil; c = c.NextSibling {44 links = visit(links, c)45 }46}47import (48func main() {49 doc, err := html.Parse(os.Stdin)50 if err != nil {51 fmt.Fprintf(os.Stderr, "findlinks1: %v52 os.Exit(1)53 }54 for _, link := range visit(nil, doc) {55 fmt.Println(link)56 }57}58func visit(links []string, n *html.Node) []string {
Siblings
Using AI Code Generation
1import (2func main() {3 doc, err := html.Parse(os.Stdin)4 if err != nil {5 fmt.Fprintf(os.Stderr, "findlinks1: %v6 os.Exit(1)7 }8 for _, link := range visit(nil, doc) {9 fmt.Println(link)10 }11}12func visit(links []string, n *html.Node) []string {13 if n.Type == html.ElementNode && n.Data == "a" {14 for _, a := range n.Attr {15 if a.Key == "href" {16 links = append(links, a.Val)17 }18 }19 }20 for c := n.FirstChild; c != nil; c = c.NextSibling {21 links = visit(links, c)22 }23}
Siblings
Using AI Code Generation
1import (2func main() {3 if err != nil {4 log.Fatal(err)5 }6 defer resp.Body.Close()7 b, err := ioutil.ReadAll(resp.Body)8 if err != nil {9 log.Fatal(err)10 }11 doc, err := html.Parse(strings.NewReader(string(b)))12 if err != nil {13 log.Fatal(err)14 }15 for _, link := range visit(nil, doc) {16 fmt.Println(link)17 }18}19func visit(links []string, n *html.Node) []string {20 if n.Type == html.ElementNode && n.Data == "a" {21 for _, a := range n.Attr {22 if a.Key == "href" {23 links = append(links, a.Val)24 }25 }26 }27 for c := n.FirstChild; c != nil; c = c.NextSibling {28 links = visit(links, c)29 }30}
Siblings
Using AI Code Generation
1import (2func main() {3 doc, err := html.Parse(os.Stdin)4 if err != nil {5 log.Fatalf("findlinks1: %v6 }7 for _, link := range visit(nil, doc) {8 fmt.Println(link)9 }10}11func visit(links []string, n *html.Node) []string {12 if n.Type == html.ElementNode && n.Data == "a" {13 for _, a := range n.Attr {14 if a.Key == "href" {15 links = append(links, a.Val)16 }17 }18 }19 for c := n.FirstChild; c != nil; c = c.NextSibling {20 links = visit(links, c)21 }22}
Siblings
Using AI Code Generation
1import (2func main() {3 resp, err := http.Get(os.Args[1])4 if err != nil {5 log.Fatal(err)6 }7 defer resp.Body.Close()8 z := html.NewTokenizer(resp.Body)9 for {10 tt := z.Next()11 switch {12 t := z.Token()13 if t.Data == "a" {14 for _, a := range t.Attr {15 if a.Key == "href" {16 fmt.Println(a.Val)17 }18 }19 }20 }21 }22}
Siblings
Using AI Code Generation
1import (2func main() {3 if err != nil {4 log.Fatal(err)5 }6 defer resp.Body.Close()7 doc, err := html.Parse(resp.Body)8 if err != nil {9 log.Fatal(err)10 }11 forEachNode(doc, startElement, endElement)12}13func startElement(n *html.Node) {14 if n.Type == html.ElementNode {15 fmt.Printf("%s16 }17}18func endElement(n *html.Node) {19}20func forEachNode(n *html.Node, pre, post func(n *html.Node)) {21 if pre != nil {22 pre(n)23 }24 for c := n.FirstChild; c != nil; c = c.NextSibling {25 forEachNode(c, pre, post)26 }27 if post != nil {28 post(n)29 }30}
Siblings
Using AI Code Generation
1import (2func main() {3 f, err := os.Open("1.html")4 if err != nil {5 log.Fatal(err)6 }7 defer f.Close()8 doc, err := html.Parse(f)9 if err != nil {10 log.Fatal(err)11 }12 forEachNode(doc, startElement, endElement)13}14func forEachNode(n *html.Node, pre, post func(n *html.Node)) {15 if pre != nil {16 pre(n)17 }18 for c := n.FirstChild; c != nil; c = c.NextSibling {19 forEachNode(c, pre, post)20 }21 if post != nil {22 post(n)23 }24}25func startElement(n *html.Node) {26 if n.Type == html.ElementNode {27 fmt.Printf("%*s<%s>\n", n.Depth*2, "", n.Data)28 }29}30func endElement(n *html.Node) {31 if n.Type == html.ElementNode {32 fmt.Printf("%*s</%s>\n", n.Depth*2, "", n.Data)33 }34}35import (36func main() {37 f, err := os.Open("1.html")38 if err != nil {39 log.Fatal(err)40 }41 defer f.Close()42 doc, err := html.Parse(f)43 if err != nil {44 log.Fatal(err)45 }46 forEachNode(doc, startElement, endElement)47}48func forEachNode(n *html.Node, pre, post func(n *html.Node)) {49 if pre != nil {50 pre(n)51 }52 for c := n.FirstChild; c != nil; c = c.NextSibling {53 forEachNode(c, pre, post)54 }55 if post != nil {56 post(n)57 }58}59func startElement(n *html.Node) {60 if n.Type == html.ElementNode {61 fmt.Printf("%*s<%s>\n", n.Depth*2, "", n.Data)62 }63}64func endElement(n *html.Node) {65 if n.Type == html.ElementNode {66 fmt.Printf("%*s</%s>\n", n.Depth*2, "", n.Data)67 }68}
Siblings
Using AI Code Generation
1import (2func main() {3 f, err := os.Open("index.html")4 if err != nil {5 fmt.Println(err)6 }7 doc, err := html.Parse(f)8 if err != nil {9 fmt.Println(err)10 }11 forEachNode(doc, startElement, endElement)12}13func forEachNode(n *html.Node, pre, post func(n *html.Node)) {14 if pre != nil {15 pre(n)16 }17 for c := n.FirstChild; c != nil; c = c.NextSibling {18 forEachNode(c, pre, post)19 }20 if post != nil {21 post(n)22 }23}24func startElement(n *html.Node) {25 if n.Type == html.ElementNode {26 fmt.Printf("<%s", n.Data)27 for _, a := range n.Attr {28 fmt.Printf(" %s='%s'", a.Key, a.Val)29 }30 fmt.Printf(">\n")31 }32}33func endElement(n *html.Node) {34 if n.Type == html.ElementNode {35 fmt.Printf("</%s>\n", n.Data)36 }37}38import (39func main() {40 f, err := os.Open("index.html")41 if err != nil {42 fmt.Println(err)43 }44 doc, err := html.Parse(f)45 if err != nil {46 fmt.Println(err)47 }48 forEachNode(doc, startElement, endElement)49}50func forEachNode(n *html.Node, pre, post func(n *html.Node)) {51 if pre != nil {52 pre(n)53 }54 for c := n.FirstChild; c != nil; c = c.NextSibling {55 forEachNode(c, pre, post)56 }57 if post != nil {58 post(n)59 }60}61func startElement(n *html.Node) {62 if n.Type == html.ElementNode {63 fmt.Printf("<%s", n.Data)64 for _, a := range n.Attr {65 fmt.Printf(" %s='%s'", a.Key, a.Val)66 }67 fmt.Printf(">\n")68 }69}70func endElement(n
Siblings
Using AI Code Generation
1import (2func main() {3 if err != nil {4 log.Fatal(err)5 }6 defer resp.Body.Close()7 body, err := ioutil.ReadAll(resp.Body)8 if err != nil {9 log.Fatal(err)10 }11 doc, err := html.Parse(resp.Body)12 if err != nil {13 log.Fatal(err)14 }15 fmt.Println(doc.FirstChild.Data)16}
Siblings
Using AI Code Generation
1import (2func main() {3 doc, err := html.Parse(os.Stdin)4 if err != nil {5 fmt.Fprintf(os.Stderr, "findlinks1: %v6 os.Exit(1)7 }8 for _, link := range visit(nil, doc) {9 fmt.Println(link)10 }11}12func visit(links []string, n *html.Node) []string {13 if n.Type == html.ElementNode && n.Data == "a" {14 for _, a := range n.Attr {15 if a.Key == "href" {16 links = append(links, a.Val)17 }18 }19 }20 for c := n.FirstChild; c != nil; c = c.NextSibling {21 links = visit(links, c)22 }23}24import (25func main() {26 doc, err := html.Parse(os.Stdin)27 if err != nil {28 fmt.Fprintf(os.Stderr, "findlinks1: %v29 os.Exit(1)30 }31 for _, link := range visit(nil, doc) {32 fmt.Println(link)33 }34}35func visit(links []string, n *html.Node) []string {36 if n.Type == html.ElementNode && n.Data == "a" {37 for _, a := range n.Attr {38 if a.Key == "href" {39 links = append(links, a.Val)40 }41 }42 }43 for c := n.FirstChild; c != nil; c = c.NextSibling {44 links = visit(links, c)45 }46}47import (48func main() {49 doc, err := html.Parse(os.Stdin)50 if err != nil {51 fmt.Fprintf(os.Stderr, "findlinks1: %v
Automation Testing Tutorials
Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.
LambdaTest Learning Hubs:
- JUnit Tutorial
- TestNG Tutorial
- Webdriver Tutorial
- WebDriverIO Tutorial
- Protractor Tutorial
- Selenium 4 Tutorial
- Jenkins Tutorial
- NUnit Tutorial
- Jest Tutorial
- Playwright Tutorial
- Cypress Tutorial
- PyTest Tutorial
YouTube
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Run K6 automation tests on LambdaTest cloud grid
Perform automation testing on 3000+ real desktop and mobile devices online.
Most used method in
- TestGenElementsTestTextProperties
- TestGenElementsBoolProperties
- TestGenElementsIntProperties
- TestGenElementsNullProperties
- TestGenElementsURLProperties
- TestElements
- New
- Exports
- NewModuleInstance
- ParseHTML
- emptySelection
- buildMatcher
- varargFnCall
- adjacent
- adjacentUntil
- Add
- Find
- Closest
- Has
- Not
- Next
- NextAll
- Prev
- PrevAll
- Parent
- Parents
- Siblings
- PrevUntil
- NextUntil
- ParentsUntil
- Size
- End
- Eq
- First
- Last
- Contents
- Text
- Attr
- Html
- Val
- Children
- Each
- Filter
- Is
- Map
- Slice
- Get
- ToArray
- Index
- Data
- hrefURL
- Hash
- Host
- Hostname
- Port
- Username
- Password
- Origin
- Pathname
- Protocol
- RelList
- Search
- Form
- formOrElemAttr
- FormAction
- FormEnctype
- FormMethod
- FormNoValidate
- FormTarget
- Labels
- Name
- Value
- Width
- Height
- Options
- Type
- Elements
- Validity
- Length
- Method
- List
- Control
- Areas
- Images
- Disabled
- Label
- DefaultValue
- Max
- calcProgress
- Position
- SelectedIndex
- SelectedOptions
- FirstChild
- Caption
- THead
- TFoot
- Rows
- TBodies
- CellIndex
- Cells
- RowIndex
- SectionRowIndex
- Span
- TextTracks
- TestSerialize
- selToElement
- Download
- ReferrerPolicy
- Rel
- Href
- Target
- AccessKey
- Hreflang
- ToString
- Autoplay
- Controls
- Loop
- Muted
- Preload
- Src
- CrossOrigin
- CurrentSrc
- DefaultMuted
- MediaGroup
- Autofocus
- TabIndex
- Action
- Enctype
- Encoding
- AcceptCharset
- Autocomplete
- NoValidate
- Allowfullscreen
- Sizes
- Srcset
- Alt
- IsMap
- UseMap
- Required
- Checked
- DefaultChecked
- Accept
- MaxLength
- Pattern
- Placeholder
- ReadOnly
- Min
- DirName
- Multiple
- Step
- Challenge
- Keytype
- HtmlFor
- Media
- Content
- HttpEquiv
- High
- Low
- Optimum
- Cite
- Datetime
- TypeMustMatch
- Reversed
- Start
- DefaultSelected
- Selected
- Charset
- Async
- Defer
- NoModule
- KeySystem
- Sortable
- ColSpan
- RowSpan
- Headers
- Abbr
- Scope
- Sorted
- Cols
- Autocapitalize
- Wrap
- Kind
- Srclang
- Default
- getTestModuleInstance
- getTestRuntimeAndModuleInstanceWithDoc
- getTestRuntimeWithDoc
- TestParseHTML
- SerializeArray
- SerializeObject
- Serialize
- attrAsString
- resolveURL
- attrAsURL
- attrAsURLString
- attrAsInt
- attrIsPresent
- ownerFormSel
- ownerFormVal
- elemLabels
- splitAttr
- idOrNameAttr
- Prefix
- namespaceURI
- LocalName
- GetAttribute
- GetAttributeNode
- HasAttribute
- HasAttributes
- Attributes
- HasChildNodes
- TextContent
- Id
- IsEqualNode
- IsSameNode
- GetElementsByClassName
- GetElementsByTagName
- QuerySelector
- QuerySelectorAll
- NodeName
- LastChild
- FirstElementChild
- LastElementChild
- PreviousSibling
- NextSibling
- PreviousElementSibling
- NextElementSibling
- ParentNode
- ParentElement
- ChildNodes
- ChildElementCount
- ClassList
- ClassName
- Lang
- OwnerDocument
- IsDefaultNamespace
- getOwnerDocNode
- InnerHTML
- NodeType
- NodeValue
- Contains
- Matches
- TestElement
- attrToProperty
- propertyToAttr
- valueOrHTML
- getHTMLAttr
- elemList
- nodeToElement
- toNumeric
- convertDataAttrVal
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
