def html = html(writer.toString());
        then:
        html.select("div#tabs > ul > li > a").find { it.text() == "tab 1" }
        html.select("div#tabs > ul > li > a").find { it.text() == "tab 2" }

        html.select("div#tabs > div#tab0 > h2").find { it.text() == "tab 1" }
        html.select("div#tabs > div#tab1 > h2").find { it.text() == "tab 2" }
    }

    Document html(String renderedString) {

                }
            }
            """,
        "select 1.1": """{ ComponentSelection selection ->
                if (selection.candidate.version != '1.1') {
                    selection.reject("not 1.1")
                }
                candidates << selection.candidate.version
            }
            """,
        "select 2.0": """{ ComponentSelection selection ->

	var total int
	if err := DB.Model(&User{}).Select("name, sum(age)").Where("name = ?", "groupby").Group("name").Row().Scan(&name, &total); err != nil {
		t.Errorf("no error should happen, but got %v", err)
	}

	if name != "groupby" || total != 60 {
		t.Errorf("name should be groupby, but got %v, total should be 60, but got %v", name, total)
	}

	if ciCtx, is := ci.(driver.ConnPrepareContext); is {
		return ciCtx.PrepareContext(ctx, query)
	}
	si, err := ci.Prepare(query)
	if err == nil {
		select {
		default:
		case <-ctx.Done():
			si.Close()
			return nil, ctx.Err()
		}
	}
	return si, err
}

		if gotRemove != file {
			t.Fatalf("Remove() failed: got %v want %v", gotRemove, file)
		}
		select {
		case <-addedChan:
			t.Fatal("Remove() failed: callback invoked with added=false")
		default:
		}

		wantEvent = fsnotify.Event{Name: file, Op: fsnotify.Write}
		fakeWatcher.InjectEvent(file, wantEvent)
		select {
		case gotEvent := <-watcher.Events(file):
			t.Fatalf("Unexpected Events() after Remove(): got %v", gotEvent)

/**
 * The specification of a dependency variant. Some dependencies can be fined tuned
 * to select a particular variant. For example, one might want to select the test
 * fixtures of a target component, or a specific classifier.
 *
 * @since 6.8
 */
public interface ExternalModuleDependencyVariantSpec {
    /**
     * Configures the dependency to select the "platform" variant.
     */
    void platform();

    /**

	var storeNumber []int32

	// Compute map from a value to the SelectN [1] value that uses it.
	select1 := f.Cache.allocValueSlice(f.NumValues())
	defer func() { f.Cache.freeValueSlice(select1) }()
	for _, b := range f.Blocks {
		for _, v := range b.Values {
			if v.Op != OpSelectN {
				continue
			}
			if v.AuxInt != 1 {
				continue
			}
			select1[v.Args[0].ID] = v
		}
	}

		clauses := []clause.Interface{clause.Select{}, clause.From{}, clause.Where{Exprs: []clause.Expression{clause.Eq{Column: clause.PrimaryColumn, Value: "1"}, clause.Gt{Column: "age", Value: 18}, clause.Or(clause.Neq{Column: "name", Value: "jinzhu"})}}}

		for _, clause := range clauses {
			stmt.AddClause(clause)
		}

		stmt.Build("SELECT", "FROM", "WHERE")
		_ = stmt.SQL.String()
	}
}

	// wasm:"Select"
	return x
}

func cmov32bit(x, y uint32) uint32 {
	if x < y {
		x = -y
	}
	// amd64:"CMOVL(HI|CS)"
	// arm64:"CSNEG\t(LS|HS)"
	// ppc64x:"ISEL\t[$]1"
	// wasm:"Select"
	return x
}

func cmov16bit(x, y uint16) uint16 {
	if x < y {
		x = -y
	}
	// amd64:"CMOVW(HI|CS)"
	// arm64:"CSNEG\t(LS|HS)"
	// ppc64x:"ISEL\t[$][01]"
	// wasm:"Select"
	return x
}

	aux := make(chan bool)
	data := 0
	_ = data
	go func() {
		select {
		case mtx <- struct{}{}:
		case <-aux:
		}
		data = 42
		select {
		case <-mtx:
		case <-aux:
		}
		done <- struct{}{}
	}()
	select {
	case mtx <- struct{}{}:
	case <-aux:
	}
	data = 43
	select {
	case <-mtx:
	case <-aux:
	}
	<-done
}