gio/app/window_test.go

// SPDX-License-Identifier: Unlicense OR MIT

package app

import (
	"image"
	"image/color"
	"testing"

	"gioui.org/gpu"
	"gioui.org/op"
)

func TestValidateAndProcessRelocksAfterRefresh(t *testing.T) {
	ctx := &testContext{}
	w := &Window{
		ctx:          ctx,
		gpu:          &testGPU{},
		ctxNeedsLock: false,
	}

	if err := w.validateAndProcess(image.Pt(320, 240), true, new(op.Ops), nil); err != nil {
		t.Fatalf("validateAndProcess returned error: %v", err)
	}

	want := []string{"refresh", "lock", "render-target", "present"}
	if got := ctx.ops; !equalStringSlices(got, want) {
		t.Fatalf("unexpected call order:\n got  %v\n want %v", got, want)
	}
	if w.ctxNeedsLock {
		t.Fatalf("context should remain current after a successful frame")
	}
}

func TestValidateAndProcessSkipsRedundantRelock(t *testing.T) {
	ctx := &testContext{}
	w := &Window{
		ctx:          ctx,
		gpu:          &testGPU{},
		ctxNeedsLock: false,
	}

	if err := w.validateAndProcess(image.Pt(320, 240), false, new(op.Ops), nil); err != nil {
		t.Fatalf("validateAndProcess returned error: %v", err)
	}

	want := []string{"render-target", "present"}
	if got := ctx.ops; !equalStringSlices(got, want) {
		t.Fatalf("unexpected call order:\n got  %v\n want %v", got, want)
	}
}

type testContext struct {
	ops []string
}

func (c *testContext) API() gpu.API {
	return nil
}

func (c *testContext) RenderTarget() (gpu.RenderTarget, error) {
	c.ops = append(c.ops, "render-target")
	return gpu.OpenGLRenderTarget{}, nil
}

func (c *testContext) Present() error {
	c.ops = append(c.ops, "present")
	return nil
}

func (c *testContext) Refresh() error {
	c.ops = append(c.ops, "refresh")
	return nil
}

func (c *testContext) Release() {}

func (c *testContext) Lock() error {
	c.ops = append(c.ops, "lock")
	return nil
}

func (c *testContext) Unlock() {
	c.ops = append(c.ops, "unlock")
}

type testGPU struct{}

func (g *testGPU) Release() {}

func (g *testGPU) Clear(color.NRGBA) {}

func (g *testGPU) Frame(*op.Ops, gpu.RenderTarget, image.Point) error {
	return nil
}

func equalStringSlices(a, b []string) bool {
	if len(a) != len(b) {
		return false
	}
	for i := range a {
		if a[i] != b[i] {
			return false
		}
	}
	return true
}