mirror of
https://github.com/hajimehoshi/ebiten.git
synced 2024-11-10 04:57:26 +01:00
434 lines
9.2 KiB
Go
434 lines
9.2 KiB
Go
// Copyright 2018 The Ebiten Authors
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package packing_test
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/hajimehoshi/ebiten/v2/internal/packing"
|
|
)
|
|
|
|
func TestPage(t *testing.T) {
|
|
type Rect struct {
|
|
X int
|
|
Y int
|
|
Width int
|
|
Height int
|
|
}
|
|
|
|
type Op struct {
|
|
Width int
|
|
Height int
|
|
FreeNodeID int
|
|
}
|
|
|
|
cases := []struct {
|
|
Name string
|
|
In []Op
|
|
Out []*Rect
|
|
}{
|
|
{
|
|
Name: "alloc and random free",
|
|
In: []Op{
|
|
{100, 100, -1},
|
|
{100, 100, -1},
|
|
{100, 100, -1},
|
|
{100, 100, -1},
|
|
{100, 100, -1},
|
|
{100, 100, -1},
|
|
{0, 0, 1},
|
|
{0, 0, 3},
|
|
{0, 0, 5},
|
|
{0, 0, 0},
|
|
{0, 0, 2},
|
|
{0, 0, 4},
|
|
{1024, 1024, -1},
|
|
},
|
|
Out: []*Rect{
|
|
{0, 0, 100, 100},
|
|
{0, 100, 100, 100},
|
|
{0, 200, 100, 100},
|
|
{0, 300, 100, 100},
|
|
{0, 400, 100, 100},
|
|
{0, 500, 100, 100},
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
{0, 0, 1024, 1024},
|
|
},
|
|
},
|
|
{
|
|
Name: "alloc and free and empty",
|
|
In: []Op{
|
|
{31, 41, -1},
|
|
{59, 26, -1},
|
|
{53, 58, -1},
|
|
{97, 93, -1},
|
|
{28, 84, -1},
|
|
{62, 64, -1},
|
|
{0, 0, 0},
|
|
{0, 0, 1},
|
|
{0, 0, 2},
|
|
{0, 0, 3},
|
|
{0, 0, 4},
|
|
{0, 0, 5},
|
|
},
|
|
Out: []*Rect{
|
|
{0, 0, 31, 41},
|
|
{31, 0, 59, 26},
|
|
{31, 26, 53, 58},
|
|
{31, 84, 97, 93},
|
|
{0, 41, 28, 84},
|
|
{31, 177, 62, 64},
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
},
|
|
},
|
|
{
|
|
Name: "random Alloc",
|
|
In: []Op{
|
|
{100, 200, -1},
|
|
{1024, 1024, -1},
|
|
{100, 200, -1},
|
|
{50, 50, -1},
|
|
{200, 200, -1},
|
|
{1024, 1024, -1},
|
|
{500, 500, -1},
|
|
{600, 600, -1},
|
|
{100, 100, -1},
|
|
{0, 0, 2},
|
|
{100, 200, -1},
|
|
},
|
|
Out: []*Rect{
|
|
{0, 0, 100, 200},
|
|
nil,
|
|
{0, 200, 100, 200},
|
|
{0, 400, 50, 50},
|
|
{100, 0, 200, 200},
|
|
nil,
|
|
{100, 200, 500, 500},
|
|
nil,
|
|
{0, 450, 100, 100},
|
|
nil,
|
|
{0, 200, 100, 200},
|
|
},
|
|
},
|
|
{
|
|
Name: "fill squares",
|
|
In: []Op{
|
|
{256, 256, -1},
|
|
{256, 256, -1},
|
|
{256, 256, -1},
|
|
{256, 256, -1},
|
|
|
|
{256, 256, -1},
|
|
{256, 256, -1},
|
|
{256, 256, -1},
|
|
{256, 256, -1},
|
|
|
|
{256, 256, -1},
|
|
{256, 256, -1},
|
|
{256, 256, -1},
|
|
{256, 256, -1},
|
|
|
|
{256, 256, -1},
|
|
{256, 256, -1},
|
|
{256, 256, -1},
|
|
{256, 256, -1},
|
|
|
|
{256, 256, -1},
|
|
},
|
|
Out: []*Rect{
|
|
{0, 0, 256, 256},
|
|
{0, 256, 256, 256},
|
|
{0, 512, 256, 256},
|
|
{0, 768, 256, 256},
|
|
|
|
{256, 0, 256, 256},
|
|
{512, 0, 256, 256},
|
|
{768, 0, 256, 256},
|
|
{256, 256, 256, 256},
|
|
|
|
{256, 512, 256, 256},
|
|
{256, 768, 256, 256},
|
|
{512, 256, 256, 256},
|
|
{768, 256, 256, 256},
|
|
|
|
{512, 512, 256, 256},
|
|
{512, 768, 256, 256},
|
|
{768, 512, 256, 256},
|
|
{768, 768, 256, 256},
|
|
|
|
nil,
|
|
},
|
|
},
|
|
{
|
|
Name: "fill not fitting squares",
|
|
In: []Op{
|
|
{300, 300, -1},
|
|
{300, 300, -1},
|
|
{300, 300, -1},
|
|
{300, 300, -1},
|
|
{300, 300, -1},
|
|
{300, 300, -1},
|
|
{300, 300, -1},
|
|
{300, 300, -1},
|
|
{300, 300, -1},
|
|
{300, 300, -1},
|
|
},
|
|
Out: []*Rect{
|
|
{0, 0, 300, 300},
|
|
{0, 300, 300, 300},
|
|
{0, 600, 300, 300},
|
|
{300, 0, 300, 300},
|
|
{600, 0, 300, 300},
|
|
{300, 300, 300, 300},
|
|
{300, 600, 300, 300},
|
|
{600, 300, 300, 300},
|
|
{600, 600, 300, 300},
|
|
nil,
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
p := packing.NewPage(1024, 1024)
|
|
nodes := []*packing.Node{}
|
|
nnodes := 0
|
|
for i, in := range c.In {
|
|
if in.FreeNodeID == -1 {
|
|
n := p.Alloc(in.Width, in.Height)
|
|
nodes = append(nodes, n)
|
|
nnodes++
|
|
} else {
|
|
p.Free(nodes[in.FreeNodeID])
|
|
nodes = append(nodes, nil)
|
|
nnodes--
|
|
}
|
|
if nnodes < 0 {
|
|
panic("not reached")
|
|
}
|
|
|
|
if p.IsEmpty() != (nnodes == 0) {
|
|
t.Errorf("%s: nodes[%d]: page.IsEmpty(): got: %v, want: %v", c.Name, i, p.IsEmpty(), (nnodes == 0))
|
|
}
|
|
}
|
|
for i, out := range c.Out {
|
|
if nodes[i] == nil {
|
|
if out != nil {
|
|
t.Errorf("%s: nodes[%d]: should be nil but %v", c.Name, i, out)
|
|
}
|
|
continue
|
|
}
|
|
x, y, width, height := nodes[i].Region()
|
|
got := Rect{x, y, width, height}
|
|
if out == nil {
|
|
t.Errorf("%s: nodes[%d]: got: %v, want: %v", c.Name, i, got, nil)
|
|
continue
|
|
}
|
|
want := *out
|
|
if got != want {
|
|
t.Errorf("%s: nodes[%d]: got: %v, want: %v", c.Name, i, got, want)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestAlloc(t *testing.T) {
|
|
p := packing.NewPage(1024, 2048)
|
|
w, h := p.Size()
|
|
p.Alloc(w/2, h/2)
|
|
|
|
n0 := p.Alloc(w*3/2, h*2)
|
|
if n0 == nil {
|
|
t.Errorf("p.Alloc failed: width: %d, height: %d", w*3/2, h*2)
|
|
}
|
|
n1 := p.Alloc(w/2, h*3/2)
|
|
if n1 == nil {
|
|
t.Errorf("p.Alloc failed: width: %d, height: %d", w/2, h*3/2)
|
|
}
|
|
if p.Alloc(1, 1) != nil {
|
|
t.Errorf("p.Alloc(1, 1) must fail but not")
|
|
}
|
|
p.Free(n1)
|
|
if p.Alloc(1, 1) == nil {
|
|
t.Errorf("p.Alloc(1, 1) failed")
|
|
}
|
|
p.Free(n0)
|
|
}
|
|
|
|
func TestAlloc2(t *testing.T) {
|
|
p := packing.NewPage(1024, 2048)
|
|
w, h := p.Size()
|
|
p.Alloc(w/2, h/2)
|
|
n1 := p.Alloc(w/2, h/2)
|
|
n2 := p.Alloc(w/2, h/2)
|
|
p.Alloc(w/2, h/2)
|
|
p.Free(n1)
|
|
p.Free(n2)
|
|
|
|
n3 := p.Alloc(w, h*2)
|
|
if n3 == nil {
|
|
t.Errorf("p.Alloc failed: width: %d, height: %d", w, h*2)
|
|
}
|
|
n4 := p.Alloc(w, h)
|
|
if n4 == nil {
|
|
t.Errorf("p.Alloc failed: width: %d, height: %d", w, h)
|
|
}
|
|
p.Free(n4)
|
|
p.Free(n3)
|
|
}
|
|
|
|
func TestAllocJustSize(t *testing.T) {
|
|
p := packing.NewPage(1024, 4096)
|
|
if p.Alloc(4096, 4096) == nil {
|
|
t.Errorf("got: nil, want: non-nil")
|
|
}
|
|
}
|
|
|
|
// Issue #1454
|
|
func TestAllocTooMuch(t *testing.T) {
|
|
p := packing.NewPage(1024, 4096)
|
|
p.Alloc(1, 1)
|
|
if p.Alloc(4096, 4096) != nil {
|
|
t.Errorf("got: non-nil, want: nil")
|
|
}
|
|
}
|
|
|
|
func TestNonSquareAlloc(t *testing.T) {
|
|
p := packing.NewPage(1024, 16384)
|
|
n0 := p.Alloc(16384, 1)
|
|
if _, h := p.Size(); h != 1024 {
|
|
t.Errorf("got: %d, want: 1024", h)
|
|
}
|
|
n1 := p.Alloc(16384, 1)
|
|
if _, h := p.Size(); h != 1024 {
|
|
t.Errorf("got: %d, want: 1024", h)
|
|
}
|
|
p.Free(n0)
|
|
p.Free(n1)
|
|
}
|
|
|
|
func TestExtend(t *testing.T) {
|
|
p := packing.NewPage(1024, 2048)
|
|
n0 := p.Alloc(1024, 1024)
|
|
if n0 == nil {
|
|
t.Errorf("p.Alloc(1024, 1024) failed")
|
|
}
|
|
|
|
// In the current implementation, the page is extended in a horizontal direction first.
|
|
n1 := p.Alloc(1024, 1024)
|
|
if n1 == nil {
|
|
t.Errorf("p.Alloc(1024, 1024) failed")
|
|
}
|
|
gotWidth, gotHeight := p.Size()
|
|
if wantWidth, wantHeight := 2048, 1024; gotWidth != wantWidth || gotHeight != wantHeight {
|
|
t.Errorf("got: (%d, %d), want: (%d, %d)", gotWidth, gotHeight, wantWidth, wantHeight)
|
|
}
|
|
|
|
// Then, allocating (1024, 2048) fails unfortunately.
|
|
if p.Alloc(1024, 2048) != nil {
|
|
t.Errorf("p.Alloc(1024, 2048) must fail but not")
|
|
}
|
|
|
|
n2 := p.Alloc(2048, 1024)
|
|
if n2 == nil {
|
|
t.Errorf("p.Alloc(1024, 2048) failed")
|
|
}
|
|
gotWidth, gotHeight = p.Size()
|
|
if wantWidth, wantHeight := 2048, 2048; gotWidth != wantWidth || gotHeight != wantHeight {
|
|
t.Errorf("got: (%d, %d), want: (%d, %d)", gotWidth, gotHeight, wantWidth, wantHeight)
|
|
}
|
|
|
|
p.Free(n0)
|
|
p.Free(n1)
|
|
p.Free(n2)
|
|
}
|
|
|
|
func TestExtend2(t *testing.T) {
|
|
p := packing.NewPage(1024, 2048)
|
|
n0 := p.Alloc(1024, 1024)
|
|
if n0 == nil {
|
|
t.Errorf("p.Alloc(1024, 1024) failed")
|
|
}
|
|
|
|
// Extend the page in the both directions. (1024, 2048) should be allocated on the right side.
|
|
n1 := p.Alloc(1024, 2048)
|
|
if n1 == nil {
|
|
t.Errorf("p.Alloc(1024, 2048) failed")
|
|
}
|
|
gotWidth, gotHeight := p.Size()
|
|
if wantWidth, wantHeight := 2048, 2048; gotWidth != wantWidth || gotHeight != wantHeight {
|
|
t.Errorf("got: (%d, %d), want: (%d, %d)", gotWidth, gotHeight, wantWidth, wantHeight)
|
|
}
|
|
|
|
// There should be a space in the lower-left corner.
|
|
n2 := p.Alloc(1024, 1024)
|
|
if n2 == nil {
|
|
t.Errorf("p.Alloc(1024, 1024) failed")
|
|
}
|
|
gotWidth, gotHeight = p.Size()
|
|
if wantWidth, wantHeight := 2048, 2048; gotWidth != wantWidth || gotHeight != wantHeight {
|
|
t.Errorf("got: (%d, %d), want: (%d, %d)", gotWidth, gotHeight, wantWidth, wantHeight)
|
|
}
|
|
|
|
p.Free(n0)
|
|
p.Free(n1)
|
|
p.Free(n2)
|
|
}
|
|
|
|
func TestExtend3(t *testing.T) {
|
|
p := packing.NewPage(1024, 2048)
|
|
|
|
// Allocate a small area that doesn't touch the left edge and the bottom edge.
|
|
// Allocating (1, 1) would split the entire region into left and right in the current implementation,
|
|
// so allocate (2, 1) here.
|
|
n0 := p.Alloc(2, 1)
|
|
if n0 == nil {
|
|
t.Errorf("p.Alloc(1, 1) failed")
|
|
}
|
|
|
|
// Extend the page in the vertical direction.
|
|
n1 := p.Alloc(1024, 2047)
|
|
if n1 == nil {
|
|
t.Errorf("p.Alloc(1024, 2047) failed")
|
|
}
|
|
gotWidth, gotHeight := p.Size()
|
|
if wantWidth, wantHeight := 1024, 2048; gotWidth != wantWidth || gotHeight != wantHeight {
|
|
t.Errorf("got: (%d, %d), want: (%d, %d)", gotWidth, gotHeight, wantWidth, wantHeight)
|
|
}
|
|
|
|
// There should be a space on the right side.
|
|
n2 := p.Alloc(1024, 2048)
|
|
if n2 == nil {
|
|
t.Errorf("p.Alloc(1024, 2048) failed")
|
|
}
|
|
gotWidth, gotHeight = p.Size()
|
|
if wantWidth, wantHeight := 2048, 2048; gotWidth != wantWidth || gotHeight != wantHeight {
|
|
t.Errorf("got: (%d, %d), want: (%d, %d)", gotWidth, gotHeight, wantWidth, wantHeight)
|
|
}
|
|
|
|
p.Free(n0)
|
|
p.Free(n1)
|
|
p.Free(n2)
|
|
}
|