github.com/remoteit/go-ole@v1.2.7/idispatch_windows_test.go

// +build windows

package ole

import "testing"

func wrapCOMExecute(t *testing.T, callback func(*testing.T)) {
	defer func() {
		if r := recover(); r != nil {
			t.Error(r)
		}
	}()

	err := CoInitialize(0)
	if err != nil {
		t.Fatal(err)
	}
	defer CoUninitialize()

	callback(t)
}

func wrapDispatch(t *testing.T, ClassID, UnknownInterfaceID, DispatchInterfaceID *GUID, callback func(*testing.T, *IUnknown, *IDispatch)) {
	var unknown *IUnknown
	var dispatch *IDispatch
	var err error

	unknown, err = CreateInstance(ClassID, UnknownInterfaceID)
	if err != nil {
		t.Error(err)
		return
	}
	defer unknown.Release()

	dispatch, err = unknown.QueryInterface(DispatchInterfaceID)
	if err != nil {
		t.Error(err)
		return
	}
	defer dispatch.Release()

	callback(t, unknown, dispatch)
}

func wrapGoOLETestCOMServerEcho(t *testing.T, callback func(*testing.T, *IUnknown, *IDispatch)) {
	wrapCOMExecute(t, func(t *testing.T) {
		wrapDispatch(t, CLSID_COMEchoTestObject, IID_IUnknown, IID_ICOMEchoTestObject, callback)
	})
}

func wrapGoOLETestCOMServerScalar(t *testing.T, callback func(*testing.T, *IUnknown, *IDispatch)) {
	wrapCOMExecute(t, func(t *testing.T) {
		wrapDispatch(t, CLSID_COMTestScalarClass, IID_IUnknown, IID_ICOMTestTypes, callback)
	})
}

func TestIDispatch_goolecomserver_stringfield(t *testing.T) {
	wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "StringField"
		expected := "Test String"
		_, err := idispatch.PutProperty(method, expected)
		if err != nil {
			t.Error(err)
			return
		}
		variant, err := idispatch.GetProperty(method)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(string)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "string", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}

func TestIDispatch_goolecomserver_int8field(t *testing.T) {
	wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "Int8Field"
		expected := int8(2)
		_, err := idispatch.PutProperty(method, expected)
		if err != nil {
			t.Error(err)
			return
		}
		variant, err := idispatch.GetProperty(method)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(int8)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "int8", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}

func TestIDispatch_goolecomserver_uint8field(t *testing.T) {
	wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "UInt8Field"
		expected := uint8(4)
		_, err := idispatch.PutProperty(method, expected)
		if err != nil {
			t.Error(err)
			return
		}
		variant, err := idispatch.GetProperty(method)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(uint8)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "uint8", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}

func TestIDispatch_goolecomserver_int16field(t *testing.T) {
	wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "Int16Field"
		expected := int16(4)
		_, err := idispatch.PutProperty(method, expected)
		if err != nil {
			t.Error(err)
			return
		}
		variant, err := idispatch.GetProperty(method)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(int16)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "int16", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}

func TestIDispatch_goolecomserver_uint16field(t *testing.T) {
	wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "UInt16Field"
		expected := uint16(4)
		_, err := idispatch.PutProperty(method, expected)
		if err != nil {
			t.Error(err)
			return
		}
		variant, err := idispatch.GetProperty(method)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(uint16)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "uint16", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}

func TestIDispatch_goolecomserver_int32field(t *testing.T) {
	wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "Int32Field"
		expected := int32(8)
		_, err := idispatch.PutProperty(method, expected)
		if err != nil {
			t.Error(err)
			return
		}
		variant, err := idispatch.GetProperty(method)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(int32)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "int32", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}

func TestIDispatch_goolecomserver_uint32field(t *testing.T) {
	wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "UInt32Field"
		expected := uint32(16)
		_, err := idispatch.PutProperty(method, expected)
		if err != nil {
			t.Error(err)
			return
		}
		variant, err := idispatch.GetProperty(method)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(uint32)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "uint32", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}

func TestIDispatch_goolecomserver_int64field(t *testing.T) {
	wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "Int64Field"
		expected := int64(32)
		_, err := idispatch.PutProperty(method, expected)
		if err != nil {
			t.Error(err)
			return
		}
		variant, err := idispatch.GetProperty(method)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(int64)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "int64", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}

func TestIDispatch_goolecomserver_uint64field(t *testing.T) {
	wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "UInt64Field"
		expected := uint64(64)
		_, err := idispatch.PutProperty(method, expected)
		if err != nil {
			t.Error(err)
			return
		}
		variant, err := idispatch.GetProperty(method)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(uint64)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "uint64", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}

func TestIDispatch_goolecomserver_booleanfield_true(t *testing.T) {
	wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "BooleanField"
		expected := true
		_, err := idispatch.PutProperty(method, expected)
		if err != nil {
			t.Error(err)
			return
		}
		variant, err := idispatch.GetProperty(method)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(bool)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "bool", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}

func TestIDispatch_goolecomserver_booleanfield_false(t *testing.T) {
	wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "BooleanField"
		expected := false
		_, err := idispatch.PutProperty(method, expected)
		if err != nil {
			t.Error(err)
			return
		}
		variant, err := idispatch.GetProperty(method)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(bool)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "bool", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}

func TestIDispatch_goolecomserver_float32field(t *testing.T) {
	wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "Float32Field"
		expected := float32(2.2)
		_, err := idispatch.PutProperty(method, expected)
		if err != nil {
			t.Error(err)
		}
		variant, err := idispatch.GetProperty(method)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(float32)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "float32", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}

func TestIDispatch_goolecomserver_float64field(t *testing.T) {
	wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "Float64Field"
		expected := float64(4.4)
		_, err := idispatch.PutProperty(method, expected)
		if err != nil {
			t.Error(err)
		}
		variant, err := idispatch.GetProperty(method)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(float64)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "float64", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}

func TestIDispatch_goolecomserver_echostring(t *testing.T) {
	wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "EchoString"
		expected := "Test String"
		variant, err := idispatch.CallMethod(method, expected)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(string)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "string", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}

func TestIDispatch_goolecomserver_echoboolean(t *testing.T) {
	wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "EchoBoolean"
		expected := true
		variant, err := idispatch.CallMethod(method, expected)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(bool)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "bool", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}

func TestIDispatch_goolecomserver_echoint8(t *testing.T) {
	wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "EchoInt8"
		expected := int8(1)
		variant, err := idispatch.CallMethod(method, expected)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(int8)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "int8", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}

func TestIDispatch_goolecomserver_echouint8(t *testing.T) {
	wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "EchoUInt8"
		expected := uint8(1)
		variant, err := idispatch.CallMethod(method, expected)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(uint8)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "uint8", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}

func TestIDispatch_goolecomserver_echoint16(t *testing.T) {
	wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "EchoInt16"
		expected := int16(1)
		variant, err := idispatch.CallMethod(method, expected)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(int16)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "int16", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}

func TestIDispatch_goolecomserver_echouint16(t *testing.T) {
	wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "EchoUInt16"
		expected := uint16(1)
		variant, err := idispatch.CallMethod(method, expected)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(uint16)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "uint16", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}

func TestIDispatch_goolecomserver_echoint32(t *testing.T) {
	wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "EchoInt32"
		expected := int32(2)
		variant, err := idispatch.CallMethod(method, expected)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(int32)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "int32", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}

func TestIDispatch_goolecomserver_echouint32(t *testing.T) {
	wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "EchoUInt32"
		expected := uint32(4)
		variant, err := idispatch.CallMethod(method, expected)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(uint32)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "uint32", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}

func TestIDispatch_goolecomserver_echoint64(t *testing.T) {
	wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "EchoInt64"
		expected := int64(1)
		variant, err := idispatch.CallMethod(method, expected)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(int64)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "int64", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}

func TestIDispatch_goolecomserver_echouint64(t *testing.T) {
	wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "EchoUInt64"
		expected := uint64(1)
		variant, err := idispatch.CallMethod(method, expected)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(uint64)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "uint64", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}

func TestIDispatch_goolecomserver_echofloat32(t *testing.T) {
	wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "EchoFloat32"
		expected := float32(2.2)
		variant, err := idispatch.CallMethod(method, expected)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(float32)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "float32", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}

func TestIDispatch_goolecomserver_echofloat64(t *testing.T) {
	wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
		method := "EchoFloat64"
		expected := float64(2.2)
		variant, err := idispatch.CallMethod(method, expected)
		if err != nil {
			t.Error(err)
			return
		}
		defer variant.Clear()
		actual, passed := variant.Value().(float64)
		if !passed {
			t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "float64", variant.VT, variant.Val)
			return
		}
		if actual != expected {
			t.Errorf("%s() expected %v did not match %v", method, expected, actual)
		}
	})
}