30240283751

Committed 27 Jul 2026 05:37AM UTC coverage: 59.896% (-0.02%) from 59.912%

Build # 30240283751

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #6440 from toaster/lint/trivial_checks

enable a couple of linter checks which only require trivial adjustments

Coverage Stats

589 of 969 new or added lines in 144 files covered. (60.78%)

14 existing lines in 10 files now uncovered.

27103 of 45250 relevant lines covered (59.9%)

815.37 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

51.0

/test/driver.go

package test

import (
        "sync"
        "time"

        "fyne.io/fyne/v2"
        fynedriver "fyne.io/fyne/v2/driver"
        intdriver "fyne.io/fyne/v2/internal/driver"
        "fyne.io/fyne/v2/internal/painter"
        "fyne.io/fyne/v2/internal/painter/software"
        intRepo "fyne.io/fyne/v2/internal/repository"
        "fyne.io/fyne/v2/storage/repository"
)

// SoftwarePainter describes a simple type that can render canvases
//
// Deprecated: Use driver.Painter instead.
type SoftwarePainter = fynedriver.Painter

type driver struct {
        device       device
        painter      fynedriver.Painter
        windows      []fyne.Window
        windowsMutex sync.RWMutex
}

// Declare conformity with Driver
var _ fyne.Driver = (*driver)(nil)

// NewDriver sets up and registers a new dummy driver for test purpose
func NewDriver() fyne.Driver {
        drv := &driver{windowsMutex: sync.RWMutex{}}
        repository.Register("file", intRepo.NewFileRepository())

        httpHandler := intRepo.NewHTTPRepository()
        repository.Register("http", httpHandler)
        repository.Register("https", httpHandler)

        // make a single dummy window for rendering tests
        drv.CreateWindow("")

        return drv
}

// NewDriverWithPainter creates a new dummy driver that will pass the given
// painter to all canvases created
func NewDriverWithPainter(p fynedriver.Painter) fyne.Driver {
        return &driver{painter: p}
}

// DoFromGoroutine on a test driver ignores the wait flag as our threading is simple
func (*driver) DoFromGoroutine(f func(), _ bool) {
        // Tests all run on a single (but potentially different per-test) thread
        f()
}

func (d *driver) AbsolutePositionForObject(co fyne.CanvasObject) fyne.Position {
        c := d.CanvasForObject(co)
        if c == nil {
                return fyne.NewPos(0, 0)
        }

        overlays := c.Overlays().List()
        trees := make([]fyne.CanvasObject, 0, len(overlays)+1)
        if content := c.Content(); content != nil {
                trees = append(trees, content)
        }
        trees = append(trees, overlays...)
        pos := intdriver.AbsolutePositionForObject(co, trees)
        inset, _ := c.InteractiveArea()
        return pos.Subtract(inset)
}

func (d *driver) AllWindows() []fyne.Window {
        d.windowsMutex.RLock()
        defer d.windowsMutex.RUnlock()
        return d.windows
}

func (d *driver) CanvasForObject(fyne.CanvasObject) fyne.Canvas {
        d.windowsMutex.RLock()
        defer d.windowsMutex.RUnlock()
        // cheating: probably the last created window is meant
        return d.windows[len(d.windows)-1].Canvas()
}

func (d *driver) CreateWindow(title string) fyne.Window {
        p := d.painter
        if p == nil {
                p = software.NewPainter()
        }
        c := NewCanvasWithPainter(p)
        w := &window{canvas: c, driver: d, title: title}

        d.windowsMutex.Lock()
        d.windows = append(d.windows, w)
        d.windowsMutex.Unlock()
        return w
}

func (d *driver) Device() fyne.Device {
        return &d.device
}

// RenderedTextSize looks up how bit a string would be if drawn on screen
func (*driver) RenderedTextSize(text string, size float32, style fyne.TextStyle, source fyne.Resource) (fyne.Size, float32) {
        return painter.RenderedTextSize(text, size, style, source)
}

func (*driver) Run() {
        // no-op
}

func (*driver) StartAnimation(a *fyne.Animation) {
        // currently no animations in test app, we just initialize it and leave
        if a.AutoReverse {
                a.Tick(0.0)
        } else {
                a.Tick(1.0)
        }
}

func (*driver) StopAnimation(*fyne.Animation) {
        // currently no animations in test app, do nothing
}

func (*driver) Quit() {
        // no-op
}

func (*driver) Clipboard() fyne.Clipboard {
        return nil
}

func (d *driver) removeWindow(w *window) {
        d.windowsMutex.Lock()
        i := 0
        for _, win := range d.windows {
                if win == w {
                        break
                }
                i++
        }

        copy(d.windows[i:], d.windows[i+1:])
        d.windows[len(d.windows)-1] = nil // Allow the garbage collector to reclaim the memory.
        d.windows = d.windows[:len(d.windows)-1]

        d.windowsMutex.Unlock()
}

func (*driver) DoubleTapDelay() time.Duration {
        return 300 * time.Millisecond
}

func (*driver) SetDisableScreenBlanking(_ bool) {
        // no-op for test
}

1	package test
2
3	import (
4	"sync"
5	"time"
6
7	"fyne.io/fyne/v2"
8	fynedriver "fyne.io/fyne/v2/driver"
9	intdriver "fyne.io/fyne/v2/internal/driver"
10	"fyne.io/fyne/v2/internal/painter"
11	"fyne.io/fyne/v2/internal/painter/software"
12	intRepo "fyne.io/fyne/v2/internal/repository"
13	"fyne.io/fyne/v2/storage/repository"
14	)
15
16	// SoftwarePainter describes a simple type that can render canvases
17	//
18	// Deprecated: Use driver.Painter instead.
19	type SoftwarePainter = fynedriver.Painter
20
21	type driver struct {
22	device device
23	painter fynedriver.Painter
24	windows []fyne.Window
25	windowsMutex sync.RWMutex
26	}
27
28	// Declare conformity with Driver
29	var _ fyne.Driver = (*driver)(nil)
30
31	// NewDriver sets up and registers a new dummy driver for test purpose
32	func NewDriver() fyne.Driver {	35✔
33	drv := &driver{windowsMutex: sync.RWMutex{}}	35✔
34	repository.Register("file", intRepo.NewFileRepository())	35✔
35		35✔
36	httpHandler := intRepo.NewHTTPRepository()	35✔
37	repository.Register("http", httpHandler)	35✔
38	repository.Register("https", httpHandler)	35✔
39		35✔
40	// make a single dummy window for rendering tests	35✔
41	drv.CreateWindow("")	35✔
42		35✔
43	return drv	35✔
44	}	35✔
45
46	// NewDriverWithPainter creates a new dummy driver that will pass the given
47	// painter to all canvases created
NEW 48	func NewDriverWithPainter(p fynedriver.Painter) fyne.Driver {	×
NEW 49	return &driver{painter: p}	×
UNCOV 50	}	×
51
52	// DoFromGoroutine on a test driver ignores the wait flag as our threading is simple
NEW 53	func (*driver) DoFromGoroutine(f func(), _ bool) {	×
54	// Tests all run on a single (but potentially different per-test) thread	×
55	f()	×
56	}	×
57
58	func (d *driver) AbsolutePositionForObject(co fyne.CanvasObject) fyne.Position {	2✔
59	c := d.CanvasForObject(co)	2✔
60	if c == nil {	2✔
61	return fyne.NewPos(0, 0)	×
62	}	×
63
64	overlays := c.Overlays().List()	2✔
65	trees := make([]fyne.CanvasObject, 0, len(overlays)+1)	2✔
66	if content := c.Content(); content != nil {	4✔
67	trees = append(trees, content)	2✔
68	}	2✔
69	trees = append(trees, overlays...)	2✔
70	pos := intdriver.AbsolutePositionForObject(co, trees)	2✔
71	inset, _ := c.InteractiveArea()	2✔
72	return pos.Subtract(inset)	2✔
73	}
74
75	func (d *driver) AllWindows() []fyne.Window {	2✔
76	d.windowsMutex.RLock()	2✔
77	defer d.windowsMutex.RUnlock()	2✔
78	return d.windows	2✔
79	}	2✔
80
81	func (d *driver) CanvasForObject(fyne.CanvasObject) fyne.Canvas {	245✔
82	d.windowsMutex.RLock()	245✔
83	defer d.windowsMutex.RUnlock()	245✔
84	// cheating: probably the last created window is meant	245✔
85	return d.windows[len(d.windows)-1].Canvas()	245✔
86	}	245✔
87
88	func (d *driver) CreateWindow(title string) fyne.Window {	37✔
89	p := d.painter	37✔
90	if p == nil {	74✔
91	p = software.NewPainter()	37✔
92	}	37✔
93	c := NewCanvasWithPainter(p)	37✔
94	w := &window{canvas: c, driver: d, title: title}	37✔
95		37✔
96	d.windowsMutex.Lock()	37✔
97	d.windows = append(d.windows, w)	37✔
98	d.windowsMutex.Unlock()	37✔
99	return w	37✔
100	}
101
102	func (d *driver) Device() fyne.Device {	×
103	return &d.device	×
104	}	×
105
106	// RenderedTextSize looks up how bit a string would be if drawn on screen
107	func (*driver) RenderedTextSize(text string, size float32, style fyne.TextStyle, source fyne.Resource) (fyne.Size, float32) {	15✔
108	return painter.RenderedTextSize(text, size, style, source)	15✔
109	}	15✔
110
NEW 111	func (*driver) Run() {	×
112	// no-op	×
113	}	×
114
NEW 115	func (driver) StartAnimation(a fyne.Animation) {	×
NEW 116	// currently no animations in test app, we just initialize it and leave	×
117	if a.AutoReverse {	×
118	a.Tick(0.0)	×
119	} else {	×
120	a.Tick(1.0)	×
121	}	×
122	}
123
NEW 124	func (driver) StopAnimation(fyne.Animation) {	×
125	// currently no animations in test app, do nothing	×
126	}	×
127
NEW 128	func (*driver) Quit() {	×
129	// no-op	×
130	}	×
131
NEW 132	func (*driver) Clipboard() fyne.Clipboard {	×
133	return nil	×
134	}	×
135
136	func (d driver) removeWindow(w window) {	×
137	d.windowsMutex.Lock()	×
138	i := 0	×
139	for _, win := range d.windows {	×
140	if win == w {	×
141	break	×
142	}
143	i++	×
144	}
145
146	copy(d.windows[i:], d.windows[i+1:])	×
147	d.windows[len(d.windows)-1] = nil // Allow the garbage collector to reclaim the memory.	×
148	d.windows = d.windows[:len(d.windows)-1]	×
149		×
150	d.windowsMutex.Unlock()	×
151	}
152
NEW 153	func (*driver) DoubleTapDelay() time.Duration {	×
154	return 300 * time.Millisecond	×
155	}	×
156
NEW 157	func (*driver) SetDisableScreenBlanking(_ bool) {	×
158	// no-op for test	×
159	}	×

fyne-io / fyne / 30240283751

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous