_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q178900 | ParseInLocation | test | func ParseInLocation(loc *time.Location, strs ...string) (time.Time, error) {
return New(time.Now().In(loc)).Parse(strs...)
} | go | {
"resource": ""
} |
q178901 | MustParse | test | func MustParse(strs ...string) time.Time {
return New(time.Now()).MustParse(strs...)
} | go | {
"resource": ""
} |
q178902 | MustParseInLocation | test | func MustParseInLocation(loc *time.Location, strs ...string) time.Time {
return New(time.Now().In(loc)).MustParse(strs...)
} | go | {
"resource": ""
} |
q178903 | Between | test | func Between(time1, time2 string) bool {
return New(time.Now()).Between(time1, time2)
} | go | {
"resource": ""
} |
q178904 | NewChannelMemoryBackend | test | func NewChannelMemoryBackend(size int) *ChannelMemoryBackend {
backend := &ChannelMemoryBackend{
maxSize: size,
incoming: make(chan *Record, 1024),
events: make(chan event),
}
backend.Start()
return backend
} | go | {
"resource": ""
} |
q178905 | Start | test | func (b *ChannelMemoryBackend) Start() {
b.mu.Lock()
defer b.mu.Unlock()
// Launch the goroutine unless it's already running.
if b.running != true {
b.running = true
b.stopWg.Add(1)
go b.process()
}
} | go | {
"resource": ""
} |
q178906 | Flush | test | func (b *ChannelMemoryBackend) Flush() {
b.flushWg.Add(1)
b.events <- eventFlush
b.flushWg.Wait()
} | go | {
"resource": ""
} |
q178907 | Stop | test | func (b *ChannelMemoryBackend) Stop() {
b.mu.Lock()
if b.running == true {
b.running = false
b.events <- eventStop
}
b.mu.Unlock()
b.stopWg.Wait()
} | go | {
"resource": ""
} |
q178908 | Formatted | test | func (r *Record) Formatted(calldepth int) string {
if r.formatted == "" {
var buf bytes.Buffer
r.formatter.Format(calldepth+1, r, &buf)
r.formatted = buf.String()
}
return r.formatted
} | go | {
"resource": ""
} |
q178909 | Message | test | func (r *Record) Message() string {
if r.message == nil {
// Redact the arguments that implements the Redactor interface
for i, arg := range r.Args {
if redactor, ok := arg.(Redactor); ok == true {
r.Args[i] = redactor.Redacted()
}
}
var buf bytes.Buffer
if r.fmt != nil {
fmt.Fprintf(&buf, *r.fm... | go | {
"resource": ""
} |
q178910 | SetBackend | test | func (l *Logger) SetBackend(backend LeveledBackend) {
l.backend = backend
l.haveBackend = true
} | go | {
"resource": ""
} |
q178911 | MustGetLogger | test | func MustGetLogger(module string) *Logger {
logger, err := GetLogger(module)
if err != nil {
panic("logger: " + module + ": " + err.Error())
}
return logger
} | go | {
"resource": ""
} |
q178912 | Reset | test | func Reset() {
// TODO make a global Init() method to be less magic? or make it such that
// if there's no backends at all configured, we could use some tricks to
// automatically setup backends based if we have a TTY or not.
sequenceNo = 0
b := SetBackend(NewLogBackend(os.Stderr, "", log.LstdFlags))
b.SetLevel(D... | go | {
"resource": ""
} |
q178913 | IsEnabledFor | test | func (l *Logger) IsEnabledFor(level Level) bool {
return defaultBackend.IsEnabledFor(level, l.Module)
} | go | {
"resource": ""
} |
q178914 | Criticalf | test | func (l *Logger) Criticalf(format string, args ...interface{}) {
l.log(CRITICAL, &format, args...)
} | go | {
"resource": ""
} |
q178915 | Warningf | test | func (l *Logger) Warningf(format string, args ...interface{}) {
l.log(WARNING, &format, args...)
} | go | {
"resource": ""
} |
q178916 | Noticef | test | func (l *Logger) Noticef(format string, args ...interface{}) {
l.log(NOTICE, &format, args...)
} | go | {
"resource": ""
} |
q178917 | Infof | test | func (l *Logger) Infof(format string, args ...interface{}) {
l.log(INFO, &format, args...)
} | go | {
"resource": ""
} |
q178918 | SetFormatter | test | func SetFormatter(f Formatter) {
formatter.Lock()
defer formatter.Unlock()
formatter.def = f
} | go | {
"resource": ""
} |
q178919 | MustStringFormatter | test | func MustStringFormatter(format string) Formatter {
f, err := NewStringFormatter(format)
if err != nil {
panic("Failed to initialized string formatter: " + err.Error())
}
return f
} | go | {
"resource": ""
} |
q178920 | formatFuncName | test | func formatFuncName(v fmtVerb, f string) string {
i := strings.LastIndex(f, "/")
j := strings.Index(f[i+1:], ".")
if j < 1 {
return "???"
}
pkg, fun := f[:i+j+1], f[i+j+2:]
switch v {
case fmtVerbLongpkg:
return pkg
case fmtVerbShortpkg:
return path.Base(pkg)
case fmtVerbLongfunc:
return fun
case fmtV... | go | {
"resource": ""
} |
q178921 | Log | test | func (bf *backendFormatter) Log(level Level, calldepth int, r *Record) error {
// Make a shallow copy of the record and replace any formatter
r2 := *r
r2.formatter = bf.f
return bf.b.Log(level, calldepth+1, &r2)
} | go | {
"resource": ""
} |
q178922 | LogLevel | test | func LogLevel(level string) (Level, error) {
for i, name := range levelNames {
if strings.EqualFold(name, level) {
return Level(i), nil
}
}
return ERROR, ErrInvalidLogLevel
} | go | {
"resource": ""
} |
q178923 | AddModuleLevel | test | func AddModuleLevel(backend Backend) LeveledBackend {
var leveled LeveledBackend
var ok bool
if leveled, ok = backend.(LeveledBackend); !ok {
leveled = &moduleLeveled{
levels: make(map[string]Level),
backend: backend,
}
}
return leveled
} | go | {
"resource": ""
} |
q178924 | GetLevel | test | func (l *moduleLeveled) GetLevel(module string) Level {
level, exists := l.levels[module]
if exists == false {
level, exists = l.levels[""]
// no configuration exists, default to debug
if exists == false {
level = DEBUG
}
}
return level
} | go | {
"resource": ""
} |
q178925 | SetLevel | test | func (l *moduleLeveled) SetLevel(level Level, module string) {
l.levels[module] = level
} | go | {
"resource": ""
} |
q178926 | IsEnabledFor | test | func (l *moduleLeveled) IsEnabledFor(level Level, module string) bool {
return level <= l.GetLevel(module)
} | go | {
"resource": ""
} |
q178927 | MultiLogger | test | func MultiLogger(backends ...Backend) LeveledBackend {
var leveledBackends []LeveledBackend
for _, backend := range backends {
leveledBackends = append(leveledBackends, AddModuleLevel(backend))
}
return &multiLogger{leveledBackends}
} | go | {
"resource": ""
} |
q178928 | Log | test | func (b *multiLogger) Log(level Level, calldepth int, rec *Record) (err error) {
for _, backend := range b.backends {
if backend.IsEnabledFor(level, rec.Module) {
// Shallow copy of the record for the formatted cache on Record and get the
// record formatter from the backend.
r2 := *rec
if e := backend.L... | go | {
"resource": ""
} |
q178929 | GetLevel | test | func (b *multiLogger) GetLevel(module string) Level {
var level Level
for _, backend := range b.backends {
if backendLevel := backend.GetLevel(module); backendLevel > level {
level = backendLevel
}
}
return level
} | go | {
"resource": ""
} |
q178930 | SetLevel | test | func (b *multiLogger) SetLevel(level Level, module string) {
for _, backend := range b.backends {
backend.SetLevel(level, module)
}
} | go | {
"resource": ""
} |
q178931 | IsEnabledFor | test | func (b *multiLogger) IsEnabledFor(level Level, module string) bool {
for _, backend := range b.backends {
if backend.IsEnabledFor(level, module) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q178932 | ConvertColors | test | func ConvertColors(colors []int, bold bool) []string {
converted := []string{}
for _, i := range colors {
if bold {
converted = append(converted, ColorSeqBold(color(i)))
} else {
converted = append(converted, ColorSeq(color(i)))
}
}
return converted
} | go | {
"resource": ""
} |
q178933 | NewSyslogBackend | test | func NewSyslogBackend(prefix string) (b *SyslogBackend, err error) {
var w *syslog.Writer
w, err = syslog.New(syslog.LOG_CRIT, prefix)
return &SyslogBackend{w}, err
} | go | {
"resource": ""
} |
q178934 | NewSyslogBackendPriority | test | func NewSyslogBackendPriority(prefix string, priority syslog.Priority) (b *SyslogBackend, err error) {
var w *syslog.Writer
w, err = syslog.New(priority, prefix)
return &SyslogBackend{w}, err
} | go | {
"resource": ""
} |
q178935 | SetBackend | test | func SetBackend(backends ...Backend) LeveledBackend {
var backend Backend
if len(backends) == 1 {
backend = backends[0]
} else {
backend = MultiLogger(backends...)
}
defaultBackend = AddModuleLevel(backend)
return defaultBackend
} | go | {
"resource": ""
} |
q178936 | NewCommander | test | func NewCommander(topLevelFlags *flag.FlagSet, name string) *Commander {
cdr := &Commander{
topFlags: topLevelFlags,
name: name,
Output: os.Stdout,
Error: os.Stderr,
}
topLevelFlags.Usage = func() { cdr.explain(cdr.Error) }
return cdr
} | go | {
"resource": ""
} |
q178937 | Execute | test | func (cdr *Commander) Execute(ctx context.Context, args ...interface{}) ExitStatus {
if cdr.topFlags.NArg() < 1 {
cdr.topFlags.Usage()
return ExitUsageError
}
name := cdr.topFlags.Arg(0)
for _, group := range cdr.commands {
for _, cmd := range group.commands {
if name != cmd.Name() {
continue
}
... | go | {
"resource": ""
} |
q178938 | explain | test | func (cdr *Commander) explain(w io.Writer) {
fmt.Fprintf(w, "Usage: %s <flags> <subcommand> <subcommand args>\n\n", cdr.name)
sort.Sort(byGroupName(cdr.commands))
for _, group := range cdr.commands {
explainGroup(w, group)
}
if cdr.topFlags == nil {
fmt.Fprintln(w, "\nNo top level flags.")
return
}
if len(... | go | {
"resource": ""
} |
q178939 | explainGroup | test | func explainGroup(w io.Writer, group *commandGroup) {
if len(group.commands) == 0 {
return
}
if group.name == "" {
fmt.Fprintf(w, "Subcommands:\n")
} else {
fmt.Fprintf(w, "Subcommands for %s:\n", group.name)
}
sort.Sort(group)
aliases := make(map[string][]string)
for _, cmd := range group.commands {
i... | go | {
"resource": ""
} |
q178940 | explain | test | func explain(w io.Writer, cmd Command) {
fmt.Fprintf(w, "%s", cmd.Usage())
subflags := flag.NewFlagSet(cmd.Name(), flag.PanicOnError)
subflags.SetOutput(w)
cmd.SetFlags(subflags)
subflags.PrintDefaults()
} | go | {
"resource": ""
} |
q178941 | dealias | test | func dealias(cmd Command) Command {
if alias, ok := cmd.(*aliaser); ok {
return dealias(alias.Command)
}
return cmd
} | go | {
"resource": ""
} |
q178942 | Execute | test | func Execute(ctx context.Context, args ...interface{}) ExitStatus {
return DefaultCommander.Execute(ctx, args...)
} | go | {
"resource": ""
} |
q178943 | LoadFromData | test | func LoadFromData(data []byte) (c *ConfigFile, err error) {
// Save memory data to temporary file to support further operations.
tmpName := path.Join(os.TempDir(), "goconfig", fmt.Sprintf("%d", time.Now().Nanosecond()))
if err = os.MkdirAll(path.Dir(tmpName), os.ModePerm); err != nil {
return nil, err
}
if err =... | go | {
"resource": ""
} |
q178944 | LoadFromReader | test | func LoadFromReader(in io.Reader) (c *ConfigFile, err error) {
c = newConfigFile([]string{""})
err = c.read(in)
return c, err
} | go | {
"resource": ""
} |
q178945 | ReloadData | test | func (c *ConfigFile) ReloadData(in io.Reader) (err error) {
var cfg *ConfigFile
if len(c.fileNames) != 1 {
return fmt.Errorf("Multiple files loaded, unable to mix in-memory and file data")
}
cfg, err = LoadFromReader(in)
if err == nil {
*c = *cfg
}
return err
} | go | {
"resource": ""
} |
q178946 | AppendFiles | test | func (c *ConfigFile) AppendFiles(files ...string) error {
if len(c.fileNames) == 1 && c.fileNames[0] == "" {
return fmt.Errorf("Cannot append file data to in-memory data")
}
c.fileNames = append(c.fileNames, files...)
return c.Reload()
} | go | {
"resource": ""
} |
q178947 | GetKeyList | test | func (c *ConfigFile) GetKeyList(section string) []string {
// Blank section name represents DEFAULT section.
if len(section) == 0 {
section = DEFAULT_SECTION
}
if c.BlockMode {
c.lock.RLock()
defer c.lock.RUnlock()
}
// Check if section exists.
if _, ok := c.data[section]; !ok {
return nil
}
// Non-... | go | {
"resource": ""
} |
q178948 | SaveConfigData | test | func SaveConfigData(c *ConfigFile, out io.Writer) (err error) {
equalSign := "="
if PrettyFormat {
equalSign = " = "
}
buf := bytes.NewBuffer(nil)
for _, section := range c.sectionList {
// Write section comments.
if len(c.GetSectionComments(section)) > 0 {
if _, err = buf.WriteString(c.GetSectionComment... | go | {
"resource": ""
} |
q178949 | SaveConfigFile | test | func SaveConfigFile(c *ConfigFile, filename string) (err error) {
// Write configuration file by filename.
var f *os.File
if f, err = os.Create(filename); err != nil {
return err
}
if err := SaveConfigData(c, f); err != nil {
return err
}
return f.Close()
} | go | {
"resource": ""
} |
q178950 | Find | test | func (s *selectable) Find(selector string) *Selection {
return newSelection(s.session, s.selectors.Append(target.CSS, selector).Single())
} | go | {
"resource": ""
} |
q178951 | FindByXPath | test | func (s *selectable) FindByXPath(selector string) *Selection {
return newSelection(s.session, s.selectors.Append(target.XPath, selector).Single())
} | go | {
"resource": ""
} |
q178952 | FindByLink | test | func (s *selectable) FindByLink(text string) *Selection {
return newSelection(s.session, s.selectors.Append(target.Link, text).Single())
} | go | {
"resource": ""
} |
q178953 | FindByLabel | test | func (s *selectable) FindByLabel(text string) *Selection {
return newSelection(s.session, s.selectors.Append(target.Label, text).Single())
} | go | {
"resource": ""
} |
q178954 | FindByName | test | func (s *selectable) FindByName(name string) *Selection {
return newSelection(s.session, s.selectors.Append(target.Name, name).Single())
} | go | {
"resource": ""
} |
q178955 | FindByClass | test | func (s *selectable) FindByClass(text string) *Selection {
return newSelection(s.session, s.selectors.Append(target.Class, text).Single())
} | go | {
"resource": ""
} |
q178956 | FindByID | test | func (s *selectable) FindByID(id string) *Selection {
return newSelection(s.session, s.selectors.Append(target.ID, id).Single())
} | go | {
"resource": ""
} |
q178957 | First | test | func (s *selectable) First(selector string) *Selection {
return newSelection(s.session, s.selectors.Append(target.CSS, selector).At(0))
} | go | {
"resource": ""
} |
q178958 | FirstByXPath | test | func (s *selectable) FirstByXPath(selector string) *Selection {
return newSelection(s.session, s.selectors.Append(target.XPath, selector).At(0))
} | go | {
"resource": ""
} |
q178959 | FirstByLink | test | func (s *selectable) FirstByLink(text string) *Selection {
return newSelection(s.session, s.selectors.Append(target.Link, text).At(0))
} | go | {
"resource": ""
} |
q178960 | FirstByLabel | test | func (s *selectable) FirstByLabel(text string) *Selection {
return newSelection(s.session, s.selectors.Append(target.Label, text).At(0))
} | go | {
"resource": ""
} |
q178961 | FirstByName | test | func (s *selectable) FirstByName(name string) *Selection {
return newSelection(s.session, s.selectors.Append(target.Name, name).At(0))
} | go | {
"resource": ""
} |
q178962 | All | test | func (s *selectable) All(selector string) *MultiSelection {
return newMultiSelection(s.session, s.selectors.Append(target.CSS, selector))
} | go | {
"resource": ""
} |
q178963 | AllByXPath | test | func (s *selectable) AllByXPath(selector string) *MultiSelection {
return newMultiSelection(s.session, s.selectors.Append(target.XPath, selector))
} | go | {
"resource": ""
} |
q178964 | AllByLink | test | func (s *selectable) AllByLink(text string) *MultiSelection {
return newMultiSelection(s.session, s.selectors.Append(target.Link, text))
} | go | {
"resource": ""
} |
q178965 | AllByLabel | test | func (s *selectable) AllByLabel(text string) *MultiSelection {
return newMultiSelection(s.session, s.selectors.Append(target.Label, text))
} | go | {
"resource": ""
} |
q178966 | AllByName | test | func (s *selectable) AllByName(name string) *MultiSelection {
return newMultiSelection(s.session, s.selectors.Append(target.Name, name))
} | go | {
"resource": ""
} |
q178967 | AllByClass | test | func (s *selectable) AllByClass(text string) *MultiSelection {
return newMultiSelection(s.session, s.selectors.Append(target.Class, text))
} | go | {
"resource": ""
} |
q178968 | AllByID | test | func (s *selectable) AllByID(text string) *MultiSelection {
return newMultiSelection(s.session, s.selectors.Append(target.ID, text))
} | go | {
"resource": ""
} |
q178969 | FindForAppium | test | func (s *selectable) FindForAppium(selectorType string, text string) *Selection {
return newSelection(s.session, s.selectors.Append(target.Class, text).At(0))
} | go | {
"resource": ""
} |
q178970 | Timeout | test | func Timeout(seconds int) Option {
return func(c *config) {
c.Timeout = time.Duration(seconds) * time.Second
}
} | go | {
"resource": ""
} |
q178971 | ChromeOptions | test | func ChromeOptions(opt string, value interface{}) Option {
return func(c *config) {
if c.ChromeOptions == nil {
c.ChromeOptions = make(map[string]interface{})
}
c.ChromeOptions[opt] = value
}
} | go | {
"resource": ""
} |
q178972 | JoinPage | test | func JoinPage(url string, options ...Option) *Page {
pageOptions := config{}.Merge(options)
session := api.NewWithClient(url, pageOptions.HTTPClient)
return newPage(session)
} | go | {
"resource": ""
} |
q178973 | Destroy | test | func (p *Page) Destroy() error {
if err := p.session.Delete(); err != nil {
return fmt.Errorf("failed to destroy session: %s", err)
}
return nil
} | go | {
"resource": ""
} |
q178974 | Reset | test | func (p *Page) Reset() error {
p.ConfirmPopup()
url, err := p.URL()
if err != nil {
return err
}
if url == "about:blank" {
return nil
}
if err := p.ClearCookies(); err != nil {
return err
}
if err := p.session.DeleteLocalStorage(); err != nil {
if err := p.RunScript("localStorage.clear();", nil, nil... | go | {
"resource": ""
} |
q178975 | Navigate | test | func (p *Page) Navigate(url string) error {
if err := p.session.SetURL(url); err != nil {
return fmt.Errorf("failed to navigate: %s", err)
}
return nil
} | go | {
"resource": ""
} |
q178976 | GetCookies | test | func (p *Page) GetCookies() ([]*http.Cookie, error) {
apiCookies, err := p.session.GetCookies()
if err != nil {
return nil, fmt.Errorf("failed to get cookies: %s", err)
}
cookies := []*http.Cookie{}
for _, apiCookie := range apiCookies {
expSeconds := int64(apiCookie.Expiry)
expNano := int64(apiCookie.Expiry... | go | {
"resource": ""
} |
q178977 | SetCookie | test | func (p *Page) SetCookie(cookie *http.Cookie) error {
if cookie == nil {
return errors.New("nil cookie is invalid")
}
var expiry int64
if !cookie.Expires.IsZero() {
expiry = cookie.Expires.Unix()
}
apiCookie := &api.Cookie{
Name: cookie.Name,
Value: cookie.Value,
Path: cookie.Path,
Domain... | go | {
"resource": ""
} |
q178978 | DeleteCookie | test | func (p *Page) DeleteCookie(name string) error {
if err := p.session.DeleteCookie(name); err != nil {
return fmt.Errorf("failed to delete cookie %s: %s", name, err)
}
return nil
} | go | {
"resource": ""
} |
q178979 | ClearCookies | test | func (p *Page) ClearCookies() error {
if err := p.session.DeleteCookies(); err != nil {
return fmt.Errorf("failed to clear cookies: %s", err)
}
return nil
} | go | {
"resource": ""
} |
q178980 | URL | test | func (p *Page) URL() (string, error) {
url, err := p.session.GetURL()
if err != nil {
return "", fmt.Errorf("failed to retrieve URL: %s", err)
}
return url, nil
} | go | {
"resource": ""
} |
q178981 | Size | test | func (p *Page) Size(width, height int) error {
window, err := p.session.GetWindow()
if err != nil {
return fmt.Errorf("failed to retrieve window: %s", err)
}
if err := window.SetSize(width, height); err != nil {
return fmt.Errorf("failed to set window size: %s", err)
}
return nil
} | go | {
"resource": ""
} |
q178982 | Screenshot | test | func (p *Page) Screenshot(filename string) error {
absFilePath, err := filepath.Abs(filename)
if err != nil {
return fmt.Errorf("failed to find absolute path for filename: %s", err)
}
screenshot, err := p.session.GetScreenshot()
if err != nil {
return fmt.Errorf("failed to retrieve screenshot: %s", err)
}
... | go | {
"resource": ""
} |
q178983 | Title | test | func (p *Page) Title() (string, error) {
title, err := p.session.GetTitle()
if err != nil {
return "", fmt.Errorf("failed to retrieve page title: %s", err)
}
return title, nil
} | go | {
"resource": ""
} |
q178984 | HTML | test | func (p *Page) HTML() (string, error) {
html, err := p.session.GetSource()
if err != nil {
return "", fmt.Errorf("failed to retrieve page HTML: %s", err)
}
return html, nil
} | go | {
"resource": ""
} |
q178985 | PopupText | test | func (p *Page) PopupText() (string, error) {
text, err := p.session.GetAlertText()
if err != nil {
return "", fmt.Errorf("failed to retrieve popup text: %s", err)
}
return text, nil
} | go | {
"resource": ""
} |
q178986 | EnterPopupText | test | func (p *Page) EnterPopupText(text string) error {
if err := p.session.SetAlertText(text); err != nil {
return fmt.Errorf("failed to enter popup text: %s", err)
}
return nil
} | go | {
"resource": ""
} |
q178987 | ConfirmPopup | test | func (p *Page) ConfirmPopup() error {
if err := p.session.AcceptAlert(); err != nil {
return fmt.Errorf("failed to confirm popup: %s", err)
}
return nil
} | go | {
"resource": ""
} |
q178988 | CancelPopup | test | func (p *Page) CancelPopup() error {
if err := p.session.DismissAlert(); err != nil {
return fmt.Errorf("failed to cancel popup: %s", err)
}
return nil
} | go | {
"resource": ""
} |
q178989 | SwitchToParentFrame | test | func (p *Page) SwitchToParentFrame() error {
if err := p.session.FrameParent(); err != nil {
return fmt.Errorf("failed to switch to parent frame: %s", err)
}
return nil
} | go | {
"resource": ""
} |
q178990 | SwitchToRootFrame | test | func (p *Page) SwitchToRootFrame() error {
if err := p.session.Frame(nil); err != nil {
return fmt.Errorf("failed to switch to original page frame: %s", err)
}
return nil
} | go | {
"resource": ""
} |
q178991 | NextWindow | test | func (p *Page) NextWindow() error {
windows, err := p.session.GetWindows()
if err != nil {
return fmt.Errorf("failed to find available windows: %s", err)
}
var windowIDs []string
for _, window := range windows {
windowIDs = append(windowIDs, window.ID)
}
// order not defined according to W3 spec
sort.Stri... | go | {
"resource": ""
} |
q178992 | CloseWindow | test | func (p *Page) CloseWindow() error {
if err := p.session.DeleteWindow(); err != nil {
return fmt.Errorf("failed to close active window: %s", err)
}
return nil
} | go | {
"resource": ""
} |
q178993 | WindowCount | test | func (p *Page) WindowCount() (int, error) {
windows, err := p.session.GetWindows()
if err != nil {
return 0, fmt.Errorf("failed to find available windows: %s", err)
}
return len(windows), nil
} | go | {
"resource": ""
} |
q178994 | LogTypes | test | func (p *Page) LogTypes() ([]string, error) {
types, err := p.session.GetLogTypes()
if err != nil {
return nil, fmt.Errorf("failed to retrieve log types: %s", err)
}
return types, nil
} | go | {
"resource": ""
} |
q178995 | MoveMouseBy | test | func (p *Page) MoveMouseBy(xOffset, yOffset int) error {
if err := p.session.MoveTo(nil, api.XYOffset{X: xOffset, Y: yOffset}); err != nil {
return fmt.Errorf("failed to move mouse: %s", err)
}
return nil
} | go | {
"resource": ""
} |
q178996 | DoubleClick | test | func (p *Page) DoubleClick() error {
if err := p.session.DoubleClick(); err != nil {
return fmt.Errorf("failed to double click: %s", err)
}
return nil
} | go | {
"resource": ""
} |
q178997 | Click | test | func (p *Page) Click(event Click, button Button) error {
var err error
switch event {
case SingleClick:
err = p.session.Click(api.Button(button))
case HoldClick:
err = p.session.ButtonDown(api.Button(button))
case ReleaseClick:
err = p.session.ButtonUp(api.Button(button))
default:
err = errors.New("invali... | go | {
"resource": ""
} |
q178998 | Click | test | func (s *Selection) Click() error {
return s.forEachElement(func(selectedElement element.Element) error {
if err := selectedElement.Click(); err != nil {
return fmt.Errorf("failed to click on %s: %s", s, err)
}
return nil
})
} | go | {
"resource": ""
} |
q178999 | DoubleClick | test | func (s *Selection) DoubleClick() error {
return s.forEachElement(func(selectedElement element.Element) error {
if err := s.session.MoveTo(selectedElement.(*api.Element), nil); err != nil {
return fmt.Errorf("failed to move mouse to %s: %s", s, err)
}
if err := s.session.DoubleClick(); err != nil {
return ... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.