path: root/Godeps/_workspace/src/github.com/obscuren/qml/qml_test.go

package qml_test

import (
    "encoding/base64"
    "flag"
    "fmt"
    "image"
    "image/color"
    "io/ioutil"
    "os"
    "reflect"
    "regexp"
    "runtime"
    "strings"
    "testing"
    "time"

    . "gopkg.in/check.v1"
    "gopkg.in/qml.v1"
    "gopkg.in/qml.v1/cpptest"
    "gopkg.in/qml.v1/gl/2.0"
    "path/filepath"
)

func init() { qml.SetupTesting() }

func Test(t *testing.T) { TestingT(t) }

type S struct {
    engine  *qml.Engine
    context *qml.Context
}

var _ = Suite(&S{})

func (s *S) SetUpTest(c *C) {
    qml.SetLogger(c)
    qml.CollectStats(true)
    qml.ResetStats()

    stats := qml.Stats()
    if stats.EnginesAlive > 0 || stats.ValuesAlive > 0 || stats.ConnectionsAlive > 0 {
        panic(fmt.Sprintf("Test started with values alive: %#v\n", stats))
    }

    s.engine = qml.NewEngine()
    s.context = s.engine.Context()
}

func (s *S) TearDownTest(c *C) {
    s.engine.Destroy()

    retries := 30 // Three seconds top.
    for {
        // Do not call qml.Flush here. It creates a nested event loop
        // that attempts to process the deferred object deletes and cannot,
        // because deferred deletes are only processed at the same loop level.
        // So it *reposts* the deferred deletion event, in practice *preventing*
        // these objects from being deleted.
        runtime.GC()
        stats := qml.Stats()
        if stats.EnginesAlive == 0 && stats.ValuesAlive == 0 && stats.ConnectionsAlive == 0 {
            break
        }
        if retries == 0 {
            panic(fmt.Sprintf("there are values alive:\n%#v\n", stats))
        }
        retries--
        time.Sleep(100 * time.Millisecond)
        if retries%10 == 0 {
            c.Logf("There are still objects alive; waiting for them to die: %#v\n", stats)
        }
    }

    qml.SetLogger(nil)
}

type GoRect struct {
    PaintCount int
}

func (r *GoRect) Paint(p *qml.Painter) {
    r.PaintCount++

    obj := p.Object()

    gl := GL.API(p)

    width := float32(obj.Int("width"))
    height := float32(obj.Int("height"))

    gl.Color3f(1.0, 0.0, 0.0)
    gl.Begin(GL.QUADS)
    gl.Vertex2f(0, 0)
    gl.Vertex2f(width, 0)
    gl.Vertex2f(width, height)
    gl.Vertex2f(0, height)
    gl.End()
}

type GoType struct {
    private bool // Besides being private, also adds a gap in the reflect field index.

    StringValue     string
    StringAddrValue *string
    BoolValue       bool
    IntValue        int
    Int64Value      int64
    Int32Value      int32
    Uint32Value     uint32
    Float64Value    float64
    Float32Value    float32
    AnyValue        interface{}
    ObjectValue     qml.Object
    ColorValue      color.RGBA
    IntsValue       []int
    ObjectsValue    []qml.Object
    MapValue        map[string]interface{}

    SetterStringValue  string
    SetterObjectsValue []qml.Object

    setterStringValueChanged  int
    setterStringValueSet      string
    setterObjectsValueChanged int
    setterObjectsValueSet     []qml.Object

    getterStringValue        string
    getterStringValueChanged int

    // The object representing this value, on custom type tests.
    object qml.Object
}

// Force a gap in the reflect method index and ensure the handling
// of private methods is being done properly.
func (ts *GoType) privateMethod() {}

func (ts *GoType) StringMethod() string {
    return ts.StringValue
}

func (ts *GoType) SetSetterStringValue(s string) {
    ts.setterStringValueChanged++
    ts.setterStringValueSet = s
}

func (ts *GoType) SetSetterObjectsValue(v []qml.Object) {
    ts.setterObjectsValueChanged++
    ts.setterObjectsValueSet = v
}

func (ts *GoType) GetterStringValue() string {
    return ts.getterStringValue
}

func (ts *GoType) SetGetterStringValue(s string) {
    ts.getterStringValueChanged++
    ts.getterStringValue = s
}

func (ts *GoType) SetMapValue(m map[string]interface{}) {
    ts.MapValue = m
}

func (ts *GoType) Mod(dividend, divisor int) (int, error) {
    if divisor == 0 {
        return 0, fmt.Errorf("<division by zero>")
    }
    return dividend % divisor, nil
}

func (ts *GoType) ChangeString(new string) (old string) {
    old = ts.StringValue
    ts.StringValue = new
    return
}

func (ts *GoType) NotifyStringChanged() {
    qml.Changed(ts, &ts.StringValue)
}

func (ts *GoType) IncrementInt() {
    ts.IntValue++
}

func (s *S) TestEngineDestroyedUse(c *C) {
    s.engine.Destroy()
    s.engine.Destroy()
    c.Assert(s.engine.Context, PanicMatches, "engine already destroyed")
}

var same = "<same>"

var getSetTests = []struct{ set, get interface{} }{
    {"value", same},
    {true, same},
    {false, same},
    {int(42), same},
    {int32(42), int(42)},
    {int64(42), same},
    {uint32(42), same},
    {uint64(42), same},
    {float64(42), same},
    {float32(42), same},
    {new(GoType), same},
    {nil, same},
    {42, same},
}

func (s *S) TestContextGetSet(c *C) {
    for i, t := range getSetTests {
        want := t.get
        if t.get == same {
            want = t.set
        }
        s.context.SetVar("key", t.set)
        c.Assert(s.context.Var("key"), Equals, want,
            Commentf("entry %d is {%v (%T), %v (%T)}", i, t.set, t.set, t.get, t.get))
    }
}

func (s *S) TestContextGetMissing(c *C) {
    c.Assert(s.context.Var("missing"), Equals, nil)
}

func (s *S) TestContextSetVars(c *C) {
    component, err := s.engine.LoadString("file.qml", "import QtQuick 2.0\nItem { width: 42 }")
    c.Assert(err, IsNil)
    root := component.Create(nil)

    vars := GoType{
        StringValue:  "<content>",
        BoolValue:    true,
        IntValue:     42,
        Int64Value:   42,
        Int32Value:   42,
        Float64Value: 4.2,
        Float32Value: 4.2,
        AnyValue:     nil,
        ObjectValue:  root,
    }
    s.context.SetVars(&vars)

    c.Assert(s.context.Var("stringValue"), Equals, "<content>")
    c.Assert(s.context.Var("boolValue"), Equals, true)
    c.Assert(s.context.Var("intValue"), Equals, 42)
    c.Assert(s.context.Var("int64Value"), Equals, int64(42))
    c.Assert(s.context.Var("int32Value"), Equals, 42)
    c.Assert(s.context.Var("float64Value"), Equals, float64(4.2))
    c.Assert(s.context.Var("float32Value"), Equals, float32(4.2))
    c.Assert(s.context.Var("anyValue"), Equals, nil)

    vars.AnyValue = 42
    c.Assert(s.context.Var("anyValue"), Equals, 42)

    c.Assert(s.context.Var("objectValue").(qml.Object).Int("width"), Equals, 42)
}

func (s *S) TestComponentSetDataError(c *C) {
    _, err := s.engine.LoadString("file.qml", "Item{}")
    c.Assert(err, ErrorMatches, "file:.*/file.qml:1 Item is not a type")
}

func (s *S) TestComponentCreateWindow(c *C) {
    data := `
        import QtQuick 2.0
        Item { width: 300; height: 200; }
    `
    component, err := s.engine.LoadString("file.qml", data)
    c.Assert(err, IsNil)

    // TODO How to test this more effectively?
    window := component.CreateWindow(nil)
    window.Show()

    // Just a smoke test, as there isn't much to assert.
    c.Assert(window.PlatformId(), Not(Equals), uintptr(0))

    // Qt doesn't hide the Window if we call it too quickly. :-(
    time.Sleep(100 * time.Millisecond)
    window.Hide()
}

func (s *S) TestContextSpawn(c *C) {
    context1 := s.engine.Context()
    context2 := context1.Spawn()

    context1.SetVar("mystr", "context1")
    context2.SetVar("mystr", "context2")

    data := `
        import QtQuick 2.0
        Item { property var s: mystr }
    `
    component, err := s.engine.LoadString("file.qml", data)
    c.Assert(err, IsNil)

    obj1 := component.Create(context1)
    obj2 := component.Create(context2)

    c.Assert(obj1.String("s"), Equals, "context1")
    c.Assert(obj2.String("s"), Equals, "context2")
}

func (s *S) TestReadVoidAddrProperty(c *C) {
    obj := cpptest.NewTestType(s.engine)
    addr := obj.Property("voidAddr").(uintptr)
    c.Assert(addr, Equals, uintptr(42))
}

func (s *S) TestRegisterConverterPlainObject(c *C) {
    qml.RegisterConverter("PlainTestType", func(engine *qml.Engine, obj qml.Object) interface{} {
        c.Check(engine, Equals, s.engine)
        c.Check(obj.String("plainType"), Matches, "(const )?PlainTestType[&*]?")
        c.Check(obj.Property("plainAddr"), FitsTypeOf, uintptr(0))
        c.Check(cpptest.PlainTestTypeN(obj), Equals, 42)
        return "<converted>"
    })
    obj := cpptest.NewTestType(s.engine)
    defer obj.Destroy()

    var calls int
    obj.On("plainEmittedCpy", func(s string) {
        c.Check(s, Equals, "<converted>")
        calls++
    })
    obj.On("plainEmittedRef", func(s string) {
        c.Check(s, Equals, "<converted>")
        calls++
    })
    obj.On("plainEmittedPtr", func(s string) {
        c.Check(s, Equals, "<converted>")
        calls++
    })
    obj.Call("emitPlain")
    c.Assert(calls, Equals, 3)
}

func (s *S) TestIssue84(c *C) {
    // Regression test for issue #84 (QTBUG-41193).
    data := `
        import QtQuick 2.0
        Item {
            id: item
            property string s1: "<before>"
            property string s2: "<after>"
            states: State {
                name: "after";
                PropertyChanges { target: item; s1: s2 }
            }
            Component.onCompleted: state = "after"
        }
    `
    filename := filepath.Join(c.MkDir(), "file.qml")
    err := ioutil.WriteFile(filename, []byte(data), 0644)
    c.Assert(err, IsNil)

    component, err := s.engine.LoadString(filename, data)
    c.Assert(err, IsNil)

    root := component.Create(nil)
    defer root.Destroy()

    c.Assert(root.String("s1"), Equals, "<after>")
}

func (s *S) TestResources(c *C) {
    var rp qml.ResourcesPacker
    rp.Add("sub/path/Foo.qml", []byte("import QtQuick 2.0\nItem { Component.onCompleted: console.log('<Foo>') }"))
    rp.AddString("sub/path/Bar.qml", "import QtQuick 2.0\nItem { Component.onCompleted: console.log('<Bar>') }")
    rp.AddString("/sub/Main.qml", "import QtQuick 2.0\nimport \"./path\"\nItem {\nFoo{}\nBar{}\n}")

    r := rp.Pack()
    qml.LoadResources(r)
    testResourcesLoaded(c, true)
    qml.UnloadResources(r)
    testResourcesLoaded(c, false)

    data := r.Bytes()

    rb, err := qml.ParseResources(data)
    c.Assert(err, IsNil)
    qml.LoadResources(rb)
    testResourcesLoaded(c, true)
    qml.UnloadResources(rb)
    testResourcesLoaded(c, false)

    rs, err := qml.ParseResourcesString(string(data))
    c.Assert(err, IsNil)
    qml.LoadResources(rs)
    testResourcesLoaded(c, true)
    qml.UnloadResources(rs)
    testResourcesLoaded(c, false)
}

func testResourcesLoaded(c *C, loaded bool) {
    engine := qml.NewEngine()
    defer engine.Destroy()
    component, err := engine.LoadFile("qrc:///sub/Main.qml")
    if loaded {
        c.Assert(err, IsNil)
    } else {
        c.Assert(err, ErrorMatches, "qrc:///sub/Main.qml:-1 File not found")
        return
    }
    root := component.Create(nil)
    defer root.Destroy()
    c.Assert(c.GetTestLog(), Matches, "(?s).*(<Foo>.*<Bar>|<Bar>.*<Foo>).*")
}

func (s *S) TestResourcesIssue107(c *C) {
    var rp qml.ResourcesPacker

    rp.Add("a/Foo.qml", []byte("import QtQuick 2.0\nItem { Component.onCompleted: console.log('<Foo>') }"))
    rp.Add("b/Bar.qml", []byte("import QtQuick 2.0\nItem { Component.onCompleted: console.log('<Bar>') }"))
    rp.Add("c/Baz.qml", []byte("import QtQuick 2.0\nItem { Component.onCompleted: console.log('<Baz>') }"))
    rp.Add("d/Buz.qml", []byte("import QtQuick 2.0\nItem { Component.onCompleted: console.log('<Buz>') }"))

    r := rp.Pack()
    qml.LoadResources(r)

    for _, name := range []string{"a/Foo", "b/Bar", "c/Baz", "d/Buz"} {
        component, err := s.engine.LoadFile("qrc:///" + name + ".qml")
        c.Assert(err, IsNil)
        root := component.Create(nil)
        defer root.Destroy()
    }
    c.Assert(c.GetTestLog(), Matches, "(?s).*<Foo>.*<Bar>.*<Baz>.*<Buz>.*")
}

type TestData struct {
    *C
    engine           *qml.Engine
    context          *qml.Context
    component        qml.Object
    root             qml.Object
    value            *GoType
    createdValue     []*GoType
    createdRect      []*GoRect
    createdSingleton []*GoType
}

var tests = []struct {
    Summary string
    Value   GoType
    Rect    GoRect

    Init func(d *TestData)

    // The QML provided is run with the initial state above, and
    // then checks are made to ensure the provided state is found.
    QML      string
    QMLLog   string
    QMLValue GoType

    // The function provided is run with the post-QML state above,
    // and then checks are made to ensure the provided state is found.
    Done      func(c *TestData)
    DoneLog   string
    DoneValue GoType
}{
    {
        Summary: "Read a context variable and its fields",
        Value:   GoType{StringValue: "<content>", IntValue: 42},
        QML: `
            Item {
                Component.onCompleted: {
                    console.log("String is", value.stringValue)
                    console.log("Int is", value.intValue)
                    console.log("Any is", value.anyValue)
                }
            }
        `,
        QMLLog: "String is <content>.*Int is 42.*Any is undefined",
    },
    {
        Summary: "Read a nested field via a value (not pointer) in an interface",
        Value:   GoType{AnyValue: struct{ StringValue string }{"<content>"}},
        QML:     `Item { Component.onCompleted: console.log("String is", value.anyValue.stringValue) }`,
        QMLLog:  "String is <content>",
    },
    {
        Summary: "Read a native property",
        QML:     `Item { width: 123 }`,
        Done:    func(c *TestData) { c.Check(c.root.Int("width"), Equals, 123) },
    },
    {
        Summary: "Read object properties",
        QML: `
            Item {
                property bool boolp: true
                property int intp: 1
                property var int64p: 4294967296
                property real float32p: 1.1
                property double float64p: 1.1
                property string stringp: "<content>"
                property var objectp: Rectangle { width: 123 }
                property var nilp: null
            }
        `,
        Done: func(c *TestData) {
            obj := c.root
            c.Check(obj.Bool("boolp"), Equals, true)
            c.Check(obj.Int("intp"), Equals, 1)
            c.Check(obj.Int64("intp"), Equals, int64(1))
            c.Check(obj.Int64("int64p"), Equals, int64(4294967296))
            c.Check(obj.Float64("intp"), Equals, float64(1))
            c.Check(obj.Float64("int64p"), Equals, float64(4294967296))
            c.Check(obj.Float64("float32p"), Equals, float64(1.1))
            c.Check(obj.Float64("float64p"), Equals, float64(1.1))
            c.Check(obj.String("stringp"), Equals, "<content>")
            c.Check(obj.Object("objectp").Int("width"), Equals, 123)
            c.Check(obj.Property("nilp"), Equals, nil)

            c.Check(func() { obj.Bool("intp") }, Panics, `value of property "intp" is not a bool: 1`)
            c.Check(func() { obj.Int("boolp") }, Panics, `value of property "boolp" cannot be represented as an int: true`)
            c.Check(func() { obj.Int64("boolp") }, Panics, `value of property "boolp" cannot be represented as an int64: true`)
            c.Check(func() { obj.Float64("boolp") }, Panics, `value of property "boolp" cannot be represented as a float64: true`)
            c.Check(func() { obj.String("boolp") }, Panics, `value of property "boolp" is not a string: true`)
            c.Check(func() { obj.Object("boolp") }, Panics, `value of property "boolp" is not a QML object: true`)
            c.Check(func() { obj.Property("missing") }, Panics, `object does not have a "missing" property`)
        },
    },
    {
        Summary: "Lowercasing of object properties",
        Init: func(c *TestData) {
            obj := struct{ THE, THEName, Name, N string }{"<a>", "<b>", "<c>", "<d>"}
            c.context.SetVar("obj", &obj)
        },
        QML:    `Item { Component.onCompleted: console.log("Names are", obj.the, obj.theName, obj.name, obj.n) }`,
        QMLLog: "Names are <a> <b> <c> <d>",
    },
    {
        Summary: "No access to private fields",
        Value:   GoType{private: true},
        QML:     `Item { Component.onCompleted: console.log("Private is", value.private); }`,
        QMLLog:  "Private is undefined",
    },
    {
        Summary: "Set a custom property",
        QML: `
            Item {
                property var obj: null

                onObjChanged:     console.log("String is", obj.stringValue)
                onWidthChanged:   console.log("Width is", width)
                onHeightChanged:  console.log("Height is", height)
            }
        `,
        Done: func(c *TestData) {
            value := GoType{StringValue: "<content>"}
            c.root.Set("obj", &value)
            c.root.Set("width", 300)
            c.root.Set("height", 200)
        },
        DoneLog: "String is <content>.*Width is 300.*Height is 200",
    },
    {
        Summary: "Read and set a QUrl property",
        QML:     `import QtWebKit 3.0; WebView {}`,
        Done: func(c *TestData) {
            c.Check(c.root.String("url"), Equals, "")
            url := "http://localhost:54321"
            c.root.Set("url", url)
            c.Check(c.root.String("url"), Equals, url)
        },
    },
    {
        Summary: "Read and set a QColor property",
        QML:     `Text{ color: Qt.rgba(1/16, 1/8, 1/4, 1/2); function hasColor(c) { return Qt.colorEqual(color, c) }}`,
        Done: func(c *TestData) {
            c.Assert(c.root.Color("color"), Equals, color.RGBA{256 / 16, 256 / 8, 256 / 4, 256 / 2})
            c.root.Set("color", color.RGBA{256 / 2, 256 / 4, 256 / 8, 256 / 16})
            c.Assert(c.root.Call("hasColor", color.RGBA{256 / 2, 256 / 4, 256 / 8, 256 / 16}), Equals, true)
        },
    },
    {
        Summary: "Read and set a QColor property from a Go field",
        Init:    func(c *TestData) { c.value.ColorValue = color.RGBA{256 / 16, 256 / 8, 256 / 4, 256 / 2} },
        QML:     `Text{ property var c: value.colorValue; Component.onCompleted: { console.log(value.colorValue); } }`,
        Done: func(c *TestData) {
            c.Assert(c.root.Color("c"), Equals, color.RGBA{256 / 16, 256 / 8, 256 / 4, 256 / 2})
        },
    },
    {
        Summary: "Read a QQmlListProperty property into a Go slice",
        QML: `
            Item {
                states: [
                    State { id: on;  name: "on" },
                    State { id: off; name: "off" }
                ]
            }
        `,
        Done: func(c *TestData) {
            var states []qml.Object
            c.root.List("states").Convert(&states)
            c.Assert(states[0].String("name"), Equals, "on")
            c.Assert(states[1].String("name"), Equals, "off")
            c.Assert(len(states), Equals, 2)
            c.Assert(c.root.Property("states").(*qml.List).Len(), Equals, 2)
        },
    },
    {
        Summary: "Read a QQmlListReference property into a Go slice",
        QML: `
            Item {
                property list<State> mystates: [
                    State { id: on;  name: "on" },
                    State { id: off; name: "off" }
                ]
                Component.onCompleted: value.objectsValue = mystates
            }
        `,
        Done: func(c *TestData) {
            var states []qml.Object
            c.root.List("mystates").Convert(&states)
            c.Assert(states[0].String("name"), Equals, "on")
            c.Assert(states[1].String("name"), Equals, "off")
            c.Assert(len(states), Equals, 2)
            c.Assert(len(c.value.ObjectsValue), Equals, 2)
        },
    },
    {
        Summary: "Read a QVariantList property into a Go slice",
        QML: `
            Item {
                State { id: on;  name: "on" }
                State { id: off; name: "off" }
                property var mystates: [on, off]
            }
        `,
        Done: func(c *TestData) {
            var states []qml.Object
            c.root.List("mystates").Convert(&states)
            c.Assert(states[0].String("name"), Equals, "on")
            c.Assert(states[1].String("name"), Equals, "off")
            c.Assert(len(states), Equals, 2)
        },
    },
    {
        Summary:  "Set a Go slice property",
        QML:      `Item { Component.onCompleted: value.intsValue = [1, 2, 3.5] }`,
        QMLValue: GoType{IntsValue: []int{1, 2, 3}},
    },
    {
        Summary: "Set a Go slice property with objects",
        QML: `
            Item {
                State { id: on;  name: "on" }
                State { id: off; name: "off" }
                Component.onCompleted: value.objectsValue = [on, off]
            }
        `,
        Done: func(c *TestData) {
            c.Assert(c.value.ObjectsValue[0].String("name"), Equals, "on")
            c.Assert(c.value.ObjectsValue[1].String("name"), Equals, "off")
            c.Assert(len(c.value.ObjectsValue), Equals, 2)
        },
    },
    {
        Summary:  "Call a method with a JSON object (issue #48)",
        QML:      `Item { Component.onCompleted: value.setMapValue({a: 1, b: 2}) }`,
        QMLValue: GoType{MapValue: map[string]interface{}{"a": 1, "b": 2}},
    },
    {
        Summary: "Read a map from a QML property",
        QML:     `Item { property var m: {"a": 1, "b": 2} }`,
        Done: func(c *TestData) {
            var m1 map[string]interface{}
            var m2 map[string]int
            m := c.root.Map("m")
            m.Convert(&m1)
            m.Convert(&m2)
            c.Assert(m1, DeepEquals, map[string]interface{}{"a": 1, "b": 2})
            c.Assert(m2, DeepEquals, map[string]int{"a": 1, "b": 2})
            c.Assert(m.Len(), Equals, 2)
        },
    },
    {
        Summary: "Identical values remain identical when possible",
        Init: func(c *TestData) {
            c.context.SetVar("a", c.value)
            c.context.SetVar("b", c.value)
        },
        QML:    `Item { Component.onCompleted: console.log('Identical:', a === b); }`,
        QMLLog: "Identical: true",
    },
    {
        Summary: "Object finding via ObjectByName",
        QML:     `Item { Item { objectName: "subitem"; property string s: "<found>" } }`,
        Done: func(c *TestData) {
            obj := c.root.ObjectByName("subitem")
            c.Check(obj.String("s"), Equals, "<found>")
            c.Check(func() { c.root.ObjectByName("foo") }, Panics, `cannot find descendant with objectName == "foo"`)
        },
    },
    {
        Summary: "Object finding via ObjectByName on GoType",
        QML:     `Item { GoType { objectName: "subitem"; property string s: "<found>" } }`,
        Done: func(c *TestData) {
            obj := c.root.ObjectByName("subitem")
            c.Check(obj.String("s"), Equals, "<found>")
            c.Check(func() { c.root.ObjectByName("foo") }, Panics, `cannot find descendant with objectName == "foo"`)
        },
    },
    {
        Summary: "Register Go type",
        QML:     `GoType { objectName: "test"; Component.onCompleted: console.log("String is", stringValue) }`,
        QMLLog:  "String is <initial>",
        Done: func(c *TestData) {
            c.Assert(c.createdValue, HasLen, 1)
            c.Assert(c.createdValue[0].object.String("objectName"), Equals, "test")
        },
    },
    {
        Summary: "Register Go type with an explicit name",
        QML:     `NamedGoType { objectName: "test"; Component.onCompleted: console.log("String is", stringValue) }`,
        QMLLog:  "String is <initial>",
        Done: func(c *TestData) {
            c.Assert(c.createdValue, HasLen, 1)
            c.Assert(c.createdValue[0].object.String("objectName"), Equals, "test")
        },
    },
    {
        Summary: "Write Go type property",
        QML:     `GoType { stringValue: "<content>"; intValue: 300 }`,
        Done: func(c *TestData) {
            c.Assert(c.createdValue, HasLen, 1)
            c.Assert(c.createdValue[0].StringValue, Equals, "<content>")
            c.Assert(c.createdValue[0].IntValue, Equals, 300)
        },
    },
    {
        Summary: "Write Go type property that has a setter",
        QML:     `GoType { setterStringValue: "<content>" }`,
        Done: func(c *TestData) {
            c.Assert(c.createdValue, HasLen, 1)
            c.Assert(c.createdValue[0].SetterStringValue, Equals, "")
            c.Assert(c.createdValue[0].setterStringValueChanged, Equals, 1)
            c.Assert(c.createdValue[0].setterStringValueSet, Equals, "<content>")
        },
    },
    {
        Summary: "Write Go type property that has a setter and a getter",
        QML: `
            GoType {
                getterStringValue: "<content>"
                Component.onCompleted: console.log("Getter returned", getterStringValue)
            }
        `,
        QMLLog: `Getter returned <content>`,
        Done: func(c *TestData) {
            c.Assert(c.createdValue, HasLen, 1)
            c.Assert(c.createdValue[0].getterStringValue, Equals, "<content>")
            c.Assert(c.createdValue[0].getterStringValueChanged, Equals, 1)
        },
    },
    {
        Summary: "Write an inline object list to a Go type property",
        QML: `
            GoType {
                objectsValue: [State{ name: "on" }, State{ name: "off" }]
                Component.onCompleted: {
                    console.log("Length:", objectsValue.length)
                    console.log("Name:", objectsValue[0].name)
                }
            }
        `,
        QMLLog: "Length: 2.*Name: on",
        Done: func(c *TestData) {
            c.Assert(c.createdValue, HasLen, 1)
            c.Assert(c.createdValue[0].ObjectsValue[0].String("name"), Equals, "on")
            c.Assert(c.createdValue[0].ObjectsValue[1].String("name"), Equals, "off")
            c.Assert(c.createdValue[0].ObjectsValue, HasLen, 2)
        },
    },
    {
        Summary: "Write an inline object list to a Go type property that has a setter",
        QML:     `GoType { setterObjectsValue: [State{ name: "on" }, State{ name: "off" }] }`,
        Done: func(c *TestData) {
            // Note that the setter is not actually updating the field value, for testing purposes.
            c.Assert(c.createdValue, HasLen, 1)
            c.Assert(c.createdValue[0].SetterObjectsValue, IsNil)
            c.Assert(c.createdValue[0].setterObjectsValueChanged, Equals, 2)
            c.Assert(c.createdValue[0].setterObjectsValueSet, HasLen, 1)
            c.Assert(c.createdValue[0].setterObjectsValueSet[0].String("name"), Equals, "off")
        },
    },
    {
        Summary: "Clear an object list in a Go type property",
        QML: `
            GoType {
                objectsValue: [State{ name: "on" }, State{ name: "off" }]
                Component.onCompleted: objectsValue = []
            }
        `,
        Done: func(c *TestData) {
            c.Assert(c.createdValue, HasLen, 1)
            c.Assert(c.createdValue[0].ObjectsValue, HasLen, 0)
        },
    },
    {
        Summary: "Clear an object list in a Go type property that has a setter",
        Value:   GoType{SetterObjectsValue: []qml.Object{nil, nil}},
        QML: `
            GoType {
                objectsValue: [State{ name: "on" }, State{ name: "off" }]
                function clear() { setterObjectsValue = [] }
            }
        `,
        Done: func(c *TestData) {
            // Note that the setter is not actually updating the field value, for testing purposes.
            c.Assert(c.createdValue, HasLen, 1)
            c.createdValue[0].SetterObjectsValue = c.createdValue[0].ObjectsValue

            c.createdValue[0].object.Call("clear")

            c.Assert(c.createdValue[0].SetterObjectsValue, HasLen, 2)
            c.Assert(c.createdValue[0].setterObjectsValueChanged, Equals, 1)
            c.Assert(c.createdValue[0].setterObjectsValueSet, DeepEquals, []qml.Object{})
            c.Assert(&c.createdValue[0].SetterObjectsValue[0], Equals, &c.createdValue[0].ObjectsValue[0])
        },
    },
    {
        Summary: "Access underlying Go value with Interface",
        QML:     `GoType { stringValue: "<content>" }`,
        Done: func(c *TestData) {
            c.Assert(c.root.Interface().(*GoType).StringValue, Equals, "<content>")
            c.Assert(c.context.Interface, Panics, "QML object is not backed by a Go value")
        },
    },
    {
        Summary: "Notification signals on custom Go type",
        QML: `
            GoType {
                id: custom
                stringValue: "<old>"
                onStringValueChanged: if (custom.stringValue != "<newest>") { custom.stringValue = "<newest>" }
                Component.onCompleted: custom.stringValue = "<new>"
            }
        `,
        Done: func(c *TestData) {
            c.Assert(c.createdValue, HasLen, 1)
            c.Assert(c.createdValue[0].StringValue, Equals, "<newest>")
        },
    },
    {
        Summary: "Singleton type registration",
        QML:     `Item { Component.onCompleted: console.log("String is", GoSingleton.stringValue) }`,
        QMLLog:  "String is <initial>",
    },
    {
        Summary: "qml.Changed on unknown value is okay",
        Value:   GoType{StringValue: "<old>"},
        Init: func(c *TestData) {
            value := &GoType{}
            qml.Changed(&value, &value.StringValue)
        },
        QML: `Item{}`,
    },
    {
        Summary: "qml.Changed triggers a QML slot",
        QML: `
            GoType {
                stringValue: "<old>"
                onStringValueChanged: console.log("String is", stringValue)
                onStringAddrValueChanged: console.log("String at addr is", stringAddrValue)
            }
        `,
        QMLLog: "!String is",
        Done: func(c *TestData) {
            c.Assert(c.createdValue, HasLen, 1)
            value := c.createdValue[0]
            s := "<new at addr>"
            value.StringValue = "<new>"
            value.StringAddrValue = &s
            qml.Changed(value, &value.StringValue)
            qml.Changed(value, &value.StringAddrValue)
        },
        DoneLog: "String is <new>.*String at addr is <new at addr>",
    },
    {
        Summary: "qml.Changed must not trigger on the wrong field",
        QML: `
            GoType {
                stringValue: "<old>"
                onStringValueChanged: console.log("String is", stringValue)
            }
        `,
        Done: func(c *TestData) {
            c.Assert(c.createdValue, HasLen, 1)
            value := c.createdValue[0]
            value.StringValue = "<new>"
            qml.Changed(value, &value.IntValue)
        },
        DoneLog: "!String is",
    },
    {
        Summary: "qml.Changed updates bindings",
        Value:   GoType{StringValue: "<old>"},
        QML:     `Item { property string s: "String is " + value.stringValue }`,
        Done: func(c *TestData) {
            c.value.StringValue = "<new>"
            qml.Changed(c.value, &c.value.StringValue)
            c.Check(c.root.String("s"), Equals, "String is <new>")
        },
    },
    {
        Summary:  "Call a Go method without arguments or result",
        Value:    GoType{IntValue: 42},
        QML:      `Item { Component.onCompleted: console.log("Undefined is", value.incrementInt()); }`,
        QMLLog:   "Undefined is undefined",
        QMLValue: GoType{IntValue: 43},
    },
    {
        Summary:  "Call a Go method with one argument and one result",
        Value:    GoType{StringValue: "<old>"},
        QML:      `Item { Component.onCompleted: console.log("String was", value.changeString("<new>")); }`,
        QMLLog:   "String was <old>",
        QMLValue: GoType{StringValue: "<new>"},
    },
    {
        Summary: "Call a Go method with multiple results",
        QML: `
            Item {
                Component.onCompleted: {
                    var r = value.mod(42, 4);
                    console.log("mod is", r[0], "and err is", r[1]);
                }
            }
        `,
        QMLLog: `mod is 2 and err is undefined`,
    },
    {
        Summary: "Call a Go method that returns an error",
        QML: `
            Item {
                Component.onCompleted: {
                    var r = value.mod(0, 0);
                    console.log("err is", r[1].error());
                }
            }
        `,
        QMLLog: `err is <division by zero>`,
    },
    {
        Summary: "Call a Go method that recurses back into the GUI thread",
        QML: `
            Item {
                Connections {
                    target: value
                    onStringValueChanged: console.log("Notification arrived")
                }
                Component.onCompleted: {
                    value.notifyStringChanged()
                }
            }
        `,
        QMLLog: "Notification arrived",
    },
    {
        Summary: "Connect a QML signal to a Go method",
        Value:   GoType{StringValue: "<old>"},
        QML: `
            Item {
                id: item
                signal testSignal(string s)
                Component.onCompleted: {
                    item.testSignal.connect(value.changeString)
                    item.testSignal("<new>")
                }
            }
        `,
        QMLValue: GoType{StringValue: "<new>"},
    },
    {
        Summary: "Call a QML method with no result or parameters from Go",
        QML:     `Item { function f() { console.log("f was called"); } }`,
        Done:    func(c *TestData) { c.Check(c.root.Call("f"), IsNil) },
        DoneLog: "f was called",
    },
    {
        Summary: "Call a QML method with result and parameters from Go",
        QML:     `Item { function add(a, b) { return a+b; } }`,
        Done:    func(c *TestData) { c.Check(c.root.Call("add", 1, 2.1), Equals, float64(3.1)) },
    },
    {
        Summary: "Call a QML method with a custom type",
        Value:   GoType{StringValue: "<content>"},
        QML:     `Item { function log(value) { console.log("String is", value.stringValue) } }`,
        Done:    func(c *TestData) { c.root.Call("log", c.value) },
        DoneLog: "String is <content>",
    },
    {
        Summary: "Call a QML method that returns a QML object",
        QML: `
            Item {
                property var custom: Rectangle { width: 300; }
                function f() { return custom }
            }
        `,
        Done: func(c *TestData) {
            c.Check(c.root.Call("f").(qml.Object).Int("width"), Equals, 300)
        },
    },
    {
        Summary: "Call a QML method that holds a custom type past the return point",
        QML: `
            Item {
                property var held
                function hold(v) { held = v; gc(); gc(); }
                function log()   { console.log("String is", held.stringValue) }
            }`,
        Done: func(c *TestData) {
            value := GoType{StringValue: "<content>"}
            stats := qml.Stats()
            c.root.Call("hold", &value)
            c.Check(qml.Stats().ValuesAlive, Equals, stats.ValuesAlive+1)
            c.root.Call("log")
            c.root.Call("hold", nil)
            c.Check(qml.Stats().ValuesAlive, Equals, stats.ValuesAlive)
        },
        DoneLog: "String is <content>",
    },
    {
        Summary: "Call a non-existent QML method",
        QML:     `Item {}`,
        Done: func(c *TestData) {
            c.Check(func() { c.root.Call("add", 1, 2) }, Panics, `object does not expose a method "add"`)
        },
    },
    {
        Summary: "Ensure URL of provided file is correct by loading a local file",
        Init: func(c *TestData) {
            data, err := base64.StdEncoding.DecodeString("R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==")
            c.Assert(err, IsNil)
            err = ioutil.WriteFile("test.gif", data, 0644)
            c.Check(err, IsNil)
        },
        QML:    `Image { source: "test.gif"; Component.onCompleted: console.log("Ready:", status == Image.Ready) }`,
        QMLLog: "Ready: true",
        Done:   func(c *TestData) { os.Remove("test.gif") },
    },
    {
        Summary: "Create window with non-window root object",
        QML:     `Rectangle { width: 300; height: 200; function inc(x) { return x+1 } }`,
        Done: func(c *TestData) {
            win := c.component.CreateWindow(nil)
            root := win.Root()
            c.Check(root.Int("width"), Equals, 300)
            c.Check(root.Int("height"), Equals, 200)
            c.Check(root.Call("inc", 42.5), Equals, float64(43.5))
            root.Destroy()
        },
    },
    {
        Summary: "Create window with window root object",
        QML: `
            import QtQuick.Window 2.0
            Window { title: "<title>"; width: 300; height: 200 }
        `,
        Done: func(c *TestData) {
            win := c.component.CreateWindow(nil)
            root := win.Root()
            c.Check(root.String("title"), Equals, "<title>")
            c.Check(root.Int("width"), Equals, 300)
            c.Check(root.Int("height"), Equals, 200)
        },
    },
    {
        Summary: "Window is object",
        QML:     `Item {}`,
        Done: func(c *TestData) {
            win := c.component.CreateWindow(nil)
            c.Assert(win.Int("status"), Equals, 1) // Ready
        },
    },
    {
        Summary: "Pass a *Value back into a method",
        QML:     `Rectangle { width: 300; function log(r) { console.log("Width is", r.width) } }`,
        Done:    func(c *TestData) { c.root.Call("log", c.root) },
        DoneLog: "Width is 300",
    },
    {
        Summary: "Create a QML-defined component in Go",
        QML:     `Item { property var comp: Component { Rectangle { width: 300 } } }`,
        Done: func(c *TestData) {
            rect := c.root.Object("comp").Create(nil)
            c.Check(rect.Int("width"), Equals, 300)
            c.Check(func() { c.root.Create(nil) }, Panics, "object is not a component")
            c.Check(func() { c.root.CreateWindow(nil) }, Panics, "object is not a component")
        },
    },
    {
        Summary: "Call a Qt method that has no result",
        QML:     `Item { Component.onDestruction: console.log("item destroyed") }`,
        Done: func(c *TestData) {
            // Create a local instance to avoid double-destroying it.
            root := c.component.Create(nil)
            root.Call("deleteLater")
            time.Sleep(100 * time.Millisecond)
        },
        DoneLog: "item destroyed",
    },
    {
        Summary: "Errors connecting to QML signals",
        QML:     `Item { signal doIt() }`,
        Done: func(c *TestData) {
            c.Check(func() { c.root.On("missing", func() {}) }, Panics, `object does not expose a "missing" signal`)
            c.Check(func() { c.root.On("doIt", func(s string) {}) }, Panics, `signal "doIt" has too few parameters for provided function`)
        },
    },
    {
        Summary: "Connect to a QML signal without parameters",
        QML: `
            Item {
                id: item
                signal doIt()
                function emitDoIt() { item.doIt() }
            }
        `,
        Done: func(c *TestData) {
            itWorks := false
            c.root.On("doIt", func() { itWorks = true })
            c.Check(itWorks, Equals, false)
            c.root.Call("emitDoIt")
            c.Check(itWorks, Equals, true)
        },
    },
    {
        Summary: "Connect to a QML signal with a parameters",
        QML: `
            Item {
                id: item
                signal doIt(string s, int n)
                function emitDoIt() { item.doIt("<arg>", 123) }
            }
        `,
        Done: func(c *TestData) {
            var stack []interface{}
            c.root.On("doIt", func() { stack = append(stack, "A") })
            c.root.On("doIt", func(s string) { stack = append(stack, "B", s) })
            c.root.On("doIt", func(s string, i int) { stack = append(stack, "C", s, i) })
            c.Check(stack, IsNil)
            c.root.Call("emitDoIt")
            c.Check(stack, DeepEquals, []interface{}{"A", "B", "<arg>", "C", "<arg>", 123})
        },
    },
    {
        Summary: "Connect to a QML signal with an object parameter",
        QML:     `import QtWebKit 3.0; WebView{}`,
        Done: func(c *TestData) {
            url := "http://localhost:54321/"
            done := make(chan bool)
            c.root.On("navigationRequested", func(request qml.Object) {
                c.Check(request.String("url"), Equals, url)
                done <- true
            })
            c.root.Set("url", url)
            <-done
        },
    },
    {
        Summary: "Load image from Go provider",
        Init: func(c *TestData) {
            c.engine.AddImageProvider("myprov", func(id string, width, height int) image.Image {
                return image.NewRGBA(image.Rect(0, 0, 200, 100))
            })
        },
        QML: `
            Image {
                source: "image://myprov/myid.png"
                Component.onCompleted: console.log("Size:", width, height)
            }
        `,
        QMLLog: "Size: 200 100",
    },
    {
        Summary: "TypeName",
        QML:     `Item{}`,
        Done:    func(c *TestData) { c.Assert(c.root.TypeName(), Equals, "QQuickItem") },
    },
    {
        Summary: "Custom Go type with painting",
        QML: `
            Rectangle {
                width: 200; height: 200
                color: "black"
                GoRect {
                    width: 100; height: 100; x: 50; y: 50
                }
            }
        `,
        Done: func(c *TestData) {
            c.Assert(c.createdRect, HasLen, 0)

            window := c.component.CreateWindow(nil)
            defer window.Destroy()
            window.Show()

            // Qt doesn't hide the Window if we call it too quickly. :-(
            time.Sleep(100 * time.Millisecond)

            c.Assert(c.createdRect, HasLen, 1)
            c.Assert(c.createdRect[0].PaintCount, Equals, 1)

            image := window.Snapshot()
            c.Assert(image.At(25, 25), Equals, color.RGBA{0, 0, 0, 255})
            c.Assert(image.At(100, 100), Equals, color.RGBA{255, 0, 0, 255})
        },
    },
    {
        Summary: "Set a property with the wrong type",
        QML: `
            import QtQuick.Window 2.0
            Window { Rectangle { objectName: "rect" } }
        `,
        Done: func(c *TestData) {
            window := c.component.CreateWindow(nil)
            defer window.Destroy()

            root := window.Root() // It's the window itself in this case
            rect := root.ObjectByName("rect")

            c.Assert(func() { rect.Set("parent", root) }, Panics,
                `cannot set property "parent" with type QQuickItem* to value of QQuickWindow*`)
            c.Assert(func() { rect.Set("parent", 42) }, Panics,
                `cannot set property "parent" with type QQuickItem* to value of int`)
            c.Assert(func() { rect.Set("non_existent", 0) }, Panics,
                `cannot set non-existent property "non_existent" on type QQuickRectangle`)
        },
    },
    {
        Summary: "Register a type converter for a signal parameter",
        QML: `
            Item {
                id: item
                property Item self
                signal testSignal(Item obj)
                function emitSignal() { item.testSignal(item) }
                function getSelf() { return item }
                Component.onCompleted: { self = item }
            }
        `,
        Done: func(c *TestData) {
            type Wrapper struct{ Item qml.Object }
            qml.RegisterConverter(c.root.TypeName(), func(engine *qml.Engine, item qml.Object) interface{} {
                return &Wrapper{item}
            })
            defer qml.RegisterConverter(c.root.TypeName(), nil)

            // Check that it works on signal parameters...
            c.root.On("testSignal", func(wrapped *Wrapper) {
                c.Check(wrapped.Item.Addr(), Equals, c.root.Addr())
                c.Logf("Signal has run.")
            })
            c.root.Call("emitSignal")

            // ... on properties ...
            wrapped, ok := c.root.Property("self").(*Wrapper)
            if c.Check(ok, Equals, true) {
                c.Check(wrapped.Item.Addr(), Equals, c.root.Addr())
            }

            // ... and on results.
            wrapped, ok = c.root.Call("getSelf").(*Wrapper)
            if c.Check(ok, Equals, true) {
                c.Check(wrapped.Item.Addr(), Equals, c.root.Addr())
            }

            // Now unregister and ensure it got disabled.
            qml.RegisterConverter(c.root.TypeName(), nil)
            _, ok = c.root.Property("self").(*qml.Common)
            c.Check(ok, Equals, true)
        },
        DoneLog: "Signal has run.",
    },
    {
        Summary: "References handed out must not be GCd (issue #68)",
        Init: func(c *TestData) {
            type B struct{ S string }
            type A struct{ B *B }
            c.context.SetVar("a", &A{&B{}})
        },
        QML: `Item { function f() { var x = [[],[],[]]; gc(); if (!a.b) console.log("BUG"); } }`,
        Done: func(c *TestData) {
            for i := 0; i < 100; i++ {
                c.root.Call("f")
            }
        },
        DoneLog: "!BUG",
    },
}

var tablef = flag.String("tablef", "", "if provided, TestTable only runs tests with a summary matching the regexp")

func (s *S) TestTable(c *C) {
    var testData TestData

    types := []qml.TypeSpec{{
        Init: func(v *GoType, obj qml.Object) {
            v.object = obj
            v.StringValue = "<initial>"
            testData.createdValue = append(testData.createdValue, v)
        },
    }, {
        Name: "NamedGoType",
        Init: func(v *GoType, obj qml.Object) {
            v.object = obj
            v.StringValue = "<initial>"
            testData.createdValue = append(testData.createdValue, v)
        },
    }, {
        Name: "GoSingleton",
        Init: func(v *GoType, obj qml.Object) {
            v.object = obj
            v.StringValue = "<initial>"
            testData.createdSingleton = append(testData.createdSingleton, v)
        },
        Singleton: true,
    }, {
        Init: func(v *GoRect, obj qml.Object) {
            testData.createdRect = append(testData.createdRect, v)
        },
    }}

    qml.RegisterTypes("GoTypes", 4, 2, types)

    filter := regexp.MustCompile("")
    if tablef != nil {
        filter = regexp.MustCompile(*tablef)
    }

    for i := range tests {
        s.TearDownTest(c)
        t := &tests[i]
        header := fmt.Sprintf("----- Running table test %d: %s -----", i, t.Summary)
        if !filter.MatchString(header) {
            continue
        }
        c.Log(header)
        s.SetUpTest(c)

        value := t.Value
        s.context.SetVar("value", &value)

        testData = TestData{
            C:       c,
            value:   &value,
            engine:  s.engine,
            context: s.context,
        }

        if t.Init != nil {
            t.Init(&testData)
            if c.Failed() {
                c.FailNow()
            }
        }

        component, err := s.engine.LoadString("file.qml", "import QtQuick 2.0\nimport GoTypes 4.2\n"+strings.TrimSpace(t.QML))
        c.Assert(err, IsNil)

        logMark := c.GetTestLog()

        // The component instance is destroyed before the loop ends below,
        // but do a defer to ensure it will be destroyed if the test fails.
        root := component.Create(nil)
        defer root.Destroy()

        testData.component = component
        testData.root = root

        if t.QMLLog != "" {
            logged := c.GetTestLog()[len(logMark):]
            if t.QMLLog[0] == '!' {
                c.Check(logged, Not(Matches), "(?s).*"+t.QMLLog[1:]+".*")
            } else {
                c.Check(logged, Matches, "(?s).*"+t.QMLLog+".*")
            }
        }

        if !reflect.DeepEqual(t.QMLValue, GoType{}) {
            c.Check(value.StringValue, Equals, t.QMLValue.StringValue)
            c.Check(value.StringAddrValue, Equals, t.QMLValue.StringAddrValue)
            c.Check(value.BoolValue, Equals, t.QMLValue.BoolValue)
            c.Check(value.IntValue, Equals, t.QMLValue.IntValue)
            c.Check(value.Int64Value, Equals, t.QMLValue.Int64Value)
            c.Check(value.Int32Value, Equals, t.QMLValue.Int32Value)
            c.Check(value.Float64Value, Equals, t.QMLValue.Float64Value)
            c.Check(value.Float32Value, Equals, t.QMLValue.Float32Value)
            c.Check(value.AnyValue, Equals, t.QMLValue.AnyValue)
            c.Check(value.IntsValue, DeepEquals, t.QMLValue.IntsValue)
            c.Check(value.MapValue, DeepEquals, t.QMLValue.MapValue)
        }

        if !c.Failed() {
            logMark := c.GetTestLog()

            if t.Done != nil {
                t.Done(&testData)
            }

            if t.DoneLog != "" {
                logged := c.GetTestLog()[len(logMark):]
                if t.DoneLog[0] == '!' {
                    c.Check(logged, Not(Matches), "(?s).*"+t.DoneLog[1:]+".*")
                } else {
                    c.Check(logged, Matches, "(?s).*"+t.DoneLog+".*")
                }
            }

            if !reflect.DeepEqual(t.DoneValue, GoType{}) {
                c.Check(value.StringValue, Equals, t.DoneValue.StringValue)
                c.Check(value.StringAddrValue, Equals, t.DoneValue.StringAddrValue)
                c.Check(value.BoolValue, Equals, t.DoneValue.BoolValue)
                c.Check(value.IntValue, Equals, t.DoneValue.IntValue)
                c.Check(value.Int64Value, Equals, t.DoneValue.Int64Value)
                c.Check(value.Int32Value, Equals, t.DoneValue.Int32Value)
                c.Check(value.Float64Value, Equals, t.DoneValue.Float64Value)
                c.Check(value.Float32Value, Equals, t.DoneValue.Float32Value)
                c.Check(value.AnyValue, Equals, t.DoneValue.AnyValue)
                c.Check(value.IntsValue, DeepEquals, t.DoneValue.IntsValue)
                c.Check(value.MapValue, DeepEquals, t.DoneValue.MapValue)
            }
        }

        root.Destroy()

        if c.Failed() {
            c.FailNow() // So relevant logs are at the bottom.
        }
    }
}