func (t *TestBusObject) SetProperty(prop string, value interface{}) error {
	t.SetPropertyForTest(prop, value, SignalTypeChanged)
	return nil
}
SetProperty sets a property of the test object.
package dbus
import (
	"context"
	"errors"
	"reflect"
	"strings"
	"sync"
	"time"
	"github.com/godbus/dbus/v5"
)
type testBusObject struct {
	mu sync.Mutex
	svc   *TestBusService
	path  dbus.ObjectPath
	props map[string]interface{}
	calls map[string]func(...interface{}) ([]interface{}, error)
	eCall func(string, ...interface{}) ([]interface{}, error)
}
type TestBusObject struct {
	*testBusObject
	dest string
	conn *testBusConnection
}
func (t *TestBusObject) Call(method string, flags dbus.Flags, args ...interface{}) *dbus.Call {
	t.check()
	method = expand(t.dest, method)
	call := &dbus.Call{
		Destination: t.dest,
		Path:        t.path,
		Method:      method,
		Args:        args,
		Done:        make(chan *dbus.Call, 1),
	}
	call.Done <- call
	t.mu.Lock()
	defer t.mu.Unlock()
	h, ok := t.calls[method]
	if !ok && t.eCall != nil {
		h = func(args ...interface{}) ([]interface{}, error) {
			return t.eCall(method, args...)
		}
	}
	if h == nil {
		call.Err = errors.New("No such method: " + method)
	} else {
		call.Body, call.Err = h(args...)
	}
	return call
}
func (t *TestBusObject) CallWithContext(ctx context.Context, method string, flags dbus.Flags, args ...interface{}) *dbus.Call {
	return t.Call(method, flags, args...)
}
func (t *TestBusObject) Go(method string, flags dbus.Flags, ch chan *dbus.Call, args ...interface{}) *dbus.Call {
	go func() {
		time.Sleep(505 * time.Millisecond)
		ch <- t.Call(method, flags, args...)
	}()
	return nil
}
func (t *TestBusObject) GoWithContext(ctx context.Context, method string, flags dbus.Flags, ch chan *dbus.Call, args ...interface{}) *dbus.Call {
	return t.Go(method, flags, ch, args...)
}
func matchCallResult(method string, err error) *dbus.Call {
	c := &dbus.Call{
		Destination: bus,
		Path:        busPath,
		Method:      expand(bus, method),
		Args:        []interface{}{"should not matter"},
		Done:        make(chan *dbus.Call, 1),
		Err:         err,
	}
	c.Done <- c
	return c
}
func (t *TestBusObject) AddMatchSignal(iface, member string, options ...dbus.MatchOption) *dbus.Call {
	name := iface + "." + member
	t.check()
	optMap := dbusMatchOptionMap(options)
	for k := range optMap {
		if k == "path" || k == "path_namespace" || k == "sender" {
			continue
		}
		if strings.HasPrefix(k, "arg") {
			continue
		}
		return matchCallResult("AddMatch", errors.New("Unsupported match type: "+k))
	}
	t.conn.mu.Lock()
	defer t.conn.mu.Unlock()
	t.conn.matches[name] = append(t.conn.matches[name], optMap)
	return matchCallResult("AddMatch", nil)
}
func (t *TestBusObject) RemoveMatchSignal(iface, member string, options ...dbus.MatchOption) *dbus.Call {
	name := iface + "." + member
	t.check()
	t.conn.mu.Lock()
	defer t.conn.mu.Unlock()
	ms := t.conn.matches[name]
	optMap := dbusMatchOptionMap(options)
	for i, m := range ms {
		if reflect.DeepEqual(m, optMap) {
			t.conn.matches[name] = append(ms[:i], ms[i+1:]...)
			return matchCallResult("RemoveMatch", nil)
		}
	}
	return matchCallResult("RemoveMatch", errors.New("Match not found"))
}
func (t *TestBusObject) GetProperty(p string) (dbus.Variant, error) {
	t.check()
	t.mu.Lock()
	defer t.mu.Unlock()
	if val, ok := t.props[p]; ok {
		return dbus.MakeVariant(val), nil
	}
	return dbus.Variant{}, errors.New("No such property: " + p)
}
func (t *TestBusObject) StoreProperty(p string, dest interface{}) error {
	val, err := t.GetProperty(p)
	if err == nil {
		err = dbus.Store([]interface{}{val}, dest)
	}
	return err
}
func (t *TestBusObject) Destination() string {
	t.check()
	return t.dest
}
func (t *TestBusObject) Path() dbus.ObjectPath {
	t.check()
	return t.path
}
type SignalType byte
const (
	SignalTypeNone SignalType = iota
	SignalTypeChanged
	SignalTypeInvalidated
)